1 /* DWARF 2 debugging format support for GDB.
3 Copyright (C) 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2001,
4 2002, 2003, 2004, 2005, 2006
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
12 support in dwarfread.c
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 2 of the License, or (at
19 your option) any later version.
21 This program is distributed in the hope that it will be useful, but
22 WITHOUT ANY WARRANTY; without even the implied warranty of
23 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
24 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, write to the Free Software
28 Foundation, Inc., 51 Franklin Street, Fifth Floor,
29 Boston, MA 02110-1301, USA. */
36 #include "elf/dwarf2.h"
39 #include "expression.h"
40 #include "filenames.h" /* for DOSish file names */
43 #include "complaints.h"
45 #include "dwarf2expr.h"
46 #include "dwarf2loc.h"
47 #include "cp-support.h"
53 #include "gdb_string.h"
54 #include "gdb_assert.h"
55 #include <sys/types.h>
57 /* A note on memory usage for this file.
59 At the present time, this code reads the debug info sections into
60 the objfile's objfile_obstack. A definite improvement for startup
61 time, on platforms which do not emit relocations for debug
62 sections, would be to use mmap instead. The object's complete
63 debug information is loaded into memory, partly to simplify
64 absolute DIE references.
66 Whether using obstacks or mmap, the sections should remain loaded
67 until the objfile is released, and pointers into the section data
68 can be used for any other data associated to the objfile (symbol
69 names, type names, location expressions to name a few). */
71 #ifndef DWARF2_REG_TO_REGNUM
72 #define DWARF2_REG_TO_REGNUM(REG) (REG)
76 /* .debug_info header for a compilation unit
77 Because of alignment constraints, this structure has padding and cannot
78 be mapped directly onto the beginning of the .debug_info section. */
79 typedef struct comp_unit_header
81 unsigned int length
; /* length of the .debug_info
83 unsigned short version
; /* version number -- 2 for DWARF
85 unsigned int abbrev_offset
; /* offset into .debug_abbrev section */
86 unsigned char addr_size
; /* byte size of an address -- 4 */
89 #define _ACTUAL_COMP_UNIT_HEADER_SIZE 11
92 /* .debug_pubnames header
93 Because of alignment constraints, this structure has padding and cannot
94 be mapped directly onto the beginning of the .debug_info section. */
95 typedef struct pubnames_header
97 unsigned int length
; /* length of the .debug_pubnames
99 unsigned char version
; /* version number -- 2 for DWARF
101 unsigned int info_offset
; /* offset into .debug_info section */
102 unsigned int info_size
; /* byte size of .debug_info section
106 #define _ACTUAL_PUBNAMES_HEADER_SIZE 13
108 /* .debug_pubnames header
109 Because of alignment constraints, this structure has padding and cannot
110 be mapped directly onto the beginning of the .debug_info section. */
111 typedef struct aranges_header
113 unsigned int length
; /* byte len of the .debug_aranges
115 unsigned short version
; /* version number -- 2 for DWARF
117 unsigned int info_offset
; /* offset into .debug_info section */
118 unsigned char addr_size
; /* byte size of an address */
119 unsigned char seg_size
; /* byte size of segment descriptor */
122 #define _ACTUAL_ARANGES_HEADER_SIZE 12
124 /* .debug_line statement program prologue
125 Because of alignment constraints, this structure has padding and cannot
126 be mapped directly onto the beginning of the .debug_info section. */
127 typedef struct statement_prologue
129 unsigned int total_length
; /* byte length of the statement
131 unsigned short version
; /* version number -- 2 for DWARF
133 unsigned int prologue_length
; /* # bytes between prologue &
135 unsigned char minimum_instruction_length
; /* byte size of
137 unsigned char default_is_stmt
; /* initial value of is_stmt
140 unsigned char line_range
;
141 unsigned char opcode_base
; /* number assigned to first special
143 unsigned char *standard_opcode_lengths
;
147 static const struct objfile_data
*dwarf2_objfile_data_key
;
149 struct dwarf2_per_objfile
151 /* Sizes of debugging sections. */
152 unsigned int info_size
;
153 unsigned int abbrev_size
;
154 unsigned int line_size
;
155 unsigned int pubnames_size
;
156 unsigned int aranges_size
;
157 unsigned int loc_size
;
158 unsigned int macinfo_size
;
159 unsigned int str_size
;
160 unsigned int ranges_size
;
161 unsigned int frame_size
;
162 unsigned int eh_frame_size
;
164 /* Loaded data from the sections. */
165 gdb_byte
*info_buffer
;
166 gdb_byte
*abbrev_buffer
;
167 gdb_byte
*line_buffer
;
168 gdb_byte
*str_buffer
;
169 gdb_byte
*macinfo_buffer
;
170 gdb_byte
*ranges_buffer
;
171 gdb_byte
*loc_buffer
;
173 /* A list of all the compilation units. This is used to locate
174 the target compilation unit of a particular reference. */
175 struct dwarf2_per_cu_data
**all_comp_units
;
177 /* The number of compilation units in ALL_COMP_UNITS. */
180 /* A chain of compilation units that are currently read in, so that
181 they can be freed later. */
182 struct dwarf2_per_cu_data
*read_in_chain
;
184 /* A flag indicating wether this objfile has a section loaded at a
186 int has_section_at_zero
;
189 static struct dwarf2_per_objfile
*dwarf2_per_objfile
;
191 static asection
*dwarf_info_section
;
192 static asection
*dwarf_abbrev_section
;
193 static asection
*dwarf_line_section
;
194 static asection
*dwarf_pubnames_section
;
195 static asection
*dwarf_aranges_section
;
196 static asection
*dwarf_loc_section
;
197 static asection
*dwarf_macinfo_section
;
198 static asection
*dwarf_str_section
;
199 static asection
*dwarf_ranges_section
;
200 asection
*dwarf_frame_section
;
201 asection
*dwarf_eh_frame_section
;
203 /* names of the debugging sections */
205 #define INFO_SECTION ".debug_info"
206 #define ABBREV_SECTION ".debug_abbrev"
207 #define LINE_SECTION ".debug_line"
208 #define PUBNAMES_SECTION ".debug_pubnames"
209 #define ARANGES_SECTION ".debug_aranges"
210 #define LOC_SECTION ".debug_loc"
211 #define MACINFO_SECTION ".debug_macinfo"
212 #define STR_SECTION ".debug_str"
213 #define RANGES_SECTION ".debug_ranges"
214 #define FRAME_SECTION ".debug_frame"
215 #define EH_FRAME_SECTION ".eh_frame"
217 /* local data types */
219 /* We hold several abbreviation tables in memory at the same time. */
220 #ifndef ABBREV_HASH_SIZE
221 #define ABBREV_HASH_SIZE 121
224 /* The data in a compilation unit header, after target2host
225 translation, looks like this. */
226 struct comp_unit_head
228 unsigned long length
;
230 unsigned int abbrev_offset
;
231 unsigned char addr_size
;
232 unsigned char signed_addr_p
;
234 /* Size of file offsets; either 4 or 8. */
235 unsigned int offset_size
;
237 /* Size of the length field; either 4 or 12. */
238 unsigned int initial_length_size
;
240 /* Offset to the first byte of this compilation unit header in the
241 .debug_info section, for resolving relative reference dies. */
244 /* Pointer to this compilation unit header in the .debug_info
246 gdb_byte
*cu_head_ptr
;
248 /* Pointer to the first die of this compilation unit. This will be
249 the first byte following the compilation unit header. */
250 gdb_byte
*first_die_ptr
;
252 /* Pointer to the next compilation unit header in the program. */
253 struct comp_unit_head
*next
;
255 /* Base address of this compilation unit. */
256 CORE_ADDR base_address
;
258 /* Non-zero if base_address has been set. */
262 /* Fixed size for the DIE hash table. */
263 #ifndef REF_HASH_SIZE
264 #define REF_HASH_SIZE 1021
267 /* Internal state when decoding a particular compilation unit. */
270 /* The objfile containing this compilation unit. */
271 struct objfile
*objfile
;
273 /* The header of the compilation unit.
275 FIXME drow/2003-11-10: Some of the things from the comp_unit_head
276 should logically be moved to the dwarf2_cu structure. */
277 struct comp_unit_head header
;
279 struct function_range
*first_fn
, *last_fn
, *cached_fn
;
281 /* The language we are debugging. */
282 enum language language
;
283 const struct language_defn
*language_defn
;
285 const char *producer
;
287 /* The generic symbol table building routines have separate lists for
288 file scope symbols and all all other scopes (local scopes). So
289 we need to select the right one to pass to add_symbol_to_list().
290 We do it by keeping a pointer to the correct list in list_in_scope.
292 FIXME: The original dwarf code just treated the file scope as the
293 first local scope, and all other local scopes as nested local
294 scopes, and worked fine. Check to see if we really need to
295 distinguish these in buildsym.c. */
296 struct pending
**list_in_scope
;
298 /* Maintain an array of referenced fundamental types for the current
299 compilation unit being read. For DWARF version 1, we have to construct
300 the fundamental types on the fly, since no information about the
301 fundamental types is supplied. Each such fundamental type is created by
302 calling a language dependent routine to create the type, and then a
303 pointer to that type is then placed in the array at the index specified
304 by it's FT_<TYPENAME> value. The array has a fixed size set by the
305 FT_NUM_MEMBERS compile time constant, which is the number of predefined
306 fundamental types gdb knows how to construct. */
307 struct type
*ftypes
[FT_NUM_MEMBERS
]; /* Fundamental types */
309 /* DWARF abbreviation table associated with this compilation unit. */
310 struct abbrev_info
**dwarf2_abbrevs
;
312 /* Storage for the abbrev table. */
313 struct obstack abbrev_obstack
;
315 /* Hash table holding all the loaded partial DIEs. */
318 /* Storage for things with the same lifetime as this read-in compilation
319 unit, including partial DIEs. */
320 struct obstack comp_unit_obstack
;
322 /* When multiple dwarf2_cu structures are living in memory, this field
323 chains them all together, so that they can be released efficiently.
324 We will probably also want a generation counter so that most-recently-used
325 compilation units are cached... */
326 struct dwarf2_per_cu_data
*read_in_chain
;
328 /* Backchain to our per_cu entry if the tree has been built. */
329 struct dwarf2_per_cu_data
*per_cu
;
331 /* How many compilation units ago was this CU last referenced? */
334 /* A hash table of die offsets for following references. */
335 struct die_info
*die_ref_table
[REF_HASH_SIZE
];
337 /* Full DIEs if read in. */
338 struct die_info
*dies
;
340 /* A set of pointers to dwarf2_per_cu_data objects for compilation
341 units referenced by this one. Only set during full symbol processing;
342 partial symbol tables do not have dependencies. */
345 /* Mark used when releasing cached dies. */
346 unsigned int mark
: 1;
348 /* This flag will be set if this compilation unit might include
349 inter-compilation-unit references. */
350 unsigned int has_form_ref_addr
: 1;
352 /* This flag will be set if this compilation unit includes any
353 DW_TAG_namespace DIEs. If we know that there are explicit
354 DIEs for namespaces, we don't need to try to infer them
355 from mangled names. */
356 unsigned int has_namespace_info
: 1;
359 /* Persistent data held for a compilation unit, even when not
360 processing it. We put a pointer to this structure in the
361 read_symtab_private field of the psymtab. If we encounter
362 inter-compilation-unit references, we also maintain a sorted
363 list of all compilation units. */
365 struct dwarf2_per_cu_data
367 /* The start offset and length of this compilation unit. 2**30-1
368 bytes should suffice to store the length of any compilation unit
369 - if it doesn't, GDB will fall over anyway. */
370 unsigned long offset
;
371 unsigned long length
: 30;
373 /* Flag indicating this compilation unit will be read in before
374 any of the current compilation units are processed. */
375 unsigned long queued
: 1;
377 /* This flag will be set if we need to load absolutely all DIEs
378 for this compilation unit, instead of just the ones we think
379 are interesting. It gets set if we look for a DIE in the
380 hash table and don't find it. */
381 unsigned int load_all_dies
: 1;
383 /* Set iff currently read in. */
384 struct dwarf2_cu
*cu
;
386 /* If full symbols for this CU have been read in, then this field
387 holds a map of DIE offsets to types. It isn't always possible
388 to reconstruct this information later, so we have to preserve
392 /* The partial symbol table associated with this compilation unit,
393 or NULL for partial units (which do not have an associated
395 struct partial_symtab
*psymtab
;
398 /* The line number information for a compilation unit (found in the
399 .debug_line section) begins with a "statement program header",
400 which contains the following information. */
403 unsigned int total_length
;
404 unsigned short version
;
405 unsigned int header_length
;
406 unsigned char minimum_instruction_length
;
407 unsigned char default_is_stmt
;
409 unsigned char line_range
;
410 unsigned char opcode_base
;
412 /* standard_opcode_lengths[i] is the number of operands for the
413 standard opcode whose value is i. This means that
414 standard_opcode_lengths[0] is unused, and the last meaningful
415 element is standard_opcode_lengths[opcode_base - 1]. */
416 unsigned char *standard_opcode_lengths
;
418 /* The include_directories table. NOTE! These strings are not
419 allocated with xmalloc; instead, they are pointers into
420 debug_line_buffer. If you try to free them, `free' will get
422 unsigned int num_include_dirs
, include_dirs_size
;
425 /* The file_names table. NOTE! These strings are not allocated
426 with xmalloc; instead, they are pointers into debug_line_buffer.
427 Don't try to free them directly. */
428 unsigned int num_file_names
, file_names_size
;
432 unsigned int dir_index
;
433 unsigned int mod_time
;
435 int included_p
; /* Non-zero if referenced by the Line Number Program. */
438 /* The start and end of the statement program following this
439 header. These point into dwarf2_per_objfile->line_buffer. */
440 gdb_byte
*statement_program_start
, *statement_program_end
;
443 /* When we construct a partial symbol table entry we only
444 need this much information. */
445 struct partial_die_info
447 /* Offset of this DIE. */
450 /* DWARF-2 tag for this DIE. */
451 ENUM_BITFIELD(dwarf_tag
) tag
: 16;
453 /* Language code associated with this DIE. This is only used
454 for the compilation unit DIE. */
455 unsigned int language
: 8;
457 /* Assorted flags describing the data found in this DIE. */
458 unsigned int has_children
: 1;
459 unsigned int is_external
: 1;
460 unsigned int is_declaration
: 1;
461 unsigned int has_type
: 1;
462 unsigned int has_specification
: 1;
463 unsigned int has_stmt_list
: 1;
464 unsigned int has_pc_info
: 1;
466 /* Flag set if the SCOPE field of this structure has been
468 unsigned int scope_set
: 1;
470 /* The name of this DIE. Normally the value of DW_AT_name, but
471 sometimes DW_TAG_MIPS_linkage_name or a string computed in some
476 /* The scope to prepend to our children. This is generally
477 allocated on the comp_unit_obstack, so will disappear
478 when this compilation unit leaves the cache. */
481 /* The location description associated with this DIE, if any. */
482 struct dwarf_block
*locdesc
;
484 /* If HAS_PC_INFO, the PC range associated with this DIE. */
488 /* Pointer into the info_buffer pointing at the target of
489 DW_AT_sibling, if any. */
492 /* If HAS_SPECIFICATION, the offset of the DIE referred to by
493 DW_AT_specification (or DW_AT_abstract_origin or
495 unsigned int spec_offset
;
497 /* If HAS_STMT_LIST, the offset of the Line Number Information data. */
498 unsigned int line_offset
;
500 /* Pointers to this DIE's parent, first child, and next sibling,
502 struct partial_die_info
*die_parent
, *die_child
, *die_sibling
;
505 /* This data structure holds the information of an abbrev. */
508 unsigned int number
; /* number identifying abbrev */
509 enum dwarf_tag tag
; /* dwarf tag */
510 unsigned short has_children
; /* boolean */
511 unsigned short num_attrs
; /* number of attributes */
512 struct attr_abbrev
*attrs
; /* an array of attribute descriptions */
513 struct abbrev_info
*next
; /* next in chain */
518 enum dwarf_attribute name
;
519 enum dwarf_form form
;
522 /* This data structure holds a complete die structure. */
525 enum dwarf_tag tag
; /* Tag indicating type of die */
526 unsigned int abbrev
; /* Abbrev number */
527 unsigned int offset
; /* Offset in .debug_info section */
528 unsigned int num_attrs
; /* Number of attributes */
529 struct attribute
*attrs
; /* An array of attributes */
530 struct die_info
*next_ref
; /* Next die in ref hash table */
532 /* The dies in a compilation unit form an n-ary tree. PARENT
533 points to this die's parent; CHILD points to the first child of
534 this node; and all the children of a given node are chained
535 together via their SIBLING fields, terminated by a die whose
537 struct die_info
*child
; /* Its first child, if any. */
538 struct die_info
*sibling
; /* Its next sibling, if any. */
539 struct die_info
*parent
; /* Its parent, if any. */
541 struct type
*type
; /* Cached type information */
544 /* Attributes have a name and a value */
547 enum dwarf_attribute name
;
548 enum dwarf_form form
;
552 struct dwarf_block
*blk
;
560 struct function_range
563 CORE_ADDR lowpc
, highpc
;
565 struct function_range
*next
;
568 /* Get at parts of an attribute structure */
570 #define DW_STRING(attr) ((attr)->u.str)
571 #define DW_UNSND(attr) ((attr)->u.unsnd)
572 #define DW_BLOCK(attr) ((attr)->u.blk)
573 #define DW_SND(attr) ((attr)->u.snd)
574 #define DW_ADDR(attr) ((attr)->u.addr)
576 /* Blocks are a bunch of untyped bytes. */
583 #ifndef ATTR_ALLOC_CHUNK
584 #define ATTR_ALLOC_CHUNK 4
587 /* Allocate fields for structs, unions and enums in this size. */
588 #ifndef DW_FIELD_ALLOC_CHUNK
589 #define DW_FIELD_ALLOC_CHUNK 4
592 /* A zeroed version of a partial die for initialization purposes. */
593 static struct partial_die_info zeroed_partial_die
;
595 /* FIXME: We might want to set this from BFD via bfd_arch_bits_per_byte,
596 but this would require a corresponding change in unpack_field_as_long
598 static int bits_per_byte
= 8;
600 /* The routines that read and process dies for a C struct or C++ class
601 pass lists of data member fields and lists of member function fields
602 in an instance of a field_info structure, as defined below. */
605 /* List of data member and baseclasses fields. */
608 struct nextfield
*next
;
615 /* Number of fields. */
618 /* Number of baseclasses. */
621 /* Set if the accesibility of one of the fields is not public. */
622 int non_public_fields
;
624 /* Member function fields array, entries are allocated in the order they
625 are encountered in the object file. */
628 struct nextfnfield
*next
;
629 struct fn_field fnfield
;
633 /* Member function fieldlist array, contains name of possibly overloaded
634 member function, number of overloaded member functions and a pointer
635 to the head of the member function field chain. */
640 struct nextfnfield
*head
;
644 /* Number of entries in the fnfieldlists array. */
648 /* One item on the queue of compilation units to read in full symbols
650 struct dwarf2_queue_item
652 struct dwarf2_per_cu_data
*per_cu
;
653 struct dwarf2_queue_item
*next
;
656 /* The current queue. */
657 static struct dwarf2_queue_item
*dwarf2_queue
, *dwarf2_queue_tail
;
659 /* Loaded secondary compilation units are kept in memory until they
660 have not been referenced for the processing of this many
661 compilation units. Set this to zero to disable caching. Cache
662 sizes of up to at least twenty will improve startup time for
663 typical inter-CU-reference binaries, at an obvious memory cost. */
664 static int dwarf2_max_cache_age
= 5;
666 show_dwarf2_max_cache_age (struct ui_file
*file
, int from_tty
,
667 struct cmd_list_element
*c
, const char *value
)
669 fprintf_filtered (file
, _("\
670 The upper bound on the age of cached dwarf2 compilation units is %s.\n"),
675 /* Various complaints about symbol reading that don't abort the process */
678 dwarf2_statement_list_fits_in_line_number_section_complaint (void)
680 complaint (&symfile_complaints
,
681 _("statement list doesn't fit in .debug_line section"));
685 dwarf2_complex_location_expr_complaint (void)
687 complaint (&symfile_complaints
, _("location expression too complex"));
691 dwarf2_const_value_length_mismatch_complaint (const char *arg1
, int arg2
,
694 complaint (&symfile_complaints
,
695 _("const value length mismatch for '%s', got %d, expected %d"), arg1
,
700 dwarf2_macros_too_long_complaint (void)
702 complaint (&symfile_complaints
,
703 _("macro info runs off end of `.debug_macinfo' section"));
707 dwarf2_macro_malformed_definition_complaint (const char *arg1
)
709 complaint (&symfile_complaints
,
710 _("macro debug info contains a malformed macro definition:\n`%s'"),
715 dwarf2_invalid_attrib_class_complaint (const char *arg1
, const char *arg2
)
717 complaint (&symfile_complaints
,
718 _("invalid attribute class or form for '%s' in '%s'"), arg1
, arg2
);
721 /* local function prototypes */
723 static void dwarf2_locate_sections (bfd
*, asection
*, void *);
726 static void dwarf2_build_psymtabs_easy (struct objfile
*, int);
729 static void dwarf2_create_include_psymtab (char *, struct partial_symtab
*,
732 static void dwarf2_build_include_psymtabs (struct dwarf2_cu
*,
733 struct partial_die_info
*,
734 struct partial_symtab
*);
736 static void dwarf2_build_psymtabs_hard (struct objfile
*, int);
738 static void scan_partial_symbols (struct partial_die_info
*,
739 CORE_ADDR
*, CORE_ADDR
*,
742 static void add_partial_symbol (struct partial_die_info
*,
745 static int pdi_needs_namespace (enum dwarf_tag tag
);
747 static void add_partial_namespace (struct partial_die_info
*pdi
,
748 CORE_ADDR
*lowpc
, CORE_ADDR
*highpc
,
749 struct dwarf2_cu
*cu
);
751 static void add_partial_enumeration (struct partial_die_info
*enum_pdi
,
752 struct dwarf2_cu
*cu
);
754 static gdb_byte
*locate_pdi_sibling (struct partial_die_info
*orig_pdi
,
757 struct dwarf2_cu
*cu
);
759 static void dwarf2_psymtab_to_symtab (struct partial_symtab
*);
761 static void psymtab_to_symtab_1 (struct partial_symtab
*);
763 gdb_byte
*dwarf2_read_section (struct objfile
*, asection
*);
765 static void dwarf2_read_abbrevs (bfd
*abfd
, struct dwarf2_cu
*cu
);
767 static void dwarf2_free_abbrev_table (void *);
769 static struct abbrev_info
*peek_die_abbrev (gdb_byte
*, unsigned int *,
772 static struct abbrev_info
*dwarf2_lookup_abbrev (unsigned int,
775 static struct partial_die_info
*load_partial_dies (bfd
*, gdb_byte
*, int,
778 static gdb_byte
*read_partial_die (struct partial_die_info
*,
779 struct abbrev_info
*abbrev
, unsigned int,
780 bfd
*, gdb_byte
*, struct dwarf2_cu
*);
782 static struct partial_die_info
*find_partial_die (unsigned long,
785 static void fixup_partial_die (struct partial_die_info
*,
788 static gdb_byte
*read_full_die (struct die_info
**, bfd
*, gdb_byte
*,
789 struct dwarf2_cu
*, int *);
791 static gdb_byte
*read_attribute (struct attribute
*, struct attr_abbrev
*,
792 bfd
*, gdb_byte
*, struct dwarf2_cu
*);
794 static gdb_byte
*read_attribute_value (struct attribute
*, unsigned,
795 bfd
*, gdb_byte
*, struct dwarf2_cu
*);
797 static unsigned int read_1_byte (bfd
*, gdb_byte
*);
799 static int read_1_signed_byte (bfd
*, gdb_byte
*);
801 static unsigned int read_2_bytes (bfd
*, gdb_byte
*);
803 static unsigned int read_4_bytes (bfd
*, gdb_byte
*);
805 static unsigned long read_8_bytes (bfd
*, gdb_byte
*);
807 static CORE_ADDR
read_address (bfd
*, gdb_byte
*ptr
, struct dwarf2_cu
*,
810 static LONGEST
read_initial_length (bfd
*, gdb_byte
*,
811 struct comp_unit_head
*, unsigned int *);
813 static LONGEST
read_offset (bfd
*, gdb_byte
*, const struct comp_unit_head
*,
816 static gdb_byte
*read_n_bytes (bfd
*, gdb_byte
*, unsigned int);
818 static char *read_string (bfd
*, gdb_byte
*, unsigned int *);
820 static char *read_indirect_string (bfd
*, gdb_byte
*,
821 const struct comp_unit_head
*,
824 static unsigned long read_unsigned_leb128 (bfd
*, gdb_byte
*, unsigned int *);
826 static long read_signed_leb128 (bfd
*, gdb_byte
*, unsigned int *);
828 static gdb_byte
*skip_leb128 (bfd
*, gdb_byte
*);
830 static void set_cu_language (unsigned int, struct dwarf2_cu
*);
832 static struct attribute
*dwarf2_attr (struct die_info
*, unsigned int,
835 static int dwarf2_flag_true_p (struct die_info
*die
, unsigned name
,
836 struct dwarf2_cu
*cu
);
838 static int die_is_declaration (struct die_info
*, struct dwarf2_cu
*cu
);
840 static struct die_info
*die_specification (struct die_info
*die
,
843 static void free_line_header (struct line_header
*lh
);
845 static void add_file_name (struct line_header
*, char *, unsigned int,
846 unsigned int, unsigned int);
848 static struct line_header
*(dwarf_decode_line_header
849 (unsigned int offset
,
850 bfd
*abfd
, struct dwarf2_cu
*cu
));
852 static void dwarf_decode_lines (struct line_header
*, char *, bfd
*,
853 struct dwarf2_cu
*, struct partial_symtab
*);
855 static void dwarf2_start_subfile (char *, char *, char *);
857 static struct symbol
*new_symbol (struct die_info
*, struct type
*,
860 static void dwarf2_const_value (struct attribute
*, struct symbol
*,
863 static void dwarf2_const_value_data (struct attribute
*attr
,
867 static struct type
*die_type (struct die_info
*, struct dwarf2_cu
*);
869 static struct type
*die_containing_type (struct die_info
*,
872 static struct type
*tag_type_to_type (struct die_info
*, struct dwarf2_cu
*);
874 static void read_type_die (struct die_info
*, struct dwarf2_cu
*);
876 static char *determine_prefix (struct die_info
*die
, struct dwarf2_cu
*);
878 static char *typename_concat (struct obstack
*,
883 static void read_typedef (struct die_info
*, struct dwarf2_cu
*);
885 static void read_base_type (struct die_info
*, struct dwarf2_cu
*);
887 static void read_subrange_type (struct die_info
*die
, struct dwarf2_cu
*cu
);
889 static void read_file_scope (struct die_info
*, struct dwarf2_cu
*);
891 static void read_func_scope (struct die_info
*, struct dwarf2_cu
*);
893 static void read_lexical_block_scope (struct die_info
*, struct dwarf2_cu
*);
895 static int dwarf2_get_pc_bounds (struct die_info
*,
896 CORE_ADDR
*, CORE_ADDR
*, struct dwarf2_cu
*);
898 static void get_scope_pc_bounds (struct die_info
*,
899 CORE_ADDR
*, CORE_ADDR
*,
902 static void dwarf2_add_field (struct field_info
*, struct die_info
*,
905 static void dwarf2_attach_fields_to_type (struct field_info
*,
906 struct type
*, struct dwarf2_cu
*);
908 static void dwarf2_add_member_fn (struct field_info
*,
909 struct die_info
*, struct type
*,
912 static void dwarf2_attach_fn_fields_to_type (struct field_info
*,
913 struct type
*, struct dwarf2_cu
*);
915 static void read_structure_type (struct die_info
*, struct dwarf2_cu
*);
917 static void process_structure_scope (struct die_info
*, struct dwarf2_cu
*);
919 static char *determine_class_name (struct die_info
*die
, struct dwarf2_cu
*cu
);
921 static void read_common_block (struct die_info
*, struct dwarf2_cu
*);
923 static void read_namespace (struct die_info
*die
, struct dwarf2_cu
*);
925 static const char *namespace_name (struct die_info
*die
,
926 int *is_anonymous
, struct dwarf2_cu
*);
928 static void read_enumeration_type (struct die_info
*, struct dwarf2_cu
*);
930 static void process_enumeration_scope (struct die_info
*, struct dwarf2_cu
*);
932 static struct type
*dwarf_base_type (int, int, struct dwarf2_cu
*);
934 static CORE_ADDR
decode_locdesc (struct dwarf_block
*, struct dwarf2_cu
*);
936 static void read_array_type (struct die_info
*, struct dwarf2_cu
*);
938 static enum dwarf_array_dim_ordering
read_array_order (struct die_info
*,
941 static void read_tag_pointer_type (struct die_info
*, struct dwarf2_cu
*);
943 static void read_tag_ptr_to_member_type (struct die_info
*,
946 static void read_tag_reference_type (struct die_info
*, struct dwarf2_cu
*);
948 static void read_tag_const_type (struct die_info
*, struct dwarf2_cu
*);
950 static void read_tag_volatile_type (struct die_info
*, struct dwarf2_cu
*);
952 static void read_tag_string_type (struct die_info
*, struct dwarf2_cu
*);
954 static void read_subroutine_type (struct die_info
*, struct dwarf2_cu
*);
956 static struct die_info
*read_comp_unit (gdb_byte
*, bfd
*, struct dwarf2_cu
*);
958 static struct die_info
*read_die_and_children (gdb_byte
*info_ptr
, bfd
*abfd
,
960 gdb_byte
**new_info_ptr
,
961 struct die_info
*parent
);
963 static struct die_info
*read_die_and_siblings (gdb_byte
*info_ptr
, bfd
*abfd
,
965 gdb_byte
**new_info_ptr
,
966 struct die_info
*parent
);
968 static void free_die_list (struct die_info
*);
970 static void process_die (struct die_info
*, struct dwarf2_cu
*);
972 static char *dwarf2_linkage_name (struct die_info
*, struct dwarf2_cu
*);
974 static char *dwarf2_name (struct die_info
*die
, struct dwarf2_cu
*);
976 static struct die_info
*dwarf2_extension (struct die_info
*die
,
979 static char *dwarf_tag_name (unsigned int);
981 static char *dwarf_attr_name (unsigned int);
983 static char *dwarf_form_name (unsigned int);
985 static char *dwarf_stack_op_name (unsigned int);
987 static char *dwarf_bool_name (unsigned int);
989 static char *dwarf_type_encoding_name (unsigned int);
992 static char *dwarf_cfi_name (unsigned int);
994 struct die_info
*copy_die (struct die_info
*);
997 static struct die_info
*sibling_die (struct die_info
*);
999 static void dump_die (struct die_info
*);
1001 static void dump_die_list (struct die_info
*);
1003 static void store_in_ref_table (unsigned int, struct die_info
*,
1004 struct dwarf2_cu
*);
1006 static unsigned int dwarf2_get_ref_die_offset (struct attribute
*,
1007 struct dwarf2_cu
*);
1009 static int dwarf2_get_attr_constant_value (struct attribute
*, int);
1011 static struct die_info
*follow_die_ref (struct die_info
*,
1013 struct dwarf2_cu
*);
1015 static struct type
*dwarf2_fundamental_type (struct objfile
*, int,
1016 struct dwarf2_cu
*);
1018 /* memory allocation interface */
1020 static struct dwarf_block
*dwarf_alloc_block (struct dwarf2_cu
*);
1022 static struct abbrev_info
*dwarf_alloc_abbrev (struct dwarf2_cu
*);
1024 static struct die_info
*dwarf_alloc_die (void);
1026 static void initialize_cu_func_list (struct dwarf2_cu
*);
1028 static void add_to_cu_func_list (const char *, CORE_ADDR
, CORE_ADDR
,
1029 struct dwarf2_cu
*);
1031 static void dwarf_decode_macros (struct line_header
*, unsigned int,
1032 char *, bfd
*, struct dwarf2_cu
*);
1034 static int attr_form_is_block (struct attribute
*);
1037 dwarf2_symbol_mark_computed (struct attribute
*attr
, struct symbol
*sym
,
1038 struct dwarf2_cu
*cu
);
1040 static gdb_byte
*skip_one_die (gdb_byte
*info_ptr
, struct abbrev_info
*abbrev
,
1041 struct dwarf2_cu
*cu
);
1043 static void free_stack_comp_unit (void *);
1045 static hashval_t
partial_die_hash (const void *item
);
1047 static int partial_die_eq (const void *item_lhs
, const void *item_rhs
);
1049 static struct dwarf2_per_cu_data
*dwarf2_find_containing_comp_unit
1050 (unsigned long offset
, struct objfile
*objfile
);
1052 static struct dwarf2_per_cu_data
*dwarf2_find_comp_unit
1053 (unsigned long offset
, struct objfile
*objfile
);
1055 static void free_one_comp_unit (void *);
1057 static void free_cached_comp_units (void *);
1059 static void age_cached_comp_units (void);
1061 static void free_one_cached_comp_unit (void *);
1063 static void set_die_type (struct die_info
*, struct type
*,
1064 struct dwarf2_cu
*);
1066 static void reset_die_and_siblings_types (struct die_info
*,
1067 struct dwarf2_cu
*);
1069 static void create_all_comp_units (struct objfile
*);
1071 static struct dwarf2_cu
*load_full_comp_unit (struct dwarf2_per_cu_data
*,
1074 static void process_full_comp_unit (struct dwarf2_per_cu_data
*);
1076 static void dwarf2_add_dependence (struct dwarf2_cu
*,
1077 struct dwarf2_per_cu_data
*);
1079 static void dwarf2_mark (struct dwarf2_cu
*);
1081 static void dwarf2_clear_marks (struct dwarf2_per_cu_data
*);
1083 static void read_set_type (struct die_info
*, struct dwarf2_cu
*);
1086 /* Try to locate the sections we need for DWARF 2 debugging
1087 information and return true if we have enough to do something. */
1090 dwarf2_has_info (struct objfile
*objfile
)
1092 struct dwarf2_per_objfile
*data
;
1094 /* Initialize per-objfile state. */
1095 data
= obstack_alloc (&objfile
->objfile_obstack
, sizeof (*data
));
1096 memset (data
, 0, sizeof (*data
));
1097 set_objfile_data (objfile
, dwarf2_objfile_data_key
, data
);
1098 dwarf2_per_objfile
= data
;
1100 dwarf_info_section
= 0;
1101 dwarf_abbrev_section
= 0;
1102 dwarf_line_section
= 0;
1103 dwarf_str_section
= 0;
1104 dwarf_macinfo_section
= 0;
1105 dwarf_frame_section
= 0;
1106 dwarf_eh_frame_section
= 0;
1107 dwarf_ranges_section
= 0;
1108 dwarf_loc_section
= 0;
1110 bfd_map_over_sections (objfile
->obfd
, dwarf2_locate_sections
, NULL
);
1111 return (dwarf_info_section
!= NULL
&& dwarf_abbrev_section
!= NULL
);
1114 /* This function is mapped across the sections and remembers the
1115 offset and size of each of the debugging sections we are interested
1119 dwarf2_locate_sections (bfd
*abfd
, asection
*sectp
, void *ignore_ptr
)
1121 if (strcmp (sectp
->name
, INFO_SECTION
) == 0)
1123 dwarf2_per_objfile
->info_size
= bfd_get_section_size (sectp
);
1124 dwarf_info_section
= sectp
;
1126 else if (strcmp (sectp
->name
, ABBREV_SECTION
) == 0)
1128 dwarf2_per_objfile
->abbrev_size
= bfd_get_section_size (sectp
);
1129 dwarf_abbrev_section
= sectp
;
1131 else if (strcmp (sectp
->name
, LINE_SECTION
) == 0)
1133 dwarf2_per_objfile
->line_size
= bfd_get_section_size (sectp
);
1134 dwarf_line_section
= sectp
;
1136 else if (strcmp (sectp
->name
, PUBNAMES_SECTION
) == 0)
1138 dwarf2_per_objfile
->pubnames_size
= bfd_get_section_size (sectp
);
1139 dwarf_pubnames_section
= sectp
;
1141 else if (strcmp (sectp
->name
, ARANGES_SECTION
) == 0)
1143 dwarf2_per_objfile
->aranges_size
= bfd_get_section_size (sectp
);
1144 dwarf_aranges_section
= sectp
;
1146 else if (strcmp (sectp
->name
, LOC_SECTION
) == 0)
1148 dwarf2_per_objfile
->loc_size
= bfd_get_section_size (sectp
);
1149 dwarf_loc_section
= sectp
;
1151 else if (strcmp (sectp
->name
, MACINFO_SECTION
) == 0)
1153 dwarf2_per_objfile
->macinfo_size
= bfd_get_section_size (sectp
);
1154 dwarf_macinfo_section
= sectp
;
1156 else if (strcmp (sectp
->name
, STR_SECTION
) == 0)
1158 dwarf2_per_objfile
->str_size
= bfd_get_section_size (sectp
);
1159 dwarf_str_section
= sectp
;
1161 else if (strcmp (sectp
->name
, FRAME_SECTION
) == 0)
1163 dwarf2_per_objfile
->frame_size
= bfd_get_section_size (sectp
);
1164 dwarf_frame_section
= sectp
;
1166 else if (strcmp (sectp
->name
, EH_FRAME_SECTION
) == 0)
1168 flagword aflag
= bfd_get_section_flags (ignore_abfd
, sectp
);
1169 if (aflag
& SEC_HAS_CONTENTS
)
1171 dwarf2_per_objfile
->eh_frame_size
= bfd_get_section_size (sectp
);
1172 dwarf_eh_frame_section
= sectp
;
1175 else if (strcmp (sectp
->name
, RANGES_SECTION
) == 0)
1177 dwarf2_per_objfile
->ranges_size
= bfd_get_section_size (sectp
);
1178 dwarf_ranges_section
= sectp
;
1181 if ((bfd_get_section_flags (abfd
, sectp
) & SEC_LOAD
)
1182 && bfd_section_vma (abfd
, sectp
) == 0)
1183 dwarf2_per_objfile
->has_section_at_zero
= 1;
1186 /* Build a partial symbol table. */
1189 dwarf2_build_psymtabs (struct objfile
*objfile
, int mainline
)
1191 /* We definitely need the .debug_info and .debug_abbrev sections */
1193 dwarf2_per_objfile
->info_buffer
= dwarf2_read_section (objfile
, dwarf_info_section
);
1194 dwarf2_per_objfile
->abbrev_buffer
= dwarf2_read_section (objfile
, dwarf_abbrev_section
);
1196 if (dwarf_line_section
)
1197 dwarf2_per_objfile
->line_buffer
= dwarf2_read_section (objfile
, dwarf_line_section
);
1199 dwarf2_per_objfile
->line_buffer
= NULL
;
1201 if (dwarf_str_section
)
1202 dwarf2_per_objfile
->str_buffer
= dwarf2_read_section (objfile
, dwarf_str_section
);
1204 dwarf2_per_objfile
->str_buffer
= NULL
;
1206 if (dwarf_macinfo_section
)
1207 dwarf2_per_objfile
->macinfo_buffer
= dwarf2_read_section (objfile
,
1208 dwarf_macinfo_section
);
1210 dwarf2_per_objfile
->macinfo_buffer
= NULL
;
1212 if (dwarf_ranges_section
)
1213 dwarf2_per_objfile
->ranges_buffer
= dwarf2_read_section (objfile
, dwarf_ranges_section
);
1215 dwarf2_per_objfile
->ranges_buffer
= NULL
;
1217 if (dwarf_loc_section
)
1218 dwarf2_per_objfile
->loc_buffer
= dwarf2_read_section (objfile
, dwarf_loc_section
);
1220 dwarf2_per_objfile
->loc_buffer
= NULL
;
1223 || (objfile
->global_psymbols
.size
== 0
1224 && objfile
->static_psymbols
.size
== 0))
1226 init_psymbol_list (objfile
, 1024);
1230 if (dwarf_aranges_offset
&& dwarf_pubnames_offset
)
1232 /* Things are significantly easier if we have .debug_aranges and
1233 .debug_pubnames sections */
1235 dwarf2_build_psymtabs_easy (objfile
, mainline
);
1239 /* only test this case for now */
1241 /* In this case we have to work a bit harder */
1242 dwarf2_build_psymtabs_hard (objfile
, mainline
);
1247 /* Build the partial symbol table from the information in the
1248 .debug_pubnames and .debug_aranges sections. */
1251 dwarf2_build_psymtabs_easy (struct objfile
*objfile
, int mainline
)
1253 bfd
*abfd
= objfile
->obfd
;
1254 char *aranges_buffer
, *pubnames_buffer
;
1255 char *aranges_ptr
, *pubnames_ptr
;
1256 unsigned int entry_length
, version
, info_offset
, info_size
;
1258 pubnames_buffer
= dwarf2_read_section (objfile
,
1259 dwarf_pubnames_section
);
1260 pubnames_ptr
= pubnames_buffer
;
1261 while ((pubnames_ptr
- pubnames_buffer
) < dwarf2_per_objfile
->pubnames_size
)
1263 struct comp_unit_head cu_header
;
1264 unsigned int bytes_read
;
1266 entry_length
= read_initial_length (abfd
, pubnames_ptr
, &cu_header
,
1268 pubnames_ptr
+= bytes_read
;
1269 version
= read_1_byte (abfd
, pubnames_ptr
);
1271 info_offset
= read_4_bytes (abfd
, pubnames_ptr
);
1273 info_size
= read_4_bytes (abfd
, pubnames_ptr
);
1277 aranges_buffer
= dwarf2_read_section (objfile
,
1278 dwarf_aranges_section
);
1283 /* Read in the comp unit header information from the debug_info at
1287 read_comp_unit_head (struct comp_unit_head
*cu_header
,
1288 gdb_byte
*info_ptr
, bfd
*abfd
)
1291 unsigned int bytes_read
;
1292 cu_header
->length
= read_initial_length (abfd
, info_ptr
, cu_header
,
1294 info_ptr
+= bytes_read
;
1295 cu_header
->version
= read_2_bytes (abfd
, info_ptr
);
1297 cu_header
->abbrev_offset
= read_offset (abfd
, info_ptr
, cu_header
,
1299 info_ptr
+= bytes_read
;
1300 cu_header
->addr_size
= read_1_byte (abfd
, info_ptr
);
1302 signed_addr
= bfd_get_sign_extend_vma (abfd
);
1303 if (signed_addr
< 0)
1304 internal_error (__FILE__
, __LINE__
,
1305 _("read_comp_unit_head: dwarf from non elf file"));
1306 cu_header
->signed_addr_p
= signed_addr
;
1311 partial_read_comp_unit_head (struct comp_unit_head
*header
, gdb_byte
*info_ptr
,
1314 gdb_byte
*beg_of_comp_unit
= info_ptr
;
1316 info_ptr
= read_comp_unit_head (header
, info_ptr
, abfd
);
1318 if (header
->version
!= 2 && header
->version
!= 3)
1319 error (_("Dwarf Error: wrong version in compilation unit header "
1320 "(is %d, should be %d) [in module %s]"), header
->version
,
1321 2, bfd_get_filename (abfd
));
1323 if (header
->abbrev_offset
>= dwarf2_per_objfile
->abbrev_size
)
1324 error (_("Dwarf Error: bad offset (0x%lx) in compilation unit header "
1325 "(offset 0x%lx + 6) [in module %s]"),
1326 (long) header
->abbrev_offset
,
1327 (long) (beg_of_comp_unit
- dwarf2_per_objfile
->info_buffer
),
1328 bfd_get_filename (abfd
));
1330 if (beg_of_comp_unit
+ header
->length
+ header
->initial_length_size
1331 > dwarf2_per_objfile
->info_buffer
+ dwarf2_per_objfile
->info_size
)
1332 error (_("Dwarf Error: bad length (0x%lx) in compilation unit header "
1333 "(offset 0x%lx + 0) [in module %s]"),
1334 (long) header
->length
,
1335 (long) (beg_of_comp_unit
- dwarf2_per_objfile
->info_buffer
),
1336 bfd_get_filename (abfd
));
1341 /* Allocate a new partial symtab for file named NAME and mark this new
1342 partial symtab as being an include of PST. */
1345 dwarf2_create_include_psymtab (char *name
, struct partial_symtab
*pst
,
1346 struct objfile
*objfile
)
1348 struct partial_symtab
*subpst
= allocate_psymtab (name
, objfile
);
1350 subpst
->section_offsets
= pst
->section_offsets
;
1351 subpst
->textlow
= 0;
1352 subpst
->texthigh
= 0;
1354 subpst
->dependencies
= (struct partial_symtab
**)
1355 obstack_alloc (&objfile
->objfile_obstack
,
1356 sizeof (struct partial_symtab
*));
1357 subpst
->dependencies
[0] = pst
;
1358 subpst
->number_of_dependencies
= 1;
1360 subpst
->globals_offset
= 0;
1361 subpst
->n_global_syms
= 0;
1362 subpst
->statics_offset
= 0;
1363 subpst
->n_static_syms
= 0;
1364 subpst
->symtab
= NULL
;
1365 subpst
->read_symtab
= pst
->read_symtab
;
1368 /* No private part is necessary for include psymtabs. This property
1369 can be used to differentiate between such include psymtabs and
1370 the regular ones. */
1371 subpst
->read_symtab_private
= NULL
;
1374 /* Read the Line Number Program data and extract the list of files
1375 included by the source file represented by PST. Build an include
1376 partial symtab for each of these included files.
1378 This procedure assumes that there *is* a Line Number Program in
1379 the given CU. Callers should check that PDI->HAS_STMT_LIST is set
1380 before calling this procedure. */
1383 dwarf2_build_include_psymtabs (struct dwarf2_cu
*cu
,
1384 struct partial_die_info
*pdi
,
1385 struct partial_symtab
*pst
)
1387 struct objfile
*objfile
= cu
->objfile
;
1388 bfd
*abfd
= objfile
->obfd
;
1389 struct line_header
*lh
;
1391 lh
= dwarf_decode_line_header (pdi
->line_offset
, abfd
, cu
);
1393 return; /* No linetable, so no includes. */
1395 dwarf_decode_lines (lh
, NULL
, abfd
, cu
, pst
);
1397 free_line_header (lh
);
1401 /* Build the partial symbol table by doing a quick pass through the
1402 .debug_info and .debug_abbrev sections. */
1405 dwarf2_build_psymtabs_hard (struct objfile
*objfile
, int mainline
)
1407 /* Instead of reading this into a big buffer, we should probably use
1408 mmap() on architectures that support it. (FIXME) */
1409 bfd
*abfd
= objfile
->obfd
;
1411 gdb_byte
*beg_of_comp_unit
;
1412 struct partial_die_info comp_unit_die
;
1413 struct partial_symtab
*pst
;
1414 struct cleanup
*back_to
;
1415 CORE_ADDR lowpc
, highpc
, baseaddr
;
1417 info_ptr
= dwarf2_per_objfile
->info_buffer
;
1419 /* Any cached compilation units will be linked by the per-objfile
1420 read_in_chain. Make sure to free them when we're done. */
1421 back_to
= make_cleanup (free_cached_comp_units
, NULL
);
1423 create_all_comp_units (objfile
);
1425 /* Since the objects we're extracting from .debug_info vary in
1426 length, only the individual functions to extract them (like
1427 read_comp_unit_head and load_partial_die) can really know whether
1428 the buffer is large enough to hold another complete object.
1430 At the moment, they don't actually check that. If .debug_info
1431 holds just one extra byte after the last compilation unit's dies,
1432 then read_comp_unit_head will happily read off the end of the
1433 buffer. read_partial_die is similarly casual. Those functions
1436 For this loop condition, simply checking whether there's any data
1437 left at all should be sufficient. */
1438 while (info_ptr
< (dwarf2_per_objfile
->info_buffer
1439 + dwarf2_per_objfile
->info_size
))
1441 struct cleanup
*back_to_inner
;
1442 struct dwarf2_cu cu
;
1443 struct abbrev_info
*abbrev
;
1444 unsigned int bytes_read
;
1445 struct dwarf2_per_cu_data
*this_cu
;
1447 beg_of_comp_unit
= info_ptr
;
1449 memset (&cu
, 0, sizeof (cu
));
1451 obstack_init (&cu
.comp_unit_obstack
);
1453 back_to_inner
= make_cleanup (free_stack_comp_unit
, &cu
);
1455 cu
.objfile
= objfile
;
1456 info_ptr
= partial_read_comp_unit_head (&cu
.header
, info_ptr
, abfd
);
1458 /* Complete the cu_header */
1459 cu
.header
.offset
= beg_of_comp_unit
- dwarf2_per_objfile
->info_buffer
;
1460 cu
.header
.first_die_ptr
= info_ptr
;
1461 cu
.header
.cu_head_ptr
= beg_of_comp_unit
;
1463 cu
.list_in_scope
= &file_symbols
;
1465 /* Read the abbrevs for this compilation unit into a table */
1466 dwarf2_read_abbrevs (abfd
, &cu
);
1467 make_cleanup (dwarf2_free_abbrev_table
, &cu
);
1469 this_cu
= dwarf2_find_comp_unit (cu
.header
.offset
, objfile
);
1471 /* Read the compilation unit die */
1472 abbrev
= peek_die_abbrev (info_ptr
, &bytes_read
, &cu
);
1473 info_ptr
= read_partial_die (&comp_unit_die
, abbrev
, bytes_read
,
1474 abfd
, info_ptr
, &cu
);
1476 if (comp_unit_die
.tag
== DW_TAG_partial_unit
)
1478 info_ptr
= (beg_of_comp_unit
+ cu
.header
.length
1479 + cu
.header
.initial_length_size
);
1480 do_cleanups (back_to_inner
);
1484 /* Set the language we're debugging */
1485 set_cu_language (comp_unit_die
.language
, &cu
);
1487 /* Allocate a new partial symbol table structure */
1488 pst
= start_psymtab_common (objfile
, objfile
->section_offsets
,
1489 comp_unit_die
.name
? comp_unit_die
.name
: "",
1490 comp_unit_die
.lowpc
,
1491 objfile
->global_psymbols
.next
,
1492 objfile
->static_psymbols
.next
);
1494 if (comp_unit_die
.dirname
)
1495 pst
->dirname
= xstrdup (comp_unit_die
.dirname
);
1497 pst
->read_symtab_private
= (char *) this_cu
;
1499 baseaddr
= ANOFFSET (objfile
->section_offsets
, SECT_OFF_TEXT (objfile
));
1501 /* Store the function that reads in the rest of the symbol table */
1502 pst
->read_symtab
= dwarf2_psymtab_to_symtab
;
1504 /* If this compilation unit was already read in, free the
1505 cached copy in order to read it in again. This is
1506 necessary because we skipped some symbols when we first
1507 read in the compilation unit (see load_partial_dies).
1508 This problem could be avoided, but the benefit is
1510 if (this_cu
->cu
!= NULL
)
1511 free_one_cached_comp_unit (this_cu
->cu
);
1513 cu
.per_cu
= this_cu
;
1515 /* Note that this is a pointer to our stack frame, being
1516 added to a global data structure. It will be cleaned up
1517 in free_stack_comp_unit when we finish with this
1518 compilation unit. */
1521 this_cu
->psymtab
= pst
;
1523 /* Check if comp unit has_children.
1524 If so, read the rest of the partial symbols from this comp unit.
1525 If not, there's no more debug_info for this comp unit. */
1526 if (comp_unit_die
.has_children
)
1528 struct partial_die_info
*first_die
;
1530 lowpc
= ((CORE_ADDR
) -1);
1531 highpc
= ((CORE_ADDR
) 0);
1533 first_die
= load_partial_dies (abfd
, info_ptr
, 1, &cu
);
1535 scan_partial_symbols (first_die
, &lowpc
, &highpc
, &cu
);
1537 /* If we didn't find a lowpc, set it to highpc to avoid
1538 complaints from `maint check'. */
1539 if (lowpc
== ((CORE_ADDR
) -1))
1542 /* If the compilation unit didn't have an explicit address range,
1543 then use the information extracted from its child dies. */
1544 if (! comp_unit_die
.has_pc_info
)
1546 comp_unit_die
.lowpc
= lowpc
;
1547 comp_unit_die
.highpc
= highpc
;
1550 pst
->textlow
= comp_unit_die
.lowpc
+ baseaddr
;
1551 pst
->texthigh
= comp_unit_die
.highpc
+ baseaddr
;
1553 pst
->n_global_syms
= objfile
->global_psymbols
.next
-
1554 (objfile
->global_psymbols
.list
+ pst
->globals_offset
);
1555 pst
->n_static_syms
= objfile
->static_psymbols
.next
-
1556 (objfile
->static_psymbols
.list
+ pst
->statics_offset
);
1557 sort_pst_symbols (pst
);
1559 /* If there is already a psymtab or symtab for a file of this
1560 name, remove it. (If there is a symtab, more drastic things
1561 also happen.) This happens in VxWorks. */
1562 free_named_symtabs (pst
->filename
);
1564 info_ptr
= beg_of_comp_unit
+ cu
.header
.length
1565 + cu
.header
.initial_length_size
;
1567 if (comp_unit_die
.has_stmt_list
)
1569 /* Get the list of files included in the current compilation unit,
1570 and build a psymtab for each of them. */
1571 dwarf2_build_include_psymtabs (&cu
, &comp_unit_die
, pst
);
1574 do_cleanups (back_to_inner
);
1576 do_cleanups (back_to
);
1579 /* Load the DIEs for a secondary CU into memory. */
1582 load_comp_unit (struct dwarf2_per_cu_data
*this_cu
, struct objfile
*objfile
)
1584 bfd
*abfd
= objfile
->obfd
;
1585 gdb_byte
*info_ptr
, *beg_of_comp_unit
;
1586 struct partial_die_info comp_unit_die
;
1587 struct dwarf2_cu
*cu
;
1588 struct abbrev_info
*abbrev
;
1589 unsigned int bytes_read
;
1590 struct cleanup
*back_to
;
1592 info_ptr
= dwarf2_per_objfile
->info_buffer
+ this_cu
->offset
;
1593 beg_of_comp_unit
= info_ptr
;
1595 cu
= xmalloc (sizeof (struct dwarf2_cu
));
1596 memset (cu
, 0, sizeof (struct dwarf2_cu
));
1598 obstack_init (&cu
->comp_unit_obstack
);
1600 cu
->objfile
= objfile
;
1601 info_ptr
= partial_read_comp_unit_head (&cu
->header
, info_ptr
, abfd
);
1603 /* Complete the cu_header. */
1604 cu
->header
.offset
= beg_of_comp_unit
- dwarf2_per_objfile
->info_buffer
;
1605 cu
->header
.first_die_ptr
= info_ptr
;
1606 cu
->header
.cu_head_ptr
= beg_of_comp_unit
;
1608 /* Read the abbrevs for this compilation unit into a table. */
1609 dwarf2_read_abbrevs (abfd
, cu
);
1610 back_to
= make_cleanup (dwarf2_free_abbrev_table
, cu
);
1612 /* Read the compilation unit die. */
1613 abbrev
= peek_die_abbrev (info_ptr
, &bytes_read
, cu
);
1614 info_ptr
= read_partial_die (&comp_unit_die
, abbrev
, bytes_read
,
1615 abfd
, info_ptr
, cu
);
1617 /* Set the language we're debugging. */
1618 set_cu_language (comp_unit_die
.language
, cu
);
1620 /* Link this compilation unit into the compilation unit tree. */
1622 cu
->per_cu
= this_cu
;
1624 /* Check if comp unit has_children.
1625 If so, read the rest of the partial symbols from this comp unit.
1626 If not, there's no more debug_info for this comp unit. */
1627 if (comp_unit_die
.has_children
)
1628 load_partial_dies (abfd
, info_ptr
, 0, cu
);
1630 do_cleanups (back_to
);
1633 /* Create a list of all compilation units in OBJFILE. We do this only
1634 if an inter-comp-unit reference is found; presumably if there is one,
1635 there will be many, and one will occur early in the .debug_info section.
1636 So there's no point in building this list incrementally. */
1639 create_all_comp_units (struct objfile
*objfile
)
1643 struct dwarf2_per_cu_data
**all_comp_units
;
1644 gdb_byte
*info_ptr
= dwarf2_per_objfile
->info_buffer
;
1648 all_comp_units
= xmalloc (n_allocated
1649 * sizeof (struct dwarf2_per_cu_data
*));
1651 while (info_ptr
< dwarf2_per_objfile
->info_buffer
+ dwarf2_per_objfile
->info_size
)
1653 struct comp_unit_head cu_header
;
1654 gdb_byte
*beg_of_comp_unit
;
1655 struct dwarf2_per_cu_data
*this_cu
;
1656 unsigned long offset
;
1657 unsigned int bytes_read
;
1659 offset
= info_ptr
- dwarf2_per_objfile
->info_buffer
;
1661 /* Read just enough information to find out where the next
1662 compilation unit is. */
1663 cu_header
.initial_length_size
= 0;
1664 cu_header
.length
= read_initial_length (objfile
->obfd
, info_ptr
,
1665 &cu_header
, &bytes_read
);
1667 /* Save the compilation unit for later lookup. */
1668 this_cu
= obstack_alloc (&objfile
->objfile_obstack
,
1669 sizeof (struct dwarf2_per_cu_data
));
1670 memset (this_cu
, 0, sizeof (*this_cu
));
1671 this_cu
->offset
= offset
;
1672 this_cu
->length
= cu_header
.length
+ cu_header
.initial_length_size
;
1674 if (n_comp_units
== n_allocated
)
1677 all_comp_units
= xrealloc (all_comp_units
,
1679 * sizeof (struct dwarf2_per_cu_data
*));
1681 all_comp_units
[n_comp_units
++] = this_cu
;
1683 info_ptr
= info_ptr
+ this_cu
->length
;
1686 dwarf2_per_objfile
->all_comp_units
1687 = obstack_alloc (&objfile
->objfile_obstack
,
1688 n_comp_units
* sizeof (struct dwarf2_per_cu_data
*));
1689 memcpy (dwarf2_per_objfile
->all_comp_units
, all_comp_units
,
1690 n_comp_units
* sizeof (struct dwarf2_per_cu_data
*));
1691 xfree (all_comp_units
);
1692 dwarf2_per_objfile
->n_comp_units
= n_comp_units
;
1695 /* Process all loaded DIEs for compilation unit CU, starting at FIRST_DIE.
1696 Also set *LOWPC and *HIGHPC to the lowest and highest PC values found
1700 scan_partial_symbols (struct partial_die_info
*first_die
, CORE_ADDR
*lowpc
,
1701 CORE_ADDR
*highpc
, struct dwarf2_cu
*cu
)
1703 struct objfile
*objfile
= cu
->objfile
;
1704 bfd
*abfd
= objfile
->obfd
;
1705 struct partial_die_info
*pdi
;
1707 /* Now, march along the PDI's, descending into ones which have
1708 interesting children but skipping the children of the other ones,
1709 until we reach the end of the compilation unit. */
1715 fixup_partial_die (pdi
, cu
);
1717 /* Anonymous namespaces have no name but have interesting
1718 children, so we need to look at them. Ditto for anonymous
1721 if (pdi
->name
!= NULL
|| pdi
->tag
== DW_TAG_namespace
1722 || pdi
->tag
== DW_TAG_enumeration_type
)
1726 case DW_TAG_subprogram
:
1727 if (pdi
->has_pc_info
)
1729 if (pdi
->lowpc
< *lowpc
)
1731 *lowpc
= pdi
->lowpc
;
1733 if (pdi
->highpc
> *highpc
)
1735 *highpc
= pdi
->highpc
;
1737 if (!pdi
->is_declaration
)
1739 add_partial_symbol (pdi
, cu
);
1743 case DW_TAG_variable
:
1744 case DW_TAG_typedef
:
1745 case DW_TAG_union_type
:
1746 if (!pdi
->is_declaration
)
1748 add_partial_symbol (pdi
, cu
);
1751 case DW_TAG_class_type
:
1752 case DW_TAG_structure_type
:
1753 if (!pdi
->is_declaration
)
1755 add_partial_symbol (pdi
, cu
);
1758 case DW_TAG_enumeration_type
:
1759 if (!pdi
->is_declaration
)
1760 add_partial_enumeration (pdi
, cu
);
1762 case DW_TAG_base_type
:
1763 case DW_TAG_subrange_type
:
1764 /* File scope base type definitions are added to the partial
1766 add_partial_symbol (pdi
, cu
);
1768 case DW_TAG_namespace
:
1769 add_partial_namespace (pdi
, lowpc
, highpc
, cu
);
1776 /* If the die has a sibling, skip to the sibling. */
1778 pdi
= pdi
->die_sibling
;
1782 /* Functions used to compute the fully scoped name of a partial DIE.
1784 Normally, this is simple. For C++, the parent DIE's fully scoped
1785 name is concatenated with "::" and the partial DIE's name. For
1786 Java, the same thing occurs except that "." is used instead of "::".
1787 Enumerators are an exception; they use the scope of their parent
1788 enumeration type, i.e. the name of the enumeration type is not
1789 prepended to the enumerator.
1791 There are two complexities. One is DW_AT_specification; in this
1792 case "parent" means the parent of the target of the specification,
1793 instead of the direct parent of the DIE. The other is compilers
1794 which do not emit DW_TAG_namespace; in this case we try to guess
1795 the fully qualified name of structure types from their members'
1796 linkage names. This must be done using the DIE's children rather
1797 than the children of any DW_AT_specification target. We only need
1798 to do this for structures at the top level, i.e. if the target of
1799 any DW_AT_specification (if any; otherwise the DIE itself) does not
1802 /* Compute the scope prefix associated with PDI's parent, in
1803 compilation unit CU. The result will be allocated on CU's
1804 comp_unit_obstack, or a copy of the already allocated PDI->NAME
1805 field. NULL is returned if no prefix is necessary. */
1807 partial_die_parent_scope (struct partial_die_info
*pdi
,
1808 struct dwarf2_cu
*cu
)
1810 char *grandparent_scope
;
1811 struct partial_die_info
*parent
, *real_pdi
;
1813 /* We need to look at our parent DIE; if we have a DW_AT_specification,
1814 then this means the parent of the specification DIE. */
1817 while (real_pdi
->has_specification
)
1818 real_pdi
= find_partial_die (real_pdi
->spec_offset
, cu
);
1820 parent
= real_pdi
->die_parent
;
1824 if (parent
->scope_set
)
1825 return parent
->scope
;
1827 fixup_partial_die (parent
, cu
);
1829 grandparent_scope
= partial_die_parent_scope (parent
, cu
);
1831 if (parent
->tag
== DW_TAG_namespace
1832 || parent
->tag
== DW_TAG_structure_type
1833 || parent
->tag
== DW_TAG_class_type
1834 || parent
->tag
== DW_TAG_union_type
)
1836 if (grandparent_scope
== NULL
)
1837 parent
->scope
= parent
->name
;
1839 parent
->scope
= typename_concat (&cu
->comp_unit_obstack
, grandparent_scope
,
1842 else if (parent
->tag
== DW_TAG_enumeration_type
)
1843 /* Enumerators should not get the name of the enumeration as a prefix. */
1844 parent
->scope
= grandparent_scope
;
1847 /* FIXME drow/2004-04-01: What should we be doing with
1848 function-local names? For partial symbols, we should probably be
1850 complaint (&symfile_complaints
,
1851 _("unhandled containing DIE tag %d for DIE at %d"),
1852 parent
->tag
, pdi
->offset
);
1853 parent
->scope
= grandparent_scope
;
1856 parent
->scope_set
= 1;
1857 return parent
->scope
;
1860 /* Return the fully scoped name associated with PDI, from compilation unit
1861 CU. The result will be allocated with malloc. */
1863 partial_die_full_name (struct partial_die_info
*pdi
,
1864 struct dwarf2_cu
*cu
)
1868 parent_scope
= partial_die_parent_scope (pdi
, cu
);
1869 if (parent_scope
== NULL
)
1872 return typename_concat (NULL
, parent_scope
, pdi
->name
, cu
);
1876 add_partial_symbol (struct partial_die_info
*pdi
, struct dwarf2_cu
*cu
)
1878 struct objfile
*objfile
= cu
->objfile
;
1881 const char *my_prefix
;
1882 const struct partial_symbol
*psym
= NULL
;
1884 int built_actual_name
= 0;
1886 baseaddr
= ANOFFSET (objfile
->section_offsets
, SECT_OFF_TEXT (objfile
));
1890 if (pdi_needs_namespace (pdi
->tag
))
1892 actual_name
= partial_die_full_name (pdi
, cu
);
1894 built_actual_name
= 1;
1897 if (actual_name
== NULL
)
1898 actual_name
= pdi
->name
;
1902 case DW_TAG_subprogram
:
1903 if (pdi
->is_external
)
1905 /*prim_record_minimal_symbol (actual_name, pdi->lowpc + baseaddr,
1906 mst_text, objfile); */
1907 psym
= add_psymbol_to_list (actual_name
, strlen (actual_name
),
1908 VAR_DOMAIN
, LOC_BLOCK
,
1909 &objfile
->global_psymbols
,
1910 0, pdi
->lowpc
+ baseaddr
,
1911 cu
->language
, objfile
);
1915 /*prim_record_minimal_symbol (actual_name, pdi->lowpc + baseaddr,
1916 mst_file_text, objfile); */
1917 psym
= add_psymbol_to_list (actual_name
, strlen (actual_name
),
1918 VAR_DOMAIN
, LOC_BLOCK
,
1919 &objfile
->static_psymbols
,
1920 0, pdi
->lowpc
+ baseaddr
,
1921 cu
->language
, objfile
);
1924 case DW_TAG_variable
:
1925 if (pdi
->is_external
)
1928 Don't enter into the minimal symbol tables as there is
1929 a minimal symbol table entry from the ELF symbols already.
1930 Enter into partial symbol table if it has a location
1931 descriptor or a type.
1932 If the location descriptor is missing, new_symbol will create
1933 a LOC_UNRESOLVED symbol, the address of the variable will then
1934 be determined from the minimal symbol table whenever the variable
1936 The address for the partial symbol table entry is not
1937 used by GDB, but it comes in handy for debugging partial symbol
1941 addr
= decode_locdesc (pdi
->locdesc
, cu
);
1942 if (pdi
->locdesc
|| pdi
->has_type
)
1943 psym
= add_psymbol_to_list (actual_name
, strlen (actual_name
),
1944 VAR_DOMAIN
, LOC_STATIC
,
1945 &objfile
->global_psymbols
,
1947 cu
->language
, objfile
);
1951 /* Static Variable. Skip symbols without location descriptors. */
1952 if (pdi
->locdesc
== NULL
)
1954 addr
= decode_locdesc (pdi
->locdesc
, cu
);
1955 /*prim_record_minimal_symbol (actual_name, addr + baseaddr,
1956 mst_file_data, objfile); */
1957 psym
= add_psymbol_to_list (actual_name
, strlen (actual_name
),
1958 VAR_DOMAIN
, LOC_STATIC
,
1959 &objfile
->static_psymbols
,
1961 cu
->language
, objfile
);
1964 case DW_TAG_typedef
:
1965 case DW_TAG_base_type
:
1966 case DW_TAG_subrange_type
:
1967 add_psymbol_to_list (actual_name
, strlen (actual_name
),
1968 VAR_DOMAIN
, LOC_TYPEDEF
,
1969 &objfile
->static_psymbols
,
1970 0, (CORE_ADDR
) 0, cu
->language
, objfile
);
1972 case DW_TAG_namespace
:
1973 add_psymbol_to_list (actual_name
, strlen (actual_name
),
1974 VAR_DOMAIN
, LOC_TYPEDEF
,
1975 &objfile
->global_psymbols
,
1976 0, (CORE_ADDR
) 0, cu
->language
, objfile
);
1978 case DW_TAG_class_type
:
1979 case DW_TAG_structure_type
:
1980 case DW_TAG_union_type
:
1981 case DW_TAG_enumeration_type
:
1982 /* Skip aggregate types without children, these are external
1984 /* NOTE: carlton/2003-10-07: See comment in new_symbol about
1985 static vs. global. */
1986 if (pdi
->has_children
== 0)
1988 add_psymbol_to_list (actual_name
, strlen (actual_name
),
1989 STRUCT_DOMAIN
, LOC_TYPEDEF
,
1990 (cu
->language
== language_cplus
1991 || cu
->language
== language_java
)
1992 ? &objfile
->global_psymbols
1993 : &objfile
->static_psymbols
,
1994 0, (CORE_ADDR
) 0, cu
->language
, objfile
);
1996 if (cu
->language
== language_cplus
1997 || cu
->language
== language_java
)
1999 /* For C++ and Java, these implicitly act as typedefs as well. */
2000 add_psymbol_to_list (actual_name
, strlen (actual_name
),
2001 VAR_DOMAIN
, LOC_TYPEDEF
,
2002 &objfile
->global_psymbols
,
2003 0, (CORE_ADDR
) 0, cu
->language
, objfile
);
2006 case DW_TAG_enumerator
:
2007 add_psymbol_to_list (actual_name
, strlen (actual_name
),
2008 VAR_DOMAIN
, LOC_CONST
,
2009 (cu
->language
== language_cplus
2010 || cu
->language
== language_java
)
2011 ? &objfile
->global_psymbols
2012 : &objfile
->static_psymbols
,
2013 0, (CORE_ADDR
) 0, cu
->language
, objfile
);
2019 /* Check to see if we should scan the name for possible namespace
2020 info. Only do this if this is C++, if we don't have namespace
2021 debugging info in the file, if the psym is of an appropriate type
2022 (otherwise we'll have psym == NULL), and if we actually had a
2023 mangled name to begin with. */
2025 /* FIXME drow/2004-02-22: Why don't we do this for classes, i.e. the
2026 cases which do not set PSYM above? */
2028 if (cu
->language
== language_cplus
2029 && cu
->has_namespace_info
== 0
2031 && SYMBOL_CPLUS_DEMANGLED_NAME (psym
) != NULL
)
2032 cp_check_possible_namespace_symbols (SYMBOL_CPLUS_DEMANGLED_NAME (psym
),
2035 if (built_actual_name
)
2036 xfree (actual_name
);
2039 /* Determine whether a die of type TAG living in a C++ class or
2040 namespace needs to have the name of the scope prepended to the
2041 name listed in the die. */
2044 pdi_needs_namespace (enum dwarf_tag tag
)
2048 case DW_TAG_namespace
:
2049 case DW_TAG_typedef
:
2050 case DW_TAG_class_type
:
2051 case DW_TAG_structure_type
:
2052 case DW_TAG_union_type
:
2053 case DW_TAG_enumeration_type
:
2054 case DW_TAG_enumerator
:
2061 /* Read a partial die corresponding to a namespace; also, add a symbol
2062 corresponding to that namespace to the symbol table. NAMESPACE is
2063 the name of the enclosing namespace. */
2066 add_partial_namespace (struct partial_die_info
*pdi
,
2067 CORE_ADDR
*lowpc
, CORE_ADDR
*highpc
,
2068 struct dwarf2_cu
*cu
)
2070 struct objfile
*objfile
= cu
->objfile
;
2072 /* Add a symbol for the namespace. */
2074 add_partial_symbol (pdi
, cu
);
2076 /* Now scan partial symbols in that namespace. */
2078 if (pdi
->has_children
)
2079 scan_partial_symbols (pdi
->die_child
, lowpc
, highpc
, cu
);
2082 /* See if we can figure out if the class lives in a namespace. We do
2083 this by looking for a member function; its demangled name will
2084 contain namespace info, if there is any. */
2087 guess_structure_name (struct partial_die_info
*struct_pdi
,
2088 struct dwarf2_cu
*cu
)
2090 if ((cu
->language
== language_cplus
2091 || cu
->language
== language_java
)
2092 && cu
->has_namespace_info
== 0
2093 && struct_pdi
->has_children
)
2095 /* NOTE: carlton/2003-10-07: Getting the info this way changes
2096 what template types look like, because the demangler
2097 frequently doesn't give the same name as the debug info. We
2098 could fix this by only using the demangled name to get the
2099 prefix (but see comment in read_structure_type). */
2101 struct partial_die_info
*child_pdi
= struct_pdi
->die_child
;
2102 struct partial_die_info
*real_pdi
;
2104 /* If this DIE (this DIE's specification, if any) has a parent, then
2105 we should not do this. We'll prepend the parent's fully qualified
2106 name when we create the partial symbol. */
2108 real_pdi
= struct_pdi
;
2109 while (real_pdi
->has_specification
)
2110 real_pdi
= find_partial_die (real_pdi
->spec_offset
, cu
);
2112 if (real_pdi
->die_parent
!= NULL
)
2115 while (child_pdi
!= NULL
)
2117 if (child_pdi
->tag
== DW_TAG_subprogram
)
2119 char *actual_class_name
2120 = language_class_name_from_physname (cu
->language_defn
,
2122 if (actual_class_name
!= NULL
)
2125 = obsavestring (actual_class_name
,
2126 strlen (actual_class_name
),
2127 &cu
->comp_unit_obstack
);
2128 xfree (actual_class_name
);
2133 child_pdi
= child_pdi
->die_sibling
;
2138 /* Read a partial die corresponding to an enumeration type. */
2141 add_partial_enumeration (struct partial_die_info
*enum_pdi
,
2142 struct dwarf2_cu
*cu
)
2144 struct objfile
*objfile
= cu
->objfile
;
2145 bfd
*abfd
= objfile
->obfd
;
2146 struct partial_die_info
*pdi
;
2148 if (enum_pdi
->name
!= NULL
)
2149 add_partial_symbol (enum_pdi
, cu
);
2151 pdi
= enum_pdi
->die_child
;
2154 if (pdi
->tag
!= DW_TAG_enumerator
|| pdi
->name
== NULL
)
2155 complaint (&symfile_complaints
, _("malformed enumerator DIE ignored"));
2157 add_partial_symbol (pdi
, cu
);
2158 pdi
= pdi
->die_sibling
;
2162 /* Read the initial uleb128 in the die at INFO_PTR in compilation unit CU.
2163 Return the corresponding abbrev, or NULL if the number is zero (indicating
2164 an empty DIE). In either case *BYTES_READ will be set to the length of
2165 the initial number. */
2167 static struct abbrev_info
*
2168 peek_die_abbrev (gdb_byte
*info_ptr
, unsigned int *bytes_read
,
2169 struct dwarf2_cu
*cu
)
2171 bfd
*abfd
= cu
->objfile
->obfd
;
2172 unsigned int abbrev_number
;
2173 struct abbrev_info
*abbrev
;
2175 abbrev_number
= read_unsigned_leb128 (abfd
, info_ptr
, bytes_read
);
2177 if (abbrev_number
== 0)
2180 abbrev
= dwarf2_lookup_abbrev (abbrev_number
, cu
);
2183 error (_("Dwarf Error: Could not find abbrev number %d [in module %s]"), abbrev_number
,
2184 bfd_get_filename (abfd
));
2190 /* Scan the debug information for CU starting at INFO_PTR. Returns a
2191 pointer to the end of a series of DIEs, terminated by an empty
2192 DIE. Any children of the skipped DIEs will also be skipped. */
2195 skip_children (gdb_byte
*info_ptr
, struct dwarf2_cu
*cu
)
2197 struct abbrev_info
*abbrev
;
2198 unsigned int bytes_read
;
2202 abbrev
= peek_die_abbrev (info_ptr
, &bytes_read
, cu
);
2204 return info_ptr
+ bytes_read
;
2206 info_ptr
= skip_one_die (info_ptr
+ bytes_read
, abbrev
, cu
);
2210 /* Scan the debug information for CU starting at INFO_PTR. INFO_PTR
2211 should point just after the initial uleb128 of a DIE, and the
2212 abbrev corresponding to that skipped uleb128 should be passed in
2213 ABBREV. Returns a pointer to this DIE's sibling, skipping any
2217 skip_one_die (gdb_byte
*info_ptr
, struct abbrev_info
*abbrev
,
2218 struct dwarf2_cu
*cu
)
2220 unsigned int bytes_read
;
2221 struct attribute attr
;
2222 bfd
*abfd
= cu
->objfile
->obfd
;
2223 unsigned int form
, i
;
2225 for (i
= 0; i
< abbrev
->num_attrs
; i
++)
2227 /* The only abbrev we care about is DW_AT_sibling. */
2228 if (abbrev
->attrs
[i
].name
== DW_AT_sibling
)
2230 read_attribute (&attr
, &abbrev
->attrs
[i
],
2231 abfd
, info_ptr
, cu
);
2232 if (attr
.form
== DW_FORM_ref_addr
)
2233 complaint (&symfile_complaints
, _("ignoring absolute DW_AT_sibling"));
2235 return dwarf2_per_objfile
->info_buffer
2236 + dwarf2_get_ref_die_offset (&attr
, cu
);
2239 /* If it isn't DW_AT_sibling, skip this attribute. */
2240 form
= abbrev
->attrs
[i
].form
;
2245 case DW_FORM_ref_addr
:
2246 info_ptr
+= cu
->header
.addr_size
;
2265 case DW_FORM_string
:
2266 read_string (abfd
, info_ptr
, &bytes_read
);
2267 info_ptr
+= bytes_read
;
2270 info_ptr
+= cu
->header
.offset_size
;
2273 info_ptr
+= read_unsigned_leb128 (abfd
, info_ptr
, &bytes_read
);
2274 info_ptr
+= bytes_read
;
2276 case DW_FORM_block1
:
2277 info_ptr
+= 1 + read_1_byte (abfd
, info_ptr
);
2279 case DW_FORM_block2
:
2280 info_ptr
+= 2 + read_2_bytes (abfd
, info_ptr
);
2282 case DW_FORM_block4
:
2283 info_ptr
+= 4 + read_4_bytes (abfd
, info_ptr
);
2287 case DW_FORM_ref_udata
:
2288 info_ptr
= skip_leb128 (abfd
, info_ptr
);
2290 case DW_FORM_indirect
:
2291 form
= read_unsigned_leb128 (abfd
, info_ptr
, &bytes_read
);
2292 info_ptr
+= bytes_read
;
2293 /* We need to continue parsing from here, so just go back to
2295 goto skip_attribute
;
2298 error (_("Dwarf Error: Cannot handle %s in DWARF reader [in module %s]"),
2299 dwarf_form_name (form
),
2300 bfd_get_filename (abfd
));
2304 if (abbrev
->has_children
)
2305 return skip_children (info_ptr
, cu
);
2310 /* Locate ORIG_PDI's sibling; INFO_PTR should point to the start of
2311 the next DIE after ORIG_PDI. */
2314 locate_pdi_sibling (struct partial_die_info
*orig_pdi
, gdb_byte
*info_ptr
,
2315 bfd
*abfd
, struct dwarf2_cu
*cu
)
2317 /* Do we know the sibling already? */
2319 if (orig_pdi
->sibling
)
2320 return orig_pdi
->sibling
;
2322 /* Are there any children to deal with? */
2324 if (!orig_pdi
->has_children
)
2327 /* Skip the children the long way. */
2329 return skip_children (info_ptr
, cu
);
2332 /* Expand this partial symbol table into a full symbol table. */
2335 dwarf2_psymtab_to_symtab (struct partial_symtab
*pst
)
2337 /* FIXME: This is barely more than a stub. */
2342 warning (_("bug: psymtab for %s is already read in."), pst
->filename
);
2348 printf_filtered (_("Reading in symbols for %s..."), pst
->filename
);
2349 gdb_flush (gdb_stdout
);
2352 /* Restore our global data. */
2353 dwarf2_per_objfile
= objfile_data (pst
->objfile
,
2354 dwarf2_objfile_data_key
);
2356 psymtab_to_symtab_1 (pst
);
2358 /* Finish up the debug error message. */
2360 printf_filtered (_("done.\n"));
2365 /* Add PER_CU to the queue. */
2368 queue_comp_unit (struct dwarf2_per_cu_data
*per_cu
)
2370 struct dwarf2_queue_item
*item
;
2373 item
= xmalloc (sizeof (*item
));
2374 item
->per_cu
= per_cu
;
2377 if (dwarf2_queue
== NULL
)
2378 dwarf2_queue
= item
;
2380 dwarf2_queue_tail
->next
= item
;
2382 dwarf2_queue_tail
= item
;
2385 /* Process the queue. */
2388 process_queue (struct objfile
*objfile
)
2390 struct dwarf2_queue_item
*item
, *next_item
;
2392 /* Initially, there is just one item on the queue. Load its DIEs,
2393 and the DIEs of any other compilation units it requires,
2396 for (item
= dwarf2_queue
; item
!= NULL
; item
= item
->next
)
2398 /* Read in this compilation unit. This may add new items to
2399 the end of the queue. */
2400 load_full_comp_unit (item
->per_cu
, objfile
);
2402 item
->per_cu
->cu
->read_in_chain
= dwarf2_per_objfile
->read_in_chain
;
2403 dwarf2_per_objfile
->read_in_chain
= item
->per_cu
;
2405 /* If this compilation unit has already had full symbols created,
2406 reset the TYPE fields in each DIE. */
2407 if (item
->per_cu
->type_hash
)
2408 reset_die_and_siblings_types (item
->per_cu
->cu
->dies
,
2412 /* Now everything left on the queue needs to be read in. Process
2413 them, one at a time, removing from the queue as we finish. */
2414 for (item
= dwarf2_queue
; item
!= NULL
; dwarf2_queue
= item
= next_item
)
2416 if (item
->per_cu
->psymtab
&& !item
->per_cu
->psymtab
->readin
)
2417 process_full_comp_unit (item
->per_cu
);
2419 item
->per_cu
->queued
= 0;
2420 next_item
= item
->next
;
2424 dwarf2_queue_tail
= NULL
;
2427 /* Free all allocated queue entries. This function only releases anything if
2428 an error was thrown; if the queue was processed then it would have been
2429 freed as we went along. */
2432 dwarf2_release_queue (void *dummy
)
2434 struct dwarf2_queue_item
*item
, *last
;
2436 item
= dwarf2_queue
;
2439 /* Anything still marked queued is likely to be in an
2440 inconsistent state, so discard it. */
2441 if (item
->per_cu
->queued
)
2443 if (item
->per_cu
->cu
!= NULL
)
2444 free_one_cached_comp_unit (item
->per_cu
->cu
);
2445 item
->per_cu
->queued
= 0;
2453 dwarf2_queue
= dwarf2_queue_tail
= NULL
;
2456 /* Read in full symbols for PST, and anything it depends on. */
2459 psymtab_to_symtab_1 (struct partial_symtab
*pst
)
2461 struct dwarf2_per_cu_data
*per_cu
;
2462 struct cleanup
*back_to
;
2465 for (i
= 0; i
< pst
->number_of_dependencies
; i
++)
2466 if (!pst
->dependencies
[i
]->readin
)
2468 /* Inform about additional files that need to be read in. */
2471 /* FIXME: i18n: Need to make this a single string. */
2472 fputs_filtered (" ", gdb_stdout
);
2474 fputs_filtered ("and ", gdb_stdout
);
2476 printf_filtered ("%s...", pst
->dependencies
[i
]->filename
);
2477 wrap_here (""); /* Flush output */
2478 gdb_flush (gdb_stdout
);
2480 psymtab_to_symtab_1 (pst
->dependencies
[i
]);
2483 per_cu
= (struct dwarf2_per_cu_data
*) pst
->read_symtab_private
;
2487 /* It's an include file, no symbols to read for it.
2488 Everything is in the parent symtab. */
2493 back_to
= make_cleanup (dwarf2_release_queue
, NULL
);
2495 queue_comp_unit (per_cu
);
2497 process_queue (pst
->objfile
);
2499 /* Age the cache, releasing compilation units that have not
2500 been used recently. */
2501 age_cached_comp_units ();
2503 do_cleanups (back_to
);
2506 /* Load the DIEs associated with PST and PER_CU into memory. */
2508 static struct dwarf2_cu
*
2509 load_full_comp_unit (struct dwarf2_per_cu_data
*per_cu
, struct objfile
*objfile
)
2511 bfd
*abfd
= objfile
->obfd
;
2512 struct dwarf2_cu
*cu
;
2513 unsigned long offset
;
2515 struct cleanup
*back_to
, *free_cu_cleanup
;
2516 struct attribute
*attr
;
2519 /* Set local variables from the partial symbol table info. */
2520 offset
= per_cu
->offset
;
2522 info_ptr
= dwarf2_per_objfile
->info_buffer
+ offset
;
2524 cu
= xmalloc (sizeof (struct dwarf2_cu
));
2525 memset (cu
, 0, sizeof (struct dwarf2_cu
));
2527 /* If an error occurs while loading, release our storage. */
2528 free_cu_cleanup
= make_cleanup (free_one_comp_unit
, cu
);
2530 cu
->objfile
= objfile
;
2532 /* read in the comp_unit header */
2533 info_ptr
= read_comp_unit_head (&cu
->header
, info_ptr
, abfd
);
2535 /* Read the abbrevs for this compilation unit */
2536 dwarf2_read_abbrevs (abfd
, cu
);
2537 back_to
= make_cleanup (dwarf2_free_abbrev_table
, cu
);
2539 cu
->header
.offset
= offset
;
2541 cu
->per_cu
= per_cu
;
2544 /* We use this obstack for block values in dwarf_alloc_block. */
2545 obstack_init (&cu
->comp_unit_obstack
);
2547 cu
->dies
= read_comp_unit (info_ptr
, abfd
, cu
);
2549 /* We try not to read any attributes in this function, because not
2550 all objfiles needed for references have been loaded yet, and symbol
2551 table processing isn't initialized. But we have to set the CU language,
2552 or we won't be able to build types correctly. */
2553 attr
= dwarf2_attr (cu
->dies
, DW_AT_language
, cu
);
2555 set_cu_language (DW_UNSND (attr
), cu
);
2557 set_cu_language (language_minimal
, cu
);
2559 do_cleanups (back_to
);
2561 /* We've successfully allocated this compilation unit. Let our caller
2562 clean it up when finished with it. */
2563 discard_cleanups (free_cu_cleanup
);
2568 /* Generate full symbol information for PST and CU, whose DIEs have
2569 already been loaded into memory. */
2572 process_full_comp_unit (struct dwarf2_per_cu_data
*per_cu
)
2574 struct partial_symtab
*pst
= per_cu
->psymtab
;
2575 struct dwarf2_cu
*cu
= per_cu
->cu
;
2576 struct objfile
*objfile
= pst
->objfile
;
2577 bfd
*abfd
= objfile
->obfd
;
2578 CORE_ADDR lowpc
, highpc
;
2579 struct symtab
*symtab
;
2580 struct cleanup
*back_to
;
2581 struct attribute
*attr
;
2584 baseaddr
= ANOFFSET (objfile
->section_offsets
, SECT_OFF_TEXT (objfile
));
2586 /* We're in the global namespace. */
2587 processing_current_prefix
= "";
2590 back_to
= make_cleanup (really_free_pendings
, NULL
);
2592 cu
->list_in_scope
= &file_symbols
;
2594 /* Find the base address of the compilation unit for range lists and
2595 location lists. It will normally be specified by DW_AT_low_pc.
2596 In DWARF-3 draft 4, the base address could be overridden by
2597 DW_AT_entry_pc. It's been removed, but GCC still uses this for
2598 compilation units with discontinuous ranges. */
2600 cu
->header
.base_known
= 0;
2601 cu
->header
.base_address
= 0;
2603 attr
= dwarf2_attr (cu
->dies
, DW_AT_entry_pc
, cu
);
2606 cu
->header
.base_address
= DW_ADDR (attr
);
2607 cu
->header
.base_known
= 1;
2611 attr
= dwarf2_attr (cu
->dies
, DW_AT_low_pc
, cu
);
2614 cu
->header
.base_address
= DW_ADDR (attr
);
2615 cu
->header
.base_known
= 1;
2619 /* Do line number decoding in read_file_scope () */
2620 process_die (cu
->dies
, cu
);
2622 /* Some compilers don't define a DW_AT_high_pc attribute for the
2623 compilation unit. If the DW_AT_high_pc is missing, synthesize
2624 it, by scanning the DIE's below the compilation unit. */
2625 get_scope_pc_bounds (cu
->dies
, &lowpc
, &highpc
, cu
);
2627 symtab
= end_symtab (highpc
+ baseaddr
, objfile
, SECT_OFF_TEXT (objfile
));
2629 /* Set symtab language to language from DW_AT_language.
2630 If the compilation is from a C file generated by language preprocessors,
2631 do not set the language if it was already deduced by start_subfile. */
2633 && !(cu
->language
== language_c
&& symtab
->language
!= language_c
))
2635 symtab
->language
= cu
->language
;
2637 pst
->symtab
= symtab
;
2640 do_cleanups (back_to
);
2643 /* Process a die and its children. */
2646 process_die (struct die_info
*die
, struct dwarf2_cu
*cu
)
2650 case DW_TAG_padding
:
2652 case DW_TAG_compile_unit
:
2653 read_file_scope (die
, cu
);
2655 case DW_TAG_subprogram
:
2656 read_subroutine_type (die
, cu
);
2657 read_func_scope (die
, cu
);
2659 case DW_TAG_inlined_subroutine
:
2660 /* FIXME: These are ignored for now.
2661 They could be used to set breakpoints on all inlined instances
2662 of a function and make GDB `next' properly over inlined functions. */
2664 case DW_TAG_lexical_block
:
2665 case DW_TAG_try_block
:
2666 case DW_TAG_catch_block
:
2667 read_lexical_block_scope (die
, cu
);
2669 case DW_TAG_class_type
:
2670 case DW_TAG_structure_type
:
2671 case DW_TAG_union_type
:
2672 read_structure_type (die
, cu
);
2673 process_structure_scope (die
, cu
);
2675 case DW_TAG_enumeration_type
:
2676 read_enumeration_type (die
, cu
);
2677 process_enumeration_scope (die
, cu
);
2680 /* FIXME drow/2004-03-14: These initialize die->type, but do not create
2681 a symbol or process any children. Therefore it doesn't do anything
2682 that won't be done on-demand by read_type_die. */
2683 case DW_TAG_subroutine_type
:
2684 read_subroutine_type (die
, cu
);
2686 case DW_TAG_set_type
:
2687 read_set_type (die
, cu
);
2689 case DW_TAG_array_type
:
2690 read_array_type (die
, cu
);
2692 case DW_TAG_pointer_type
:
2693 read_tag_pointer_type (die
, cu
);
2695 case DW_TAG_ptr_to_member_type
:
2696 read_tag_ptr_to_member_type (die
, cu
);
2698 case DW_TAG_reference_type
:
2699 read_tag_reference_type (die
, cu
);
2701 case DW_TAG_string_type
:
2702 read_tag_string_type (die
, cu
);
2706 case DW_TAG_base_type
:
2707 read_base_type (die
, cu
);
2708 /* Add a typedef symbol for the type definition, if it has a
2710 new_symbol (die
, die
->type
, cu
);
2712 case DW_TAG_subrange_type
:
2713 read_subrange_type (die
, cu
);
2714 /* Add a typedef symbol for the type definition, if it has a
2716 new_symbol (die
, die
->type
, cu
);
2718 case DW_TAG_common_block
:
2719 read_common_block (die
, cu
);
2721 case DW_TAG_common_inclusion
:
2723 case DW_TAG_namespace
:
2724 processing_has_namespace_info
= 1;
2725 read_namespace (die
, cu
);
2727 case DW_TAG_imported_declaration
:
2728 case DW_TAG_imported_module
:
2729 /* FIXME: carlton/2002-10-16: Eventually, we should use the
2730 information contained in these. DW_TAG_imported_declaration
2731 dies shouldn't have children; DW_TAG_imported_module dies
2732 shouldn't in the C++ case, but conceivably could in the
2733 Fortran case, so we'll have to replace this gdb_assert if
2734 Fortran compilers start generating that info. */
2735 processing_has_namespace_info
= 1;
2736 gdb_assert (die
->child
== NULL
);
2739 new_symbol (die
, NULL
, cu
);
2745 initialize_cu_func_list (struct dwarf2_cu
*cu
)
2747 cu
->first_fn
= cu
->last_fn
= cu
->cached_fn
= NULL
;
2751 read_file_scope (struct die_info
*die
, struct dwarf2_cu
*cu
)
2753 struct objfile
*objfile
= cu
->objfile
;
2754 struct comp_unit_head
*cu_header
= &cu
->header
;
2755 struct cleanup
*back_to
= make_cleanup (null_cleanup
, 0);
2756 CORE_ADDR lowpc
= ((CORE_ADDR
) -1);
2757 CORE_ADDR highpc
= ((CORE_ADDR
) 0);
2758 struct attribute
*attr
;
2759 char *name
= "<unknown>";
2760 char *comp_dir
= NULL
;
2761 struct die_info
*child_die
;
2762 bfd
*abfd
= objfile
->obfd
;
2763 struct line_header
*line_header
= 0;
2766 baseaddr
= ANOFFSET (objfile
->section_offsets
, SECT_OFF_TEXT (objfile
));
2768 get_scope_pc_bounds (die
, &lowpc
, &highpc
, cu
);
2770 /* If we didn't find a lowpc, set it to highpc to avoid complaints
2771 from finish_block. */
2772 if (lowpc
== ((CORE_ADDR
) -1))
2777 attr
= dwarf2_attr (die
, DW_AT_name
, cu
);
2780 name
= DW_STRING (attr
);
2782 attr
= dwarf2_attr (die
, DW_AT_comp_dir
, cu
);
2785 comp_dir
= DW_STRING (attr
);
2788 /* Irix 6.2 native cc prepends <machine>.: to the compilation
2789 directory, get rid of it. */
2790 char *cp
= strchr (comp_dir
, ':');
2792 if (cp
&& cp
!= comp_dir
&& cp
[-1] == '.' && cp
[1] == '/')
2797 attr
= dwarf2_attr (die
, DW_AT_language
, cu
);
2800 set_cu_language (DW_UNSND (attr
), cu
);
2803 attr
= dwarf2_attr (die
, DW_AT_producer
, cu
);
2805 cu
->producer
= DW_STRING (attr
);
2807 /* We assume that we're processing GCC output. */
2808 processing_gcc_compilation
= 2;
2810 /* FIXME:Do something here. */
2811 if (dip
->at_producer
!= NULL
)
2813 handle_producer (dip
->at_producer
);
2817 /* The compilation unit may be in a different language or objfile,
2818 zero out all remembered fundamental types. */
2819 memset (cu
->ftypes
, 0, FT_NUM_MEMBERS
* sizeof (struct type
*));
2821 start_symtab (name
, comp_dir
, lowpc
);
2822 record_debugformat ("DWARF 2");
2824 initialize_cu_func_list (cu
);
2826 /* Process all dies in compilation unit. */
2827 if (die
->child
!= NULL
)
2829 child_die
= die
->child
;
2830 while (child_die
&& child_die
->tag
)
2832 process_die (child_die
, cu
);
2833 child_die
= sibling_die (child_die
);
2837 /* Decode line number information if present. */
2838 attr
= dwarf2_attr (die
, DW_AT_stmt_list
, cu
);
2841 unsigned int line_offset
= DW_UNSND (attr
);
2842 line_header
= dwarf_decode_line_header (line_offset
, abfd
, cu
);
2845 make_cleanup ((make_cleanup_ftype
*) free_line_header
,
2846 (void *) line_header
);
2847 dwarf_decode_lines (line_header
, comp_dir
, abfd
, cu
, NULL
);
2851 /* Decode macro information, if present. Dwarf 2 macro information
2852 refers to information in the line number info statement program
2853 header, so we can only read it if we've read the header
2855 attr
= dwarf2_attr (die
, DW_AT_macro_info
, cu
);
2856 if (attr
&& line_header
)
2858 unsigned int macro_offset
= DW_UNSND (attr
);
2859 dwarf_decode_macros (line_header
, macro_offset
,
2860 comp_dir
, abfd
, cu
);
2862 do_cleanups (back_to
);
2866 add_to_cu_func_list (const char *name
, CORE_ADDR lowpc
, CORE_ADDR highpc
,
2867 struct dwarf2_cu
*cu
)
2869 struct function_range
*thisfn
;
2871 thisfn
= (struct function_range
*)
2872 obstack_alloc (&cu
->comp_unit_obstack
, sizeof (struct function_range
));
2873 thisfn
->name
= name
;
2874 thisfn
->lowpc
= lowpc
;
2875 thisfn
->highpc
= highpc
;
2876 thisfn
->seen_line
= 0;
2877 thisfn
->next
= NULL
;
2879 if (cu
->last_fn
== NULL
)
2880 cu
->first_fn
= thisfn
;
2882 cu
->last_fn
->next
= thisfn
;
2884 cu
->last_fn
= thisfn
;
2888 read_func_scope (struct die_info
*die
, struct dwarf2_cu
*cu
)
2890 struct objfile
*objfile
= cu
->objfile
;
2891 struct context_stack
*new;
2894 struct die_info
*child_die
;
2895 struct attribute
*attr
;
2897 const char *previous_prefix
= processing_current_prefix
;
2898 struct cleanup
*back_to
= NULL
;
2901 baseaddr
= ANOFFSET (objfile
->section_offsets
, SECT_OFF_TEXT (objfile
));
2903 name
= dwarf2_linkage_name (die
, cu
);
2905 /* Ignore functions with missing or empty names and functions with
2906 missing or invalid low and high pc attributes. */
2907 if (name
== NULL
|| !dwarf2_get_pc_bounds (die
, &lowpc
, &highpc
, cu
))
2910 if (cu
->language
== language_cplus
2911 || cu
->language
== language_java
)
2913 struct die_info
*spec_die
= die_specification (die
, cu
);
2915 /* NOTE: carlton/2004-01-23: We have to be careful in the
2916 presence of DW_AT_specification. For example, with GCC 3.4,
2921 // Definition of N::foo.
2925 then we'll have a tree of DIEs like this:
2927 1: DW_TAG_compile_unit
2928 2: DW_TAG_namespace // N
2929 3: DW_TAG_subprogram // declaration of N::foo
2930 4: DW_TAG_subprogram // definition of N::foo
2931 DW_AT_specification // refers to die #3
2933 Thus, when processing die #4, we have to pretend that we're
2934 in the context of its DW_AT_specification, namely the contex
2937 if (spec_die
!= NULL
)
2939 char *specification_prefix
= determine_prefix (spec_die
, cu
);
2940 processing_current_prefix
= specification_prefix
;
2941 back_to
= make_cleanup (xfree
, specification_prefix
);
2948 /* Record the function range for dwarf_decode_lines. */
2949 add_to_cu_func_list (name
, lowpc
, highpc
, cu
);
2951 new = push_context (0, lowpc
);
2952 new->name
= new_symbol (die
, die
->type
, cu
);
2954 /* If there is a location expression for DW_AT_frame_base, record
2956 attr
= dwarf2_attr (die
, DW_AT_frame_base
, cu
);
2958 /* FIXME: cagney/2004-01-26: The DW_AT_frame_base's location
2959 expression is being recorded directly in the function's symbol
2960 and not in a separate frame-base object. I guess this hack is
2961 to avoid adding some sort of frame-base adjunct/annex to the
2962 function's symbol :-(. The problem with doing this is that it
2963 results in a function symbol with a location expression that
2964 has nothing to do with the location of the function, ouch! The
2965 relationship should be: a function's symbol has-a frame base; a
2966 frame-base has-a location expression. */
2967 dwarf2_symbol_mark_computed (attr
, new->name
, cu
);
2969 cu
->list_in_scope
= &local_symbols
;
2971 if (die
->child
!= NULL
)
2973 child_die
= die
->child
;
2974 while (child_die
&& child_die
->tag
)
2976 process_die (child_die
, cu
);
2977 child_die
= sibling_die (child_die
);
2981 new = pop_context ();
2982 /* Make a block for the local symbols within. */
2983 finish_block (new->name
, &local_symbols
, new->old_blocks
,
2984 lowpc
, highpc
, objfile
);
2986 /* In C++, we can have functions nested inside functions (e.g., when
2987 a function declares a class that has methods). This means that
2988 when we finish processing a function scope, we may need to go
2989 back to building a containing block's symbol lists. */
2990 local_symbols
= new->locals
;
2991 param_symbols
= new->params
;
2993 /* If we've finished processing a top-level function, subsequent
2994 symbols go in the file symbol list. */
2995 if (outermost_context_p ())
2996 cu
->list_in_scope
= &file_symbols
;
2998 processing_current_prefix
= previous_prefix
;
2999 if (back_to
!= NULL
)
3000 do_cleanups (back_to
);
3003 /* Process all the DIES contained within a lexical block scope. Start
3004 a new scope, process the dies, and then close the scope. */
3007 read_lexical_block_scope (struct die_info
*die
, struct dwarf2_cu
*cu
)
3009 struct objfile
*objfile
= cu
->objfile
;
3010 struct context_stack
*new;
3011 CORE_ADDR lowpc
, highpc
;
3012 struct die_info
*child_die
;
3015 baseaddr
= ANOFFSET (objfile
->section_offsets
, SECT_OFF_TEXT (objfile
));
3017 /* Ignore blocks with missing or invalid low and high pc attributes. */
3018 /* ??? Perhaps consider discontiguous blocks defined by DW_AT_ranges
3019 as multiple lexical blocks? Handling children in a sane way would
3020 be nasty. Might be easier to properly extend generic blocks to
3022 if (!dwarf2_get_pc_bounds (die
, &lowpc
, &highpc
, cu
))
3027 push_context (0, lowpc
);
3028 if (die
->child
!= NULL
)
3030 child_die
= die
->child
;
3031 while (child_die
&& child_die
->tag
)
3033 process_die (child_die
, cu
);
3034 child_die
= sibling_die (child_die
);
3037 new = pop_context ();
3039 if (local_symbols
!= NULL
)
3041 finish_block (0, &local_symbols
, new->old_blocks
, new->start_addr
,
3044 local_symbols
= new->locals
;
3047 /* Get low and high pc attributes from a die. Return 1 if the attributes
3048 are present and valid, otherwise, return 0. Return -1 if the range is
3049 discontinuous, i.e. derived from DW_AT_ranges information. */
3051 dwarf2_get_pc_bounds (struct die_info
*die
, CORE_ADDR
*lowpc
,
3052 CORE_ADDR
*highpc
, struct dwarf2_cu
*cu
)
3054 struct objfile
*objfile
= cu
->objfile
;
3055 struct comp_unit_head
*cu_header
= &cu
->header
;
3056 struct attribute
*attr
;
3057 bfd
*obfd
= objfile
->obfd
;
3062 attr
= dwarf2_attr (die
, DW_AT_high_pc
, cu
);
3065 high
= DW_ADDR (attr
);
3066 attr
= dwarf2_attr (die
, DW_AT_low_pc
, cu
);
3068 low
= DW_ADDR (attr
);
3070 /* Found high w/o low attribute. */
3073 /* Found consecutive range of addresses. */
3078 attr
= dwarf2_attr (die
, DW_AT_ranges
, cu
);
3081 unsigned int addr_size
= cu_header
->addr_size
;
3082 CORE_ADDR mask
= ~(~(CORE_ADDR
)1 << (addr_size
* 8 - 1));
3083 /* Value of the DW_AT_ranges attribute is the offset in the
3084 .debug_ranges section. */
3085 unsigned int offset
= DW_UNSND (attr
);
3086 /* Base address selection entry. */
3094 found_base
= cu_header
->base_known
;
3095 base
= cu_header
->base_address
;
3097 if (offset
>= dwarf2_per_objfile
->ranges_size
)
3099 complaint (&symfile_complaints
,
3100 _("Offset %d out of bounds for DW_AT_ranges attribute"),
3104 buffer
= dwarf2_per_objfile
->ranges_buffer
+ offset
;
3106 /* Read in the largest possible address. */
3107 marker
= read_address (obfd
, buffer
, cu
, &dummy
);
3108 if ((marker
& mask
) == mask
)
3110 /* If we found the largest possible address, then
3111 read the base address. */
3112 base
= read_address (obfd
, buffer
+ addr_size
, cu
, &dummy
);
3113 buffer
+= 2 * addr_size
;
3114 offset
+= 2 * addr_size
;
3122 CORE_ADDR range_beginning
, range_end
;
3124 range_beginning
= read_address (obfd
, buffer
, cu
, &dummy
);
3125 buffer
+= addr_size
;
3126 range_end
= read_address (obfd
, buffer
, cu
, &dummy
);
3127 buffer
+= addr_size
;
3128 offset
+= 2 * addr_size
;
3130 /* An end of list marker is a pair of zero addresses. */
3131 if (range_beginning
== 0 && range_end
== 0)
3132 /* Found the end of list entry. */
3135 /* Each base address selection entry is a pair of 2 values.
3136 The first is the largest possible address, the second is
3137 the base address. Check for a base address here. */
3138 if ((range_beginning
& mask
) == mask
)
3140 /* If we found the largest possible address, then
3141 read the base address. */
3142 base
= read_address (obfd
, buffer
+ addr_size
, cu
, &dummy
);
3149 /* We have no valid base address for the ranges
3151 complaint (&symfile_complaints
,
3152 _("Invalid .debug_ranges data (no base address)"));
3156 range_beginning
+= base
;
3159 /* FIXME: This is recording everything as a low-high
3160 segment of consecutive addresses. We should have a
3161 data structure for discontiguous block ranges
3165 low
= range_beginning
;
3171 if (range_beginning
< low
)
3172 low
= range_beginning
;
3173 if (range_end
> high
)
3179 /* If the first entry is an end-of-list marker, the range
3180 describes an empty scope, i.e. no instructions. */
3190 /* When using the GNU linker, .gnu.linkonce. sections are used to
3191 eliminate duplicate copies of functions and vtables and such.
3192 The linker will arbitrarily choose one and discard the others.
3193 The AT_*_pc values for such functions refer to local labels in
3194 these sections. If the section from that file was discarded, the
3195 labels are not in the output, so the relocs get a value of 0.
3196 If this is a discarded function, mark the pc bounds as invalid,
3197 so that GDB will ignore it. */
3198 if (low
== 0 && !dwarf2_per_objfile
->has_section_at_zero
)
3206 /* Get the low and high pc's represented by the scope DIE, and store
3207 them in *LOWPC and *HIGHPC. If the correct values can't be
3208 determined, set *LOWPC to -1 and *HIGHPC to 0. */
3211 get_scope_pc_bounds (struct die_info
*die
,
3212 CORE_ADDR
*lowpc
, CORE_ADDR
*highpc
,
3213 struct dwarf2_cu
*cu
)
3215 CORE_ADDR best_low
= (CORE_ADDR
) -1;
3216 CORE_ADDR best_high
= (CORE_ADDR
) 0;
3217 CORE_ADDR current_low
, current_high
;
3219 if (dwarf2_get_pc_bounds (die
, ¤t_low
, ¤t_high
, cu
))
3221 best_low
= current_low
;
3222 best_high
= current_high
;
3226 struct die_info
*child
= die
->child
;
3228 while (child
&& child
->tag
)
3230 switch (child
->tag
) {
3231 case DW_TAG_subprogram
:
3232 if (dwarf2_get_pc_bounds (child
, ¤t_low
, ¤t_high
, cu
))
3234 best_low
= min (best_low
, current_low
);
3235 best_high
= max (best_high
, current_high
);
3238 case DW_TAG_namespace
:
3239 /* FIXME: carlton/2004-01-16: Should we do this for
3240 DW_TAG_class_type/DW_TAG_structure_type, too? I think
3241 that current GCC's always emit the DIEs corresponding
3242 to definitions of methods of classes as children of a
3243 DW_TAG_compile_unit or DW_TAG_namespace (as opposed to
3244 the DIEs giving the declarations, which could be
3245 anywhere). But I don't see any reason why the
3246 standards says that they have to be there. */
3247 get_scope_pc_bounds (child
, ¤t_low
, ¤t_high
, cu
);
3249 if (current_low
!= ((CORE_ADDR
) -1))
3251 best_low
= min (best_low
, current_low
);
3252 best_high
= max (best_high
, current_high
);
3260 child
= sibling_die (child
);
3265 *highpc
= best_high
;
3268 /* Add an aggregate field to the field list. */
3271 dwarf2_add_field (struct field_info
*fip
, struct die_info
*die
,
3272 struct dwarf2_cu
*cu
)
3274 struct objfile
*objfile
= cu
->objfile
;
3275 struct nextfield
*new_field
;
3276 struct attribute
*attr
;
3278 char *fieldname
= "";
3280 /* Allocate a new field list entry and link it in. */
3281 new_field
= (struct nextfield
*) xmalloc (sizeof (struct nextfield
));
3282 make_cleanup (xfree
, new_field
);
3283 memset (new_field
, 0, sizeof (struct nextfield
));
3284 new_field
->next
= fip
->fields
;
3285 fip
->fields
= new_field
;
3288 /* Handle accessibility and virtuality of field.
3289 The default accessibility for members is public, the default
3290 accessibility for inheritance is private. */
3291 if (die
->tag
!= DW_TAG_inheritance
)
3292 new_field
->accessibility
= DW_ACCESS_public
;
3294 new_field
->accessibility
= DW_ACCESS_private
;
3295 new_field
->virtuality
= DW_VIRTUALITY_none
;
3297 attr
= dwarf2_attr (die
, DW_AT_accessibility
, cu
);
3299 new_field
->accessibility
= DW_UNSND (attr
);
3300 if (new_field
->accessibility
!= DW_ACCESS_public
)
3301 fip
->non_public_fields
= 1;
3302 attr
= dwarf2_attr (die
, DW_AT_virtuality
, cu
);
3304 new_field
->virtuality
= DW_UNSND (attr
);
3306 fp
= &new_field
->field
;
3308 if (die
->tag
== DW_TAG_member
&& ! die_is_declaration (die
, cu
))
3310 /* Data member other than a C++ static data member. */
3312 /* Get type of field. */
3313 fp
->type
= die_type (die
, cu
);
3315 FIELD_STATIC_KIND (*fp
) = 0;
3317 /* Get bit size of field (zero if none). */
3318 attr
= dwarf2_attr (die
, DW_AT_bit_size
, cu
);
3321 FIELD_BITSIZE (*fp
) = DW_UNSND (attr
);
3325 FIELD_BITSIZE (*fp
) = 0;
3328 /* Get bit offset of field. */
3329 attr
= dwarf2_attr (die
, DW_AT_data_member_location
, cu
);
3332 FIELD_BITPOS (*fp
) =
3333 decode_locdesc (DW_BLOCK (attr
), cu
) * bits_per_byte
;
3336 FIELD_BITPOS (*fp
) = 0;
3337 attr
= dwarf2_attr (die
, DW_AT_bit_offset
, cu
);
3340 if (BITS_BIG_ENDIAN
)
3342 /* For big endian bits, the DW_AT_bit_offset gives the
3343 additional bit offset from the MSB of the containing
3344 anonymous object to the MSB of the field. We don't
3345 have to do anything special since we don't need to
3346 know the size of the anonymous object. */
3347 FIELD_BITPOS (*fp
) += DW_UNSND (attr
);
3351 /* For little endian bits, compute the bit offset to the
3352 MSB of the anonymous object, subtract off the number of
3353 bits from the MSB of the field to the MSB of the
3354 object, and then subtract off the number of bits of
3355 the field itself. The result is the bit offset of
3356 the LSB of the field. */
3358 int bit_offset
= DW_UNSND (attr
);
3360 attr
= dwarf2_attr (die
, DW_AT_byte_size
, cu
);
3363 /* The size of the anonymous object containing
3364 the bit field is explicit, so use the
3365 indicated size (in bytes). */
3366 anonymous_size
= DW_UNSND (attr
);
3370 /* The size of the anonymous object containing
3371 the bit field must be inferred from the type
3372 attribute of the data member containing the
3374 anonymous_size
= TYPE_LENGTH (fp
->type
);
3376 FIELD_BITPOS (*fp
) += anonymous_size
* bits_per_byte
3377 - bit_offset
- FIELD_BITSIZE (*fp
);
3381 /* Get name of field. */
3382 attr
= dwarf2_attr (die
, DW_AT_name
, cu
);
3383 if (attr
&& DW_STRING (attr
))
3384 fieldname
= DW_STRING (attr
);
3386 /* The name is already allocated along with this objfile, so we don't
3387 need to duplicate it for the type. */
3388 fp
->name
= fieldname
;
3390 /* Change accessibility for artificial fields (e.g. virtual table
3391 pointer or virtual base class pointer) to private. */
3392 if (dwarf2_attr (die
, DW_AT_artificial
, cu
))
3394 new_field
->accessibility
= DW_ACCESS_private
;
3395 fip
->non_public_fields
= 1;
3398 else if (die
->tag
== DW_TAG_member
|| die
->tag
== DW_TAG_variable
)
3400 /* C++ static member. */
3402 /* NOTE: carlton/2002-11-05: It should be a DW_TAG_member that
3403 is a declaration, but all versions of G++ as of this writing
3404 (so through at least 3.2.1) incorrectly generate
3405 DW_TAG_variable tags. */
3409 /* Get name of field. */
3410 attr
= dwarf2_attr (die
, DW_AT_name
, cu
);
3411 if (attr
&& DW_STRING (attr
))
3412 fieldname
= DW_STRING (attr
);
3416 /* Get physical name. */
3417 physname
= dwarf2_linkage_name (die
, cu
);
3419 /* The name is already allocated along with this objfile, so we don't
3420 need to duplicate it for the type. */
3421 SET_FIELD_PHYSNAME (*fp
, physname
? physname
: "");
3422 FIELD_TYPE (*fp
) = die_type (die
, cu
);
3423 FIELD_NAME (*fp
) = fieldname
;
3425 else if (die
->tag
== DW_TAG_inheritance
)
3427 /* C++ base class field. */
3428 attr
= dwarf2_attr (die
, DW_AT_data_member_location
, cu
);
3430 FIELD_BITPOS (*fp
) = (decode_locdesc (DW_BLOCK (attr
), cu
)
3432 FIELD_BITSIZE (*fp
) = 0;
3433 FIELD_STATIC_KIND (*fp
) = 0;
3434 FIELD_TYPE (*fp
) = die_type (die
, cu
);
3435 FIELD_NAME (*fp
) = type_name_no_tag (fp
->type
);
3436 fip
->nbaseclasses
++;
3440 /* Create the vector of fields, and attach it to the type. */
3443 dwarf2_attach_fields_to_type (struct field_info
*fip
, struct type
*type
,
3444 struct dwarf2_cu
*cu
)
3446 int nfields
= fip
->nfields
;
3448 /* Record the field count, allocate space for the array of fields,
3449 and create blank accessibility bitfields if necessary. */
3450 TYPE_NFIELDS (type
) = nfields
;
3451 TYPE_FIELDS (type
) = (struct field
*)
3452 TYPE_ALLOC (type
, sizeof (struct field
) * nfields
);
3453 memset (TYPE_FIELDS (type
), 0, sizeof (struct field
) * nfields
);
3455 if (fip
->non_public_fields
)
3457 ALLOCATE_CPLUS_STRUCT_TYPE (type
);
3459 TYPE_FIELD_PRIVATE_BITS (type
) =
3460 (B_TYPE
*) TYPE_ALLOC (type
, B_BYTES (nfields
));
3461 B_CLRALL (TYPE_FIELD_PRIVATE_BITS (type
), nfields
);
3463 TYPE_FIELD_PROTECTED_BITS (type
) =
3464 (B_TYPE
*) TYPE_ALLOC (type
, B_BYTES (nfields
));
3465 B_CLRALL (TYPE_FIELD_PROTECTED_BITS (type
), nfields
);
3467 TYPE_FIELD_IGNORE_BITS (type
) =
3468 (B_TYPE
*) TYPE_ALLOC (type
, B_BYTES (nfields
));
3469 B_CLRALL (TYPE_FIELD_IGNORE_BITS (type
), nfields
);
3472 /* If the type has baseclasses, allocate and clear a bit vector for
3473 TYPE_FIELD_VIRTUAL_BITS. */
3474 if (fip
->nbaseclasses
)
3476 int num_bytes
= B_BYTES (fip
->nbaseclasses
);
3477 unsigned char *pointer
;
3479 ALLOCATE_CPLUS_STRUCT_TYPE (type
);
3480 pointer
= TYPE_ALLOC (type
, num_bytes
);
3481 TYPE_FIELD_VIRTUAL_BITS (type
) = pointer
;
3482 B_CLRALL (TYPE_FIELD_VIRTUAL_BITS (type
), fip
->nbaseclasses
);
3483 TYPE_N_BASECLASSES (type
) = fip
->nbaseclasses
;
3486 /* Copy the saved-up fields into the field vector. Start from the head
3487 of the list, adding to the tail of the field array, so that they end
3488 up in the same order in the array in which they were added to the list. */
3489 while (nfields
-- > 0)
3491 TYPE_FIELD (type
, nfields
) = fip
->fields
->field
;
3492 switch (fip
->fields
->accessibility
)
3494 case DW_ACCESS_private
:
3495 SET_TYPE_FIELD_PRIVATE (type
, nfields
);
3498 case DW_ACCESS_protected
:
3499 SET_TYPE_FIELD_PROTECTED (type
, nfields
);
3502 case DW_ACCESS_public
:
3506 /* Unknown accessibility. Complain and treat it as public. */
3508 complaint (&symfile_complaints
, _("unsupported accessibility %d"),
3509 fip
->fields
->accessibility
);
3513 if (nfields
< fip
->nbaseclasses
)
3515 switch (fip
->fields
->virtuality
)
3517 case DW_VIRTUALITY_virtual
:
3518 case DW_VIRTUALITY_pure_virtual
:
3519 SET_TYPE_FIELD_VIRTUAL (type
, nfields
);
3523 fip
->fields
= fip
->fields
->next
;
3527 /* Add a member function to the proper fieldlist. */
3530 dwarf2_add_member_fn (struct field_info
*fip
, struct die_info
*die
,
3531 struct type
*type
, struct dwarf2_cu
*cu
)
3533 struct objfile
*objfile
= cu
->objfile
;
3534 struct attribute
*attr
;
3535 struct fnfieldlist
*flp
;
3537 struct fn_field
*fnp
;
3540 struct nextfnfield
*new_fnfield
;
3542 /* Get name of member function. */
3543 attr
= dwarf2_attr (die
, DW_AT_name
, cu
);
3544 if (attr
&& DW_STRING (attr
))
3545 fieldname
= DW_STRING (attr
);
3549 /* Get the mangled name. */
3550 physname
= dwarf2_linkage_name (die
, cu
);
3552 /* Look up member function name in fieldlist. */
3553 for (i
= 0; i
< fip
->nfnfields
; i
++)
3555 if (strcmp (fip
->fnfieldlists
[i
].name
, fieldname
) == 0)
3559 /* Create new list element if necessary. */
3560 if (i
< fip
->nfnfields
)
3561 flp
= &fip
->fnfieldlists
[i
];
3564 if ((fip
->nfnfields
% DW_FIELD_ALLOC_CHUNK
) == 0)
3566 fip
->fnfieldlists
= (struct fnfieldlist
*)
3567 xrealloc (fip
->fnfieldlists
,
3568 (fip
->nfnfields
+ DW_FIELD_ALLOC_CHUNK
)
3569 * sizeof (struct fnfieldlist
));
3570 if (fip
->nfnfields
== 0)
3571 make_cleanup (free_current_contents
, &fip
->fnfieldlists
);
3573 flp
= &fip
->fnfieldlists
[fip
->nfnfields
];
3574 flp
->name
= fieldname
;
3580 /* Create a new member function field and chain it to the field list
3582 new_fnfield
= (struct nextfnfield
*) xmalloc (sizeof (struct nextfnfield
));
3583 make_cleanup (xfree
, new_fnfield
);
3584 memset (new_fnfield
, 0, sizeof (struct nextfnfield
));
3585 new_fnfield
->next
= flp
->head
;
3586 flp
->head
= new_fnfield
;
3589 /* Fill in the member function field info. */
3590 fnp
= &new_fnfield
->fnfield
;
3591 /* The name is already allocated along with this objfile, so we don't
3592 need to duplicate it for the type. */
3593 fnp
->physname
= physname
? physname
: "";
3594 fnp
->type
= alloc_type (objfile
);
3595 if (die
->type
&& TYPE_CODE (die
->type
) == TYPE_CODE_FUNC
)
3597 int nparams
= TYPE_NFIELDS (die
->type
);
3599 /* TYPE is the domain of this method, and DIE->TYPE is the type
3600 of the method itself (TYPE_CODE_METHOD). */
3601 smash_to_method_type (fnp
->type
, type
,
3602 TYPE_TARGET_TYPE (die
->type
),
3603 TYPE_FIELDS (die
->type
),
3604 TYPE_NFIELDS (die
->type
),
3605 TYPE_VARARGS (die
->type
));
3607 /* Handle static member functions.
3608 Dwarf2 has no clean way to discern C++ static and non-static
3609 member functions. G++ helps GDB by marking the first
3610 parameter for non-static member functions (which is the
3611 this pointer) as artificial. We obtain this information
3612 from read_subroutine_type via TYPE_FIELD_ARTIFICIAL. */
3613 if (nparams
== 0 || TYPE_FIELD_ARTIFICIAL (die
->type
, 0) == 0)
3614 fnp
->voffset
= VOFFSET_STATIC
;
3617 complaint (&symfile_complaints
, _("member function type missing for '%s'"),
3620 /* Get fcontext from DW_AT_containing_type if present. */
3621 if (dwarf2_attr (die
, DW_AT_containing_type
, cu
) != NULL
)
3622 fnp
->fcontext
= die_containing_type (die
, cu
);
3624 /* dwarf2 doesn't have stubbed physical names, so the setting of is_const
3625 and is_volatile is irrelevant, as it is needed by gdb_mangle_name only. */
3627 /* Get accessibility. */
3628 attr
= dwarf2_attr (die
, DW_AT_accessibility
, cu
);
3631 switch (DW_UNSND (attr
))
3633 case DW_ACCESS_private
:
3634 fnp
->is_private
= 1;
3636 case DW_ACCESS_protected
:
3637 fnp
->is_protected
= 1;
3642 /* Check for artificial methods. */
3643 attr
= dwarf2_attr (die
, DW_AT_artificial
, cu
);
3644 if (attr
&& DW_UNSND (attr
) != 0)
3645 fnp
->is_artificial
= 1;
3647 /* Get index in virtual function table if it is a virtual member function. */
3648 attr
= dwarf2_attr (die
, DW_AT_vtable_elem_location
, cu
);
3651 /* Support the .debug_loc offsets */
3652 if (attr_form_is_block (attr
))
3654 fnp
->voffset
= decode_locdesc (DW_BLOCK (attr
), cu
) + 2;
3656 else if (attr
->form
== DW_FORM_data4
|| attr
->form
== DW_FORM_data8
)
3658 dwarf2_complex_location_expr_complaint ();
3662 dwarf2_invalid_attrib_class_complaint ("DW_AT_vtable_elem_location",
3668 /* Create the vector of member function fields, and attach it to the type. */
3671 dwarf2_attach_fn_fields_to_type (struct field_info
*fip
, struct type
*type
,
3672 struct dwarf2_cu
*cu
)
3674 struct fnfieldlist
*flp
;
3675 int total_length
= 0;
3678 ALLOCATE_CPLUS_STRUCT_TYPE (type
);
3679 TYPE_FN_FIELDLISTS (type
) = (struct fn_fieldlist
*)
3680 TYPE_ALLOC (type
, sizeof (struct fn_fieldlist
) * fip
->nfnfields
);
3682 for (i
= 0, flp
= fip
->fnfieldlists
; i
< fip
->nfnfields
; i
++, flp
++)
3684 struct nextfnfield
*nfp
= flp
->head
;
3685 struct fn_fieldlist
*fn_flp
= &TYPE_FN_FIELDLIST (type
, i
);
3688 TYPE_FN_FIELDLIST_NAME (type
, i
) = flp
->name
;
3689 TYPE_FN_FIELDLIST_LENGTH (type
, i
) = flp
->length
;
3690 fn_flp
->fn_fields
= (struct fn_field
*)
3691 TYPE_ALLOC (type
, sizeof (struct fn_field
) * flp
->length
);
3692 for (k
= flp
->length
; (k
--, nfp
); nfp
= nfp
->next
)
3693 fn_flp
->fn_fields
[k
] = nfp
->fnfield
;
3695 total_length
+= flp
->length
;
3698 TYPE_NFN_FIELDS (type
) = fip
->nfnfields
;
3699 TYPE_NFN_FIELDS_TOTAL (type
) = total_length
;
3703 /* Returns non-zero if NAME is the name of a vtable member in CU's
3704 language, zero otherwise. */
3706 is_vtable_name (const char *name
, struct dwarf2_cu
*cu
)
3708 static const char vptr
[] = "_vptr";
3709 static const char vtable
[] = "vtable";
3711 /* Look for the C++ and Java forms of the vtable. */
3712 if ((cu
->language
== language_java
3713 && strncmp (name
, vtable
, sizeof (vtable
) - 1) == 0)
3714 || (strncmp (name
, vptr
, sizeof (vptr
) - 1) == 0
3715 && is_cplus_marker (name
[sizeof (vptr
) - 1])))
3721 /* GCC outputs unnamed structures that are really pointers to member
3722 functions, with the ABI-specified layout. If DIE (from CU) describes
3723 such a structure, set its type, and return nonzero. Otherwise return
3726 GCC shouldn't do this; it should just output pointer to member DIEs.
3727 This is GCC PR debug/28767. */
3730 quirk_gcc_member_function_pointer (struct die_info
*die
, struct dwarf2_cu
*cu
)
3732 struct objfile
*objfile
= cu
->objfile
;
3734 struct die_info
*pfn_die
, *delta_die
;
3735 struct attribute
*pfn_name
, *delta_name
;
3736 struct type
*pfn_type
, *domain_type
;
3738 /* Check for a structure with no name and two children. */
3739 if (die
->tag
!= DW_TAG_structure_type
3740 || dwarf2_attr (die
, DW_AT_name
, cu
) != NULL
3741 || die
->child
== NULL
3742 || die
->child
->sibling
== NULL
3743 || (die
->child
->sibling
->sibling
!= NULL
3744 && die
->child
->sibling
->sibling
->tag
!= DW_TAG_padding
))
3747 /* Check for __pfn and __delta members. */
3748 pfn_die
= die
->child
;
3749 pfn_name
= dwarf2_attr (pfn_die
, DW_AT_name
, cu
);
3750 if (pfn_die
->tag
!= DW_TAG_member
3752 || DW_STRING (pfn_name
) == NULL
3753 || strcmp ("__pfn", DW_STRING (pfn_name
)) != 0)
3756 delta_die
= pfn_die
->sibling
;
3757 delta_name
= dwarf2_attr (delta_die
, DW_AT_name
, cu
);
3758 if (delta_die
->tag
!= DW_TAG_member
3759 || delta_name
== NULL
3760 || DW_STRING (delta_name
) == NULL
3761 || strcmp ("__delta", DW_STRING (delta_name
)) != 0)
3764 /* Find the type of the method. */
3765 pfn_type
= die_type (pfn_die
, cu
);
3766 if (pfn_type
== NULL
3767 || TYPE_CODE (pfn_type
) != TYPE_CODE_PTR
3768 || TYPE_CODE (TYPE_TARGET_TYPE (pfn_type
)) != TYPE_CODE_FUNC
)
3771 /* Look for the "this" argument. */
3772 pfn_type
= TYPE_TARGET_TYPE (pfn_type
);
3773 if (TYPE_NFIELDS (pfn_type
) == 0
3774 || TYPE_CODE (TYPE_FIELD_TYPE (pfn_type
, 0)) != TYPE_CODE_PTR
)
3777 domain_type
= TYPE_TARGET_TYPE (TYPE_FIELD_TYPE (pfn_type
, 0));
3778 type
= alloc_type (objfile
);
3779 smash_to_method_type (type
, domain_type
, TYPE_TARGET_TYPE (pfn_type
),
3780 TYPE_FIELDS (pfn_type
), TYPE_NFIELDS (pfn_type
),
3781 TYPE_VARARGS (pfn_type
));
3782 type
= lookup_pointer_type (type
);
3783 set_die_type (die
, type
, cu
);
3788 /* Called when we find the DIE that starts a structure or union scope
3789 (definition) to process all dies that define the members of the
3792 NOTE: we need to call struct_type regardless of whether or not the
3793 DIE has an at_name attribute, since it might be an anonymous
3794 structure or union. This gets the type entered into our set of
3797 However, if the structure is incomplete (an opaque struct/union)
3798 then suppress creating a symbol table entry for it since gdb only
3799 wants to find the one with the complete definition. Note that if
3800 it is complete, we just call new_symbol, which does it's own
3801 checking about whether the struct/union is anonymous or not (and
3802 suppresses creating a symbol table entry itself). */
3805 read_structure_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
3807 struct objfile
*objfile
= cu
->objfile
;
3809 struct attribute
*attr
;
3810 const char *previous_prefix
= processing_current_prefix
;
3811 struct cleanup
*back_to
= NULL
;
3816 if (quirk_gcc_member_function_pointer (die
, cu
))
3819 type
= alloc_type (objfile
);
3820 INIT_CPLUS_SPECIFIC (type
);
3821 attr
= dwarf2_attr (die
, DW_AT_name
, cu
);
3822 if (attr
&& DW_STRING (attr
))
3824 if (cu
->language
== language_cplus
3825 || cu
->language
== language_java
)
3827 char *new_prefix
= determine_class_name (die
, cu
);
3828 TYPE_TAG_NAME (type
) = obsavestring (new_prefix
,
3829 strlen (new_prefix
),
3830 &objfile
->objfile_obstack
);
3831 back_to
= make_cleanup (xfree
, new_prefix
);
3832 processing_current_prefix
= new_prefix
;
3836 /* The name is already allocated along with this objfile, so
3837 we don't need to duplicate it for the type. */
3838 TYPE_TAG_NAME (type
) = DW_STRING (attr
);
3842 if (die
->tag
== DW_TAG_structure_type
)
3844 TYPE_CODE (type
) = TYPE_CODE_STRUCT
;
3846 else if (die
->tag
== DW_TAG_union_type
)
3848 TYPE_CODE (type
) = TYPE_CODE_UNION
;
3852 /* FIXME: TYPE_CODE_CLASS is currently defined to TYPE_CODE_STRUCT
3854 TYPE_CODE (type
) = TYPE_CODE_CLASS
;
3857 attr
= dwarf2_attr (die
, DW_AT_byte_size
, cu
);
3860 TYPE_LENGTH (type
) = DW_UNSND (attr
);
3864 TYPE_LENGTH (type
) = 0;
3867 if (die_is_declaration (die
, cu
))
3868 TYPE_FLAGS (type
) |= TYPE_FLAG_STUB
;
3870 /* We need to add the type field to the die immediately so we don't
3871 infinitely recurse when dealing with pointers to the structure
3872 type within the structure itself. */
3873 set_die_type (die
, type
, cu
);
3875 if (die
->child
!= NULL
&& ! die_is_declaration (die
, cu
))
3877 struct field_info fi
;
3878 struct die_info
*child_die
;
3879 struct cleanup
*back_to
= make_cleanup (null_cleanup
, NULL
);
3881 memset (&fi
, 0, sizeof (struct field_info
));
3883 child_die
= die
->child
;
3885 while (child_die
&& child_die
->tag
)
3887 if (child_die
->tag
== DW_TAG_member
3888 || child_die
->tag
== DW_TAG_variable
)
3890 /* NOTE: carlton/2002-11-05: A C++ static data member
3891 should be a DW_TAG_member that is a declaration, but
3892 all versions of G++ as of this writing (so through at
3893 least 3.2.1) incorrectly generate DW_TAG_variable
3894 tags for them instead. */
3895 dwarf2_add_field (&fi
, child_die
, cu
);
3897 else if (child_die
->tag
== DW_TAG_subprogram
)
3899 /* C++ member function. */
3900 read_type_die (child_die
, cu
);
3901 dwarf2_add_member_fn (&fi
, child_die
, type
, cu
);
3903 else if (child_die
->tag
== DW_TAG_inheritance
)
3905 /* C++ base class field. */
3906 dwarf2_add_field (&fi
, child_die
, cu
);
3908 child_die
= sibling_die (child_die
);
3911 /* Attach fields and member functions to the type. */
3913 dwarf2_attach_fields_to_type (&fi
, type
, cu
);
3916 dwarf2_attach_fn_fields_to_type (&fi
, type
, cu
);
3918 /* Get the type which refers to the base class (possibly this
3919 class itself) which contains the vtable pointer for the current
3920 class from the DW_AT_containing_type attribute. */
3922 if (dwarf2_attr (die
, DW_AT_containing_type
, cu
) != NULL
)
3924 struct type
*t
= die_containing_type (die
, cu
);
3926 TYPE_VPTR_BASETYPE (type
) = t
;
3931 /* Our own class provides vtbl ptr. */
3932 for (i
= TYPE_NFIELDS (t
) - 1;
3933 i
>= TYPE_N_BASECLASSES (t
);
3936 char *fieldname
= TYPE_FIELD_NAME (t
, i
);
3938 if (is_vtable_name (fieldname
, cu
))
3940 TYPE_VPTR_FIELDNO (type
) = i
;
3945 /* Complain if virtual function table field not found. */
3946 if (i
< TYPE_N_BASECLASSES (t
))
3947 complaint (&symfile_complaints
,
3948 _("virtual function table pointer not found when defining class '%s'"),
3949 TYPE_TAG_NAME (type
) ? TYPE_TAG_NAME (type
) :
3954 TYPE_VPTR_FIELDNO (type
) = TYPE_VPTR_FIELDNO (t
);
3957 else if (cu
->producer
3958 && strncmp (cu
->producer
,
3959 "IBM(R) XL C/C++ Advanced Edition", 32) == 0)
3961 /* The IBM XLC compiler does not provide direct indication
3962 of the containing type, but the vtable pointer is
3963 always named __vfp. */
3967 for (i
= TYPE_NFIELDS (type
) - 1;
3968 i
>= TYPE_N_BASECLASSES (type
);
3971 if (strcmp (TYPE_FIELD_NAME (type
, i
), "__vfp") == 0)
3973 TYPE_VPTR_FIELDNO (type
) = i
;
3974 TYPE_VPTR_BASETYPE (type
) = type
;
3981 do_cleanups (back_to
);
3984 processing_current_prefix
= previous_prefix
;
3985 if (back_to
!= NULL
)
3986 do_cleanups (back_to
);
3990 process_structure_scope (struct die_info
*die
, struct dwarf2_cu
*cu
)
3992 struct objfile
*objfile
= cu
->objfile
;
3993 const char *previous_prefix
= processing_current_prefix
;
3994 struct die_info
*child_die
= die
->child
;
3996 if (TYPE_TAG_NAME (die
->type
) != NULL
)
3997 processing_current_prefix
= TYPE_TAG_NAME (die
->type
);
3999 /* NOTE: carlton/2004-03-16: GCC 3.4 (or at least one of its
4000 snapshots) has been known to create a die giving a declaration
4001 for a class that has, as a child, a die giving a definition for a
4002 nested class. So we have to process our children even if the
4003 current die is a declaration. Normally, of course, a declaration
4004 won't have any children at all. */
4006 while (child_die
!= NULL
&& child_die
->tag
)
4008 if (child_die
->tag
== DW_TAG_member
4009 || child_die
->tag
== DW_TAG_variable
4010 || child_die
->tag
== DW_TAG_inheritance
)
4015 process_die (child_die
, cu
);
4017 child_die
= sibling_die (child_die
);
4020 if (die
->child
!= NULL
&& ! die_is_declaration (die
, cu
))
4021 new_symbol (die
, die
->type
, cu
);
4023 processing_current_prefix
= previous_prefix
;
4026 /* Given a DW_AT_enumeration_type die, set its type. We do not
4027 complete the type's fields yet, or create any symbols. */
4030 read_enumeration_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
4032 struct objfile
*objfile
= cu
->objfile
;
4034 struct attribute
*attr
;
4039 type
= alloc_type (objfile
);
4041 TYPE_CODE (type
) = TYPE_CODE_ENUM
;
4042 attr
= dwarf2_attr (die
, DW_AT_name
, cu
);
4043 if (attr
&& DW_STRING (attr
))
4045 char *name
= DW_STRING (attr
);
4047 if (processing_has_namespace_info
)
4049 TYPE_TAG_NAME (type
) = typename_concat (&objfile
->objfile_obstack
,
4050 processing_current_prefix
,
4055 /* The name is already allocated along with this objfile, so
4056 we don't need to duplicate it for the type. */
4057 TYPE_TAG_NAME (type
) = name
;
4061 attr
= dwarf2_attr (die
, DW_AT_byte_size
, cu
);
4064 TYPE_LENGTH (type
) = DW_UNSND (attr
);
4068 TYPE_LENGTH (type
) = 0;
4071 set_die_type (die
, type
, cu
);
4074 /* Determine the name of the type represented by DIE, which should be
4075 a named C++ or Java compound type. Return the name in question; the caller
4076 is responsible for xfree()'ing it. */
4079 determine_class_name (struct die_info
*die
, struct dwarf2_cu
*cu
)
4081 struct cleanup
*back_to
= NULL
;
4082 struct die_info
*spec_die
= die_specification (die
, cu
);
4083 char *new_prefix
= NULL
;
4085 /* If this is the definition of a class that is declared by another
4086 die, then processing_current_prefix may not be accurate; see
4087 read_func_scope for a similar example. */
4088 if (spec_die
!= NULL
)
4090 char *specification_prefix
= determine_prefix (spec_die
, cu
);
4091 processing_current_prefix
= specification_prefix
;
4092 back_to
= make_cleanup (xfree
, specification_prefix
);
4095 /* If we don't have namespace debug info, guess the name by trying
4096 to demangle the names of members, just like we did in
4097 guess_structure_name. */
4098 if (!processing_has_namespace_info
)
4100 struct die_info
*child
;
4102 for (child
= die
->child
;
4103 child
!= NULL
&& child
->tag
!= 0;
4104 child
= sibling_die (child
))
4106 if (child
->tag
== DW_TAG_subprogram
)
4109 = language_class_name_from_physname (cu
->language_defn
,
4113 if (new_prefix
!= NULL
)
4119 if (new_prefix
== NULL
)
4121 const char *name
= dwarf2_name (die
, cu
);
4122 new_prefix
= typename_concat (NULL
, processing_current_prefix
,
4123 name
? name
: "<<anonymous>>",
4127 if (back_to
!= NULL
)
4128 do_cleanups (back_to
);
4133 /* Given a pointer to a die which begins an enumeration, process all
4134 the dies that define the members of the enumeration, and create the
4135 symbol for the enumeration type.
4137 NOTE: We reverse the order of the element list. */
4140 process_enumeration_scope (struct die_info
*die
, struct dwarf2_cu
*cu
)
4142 struct objfile
*objfile
= cu
->objfile
;
4143 struct die_info
*child_die
;
4144 struct field
*fields
;
4145 struct attribute
*attr
;
4148 int unsigned_enum
= 1;
4152 if (die
->child
!= NULL
)
4154 child_die
= die
->child
;
4155 while (child_die
&& child_die
->tag
)
4157 if (child_die
->tag
!= DW_TAG_enumerator
)
4159 process_die (child_die
, cu
);
4163 attr
= dwarf2_attr (child_die
, DW_AT_name
, cu
);
4166 sym
= new_symbol (child_die
, die
->type
, cu
);
4167 if (SYMBOL_VALUE (sym
) < 0)
4170 if ((num_fields
% DW_FIELD_ALLOC_CHUNK
) == 0)
4172 fields
= (struct field
*)
4174 (num_fields
+ DW_FIELD_ALLOC_CHUNK
)
4175 * sizeof (struct field
));
4178 FIELD_NAME (fields
[num_fields
]) = DEPRECATED_SYMBOL_NAME (sym
);
4179 FIELD_TYPE (fields
[num_fields
]) = NULL
;
4180 FIELD_BITPOS (fields
[num_fields
]) = SYMBOL_VALUE (sym
);
4181 FIELD_BITSIZE (fields
[num_fields
]) = 0;
4182 FIELD_STATIC_KIND (fields
[num_fields
]) = 0;
4188 child_die
= sibling_die (child_die
);
4193 TYPE_NFIELDS (die
->type
) = num_fields
;
4194 TYPE_FIELDS (die
->type
) = (struct field
*)
4195 TYPE_ALLOC (die
->type
, sizeof (struct field
) * num_fields
);
4196 memcpy (TYPE_FIELDS (die
->type
), fields
,
4197 sizeof (struct field
) * num_fields
);
4201 TYPE_FLAGS (die
->type
) |= TYPE_FLAG_UNSIGNED
;
4204 new_symbol (die
, die
->type
, cu
);
4207 /* Extract all information from a DW_TAG_array_type DIE and put it in
4208 the DIE's type field. For now, this only handles one dimensional
4212 read_array_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
4214 struct objfile
*objfile
= cu
->objfile
;
4215 struct die_info
*child_die
;
4216 struct type
*type
= NULL
;
4217 struct type
*element_type
, *range_type
, *index_type
;
4218 struct type
**range_types
= NULL
;
4219 struct attribute
*attr
;
4221 struct cleanup
*back_to
;
4223 /* Return if we've already decoded this type. */
4229 element_type
= die_type (die
, cu
);
4231 /* Irix 6.2 native cc creates array types without children for
4232 arrays with unspecified length. */
4233 if (die
->child
== NULL
)
4235 index_type
= dwarf2_fundamental_type (objfile
, FT_INTEGER
, cu
);
4236 range_type
= create_range_type (NULL
, index_type
, 0, -1);
4237 set_die_type (die
, create_array_type (NULL
, element_type
, range_type
),
4242 back_to
= make_cleanup (null_cleanup
, NULL
);
4243 child_die
= die
->child
;
4244 while (child_die
&& child_die
->tag
)
4246 if (child_die
->tag
== DW_TAG_subrange_type
)
4248 read_subrange_type (child_die
, cu
);
4250 if (child_die
->type
!= NULL
)
4252 /* The range type was succesfully read. Save it for
4253 the array type creation. */
4254 if ((ndim
% DW_FIELD_ALLOC_CHUNK
) == 0)
4256 range_types
= (struct type
**)
4257 xrealloc (range_types
, (ndim
+ DW_FIELD_ALLOC_CHUNK
)
4258 * sizeof (struct type
*));
4260 make_cleanup (free_current_contents
, &range_types
);
4262 range_types
[ndim
++] = child_die
->type
;
4265 child_die
= sibling_die (child_die
);
4268 /* Dwarf2 dimensions are output from left to right, create the
4269 necessary array types in backwards order. */
4271 type
= element_type
;
4273 if (read_array_order (die
, cu
) == DW_ORD_col_major
)
4277 type
= create_array_type (NULL
, type
, range_types
[i
++]);
4282 type
= create_array_type (NULL
, type
, range_types
[ndim
]);
4285 /* Understand Dwarf2 support for vector types (like they occur on
4286 the PowerPC w/ AltiVec). Gcc just adds another attribute to the
4287 array type. This is not part of the Dwarf2/3 standard yet, but a
4288 custom vendor extension. The main difference between a regular
4289 array and the vector variant is that vectors are passed by value
4291 attr
= dwarf2_attr (die
, DW_AT_GNU_vector
, cu
);
4293 TYPE_FLAGS (type
) |= TYPE_FLAG_VECTOR
;
4295 attr
= dwarf2_attr (die
, DW_AT_name
, cu
);
4296 if (attr
&& DW_STRING (attr
))
4297 TYPE_NAME (type
) = DW_STRING (attr
);
4299 do_cleanups (back_to
);
4301 /* Install the type in the die. */
4302 set_die_type (die
, type
, cu
);
4305 static enum dwarf_array_dim_ordering
4306 read_array_order (struct die_info
*die
, struct dwarf2_cu
*cu
)
4308 struct attribute
*attr
;
4310 attr
= dwarf2_attr (die
, DW_AT_ordering
, cu
);
4312 if (attr
) return DW_SND (attr
);
4315 GNU F77 is a special case, as at 08/2004 array type info is the
4316 opposite order to the dwarf2 specification, but data is still
4317 laid out as per normal fortran.
4319 FIXME: dsl/2004-8-20: If G77 is ever fixed, this will also need
4323 if (cu
->language
== language_fortran
&&
4324 cu
->producer
&& strstr (cu
->producer
, "GNU F77"))
4326 return DW_ORD_row_major
;
4329 switch (cu
->language_defn
->la_array_ordering
)
4331 case array_column_major
:
4332 return DW_ORD_col_major
;
4333 case array_row_major
:
4335 return DW_ORD_row_major
;
4339 /* Extract all information from a DW_TAG_set_type DIE and put it in
4340 the DIE's type field. */
4343 read_set_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
4345 if (die
->type
== NULL
)
4346 die
->type
= create_set_type ((struct type
*) NULL
, die_type (die
, cu
));
4349 /* First cut: install each common block member as a global variable. */
4352 read_common_block (struct die_info
*die
, struct dwarf2_cu
*cu
)
4354 struct die_info
*child_die
;
4355 struct attribute
*attr
;
4357 CORE_ADDR base
= (CORE_ADDR
) 0;
4359 attr
= dwarf2_attr (die
, DW_AT_location
, cu
);
4362 /* Support the .debug_loc offsets */
4363 if (attr_form_is_block (attr
))
4365 base
= decode_locdesc (DW_BLOCK (attr
), cu
);
4367 else if (attr
->form
== DW_FORM_data4
|| attr
->form
== DW_FORM_data8
)
4369 dwarf2_complex_location_expr_complaint ();
4373 dwarf2_invalid_attrib_class_complaint ("DW_AT_location",
4374 "common block member");
4377 if (die
->child
!= NULL
)
4379 child_die
= die
->child
;
4380 while (child_die
&& child_die
->tag
)
4382 sym
= new_symbol (child_die
, NULL
, cu
);
4383 attr
= dwarf2_attr (child_die
, DW_AT_data_member_location
, cu
);
4386 SYMBOL_VALUE_ADDRESS (sym
) =
4387 base
+ decode_locdesc (DW_BLOCK (attr
), cu
);
4388 add_symbol_to_list (sym
, &global_symbols
);
4390 child_die
= sibling_die (child_die
);
4395 /* Read a C++ namespace. */
4398 read_namespace (struct die_info
*die
, struct dwarf2_cu
*cu
)
4400 struct objfile
*objfile
= cu
->objfile
;
4401 const char *previous_prefix
= processing_current_prefix
;
4404 struct die_info
*current_die
;
4405 struct cleanup
*back_to
= make_cleanup (null_cleanup
, 0);
4407 name
= namespace_name (die
, &is_anonymous
, cu
);
4409 /* Now build the name of the current namespace. */
4411 if (previous_prefix
[0] == '\0')
4413 processing_current_prefix
= name
;
4417 char *temp_name
= typename_concat (NULL
, previous_prefix
, name
, cu
);
4418 make_cleanup (xfree
, temp_name
);
4419 processing_current_prefix
= temp_name
;
4422 /* Add a symbol associated to this if we haven't seen the namespace
4423 before. Also, add a using directive if it's an anonymous
4426 if (dwarf2_extension (die
, cu
) == NULL
)
4430 /* FIXME: carlton/2003-06-27: Once GDB is more const-correct,
4431 this cast will hopefully become unnecessary. */
4432 type
= init_type (TYPE_CODE_NAMESPACE
, 0, 0,
4433 (char *) processing_current_prefix
,
4435 TYPE_TAG_NAME (type
) = TYPE_NAME (type
);
4437 new_symbol (die
, type
, cu
);
4438 set_die_type (die
, type
, cu
);
4441 cp_add_using_directive (processing_current_prefix
,
4442 strlen (previous_prefix
),
4443 strlen (processing_current_prefix
));
4446 if (die
->child
!= NULL
)
4448 struct die_info
*child_die
= die
->child
;
4450 while (child_die
&& child_die
->tag
)
4452 process_die (child_die
, cu
);
4453 child_die
= sibling_die (child_die
);
4457 processing_current_prefix
= previous_prefix
;
4458 do_cleanups (back_to
);
4461 /* Return the name of the namespace represented by DIE. Set
4462 *IS_ANONYMOUS to tell whether or not the namespace is an anonymous
4466 namespace_name (struct die_info
*die
, int *is_anonymous
, struct dwarf2_cu
*cu
)
4468 struct die_info
*current_die
;
4469 const char *name
= NULL
;
4471 /* Loop through the extensions until we find a name. */
4473 for (current_die
= die
;
4474 current_die
!= NULL
;
4475 current_die
= dwarf2_extension (die
, cu
))
4477 name
= dwarf2_name (current_die
, cu
);
4482 /* Is it an anonymous namespace? */
4484 *is_anonymous
= (name
== NULL
);
4486 name
= "(anonymous namespace)";
4491 /* Extract all information from a DW_TAG_pointer_type DIE and add to
4492 the user defined type vector. */
4495 read_tag_pointer_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
4497 struct comp_unit_head
*cu_header
= &cu
->header
;
4499 struct attribute
*attr_byte_size
;
4500 struct attribute
*attr_address_class
;
4501 int byte_size
, addr_class
;
4508 type
= lookup_pointer_type (die_type (die
, cu
));
4510 attr_byte_size
= dwarf2_attr (die
, DW_AT_byte_size
, cu
);
4512 byte_size
= DW_UNSND (attr_byte_size
);
4514 byte_size
= cu_header
->addr_size
;
4516 attr_address_class
= dwarf2_attr (die
, DW_AT_address_class
, cu
);
4517 if (attr_address_class
)
4518 addr_class
= DW_UNSND (attr_address_class
);
4520 addr_class
= DW_ADDR_none
;
4522 /* If the pointer size or address class is different than the
4523 default, create a type variant marked as such and set the
4524 length accordingly. */
4525 if (TYPE_LENGTH (type
) != byte_size
|| addr_class
!= DW_ADDR_none
)
4527 if (ADDRESS_CLASS_TYPE_FLAGS_P ())
4531 type_flags
= ADDRESS_CLASS_TYPE_FLAGS (byte_size
, addr_class
);
4532 gdb_assert ((type_flags
& ~TYPE_FLAG_ADDRESS_CLASS_ALL
) == 0);
4533 type
= make_type_with_address_space (type
, type_flags
);
4535 else if (TYPE_LENGTH (type
) != byte_size
)
4537 complaint (&symfile_complaints
, _("invalid pointer size %d"), byte_size
);
4540 /* Should we also complain about unhandled address classes? */
4544 TYPE_LENGTH (type
) = byte_size
;
4545 set_die_type (die
, type
, cu
);
4548 /* Extract all information from a DW_TAG_ptr_to_member_type DIE and add to
4549 the user defined type vector. */
4552 read_tag_ptr_to_member_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
4554 struct objfile
*objfile
= cu
->objfile
;
4556 struct type
*to_type
;
4557 struct type
*domain
;
4564 type
= alloc_type (objfile
);
4565 to_type
= die_type (die
, cu
);
4566 domain
= die_containing_type (die
, cu
);
4567 smash_to_member_type (type
, domain
, to_type
);
4569 set_die_type (die
, type
, cu
);
4572 /* Extract all information from a DW_TAG_reference_type DIE and add to
4573 the user defined type vector. */
4576 read_tag_reference_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
4578 struct comp_unit_head
*cu_header
= &cu
->header
;
4580 struct attribute
*attr
;
4587 type
= lookup_reference_type (die_type (die
, cu
));
4588 attr
= dwarf2_attr (die
, DW_AT_byte_size
, cu
);
4591 TYPE_LENGTH (type
) = DW_UNSND (attr
);
4595 TYPE_LENGTH (type
) = cu_header
->addr_size
;
4597 set_die_type (die
, type
, cu
);
4601 read_tag_const_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
4603 struct type
*base_type
;
4610 base_type
= die_type (die
, cu
);
4611 set_die_type (die
, make_cv_type (1, TYPE_VOLATILE (base_type
), base_type
, 0),
4616 read_tag_volatile_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
4618 struct type
*base_type
;
4625 base_type
= die_type (die
, cu
);
4626 set_die_type (die
, make_cv_type (TYPE_CONST (base_type
), 1, base_type
, 0),
4630 /* Extract all information from a DW_TAG_string_type DIE and add to
4631 the user defined type vector. It isn't really a user defined type,
4632 but it behaves like one, with other DIE's using an AT_user_def_type
4633 attribute to reference it. */
4636 read_tag_string_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
4638 struct objfile
*objfile
= cu
->objfile
;
4639 struct type
*type
, *range_type
, *index_type
, *char_type
;
4640 struct attribute
*attr
;
4641 unsigned int length
;
4648 attr
= dwarf2_attr (die
, DW_AT_string_length
, cu
);
4651 length
= DW_UNSND (attr
);
4655 /* check for the DW_AT_byte_size attribute */
4656 attr
= dwarf2_attr (die
, DW_AT_byte_size
, cu
);
4659 length
= DW_UNSND (attr
);
4666 index_type
= dwarf2_fundamental_type (objfile
, FT_INTEGER
, cu
);
4667 range_type
= create_range_type (NULL
, index_type
, 1, length
);
4668 if (cu
->language
== language_fortran
)
4670 /* Need to create a unique string type for bounds
4672 type
= create_string_type (0, range_type
);
4676 char_type
= dwarf2_fundamental_type (objfile
, FT_CHAR
, cu
);
4677 type
= create_string_type (char_type
, range_type
);
4679 set_die_type (die
, type
, cu
);
4682 /* Handle DIES due to C code like:
4686 int (*funcp)(int a, long l);
4690 ('funcp' generates a DW_TAG_subroutine_type DIE)
4694 read_subroutine_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
4696 struct type
*type
; /* Type that this function returns */
4697 struct type
*ftype
; /* Function that returns above type */
4698 struct attribute
*attr
;
4700 /* Decode the type that this subroutine returns */
4705 type
= die_type (die
, cu
);
4706 ftype
= make_function_type (type
, (struct type
**) 0);
4708 /* All functions in C++ and Java have prototypes. */
4709 attr
= dwarf2_attr (die
, DW_AT_prototyped
, cu
);
4710 if ((attr
&& (DW_UNSND (attr
) != 0))
4711 || cu
->language
== language_cplus
4712 || cu
->language
== language_java
)
4713 TYPE_FLAGS (ftype
) |= TYPE_FLAG_PROTOTYPED
;
4715 if (die
->child
!= NULL
)
4717 struct die_info
*child_die
;
4721 /* Count the number of parameters.
4722 FIXME: GDB currently ignores vararg functions, but knows about
4723 vararg member functions. */
4724 child_die
= die
->child
;
4725 while (child_die
&& child_die
->tag
)
4727 if (child_die
->tag
== DW_TAG_formal_parameter
)
4729 else if (child_die
->tag
== DW_TAG_unspecified_parameters
)
4730 TYPE_FLAGS (ftype
) |= TYPE_FLAG_VARARGS
;
4731 child_die
= sibling_die (child_die
);
4734 /* Allocate storage for parameters and fill them in. */
4735 TYPE_NFIELDS (ftype
) = nparams
;
4736 TYPE_FIELDS (ftype
) = (struct field
*)
4737 TYPE_ZALLOC (ftype
, nparams
* sizeof (struct field
));
4739 child_die
= die
->child
;
4740 while (child_die
&& child_die
->tag
)
4742 if (child_die
->tag
== DW_TAG_formal_parameter
)
4744 /* Dwarf2 has no clean way to discern C++ static and non-static
4745 member functions. G++ helps GDB by marking the first
4746 parameter for non-static member functions (which is the
4747 this pointer) as artificial. We pass this information
4748 to dwarf2_add_member_fn via TYPE_FIELD_ARTIFICIAL. */
4749 attr
= dwarf2_attr (child_die
, DW_AT_artificial
, cu
);
4751 TYPE_FIELD_ARTIFICIAL (ftype
, iparams
) = DW_UNSND (attr
);
4753 TYPE_FIELD_ARTIFICIAL (ftype
, iparams
) = 0;
4754 TYPE_FIELD_TYPE (ftype
, iparams
) = die_type (child_die
, cu
);
4757 child_die
= sibling_die (child_die
);
4761 set_die_type (die
, ftype
, cu
);
4765 read_typedef (struct die_info
*die
, struct dwarf2_cu
*cu
)
4767 struct objfile
*objfile
= cu
->objfile
;
4768 struct attribute
*attr
;
4773 attr
= dwarf2_attr (die
, DW_AT_name
, cu
);
4774 if (attr
&& DW_STRING (attr
))
4776 name
= DW_STRING (attr
);
4778 set_die_type (die
, init_type (TYPE_CODE_TYPEDEF
, 0,
4779 TYPE_FLAG_TARGET_STUB
, name
, objfile
),
4781 TYPE_TARGET_TYPE (die
->type
) = die_type (die
, cu
);
4785 /* Find a representation of a given base type and install
4786 it in the TYPE field of the die. */
4789 read_base_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
4791 struct objfile
*objfile
= cu
->objfile
;
4793 struct attribute
*attr
;
4794 int encoding
= 0, size
= 0;
4796 /* If we've already decoded this die, this is a no-op. */
4802 attr
= dwarf2_attr (die
, DW_AT_encoding
, cu
);
4805 encoding
= DW_UNSND (attr
);
4807 attr
= dwarf2_attr (die
, DW_AT_byte_size
, cu
);
4810 size
= DW_UNSND (attr
);
4812 attr
= dwarf2_attr (die
, DW_AT_name
, cu
);
4813 if (attr
&& DW_STRING (attr
))
4815 enum type_code code
= TYPE_CODE_INT
;
4820 case DW_ATE_address
:
4821 /* Turn DW_ATE_address into a void * pointer. */
4822 code
= TYPE_CODE_PTR
;
4823 type_flags
|= TYPE_FLAG_UNSIGNED
;
4825 case DW_ATE_boolean
:
4826 code
= TYPE_CODE_BOOL
;
4827 type_flags
|= TYPE_FLAG_UNSIGNED
;
4829 case DW_ATE_complex_float
:
4830 code
= TYPE_CODE_COMPLEX
;
4833 code
= TYPE_CODE_FLT
;
4837 case DW_ATE_unsigned
:
4838 type_flags
|= TYPE_FLAG_UNSIGNED
;
4840 case DW_ATE_signed_char
:
4841 if (cu
->language
== language_m2
)
4842 code
= TYPE_CODE_CHAR
;
4844 case DW_ATE_unsigned_char
:
4845 if (cu
->language
== language_m2
)
4846 code
= TYPE_CODE_CHAR
;
4847 type_flags
|= TYPE_FLAG_UNSIGNED
;
4850 complaint (&symfile_complaints
, _("unsupported DW_AT_encoding: '%s'"),
4851 dwarf_type_encoding_name (encoding
));
4854 type
= init_type (code
, size
, type_flags
, DW_STRING (attr
), objfile
);
4855 if (encoding
== DW_ATE_address
)
4856 TYPE_TARGET_TYPE (type
) = dwarf2_fundamental_type (objfile
, FT_VOID
,
4858 else if (encoding
== DW_ATE_complex_float
)
4861 TYPE_TARGET_TYPE (type
)
4862 = dwarf2_fundamental_type (objfile
, FT_EXT_PREC_FLOAT
, cu
);
4863 else if (size
== 16)
4864 TYPE_TARGET_TYPE (type
)
4865 = dwarf2_fundamental_type (objfile
, FT_DBL_PREC_FLOAT
, cu
);
4867 TYPE_TARGET_TYPE (type
)
4868 = dwarf2_fundamental_type (objfile
, FT_FLOAT
, cu
);
4873 type
= dwarf_base_type (encoding
, size
, cu
);
4875 set_die_type (die
, type
, cu
);
4878 /* Read the given DW_AT_subrange DIE. */
4881 read_subrange_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
4883 struct type
*base_type
;
4884 struct type
*range_type
;
4885 struct attribute
*attr
;
4889 /* If we have already decoded this die, then nothing more to do. */
4893 base_type
= die_type (die
, cu
);
4894 if (base_type
== NULL
)
4896 complaint (&symfile_complaints
,
4897 _("DW_AT_type missing from DW_TAG_subrange_type"));
4901 if (TYPE_CODE (base_type
) == TYPE_CODE_VOID
)
4902 base_type
= alloc_type (NULL
);
4904 if (cu
->language
== language_fortran
)
4906 /* FORTRAN implies a lower bound of 1, if not given. */
4910 /* FIXME: For variable sized arrays either of these could be
4911 a variable rather than a constant value. We'll allow it,
4912 but we don't know how to handle it. */
4913 attr
= dwarf2_attr (die
, DW_AT_lower_bound
, cu
);
4915 low
= dwarf2_get_attr_constant_value (attr
, 0);
4917 attr
= dwarf2_attr (die
, DW_AT_upper_bound
, cu
);
4920 if (attr
->form
== DW_FORM_block1
)
4922 /* GCC encodes arrays with unspecified or dynamic length
4923 with a DW_FORM_block1 attribute.
4924 FIXME: GDB does not yet know how to handle dynamic
4925 arrays properly, treat them as arrays with unspecified
4928 FIXME: jimb/2003-09-22: GDB does not really know
4929 how to handle arrays of unspecified length
4930 either; we just represent them as zero-length
4931 arrays. Choose an appropriate upper bound given
4932 the lower bound we've computed above. */
4936 high
= dwarf2_get_attr_constant_value (attr
, 1);
4939 range_type
= create_range_type (NULL
, base_type
, low
, high
);
4941 attr
= dwarf2_attr (die
, DW_AT_name
, cu
);
4942 if (attr
&& DW_STRING (attr
))
4943 TYPE_NAME (range_type
) = DW_STRING (attr
);
4945 attr
= dwarf2_attr (die
, DW_AT_byte_size
, cu
);
4947 TYPE_LENGTH (range_type
) = DW_UNSND (attr
);
4949 set_die_type (die
, range_type
, cu
);
4953 read_unspecified_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
4956 struct attribute
*attr
;
4961 /* For now, we only support the C meaning of an unspecified type: void. */
4963 attr
= dwarf2_attr (die
, DW_AT_name
, cu
);
4964 type
= init_type (TYPE_CODE_VOID
, 0, 0, attr
? DW_STRING (attr
) : "",
4967 set_die_type (die
, type
, cu
);
4970 /* Read a whole compilation unit into a linked list of dies. */
4972 static struct die_info
*
4973 read_comp_unit (gdb_byte
*info_ptr
, bfd
*abfd
, struct dwarf2_cu
*cu
)
4975 return read_die_and_children (info_ptr
, abfd
, cu
, &info_ptr
, NULL
);
4978 /* Read a single die and all its descendents. Set the die's sibling
4979 field to NULL; set other fields in the die correctly, and set all
4980 of the descendents' fields correctly. Set *NEW_INFO_PTR to the
4981 location of the info_ptr after reading all of those dies. PARENT
4982 is the parent of the die in question. */
4984 static struct die_info
*
4985 read_die_and_children (gdb_byte
*info_ptr
, bfd
*abfd
,
4986 struct dwarf2_cu
*cu
,
4987 gdb_byte
**new_info_ptr
,
4988 struct die_info
*parent
)
4990 struct die_info
*die
;
4994 cur_ptr
= read_full_die (&die
, abfd
, info_ptr
, cu
, &has_children
);
4995 store_in_ref_table (die
->offset
, die
, cu
);
4999 die
->child
= read_die_and_siblings (cur_ptr
, abfd
, cu
,
5005 *new_info_ptr
= cur_ptr
;
5008 die
->sibling
= NULL
;
5009 die
->parent
= parent
;
5013 /* Read a die, all of its descendents, and all of its siblings; set
5014 all of the fields of all of the dies correctly. Arguments are as
5015 in read_die_and_children. */
5017 static struct die_info
*
5018 read_die_and_siblings (gdb_byte
*info_ptr
, bfd
*abfd
,
5019 struct dwarf2_cu
*cu
,
5020 gdb_byte
**new_info_ptr
,
5021 struct die_info
*parent
)
5023 struct die_info
*first_die
, *last_sibling
;
5027 first_die
= last_sibling
= NULL
;
5031 struct die_info
*die
5032 = read_die_and_children (cur_ptr
, abfd
, cu
, &cur_ptr
, parent
);
5040 last_sibling
->sibling
= die
;
5045 *new_info_ptr
= cur_ptr
;
5055 /* Free a linked list of dies. */
5058 free_die_list (struct die_info
*dies
)
5060 struct die_info
*die
, *next
;
5065 if (die
->child
!= NULL
)
5066 free_die_list (die
->child
);
5067 next
= die
->sibling
;
5074 /* Read the contents of the section at OFFSET and of size SIZE from the
5075 object file specified by OBJFILE into the objfile_obstack and return it. */
5078 dwarf2_read_section (struct objfile
*objfile
, asection
*sectp
)
5080 bfd
*abfd
= objfile
->obfd
;
5081 gdb_byte
*buf
, *retbuf
;
5082 bfd_size_type size
= bfd_get_section_size (sectp
);
5087 buf
= obstack_alloc (&objfile
->objfile_obstack
, size
);
5088 retbuf
= symfile_relocate_debug_section (abfd
, sectp
, buf
);
5092 if (bfd_seek (abfd
, sectp
->filepos
, SEEK_SET
) != 0
5093 || bfd_bread (buf
, size
, abfd
) != size
)
5094 error (_("Dwarf Error: Can't read DWARF data from '%s'"),
5095 bfd_get_filename (abfd
));
5100 /* In DWARF version 2, the description of the debugging information is
5101 stored in a separate .debug_abbrev section. Before we read any
5102 dies from a section we read in all abbreviations and install them
5103 in a hash table. This function also sets flags in CU describing
5104 the data found in the abbrev table. */
5107 dwarf2_read_abbrevs (bfd
*abfd
, struct dwarf2_cu
*cu
)
5109 struct comp_unit_head
*cu_header
= &cu
->header
;
5110 gdb_byte
*abbrev_ptr
;
5111 struct abbrev_info
*cur_abbrev
;
5112 unsigned int abbrev_number
, bytes_read
, abbrev_name
;
5113 unsigned int abbrev_form
, hash_number
;
5114 struct attr_abbrev
*cur_attrs
;
5115 unsigned int allocated_attrs
;
5117 /* Initialize dwarf2 abbrevs */
5118 obstack_init (&cu
->abbrev_obstack
);
5119 cu
->dwarf2_abbrevs
= obstack_alloc (&cu
->abbrev_obstack
,
5121 * sizeof (struct abbrev_info
*)));
5122 memset (cu
->dwarf2_abbrevs
, 0,
5123 ABBREV_HASH_SIZE
* sizeof (struct abbrev_info
*));
5125 abbrev_ptr
= dwarf2_per_objfile
->abbrev_buffer
+ cu_header
->abbrev_offset
;
5126 abbrev_number
= read_unsigned_leb128 (abfd
, abbrev_ptr
, &bytes_read
);
5127 abbrev_ptr
+= bytes_read
;
5129 allocated_attrs
= ATTR_ALLOC_CHUNK
;
5130 cur_attrs
= xmalloc (allocated_attrs
* sizeof (struct attr_abbrev
));
5132 /* loop until we reach an abbrev number of 0 */
5133 while (abbrev_number
)
5135 cur_abbrev
= dwarf_alloc_abbrev (cu
);
5137 /* read in abbrev header */
5138 cur_abbrev
->number
= abbrev_number
;
5139 cur_abbrev
->tag
= read_unsigned_leb128 (abfd
, abbrev_ptr
, &bytes_read
);
5140 abbrev_ptr
+= bytes_read
;
5141 cur_abbrev
->has_children
= read_1_byte (abfd
, abbrev_ptr
);
5144 if (cur_abbrev
->tag
== DW_TAG_namespace
)
5145 cu
->has_namespace_info
= 1;
5147 /* now read in declarations */
5148 abbrev_name
= read_unsigned_leb128 (abfd
, abbrev_ptr
, &bytes_read
);
5149 abbrev_ptr
+= bytes_read
;
5150 abbrev_form
= read_unsigned_leb128 (abfd
, abbrev_ptr
, &bytes_read
);
5151 abbrev_ptr
+= bytes_read
;
5154 if (cur_abbrev
->num_attrs
== allocated_attrs
)
5156 allocated_attrs
+= ATTR_ALLOC_CHUNK
;
5158 = xrealloc (cur_attrs
, (allocated_attrs
5159 * sizeof (struct attr_abbrev
)));
5162 /* Record whether this compilation unit might have
5163 inter-compilation-unit references. If we don't know what form
5164 this attribute will have, then it might potentially be a
5165 DW_FORM_ref_addr, so we conservatively expect inter-CU
5168 if (abbrev_form
== DW_FORM_ref_addr
5169 || abbrev_form
== DW_FORM_indirect
)
5170 cu
->has_form_ref_addr
= 1;
5172 cur_attrs
[cur_abbrev
->num_attrs
].name
= abbrev_name
;
5173 cur_attrs
[cur_abbrev
->num_attrs
++].form
= abbrev_form
;
5174 abbrev_name
= read_unsigned_leb128 (abfd
, abbrev_ptr
, &bytes_read
);
5175 abbrev_ptr
+= bytes_read
;
5176 abbrev_form
= read_unsigned_leb128 (abfd
, abbrev_ptr
, &bytes_read
);
5177 abbrev_ptr
+= bytes_read
;
5180 cur_abbrev
->attrs
= obstack_alloc (&cu
->abbrev_obstack
,
5181 (cur_abbrev
->num_attrs
5182 * sizeof (struct attr_abbrev
)));
5183 memcpy (cur_abbrev
->attrs
, cur_attrs
,
5184 cur_abbrev
->num_attrs
* sizeof (struct attr_abbrev
));
5186 hash_number
= abbrev_number
% ABBREV_HASH_SIZE
;
5187 cur_abbrev
->next
= cu
->dwarf2_abbrevs
[hash_number
];
5188 cu
->dwarf2_abbrevs
[hash_number
] = cur_abbrev
;
5190 /* Get next abbreviation.
5191 Under Irix6 the abbreviations for a compilation unit are not
5192 always properly terminated with an abbrev number of 0.
5193 Exit loop if we encounter an abbreviation which we have
5194 already read (which means we are about to read the abbreviations
5195 for the next compile unit) or if the end of the abbreviation
5196 table is reached. */
5197 if ((unsigned int) (abbrev_ptr
- dwarf2_per_objfile
->abbrev_buffer
)
5198 >= dwarf2_per_objfile
->abbrev_size
)
5200 abbrev_number
= read_unsigned_leb128 (abfd
, abbrev_ptr
, &bytes_read
);
5201 abbrev_ptr
+= bytes_read
;
5202 if (dwarf2_lookup_abbrev (abbrev_number
, cu
) != NULL
)
5209 /* Release the memory used by the abbrev table for a compilation unit. */
5212 dwarf2_free_abbrev_table (void *ptr_to_cu
)
5214 struct dwarf2_cu
*cu
= ptr_to_cu
;
5216 obstack_free (&cu
->abbrev_obstack
, NULL
);
5217 cu
->dwarf2_abbrevs
= NULL
;
5220 /* Lookup an abbrev_info structure in the abbrev hash table. */
5222 static struct abbrev_info
*
5223 dwarf2_lookup_abbrev (unsigned int number
, struct dwarf2_cu
*cu
)
5225 unsigned int hash_number
;
5226 struct abbrev_info
*abbrev
;
5228 hash_number
= number
% ABBREV_HASH_SIZE
;
5229 abbrev
= cu
->dwarf2_abbrevs
[hash_number
];
5233 if (abbrev
->number
== number
)
5236 abbrev
= abbrev
->next
;
5241 /* Returns nonzero if TAG represents a type that we might generate a partial
5245 is_type_tag_for_partial (int tag
)
5250 /* Some types that would be reasonable to generate partial symbols for,
5251 that we don't at present. */
5252 case DW_TAG_array_type
:
5253 case DW_TAG_file_type
:
5254 case DW_TAG_ptr_to_member_type
:
5255 case DW_TAG_set_type
:
5256 case DW_TAG_string_type
:
5257 case DW_TAG_subroutine_type
:
5259 case DW_TAG_base_type
:
5260 case DW_TAG_class_type
:
5261 case DW_TAG_enumeration_type
:
5262 case DW_TAG_structure_type
:
5263 case DW_TAG_subrange_type
:
5264 case DW_TAG_typedef
:
5265 case DW_TAG_union_type
:
5272 /* Load all DIEs that are interesting for partial symbols into memory. */
5274 static struct partial_die_info
*
5275 load_partial_dies (bfd
*abfd
, gdb_byte
*info_ptr
, int building_psymtab
,
5276 struct dwarf2_cu
*cu
)
5278 struct partial_die_info
*part_die
;
5279 struct partial_die_info
*parent_die
, *last_die
, *first_die
= NULL
;
5280 struct abbrev_info
*abbrev
;
5281 unsigned int bytes_read
;
5282 unsigned int load_all
= 0;
5284 int nesting_level
= 1;
5289 if (cu
->per_cu
&& cu
->per_cu
->load_all_dies
)
5293 = htab_create_alloc_ex (cu
->header
.length
/ 12,
5297 &cu
->comp_unit_obstack
,
5298 hashtab_obstack_allocate
,
5299 dummy_obstack_deallocate
);
5301 part_die
= obstack_alloc (&cu
->comp_unit_obstack
,
5302 sizeof (struct partial_die_info
));
5306 abbrev
= peek_die_abbrev (info_ptr
, &bytes_read
, cu
);
5308 /* A NULL abbrev means the end of a series of children. */
5311 if (--nesting_level
== 0)
5313 /* PART_DIE was probably the last thing allocated on the
5314 comp_unit_obstack, so we could call obstack_free
5315 here. We don't do that because the waste is small,
5316 and will be cleaned up when we're done with this
5317 compilation unit. This way, we're also more robust
5318 against other users of the comp_unit_obstack. */
5321 info_ptr
+= bytes_read
;
5322 last_die
= parent_die
;
5323 parent_die
= parent_die
->die_parent
;
5327 /* Check whether this DIE is interesting enough to save. Normally
5328 we would not be interested in members here, but there may be
5329 later variables referencing them via DW_AT_specification (for
5332 && !is_type_tag_for_partial (abbrev
->tag
)
5333 && abbrev
->tag
!= DW_TAG_enumerator
5334 && abbrev
->tag
!= DW_TAG_subprogram
5335 && abbrev
->tag
!= DW_TAG_variable
5336 && abbrev
->tag
!= DW_TAG_namespace
5337 && abbrev
->tag
!= DW_TAG_member
)
5339 /* Otherwise we skip to the next sibling, if any. */
5340 info_ptr
= skip_one_die (info_ptr
+ bytes_read
, abbrev
, cu
);
5344 info_ptr
= read_partial_die (part_die
, abbrev
, bytes_read
,
5345 abfd
, info_ptr
, cu
);
5347 /* This two-pass algorithm for processing partial symbols has a
5348 high cost in cache pressure. Thus, handle some simple cases
5349 here which cover the majority of C partial symbols. DIEs
5350 which neither have specification tags in them, nor could have
5351 specification tags elsewhere pointing at them, can simply be
5352 processed and discarded.
5354 This segment is also optional; scan_partial_symbols and
5355 add_partial_symbol will handle these DIEs if we chain
5356 them in normally. When compilers which do not emit large
5357 quantities of duplicate debug information are more common,
5358 this code can probably be removed. */
5360 /* Any complete simple types at the top level (pretty much all
5361 of them, for a language without namespaces), can be processed
5363 if (parent_die
== NULL
5364 && part_die
->has_specification
== 0
5365 && part_die
->is_declaration
== 0
5366 && (part_die
->tag
== DW_TAG_typedef
5367 || part_die
->tag
== DW_TAG_base_type
5368 || part_die
->tag
== DW_TAG_subrange_type
))
5370 if (building_psymtab
&& part_die
->name
!= NULL
)
5371 add_psymbol_to_list (part_die
->name
, strlen (part_die
->name
),
5372 VAR_DOMAIN
, LOC_TYPEDEF
,
5373 &cu
->objfile
->static_psymbols
,
5374 0, (CORE_ADDR
) 0, cu
->language
, cu
->objfile
);
5375 info_ptr
= locate_pdi_sibling (part_die
, info_ptr
, abfd
, cu
);
5379 /* If we're at the second level, and we're an enumerator, and
5380 our parent has no specification (meaning possibly lives in a
5381 namespace elsewhere), then we can add the partial symbol now
5382 instead of queueing it. */
5383 if (part_die
->tag
== DW_TAG_enumerator
5384 && parent_die
!= NULL
5385 && parent_die
->die_parent
== NULL
5386 && parent_die
->tag
== DW_TAG_enumeration_type
5387 && parent_die
->has_specification
== 0)
5389 if (part_die
->name
== NULL
)
5390 complaint (&symfile_complaints
, _("malformed enumerator DIE ignored"));
5391 else if (building_psymtab
)
5392 add_psymbol_to_list (part_die
->name
, strlen (part_die
->name
),
5393 VAR_DOMAIN
, LOC_CONST
,
5394 (cu
->language
== language_cplus
5395 || cu
->language
== language_java
)
5396 ? &cu
->objfile
->global_psymbols
5397 : &cu
->objfile
->static_psymbols
,
5398 0, (CORE_ADDR
) 0, cu
->language
, cu
->objfile
);
5400 info_ptr
= locate_pdi_sibling (part_die
, info_ptr
, abfd
, cu
);
5404 /* We'll save this DIE so link it in. */
5405 part_die
->die_parent
= parent_die
;
5406 part_die
->die_sibling
= NULL
;
5407 part_die
->die_child
= NULL
;
5409 if (last_die
&& last_die
== parent_die
)
5410 last_die
->die_child
= part_die
;
5412 last_die
->die_sibling
= part_die
;
5414 last_die
= part_die
;
5416 if (first_die
== NULL
)
5417 first_die
= part_die
;
5419 /* Maybe add the DIE to the hash table. Not all DIEs that we
5420 find interesting need to be in the hash table, because we
5421 also have the parent/sibling/child chains; only those that we
5422 might refer to by offset later during partial symbol reading.
5424 For now this means things that might have be the target of a
5425 DW_AT_specification, DW_AT_abstract_origin, or
5426 DW_AT_extension. DW_AT_extension will refer only to
5427 namespaces; DW_AT_abstract_origin refers to functions (and
5428 many things under the function DIE, but we do not recurse
5429 into function DIEs during partial symbol reading) and
5430 possibly variables as well; DW_AT_specification refers to
5431 declarations. Declarations ought to have the DW_AT_declaration
5432 flag. It happens that GCC forgets to put it in sometimes, but
5433 only for functions, not for types.
5435 Adding more things than necessary to the hash table is harmless
5436 except for the performance cost. Adding too few will result in
5437 wasted time in find_partial_die, when we reread the compilation
5438 unit with load_all_dies set. */
5441 || abbrev
->tag
== DW_TAG_subprogram
5442 || abbrev
->tag
== DW_TAG_variable
5443 || abbrev
->tag
== DW_TAG_namespace
5444 || part_die
->is_declaration
)
5448 slot
= htab_find_slot_with_hash (cu
->partial_dies
, part_die
,
5449 part_die
->offset
, INSERT
);
5453 part_die
= obstack_alloc (&cu
->comp_unit_obstack
,
5454 sizeof (struct partial_die_info
));
5456 /* For some DIEs we want to follow their children (if any). For C
5457 we have no reason to follow the children of structures; for other
5458 languages we have to, both so that we can get at method physnames
5459 to infer fully qualified class names, and for DW_AT_specification. */
5460 if (last_die
->has_children
5462 || last_die
->tag
== DW_TAG_namespace
5463 || last_die
->tag
== DW_TAG_enumeration_type
5464 || (cu
->language
!= language_c
5465 && (last_die
->tag
== DW_TAG_class_type
5466 || last_die
->tag
== DW_TAG_structure_type
5467 || last_die
->tag
== DW_TAG_union_type
))))
5470 parent_die
= last_die
;
5474 /* Otherwise we skip to the next sibling, if any. */
5475 info_ptr
= locate_pdi_sibling (last_die
, info_ptr
, abfd
, cu
);
5477 /* Back to the top, do it again. */
5481 /* Read a minimal amount of information into the minimal die structure. */
5484 read_partial_die (struct partial_die_info
*part_die
,
5485 struct abbrev_info
*abbrev
,
5486 unsigned int abbrev_len
, bfd
*abfd
,
5487 gdb_byte
*info_ptr
, struct dwarf2_cu
*cu
)
5489 unsigned int bytes_read
, i
;
5490 struct attribute attr
;
5491 int has_low_pc_attr
= 0;
5492 int has_high_pc_attr
= 0;
5494 memset (part_die
, 0, sizeof (struct partial_die_info
));
5496 part_die
->offset
= info_ptr
- dwarf2_per_objfile
->info_buffer
;
5498 info_ptr
+= abbrev_len
;
5503 part_die
->tag
= abbrev
->tag
;
5504 part_die
->has_children
= abbrev
->has_children
;
5506 for (i
= 0; i
< abbrev
->num_attrs
; ++i
)
5508 info_ptr
= read_attribute (&attr
, &abbrev
->attrs
[i
], abfd
, info_ptr
, cu
);
5510 /* Store the data if it is of an attribute we want to keep in a
5511 partial symbol table. */
5516 /* Prefer DW_AT_MIPS_linkage_name over DW_AT_name. */
5517 if (part_die
->name
== NULL
)
5518 part_die
->name
= DW_STRING (&attr
);
5520 case DW_AT_comp_dir
:
5521 if (part_die
->dirname
== NULL
)
5522 part_die
->dirname
= DW_STRING (&attr
);
5524 case DW_AT_MIPS_linkage_name
:
5525 part_die
->name
= DW_STRING (&attr
);
5528 has_low_pc_attr
= 1;
5529 part_die
->lowpc
= DW_ADDR (&attr
);
5532 has_high_pc_attr
= 1;
5533 part_die
->highpc
= DW_ADDR (&attr
);
5535 case DW_AT_location
:
5536 /* Support the .debug_loc offsets */
5537 if (attr_form_is_block (&attr
))
5539 part_die
->locdesc
= DW_BLOCK (&attr
);
5541 else if (attr
.form
== DW_FORM_data4
|| attr
.form
== DW_FORM_data8
)
5543 dwarf2_complex_location_expr_complaint ();
5547 dwarf2_invalid_attrib_class_complaint ("DW_AT_location",
5548 "partial symbol information");
5551 case DW_AT_language
:
5552 part_die
->language
= DW_UNSND (&attr
);
5554 case DW_AT_external
:
5555 part_die
->is_external
= DW_UNSND (&attr
);
5557 case DW_AT_declaration
:
5558 part_die
->is_declaration
= DW_UNSND (&attr
);
5561 part_die
->has_type
= 1;
5563 case DW_AT_abstract_origin
:
5564 case DW_AT_specification
:
5565 case DW_AT_extension
:
5566 part_die
->has_specification
= 1;
5567 part_die
->spec_offset
= dwarf2_get_ref_die_offset (&attr
, cu
);
5570 /* Ignore absolute siblings, they might point outside of
5571 the current compile unit. */
5572 if (attr
.form
== DW_FORM_ref_addr
)
5573 complaint (&symfile_complaints
, _("ignoring absolute DW_AT_sibling"));
5575 part_die
->sibling
= dwarf2_per_objfile
->info_buffer
5576 + dwarf2_get_ref_die_offset (&attr
, cu
);
5578 case DW_AT_stmt_list
:
5579 part_die
->has_stmt_list
= 1;
5580 part_die
->line_offset
= DW_UNSND (&attr
);
5587 /* When using the GNU linker, .gnu.linkonce. sections are used to
5588 eliminate duplicate copies of functions and vtables and such.
5589 The linker will arbitrarily choose one and discard the others.
5590 The AT_*_pc values for such functions refer to local labels in
5591 these sections. If the section from that file was discarded, the
5592 labels are not in the output, so the relocs get a value of 0.
5593 If this is a discarded function, mark the pc bounds as invalid,
5594 so that GDB will ignore it. */
5595 if (has_low_pc_attr
&& has_high_pc_attr
5596 && part_die
->lowpc
< part_die
->highpc
5597 && (part_die
->lowpc
!= 0
5598 || dwarf2_per_objfile
->has_section_at_zero
))
5599 part_die
->has_pc_info
= 1;
5603 /* Find a cached partial DIE at OFFSET in CU. */
5605 static struct partial_die_info
*
5606 find_partial_die_in_comp_unit (unsigned long offset
, struct dwarf2_cu
*cu
)
5608 struct partial_die_info
*lookup_die
= NULL
;
5609 struct partial_die_info part_die
;
5611 part_die
.offset
= offset
;
5612 lookup_die
= htab_find_with_hash (cu
->partial_dies
, &part_die
, offset
);
5617 /* Find a partial DIE at OFFSET, which may or may not be in CU. */
5619 static struct partial_die_info
*
5620 find_partial_die (unsigned long offset
, struct dwarf2_cu
*cu
)
5622 struct dwarf2_per_cu_data
*per_cu
= NULL
;
5623 struct partial_die_info
*pd
= NULL
;
5625 if (offset
>= cu
->header
.offset
5626 && offset
< cu
->header
.offset
+ cu
->header
.length
)
5628 pd
= find_partial_die_in_comp_unit (offset
, cu
);
5633 per_cu
= dwarf2_find_containing_comp_unit (offset
, cu
->objfile
);
5635 if (per_cu
->cu
== NULL
)
5637 load_comp_unit (per_cu
, cu
->objfile
);
5638 per_cu
->cu
->read_in_chain
= dwarf2_per_objfile
->read_in_chain
;
5639 dwarf2_per_objfile
->read_in_chain
= per_cu
;
5642 per_cu
->cu
->last_used
= 0;
5643 pd
= find_partial_die_in_comp_unit (offset
, per_cu
->cu
);
5645 if (pd
== NULL
&& per_cu
->load_all_dies
== 0)
5647 struct cleanup
*back_to
;
5648 struct partial_die_info comp_unit_die
;
5649 struct abbrev_info
*abbrev
;
5650 unsigned int bytes_read
;
5653 per_cu
->load_all_dies
= 1;
5655 /* Re-read the DIEs. */
5656 back_to
= make_cleanup (null_cleanup
, 0);
5657 if (per_cu
->cu
->dwarf2_abbrevs
== NULL
)
5659 dwarf2_read_abbrevs (per_cu
->cu
->objfile
->obfd
, per_cu
->cu
);
5660 back_to
= make_cleanup (dwarf2_free_abbrev_table
, per_cu
->cu
);
5662 info_ptr
= per_cu
->cu
->header
.first_die_ptr
;
5663 abbrev
= peek_die_abbrev (info_ptr
, &bytes_read
, per_cu
->cu
);
5664 info_ptr
= read_partial_die (&comp_unit_die
, abbrev
, bytes_read
,
5665 per_cu
->cu
->objfile
->obfd
, info_ptr
,
5667 if (comp_unit_die
.has_children
)
5668 load_partial_dies (per_cu
->cu
->objfile
->obfd
, info_ptr
, 0, per_cu
->cu
);
5669 do_cleanups (back_to
);
5671 pd
= find_partial_die_in_comp_unit (offset
, per_cu
->cu
);
5675 internal_error (__FILE__
, __LINE__
,
5676 _("could not find partial DIE 0x%lx in cache [from module %s]\n"),
5677 offset
, bfd_get_filename (cu
->objfile
->obfd
));
5681 /* Adjust PART_DIE before generating a symbol for it. This function
5682 may set the is_external flag or change the DIE's name. */
5685 fixup_partial_die (struct partial_die_info
*part_die
,
5686 struct dwarf2_cu
*cu
)
5688 /* If we found a reference attribute and the DIE has no name, try
5689 to find a name in the referred to DIE. */
5691 if (part_die
->name
== NULL
&& part_die
->has_specification
)
5693 struct partial_die_info
*spec_die
;
5695 spec_die
= find_partial_die (part_die
->spec_offset
, cu
);
5697 fixup_partial_die (spec_die
, cu
);
5701 part_die
->name
= spec_die
->name
;
5703 /* Copy DW_AT_external attribute if it is set. */
5704 if (spec_die
->is_external
)
5705 part_die
->is_external
= spec_die
->is_external
;
5709 /* Set default names for some unnamed DIEs. */
5710 if (part_die
->name
== NULL
&& (part_die
->tag
== DW_TAG_structure_type
5711 || part_die
->tag
== DW_TAG_class_type
))
5712 part_die
->name
= "(anonymous class)";
5714 if (part_die
->name
== NULL
&& part_die
->tag
== DW_TAG_namespace
)
5715 part_die
->name
= "(anonymous namespace)";
5717 if (part_die
->tag
== DW_TAG_structure_type
5718 || part_die
->tag
== DW_TAG_class_type
5719 || part_die
->tag
== DW_TAG_union_type
)
5720 guess_structure_name (part_die
, cu
);
5723 /* Read the die from the .debug_info section buffer. Set DIEP to
5724 point to a newly allocated die with its information, except for its
5725 child, sibling, and parent fields. Set HAS_CHILDREN to tell
5726 whether the die has children or not. */
5729 read_full_die (struct die_info
**diep
, bfd
*abfd
, gdb_byte
*info_ptr
,
5730 struct dwarf2_cu
*cu
, int *has_children
)
5732 unsigned int abbrev_number
, bytes_read
, i
, offset
;
5733 struct abbrev_info
*abbrev
;
5734 struct die_info
*die
;
5736 offset
= info_ptr
- dwarf2_per_objfile
->info_buffer
;
5737 abbrev_number
= read_unsigned_leb128 (abfd
, info_ptr
, &bytes_read
);
5738 info_ptr
+= bytes_read
;
5741 die
= dwarf_alloc_die ();
5743 die
->abbrev
= abbrev_number
;
5750 abbrev
= dwarf2_lookup_abbrev (abbrev_number
, cu
);
5753 error (_("Dwarf Error: could not find abbrev number %d [in module %s]"),
5755 bfd_get_filename (abfd
));
5757 die
= dwarf_alloc_die ();
5758 die
->offset
= offset
;
5759 die
->tag
= abbrev
->tag
;
5760 die
->abbrev
= abbrev_number
;
5763 die
->num_attrs
= abbrev
->num_attrs
;
5764 die
->attrs
= (struct attribute
*)
5765 xmalloc (die
->num_attrs
* sizeof (struct attribute
));
5767 for (i
= 0; i
< abbrev
->num_attrs
; ++i
)
5769 info_ptr
= read_attribute (&die
->attrs
[i
], &abbrev
->attrs
[i
],
5770 abfd
, info_ptr
, cu
);
5772 /* If this attribute is an absolute reference to a different
5773 compilation unit, make sure that compilation unit is loaded
5775 if (die
->attrs
[i
].form
== DW_FORM_ref_addr
5776 && (DW_ADDR (&die
->attrs
[i
]) < cu
->header
.offset
5777 || (DW_ADDR (&die
->attrs
[i
])
5778 >= cu
->header
.offset
+ cu
->header
.length
)))
5780 struct dwarf2_per_cu_data
*per_cu
;
5781 per_cu
= dwarf2_find_containing_comp_unit (DW_ADDR (&die
->attrs
[i
]),
5784 /* Mark the dependence relation so that we don't flush PER_CU
5786 dwarf2_add_dependence (cu
, per_cu
);
5788 /* If it's already on the queue, we have nothing to do. */
5792 /* If the compilation unit is already loaded, just mark it as
5794 if (per_cu
->cu
!= NULL
)
5796 per_cu
->cu
->last_used
= 0;
5800 /* Add it to the queue. */
5801 queue_comp_unit (per_cu
);
5806 *has_children
= abbrev
->has_children
;
5810 /* Read an attribute value described by an attribute form. */
5813 read_attribute_value (struct attribute
*attr
, unsigned form
,
5814 bfd
*abfd
, gdb_byte
*info_ptr
,
5815 struct dwarf2_cu
*cu
)
5817 struct comp_unit_head
*cu_header
= &cu
->header
;
5818 unsigned int bytes_read
;
5819 struct dwarf_block
*blk
;
5825 case DW_FORM_ref_addr
:
5826 DW_ADDR (attr
) = read_address (abfd
, info_ptr
, cu
, &bytes_read
);
5827 info_ptr
+= bytes_read
;
5829 case DW_FORM_block2
:
5830 blk
= dwarf_alloc_block (cu
);
5831 blk
->size
= read_2_bytes (abfd
, info_ptr
);
5833 blk
->data
= read_n_bytes (abfd
, info_ptr
, blk
->size
);
5834 info_ptr
+= blk
->size
;
5835 DW_BLOCK (attr
) = blk
;
5837 case DW_FORM_block4
:
5838 blk
= dwarf_alloc_block (cu
);
5839 blk
->size
= read_4_bytes (abfd
, info_ptr
);
5841 blk
->data
= read_n_bytes (abfd
, info_ptr
, blk
->size
);
5842 info_ptr
+= blk
->size
;
5843 DW_BLOCK (attr
) = blk
;
5846 DW_UNSND (attr
) = read_2_bytes (abfd
, info_ptr
);
5850 DW_UNSND (attr
) = read_4_bytes (abfd
, info_ptr
);
5854 DW_UNSND (attr
) = read_8_bytes (abfd
, info_ptr
);
5857 case DW_FORM_string
:
5858 DW_STRING (attr
) = read_string (abfd
, info_ptr
, &bytes_read
);
5859 info_ptr
+= bytes_read
;
5862 DW_STRING (attr
) = read_indirect_string (abfd
, info_ptr
, cu_header
,
5864 info_ptr
+= bytes_read
;
5867 blk
= dwarf_alloc_block (cu
);
5868 blk
->size
= read_unsigned_leb128 (abfd
, info_ptr
, &bytes_read
);
5869 info_ptr
+= bytes_read
;
5870 blk
->data
= read_n_bytes (abfd
, info_ptr
, blk
->size
);
5871 info_ptr
+= blk
->size
;
5872 DW_BLOCK (attr
) = blk
;
5874 case DW_FORM_block1
:
5875 blk
= dwarf_alloc_block (cu
);
5876 blk
->size
= read_1_byte (abfd
, info_ptr
);
5878 blk
->data
= read_n_bytes (abfd
, info_ptr
, blk
->size
);
5879 info_ptr
+= blk
->size
;
5880 DW_BLOCK (attr
) = blk
;
5883 DW_UNSND (attr
) = read_1_byte (abfd
, info_ptr
);
5887 DW_UNSND (attr
) = read_1_byte (abfd
, info_ptr
);
5891 DW_SND (attr
) = read_signed_leb128 (abfd
, info_ptr
, &bytes_read
);
5892 info_ptr
+= bytes_read
;
5895 DW_UNSND (attr
) = read_unsigned_leb128 (abfd
, info_ptr
, &bytes_read
);
5896 info_ptr
+= bytes_read
;
5899 DW_ADDR (attr
) = cu
->header
.offset
+ read_1_byte (abfd
, info_ptr
);
5903 DW_ADDR (attr
) = cu
->header
.offset
+ read_2_bytes (abfd
, info_ptr
);
5907 DW_ADDR (attr
) = cu
->header
.offset
+ read_4_bytes (abfd
, info_ptr
);
5911 DW_ADDR (attr
) = cu
->header
.offset
+ read_8_bytes (abfd
, info_ptr
);
5914 case DW_FORM_ref_udata
:
5915 DW_ADDR (attr
) = (cu
->header
.offset
5916 + read_unsigned_leb128 (abfd
, info_ptr
, &bytes_read
));
5917 info_ptr
+= bytes_read
;
5919 case DW_FORM_indirect
:
5920 form
= read_unsigned_leb128 (abfd
, info_ptr
, &bytes_read
);
5921 info_ptr
+= bytes_read
;
5922 info_ptr
= read_attribute_value (attr
, form
, abfd
, info_ptr
, cu
);
5925 error (_("Dwarf Error: Cannot handle %s in DWARF reader [in module %s]"),
5926 dwarf_form_name (form
),
5927 bfd_get_filename (abfd
));
5932 /* Read an attribute described by an abbreviated attribute. */
5935 read_attribute (struct attribute
*attr
, struct attr_abbrev
*abbrev
,
5936 bfd
*abfd
, gdb_byte
*info_ptr
, struct dwarf2_cu
*cu
)
5938 attr
->name
= abbrev
->name
;
5939 return read_attribute_value (attr
, abbrev
->form
, abfd
, info_ptr
, cu
);
5942 /* read dwarf information from a buffer */
5945 read_1_byte (bfd
*abfd
, gdb_byte
*buf
)
5947 return bfd_get_8 (abfd
, buf
);
5951 read_1_signed_byte (bfd
*abfd
, gdb_byte
*buf
)
5953 return bfd_get_signed_8 (abfd
, buf
);
5957 read_2_bytes (bfd
*abfd
, gdb_byte
*buf
)
5959 return bfd_get_16 (abfd
, buf
);
5963 read_2_signed_bytes (bfd
*abfd
, gdb_byte
*buf
)
5965 return bfd_get_signed_16 (abfd
, buf
);
5969 read_4_bytes (bfd
*abfd
, gdb_byte
*buf
)
5971 return bfd_get_32 (abfd
, buf
);
5975 read_4_signed_bytes (bfd
*abfd
, gdb_byte
*buf
)
5977 return bfd_get_signed_32 (abfd
, buf
);
5980 static unsigned long
5981 read_8_bytes (bfd
*abfd
, gdb_byte
*buf
)
5983 return bfd_get_64 (abfd
, buf
);
5987 read_address (bfd
*abfd
, gdb_byte
*buf
, struct dwarf2_cu
*cu
,
5988 unsigned int *bytes_read
)
5990 struct comp_unit_head
*cu_header
= &cu
->header
;
5991 CORE_ADDR retval
= 0;
5993 if (cu_header
->signed_addr_p
)
5995 switch (cu_header
->addr_size
)
5998 retval
= bfd_get_signed_16 (abfd
, buf
);
6001 retval
= bfd_get_signed_32 (abfd
, buf
);
6004 retval
= bfd_get_signed_64 (abfd
, buf
);
6007 internal_error (__FILE__
, __LINE__
,
6008 _("read_address: bad switch, signed [in module %s]"),
6009 bfd_get_filename (abfd
));
6014 switch (cu_header
->addr_size
)
6017 retval
= bfd_get_16 (abfd
, buf
);
6020 retval
= bfd_get_32 (abfd
, buf
);
6023 retval
= bfd_get_64 (abfd
, buf
);
6026 internal_error (__FILE__
, __LINE__
,
6027 _("read_address: bad switch, unsigned [in module %s]"),
6028 bfd_get_filename (abfd
));
6032 *bytes_read
= cu_header
->addr_size
;
6036 /* Read the initial length from a section. The (draft) DWARF 3
6037 specification allows the initial length to take up either 4 bytes
6038 or 12 bytes. If the first 4 bytes are 0xffffffff, then the next 8
6039 bytes describe the length and all offsets will be 8 bytes in length
6042 An older, non-standard 64-bit format is also handled by this
6043 function. The older format in question stores the initial length
6044 as an 8-byte quantity without an escape value. Lengths greater
6045 than 2^32 aren't very common which means that the initial 4 bytes
6046 is almost always zero. Since a length value of zero doesn't make
6047 sense for the 32-bit format, this initial zero can be considered to
6048 be an escape value which indicates the presence of the older 64-bit
6049 format. As written, the code can't detect (old format) lengths
6050 greater than 4GB. If it becomes necessary to handle lengths
6051 somewhat larger than 4GB, we could allow other small values (such
6052 as the non-sensical values of 1, 2, and 3) to also be used as
6053 escape values indicating the presence of the old format.
6055 The value returned via bytes_read should be used to increment the
6056 relevant pointer after calling read_initial_length().
6058 As a side effect, this function sets the fields initial_length_size
6059 and offset_size in cu_header to the values appropriate for the
6060 length field. (The format of the initial length field determines
6061 the width of file offsets to be fetched later with read_offset().)
6063 [ Note: read_initial_length() and read_offset() are based on the
6064 document entitled "DWARF Debugging Information Format", revision
6065 3, draft 8, dated November 19, 2001. This document was obtained
6068 http://reality.sgiweb.org/davea/dwarf3-draft8-011125.pdf
6070 This document is only a draft and is subject to change. (So beware.)
6072 Details regarding the older, non-standard 64-bit format were
6073 determined empirically by examining 64-bit ELF files produced by
6074 the SGI toolchain on an IRIX 6.5 machine.
6076 - Kevin, July 16, 2002
6080 read_initial_length (bfd
*abfd
, gdb_byte
*buf
, struct comp_unit_head
*cu_header
,
6081 unsigned int *bytes_read
)
6083 LONGEST length
= bfd_get_32 (abfd
, buf
);
6085 if (length
== 0xffffffff)
6087 length
= bfd_get_64 (abfd
, buf
+ 4);
6090 else if (length
== 0)
6092 /* Handle the (non-standard) 64-bit DWARF2 format used by IRIX. */
6093 length
= bfd_get_64 (abfd
, buf
);
6103 gdb_assert (cu_header
->initial_length_size
== 0
6104 || cu_header
->initial_length_size
== 4
6105 || cu_header
->initial_length_size
== 8
6106 || cu_header
->initial_length_size
== 12);
6108 if (cu_header
->initial_length_size
!= 0
6109 && cu_header
->initial_length_size
!= *bytes_read
)
6110 complaint (&symfile_complaints
,
6111 _("intermixed 32-bit and 64-bit DWARF sections"));
6113 cu_header
->initial_length_size
= *bytes_read
;
6114 cu_header
->offset_size
= (*bytes_read
== 4) ? 4 : 8;
6120 /* Read an offset from the data stream. The size of the offset is
6121 given by cu_header->offset_size. */
6124 read_offset (bfd
*abfd
, gdb_byte
*buf
, const struct comp_unit_head
*cu_header
,
6125 unsigned int *bytes_read
)
6129 switch (cu_header
->offset_size
)
6132 retval
= bfd_get_32 (abfd
, buf
);
6136 retval
= bfd_get_64 (abfd
, buf
);
6140 internal_error (__FILE__
, __LINE__
,
6141 _("read_offset: bad switch [in module %s]"),
6142 bfd_get_filename (abfd
));
6149 read_n_bytes (bfd
*abfd
, gdb_byte
*buf
, unsigned int size
)
6151 /* If the size of a host char is 8 bits, we can return a pointer
6152 to the buffer, otherwise we have to copy the data to a buffer
6153 allocated on the temporary obstack. */
6154 gdb_assert (HOST_CHAR_BIT
== 8);
6159 read_string (bfd
*abfd
, gdb_byte
*buf
, unsigned int *bytes_read_ptr
)
6161 /* If the size of a host char is 8 bits, we can return a pointer
6162 to the string, otherwise we have to copy the string to a buffer
6163 allocated on the temporary obstack. */
6164 gdb_assert (HOST_CHAR_BIT
== 8);
6167 *bytes_read_ptr
= 1;
6170 *bytes_read_ptr
= strlen ((char *) buf
) + 1;
6171 return (char *) buf
;
6175 read_indirect_string (bfd
*abfd
, gdb_byte
*buf
,
6176 const struct comp_unit_head
*cu_header
,
6177 unsigned int *bytes_read_ptr
)
6179 LONGEST str_offset
= read_offset (abfd
, buf
, cu_header
,
6182 if (dwarf2_per_objfile
->str_buffer
== NULL
)
6184 error (_("DW_FORM_strp used without .debug_str section [in module %s]"),
6185 bfd_get_filename (abfd
));
6188 if (str_offset
>= dwarf2_per_objfile
->str_size
)
6190 error (_("DW_FORM_strp pointing outside of .debug_str section [in module %s]"),
6191 bfd_get_filename (abfd
));
6194 gdb_assert (HOST_CHAR_BIT
== 8);
6195 if (dwarf2_per_objfile
->str_buffer
[str_offset
] == '\0')
6197 return (char *) (dwarf2_per_objfile
->str_buffer
+ str_offset
);
6200 static unsigned long
6201 read_unsigned_leb128 (bfd
*abfd
, gdb_byte
*buf
, unsigned int *bytes_read_ptr
)
6203 unsigned long result
;
6204 unsigned int num_read
;
6214 byte
= bfd_get_8 (abfd
, buf
);
6217 result
|= ((unsigned long)(byte
& 127) << shift
);
6218 if ((byte
& 128) == 0)
6224 *bytes_read_ptr
= num_read
;
6229 read_signed_leb128 (bfd
*abfd
, gdb_byte
*buf
, unsigned int *bytes_read_ptr
)
6232 int i
, shift
, num_read
;
6241 byte
= bfd_get_8 (abfd
, buf
);
6244 result
|= ((long)(byte
& 127) << shift
);
6246 if ((byte
& 128) == 0)
6251 if ((shift
< 8 * sizeof (result
)) && (byte
& 0x40))
6252 result
|= -(((long)1) << shift
);
6253 *bytes_read_ptr
= num_read
;
6257 /* Return a pointer to just past the end of an LEB128 number in BUF. */
6260 skip_leb128 (bfd
*abfd
, gdb_byte
*buf
)
6266 byte
= bfd_get_8 (abfd
, buf
);
6268 if ((byte
& 128) == 0)
6274 set_cu_language (unsigned int lang
, struct dwarf2_cu
*cu
)
6280 cu
->language
= language_c
;
6282 case DW_LANG_C_plus_plus
:
6283 cu
->language
= language_cplus
;
6285 case DW_LANG_Fortran77
:
6286 case DW_LANG_Fortran90
:
6287 case DW_LANG_Fortran95
:
6288 cu
->language
= language_fortran
;
6290 case DW_LANG_Mips_Assembler
:
6291 cu
->language
= language_asm
;
6294 cu
->language
= language_java
;
6298 cu
->language
= language_ada
;
6300 case DW_LANG_Modula2
:
6301 cu
->language
= language_m2
;
6303 case DW_LANG_Cobol74
:
6304 case DW_LANG_Cobol85
:
6305 case DW_LANG_Pascal83
:
6307 cu
->language
= language_minimal
;
6310 cu
->language_defn
= language_def (cu
->language
);
6313 /* Return the named attribute or NULL if not there. */
6315 static struct attribute
*
6316 dwarf2_attr (struct die_info
*die
, unsigned int name
, struct dwarf2_cu
*cu
)
6319 struct attribute
*spec
= NULL
;
6321 for (i
= 0; i
< die
->num_attrs
; ++i
)
6323 if (die
->attrs
[i
].name
== name
)
6324 return &die
->attrs
[i
];
6325 if (die
->attrs
[i
].name
== DW_AT_specification
6326 || die
->attrs
[i
].name
== DW_AT_abstract_origin
)
6327 spec
= &die
->attrs
[i
];
6331 return dwarf2_attr (follow_die_ref (die
, spec
, cu
), name
, cu
);
6336 /* Return non-zero iff the attribute NAME is defined for the given DIE,
6337 and holds a non-zero value. This function should only be used for
6338 DW_FORM_flag attributes. */
6341 dwarf2_flag_true_p (struct die_info
*die
, unsigned name
, struct dwarf2_cu
*cu
)
6343 struct attribute
*attr
= dwarf2_attr (die
, name
, cu
);
6345 return (attr
&& DW_UNSND (attr
));
6349 die_is_declaration (struct die_info
*die
, struct dwarf2_cu
*cu
)
6351 /* A DIE is a declaration if it has a DW_AT_declaration attribute
6352 which value is non-zero. However, we have to be careful with
6353 DIEs having a DW_AT_specification attribute, because dwarf2_attr()
6354 (via dwarf2_flag_true_p) follows this attribute. So we may
6355 end up accidently finding a declaration attribute that belongs
6356 to a different DIE referenced by the specification attribute,
6357 even though the given DIE does not have a declaration attribute. */
6358 return (dwarf2_flag_true_p (die
, DW_AT_declaration
, cu
)
6359 && dwarf2_attr (die
, DW_AT_specification
, cu
) == NULL
);
6362 /* Return the die giving the specification for DIE, if there is
6365 static struct die_info
*
6366 die_specification (struct die_info
*die
, struct dwarf2_cu
*cu
)
6368 struct attribute
*spec_attr
= dwarf2_attr (die
, DW_AT_specification
, cu
);
6370 if (spec_attr
== NULL
)
6373 return follow_die_ref (die
, spec_attr
, cu
);
6376 /* Free the line_header structure *LH, and any arrays and strings it
6379 free_line_header (struct line_header
*lh
)
6381 if (lh
->standard_opcode_lengths
)
6382 xfree (lh
->standard_opcode_lengths
);
6384 /* Remember that all the lh->file_names[i].name pointers are
6385 pointers into debug_line_buffer, and don't need to be freed. */
6387 xfree (lh
->file_names
);
6389 /* Similarly for the include directory names. */
6390 if (lh
->include_dirs
)
6391 xfree (lh
->include_dirs
);
6397 /* Add an entry to LH's include directory table. */
6399 add_include_dir (struct line_header
*lh
, char *include_dir
)
6401 /* Grow the array if necessary. */
6402 if (lh
->include_dirs_size
== 0)
6404 lh
->include_dirs_size
= 1; /* for testing */
6405 lh
->include_dirs
= xmalloc (lh
->include_dirs_size
6406 * sizeof (*lh
->include_dirs
));
6408 else if (lh
->num_include_dirs
>= lh
->include_dirs_size
)
6410 lh
->include_dirs_size
*= 2;
6411 lh
->include_dirs
= xrealloc (lh
->include_dirs
,
6412 (lh
->include_dirs_size
6413 * sizeof (*lh
->include_dirs
)));
6416 lh
->include_dirs
[lh
->num_include_dirs
++] = include_dir
;
6420 /* Add an entry to LH's file name table. */
6422 add_file_name (struct line_header
*lh
,
6424 unsigned int dir_index
,
6425 unsigned int mod_time
,
6426 unsigned int length
)
6428 struct file_entry
*fe
;
6430 /* Grow the array if necessary. */
6431 if (lh
->file_names_size
== 0)
6433 lh
->file_names_size
= 1; /* for testing */
6434 lh
->file_names
= xmalloc (lh
->file_names_size
6435 * sizeof (*lh
->file_names
));
6437 else if (lh
->num_file_names
>= lh
->file_names_size
)
6439 lh
->file_names_size
*= 2;
6440 lh
->file_names
= xrealloc (lh
->file_names
,
6441 (lh
->file_names_size
6442 * sizeof (*lh
->file_names
)));
6445 fe
= &lh
->file_names
[lh
->num_file_names
++];
6447 fe
->dir_index
= dir_index
;
6448 fe
->mod_time
= mod_time
;
6449 fe
->length
= length
;
6454 /* Read the statement program header starting at OFFSET in
6455 .debug_line, according to the endianness of ABFD. Return a pointer
6456 to a struct line_header, allocated using xmalloc.
6458 NOTE: the strings in the include directory and file name tables of
6459 the returned object point into debug_line_buffer, and must not be
6461 static struct line_header
*
6462 dwarf_decode_line_header (unsigned int offset
, bfd
*abfd
,
6463 struct dwarf2_cu
*cu
)
6465 struct cleanup
*back_to
;
6466 struct line_header
*lh
;
6468 unsigned int bytes_read
;
6470 char *cur_dir
, *cur_file
;
6472 if (dwarf2_per_objfile
->line_buffer
== NULL
)
6474 complaint (&symfile_complaints
, _("missing .debug_line section"));
6478 /* Make sure that at least there's room for the total_length field.
6479 That could be 12 bytes long, but we're just going to fudge that. */
6480 if (offset
+ 4 >= dwarf2_per_objfile
->line_size
)
6482 dwarf2_statement_list_fits_in_line_number_section_complaint ();
6486 lh
= xmalloc (sizeof (*lh
));
6487 memset (lh
, 0, sizeof (*lh
));
6488 back_to
= make_cleanup ((make_cleanup_ftype
*) free_line_header
,
6491 line_ptr
= dwarf2_per_objfile
->line_buffer
+ offset
;
6493 /* Read in the header. */
6495 read_initial_length (abfd
, line_ptr
, &cu
->header
, &bytes_read
);
6496 line_ptr
+= bytes_read
;
6497 if (line_ptr
+ lh
->total_length
> (dwarf2_per_objfile
->line_buffer
6498 + dwarf2_per_objfile
->line_size
))
6500 dwarf2_statement_list_fits_in_line_number_section_complaint ();
6503 lh
->statement_program_end
= line_ptr
+ lh
->total_length
;
6504 lh
->version
= read_2_bytes (abfd
, line_ptr
);
6506 lh
->header_length
= read_offset (abfd
, line_ptr
, &cu
->header
, &bytes_read
);
6507 line_ptr
+= bytes_read
;
6508 lh
->minimum_instruction_length
= read_1_byte (abfd
, line_ptr
);
6510 lh
->default_is_stmt
= read_1_byte (abfd
, line_ptr
);
6512 lh
->line_base
= read_1_signed_byte (abfd
, line_ptr
);
6514 lh
->line_range
= read_1_byte (abfd
, line_ptr
);
6516 lh
->opcode_base
= read_1_byte (abfd
, line_ptr
);
6518 lh
->standard_opcode_lengths
6519 = xmalloc (lh
->opcode_base
* sizeof (lh
->standard_opcode_lengths
[0]));
6521 lh
->standard_opcode_lengths
[0] = 1; /* This should never be used anyway. */
6522 for (i
= 1; i
< lh
->opcode_base
; ++i
)
6524 lh
->standard_opcode_lengths
[i
] = read_1_byte (abfd
, line_ptr
);
6528 /* Read directory table. */
6529 while ((cur_dir
= read_string (abfd
, line_ptr
, &bytes_read
)) != NULL
)
6531 line_ptr
+= bytes_read
;
6532 add_include_dir (lh
, cur_dir
);
6534 line_ptr
+= bytes_read
;
6536 /* Read file name table. */
6537 while ((cur_file
= read_string (abfd
, line_ptr
, &bytes_read
)) != NULL
)
6539 unsigned int dir_index
, mod_time
, length
;
6541 line_ptr
+= bytes_read
;
6542 dir_index
= read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
6543 line_ptr
+= bytes_read
;
6544 mod_time
= read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
6545 line_ptr
+= bytes_read
;
6546 length
= read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
6547 line_ptr
+= bytes_read
;
6549 add_file_name (lh
, cur_file
, dir_index
, mod_time
, length
);
6551 line_ptr
+= bytes_read
;
6552 lh
->statement_program_start
= line_ptr
;
6554 if (line_ptr
> (dwarf2_per_objfile
->line_buffer
6555 + dwarf2_per_objfile
->line_size
))
6556 complaint (&symfile_complaints
,
6557 _("line number info header doesn't fit in `.debug_line' section"));
6559 discard_cleanups (back_to
);
6563 /* This function exists to work around a bug in certain compilers
6564 (particularly GCC 2.95), in which the first line number marker of a
6565 function does not show up until after the prologue, right before
6566 the second line number marker. This function shifts ADDRESS down
6567 to the beginning of the function if necessary, and is called on
6568 addresses passed to record_line. */
6571 check_cu_functions (CORE_ADDR address
, struct dwarf2_cu
*cu
)
6573 struct function_range
*fn
;
6575 /* Find the function_range containing address. */
6580 cu
->cached_fn
= cu
->first_fn
;
6584 if (fn
->lowpc
<= address
&& fn
->highpc
> address
)
6590 while (fn
&& fn
!= cu
->cached_fn
)
6591 if (fn
->lowpc
<= address
&& fn
->highpc
> address
)
6601 if (address
!= fn
->lowpc
)
6602 complaint (&symfile_complaints
,
6603 _("misplaced first line number at 0x%lx for '%s'"),
6604 (unsigned long) address
, fn
->name
);
6609 /* Decode the Line Number Program (LNP) for the given line_header
6610 structure and CU. The actual information extracted and the type
6611 of structures created from the LNP depends on the value of PST.
6613 1. If PST is NULL, then this procedure uses the data from the program
6614 to create all necessary symbol tables, and their linetables.
6615 The compilation directory of the file is passed in COMP_DIR,
6616 and must not be NULL.
6618 2. If PST is not NULL, this procedure reads the program to determine
6619 the list of files included by the unit represented by PST, and
6620 builds all the associated partial symbol tables. In this case,
6621 the value of COMP_DIR is ignored, and can thus be NULL (the COMP_DIR
6622 is not used to compute the full name of the symtab, and therefore
6623 omitting it when building the partial symtab does not introduce
6624 the potential for inconsistency - a partial symtab and its associated
6625 symbtab having a different fullname -). */
6628 dwarf_decode_lines (struct line_header
*lh
, char *comp_dir
, bfd
*abfd
,
6629 struct dwarf2_cu
*cu
, struct partial_symtab
*pst
)
6633 unsigned int bytes_read
;
6634 unsigned char op_code
, extended_op
, adj_opcode
;
6636 struct objfile
*objfile
= cu
->objfile
;
6637 const int decode_for_pst_p
= (pst
!= NULL
);
6638 struct subfile
*last_subfile
= NULL
;
6640 baseaddr
= ANOFFSET (objfile
->section_offsets
, SECT_OFF_TEXT (objfile
));
6642 line_ptr
= lh
->statement_program_start
;
6643 line_end
= lh
->statement_program_end
;
6645 /* Read the statement sequences until there's nothing left. */
6646 while (line_ptr
< line_end
)
6648 /* state machine registers */
6649 CORE_ADDR address
= 0;
6650 unsigned int file
= 1;
6651 unsigned int line
= 1;
6652 unsigned int column
= 0;
6653 int is_stmt
= lh
->default_is_stmt
;
6654 int basic_block
= 0;
6655 int end_sequence
= 0;
6657 if (!decode_for_pst_p
&& lh
->num_file_names
>= file
)
6659 /* Start a subfile for the current file of the state machine. */
6660 /* lh->include_dirs and lh->file_names are 0-based, but the
6661 directory and file name numbers in the statement program
6663 struct file_entry
*fe
= &lh
->file_names
[file
- 1];
6667 dir
= lh
->include_dirs
[fe
->dir_index
- 1];
6669 dwarf2_start_subfile (fe
->name
, dir
, comp_dir
);
6672 /* Decode the table. */
6673 while (!end_sequence
)
6675 op_code
= read_1_byte (abfd
, line_ptr
);
6678 if (op_code
>= lh
->opcode_base
)
6680 /* Special operand. */
6681 adj_opcode
= op_code
- lh
->opcode_base
;
6682 address
+= (adj_opcode
/ lh
->line_range
)
6683 * lh
->minimum_instruction_length
;
6684 line
+= lh
->line_base
+ (adj_opcode
% lh
->line_range
);
6685 lh
->file_names
[file
- 1].included_p
= 1;
6686 if (!decode_for_pst_p
)
6688 if (last_subfile
!= current_subfile
)
6691 record_line (last_subfile
, 0, address
);
6692 last_subfile
= current_subfile
;
6694 /* Append row to matrix using current values. */
6695 record_line (current_subfile
, line
,
6696 check_cu_functions (address
, cu
));
6700 else switch (op_code
)
6702 case DW_LNS_extended_op
:
6703 read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
6704 line_ptr
+= bytes_read
;
6705 extended_op
= read_1_byte (abfd
, line_ptr
);
6707 switch (extended_op
)
6709 case DW_LNE_end_sequence
:
6711 lh
->file_names
[file
- 1].included_p
= 1;
6712 if (!decode_for_pst_p
)
6713 record_line (current_subfile
, 0, address
);
6715 case DW_LNE_set_address
:
6716 address
= read_address (abfd
, line_ptr
, cu
, &bytes_read
);
6717 line_ptr
+= bytes_read
;
6718 address
+= baseaddr
;
6720 case DW_LNE_define_file
:
6723 unsigned int dir_index
, mod_time
, length
;
6725 cur_file
= read_string (abfd
, line_ptr
, &bytes_read
);
6726 line_ptr
+= bytes_read
;
6728 read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
6729 line_ptr
+= bytes_read
;
6731 read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
6732 line_ptr
+= bytes_read
;
6734 read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
6735 line_ptr
+= bytes_read
;
6736 add_file_name (lh
, cur_file
, dir_index
, mod_time
, length
);
6740 complaint (&symfile_complaints
,
6741 _("mangled .debug_line section"));
6746 lh
->file_names
[file
- 1].included_p
= 1;
6747 if (!decode_for_pst_p
)
6749 if (last_subfile
!= current_subfile
)
6752 record_line (last_subfile
, 0, address
);
6753 last_subfile
= current_subfile
;
6755 record_line (current_subfile
, line
,
6756 check_cu_functions (address
, cu
));
6760 case DW_LNS_advance_pc
:
6761 address
+= lh
->minimum_instruction_length
6762 * read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
6763 line_ptr
+= bytes_read
;
6765 case DW_LNS_advance_line
:
6766 line
+= read_signed_leb128 (abfd
, line_ptr
, &bytes_read
);
6767 line_ptr
+= bytes_read
;
6769 case DW_LNS_set_file
:
6771 /* The arrays lh->include_dirs and lh->file_names are
6772 0-based, but the directory and file name numbers in
6773 the statement program are 1-based. */
6774 struct file_entry
*fe
;
6777 file
= read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
6778 line_ptr
+= bytes_read
;
6779 fe
= &lh
->file_names
[file
- 1];
6781 dir
= lh
->include_dirs
[fe
->dir_index
- 1];
6783 if (!decode_for_pst_p
)
6785 last_subfile
= current_subfile
;
6786 dwarf2_start_subfile (fe
->name
, dir
, comp_dir
);
6790 case DW_LNS_set_column
:
6791 column
= read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
6792 line_ptr
+= bytes_read
;
6794 case DW_LNS_negate_stmt
:
6795 is_stmt
= (!is_stmt
);
6797 case DW_LNS_set_basic_block
:
6800 /* Add to the address register of the state machine the
6801 address increment value corresponding to special opcode
6802 255. I.e., this value is scaled by the minimum
6803 instruction length since special opcode 255 would have
6804 scaled the the increment. */
6805 case DW_LNS_const_add_pc
:
6806 address
+= (lh
->minimum_instruction_length
6807 * ((255 - lh
->opcode_base
) / lh
->line_range
));
6809 case DW_LNS_fixed_advance_pc
:
6810 address
+= read_2_bytes (abfd
, line_ptr
);
6815 /* Unknown standard opcode, ignore it. */
6818 for (i
= 0; i
< lh
->standard_opcode_lengths
[op_code
]; i
++)
6820 (void) read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
6821 line_ptr
+= bytes_read
;
6828 if (decode_for_pst_p
)
6832 /* Now that we're done scanning the Line Header Program, we can
6833 create the psymtab of each included file. */
6834 for (file_index
= 0; file_index
< lh
->num_file_names
; file_index
++)
6835 if (lh
->file_names
[file_index
].included_p
== 1)
6837 const struct file_entry fe
= lh
->file_names
[file_index
];
6838 char *include_name
= fe
.name
;
6839 char *dir_name
= NULL
;
6840 char *pst_filename
= pst
->filename
;
6843 dir_name
= lh
->include_dirs
[fe
.dir_index
- 1];
6845 if (!IS_ABSOLUTE_PATH (include_name
) && dir_name
!= NULL
)
6847 include_name
= concat (dir_name
, SLASH_STRING
,
6848 include_name
, (char *)NULL
);
6849 make_cleanup (xfree
, include_name
);
6852 if (!IS_ABSOLUTE_PATH (pst_filename
) && pst
->dirname
!= NULL
)
6854 pst_filename
= concat (pst
->dirname
, SLASH_STRING
,
6855 pst_filename
, (char *)NULL
);
6856 make_cleanup (xfree
, pst_filename
);
6859 if (strcmp (include_name
, pst_filename
) != 0)
6860 dwarf2_create_include_psymtab (include_name
, pst
, objfile
);
6865 /* Start a subfile for DWARF. FILENAME is the name of the file and
6866 DIRNAME the name of the source directory which contains FILENAME
6867 or NULL if not known. COMP_DIR is the compilation directory for the
6868 linetable's compilation unit or NULL if not known.
6869 This routine tries to keep line numbers from identical absolute and
6870 relative file names in a common subfile.
6872 Using the `list' example from the GDB testsuite, which resides in
6873 /srcdir and compiling it with Irix6.2 cc in /compdir using a filename
6874 of /srcdir/list0.c yields the following debugging information for list0.c:
6876 DW_AT_name: /srcdir/list0.c
6877 DW_AT_comp_dir: /compdir
6878 files.files[0].name: list0.h
6879 files.files[0].dir: /srcdir
6880 files.files[1].name: list0.c
6881 files.files[1].dir: /srcdir
6883 The line number information for list0.c has to end up in a single
6884 subfile, so that `break /srcdir/list0.c:1' works as expected.
6885 start_subfile will ensure that this happens provided that we pass the
6886 concatenation of files.files[1].dir and files.files[1].name as the
6890 dwarf2_start_subfile (char *filename
, char *dirname
, char *comp_dir
)
6894 /* While reading the DIEs, we call start_symtab(DW_AT_name, DW_AT_comp_dir).
6895 `start_symtab' will always pass the contents of DW_AT_comp_dir as
6896 second argument to start_subfile. To be consistent, we do the
6897 same here. In order not to lose the line information directory,
6898 we concatenate it to the filename when it makes sense.
6899 Note that the Dwarf3 standard says (speaking of filenames in line
6900 information): ``The directory index is ignored for file names
6901 that represent full path names''. Thus ignoring dirname in the
6902 `else' branch below isn't an issue. */
6904 if (!IS_ABSOLUTE_PATH (filename
) && dirname
!= NULL
)
6905 fullname
= concat (dirname
, SLASH_STRING
, filename
, (char *)NULL
);
6907 fullname
= filename
;
6909 start_subfile (fullname
, comp_dir
);
6911 if (fullname
!= filename
)
6916 var_decode_location (struct attribute
*attr
, struct symbol
*sym
,
6917 struct dwarf2_cu
*cu
)
6919 struct objfile
*objfile
= cu
->objfile
;
6920 struct comp_unit_head
*cu_header
= &cu
->header
;
6922 /* NOTE drow/2003-01-30: There used to be a comment and some special
6923 code here to turn a symbol with DW_AT_external and a
6924 SYMBOL_VALUE_ADDRESS of 0 into a LOC_UNRESOLVED symbol. This was
6925 necessary for platforms (maybe Alpha, certainly PowerPC GNU/Linux
6926 with some versions of binutils) where shared libraries could have
6927 relocations against symbols in their debug information - the
6928 minimal symbol would have the right address, but the debug info
6929 would not. It's no longer necessary, because we will explicitly
6930 apply relocations when we read in the debug information now. */
6932 /* A DW_AT_location attribute with no contents indicates that a
6933 variable has been optimized away. */
6934 if (attr_form_is_block (attr
) && DW_BLOCK (attr
)->size
== 0)
6936 SYMBOL_CLASS (sym
) = LOC_OPTIMIZED_OUT
;
6940 /* Handle one degenerate form of location expression specially, to
6941 preserve GDB's previous behavior when section offsets are
6942 specified. If this is just a DW_OP_addr then mark this symbol
6945 if (attr_form_is_block (attr
)
6946 && DW_BLOCK (attr
)->size
== 1 + cu_header
->addr_size
6947 && DW_BLOCK (attr
)->data
[0] == DW_OP_addr
)
6951 SYMBOL_VALUE_ADDRESS (sym
) =
6952 read_address (objfile
->obfd
, DW_BLOCK (attr
)->data
+ 1, cu
, &dummy
);
6953 fixup_symbol_section (sym
, objfile
);
6954 SYMBOL_VALUE_ADDRESS (sym
) += ANOFFSET (objfile
->section_offsets
,
6955 SYMBOL_SECTION (sym
));
6956 SYMBOL_CLASS (sym
) = LOC_STATIC
;
6960 /* NOTE drow/2002-01-30: It might be worthwhile to have a static
6961 expression evaluator, and use LOC_COMPUTED only when necessary
6962 (i.e. when the value of a register or memory location is
6963 referenced, or a thread-local block, etc.). Then again, it might
6964 not be worthwhile. I'm assuming that it isn't unless performance
6965 or memory numbers show me otherwise. */
6967 dwarf2_symbol_mark_computed (attr
, sym
, cu
);
6968 SYMBOL_CLASS (sym
) = LOC_COMPUTED
;
6971 /* Given a pointer to a DWARF information entry, figure out if we need
6972 to make a symbol table entry for it, and if so, create a new entry
6973 and return a pointer to it.
6974 If TYPE is NULL, determine symbol type from the die, otherwise
6975 used the passed type. */
6977 static struct symbol
*
6978 new_symbol (struct die_info
*die
, struct type
*type
, struct dwarf2_cu
*cu
)
6980 struct objfile
*objfile
= cu
->objfile
;
6981 struct symbol
*sym
= NULL
;
6983 struct attribute
*attr
= NULL
;
6984 struct attribute
*attr2
= NULL
;
6987 baseaddr
= ANOFFSET (objfile
->section_offsets
, SECT_OFF_TEXT (objfile
));
6989 if (die
->tag
!= DW_TAG_namespace
)
6990 name
= dwarf2_linkage_name (die
, cu
);
6992 name
= TYPE_NAME (type
);
6996 sym
= (struct symbol
*) obstack_alloc (&objfile
->objfile_obstack
,
6997 sizeof (struct symbol
));
6998 OBJSTAT (objfile
, n_syms
++);
6999 memset (sym
, 0, sizeof (struct symbol
));
7001 /* Cache this symbol's name and the name's demangled form (if any). */
7002 SYMBOL_LANGUAGE (sym
) = cu
->language
;
7003 SYMBOL_SET_NAMES (sym
, name
, strlen (name
), objfile
);
7005 /* Default assumptions.
7006 Use the passed type or decode it from the die. */
7007 SYMBOL_DOMAIN (sym
) = VAR_DOMAIN
;
7008 SYMBOL_CLASS (sym
) = LOC_OPTIMIZED_OUT
;
7010 SYMBOL_TYPE (sym
) = type
;
7012 SYMBOL_TYPE (sym
) = die_type (die
, cu
);
7013 attr
= dwarf2_attr (die
, DW_AT_decl_line
, cu
);
7016 SYMBOL_LINE (sym
) = DW_UNSND (attr
);
7021 attr
= dwarf2_attr (die
, DW_AT_low_pc
, cu
);
7024 SYMBOL_VALUE_ADDRESS (sym
) = DW_ADDR (attr
) + baseaddr
;
7026 SYMBOL_CLASS (sym
) = LOC_LABEL
;
7028 case DW_TAG_subprogram
:
7029 /* SYMBOL_BLOCK_VALUE (sym) will be filled in later by
7031 SYMBOL_CLASS (sym
) = LOC_BLOCK
;
7032 attr2
= dwarf2_attr (die
, DW_AT_external
, cu
);
7033 if (attr2
&& (DW_UNSND (attr2
) != 0))
7035 add_symbol_to_list (sym
, &global_symbols
);
7039 add_symbol_to_list (sym
, cu
->list_in_scope
);
7042 case DW_TAG_variable
:
7043 /* Compilation with minimal debug info may result in variables
7044 with missing type entries. Change the misleading `void' type
7045 to something sensible. */
7046 if (TYPE_CODE (SYMBOL_TYPE (sym
)) == TYPE_CODE_VOID
)
7047 SYMBOL_TYPE (sym
) = init_type (TYPE_CODE_INT
,
7048 TARGET_INT_BIT
/ HOST_CHAR_BIT
, 0,
7049 "<variable, no debug info>",
7051 attr
= dwarf2_attr (die
, DW_AT_const_value
, cu
);
7054 dwarf2_const_value (attr
, sym
, cu
);
7055 attr2
= dwarf2_attr (die
, DW_AT_external
, cu
);
7056 if (attr2
&& (DW_UNSND (attr2
) != 0))
7057 add_symbol_to_list (sym
, &global_symbols
);
7059 add_symbol_to_list (sym
, cu
->list_in_scope
);
7062 attr
= dwarf2_attr (die
, DW_AT_location
, cu
);
7065 var_decode_location (attr
, sym
, cu
);
7066 attr2
= dwarf2_attr (die
, DW_AT_external
, cu
);
7067 if (attr2
&& (DW_UNSND (attr2
) != 0))
7068 add_symbol_to_list (sym
, &global_symbols
);
7070 add_symbol_to_list (sym
, cu
->list_in_scope
);
7074 /* We do not know the address of this symbol.
7075 If it is an external symbol and we have type information
7076 for it, enter the symbol as a LOC_UNRESOLVED symbol.
7077 The address of the variable will then be determined from
7078 the minimal symbol table whenever the variable is
7080 attr2
= dwarf2_attr (die
, DW_AT_external
, cu
);
7081 if (attr2
&& (DW_UNSND (attr2
) != 0)
7082 && dwarf2_attr (die
, DW_AT_type
, cu
) != NULL
)
7084 SYMBOL_CLASS (sym
) = LOC_UNRESOLVED
;
7085 add_symbol_to_list (sym
, &global_symbols
);
7089 case DW_TAG_formal_parameter
:
7090 attr
= dwarf2_attr (die
, DW_AT_location
, cu
);
7093 var_decode_location (attr
, sym
, cu
);
7094 /* FIXME drow/2003-07-31: Is LOC_COMPUTED_ARG necessary? */
7095 if (SYMBOL_CLASS (sym
) == LOC_COMPUTED
)
7096 SYMBOL_CLASS (sym
) = LOC_COMPUTED_ARG
;
7098 attr
= dwarf2_attr (die
, DW_AT_const_value
, cu
);
7101 dwarf2_const_value (attr
, sym
, cu
);
7103 add_symbol_to_list (sym
, cu
->list_in_scope
);
7105 case DW_TAG_unspecified_parameters
:
7106 /* From varargs functions; gdb doesn't seem to have any
7107 interest in this information, so just ignore it for now.
7110 case DW_TAG_class_type
:
7111 case DW_TAG_structure_type
:
7112 case DW_TAG_union_type
:
7113 case DW_TAG_set_type
:
7114 case DW_TAG_enumeration_type
:
7115 SYMBOL_CLASS (sym
) = LOC_TYPEDEF
;
7116 SYMBOL_DOMAIN (sym
) = STRUCT_DOMAIN
;
7118 /* Make sure that the symbol includes appropriate enclosing
7119 classes/namespaces in its name. These are calculated in
7120 read_structure_type, and the correct name is saved in
7123 if (cu
->language
== language_cplus
7124 || cu
->language
== language_java
)
7126 struct type
*type
= SYMBOL_TYPE (sym
);
7128 if (TYPE_TAG_NAME (type
) != NULL
)
7130 /* FIXME: carlton/2003-11-10: Should this use
7131 SYMBOL_SET_NAMES instead? (The same problem also
7132 arises further down in this function.) */
7133 /* The type's name is already allocated along with
7134 this objfile, so we don't need to duplicate it
7136 SYMBOL_LINKAGE_NAME (sym
) = TYPE_TAG_NAME (type
);
7141 /* NOTE: carlton/2003-11-10: C++ and Java class symbols shouldn't
7142 really ever be static objects: otherwise, if you try
7143 to, say, break of a class's method and you're in a file
7144 which doesn't mention that class, it won't work unless
7145 the check for all static symbols in lookup_symbol_aux
7146 saves you. See the OtherFileClass tests in
7147 gdb.c++/namespace.exp. */
7149 struct pending
**list_to_add
;
7151 list_to_add
= (cu
->list_in_scope
== &file_symbols
7152 && (cu
->language
== language_cplus
7153 || cu
->language
== language_java
)
7154 ? &global_symbols
: cu
->list_in_scope
);
7156 add_symbol_to_list (sym
, list_to_add
);
7158 /* The semantics of C++ state that "struct foo { ... }" also
7159 defines a typedef for "foo". A Java class declaration also
7160 defines a typedef for the class. Synthesize a typedef symbol
7161 so that "ptype foo" works as expected. */
7162 if (cu
->language
== language_cplus
7163 || cu
->language
== language_java
)
7165 struct symbol
*typedef_sym
= (struct symbol
*)
7166 obstack_alloc (&objfile
->objfile_obstack
,
7167 sizeof (struct symbol
));
7168 *typedef_sym
= *sym
;
7169 SYMBOL_DOMAIN (typedef_sym
) = VAR_DOMAIN
;
7170 /* The symbol's name is already allocated along with
7171 this objfile, so we don't need to duplicate it for
7173 if (TYPE_NAME (SYMBOL_TYPE (sym
)) == 0)
7174 TYPE_NAME (SYMBOL_TYPE (sym
)) = SYMBOL_SEARCH_NAME (sym
);
7175 add_symbol_to_list (typedef_sym
, list_to_add
);
7179 case DW_TAG_typedef
:
7180 if (processing_has_namespace_info
7181 && processing_current_prefix
[0] != '\0')
7183 SYMBOL_LINKAGE_NAME (sym
) = typename_concat (&objfile
->objfile_obstack
,
7184 processing_current_prefix
,
7187 SYMBOL_CLASS (sym
) = LOC_TYPEDEF
;
7188 SYMBOL_DOMAIN (sym
) = VAR_DOMAIN
;
7189 add_symbol_to_list (sym
, cu
->list_in_scope
);
7191 case DW_TAG_base_type
:
7192 case DW_TAG_subrange_type
:
7193 SYMBOL_CLASS (sym
) = LOC_TYPEDEF
;
7194 SYMBOL_DOMAIN (sym
) = VAR_DOMAIN
;
7195 add_symbol_to_list (sym
, cu
->list_in_scope
);
7197 case DW_TAG_enumerator
:
7198 if (processing_has_namespace_info
7199 && processing_current_prefix
[0] != '\0')
7201 SYMBOL_LINKAGE_NAME (sym
) = typename_concat (&objfile
->objfile_obstack
,
7202 processing_current_prefix
,
7205 attr
= dwarf2_attr (die
, DW_AT_const_value
, cu
);
7208 dwarf2_const_value (attr
, sym
, cu
);
7211 /* NOTE: carlton/2003-11-10: See comment above in the
7212 DW_TAG_class_type, etc. block. */
7214 struct pending
**list_to_add
;
7216 list_to_add
= (cu
->list_in_scope
== &file_symbols
7217 && (cu
->language
== language_cplus
7218 || cu
->language
== language_java
)
7219 ? &global_symbols
: cu
->list_in_scope
);
7221 add_symbol_to_list (sym
, list_to_add
);
7224 case DW_TAG_namespace
:
7225 SYMBOL_CLASS (sym
) = LOC_TYPEDEF
;
7226 add_symbol_to_list (sym
, &global_symbols
);
7229 /* Not a tag we recognize. Hopefully we aren't processing
7230 trash data, but since we must specifically ignore things
7231 we don't recognize, there is nothing else we should do at
7233 complaint (&symfile_complaints
, _("unsupported tag: '%s'"),
7234 dwarf_tag_name (die
->tag
));
7241 /* Copy constant value from an attribute to a symbol. */
7244 dwarf2_const_value (struct attribute
*attr
, struct symbol
*sym
,
7245 struct dwarf2_cu
*cu
)
7247 struct objfile
*objfile
= cu
->objfile
;
7248 struct comp_unit_head
*cu_header
= &cu
->header
;
7249 struct dwarf_block
*blk
;
7254 if (TYPE_LENGTH (SYMBOL_TYPE (sym
)) != cu_header
->addr_size
)
7255 dwarf2_const_value_length_mismatch_complaint (DEPRECATED_SYMBOL_NAME (sym
),
7256 cu_header
->addr_size
,
7257 TYPE_LENGTH (SYMBOL_TYPE
7259 SYMBOL_VALUE_BYTES (sym
) =
7260 obstack_alloc (&objfile
->objfile_obstack
, cu_header
->addr_size
);
7261 /* NOTE: cagney/2003-05-09: In-lined store_address call with
7262 it's body - store_unsigned_integer. */
7263 store_unsigned_integer (SYMBOL_VALUE_BYTES (sym
), cu_header
->addr_size
,
7265 SYMBOL_CLASS (sym
) = LOC_CONST_BYTES
;
7267 case DW_FORM_block1
:
7268 case DW_FORM_block2
:
7269 case DW_FORM_block4
:
7271 blk
= DW_BLOCK (attr
);
7272 if (TYPE_LENGTH (SYMBOL_TYPE (sym
)) != blk
->size
)
7273 dwarf2_const_value_length_mismatch_complaint (DEPRECATED_SYMBOL_NAME (sym
),
7275 TYPE_LENGTH (SYMBOL_TYPE
7277 SYMBOL_VALUE_BYTES (sym
) =
7278 obstack_alloc (&objfile
->objfile_obstack
, blk
->size
);
7279 memcpy (SYMBOL_VALUE_BYTES (sym
), blk
->data
, blk
->size
);
7280 SYMBOL_CLASS (sym
) = LOC_CONST_BYTES
;
7283 /* The DW_AT_const_value attributes are supposed to carry the
7284 symbol's value "represented as it would be on the target
7285 architecture." By the time we get here, it's already been
7286 converted to host endianness, so we just need to sign- or
7287 zero-extend it as appropriate. */
7289 dwarf2_const_value_data (attr
, sym
, 8);
7292 dwarf2_const_value_data (attr
, sym
, 16);
7295 dwarf2_const_value_data (attr
, sym
, 32);
7298 dwarf2_const_value_data (attr
, sym
, 64);
7302 SYMBOL_VALUE (sym
) = DW_SND (attr
);
7303 SYMBOL_CLASS (sym
) = LOC_CONST
;
7307 SYMBOL_VALUE (sym
) = DW_UNSND (attr
);
7308 SYMBOL_CLASS (sym
) = LOC_CONST
;
7312 complaint (&symfile_complaints
,
7313 _("unsupported const value attribute form: '%s'"),
7314 dwarf_form_name (attr
->form
));
7315 SYMBOL_VALUE (sym
) = 0;
7316 SYMBOL_CLASS (sym
) = LOC_CONST
;
7322 /* Given an attr with a DW_FORM_dataN value in host byte order, sign-
7323 or zero-extend it as appropriate for the symbol's type. */
7325 dwarf2_const_value_data (struct attribute
*attr
,
7329 LONGEST l
= DW_UNSND (attr
);
7331 if (bits
< sizeof (l
) * 8)
7333 if (TYPE_UNSIGNED (SYMBOL_TYPE (sym
)))
7334 l
&= ((LONGEST
) 1 << bits
) - 1;
7336 l
= (l
<< (sizeof (l
) * 8 - bits
)) >> (sizeof (l
) * 8 - bits
);
7339 SYMBOL_VALUE (sym
) = l
;
7340 SYMBOL_CLASS (sym
) = LOC_CONST
;
7344 /* Return the type of the die in question using its DW_AT_type attribute. */
7346 static struct type
*
7347 die_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
7350 struct attribute
*type_attr
;
7351 struct die_info
*type_die
;
7353 type_attr
= dwarf2_attr (die
, DW_AT_type
, cu
);
7356 /* A missing DW_AT_type represents a void type. */
7357 return dwarf2_fundamental_type (cu
->objfile
, FT_VOID
, cu
);
7360 type_die
= follow_die_ref (die
, type_attr
, cu
);
7362 type
= tag_type_to_type (type_die
, cu
);
7365 dump_die (type_die
);
7366 error (_("Dwarf Error: Problem turning type die at offset into gdb type [in module %s]"),
7372 /* Return the containing type of the die in question using its
7373 DW_AT_containing_type attribute. */
7375 static struct type
*
7376 die_containing_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
7378 struct type
*type
= NULL
;
7379 struct attribute
*type_attr
;
7380 struct die_info
*type_die
= NULL
;
7382 type_attr
= dwarf2_attr (die
, DW_AT_containing_type
, cu
);
7385 type_die
= follow_die_ref (die
, type_attr
, cu
);
7386 type
= tag_type_to_type (type_die
, cu
);
7391 dump_die (type_die
);
7392 error (_("Dwarf Error: Problem turning containing type into gdb type [in module %s]"),
7398 static struct type
*
7399 tag_type_to_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
7407 read_type_die (die
, cu
);
7411 error (_("Dwarf Error: Cannot find type of die [in module %s]"),
7419 read_type_die (struct die_info
*die
, struct dwarf2_cu
*cu
)
7421 char *prefix
= determine_prefix (die
, cu
);
7422 const char *old_prefix
= processing_current_prefix
;
7423 struct cleanup
*back_to
= make_cleanup (xfree
, prefix
);
7424 processing_current_prefix
= prefix
;
7428 case DW_TAG_class_type
:
7429 case DW_TAG_structure_type
:
7430 case DW_TAG_union_type
:
7431 read_structure_type (die
, cu
);
7433 case DW_TAG_enumeration_type
:
7434 read_enumeration_type (die
, cu
);
7436 case DW_TAG_subprogram
:
7437 case DW_TAG_subroutine_type
:
7438 read_subroutine_type (die
, cu
);
7440 case DW_TAG_array_type
:
7441 read_array_type (die
, cu
);
7443 case DW_TAG_set_type
:
7444 read_set_type (die
, cu
);
7446 case DW_TAG_pointer_type
:
7447 read_tag_pointer_type (die
, cu
);
7449 case DW_TAG_ptr_to_member_type
:
7450 read_tag_ptr_to_member_type (die
, cu
);
7452 case DW_TAG_reference_type
:
7453 read_tag_reference_type (die
, cu
);
7455 case DW_TAG_const_type
:
7456 read_tag_const_type (die
, cu
);
7458 case DW_TAG_volatile_type
:
7459 read_tag_volatile_type (die
, cu
);
7461 case DW_TAG_string_type
:
7462 read_tag_string_type (die
, cu
);
7464 case DW_TAG_typedef
:
7465 read_typedef (die
, cu
);
7467 case DW_TAG_subrange_type
:
7468 read_subrange_type (die
, cu
);
7470 case DW_TAG_base_type
:
7471 read_base_type (die
, cu
);
7473 case DW_TAG_unspecified_type
:
7474 read_unspecified_type (die
, cu
);
7477 complaint (&symfile_complaints
, _("unexpected tag in read_type_die: '%s'"),
7478 dwarf_tag_name (die
->tag
));
7482 processing_current_prefix
= old_prefix
;
7483 do_cleanups (back_to
);
7486 /* Return the name of the namespace/class that DIE is defined within,
7487 or "" if we can't tell. The caller should xfree the result. */
7489 /* NOTE: carlton/2004-01-23: See read_func_scope (and the comment
7490 therein) for an example of how to use this function to deal with
7491 DW_AT_specification. */
7494 determine_prefix (struct die_info
*die
, struct dwarf2_cu
*cu
)
7496 struct die_info
*parent
;
7498 if (cu
->language
!= language_cplus
7499 && cu
->language
!= language_java
)
7502 parent
= die
->parent
;
7506 return xstrdup ("");
7510 switch (parent
->tag
) {
7511 case DW_TAG_namespace
:
7513 /* FIXME: carlton/2004-03-05: Should I follow extension dies
7514 before doing this check? */
7515 if (parent
->type
!= NULL
&& TYPE_TAG_NAME (parent
->type
) != NULL
)
7517 return xstrdup (TYPE_TAG_NAME (parent
->type
));
7522 char *parent_prefix
= determine_prefix (parent
, cu
);
7523 char *retval
= typename_concat (NULL
, parent_prefix
,
7524 namespace_name (parent
, &dummy
,
7527 xfree (parent_prefix
);
7532 case DW_TAG_class_type
:
7533 case DW_TAG_structure_type
:
7535 if (parent
->type
!= NULL
&& TYPE_TAG_NAME (parent
->type
) != NULL
)
7537 return xstrdup (TYPE_TAG_NAME (parent
->type
));
7541 const char *old_prefix
= processing_current_prefix
;
7542 char *new_prefix
= determine_prefix (parent
, cu
);
7545 processing_current_prefix
= new_prefix
;
7546 retval
= determine_class_name (parent
, cu
);
7547 processing_current_prefix
= old_prefix
;
7554 return determine_prefix (parent
, cu
);
7559 /* Return a newly-allocated string formed by concatenating PREFIX and
7560 SUFFIX with appropriate separator. If PREFIX or SUFFIX is NULL or empty, then
7561 simply copy the SUFFIX or PREFIX, respectively. If OBS is non-null,
7562 perform an obconcat, otherwise allocate storage for the result. The CU argument
7563 is used to determine the language and hence, the appropriate separator. */
7565 #define MAX_SEP_LEN 2 /* sizeof ("::") */
7568 typename_concat (struct obstack
*obs
, const char *prefix
, const char *suffix
,
7569 struct dwarf2_cu
*cu
)
7573 if (suffix
== NULL
|| suffix
[0] == '\0' || prefix
== NULL
|| prefix
[0] == '\0')
7575 else if (cu
->language
== language_java
)
7582 char *retval
= xmalloc (strlen (prefix
) + MAX_SEP_LEN
+ strlen (suffix
) + 1);
7587 strcpy (retval
, prefix
);
7588 strcat (retval
, sep
);
7591 strcat (retval
, suffix
);
7597 /* We have an obstack. */
7598 return obconcat (obs
, prefix
, sep
, suffix
);
7602 static struct type
*
7603 dwarf_base_type (int encoding
, int size
, struct dwarf2_cu
*cu
)
7605 struct objfile
*objfile
= cu
->objfile
;
7607 /* FIXME - this should not produce a new (struct type *)
7608 every time. It should cache base types. */
7612 case DW_ATE_address
:
7613 type
= dwarf2_fundamental_type (objfile
, FT_VOID
, cu
);
7615 case DW_ATE_boolean
:
7616 type
= dwarf2_fundamental_type (objfile
, FT_BOOLEAN
, cu
);
7618 case DW_ATE_complex_float
:
7621 type
= dwarf2_fundamental_type (objfile
, FT_DBL_PREC_COMPLEX
, cu
);
7625 type
= dwarf2_fundamental_type (objfile
, FT_COMPLEX
, cu
);
7631 type
= dwarf2_fundamental_type (objfile
, FT_DBL_PREC_FLOAT
, cu
);
7635 type
= dwarf2_fundamental_type (objfile
, FT_FLOAT
, cu
);
7642 type
= dwarf2_fundamental_type (objfile
, FT_SIGNED_CHAR
, cu
);
7645 type
= dwarf2_fundamental_type (objfile
, FT_SIGNED_SHORT
, cu
);
7649 type
= dwarf2_fundamental_type (objfile
, FT_SIGNED_INTEGER
, cu
);
7653 case DW_ATE_signed_char
:
7654 type
= dwarf2_fundamental_type (objfile
, FT_SIGNED_CHAR
, cu
);
7656 case DW_ATE_unsigned
:
7660 type
= dwarf2_fundamental_type (objfile
, FT_UNSIGNED_CHAR
, cu
);
7663 type
= dwarf2_fundamental_type (objfile
, FT_UNSIGNED_SHORT
, cu
);
7667 type
= dwarf2_fundamental_type (objfile
, FT_UNSIGNED_INTEGER
, cu
);
7671 case DW_ATE_unsigned_char
:
7672 type
= dwarf2_fundamental_type (objfile
, FT_UNSIGNED_CHAR
, cu
);
7675 type
= dwarf2_fundamental_type (objfile
, FT_SIGNED_INTEGER
, cu
);
7682 copy_die (struct die_info
*old_die
)
7684 struct die_info
*new_die
;
7687 new_die
= (struct die_info
*) xmalloc (sizeof (struct die_info
));
7688 memset (new_die
, 0, sizeof (struct die_info
));
7690 new_die
->tag
= old_die
->tag
;
7691 new_die
->has_children
= old_die
->has_children
;
7692 new_die
->abbrev
= old_die
->abbrev
;
7693 new_die
->offset
= old_die
->offset
;
7694 new_die
->type
= NULL
;
7696 num_attrs
= old_die
->num_attrs
;
7697 new_die
->num_attrs
= num_attrs
;
7698 new_die
->attrs
= (struct attribute
*)
7699 xmalloc (num_attrs
* sizeof (struct attribute
));
7701 for (i
= 0; i
< old_die
->num_attrs
; ++i
)
7703 new_die
->attrs
[i
].name
= old_die
->attrs
[i
].name
;
7704 new_die
->attrs
[i
].form
= old_die
->attrs
[i
].form
;
7705 new_die
->attrs
[i
].u
.addr
= old_die
->attrs
[i
].u
.addr
;
7708 new_die
->next
= NULL
;
7713 /* Return sibling of die, NULL if no sibling. */
7715 static struct die_info
*
7716 sibling_die (struct die_info
*die
)
7718 return die
->sibling
;
7721 /* Get linkage name of a die, return NULL if not found. */
7724 dwarf2_linkage_name (struct die_info
*die
, struct dwarf2_cu
*cu
)
7726 struct attribute
*attr
;
7728 attr
= dwarf2_attr (die
, DW_AT_MIPS_linkage_name
, cu
);
7729 if (attr
&& DW_STRING (attr
))
7730 return DW_STRING (attr
);
7731 attr
= dwarf2_attr (die
, DW_AT_name
, cu
);
7732 if (attr
&& DW_STRING (attr
))
7733 return DW_STRING (attr
);
7737 /* Get name of a die, return NULL if not found. */
7740 dwarf2_name (struct die_info
*die
, struct dwarf2_cu
*cu
)
7742 struct attribute
*attr
;
7744 attr
= dwarf2_attr (die
, DW_AT_name
, cu
);
7745 if (attr
&& DW_STRING (attr
))
7746 return DW_STRING (attr
);
7750 /* Return the die that this die in an extension of, or NULL if there
7753 static struct die_info
*
7754 dwarf2_extension (struct die_info
*die
, struct dwarf2_cu
*cu
)
7756 struct attribute
*attr
;
7758 attr
= dwarf2_attr (die
, DW_AT_extension
, cu
);
7762 return follow_die_ref (die
, attr
, cu
);
7765 /* Convert a DIE tag into its string name. */
7768 dwarf_tag_name (unsigned tag
)
7772 case DW_TAG_padding
:
7773 return "DW_TAG_padding";
7774 case DW_TAG_array_type
:
7775 return "DW_TAG_array_type";
7776 case DW_TAG_class_type
:
7777 return "DW_TAG_class_type";
7778 case DW_TAG_entry_point
:
7779 return "DW_TAG_entry_point";
7780 case DW_TAG_enumeration_type
:
7781 return "DW_TAG_enumeration_type";
7782 case DW_TAG_formal_parameter
:
7783 return "DW_TAG_formal_parameter";
7784 case DW_TAG_imported_declaration
:
7785 return "DW_TAG_imported_declaration";
7787 return "DW_TAG_label";
7788 case DW_TAG_lexical_block
:
7789 return "DW_TAG_lexical_block";
7791 return "DW_TAG_member";
7792 case DW_TAG_pointer_type
:
7793 return "DW_TAG_pointer_type";
7794 case DW_TAG_reference_type
:
7795 return "DW_TAG_reference_type";
7796 case DW_TAG_compile_unit
:
7797 return "DW_TAG_compile_unit";
7798 case DW_TAG_string_type
:
7799 return "DW_TAG_string_type";
7800 case DW_TAG_structure_type
:
7801 return "DW_TAG_structure_type";
7802 case DW_TAG_subroutine_type
:
7803 return "DW_TAG_subroutine_type";
7804 case DW_TAG_typedef
:
7805 return "DW_TAG_typedef";
7806 case DW_TAG_union_type
:
7807 return "DW_TAG_union_type";
7808 case DW_TAG_unspecified_parameters
:
7809 return "DW_TAG_unspecified_parameters";
7810 case DW_TAG_variant
:
7811 return "DW_TAG_variant";
7812 case DW_TAG_common_block
:
7813 return "DW_TAG_common_block";
7814 case DW_TAG_common_inclusion
:
7815 return "DW_TAG_common_inclusion";
7816 case DW_TAG_inheritance
:
7817 return "DW_TAG_inheritance";
7818 case DW_TAG_inlined_subroutine
:
7819 return "DW_TAG_inlined_subroutine";
7821 return "DW_TAG_module";
7822 case DW_TAG_ptr_to_member_type
:
7823 return "DW_TAG_ptr_to_member_type";
7824 case DW_TAG_set_type
:
7825 return "DW_TAG_set_type";
7826 case DW_TAG_subrange_type
:
7827 return "DW_TAG_subrange_type";
7828 case DW_TAG_with_stmt
:
7829 return "DW_TAG_with_stmt";
7830 case DW_TAG_access_declaration
:
7831 return "DW_TAG_access_declaration";
7832 case DW_TAG_base_type
:
7833 return "DW_TAG_base_type";
7834 case DW_TAG_catch_block
:
7835 return "DW_TAG_catch_block";
7836 case DW_TAG_const_type
:
7837 return "DW_TAG_const_type";
7838 case DW_TAG_constant
:
7839 return "DW_TAG_constant";
7840 case DW_TAG_enumerator
:
7841 return "DW_TAG_enumerator";
7842 case DW_TAG_file_type
:
7843 return "DW_TAG_file_type";
7845 return "DW_TAG_friend";
7846 case DW_TAG_namelist
:
7847 return "DW_TAG_namelist";
7848 case DW_TAG_namelist_item
:
7849 return "DW_TAG_namelist_item";
7850 case DW_TAG_packed_type
:
7851 return "DW_TAG_packed_type";
7852 case DW_TAG_subprogram
:
7853 return "DW_TAG_subprogram";
7854 case DW_TAG_template_type_param
:
7855 return "DW_TAG_template_type_param";
7856 case DW_TAG_template_value_param
:
7857 return "DW_TAG_template_value_param";
7858 case DW_TAG_thrown_type
:
7859 return "DW_TAG_thrown_type";
7860 case DW_TAG_try_block
:
7861 return "DW_TAG_try_block";
7862 case DW_TAG_variant_part
:
7863 return "DW_TAG_variant_part";
7864 case DW_TAG_variable
:
7865 return "DW_TAG_variable";
7866 case DW_TAG_volatile_type
:
7867 return "DW_TAG_volatile_type";
7868 case DW_TAG_dwarf_procedure
:
7869 return "DW_TAG_dwarf_procedure";
7870 case DW_TAG_restrict_type
:
7871 return "DW_TAG_restrict_type";
7872 case DW_TAG_interface_type
:
7873 return "DW_TAG_interface_type";
7874 case DW_TAG_namespace
:
7875 return "DW_TAG_namespace";
7876 case DW_TAG_imported_module
:
7877 return "DW_TAG_imported_module";
7878 case DW_TAG_unspecified_type
:
7879 return "DW_TAG_unspecified_type";
7880 case DW_TAG_partial_unit
:
7881 return "DW_TAG_partial_unit";
7882 case DW_TAG_imported_unit
:
7883 return "DW_TAG_imported_unit";
7884 case DW_TAG_MIPS_loop
:
7885 return "DW_TAG_MIPS_loop";
7886 case DW_TAG_format_label
:
7887 return "DW_TAG_format_label";
7888 case DW_TAG_function_template
:
7889 return "DW_TAG_function_template";
7890 case DW_TAG_class_template
:
7891 return "DW_TAG_class_template";
7893 return "DW_TAG_<unknown>";
7897 /* Convert a DWARF attribute code into its string name. */
7900 dwarf_attr_name (unsigned attr
)
7905 return "DW_AT_sibling";
7906 case DW_AT_location
:
7907 return "DW_AT_location";
7909 return "DW_AT_name";
7910 case DW_AT_ordering
:
7911 return "DW_AT_ordering";
7912 case DW_AT_subscr_data
:
7913 return "DW_AT_subscr_data";
7914 case DW_AT_byte_size
:
7915 return "DW_AT_byte_size";
7916 case DW_AT_bit_offset
:
7917 return "DW_AT_bit_offset";
7918 case DW_AT_bit_size
:
7919 return "DW_AT_bit_size";
7920 case DW_AT_element_list
:
7921 return "DW_AT_element_list";
7922 case DW_AT_stmt_list
:
7923 return "DW_AT_stmt_list";
7925 return "DW_AT_low_pc";
7927 return "DW_AT_high_pc";
7928 case DW_AT_language
:
7929 return "DW_AT_language";
7931 return "DW_AT_member";
7933 return "DW_AT_discr";
7934 case DW_AT_discr_value
:
7935 return "DW_AT_discr_value";
7936 case DW_AT_visibility
:
7937 return "DW_AT_visibility";
7939 return "DW_AT_import";
7940 case DW_AT_string_length
:
7941 return "DW_AT_string_length";
7942 case DW_AT_common_reference
:
7943 return "DW_AT_common_reference";
7944 case DW_AT_comp_dir
:
7945 return "DW_AT_comp_dir";
7946 case DW_AT_const_value
:
7947 return "DW_AT_const_value";
7948 case DW_AT_containing_type
:
7949 return "DW_AT_containing_type";
7950 case DW_AT_default_value
:
7951 return "DW_AT_default_value";
7953 return "DW_AT_inline";
7954 case DW_AT_is_optional
:
7955 return "DW_AT_is_optional";
7956 case DW_AT_lower_bound
:
7957 return "DW_AT_lower_bound";
7958 case DW_AT_producer
:
7959 return "DW_AT_producer";
7960 case DW_AT_prototyped
:
7961 return "DW_AT_prototyped";
7962 case DW_AT_return_addr
:
7963 return "DW_AT_return_addr";
7964 case DW_AT_start_scope
:
7965 return "DW_AT_start_scope";
7966 case DW_AT_stride_size
:
7967 return "DW_AT_stride_size";
7968 case DW_AT_upper_bound
:
7969 return "DW_AT_upper_bound";
7970 case DW_AT_abstract_origin
:
7971 return "DW_AT_abstract_origin";
7972 case DW_AT_accessibility
:
7973 return "DW_AT_accessibility";
7974 case DW_AT_address_class
:
7975 return "DW_AT_address_class";
7976 case DW_AT_artificial
:
7977 return "DW_AT_artificial";
7978 case DW_AT_base_types
:
7979 return "DW_AT_base_types";
7980 case DW_AT_calling_convention
:
7981 return "DW_AT_calling_convention";
7983 return "DW_AT_count";
7984 case DW_AT_data_member_location
:
7985 return "DW_AT_data_member_location";
7986 case DW_AT_decl_column
:
7987 return "DW_AT_decl_column";
7988 case DW_AT_decl_file
:
7989 return "DW_AT_decl_file";
7990 case DW_AT_decl_line
:
7991 return "DW_AT_decl_line";
7992 case DW_AT_declaration
:
7993 return "DW_AT_declaration";
7994 case DW_AT_discr_list
:
7995 return "DW_AT_discr_list";
7996 case DW_AT_encoding
:
7997 return "DW_AT_encoding";
7998 case DW_AT_external
:
7999 return "DW_AT_external";
8000 case DW_AT_frame_base
:
8001 return "DW_AT_frame_base";
8003 return "DW_AT_friend";
8004 case DW_AT_identifier_case
:
8005 return "DW_AT_identifier_case";
8006 case DW_AT_macro_info
:
8007 return "DW_AT_macro_info";
8008 case DW_AT_namelist_items
:
8009 return "DW_AT_namelist_items";
8010 case DW_AT_priority
:
8011 return "DW_AT_priority";
8013 return "DW_AT_segment";
8014 case DW_AT_specification
:
8015 return "DW_AT_specification";
8016 case DW_AT_static_link
:
8017 return "DW_AT_static_link";
8019 return "DW_AT_type";
8020 case DW_AT_use_location
:
8021 return "DW_AT_use_location";
8022 case DW_AT_variable_parameter
:
8023 return "DW_AT_variable_parameter";
8024 case DW_AT_virtuality
:
8025 return "DW_AT_virtuality";
8026 case DW_AT_vtable_elem_location
:
8027 return "DW_AT_vtable_elem_location";
8028 case DW_AT_allocated
:
8029 return "DW_AT_allocated";
8030 case DW_AT_associated
:
8031 return "DW_AT_associated";
8032 case DW_AT_data_location
:
8033 return "DW_AT_data_location";
8035 return "DW_AT_stride";
8036 case DW_AT_entry_pc
:
8037 return "DW_AT_entry_pc";
8038 case DW_AT_use_UTF8
:
8039 return "DW_AT_use_UTF8";
8040 case DW_AT_extension
:
8041 return "DW_AT_extension";
8043 return "DW_AT_ranges";
8044 case DW_AT_trampoline
:
8045 return "DW_AT_trampoline";
8046 case DW_AT_call_column
:
8047 return "DW_AT_call_column";
8048 case DW_AT_call_file
:
8049 return "DW_AT_call_file";
8050 case DW_AT_call_line
:
8051 return "DW_AT_call_line";
8053 case DW_AT_MIPS_fde
:
8054 return "DW_AT_MIPS_fde";
8055 case DW_AT_MIPS_loop_begin
:
8056 return "DW_AT_MIPS_loop_begin";
8057 case DW_AT_MIPS_tail_loop_begin
:
8058 return "DW_AT_MIPS_tail_loop_begin";
8059 case DW_AT_MIPS_epilog_begin
:
8060 return "DW_AT_MIPS_epilog_begin";
8061 case DW_AT_MIPS_loop_unroll_factor
:
8062 return "DW_AT_MIPS_loop_unroll_factor";
8063 case DW_AT_MIPS_software_pipeline_depth
:
8064 return "DW_AT_MIPS_software_pipeline_depth";
8066 case DW_AT_MIPS_linkage_name
:
8067 return "DW_AT_MIPS_linkage_name";
8069 case DW_AT_sf_names
:
8070 return "DW_AT_sf_names";
8071 case DW_AT_src_info
:
8072 return "DW_AT_src_info";
8073 case DW_AT_mac_info
:
8074 return "DW_AT_mac_info";
8075 case DW_AT_src_coords
:
8076 return "DW_AT_src_coords";
8077 case DW_AT_body_begin
:
8078 return "DW_AT_body_begin";
8079 case DW_AT_body_end
:
8080 return "DW_AT_body_end";
8081 case DW_AT_GNU_vector
:
8082 return "DW_AT_GNU_vector";
8084 return "DW_AT_<unknown>";
8088 /* Convert a DWARF value form code into its string name. */
8091 dwarf_form_name (unsigned form
)
8096 return "DW_FORM_addr";
8097 case DW_FORM_block2
:
8098 return "DW_FORM_block2";
8099 case DW_FORM_block4
:
8100 return "DW_FORM_block4";
8102 return "DW_FORM_data2";
8104 return "DW_FORM_data4";
8106 return "DW_FORM_data8";
8107 case DW_FORM_string
:
8108 return "DW_FORM_string";
8110 return "DW_FORM_block";
8111 case DW_FORM_block1
:
8112 return "DW_FORM_block1";
8114 return "DW_FORM_data1";
8116 return "DW_FORM_flag";
8118 return "DW_FORM_sdata";
8120 return "DW_FORM_strp";
8122 return "DW_FORM_udata";
8123 case DW_FORM_ref_addr
:
8124 return "DW_FORM_ref_addr";
8126 return "DW_FORM_ref1";
8128 return "DW_FORM_ref2";
8130 return "DW_FORM_ref4";
8132 return "DW_FORM_ref8";
8133 case DW_FORM_ref_udata
:
8134 return "DW_FORM_ref_udata";
8135 case DW_FORM_indirect
:
8136 return "DW_FORM_indirect";
8138 return "DW_FORM_<unknown>";
8142 /* Convert a DWARF stack opcode into its string name. */
8145 dwarf_stack_op_name (unsigned op
)
8150 return "DW_OP_addr";
8152 return "DW_OP_deref";
8154 return "DW_OP_const1u";
8156 return "DW_OP_const1s";
8158 return "DW_OP_const2u";
8160 return "DW_OP_const2s";
8162 return "DW_OP_const4u";
8164 return "DW_OP_const4s";
8166 return "DW_OP_const8u";
8168 return "DW_OP_const8s";
8170 return "DW_OP_constu";
8172 return "DW_OP_consts";
8176 return "DW_OP_drop";
8178 return "DW_OP_over";
8180 return "DW_OP_pick";
8182 return "DW_OP_swap";
8186 return "DW_OP_xderef";
8194 return "DW_OP_minus";
8206 return "DW_OP_plus";
8207 case DW_OP_plus_uconst
:
8208 return "DW_OP_plus_uconst";
8214 return "DW_OP_shra";
8232 return "DW_OP_skip";
8234 return "DW_OP_lit0";
8236 return "DW_OP_lit1";
8238 return "DW_OP_lit2";
8240 return "DW_OP_lit3";
8242 return "DW_OP_lit4";
8244 return "DW_OP_lit5";
8246 return "DW_OP_lit6";
8248 return "DW_OP_lit7";
8250 return "DW_OP_lit8";
8252 return "DW_OP_lit9";
8254 return "DW_OP_lit10";
8256 return "DW_OP_lit11";
8258 return "DW_OP_lit12";
8260 return "DW_OP_lit13";
8262 return "DW_OP_lit14";
8264 return "DW_OP_lit15";
8266 return "DW_OP_lit16";
8268 return "DW_OP_lit17";
8270 return "DW_OP_lit18";
8272 return "DW_OP_lit19";
8274 return "DW_OP_lit20";
8276 return "DW_OP_lit21";
8278 return "DW_OP_lit22";
8280 return "DW_OP_lit23";
8282 return "DW_OP_lit24";
8284 return "DW_OP_lit25";
8286 return "DW_OP_lit26";
8288 return "DW_OP_lit27";
8290 return "DW_OP_lit28";
8292 return "DW_OP_lit29";
8294 return "DW_OP_lit30";
8296 return "DW_OP_lit31";
8298 return "DW_OP_reg0";
8300 return "DW_OP_reg1";
8302 return "DW_OP_reg2";
8304 return "DW_OP_reg3";
8306 return "DW_OP_reg4";
8308 return "DW_OP_reg5";
8310 return "DW_OP_reg6";
8312 return "DW_OP_reg7";
8314 return "DW_OP_reg8";
8316 return "DW_OP_reg9";
8318 return "DW_OP_reg10";
8320 return "DW_OP_reg11";
8322 return "DW_OP_reg12";
8324 return "DW_OP_reg13";
8326 return "DW_OP_reg14";
8328 return "DW_OP_reg15";
8330 return "DW_OP_reg16";
8332 return "DW_OP_reg17";
8334 return "DW_OP_reg18";
8336 return "DW_OP_reg19";
8338 return "DW_OP_reg20";
8340 return "DW_OP_reg21";
8342 return "DW_OP_reg22";
8344 return "DW_OP_reg23";
8346 return "DW_OP_reg24";
8348 return "DW_OP_reg25";
8350 return "DW_OP_reg26";
8352 return "DW_OP_reg27";
8354 return "DW_OP_reg28";
8356 return "DW_OP_reg29";
8358 return "DW_OP_reg30";
8360 return "DW_OP_reg31";
8362 return "DW_OP_breg0";
8364 return "DW_OP_breg1";
8366 return "DW_OP_breg2";
8368 return "DW_OP_breg3";
8370 return "DW_OP_breg4";
8372 return "DW_OP_breg5";
8374 return "DW_OP_breg6";
8376 return "DW_OP_breg7";
8378 return "DW_OP_breg8";
8380 return "DW_OP_breg9";
8382 return "DW_OP_breg10";
8384 return "DW_OP_breg11";
8386 return "DW_OP_breg12";
8388 return "DW_OP_breg13";
8390 return "DW_OP_breg14";
8392 return "DW_OP_breg15";
8394 return "DW_OP_breg16";
8396 return "DW_OP_breg17";
8398 return "DW_OP_breg18";
8400 return "DW_OP_breg19";
8402 return "DW_OP_breg20";
8404 return "DW_OP_breg21";
8406 return "DW_OP_breg22";
8408 return "DW_OP_breg23";
8410 return "DW_OP_breg24";
8412 return "DW_OP_breg25";
8414 return "DW_OP_breg26";
8416 return "DW_OP_breg27";
8418 return "DW_OP_breg28";
8420 return "DW_OP_breg29";
8422 return "DW_OP_breg30";
8424 return "DW_OP_breg31";
8426 return "DW_OP_regx";
8428 return "DW_OP_fbreg";
8430 return "DW_OP_bregx";
8432 return "DW_OP_piece";
8433 case DW_OP_deref_size
:
8434 return "DW_OP_deref_size";
8435 case DW_OP_xderef_size
:
8436 return "DW_OP_xderef_size";
8439 /* DWARF 3 extensions. */
8440 case DW_OP_push_object_address
:
8441 return "DW_OP_push_object_address";
8443 return "DW_OP_call2";
8445 return "DW_OP_call4";
8446 case DW_OP_call_ref
:
8447 return "DW_OP_call_ref";
8448 /* GNU extensions. */
8449 case DW_OP_GNU_push_tls_address
:
8450 return "DW_OP_GNU_push_tls_address";
8452 return "OP_<unknown>";
8457 dwarf_bool_name (unsigned mybool
)
8465 /* Convert a DWARF type code into its string name. */
8468 dwarf_type_encoding_name (unsigned enc
)
8472 case DW_ATE_address
:
8473 return "DW_ATE_address";
8474 case DW_ATE_boolean
:
8475 return "DW_ATE_boolean";
8476 case DW_ATE_complex_float
:
8477 return "DW_ATE_complex_float";
8479 return "DW_ATE_float";
8481 return "DW_ATE_signed";
8482 case DW_ATE_signed_char
:
8483 return "DW_ATE_signed_char";
8484 case DW_ATE_unsigned
:
8485 return "DW_ATE_unsigned";
8486 case DW_ATE_unsigned_char
:
8487 return "DW_ATE_unsigned_char";
8488 case DW_ATE_imaginary_float
:
8489 return "DW_ATE_imaginary_float";
8491 return "DW_ATE_<unknown>";
8495 /* Convert a DWARF call frame info operation to its string name. */
8499 dwarf_cfi_name (unsigned cfi_opc
)
8503 case DW_CFA_advance_loc
:
8504 return "DW_CFA_advance_loc";
8506 return "DW_CFA_offset";
8507 case DW_CFA_restore
:
8508 return "DW_CFA_restore";
8510 return "DW_CFA_nop";
8511 case DW_CFA_set_loc
:
8512 return "DW_CFA_set_loc";
8513 case DW_CFA_advance_loc1
:
8514 return "DW_CFA_advance_loc1";
8515 case DW_CFA_advance_loc2
:
8516 return "DW_CFA_advance_loc2";
8517 case DW_CFA_advance_loc4
:
8518 return "DW_CFA_advance_loc4";
8519 case DW_CFA_offset_extended
:
8520 return "DW_CFA_offset_extended";
8521 case DW_CFA_restore_extended
:
8522 return "DW_CFA_restore_extended";
8523 case DW_CFA_undefined
:
8524 return "DW_CFA_undefined";
8525 case DW_CFA_same_value
:
8526 return "DW_CFA_same_value";
8527 case DW_CFA_register
:
8528 return "DW_CFA_register";
8529 case DW_CFA_remember_state
:
8530 return "DW_CFA_remember_state";
8531 case DW_CFA_restore_state
:
8532 return "DW_CFA_restore_state";
8533 case DW_CFA_def_cfa
:
8534 return "DW_CFA_def_cfa";
8535 case DW_CFA_def_cfa_register
:
8536 return "DW_CFA_def_cfa_register";
8537 case DW_CFA_def_cfa_offset
:
8538 return "DW_CFA_def_cfa_offset";
8541 case DW_CFA_def_cfa_expression
:
8542 return "DW_CFA_def_cfa_expression";
8543 case DW_CFA_expression
:
8544 return "DW_CFA_expression";
8545 case DW_CFA_offset_extended_sf
:
8546 return "DW_CFA_offset_extended_sf";
8547 case DW_CFA_def_cfa_sf
:
8548 return "DW_CFA_def_cfa_sf";
8549 case DW_CFA_def_cfa_offset_sf
:
8550 return "DW_CFA_def_cfa_offset_sf";
8552 /* SGI/MIPS specific */
8553 case DW_CFA_MIPS_advance_loc8
:
8554 return "DW_CFA_MIPS_advance_loc8";
8556 /* GNU extensions */
8557 case DW_CFA_GNU_window_save
:
8558 return "DW_CFA_GNU_window_save";
8559 case DW_CFA_GNU_args_size
:
8560 return "DW_CFA_GNU_args_size";
8561 case DW_CFA_GNU_negative_offset_extended
:
8562 return "DW_CFA_GNU_negative_offset_extended";
8565 return "DW_CFA_<unknown>";
8571 dump_die (struct die_info
*die
)
8575 fprintf_unfiltered (gdb_stderr
, "Die: %s (abbrev = %d, offset = %d)\n",
8576 dwarf_tag_name (die
->tag
), die
->abbrev
, die
->offset
);
8577 fprintf_unfiltered (gdb_stderr
, "\thas children: %s\n",
8578 dwarf_bool_name (die
->child
!= NULL
));
8580 fprintf_unfiltered (gdb_stderr
, "\tattributes:\n");
8581 for (i
= 0; i
< die
->num_attrs
; ++i
)
8583 fprintf_unfiltered (gdb_stderr
, "\t\t%s (%s) ",
8584 dwarf_attr_name (die
->attrs
[i
].name
),
8585 dwarf_form_name (die
->attrs
[i
].form
));
8586 switch (die
->attrs
[i
].form
)
8588 case DW_FORM_ref_addr
:
8590 fprintf_unfiltered (gdb_stderr
, "address: ");
8591 deprecated_print_address_numeric (DW_ADDR (&die
->attrs
[i
]), 1, gdb_stderr
);
8593 case DW_FORM_block2
:
8594 case DW_FORM_block4
:
8596 case DW_FORM_block1
:
8597 fprintf_unfiltered (gdb_stderr
, "block: size %d", DW_BLOCK (&die
->attrs
[i
])->size
);
8602 fprintf_unfiltered (gdb_stderr
, "constant ref: %ld (adjusted)",
8603 (long) (DW_ADDR (&die
->attrs
[i
])));
8611 fprintf_unfiltered (gdb_stderr
, "constant: %ld", DW_UNSND (&die
->attrs
[i
]));
8613 case DW_FORM_string
:
8615 fprintf_unfiltered (gdb_stderr
, "string: \"%s\"",
8616 DW_STRING (&die
->attrs
[i
])
8617 ? DW_STRING (&die
->attrs
[i
]) : "");
8620 if (DW_UNSND (&die
->attrs
[i
]))
8621 fprintf_unfiltered (gdb_stderr
, "flag: TRUE");
8623 fprintf_unfiltered (gdb_stderr
, "flag: FALSE");
8625 case DW_FORM_indirect
:
8626 /* the reader will have reduced the indirect form to
8627 the "base form" so this form should not occur */
8628 fprintf_unfiltered (gdb_stderr
, "unexpected attribute form: DW_FORM_indirect");
8631 fprintf_unfiltered (gdb_stderr
, "unsupported attribute form: %d.",
8632 die
->attrs
[i
].form
);
8634 fprintf_unfiltered (gdb_stderr
, "\n");
8639 dump_die_list (struct die_info
*die
)
8644 if (die
->child
!= NULL
)
8645 dump_die_list (die
->child
);
8646 if (die
->sibling
!= NULL
)
8647 dump_die_list (die
->sibling
);
8652 store_in_ref_table (unsigned int offset
, struct die_info
*die
,
8653 struct dwarf2_cu
*cu
)
8656 struct die_info
*old
;
8658 h
= (offset
% REF_HASH_SIZE
);
8659 old
= cu
->die_ref_table
[h
];
8660 die
->next_ref
= old
;
8661 cu
->die_ref_table
[h
] = die
;
8665 dwarf2_get_ref_die_offset (struct attribute
*attr
, struct dwarf2_cu
*cu
)
8667 unsigned int result
= 0;
8671 case DW_FORM_ref_addr
:
8676 case DW_FORM_ref_udata
:
8677 result
= DW_ADDR (attr
);
8680 complaint (&symfile_complaints
,
8681 _("unsupported die ref attribute form: '%s'"),
8682 dwarf_form_name (attr
->form
));
8687 /* Return the constant value held by the given attribute. Return -1
8688 if the value held by the attribute is not constant. */
8691 dwarf2_get_attr_constant_value (struct attribute
*attr
, int default_value
)
8693 if (attr
->form
== DW_FORM_sdata
)
8694 return DW_SND (attr
);
8695 else if (attr
->form
== DW_FORM_udata
8696 || attr
->form
== DW_FORM_data1
8697 || attr
->form
== DW_FORM_data2
8698 || attr
->form
== DW_FORM_data4
8699 || attr
->form
== DW_FORM_data8
)
8700 return DW_UNSND (attr
);
8703 complaint (&symfile_complaints
, _("Attribute value is not a constant (%s)"),
8704 dwarf_form_name (attr
->form
));
8705 return default_value
;
8709 static struct die_info
*
8710 follow_die_ref (struct die_info
*src_die
, struct attribute
*attr
,
8711 struct dwarf2_cu
*cu
)
8713 struct die_info
*die
;
8714 unsigned int offset
;
8716 struct die_info temp_die
;
8717 struct dwarf2_cu
*target_cu
;
8719 offset
= dwarf2_get_ref_die_offset (attr
, cu
);
8721 if (DW_ADDR (attr
) < cu
->header
.offset
8722 || DW_ADDR (attr
) >= cu
->header
.offset
+ cu
->header
.length
)
8724 struct dwarf2_per_cu_data
*per_cu
;
8725 per_cu
= dwarf2_find_containing_comp_unit (DW_ADDR (attr
),
8727 target_cu
= per_cu
->cu
;
8732 h
= (offset
% REF_HASH_SIZE
);
8733 die
= target_cu
->die_ref_table
[h
];
8736 if (die
->offset
== offset
)
8738 die
= die
->next_ref
;
8741 error (_("Dwarf Error: Cannot find DIE at 0x%lx referenced from DIE "
8742 "at 0x%lx [in module %s]"),
8743 (long) src_die
->offset
, (long) offset
, cu
->objfile
->name
);
8748 static struct type
*
8749 dwarf2_fundamental_type (struct objfile
*objfile
, int typeid,
8750 struct dwarf2_cu
*cu
)
8752 if (typeid < 0 || typeid >= FT_NUM_MEMBERS
)
8754 error (_("Dwarf Error: internal error - invalid fundamental type id %d [in module %s]"),
8755 typeid, objfile
->name
);
8758 /* Look for this particular type in the fundamental type vector. If
8759 one is not found, create and install one appropriate for the
8760 current language and the current target machine. */
8762 if (cu
->ftypes
[typeid] == NULL
)
8764 cu
->ftypes
[typeid] = cu
->language_defn
->la_fund_type (objfile
, typeid);
8767 return (cu
->ftypes
[typeid]);
8770 /* Decode simple location descriptions.
8771 Given a pointer to a dwarf block that defines a location, compute
8772 the location and return the value.
8774 NOTE drow/2003-11-18: This function is called in two situations
8775 now: for the address of static or global variables (partial symbols
8776 only) and for offsets into structures which are expected to be
8777 (more or less) constant. The partial symbol case should go away,
8778 and only the constant case should remain. That will let this
8779 function complain more accurately. A few special modes are allowed
8780 without complaint for global variables (for instance, global
8781 register values and thread-local values).
8783 A location description containing no operations indicates that the
8784 object is optimized out. The return value is 0 for that case.
8785 FIXME drow/2003-11-16: No callers check for this case any more; soon all
8786 callers will only want a very basic result and this can become a
8789 Note that stack[0] is unused except as a default error return.
8790 Note that stack overflow is not yet handled. */
8793 decode_locdesc (struct dwarf_block
*blk
, struct dwarf2_cu
*cu
)
8795 struct objfile
*objfile
= cu
->objfile
;
8796 struct comp_unit_head
*cu_header
= &cu
->header
;
8798 int size
= blk
->size
;
8799 gdb_byte
*data
= blk
->data
;
8800 CORE_ADDR stack
[64];
8802 unsigned int bytes_read
, unsnd
;
8846 stack
[++stacki
] = op
- DW_OP_lit0
;
8881 stack
[++stacki
] = op
- DW_OP_reg0
;
8883 dwarf2_complex_location_expr_complaint ();
8887 unsnd
= read_unsigned_leb128 (NULL
, (data
+ i
), &bytes_read
);
8889 stack
[++stacki
] = unsnd
;
8891 dwarf2_complex_location_expr_complaint ();
8895 stack
[++stacki
] = read_address (objfile
->obfd
, &data
[i
],
8901 stack
[++stacki
] = read_1_byte (objfile
->obfd
, &data
[i
]);
8906 stack
[++stacki
] = read_1_signed_byte (objfile
->obfd
, &data
[i
]);
8911 stack
[++stacki
] = read_2_bytes (objfile
->obfd
, &data
[i
]);
8916 stack
[++stacki
] = read_2_signed_bytes (objfile
->obfd
, &data
[i
]);
8921 stack
[++stacki
] = read_4_bytes (objfile
->obfd
, &data
[i
]);
8926 stack
[++stacki
] = read_4_signed_bytes (objfile
->obfd
, &data
[i
]);
8931 stack
[++stacki
] = read_unsigned_leb128 (NULL
, (data
+ i
),
8937 stack
[++stacki
] = read_signed_leb128 (NULL
, (data
+ i
), &bytes_read
);
8942 stack
[stacki
+ 1] = stack
[stacki
];
8947 stack
[stacki
- 1] += stack
[stacki
];
8951 case DW_OP_plus_uconst
:
8952 stack
[stacki
] += read_unsigned_leb128 (NULL
, (data
+ i
), &bytes_read
);
8957 stack
[stacki
- 1] -= stack
[stacki
];
8962 /* If we're not the last op, then we definitely can't encode
8963 this using GDB's address_class enum. This is valid for partial
8964 global symbols, although the variable's address will be bogus
8967 dwarf2_complex_location_expr_complaint ();
8970 case DW_OP_GNU_push_tls_address
:
8971 /* The top of the stack has the offset from the beginning
8972 of the thread control block at which the variable is located. */
8973 /* Nothing should follow this operator, so the top of stack would
8975 /* This is valid for partial global symbols, but the variable's
8976 address will be bogus in the psymtab. */
8978 dwarf2_complex_location_expr_complaint ();
8982 complaint (&symfile_complaints
, _("unsupported stack op: '%s'"),
8983 dwarf_stack_op_name (op
));
8984 return (stack
[stacki
]);
8987 return (stack
[stacki
]);
8990 /* memory allocation interface */
8992 static struct dwarf_block
*
8993 dwarf_alloc_block (struct dwarf2_cu
*cu
)
8995 struct dwarf_block
*blk
;
8997 blk
= (struct dwarf_block
*)
8998 obstack_alloc (&cu
->comp_unit_obstack
, sizeof (struct dwarf_block
));
9002 static struct abbrev_info
*
9003 dwarf_alloc_abbrev (struct dwarf2_cu
*cu
)
9005 struct abbrev_info
*abbrev
;
9007 abbrev
= (struct abbrev_info
*)
9008 obstack_alloc (&cu
->abbrev_obstack
, sizeof (struct abbrev_info
));
9009 memset (abbrev
, 0, sizeof (struct abbrev_info
));
9013 static struct die_info
*
9014 dwarf_alloc_die (void)
9016 struct die_info
*die
;
9018 die
= (struct die_info
*) xmalloc (sizeof (struct die_info
));
9019 memset (die
, 0, sizeof (struct die_info
));
9024 /* Macro support. */
9027 /* Return the full name of file number I in *LH's file name table.
9028 Use COMP_DIR as the name of the current directory of the
9029 compilation. The result is allocated using xmalloc; the caller is
9030 responsible for freeing it. */
9032 file_full_name (int file
, struct line_header
*lh
, const char *comp_dir
)
9034 /* Is the file number a valid index into the line header's file name
9035 table? Remember that file numbers start with one, not zero. */
9036 if (1 <= file
&& file
<= lh
->num_file_names
)
9038 struct file_entry
*fe
= &lh
->file_names
[file
- 1];
9040 if (IS_ABSOLUTE_PATH (fe
->name
))
9041 return xstrdup (fe
->name
);
9049 dir
= lh
->include_dirs
[fe
->dir_index
- 1];
9055 dir_len
= strlen (dir
);
9056 full_name
= xmalloc (dir_len
+ 1 + strlen (fe
->name
) + 1);
9057 strcpy (full_name
, dir
);
9058 full_name
[dir_len
] = '/';
9059 strcpy (full_name
+ dir_len
+ 1, fe
->name
);
9063 return xstrdup (fe
->name
);
9068 /* The compiler produced a bogus file number. We can at least
9069 record the macro definitions made in the file, even if we
9070 won't be able to find the file by name. */
9072 sprintf (fake_name
, "<bad macro file number %d>", file
);
9074 complaint (&symfile_complaints
,
9075 _("bad file number in macro information (%d)"),
9078 return xstrdup (fake_name
);
9083 static struct macro_source_file
*
9084 macro_start_file (int file
, int line
,
9085 struct macro_source_file
*current_file
,
9086 const char *comp_dir
,
9087 struct line_header
*lh
, struct objfile
*objfile
)
9089 /* The full name of this source file. */
9090 char *full_name
= file_full_name (file
, lh
, comp_dir
);
9092 /* We don't create a macro table for this compilation unit
9093 at all until we actually get a filename. */
9094 if (! pending_macros
)
9095 pending_macros
= new_macro_table (&objfile
->objfile_obstack
,
9096 objfile
->macro_cache
);
9099 /* If we have no current file, then this must be the start_file
9100 directive for the compilation unit's main source file. */
9101 current_file
= macro_set_main (pending_macros
, full_name
);
9103 current_file
= macro_include (current_file
, line
, full_name
);
9107 return current_file
;
9111 /* Copy the LEN characters at BUF to a xmalloc'ed block of memory,
9112 followed by a null byte. */
9114 copy_string (const char *buf
, int len
)
9116 char *s
= xmalloc (len
+ 1);
9117 memcpy (s
, buf
, len
);
9125 consume_improper_spaces (const char *p
, const char *body
)
9129 complaint (&symfile_complaints
,
9130 _("macro definition contains spaces in formal argument list:\n`%s'"),
9142 parse_macro_definition (struct macro_source_file
*file
, int line
,
9147 /* The body string takes one of two forms. For object-like macro
9148 definitions, it should be:
9150 <macro name> " " <definition>
9152 For function-like macro definitions, it should be:
9154 <macro name> "() " <definition>
9156 <macro name> "(" <arg name> ( "," <arg name> ) * ") " <definition>
9158 Spaces may appear only where explicitly indicated, and in the
9161 The Dwarf 2 spec says that an object-like macro's name is always
9162 followed by a space, but versions of GCC around March 2002 omit
9163 the space when the macro's definition is the empty string.
9165 The Dwarf 2 spec says that there should be no spaces between the
9166 formal arguments in a function-like macro's formal argument list,
9167 but versions of GCC around March 2002 include spaces after the
9171 /* Find the extent of the macro name. The macro name is terminated
9172 by either a space or null character (for an object-like macro) or
9173 an opening paren (for a function-like macro). */
9174 for (p
= body
; *p
; p
++)
9175 if (*p
== ' ' || *p
== '(')
9178 if (*p
== ' ' || *p
== '\0')
9180 /* It's an object-like macro. */
9181 int name_len
= p
- body
;
9182 char *name
= copy_string (body
, name_len
);
9183 const char *replacement
;
9186 replacement
= body
+ name_len
+ 1;
9189 dwarf2_macro_malformed_definition_complaint (body
);
9190 replacement
= body
+ name_len
;
9193 macro_define_object (file
, line
, name
, replacement
);
9199 /* It's a function-like macro. */
9200 char *name
= copy_string (body
, p
- body
);
9203 char **argv
= xmalloc (argv_size
* sizeof (*argv
));
9207 p
= consume_improper_spaces (p
, body
);
9209 /* Parse the formal argument list. */
9210 while (*p
&& *p
!= ')')
9212 /* Find the extent of the current argument name. */
9213 const char *arg_start
= p
;
9215 while (*p
&& *p
!= ',' && *p
!= ')' && *p
!= ' ')
9218 if (! *p
|| p
== arg_start
)
9219 dwarf2_macro_malformed_definition_complaint (body
);
9222 /* Make sure argv has room for the new argument. */
9223 if (argc
>= argv_size
)
9226 argv
= xrealloc (argv
, argv_size
* sizeof (*argv
));
9229 argv
[argc
++] = copy_string (arg_start
, p
- arg_start
);
9232 p
= consume_improper_spaces (p
, body
);
9234 /* Consume the comma, if present. */
9239 p
= consume_improper_spaces (p
, body
);
9248 /* Perfectly formed definition, no complaints. */
9249 macro_define_function (file
, line
, name
,
9250 argc
, (const char **) argv
,
9252 else if (*p
== '\0')
9254 /* Complain, but do define it. */
9255 dwarf2_macro_malformed_definition_complaint (body
);
9256 macro_define_function (file
, line
, name
,
9257 argc
, (const char **) argv
,
9261 /* Just complain. */
9262 dwarf2_macro_malformed_definition_complaint (body
);
9265 /* Just complain. */
9266 dwarf2_macro_malformed_definition_complaint (body
);
9272 for (i
= 0; i
< argc
; i
++)
9278 dwarf2_macro_malformed_definition_complaint (body
);
9283 dwarf_decode_macros (struct line_header
*lh
, unsigned int offset
,
9284 char *comp_dir
, bfd
*abfd
,
9285 struct dwarf2_cu
*cu
)
9287 gdb_byte
*mac_ptr
, *mac_end
;
9288 struct macro_source_file
*current_file
= 0;
9290 if (dwarf2_per_objfile
->macinfo_buffer
== NULL
)
9292 complaint (&symfile_complaints
, _("missing .debug_macinfo section"));
9296 mac_ptr
= dwarf2_per_objfile
->macinfo_buffer
+ offset
;
9297 mac_end
= dwarf2_per_objfile
->macinfo_buffer
9298 + dwarf2_per_objfile
->macinfo_size
;
9302 enum dwarf_macinfo_record_type macinfo_type
;
9304 /* Do we at least have room for a macinfo type byte? */
9305 if (mac_ptr
>= mac_end
)
9307 dwarf2_macros_too_long_complaint ();
9311 macinfo_type
= read_1_byte (abfd
, mac_ptr
);
9314 switch (macinfo_type
)
9316 /* A zero macinfo type indicates the end of the macro
9321 case DW_MACINFO_define
:
9322 case DW_MACINFO_undef
:
9324 unsigned int bytes_read
;
9328 line
= read_unsigned_leb128 (abfd
, mac_ptr
, &bytes_read
);
9329 mac_ptr
+= bytes_read
;
9330 body
= read_string (abfd
, mac_ptr
, &bytes_read
);
9331 mac_ptr
+= bytes_read
;
9334 complaint (&symfile_complaints
,
9335 _("debug info gives macro %s outside of any file: %s"),
9337 DW_MACINFO_define
? "definition" : macinfo_type
==
9338 DW_MACINFO_undef
? "undefinition" :
9339 "something-or-other", body
);
9342 if (macinfo_type
== DW_MACINFO_define
)
9343 parse_macro_definition (current_file
, line
, body
);
9344 else if (macinfo_type
== DW_MACINFO_undef
)
9345 macro_undef (current_file
, line
, body
);
9350 case DW_MACINFO_start_file
:
9352 unsigned int bytes_read
;
9355 line
= read_unsigned_leb128 (abfd
, mac_ptr
, &bytes_read
);
9356 mac_ptr
+= bytes_read
;
9357 file
= read_unsigned_leb128 (abfd
, mac_ptr
, &bytes_read
);
9358 mac_ptr
+= bytes_read
;
9360 current_file
= macro_start_file (file
, line
,
9361 current_file
, comp_dir
,
9366 case DW_MACINFO_end_file
:
9368 complaint (&symfile_complaints
,
9369 _("macro debug info has an unmatched `close_file' directive"));
9372 current_file
= current_file
->included_by
;
9375 enum dwarf_macinfo_record_type next_type
;
9377 /* GCC circa March 2002 doesn't produce the zero
9378 type byte marking the end of the compilation
9379 unit. Complain if it's not there, but exit no
9382 /* Do we at least have room for a macinfo type byte? */
9383 if (mac_ptr
>= mac_end
)
9385 dwarf2_macros_too_long_complaint ();
9389 /* We don't increment mac_ptr here, so this is just
9391 next_type
= read_1_byte (abfd
, mac_ptr
);
9393 complaint (&symfile_complaints
,
9394 _("no terminating 0-type entry for macros in `.debug_macinfo' section"));
9401 case DW_MACINFO_vendor_ext
:
9403 unsigned int bytes_read
;
9407 constant
= read_unsigned_leb128 (abfd
, mac_ptr
, &bytes_read
);
9408 mac_ptr
+= bytes_read
;
9409 string
= read_string (abfd
, mac_ptr
, &bytes_read
);
9410 mac_ptr
+= bytes_read
;
9412 /* We don't recognize any vendor extensions. */
9419 /* Check if the attribute's form is a DW_FORM_block*
9420 if so return true else false. */
9422 attr_form_is_block (struct attribute
*attr
)
9424 return (attr
== NULL
? 0 :
9425 attr
->form
== DW_FORM_block1
9426 || attr
->form
== DW_FORM_block2
9427 || attr
->form
== DW_FORM_block4
9428 || attr
->form
== DW_FORM_block
);
9432 dwarf2_symbol_mark_computed (struct attribute
*attr
, struct symbol
*sym
,
9433 struct dwarf2_cu
*cu
)
9435 if ((attr
->form
== DW_FORM_data4
|| attr
->form
== DW_FORM_data8
)
9436 /* ".debug_loc" may not exist at all, or the offset may be outside
9437 the section. If so, fall through to the complaint in the
9439 && DW_UNSND (attr
) < dwarf2_per_objfile
->loc_size
)
9441 struct dwarf2_loclist_baton
*baton
;
9443 baton
= obstack_alloc (&cu
->objfile
->objfile_obstack
,
9444 sizeof (struct dwarf2_loclist_baton
));
9445 baton
->objfile
= cu
->objfile
;
9447 /* We don't know how long the location list is, but make sure we
9448 don't run off the edge of the section. */
9449 baton
->size
= dwarf2_per_objfile
->loc_size
- DW_UNSND (attr
);
9450 baton
->data
= dwarf2_per_objfile
->loc_buffer
+ DW_UNSND (attr
);
9451 baton
->base_address
= cu
->header
.base_address
;
9452 if (cu
->header
.base_known
== 0)
9453 complaint (&symfile_complaints
,
9454 _("Location list used without specifying the CU base address."));
9456 SYMBOL_OPS (sym
) = &dwarf2_loclist_funcs
;
9457 SYMBOL_LOCATION_BATON (sym
) = baton
;
9461 struct dwarf2_locexpr_baton
*baton
;
9463 baton
= obstack_alloc (&cu
->objfile
->objfile_obstack
,
9464 sizeof (struct dwarf2_locexpr_baton
));
9465 baton
->objfile
= cu
->objfile
;
9467 if (attr_form_is_block (attr
))
9469 /* Note that we're just copying the block's data pointer
9470 here, not the actual data. We're still pointing into the
9471 info_buffer for SYM's objfile; right now we never release
9472 that buffer, but when we do clean up properly this may
9474 baton
->size
= DW_BLOCK (attr
)->size
;
9475 baton
->data
= DW_BLOCK (attr
)->data
;
9479 dwarf2_invalid_attrib_class_complaint ("location description",
9480 SYMBOL_NATURAL_NAME (sym
));
9485 SYMBOL_OPS (sym
) = &dwarf2_locexpr_funcs
;
9486 SYMBOL_LOCATION_BATON (sym
) = baton
;
9490 /* Locate the compilation unit from CU's objfile which contains the
9491 DIE at OFFSET. Raises an error on failure. */
9493 static struct dwarf2_per_cu_data
*
9494 dwarf2_find_containing_comp_unit (unsigned long offset
,
9495 struct objfile
*objfile
)
9497 struct dwarf2_per_cu_data
*this_cu
;
9501 high
= dwarf2_per_objfile
->n_comp_units
- 1;
9504 int mid
= low
+ (high
- low
) / 2;
9505 if (dwarf2_per_objfile
->all_comp_units
[mid
]->offset
>= offset
)
9510 gdb_assert (low
== high
);
9511 if (dwarf2_per_objfile
->all_comp_units
[low
]->offset
> offset
)
9514 error (_("Dwarf Error: could not find partial DIE containing "
9515 "offset 0x%lx [in module %s]"),
9516 (long) offset
, bfd_get_filename (objfile
->obfd
));
9518 gdb_assert (dwarf2_per_objfile
->all_comp_units
[low
-1]->offset
<= offset
);
9519 return dwarf2_per_objfile
->all_comp_units
[low
-1];
9523 this_cu
= dwarf2_per_objfile
->all_comp_units
[low
];
9524 if (low
== dwarf2_per_objfile
->n_comp_units
- 1
9525 && offset
>= this_cu
->offset
+ this_cu
->length
)
9526 error (_("invalid dwarf2 offset %ld"), offset
);
9527 gdb_assert (offset
< this_cu
->offset
+ this_cu
->length
);
9532 /* Locate the compilation unit from OBJFILE which is located at exactly
9533 OFFSET. Raises an error on failure. */
9535 static struct dwarf2_per_cu_data
*
9536 dwarf2_find_comp_unit (unsigned long offset
, struct objfile
*objfile
)
9538 struct dwarf2_per_cu_data
*this_cu
;
9539 this_cu
= dwarf2_find_containing_comp_unit (offset
, objfile
);
9540 if (this_cu
->offset
!= offset
)
9541 error (_("no compilation unit with offset %ld."), offset
);
9545 /* Release one cached compilation unit, CU. We unlink it from the tree
9546 of compilation units, but we don't remove it from the read_in_chain;
9547 the caller is responsible for that. */
9550 free_one_comp_unit (void *data
)
9552 struct dwarf2_cu
*cu
= data
;
9554 if (cu
->per_cu
!= NULL
)
9555 cu
->per_cu
->cu
= NULL
;
9558 obstack_free (&cu
->comp_unit_obstack
, NULL
);
9560 free_die_list (cu
->dies
);
9565 /* This cleanup function is passed the address of a dwarf2_cu on the stack
9566 when we're finished with it. We can't free the pointer itself, but be
9567 sure to unlink it from the cache. Also release any associated storage
9568 and perform cache maintenance.
9570 Only used during partial symbol parsing. */
9573 free_stack_comp_unit (void *data
)
9575 struct dwarf2_cu
*cu
= data
;
9577 obstack_free (&cu
->comp_unit_obstack
, NULL
);
9578 cu
->partial_dies
= NULL
;
9580 if (cu
->per_cu
!= NULL
)
9582 /* This compilation unit is on the stack in our caller, so we
9583 should not xfree it. Just unlink it. */
9584 cu
->per_cu
->cu
= NULL
;
9587 /* If we had a per-cu pointer, then we may have other compilation
9588 units loaded, so age them now. */
9589 age_cached_comp_units ();
9593 /* Free all cached compilation units. */
9596 free_cached_comp_units (void *data
)
9598 struct dwarf2_per_cu_data
*per_cu
, **last_chain
;
9600 per_cu
= dwarf2_per_objfile
->read_in_chain
;
9601 last_chain
= &dwarf2_per_objfile
->read_in_chain
;
9602 while (per_cu
!= NULL
)
9604 struct dwarf2_per_cu_data
*next_cu
;
9606 next_cu
= per_cu
->cu
->read_in_chain
;
9608 free_one_comp_unit (per_cu
->cu
);
9609 *last_chain
= next_cu
;
9615 /* Increase the age counter on each cached compilation unit, and free
9616 any that are too old. */
9619 age_cached_comp_units (void)
9621 struct dwarf2_per_cu_data
*per_cu
, **last_chain
;
9623 dwarf2_clear_marks (dwarf2_per_objfile
->read_in_chain
);
9624 per_cu
= dwarf2_per_objfile
->read_in_chain
;
9625 while (per_cu
!= NULL
)
9627 per_cu
->cu
->last_used
++;
9628 if (per_cu
->cu
->last_used
<= dwarf2_max_cache_age
)
9629 dwarf2_mark (per_cu
->cu
);
9630 per_cu
= per_cu
->cu
->read_in_chain
;
9633 per_cu
= dwarf2_per_objfile
->read_in_chain
;
9634 last_chain
= &dwarf2_per_objfile
->read_in_chain
;
9635 while (per_cu
!= NULL
)
9637 struct dwarf2_per_cu_data
*next_cu
;
9639 next_cu
= per_cu
->cu
->read_in_chain
;
9641 if (!per_cu
->cu
->mark
)
9643 free_one_comp_unit (per_cu
->cu
);
9644 *last_chain
= next_cu
;
9647 last_chain
= &per_cu
->cu
->read_in_chain
;
9653 /* Remove a single compilation unit from the cache. */
9656 free_one_cached_comp_unit (void *target_cu
)
9658 struct dwarf2_per_cu_data
*per_cu
, **last_chain
;
9660 per_cu
= dwarf2_per_objfile
->read_in_chain
;
9661 last_chain
= &dwarf2_per_objfile
->read_in_chain
;
9662 while (per_cu
!= NULL
)
9664 struct dwarf2_per_cu_data
*next_cu
;
9666 next_cu
= per_cu
->cu
->read_in_chain
;
9668 if (per_cu
->cu
== target_cu
)
9670 free_one_comp_unit (per_cu
->cu
);
9671 *last_chain
= next_cu
;
9675 last_chain
= &per_cu
->cu
->read_in_chain
;
9681 /* A pair of DIE offset and GDB type pointer. We store these
9682 in a hash table separate from the DIEs, and preserve them
9683 when the DIEs are flushed out of cache. */
9685 struct dwarf2_offset_and_type
9687 unsigned int offset
;
9691 /* Hash function for a dwarf2_offset_and_type. */
9694 offset_and_type_hash (const void *item
)
9696 const struct dwarf2_offset_and_type
*ofs
= item
;
9700 /* Equality function for a dwarf2_offset_and_type. */
9703 offset_and_type_eq (const void *item_lhs
, const void *item_rhs
)
9705 const struct dwarf2_offset_and_type
*ofs_lhs
= item_lhs
;
9706 const struct dwarf2_offset_and_type
*ofs_rhs
= item_rhs
;
9707 return ofs_lhs
->offset
== ofs_rhs
->offset
;
9710 /* Set the type associated with DIE to TYPE. Save it in CU's hash
9711 table if necessary. */
9714 set_die_type (struct die_info
*die
, struct type
*type
, struct dwarf2_cu
*cu
)
9716 struct dwarf2_offset_and_type
**slot
, ofs
;
9720 if (cu
->per_cu
== NULL
)
9723 if (cu
->per_cu
->type_hash
== NULL
)
9724 cu
->per_cu
->type_hash
9725 = htab_create_alloc_ex (cu
->header
.length
/ 24,
9726 offset_and_type_hash
,
9729 &cu
->objfile
->objfile_obstack
,
9730 hashtab_obstack_allocate
,
9731 dummy_obstack_deallocate
);
9733 ofs
.offset
= die
->offset
;
9735 slot
= (struct dwarf2_offset_and_type
**)
9736 htab_find_slot_with_hash (cu
->per_cu
->type_hash
, &ofs
, ofs
.offset
, INSERT
);
9737 *slot
= obstack_alloc (&cu
->objfile
->objfile_obstack
, sizeof (**slot
));
9741 /* Find the type for DIE in TYPE_HASH, or return NULL if DIE does not
9742 have a saved type. */
9744 static struct type
*
9745 get_die_type (struct die_info
*die
, htab_t type_hash
)
9747 struct dwarf2_offset_and_type
*slot
, ofs
;
9749 ofs
.offset
= die
->offset
;
9750 slot
= htab_find_with_hash (type_hash
, &ofs
, ofs
.offset
);
9757 /* Restore the types of the DIE tree starting at START_DIE from the hash
9758 table saved in CU. */
9761 reset_die_and_siblings_types (struct die_info
*start_die
, struct dwarf2_cu
*cu
)
9763 struct die_info
*die
;
9765 if (cu
->per_cu
->type_hash
== NULL
)
9768 for (die
= start_die
; die
!= NULL
; die
= die
->sibling
)
9770 die
->type
= get_die_type (die
, cu
->per_cu
->type_hash
);
9771 if (die
->child
!= NULL
)
9772 reset_die_and_siblings_types (die
->child
, cu
);
9776 /* Set the mark field in CU and in every other compilation unit in the
9777 cache that we must keep because we are keeping CU. */
9779 /* Add a dependence relationship from CU to REF_PER_CU. */
9782 dwarf2_add_dependence (struct dwarf2_cu
*cu
,
9783 struct dwarf2_per_cu_data
*ref_per_cu
)
9787 if (cu
->dependencies
== NULL
)
9789 = htab_create_alloc_ex (5, htab_hash_pointer
, htab_eq_pointer
,
9790 NULL
, &cu
->comp_unit_obstack
,
9791 hashtab_obstack_allocate
,
9792 dummy_obstack_deallocate
);
9794 slot
= htab_find_slot (cu
->dependencies
, ref_per_cu
, INSERT
);
9799 /* Set the mark field in CU and in every other compilation unit in the
9800 cache that we must keep because we are keeping CU. */
9803 dwarf2_mark_helper (void **slot
, void *data
)
9805 struct dwarf2_per_cu_data
*per_cu
;
9807 per_cu
= (struct dwarf2_per_cu_data
*) *slot
;
9808 if (per_cu
->cu
->mark
)
9810 per_cu
->cu
->mark
= 1;
9812 if (per_cu
->cu
->dependencies
!= NULL
)
9813 htab_traverse (per_cu
->cu
->dependencies
, dwarf2_mark_helper
, NULL
);
9819 dwarf2_mark (struct dwarf2_cu
*cu
)
9824 if (cu
->dependencies
!= NULL
)
9825 htab_traverse (cu
->dependencies
, dwarf2_mark_helper
, NULL
);
9829 dwarf2_clear_marks (struct dwarf2_per_cu_data
*per_cu
)
9833 per_cu
->cu
->mark
= 0;
9834 per_cu
= per_cu
->cu
->read_in_chain
;
9838 /* Trivial hash function for partial_die_info: the hash value of a DIE
9839 is its offset in .debug_info for this objfile. */
9842 partial_die_hash (const void *item
)
9844 const struct partial_die_info
*part_die
= item
;
9845 return part_die
->offset
;
9848 /* Trivial comparison function for partial_die_info structures: two DIEs
9849 are equal if they have the same offset. */
9852 partial_die_eq (const void *item_lhs
, const void *item_rhs
)
9854 const struct partial_die_info
*part_die_lhs
= item_lhs
;
9855 const struct partial_die_info
*part_die_rhs
= item_rhs
;
9856 return part_die_lhs
->offset
== part_die_rhs
->offset
;
9859 static struct cmd_list_element
*set_dwarf2_cmdlist
;
9860 static struct cmd_list_element
*show_dwarf2_cmdlist
;
9863 set_dwarf2_cmd (char *args
, int from_tty
)
9865 help_list (set_dwarf2_cmdlist
, "maintenance set dwarf2 ", -1, gdb_stdout
);
9869 show_dwarf2_cmd (char *args
, int from_tty
)
9871 cmd_show_list (show_dwarf2_cmdlist
, from_tty
, "");
9874 void _initialize_dwarf2_read (void);
9877 _initialize_dwarf2_read (void)
9879 dwarf2_objfile_data_key
= register_objfile_data ();
9881 add_prefix_cmd ("dwarf2", class_maintenance
, set_dwarf2_cmd
, _("\
9882 Set DWARF 2 specific variables.\n\
9883 Configure DWARF 2 variables such as the cache size"),
9884 &set_dwarf2_cmdlist
, "maintenance set dwarf2 ",
9885 0/*allow-unknown*/, &maintenance_set_cmdlist
);
9887 add_prefix_cmd ("dwarf2", class_maintenance
, show_dwarf2_cmd
, _("\
9888 Show DWARF 2 specific variables\n\
9889 Show DWARF 2 variables such as the cache size"),
9890 &show_dwarf2_cmdlist
, "maintenance show dwarf2 ",
9891 0/*allow-unknown*/, &maintenance_show_cmdlist
);
9893 add_setshow_zinteger_cmd ("max-cache-age", class_obscure
,
9894 &dwarf2_max_cache_age
, _("\
9895 Set the upper bound on the age of cached dwarf2 compilation units."), _("\
9896 Show the upper bound on the age of cached dwarf2 compilation units."), _("\
9897 A higher limit means that cached compilation units will be stored\n\
9898 in memory longer, and more total memory will be used. Zero disables\n\
9899 caching, which can slow down startup."),
9901 show_dwarf2_max_cache_age
,
9902 &set_dwarf2_cmdlist
,
9903 &show_dwarf2_cmdlist
);