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, 2009
5 Free Software Foundation, Inc.
7 Adapted by Gary Funck (gary@intrepid.com), Intrepid Technology,
8 Inc. with support from Florida State University (under contract
9 with the Ada Joint Program Office), and Silicon Graphics, Inc.
10 Initial contribution by Brent Benson, Harris Computer Systems, Inc.,
11 based on Fred Fish's (Cygnus Support) implementation of DWARF 1
14 This file is part of GDB.
16 This program is free software; you can redistribute it and/or modify
17 it under the terms of the GNU General Public License as published by
18 the Free Software Foundation; either version 3 of the License, or
19 (at your option) any later version.
21 This program is distributed in the hope that it will be useful,
22 but WITHOUT ANY WARRANTY; without even the implied warranty of
23 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
24 GNU General Public License for more details.
26 You should have received a copy of the GNU General Public License
27 along with this program. If not, see <http://www.gnu.org/licenses/>. */
34 #include "elf/dwarf2.h"
37 #include "expression.h"
38 #include "filenames.h" /* for DOSish file names */
41 #include "complaints.h"
43 #include "dwarf2expr.h"
44 #include "dwarf2loc.h"
45 #include "cp-support.h"
53 #include "gdb_string.h"
54 #include "gdb_assert.h"
55 #include <sys/types.h>
64 /* .debug_info header for a compilation unit
65 Because of alignment constraints, this structure has padding and cannot
66 be mapped directly onto the beginning of the .debug_info section. */
67 typedef struct comp_unit_header
69 unsigned int length
; /* length of the .debug_info
71 unsigned short version
; /* version number -- 2 for DWARF
73 unsigned int abbrev_offset
; /* offset into .debug_abbrev section */
74 unsigned char addr_size
; /* byte size of an address -- 4 */
77 #define _ACTUAL_COMP_UNIT_HEADER_SIZE 11
80 /* .debug_pubnames header
81 Because of alignment constraints, this structure has padding and cannot
82 be mapped directly onto the beginning of the .debug_info section. */
83 typedef struct pubnames_header
85 unsigned int length
; /* length of the .debug_pubnames
87 unsigned char version
; /* version number -- 2 for DWARF
89 unsigned int info_offset
; /* offset into .debug_info section */
90 unsigned int info_size
; /* byte size of .debug_info section
94 #define _ACTUAL_PUBNAMES_HEADER_SIZE 13
96 /* .debug_pubnames header
97 Because of alignment constraints, this structure has padding and cannot
98 be mapped directly onto the beginning of the .debug_info section. */
99 typedef struct aranges_header
101 unsigned int length
; /* byte len of the .debug_aranges
103 unsigned short version
; /* version number -- 2 for DWARF
105 unsigned int info_offset
; /* offset into .debug_info section */
106 unsigned char addr_size
; /* byte size of an address */
107 unsigned char seg_size
; /* byte size of segment descriptor */
110 #define _ACTUAL_ARANGES_HEADER_SIZE 12
112 /* .debug_line statement program prologue
113 Because of alignment constraints, this structure has padding and cannot
114 be mapped directly onto the beginning of the .debug_info section. */
115 typedef struct statement_prologue
117 unsigned int total_length
; /* byte length of the statement
119 unsigned short version
; /* version number -- 2 for DWARF
121 unsigned int prologue_length
; /* # bytes between prologue &
123 unsigned char minimum_instruction_length
; /* byte size of
125 unsigned char default_is_stmt
; /* initial value of is_stmt
128 unsigned char line_range
;
129 unsigned char opcode_base
; /* number assigned to first special
131 unsigned char *standard_opcode_lengths
;
135 /* When non-zero, dump DIEs after they are read in. */
136 static int dwarf2_die_debug
= 0;
140 /* When set, the file that we're processing is known to have debugging
141 info for C++ namespaces. GCC 3.3.x did not produce this information,
142 but later versions do. */
144 static int processing_has_namespace_info
;
146 static const struct objfile_data
*dwarf2_objfile_data_key
;
148 struct dwarf2_section_info
156 struct dwarf2_per_objfile
158 struct dwarf2_section_info info
;
159 struct dwarf2_section_info abbrev
;
160 struct dwarf2_section_info line
;
161 struct dwarf2_section_info pubnames
;
162 struct dwarf2_section_info aranges
;
163 struct dwarf2_section_info loc
;
164 struct dwarf2_section_info macinfo
;
165 struct dwarf2_section_info str
;
166 struct dwarf2_section_info ranges
;
167 struct dwarf2_section_info frame
;
168 struct dwarf2_section_info eh_frame
;
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 /* names of the debugging sections */
190 /* Note that if the debugging section has been compressed, it might
191 have a name like .zdebug_info. */
193 #define INFO_SECTION "debug_info"
194 #define ABBREV_SECTION "debug_abbrev"
195 #define LINE_SECTION "debug_line"
196 #define PUBNAMES_SECTION "debug_pubnames"
197 #define ARANGES_SECTION "debug_aranges"
198 #define LOC_SECTION "debug_loc"
199 #define MACINFO_SECTION "debug_macinfo"
200 #define STR_SECTION "debug_str"
201 #define RANGES_SECTION "debug_ranges"
202 #define FRAME_SECTION "debug_frame"
203 #define EH_FRAME_SECTION "eh_frame"
205 /* local data types */
207 /* We hold several abbreviation tables in memory at the same time. */
208 #ifndef ABBREV_HASH_SIZE
209 #define ABBREV_HASH_SIZE 121
212 /* The data in a compilation unit header, after target2host
213 translation, looks like this. */
214 struct comp_unit_head
218 unsigned char addr_size
;
219 unsigned char signed_addr_p
;
220 unsigned int abbrev_offset
;
222 /* Size of file offsets; either 4 or 8. */
223 unsigned int offset_size
;
225 /* Size of the length field; either 4 or 12. */
226 unsigned int initial_length_size
;
228 /* Offset to the first byte of this compilation unit header in the
229 .debug_info section, for resolving relative reference dies. */
232 /* Offset to first die in this cu from the start of the cu.
233 This will be the first byte following the compilation unit header. */
234 unsigned int first_die_offset
;
237 /* Internal state when decoding a particular compilation unit. */
240 /* The objfile containing this compilation unit. */
241 struct objfile
*objfile
;
243 /* The header of the compilation unit. */
244 struct comp_unit_head header
;
246 /* Base address of this compilation unit. */
247 CORE_ADDR base_address
;
249 /* Non-zero if base_address has been set. */
252 struct function_range
*first_fn
, *last_fn
, *cached_fn
;
254 /* The language we are debugging. */
255 enum language language
;
256 const struct language_defn
*language_defn
;
258 const char *producer
;
260 /* The generic symbol table building routines have separate lists for
261 file scope symbols and all all other scopes (local scopes). So
262 we need to select the right one to pass to add_symbol_to_list().
263 We do it by keeping a pointer to the correct list in list_in_scope.
265 FIXME: The original dwarf code just treated the file scope as the
266 first local scope, and all other local scopes as nested local
267 scopes, and worked fine. Check to see if we really need to
268 distinguish these in buildsym.c. */
269 struct pending
**list_in_scope
;
271 /* DWARF abbreviation table associated with this compilation unit. */
272 struct abbrev_info
**dwarf2_abbrevs
;
274 /* Storage for the abbrev table. */
275 struct obstack abbrev_obstack
;
277 /* Hash table holding all the loaded partial DIEs. */
280 /* `.debug_ranges' offset for this `DW_TAG_compile_unit' DIE. */
281 unsigned int ranges_offset
;
283 /* Storage for things with the same lifetime as this read-in compilation
284 unit, including partial DIEs. */
285 struct obstack comp_unit_obstack
;
287 /* When multiple dwarf2_cu structures are living in memory, this field
288 chains them all together, so that they can be released efficiently.
289 We will probably also want a generation counter so that most-recently-used
290 compilation units are cached... */
291 struct dwarf2_per_cu_data
*read_in_chain
;
293 /* Backchain to our per_cu entry if the tree has been built. */
294 struct dwarf2_per_cu_data
*per_cu
;
296 /* Pointer to the die -> type map. Although it is stored
297 permanently in per_cu, we copy it here to avoid double
301 /* How many compilation units ago was this CU last referenced? */
304 /* A hash table of die offsets for following references. */
307 /* Full DIEs if read in. */
308 struct die_info
*dies
;
310 /* A set of pointers to dwarf2_per_cu_data objects for compilation
311 units referenced by this one. Only set during full symbol processing;
312 partial symbol tables do not have dependencies. */
315 /* Header data from the line table, during full symbol processing. */
316 struct line_header
*line_header
;
318 /* Mark used when releasing cached dies. */
319 unsigned int mark
: 1;
321 /* This flag will be set if this compilation unit might include
322 inter-compilation-unit references. */
323 unsigned int has_form_ref_addr
: 1;
325 /* This flag will be set if this compilation unit includes any
326 DW_TAG_namespace DIEs. If we know that there are explicit
327 DIEs for namespaces, we don't need to try to infer them
328 from mangled names. */
329 unsigned int has_namespace_info
: 1;
331 /* Field `ranges_offset' is filled in; flag as the value may be zero. */
332 unsigned int has_ranges_offset
: 1;
335 /* Persistent data held for a compilation unit, even when not
336 processing it. We put a pointer to this structure in the
337 read_symtab_private field of the psymtab. If we encounter
338 inter-compilation-unit references, we also maintain a sorted
339 list of all compilation units. */
341 struct dwarf2_per_cu_data
343 /* The start offset and length of this compilation unit. 2**30-1
344 bytes should suffice to store the length of any compilation unit
345 - if it doesn't, GDB will fall over anyway.
346 NOTE: Unlike comp_unit_head.length, this length includes
347 initial_length_size. */
349 unsigned int length
: 30;
351 /* Flag indicating this compilation unit will be read in before
352 any of the current compilation units are processed. */
353 unsigned int queued
: 1;
355 /* This flag will be set if we need to load absolutely all DIEs
356 for this compilation unit, instead of just the ones we think
357 are interesting. It gets set if we look for a DIE in the
358 hash table and don't find it. */
359 unsigned int load_all_dies
: 1;
361 /* Set iff currently read in. */
362 struct dwarf2_cu
*cu
;
364 /* If full symbols for this CU have been read in, then this field
365 holds a map of DIE offsets to types. It isn't always possible
366 to reconstruct this information later, so we have to preserve
370 /* The partial symbol table associated with this compilation unit,
371 or NULL for partial units (which do not have an associated
373 struct partial_symtab
*psymtab
;
376 /* The line number information for a compilation unit (found in the
377 .debug_line section) begins with a "statement program header",
378 which contains the following information. */
381 unsigned int total_length
;
382 unsigned short version
;
383 unsigned int header_length
;
384 unsigned char minimum_instruction_length
;
385 unsigned char default_is_stmt
;
387 unsigned char line_range
;
388 unsigned char opcode_base
;
390 /* standard_opcode_lengths[i] is the number of operands for the
391 standard opcode whose value is i. This means that
392 standard_opcode_lengths[0] is unused, and the last meaningful
393 element is standard_opcode_lengths[opcode_base - 1]. */
394 unsigned char *standard_opcode_lengths
;
396 /* The include_directories table. NOTE! These strings are not
397 allocated with xmalloc; instead, they are pointers into
398 debug_line_buffer. If you try to free them, `free' will get
400 unsigned int num_include_dirs
, include_dirs_size
;
403 /* The file_names table. NOTE! These strings are not allocated
404 with xmalloc; instead, they are pointers into debug_line_buffer.
405 Don't try to free them directly. */
406 unsigned int num_file_names
, file_names_size
;
410 unsigned int dir_index
;
411 unsigned int mod_time
;
413 int included_p
; /* Non-zero if referenced by the Line Number Program. */
414 struct symtab
*symtab
; /* The associated symbol table, if any. */
417 /* The start and end of the statement program following this
418 header. These point into dwarf2_per_objfile->line_buffer. */
419 gdb_byte
*statement_program_start
, *statement_program_end
;
422 /* When we construct a partial symbol table entry we only
423 need this much information. */
424 struct partial_die_info
426 /* Offset of this DIE. */
429 /* DWARF-2 tag for this DIE. */
430 ENUM_BITFIELD(dwarf_tag
) tag
: 16;
432 /* Language code associated with this DIE. This is only used
433 for the compilation unit DIE. */
434 unsigned int language
: 8;
436 /* Assorted flags describing the data found in this DIE. */
437 unsigned int has_children
: 1;
438 unsigned int is_external
: 1;
439 unsigned int is_declaration
: 1;
440 unsigned int has_type
: 1;
441 unsigned int has_specification
: 1;
442 unsigned int has_stmt_list
: 1;
443 unsigned int has_pc_info
: 1;
445 /* Flag set if the SCOPE field of this structure has been
447 unsigned int scope_set
: 1;
449 /* Flag set if the DIE has a byte_size attribute. */
450 unsigned int has_byte_size
: 1;
452 /* The name of this DIE. Normally the value of DW_AT_name, but
453 sometimes DW_TAG_MIPS_linkage_name or a string computed in some
458 /* The scope to prepend to our children. This is generally
459 allocated on the comp_unit_obstack, so will disappear
460 when this compilation unit leaves the cache. */
463 /* The location description associated with this DIE, if any. */
464 struct dwarf_block
*locdesc
;
466 /* If HAS_PC_INFO, the PC range associated with this DIE. */
470 /* Pointer into the info_buffer pointing at the target of
471 DW_AT_sibling, if any. */
474 /* If HAS_SPECIFICATION, the offset of the DIE referred to by
475 DW_AT_specification (or DW_AT_abstract_origin or
477 unsigned int spec_offset
;
479 /* If HAS_STMT_LIST, the offset of the Line Number Information data. */
480 unsigned int line_offset
;
482 /* Pointers to this DIE's parent, first child, and next sibling,
484 struct partial_die_info
*die_parent
, *die_child
, *die_sibling
;
487 /* This data structure holds the information of an abbrev. */
490 unsigned int number
; /* number identifying abbrev */
491 enum dwarf_tag tag
; /* dwarf tag */
492 unsigned short has_children
; /* boolean */
493 unsigned short num_attrs
; /* number of attributes */
494 struct attr_abbrev
*attrs
; /* an array of attribute descriptions */
495 struct abbrev_info
*next
; /* next in chain */
500 ENUM_BITFIELD(dwarf_attribute
) name
: 16;
501 ENUM_BITFIELD(dwarf_form
) form
: 16;
504 /* Additional GDB-specific attribute forms. */
507 /* A string which has been updated to GDB's internal
508 representation (e.g. converted to canonical form) and does not
509 need to be updated again. */
510 GDB_FORM_cached_string
= 0xff
513 /* Attributes have a name and a value */
516 ENUM_BITFIELD(dwarf_attribute
) name
: 16;
517 ENUM_BITFIELD(dwarf_form
) form
: 16;
521 struct dwarf_block
*blk
;
529 /* This data structure holds a complete die structure. */
532 /* DWARF-2 tag for this DIE. */
533 ENUM_BITFIELD(dwarf_tag
) tag
: 16;
535 /* Number of attributes */
536 unsigned short num_attrs
;
541 /* Offset in .debug_info section */
544 /* The dies in a compilation unit form an n-ary tree. PARENT
545 points to this die's parent; CHILD points to the first child of
546 this node; and all the children of a given node are chained
547 together via their SIBLING fields, terminated by a die whose
549 struct die_info
*child
; /* Its first child, if any. */
550 struct die_info
*sibling
; /* Its next sibling, if any. */
551 struct die_info
*parent
; /* Its parent, if any. */
553 /* An array of attributes, with NUM_ATTRS elements. There may be
554 zero, but it's not common and zero-sized arrays are not
555 sufficiently portable C. */
556 struct attribute attrs
[1];
559 struct function_range
562 CORE_ADDR lowpc
, highpc
;
564 struct function_range
*next
;
567 /* Get at parts of an attribute structure */
569 #define DW_STRING(attr) ((attr)->u.str)
570 #define DW_UNSND(attr) ((attr)->u.unsnd)
571 #define DW_BLOCK(attr) ((attr)->u.blk)
572 #define DW_SND(attr) ((attr)->u.snd)
573 #define DW_ADDR(attr) ((attr)->u.addr)
575 /* Blocks are a bunch of untyped bytes. */
582 #ifndef ATTR_ALLOC_CHUNK
583 #define ATTR_ALLOC_CHUNK 4
586 /* Allocate fields for structs, unions and enums in this size. */
587 #ifndef DW_FIELD_ALLOC_CHUNK
588 #define DW_FIELD_ALLOC_CHUNK 4
591 /* A zeroed version of a partial die for initialization purposes. */
592 static struct partial_die_info zeroed_partial_die
;
594 /* FIXME: We might want to set this from BFD via bfd_arch_bits_per_byte,
595 but this would require a corresponding change in unpack_field_as_long
597 static int bits_per_byte
= 8;
599 /* The routines that read and process dies for a C struct or C++ class
600 pass lists of data member fields and lists of member function fields
601 in an instance of a field_info structure, as defined below. */
604 /* List of data member and baseclasses fields. */
607 struct nextfield
*next
;
614 /* Number of fields. */
617 /* Number of baseclasses. */
620 /* Set if the accesibility of one of the fields is not public. */
621 int non_public_fields
;
623 /* Member function fields array, entries are allocated in the order they
624 are encountered in the object file. */
627 struct nextfnfield
*next
;
628 struct fn_field fnfield
;
632 /* Member function fieldlist array, contains name of possibly overloaded
633 member function, number of overloaded member functions and a pointer
634 to the head of the member function field chain. */
639 struct nextfnfield
*head
;
643 /* Number of entries in the fnfieldlists array. */
647 /* One item on the queue of compilation units to read in full symbols
649 struct dwarf2_queue_item
651 struct dwarf2_per_cu_data
*per_cu
;
652 struct dwarf2_queue_item
*next
;
655 /* The current queue. */
656 static struct dwarf2_queue_item
*dwarf2_queue
, *dwarf2_queue_tail
;
658 /* Loaded secondary compilation units are kept in memory until they
659 have not been referenced for the processing of this many
660 compilation units. Set this to zero to disable caching. Cache
661 sizes of up to at least twenty will improve startup time for
662 typical inter-CU-reference binaries, at an obvious memory cost. */
663 static int dwarf2_max_cache_age
= 5;
665 show_dwarf2_max_cache_age (struct ui_file
*file
, int from_tty
,
666 struct cmd_list_element
*c
, const char *value
)
668 fprintf_filtered (file
, _("\
669 The upper bound on the age of cached dwarf2 compilation units is %s.\n"),
674 /* Various complaints about symbol reading that don't abort the process */
677 dwarf2_statement_list_fits_in_line_number_section_complaint (void)
679 complaint (&symfile_complaints
,
680 _("statement list doesn't fit in .debug_line section"));
684 dwarf2_debug_line_missing_file_complaint (void)
686 complaint (&symfile_complaints
,
687 _(".debug_line section has line data without a file"));
691 dwarf2_debug_line_missing_end_sequence_complaint (void)
693 complaint (&symfile_complaints
,
694 _(".debug_line section has line program sequence without an end"));
698 dwarf2_complex_location_expr_complaint (void)
700 complaint (&symfile_complaints
, _("location expression too complex"));
704 dwarf2_const_value_length_mismatch_complaint (const char *arg1
, int arg2
,
707 complaint (&symfile_complaints
,
708 _("const value length mismatch for '%s', got %d, expected %d"), arg1
,
713 dwarf2_macros_too_long_complaint (void)
715 complaint (&symfile_complaints
,
716 _("macro info runs off end of `.debug_macinfo' section"));
720 dwarf2_macro_malformed_definition_complaint (const char *arg1
)
722 complaint (&symfile_complaints
,
723 _("macro debug info contains a malformed macro definition:\n`%s'"),
728 dwarf2_invalid_attrib_class_complaint (const char *arg1
, const char *arg2
)
730 complaint (&symfile_complaints
,
731 _("invalid attribute class or form for '%s' in '%s'"), arg1
, arg2
);
734 /* local function prototypes */
736 static void dwarf2_locate_sections (bfd
*, asection
*, void *);
739 static void dwarf2_build_psymtabs_easy (struct objfile
*, int);
742 static void dwarf2_create_include_psymtab (char *, struct partial_symtab
*,
745 static void dwarf2_build_include_psymtabs (struct dwarf2_cu
*,
746 struct partial_die_info
*,
747 struct partial_symtab
*);
749 static void dwarf2_build_psymtabs_hard (struct objfile
*, int);
751 static void scan_partial_symbols (struct partial_die_info
*,
752 CORE_ADDR
*, CORE_ADDR
*,
753 int, struct dwarf2_cu
*);
755 static void add_partial_symbol (struct partial_die_info
*,
758 static int pdi_needs_namespace (enum dwarf_tag tag
);
760 static void add_partial_namespace (struct partial_die_info
*pdi
,
761 CORE_ADDR
*lowpc
, CORE_ADDR
*highpc
,
762 int need_pc
, struct dwarf2_cu
*cu
);
764 static void add_partial_module (struct partial_die_info
*pdi
, CORE_ADDR
*lowpc
,
765 CORE_ADDR
*highpc
, int need_pc
,
766 struct dwarf2_cu
*cu
);
768 static void add_partial_enumeration (struct partial_die_info
*enum_pdi
,
769 struct dwarf2_cu
*cu
);
771 static void add_partial_subprogram (struct partial_die_info
*pdi
,
772 CORE_ADDR
*lowpc
, CORE_ADDR
*highpc
,
773 int need_pc
, struct dwarf2_cu
*cu
);
775 static gdb_byte
*locate_pdi_sibling (struct partial_die_info
*orig_pdi
,
778 struct dwarf2_cu
*cu
);
780 static void dwarf2_psymtab_to_symtab (struct partial_symtab
*);
782 static void psymtab_to_symtab_1 (struct partial_symtab
*);
784 static void dwarf2_read_abbrevs (bfd
*abfd
, struct dwarf2_cu
*cu
);
786 static void dwarf2_free_abbrev_table (void *);
788 static struct abbrev_info
*peek_die_abbrev (gdb_byte
*, unsigned int *,
791 static struct abbrev_info
*dwarf2_lookup_abbrev (unsigned int,
794 static struct partial_die_info
*load_partial_dies (bfd
*, gdb_byte
*, int,
797 static gdb_byte
*read_partial_die (struct partial_die_info
*,
798 struct abbrev_info
*abbrev
, unsigned int,
799 bfd
*, gdb_byte
*, struct dwarf2_cu
*);
801 static struct partial_die_info
*find_partial_die (unsigned int,
804 static void fixup_partial_die (struct partial_die_info
*,
807 static gdb_byte
*read_full_die (struct die_info
**, bfd
*, gdb_byte
*,
808 struct dwarf2_cu
*, int *);
810 static gdb_byte
*read_attribute (struct attribute
*, struct attr_abbrev
*,
811 bfd
*, gdb_byte
*, struct dwarf2_cu
*);
813 static gdb_byte
*read_attribute_value (struct attribute
*, unsigned,
814 bfd
*, gdb_byte
*, struct dwarf2_cu
*);
816 static unsigned int read_1_byte (bfd
*, gdb_byte
*);
818 static int read_1_signed_byte (bfd
*, gdb_byte
*);
820 static unsigned int read_2_bytes (bfd
*, gdb_byte
*);
822 static unsigned int read_4_bytes (bfd
*, gdb_byte
*);
824 static unsigned long read_8_bytes (bfd
*, gdb_byte
*);
826 static CORE_ADDR
read_address (bfd
*, gdb_byte
*ptr
, struct dwarf2_cu
*,
829 static LONGEST
read_initial_length (bfd
*, gdb_byte
*, unsigned int *);
831 static LONGEST read_checked_initial_length_and_offset
832 (bfd
*, gdb_byte
*, const struct comp_unit_head
*,
833 unsigned int *, unsigned int *);
835 static LONGEST
read_offset (bfd
*, gdb_byte
*, const struct comp_unit_head
*,
838 static LONGEST
read_offset_1 (bfd
*, gdb_byte
*, unsigned int);
840 static gdb_byte
*read_n_bytes (bfd
*, gdb_byte
*, unsigned int);
842 static char *read_string (bfd
*, gdb_byte
*, unsigned int *);
844 static char *read_indirect_string (bfd
*, gdb_byte
*,
845 const struct comp_unit_head
*,
848 static unsigned long read_unsigned_leb128 (bfd
*, gdb_byte
*, unsigned int *);
850 static long read_signed_leb128 (bfd
*, gdb_byte
*, unsigned int *);
852 static gdb_byte
*skip_leb128 (bfd
*, gdb_byte
*);
854 static void set_cu_language (unsigned int, struct dwarf2_cu
*);
856 static struct attribute
*dwarf2_attr (struct die_info
*, unsigned int,
859 static int dwarf2_flag_true_p (struct die_info
*die
, unsigned name
,
860 struct dwarf2_cu
*cu
);
862 static int die_is_declaration (struct die_info
*, struct dwarf2_cu
*cu
);
864 static struct die_info
*die_specification (struct die_info
*die
,
865 struct dwarf2_cu
**);
867 static void free_line_header (struct line_header
*lh
);
869 static void add_file_name (struct line_header
*, char *, unsigned int,
870 unsigned int, unsigned int);
872 static struct line_header
*(dwarf_decode_line_header
873 (unsigned int offset
,
874 bfd
*abfd
, struct dwarf2_cu
*cu
));
876 static void dwarf_decode_lines (struct line_header
*, char *, bfd
*,
877 struct dwarf2_cu
*, struct partial_symtab
*);
879 static void dwarf2_start_subfile (char *, char *, char *);
881 static struct symbol
*new_symbol (struct die_info
*, struct type
*,
884 static void dwarf2_const_value (struct attribute
*, struct symbol
*,
887 static void dwarf2_const_value_data (struct attribute
*attr
,
891 static struct type
*die_type (struct die_info
*, struct dwarf2_cu
*);
893 static struct type
*die_containing_type (struct die_info
*,
896 static struct type
*tag_type_to_type (struct die_info
*, struct dwarf2_cu
*);
898 static struct type
*read_type_die (struct die_info
*, struct dwarf2_cu
*);
900 static char *determine_prefix (struct die_info
*die
, struct dwarf2_cu
*);
902 static char *typename_concat (struct obstack
*,
907 static void read_file_scope (struct die_info
*, struct dwarf2_cu
*);
909 static void read_func_scope (struct die_info
*, struct dwarf2_cu
*);
911 static void read_lexical_block_scope (struct die_info
*, struct dwarf2_cu
*);
913 static int dwarf2_ranges_read (unsigned, CORE_ADDR
*, CORE_ADDR
*,
914 struct dwarf2_cu
*, struct partial_symtab
*);
916 static int dwarf2_get_pc_bounds (struct die_info
*,
917 CORE_ADDR
*, CORE_ADDR
*, struct dwarf2_cu
*);
919 static void get_scope_pc_bounds (struct die_info
*,
920 CORE_ADDR
*, CORE_ADDR
*,
923 static void dwarf2_record_block_ranges (struct die_info
*, struct block
*,
924 CORE_ADDR
, struct dwarf2_cu
*);
926 static void dwarf2_add_field (struct field_info
*, struct die_info
*,
929 static void dwarf2_attach_fields_to_type (struct field_info
*,
930 struct type
*, struct dwarf2_cu
*);
932 static void dwarf2_add_member_fn (struct field_info
*,
933 struct die_info
*, struct type
*,
936 static void dwarf2_attach_fn_fields_to_type (struct field_info
*,
937 struct type
*, struct dwarf2_cu
*);
939 static void process_structure_scope (struct die_info
*, struct dwarf2_cu
*);
941 static const char *determine_class_name (struct die_info
*die
,
942 struct dwarf2_cu
*cu
);
944 static void read_common_block (struct die_info
*, struct dwarf2_cu
*);
946 static void read_namespace (struct die_info
*die
, struct dwarf2_cu
*);
948 static void read_module (struct die_info
*die
, struct dwarf2_cu
*cu
);
950 static void read_import_statement (struct die_info
*die
, struct dwarf2_cu
*);
952 static const char *namespace_name (struct die_info
*die
,
953 int *is_anonymous
, struct dwarf2_cu
*);
955 static void process_enumeration_scope (struct die_info
*, struct dwarf2_cu
*);
957 static CORE_ADDR
decode_locdesc (struct dwarf_block
*, struct dwarf2_cu
*);
959 static enum dwarf_array_dim_ordering
read_array_order (struct die_info
*,
962 static struct die_info
*read_comp_unit (gdb_byte
*, bfd
*, struct dwarf2_cu
*);
964 static struct die_info
*read_die_and_children_1 (gdb_byte
*info_ptr
, bfd
*abfd
,
966 gdb_byte
**new_info_ptr
,
967 struct die_info
*parent
);
969 static struct die_info
*read_die_and_children (gdb_byte
*info_ptr
, bfd
*abfd
,
971 gdb_byte
**new_info_ptr
,
972 struct die_info
*parent
);
974 static struct die_info
*read_die_and_siblings (gdb_byte
*info_ptr
, bfd
*abfd
,
976 gdb_byte
**new_info_ptr
,
977 struct die_info
*parent
);
979 static void process_die (struct die_info
*, struct dwarf2_cu
*);
981 static char *dwarf2_linkage_name (struct die_info
*, struct dwarf2_cu
*);
983 static char *dwarf2_canonicalize_name (char *, struct dwarf2_cu
*,
986 static char *dwarf2_name (struct die_info
*die
, struct dwarf2_cu
*);
988 static struct die_info
*dwarf2_extension (struct die_info
*die
,
989 struct dwarf2_cu
**);
991 static char *dwarf_tag_name (unsigned int);
993 static char *dwarf_attr_name (unsigned int);
995 static char *dwarf_form_name (unsigned int);
997 static char *dwarf_stack_op_name (unsigned int);
999 static char *dwarf_bool_name (unsigned int);
1001 static char *dwarf_type_encoding_name (unsigned int);
1004 static char *dwarf_cfi_name (unsigned int);
1007 static struct die_info
*sibling_die (struct die_info
*);
1009 static void dump_die_shallow (struct ui_file
*, int indent
, struct die_info
*);
1011 static void dump_die_for_error (struct die_info
*);
1013 static void dump_die_1 (struct ui_file
*, int level
, int max_level
,
1016 /*static*/ void dump_die (struct die_info
*, int max_level
);
1018 static void store_in_ref_table (struct die_info
*,
1019 struct dwarf2_cu
*);
1021 static unsigned int dwarf2_get_ref_die_offset (struct attribute
*);
1023 static int dwarf2_get_attr_constant_value (struct attribute
*, int);
1025 static struct die_info
*follow_die_ref (struct die_info
*,
1027 struct dwarf2_cu
**);
1029 /* memory allocation interface */
1031 static struct dwarf_block
*dwarf_alloc_block (struct dwarf2_cu
*);
1033 static struct abbrev_info
*dwarf_alloc_abbrev (struct dwarf2_cu
*);
1035 static struct die_info
*dwarf_alloc_die (struct dwarf2_cu
*, int);
1037 static void initialize_cu_func_list (struct dwarf2_cu
*);
1039 static void add_to_cu_func_list (const char *, CORE_ADDR
, CORE_ADDR
,
1040 struct dwarf2_cu
*);
1042 static void dwarf_decode_macros (struct line_header
*, unsigned int,
1043 char *, bfd
*, struct dwarf2_cu
*);
1045 static int attr_form_is_block (struct attribute
*);
1047 static int attr_form_is_section_offset (struct attribute
*);
1049 static int attr_form_is_constant (struct attribute
*);
1051 static void dwarf2_symbol_mark_computed (struct attribute
*attr
,
1053 struct dwarf2_cu
*cu
);
1055 static gdb_byte
*skip_one_die (gdb_byte
*info_ptr
, struct abbrev_info
*abbrev
,
1056 struct dwarf2_cu
*cu
);
1058 static void free_stack_comp_unit (void *);
1060 static hashval_t
partial_die_hash (const void *item
);
1062 static int partial_die_eq (const void *item_lhs
, const void *item_rhs
);
1064 static struct dwarf2_per_cu_data
*dwarf2_find_containing_comp_unit
1065 (unsigned int offset
, struct objfile
*objfile
);
1067 static struct dwarf2_per_cu_data
*dwarf2_find_comp_unit
1068 (unsigned int offset
, struct objfile
*objfile
);
1070 static void free_one_comp_unit (void *);
1072 static void free_cached_comp_units (void *);
1074 static void age_cached_comp_units (void);
1076 static void free_one_cached_comp_unit (void *);
1078 static struct type
*set_die_type (struct die_info
*, struct type
*,
1079 struct dwarf2_cu
*);
1081 static void create_all_comp_units (struct objfile
*);
1083 static struct dwarf2_cu
*load_full_comp_unit (struct dwarf2_per_cu_data
*,
1086 static void process_full_comp_unit (struct dwarf2_per_cu_data
*);
1088 static void dwarf2_add_dependence (struct dwarf2_cu
*,
1089 struct dwarf2_per_cu_data
*);
1091 static void dwarf2_mark (struct dwarf2_cu
*);
1093 static void dwarf2_clear_marks (struct dwarf2_per_cu_data
*);
1095 static struct type
*get_die_type (struct die_info
*die
, struct dwarf2_cu
*cu
);
1097 /* Try to locate the sections we need for DWARF 2 debugging
1098 information and return true if we have enough to do something. */
1101 dwarf2_has_info (struct objfile
*objfile
)
1103 struct dwarf2_per_objfile
*data
;
1105 /* Initialize per-objfile state. */
1106 data
= obstack_alloc (&objfile
->objfile_obstack
, sizeof (*data
));
1107 memset (data
, 0, sizeof (*data
));
1108 set_objfile_data (objfile
, dwarf2_objfile_data_key
, data
);
1109 dwarf2_per_objfile
= data
;
1111 bfd_map_over_sections (objfile
->obfd
, dwarf2_locate_sections
, NULL
);
1112 return (data
->info
.asection
!= NULL
&& data
->abbrev
.asection
!= NULL
);
1115 /* When loading sections, we can either look for ".<name>", or for
1116 * ".z<name>", which indicates a compressed section. */
1119 section_is_p (const char *section_name
, const char *name
)
1121 return (section_name
[0] == '.'
1122 && (strcmp (section_name
+ 1, name
) == 0
1123 || (section_name
[1] == 'z'
1124 && strcmp (section_name
+ 2, name
) == 0)));
1127 /* This function is mapped across the sections and remembers the
1128 offset and size of each of the debugging sections we are interested
1132 dwarf2_locate_sections (bfd
*abfd
, asection
*sectp
, void *ignore_ptr
)
1134 if (section_is_p (sectp
->name
, INFO_SECTION
))
1136 dwarf2_per_objfile
->info
.asection
= sectp
;
1137 dwarf2_per_objfile
->info
.size
= bfd_get_section_size (sectp
);
1139 else if (section_is_p (sectp
->name
, ABBREV_SECTION
))
1141 dwarf2_per_objfile
->abbrev
.asection
= sectp
;
1142 dwarf2_per_objfile
->abbrev
.size
= bfd_get_section_size (sectp
);
1144 else if (section_is_p (sectp
->name
, LINE_SECTION
))
1146 dwarf2_per_objfile
->line
.asection
= sectp
;
1147 dwarf2_per_objfile
->line
.size
= bfd_get_section_size (sectp
);
1149 else if (section_is_p (sectp
->name
, PUBNAMES_SECTION
))
1151 dwarf2_per_objfile
->pubnames
.asection
= sectp
;
1152 dwarf2_per_objfile
->pubnames
.size
= bfd_get_section_size (sectp
);
1154 else if (section_is_p (sectp
->name
, ARANGES_SECTION
))
1156 dwarf2_per_objfile
->aranges
.asection
= sectp
;
1157 dwarf2_per_objfile
->aranges
.size
= bfd_get_section_size (sectp
);
1159 else if (section_is_p (sectp
->name
, LOC_SECTION
))
1161 dwarf2_per_objfile
->loc
.asection
= sectp
;
1162 dwarf2_per_objfile
->loc
.size
= bfd_get_section_size (sectp
);
1164 else if (section_is_p (sectp
->name
, MACINFO_SECTION
))
1166 dwarf2_per_objfile
->macinfo
.asection
= sectp
;
1167 dwarf2_per_objfile
->macinfo
.size
= bfd_get_section_size (sectp
);
1169 else if (section_is_p (sectp
->name
, STR_SECTION
))
1171 dwarf2_per_objfile
->str
.asection
= sectp
;
1172 dwarf2_per_objfile
->str
.size
= bfd_get_section_size (sectp
);
1174 else if (section_is_p (sectp
->name
, FRAME_SECTION
))
1176 dwarf2_per_objfile
->frame
.asection
= sectp
;
1177 dwarf2_per_objfile
->frame
.size
= bfd_get_section_size (sectp
);
1179 else if (section_is_p (sectp
->name
, EH_FRAME_SECTION
))
1181 flagword aflag
= bfd_get_section_flags (ignore_abfd
, sectp
);
1182 if (aflag
& SEC_HAS_CONTENTS
)
1184 dwarf2_per_objfile
->eh_frame
.asection
= sectp
;
1185 dwarf2_per_objfile
->eh_frame
.size
= bfd_get_section_size (sectp
);
1188 else if (section_is_p (sectp
->name
, RANGES_SECTION
))
1190 dwarf2_per_objfile
->ranges
.asection
= sectp
;
1191 dwarf2_per_objfile
->ranges
.size
= bfd_get_section_size (sectp
);
1194 if ((bfd_get_section_flags (abfd
, sectp
) & SEC_LOAD
)
1195 && bfd_section_vma (abfd
, sectp
) == 0)
1196 dwarf2_per_objfile
->has_section_at_zero
= 1;
1199 /* Decompress a section that was compressed using zlib. Store the
1200 decompressed buffer, and its size, in OUTBUF and OUTSIZE. */
1203 zlib_decompress_section (struct objfile
*objfile
, asection
*sectp
,
1204 gdb_byte
**outbuf
, bfd_size_type
*outsize
)
1206 bfd
*abfd
= objfile
->obfd
;
1208 error (_("Support for zlib-compressed DWARF data (from '%s') "
1209 "is disabled in this copy of GDB"),
1210 bfd_get_filename (abfd
));
1212 bfd_size_type compressed_size
= bfd_get_section_size (sectp
);
1213 gdb_byte
*compressed_buffer
= xmalloc (compressed_size
);
1214 struct cleanup
*cleanup
= make_cleanup (xfree
, compressed_buffer
);
1215 bfd_size_type uncompressed_size
;
1216 gdb_byte
*uncompressed_buffer
;
1219 int header_size
= 12;
1221 if (bfd_seek (abfd
, sectp
->filepos
, SEEK_SET
) != 0
1222 || bfd_bread (compressed_buffer
, compressed_size
, abfd
) != compressed_size
)
1223 error (_("Dwarf Error: Can't read DWARF data from '%s'"),
1224 bfd_get_filename (abfd
));
1226 /* Read the zlib header. In this case, it should be "ZLIB" followed
1227 by the uncompressed section size, 8 bytes in big-endian order. */
1228 if (compressed_size
< header_size
1229 || strncmp (compressed_buffer
, "ZLIB", 4) != 0)
1230 error (_("Dwarf Error: Corrupt DWARF ZLIB header from '%s'"),
1231 bfd_get_filename (abfd
));
1232 uncompressed_size
= compressed_buffer
[4]; uncompressed_size
<<= 8;
1233 uncompressed_size
+= compressed_buffer
[5]; uncompressed_size
<<= 8;
1234 uncompressed_size
+= compressed_buffer
[6]; uncompressed_size
<<= 8;
1235 uncompressed_size
+= compressed_buffer
[7]; uncompressed_size
<<= 8;
1236 uncompressed_size
+= compressed_buffer
[8]; uncompressed_size
<<= 8;
1237 uncompressed_size
+= compressed_buffer
[9]; uncompressed_size
<<= 8;
1238 uncompressed_size
+= compressed_buffer
[10]; uncompressed_size
<<= 8;
1239 uncompressed_size
+= compressed_buffer
[11];
1241 /* It is possible the section consists of several compressed
1242 buffers concatenated together, so we uncompress in a loop. */
1246 strm
.avail_in
= compressed_size
- header_size
;
1247 strm
.next_in
= (Bytef
*) compressed_buffer
+ header_size
;
1248 strm
.avail_out
= uncompressed_size
;
1249 uncompressed_buffer
= obstack_alloc (&objfile
->objfile_obstack
,
1251 rc
= inflateInit (&strm
);
1252 while (strm
.avail_in
> 0)
1255 error (_("Dwarf Error: setting up DWARF uncompression in '%s': %d"),
1256 bfd_get_filename (abfd
), rc
);
1257 strm
.next_out
= ((Bytef
*) uncompressed_buffer
1258 + (uncompressed_size
- strm
.avail_out
));
1259 rc
= inflate (&strm
, Z_FINISH
);
1260 if (rc
!= Z_STREAM_END
)
1261 error (_("Dwarf Error: zlib error uncompressing from '%s': %d"),
1262 bfd_get_filename (abfd
), rc
);
1263 rc
= inflateReset (&strm
);
1265 rc
= inflateEnd (&strm
);
1267 || strm
.avail_out
!= 0)
1268 error (_("Dwarf Error: concluding DWARF uncompression in '%s': %d"),
1269 bfd_get_filename (abfd
), rc
);
1271 do_cleanups (cleanup
);
1272 *outbuf
= uncompressed_buffer
;
1273 *outsize
= uncompressed_size
;
1277 /* Read the contents of the section SECTP from object file specified by
1278 OBJFILE, store info about the section into INFO.
1279 If the section is compressed, uncompress it before returning. */
1282 dwarf2_read_section (struct objfile
*objfile
, struct dwarf2_section_info
*info
)
1284 bfd
*abfd
= objfile
->obfd
;
1285 asection
*sectp
= info
->asection
;
1286 gdb_byte
*buf
, *retbuf
;
1287 unsigned char header
[4];
1289 info
->buffer
= NULL
;
1290 info
->was_mmapped
= 0;
1292 if (info
->asection
== NULL
|| info
->size
== 0)
1295 /* Check if the file has a 4-byte header indicating compression. */
1296 if (info
->size
> sizeof (header
)
1297 && bfd_seek (abfd
, sectp
->filepos
, SEEK_SET
) == 0
1298 && bfd_bread (header
, sizeof (header
), abfd
) == sizeof (header
))
1300 /* Upon decompression, update the buffer and its size. */
1301 if (strncmp (header
, "ZLIB", sizeof (header
)) == 0)
1303 zlib_decompress_section (objfile
, sectp
, &info
->buffer
,
1311 pagesize
= getpagesize ();
1313 /* Only try to mmap sections which are large enough: we don't want to
1314 waste space due to fragmentation. Also, only try mmap for sections
1315 without relocations. */
1317 if (info
->size
> 4 * pagesize
&& (sectp
->flags
& SEC_RELOC
) == 0)
1319 off_t pg_offset
= sectp
->filepos
& ~(pagesize
- 1);
1320 size_t map_length
= info
->size
+ sectp
->filepos
- pg_offset
;
1321 caddr_t retbuf
= bfd_mmap (abfd
, 0, map_length
, PROT_READ
,
1322 MAP_PRIVATE
, pg_offset
);
1324 if (retbuf
!= MAP_FAILED
)
1326 info
->was_mmapped
= 1;
1327 info
->buffer
= retbuf
+ (sectp
->filepos
& (pagesize
- 1)) ;
1333 /* If we get here, we are a normal, not-compressed section. */
1335 = obstack_alloc (&objfile
->objfile_obstack
, info
->size
);
1337 /* When debugging .o files, we may need to apply relocations; see
1338 http://sourceware.org/ml/gdb-patches/2002-04/msg00136.html .
1339 We never compress sections in .o files, so we only need to
1340 try this when the section is not compressed. */
1341 retbuf
= symfile_relocate_debug_section (abfd
, sectp
, buf
);
1344 info
->buffer
= retbuf
;
1348 if (bfd_seek (abfd
, sectp
->filepos
, SEEK_SET
) != 0
1349 || bfd_bread (buf
, info
->size
, abfd
) != info
->size
)
1350 error (_("Dwarf Error: Can't read DWARF data from '%s'"),
1351 bfd_get_filename (abfd
));
1354 /* Fill in SECTP, BUFP and SIZEP with section info, given OBJFILE and
1358 dwarf2_get_section_info (struct objfile
*objfile
, const char *section_name
,
1359 asection
**sectp
, gdb_byte
**bufp
,
1360 bfd_size_type
*sizep
)
1362 struct dwarf2_per_objfile
*data
1363 = objfile_data (objfile
, dwarf2_objfile_data_key
);
1364 struct dwarf2_section_info
*info
;
1365 if (section_is_p (section_name
, EH_FRAME_SECTION
))
1366 info
= &data
->eh_frame
;
1367 else if (section_is_p (section_name
, FRAME_SECTION
))
1368 info
= &data
->frame
;
1372 if (info
->asection
!= NULL
&& info
->size
!= 0 && info
->buffer
== NULL
)
1373 /* We haven't read this section in yet. Do it now. */
1374 dwarf2_read_section (objfile
, info
);
1376 *sectp
= info
->asection
;
1377 *bufp
= info
->buffer
;
1378 *sizep
= info
->size
;
1381 /* Build a partial symbol table. */
1384 dwarf2_build_psymtabs (struct objfile
*objfile
, int mainline
)
1386 dwarf2_read_section (objfile
, &dwarf2_per_objfile
->info
);
1387 dwarf2_read_section (objfile
, &dwarf2_per_objfile
->abbrev
);
1388 dwarf2_read_section (objfile
, &dwarf2_per_objfile
->line
);
1389 dwarf2_read_section (objfile
, &dwarf2_per_objfile
->str
);
1390 dwarf2_read_section (objfile
, &dwarf2_per_objfile
->macinfo
);
1391 dwarf2_read_section (objfile
, &dwarf2_per_objfile
->ranges
);
1392 dwarf2_read_section (objfile
, &dwarf2_per_objfile
->loc
);
1393 dwarf2_read_section (objfile
, &dwarf2_per_objfile
->eh_frame
);
1394 dwarf2_read_section (objfile
, &dwarf2_per_objfile
->frame
);
1397 || (objfile
->global_psymbols
.size
== 0
1398 && objfile
->static_psymbols
.size
== 0))
1400 init_psymbol_list (objfile
, 1024);
1404 if (dwarf_aranges_offset
&& dwarf_pubnames_offset
)
1406 /* Things are significantly easier if we have .debug_aranges and
1407 .debug_pubnames sections */
1409 dwarf2_build_psymtabs_easy (objfile
, mainline
);
1413 /* only test this case for now */
1415 /* In this case we have to work a bit harder */
1416 dwarf2_build_psymtabs_hard (objfile
, mainline
);
1421 /* Build the partial symbol table from the information in the
1422 .debug_pubnames and .debug_aranges sections. */
1425 dwarf2_build_psymtabs_easy (struct objfile
*objfile
, int mainline
)
1427 bfd
*abfd
= objfile
->obfd
;
1428 char *aranges_buffer
, *pubnames_buffer
;
1429 char *aranges_ptr
, *pubnames_ptr
;
1430 unsigned int entry_length
, version
, info_offset
, info_size
;
1432 pubnames_buffer
= dwarf2_read_section (objfile
,
1433 dwarf_pubnames_section
);
1434 pubnames_ptr
= pubnames_buffer
;
1435 while ((pubnames_ptr
- pubnames_buffer
) < dwarf2_per_objfile
->pubnames
.size
)
1437 unsigned int bytes_read
;
1439 entry_length
= read_initial_length (abfd
, pubnames_ptr
, &bytes_read
);
1440 pubnames_ptr
+= bytes_read
;
1441 version
= read_1_byte (abfd
, pubnames_ptr
);
1443 info_offset
= read_4_bytes (abfd
, pubnames_ptr
);
1445 info_size
= read_4_bytes (abfd
, pubnames_ptr
);
1449 aranges_buffer
= dwarf2_read_section (objfile
,
1450 dwarf_aranges_section
);
1455 /* Return TRUE if OFFSET is within CU_HEADER. */
1458 offset_in_cu_p (const struct comp_unit_head
*cu_header
, unsigned int offset
)
1460 unsigned int bottom
= cu_header
->offset
;
1461 unsigned int top
= (cu_header
->offset
1463 + cu_header
->initial_length_size
);
1464 return (offset
>= bottom
&& offset
< top
);
1467 /* Read in the comp unit header information from the debug_info at
1471 read_comp_unit_head (struct comp_unit_head
*cu_header
,
1472 gdb_byte
*info_ptr
, bfd
*abfd
)
1475 unsigned int bytes_read
;
1477 cu_header
->length
= read_initial_length (abfd
, info_ptr
, &bytes_read
);
1478 cu_header
->initial_length_size
= bytes_read
;
1479 cu_header
->offset_size
= (bytes_read
== 4) ? 4 : 8;
1480 info_ptr
+= bytes_read
;
1481 cu_header
->version
= read_2_bytes (abfd
, info_ptr
);
1483 cu_header
->abbrev_offset
= read_offset (abfd
, info_ptr
, cu_header
,
1485 info_ptr
+= bytes_read
;
1486 cu_header
->addr_size
= read_1_byte (abfd
, info_ptr
);
1488 signed_addr
= bfd_get_sign_extend_vma (abfd
);
1489 if (signed_addr
< 0)
1490 internal_error (__FILE__
, __LINE__
,
1491 _("read_comp_unit_head: dwarf from non elf file"));
1492 cu_header
->signed_addr_p
= signed_addr
;
1498 partial_read_comp_unit_head (struct comp_unit_head
*header
, gdb_byte
*info_ptr
,
1501 gdb_byte
*beg_of_comp_unit
= info_ptr
;
1503 info_ptr
= read_comp_unit_head (header
, info_ptr
, abfd
);
1505 if (header
->version
!= 2 && header
->version
!= 3)
1506 error (_("Dwarf Error: wrong version in compilation unit header "
1507 "(is %d, should be %d) [in module %s]"), header
->version
,
1508 2, bfd_get_filename (abfd
));
1510 if (header
->abbrev_offset
>= dwarf2_per_objfile
->abbrev
.size
)
1511 error (_("Dwarf Error: bad offset (0x%lx) in compilation unit header "
1512 "(offset 0x%lx + 6) [in module %s]"),
1513 (long) header
->abbrev_offset
,
1514 (long) (beg_of_comp_unit
- dwarf2_per_objfile
->info
.buffer
),
1515 bfd_get_filename (abfd
));
1517 if (beg_of_comp_unit
+ header
->length
+ header
->initial_length_size
1518 > dwarf2_per_objfile
->info
.buffer
+ dwarf2_per_objfile
->info
.size
)
1519 error (_("Dwarf Error: bad length (0x%lx) in compilation unit header "
1520 "(offset 0x%lx + 0) [in module %s]"),
1521 (long) header
->length
,
1522 (long) (beg_of_comp_unit
- dwarf2_per_objfile
->info
.buffer
),
1523 bfd_get_filename (abfd
));
1528 /* Allocate a new partial symtab for file named NAME and mark this new
1529 partial symtab as being an include of PST. */
1532 dwarf2_create_include_psymtab (char *name
, struct partial_symtab
*pst
,
1533 struct objfile
*objfile
)
1535 struct partial_symtab
*subpst
= allocate_psymtab (name
, objfile
);
1537 subpst
->section_offsets
= pst
->section_offsets
;
1538 subpst
->textlow
= 0;
1539 subpst
->texthigh
= 0;
1541 subpst
->dependencies
= (struct partial_symtab
**)
1542 obstack_alloc (&objfile
->objfile_obstack
,
1543 sizeof (struct partial_symtab
*));
1544 subpst
->dependencies
[0] = pst
;
1545 subpst
->number_of_dependencies
= 1;
1547 subpst
->globals_offset
= 0;
1548 subpst
->n_global_syms
= 0;
1549 subpst
->statics_offset
= 0;
1550 subpst
->n_static_syms
= 0;
1551 subpst
->symtab
= NULL
;
1552 subpst
->read_symtab
= pst
->read_symtab
;
1555 /* No private part is necessary for include psymtabs. This property
1556 can be used to differentiate between such include psymtabs and
1557 the regular ones. */
1558 subpst
->read_symtab_private
= NULL
;
1561 /* Read the Line Number Program data and extract the list of files
1562 included by the source file represented by PST. Build an include
1563 partial symtab for each of these included files.
1565 This procedure assumes that there *is* a Line Number Program in
1566 the given CU. Callers should check that PDI->HAS_STMT_LIST is set
1567 before calling this procedure. */
1570 dwarf2_build_include_psymtabs (struct dwarf2_cu
*cu
,
1571 struct partial_die_info
*pdi
,
1572 struct partial_symtab
*pst
)
1574 struct objfile
*objfile
= cu
->objfile
;
1575 bfd
*abfd
= objfile
->obfd
;
1576 struct line_header
*lh
;
1578 lh
= dwarf_decode_line_header (pdi
->line_offset
, abfd
, cu
);
1580 return; /* No linetable, so no includes. */
1582 dwarf_decode_lines (lh
, NULL
, abfd
, cu
, pst
);
1584 free_line_header (lh
);
1588 /* Build the partial symbol table by doing a quick pass through the
1589 .debug_info and .debug_abbrev sections. */
1592 dwarf2_build_psymtabs_hard (struct objfile
*objfile
, int mainline
)
1594 /* Instead of reading this into a big buffer, we should probably use
1595 mmap() on architectures that support it. (FIXME) */
1596 bfd
*abfd
= objfile
->obfd
;
1598 gdb_byte
*beg_of_comp_unit
;
1599 struct partial_die_info comp_unit_die
;
1600 struct partial_symtab
*pst
;
1601 struct cleanup
*back_to
;
1604 info_ptr
= dwarf2_per_objfile
->info
.buffer
;
1606 /* Any cached compilation units will be linked by the per-objfile
1607 read_in_chain. Make sure to free them when we're done. */
1608 back_to
= make_cleanup (free_cached_comp_units
, NULL
);
1610 create_all_comp_units (objfile
);
1612 objfile
->psymtabs_addrmap
= addrmap_create_mutable
1613 (&objfile
->objfile_obstack
);
1615 /* Since the objects we're extracting from .debug_info vary in
1616 length, only the individual functions to extract them (like
1617 read_comp_unit_head and load_partial_die) can really know whether
1618 the buffer is large enough to hold another complete object.
1620 At the moment, they don't actually check that. If .debug_info
1621 holds just one extra byte after the last compilation unit's dies,
1622 then read_comp_unit_head will happily read off the end of the
1623 buffer. read_partial_die is similarly casual. Those functions
1626 For this loop condition, simply checking whether there's any data
1627 left at all should be sufficient. */
1628 while (info_ptr
< (dwarf2_per_objfile
->info
.buffer
1629 + dwarf2_per_objfile
->info
.size
))
1631 struct cleanup
*back_to_inner
;
1632 struct dwarf2_cu cu
;
1633 struct abbrev_info
*abbrev
;
1634 unsigned int bytes_read
;
1635 struct dwarf2_per_cu_data
*this_cu
;
1637 beg_of_comp_unit
= info_ptr
;
1639 memset (&cu
, 0, sizeof (cu
));
1641 obstack_init (&cu
.comp_unit_obstack
);
1643 back_to_inner
= make_cleanup (free_stack_comp_unit
, &cu
);
1645 cu
.objfile
= objfile
;
1646 info_ptr
= partial_read_comp_unit_head (&cu
.header
, info_ptr
, abfd
);
1648 /* Complete the cu_header */
1649 cu
.header
.offset
= beg_of_comp_unit
- dwarf2_per_objfile
->info
.buffer
;
1650 cu
.header
.first_die_offset
= info_ptr
- beg_of_comp_unit
;
1652 cu
.list_in_scope
= &file_symbols
;
1654 /* Read the abbrevs for this compilation unit into a table */
1655 dwarf2_read_abbrevs (abfd
, &cu
);
1656 make_cleanup (dwarf2_free_abbrev_table
, &cu
);
1658 this_cu
= dwarf2_find_comp_unit (cu
.header
.offset
, objfile
);
1660 /* Read the compilation unit die */
1661 abbrev
= peek_die_abbrev (info_ptr
, &bytes_read
, &cu
);
1662 info_ptr
= read_partial_die (&comp_unit_die
, abbrev
, bytes_read
,
1663 abfd
, info_ptr
, &cu
);
1665 if (comp_unit_die
.tag
== DW_TAG_partial_unit
)
1667 info_ptr
= (beg_of_comp_unit
+ cu
.header
.length
1668 + cu
.header
.initial_length_size
);
1669 do_cleanups (back_to_inner
);
1673 /* Set the language we're debugging */
1674 set_cu_language (comp_unit_die
.language
, &cu
);
1676 /* Allocate a new partial symbol table structure */
1677 pst
= start_psymtab_common (objfile
, objfile
->section_offsets
,
1678 comp_unit_die
.name
? comp_unit_die
.name
: "",
1679 /* TEXTLOW and TEXTHIGH are set below. */
1681 objfile
->global_psymbols
.next
,
1682 objfile
->static_psymbols
.next
);
1684 if (comp_unit_die
.dirname
)
1685 pst
->dirname
= obsavestring (comp_unit_die
.dirname
,
1686 strlen (comp_unit_die
.dirname
),
1687 &objfile
->objfile_obstack
);
1689 pst
->read_symtab_private
= (char *) this_cu
;
1691 baseaddr
= ANOFFSET (objfile
->section_offsets
, SECT_OFF_TEXT (objfile
));
1693 /* Store the function that reads in the rest of the symbol table */
1694 pst
->read_symtab
= dwarf2_psymtab_to_symtab
;
1696 /* If this compilation unit was already read in, free the
1697 cached copy in order to read it in again. This is
1698 necessary because we skipped some symbols when we first
1699 read in the compilation unit (see load_partial_dies).
1700 This problem could be avoided, but the benefit is
1702 if (this_cu
->cu
!= NULL
)
1703 free_one_cached_comp_unit (this_cu
->cu
);
1705 cu
.per_cu
= this_cu
;
1707 /* Note that this is a pointer to our stack frame, being
1708 added to a global data structure. It will be cleaned up
1709 in free_stack_comp_unit when we finish with this
1710 compilation unit. */
1713 this_cu
->psymtab
= pst
;
1715 /* Possibly set the default values of LOWPC and HIGHPC from
1717 if (cu
.has_ranges_offset
)
1719 if (dwarf2_ranges_read (cu
.ranges_offset
, &comp_unit_die
.lowpc
,
1720 &comp_unit_die
.highpc
, &cu
, pst
))
1721 comp_unit_die
.has_pc_info
= 1;
1723 else if (comp_unit_die
.has_pc_info
1724 && comp_unit_die
.lowpc
< comp_unit_die
.highpc
)
1725 /* Store the contiguous range if it is not empty; it can be empty for
1726 CUs with no code. */
1727 addrmap_set_empty (objfile
->psymtabs_addrmap
,
1728 comp_unit_die
.lowpc
+ baseaddr
,
1729 comp_unit_die
.highpc
+ baseaddr
- 1, pst
);
1731 /* Check if comp unit has_children.
1732 If so, read the rest of the partial symbols from this comp unit.
1733 If not, there's no more debug_info for this comp unit. */
1734 if (comp_unit_die
.has_children
)
1736 struct partial_die_info
*first_die
;
1737 CORE_ADDR lowpc
, highpc
;
1739 lowpc
= ((CORE_ADDR
) -1);
1740 highpc
= ((CORE_ADDR
) 0);
1742 first_die
= load_partial_dies (abfd
, info_ptr
, 1, &cu
);
1744 scan_partial_symbols (first_die
, &lowpc
, &highpc
,
1745 ! comp_unit_die
.has_pc_info
, &cu
);
1747 /* If we didn't find a lowpc, set it to highpc to avoid
1748 complaints from `maint check'. */
1749 if (lowpc
== ((CORE_ADDR
) -1))
1752 /* If the compilation unit didn't have an explicit address range,
1753 then use the information extracted from its child dies. */
1754 if (! comp_unit_die
.has_pc_info
)
1756 comp_unit_die
.lowpc
= lowpc
;
1757 comp_unit_die
.highpc
= highpc
;
1760 pst
->textlow
= comp_unit_die
.lowpc
+ baseaddr
;
1761 pst
->texthigh
= comp_unit_die
.highpc
+ baseaddr
;
1763 pst
->n_global_syms
= objfile
->global_psymbols
.next
-
1764 (objfile
->global_psymbols
.list
+ pst
->globals_offset
);
1765 pst
->n_static_syms
= objfile
->static_psymbols
.next
-
1766 (objfile
->static_psymbols
.list
+ pst
->statics_offset
);
1767 sort_pst_symbols (pst
);
1769 /* If there is already a psymtab or symtab for a file of this
1770 name, remove it. (If there is a symtab, more drastic things
1771 also happen.) This happens in VxWorks. */
1772 free_named_symtabs (pst
->filename
);
1774 info_ptr
= beg_of_comp_unit
+ cu
.header
.length
1775 + cu
.header
.initial_length_size
;
1777 if (comp_unit_die
.has_stmt_list
)
1779 /* Get the list of files included in the current compilation unit,
1780 and build a psymtab for each of them. */
1781 dwarf2_build_include_psymtabs (&cu
, &comp_unit_die
, pst
);
1784 do_cleanups (back_to_inner
);
1787 objfile
->psymtabs_addrmap
= addrmap_create_fixed (objfile
->psymtabs_addrmap
,
1788 &objfile
->objfile_obstack
);
1790 do_cleanups (back_to
);
1793 /* Load the DIEs for a secondary CU into memory. */
1796 load_comp_unit (struct dwarf2_per_cu_data
*this_cu
, struct objfile
*objfile
)
1798 bfd
*abfd
= objfile
->obfd
;
1799 gdb_byte
*info_ptr
, *beg_of_comp_unit
;
1800 struct partial_die_info comp_unit_die
;
1801 struct dwarf2_cu
*cu
;
1802 struct abbrev_info
*abbrev
;
1803 unsigned int bytes_read
;
1804 struct cleanup
*back_to
;
1806 info_ptr
= dwarf2_per_objfile
->info
.buffer
+ this_cu
->offset
;
1807 beg_of_comp_unit
= info_ptr
;
1809 cu
= xmalloc (sizeof (struct dwarf2_cu
));
1810 memset (cu
, 0, sizeof (struct dwarf2_cu
));
1812 obstack_init (&cu
->comp_unit_obstack
);
1814 cu
->objfile
= objfile
;
1815 info_ptr
= partial_read_comp_unit_head (&cu
->header
, info_ptr
, abfd
);
1817 /* Complete the cu_header. */
1818 cu
->header
.offset
= beg_of_comp_unit
- dwarf2_per_objfile
->info
.buffer
;
1819 cu
->header
.first_die_offset
= info_ptr
- beg_of_comp_unit
;
1821 /* Read the abbrevs for this compilation unit into a table. */
1822 dwarf2_read_abbrevs (abfd
, cu
);
1823 back_to
= make_cleanup (dwarf2_free_abbrev_table
, cu
);
1825 /* Read the compilation unit die. */
1826 abbrev
= peek_die_abbrev (info_ptr
, &bytes_read
, cu
);
1827 info_ptr
= read_partial_die (&comp_unit_die
, abbrev
, bytes_read
,
1828 abfd
, info_ptr
, cu
);
1830 /* Set the language we're debugging. */
1831 set_cu_language (comp_unit_die
.language
, cu
);
1833 /* Link this compilation unit into the compilation unit tree. */
1835 cu
->per_cu
= this_cu
;
1836 cu
->type_hash
= cu
->per_cu
->type_hash
;
1838 /* Check if comp unit has_children.
1839 If so, read the rest of the partial symbols from this comp unit.
1840 If not, there's no more debug_info for this comp unit. */
1841 if (comp_unit_die
.has_children
)
1842 load_partial_dies (abfd
, info_ptr
, 0, cu
);
1844 do_cleanups (back_to
);
1847 /* Create a list of all compilation units in OBJFILE. We do this only
1848 if an inter-comp-unit reference is found; presumably if there is one,
1849 there will be many, and one will occur early in the .debug_info section.
1850 So there's no point in building this list incrementally. */
1853 create_all_comp_units (struct objfile
*objfile
)
1857 struct dwarf2_per_cu_data
**all_comp_units
;
1858 gdb_byte
*info_ptr
= dwarf2_per_objfile
->info
.buffer
;
1862 all_comp_units
= xmalloc (n_allocated
1863 * sizeof (struct dwarf2_per_cu_data
*));
1865 while (info_ptr
< dwarf2_per_objfile
->info
.buffer
+ dwarf2_per_objfile
->info
.size
)
1867 unsigned int length
, initial_length_size
;
1868 gdb_byte
*beg_of_comp_unit
;
1869 struct dwarf2_per_cu_data
*this_cu
;
1870 unsigned int offset
;
1872 offset
= info_ptr
- dwarf2_per_objfile
->info
.buffer
;
1874 /* Read just enough information to find out where the next
1875 compilation unit is. */
1876 length
= read_initial_length (objfile
->obfd
, info_ptr
,
1877 &initial_length_size
);
1879 /* Save the compilation unit for later lookup. */
1880 this_cu
= obstack_alloc (&objfile
->objfile_obstack
,
1881 sizeof (struct dwarf2_per_cu_data
));
1882 memset (this_cu
, 0, sizeof (*this_cu
));
1883 this_cu
->offset
= offset
;
1884 this_cu
->length
= length
+ initial_length_size
;
1886 if (n_comp_units
== n_allocated
)
1889 all_comp_units
= xrealloc (all_comp_units
,
1891 * sizeof (struct dwarf2_per_cu_data
*));
1893 all_comp_units
[n_comp_units
++] = this_cu
;
1895 info_ptr
= info_ptr
+ this_cu
->length
;
1898 dwarf2_per_objfile
->all_comp_units
1899 = obstack_alloc (&objfile
->objfile_obstack
,
1900 n_comp_units
* sizeof (struct dwarf2_per_cu_data
*));
1901 memcpy (dwarf2_per_objfile
->all_comp_units
, all_comp_units
,
1902 n_comp_units
* sizeof (struct dwarf2_per_cu_data
*));
1903 xfree (all_comp_units
);
1904 dwarf2_per_objfile
->n_comp_units
= n_comp_units
;
1907 /* Process all loaded DIEs for compilation unit CU, starting at
1908 FIRST_DIE. The caller should pass NEED_PC == 1 if the compilation
1909 unit DIE did not have PC info (DW_AT_low_pc and DW_AT_high_pc, or
1910 DW_AT_ranges). If NEED_PC is set, then this function will set
1911 *LOWPC and *HIGHPC to the lowest and highest PC values found in CU
1912 and record the covered ranges in the addrmap. */
1915 scan_partial_symbols (struct partial_die_info
*first_die
, CORE_ADDR
*lowpc
,
1916 CORE_ADDR
*highpc
, int need_pc
, struct dwarf2_cu
*cu
)
1918 struct objfile
*objfile
= cu
->objfile
;
1919 bfd
*abfd
= objfile
->obfd
;
1920 struct partial_die_info
*pdi
;
1922 /* Now, march along the PDI's, descending into ones which have
1923 interesting children but skipping the children of the other ones,
1924 until we reach the end of the compilation unit. */
1930 fixup_partial_die (pdi
, cu
);
1932 /* Anonymous namespaces have no name but have interesting
1933 children, so we need to look at them. Ditto for anonymous
1936 if (pdi
->name
!= NULL
|| pdi
->tag
== DW_TAG_namespace
1937 || pdi
->tag
== DW_TAG_enumeration_type
)
1941 case DW_TAG_subprogram
:
1942 add_partial_subprogram (pdi
, lowpc
, highpc
, need_pc
, cu
);
1944 case DW_TAG_variable
:
1945 case DW_TAG_typedef
:
1946 case DW_TAG_union_type
:
1947 if (!pdi
->is_declaration
)
1949 add_partial_symbol (pdi
, cu
);
1952 case DW_TAG_class_type
:
1953 case DW_TAG_interface_type
:
1954 case DW_TAG_structure_type
:
1955 if (!pdi
->is_declaration
)
1957 add_partial_symbol (pdi
, cu
);
1960 case DW_TAG_enumeration_type
:
1961 if (!pdi
->is_declaration
)
1962 add_partial_enumeration (pdi
, cu
);
1964 case DW_TAG_base_type
:
1965 case DW_TAG_subrange_type
:
1966 /* File scope base type definitions are added to the partial
1968 add_partial_symbol (pdi
, cu
);
1970 case DW_TAG_namespace
:
1971 add_partial_namespace (pdi
, lowpc
, highpc
, need_pc
, cu
);
1974 add_partial_module (pdi
, lowpc
, highpc
, need_pc
, cu
);
1981 /* If the die has a sibling, skip to the sibling. */
1983 pdi
= pdi
->die_sibling
;
1987 /* Functions used to compute the fully scoped name of a partial DIE.
1989 Normally, this is simple. For C++, the parent DIE's fully scoped
1990 name is concatenated with "::" and the partial DIE's name. For
1991 Java, the same thing occurs except that "." is used instead of "::".
1992 Enumerators are an exception; they use the scope of their parent
1993 enumeration type, i.e. the name of the enumeration type is not
1994 prepended to the enumerator.
1996 There are two complexities. One is DW_AT_specification; in this
1997 case "parent" means the parent of the target of the specification,
1998 instead of the direct parent of the DIE. The other is compilers
1999 which do not emit DW_TAG_namespace; in this case we try to guess
2000 the fully qualified name of structure types from their members'
2001 linkage names. This must be done using the DIE's children rather
2002 than the children of any DW_AT_specification target. We only need
2003 to do this for structures at the top level, i.e. if the target of
2004 any DW_AT_specification (if any; otherwise the DIE itself) does not
2007 /* Compute the scope prefix associated with PDI's parent, in
2008 compilation unit CU. The result will be allocated on CU's
2009 comp_unit_obstack, or a copy of the already allocated PDI->NAME
2010 field. NULL is returned if no prefix is necessary. */
2012 partial_die_parent_scope (struct partial_die_info
*pdi
,
2013 struct dwarf2_cu
*cu
)
2015 char *grandparent_scope
;
2016 struct partial_die_info
*parent
, *real_pdi
;
2018 /* We need to look at our parent DIE; if we have a DW_AT_specification,
2019 then this means the parent of the specification DIE. */
2022 while (real_pdi
->has_specification
)
2023 real_pdi
= find_partial_die (real_pdi
->spec_offset
, cu
);
2025 parent
= real_pdi
->die_parent
;
2029 if (parent
->scope_set
)
2030 return parent
->scope
;
2032 fixup_partial_die (parent
, cu
);
2034 grandparent_scope
= partial_die_parent_scope (parent
, cu
);
2036 if (parent
->tag
== DW_TAG_namespace
2037 || parent
->tag
== DW_TAG_structure_type
2038 || parent
->tag
== DW_TAG_class_type
2039 || parent
->tag
== DW_TAG_interface_type
2040 || parent
->tag
== DW_TAG_union_type
)
2042 if (grandparent_scope
== NULL
)
2043 parent
->scope
= parent
->name
;
2045 parent
->scope
= typename_concat (&cu
->comp_unit_obstack
, grandparent_scope
,
2048 else if (parent
->tag
== DW_TAG_enumeration_type
)
2049 /* Enumerators should not get the name of the enumeration as a prefix. */
2050 parent
->scope
= grandparent_scope
;
2053 /* FIXME drow/2004-04-01: What should we be doing with
2054 function-local names? For partial symbols, we should probably be
2056 complaint (&symfile_complaints
,
2057 _("unhandled containing DIE tag %d for DIE at %d"),
2058 parent
->tag
, pdi
->offset
);
2059 parent
->scope
= grandparent_scope
;
2062 parent
->scope_set
= 1;
2063 return parent
->scope
;
2066 /* Return the fully scoped name associated with PDI, from compilation unit
2067 CU. The result will be allocated with malloc. */
2069 partial_die_full_name (struct partial_die_info
*pdi
,
2070 struct dwarf2_cu
*cu
)
2074 parent_scope
= partial_die_parent_scope (pdi
, cu
);
2075 if (parent_scope
== NULL
)
2078 return typename_concat (NULL
, parent_scope
, pdi
->name
, cu
);
2082 add_partial_symbol (struct partial_die_info
*pdi
, struct dwarf2_cu
*cu
)
2084 struct objfile
*objfile
= cu
->objfile
;
2086 char *actual_name
= NULL
;
2087 const char *my_prefix
;
2088 const struct partial_symbol
*psym
= NULL
;
2090 int built_actual_name
= 0;
2092 baseaddr
= ANOFFSET (objfile
->section_offsets
, SECT_OFF_TEXT (objfile
));
2094 if (pdi_needs_namespace (pdi
->tag
))
2096 actual_name
= partial_die_full_name (pdi
, cu
);
2098 built_actual_name
= 1;
2101 if (actual_name
== NULL
)
2102 actual_name
= pdi
->name
;
2106 case DW_TAG_subprogram
:
2107 if (pdi
->is_external
|| cu
->language
== language_ada
)
2109 /* brobecker/2007-12-26: Normally, only "external" DIEs are part
2110 of the global scope. But in Ada, we want to be able to access
2111 nested procedures globally. So all Ada subprograms are stored
2112 in the global scope. */
2113 /*prim_record_minimal_symbol (actual_name, pdi->lowpc + baseaddr,
2114 mst_text, objfile); */
2115 psym
= add_psymbol_to_list (actual_name
, strlen (actual_name
),
2116 VAR_DOMAIN
, LOC_BLOCK
,
2117 &objfile
->global_psymbols
,
2118 0, pdi
->lowpc
+ baseaddr
,
2119 cu
->language
, objfile
);
2123 /*prim_record_minimal_symbol (actual_name, pdi->lowpc + baseaddr,
2124 mst_file_text, objfile); */
2125 psym
= add_psymbol_to_list (actual_name
, strlen (actual_name
),
2126 VAR_DOMAIN
, LOC_BLOCK
,
2127 &objfile
->static_psymbols
,
2128 0, pdi
->lowpc
+ baseaddr
,
2129 cu
->language
, objfile
);
2132 case DW_TAG_variable
:
2133 if (pdi
->is_external
)
2136 Don't enter into the minimal symbol tables as there is
2137 a minimal symbol table entry from the ELF symbols already.
2138 Enter into partial symbol table if it has a location
2139 descriptor or a type.
2140 If the location descriptor is missing, new_symbol will create
2141 a LOC_UNRESOLVED symbol, the address of the variable will then
2142 be determined from the minimal symbol table whenever the variable
2144 The address for the partial symbol table entry is not
2145 used by GDB, but it comes in handy for debugging partial symbol
2149 addr
= decode_locdesc (pdi
->locdesc
, cu
);
2150 if (pdi
->locdesc
|| pdi
->has_type
)
2151 psym
= add_psymbol_to_list (actual_name
, strlen (actual_name
),
2152 VAR_DOMAIN
, LOC_STATIC
,
2153 &objfile
->global_psymbols
,
2155 cu
->language
, objfile
);
2159 /* Static Variable. Skip symbols without location descriptors. */
2160 if (pdi
->locdesc
== NULL
)
2162 if (built_actual_name
)
2163 xfree (actual_name
);
2166 addr
= decode_locdesc (pdi
->locdesc
, cu
);
2167 /*prim_record_minimal_symbol (actual_name, addr + baseaddr,
2168 mst_file_data, objfile); */
2169 psym
= add_psymbol_to_list (actual_name
, strlen (actual_name
),
2170 VAR_DOMAIN
, LOC_STATIC
,
2171 &objfile
->static_psymbols
,
2173 cu
->language
, objfile
);
2176 case DW_TAG_typedef
:
2177 case DW_TAG_base_type
:
2178 case DW_TAG_subrange_type
:
2179 add_psymbol_to_list (actual_name
, strlen (actual_name
),
2180 VAR_DOMAIN
, LOC_TYPEDEF
,
2181 &objfile
->static_psymbols
,
2182 0, (CORE_ADDR
) 0, cu
->language
, objfile
);
2184 case DW_TAG_namespace
:
2185 add_psymbol_to_list (actual_name
, strlen (actual_name
),
2186 VAR_DOMAIN
, LOC_TYPEDEF
,
2187 &objfile
->global_psymbols
,
2188 0, (CORE_ADDR
) 0, cu
->language
, objfile
);
2190 case DW_TAG_class_type
:
2191 case DW_TAG_interface_type
:
2192 case DW_TAG_structure_type
:
2193 case DW_TAG_union_type
:
2194 case DW_TAG_enumeration_type
:
2195 /* Skip external references. The DWARF standard says in the section
2196 about "Structure, Union, and Class Type Entries": "An incomplete
2197 structure, union or class type is represented by a structure,
2198 union or class entry that does not have a byte size attribute
2199 and that has a DW_AT_declaration attribute." */
2200 if (!pdi
->has_byte_size
&& pdi
->is_declaration
)
2202 if (built_actual_name
)
2203 xfree (actual_name
);
2207 /* NOTE: carlton/2003-10-07: See comment in new_symbol about
2208 static vs. global. */
2209 add_psymbol_to_list (actual_name
, strlen (actual_name
),
2210 STRUCT_DOMAIN
, LOC_TYPEDEF
,
2211 (cu
->language
== language_cplus
2212 || cu
->language
== language_java
)
2213 ? &objfile
->global_psymbols
2214 : &objfile
->static_psymbols
,
2215 0, (CORE_ADDR
) 0, cu
->language
, objfile
);
2218 case DW_TAG_enumerator
:
2219 add_psymbol_to_list (actual_name
, strlen (actual_name
),
2220 VAR_DOMAIN
, LOC_CONST
,
2221 (cu
->language
== language_cplus
2222 || cu
->language
== language_java
)
2223 ? &objfile
->global_psymbols
2224 : &objfile
->static_psymbols
,
2225 0, (CORE_ADDR
) 0, cu
->language
, objfile
);
2231 /* Check to see if we should scan the name for possible namespace
2232 info. Only do this if this is C++, if we don't have namespace
2233 debugging info in the file, if the psym is of an appropriate type
2234 (otherwise we'll have psym == NULL), and if we actually had a
2235 mangled name to begin with. */
2237 /* FIXME drow/2004-02-22: Why don't we do this for classes, i.e. the
2238 cases which do not set PSYM above? */
2240 if (cu
->language
== language_cplus
2241 && cu
->has_namespace_info
== 0
2243 && SYMBOL_CPLUS_DEMANGLED_NAME (psym
) != NULL
)
2244 cp_check_possible_namespace_symbols (SYMBOL_CPLUS_DEMANGLED_NAME (psym
),
2247 if (built_actual_name
)
2248 xfree (actual_name
);
2251 /* Determine whether a die of type TAG living in a C++ class or
2252 namespace needs to have the name of the scope prepended to the
2253 name listed in the die. */
2256 pdi_needs_namespace (enum dwarf_tag tag
)
2260 case DW_TAG_namespace
:
2261 case DW_TAG_typedef
:
2262 case DW_TAG_class_type
:
2263 case DW_TAG_interface_type
:
2264 case DW_TAG_structure_type
:
2265 case DW_TAG_union_type
:
2266 case DW_TAG_enumeration_type
:
2267 case DW_TAG_enumerator
:
2274 /* Read a partial die corresponding to a namespace; also, add a symbol
2275 corresponding to that namespace to the symbol table. NAMESPACE is
2276 the name of the enclosing namespace. */
2279 add_partial_namespace (struct partial_die_info
*pdi
,
2280 CORE_ADDR
*lowpc
, CORE_ADDR
*highpc
,
2281 int need_pc
, struct dwarf2_cu
*cu
)
2283 struct objfile
*objfile
= cu
->objfile
;
2285 /* Add a symbol for the namespace. */
2287 add_partial_symbol (pdi
, cu
);
2289 /* Now scan partial symbols in that namespace. */
2291 if (pdi
->has_children
)
2292 scan_partial_symbols (pdi
->die_child
, lowpc
, highpc
, need_pc
, cu
);
2295 /* Read a partial die corresponding to a Fortran module. */
2298 add_partial_module (struct partial_die_info
*pdi
, CORE_ADDR
*lowpc
,
2299 CORE_ADDR
*highpc
, int need_pc
, struct dwarf2_cu
*cu
)
2301 /* Now scan partial symbols in that module.
2303 FIXME: Support the separate Fortran module namespaces. */
2305 if (pdi
->has_children
)
2306 scan_partial_symbols (pdi
->die_child
, lowpc
, highpc
, need_pc
, cu
);
2309 /* Read a partial die corresponding to a subprogram and create a partial
2310 symbol for that subprogram. When the CU language allows it, this
2311 routine also defines a partial symbol for each nested subprogram
2312 that this subprogram contains.
2314 DIE my also be a lexical block, in which case we simply search
2315 recursively for suprograms defined inside that lexical block.
2316 Again, this is only performed when the CU language allows this
2317 type of definitions. */
2320 add_partial_subprogram (struct partial_die_info
*pdi
,
2321 CORE_ADDR
*lowpc
, CORE_ADDR
*highpc
,
2322 int need_pc
, struct dwarf2_cu
*cu
)
2324 if (pdi
->tag
== DW_TAG_subprogram
)
2326 if (pdi
->has_pc_info
)
2328 if (pdi
->lowpc
< *lowpc
)
2329 *lowpc
= pdi
->lowpc
;
2330 if (pdi
->highpc
> *highpc
)
2331 *highpc
= pdi
->highpc
;
2335 struct objfile
*objfile
= cu
->objfile
;
2337 baseaddr
= ANOFFSET (objfile
->section_offsets
,
2338 SECT_OFF_TEXT (objfile
));
2339 addrmap_set_empty (objfile
->psymtabs_addrmap
,
2340 pdi
->lowpc
, pdi
->highpc
- 1,
2341 cu
->per_cu
->psymtab
);
2343 if (!pdi
->is_declaration
)
2344 add_partial_symbol (pdi
, cu
);
2348 if (! pdi
->has_children
)
2351 if (cu
->language
== language_ada
)
2353 pdi
= pdi
->die_child
;
2356 fixup_partial_die (pdi
, cu
);
2357 if (pdi
->tag
== DW_TAG_subprogram
2358 || pdi
->tag
== DW_TAG_lexical_block
)
2359 add_partial_subprogram (pdi
, lowpc
, highpc
, need_pc
, cu
);
2360 pdi
= pdi
->die_sibling
;
2365 /* See if we can figure out if the class lives in a namespace. We do
2366 this by looking for a member function; its demangled name will
2367 contain namespace info, if there is any. */
2370 guess_structure_name (struct partial_die_info
*struct_pdi
,
2371 struct dwarf2_cu
*cu
)
2373 if ((cu
->language
== language_cplus
2374 || cu
->language
== language_java
)
2375 && cu
->has_namespace_info
== 0
2376 && struct_pdi
->has_children
)
2378 /* NOTE: carlton/2003-10-07: Getting the info this way changes
2379 what template types look like, because the demangler
2380 frequently doesn't give the same name as the debug info. We
2381 could fix this by only using the demangled name to get the
2382 prefix (but see comment in read_structure_type). */
2384 struct partial_die_info
*child_pdi
= struct_pdi
->die_child
;
2385 struct partial_die_info
*real_pdi
;
2387 /* If this DIE (this DIE's specification, if any) has a parent, then
2388 we should not do this. We'll prepend the parent's fully qualified
2389 name when we create the partial symbol. */
2391 real_pdi
= struct_pdi
;
2392 while (real_pdi
->has_specification
)
2393 real_pdi
= find_partial_die (real_pdi
->spec_offset
, cu
);
2395 if (real_pdi
->die_parent
!= NULL
)
2398 while (child_pdi
!= NULL
)
2400 if (child_pdi
->tag
== DW_TAG_subprogram
)
2402 char *actual_class_name
2403 = language_class_name_from_physname (cu
->language_defn
,
2405 if (actual_class_name
!= NULL
)
2408 = obsavestring (actual_class_name
,
2409 strlen (actual_class_name
),
2410 &cu
->comp_unit_obstack
);
2411 xfree (actual_class_name
);
2416 child_pdi
= child_pdi
->die_sibling
;
2421 /* Read a partial die corresponding to an enumeration type. */
2424 add_partial_enumeration (struct partial_die_info
*enum_pdi
,
2425 struct dwarf2_cu
*cu
)
2427 struct objfile
*objfile
= cu
->objfile
;
2428 bfd
*abfd
= objfile
->obfd
;
2429 struct partial_die_info
*pdi
;
2431 if (enum_pdi
->name
!= NULL
)
2432 add_partial_symbol (enum_pdi
, cu
);
2434 pdi
= enum_pdi
->die_child
;
2437 if (pdi
->tag
!= DW_TAG_enumerator
|| pdi
->name
== NULL
)
2438 complaint (&symfile_complaints
, _("malformed enumerator DIE ignored"));
2440 add_partial_symbol (pdi
, cu
);
2441 pdi
= pdi
->die_sibling
;
2445 /* Read the initial uleb128 in the die at INFO_PTR in compilation unit CU.
2446 Return the corresponding abbrev, or NULL if the number is zero (indicating
2447 an empty DIE). In either case *BYTES_READ will be set to the length of
2448 the initial number. */
2450 static struct abbrev_info
*
2451 peek_die_abbrev (gdb_byte
*info_ptr
, unsigned int *bytes_read
,
2452 struct dwarf2_cu
*cu
)
2454 bfd
*abfd
= cu
->objfile
->obfd
;
2455 unsigned int abbrev_number
;
2456 struct abbrev_info
*abbrev
;
2458 abbrev_number
= read_unsigned_leb128 (abfd
, info_ptr
, bytes_read
);
2460 if (abbrev_number
== 0)
2463 abbrev
= dwarf2_lookup_abbrev (abbrev_number
, cu
);
2466 error (_("Dwarf Error: Could not find abbrev number %d [in module %s]"), abbrev_number
,
2467 bfd_get_filename (abfd
));
2473 /* Scan the debug information for CU starting at INFO_PTR. Returns a
2474 pointer to the end of a series of DIEs, terminated by an empty
2475 DIE. Any children of the skipped DIEs will also be skipped. */
2478 skip_children (gdb_byte
*info_ptr
, struct dwarf2_cu
*cu
)
2480 struct abbrev_info
*abbrev
;
2481 unsigned int bytes_read
;
2485 abbrev
= peek_die_abbrev (info_ptr
, &bytes_read
, cu
);
2487 return info_ptr
+ bytes_read
;
2489 info_ptr
= skip_one_die (info_ptr
+ bytes_read
, abbrev
, cu
);
2493 /* Scan the debug information for CU starting at INFO_PTR. INFO_PTR
2494 should point just after the initial uleb128 of a DIE, and the
2495 abbrev corresponding to that skipped uleb128 should be passed in
2496 ABBREV. Returns a pointer to this DIE's sibling, skipping any
2500 skip_one_die (gdb_byte
*info_ptr
, struct abbrev_info
*abbrev
,
2501 struct dwarf2_cu
*cu
)
2503 unsigned int bytes_read
;
2504 struct attribute attr
;
2505 bfd
*abfd
= cu
->objfile
->obfd
;
2506 unsigned int form
, i
;
2508 for (i
= 0; i
< abbrev
->num_attrs
; i
++)
2510 /* The only abbrev we care about is DW_AT_sibling. */
2511 if (abbrev
->attrs
[i
].name
== DW_AT_sibling
)
2513 read_attribute (&attr
, &abbrev
->attrs
[i
],
2514 abfd
, info_ptr
, cu
);
2515 if (attr
.form
== DW_FORM_ref_addr
)
2516 complaint (&symfile_complaints
, _("ignoring absolute DW_AT_sibling"));
2518 return dwarf2_per_objfile
->info
.buffer
2519 + dwarf2_get_ref_die_offset (&attr
);
2522 /* If it isn't DW_AT_sibling, skip this attribute. */
2523 form
= abbrev
->attrs
[i
].form
;
2528 case DW_FORM_ref_addr
:
2529 info_ptr
+= cu
->header
.addr_size
;
2548 case DW_FORM_string
:
2549 read_string (abfd
, info_ptr
, &bytes_read
);
2550 info_ptr
+= bytes_read
;
2553 info_ptr
+= cu
->header
.offset_size
;
2556 info_ptr
+= read_unsigned_leb128 (abfd
, info_ptr
, &bytes_read
);
2557 info_ptr
+= bytes_read
;
2559 case DW_FORM_block1
:
2560 info_ptr
+= 1 + read_1_byte (abfd
, info_ptr
);
2562 case DW_FORM_block2
:
2563 info_ptr
+= 2 + read_2_bytes (abfd
, info_ptr
);
2565 case DW_FORM_block4
:
2566 info_ptr
+= 4 + read_4_bytes (abfd
, info_ptr
);
2570 case DW_FORM_ref_udata
:
2571 info_ptr
= skip_leb128 (abfd
, info_ptr
);
2573 case DW_FORM_indirect
:
2574 form
= read_unsigned_leb128 (abfd
, info_ptr
, &bytes_read
);
2575 info_ptr
+= bytes_read
;
2576 /* We need to continue parsing from here, so just go back to
2578 goto skip_attribute
;
2581 error (_("Dwarf Error: Cannot handle %s in DWARF reader [in module %s]"),
2582 dwarf_form_name (form
),
2583 bfd_get_filename (abfd
));
2587 if (abbrev
->has_children
)
2588 return skip_children (info_ptr
, cu
);
2593 /* Locate ORIG_PDI's sibling; INFO_PTR should point to the start of
2594 the next DIE after ORIG_PDI. */
2597 locate_pdi_sibling (struct partial_die_info
*orig_pdi
, gdb_byte
*info_ptr
,
2598 bfd
*abfd
, struct dwarf2_cu
*cu
)
2600 /* Do we know the sibling already? */
2602 if (orig_pdi
->sibling
)
2603 return orig_pdi
->sibling
;
2605 /* Are there any children to deal with? */
2607 if (!orig_pdi
->has_children
)
2610 /* Skip the children the long way. */
2612 return skip_children (info_ptr
, cu
);
2615 /* Expand this partial symbol table into a full symbol table. */
2618 dwarf2_psymtab_to_symtab (struct partial_symtab
*pst
)
2620 /* FIXME: This is barely more than a stub. */
2625 warning (_("bug: psymtab for %s is already read in."), pst
->filename
);
2631 printf_filtered (_("Reading in symbols for %s..."), pst
->filename
);
2632 gdb_flush (gdb_stdout
);
2635 /* Restore our global data. */
2636 dwarf2_per_objfile
= objfile_data (pst
->objfile
,
2637 dwarf2_objfile_data_key
);
2639 /* If this psymtab is constructed from a debug-only objfile, the
2640 has_section_at_zero flag will not necessarily be correct. We
2641 can get the correct value for this flag by looking at the data
2642 associated with the (presumably stripped) associated objfile. */
2643 if (pst
->objfile
->separate_debug_objfile_backlink
)
2645 struct dwarf2_per_objfile
*dpo_backlink
2646 = objfile_data (pst
->objfile
->separate_debug_objfile_backlink
,
2647 dwarf2_objfile_data_key
);
2648 dwarf2_per_objfile
->has_section_at_zero
2649 = dpo_backlink
->has_section_at_zero
;
2652 psymtab_to_symtab_1 (pst
);
2654 /* Finish up the debug error message. */
2656 printf_filtered (_("done.\n"));
2661 /* Add PER_CU to the queue. */
2664 queue_comp_unit (struct dwarf2_per_cu_data
*per_cu
, struct objfile
*objfile
)
2666 struct dwarf2_queue_item
*item
;
2669 item
= xmalloc (sizeof (*item
));
2670 item
->per_cu
= per_cu
;
2673 if (dwarf2_queue
== NULL
)
2674 dwarf2_queue
= item
;
2676 dwarf2_queue_tail
->next
= item
;
2678 dwarf2_queue_tail
= item
;
2680 /* Either PER_CU is the CU we want to process, or we're following a reference
2681 pointing into PER_CU. Either way, we need its DIEs now. */
2682 load_full_comp_unit (item
->per_cu
, objfile
);
2683 item
->per_cu
->cu
->read_in_chain
= dwarf2_per_objfile
->read_in_chain
;
2684 dwarf2_per_objfile
->read_in_chain
= item
->per_cu
;
2687 /* Process the queue. */
2690 process_queue (struct objfile
*objfile
)
2692 struct dwarf2_queue_item
*item
, *next_item
;
2694 /* The queue starts out with one item, but following a DIE reference
2695 may load a new CU, adding it to the end of the queue. */
2696 for (item
= dwarf2_queue
; item
!= NULL
; dwarf2_queue
= item
= next_item
)
2698 if (item
->per_cu
->psymtab
&& !item
->per_cu
->psymtab
->readin
)
2699 process_full_comp_unit (item
->per_cu
);
2701 item
->per_cu
->queued
= 0;
2702 next_item
= item
->next
;
2706 dwarf2_queue_tail
= NULL
;
2709 /* Free all allocated queue entries. This function only releases anything if
2710 an error was thrown; if the queue was processed then it would have been
2711 freed as we went along. */
2714 dwarf2_release_queue (void *dummy
)
2716 struct dwarf2_queue_item
*item
, *last
;
2718 item
= dwarf2_queue
;
2721 /* Anything still marked queued is likely to be in an
2722 inconsistent state, so discard it. */
2723 if (item
->per_cu
->queued
)
2725 if (item
->per_cu
->cu
!= NULL
)
2726 free_one_cached_comp_unit (item
->per_cu
->cu
);
2727 item
->per_cu
->queued
= 0;
2735 dwarf2_queue
= dwarf2_queue_tail
= NULL
;
2738 /* Read in full symbols for PST, and anything it depends on. */
2741 psymtab_to_symtab_1 (struct partial_symtab
*pst
)
2743 struct dwarf2_per_cu_data
*per_cu
;
2744 struct cleanup
*back_to
;
2747 for (i
= 0; i
< pst
->number_of_dependencies
; i
++)
2748 if (!pst
->dependencies
[i
]->readin
)
2750 /* Inform about additional files that need to be read in. */
2753 /* FIXME: i18n: Need to make this a single string. */
2754 fputs_filtered (" ", gdb_stdout
);
2756 fputs_filtered ("and ", gdb_stdout
);
2758 printf_filtered ("%s...", pst
->dependencies
[i
]->filename
);
2759 wrap_here (""); /* Flush output */
2760 gdb_flush (gdb_stdout
);
2762 psymtab_to_symtab_1 (pst
->dependencies
[i
]);
2765 per_cu
= (struct dwarf2_per_cu_data
*) pst
->read_symtab_private
;
2769 /* It's an include file, no symbols to read for it.
2770 Everything is in the parent symtab. */
2775 back_to
= make_cleanup (dwarf2_release_queue
, NULL
);
2777 queue_comp_unit (per_cu
, pst
->objfile
);
2779 process_queue (pst
->objfile
);
2781 /* Age the cache, releasing compilation units that have not
2782 been used recently. */
2783 age_cached_comp_units ();
2785 do_cleanups (back_to
);
2788 /* Load the DIEs associated with PST and PER_CU into memory. */
2790 static struct dwarf2_cu
*
2791 load_full_comp_unit (struct dwarf2_per_cu_data
*per_cu
, struct objfile
*objfile
)
2793 bfd
*abfd
= objfile
->obfd
;
2794 struct dwarf2_cu
*cu
;
2795 unsigned int offset
;
2797 struct cleanup
*back_to
, *free_cu_cleanup
;
2798 struct attribute
*attr
;
2801 /* Set local variables from the partial symbol table info. */
2802 offset
= per_cu
->offset
;
2804 info_ptr
= dwarf2_per_objfile
->info
.buffer
+ offset
;
2806 cu
= xmalloc (sizeof (struct dwarf2_cu
));
2807 memset (cu
, 0, sizeof (struct dwarf2_cu
));
2809 /* If an error occurs while loading, release our storage. */
2810 free_cu_cleanup
= make_cleanup (free_one_comp_unit
, cu
);
2812 cu
->objfile
= objfile
;
2814 /* read in the comp_unit header */
2815 info_ptr
= read_comp_unit_head (&cu
->header
, info_ptr
, abfd
);
2817 /* Read the abbrevs for this compilation unit */
2818 dwarf2_read_abbrevs (abfd
, cu
);
2819 back_to
= make_cleanup (dwarf2_free_abbrev_table
, cu
);
2821 cu
->header
.offset
= offset
;
2823 cu
->per_cu
= per_cu
;
2825 cu
->type_hash
= per_cu
->type_hash
;
2827 /* We use this obstack for block values in dwarf_alloc_block. */
2828 obstack_init (&cu
->comp_unit_obstack
);
2830 cu
->dies
= read_comp_unit (info_ptr
, abfd
, cu
);
2832 /* We try not to read any attributes in this function, because not
2833 all objfiles needed for references have been loaded yet, and symbol
2834 table processing isn't initialized. But we have to set the CU language,
2835 or we won't be able to build types correctly. */
2836 attr
= dwarf2_attr (cu
->dies
, DW_AT_language
, cu
);
2838 set_cu_language (DW_UNSND (attr
), cu
);
2840 set_cu_language (language_minimal
, cu
);
2842 do_cleanups (back_to
);
2844 /* We've successfully allocated this compilation unit. Let our caller
2845 clean it up when finished with it. */
2846 discard_cleanups (free_cu_cleanup
);
2851 /* Generate full symbol information for PST and CU, whose DIEs have
2852 already been loaded into memory. */
2855 process_full_comp_unit (struct dwarf2_per_cu_data
*per_cu
)
2857 struct partial_symtab
*pst
= per_cu
->psymtab
;
2858 struct dwarf2_cu
*cu
= per_cu
->cu
;
2859 struct objfile
*objfile
= pst
->objfile
;
2860 bfd
*abfd
= objfile
->obfd
;
2861 CORE_ADDR lowpc
, highpc
;
2862 struct symtab
*symtab
;
2863 struct cleanup
*back_to
;
2864 struct attribute
*attr
;
2867 baseaddr
= ANOFFSET (objfile
->section_offsets
, SECT_OFF_TEXT (objfile
));
2870 back_to
= make_cleanup (really_free_pendings
, NULL
);
2872 cu
->list_in_scope
= &file_symbols
;
2874 /* Find the base address of the compilation unit for range lists and
2875 location lists. It will normally be specified by DW_AT_low_pc.
2876 In DWARF-3 draft 4, the base address could be overridden by
2877 DW_AT_entry_pc. It's been removed, but GCC still uses this for
2878 compilation units with discontinuous ranges. */
2881 cu
->base_address
= 0;
2883 attr
= dwarf2_attr (cu
->dies
, DW_AT_entry_pc
, cu
);
2886 cu
->base_address
= DW_ADDR (attr
);
2891 attr
= dwarf2_attr (cu
->dies
, DW_AT_low_pc
, cu
);
2894 cu
->base_address
= DW_ADDR (attr
);
2899 /* Do line number decoding in read_file_scope () */
2900 process_die (cu
->dies
, cu
);
2902 /* Some compilers don't define a DW_AT_high_pc attribute for the
2903 compilation unit. If the DW_AT_high_pc is missing, synthesize
2904 it, by scanning the DIE's below the compilation unit. */
2905 get_scope_pc_bounds (cu
->dies
, &lowpc
, &highpc
, cu
);
2907 symtab
= end_symtab (highpc
+ baseaddr
, objfile
, SECT_OFF_TEXT (objfile
));
2909 /* Set symtab language to language from DW_AT_language.
2910 If the compilation is from a C file generated by language preprocessors,
2911 do not set the language if it was already deduced by start_subfile. */
2913 && !(cu
->language
== language_c
&& symtab
->language
!= language_c
))
2915 symtab
->language
= cu
->language
;
2917 pst
->symtab
= symtab
;
2920 do_cleanups (back_to
);
2923 /* Process a die and its children. */
2926 process_die (struct die_info
*die
, struct dwarf2_cu
*cu
)
2930 case DW_TAG_padding
:
2932 case DW_TAG_compile_unit
:
2933 read_file_scope (die
, cu
);
2935 case DW_TAG_subprogram
:
2936 case DW_TAG_inlined_subroutine
:
2937 read_func_scope (die
, cu
);
2939 case DW_TAG_lexical_block
:
2940 case DW_TAG_try_block
:
2941 case DW_TAG_catch_block
:
2942 read_lexical_block_scope (die
, cu
);
2944 case DW_TAG_class_type
:
2945 case DW_TAG_interface_type
:
2946 case DW_TAG_structure_type
:
2947 case DW_TAG_union_type
:
2948 process_structure_scope (die
, cu
);
2950 case DW_TAG_enumeration_type
:
2951 process_enumeration_scope (die
, cu
);
2954 /* These dies have a type, but processing them does not create
2955 a symbol or recurse to process the children. Therefore we can
2956 read them on-demand through read_type_die. */
2957 case DW_TAG_subroutine_type
:
2958 case DW_TAG_set_type
:
2959 case DW_TAG_array_type
:
2960 case DW_TAG_pointer_type
:
2961 case DW_TAG_ptr_to_member_type
:
2962 case DW_TAG_reference_type
:
2963 case DW_TAG_string_type
:
2966 case DW_TAG_base_type
:
2967 case DW_TAG_subrange_type
:
2968 case DW_TAG_typedef
:
2969 /* Add a typedef symbol for the type definition, if it has a
2971 new_symbol (die
, read_type_die (die
, cu
), cu
);
2973 case DW_TAG_common_block
:
2974 read_common_block (die
, cu
);
2976 case DW_TAG_common_inclusion
:
2978 case DW_TAG_namespace
:
2979 processing_has_namespace_info
= 1;
2980 read_namespace (die
, cu
);
2983 read_module (die
, cu
);
2985 case DW_TAG_imported_declaration
:
2986 case DW_TAG_imported_module
:
2987 processing_has_namespace_info
= 1;
2988 if (die
->child
!= NULL
&& (die
->tag
== DW_TAG_imported_declaration
2989 || cu
->language
!= language_fortran
))
2990 complaint (&symfile_complaints
, _("Tag '%s' has unexpected children"),
2991 dwarf_tag_name (die
->tag
));
2992 read_import_statement (die
, cu
);
2995 new_symbol (die
, NULL
, cu
);
3000 /* Return the fully qualified name of DIE, based on its DW_AT_name.
3001 If scope qualifiers are appropriate they will be added. The result
3002 will be allocated on the objfile_obstack, or NULL if the DIE does
3006 dwarf2_full_name (struct die_info
*die
, struct dwarf2_cu
*cu
)
3008 struct attribute
*attr
;
3009 char *prefix
, *name
;
3010 struct ui_file
*buf
= NULL
;
3012 name
= dwarf2_name (die
, cu
);
3016 /* These are the only languages we know how to qualify names in. */
3017 if (cu
->language
!= language_cplus
3018 && cu
->language
!= language_java
)
3021 /* If no prefix is necessary for this type of DIE, return the
3022 unqualified name. The other three tags listed could be handled
3023 in pdi_needs_namespace, but that requires broader changes. */
3024 if (!pdi_needs_namespace (die
->tag
)
3025 && die
->tag
!= DW_TAG_subprogram
3026 && die
->tag
!= DW_TAG_variable
3027 && die
->tag
!= DW_TAG_member
)
3030 prefix
= determine_prefix (die
, cu
);
3031 if (*prefix
!= '\0')
3032 name
= typename_concat (&cu
->objfile
->objfile_obstack
, prefix
,
3038 /* Read the import statement specified by the given die and record it. */
3041 read_import_statement (struct die_info
*die
, struct dwarf2_cu
*cu
)
3043 struct attribute
*import_attr
;
3044 struct die_info
*imported_die
;
3045 const char *imported_name
;
3046 const char *imported_name_prefix
;
3047 const char *import_prefix
;
3048 char *canonical_name
;
3050 import_attr
= dwarf2_attr (die
, DW_AT_import
, cu
);
3051 if (import_attr
== NULL
)
3053 complaint (&symfile_complaints
, _("Tag '%s' has no DW_AT_import"),
3054 dwarf_tag_name (die
->tag
));
3058 imported_die
= follow_die_ref (die
, import_attr
, &cu
);
3059 imported_name
= dwarf2_name (imported_die
, cu
);
3060 if (imported_name
== NULL
)
3062 /* GCC bug: https://bugzilla.redhat.com/show_bug.cgi?id=506524
3064 The import in the following code:
3078 <2><51>: Abbrev Number: 3 (DW_TAG_imported_declaration)
3079 <52> DW_AT_decl_file : 1
3080 <53> DW_AT_decl_line : 6
3081 <54> DW_AT_import : <0x75>
3082 <2><58>: Abbrev Number: 4 (DW_TAG_typedef)
3084 <5b> DW_AT_decl_file : 1
3085 <5c> DW_AT_decl_line : 2
3086 <5d> DW_AT_type : <0x6e>
3088 <1><75>: Abbrev Number: 7 (DW_TAG_base_type)
3089 <76> DW_AT_byte_size : 4
3090 <77> DW_AT_encoding : 5 (signed)
3092 imports the wrong die ( 0x75 instead of 0x58 ).
3093 This case will be ignored until the gcc bug is fixed. */
3097 /* FIXME: dwarf2_name (die); for the local name after import. */
3099 /* Figure out where the statement is being imported to. */
3100 import_prefix
= determine_prefix (die
, cu
);
3102 /* Figure out what the scope of the imported die is and prepend it
3103 to the name of the imported die. */
3104 imported_name_prefix
= determine_prefix (imported_die
, cu
);
3106 if (strlen (imported_name_prefix
) > 0)
3108 canonical_name
= alloca (strlen (imported_name_prefix
) + 2 + strlen (imported_name
) + 1);
3109 strcpy (canonical_name
, imported_name_prefix
);
3110 strcat (canonical_name
, "::");
3111 strcat (canonical_name
, imported_name
);
3115 canonical_name
= alloca (strlen (imported_name
) + 1);
3116 strcpy (canonical_name
, imported_name
);
3119 using_directives
= cp_add_using (import_prefix
,canonical_name
, using_directives
);
3123 initialize_cu_func_list (struct dwarf2_cu
*cu
)
3125 cu
->first_fn
= cu
->last_fn
= cu
->cached_fn
= NULL
;
3129 free_cu_line_header (void *arg
)
3131 struct dwarf2_cu
*cu
= arg
;
3133 free_line_header (cu
->line_header
);
3134 cu
->line_header
= NULL
;
3138 read_file_scope (struct die_info
*die
, struct dwarf2_cu
*cu
)
3140 struct objfile
*objfile
= cu
->objfile
;
3141 struct comp_unit_head
*cu_header
= &cu
->header
;
3142 struct cleanup
*back_to
= make_cleanup (null_cleanup
, 0);
3143 CORE_ADDR lowpc
= ((CORE_ADDR
) -1);
3144 CORE_ADDR highpc
= ((CORE_ADDR
) 0);
3145 struct attribute
*attr
;
3147 char *comp_dir
= NULL
;
3148 struct die_info
*child_die
;
3149 bfd
*abfd
= objfile
->obfd
;
3150 struct line_header
*line_header
= 0;
3153 baseaddr
= ANOFFSET (objfile
->section_offsets
, SECT_OFF_TEXT (objfile
));
3155 get_scope_pc_bounds (die
, &lowpc
, &highpc
, cu
);
3157 /* If we didn't find a lowpc, set it to highpc to avoid complaints
3158 from finish_block. */
3159 if (lowpc
== ((CORE_ADDR
) -1))
3164 /* Find the filename. Do not use dwarf2_name here, since the filename
3165 is not a source language identifier. */
3166 attr
= dwarf2_attr (die
, DW_AT_name
, cu
);
3169 name
= DW_STRING (attr
);
3172 attr
= dwarf2_attr (die
, DW_AT_comp_dir
, cu
);
3174 comp_dir
= DW_STRING (attr
);
3175 else if (name
!= NULL
&& IS_ABSOLUTE_PATH (name
))
3177 comp_dir
= ldirname (name
);
3178 if (comp_dir
!= NULL
)
3179 make_cleanup (xfree
, comp_dir
);
3181 if (comp_dir
!= NULL
)
3183 /* Irix 6.2 native cc prepends <machine>.: to the compilation
3184 directory, get rid of it. */
3185 char *cp
= strchr (comp_dir
, ':');
3187 if (cp
&& cp
!= comp_dir
&& cp
[-1] == '.' && cp
[1] == '/')
3194 attr
= dwarf2_attr (die
, DW_AT_language
, cu
);
3197 set_cu_language (DW_UNSND (attr
), cu
);
3200 attr
= dwarf2_attr (die
, DW_AT_producer
, cu
);
3202 cu
->producer
= DW_STRING (attr
);
3204 /* We assume that we're processing GCC output. */
3205 processing_gcc_compilation
= 2;
3207 processing_has_namespace_info
= 0;
3209 start_symtab (name
, comp_dir
, lowpc
);
3210 record_debugformat ("DWARF 2");
3211 record_producer (cu
->producer
);
3213 initialize_cu_func_list (cu
);
3215 /* Decode line number information if present. We do this before
3216 processing child DIEs, so that the line header table is available
3217 for DW_AT_decl_file. */
3218 attr
= dwarf2_attr (die
, DW_AT_stmt_list
, cu
);
3221 unsigned int line_offset
= DW_UNSND (attr
);
3222 line_header
= dwarf_decode_line_header (line_offset
, abfd
, cu
);
3225 cu
->line_header
= line_header
;
3226 make_cleanup (free_cu_line_header
, cu
);
3227 dwarf_decode_lines (line_header
, comp_dir
, abfd
, cu
, NULL
);
3231 /* Process all dies in compilation unit. */
3232 if (die
->child
!= NULL
)
3234 child_die
= die
->child
;
3235 while (child_die
&& child_die
->tag
)
3237 process_die (child_die
, cu
);
3238 child_die
= sibling_die (child_die
);
3242 /* Decode macro information, if present. Dwarf 2 macro information
3243 refers to information in the line number info statement program
3244 header, so we can only read it if we've read the header
3246 attr
= dwarf2_attr (die
, DW_AT_macro_info
, cu
);
3247 if (attr
&& line_header
)
3249 unsigned int macro_offset
= DW_UNSND (attr
);
3250 dwarf_decode_macros (line_header
, macro_offset
,
3251 comp_dir
, abfd
, cu
);
3253 do_cleanups (back_to
);
3257 add_to_cu_func_list (const char *name
, CORE_ADDR lowpc
, CORE_ADDR highpc
,
3258 struct dwarf2_cu
*cu
)
3260 struct function_range
*thisfn
;
3262 thisfn
= (struct function_range
*)
3263 obstack_alloc (&cu
->comp_unit_obstack
, sizeof (struct function_range
));
3264 thisfn
->name
= name
;
3265 thisfn
->lowpc
= lowpc
;
3266 thisfn
->highpc
= highpc
;
3267 thisfn
->seen_line
= 0;
3268 thisfn
->next
= NULL
;
3270 if (cu
->last_fn
== NULL
)
3271 cu
->first_fn
= thisfn
;
3273 cu
->last_fn
->next
= thisfn
;
3275 cu
->last_fn
= thisfn
;
3278 /* qsort helper for inherit_abstract_dies. */
3281 unsigned_int_compar (const void *ap
, const void *bp
)
3283 unsigned int a
= *(unsigned int *) ap
;
3284 unsigned int b
= *(unsigned int *) bp
;
3286 return (a
> b
) - (b
> a
);
3289 /* DW_AT_abstract_origin inherits whole DIEs (not just their attributes).
3290 Inherit only the children of the DW_AT_abstract_origin DIE not being already
3291 referenced by DW_AT_abstract_origin from the children of the current DIE. */
3294 inherit_abstract_dies (struct die_info
*die
, struct dwarf2_cu
*cu
)
3296 struct die_info
*child_die
;
3297 unsigned die_children_count
;
3298 /* CU offsets which were referenced by children of the current DIE. */
3300 unsigned *offsets_end
, *offsetp
;
3301 /* Parent of DIE - referenced by DW_AT_abstract_origin. */
3302 struct die_info
*origin_die
;
3303 /* Iterator of the ORIGIN_DIE children. */
3304 struct die_info
*origin_child_die
;
3305 struct cleanup
*cleanups
;
3306 struct attribute
*attr
;
3308 attr
= dwarf2_attr (die
, DW_AT_abstract_origin
, cu
);
3312 origin_die
= follow_die_ref (die
, attr
, &cu
);
3313 if (die
->tag
!= origin_die
->tag
3314 && !(die
->tag
== DW_TAG_inlined_subroutine
3315 && origin_die
->tag
== DW_TAG_subprogram
))
3316 complaint (&symfile_complaints
,
3317 _("DIE 0x%x and its abstract origin 0x%x have different tags"),
3318 die
->offset
, origin_die
->offset
);
3320 child_die
= die
->child
;
3321 die_children_count
= 0;
3322 while (child_die
&& child_die
->tag
)
3324 child_die
= sibling_die (child_die
);
3325 die_children_count
++;
3327 offsets
= xmalloc (sizeof (*offsets
) * die_children_count
);
3328 cleanups
= make_cleanup (xfree
, offsets
);
3330 offsets_end
= offsets
;
3331 child_die
= die
->child
;
3332 while (child_die
&& child_die
->tag
)
3334 attr
= dwarf2_attr (child_die
, DW_AT_abstract_origin
, cu
);
3335 /* According to DWARF3 3.3.8.2 #3 new entries without their abstract
3336 counterpart may exist. */
3339 struct die_info
*child_origin_die
;
3341 child_origin_die
= follow_die_ref (child_die
, attr
, &cu
);
3342 if (child_die
->tag
!= child_origin_die
->tag
3343 && !(child_die
->tag
== DW_TAG_inlined_subroutine
3344 && child_origin_die
->tag
== DW_TAG_subprogram
))
3345 complaint (&symfile_complaints
,
3346 _("Child DIE 0x%x and its abstract origin 0x%x have "
3347 "different tags"), child_die
->offset
,
3348 child_origin_die
->offset
);
3349 *offsets_end
++ = child_origin_die
->offset
;
3351 child_die
= sibling_die (child_die
);
3353 qsort (offsets
, offsets_end
- offsets
, sizeof (*offsets
),
3354 unsigned_int_compar
);
3355 for (offsetp
= offsets
+ 1; offsetp
< offsets_end
; offsetp
++)
3356 if (offsetp
[-1] == *offsetp
)
3357 complaint (&symfile_complaints
, _("Multiple children of DIE 0x%x refer "
3358 "to DIE 0x%x as their abstract origin"),
3359 die
->offset
, *offsetp
);
3362 origin_child_die
= origin_die
->child
;
3363 while (origin_child_die
&& origin_child_die
->tag
)
3365 /* Is ORIGIN_CHILD_DIE referenced by any of the DIE children? */
3366 while (offsetp
< offsets_end
&& *offsetp
< origin_child_die
->offset
)
3368 if (offsetp
>= offsets_end
|| *offsetp
> origin_child_die
->offset
)
3370 /* Found that ORIGIN_CHILD_DIE is really not referenced. */
3371 process_die (origin_child_die
, cu
);
3373 origin_child_die
= sibling_die (origin_child_die
);
3376 do_cleanups (cleanups
);
3380 read_func_scope (struct die_info
*die
, struct dwarf2_cu
*cu
)
3382 struct objfile
*objfile
= cu
->objfile
;
3383 struct context_stack
*new;
3386 struct die_info
*child_die
;
3387 struct attribute
*attr
, *call_line
, *call_file
;
3390 struct block
*block
;
3391 int inlined_func
= (die
->tag
== DW_TAG_inlined_subroutine
);
3395 /* If we do not have call site information, we can't show the
3396 caller of this inlined function. That's too confusing, so
3397 only use the scope for local variables. */
3398 call_line
= dwarf2_attr (die
, DW_AT_call_line
, cu
);
3399 call_file
= dwarf2_attr (die
, DW_AT_call_file
, cu
);
3400 if (call_line
== NULL
|| call_file
== NULL
)
3402 read_lexical_block_scope (die
, cu
);
3407 baseaddr
= ANOFFSET (objfile
->section_offsets
, SECT_OFF_TEXT (objfile
));
3409 name
= dwarf2_linkage_name (die
, cu
);
3411 /* Ignore functions with missing or empty names and functions with
3412 missing or invalid low and high pc attributes. */
3413 if (name
== NULL
|| !dwarf2_get_pc_bounds (die
, &lowpc
, &highpc
, cu
))
3419 /* Record the function range for dwarf_decode_lines. */
3420 add_to_cu_func_list (name
, lowpc
, highpc
, cu
);
3422 new = push_context (0, lowpc
);
3423 new->name
= new_symbol (die
, read_type_die (die
, cu
), cu
);
3425 /* If there is a location expression for DW_AT_frame_base, record
3427 attr
= dwarf2_attr (die
, DW_AT_frame_base
, cu
);
3429 /* FIXME: cagney/2004-01-26: The DW_AT_frame_base's location
3430 expression is being recorded directly in the function's symbol
3431 and not in a separate frame-base object. I guess this hack is
3432 to avoid adding some sort of frame-base adjunct/annex to the
3433 function's symbol :-(. The problem with doing this is that it
3434 results in a function symbol with a location expression that
3435 has nothing to do with the location of the function, ouch! The
3436 relationship should be: a function's symbol has-a frame base; a
3437 frame-base has-a location expression. */
3438 dwarf2_symbol_mark_computed (attr
, new->name
, cu
);
3440 cu
->list_in_scope
= &local_symbols
;
3442 if (die
->child
!= NULL
)
3444 child_die
= die
->child
;
3445 while (child_die
&& child_die
->tag
)
3447 process_die (child_die
, cu
);
3448 child_die
= sibling_die (child_die
);
3452 inherit_abstract_dies (die
, cu
);
3454 new = pop_context ();
3455 /* Make a block for the local symbols within. */
3456 block
= finish_block (new->name
, &local_symbols
, new->old_blocks
,
3457 lowpc
, highpc
, objfile
);
3459 /* For C++, set the block's scope. */
3460 if (cu
->language
== language_cplus
)
3461 cp_set_block_scope (new->name
, block
, &objfile
->objfile_obstack
,
3462 determine_prefix (die
, cu
),
3463 processing_has_namespace_info
);
3465 /* If we have address ranges, record them. */
3466 dwarf2_record_block_ranges (die
, block
, baseaddr
, cu
);
3468 /* In C++, we can have functions nested inside functions (e.g., when
3469 a function declares a class that has methods). This means that
3470 when we finish processing a function scope, we may need to go
3471 back to building a containing block's symbol lists. */
3472 local_symbols
= new->locals
;
3473 param_symbols
= new->params
;
3474 using_directives
= new->using_directives
;
3476 /* If we've finished processing a top-level function, subsequent
3477 symbols go in the file symbol list. */
3478 if (outermost_context_p ())
3479 cu
->list_in_scope
= &file_symbols
;
3482 /* Process all the DIES contained within a lexical block scope. Start
3483 a new scope, process the dies, and then close the scope. */
3486 read_lexical_block_scope (struct die_info
*die
, struct dwarf2_cu
*cu
)
3488 struct objfile
*objfile
= cu
->objfile
;
3489 struct context_stack
*new;
3490 CORE_ADDR lowpc
, highpc
;
3491 struct die_info
*child_die
;
3494 baseaddr
= ANOFFSET (objfile
->section_offsets
, SECT_OFF_TEXT (objfile
));
3496 /* Ignore blocks with missing or invalid low and high pc attributes. */
3497 /* ??? Perhaps consider discontiguous blocks defined by DW_AT_ranges
3498 as multiple lexical blocks? Handling children in a sane way would
3499 be nasty. Might be easier to properly extend generic blocks to
3501 if (!dwarf2_get_pc_bounds (die
, &lowpc
, &highpc
, cu
))
3506 push_context (0, lowpc
);
3507 if (die
->child
!= NULL
)
3509 child_die
= die
->child
;
3510 while (child_die
&& child_die
->tag
)
3512 process_die (child_die
, cu
);
3513 child_die
= sibling_die (child_die
);
3516 new = pop_context ();
3518 if (local_symbols
!= NULL
)
3521 = finish_block (0, &local_symbols
, new->old_blocks
, new->start_addr
,
3524 /* Note that recording ranges after traversing children, as we
3525 do here, means that recording a parent's ranges entails
3526 walking across all its children's ranges as they appear in
3527 the address map, which is quadratic behavior.
3529 It would be nicer to record the parent's ranges before
3530 traversing its children, simply overriding whatever you find
3531 there. But since we don't even decide whether to create a
3532 block until after we've traversed its children, that's hard
3534 dwarf2_record_block_ranges (die
, block
, baseaddr
, cu
);
3536 local_symbols
= new->locals
;
3537 using_directives
= new->using_directives
;
3540 /* Get low and high pc attributes from DW_AT_ranges attribute value OFFSET.
3541 Return 1 if the attributes are present and valid, otherwise, return 0.
3542 If RANGES_PST is not NULL we should setup `objfile->psymtabs_addrmap'. */
3545 dwarf2_ranges_read (unsigned offset
, CORE_ADDR
*low_return
,
3546 CORE_ADDR
*high_return
, struct dwarf2_cu
*cu
,
3547 struct partial_symtab
*ranges_pst
)
3549 struct objfile
*objfile
= cu
->objfile
;
3550 struct comp_unit_head
*cu_header
= &cu
->header
;
3551 bfd
*obfd
= objfile
->obfd
;
3552 unsigned int addr_size
= cu_header
->addr_size
;
3553 CORE_ADDR mask
= ~(~(CORE_ADDR
)1 << (addr_size
* 8 - 1));
3554 /* Base address selection entry. */
3565 found_base
= cu
->base_known
;
3566 base
= cu
->base_address
;
3568 if (offset
>= dwarf2_per_objfile
->ranges
.size
)
3570 complaint (&symfile_complaints
,
3571 _("Offset %d out of bounds for DW_AT_ranges attribute"),
3575 buffer
= dwarf2_per_objfile
->ranges
.buffer
+ offset
;
3577 /* Read in the largest possible address. */
3578 marker
= read_address (obfd
, buffer
, cu
, &dummy
);
3579 if ((marker
& mask
) == mask
)
3581 /* If we found the largest possible address, then
3582 read the base address. */
3583 base
= read_address (obfd
, buffer
+ addr_size
, cu
, &dummy
);
3584 buffer
+= 2 * addr_size
;
3585 offset
+= 2 * addr_size
;
3591 baseaddr
= ANOFFSET (objfile
->section_offsets
, SECT_OFF_TEXT (objfile
));
3595 CORE_ADDR range_beginning
, range_end
;
3597 range_beginning
= read_address (obfd
, buffer
, cu
, &dummy
);
3598 buffer
+= addr_size
;
3599 range_end
= read_address (obfd
, buffer
, cu
, &dummy
);
3600 buffer
+= addr_size
;
3601 offset
+= 2 * addr_size
;
3603 /* An end of list marker is a pair of zero addresses. */
3604 if (range_beginning
== 0 && range_end
== 0)
3605 /* Found the end of list entry. */
3608 /* Each base address selection entry is a pair of 2 values.
3609 The first is the largest possible address, the second is
3610 the base address. Check for a base address here. */
3611 if ((range_beginning
& mask
) == mask
)
3613 /* If we found the largest possible address, then
3614 read the base address. */
3615 base
= read_address (obfd
, buffer
+ addr_size
, cu
, &dummy
);
3622 /* We have no valid base address for the ranges
3624 complaint (&symfile_complaints
,
3625 _("Invalid .debug_ranges data (no base address)"));
3629 range_beginning
+= base
;
3632 if (ranges_pst
!= NULL
&& range_beginning
< range_end
)
3633 addrmap_set_empty (objfile
->psymtabs_addrmap
,
3634 range_beginning
+ baseaddr
, range_end
- 1 + baseaddr
,
3637 /* FIXME: This is recording everything as a low-high
3638 segment of consecutive addresses. We should have a
3639 data structure for discontiguous block ranges
3643 low
= range_beginning
;
3649 if (range_beginning
< low
)
3650 low
= range_beginning
;
3651 if (range_end
> high
)
3657 /* If the first entry is an end-of-list marker, the range
3658 describes an empty scope, i.e. no instructions. */
3664 *high_return
= high
;
3668 /* Get low and high pc attributes from a die. Return 1 if the attributes
3669 are present and valid, otherwise, return 0. Return -1 if the range is
3670 discontinuous, i.e. derived from DW_AT_ranges information. */
3672 dwarf2_get_pc_bounds (struct die_info
*die
, CORE_ADDR
*lowpc
,
3673 CORE_ADDR
*highpc
, struct dwarf2_cu
*cu
)
3675 struct attribute
*attr
;
3680 attr
= dwarf2_attr (die
, DW_AT_high_pc
, cu
);
3683 high
= DW_ADDR (attr
);
3684 attr
= dwarf2_attr (die
, DW_AT_low_pc
, cu
);
3686 low
= DW_ADDR (attr
);
3688 /* Found high w/o low attribute. */
3691 /* Found consecutive range of addresses. */
3696 attr
= dwarf2_attr (die
, DW_AT_ranges
, cu
);
3699 /* Value of the DW_AT_ranges attribute is the offset in the
3700 .debug_ranges section. */
3701 if (!dwarf2_ranges_read (DW_UNSND (attr
), &low
, &high
, cu
, NULL
))
3703 /* Found discontinuous range of addresses. */
3711 /* When using the GNU linker, .gnu.linkonce. sections are used to
3712 eliminate duplicate copies of functions and vtables and such.
3713 The linker will arbitrarily choose one and discard the others.
3714 The AT_*_pc values for such functions refer to local labels in
3715 these sections. If the section from that file was discarded, the
3716 labels are not in the output, so the relocs get a value of 0.
3717 If this is a discarded function, mark the pc bounds as invalid,
3718 so that GDB will ignore it. */
3719 if (low
== 0 && !dwarf2_per_objfile
->has_section_at_zero
)
3727 /* Assuming that DIE represents a subprogram DIE or a lexical block, get
3728 its low and high PC addresses. Do nothing if these addresses could not
3729 be determined. Otherwise, set LOWPC to the low address if it is smaller,
3730 and HIGHPC to the high address if greater than HIGHPC. */
3733 dwarf2_get_subprogram_pc_bounds (struct die_info
*die
,
3734 CORE_ADDR
*lowpc
, CORE_ADDR
*highpc
,
3735 struct dwarf2_cu
*cu
)
3737 CORE_ADDR low
, high
;
3738 struct die_info
*child
= die
->child
;
3740 if (dwarf2_get_pc_bounds (die
, &low
, &high
, cu
))
3742 *lowpc
= min (*lowpc
, low
);
3743 *highpc
= max (*highpc
, high
);
3746 /* If the language does not allow nested subprograms (either inside
3747 subprograms or lexical blocks), we're done. */
3748 if (cu
->language
!= language_ada
)
3751 /* Check all the children of the given DIE. If it contains nested
3752 subprograms, then check their pc bounds. Likewise, we need to
3753 check lexical blocks as well, as they may also contain subprogram
3755 while (child
&& child
->tag
)
3757 if (child
->tag
== DW_TAG_subprogram
3758 || child
->tag
== DW_TAG_lexical_block
)
3759 dwarf2_get_subprogram_pc_bounds (child
, lowpc
, highpc
, cu
);
3760 child
= sibling_die (child
);
3764 /* Get the low and high pc's represented by the scope DIE, and store
3765 them in *LOWPC and *HIGHPC. If the correct values can't be
3766 determined, set *LOWPC to -1 and *HIGHPC to 0. */
3769 get_scope_pc_bounds (struct die_info
*die
,
3770 CORE_ADDR
*lowpc
, CORE_ADDR
*highpc
,
3771 struct dwarf2_cu
*cu
)
3773 CORE_ADDR best_low
= (CORE_ADDR
) -1;
3774 CORE_ADDR best_high
= (CORE_ADDR
) 0;
3775 CORE_ADDR current_low
, current_high
;
3777 if (dwarf2_get_pc_bounds (die
, ¤t_low
, ¤t_high
, cu
))
3779 best_low
= current_low
;
3780 best_high
= current_high
;
3784 struct die_info
*child
= die
->child
;
3786 while (child
&& child
->tag
)
3788 switch (child
->tag
) {
3789 case DW_TAG_subprogram
:
3790 dwarf2_get_subprogram_pc_bounds (child
, &best_low
, &best_high
, cu
);
3792 case DW_TAG_namespace
:
3793 /* FIXME: carlton/2004-01-16: Should we do this for
3794 DW_TAG_class_type/DW_TAG_structure_type, too? I think
3795 that current GCC's always emit the DIEs corresponding
3796 to definitions of methods of classes as children of a
3797 DW_TAG_compile_unit or DW_TAG_namespace (as opposed to
3798 the DIEs giving the declarations, which could be
3799 anywhere). But I don't see any reason why the
3800 standards says that they have to be there. */
3801 get_scope_pc_bounds (child
, ¤t_low
, ¤t_high
, cu
);
3803 if (current_low
!= ((CORE_ADDR
) -1))
3805 best_low
= min (best_low
, current_low
);
3806 best_high
= max (best_high
, current_high
);
3814 child
= sibling_die (child
);
3819 *highpc
= best_high
;
3822 /* Record the address ranges for BLOCK, offset by BASEADDR, as given
3825 dwarf2_record_block_ranges (struct die_info
*die
, struct block
*block
,
3826 CORE_ADDR baseaddr
, struct dwarf2_cu
*cu
)
3828 struct attribute
*attr
;
3830 attr
= dwarf2_attr (die
, DW_AT_high_pc
, cu
);
3833 CORE_ADDR high
= DW_ADDR (attr
);
3834 attr
= dwarf2_attr (die
, DW_AT_low_pc
, cu
);
3837 CORE_ADDR low
= DW_ADDR (attr
);
3838 record_block_range (block
, baseaddr
+ low
, baseaddr
+ high
- 1);
3842 attr
= dwarf2_attr (die
, DW_AT_ranges
, cu
);
3845 bfd
*obfd
= cu
->objfile
->obfd
;
3847 /* The value of the DW_AT_ranges attribute is the offset of the
3848 address range list in the .debug_ranges section. */
3849 unsigned long offset
= DW_UNSND (attr
);
3850 gdb_byte
*buffer
= dwarf2_per_objfile
->ranges
.buffer
+ offset
;
3852 /* For some target architectures, but not others, the
3853 read_address function sign-extends the addresses it returns.
3854 To recognize base address selection entries, we need a
3856 unsigned int addr_size
= cu
->header
.addr_size
;
3857 CORE_ADDR base_select_mask
= ~(~(CORE_ADDR
)1 << (addr_size
* 8 - 1));
3859 /* The base address, to which the next pair is relative. Note
3860 that this 'base' is a DWARF concept: most entries in a range
3861 list are relative, to reduce the number of relocs against the
3862 debugging information. This is separate from this function's
3863 'baseaddr' argument, which GDB uses to relocate debugging
3864 information from a shared library based on the address at
3865 which the library was loaded. */
3866 CORE_ADDR base
= cu
->base_address
;
3867 int base_known
= cu
->base_known
;
3869 if (offset
>= dwarf2_per_objfile
->ranges
.size
)
3871 complaint (&symfile_complaints
,
3872 _("Offset %lu out of bounds for DW_AT_ranges attribute"),
3879 unsigned int bytes_read
;
3880 CORE_ADDR start
, end
;
3882 start
= read_address (obfd
, buffer
, cu
, &bytes_read
);
3883 buffer
+= bytes_read
;
3884 end
= read_address (obfd
, buffer
, cu
, &bytes_read
);
3885 buffer
+= bytes_read
;
3887 /* Did we find the end of the range list? */
3888 if (start
== 0 && end
== 0)
3891 /* Did we find a base address selection entry? */
3892 else if ((start
& base_select_mask
) == base_select_mask
)
3898 /* We found an ordinary address range. */
3903 complaint (&symfile_complaints
,
3904 _("Invalid .debug_ranges data (no base address)"));
3908 record_block_range (block
,
3909 baseaddr
+ base
+ start
,
3910 baseaddr
+ base
+ end
- 1);
3916 /* Add an aggregate field to the field list. */
3919 dwarf2_add_field (struct field_info
*fip
, struct die_info
*die
,
3920 struct dwarf2_cu
*cu
)
3922 struct objfile
*objfile
= cu
->objfile
;
3923 struct gdbarch
*gdbarch
= get_objfile_arch (objfile
);
3924 struct nextfield
*new_field
;
3925 struct attribute
*attr
;
3927 char *fieldname
= "";
3929 /* Allocate a new field list entry and link it in. */
3930 new_field
= (struct nextfield
*) xmalloc (sizeof (struct nextfield
));
3931 make_cleanup (xfree
, new_field
);
3932 memset (new_field
, 0, sizeof (struct nextfield
));
3933 new_field
->next
= fip
->fields
;
3934 fip
->fields
= new_field
;
3937 /* Handle accessibility and virtuality of field.
3938 The default accessibility for members is public, the default
3939 accessibility for inheritance is private. */
3940 if (die
->tag
!= DW_TAG_inheritance
)
3941 new_field
->accessibility
= DW_ACCESS_public
;
3943 new_field
->accessibility
= DW_ACCESS_private
;
3944 new_field
->virtuality
= DW_VIRTUALITY_none
;
3946 attr
= dwarf2_attr (die
, DW_AT_accessibility
, cu
);
3948 new_field
->accessibility
= DW_UNSND (attr
);
3949 if (new_field
->accessibility
!= DW_ACCESS_public
)
3950 fip
->non_public_fields
= 1;
3951 attr
= dwarf2_attr (die
, DW_AT_virtuality
, cu
);
3953 new_field
->virtuality
= DW_UNSND (attr
);
3955 fp
= &new_field
->field
;
3957 if (die
->tag
== DW_TAG_member
&& ! die_is_declaration (die
, cu
))
3959 /* Data member other than a C++ static data member. */
3961 /* Get type of field. */
3962 fp
->type
= die_type (die
, cu
);
3964 SET_FIELD_BITPOS (*fp
, 0);
3966 /* Get bit size of field (zero if none). */
3967 attr
= dwarf2_attr (die
, DW_AT_bit_size
, cu
);
3970 FIELD_BITSIZE (*fp
) = DW_UNSND (attr
);
3974 FIELD_BITSIZE (*fp
) = 0;
3977 /* Get bit offset of field. */
3978 attr
= dwarf2_attr (die
, DW_AT_data_member_location
, cu
);
3983 if (attr_form_is_section_offset (attr
))
3985 dwarf2_complex_location_expr_complaint ();
3988 else if (attr_form_is_constant (attr
))
3989 byte_offset
= dwarf2_get_attr_constant_value (attr
, 0);
3991 byte_offset
= decode_locdesc (DW_BLOCK (attr
), cu
);
3993 SET_FIELD_BITPOS (*fp
, byte_offset
* bits_per_byte
);
3995 attr
= dwarf2_attr (die
, DW_AT_bit_offset
, cu
);
3998 if (gdbarch_bits_big_endian (gdbarch
))
4000 /* For big endian bits, the DW_AT_bit_offset gives the
4001 additional bit offset from the MSB of the containing
4002 anonymous object to the MSB of the field. We don't
4003 have to do anything special since we don't need to
4004 know the size of the anonymous object. */
4005 FIELD_BITPOS (*fp
) += DW_UNSND (attr
);
4009 /* For little endian bits, compute the bit offset to the
4010 MSB of the anonymous object, subtract off the number of
4011 bits from the MSB of the field to the MSB of the
4012 object, and then subtract off the number of bits of
4013 the field itself. The result is the bit offset of
4014 the LSB of the field. */
4016 int bit_offset
= DW_UNSND (attr
);
4018 attr
= dwarf2_attr (die
, DW_AT_byte_size
, cu
);
4021 /* The size of the anonymous object containing
4022 the bit field is explicit, so use the
4023 indicated size (in bytes). */
4024 anonymous_size
= DW_UNSND (attr
);
4028 /* The size of the anonymous object containing
4029 the bit field must be inferred from the type
4030 attribute of the data member containing the
4032 anonymous_size
= TYPE_LENGTH (fp
->type
);
4034 FIELD_BITPOS (*fp
) += anonymous_size
* bits_per_byte
4035 - bit_offset
- FIELD_BITSIZE (*fp
);
4039 /* Get name of field. */
4040 fieldname
= dwarf2_name (die
, cu
);
4041 if (fieldname
== NULL
)
4044 /* The name is already allocated along with this objfile, so we don't
4045 need to duplicate it for the type. */
4046 fp
->name
= fieldname
;
4048 /* Change accessibility for artificial fields (e.g. virtual table
4049 pointer or virtual base class pointer) to private. */
4050 if (dwarf2_attr (die
, DW_AT_artificial
, cu
))
4052 new_field
->accessibility
= DW_ACCESS_private
;
4053 fip
->non_public_fields
= 1;
4056 else if (die
->tag
== DW_TAG_member
|| die
->tag
== DW_TAG_variable
)
4058 /* C++ static member. */
4060 /* NOTE: carlton/2002-11-05: It should be a DW_TAG_member that
4061 is a declaration, but all versions of G++ as of this writing
4062 (so through at least 3.2.1) incorrectly generate
4063 DW_TAG_variable tags. */
4067 /* Get name of field. */
4068 fieldname
= dwarf2_name (die
, cu
);
4069 if (fieldname
== NULL
)
4072 /* Get physical name. */
4073 physname
= dwarf2_linkage_name (die
, cu
);
4075 /* The name is already allocated along with this objfile, so we don't
4076 need to duplicate it for the type. */
4077 SET_FIELD_PHYSNAME (*fp
, physname
? physname
: "");
4078 FIELD_TYPE (*fp
) = die_type (die
, cu
);
4079 FIELD_NAME (*fp
) = fieldname
;
4081 else if (die
->tag
== DW_TAG_inheritance
)
4083 /* C++ base class field. */
4084 attr
= dwarf2_attr (die
, DW_AT_data_member_location
, cu
);
4086 SET_FIELD_BITPOS (*fp
, decode_locdesc (DW_BLOCK (attr
), cu
)
4088 FIELD_BITSIZE (*fp
) = 0;
4089 FIELD_TYPE (*fp
) = die_type (die
, cu
);
4090 FIELD_NAME (*fp
) = type_name_no_tag (fp
->type
);
4091 fip
->nbaseclasses
++;
4095 /* Create the vector of fields, and attach it to the type. */
4098 dwarf2_attach_fields_to_type (struct field_info
*fip
, struct type
*type
,
4099 struct dwarf2_cu
*cu
)
4101 int nfields
= fip
->nfields
;
4103 /* Record the field count, allocate space for the array of fields,
4104 and create blank accessibility bitfields if necessary. */
4105 TYPE_NFIELDS (type
) = nfields
;
4106 TYPE_FIELDS (type
) = (struct field
*)
4107 TYPE_ALLOC (type
, sizeof (struct field
) * nfields
);
4108 memset (TYPE_FIELDS (type
), 0, sizeof (struct field
) * nfields
);
4110 if (fip
->non_public_fields
)
4112 ALLOCATE_CPLUS_STRUCT_TYPE (type
);
4114 TYPE_FIELD_PRIVATE_BITS (type
) =
4115 (B_TYPE
*) TYPE_ALLOC (type
, B_BYTES (nfields
));
4116 B_CLRALL (TYPE_FIELD_PRIVATE_BITS (type
), nfields
);
4118 TYPE_FIELD_PROTECTED_BITS (type
) =
4119 (B_TYPE
*) TYPE_ALLOC (type
, B_BYTES (nfields
));
4120 B_CLRALL (TYPE_FIELD_PROTECTED_BITS (type
), nfields
);
4122 TYPE_FIELD_IGNORE_BITS (type
) =
4123 (B_TYPE
*) TYPE_ALLOC (type
, B_BYTES (nfields
));
4124 B_CLRALL (TYPE_FIELD_IGNORE_BITS (type
), nfields
);
4127 /* If the type has baseclasses, allocate and clear a bit vector for
4128 TYPE_FIELD_VIRTUAL_BITS. */
4129 if (fip
->nbaseclasses
)
4131 int num_bytes
= B_BYTES (fip
->nbaseclasses
);
4132 unsigned char *pointer
;
4134 ALLOCATE_CPLUS_STRUCT_TYPE (type
);
4135 pointer
= TYPE_ALLOC (type
, num_bytes
);
4136 TYPE_FIELD_VIRTUAL_BITS (type
) = pointer
;
4137 B_CLRALL (TYPE_FIELD_VIRTUAL_BITS (type
), fip
->nbaseclasses
);
4138 TYPE_N_BASECLASSES (type
) = fip
->nbaseclasses
;
4141 /* Copy the saved-up fields into the field vector. Start from the head
4142 of the list, adding to the tail of the field array, so that they end
4143 up in the same order in the array in which they were added to the list. */
4144 while (nfields
-- > 0)
4146 TYPE_FIELD (type
, nfields
) = fip
->fields
->field
;
4147 switch (fip
->fields
->accessibility
)
4149 case DW_ACCESS_private
:
4150 SET_TYPE_FIELD_PRIVATE (type
, nfields
);
4153 case DW_ACCESS_protected
:
4154 SET_TYPE_FIELD_PROTECTED (type
, nfields
);
4157 case DW_ACCESS_public
:
4161 /* Unknown accessibility. Complain and treat it as public. */
4163 complaint (&symfile_complaints
, _("unsupported accessibility %d"),
4164 fip
->fields
->accessibility
);
4168 if (nfields
< fip
->nbaseclasses
)
4170 switch (fip
->fields
->virtuality
)
4172 case DW_VIRTUALITY_virtual
:
4173 case DW_VIRTUALITY_pure_virtual
:
4174 SET_TYPE_FIELD_VIRTUAL (type
, nfields
);
4178 fip
->fields
= fip
->fields
->next
;
4182 /* Add a member function to the proper fieldlist. */
4185 dwarf2_add_member_fn (struct field_info
*fip
, struct die_info
*die
,
4186 struct type
*type
, struct dwarf2_cu
*cu
)
4188 struct objfile
*objfile
= cu
->objfile
;
4189 struct attribute
*attr
;
4190 struct fnfieldlist
*flp
;
4192 struct fn_field
*fnp
;
4195 struct nextfnfield
*new_fnfield
;
4196 struct type
*this_type
;
4198 /* Get name of member function. */
4199 fieldname
= dwarf2_name (die
, cu
);
4200 if (fieldname
== NULL
)
4203 /* Get the mangled name. */
4204 physname
= dwarf2_linkage_name (die
, cu
);
4206 /* Look up member function name in fieldlist. */
4207 for (i
= 0; i
< fip
->nfnfields
; i
++)
4209 if (strcmp (fip
->fnfieldlists
[i
].name
, fieldname
) == 0)
4213 /* Create new list element if necessary. */
4214 if (i
< fip
->nfnfields
)
4215 flp
= &fip
->fnfieldlists
[i
];
4218 if ((fip
->nfnfields
% DW_FIELD_ALLOC_CHUNK
) == 0)
4220 fip
->fnfieldlists
= (struct fnfieldlist
*)
4221 xrealloc (fip
->fnfieldlists
,
4222 (fip
->nfnfields
+ DW_FIELD_ALLOC_CHUNK
)
4223 * sizeof (struct fnfieldlist
));
4224 if (fip
->nfnfields
== 0)
4225 make_cleanup (free_current_contents
, &fip
->fnfieldlists
);
4227 flp
= &fip
->fnfieldlists
[fip
->nfnfields
];
4228 flp
->name
= fieldname
;
4234 /* Create a new member function field and chain it to the field list
4236 new_fnfield
= (struct nextfnfield
*) xmalloc (sizeof (struct nextfnfield
));
4237 make_cleanup (xfree
, new_fnfield
);
4238 memset (new_fnfield
, 0, sizeof (struct nextfnfield
));
4239 new_fnfield
->next
= flp
->head
;
4240 flp
->head
= new_fnfield
;
4243 /* Fill in the member function field info. */
4244 fnp
= &new_fnfield
->fnfield
;
4245 /* The name is already allocated along with this objfile, so we don't
4246 need to duplicate it for the type. */
4247 fnp
->physname
= physname
? physname
: "";
4248 fnp
->type
= alloc_type (objfile
);
4249 this_type
= read_type_die (die
, cu
);
4250 if (this_type
&& TYPE_CODE (this_type
) == TYPE_CODE_FUNC
)
4252 int nparams
= TYPE_NFIELDS (this_type
);
4254 /* TYPE is the domain of this method, and THIS_TYPE is the type
4255 of the method itself (TYPE_CODE_METHOD). */
4256 smash_to_method_type (fnp
->type
, type
,
4257 TYPE_TARGET_TYPE (this_type
),
4258 TYPE_FIELDS (this_type
),
4259 TYPE_NFIELDS (this_type
),
4260 TYPE_VARARGS (this_type
));
4262 /* Handle static member functions.
4263 Dwarf2 has no clean way to discern C++ static and non-static
4264 member functions. G++ helps GDB by marking the first
4265 parameter for non-static member functions (which is the
4266 this pointer) as artificial. We obtain this information
4267 from read_subroutine_type via TYPE_FIELD_ARTIFICIAL. */
4268 if (nparams
== 0 || TYPE_FIELD_ARTIFICIAL (this_type
, 0) == 0)
4269 fnp
->voffset
= VOFFSET_STATIC
;
4272 complaint (&symfile_complaints
, _("member function type missing for '%s'"),
4275 /* Get fcontext from DW_AT_containing_type if present. */
4276 if (dwarf2_attr (die
, DW_AT_containing_type
, cu
) != NULL
)
4277 fnp
->fcontext
= die_containing_type (die
, cu
);
4279 /* dwarf2 doesn't have stubbed physical names, so the setting of is_const
4280 and is_volatile is irrelevant, as it is needed by gdb_mangle_name only. */
4282 /* Get accessibility. */
4283 attr
= dwarf2_attr (die
, DW_AT_accessibility
, cu
);
4286 switch (DW_UNSND (attr
))
4288 case DW_ACCESS_private
:
4289 fnp
->is_private
= 1;
4291 case DW_ACCESS_protected
:
4292 fnp
->is_protected
= 1;
4297 /* Check for artificial methods. */
4298 attr
= dwarf2_attr (die
, DW_AT_artificial
, cu
);
4299 if (attr
&& DW_UNSND (attr
) != 0)
4300 fnp
->is_artificial
= 1;
4302 /* Get index in virtual function table if it is a virtual member function. */
4303 attr
= dwarf2_attr (die
, DW_AT_vtable_elem_location
, cu
);
4306 /* Support the .debug_loc offsets */
4307 if (attr_form_is_block (attr
))
4309 fnp
->voffset
= decode_locdesc (DW_BLOCK (attr
), cu
) + 2;
4311 else if (attr_form_is_section_offset (attr
))
4313 dwarf2_complex_location_expr_complaint ();
4317 dwarf2_invalid_attrib_class_complaint ("DW_AT_vtable_elem_location",
4323 /* Create the vector of member function fields, and attach it to the type. */
4326 dwarf2_attach_fn_fields_to_type (struct field_info
*fip
, struct type
*type
,
4327 struct dwarf2_cu
*cu
)
4329 struct fnfieldlist
*flp
;
4330 int total_length
= 0;
4333 ALLOCATE_CPLUS_STRUCT_TYPE (type
);
4334 TYPE_FN_FIELDLISTS (type
) = (struct fn_fieldlist
*)
4335 TYPE_ALLOC (type
, sizeof (struct fn_fieldlist
) * fip
->nfnfields
);
4337 for (i
= 0, flp
= fip
->fnfieldlists
; i
< fip
->nfnfields
; i
++, flp
++)
4339 struct nextfnfield
*nfp
= flp
->head
;
4340 struct fn_fieldlist
*fn_flp
= &TYPE_FN_FIELDLIST (type
, i
);
4343 TYPE_FN_FIELDLIST_NAME (type
, i
) = flp
->name
;
4344 TYPE_FN_FIELDLIST_LENGTH (type
, i
) = flp
->length
;
4345 fn_flp
->fn_fields
= (struct fn_field
*)
4346 TYPE_ALLOC (type
, sizeof (struct fn_field
) * flp
->length
);
4347 for (k
= flp
->length
; (k
--, nfp
); nfp
= nfp
->next
)
4348 fn_flp
->fn_fields
[k
] = nfp
->fnfield
;
4350 total_length
+= flp
->length
;
4353 TYPE_NFN_FIELDS (type
) = fip
->nfnfields
;
4354 TYPE_NFN_FIELDS_TOTAL (type
) = total_length
;
4357 /* Returns non-zero if NAME is the name of a vtable member in CU's
4358 language, zero otherwise. */
4360 is_vtable_name (const char *name
, struct dwarf2_cu
*cu
)
4362 static const char vptr
[] = "_vptr";
4363 static const char vtable
[] = "vtable";
4365 /* Look for the C++ and Java forms of the vtable. */
4366 if ((cu
->language
== language_java
4367 && strncmp (name
, vtable
, sizeof (vtable
) - 1) == 0)
4368 || (strncmp (name
, vptr
, sizeof (vptr
) - 1) == 0
4369 && is_cplus_marker (name
[sizeof (vptr
) - 1])))
4375 /* GCC outputs unnamed structures that are really pointers to member
4376 functions, with the ABI-specified layout. If DIE (from CU) describes
4377 such a structure, set its type, and return nonzero. Otherwise return
4380 GCC shouldn't do this; it should just output pointer to member DIEs.
4381 This is GCC PR debug/28767. */
4383 static struct type
*
4384 quirk_gcc_member_function_pointer (struct die_info
*die
, struct dwarf2_cu
*cu
)
4386 struct objfile
*objfile
= cu
->objfile
;
4388 struct die_info
*pfn_die
, *delta_die
;
4389 struct attribute
*pfn_name
, *delta_name
;
4390 struct type
*pfn_type
, *domain_type
;
4392 /* Check for a structure with no name and two children. */
4393 if (die
->tag
!= DW_TAG_structure_type
4394 || dwarf2_attr (die
, DW_AT_name
, cu
) != NULL
4395 || die
->child
== NULL
4396 || die
->child
->sibling
== NULL
4397 || (die
->child
->sibling
->sibling
!= NULL
4398 && die
->child
->sibling
->sibling
->tag
!= DW_TAG_padding
))
4401 /* Check for __pfn and __delta members. */
4402 pfn_die
= die
->child
;
4403 pfn_name
= dwarf2_attr (pfn_die
, DW_AT_name
, cu
);
4404 if (pfn_die
->tag
!= DW_TAG_member
4406 || DW_STRING (pfn_name
) == NULL
4407 || strcmp ("__pfn", DW_STRING (pfn_name
)) != 0)
4410 delta_die
= pfn_die
->sibling
;
4411 delta_name
= dwarf2_attr (delta_die
, DW_AT_name
, cu
);
4412 if (delta_die
->tag
!= DW_TAG_member
4413 || delta_name
== NULL
4414 || DW_STRING (delta_name
) == NULL
4415 || strcmp ("__delta", DW_STRING (delta_name
)) != 0)
4418 /* Find the type of the method. */
4419 pfn_type
= die_type (pfn_die
, cu
);
4420 if (pfn_type
== NULL
4421 || TYPE_CODE (pfn_type
) != TYPE_CODE_PTR
4422 || TYPE_CODE (TYPE_TARGET_TYPE (pfn_type
)) != TYPE_CODE_FUNC
)
4425 /* Look for the "this" argument. */
4426 pfn_type
= TYPE_TARGET_TYPE (pfn_type
);
4427 if (TYPE_NFIELDS (pfn_type
) == 0
4428 || TYPE_CODE (TYPE_FIELD_TYPE (pfn_type
, 0)) != TYPE_CODE_PTR
)
4431 domain_type
= TYPE_TARGET_TYPE (TYPE_FIELD_TYPE (pfn_type
, 0));
4432 type
= alloc_type (objfile
);
4433 smash_to_method_type (type
, domain_type
, TYPE_TARGET_TYPE (pfn_type
),
4434 TYPE_FIELDS (pfn_type
), TYPE_NFIELDS (pfn_type
),
4435 TYPE_VARARGS (pfn_type
));
4436 type
= lookup_methodptr_type (type
);
4437 return set_die_type (die
, type
, cu
);
4440 /* Called when we find the DIE that starts a structure or union scope
4441 (definition) to process all dies that define the members of the
4444 NOTE: we need to call struct_type regardless of whether or not the
4445 DIE has an at_name attribute, since it might be an anonymous
4446 structure or union. This gets the type entered into our set of
4449 However, if the structure is incomplete (an opaque struct/union)
4450 then suppress creating a symbol table entry for it since gdb only
4451 wants to find the one with the complete definition. Note that if
4452 it is complete, we just call new_symbol, which does it's own
4453 checking about whether the struct/union is anonymous or not (and
4454 suppresses creating a symbol table entry itself). */
4456 static struct type
*
4457 read_structure_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
4459 struct objfile
*objfile
= cu
->objfile
;
4461 struct attribute
*attr
;
4463 struct cleanup
*back_to
= make_cleanup (null_cleanup
, 0);
4465 type
= quirk_gcc_member_function_pointer (die
, cu
);
4469 type
= alloc_type (objfile
);
4470 INIT_CPLUS_SPECIFIC (type
);
4471 name
= dwarf2_name (die
, cu
);
4474 if (cu
->language
== language_cplus
4475 || cu
->language
== language_java
)
4477 const char *new_prefix
= determine_class_name (die
, cu
);
4478 TYPE_TAG_NAME (type
) = (char *) new_prefix
;
4482 /* The name is already allocated along with this objfile, so
4483 we don't need to duplicate it for the type. */
4484 TYPE_TAG_NAME (type
) = name
;
4488 if (die
->tag
== DW_TAG_structure_type
)
4490 TYPE_CODE (type
) = TYPE_CODE_STRUCT
;
4492 else if (die
->tag
== DW_TAG_union_type
)
4494 TYPE_CODE (type
) = TYPE_CODE_UNION
;
4498 /* FIXME: TYPE_CODE_CLASS is currently defined to TYPE_CODE_STRUCT
4500 TYPE_CODE (type
) = TYPE_CODE_CLASS
;
4503 attr
= dwarf2_attr (die
, DW_AT_byte_size
, cu
);
4506 TYPE_LENGTH (type
) = DW_UNSND (attr
);
4510 TYPE_LENGTH (type
) = 0;
4513 TYPE_STUB_SUPPORTED (type
) = 1;
4514 if (die_is_declaration (die
, cu
))
4515 TYPE_STUB (type
) = 1;
4517 /* We need to add the type field to the die immediately so we don't
4518 infinitely recurse when dealing with pointers to the structure
4519 type within the structure itself. */
4520 set_die_type (die
, type
, cu
);
4522 if (die
->child
!= NULL
&& ! die_is_declaration (die
, cu
))
4524 struct field_info fi
;
4525 struct die_info
*child_die
;
4527 memset (&fi
, 0, sizeof (struct field_info
));
4529 child_die
= die
->child
;
4531 while (child_die
&& child_die
->tag
)
4533 if (child_die
->tag
== DW_TAG_member
4534 || child_die
->tag
== DW_TAG_variable
)
4536 /* NOTE: carlton/2002-11-05: A C++ static data member
4537 should be a DW_TAG_member that is a declaration, but
4538 all versions of G++ as of this writing (so through at
4539 least 3.2.1) incorrectly generate DW_TAG_variable
4540 tags for them instead. */
4541 dwarf2_add_field (&fi
, child_die
, cu
);
4543 else if (child_die
->tag
== DW_TAG_subprogram
)
4545 /* C++ member function. */
4546 dwarf2_add_member_fn (&fi
, child_die
, type
, cu
);
4548 else if (child_die
->tag
== DW_TAG_inheritance
)
4550 /* C++ base class field. */
4551 dwarf2_add_field (&fi
, child_die
, cu
);
4553 child_die
= sibling_die (child_die
);
4556 /* Attach fields and member functions to the type. */
4558 dwarf2_attach_fields_to_type (&fi
, type
, cu
);
4561 dwarf2_attach_fn_fields_to_type (&fi
, type
, cu
);
4563 /* Get the type which refers to the base class (possibly this
4564 class itself) which contains the vtable pointer for the current
4565 class from the DW_AT_containing_type attribute. */
4567 if (dwarf2_attr (die
, DW_AT_containing_type
, cu
) != NULL
)
4569 struct type
*t
= die_containing_type (die
, cu
);
4571 TYPE_VPTR_BASETYPE (type
) = t
;
4576 /* Our own class provides vtbl ptr. */
4577 for (i
= TYPE_NFIELDS (t
) - 1;
4578 i
>= TYPE_N_BASECLASSES (t
);
4581 char *fieldname
= TYPE_FIELD_NAME (t
, i
);
4583 if (is_vtable_name (fieldname
, cu
))
4585 TYPE_VPTR_FIELDNO (type
) = i
;
4590 /* Complain if virtual function table field not found. */
4591 if (i
< TYPE_N_BASECLASSES (t
))
4592 complaint (&symfile_complaints
,
4593 _("virtual function table pointer not found when defining class '%s'"),
4594 TYPE_TAG_NAME (type
) ? TYPE_TAG_NAME (type
) :
4599 TYPE_VPTR_FIELDNO (type
) = TYPE_VPTR_FIELDNO (t
);
4602 else if (cu
->producer
4603 && strncmp (cu
->producer
,
4604 "IBM(R) XL C/C++ Advanced Edition", 32) == 0)
4606 /* The IBM XLC compiler does not provide direct indication
4607 of the containing type, but the vtable pointer is
4608 always named __vfp. */
4612 for (i
= TYPE_NFIELDS (type
) - 1;
4613 i
>= TYPE_N_BASECLASSES (type
);
4616 if (strcmp (TYPE_FIELD_NAME (type
, i
), "__vfp") == 0)
4618 TYPE_VPTR_FIELDNO (type
) = i
;
4619 TYPE_VPTR_BASETYPE (type
) = type
;
4627 do_cleanups (back_to
);
4632 process_structure_scope (struct die_info
*die
, struct dwarf2_cu
*cu
)
4634 struct objfile
*objfile
= cu
->objfile
;
4635 struct die_info
*child_die
= die
->child
;
4636 struct type
*this_type
;
4638 this_type
= get_die_type (die
, cu
);
4639 if (this_type
== NULL
)
4640 this_type
= read_structure_type (die
, cu
);
4642 /* NOTE: carlton/2004-03-16: GCC 3.4 (or at least one of its
4643 snapshots) has been known to create a die giving a declaration
4644 for a class that has, as a child, a die giving a definition for a
4645 nested class. So we have to process our children even if the
4646 current die is a declaration. Normally, of course, a declaration
4647 won't have any children at all. */
4649 while (child_die
!= NULL
&& child_die
->tag
)
4651 if (child_die
->tag
== DW_TAG_member
4652 || child_die
->tag
== DW_TAG_variable
4653 || child_die
->tag
== DW_TAG_inheritance
)
4658 process_die (child_die
, cu
);
4660 child_die
= sibling_die (child_die
);
4663 /* Do not consider external references. According to the DWARF standard,
4664 these DIEs are identified by the fact that they have no byte_size
4665 attribute, and a declaration attribute. */
4666 if (dwarf2_attr (die
, DW_AT_byte_size
, cu
) != NULL
4667 || !die_is_declaration (die
, cu
))
4668 new_symbol (die
, this_type
, cu
);
4671 /* Given a DW_AT_enumeration_type die, set its type. We do not
4672 complete the type's fields yet, or create any symbols. */
4674 static struct type
*
4675 read_enumeration_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
4677 struct objfile
*objfile
= cu
->objfile
;
4679 struct attribute
*attr
;
4682 type
= alloc_type (objfile
);
4684 TYPE_CODE (type
) = TYPE_CODE_ENUM
;
4685 name
= dwarf2_full_name (die
, cu
);
4687 TYPE_TAG_NAME (type
) = (char *) name
;
4689 attr
= dwarf2_attr (die
, DW_AT_byte_size
, cu
);
4692 TYPE_LENGTH (type
) = DW_UNSND (attr
);
4696 TYPE_LENGTH (type
) = 0;
4699 /* The enumeration DIE can be incomplete. In Ada, any type can be
4700 declared as private in the package spec, and then defined only
4701 inside the package body. Such types are known as Taft Amendment
4702 Types. When another package uses such a type, an incomplete DIE
4703 may be generated by the compiler. */
4704 if (die_is_declaration (die
, cu
))
4705 TYPE_STUB (type
) = 1;
4707 return set_die_type (die
, type
, cu
);
4710 /* Determine the name of the type represented by DIE, which should be
4711 a named C++ or Java compound type. Return the name in question,
4712 allocated on the objfile obstack. */
4715 determine_class_name (struct die_info
*die
, struct dwarf2_cu
*cu
)
4717 const char *new_prefix
= NULL
;
4719 /* If we don't have namespace debug info, guess the name by trying
4720 to demangle the names of members, just like we did in
4721 guess_structure_name. */
4722 if (!processing_has_namespace_info
)
4724 struct die_info
*child
;
4726 for (child
= die
->child
;
4727 child
!= NULL
&& child
->tag
!= 0;
4728 child
= sibling_die (child
))
4730 if (child
->tag
== DW_TAG_subprogram
)
4733 = language_class_name_from_physname (cu
->language_defn
,
4737 if (phys_prefix
!= NULL
)
4740 = obsavestring (phys_prefix
, strlen (phys_prefix
),
4741 &cu
->objfile
->objfile_obstack
);
4742 xfree (phys_prefix
);
4749 if (new_prefix
== NULL
)
4750 new_prefix
= dwarf2_full_name (die
, cu
);
4755 /* Given a pointer to a die which begins an enumeration, process all
4756 the dies that define the members of the enumeration, and create the
4757 symbol for the enumeration type.
4759 NOTE: We reverse the order of the element list. */
4762 process_enumeration_scope (struct die_info
*die
, struct dwarf2_cu
*cu
)
4764 struct objfile
*objfile
= cu
->objfile
;
4765 struct die_info
*child_die
;
4766 struct field
*fields
;
4769 int unsigned_enum
= 1;
4771 struct type
*this_type
;
4775 this_type
= get_die_type (die
, cu
);
4776 if (this_type
== NULL
)
4777 this_type
= read_enumeration_type (die
, cu
);
4778 if (die
->child
!= NULL
)
4780 child_die
= die
->child
;
4781 while (child_die
&& child_die
->tag
)
4783 if (child_die
->tag
!= DW_TAG_enumerator
)
4785 process_die (child_die
, cu
);
4789 name
= dwarf2_name (child_die
, cu
);
4792 sym
= new_symbol (child_die
, this_type
, cu
);
4793 if (SYMBOL_VALUE (sym
) < 0)
4796 if ((num_fields
% DW_FIELD_ALLOC_CHUNK
) == 0)
4798 fields
= (struct field
*)
4800 (num_fields
+ DW_FIELD_ALLOC_CHUNK
)
4801 * sizeof (struct field
));
4804 FIELD_NAME (fields
[num_fields
]) = SYMBOL_LINKAGE_NAME (sym
);
4805 FIELD_TYPE (fields
[num_fields
]) = NULL
;
4806 SET_FIELD_BITPOS (fields
[num_fields
], SYMBOL_VALUE (sym
));
4807 FIELD_BITSIZE (fields
[num_fields
]) = 0;
4813 child_die
= sibling_die (child_die
);
4818 TYPE_NFIELDS (this_type
) = num_fields
;
4819 TYPE_FIELDS (this_type
) = (struct field
*)
4820 TYPE_ALLOC (this_type
, sizeof (struct field
) * num_fields
);
4821 memcpy (TYPE_FIELDS (this_type
), fields
,
4822 sizeof (struct field
) * num_fields
);
4826 TYPE_UNSIGNED (this_type
) = 1;
4829 new_symbol (die
, this_type
, cu
);
4832 /* Extract all information from a DW_TAG_array_type DIE and put it in
4833 the DIE's type field. For now, this only handles one dimensional
4836 static struct type
*
4837 read_array_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
4839 struct objfile
*objfile
= cu
->objfile
;
4840 struct die_info
*child_die
;
4841 struct type
*type
= NULL
;
4842 struct type
*element_type
, *range_type
, *index_type
;
4843 struct type
**range_types
= NULL
;
4844 struct attribute
*attr
;
4846 struct cleanup
*back_to
;
4849 element_type
= die_type (die
, cu
);
4851 /* Irix 6.2 native cc creates array types without children for
4852 arrays with unspecified length. */
4853 if (die
->child
== NULL
)
4855 index_type
= objfile_type (objfile
)->builtin_int
;
4856 range_type
= create_range_type (NULL
, index_type
, 0, -1);
4857 type
= create_array_type (NULL
, element_type
, range_type
);
4858 return set_die_type (die
, type
, cu
);
4861 back_to
= make_cleanup (null_cleanup
, NULL
);
4862 child_die
= die
->child
;
4863 while (child_die
&& child_die
->tag
)
4865 if (child_die
->tag
== DW_TAG_subrange_type
)
4867 struct type
*child_type
= read_type_die (child_die
, cu
);
4868 if (child_type
!= NULL
)
4870 /* The range type was succesfully read. Save it for
4871 the array type creation. */
4872 if ((ndim
% DW_FIELD_ALLOC_CHUNK
) == 0)
4874 range_types
= (struct type
**)
4875 xrealloc (range_types
, (ndim
+ DW_FIELD_ALLOC_CHUNK
)
4876 * sizeof (struct type
*));
4878 make_cleanup (free_current_contents
, &range_types
);
4880 range_types
[ndim
++] = child_type
;
4883 child_die
= sibling_die (child_die
);
4886 /* Dwarf2 dimensions are output from left to right, create the
4887 necessary array types in backwards order. */
4889 type
= element_type
;
4891 if (read_array_order (die
, cu
) == DW_ORD_col_major
)
4895 type
= create_array_type (NULL
, type
, range_types
[i
++]);
4900 type
= create_array_type (NULL
, type
, range_types
[ndim
]);
4903 /* Understand Dwarf2 support for vector types (like they occur on
4904 the PowerPC w/ AltiVec). Gcc just adds another attribute to the
4905 array type. This is not part of the Dwarf2/3 standard yet, but a
4906 custom vendor extension. The main difference between a regular
4907 array and the vector variant is that vectors are passed by value
4909 attr
= dwarf2_attr (die
, DW_AT_GNU_vector
, cu
);
4911 make_vector_type (type
);
4913 name
= dwarf2_name (die
, cu
);
4915 TYPE_NAME (type
) = name
;
4917 do_cleanups (back_to
);
4919 /* Install the type in the die. */
4920 return set_die_type (die
, type
, cu
);
4923 static enum dwarf_array_dim_ordering
4924 read_array_order (struct die_info
*die
, struct dwarf2_cu
*cu
)
4926 struct attribute
*attr
;
4928 attr
= dwarf2_attr (die
, DW_AT_ordering
, cu
);
4930 if (attr
) return DW_SND (attr
);
4933 GNU F77 is a special case, as at 08/2004 array type info is the
4934 opposite order to the dwarf2 specification, but data is still
4935 laid out as per normal fortran.
4937 FIXME: dsl/2004-8-20: If G77 is ever fixed, this will also need
4941 if (cu
->language
== language_fortran
&&
4942 cu
->producer
&& strstr (cu
->producer
, "GNU F77"))
4944 return DW_ORD_row_major
;
4947 switch (cu
->language_defn
->la_array_ordering
)
4949 case array_column_major
:
4950 return DW_ORD_col_major
;
4951 case array_row_major
:
4953 return DW_ORD_row_major
;
4957 /* Extract all information from a DW_TAG_set_type DIE and put it in
4958 the DIE's type field. */
4960 static struct type
*
4961 read_set_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
4963 struct type
*set_type
= create_set_type (NULL
, die_type (die
, cu
));
4965 return set_die_type (die
, set_type
, cu
);
4968 /* First cut: install each common block member as a global variable. */
4971 read_common_block (struct die_info
*die
, struct dwarf2_cu
*cu
)
4973 struct die_info
*child_die
;
4974 struct attribute
*attr
;
4976 CORE_ADDR base
= (CORE_ADDR
) 0;
4978 attr
= dwarf2_attr (die
, DW_AT_location
, cu
);
4981 /* Support the .debug_loc offsets */
4982 if (attr_form_is_block (attr
))
4984 base
= decode_locdesc (DW_BLOCK (attr
), cu
);
4986 else if (attr_form_is_section_offset (attr
))
4988 dwarf2_complex_location_expr_complaint ();
4992 dwarf2_invalid_attrib_class_complaint ("DW_AT_location",
4993 "common block member");
4996 if (die
->child
!= NULL
)
4998 child_die
= die
->child
;
4999 while (child_die
&& child_die
->tag
)
5001 sym
= new_symbol (child_die
, NULL
, cu
);
5002 attr
= dwarf2_attr (child_die
, DW_AT_data_member_location
, cu
);
5005 SYMBOL_VALUE_ADDRESS (sym
) =
5006 base
+ decode_locdesc (DW_BLOCK (attr
), cu
);
5007 add_symbol_to_list (sym
, &global_symbols
);
5009 child_die
= sibling_die (child_die
);
5014 /* Create a type for a C++ namespace. */
5016 static struct type
*
5017 read_namespace_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
5019 struct objfile
*objfile
= cu
->objfile
;
5020 const char *previous_prefix
, *name
;
5024 /* For extensions, reuse the type of the original namespace. */
5025 if (dwarf2_attr (die
, DW_AT_extension
, cu
) != NULL
)
5027 struct die_info
*ext_die
;
5028 struct dwarf2_cu
*ext_cu
= cu
;
5029 ext_die
= dwarf2_extension (die
, &ext_cu
);
5030 type
= read_type_die (ext_die
, ext_cu
);
5031 return set_die_type (die
, type
, cu
);
5034 name
= namespace_name (die
, &is_anonymous
, cu
);
5036 /* Now build the name of the current namespace. */
5038 previous_prefix
= determine_prefix (die
, cu
);
5039 if (previous_prefix
[0] != '\0')
5040 name
= typename_concat (&objfile
->objfile_obstack
,
5041 previous_prefix
, name
, cu
);
5043 /* Create the type. */
5044 type
= init_type (TYPE_CODE_NAMESPACE
, 0, 0, NULL
,
5046 TYPE_NAME (type
) = (char *) name
;
5047 TYPE_TAG_NAME (type
) = TYPE_NAME (type
);
5049 set_die_type (die
, type
, cu
);
5054 /* Read a C++ namespace. */
5057 read_namespace (struct die_info
*die
, struct dwarf2_cu
*cu
)
5059 struct objfile
*objfile
= cu
->objfile
;
5063 /* Add a symbol associated to this if we haven't seen the namespace
5064 before. Also, add a using directive if it's an anonymous
5067 if (dwarf2_attr (die
, DW_AT_extension
, cu
) == NULL
)
5071 type
= read_type_die (die
, cu
);
5072 new_symbol (die
, type
, cu
);
5074 name
= namespace_name (die
, &is_anonymous
, cu
);
5077 const char *previous_prefix
= determine_prefix (die
, cu
);
5078 cp_add_using_directive (previous_prefix
, TYPE_NAME (type
));
5082 if (die
->child
!= NULL
)
5084 struct die_info
*child_die
= die
->child
;
5086 while (child_die
&& child_die
->tag
)
5088 process_die (child_die
, cu
);
5089 child_die
= sibling_die (child_die
);
5094 /* Read a Fortran module. */
5097 read_module (struct die_info
*die
, struct dwarf2_cu
*cu
)
5099 struct die_info
*child_die
= die
->child
;
5101 /* FIXME: Support the separate Fortran module namespaces. */
5103 while (child_die
&& child_die
->tag
)
5105 process_die (child_die
, cu
);
5106 child_die
= sibling_die (child_die
);
5110 /* Return the name of the namespace represented by DIE. Set
5111 *IS_ANONYMOUS to tell whether or not the namespace is an anonymous
5115 namespace_name (struct die_info
*die
, int *is_anonymous
, struct dwarf2_cu
*cu
)
5117 struct die_info
*current_die
;
5118 const char *name
= NULL
;
5120 /* Loop through the extensions until we find a name. */
5122 for (current_die
= die
;
5123 current_die
!= NULL
;
5124 current_die
= dwarf2_extension (die
, &cu
))
5126 name
= dwarf2_name (current_die
, cu
);
5131 /* Is it an anonymous namespace? */
5133 *is_anonymous
= (name
== NULL
);
5135 name
= "(anonymous namespace)";
5140 /* Extract all information from a DW_TAG_pointer_type DIE and add to
5141 the user defined type vector. */
5143 static struct type
*
5144 read_tag_pointer_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
5146 struct gdbarch
*gdbarch
= get_objfile_arch (cu
->objfile
);
5147 struct comp_unit_head
*cu_header
= &cu
->header
;
5149 struct attribute
*attr_byte_size
;
5150 struct attribute
*attr_address_class
;
5151 int byte_size
, addr_class
;
5153 type
= lookup_pointer_type (die_type (die
, cu
));
5155 attr_byte_size
= dwarf2_attr (die
, DW_AT_byte_size
, cu
);
5157 byte_size
= DW_UNSND (attr_byte_size
);
5159 byte_size
= cu_header
->addr_size
;
5161 attr_address_class
= dwarf2_attr (die
, DW_AT_address_class
, cu
);
5162 if (attr_address_class
)
5163 addr_class
= DW_UNSND (attr_address_class
);
5165 addr_class
= DW_ADDR_none
;
5167 /* If the pointer size or address class is different than the
5168 default, create a type variant marked as such and set the
5169 length accordingly. */
5170 if (TYPE_LENGTH (type
) != byte_size
|| addr_class
!= DW_ADDR_none
)
5172 if (gdbarch_address_class_type_flags_p (gdbarch
))
5176 type_flags
= gdbarch_address_class_type_flags
5177 (gdbarch
, byte_size
, addr_class
);
5178 gdb_assert ((type_flags
& ~TYPE_INSTANCE_FLAG_ADDRESS_CLASS_ALL
)
5180 type
= make_type_with_address_space (type
, type_flags
);
5182 else if (TYPE_LENGTH (type
) != byte_size
)
5184 complaint (&symfile_complaints
, _("invalid pointer size %d"), byte_size
);
5187 /* Should we also complain about unhandled address classes? */
5191 TYPE_LENGTH (type
) = byte_size
;
5192 return set_die_type (die
, type
, cu
);
5195 /* Extract all information from a DW_TAG_ptr_to_member_type DIE and add to
5196 the user defined type vector. */
5198 static struct type
*
5199 read_tag_ptr_to_member_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
5201 struct objfile
*objfile
= cu
->objfile
;
5203 struct type
*to_type
;
5204 struct type
*domain
;
5206 to_type
= die_type (die
, cu
);
5207 domain
= die_containing_type (die
, cu
);
5209 if (TYPE_CODE (check_typedef (to_type
)) == TYPE_CODE_METHOD
)
5210 type
= lookup_methodptr_type (to_type
);
5212 type
= lookup_memberptr_type (to_type
, domain
);
5214 return set_die_type (die
, type
, cu
);
5217 /* Extract all information from a DW_TAG_reference_type DIE and add to
5218 the user defined type vector. */
5220 static struct type
*
5221 read_tag_reference_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
5223 struct comp_unit_head
*cu_header
= &cu
->header
;
5225 struct attribute
*attr
;
5227 type
= lookup_reference_type (die_type (die
, cu
));
5228 attr
= dwarf2_attr (die
, DW_AT_byte_size
, cu
);
5231 TYPE_LENGTH (type
) = DW_UNSND (attr
);
5235 TYPE_LENGTH (type
) = cu_header
->addr_size
;
5237 return set_die_type (die
, type
, cu
);
5240 static struct type
*
5241 read_tag_const_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
5243 struct type
*base_type
, *cv_type
;
5245 base_type
= die_type (die
, cu
);
5246 cv_type
= make_cv_type (1, TYPE_VOLATILE (base_type
), base_type
, 0);
5247 return set_die_type (die
, cv_type
, cu
);
5250 static struct type
*
5251 read_tag_volatile_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
5253 struct type
*base_type
, *cv_type
;
5255 base_type
= die_type (die
, cu
);
5256 cv_type
= make_cv_type (TYPE_CONST (base_type
), 1, base_type
, 0);
5257 return set_die_type (die
, cv_type
, cu
);
5260 /* Extract all information from a DW_TAG_string_type DIE and add to
5261 the user defined type vector. It isn't really a user defined type,
5262 but it behaves like one, with other DIE's using an AT_user_def_type
5263 attribute to reference it. */
5265 static struct type
*
5266 read_tag_string_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
5268 struct objfile
*objfile
= cu
->objfile
;
5269 struct gdbarch
*gdbarch
= get_objfile_arch (objfile
);
5270 struct type
*type
, *range_type
, *index_type
, *char_type
;
5271 struct attribute
*attr
;
5272 unsigned int length
;
5274 attr
= dwarf2_attr (die
, DW_AT_string_length
, cu
);
5277 length
= DW_UNSND (attr
);
5281 /* check for the DW_AT_byte_size attribute */
5282 attr
= dwarf2_attr (die
, DW_AT_byte_size
, cu
);
5285 length
= DW_UNSND (attr
);
5293 index_type
= objfile_type (objfile
)->builtin_int
;
5294 range_type
= create_range_type (NULL
, index_type
, 1, length
);
5295 char_type
= language_string_char_type (cu
->language_defn
, gdbarch
);
5296 type
= create_string_type (NULL
, char_type
, range_type
);
5298 return set_die_type (die
, type
, cu
);
5301 /* Handle DIES due to C code like:
5305 int (*funcp)(int a, long l);
5309 ('funcp' generates a DW_TAG_subroutine_type DIE)
5312 static struct type
*
5313 read_subroutine_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
5315 struct type
*type
; /* Type that this function returns */
5316 struct type
*ftype
; /* Function that returns above type */
5317 struct attribute
*attr
;
5319 type
= die_type (die
, cu
);
5320 ftype
= lookup_function_type (type
);
5322 /* All functions in C++, Pascal and Java have prototypes. */
5323 attr
= dwarf2_attr (die
, DW_AT_prototyped
, cu
);
5324 if ((attr
&& (DW_UNSND (attr
) != 0))
5325 || cu
->language
== language_cplus
5326 || cu
->language
== language_java
5327 || cu
->language
== language_pascal
)
5328 TYPE_PROTOTYPED (ftype
) = 1;
5330 /* Store the calling convention in the type if it's available in
5331 the subroutine die. Otherwise set the calling convention to
5332 the default value DW_CC_normal. */
5333 attr
= dwarf2_attr (die
, DW_AT_calling_convention
, cu
);
5334 TYPE_CALLING_CONVENTION (ftype
) = attr
? DW_UNSND (attr
) : DW_CC_normal
;
5336 if (die
->child
!= NULL
)
5338 struct die_info
*child_die
;
5342 /* Count the number of parameters.
5343 FIXME: GDB currently ignores vararg functions, but knows about
5344 vararg member functions. */
5345 child_die
= die
->child
;
5346 while (child_die
&& child_die
->tag
)
5348 if (child_die
->tag
== DW_TAG_formal_parameter
)
5350 else if (child_die
->tag
== DW_TAG_unspecified_parameters
)
5351 TYPE_VARARGS (ftype
) = 1;
5352 child_die
= sibling_die (child_die
);
5355 /* Allocate storage for parameters and fill them in. */
5356 TYPE_NFIELDS (ftype
) = nparams
;
5357 TYPE_FIELDS (ftype
) = (struct field
*)
5358 TYPE_ZALLOC (ftype
, nparams
* sizeof (struct field
));
5360 child_die
= die
->child
;
5361 while (child_die
&& child_die
->tag
)
5363 if (child_die
->tag
== DW_TAG_formal_parameter
)
5365 /* Dwarf2 has no clean way to discern C++ static and non-static
5366 member functions. G++ helps GDB by marking the first
5367 parameter for non-static member functions (which is the
5368 this pointer) as artificial. We pass this information
5369 to dwarf2_add_member_fn via TYPE_FIELD_ARTIFICIAL. */
5370 attr
= dwarf2_attr (child_die
, DW_AT_artificial
, cu
);
5372 TYPE_FIELD_ARTIFICIAL (ftype
, iparams
) = DW_UNSND (attr
);
5374 TYPE_FIELD_ARTIFICIAL (ftype
, iparams
) = 0;
5375 TYPE_FIELD_TYPE (ftype
, iparams
) = die_type (child_die
, cu
);
5378 child_die
= sibling_die (child_die
);
5382 return set_die_type (die
, ftype
, cu
);
5385 static struct type
*
5386 read_typedef (struct die_info
*die
, struct dwarf2_cu
*cu
)
5388 struct objfile
*objfile
= cu
->objfile
;
5389 struct attribute
*attr
;
5390 const char *name
= NULL
;
5391 struct type
*this_type
;
5393 name
= dwarf2_full_name (die
, cu
);
5394 this_type
= init_type (TYPE_CODE_TYPEDEF
, 0,
5395 TYPE_FLAG_TARGET_STUB
, NULL
, objfile
);
5396 TYPE_NAME (this_type
) = (char *) name
;
5397 set_die_type (die
, this_type
, cu
);
5398 TYPE_TARGET_TYPE (this_type
) = die_type (die
, cu
);
5402 /* Find a representation of a given base type and install
5403 it in the TYPE field of the die. */
5405 static struct type
*
5406 read_base_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
5408 struct objfile
*objfile
= cu
->objfile
;
5410 struct attribute
*attr
;
5411 int encoding
= 0, size
= 0;
5413 enum type_code code
= TYPE_CODE_INT
;
5415 struct type
*target_type
= NULL
;
5417 attr
= dwarf2_attr (die
, DW_AT_encoding
, cu
);
5420 encoding
= DW_UNSND (attr
);
5422 attr
= dwarf2_attr (die
, DW_AT_byte_size
, cu
);
5425 size
= DW_UNSND (attr
);
5427 name
= dwarf2_name (die
, cu
);
5430 complaint (&symfile_complaints
,
5431 _("DW_AT_name missing from DW_TAG_base_type"));
5436 case DW_ATE_address
:
5437 /* Turn DW_ATE_address into a void * pointer. */
5438 code
= TYPE_CODE_PTR
;
5439 type_flags
|= TYPE_FLAG_UNSIGNED
;
5440 target_type
= init_type (TYPE_CODE_VOID
, 1, 0, NULL
, objfile
);
5442 case DW_ATE_boolean
:
5443 code
= TYPE_CODE_BOOL
;
5444 type_flags
|= TYPE_FLAG_UNSIGNED
;
5446 case DW_ATE_complex_float
:
5447 code
= TYPE_CODE_COMPLEX
;
5448 target_type
= init_type (TYPE_CODE_FLT
, size
/ 2, 0, NULL
, objfile
);
5450 case DW_ATE_decimal_float
:
5451 code
= TYPE_CODE_DECFLOAT
;
5454 code
= TYPE_CODE_FLT
;
5458 case DW_ATE_unsigned
:
5459 type_flags
|= TYPE_FLAG_UNSIGNED
;
5461 case DW_ATE_signed_char
:
5462 if (cu
->language
== language_ada
|| cu
->language
== language_m2
5463 || cu
->language
== language_pascal
)
5464 code
= TYPE_CODE_CHAR
;
5466 case DW_ATE_unsigned_char
:
5467 if (cu
->language
== language_ada
|| cu
->language
== language_m2
5468 || cu
->language
== language_pascal
)
5469 code
= TYPE_CODE_CHAR
;
5470 type_flags
|= TYPE_FLAG_UNSIGNED
;
5473 complaint (&symfile_complaints
, _("unsupported DW_AT_encoding: '%s'"),
5474 dwarf_type_encoding_name (encoding
));
5478 type
= init_type (code
, size
, type_flags
, NULL
, objfile
);
5479 TYPE_NAME (type
) = name
;
5480 TYPE_TARGET_TYPE (type
) = target_type
;
5482 if (name
&& strcmp (name
, "char") == 0)
5483 TYPE_NOSIGN (type
) = 1;
5485 return set_die_type (die
, type
, cu
);
5488 /* Read the given DW_AT_subrange DIE. */
5490 static struct type
*
5491 read_subrange_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
5493 struct gdbarch
*gdbarch
= get_objfile_arch (cu
->objfile
);
5494 struct type
*base_type
;
5495 struct type
*range_type
;
5496 struct attribute
*attr
;
5501 base_type
= die_type (die
, cu
);
5502 if (TYPE_CODE (base_type
) == TYPE_CODE_VOID
)
5504 complaint (&symfile_complaints
,
5505 _("DW_AT_type missing from DW_TAG_subrange_type"));
5507 = init_type (TYPE_CODE_INT
, gdbarch_addr_bit (gdbarch
) / 8,
5508 0, NULL
, cu
->objfile
);
5511 if (cu
->language
== language_fortran
)
5513 /* FORTRAN implies a lower bound of 1, if not given. */
5517 /* FIXME: For variable sized arrays either of these could be
5518 a variable rather than a constant value. We'll allow it,
5519 but we don't know how to handle it. */
5520 attr
= dwarf2_attr (die
, DW_AT_lower_bound
, cu
);
5522 low
= dwarf2_get_attr_constant_value (attr
, 0);
5524 attr
= dwarf2_attr (die
, DW_AT_upper_bound
, cu
);
5527 if (attr
->form
== DW_FORM_block1
)
5529 /* GCC encodes arrays with unspecified or dynamic length
5530 with a DW_FORM_block1 attribute.
5531 FIXME: GDB does not yet know how to handle dynamic
5532 arrays properly, treat them as arrays with unspecified
5535 FIXME: jimb/2003-09-22: GDB does not really know
5536 how to handle arrays of unspecified length
5537 either; we just represent them as zero-length
5538 arrays. Choose an appropriate upper bound given
5539 the lower bound we've computed above. */
5543 high
= dwarf2_get_attr_constant_value (attr
, 1);
5546 range_type
= create_range_type (NULL
, base_type
, low
, high
);
5548 name
= dwarf2_name (die
, cu
);
5550 TYPE_NAME (range_type
) = name
;
5552 attr
= dwarf2_attr (die
, DW_AT_byte_size
, cu
);
5554 TYPE_LENGTH (range_type
) = DW_UNSND (attr
);
5556 return set_die_type (die
, range_type
, cu
);
5559 static struct type
*
5560 read_unspecified_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
5564 /* For now, we only support the C meaning of an unspecified type: void. */
5566 type
= init_type (TYPE_CODE_VOID
, 0, 0, NULL
, cu
->objfile
);
5567 TYPE_NAME (type
) = dwarf2_name (die
, cu
);
5569 return set_die_type (die
, type
, cu
);
5572 /* Trivial hash function for die_info: the hash value of a DIE
5573 is its offset in .debug_info for this objfile. */
5576 die_hash (const void *item
)
5578 const struct die_info
*die
= item
;
5582 /* Trivial comparison function for die_info structures: two DIEs
5583 are equal if they have the same offset. */
5586 die_eq (const void *item_lhs
, const void *item_rhs
)
5588 const struct die_info
*die_lhs
= item_lhs
;
5589 const struct die_info
*die_rhs
= item_rhs
;
5590 return die_lhs
->offset
== die_rhs
->offset
;
5593 /* Read a whole compilation unit into a linked list of dies. */
5595 static struct die_info
*
5596 read_comp_unit (gdb_byte
*info_ptr
, bfd
*abfd
, struct dwarf2_cu
*cu
)
5599 = htab_create_alloc_ex (cu
->header
.length
/ 12,
5603 &cu
->comp_unit_obstack
,
5604 hashtab_obstack_allocate
,
5605 dummy_obstack_deallocate
);
5607 return read_die_and_children (info_ptr
, abfd
, cu
, &info_ptr
, NULL
);
5610 /* Main entry point for reading a DIE and all children.
5611 Read the DIE and dump it if requested. */
5613 static struct die_info
*
5614 read_die_and_children (gdb_byte
*info_ptr
, bfd
*abfd
,
5615 struct dwarf2_cu
*cu
,
5616 gdb_byte
**new_info_ptr
,
5617 struct die_info
*parent
)
5619 struct die_info
*result
= read_die_and_children_1 (info_ptr
, abfd
, cu
,
5620 new_info_ptr
, parent
);
5622 if (dwarf2_die_debug
)
5624 fprintf_unfiltered (gdb_stdlog
, "Read die from .debug_info:\n");
5625 dump_die (result
, dwarf2_die_debug
);
5631 /* Read a single die and all its descendents. Set the die's sibling
5632 field to NULL; set other fields in the die correctly, and set all
5633 of the descendents' fields correctly. Set *NEW_INFO_PTR to the
5634 location of the info_ptr after reading all of those dies. PARENT
5635 is the parent of the die in question. */
5637 static struct die_info
*
5638 read_die_and_children_1 (gdb_byte
*info_ptr
, bfd
*abfd
,
5639 struct dwarf2_cu
*cu
,
5640 gdb_byte
**new_info_ptr
,
5641 struct die_info
*parent
)
5643 struct die_info
*die
;
5647 cur_ptr
= read_full_die (&die
, abfd
, info_ptr
, cu
, &has_children
);
5650 *new_info_ptr
= cur_ptr
;
5653 store_in_ref_table (die
, cu
);
5657 die
->child
= read_die_and_siblings (cur_ptr
, abfd
, cu
,
5663 *new_info_ptr
= cur_ptr
;
5666 die
->sibling
= NULL
;
5667 die
->parent
= parent
;
5671 /* Read a die, all of its descendents, and all of its siblings; set
5672 all of the fields of all of the dies correctly. Arguments are as
5673 in read_die_and_children. */
5675 static struct die_info
*
5676 read_die_and_siblings (gdb_byte
*info_ptr
, bfd
*abfd
,
5677 struct dwarf2_cu
*cu
,
5678 gdb_byte
**new_info_ptr
,
5679 struct die_info
*parent
)
5681 struct die_info
*first_die
, *last_sibling
;
5685 first_die
= last_sibling
= NULL
;
5689 struct die_info
*die
5690 = read_die_and_children_1 (cur_ptr
, abfd
, cu
, &cur_ptr
, parent
);
5694 *new_info_ptr
= cur_ptr
;
5701 last_sibling
->sibling
= die
;
5707 /* In DWARF version 2, the description of the debugging information is
5708 stored in a separate .debug_abbrev section. Before we read any
5709 dies from a section we read in all abbreviations and install them
5710 in a hash table. This function also sets flags in CU describing
5711 the data found in the abbrev table. */
5714 dwarf2_read_abbrevs (bfd
*abfd
, struct dwarf2_cu
*cu
)
5716 struct comp_unit_head
*cu_header
= &cu
->header
;
5717 gdb_byte
*abbrev_ptr
;
5718 struct abbrev_info
*cur_abbrev
;
5719 unsigned int abbrev_number
, bytes_read
, abbrev_name
;
5720 unsigned int abbrev_form
, hash_number
;
5721 struct attr_abbrev
*cur_attrs
;
5722 unsigned int allocated_attrs
;
5724 /* Initialize dwarf2 abbrevs */
5725 obstack_init (&cu
->abbrev_obstack
);
5726 cu
->dwarf2_abbrevs
= obstack_alloc (&cu
->abbrev_obstack
,
5728 * sizeof (struct abbrev_info
*)));
5729 memset (cu
->dwarf2_abbrevs
, 0,
5730 ABBREV_HASH_SIZE
* sizeof (struct abbrev_info
*));
5732 abbrev_ptr
= dwarf2_per_objfile
->abbrev
.buffer
+ cu_header
->abbrev_offset
;
5733 abbrev_number
= read_unsigned_leb128 (abfd
, abbrev_ptr
, &bytes_read
);
5734 abbrev_ptr
+= bytes_read
;
5736 allocated_attrs
= ATTR_ALLOC_CHUNK
;
5737 cur_attrs
= xmalloc (allocated_attrs
* sizeof (struct attr_abbrev
));
5739 /* loop until we reach an abbrev number of 0 */
5740 while (abbrev_number
)
5742 cur_abbrev
= dwarf_alloc_abbrev (cu
);
5744 /* read in abbrev header */
5745 cur_abbrev
->number
= abbrev_number
;
5746 cur_abbrev
->tag
= read_unsigned_leb128 (abfd
, abbrev_ptr
, &bytes_read
);
5747 abbrev_ptr
+= bytes_read
;
5748 cur_abbrev
->has_children
= read_1_byte (abfd
, abbrev_ptr
);
5751 if (cur_abbrev
->tag
== DW_TAG_namespace
)
5752 cu
->has_namespace_info
= 1;
5754 /* now read in declarations */
5755 abbrev_name
= read_unsigned_leb128 (abfd
, abbrev_ptr
, &bytes_read
);
5756 abbrev_ptr
+= bytes_read
;
5757 abbrev_form
= read_unsigned_leb128 (abfd
, abbrev_ptr
, &bytes_read
);
5758 abbrev_ptr
+= bytes_read
;
5761 if (cur_abbrev
->num_attrs
== allocated_attrs
)
5763 allocated_attrs
+= ATTR_ALLOC_CHUNK
;
5765 = xrealloc (cur_attrs
, (allocated_attrs
5766 * sizeof (struct attr_abbrev
)));
5769 /* Record whether this compilation unit might have
5770 inter-compilation-unit references. If we don't know what form
5771 this attribute will have, then it might potentially be a
5772 DW_FORM_ref_addr, so we conservatively expect inter-CU
5775 if (abbrev_form
== DW_FORM_ref_addr
5776 || abbrev_form
== DW_FORM_indirect
)
5777 cu
->has_form_ref_addr
= 1;
5779 cur_attrs
[cur_abbrev
->num_attrs
].name
= abbrev_name
;
5780 cur_attrs
[cur_abbrev
->num_attrs
++].form
= abbrev_form
;
5781 abbrev_name
= read_unsigned_leb128 (abfd
, abbrev_ptr
, &bytes_read
);
5782 abbrev_ptr
+= bytes_read
;
5783 abbrev_form
= read_unsigned_leb128 (abfd
, abbrev_ptr
, &bytes_read
);
5784 abbrev_ptr
+= bytes_read
;
5787 cur_abbrev
->attrs
= obstack_alloc (&cu
->abbrev_obstack
,
5788 (cur_abbrev
->num_attrs
5789 * sizeof (struct attr_abbrev
)));
5790 memcpy (cur_abbrev
->attrs
, cur_attrs
,
5791 cur_abbrev
->num_attrs
* sizeof (struct attr_abbrev
));
5793 hash_number
= abbrev_number
% ABBREV_HASH_SIZE
;
5794 cur_abbrev
->next
= cu
->dwarf2_abbrevs
[hash_number
];
5795 cu
->dwarf2_abbrevs
[hash_number
] = cur_abbrev
;
5797 /* Get next abbreviation.
5798 Under Irix6 the abbreviations for a compilation unit are not
5799 always properly terminated with an abbrev number of 0.
5800 Exit loop if we encounter an abbreviation which we have
5801 already read (which means we are about to read the abbreviations
5802 for the next compile unit) or if the end of the abbreviation
5803 table is reached. */
5804 if ((unsigned int) (abbrev_ptr
- dwarf2_per_objfile
->abbrev
.buffer
)
5805 >= dwarf2_per_objfile
->abbrev
.size
)
5807 abbrev_number
= read_unsigned_leb128 (abfd
, abbrev_ptr
, &bytes_read
);
5808 abbrev_ptr
+= bytes_read
;
5809 if (dwarf2_lookup_abbrev (abbrev_number
, cu
) != NULL
)
5816 /* Release the memory used by the abbrev table for a compilation unit. */
5819 dwarf2_free_abbrev_table (void *ptr_to_cu
)
5821 struct dwarf2_cu
*cu
= ptr_to_cu
;
5823 obstack_free (&cu
->abbrev_obstack
, NULL
);
5824 cu
->dwarf2_abbrevs
= NULL
;
5827 /* Lookup an abbrev_info structure in the abbrev hash table. */
5829 static struct abbrev_info
*
5830 dwarf2_lookup_abbrev (unsigned int number
, struct dwarf2_cu
*cu
)
5832 unsigned int hash_number
;
5833 struct abbrev_info
*abbrev
;
5835 hash_number
= number
% ABBREV_HASH_SIZE
;
5836 abbrev
= cu
->dwarf2_abbrevs
[hash_number
];
5840 if (abbrev
->number
== number
)
5843 abbrev
= abbrev
->next
;
5848 /* Returns nonzero if TAG represents a type that we might generate a partial
5852 is_type_tag_for_partial (int tag
)
5857 /* Some types that would be reasonable to generate partial symbols for,
5858 that we don't at present. */
5859 case DW_TAG_array_type
:
5860 case DW_TAG_file_type
:
5861 case DW_TAG_ptr_to_member_type
:
5862 case DW_TAG_set_type
:
5863 case DW_TAG_string_type
:
5864 case DW_TAG_subroutine_type
:
5866 case DW_TAG_base_type
:
5867 case DW_TAG_class_type
:
5868 case DW_TAG_interface_type
:
5869 case DW_TAG_enumeration_type
:
5870 case DW_TAG_structure_type
:
5871 case DW_TAG_subrange_type
:
5872 case DW_TAG_typedef
:
5873 case DW_TAG_union_type
:
5880 /* Load all DIEs that are interesting for partial symbols into memory. */
5882 static struct partial_die_info
*
5883 load_partial_dies (bfd
*abfd
, gdb_byte
*info_ptr
, int building_psymtab
,
5884 struct dwarf2_cu
*cu
)
5886 struct partial_die_info
*part_die
;
5887 struct partial_die_info
*parent_die
, *last_die
, *first_die
= NULL
;
5888 struct abbrev_info
*abbrev
;
5889 unsigned int bytes_read
;
5890 unsigned int load_all
= 0;
5892 int nesting_level
= 1;
5897 if (cu
->per_cu
&& cu
->per_cu
->load_all_dies
)
5901 = htab_create_alloc_ex (cu
->header
.length
/ 12,
5905 &cu
->comp_unit_obstack
,
5906 hashtab_obstack_allocate
,
5907 dummy_obstack_deallocate
);
5909 part_die
= obstack_alloc (&cu
->comp_unit_obstack
,
5910 sizeof (struct partial_die_info
));
5914 abbrev
= peek_die_abbrev (info_ptr
, &bytes_read
, cu
);
5916 /* A NULL abbrev means the end of a series of children. */
5919 if (--nesting_level
== 0)
5921 /* PART_DIE was probably the last thing allocated on the
5922 comp_unit_obstack, so we could call obstack_free
5923 here. We don't do that because the waste is small,
5924 and will be cleaned up when we're done with this
5925 compilation unit. This way, we're also more robust
5926 against other users of the comp_unit_obstack. */
5929 info_ptr
+= bytes_read
;
5930 last_die
= parent_die
;
5931 parent_die
= parent_die
->die_parent
;
5935 /* Check whether this DIE is interesting enough to save. Normally
5936 we would not be interested in members here, but there may be
5937 later variables referencing them via DW_AT_specification (for
5940 && !is_type_tag_for_partial (abbrev
->tag
)
5941 && abbrev
->tag
!= DW_TAG_enumerator
5942 && abbrev
->tag
!= DW_TAG_subprogram
5943 && abbrev
->tag
!= DW_TAG_lexical_block
5944 && abbrev
->tag
!= DW_TAG_variable
5945 && abbrev
->tag
!= DW_TAG_namespace
5946 && abbrev
->tag
!= DW_TAG_member
)
5948 /* Otherwise we skip to the next sibling, if any. */
5949 info_ptr
= skip_one_die (info_ptr
+ bytes_read
, abbrev
, cu
);
5953 info_ptr
= read_partial_die (part_die
, abbrev
, bytes_read
,
5954 abfd
, info_ptr
, cu
);
5956 /* This two-pass algorithm for processing partial symbols has a
5957 high cost in cache pressure. Thus, handle some simple cases
5958 here which cover the majority of C partial symbols. DIEs
5959 which neither have specification tags in them, nor could have
5960 specification tags elsewhere pointing at them, can simply be
5961 processed and discarded.
5963 This segment is also optional; scan_partial_symbols and
5964 add_partial_symbol will handle these DIEs if we chain
5965 them in normally. When compilers which do not emit large
5966 quantities of duplicate debug information are more common,
5967 this code can probably be removed. */
5969 /* Any complete simple types at the top level (pretty much all
5970 of them, for a language without namespaces), can be processed
5972 if (parent_die
== NULL
5973 && part_die
->has_specification
== 0
5974 && part_die
->is_declaration
== 0
5975 && (part_die
->tag
== DW_TAG_typedef
5976 || part_die
->tag
== DW_TAG_base_type
5977 || part_die
->tag
== DW_TAG_subrange_type
))
5979 if (building_psymtab
&& part_die
->name
!= NULL
)
5980 add_psymbol_to_list (part_die
->name
, strlen (part_die
->name
),
5981 VAR_DOMAIN
, LOC_TYPEDEF
,
5982 &cu
->objfile
->static_psymbols
,
5983 0, (CORE_ADDR
) 0, cu
->language
, cu
->objfile
);
5984 info_ptr
= locate_pdi_sibling (part_die
, info_ptr
, abfd
, cu
);
5988 /* If we're at the second level, and we're an enumerator, and
5989 our parent has no specification (meaning possibly lives in a
5990 namespace elsewhere), then we can add the partial symbol now
5991 instead of queueing it. */
5992 if (part_die
->tag
== DW_TAG_enumerator
5993 && parent_die
!= NULL
5994 && parent_die
->die_parent
== NULL
5995 && parent_die
->tag
== DW_TAG_enumeration_type
5996 && parent_die
->has_specification
== 0)
5998 if (part_die
->name
== NULL
)
5999 complaint (&symfile_complaints
, _("malformed enumerator DIE ignored"));
6000 else if (building_psymtab
)
6001 add_psymbol_to_list (part_die
->name
, strlen (part_die
->name
),
6002 VAR_DOMAIN
, LOC_CONST
,
6003 (cu
->language
== language_cplus
6004 || cu
->language
== language_java
)
6005 ? &cu
->objfile
->global_psymbols
6006 : &cu
->objfile
->static_psymbols
,
6007 0, (CORE_ADDR
) 0, cu
->language
, cu
->objfile
);
6009 info_ptr
= locate_pdi_sibling (part_die
, info_ptr
, abfd
, cu
);
6013 /* We'll save this DIE so link it in. */
6014 part_die
->die_parent
= parent_die
;
6015 part_die
->die_sibling
= NULL
;
6016 part_die
->die_child
= NULL
;
6018 if (last_die
&& last_die
== parent_die
)
6019 last_die
->die_child
= part_die
;
6021 last_die
->die_sibling
= part_die
;
6023 last_die
= part_die
;
6025 if (first_die
== NULL
)
6026 first_die
= part_die
;
6028 /* Maybe add the DIE to the hash table. Not all DIEs that we
6029 find interesting need to be in the hash table, because we
6030 also have the parent/sibling/child chains; only those that we
6031 might refer to by offset later during partial symbol reading.
6033 For now this means things that might have be the target of a
6034 DW_AT_specification, DW_AT_abstract_origin, or
6035 DW_AT_extension. DW_AT_extension will refer only to
6036 namespaces; DW_AT_abstract_origin refers to functions (and
6037 many things under the function DIE, but we do not recurse
6038 into function DIEs during partial symbol reading) and
6039 possibly variables as well; DW_AT_specification refers to
6040 declarations. Declarations ought to have the DW_AT_declaration
6041 flag. It happens that GCC forgets to put it in sometimes, but
6042 only for functions, not for types.
6044 Adding more things than necessary to the hash table is harmless
6045 except for the performance cost. Adding too few will result in
6046 wasted time in find_partial_die, when we reread the compilation
6047 unit with load_all_dies set. */
6050 || abbrev
->tag
== DW_TAG_subprogram
6051 || abbrev
->tag
== DW_TAG_variable
6052 || abbrev
->tag
== DW_TAG_namespace
6053 || part_die
->is_declaration
)
6057 slot
= htab_find_slot_with_hash (cu
->partial_dies
, part_die
,
6058 part_die
->offset
, INSERT
);
6062 part_die
= obstack_alloc (&cu
->comp_unit_obstack
,
6063 sizeof (struct partial_die_info
));
6065 /* For some DIEs we want to follow their children (if any). For C
6066 we have no reason to follow the children of structures; for other
6067 languages we have to, both so that we can get at method physnames
6068 to infer fully qualified class names, and for DW_AT_specification.
6070 For Ada, we need to scan the children of subprograms and lexical
6071 blocks as well because Ada allows the definition of nested
6072 entities that could be interesting for the debugger, such as
6073 nested subprograms for instance. */
6074 if (last_die
->has_children
6076 || last_die
->tag
== DW_TAG_namespace
6077 || last_die
->tag
== DW_TAG_enumeration_type
6078 || (cu
->language
!= language_c
6079 && (last_die
->tag
== DW_TAG_class_type
6080 || last_die
->tag
== DW_TAG_interface_type
6081 || last_die
->tag
== DW_TAG_structure_type
6082 || last_die
->tag
== DW_TAG_union_type
))
6083 || (cu
->language
== language_ada
6084 && (last_die
->tag
== DW_TAG_subprogram
6085 || last_die
->tag
== DW_TAG_lexical_block
))))
6088 parent_die
= last_die
;
6092 /* Otherwise we skip to the next sibling, if any. */
6093 info_ptr
= locate_pdi_sibling (last_die
, info_ptr
, abfd
, cu
);
6095 /* Back to the top, do it again. */
6099 /* Read a minimal amount of information into the minimal die structure. */
6102 read_partial_die (struct partial_die_info
*part_die
,
6103 struct abbrev_info
*abbrev
,
6104 unsigned int abbrev_len
, bfd
*abfd
,
6105 gdb_byte
*info_ptr
, struct dwarf2_cu
*cu
)
6107 unsigned int bytes_read
, i
;
6108 struct attribute attr
;
6109 int has_low_pc_attr
= 0;
6110 int has_high_pc_attr
= 0;
6111 CORE_ADDR base_address
= 0;
6115 base_address_low_pc
,
6116 /* Overrides BASE_ADDRESS_LOW_PC. */
6117 base_address_entry_pc
6119 base_address_type
= base_address_none
;
6121 memset (part_die
, 0, sizeof (struct partial_die_info
));
6123 part_die
->offset
= info_ptr
- dwarf2_per_objfile
->info
.buffer
;
6125 info_ptr
+= abbrev_len
;
6130 part_die
->tag
= abbrev
->tag
;
6131 part_die
->has_children
= abbrev
->has_children
;
6133 for (i
= 0; i
< abbrev
->num_attrs
; ++i
)
6135 info_ptr
= read_attribute (&attr
, &abbrev
->attrs
[i
], abfd
, info_ptr
, cu
);
6137 /* Store the data if it is of an attribute we want to keep in a
6138 partial symbol table. */
6142 switch (part_die
->tag
)
6144 case DW_TAG_compile_unit
:
6145 /* Compilation units have a DW_AT_name that is a filename, not
6146 a source language identifier. */
6147 case DW_TAG_enumeration_type
:
6148 case DW_TAG_enumerator
:
6149 /* These tags always have simple identifiers already; no need
6150 to canonicalize them. */
6151 part_die
->name
= DW_STRING (&attr
);
6155 = dwarf2_canonicalize_name (DW_STRING (&attr
), cu
,
6156 &cu
->comp_unit_obstack
);
6160 case DW_AT_comp_dir
:
6161 if (part_die
->dirname
== NULL
)
6162 part_die
->dirname
= DW_STRING (&attr
);
6164 case DW_AT_MIPS_linkage_name
:
6165 part_die
->name
= DW_STRING (&attr
);
6168 has_low_pc_attr
= 1;
6169 part_die
->lowpc
= DW_ADDR (&attr
);
6170 if (part_die
->tag
== DW_TAG_compile_unit
6171 && base_address_type
< base_address_low_pc
)
6173 base_address
= DW_ADDR (&attr
);
6174 base_address_type
= base_address_low_pc
;
6178 has_high_pc_attr
= 1;
6179 part_die
->highpc
= DW_ADDR (&attr
);
6181 case DW_AT_entry_pc
:
6182 if (part_die
->tag
== DW_TAG_compile_unit
6183 && base_address_type
< base_address_entry_pc
)
6185 base_address
= DW_ADDR (&attr
);
6186 base_address_type
= base_address_entry_pc
;
6190 if (part_die
->tag
== DW_TAG_compile_unit
)
6192 cu
->ranges_offset
= DW_UNSND (&attr
);
6193 cu
->has_ranges_offset
= 1;
6196 case DW_AT_location
:
6197 /* Support the .debug_loc offsets */
6198 if (attr_form_is_block (&attr
))
6200 part_die
->locdesc
= DW_BLOCK (&attr
);
6202 else if (attr_form_is_section_offset (&attr
))
6204 dwarf2_complex_location_expr_complaint ();
6208 dwarf2_invalid_attrib_class_complaint ("DW_AT_location",
6209 "partial symbol information");
6212 case DW_AT_language
:
6213 part_die
->language
= DW_UNSND (&attr
);
6215 case DW_AT_external
:
6216 part_die
->is_external
= DW_UNSND (&attr
);
6218 case DW_AT_declaration
:
6219 part_die
->is_declaration
= DW_UNSND (&attr
);
6222 part_die
->has_type
= 1;
6224 case DW_AT_abstract_origin
:
6225 case DW_AT_specification
:
6226 case DW_AT_extension
:
6227 part_die
->has_specification
= 1;
6228 part_die
->spec_offset
= dwarf2_get_ref_die_offset (&attr
);
6231 /* Ignore absolute siblings, they might point outside of
6232 the current compile unit. */
6233 if (attr
.form
== DW_FORM_ref_addr
)
6234 complaint (&symfile_complaints
, _("ignoring absolute DW_AT_sibling"));
6236 part_die
->sibling
= dwarf2_per_objfile
->info
.buffer
6237 + dwarf2_get_ref_die_offset (&attr
);
6239 case DW_AT_stmt_list
:
6240 part_die
->has_stmt_list
= 1;
6241 part_die
->line_offset
= DW_UNSND (&attr
);
6243 case DW_AT_byte_size
:
6244 part_die
->has_byte_size
= 1;
6246 case DW_AT_calling_convention
:
6247 /* DWARF doesn't provide a way to identify a program's source-level
6248 entry point. DW_AT_calling_convention attributes are only meant
6249 to describe functions' calling conventions.
6251 However, because it's a necessary piece of information in
6252 Fortran, and because DW_CC_program is the only piece of debugging
6253 information whose definition refers to a 'main program' at all,
6254 several compilers have begun marking Fortran main programs with
6255 DW_CC_program --- even when those functions use the standard
6256 calling conventions.
6258 So until DWARF specifies a way to provide this information and
6259 compilers pick up the new representation, we'll support this
6261 if (DW_UNSND (&attr
) == DW_CC_program
6262 && cu
->language
== language_fortran
)
6263 set_main_name (part_die
->name
);
6270 /* When using the GNU linker, .gnu.linkonce. sections are used to
6271 eliminate duplicate copies of functions and vtables and such.
6272 The linker will arbitrarily choose one and discard the others.
6273 The AT_*_pc values for such functions refer to local labels in
6274 these sections. If the section from that file was discarded, the
6275 labels are not in the output, so the relocs get a value of 0.
6276 If this is a discarded function, mark the pc bounds as invalid,
6277 so that GDB will ignore it. */
6278 if (has_low_pc_attr
&& has_high_pc_attr
6279 && part_die
->lowpc
< part_die
->highpc
6280 && (part_die
->lowpc
!= 0
6281 || dwarf2_per_objfile
->has_section_at_zero
))
6282 part_die
->has_pc_info
= 1;
6284 if (base_address_type
!= base_address_none
&& !cu
->base_known
)
6286 gdb_assert (part_die
->tag
== DW_TAG_compile_unit
);
6288 cu
->base_address
= base_address
;
6294 /* Find a cached partial DIE at OFFSET in CU. */
6296 static struct partial_die_info
*
6297 find_partial_die_in_comp_unit (unsigned int offset
, struct dwarf2_cu
*cu
)
6299 struct partial_die_info
*lookup_die
= NULL
;
6300 struct partial_die_info part_die
;
6302 part_die
.offset
= offset
;
6303 lookup_die
= htab_find_with_hash (cu
->partial_dies
, &part_die
, offset
);
6308 /* Find a partial DIE at OFFSET, which may or may not be in CU. */
6310 static struct partial_die_info
*
6311 find_partial_die (unsigned int offset
, struct dwarf2_cu
*cu
)
6313 struct dwarf2_per_cu_data
*per_cu
= NULL
;
6314 struct partial_die_info
*pd
= NULL
;
6316 if (offset_in_cu_p (&cu
->header
, offset
))
6318 pd
= find_partial_die_in_comp_unit (offset
, cu
);
6323 per_cu
= dwarf2_find_containing_comp_unit (offset
, cu
->objfile
);
6325 if (per_cu
->cu
== NULL
)
6327 load_comp_unit (per_cu
, cu
->objfile
);
6328 per_cu
->cu
->read_in_chain
= dwarf2_per_objfile
->read_in_chain
;
6329 dwarf2_per_objfile
->read_in_chain
= per_cu
;
6332 per_cu
->cu
->last_used
= 0;
6333 pd
= find_partial_die_in_comp_unit (offset
, per_cu
->cu
);
6335 if (pd
== NULL
&& per_cu
->load_all_dies
== 0)
6337 struct cleanup
*back_to
;
6338 struct partial_die_info comp_unit_die
;
6339 struct abbrev_info
*abbrev
;
6340 unsigned int bytes_read
;
6343 per_cu
->load_all_dies
= 1;
6345 /* Re-read the DIEs. */
6346 back_to
= make_cleanup (null_cleanup
, 0);
6347 if (per_cu
->cu
->dwarf2_abbrevs
== NULL
)
6349 dwarf2_read_abbrevs (per_cu
->cu
->objfile
->obfd
, per_cu
->cu
);
6350 back_to
= make_cleanup (dwarf2_free_abbrev_table
, per_cu
->cu
);
6352 info_ptr
= (dwarf2_per_objfile
->info
.buffer
6353 + per_cu
->cu
->header
.offset
6354 + per_cu
->cu
->header
.first_die_offset
);
6355 abbrev
= peek_die_abbrev (info_ptr
, &bytes_read
, per_cu
->cu
);
6356 info_ptr
= read_partial_die (&comp_unit_die
, abbrev
, bytes_read
,
6357 per_cu
->cu
->objfile
->obfd
, info_ptr
,
6359 if (comp_unit_die
.has_children
)
6360 load_partial_dies (per_cu
->cu
->objfile
->obfd
, info_ptr
, 0, per_cu
->cu
);
6361 do_cleanups (back_to
);
6363 pd
= find_partial_die_in_comp_unit (offset
, per_cu
->cu
);
6367 internal_error (__FILE__
, __LINE__
,
6368 _("could not find partial DIE 0x%x in cache [from module %s]\n"),
6369 offset
, bfd_get_filename (cu
->objfile
->obfd
));
6373 /* Adjust PART_DIE before generating a symbol for it. This function
6374 may set the is_external flag or change the DIE's name. */
6377 fixup_partial_die (struct partial_die_info
*part_die
,
6378 struct dwarf2_cu
*cu
)
6380 /* If we found a reference attribute and the DIE has no name, try
6381 to find a name in the referred to DIE. */
6383 if (part_die
->name
== NULL
&& part_die
->has_specification
)
6385 struct partial_die_info
*spec_die
;
6387 spec_die
= find_partial_die (part_die
->spec_offset
, cu
);
6389 fixup_partial_die (spec_die
, cu
);
6393 part_die
->name
= spec_die
->name
;
6395 /* Copy DW_AT_external attribute if it is set. */
6396 if (spec_die
->is_external
)
6397 part_die
->is_external
= spec_die
->is_external
;
6401 /* Set default names for some unnamed DIEs. */
6402 if (part_die
->name
== NULL
&& (part_die
->tag
== DW_TAG_structure_type
6403 || part_die
->tag
== DW_TAG_class_type
))
6404 part_die
->name
= "(anonymous class)";
6406 if (part_die
->name
== NULL
&& part_die
->tag
== DW_TAG_namespace
)
6407 part_die
->name
= "(anonymous namespace)";
6409 if (part_die
->tag
== DW_TAG_structure_type
6410 || part_die
->tag
== DW_TAG_class_type
6411 || part_die
->tag
== DW_TAG_union_type
)
6412 guess_structure_name (part_die
, cu
);
6415 /* Read the die from the .debug_info section buffer. Set DIEP to
6416 point to a newly allocated die with its information, except for its
6417 child, sibling, and parent fields. Set HAS_CHILDREN to tell
6418 whether the die has children or not. */
6421 read_full_die (struct die_info
**diep
, bfd
*abfd
, gdb_byte
*info_ptr
,
6422 struct dwarf2_cu
*cu
, int *has_children
)
6424 unsigned int abbrev_number
, bytes_read
, i
, offset
;
6425 struct abbrev_info
*abbrev
;
6426 struct die_info
*die
;
6428 offset
= info_ptr
- dwarf2_per_objfile
->info
.buffer
;
6429 abbrev_number
= read_unsigned_leb128 (abfd
, info_ptr
, &bytes_read
);
6430 info_ptr
+= bytes_read
;
6438 abbrev
= dwarf2_lookup_abbrev (abbrev_number
, cu
);
6441 error (_("Dwarf Error: could not find abbrev number %d [in module %s]"),
6443 bfd_get_filename (abfd
));
6445 die
= dwarf_alloc_die (cu
, abbrev
->num_attrs
);
6446 die
->offset
= offset
;
6447 die
->tag
= abbrev
->tag
;
6448 die
->abbrev
= abbrev_number
;
6450 die
->num_attrs
= abbrev
->num_attrs
;
6452 for (i
= 0; i
< abbrev
->num_attrs
; ++i
)
6453 info_ptr
= read_attribute (&die
->attrs
[i
], &abbrev
->attrs
[i
],
6454 abfd
, info_ptr
, cu
);
6457 *has_children
= abbrev
->has_children
;
6461 /* Read an attribute value described by an attribute form. */
6464 read_attribute_value (struct attribute
*attr
, unsigned form
,
6465 bfd
*abfd
, gdb_byte
*info_ptr
,
6466 struct dwarf2_cu
*cu
)
6468 struct comp_unit_head
*cu_header
= &cu
->header
;
6469 unsigned int bytes_read
;
6470 struct dwarf_block
*blk
;
6476 case DW_FORM_ref_addr
:
6477 DW_ADDR (attr
) = read_address (abfd
, info_ptr
, cu
, &bytes_read
);
6478 info_ptr
+= bytes_read
;
6480 case DW_FORM_block2
:
6481 blk
= dwarf_alloc_block (cu
);
6482 blk
->size
= read_2_bytes (abfd
, info_ptr
);
6484 blk
->data
= read_n_bytes (abfd
, info_ptr
, blk
->size
);
6485 info_ptr
+= blk
->size
;
6486 DW_BLOCK (attr
) = blk
;
6488 case DW_FORM_block4
:
6489 blk
= dwarf_alloc_block (cu
);
6490 blk
->size
= read_4_bytes (abfd
, info_ptr
);
6492 blk
->data
= read_n_bytes (abfd
, info_ptr
, blk
->size
);
6493 info_ptr
+= blk
->size
;
6494 DW_BLOCK (attr
) = blk
;
6497 DW_UNSND (attr
) = read_2_bytes (abfd
, info_ptr
);
6501 DW_UNSND (attr
) = read_4_bytes (abfd
, info_ptr
);
6505 DW_UNSND (attr
) = read_8_bytes (abfd
, info_ptr
);
6508 case DW_FORM_string
:
6509 DW_STRING (attr
) = read_string (abfd
, info_ptr
, &bytes_read
);
6510 info_ptr
+= bytes_read
;
6513 DW_STRING (attr
) = read_indirect_string (abfd
, info_ptr
, cu_header
,
6515 info_ptr
+= bytes_read
;
6518 blk
= dwarf_alloc_block (cu
);
6519 blk
->size
= read_unsigned_leb128 (abfd
, info_ptr
, &bytes_read
);
6520 info_ptr
+= bytes_read
;
6521 blk
->data
= read_n_bytes (abfd
, info_ptr
, blk
->size
);
6522 info_ptr
+= blk
->size
;
6523 DW_BLOCK (attr
) = blk
;
6525 case DW_FORM_block1
:
6526 blk
= dwarf_alloc_block (cu
);
6527 blk
->size
= read_1_byte (abfd
, info_ptr
);
6529 blk
->data
= read_n_bytes (abfd
, info_ptr
, blk
->size
);
6530 info_ptr
+= blk
->size
;
6531 DW_BLOCK (attr
) = blk
;
6534 DW_UNSND (attr
) = read_1_byte (abfd
, info_ptr
);
6538 DW_UNSND (attr
) = read_1_byte (abfd
, info_ptr
);
6542 DW_SND (attr
) = read_signed_leb128 (abfd
, info_ptr
, &bytes_read
);
6543 info_ptr
+= bytes_read
;
6546 DW_UNSND (attr
) = read_unsigned_leb128 (abfd
, info_ptr
, &bytes_read
);
6547 info_ptr
+= bytes_read
;
6550 DW_ADDR (attr
) = cu
->header
.offset
+ read_1_byte (abfd
, info_ptr
);
6554 DW_ADDR (attr
) = cu
->header
.offset
+ read_2_bytes (abfd
, info_ptr
);
6558 DW_ADDR (attr
) = cu
->header
.offset
+ read_4_bytes (abfd
, info_ptr
);
6562 DW_ADDR (attr
) = cu
->header
.offset
+ read_8_bytes (abfd
, info_ptr
);
6565 case DW_FORM_ref_udata
:
6566 DW_ADDR (attr
) = (cu
->header
.offset
6567 + read_unsigned_leb128 (abfd
, info_ptr
, &bytes_read
));
6568 info_ptr
+= bytes_read
;
6570 case DW_FORM_indirect
:
6571 form
= read_unsigned_leb128 (abfd
, info_ptr
, &bytes_read
);
6572 info_ptr
+= bytes_read
;
6573 info_ptr
= read_attribute_value (attr
, form
, abfd
, info_ptr
, cu
);
6576 error (_("Dwarf Error: Cannot handle %s in DWARF reader [in module %s]"),
6577 dwarf_form_name (form
),
6578 bfd_get_filename (abfd
));
6581 /* We have seen instances where the compiler tried to emit a byte
6582 size attribute of -1 which ended up being encoded as an unsigned
6583 0xffffffff. Although 0xffffffff is technically a valid size value,
6584 an object of this size seems pretty unlikely so we can relatively
6585 safely treat these cases as if the size attribute was invalid and
6586 treat them as zero by default. */
6587 if (attr
->name
== DW_AT_byte_size
6588 && form
== DW_FORM_data4
6589 && DW_UNSND (attr
) >= 0xffffffff)
6592 (&symfile_complaints
,
6593 _("Suspicious DW_AT_byte_size value treated as zero instead of 0x%lx"),
6595 DW_UNSND (attr
) = 0;
6601 /* Read an attribute described by an abbreviated attribute. */
6604 read_attribute (struct attribute
*attr
, struct attr_abbrev
*abbrev
,
6605 bfd
*abfd
, gdb_byte
*info_ptr
, struct dwarf2_cu
*cu
)
6607 attr
->name
= abbrev
->name
;
6608 return read_attribute_value (attr
, abbrev
->form
, abfd
, info_ptr
, cu
);
6611 /* read dwarf information from a buffer */
6614 read_1_byte (bfd
*abfd
, gdb_byte
*buf
)
6616 return bfd_get_8 (abfd
, buf
);
6620 read_1_signed_byte (bfd
*abfd
, gdb_byte
*buf
)
6622 return bfd_get_signed_8 (abfd
, buf
);
6626 read_2_bytes (bfd
*abfd
, gdb_byte
*buf
)
6628 return bfd_get_16 (abfd
, buf
);
6632 read_2_signed_bytes (bfd
*abfd
, gdb_byte
*buf
)
6634 return bfd_get_signed_16 (abfd
, buf
);
6638 read_4_bytes (bfd
*abfd
, gdb_byte
*buf
)
6640 return bfd_get_32 (abfd
, buf
);
6644 read_4_signed_bytes (bfd
*abfd
, gdb_byte
*buf
)
6646 return bfd_get_signed_32 (abfd
, buf
);
6649 static unsigned long
6650 read_8_bytes (bfd
*abfd
, gdb_byte
*buf
)
6652 return bfd_get_64 (abfd
, buf
);
6656 read_address (bfd
*abfd
, gdb_byte
*buf
, struct dwarf2_cu
*cu
,
6657 unsigned int *bytes_read
)
6659 struct comp_unit_head
*cu_header
= &cu
->header
;
6660 CORE_ADDR retval
= 0;
6662 if (cu_header
->signed_addr_p
)
6664 switch (cu_header
->addr_size
)
6667 retval
= bfd_get_signed_16 (abfd
, buf
);
6670 retval
= bfd_get_signed_32 (abfd
, buf
);
6673 retval
= bfd_get_signed_64 (abfd
, buf
);
6676 internal_error (__FILE__
, __LINE__
,
6677 _("read_address: bad switch, signed [in module %s]"),
6678 bfd_get_filename (abfd
));
6683 switch (cu_header
->addr_size
)
6686 retval
= bfd_get_16 (abfd
, buf
);
6689 retval
= bfd_get_32 (abfd
, buf
);
6692 retval
= bfd_get_64 (abfd
, buf
);
6695 internal_error (__FILE__
, __LINE__
,
6696 _("read_address: bad switch, unsigned [in module %s]"),
6697 bfd_get_filename (abfd
));
6701 *bytes_read
= cu_header
->addr_size
;
6705 /* Read the initial length from a section. The (draft) DWARF 3
6706 specification allows the initial length to take up either 4 bytes
6707 or 12 bytes. If the first 4 bytes are 0xffffffff, then the next 8
6708 bytes describe the length and all offsets will be 8 bytes in length
6711 An older, non-standard 64-bit format is also handled by this
6712 function. The older format in question stores the initial length
6713 as an 8-byte quantity without an escape value. Lengths greater
6714 than 2^32 aren't very common which means that the initial 4 bytes
6715 is almost always zero. Since a length value of zero doesn't make
6716 sense for the 32-bit format, this initial zero can be considered to
6717 be an escape value which indicates the presence of the older 64-bit
6718 format. As written, the code can't detect (old format) lengths
6719 greater than 4GB. If it becomes necessary to handle lengths
6720 somewhat larger than 4GB, we could allow other small values (such
6721 as the non-sensical values of 1, 2, and 3) to also be used as
6722 escape values indicating the presence of the old format.
6724 The value returned via bytes_read should be used to increment the
6725 relevant pointer after calling read_initial_length().
6727 [ Note: read_initial_length() and read_offset() are based on the
6728 document entitled "DWARF Debugging Information Format", revision
6729 3, draft 8, dated November 19, 2001. This document was obtained
6732 http://reality.sgiweb.org/davea/dwarf3-draft8-011125.pdf
6734 This document is only a draft and is subject to change. (So beware.)
6736 Details regarding the older, non-standard 64-bit format were
6737 determined empirically by examining 64-bit ELF files produced by
6738 the SGI toolchain on an IRIX 6.5 machine.
6740 - Kevin, July 16, 2002
6744 read_initial_length (bfd
*abfd
, gdb_byte
*buf
, unsigned int *bytes_read
)
6746 LONGEST length
= bfd_get_32 (abfd
, buf
);
6748 if (length
== 0xffffffff)
6750 length
= bfd_get_64 (abfd
, buf
+ 4);
6753 else if (length
== 0)
6755 /* Handle the (non-standard) 64-bit DWARF2 format used by IRIX. */
6756 length
= bfd_get_64 (abfd
, buf
);
6767 /* Cover function for read_initial_length.
6768 Returns the length of the object at BUF, and stores the size of the
6769 initial length in *BYTES_READ and stores the size that offsets will be in
6771 If the initial length size is not equivalent to that specified in
6772 CU_HEADER then issue a complaint.
6773 This is useful when reading non-comp-unit headers. */
6776 read_checked_initial_length_and_offset (bfd
*abfd
, gdb_byte
*buf
,
6777 const struct comp_unit_head
*cu_header
,
6778 unsigned int *bytes_read
,
6779 unsigned int *offset_size
)
6781 LONGEST length
= read_initial_length (abfd
, buf
, bytes_read
);
6783 gdb_assert (cu_header
->initial_length_size
== 4
6784 || cu_header
->initial_length_size
== 8
6785 || cu_header
->initial_length_size
== 12);
6787 if (cu_header
->initial_length_size
!= *bytes_read
)
6788 complaint (&symfile_complaints
,
6789 _("intermixed 32-bit and 64-bit DWARF sections"));
6791 *offset_size
= (*bytes_read
== 4) ? 4 : 8;
6795 /* Read an offset from the data stream. The size of the offset is
6796 given by cu_header->offset_size. */
6799 read_offset (bfd
*abfd
, gdb_byte
*buf
, const struct comp_unit_head
*cu_header
,
6800 unsigned int *bytes_read
)
6802 LONGEST offset
= read_offset_1 (abfd
, buf
, cu_header
->offset_size
);
6803 *bytes_read
= cu_header
->offset_size
;
6807 /* Read an offset from the data stream. */
6810 read_offset_1 (bfd
*abfd
, gdb_byte
*buf
, unsigned int offset_size
)
6814 switch (offset_size
)
6817 retval
= bfd_get_32 (abfd
, buf
);
6820 retval
= bfd_get_64 (abfd
, buf
);
6823 internal_error (__FILE__
, __LINE__
,
6824 _("read_offset_1: bad switch [in module %s]"),
6825 bfd_get_filename (abfd
));
6832 read_n_bytes (bfd
*abfd
, gdb_byte
*buf
, unsigned int size
)
6834 /* If the size of a host char is 8 bits, we can return a pointer
6835 to the buffer, otherwise we have to copy the data to a buffer
6836 allocated on the temporary obstack. */
6837 gdb_assert (HOST_CHAR_BIT
== 8);
6842 read_string (bfd
*abfd
, gdb_byte
*buf
, unsigned int *bytes_read_ptr
)
6844 /* If the size of a host char is 8 bits, we can return a pointer
6845 to the string, otherwise we have to copy the string to a buffer
6846 allocated on the temporary obstack. */
6847 gdb_assert (HOST_CHAR_BIT
== 8);
6850 *bytes_read_ptr
= 1;
6853 *bytes_read_ptr
= strlen ((char *) buf
) + 1;
6854 return (char *) buf
;
6858 read_indirect_string (bfd
*abfd
, gdb_byte
*buf
,
6859 const struct comp_unit_head
*cu_header
,
6860 unsigned int *bytes_read_ptr
)
6862 LONGEST str_offset
= read_offset (abfd
, buf
, cu_header
, bytes_read_ptr
);
6864 if (dwarf2_per_objfile
->str
.buffer
== NULL
)
6866 error (_("DW_FORM_strp used without .debug_str section [in module %s]"),
6867 bfd_get_filename (abfd
));
6870 if (str_offset
>= dwarf2_per_objfile
->str
.size
)
6872 error (_("DW_FORM_strp pointing outside of .debug_str section [in module %s]"),
6873 bfd_get_filename (abfd
));
6876 gdb_assert (HOST_CHAR_BIT
== 8);
6877 if (dwarf2_per_objfile
->str
.buffer
[str_offset
] == '\0')
6879 return (char *) (dwarf2_per_objfile
->str
.buffer
+ str_offset
);
6882 static unsigned long
6883 read_unsigned_leb128 (bfd
*abfd
, gdb_byte
*buf
, unsigned int *bytes_read_ptr
)
6885 unsigned long result
;
6886 unsigned int num_read
;
6896 byte
= bfd_get_8 (abfd
, buf
);
6899 result
|= ((unsigned long)(byte
& 127) << shift
);
6900 if ((byte
& 128) == 0)
6906 *bytes_read_ptr
= num_read
;
6911 read_signed_leb128 (bfd
*abfd
, gdb_byte
*buf
, unsigned int *bytes_read_ptr
)
6914 int i
, shift
, num_read
;
6923 byte
= bfd_get_8 (abfd
, buf
);
6926 result
|= ((long)(byte
& 127) << shift
);
6928 if ((byte
& 128) == 0)
6933 if ((shift
< 8 * sizeof (result
)) && (byte
& 0x40))
6934 result
|= -(((long)1) << shift
);
6935 *bytes_read_ptr
= num_read
;
6939 /* Return a pointer to just past the end of an LEB128 number in BUF. */
6942 skip_leb128 (bfd
*abfd
, gdb_byte
*buf
)
6948 byte
= bfd_get_8 (abfd
, buf
);
6950 if ((byte
& 128) == 0)
6956 set_cu_language (unsigned int lang
, struct dwarf2_cu
*cu
)
6963 cu
->language
= language_c
;
6965 case DW_LANG_C_plus_plus
:
6966 cu
->language
= language_cplus
;
6968 case DW_LANG_Fortran77
:
6969 case DW_LANG_Fortran90
:
6970 case DW_LANG_Fortran95
:
6971 cu
->language
= language_fortran
;
6973 case DW_LANG_Mips_Assembler
:
6974 cu
->language
= language_asm
;
6977 cu
->language
= language_java
;
6981 cu
->language
= language_ada
;
6983 case DW_LANG_Modula2
:
6984 cu
->language
= language_m2
;
6986 case DW_LANG_Pascal83
:
6987 cu
->language
= language_pascal
;
6990 cu
->language
= language_objc
;
6992 case DW_LANG_Cobol74
:
6993 case DW_LANG_Cobol85
:
6995 cu
->language
= language_minimal
;
6998 cu
->language_defn
= language_def (cu
->language
);
7001 /* Return the named attribute or NULL if not there. */
7003 static struct attribute
*
7004 dwarf2_attr (struct die_info
*die
, unsigned int name
, struct dwarf2_cu
*cu
)
7007 struct attribute
*spec
= NULL
;
7009 for (i
= 0; i
< die
->num_attrs
; ++i
)
7011 if (die
->attrs
[i
].name
== name
)
7012 return &die
->attrs
[i
];
7013 if (die
->attrs
[i
].name
== DW_AT_specification
7014 || die
->attrs
[i
].name
== DW_AT_abstract_origin
)
7015 spec
= &die
->attrs
[i
];
7020 die
= follow_die_ref (die
, spec
, &cu
);
7021 return dwarf2_attr (die
, name
, cu
);
7027 /* Return non-zero iff the attribute NAME is defined for the given DIE,
7028 and holds a non-zero value. This function should only be used for
7029 DW_FORM_flag attributes. */
7032 dwarf2_flag_true_p (struct die_info
*die
, unsigned name
, struct dwarf2_cu
*cu
)
7034 struct attribute
*attr
= dwarf2_attr (die
, name
, cu
);
7036 return (attr
&& DW_UNSND (attr
));
7040 die_is_declaration (struct die_info
*die
, struct dwarf2_cu
*cu
)
7042 /* A DIE is a declaration if it has a DW_AT_declaration attribute
7043 which value is non-zero. However, we have to be careful with
7044 DIEs having a DW_AT_specification attribute, because dwarf2_attr()
7045 (via dwarf2_flag_true_p) follows this attribute. So we may
7046 end up accidently finding a declaration attribute that belongs
7047 to a different DIE referenced by the specification attribute,
7048 even though the given DIE does not have a declaration attribute. */
7049 return (dwarf2_flag_true_p (die
, DW_AT_declaration
, cu
)
7050 && dwarf2_attr (die
, DW_AT_specification
, cu
) == NULL
);
7053 /* Return the die giving the specification for DIE, if there is
7054 one. *SPEC_CU is the CU containing DIE on input, and the CU
7055 containing the return value on output. If there is no
7056 specification, but there is an abstract origin, that is
7059 static struct die_info
*
7060 die_specification (struct die_info
*die
, struct dwarf2_cu
**spec_cu
)
7062 struct attribute
*spec_attr
= dwarf2_attr (die
, DW_AT_specification
,
7065 if (spec_attr
== NULL
)
7066 spec_attr
= dwarf2_attr (die
, DW_AT_abstract_origin
, *spec_cu
);
7068 if (spec_attr
== NULL
)
7071 return follow_die_ref (die
, spec_attr
, spec_cu
);
7074 /* Free the line_header structure *LH, and any arrays and strings it
7077 free_line_header (struct line_header
*lh
)
7079 if (lh
->standard_opcode_lengths
)
7080 xfree (lh
->standard_opcode_lengths
);
7082 /* Remember that all the lh->file_names[i].name pointers are
7083 pointers into debug_line_buffer, and don't need to be freed. */
7085 xfree (lh
->file_names
);
7087 /* Similarly for the include directory names. */
7088 if (lh
->include_dirs
)
7089 xfree (lh
->include_dirs
);
7095 /* Add an entry to LH's include directory table. */
7097 add_include_dir (struct line_header
*lh
, char *include_dir
)
7099 /* Grow the array if necessary. */
7100 if (lh
->include_dirs_size
== 0)
7102 lh
->include_dirs_size
= 1; /* for testing */
7103 lh
->include_dirs
= xmalloc (lh
->include_dirs_size
7104 * sizeof (*lh
->include_dirs
));
7106 else if (lh
->num_include_dirs
>= lh
->include_dirs_size
)
7108 lh
->include_dirs_size
*= 2;
7109 lh
->include_dirs
= xrealloc (lh
->include_dirs
,
7110 (lh
->include_dirs_size
7111 * sizeof (*lh
->include_dirs
)));
7114 lh
->include_dirs
[lh
->num_include_dirs
++] = include_dir
;
7118 /* Add an entry to LH's file name table. */
7120 add_file_name (struct line_header
*lh
,
7122 unsigned int dir_index
,
7123 unsigned int mod_time
,
7124 unsigned int length
)
7126 struct file_entry
*fe
;
7128 /* Grow the array if necessary. */
7129 if (lh
->file_names_size
== 0)
7131 lh
->file_names_size
= 1; /* for testing */
7132 lh
->file_names
= xmalloc (lh
->file_names_size
7133 * sizeof (*lh
->file_names
));
7135 else if (lh
->num_file_names
>= lh
->file_names_size
)
7137 lh
->file_names_size
*= 2;
7138 lh
->file_names
= xrealloc (lh
->file_names
,
7139 (lh
->file_names_size
7140 * sizeof (*lh
->file_names
)));
7143 fe
= &lh
->file_names
[lh
->num_file_names
++];
7145 fe
->dir_index
= dir_index
;
7146 fe
->mod_time
= mod_time
;
7147 fe
->length
= length
;
7153 /* Read the statement program header starting at OFFSET in
7154 .debug_line, according to the endianness of ABFD. Return a pointer
7155 to a struct line_header, allocated using xmalloc.
7157 NOTE: the strings in the include directory and file name tables of
7158 the returned object point into debug_line_buffer, and must not be
7160 static struct line_header
*
7161 dwarf_decode_line_header (unsigned int offset
, bfd
*abfd
,
7162 struct dwarf2_cu
*cu
)
7164 struct cleanup
*back_to
;
7165 struct line_header
*lh
;
7167 unsigned int bytes_read
, offset_size
;
7169 char *cur_dir
, *cur_file
;
7171 if (dwarf2_per_objfile
->line
.buffer
== NULL
)
7173 complaint (&symfile_complaints
, _("missing .debug_line section"));
7177 /* Make sure that at least there's room for the total_length field.
7178 That could be 12 bytes long, but we're just going to fudge that. */
7179 if (offset
+ 4 >= dwarf2_per_objfile
->line
.size
)
7181 dwarf2_statement_list_fits_in_line_number_section_complaint ();
7185 lh
= xmalloc (sizeof (*lh
));
7186 memset (lh
, 0, sizeof (*lh
));
7187 back_to
= make_cleanup ((make_cleanup_ftype
*) free_line_header
,
7190 line_ptr
= dwarf2_per_objfile
->line
.buffer
+ offset
;
7192 /* Read in the header. */
7194 read_checked_initial_length_and_offset (abfd
, line_ptr
, &cu
->header
,
7195 &bytes_read
, &offset_size
);
7196 line_ptr
+= bytes_read
;
7197 if (line_ptr
+ lh
->total_length
> (dwarf2_per_objfile
->line
.buffer
7198 + dwarf2_per_objfile
->line
.size
))
7200 dwarf2_statement_list_fits_in_line_number_section_complaint ();
7203 lh
->statement_program_end
= line_ptr
+ lh
->total_length
;
7204 lh
->version
= read_2_bytes (abfd
, line_ptr
);
7206 lh
->header_length
= read_offset_1 (abfd
, line_ptr
, offset_size
);
7207 line_ptr
+= offset_size
;
7208 lh
->minimum_instruction_length
= read_1_byte (abfd
, line_ptr
);
7210 lh
->default_is_stmt
= read_1_byte (abfd
, line_ptr
);
7212 lh
->line_base
= read_1_signed_byte (abfd
, line_ptr
);
7214 lh
->line_range
= read_1_byte (abfd
, line_ptr
);
7216 lh
->opcode_base
= read_1_byte (abfd
, line_ptr
);
7218 lh
->standard_opcode_lengths
7219 = xmalloc (lh
->opcode_base
* sizeof (lh
->standard_opcode_lengths
[0]));
7221 lh
->standard_opcode_lengths
[0] = 1; /* This should never be used anyway. */
7222 for (i
= 1; i
< lh
->opcode_base
; ++i
)
7224 lh
->standard_opcode_lengths
[i
] = read_1_byte (abfd
, line_ptr
);
7228 /* Read directory table. */
7229 while ((cur_dir
= read_string (abfd
, line_ptr
, &bytes_read
)) != NULL
)
7231 line_ptr
+= bytes_read
;
7232 add_include_dir (lh
, cur_dir
);
7234 line_ptr
+= bytes_read
;
7236 /* Read file name table. */
7237 while ((cur_file
= read_string (abfd
, line_ptr
, &bytes_read
)) != NULL
)
7239 unsigned int dir_index
, mod_time
, length
;
7241 line_ptr
+= bytes_read
;
7242 dir_index
= read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
7243 line_ptr
+= bytes_read
;
7244 mod_time
= read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
7245 line_ptr
+= bytes_read
;
7246 length
= read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
7247 line_ptr
+= bytes_read
;
7249 add_file_name (lh
, cur_file
, dir_index
, mod_time
, length
);
7251 line_ptr
+= bytes_read
;
7252 lh
->statement_program_start
= line_ptr
;
7254 if (line_ptr
> (dwarf2_per_objfile
->line
.buffer
7255 + dwarf2_per_objfile
->line
.size
))
7256 complaint (&symfile_complaints
,
7257 _("line number info header doesn't fit in `.debug_line' section"));
7259 discard_cleanups (back_to
);
7263 /* This function exists to work around a bug in certain compilers
7264 (particularly GCC 2.95), in which the first line number marker of a
7265 function does not show up until after the prologue, right before
7266 the second line number marker. This function shifts ADDRESS down
7267 to the beginning of the function if necessary, and is called on
7268 addresses passed to record_line. */
7271 check_cu_functions (CORE_ADDR address
, struct dwarf2_cu
*cu
)
7273 struct function_range
*fn
;
7275 /* Find the function_range containing address. */
7280 cu
->cached_fn
= cu
->first_fn
;
7284 if (fn
->lowpc
<= address
&& fn
->highpc
> address
)
7290 while (fn
&& fn
!= cu
->cached_fn
)
7291 if (fn
->lowpc
<= address
&& fn
->highpc
> address
)
7301 if (address
!= fn
->lowpc
)
7302 complaint (&symfile_complaints
,
7303 _("misplaced first line number at 0x%lx for '%s'"),
7304 (unsigned long) address
, fn
->name
);
7309 /* Decode the Line Number Program (LNP) for the given line_header
7310 structure and CU. The actual information extracted and the type
7311 of structures created from the LNP depends on the value of PST.
7313 1. If PST is NULL, then this procedure uses the data from the program
7314 to create all necessary symbol tables, and their linetables.
7315 The compilation directory of the file is passed in COMP_DIR,
7316 and must not be NULL.
7318 2. If PST is not NULL, this procedure reads the program to determine
7319 the list of files included by the unit represented by PST, and
7320 builds all the associated partial symbol tables. In this case,
7321 the value of COMP_DIR is ignored, and can thus be NULL (the COMP_DIR
7322 is not used to compute the full name of the symtab, and therefore
7323 omitting it when building the partial symtab does not introduce
7324 the potential for inconsistency - a partial symtab and its associated
7325 symbtab having a different fullname -). */
7328 dwarf_decode_lines (struct line_header
*lh
, char *comp_dir
, bfd
*abfd
,
7329 struct dwarf2_cu
*cu
, struct partial_symtab
*pst
)
7331 gdb_byte
*line_ptr
, *extended_end
;
7333 unsigned int bytes_read
, extended_len
;
7334 unsigned char op_code
, extended_op
, adj_opcode
;
7336 struct objfile
*objfile
= cu
->objfile
;
7337 struct gdbarch
*gdbarch
= get_objfile_arch (objfile
);
7338 const int decode_for_pst_p
= (pst
!= NULL
);
7339 struct subfile
*last_subfile
= NULL
, *first_subfile
= current_subfile
;
7341 baseaddr
= ANOFFSET (objfile
->section_offsets
, SECT_OFF_TEXT (objfile
));
7343 line_ptr
= lh
->statement_program_start
;
7344 line_end
= lh
->statement_program_end
;
7346 /* Read the statement sequences until there's nothing left. */
7347 while (line_ptr
< line_end
)
7349 /* state machine registers */
7350 CORE_ADDR address
= 0;
7351 unsigned int file
= 1;
7352 unsigned int line
= 1;
7353 unsigned int column
= 0;
7354 int is_stmt
= lh
->default_is_stmt
;
7355 int basic_block
= 0;
7356 int end_sequence
= 0;
7359 if (!decode_for_pst_p
&& lh
->num_file_names
>= file
)
7361 /* Start a subfile for the current file of the state machine. */
7362 /* lh->include_dirs and lh->file_names are 0-based, but the
7363 directory and file name numbers in the statement program
7365 struct file_entry
*fe
= &lh
->file_names
[file
- 1];
7369 dir
= lh
->include_dirs
[fe
->dir_index
- 1];
7371 dwarf2_start_subfile (fe
->name
, dir
, comp_dir
);
7374 /* Decode the table. */
7375 while (!end_sequence
)
7377 op_code
= read_1_byte (abfd
, line_ptr
);
7379 if (line_ptr
> line_end
)
7381 dwarf2_debug_line_missing_end_sequence_complaint ();
7385 if (op_code
>= lh
->opcode_base
)
7387 /* Special operand. */
7388 adj_opcode
= op_code
- lh
->opcode_base
;
7389 address
+= (adj_opcode
/ lh
->line_range
)
7390 * lh
->minimum_instruction_length
;
7391 line
+= lh
->line_base
+ (adj_opcode
% lh
->line_range
);
7392 if (lh
->num_file_names
< file
|| file
== 0)
7393 dwarf2_debug_line_missing_file_complaint ();
7396 lh
->file_names
[file
- 1].included_p
= 1;
7397 if (!decode_for_pst_p
&& is_stmt
)
7399 if (last_subfile
!= current_subfile
)
7401 addr
= gdbarch_addr_bits_remove (gdbarch
, address
);
7403 record_line (last_subfile
, 0, addr
);
7404 last_subfile
= current_subfile
;
7406 /* Append row to matrix using current values. */
7407 addr
= check_cu_functions (address
, cu
);
7408 addr
= gdbarch_addr_bits_remove (gdbarch
, addr
);
7409 record_line (current_subfile
, line
, addr
);
7414 else switch (op_code
)
7416 case DW_LNS_extended_op
:
7417 extended_len
= read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
7418 line_ptr
+= bytes_read
;
7419 extended_end
= line_ptr
+ extended_len
;
7420 extended_op
= read_1_byte (abfd
, line_ptr
);
7422 switch (extended_op
)
7424 case DW_LNE_end_sequence
:
7427 case DW_LNE_set_address
:
7428 address
= read_address (abfd
, line_ptr
, cu
, &bytes_read
);
7429 line_ptr
+= bytes_read
;
7430 address
+= baseaddr
;
7432 case DW_LNE_define_file
:
7435 unsigned int dir_index
, mod_time
, length
;
7437 cur_file
= read_string (abfd
, line_ptr
, &bytes_read
);
7438 line_ptr
+= bytes_read
;
7440 read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
7441 line_ptr
+= bytes_read
;
7443 read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
7444 line_ptr
+= bytes_read
;
7446 read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
7447 line_ptr
+= bytes_read
;
7448 add_file_name (lh
, cur_file
, dir_index
, mod_time
, length
);
7451 case DW_LNE_set_discriminator
:
7452 /* The discriminator is not interesting to the debugger;
7454 line_ptr
= extended_end
;
7457 complaint (&symfile_complaints
,
7458 _("mangled .debug_line section"));
7461 /* Make sure that we parsed the extended op correctly. If e.g.
7462 we expected a different address size than the producer used,
7463 we may have read the wrong number of bytes. */
7464 if (line_ptr
!= extended_end
)
7466 complaint (&symfile_complaints
,
7467 _("mangled .debug_line section"));
7472 if (lh
->num_file_names
< file
|| file
== 0)
7473 dwarf2_debug_line_missing_file_complaint ();
7476 lh
->file_names
[file
- 1].included_p
= 1;
7477 if (!decode_for_pst_p
&& is_stmt
)
7479 if (last_subfile
!= current_subfile
)
7481 addr
= gdbarch_addr_bits_remove (gdbarch
, address
);
7483 record_line (last_subfile
, 0, addr
);
7484 last_subfile
= current_subfile
;
7486 addr
= check_cu_functions (address
, cu
);
7487 addr
= gdbarch_addr_bits_remove (gdbarch
, addr
);
7488 record_line (current_subfile
, line
, addr
);
7493 case DW_LNS_advance_pc
:
7494 address
+= lh
->minimum_instruction_length
7495 * read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
7496 line_ptr
+= bytes_read
;
7498 case DW_LNS_advance_line
:
7499 line
+= read_signed_leb128 (abfd
, line_ptr
, &bytes_read
);
7500 line_ptr
+= bytes_read
;
7502 case DW_LNS_set_file
:
7504 /* The arrays lh->include_dirs and lh->file_names are
7505 0-based, but the directory and file name numbers in
7506 the statement program are 1-based. */
7507 struct file_entry
*fe
;
7510 file
= read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
7511 line_ptr
+= bytes_read
;
7512 if (lh
->num_file_names
< file
|| file
== 0)
7513 dwarf2_debug_line_missing_file_complaint ();
7516 fe
= &lh
->file_names
[file
- 1];
7518 dir
= lh
->include_dirs
[fe
->dir_index
- 1];
7519 if (!decode_for_pst_p
)
7521 last_subfile
= current_subfile
;
7522 dwarf2_start_subfile (fe
->name
, dir
, comp_dir
);
7527 case DW_LNS_set_column
:
7528 column
= read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
7529 line_ptr
+= bytes_read
;
7531 case DW_LNS_negate_stmt
:
7532 is_stmt
= (!is_stmt
);
7534 case DW_LNS_set_basic_block
:
7537 /* Add to the address register of the state machine the
7538 address increment value corresponding to special opcode
7539 255. I.e., this value is scaled by the minimum
7540 instruction length since special opcode 255 would have
7541 scaled the the increment. */
7542 case DW_LNS_const_add_pc
:
7543 address
+= (lh
->minimum_instruction_length
7544 * ((255 - lh
->opcode_base
) / lh
->line_range
));
7546 case DW_LNS_fixed_advance_pc
:
7547 address
+= read_2_bytes (abfd
, line_ptr
);
7552 /* Unknown standard opcode, ignore it. */
7555 for (i
= 0; i
< lh
->standard_opcode_lengths
[op_code
]; i
++)
7557 (void) read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
7558 line_ptr
+= bytes_read
;
7563 if (lh
->num_file_names
< file
|| file
== 0)
7564 dwarf2_debug_line_missing_file_complaint ();
7567 lh
->file_names
[file
- 1].included_p
= 1;
7568 if (!decode_for_pst_p
)
7570 addr
= gdbarch_addr_bits_remove (gdbarch
, address
);
7571 record_line (current_subfile
, 0, addr
);
7576 if (decode_for_pst_p
)
7580 /* Now that we're done scanning the Line Header Program, we can
7581 create the psymtab of each included file. */
7582 for (file_index
= 0; file_index
< lh
->num_file_names
; file_index
++)
7583 if (lh
->file_names
[file_index
].included_p
== 1)
7585 const struct file_entry fe
= lh
->file_names
[file_index
];
7586 char *include_name
= fe
.name
;
7587 char *dir_name
= NULL
;
7588 char *pst_filename
= pst
->filename
;
7591 dir_name
= lh
->include_dirs
[fe
.dir_index
- 1];
7593 if (!IS_ABSOLUTE_PATH (include_name
) && dir_name
!= NULL
)
7595 include_name
= concat (dir_name
, SLASH_STRING
,
7596 include_name
, (char *)NULL
);
7597 make_cleanup (xfree
, include_name
);
7600 if (!IS_ABSOLUTE_PATH (pst_filename
) && pst
->dirname
!= NULL
)
7602 pst_filename
= concat (pst
->dirname
, SLASH_STRING
,
7603 pst_filename
, (char *)NULL
);
7604 make_cleanup (xfree
, pst_filename
);
7607 if (strcmp (include_name
, pst_filename
) != 0)
7608 dwarf2_create_include_psymtab (include_name
, pst
, objfile
);
7613 /* Make sure a symtab is created for every file, even files
7614 which contain only variables (i.e. no code with associated
7618 struct file_entry
*fe
;
7620 for (i
= 0; i
< lh
->num_file_names
; i
++)
7623 fe
= &lh
->file_names
[i
];
7625 dir
= lh
->include_dirs
[fe
->dir_index
- 1];
7626 dwarf2_start_subfile (fe
->name
, dir
, comp_dir
);
7628 /* Skip the main file; we don't need it, and it must be
7629 allocated last, so that it will show up before the
7630 non-primary symtabs in the objfile's symtab list. */
7631 if (current_subfile
== first_subfile
)
7634 if (current_subfile
->symtab
== NULL
)
7635 current_subfile
->symtab
= allocate_symtab (current_subfile
->name
,
7637 fe
->symtab
= current_subfile
->symtab
;
7642 /* Start a subfile for DWARF. FILENAME is the name of the file and
7643 DIRNAME the name of the source directory which contains FILENAME
7644 or NULL if not known. COMP_DIR is the compilation directory for the
7645 linetable's compilation unit or NULL if not known.
7646 This routine tries to keep line numbers from identical absolute and
7647 relative file names in a common subfile.
7649 Using the `list' example from the GDB testsuite, which resides in
7650 /srcdir and compiling it with Irix6.2 cc in /compdir using a filename
7651 of /srcdir/list0.c yields the following debugging information for list0.c:
7653 DW_AT_name: /srcdir/list0.c
7654 DW_AT_comp_dir: /compdir
7655 files.files[0].name: list0.h
7656 files.files[0].dir: /srcdir
7657 files.files[1].name: list0.c
7658 files.files[1].dir: /srcdir
7660 The line number information for list0.c has to end up in a single
7661 subfile, so that `break /srcdir/list0.c:1' works as expected.
7662 start_subfile will ensure that this happens provided that we pass the
7663 concatenation of files.files[1].dir and files.files[1].name as the
7667 dwarf2_start_subfile (char *filename
, char *dirname
, char *comp_dir
)
7671 /* While reading the DIEs, we call start_symtab(DW_AT_name, DW_AT_comp_dir).
7672 `start_symtab' will always pass the contents of DW_AT_comp_dir as
7673 second argument to start_subfile. To be consistent, we do the
7674 same here. In order not to lose the line information directory,
7675 we concatenate it to the filename when it makes sense.
7676 Note that the Dwarf3 standard says (speaking of filenames in line
7677 information): ``The directory index is ignored for file names
7678 that represent full path names''. Thus ignoring dirname in the
7679 `else' branch below isn't an issue. */
7681 if (!IS_ABSOLUTE_PATH (filename
) && dirname
!= NULL
)
7682 fullname
= concat (dirname
, SLASH_STRING
, filename
, (char *)NULL
);
7684 fullname
= filename
;
7686 start_subfile (fullname
, comp_dir
);
7688 if (fullname
!= filename
)
7693 var_decode_location (struct attribute
*attr
, struct symbol
*sym
,
7694 struct dwarf2_cu
*cu
)
7696 struct objfile
*objfile
= cu
->objfile
;
7697 struct comp_unit_head
*cu_header
= &cu
->header
;
7699 /* NOTE drow/2003-01-30: There used to be a comment and some special
7700 code here to turn a symbol with DW_AT_external and a
7701 SYMBOL_VALUE_ADDRESS of 0 into a LOC_UNRESOLVED symbol. This was
7702 necessary for platforms (maybe Alpha, certainly PowerPC GNU/Linux
7703 with some versions of binutils) where shared libraries could have
7704 relocations against symbols in their debug information - the
7705 minimal symbol would have the right address, but the debug info
7706 would not. It's no longer necessary, because we will explicitly
7707 apply relocations when we read in the debug information now. */
7709 /* A DW_AT_location attribute with no contents indicates that a
7710 variable has been optimized away. */
7711 if (attr_form_is_block (attr
) && DW_BLOCK (attr
)->size
== 0)
7713 SYMBOL_CLASS (sym
) = LOC_OPTIMIZED_OUT
;
7717 /* Handle one degenerate form of location expression specially, to
7718 preserve GDB's previous behavior when section offsets are
7719 specified. If this is just a DW_OP_addr then mark this symbol
7722 if (attr_form_is_block (attr
)
7723 && DW_BLOCK (attr
)->size
== 1 + cu_header
->addr_size
7724 && DW_BLOCK (attr
)->data
[0] == DW_OP_addr
)
7728 SYMBOL_VALUE_ADDRESS (sym
) =
7729 read_address (objfile
->obfd
, DW_BLOCK (attr
)->data
+ 1, cu
, &dummy
);
7730 SYMBOL_CLASS (sym
) = LOC_STATIC
;
7731 fixup_symbol_section (sym
, objfile
);
7732 SYMBOL_VALUE_ADDRESS (sym
) += ANOFFSET (objfile
->section_offsets
,
7733 SYMBOL_SECTION (sym
));
7737 /* NOTE drow/2002-01-30: It might be worthwhile to have a static
7738 expression evaluator, and use LOC_COMPUTED only when necessary
7739 (i.e. when the value of a register or memory location is
7740 referenced, or a thread-local block, etc.). Then again, it might
7741 not be worthwhile. I'm assuming that it isn't unless performance
7742 or memory numbers show me otherwise. */
7744 dwarf2_symbol_mark_computed (attr
, sym
, cu
);
7745 SYMBOL_CLASS (sym
) = LOC_COMPUTED
;
7748 /* Given a pointer to a DWARF information entry, figure out if we need
7749 to make a symbol table entry for it, and if so, create a new entry
7750 and return a pointer to it.
7751 If TYPE is NULL, determine symbol type from the die, otherwise
7752 used the passed type. */
7754 static struct symbol
*
7755 new_symbol (struct die_info
*die
, struct type
*type
, struct dwarf2_cu
*cu
)
7757 struct objfile
*objfile
= cu
->objfile
;
7758 struct symbol
*sym
= NULL
;
7760 struct attribute
*attr
= NULL
;
7761 struct attribute
*attr2
= NULL
;
7763 int inlined_func
= (die
->tag
== DW_TAG_inlined_subroutine
);
7765 baseaddr
= ANOFFSET (objfile
->section_offsets
, SECT_OFF_TEXT (objfile
));
7767 if (die
->tag
!= DW_TAG_namespace
)
7768 name
= dwarf2_linkage_name (die
, cu
);
7770 name
= TYPE_NAME (type
);
7774 sym
= (struct symbol
*) obstack_alloc (&objfile
->objfile_obstack
,
7775 sizeof (struct symbol
));
7776 OBJSTAT (objfile
, n_syms
++);
7777 memset (sym
, 0, sizeof (struct symbol
));
7779 /* Cache this symbol's name and the name's demangled form (if any). */
7780 SYMBOL_LANGUAGE (sym
) = cu
->language
;
7781 SYMBOL_SET_NAMES (sym
, name
, strlen (name
), objfile
);
7783 /* Default assumptions.
7784 Use the passed type or decode it from the die. */
7785 SYMBOL_DOMAIN (sym
) = VAR_DOMAIN
;
7786 SYMBOL_CLASS (sym
) = LOC_OPTIMIZED_OUT
;
7788 SYMBOL_TYPE (sym
) = type
;
7790 SYMBOL_TYPE (sym
) = die_type (die
, cu
);
7791 attr
= dwarf2_attr (die
,
7792 inlined_func
? DW_AT_call_line
: DW_AT_decl_line
,
7796 SYMBOL_LINE (sym
) = DW_UNSND (attr
);
7799 attr
= dwarf2_attr (die
,
7800 inlined_func
? DW_AT_call_file
: DW_AT_decl_file
,
7804 int file_index
= DW_UNSND (attr
);
7805 if (cu
->line_header
== NULL
7806 || file_index
> cu
->line_header
->num_file_names
)
7807 complaint (&symfile_complaints
,
7808 _("file index out of range"));
7809 else if (file_index
> 0)
7811 struct file_entry
*fe
;
7812 fe
= &cu
->line_header
->file_names
[file_index
- 1];
7813 SYMBOL_SYMTAB (sym
) = fe
->symtab
;
7820 attr
= dwarf2_attr (die
, DW_AT_low_pc
, cu
);
7823 SYMBOL_VALUE_ADDRESS (sym
) = DW_ADDR (attr
) + baseaddr
;
7825 SYMBOL_CLASS (sym
) = LOC_LABEL
;
7827 case DW_TAG_subprogram
:
7828 /* SYMBOL_BLOCK_VALUE (sym) will be filled in later by
7830 SYMBOL_CLASS (sym
) = LOC_BLOCK
;
7831 attr2
= dwarf2_attr (die
, DW_AT_external
, cu
);
7832 if ((attr2
&& (DW_UNSND (attr2
) != 0))
7833 || cu
->language
== language_ada
)
7835 /* Subprograms marked external are stored as a global symbol.
7836 Ada subprograms, whether marked external or not, are always
7837 stored as a global symbol, because we want to be able to
7838 access them globally. For instance, we want to be able
7839 to break on a nested subprogram without having to
7840 specify the context. */
7841 add_symbol_to_list (sym
, &global_symbols
);
7845 add_symbol_to_list (sym
, cu
->list_in_scope
);
7848 case DW_TAG_inlined_subroutine
:
7849 /* SYMBOL_BLOCK_VALUE (sym) will be filled in later by
7851 SYMBOL_CLASS (sym
) = LOC_BLOCK
;
7852 SYMBOL_INLINED (sym
) = 1;
7853 /* Do not add the symbol to any lists. It will be found via
7854 BLOCK_FUNCTION from the blockvector. */
7856 case DW_TAG_variable
:
7857 /* Compilation with minimal debug info may result in variables
7858 with missing type entries. Change the misleading `void' type
7859 to something sensible. */
7860 if (TYPE_CODE (SYMBOL_TYPE (sym
)) == TYPE_CODE_VOID
)
7862 = objfile_type (objfile
)->nodebug_data_symbol
;
7864 attr
= dwarf2_attr (die
, DW_AT_const_value
, cu
);
7867 dwarf2_const_value (attr
, sym
, cu
);
7868 attr2
= dwarf2_attr (die
, DW_AT_external
, cu
);
7869 if (attr2
&& (DW_UNSND (attr2
) != 0))
7870 add_symbol_to_list (sym
, &global_symbols
);
7872 add_symbol_to_list (sym
, cu
->list_in_scope
);
7875 attr
= dwarf2_attr (die
, DW_AT_location
, cu
);
7878 var_decode_location (attr
, sym
, cu
);
7879 attr2
= dwarf2_attr (die
, DW_AT_external
, cu
);
7880 if (attr2
&& (DW_UNSND (attr2
) != 0))
7881 add_symbol_to_list (sym
, &global_symbols
);
7883 add_symbol_to_list (sym
, cu
->list_in_scope
);
7887 /* We do not know the address of this symbol.
7888 If it is an external symbol and we have type information
7889 for it, enter the symbol as a LOC_UNRESOLVED symbol.
7890 The address of the variable will then be determined from
7891 the minimal symbol table whenever the variable is
7893 attr2
= dwarf2_attr (die
, DW_AT_external
, cu
);
7894 if (attr2
&& (DW_UNSND (attr2
) != 0)
7895 && dwarf2_attr (die
, DW_AT_type
, cu
) != NULL
)
7897 SYMBOL_CLASS (sym
) = LOC_UNRESOLVED
;
7898 add_symbol_to_list (sym
, cu
->list_in_scope
);
7900 else if (!die_is_declaration (die
, cu
))
7902 /* Use the default LOC_OPTIMIZED_OUT class. */
7903 gdb_assert (SYMBOL_CLASS (sym
) == LOC_OPTIMIZED_OUT
);
7904 add_symbol_to_list (sym
, cu
->list_in_scope
);
7908 case DW_TAG_formal_parameter
:
7909 /* If we are inside a function, mark this as an argument. If
7910 not, we might be looking at an argument to an inlined function
7911 when we do not have enough information to show inlined frames;
7912 pretend it's a local variable in that case so that the user can
7914 if (context_stack_depth
> 0
7915 && context_stack
[context_stack_depth
- 1].name
!= NULL
)
7916 SYMBOL_IS_ARGUMENT (sym
) = 1;
7917 attr
= dwarf2_attr (die
, DW_AT_location
, cu
);
7920 var_decode_location (attr
, sym
, cu
);
7922 attr
= dwarf2_attr (die
, DW_AT_const_value
, cu
);
7925 dwarf2_const_value (attr
, sym
, cu
);
7927 add_symbol_to_list (sym
, cu
->list_in_scope
);
7929 case DW_TAG_unspecified_parameters
:
7930 /* From varargs functions; gdb doesn't seem to have any
7931 interest in this information, so just ignore it for now.
7934 case DW_TAG_class_type
:
7935 case DW_TAG_interface_type
:
7936 case DW_TAG_structure_type
:
7937 case DW_TAG_union_type
:
7938 case DW_TAG_set_type
:
7939 case DW_TAG_enumeration_type
:
7940 SYMBOL_CLASS (sym
) = LOC_TYPEDEF
;
7941 SYMBOL_DOMAIN (sym
) = STRUCT_DOMAIN
;
7943 /* Make sure that the symbol includes appropriate enclosing
7944 classes/namespaces in its name. These are calculated in
7945 read_structure_type, and the correct name is saved in
7948 if (cu
->language
== language_cplus
7949 || cu
->language
== language_java
)
7951 struct type
*type
= SYMBOL_TYPE (sym
);
7953 if (TYPE_TAG_NAME (type
) != NULL
)
7955 /* FIXME: carlton/2003-11-10: Should this use
7956 SYMBOL_SET_NAMES instead? (The same problem also
7957 arises further down in this function.) */
7958 /* The type's name is already allocated along with
7959 this objfile, so we don't need to duplicate it
7961 SYMBOL_LINKAGE_NAME (sym
) = TYPE_TAG_NAME (type
);
7966 /* NOTE: carlton/2003-11-10: C++ and Java class symbols shouldn't
7967 really ever be static objects: otherwise, if you try
7968 to, say, break of a class's method and you're in a file
7969 which doesn't mention that class, it won't work unless
7970 the check for all static symbols in lookup_symbol_aux
7971 saves you. See the OtherFileClass tests in
7972 gdb.c++/namespace.exp. */
7974 struct pending
**list_to_add
;
7976 list_to_add
= (cu
->list_in_scope
== &file_symbols
7977 && (cu
->language
== language_cplus
7978 || cu
->language
== language_java
)
7979 ? &global_symbols
: cu
->list_in_scope
);
7981 add_symbol_to_list (sym
, list_to_add
);
7983 /* The semantics of C++ state that "struct foo { ... }" also
7984 defines a typedef for "foo". A Java class declaration also
7985 defines a typedef for the class. */
7986 if (cu
->language
== language_cplus
7987 || cu
->language
== language_java
7988 || cu
->language
== language_ada
)
7990 /* The symbol's name is already allocated along with
7991 this objfile, so we don't need to duplicate it for
7993 if (TYPE_NAME (SYMBOL_TYPE (sym
)) == 0)
7994 TYPE_NAME (SYMBOL_TYPE (sym
)) = SYMBOL_SEARCH_NAME (sym
);
7998 case DW_TAG_typedef
:
7999 SYMBOL_LINKAGE_NAME (sym
) = (char *) dwarf2_full_name (die
, cu
);
8000 SYMBOL_CLASS (sym
) = LOC_TYPEDEF
;
8001 SYMBOL_DOMAIN (sym
) = VAR_DOMAIN
;
8002 add_symbol_to_list (sym
, cu
->list_in_scope
);
8004 case DW_TAG_base_type
:
8005 case DW_TAG_subrange_type
:
8006 SYMBOL_CLASS (sym
) = LOC_TYPEDEF
;
8007 SYMBOL_DOMAIN (sym
) = VAR_DOMAIN
;
8008 add_symbol_to_list (sym
, cu
->list_in_scope
);
8010 case DW_TAG_enumerator
:
8011 SYMBOL_LINKAGE_NAME (sym
) = (char *) dwarf2_full_name (die
, cu
);
8012 attr
= dwarf2_attr (die
, DW_AT_const_value
, cu
);
8015 dwarf2_const_value (attr
, sym
, cu
);
8018 /* NOTE: carlton/2003-11-10: See comment above in the
8019 DW_TAG_class_type, etc. block. */
8021 struct pending
**list_to_add
;
8023 list_to_add
= (cu
->list_in_scope
== &file_symbols
8024 && (cu
->language
== language_cplus
8025 || cu
->language
== language_java
)
8026 ? &global_symbols
: cu
->list_in_scope
);
8028 add_symbol_to_list (sym
, list_to_add
);
8031 case DW_TAG_namespace
:
8032 SYMBOL_CLASS (sym
) = LOC_TYPEDEF
;
8033 add_symbol_to_list (sym
, &global_symbols
);
8036 /* Not a tag we recognize. Hopefully we aren't processing
8037 trash data, but since we must specifically ignore things
8038 we don't recognize, there is nothing else we should do at
8040 complaint (&symfile_complaints
, _("unsupported tag: '%s'"),
8041 dwarf_tag_name (die
->tag
));
8045 /* For the benefit of old versions of GCC, check for anonymous
8046 namespaces based on the demangled name. */
8047 if (!processing_has_namespace_info
8048 && cu
->language
== language_cplus
8049 && dwarf2_attr (die
, DW_AT_MIPS_linkage_name
, cu
) != NULL
)
8050 cp_scan_for_anonymous_namespaces (sym
);
8055 /* Copy constant value from an attribute to a symbol. */
8058 dwarf2_const_value (struct attribute
*attr
, struct symbol
*sym
,
8059 struct dwarf2_cu
*cu
)
8061 struct objfile
*objfile
= cu
->objfile
;
8062 struct comp_unit_head
*cu_header
= &cu
->header
;
8063 struct dwarf_block
*blk
;
8068 if (TYPE_LENGTH (SYMBOL_TYPE (sym
)) != cu_header
->addr_size
)
8069 dwarf2_const_value_length_mismatch_complaint (SYMBOL_PRINT_NAME (sym
),
8070 cu_header
->addr_size
,
8071 TYPE_LENGTH (SYMBOL_TYPE
8073 SYMBOL_VALUE_BYTES (sym
) =
8074 obstack_alloc (&objfile
->objfile_obstack
, cu_header
->addr_size
);
8075 /* NOTE: cagney/2003-05-09: In-lined store_address call with
8076 it's body - store_unsigned_integer. */
8077 store_unsigned_integer (SYMBOL_VALUE_BYTES (sym
), cu_header
->addr_size
,
8079 SYMBOL_CLASS (sym
) = LOC_CONST_BYTES
;
8081 case DW_FORM_string
:
8083 /* DW_STRING is already allocated on the obstack, point directly
8085 SYMBOL_VALUE_BYTES (sym
) = (gdb_byte
*) DW_STRING (attr
);
8086 SYMBOL_CLASS (sym
) = LOC_CONST_BYTES
;
8088 case DW_FORM_block1
:
8089 case DW_FORM_block2
:
8090 case DW_FORM_block4
:
8092 blk
= DW_BLOCK (attr
);
8093 if (TYPE_LENGTH (SYMBOL_TYPE (sym
)) != blk
->size
)
8094 dwarf2_const_value_length_mismatch_complaint (SYMBOL_PRINT_NAME (sym
),
8096 TYPE_LENGTH (SYMBOL_TYPE
8098 SYMBOL_VALUE_BYTES (sym
) =
8099 obstack_alloc (&objfile
->objfile_obstack
, blk
->size
);
8100 memcpy (SYMBOL_VALUE_BYTES (sym
), blk
->data
, blk
->size
);
8101 SYMBOL_CLASS (sym
) = LOC_CONST_BYTES
;
8104 /* The DW_AT_const_value attributes are supposed to carry the
8105 symbol's value "represented as it would be on the target
8106 architecture." By the time we get here, it's already been
8107 converted to host endianness, so we just need to sign- or
8108 zero-extend it as appropriate. */
8110 dwarf2_const_value_data (attr
, sym
, 8);
8113 dwarf2_const_value_data (attr
, sym
, 16);
8116 dwarf2_const_value_data (attr
, sym
, 32);
8119 dwarf2_const_value_data (attr
, sym
, 64);
8123 SYMBOL_VALUE (sym
) = DW_SND (attr
);
8124 SYMBOL_CLASS (sym
) = LOC_CONST
;
8128 SYMBOL_VALUE (sym
) = DW_UNSND (attr
);
8129 SYMBOL_CLASS (sym
) = LOC_CONST
;
8133 complaint (&symfile_complaints
,
8134 _("unsupported const value attribute form: '%s'"),
8135 dwarf_form_name (attr
->form
));
8136 SYMBOL_VALUE (sym
) = 0;
8137 SYMBOL_CLASS (sym
) = LOC_CONST
;
8143 /* Given an attr with a DW_FORM_dataN value in host byte order, sign-
8144 or zero-extend it as appropriate for the symbol's type. */
8146 dwarf2_const_value_data (struct attribute
*attr
,
8150 LONGEST l
= DW_UNSND (attr
);
8152 if (bits
< sizeof (l
) * 8)
8154 if (TYPE_UNSIGNED (SYMBOL_TYPE (sym
)))
8155 l
&= ((LONGEST
) 1 << bits
) - 1;
8157 l
= (l
<< (sizeof (l
) * 8 - bits
)) >> (sizeof (l
) * 8 - bits
);
8160 SYMBOL_VALUE (sym
) = l
;
8161 SYMBOL_CLASS (sym
) = LOC_CONST
;
8165 /* Return the type of the die in question using its DW_AT_type attribute. */
8167 static struct type
*
8168 die_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
8171 struct attribute
*type_attr
;
8172 struct die_info
*type_die
;
8174 type_attr
= dwarf2_attr (die
, DW_AT_type
, cu
);
8177 /* A missing DW_AT_type represents a void type. */
8178 return objfile_type (cu
->objfile
)->builtin_void
;
8181 type_die
= follow_die_ref (die
, type_attr
, &cu
);
8183 type
= tag_type_to_type (type_die
, cu
);
8186 dump_die_for_error (type_die
);
8187 error (_("Dwarf Error: Problem turning type die at offset into gdb type [in module %s]"),
8193 /* Return the containing type of the die in question using its
8194 DW_AT_containing_type attribute. */
8196 static struct type
*
8197 die_containing_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
8199 struct type
*type
= NULL
;
8200 struct attribute
*type_attr
;
8201 struct die_info
*type_die
= NULL
;
8203 type_attr
= dwarf2_attr (die
, DW_AT_containing_type
, cu
);
8206 type_die
= follow_die_ref (die
, type_attr
, &cu
);
8207 type
= tag_type_to_type (type_die
, cu
);
8212 dump_die_for_error (type_die
);
8213 error (_("Dwarf Error: Problem turning containing type into gdb type [in module %s]"),
8219 static struct type
*
8220 tag_type_to_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
8222 struct type
*this_type
;
8224 this_type
= read_type_die (die
, cu
);
8227 dump_die_for_error (die
);
8228 error (_("Dwarf Error: Cannot find type of die [in module %s]"),
8234 static struct type
*
8235 read_type_die (struct die_info
*die
, struct dwarf2_cu
*cu
)
8237 struct type
*this_type
;
8239 this_type
= get_die_type (die
, cu
);
8245 case DW_TAG_class_type
:
8246 case DW_TAG_interface_type
:
8247 case DW_TAG_structure_type
:
8248 case DW_TAG_union_type
:
8249 this_type
= read_structure_type (die
, cu
);
8251 case DW_TAG_enumeration_type
:
8252 this_type
= read_enumeration_type (die
, cu
);
8254 case DW_TAG_subprogram
:
8255 case DW_TAG_subroutine_type
:
8256 case DW_TAG_inlined_subroutine
:
8257 this_type
= read_subroutine_type (die
, cu
);
8259 case DW_TAG_array_type
:
8260 this_type
= read_array_type (die
, cu
);
8262 case DW_TAG_set_type
:
8263 this_type
= read_set_type (die
, cu
);
8265 case DW_TAG_pointer_type
:
8266 this_type
= read_tag_pointer_type (die
, cu
);
8268 case DW_TAG_ptr_to_member_type
:
8269 this_type
= read_tag_ptr_to_member_type (die
, cu
);
8271 case DW_TAG_reference_type
:
8272 this_type
= read_tag_reference_type (die
, cu
);
8274 case DW_TAG_const_type
:
8275 this_type
= read_tag_const_type (die
, cu
);
8277 case DW_TAG_volatile_type
:
8278 this_type
= read_tag_volatile_type (die
, cu
);
8280 case DW_TAG_string_type
:
8281 this_type
= read_tag_string_type (die
, cu
);
8283 case DW_TAG_typedef
:
8284 this_type
= read_typedef (die
, cu
);
8286 case DW_TAG_subrange_type
:
8287 this_type
= read_subrange_type (die
, cu
);
8289 case DW_TAG_base_type
:
8290 this_type
= read_base_type (die
, cu
);
8292 case DW_TAG_unspecified_type
:
8293 this_type
= read_unspecified_type (die
, cu
);
8295 case DW_TAG_namespace
:
8296 this_type
= read_namespace_type (die
, cu
);
8299 complaint (&symfile_complaints
, _("unexpected tag in read_type_die: '%s'"),
8300 dwarf_tag_name (die
->tag
));
8307 /* Return the name of the namespace/class that DIE is defined within,
8308 or "" if we can't tell. The caller should not xfree the result.
8310 For example, if we're within the method foo() in the following
8320 then determine_prefix on foo's die will return "N::C". */
8323 determine_prefix (struct die_info
*die
, struct dwarf2_cu
*cu
)
8325 struct die_info
*parent
, *spec_die
;
8326 struct dwarf2_cu
*spec_cu
;
8327 struct type
*parent_type
;
8329 if (cu
->language
!= language_cplus
8330 && cu
->language
!= language_java
)
8333 /* We have to be careful in the presence of DW_AT_specification.
8334 For example, with GCC 3.4, given the code
8338 // Definition of N::foo.
8342 then we'll have a tree of DIEs like this:
8344 1: DW_TAG_compile_unit
8345 2: DW_TAG_namespace // N
8346 3: DW_TAG_subprogram // declaration of N::foo
8347 4: DW_TAG_subprogram // definition of N::foo
8348 DW_AT_specification // refers to die #3
8350 Thus, when processing die #4, we have to pretend that we're in
8351 the context of its DW_AT_specification, namely the contex of die
8354 spec_die
= die_specification (die
, &spec_cu
);
8355 if (spec_die
== NULL
)
8356 parent
= die
->parent
;
8359 parent
= spec_die
->parent
;
8366 switch (parent
->tag
)
8368 case DW_TAG_namespace
:
8369 parent_type
= read_type_die (parent
, cu
);
8370 /* We give a name to even anonymous namespaces. */
8371 return TYPE_TAG_NAME (parent_type
);
8372 case DW_TAG_class_type
:
8373 case DW_TAG_interface_type
:
8374 case DW_TAG_structure_type
:
8375 case DW_TAG_union_type
:
8376 parent_type
= read_type_die (parent
, cu
);
8377 if (TYPE_TAG_NAME (parent_type
) != NULL
)
8378 return TYPE_TAG_NAME (parent_type
);
8380 /* An anonymous structure is only allowed non-static data
8381 members; no typedefs, no member functions, et cetera.
8382 So it does not need a prefix. */
8385 return determine_prefix (parent
, cu
);
8389 /* Return a newly-allocated string formed by concatenating PREFIX and
8390 SUFFIX with appropriate separator. If PREFIX or SUFFIX is NULL or empty, then
8391 simply copy the SUFFIX or PREFIX, respectively. If OBS is non-null,
8392 perform an obconcat, otherwise allocate storage for the result. The CU argument
8393 is used to determine the language and hence, the appropriate separator. */
8395 #define MAX_SEP_LEN 2 /* sizeof ("::") */
8398 typename_concat (struct obstack
*obs
, const char *prefix
, const char *suffix
,
8399 struct dwarf2_cu
*cu
)
8403 if (suffix
== NULL
|| suffix
[0] == '\0' || prefix
== NULL
|| prefix
[0] == '\0')
8405 else if (cu
->language
== language_java
)
8417 char *retval
= xmalloc (strlen (prefix
) + MAX_SEP_LEN
+ strlen (suffix
) + 1);
8418 strcpy (retval
, prefix
);
8419 strcat (retval
, sep
);
8420 strcat (retval
, suffix
);
8425 /* We have an obstack. */
8426 return obconcat (obs
, prefix
, sep
, suffix
);
8430 /* Return sibling of die, NULL if no sibling. */
8432 static struct die_info
*
8433 sibling_die (struct die_info
*die
)
8435 return die
->sibling
;
8438 /* Get linkage name of a die, return NULL if not found. */
8441 dwarf2_linkage_name (struct die_info
*die
, struct dwarf2_cu
*cu
)
8443 struct attribute
*attr
;
8445 attr
= dwarf2_attr (die
, DW_AT_MIPS_linkage_name
, cu
);
8446 if (attr
&& DW_STRING (attr
))
8447 return DW_STRING (attr
);
8448 return dwarf2_name (die
, cu
);
8451 /* Get name of a die, return NULL if not found. */
8454 dwarf2_canonicalize_name (char *name
, struct dwarf2_cu
*cu
,
8455 struct obstack
*obstack
)
8457 if (name
&& cu
->language
== language_cplus
)
8459 char *canon_name
= cp_canonicalize_string (name
);
8461 if (canon_name
!= NULL
)
8463 if (strcmp (canon_name
, name
) != 0)
8464 name
= obsavestring (canon_name
, strlen (canon_name
),
8473 /* Get name of a die, return NULL if not found. */
8476 dwarf2_name (struct die_info
*die
, struct dwarf2_cu
*cu
)
8478 struct attribute
*attr
;
8480 attr
= dwarf2_attr (die
, DW_AT_name
, cu
);
8481 if (!attr
|| !DW_STRING (attr
))
8486 case DW_TAG_compile_unit
:
8487 /* Compilation units have a DW_AT_name that is a filename, not
8488 a source language identifier. */
8489 case DW_TAG_enumeration_type
:
8490 case DW_TAG_enumerator
:
8491 /* These tags always have simple identifiers already; no need
8492 to canonicalize them. */
8493 return DW_STRING (attr
);
8495 if (attr
->form
!= GDB_FORM_cached_string
)
8498 = dwarf2_canonicalize_name (DW_STRING (attr
), cu
,
8499 &cu
->objfile
->objfile_obstack
);
8500 attr
->form
= GDB_FORM_cached_string
;
8502 return DW_STRING (attr
);
8506 /* Return the die that this die in an extension of, or NULL if there
8507 is none. *EXT_CU is the CU containing DIE on input, and the CU
8508 containing the return value on output. */
8510 static struct die_info
*
8511 dwarf2_extension (struct die_info
*die
, struct dwarf2_cu
**ext_cu
)
8513 struct attribute
*attr
;
8515 attr
= dwarf2_attr (die
, DW_AT_extension
, *ext_cu
);
8519 return follow_die_ref (die
, attr
, ext_cu
);
8522 /* Convert a DIE tag into its string name. */
8525 dwarf_tag_name (unsigned tag
)
8529 case DW_TAG_padding
:
8530 return "DW_TAG_padding";
8531 case DW_TAG_array_type
:
8532 return "DW_TAG_array_type";
8533 case DW_TAG_class_type
:
8534 return "DW_TAG_class_type";
8535 case DW_TAG_entry_point
:
8536 return "DW_TAG_entry_point";
8537 case DW_TAG_enumeration_type
:
8538 return "DW_TAG_enumeration_type";
8539 case DW_TAG_formal_parameter
:
8540 return "DW_TAG_formal_parameter";
8541 case DW_TAG_imported_declaration
:
8542 return "DW_TAG_imported_declaration";
8544 return "DW_TAG_label";
8545 case DW_TAG_lexical_block
:
8546 return "DW_TAG_lexical_block";
8548 return "DW_TAG_member";
8549 case DW_TAG_pointer_type
:
8550 return "DW_TAG_pointer_type";
8551 case DW_TAG_reference_type
:
8552 return "DW_TAG_reference_type";
8553 case DW_TAG_compile_unit
:
8554 return "DW_TAG_compile_unit";
8555 case DW_TAG_string_type
:
8556 return "DW_TAG_string_type";
8557 case DW_TAG_structure_type
:
8558 return "DW_TAG_structure_type";
8559 case DW_TAG_subroutine_type
:
8560 return "DW_TAG_subroutine_type";
8561 case DW_TAG_typedef
:
8562 return "DW_TAG_typedef";
8563 case DW_TAG_union_type
:
8564 return "DW_TAG_union_type";
8565 case DW_TAG_unspecified_parameters
:
8566 return "DW_TAG_unspecified_parameters";
8567 case DW_TAG_variant
:
8568 return "DW_TAG_variant";
8569 case DW_TAG_common_block
:
8570 return "DW_TAG_common_block";
8571 case DW_TAG_common_inclusion
:
8572 return "DW_TAG_common_inclusion";
8573 case DW_TAG_inheritance
:
8574 return "DW_TAG_inheritance";
8575 case DW_TAG_inlined_subroutine
:
8576 return "DW_TAG_inlined_subroutine";
8578 return "DW_TAG_module";
8579 case DW_TAG_ptr_to_member_type
:
8580 return "DW_TAG_ptr_to_member_type";
8581 case DW_TAG_set_type
:
8582 return "DW_TAG_set_type";
8583 case DW_TAG_subrange_type
:
8584 return "DW_TAG_subrange_type";
8585 case DW_TAG_with_stmt
:
8586 return "DW_TAG_with_stmt";
8587 case DW_TAG_access_declaration
:
8588 return "DW_TAG_access_declaration";
8589 case DW_TAG_base_type
:
8590 return "DW_TAG_base_type";
8591 case DW_TAG_catch_block
:
8592 return "DW_TAG_catch_block";
8593 case DW_TAG_const_type
:
8594 return "DW_TAG_const_type";
8595 case DW_TAG_constant
:
8596 return "DW_TAG_constant";
8597 case DW_TAG_enumerator
:
8598 return "DW_TAG_enumerator";
8599 case DW_TAG_file_type
:
8600 return "DW_TAG_file_type";
8602 return "DW_TAG_friend";
8603 case DW_TAG_namelist
:
8604 return "DW_TAG_namelist";
8605 case DW_TAG_namelist_item
:
8606 return "DW_TAG_namelist_item";
8607 case DW_TAG_packed_type
:
8608 return "DW_TAG_packed_type";
8609 case DW_TAG_subprogram
:
8610 return "DW_TAG_subprogram";
8611 case DW_TAG_template_type_param
:
8612 return "DW_TAG_template_type_param";
8613 case DW_TAG_template_value_param
:
8614 return "DW_TAG_template_value_param";
8615 case DW_TAG_thrown_type
:
8616 return "DW_TAG_thrown_type";
8617 case DW_TAG_try_block
:
8618 return "DW_TAG_try_block";
8619 case DW_TAG_variant_part
:
8620 return "DW_TAG_variant_part";
8621 case DW_TAG_variable
:
8622 return "DW_TAG_variable";
8623 case DW_TAG_volatile_type
:
8624 return "DW_TAG_volatile_type";
8625 case DW_TAG_dwarf_procedure
:
8626 return "DW_TAG_dwarf_procedure";
8627 case DW_TAG_restrict_type
:
8628 return "DW_TAG_restrict_type";
8629 case DW_TAG_interface_type
:
8630 return "DW_TAG_interface_type";
8631 case DW_TAG_namespace
:
8632 return "DW_TAG_namespace";
8633 case DW_TAG_imported_module
:
8634 return "DW_TAG_imported_module";
8635 case DW_TAG_unspecified_type
:
8636 return "DW_TAG_unspecified_type";
8637 case DW_TAG_partial_unit
:
8638 return "DW_TAG_partial_unit";
8639 case DW_TAG_imported_unit
:
8640 return "DW_TAG_imported_unit";
8641 case DW_TAG_condition
:
8642 return "DW_TAG_condition";
8643 case DW_TAG_shared_type
:
8644 return "DW_TAG_shared_type";
8645 case DW_TAG_MIPS_loop
:
8646 return "DW_TAG_MIPS_loop";
8647 case DW_TAG_HP_array_descriptor
:
8648 return "DW_TAG_HP_array_descriptor";
8649 case DW_TAG_format_label
:
8650 return "DW_TAG_format_label";
8651 case DW_TAG_function_template
:
8652 return "DW_TAG_function_template";
8653 case DW_TAG_class_template
:
8654 return "DW_TAG_class_template";
8655 case DW_TAG_GNU_BINCL
:
8656 return "DW_TAG_GNU_BINCL";
8657 case DW_TAG_GNU_EINCL
:
8658 return "DW_TAG_GNU_EINCL";
8659 case DW_TAG_upc_shared_type
:
8660 return "DW_TAG_upc_shared_type";
8661 case DW_TAG_upc_strict_type
:
8662 return "DW_TAG_upc_strict_type";
8663 case DW_TAG_upc_relaxed_type
:
8664 return "DW_TAG_upc_relaxed_type";
8665 case DW_TAG_PGI_kanji_type
:
8666 return "DW_TAG_PGI_kanji_type";
8667 case DW_TAG_PGI_interface_block
:
8668 return "DW_TAG_PGI_interface_block";
8670 return "DW_TAG_<unknown>";
8674 /* Convert a DWARF attribute code into its string name. */
8677 dwarf_attr_name (unsigned attr
)
8682 return "DW_AT_sibling";
8683 case DW_AT_location
:
8684 return "DW_AT_location";
8686 return "DW_AT_name";
8687 case DW_AT_ordering
:
8688 return "DW_AT_ordering";
8689 case DW_AT_subscr_data
:
8690 return "DW_AT_subscr_data";
8691 case DW_AT_byte_size
:
8692 return "DW_AT_byte_size";
8693 case DW_AT_bit_offset
:
8694 return "DW_AT_bit_offset";
8695 case DW_AT_bit_size
:
8696 return "DW_AT_bit_size";
8697 case DW_AT_element_list
:
8698 return "DW_AT_element_list";
8699 case DW_AT_stmt_list
:
8700 return "DW_AT_stmt_list";
8702 return "DW_AT_low_pc";
8704 return "DW_AT_high_pc";
8705 case DW_AT_language
:
8706 return "DW_AT_language";
8708 return "DW_AT_member";
8710 return "DW_AT_discr";
8711 case DW_AT_discr_value
:
8712 return "DW_AT_discr_value";
8713 case DW_AT_visibility
:
8714 return "DW_AT_visibility";
8716 return "DW_AT_import";
8717 case DW_AT_string_length
:
8718 return "DW_AT_string_length";
8719 case DW_AT_common_reference
:
8720 return "DW_AT_common_reference";
8721 case DW_AT_comp_dir
:
8722 return "DW_AT_comp_dir";
8723 case DW_AT_const_value
:
8724 return "DW_AT_const_value";
8725 case DW_AT_containing_type
:
8726 return "DW_AT_containing_type";
8727 case DW_AT_default_value
:
8728 return "DW_AT_default_value";
8730 return "DW_AT_inline";
8731 case DW_AT_is_optional
:
8732 return "DW_AT_is_optional";
8733 case DW_AT_lower_bound
:
8734 return "DW_AT_lower_bound";
8735 case DW_AT_producer
:
8736 return "DW_AT_producer";
8737 case DW_AT_prototyped
:
8738 return "DW_AT_prototyped";
8739 case DW_AT_return_addr
:
8740 return "DW_AT_return_addr";
8741 case DW_AT_start_scope
:
8742 return "DW_AT_start_scope";
8743 case DW_AT_bit_stride
:
8744 return "DW_AT_bit_stride";
8745 case DW_AT_upper_bound
:
8746 return "DW_AT_upper_bound";
8747 case DW_AT_abstract_origin
:
8748 return "DW_AT_abstract_origin";
8749 case DW_AT_accessibility
:
8750 return "DW_AT_accessibility";
8751 case DW_AT_address_class
:
8752 return "DW_AT_address_class";
8753 case DW_AT_artificial
:
8754 return "DW_AT_artificial";
8755 case DW_AT_base_types
:
8756 return "DW_AT_base_types";
8757 case DW_AT_calling_convention
:
8758 return "DW_AT_calling_convention";
8760 return "DW_AT_count";
8761 case DW_AT_data_member_location
:
8762 return "DW_AT_data_member_location";
8763 case DW_AT_decl_column
:
8764 return "DW_AT_decl_column";
8765 case DW_AT_decl_file
:
8766 return "DW_AT_decl_file";
8767 case DW_AT_decl_line
:
8768 return "DW_AT_decl_line";
8769 case DW_AT_declaration
:
8770 return "DW_AT_declaration";
8771 case DW_AT_discr_list
:
8772 return "DW_AT_discr_list";
8773 case DW_AT_encoding
:
8774 return "DW_AT_encoding";
8775 case DW_AT_external
:
8776 return "DW_AT_external";
8777 case DW_AT_frame_base
:
8778 return "DW_AT_frame_base";
8780 return "DW_AT_friend";
8781 case DW_AT_identifier_case
:
8782 return "DW_AT_identifier_case";
8783 case DW_AT_macro_info
:
8784 return "DW_AT_macro_info";
8785 case DW_AT_namelist_items
:
8786 return "DW_AT_namelist_items";
8787 case DW_AT_priority
:
8788 return "DW_AT_priority";
8790 return "DW_AT_segment";
8791 case DW_AT_specification
:
8792 return "DW_AT_specification";
8793 case DW_AT_static_link
:
8794 return "DW_AT_static_link";
8796 return "DW_AT_type";
8797 case DW_AT_use_location
:
8798 return "DW_AT_use_location";
8799 case DW_AT_variable_parameter
:
8800 return "DW_AT_variable_parameter";
8801 case DW_AT_virtuality
:
8802 return "DW_AT_virtuality";
8803 case DW_AT_vtable_elem_location
:
8804 return "DW_AT_vtable_elem_location";
8805 /* DWARF 3 values. */
8806 case DW_AT_allocated
:
8807 return "DW_AT_allocated";
8808 case DW_AT_associated
:
8809 return "DW_AT_associated";
8810 case DW_AT_data_location
:
8811 return "DW_AT_data_location";
8812 case DW_AT_byte_stride
:
8813 return "DW_AT_byte_stride";
8814 case DW_AT_entry_pc
:
8815 return "DW_AT_entry_pc";
8816 case DW_AT_use_UTF8
:
8817 return "DW_AT_use_UTF8";
8818 case DW_AT_extension
:
8819 return "DW_AT_extension";
8821 return "DW_AT_ranges";
8822 case DW_AT_trampoline
:
8823 return "DW_AT_trampoline";
8824 case DW_AT_call_column
:
8825 return "DW_AT_call_column";
8826 case DW_AT_call_file
:
8827 return "DW_AT_call_file";
8828 case DW_AT_call_line
:
8829 return "DW_AT_call_line";
8830 case DW_AT_description
:
8831 return "DW_AT_description";
8832 case DW_AT_binary_scale
:
8833 return "DW_AT_binary_scale";
8834 case DW_AT_decimal_scale
:
8835 return "DW_AT_decimal_scale";
8837 return "DW_AT_small";
8838 case DW_AT_decimal_sign
:
8839 return "DW_AT_decimal_sign";
8840 case DW_AT_digit_count
:
8841 return "DW_AT_digit_count";
8842 case DW_AT_picture_string
:
8843 return "DW_AT_picture_string";
8845 return "DW_AT_mutable";
8846 case DW_AT_threads_scaled
:
8847 return "DW_AT_threads_scaled";
8848 case DW_AT_explicit
:
8849 return "DW_AT_explicit";
8850 case DW_AT_object_pointer
:
8851 return "DW_AT_object_pointer";
8852 case DW_AT_endianity
:
8853 return "DW_AT_endianity";
8854 case DW_AT_elemental
:
8855 return "DW_AT_elemental";
8857 return "DW_AT_pure";
8858 case DW_AT_recursive
:
8859 return "DW_AT_recursive";
8860 /* SGI/MIPS extensions. */
8861 #ifdef MIPS /* collides with DW_AT_HP_block_index */
8862 case DW_AT_MIPS_fde
:
8863 return "DW_AT_MIPS_fde";
8865 case DW_AT_MIPS_loop_begin
:
8866 return "DW_AT_MIPS_loop_begin";
8867 case DW_AT_MIPS_tail_loop_begin
:
8868 return "DW_AT_MIPS_tail_loop_begin";
8869 case DW_AT_MIPS_epilog_begin
:
8870 return "DW_AT_MIPS_epilog_begin";
8871 case DW_AT_MIPS_loop_unroll_factor
:
8872 return "DW_AT_MIPS_loop_unroll_factor";
8873 case DW_AT_MIPS_software_pipeline_depth
:
8874 return "DW_AT_MIPS_software_pipeline_depth";
8875 case DW_AT_MIPS_linkage_name
:
8876 return "DW_AT_MIPS_linkage_name";
8877 case DW_AT_MIPS_stride
:
8878 return "DW_AT_MIPS_stride";
8879 case DW_AT_MIPS_abstract_name
:
8880 return "DW_AT_MIPS_abstract_name";
8881 case DW_AT_MIPS_clone_origin
:
8882 return "DW_AT_MIPS_clone_origin";
8883 case DW_AT_MIPS_has_inlines
:
8884 return "DW_AT_MIPS_has_inlines";
8885 /* HP extensions. */
8886 #ifndef MIPS /* collides with DW_AT_MIPS_fde */
8887 case DW_AT_HP_block_index
:
8888 return "DW_AT_HP_block_index";
8890 case DW_AT_HP_unmodifiable
:
8891 return "DW_AT_HP_unmodifiable";
8892 case DW_AT_HP_actuals_stmt_list
:
8893 return "DW_AT_HP_actuals_stmt_list";
8894 case DW_AT_HP_proc_per_section
:
8895 return "DW_AT_HP_proc_per_section";
8896 case DW_AT_HP_raw_data_ptr
:
8897 return "DW_AT_HP_raw_data_ptr";
8898 case DW_AT_HP_pass_by_reference
:
8899 return "DW_AT_HP_pass_by_reference";
8900 case DW_AT_HP_opt_level
:
8901 return "DW_AT_HP_opt_level";
8902 case DW_AT_HP_prof_version_id
:
8903 return "DW_AT_HP_prof_version_id";
8904 case DW_AT_HP_opt_flags
:
8905 return "DW_AT_HP_opt_flags";
8906 case DW_AT_HP_cold_region_low_pc
:
8907 return "DW_AT_HP_cold_region_low_pc";
8908 case DW_AT_HP_cold_region_high_pc
:
8909 return "DW_AT_HP_cold_region_high_pc";
8910 case DW_AT_HP_all_variables_modifiable
:
8911 return "DW_AT_HP_all_variables_modifiable";
8912 case DW_AT_HP_linkage_name
:
8913 return "DW_AT_HP_linkage_name";
8914 case DW_AT_HP_prof_flags
:
8915 return "DW_AT_HP_prof_flags";
8916 /* GNU extensions. */
8917 case DW_AT_sf_names
:
8918 return "DW_AT_sf_names";
8919 case DW_AT_src_info
:
8920 return "DW_AT_src_info";
8921 case DW_AT_mac_info
:
8922 return "DW_AT_mac_info";
8923 case DW_AT_src_coords
:
8924 return "DW_AT_src_coords";
8925 case DW_AT_body_begin
:
8926 return "DW_AT_body_begin";
8927 case DW_AT_body_end
:
8928 return "DW_AT_body_end";
8929 case DW_AT_GNU_vector
:
8930 return "DW_AT_GNU_vector";
8931 /* VMS extensions. */
8932 case DW_AT_VMS_rtnbeg_pd_address
:
8933 return "DW_AT_VMS_rtnbeg_pd_address";
8934 /* UPC extension. */
8935 case DW_AT_upc_threads_scaled
:
8936 return "DW_AT_upc_threads_scaled";
8937 /* PGI (STMicroelectronics) extensions. */
8938 case DW_AT_PGI_lbase
:
8939 return "DW_AT_PGI_lbase";
8940 case DW_AT_PGI_soffset
:
8941 return "DW_AT_PGI_soffset";
8942 case DW_AT_PGI_lstride
:
8943 return "DW_AT_PGI_lstride";
8945 return "DW_AT_<unknown>";
8949 /* Convert a DWARF value form code into its string name. */
8952 dwarf_form_name (unsigned form
)
8957 return "DW_FORM_addr";
8958 case DW_FORM_block2
:
8959 return "DW_FORM_block2";
8960 case DW_FORM_block4
:
8961 return "DW_FORM_block4";
8963 return "DW_FORM_data2";
8965 return "DW_FORM_data4";
8967 return "DW_FORM_data8";
8968 case DW_FORM_string
:
8969 return "DW_FORM_string";
8971 return "DW_FORM_block";
8972 case DW_FORM_block1
:
8973 return "DW_FORM_block1";
8975 return "DW_FORM_data1";
8977 return "DW_FORM_flag";
8979 return "DW_FORM_sdata";
8981 return "DW_FORM_strp";
8983 return "DW_FORM_udata";
8984 case DW_FORM_ref_addr
:
8985 return "DW_FORM_ref_addr";
8987 return "DW_FORM_ref1";
8989 return "DW_FORM_ref2";
8991 return "DW_FORM_ref4";
8993 return "DW_FORM_ref8";
8994 case DW_FORM_ref_udata
:
8995 return "DW_FORM_ref_udata";
8996 case DW_FORM_indirect
:
8997 return "DW_FORM_indirect";
8998 case GDB_FORM_cached_string
:
8999 return "GDB_FORM_cached_string";
9001 return "DW_FORM_<unknown>";
9005 /* Convert a DWARF stack opcode into its string name. */
9008 dwarf_stack_op_name (unsigned op
)
9013 return "DW_OP_addr";
9015 return "DW_OP_deref";
9017 return "DW_OP_const1u";
9019 return "DW_OP_const1s";
9021 return "DW_OP_const2u";
9023 return "DW_OP_const2s";
9025 return "DW_OP_const4u";
9027 return "DW_OP_const4s";
9029 return "DW_OP_const8u";
9031 return "DW_OP_const8s";
9033 return "DW_OP_constu";
9035 return "DW_OP_consts";
9039 return "DW_OP_drop";
9041 return "DW_OP_over";
9043 return "DW_OP_pick";
9045 return "DW_OP_swap";
9049 return "DW_OP_xderef";
9057 return "DW_OP_minus";
9069 return "DW_OP_plus";
9070 case DW_OP_plus_uconst
:
9071 return "DW_OP_plus_uconst";
9077 return "DW_OP_shra";
9095 return "DW_OP_skip";
9097 return "DW_OP_lit0";
9099 return "DW_OP_lit1";
9101 return "DW_OP_lit2";
9103 return "DW_OP_lit3";
9105 return "DW_OP_lit4";
9107 return "DW_OP_lit5";
9109 return "DW_OP_lit6";
9111 return "DW_OP_lit7";
9113 return "DW_OP_lit8";
9115 return "DW_OP_lit9";
9117 return "DW_OP_lit10";
9119 return "DW_OP_lit11";
9121 return "DW_OP_lit12";
9123 return "DW_OP_lit13";
9125 return "DW_OP_lit14";
9127 return "DW_OP_lit15";
9129 return "DW_OP_lit16";
9131 return "DW_OP_lit17";
9133 return "DW_OP_lit18";
9135 return "DW_OP_lit19";
9137 return "DW_OP_lit20";
9139 return "DW_OP_lit21";
9141 return "DW_OP_lit22";
9143 return "DW_OP_lit23";
9145 return "DW_OP_lit24";
9147 return "DW_OP_lit25";
9149 return "DW_OP_lit26";
9151 return "DW_OP_lit27";
9153 return "DW_OP_lit28";
9155 return "DW_OP_lit29";
9157 return "DW_OP_lit30";
9159 return "DW_OP_lit31";
9161 return "DW_OP_reg0";
9163 return "DW_OP_reg1";
9165 return "DW_OP_reg2";
9167 return "DW_OP_reg3";
9169 return "DW_OP_reg4";
9171 return "DW_OP_reg5";
9173 return "DW_OP_reg6";
9175 return "DW_OP_reg7";
9177 return "DW_OP_reg8";
9179 return "DW_OP_reg9";
9181 return "DW_OP_reg10";
9183 return "DW_OP_reg11";
9185 return "DW_OP_reg12";
9187 return "DW_OP_reg13";
9189 return "DW_OP_reg14";
9191 return "DW_OP_reg15";
9193 return "DW_OP_reg16";
9195 return "DW_OP_reg17";
9197 return "DW_OP_reg18";
9199 return "DW_OP_reg19";
9201 return "DW_OP_reg20";
9203 return "DW_OP_reg21";
9205 return "DW_OP_reg22";
9207 return "DW_OP_reg23";
9209 return "DW_OP_reg24";
9211 return "DW_OP_reg25";
9213 return "DW_OP_reg26";
9215 return "DW_OP_reg27";
9217 return "DW_OP_reg28";
9219 return "DW_OP_reg29";
9221 return "DW_OP_reg30";
9223 return "DW_OP_reg31";
9225 return "DW_OP_breg0";
9227 return "DW_OP_breg1";
9229 return "DW_OP_breg2";
9231 return "DW_OP_breg3";
9233 return "DW_OP_breg4";
9235 return "DW_OP_breg5";
9237 return "DW_OP_breg6";
9239 return "DW_OP_breg7";
9241 return "DW_OP_breg8";
9243 return "DW_OP_breg9";
9245 return "DW_OP_breg10";
9247 return "DW_OP_breg11";
9249 return "DW_OP_breg12";
9251 return "DW_OP_breg13";
9253 return "DW_OP_breg14";
9255 return "DW_OP_breg15";
9257 return "DW_OP_breg16";
9259 return "DW_OP_breg17";
9261 return "DW_OP_breg18";
9263 return "DW_OP_breg19";
9265 return "DW_OP_breg20";
9267 return "DW_OP_breg21";
9269 return "DW_OP_breg22";
9271 return "DW_OP_breg23";
9273 return "DW_OP_breg24";
9275 return "DW_OP_breg25";
9277 return "DW_OP_breg26";
9279 return "DW_OP_breg27";
9281 return "DW_OP_breg28";
9283 return "DW_OP_breg29";
9285 return "DW_OP_breg30";
9287 return "DW_OP_breg31";
9289 return "DW_OP_regx";
9291 return "DW_OP_fbreg";
9293 return "DW_OP_bregx";
9295 return "DW_OP_piece";
9296 case DW_OP_deref_size
:
9297 return "DW_OP_deref_size";
9298 case DW_OP_xderef_size
:
9299 return "DW_OP_xderef_size";
9302 /* DWARF 3 extensions. */
9303 case DW_OP_push_object_address
:
9304 return "DW_OP_push_object_address";
9306 return "DW_OP_call2";
9308 return "DW_OP_call4";
9309 case DW_OP_call_ref
:
9310 return "DW_OP_call_ref";
9311 /* GNU extensions. */
9312 case DW_OP_form_tls_address
:
9313 return "DW_OP_form_tls_address";
9314 case DW_OP_call_frame_cfa
:
9315 return "DW_OP_call_frame_cfa";
9316 case DW_OP_bit_piece
:
9317 return "DW_OP_bit_piece";
9318 case DW_OP_GNU_push_tls_address
:
9319 return "DW_OP_GNU_push_tls_address";
9320 case DW_OP_GNU_uninit
:
9321 return "DW_OP_GNU_uninit";
9322 /* HP extensions. */
9323 case DW_OP_HP_is_value
:
9324 return "DW_OP_HP_is_value";
9325 case DW_OP_HP_fltconst4
:
9326 return "DW_OP_HP_fltconst4";
9327 case DW_OP_HP_fltconst8
:
9328 return "DW_OP_HP_fltconst8";
9329 case DW_OP_HP_mod_range
:
9330 return "DW_OP_HP_mod_range";
9331 case DW_OP_HP_unmod_range
:
9332 return "DW_OP_HP_unmod_range";
9334 return "DW_OP_HP_tls";
9336 return "OP_<unknown>";
9341 dwarf_bool_name (unsigned mybool
)
9349 /* Convert a DWARF type code into its string name. */
9352 dwarf_type_encoding_name (unsigned enc
)
9357 return "DW_ATE_void";
9358 case DW_ATE_address
:
9359 return "DW_ATE_address";
9360 case DW_ATE_boolean
:
9361 return "DW_ATE_boolean";
9362 case DW_ATE_complex_float
:
9363 return "DW_ATE_complex_float";
9365 return "DW_ATE_float";
9367 return "DW_ATE_signed";
9368 case DW_ATE_signed_char
:
9369 return "DW_ATE_signed_char";
9370 case DW_ATE_unsigned
:
9371 return "DW_ATE_unsigned";
9372 case DW_ATE_unsigned_char
:
9373 return "DW_ATE_unsigned_char";
9375 case DW_ATE_imaginary_float
:
9376 return "DW_ATE_imaginary_float";
9377 case DW_ATE_packed_decimal
:
9378 return "DW_ATE_packed_decimal";
9379 case DW_ATE_numeric_string
:
9380 return "DW_ATE_numeric_string";
9382 return "DW_ATE_edited";
9383 case DW_ATE_signed_fixed
:
9384 return "DW_ATE_signed_fixed";
9385 case DW_ATE_unsigned_fixed
:
9386 return "DW_ATE_unsigned_fixed";
9387 case DW_ATE_decimal_float
:
9388 return "DW_ATE_decimal_float";
9389 /* HP extensions. */
9390 case DW_ATE_HP_float80
:
9391 return "DW_ATE_HP_float80";
9392 case DW_ATE_HP_complex_float80
:
9393 return "DW_ATE_HP_complex_float80";
9394 case DW_ATE_HP_float128
:
9395 return "DW_ATE_HP_float128";
9396 case DW_ATE_HP_complex_float128
:
9397 return "DW_ATE_HP_complex_float128";
9398 case DW_ATE_HP_floathpintel
:
9399 return "DW_ATE_HP_floathpintel";
9400 case DW_ATE_HP_imaginary_float80
:
9401 return "DW_ATE_HP_imaginary_float80";
9402 case DW_ATE_HP_imaginary_float128
:
9403 return "DW_ATE_HP_imaginary_float128";
9405 return "DW_ATE_<unknown>";
9409 /* Convert a DWARF call frame info operation to its string name. */
9413 dwarf_cfi_name (unsigned cfi_opc
)
9417 case DW_CFA_advance_loc
:
9418 return "DW_CFA_advance_loc";
9420 return "DW_CFA_offset";
9421 case DW_CFA_restore
:
9422 return "DW_CFA_restore";
9424 return "DW_CFA_nop";
9425 case DW_CFA_set_loc
:
9426 return "DW_CFA_set_loc";
9427 case DW_CFA_advance_loc1
:
9428 return "DW_CFA_advance_loc1";
9429 case DW_CFA_advance_loc2
:
9430 return "DW_CFA_advance_loc2";
9431 case DW_CFA_advance_loc4
:
9432 return "DW_CFA_advance_loc4";
9433 case DW_CFA_offset_extended
:
9434 return "DW_CFA_offset_extended";
9435 case DW_CFA_restore_extended
:
9436 return "DW_CFA_restore_extended";
9437 case DW_CFA_undefined
:
9438 return "DW_CFA_undefined";
9439 case DW_CFA_same_value
:
9440 return "DW_CFA_same_value";
9441 case DW_CFA_register
:
9442 return "DW_CFA_register";
9443 case DW_CFA_remember_state
:
9444 return "DW_CFA_remember_state";
9445 case DW_CFA_restore_state
:
9446 return "DW_CFA_restore_state";
9447 case DW_CFA_def_cfa
:
9448 return "DW_CFA_def_cfa";
9449 case DW_CFA_def_cfa_register
:
9450 return "DW_CFA_def_cfa_register";
9451 case DW_CFA_def_cfa_offset
:
9452 return "DW_CFA_def_cfa_offset";
9454 case DW_CFA_def_cfa_expression
:
9455 return "DW_CFA_def_cfa_expression";
9456 case DW_CFA_expression
:
9457 return "DW_CFA_expression";
9458 case DW_CFA_offset_extended_sf
:
9459 return "DW_CFA_offset_extended_sf";
9460 case DW_CFA_def_cfa_sf
:
9461 return "DW_CFA_def_cfa_sf";
9462 case DW_CFA_def_cfa_offset_sf
:
9463 return "DW_CFA_def_cfa_offset_sf";
9464 case DW_CFA_val_offset
:
9465 return "DW_CFA_val_offset";
9466 case DW_CFA_val_offset_sf
:
9467 return "DW_CFA_val_offset_sf";
9468 case DW_CFA_val_expression
:
9469 return "DW_CFA_val_expression";
9470 /* SGI/MIPS specific. */
9471 case DW_CFA_MIPS_advance_loc8
:
9472 return "DW_CFA_MIPS_advance_loc8";
9473 /* GNU extensions. */
9474 case DW_CFA_GNU_window_save
:
9475 return "DW_CFA_GNU_window_save";
9476 case DW_CFA_GNU_args_size
:
9477 return "DW_CFA_GNU_args_size";
9478 case DW_CFA_GNU_negative_offset_extended
:
9479 return "DW_CFA_GNU_negative_offset_extended";
9481 return "DW_CFA_<unknown>";
9487 dump_die_shallow (struct ui_file
*f
, int indent
, struct die_info
*die
)
9491 print_spaces (indent
, f
);
9492 fprintf_unfiltered (f
, "Die: %s (abbrev %d, offset 0x%x)\n",
9493 dwarf_tag_name (die
->tag
), die
->abbrev
, die
->offset
);
9495 if (die
->parent
!= NULL
)
9497 print_spaces (indent
, f
);
9498 fprintf_unfiltered (f
, " parent at offset: 0x%x\n",
9499 die
->parent
->offset
);
9502 print_spaces (indent
, f
);
9503 fprintf_unfiltered (f
, " has children: %s\n",
9504 dwarf_bool_name (die
->child
!= NULL
));
9506 print_spaces (indent
, f
);
9507 fprintf_unfiltered (f
, " attributes:\n");
9509 for (i
= 0; i
< die
->num_attrs
; ++i
)
9511 print_spaces (indent
, f
);
9512 fprintf_unfiltered (f
, " %s (%s) ",
9513 dwarf_attr_name (die
->attrs
[i
].name
),
9514 dwarf_form_name (die
->attrs
[i
].form
));
9516 switch (die
->attrs
[i
].form
)
9518 case DW_FORM_ref_addr
:
9520 fprintf_unfiltered (f
, "address: ");
9521 fputs_filtered (paddress (DW_ADDR (&die
->attrs
[i
])), f
);
9523 case DW_FORM_block2
:
9524 case DW_FORM_block4
:
9526 case DW_FORM_block1
:
9527 fprintf_unfiltered (f
, "block: size %d", DW_BLOCK (&die
->attrs
[i
])->size
);
9532 fprintf_unfiltered (f
, "constant ref: 0x%lx (adjusted)",
9533 (long) (DW_ADDR (&die
->attrs
[i
])));
9541 fprintf_unfiltered (f
, "constant: %ld", DW_UNSND (&die
->attrs
[i
]));
9543 case DW_FORM_string
:
9545 case GDB_FORM_cached_string
:
9546 fprintf_unfiltered (f
, "string: \"%s\"",
9547 DW_STRING (&die
->attrs
[i
])
9548 ? DW_STRING (&die
->attrs
[i
]) : "");
9551 if (DW_UNSND (&die
->attrs
[i
]))
9552 fprintf_unfiltered (f
, "flag: TRUE");
9554 fprintf_unfiltered (f
, "flag: FALSE");
9556 case DW_FORM_indirect
:
9557 /* the reader will have reduced the indirect form to
9558 the "base form" so this form should not occur */
9559 fprintf_unfiltered (f
, "unexpected attribute form: DW_FORM_indirect");
9562 fprintf_unfiltered (f
, "unsupported attribute form: %d.",
9563 die
->attrs
[i
].form
);
9566 fprintf_unfiltered (f
, "\n");
9571 dump_die_for_error (struct die_info
*die
)
9573 dump_die_shallow (gdb_stderr
, 0, die
);
9577 dump_die_1 (struct ui_file
*f
, int level
, int max_level
, struct die_info
*die
)
9579 int indent
= level
* 4;
9581 gdb_assert (die
!= NULL
);
9583 if (level
>= max_level
)
9586 dump_die_shallow (f
, indent
, die
);
9588 if (die
->child
!= NULL
)
9590 print_spaces (indent
, f
);
9591 fprintf_unfiltered (f
, " Children:");
9592 if (level
+ 1 < max_level
)
9594 fprintf_unfiltered (f
, "\n");
9595 dump_die_1 (f
, level
+ 1, max_level
, die
->child
);
9599 fprintf_unfiltered (f
, " [not printed, max nesting level reached]\n");
9603 if (die
->sibling
!= NULL
&& level
> 0)
9605 dump_die_1 (f
, level
, max_level
, die
->sibling
);
9609 /* This is called from the pdie macro in gdbinit.in.
9610 It's not static so gcc will keep a copy callable from gdb. */
9613 dump_die (struct die_info
*die
, int max_level
)
9615 dump_die_1 (gdb_stdlog
, 0, max_level
, die
);
9619 store_in_ref_table (struct die_info
*die
, struct dwarf2_cu
*cu
)
9623 slot
= htab_find_slot_with_hash (cu
->die_hash
, die
, die
->offset
, INSERT
);
9629 dwarf2_get_ref_die_offset (struct attribute
*attr
)
9631 unsigned int result
= 0;
9635 case DW_FORM_ref_addr
:
9640 case DW_FORM_ref_udata
:
9641 result
= DW_ADDR (attr
);
9644 complaint (&symfile_complaints
,
9645 _("unsupported die ref attribute form: '%s'"),
9646 dwarf_form_name (attr
->form
));
9651 /* Return the constant value held by the given attribute. Return -1
9652 if the value held by the attribute is not constant. */
9655 dwarf2_get_attr_constant_value (struct attribute
*attr
, int default_value
)
9657 if (attr
->form
== DW_FORM_sdata
)
9658 return DW_SND (attr
);
9659 else if (attr
->form
== DW_FORM_udata
9660 || attr
->form
== DW_FORM_data1
9661 || attr
->form
== DW_FORM_data2
9662 || attr
->form
== DW_FORM_data4
9663 || attr
->form
== DW_FORM_data8
)
9664 return DW_UNSND (attr
);
9667 complaint (&symfile_complaints
, _("Attribute value is not a constant (%s)"),
9668 dwarf_form_name (attr
->form
));
9669 return default_value
;
9673 /* THIS_CU has a reference to PER_CU. If necessary, load the new compilation
9674 unit and add it to our queue. */
9677 maybe_queue_comp_unit (struct dwarf2_cu
*this_cu
,
9678 struct dwarf2_per_cu_data
*per_cu
)
9680 /* Mark the dependence relation so that we don't flush PER_CU
9682 dwarf2_add_dependence (this_cu
, per_cu
);
9684 /* If it's already on the queue, we have nothing to do. */
9688 /* If the compilation unit is already loaded, just mark it as
9690 if (per_cu
->cu
!= NULL
)
9692 per_cu
->cu
->last_used
= 0;
9696 /* Add it to the queue. */
9697 queue_comp_unit (per_cu
, this_cu
->objfile
);
9700 /* Follow reference attribute ATTR of SRC_DIE.
9701 On entry *REF_CU is the CU of SRC_DIE.
9702 On exit *REF_CU is the CU of the result. */
9704 static struct die_info
*
9705 follow_die_ref (struct die_info
*src_die
, struct attribute
*attr
,
9706 struct dwarf2_cu
**ref_cu
)
9708 struct die_info
*die
;
9709 unsigned int offset
;
9710 struct die_info temp_die
;
9711 struct dwarf2_cu
*target_cu
, *cu
= *ref_cu
;
9713 offset
= dwarf2_get_ref_die_offset (attr
);
9715 if (! offset_in_cu_p (&cu
->header
, offset
))
9717 struct dwarf2_per_cu_data
*per_cu
;
9718 per_cu
= dwarf2_find_containing_comp_unit (offset
, cu
->objfile
);
9720 /* If necessary, add it to the queue and load its DIEs. */
9721 maybe_queue_comp_unit (cu
, per_cu
);
9723 target_cu
= per_cu
->cu
;
9728 *ref_cu
= target_cu
;
9729 temp_die
.offset
= offset
;
9730 die
= htab_find_with_hash (target_cu
->die_hash
, &temp_die
, offset
);
9734 error (_("Dwarf Error: Cannot find DIE at 0x%lx referenced from DIE "
9735 "at 0x%lx [in module %s]"),
9736 (long) offset
, (long) src_die
->offset
, cu
->objfile
->name
);
9739 /* Decode simple location descriptions.
9740 Given a pointer to a dwarf block that defines a location, compute
9741 the location and return the value.
9743 NOTE drow/2003-11-18: This function is called in two situations
9744 now: for the address of static or global variables (partial symbols
9745 only) and for offsets into structures which are expected to be
9746 (more or less) constant. The partial symbol case should go away,
9747 and only the constant case should remain. That will let this
9748 function complain more accurately. A few special modes are allowed
9749 without complaint for global variables (for instance, global
9750 register values and thread-local values).
9752 A location description containing no operations indicates that the
9753 object is optimized out. The return value is 0 for that case.
9754 FIXME drow/2003-11-16: No callers check for this case any more; soon all
9755 callers will only want a very basic result and this can become a
9758 Note that stack[0] is unused except as a default error return.
9759 Note that stack overflow is not yet handled. */
9762 decode_locdesc (struct dwarf_block
*blk
, struct dwarf2_cu
*cu
)
9764 struct objfile
*objfile
= cu
->objfile
;
9765 struct comp_unit_head
*cu_header
= &cu
->header
;
9767 int size
= blk
->size
;
9768 gdb_byte
*data
= blk
->data
;
9769 CORE_ADDR stack
[64];
9771 unsigned int bytes_read
, unsnd
;
9815 stack
[++stacki
] = op
- DW_OP_lit0
;
9850 stack
[++stacki
] = op
- DW_OP_reg0
;
9852 dwarf2_complex_location_expr_complaint ();
9856 unsnd
= read_unsigned_leb128 (NULL
, (data
+ i
), &bytes_read
);
9858 stack
[++stacki
] = unsnd
;
9860 dwarf2_complex_location_expr_complaint ();
9864 stack
[++stacki
] = read_address (objfile
->obfd
, &data
[i
],
9870 stack
[++stacki
] = read_1_byte (objfile
->obfd
, &data
[i
]);
9875 stack
[++stacki
] = read_1_signed_byte (objfile
->obfd
, &data
[i
]);
9880 stack
[++stacki
] = read_2_bytes (objfile
->obfd
, &data
[i
]);
9885 stack
[++stacki
] = read_2_signed_bytes (objfile
->obfd
, &data
[i
]);
9890 stack
[++stacki
] = read_4_bytes (objfile
->obfd
, &data
[i
]);
9895 stack
[++stacki
] = read_4_signed_bytes (objfile
->obfd
, &data
[i
]);
9900 stack
[++stacki
] = read_unsigned_leb128 (NULL
, (data
+ i
),
9906 stack
[++stacki
] = read_signed_leb128 (NULL
, (data
+ i
), &bytes_read
);
9911 stack
[stacki
+ 1] = stack
[stacki
];
9916 stack
[stacki
- 1] += stack
[stacki
];
9920 case DW_OP_plus_uconst
:
9921 stack
[stacki
] += read_unsigned_leb128 (NULL
, (data
+ i
), &bytes_read
);
9926 stack
[stacki
- 1] -= stack
[stacki
];
9931 /* If we're not the last op, then we definitely can't encode
9932 this using GDB's address_class enum. This is valid for partial
9933 global symbols, although the variable's address will be bogus
9936 dwarf2_complex_location_expr_complaint ();
9939 case DW_OP_GNU_push_tls_address
:
9940 /* The top of the stack has the offset from the beginning
9941 of the thread control block at which the variable is located. */
9942 /* Nothing should follow this operator, so the top of stack would
9944 /* This is valid for partial global symbols, but the variable's
9945 address will be bogus in the psymtab. */
9947 dwarf2_complex_location_expr_complaint ();
9950 case DW_OP_GNU_uninit
:
9954 complaint (&symfile_complaints
, _("unsupported stack op: '%s'"),
9955 dwarf_stack_op_name (op
));
9956 return (stack
[stacki
]);
9959 return (stack
[stacki
]);
9962 /* memory allocation interface */
9964 static struct dwarf_block
*
9965 dwarf_alloc_block (struct dwarf2_cu
*cu
)
9967 struct dwarf_block
*blk
;
9969 blk
= (struct dwarf_block
*)
9970 obstack_alloc (&cu
->comp_unit_obstack
, sizeof (struct dwarf_block
));
9974 static struct abbrev_info
*
9975 dwarf_alloc_abbrev (struct dwarf2_cu
*cu
)
9977 struct abbrev_info
*abbrev
;
9979 abbrev
= (struct abbrev_info
*)
9980 obstack_alloc (&cu
->abbrev_obstack
, sizeof (struct abbrev_info
));
9981 memset (abbrev
, 0, sizeof (struct abbrev_info
));
9985 static struct die_info
*
9986 dwarf_alloc_die (struct dwarf2_cu
*cu
, int num_attrs
)
9988 struct die_info
*die
;
9989 size_t size
= sizeof (struct die_info
);
9992 size
+= (num_attrs
- 1) * sizeof (struct attribute
);
9994 die
= (struct die_info
*) obstack_alloc (&cu
->comp_unit_obstack
, size
);
9995 memset (die
, 0, sizeof (struct die_info
));
10000 /* Macro support. */
10003 /* Return the full name of file number I in *LH's file name table.
10004 Use COMP_DIR as the name of the current directory of the
10005 compilation. The result is allocated using xmalloc; the caller is
10006 responsible for freeing it. */
10008 file_full_name (int file
, struct line_header
*lh
, const char *comp_dir
)
10010 /* Is the file number a valid index into the line header's file name
10011 table? Remember that file numbers start with one, not zero. */
10012 if (1 <= file
&& file
<= lh
->num_file_names
)
10014 struct file_entry
*fe
= &lh
->file_names
[file
- 1];
10016 if (IS_ABSOLUTE_PATH (fe
->name
))
10017 return xstrdup (fe
->name
);
10025 dir
= lh
->include_dirs
[fe
->dir_index
- 1];
10031 dir_len
= strlen (dir
);
10032 full_name
= xmalloc (dir_len
+ 1 + strlen (fe
->name
) + 1);
10033 strcpy (full_name
, dir
);
10034 full_name
[dir_len
] = '/';
10035 strcpy (full_name
+ dir_len
+ 1, fe
->name
);
10039 return xstrdup (fe
->name
);
10044 /* The compiler produced a bogus file number. We can at least
10045 record the macro definitions made in the file, even if we
10046 won't be able to find the file by name. */
10047 char fake_name
[80];
10048 sprintf (fake_name
, "<bad macro file number %d>", file
);
10050 complaint (&symfile_complaints
,
10051 _("bad file number in macro information (%d)"),
10054 return xstrdup (fake_name
);
10059 static struct macro_source_file
*
10060 macro_start_file (int file
, int line
,
10061 struct macro_source_file
*current_file
,
10062 const char *comp_dir
,
10063 struct line_header
*lh
, struct objfile
*objfile
)
10065 /* The full name of this source file. */
10066 char *full_name
= file_full_name (file
, lh
, comp_dir
);
10068 /* We don't create a macro table for this compilation unit
10069 at all until we actually get a filename. */
10070 if (! pending_macros
)
10071 pending_macros
= new_macro_table (&objfile
->objfile_obstack
,
10072 objfile
->macro_cache
);
10074 if (! current_file
)
10075 /* If we have no current file, then this must be the start_file
10076 directive for the compilation unit's main source file. */
10077 current_file
= macro_set_main (pending_macros
, full_name
);
10079 current_file
= macro_include (current_file
, line
, full_name
);
10083 return current_file
;
10087 /* Copy the LEN characters at BUF to a xmalloc'ed block of memory,
10088 followed by a null byte. */
10090 copy_string (const char *buf
, int len
)
10092 char *s
= xmalloc (len
+ 1);
10093 memcpy (s
, buf
, len
);
10100 static const char *
10101 consume_improper_spaces (const char *p
, const char *body
)
10105 complaint (&symfile_complaints
,
10106 _("macro definition contains spaces in formal argument list:\n`%s'"),
10118 parse_macro_definition (struct macro_source_file
*file
, int line
,
10123 /* The body string takes one of two forms. For object-like macro
10124 definitions, it should be:
10126 <macro name> " " <definition>
10128 For function-like macro definitions, it should be:
10130 <macro name> "() " <definition>
10132 <macro name> "(" <arg name> ( "," <arg name> ) * ") " <definition>
10134 Spaces may appear only where explicitly indicated, and in the
10137 The Dwarf 2 spec says that an object-like macro's name is always
10138 followed by a space, but versions of GCC around March 2002 omit
10139 the space when the macro's definition is the empty string.
10141 The Dwarf 2 spec says that there should be no spaces between the
10142 formal arguments in a function-like macro's formal argument list,
10143 but versions of GCC around March 2002 include spaces after the
10147 /* Find the extent of the macro name. The macro name is terminated
10148 by either a space or null character (for an object-like macro) or
10149 an opening paren (for a function-like macro). */
10150 for (p
= body
; *p
; p
++)
10151 if (*p
== ' ' || *p
== '(')
10154 if (*p
== ' ' || *p
== '\0')
10156 /* It's an object-like macro. */
10157 int name_len
= p
- body
;
10158 char *name
= copy_string (body
, name_len
);
10159 const char *replacement
;
10162 replacement
= body
+ name_len
+ 1;
10165 dwarf2_macro_malformed_definition_complaint (body
);
10166 replacement
= body
+ name_len
;
10169 macro_define_object (file
, line
, name
, replacement
);
10173 else if (*p
== '(')
10175 /* It's a function-like macro. */
10176 char *name
= copy_string (body
, p
- body
);
10179 char **argv
= xmalloc (argv_size
* sizeof (*argv
));
10183 p
= consume_improper_spaces (p
, body
);
10185 /* Parse the formal argument list. */
10186 while (*p
&& *p
!= ')')
10188 /* Find the extent of the current argument name. */
10189 const char *arg_start
= p
;
10191 while (*p
&& *p
!= ',' && *p
!= ')' && *p
!= ' ')
10194 if (! *p
|| p
== arg_start
)
10195 dwarf2_macro_malformed_definition_complaint (body
);
10198 /* Make sure argv has room for the new argument. */
10199 if (argc
>= argv_size
)
10202 argv
= xrealloc (argv
, argv_size
* sizeof (*argv
));
10205 argv
[argc
++] = copy_string (arg_start
, p
- arg_start
);
10208 p
= consume_improper_spaces (p
, body
);
10210 /* Consume the comma, if present. */
10215 p
= consume_improper_spaces (p
, body
);
10224 /* Perfectly formed definition, no complaints. */
10225 macro_define_function (file
, line
, name
,
10226 argc
, (const char **) argv
,
10228 else if (*p
== '\0')
10230 /* Complain, but do define it. */
10231 dwarf2_macro_malformed_definition_complaint (body
);
10232 macro_define_function (file
, line
, name
,
10233 argc
, (const char **) argv
,
10237 /* Just complain. */
10238 dwarf2_macro_malformed_definition_complaint (body
);
10241 /* Just complain. */
10242 dwarf2_macro_malformed_definition_complaint (body
);
10248 for (i
= 0; i
< argc
; i
++)
10254 dwarf2_macro_malformed_definition_complaint (body
);
10259 dwarf_decode_macros (struct line_header
*lh
, unsigned int offset
,
10260 char *comp_dir
, bfd
*abfd
,
10261 struct dwarf2_cu
*cu
)
10263 gdb_byte
*mac_ptr
, *mac_end
;
10264 struct macro_source_file
*current_file
= 0;
10265 enum dwarf_macinfo_record_type macinfo_type
;
10266 int at_commandline
;
10268 if (dwarf2_per_objfile
->macinfo
.buffer
== NULL
)
10270 complaint (&symfile_complaints
, _("missing .debug_macinfo section"));
10274 /* First pass: Find the name of the base filename.
10275 This filename is needed in order to process all macros whose definition
10276 (or undefinition) comes from the command line. These macros are defined
10277 before the first DW_MACINFO_start_file entry, and yet still need to be
10278 associated to the base file.
10280 To determine the base file name, we scan the macro definitions until we
10281 reach the first DW_MACINFO_start_file entry. We then initialize
10282 CURRENT_FILE accordingly so that any macro definition found before the
10283 first DW_MACINFO_start_file can still be associated to the base file. */
10285 mac_ptr
= dwarf2_per_objfile
->macinfo
.buffer
+ offset
;
10286 mac_end
= dwarf2_per_objfile
->macinfo
.buffer
10287 + dwarf2_per_objfile
->macinfo
.size
;
10291 /* Do we at least have room for a macinfo type byte? */
10292 if (mac_ptr
>= mac_end
)
10294 /* Complaint is printed during the second pass as GDB will probably
10295 stop the first pass earlier upon finding DW_MACINFO_start_file. */
10299 macinfo_type
= read_1_byte (abfd
, mac_ptr
);
10302 switch (macinfo_type
)
10304 /* A zero macinfo type indicates the end of the macro
10309 case DW_MACINFO_define
:
10310 case DW_MACINFO_undef
:
10311 /* Only skip the data by MAC_PTR. */
10313 unsigned int bytes_read
;
10315 read_unsigned_leb128 (abfd
, mac_ptr
, &bytes_read
);
10316 mac_ptr
+= bytes_read
;
10317 read_string (abfd
, mac_ptr
, &bytes_read
);
10318 mac_ptr
+= bytes_read
;
10322 case DW_MACINFO_start_file
:
10324 unsigned int bytes_read
;
10327 line
= read_unsigned_leb128 (abfd
, mac_ptr
, &bytes_read
);
10328 mac_ptr
+= bytes_read
;
10329 file
= read_unsigned_leb128 (abfd
, mac_ptr
, &bytes_read
);
10330 mac_ptr
+= bytes_read
;
10332 current_file
= macro_start_file (file
, line
, current_file
, comp_dir
,
10337 case DW_MACINFO_end_file
:
10338 /* No data to skip by MAC_PTR. */
10341 case DW_MACINFO_vendor_ext
:
10342 /* Only skip the data by MAC_PTR. */
10344 unsigned int bytes_read
;
10346 read_unsigned_leb128 (abfd
, mac_ptr
, &bytes_read
);
10347 mac_ptr
+= bytes_read
;
10348 read_string (abfd
, mac_ptr
, &bytes_read
);
10349 mac_ptr
+= bytes_read
;
10356 } while (macinfo_type
!= 0 && current_file
== NULL
);
10358 /* Second pass: Process all entries.
10360 Use the AT_COMMAND_LINE flag to determine whether we are still processing
10361 command-line macro definitions/undefinitions. This flag is unset when we
10362 reach the first DW_MACINFO_start_file entry. */
10364 mac_ptr
= dwarf2_per_objfile
->macinfo
.buffer
+ offset
;
10366 /* Determines if GDB is still before first DW_MACINFO_start_file. If true
10367 GDB is still reading the definitions from command line. First
10368 DW_MACINFO_start_file will need to be ignored as it was already executed
10369 to create CURRENT_FILE for the main source holding also the command line
10370 definitions. On first met DW_MACINFO_start_file this flag is reset to
10371 normally execute all the remaining DW_MACINFO_start_file macinfos. */
10373 at_commandline
= 1;
10377 /* Do we at least have room for a macinfo type byte? */
10378 if (mac_ptr
>= mac_end
)
10380 dwarf2_macros_too_long_complaint ();
10384 macinfo_type
= read_1_byte (abfd
, mac_ptr
);
10387 switch (macinfo_type
)
10389 /* A zero macinfo type indicates the end of the macro
10394 case DW_MACINFO_define
:
10395 case DW_MACINFO_undef
:
10397 unsigned int bytes_read
;
10401 line
= read_unsigned_leb128 (abfd
, mac_ptr
, &bytes_read
);
10402 mac_ptr
+= bytes_read
;
10403 body
= read_string (abfd
, mac_ptr
, &bytes_read
);
10404 mac_ptr
+= bytes_read
;
10406 if (! current_file
)
10408 /* DWARF violation as no main source is present. */
10409 complaint (&symfile_complaints
,
10410 _("debug info with no main source gives macro %s "
10413 DW_MACINFO_define
? _("definition") : macinfo_type
==
10414 DW_MACINFO_undef
? _("undefinition") :
10415 "something-or-other", line
, body
);
10418 if ((line
== 0 && !at_commandline
) || (line
!= 0 && at_commandline
))
10419 complaint (&symfile_complaints
,
10420 _("debug info gives %s macro %s with %s line %d: %s"),
10421 at_commandline
? _("command-line") : _("in-file"),
10423 DW_MACINFO_define
? _("definition") : macinfo_type
==
10424 DW_MACINFO_undef
? _("undefinition") :
10425 "something-or-other",
10426 line
== 0 ? _("zero") : _("non-zero"), line
, body
);
10428 if (macinfo_type
== DW_MACINFO_define
)
10429 parse_macro_definition (current_file
, line
, body
);
10430 else if (macinfo_type
== DW_MACINFO_undef
)
10431 macro_undef (current_file
, line
, body
);
10435 case DW_MACINFO_start_file
:
10437 unsigned int bytes_read
;
10440 line
= read_unsigned_leb128 (abfd
, mac_ptr
, &bytes_read
);
10441 mac_ptr
+= bytes_read
;
10442 file
= read_unsigned_leb128 (abfd
, mac_ptr
, &bytes_read
);
10443 mac_ptr
+= bytes_read
;
10445 if ((line
== 0 && !at_commandline
) || (line
!= 0 && at_commandline
))
10446 complaint (&symfile_complaints
,
10447 _("debug info gives source %d included "
10448 "from %s at %s line %d"),
10449 file
, at_commandline
? _("command-line") : _("file"),
10450 line
== 0 ? _("zero") : _("non-zero"), line
);
10452 if (at_commandline
)
10454 /* This DW_MACINFO_start_file was executed in the pass one. */
10455 at_commandline
= 0;
10458 current_file
= macro_start_file (file
, line
,
10459 current_file
, comp_dir
,
10464 case DW_MACINFO_end_file
:
10465 if (! current_file
)
10466 complaint (&symfile_complaints
,
10467 _("macro debug info has an unmatched `close_file' directive"));
10470 current_file
= current_file
->included_by
;
10471 if (! current_file
)
10473 enum dwarf_macinfo_record_type next_type
;
10475 /* GCC circa March 2002 doesn't produce the zero
10476 type byte marking the end of the compilation
10477 unit. Complain if it's not there, but exit no
10480 /* Do we at least have room for a macinfo type byte? */
10481 if (mac_ptr
>= mac_end
)
10483 dwarf2_macros_too_long_complaint ();
10487 /* We don't increment mac_ptr here, so this is just
10489 next_type
= read_1_byte (abfd
, mac_ptr
);
10490 if (next_type
!= 0)
10491 complaint (&symfile_complaints
,
10492 _("no terminating 0-type entry for macros in `.debug_macinfo' section"));
10499 case DW_MACINFO_vendor_ext
:
10501 unsigned int bytes_read
;
10505 constant
= read_unsigned_leb128 (abfd
, mac_ptr
, &bytes_read
);
10506 mac_ptr
+= bytes_read
;
10507 string
= read_string (abfd
, mac_ptr
, &bytes_read
);
10508 mac_ptr
+= bytes_read
;
10510 /* We don't recognize any vendor extensions. */
10514 } while (macinfo_type
!= 0);
10517 /* Check if the attribute's form is a DW_FORM_block*
10518 if so return true else false. */
10520 attr_form_is_block (struct attribute
*attr
)
10522 return (attr
== NULL
? 0 :
10523 attr
->form
== DW_FORM_block1
10524 || attr
->form
== DW_FORM_block2
10525 || attr
->form
== DW_FORM_block4
10526 || attr
->form
== DW_FORM_block
);
10529 /* Return non-zero if ATTR's value is a section offset --- classes
10530 lineptr, loclistptr, macptr or rangelistptr --- or zero, otherwise.
10531 You may use DW_UNSND (attr) to retrieve such offsets.
10533 Section 7.5.4, "Attribute Encodings", explains that no attribute
10534 may have a value that belongs to more than one of these classes; it
10535 would be ambiguous if we did, because we use the same forms for all
10538 attr_form_is_section_offset (struct attribute
*attr
)
10540 return (attr
->form
== DW_FORM_data4
10541 || attr
->form
== DW_FORM_data8
);
10545 /* Return non-zero if ATTR's value falls in the 'constant' class, or
10546 zero otherwise. When this function returns true, you can apply
10547 dwarf2_get_attr_constant_value to it.
10549 However, note that for some attributes you must check
10550 attr_form_is_section_offset before using this test. DW_FORM_data4
10551 and DW_FORM_data8 are members of both the constant class, and of
10552 the classes that contain offsets into other debug sections
10553 (lineptr, loclistptr, macptr or rangelistptr). The DWARF spec says
10554 that, if an attribute's can be either a constant or one of the
10555 section offset classes, DW_FORM_data4 and DW_FORM_data8 should be
10556 taken as section offsets, not constants. */
10558 attr_form_is_constant (struct attribute
*attr
)
10560 switch (attr
->form
)
10562 case DW_FORM_sdata
:
10563 case DW_FORM_udata
:
10564 case DW_FORM_data1
:
10565 case DW_FORM_data2
:
10566 case DW_FORM_data4
:
10567 case DW_FORM_data8
:
10575 dwarf2_symbol_mark_computed (struct attribute
*attr
, struct symbol
*sym
,
10576 struct dwarf2_cu
*cu
)
10578 if (attr_form_is_section_offset (attr
)
10579 /* ".debug_loc" may not exist at all, or the offset may be outside
10580 the section. If so, fall through to the complaint in the
10582 && DW_UNSND (attr
) < dwarf2_per_objfile
->loc
.size
)
10584 struct dwarf2_loclist_baton
*baton
;
10586 baton
= obstack_alloc (&cu
->objfile
->objfile_obstack
,
10587 sizeof (struct dwarf2_loclist_baton
));
10588 baton
->per_cu
= cu
->per_cu
;
10589 gdb_assert (baton
->per_cu
);
10591 /* We don't know how long the location list is, but make sure we
10592 don't run off the edge of the section. */
10593 baton
->size
= dwarf2_per_objfile
->loc
.size
- DW_UNSND (attr
);
10594 baton
->data
= dwarf2_per_objfile
->loc
.buffer
+ DW_UNSND (attr
);
10595 baton
->base_address
= cu
->base_address
;
10596 if (cu
->base_known
== 0)
10597 complaint (&symfile_complaints
,
10598 _("Location list used without specifying the CU base address."));
10600 SYMBOL_COMPUTED_OPS (sym
) = &dwarf2_loclist_funcs
;
10601 SYMBOL_LOCATION_BATON (sym
) = baton
;
10605 struct dwarf2_locexpr_baton
*baton
;
10607 baton
= obstack_alloc (&cu
->objfile
->objfile_obstack
,
10608 sizeof (struct dwarf2_locexpr_baton
));
10609 baton
->per_cu
= cu
->per_cu
;
10610 gdb_assert (baton
->per_cu
);
10612 if (attr_form_is_block (attr
))
10614 /* Note that we're just copying the block's data pointer
10615 here, not the actual data. We're still pointing into the
10616 info_buffer for SYM's objfile; right now we never release
10617 that buffer, but when we do clean up properly this may
10619 baton
->size
= DW_BLOCK (attr
)->size
;
10620 baton
->data
= DW_BLOCK (attr
)->data
;
10624 dwarf2_invalid_attrib_class_complaint ("location description",
10625 SYMBOL_NATURAL_NAME (sym
));
10627 baton
->data
= NULL
;
10630 SYMBOL_COMPUTED_OPS (sym
) = &dwarf2_locexpr_funcs
;
10631 SYMBOL_LOCATION_BATON (sym
) = baton
;
10635 /* Return the OBJFILE associated with the compilation unit CU. */
10638 dwarf2_per_cu_objfile (struct dwarf2_per_cu_data
*per_cu
)
10640 struct objfile
*objfile
= per_cu
->psymtab
->objfile
;
10642 /* Return the master objfile, so that we can report and look up the
10643 correct file containing this variable. */
10644 if (objfile
->separate_debug_objfile_backlink
)
10645 objfile
= objfile
->separate_debug_objfile_backlink
;
10650 /* Return the address size given in the compilation unit header for CU. */
10653 dwarf2_per_cu_addr_size (struct dwarf2_per_cu_data
*per_cu
)
10656 return per_cu
->cu
->header
.addr_size
;
10659 /* If the CU is not currently read in, we re-read its header. */
10660 struct objfile
*objfile
= per_cu
->psymtab
->objfile
;
10661 struct dwarf2_per_objfile
*per_objfile
10662 = objfile_data (objfile
, dwarf2_objfile_data_key
);
10663 gdb_byte
*info_ptr
= per_objfile
->info
.buffer
+ per_cu
->offset
;
10665 struct comp_unit_head cu_header
;
10666 memset (&cu_header
, 0, sizeof cu_header
);
10667 read_comp_unit_head (&cu_header
, info_ptr
, objfile
->obfd
);
10668 return cu_header
.addr_size
;
10672 /* Locate the compilation unit from CU's objfile which contains the
10673 DIE at OFFSET. Raises an error on failure. */
10675 static struct dwarf2_per_cu_data
*
10676 dwarf2_find_containing_comp_unit (unsigned int offset
,
10677 struct objfile
*objfile
)
10679 struct dwarf2_per_cu_data
*this_cu
;
10683 high
= dwarf2_per_objfile
->n_comp_units
- 1;
10686 int mid
= low
+ (high
- low
) / 2;
10687 if (dwarf2_per_objfile
->all_comp_units
[mid
]->offset
>= offset
)
10692 gdb_assert (low
== high
);
10693 if (dwarf2_per_objfile
->all_comp_units
[low
]->offset
> offset
)
10696 error (_("Dwarf Error: could not find partial DIE containing "
10697 "offset 0x%lx [in module %s]"),
10698 (long) offset
, bfd_get_filename (objfile
->obfd
));
10700 gdb_assert (dwarf2_per_objfile
->all_comp_units
[low
-1]->offset
<= offset
);
10701 return dwarf2_per_objfile
->all_comp_units
[low
-1];
10705 this_cu
= dwarf2_per_objfile
->all_comp_units
[low
];
10706 if (low
== dwarf2_per_objfile
->n_comp_units
- 1
10707 && offset
>= this_cu
->offset
+ this_cu
->length
)
10708 error (_("invalid dwarf2 offset %u"), offset
);
10709 gdb_assert (offset
< this_cu
->offset
+ this_cu
->length
);
10714 /* Locate the compilation unit from OBJFILE which is located at exactly
10715 OFFSET. Raises an error on failure. */
10717 static struct dwarf2_per_cu_data
*
10718 dwarf2_find_comp_unit (unsigned int offset
, struct objfile
*objfile
)
10720 struct dwarf2_per_cu_data
*this_cu
;
10721 this_cu
= dwarf2_find_containing_comp_unit (offset
, objfile
);
10722 if (this_cu
->offset
!= offset
)
10723 error (_("no compilation unit with offset %u."), offset
);
10727 /* Release one cached compilation unit, CU. We unlink it from the tree
10728 of compilation units, but we don't remove it from the read_in_chain;
10729 the caller is responsible for that. */
10732 free_one_comp_unit (void *data
)
10734 struct dwarf2_cu
*cu
= data
;
10736 if (cu
->per_cu
!= NULL
)
10737 cu
->per_cu
->cu
= NULL
;
10740 obstack_free (&cu
->comp_unit_obstack
, NULL
);
10745 /* This cleanup function is passed the address of a dwarf2_cu on the stack
10746 when we're finished with it. We can't free the pointer itself, but be
10747 sure to unlink it from the cache. Also release any associated storage
10748 and perform cache maintenance.
10750 Only used during partial symbol parsing. */
10753 free_stack_comp_unit (void *data
)
10755 struct dwarf2_cu
*cu
= data
;
10757 obstack_free (&cu
->comp_unit_obstack
, NULL
);
10758 cu
->partial_dies
= NULL
;
10760 if (cu
->per_cu
!= NULL
)
10762 /* This compilation unit is on the stack in our caller, so we
10763 should not xfree it. Just unlink it. */
10764 cu
->per_cu
->cu
= NULL
;
10767 /* If we had a per-cu pointer, then we may have other compilation
10768 units loaded, so age them now. */
10769 age_cached_comp_units ();
10773 /* Free all cached compilation units. */
10776 free_cached_comp_units (void *data
)
10778 struct dwarf2_per_cu_data
*per_cu
, **last_chain
;
10780 per_cu
= dwarf2_per_objfile
->read_in_chain
;
10781 last_chain
= &dwarf2_per_objfile
->read_in_chain
;
10782 while (per_cu
!= NULL
)
10784 struct dwarf2_per_cu_data
*next_cu
;
10786 next_cu
= per_cu
->cu
->read_in_chain
;
10788 free_one_comp_unit (per_cu
->cu
);
10789 *last_chain
= next_cu
;
10795 /* Increase the age counter on each cached compilation unit, and free
10796 any that are too old. */
10799 age_cached_comp_units (void)
10801 struct dwarf2_per_cu_data
*per_cu
, **last_chain
;
10803 dwarf2_clear_marks (dwarf2_per_objfile
->read_in_chain
);
10804 per_cu
= dwarf2_per_objfile
->read_in_chain
;
10805 while (per_cu
!= NULL
)
10807 per_cu
->cu
->last_used
++;
10808 if (per_cu
->cu
->last_used
<= dwarf2_max_cache_age
)
10809 dwarf2_mark (per_cu
->cu
);
10810 per_cu
= per_cu
->cu
->read_in_chain
;
10813 per_cu
= dwarf2_per_objfile
->read_in_chain
;
10814 last_chain
= &dwarf2_per_objfile
->read_in_chain
;
10815 while (per_cu
!= NULL
)
10817 struct dwarf2_per_cu_data
*next_cu
;
10819 next_cu
= per_cu
->cu
->read_in_chain
;
10821 if (!per_cu
->cu
->mark
)
10823 free_one_comp_unit (per_cu
->cu
);
10824 *last_chain
= next_cu
;
10827 last_chain
= &per_cu
->cu
->read_in_chain
;
10833 /* Remove a single compilation unit from the cache. */
10836 free_one_cached_comp_unit (void *target_cu
)
10838 struct dwarf2_per_cu_data
*per_cu
, **last_chain
;
10840 per_cu
= dwarf2_per_objfile
->read_in_chain
;
10841 last_chain
= &dwarf2_per_objfile
->read_in_chain
;
10842 while (per_cu
!= NULL
)
10844 struct dwarf2_per_cu_data
*next_cu
;
10846 next_cu
= per_cu
->cu
->read_in_chain
;
10848 if (per_cu
->cu
== target_cu
)
10850 free_one_comp_unit (per_cu
->cu
);
10851 *last_chain
= next_cu
;
10855 last_chain
= &per_cu
->cu
->read_in_chain
;
10861 /* Release all extra memory associated with OBJFILE. */
10864 dwarf2_free_objfile (struct objfile
*objfile
)
10866 dwarf2_per_objfile
= objfile_data (objfile
, dwarf2_objfile_data_key
);
10868 if (dwarf2_per_objfile
== NULL
)
10871 /* Cached DIE trees use xmalloc and the comp_unit_obstack. */
10872 free_cached_comp_units (NULL
);
10874 /* Everything else should be on the objfile obstack. */
10877 /* A pair of DIE offset and GDB type pointer. We store these
10878 in a hash table separate from the DIEs, and preserve them
10879 when the DIEs are flushed out of cache. */
10881 struct dwarf2_offset_and_type
10883 unsigned int offset
;
10887 /* Hash function for a dwarf2_offset_and_type. */
10890 offset_and_type_hash (const void *item
)
10892 const struct dwarf2_offset_and_type
*ofs
= item
;
10893 return ofs
->offset
;
10896 /* Equality function for a dwarf2_offset_and_type. */
10899 offset_and_type_eq (const void *item_lhs
, const void *item_rhs
)
10901 const struct dwarf2_offset_and_type
*ofs_lhs
= item_lhs
;
10902 const struct dwarf2_offset_and_type
*ofs_rhs
= item_rhs
;
10903 return ofs_lhs
->offset
== ofs_rhs
->offset
;
10906 /* Set the type associated with DIE to TYPE. Save it in CU's hash
10907 table if necessary. For convenience, return TYPE. */
10909 static struct type
*
10910 set_die_type (struct die_info
*die
, struct type
*type
, struct dwarf2_cu
*cu
)
10912 struct dwarf2_offset_and_type
**slot
, ofs
;
10914 if (cu
->type_hash
== NULL
)
10916 gdb_assert (cu
->per_cu
!= NULL
);
10917 cu
->per_cu
->type_hash
10918 = htab_create_alloc_ex (cu
->header
.length
/ 24,
10919 offset_and_type_hash
,
10920 offset_and_type_eq
,
10922 &cu
->objfile
->objfile_obstack
,
10923 hashtab_obstack_allocate
,
10924 dummy_obstack_deallocate
);
10925 cu
->type_hash
= cu
->per_cu
->type_hash
;
10928 ofs
.offset
= die
->offset
;
10930 slot
= (struct dwarf2_offset_and_type
**)
10931 htab_find_slot_with_hash (cu
->type_hash
, &ofs
, ofs
.offset
, INSERT
);
10932 *slot
= obstack_alloc (&cu
->objfile
->objfile_obstack
, sizeof (**slot
));
10937 /* Find the type for DIE in CU's type_hash, or return NULL if DIE does
10938 not have a saved type. */
10940 static struct type
*
10941 get_die_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
10943 struct dwarf2_offset_and_type
*slot
, ofs
;
10944 htab_t type_hash
= cu
->type_hash
;
10946 if (type_hash
== NULL
)
10949 ofs
.offset
= die
->offset
;
10950 slot
= htab_find_with_hash (type_hash
, &ofs
, ofs
.offset
);
10957 /* Add a dependence relationship from CU to REF_PER_CU. */
10960 dwarf2_add_dependence (struct dwarf2_cu
*cu
,
10961 struct dwarf2_per_cu_data
*ref_per_cu
)
10965 if (cu
->dependencies
== NULL
)
10967 = htab_create_alloc_ex (5, htab_hash_pointer
, htab_eq_pointer
,
10968 NULL
, &cu
->comp_unit_obstack
,
10969 hashtab_obstack_allocate
,
10970 dummy_obstack_deallocate
);
10972 slot
= htab_find_slot (cu
->dependencies
, ref_per_cu
, INSERT
);
10974 *slot
= ref_per_cu
;
10977 /* Subroutine of dwarf2_mark to pass to htab_traverse.
10978 Set the mark field in every compilation unit in the
10979 cache that we must keep because we are keeping CU. */
10982 dwarf2_mark_helper (void **slot
, void *data
)
10984 struct dwarf2_per_cu_data
*per_cu
;
10986 per_cu
= (struct dwarf2_per_cu_data
*) *slot
;
10987 if (per_cu
->cu
->mark
)
10989 per_cu
->cu
->mark
= 1;
10991 if (per_cu
->cu
->dependencies
!= NULL
)
10992 htab_traverse (per_cu
->cu
->dependencies
, dwarf2_mark_helper
, NULL
);
10997 /* Set the mark field in CU and in every other compilation unit in the
10998 cache that we must keep because we are keeping CU. */
11001 dwarf2_mark (struct dwarf2_cu
*cu
)
11006 if (cu
->dependencies
!= NULL
)
11007 htab_traverse (cu
->dependencies
, dwarf2_mark_helper
, NULL
);
11011 dwarf2_clear_marks (struct dwarf2_per_cu_data
*per_cu
)
11015 per_cu
->cu
->mark
= 0;
11016 per_cu
= per_cu
->cu
->read_in_chain
;
11020 /* Trivial hash function for partial_die_info: the hash value of a DIE
11021 is its offset in .debug_info for this objfile. */
11024 partial_die_hash (const void *item
)
11026 const struct partial_die_info
*part_die
= item
;
11027 return part_die
->offset
;
11030 /* Trivial comparison function for partial_die_info structures: two DIEs
11031 are equal if they have the same offset. */
11034 partial_die_eq (const void *item_lhs
, const void *item_rhs
)
11036 const struct partial_die_info
*part_die_lhs
= item_lhs
;
11037 const struct partial_die_info
*part_die_rhs
= item_rhs
;
11038 return part_die_lhs
->offset
== part_die_rhs
->offset
;
11041 static struct cmd_list_element
*set_dwarf2_cmdlist
;
11042 static struct cmd_list_element
*show_dwarf2_cmdlist
;
11045 set_dwarf2_cmd (char *args
, int from_tty
)
11047 help_list (set_dwarf2_cmdlist
, "maintenance set dwarf2 ", -1, gdb_stdout
);
11051 show_dwarf2_cmd (char *args
, int from_tty
)
11053 cmd_show_list (show_dwarf2_cmdlist
, from_tty
, "");
11056 /* If section described by INFO was mmapped, munmap it now. */
11059 munmap_section_buffer (struct dwarf2_section_info
*info
)
11061 if (info
->was_mmapped
)
11064 intptr_t begin
= (intptr_t) info
->buffer
;
11065 intptr_t map_begin
= begin
& ~(pagesize
- 1);
11066 size_t map_length
= info
->size
+ begin
- map_begin
;
11067 gdb_assert (munmap ((void *) map_begin
, map_length
) == 0);
11069 /* Without HAVE_MMAP, we should never be here to begin with. */
11075 /* munmap debug sections for OBJFILE, if necessary. */
11078 dwarf2_per_objfile_cleanup (struct objfile
*objfile
, void *d
)
11080 struct dwarf2_per_objfile
*data
= d
;
11081 munmap_section_buffer (&data
->info
);
11082 munmap_section_buffer (&data
->abbrev
);
11083 munmap_section_buffer (&data
->line
);
11084 munmap_section_buffer (&data
->str
);
11085 munmap_section_buffer (&data
->macinfo
);
11086 munmap_section_buffer (&data
->ranges
);
11087 munmap_section_buffer (&data
->loc
);
11088 munmap_section_buffer (&data
->frame
);
11089 munmap_section_buffer (&data
->eh_frame
);
11092 void _initialize_dwarf2_read (void);
11095 _initialize_dwarf2_read (void)
11097 dwarf2_objfile_data_key
11098 = register_objfile_data_with_cleanup (dwarf2_per_objfile_cleanup
);
11100 add_prefix_cmd ("dwarf2", class_maintenance
, set_dwarf2_cmd
, _("\
11101 Set DWARF 2 specific variables.\n\
11102 Configure DWARF 2 variables such as the cache size"),
11103 &set_dwarf2_cmdlist
, "maintenance set dwarf2 ",
11104 0/*allow-unknown*/, &maintenance_set_cmdlist
);
11106 add_prefix_cmd ("dwarf2", class_maintenance
, show_dwarf2_cmd
, _("\
11107 Show DWARF 2 specific variables\n\
11108 Show DWARF 2 variables such as the cache size"),
11109 &show_dwarf2_cmdlist
, "maintenance show dwarf2 ",
11110 0/*allow-unknown*/, &maintenance_show_cmdlist
);
11112 add_setshow_zinteger_cmd ("max-cache-age", class_obscure
,
11113 &dwarf2_max_cache_age
, _("\
11114 Set the upper bound on the age of cached dwarf2 compilation units."), _("\
11115 Show the upper bound on the age of cached dwarf2 compilation units."), _("\
11116 A higher limit means that cached compilation units will be stored\n\
11117 in memory longer, and more total memory will be used. Zero disables\n\
11118 caching, which can slow down startup."),
11120 show_dwarf2_max_cache_age
,
11121 &set_dwarf2_cmdlist
,
11122 &show_dwarf2_cmdlist
);
11124 add_setshow_zinteger_cmd ("dwarf2-die", no_class
, &dwarf2_die_debug
, _("\
11125 Set debugging of the dwarf2 DIE reader."), _("\
11126 Show debugging of the dwarf2 DIE reader."), _("\
11127 When enabled (non-zero), DIEs are dumped after they are read in.\n\
11128 The value is the maximum depth to print."),
11131 &setdebuglist
, &showdebuglist
);