1 /* DWARF 2 debugging format support for GDB.
3 Copyright (C) 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003,
4 2004, 2005, 2006, 2007, 2008 Free Software Foundation, Inc.
6 Adapted by Gary Funck (gary@intrepid.com), Intrepid Technology,
7 Inc. with support from Florida State University (under contract
8 with the Ada Joint Program Office), and Silicon Graphics, Inc.
9 Initial contribution by Brent Benson, Harris Computer Systems, Inc.,
10 based on Fred Fish's (Cygnus Support) implementation of DWARF 1
13 This file is part of GDB.
15 This program is free software; you can redistribute it and/or modify
16 it under the terms of the GNU General Public License as published by
17 the Free Software Foundation; either version 3 of the License, or
18 (at your option) any later version.
20 This program is distributed in the hope that it will be useful,
21 but WITHOUT ANY WARRANTY; without even the implied warranty of
22 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
23 GNU General Public License for more details.
25 You should have received a copy of the GNU General Public License
26 along with this program. If not, see <http://www.gnu.org/licenses/>. */
33 #include "elf/dwarf2.h"
36 #include "expression.h"
37 #include "filenames.h" /* for DOSish file names */
40 #include "complaints.h"
42 #include "dwarf2expr.h"
43 #include "dwarf2loc.h"
44 #include "cp-support.h"
50 #include "gdb_string.h"
51 #include "gdb_assert.h"
52 #include <sys/types.h>
54 /* A note on memory usage for this file.
56 At the present time, this code reads the debug info sections into
57 the objfile's objfile_obstack. A definite improvement for startup
58 time, on platforms which do not emit relocations for debug
59 sections, would be to use mmap instead. The object's complete
60 debug information is loaded into memory, partly to simplify
61 absolute DIE references.
63 Whether using obstacks or mmap, the sections should remain loaded
64 until the objfile is released, and pointers into the section data
65 can be used for any other data associated to the objfile (symbol
66 names, type names, location expressions to name a few). */
69 /* .debug_info header for a compilation unit
70 Because of alignment constraints, this structure has padding and cannot
71 be mapped directly onto the beginning of the .debug_info section. */
72 typedef struct comp_unit_header
74 unsigned int length
; /* length of the .debug_info
76 unsigned short version
; /* version number -- 2 for DWARF
78 unsigned int abbrev_offset
; /* offset into .debug_abbrev section */
79 unsigned char addr_size
; /* byte size of an address -- 4 */
82 #define _ACTUAL_COMP_UNIT_HEADER_SIZE 11
85 /* .debug_pubnames header
86 Because of alignment constraints, this structure has padding and cannot
87 be mapped directly onto the beginning of the .debug_info section. */
88 typedef struct pubnames_header
90 unsigned int length
; /* length of the .debug_pubnames
92 unsigned char version
; /* version number -- 2 for DWARF
94 unsigned int info_offset
; /* offset into .debug_info section */
95 unsigned int info_size
; /* byte size of .debug_info section
99 #define _ACTUAL_PUBNAMES_HEADER_SIZE 13
101 /* .debug_pubnames header
102 Because of alignment constraints, this structure has padding and cannot
103 be mapped directly onto the beginning of the .debug_info section. */
104 typedef struct aranges_header
106 unsigned int length
; /* byte len of the .debug_aranges
108 unsigned short version
; /* version number -- 2 for DWARF
110 unsigned int info_offset
; /* offset into .debug_info section */
111 unsigned char addr_size
; /* byte size of an address */
112 unsigned char seg_size
; /* byte size of segment descriptor */
115 #define _ACTUAL_ARANGES_HEADER_SIZE 12
117 /* .debug_line statement program prologue
118 Because of alignment constraints, this structure has padding and cannot
119 be mapped directly onto the beginning of the .debug_info section. */
120 typedef struct statement_prologue
122 unsigned int total_length
; /* byte length of the statement
124 unsigned short version
; /* version number -- 2 for DWARF
126 unsigned int prologue_length
; /* # bytes between prologue &
128 unsigned char minimum_instruction_length
; /* byte size of
130 unsigned char default_is_stmt
; /* initial value of is_stmt
133 unsigned char line_range
;
134 unsigned char opcode_base
; /* number assigned to first special
136 unsigned char *standard_opcode_lengths
;
140 static const struct objfile_data
*dwarf2_objfile_data_key
;
142 struct dwarf2_per_objfile
144 /* Sizes of debugging sections. */
145 unsigned int info_size
;
146 unsigned int abbrev_size
;
147 unsigned int line_size
;
148 unsigned int pubnames_size
;
149 unsigned int aranges_size
;
150 unsigned int loc_size
;
151 unsigned int macinfo_size
;
152 unsigned int str_size
;
153 unsigned int ranges_size
;
154 unsigned int frame_size
;
155 unsigned int eh_frame_size
;
157 /* Loaded data from the sections. */
158 gdb_byte
*info_buffer
;
159 gdb_byte
*abbrev_buffer
;
160 gdb_byte
*line_buffer
;
161 gdb_byte
*str_buffer
;
162 gdb_byte
*macinfo_buffer
;
163 gdb_byte
*ranges_buffer
;
164 gdb_byte
*loc_buffer
;
166 /* A list of all the compilation units. This is used to locate
167 the target compilation unit of a particular reference. */
168 struct dwarf2_per_cu_data
**all_comp_units
;
170 /* The number of compilation units in ALL_COMP_UNITS. */
173 /* A chain of compilation units that are currently read in, so that
174 they can be freed later. */
175 struct dwarf2_per_cu_data
*read_in_chain
;
177 /* A flag indicating wether this objfile has a section loaded at a
179 int has_section_at_zero
;
182 static struct dwarf2_per_objfile
*dwarf2_per_objfile
;
184 static asection
*dwarf_info_section
;
185 static asection
*dwarf_abbrev_section
;
186 static asection
*dwarf_line_section
;
187 static asection
*dwarf_pubnames_section
;
188 static asection
*dwarf_aranges_section
;
189 static asection
*dwarf_loc_section
;
190 static asection
*dwarf_macinfo_section
;
191 static asection
*dwarf_str_section
;
192 static asection
*dwarf_ranges_section
;
193 asection
*dwarf_frame_section
;
194 asection
*dwarf_eh_frame_section
;
196 /* names of the debugging sections */
198 #define INFO_SECTION ".debug_info"
199 #define ABBREV_SECTION ".debug_abbrev"
200 #define LINE_SECTION ".debug_line"
201 #define PUBNAMES_SECTION ".debug_pubnames"
202 #define ARANGES_SECTION ".debug_aranges"
203 #define LOC_SECTION ".debug_loc"
204 #define MACINFO_SECTION ".debug_macinfo"
205 #define STR_SECTION ".debug_str"
206 #define RANGES_SECTION ".debug_ranges"
207 #define FRAME_SECTION ".debug_frame"
208 #define EH_FRAME_SECTION ".eh_frame"
210 /* local data types */
212 /* We hold several abbreviation tables in memory at the same time. */
213 #ifndef ABBREV_HASH_SIZE
214 #define ABBREV_HASH_SIZE 121
217 /* The data in a compilation unit header, after target2host
218 translation, looks like this. */
219 struct comp_unit_head
221 unsigned long length
;
223 unsigned int abbrev_offset
;
224 unsigned char addr_size
;
225 unsigned char signed_addr_p
;
227 /* Size of file offsets; either 4 or 8. */
228 unsigned int offset_size
;
230 /* Size of the length field; either 4 or 12. */
231 unsigned int initial_length_size
;
233 /* Offset to the first byte of this compilation unit header in the
234 .debug_info section, for resolving relative reference dies. */
237 /* Pointer to this compilation unit header in the .debug_info
239 gdb_byte
*cu_head_ptr
;
241 /* Pointer to the first die of this compilation unit. This will be
242 the first byte following the compilation unit header. */
243 gdb_byte
*first_die_ptr
;
245 /* Pointer to the next compilation unit header in the program. */
246 struct comp_unit_head
*next
;
248 /* Base address of this compilation unit. */
249 CORE_ADDR base_address
;
251 /* Non-zero if base_address has been set. */
255 /* Fixed size for the DIE hash table. */
256 #ifndef REF_HASH_SIZE
257 #define REF_HASH_SIZE 1021
260 /* Internal state when decoding a particular compilation unit. */
263 /* The objfile containing this compilation unit. */
264 struct objfile
*objfile
;
266 /* The header of the compilation unit.
268 FIXME drow/2003-11-10: Some of the things from the comp_unit_head
269 should logically be moved to the dwarf2_cu structure. */
270 struct comp_unit_head header
;
272 struct function_range
*first_fn
, *last_fn
, *cached_fn
;
274 /* The language we are debugging. */
275 enum language language
;
276 const struct language_defn
*language_defn
;
278 const char *producer
;
280 /* The generic symbol table building routines have separate lists for
281 file scope symbols and all all other scopes (local scopes). So
282 we need to select the right one to pass to add_symbol_to_list().
283 We do it by keeping a pointer to the correct list in list_in_scope.
285 FIXME: The original dwarf code just treated the file scope as the
286 first local scope, and all other local scopes as nested local
287 scopes, and worked fine. Check to see if we really need to
288 distinguish these in buildsym.c. */
289 struct pending
**list_in_scope
;
291 /* DWARF abbreviation table associated with this compilation unit. */
292 struct abbrev_info
**dwarf2_abbrevs
;
294 /* Storage for the abbrev table. */
295 struct obstack abbrev_obstack
;
297 /* Hash table holding all the loaded partial DIEs. */
300 /* Storage for things with the same lifetime as this read-in compilation
301 unit, including partial DIEs. */
302 struct obstack comp_unit_obstack
;
304 /* When multiple dwarf2_cu structures are living in memory, this field
305 chains them all together, so that they can be released efficiently.
306 We will probably also want a generation counter so that most-recently-used
307 compilation units are cached... */
308 struct dwarf2_per_cu_data
*read_in_chain
;
310 /* Backchain to our per_cu entry if the tree has been built. */
311 struct dwarf2_per_cu_data
*per_cu
;
313 /* How many compilation units ago was this CU last referenced? */
316 /* A hash table of die offsets for following references. */
317 struct die_info
*die_ref_table
[REF_HASH_SIZE
];
319 /* Full DIEs if read in. */
320 struct die_info
*dies
;
322 /* A set of pointers to dwarf2_per_cu_data objects for compilation
323 units referenced by this one. Only set during full symbol processing;
324 partial symbol tables do not have dependencies. */
327 /* Header data from the line table, during full symbol processing. */
328 struct line_header
*line_header
;
330 /* Mark used when releasing cached dies. */
331 unsigned int mark
: 1;
333 /* This flag will be set if this compilation unit might include
334 inter-compilation-unit references. */
335 unsigned int has_form_ref_addr
: 1;
337 /* This flag will be set if this compilation unit includes any
338 DW_TAG_namespace DIEs. If we know that there are explicit
339 DIEs for namespaces, we don't need to try to infer them
340 from mangled names. */
341 unsigned int has_namespace_info
: 1;
344 /* Persistent data held for a compilation unit, even when not
345 processing it. We put a pointer to this structure in the
346 read_symtab_private field of the psymtab. If we encounter
347 inter-compilation-unit references, we also maintain a sorted
348 list of all compilation units. */
350 struct dwarf2_per_cu_data
352 /* The start offset and length of this compilation unit. 2**30-1
353 bytes should suffice to store the length of any compilation unit
354 - if it doesn't, GDB will fall over anyway. */
355 unsigned long offset
;
356 unsigned long length
: 30;
358 /* Flag indicating this compilation unit will be read in before
359 any of the current compilation units are processed. */
360 unsigned long queued
: 1;
362 /* This flag will be set if we need to load absolutely all DIEs
363 for this compilation unit, instead of just the ones we think
364 are interesting. It gets set if we look for a DIE in the
365 hash table and don't find it. */
366 unsigned int load_all_dies
: 1;
368 /* Set iff currently read in. */
369 struct dwarf2_cu
*cu
;
371 /* If full symbols for this CU have been read in, then this field
372 holds a map of DIE offsets to types. It isn't always possible
373 to reconstruct this information later, so we have to preserve
377 /* The partial symbol table associated with this compilation unit,
378 or NULL for partial units (which do not have an associated
380 struct partial_symtab
*psymtab
;
383 /* The line number information for a compilation unit (found in the
384 .debug_line section) begins with a "statement program header",
385 which contains the following information. */
388 unsigned int total_length
;
389 unsigned short version
;
390 unsigned int header_length
;
391 unsigned char minimum_instruction_length
;
392 unsigned char default_is_stmt
;
394 unsigned char line_range
;
395 unsigned char opcode_base
;
397 /* standard_opcode_lengths[i] is the number of operands for the
398 standard opcode whose value is i. This means that
399 standard_opcode_lengths[0] is unused, and the last meaningful
400 element is standard_opcode_lengths[opcode_base - 1]. */
401 unsigned char *standard_opcode_lengths
;
403 /* The include_directories table. NOTE! These strings are not
404 allocated with xmalloc; instead, they are pointers into
405 debug_line_buffer. If you try to free them, `free' will get
407 unsigned int num_include_dirs
, include_dirs_size
;
410 /* The file_names table. NOTE! These strings are not allocated
411 with xmalloc; instead, they are pointers into debug_line_buffer.
412 Don't try to free them directly. */
413 unsigned int num_file_names
, file_names_size
;
417 unsigned int dir_index
;
418 unsigned int mod_time
;
420 int included_p
; /* Non-zero if referenced by the Line Number Program. */
421 struct symtab
*symtab
; /* The associated symbol table, if any. */
424 /* The start and end of the statement program following this
425 header. These point into dwarf2_per_objfile->line_buffer. */
426 gdb_byte
*statement_program_start
, *statement_program_end
;
429 /* When we construct a partial symbol table entry we only
430 need this much information. */
431 struct partial_die_info
433 /* Offset of this DIE. */
436 /* DWARF-2 tag for this DIE. */
437 ENUM_BITFIELD(dwarf_tag
) tag
: 16;
439 /* Language code associated with this DIE. This is only used
440 for the compilation unit DIE. */
441 unsigned int language
: 8;
443 /* Assorted flags describing the data found in this DIE. */
444 unsigned int has_children
: 1;
445 unsigned int is_external
: 1;
446 unsigned int is_declaration
: 1;
447 unsigned int has_type
: 1;
448 unsigned int has_specification
: 1;
449 unsigned int has_stmt_list
: 1;
450 unsigned int has_pc_info
: 1;
452 /* Flag set if the SCOPE field of this structure has been
454 unsigned int scope_set
: 1;
456 /* Flag set if the DIE has a byte_size attribute. */
457 unsigned int has_byte_size
: 1;
459 /* The name of this DIE. Normally the value of DW_AT_name, but
460 sometimes DW_TAG_MIPS_linkage_name or a string computed in some
465 /* The scope to prepend to our children. This is generally
466 allocated on the comp_unit_obstack, so will disappear
467 when this compilation unit leaves the cache. */
470 /* The location description associated with this DIE, if any. */
471 struct dwarf_block
*locdesc
;
473 /* If HAS_PC_INFO, the PC range associated with this DIE. */
477 /* Pointer into the info_buffer pointing at the target of
478 DW_AT_sibling, if any. */
481 /* If HAS_SPECIFICATION, the offset of the DIE referred to by
482 DW_AT_specification (or DW_AT_abstract_origin or
484 unsigned int spec_offset
;
486 /* If HAS_STMT_LIST, the offset of the Line Number Information data. */
487 unsigned int line_offset
;
489 /* Pointers to this DIE's parent, first child, and next sibling,
491 struct partial_die_info
*die_parent
, *die_child
, *die_sibling
;
494 /* This data structure holds the information of an abbrev. */
497 unsigned int number
; /* number identifying abbrev */
498 enum dwarf_tag tag
; /* dwarf tag */
499 unsigned short has_children
; /* boolean */
500 unsigned short num_attrs
; /* number of attributes */
501 struct attr_abbrev
*attrs
; /* an array of attribute descriptions */
502 struct abbrev_info
*next
; /* next in chain */
507 enum dwarf_attribute name
;
508 enum dwarf_form form
;
511 /* This data structure holds a complete die structure. */
514 enum dwarf_tag tag
; /* Tag indicating type of die */
515 unsigned int abbrev
; /* Abbrev number */
516 unsigned int offset
; /* Offset in .debug_info section */
517 unsigned int num_attrs
; /* Number of attributes */
518 struct attribute
*attrs
; /* An array of attributes */
519 struct die_info
*next_ref
; /* Next die in ref hash table */
521 /* The dies in a compilation unit form an n-ary tree. PARENT
522 points to this die's parent; CHILD points to the first child of
523 this node; and all the children of a given node are chained
524 together via their SIBLING fields, terminated by a die whose
526 struct die_info
*child
; /* Its first child, if any. */
527 struct die_info
*sibling
; /* Its next sibling, if any. */
528 struct die_info
*parent
; /* Its parent, if any. */
530 struct type
*type
; /* Cached type information */
533 /* Attributes have a name and a value */
536 enum dwarf_attribute name
;
537 enum dwarf_form form
;
541 struct dwarf_block
*blk
;
549 struct function_range
552 CORE_ADDR lowpc
, highpc
;
554 struct function_range
*next
;
557 /* Get at parts of an attribute structure */
559 #define DW_STRING(attr) ((attr)->u.str)
560 #define DW_UNSND(attr) ((attr)->u.unsnd)
561 #define DW_BLOCK(attr) ((attr)->u.blk)
562 #define DW_SND(attr) ((attr)->u.snd)
563 #define DW_ADDR(attr) ((attr)->u.addr)
565 /* Blocks are a bunch of untyped bytes. */
572 #ifndef ATTR_ALLOC_CHUNK
573 #define ATTR_ALLOC_CHUNK 4
576 /* Allocate fields for structs, unions and enums in this size. */
577 #ifndef DW_FIELD_ALLOC_CHUNK
578 #define DW_FIELD_ALLOC_CHUNK 4
581 /* A zeroed version of a partial die for initialization purposes. */
582 static struct partial_die_info zeroed_partial_die
;
584 /* FIXME: We might want to set this from BFD via bfd_arch_bits_per_byte,
585 but this would require a corresponding change in unpack_field_as_long
587 static int bits_per_byte
= 8;
589 /* The routines that read and process dies for a C struct or C++ class
590 pass lists of data member fields and lists of member function fields
591 in an instance of a field_info structure, as defined below. */
594 /* List of data member and baseclasses fields. */
597 struct nextfield
*next
;
604 /* Number of fields. */
607 /* Number of baseclasses. */
610 /* Set if the accesibility of one of the fields is not public. */
611 int non_public_fields
;
613 /* Member function fields array, entries are allocated in the order they
614 are encountered in the object file. */
617 struct nextfnfield
*next
;
618 struct fn_field fnfield
;
622 /* Member function fieldlist array, contains name of possibly overloaded
623 member function, number of overloaded member functions and a pointer
624 to the head of the member function field chain. */
629 struct nextfnfield
*head
;
633 /* Number of entries in the fnfieldlists array. */
637 /* One item on the queue of compilation units to read in full symbols
639 struct dwarf2_queue_item
641 struct dwarf2_per_cu_data
*per_cu
;
642 struct dwarf2_queue_item
*next
;
645 /* The current queue. */
646 static struct dwarf2_queue_item
*dwarf2_queue
, *dwarf2_queue_tail
;
648 /* Loaded secondary compilation units are kept in memory until they
649 have not been referenced for the processing of this many
650 compilation units. Set this to zero to disable caching. Cache
651 sizes of up to at least twenty will improve startup time for
652 typical inter-CU-reference binaries, at an obvious memory cost. */
653 static int dwarf2_max_cache_age
= 5;
655 show_dwarf2_max_cache_age (struct ui_file
*file
, int from_tty
,
656 struct cmd_list_element
*c
, const char *value
)
658 fprintf_filtered (file
, _("\
659 The upper bound on the age of cached dwarf2 compilation units is %s.\n"),
664 /* Various complaints about symbol reading that don't abort the process */
667 dwarf2_statement_list_fits_in_line_number_section_complaint (void)
669 complaint (&symfile_complaints
,
670 _("statement list doesn't fit in .debug_line section"));
674 dwarf2_debug_line_missing_file_complaint (void)
676 complaint (&symfile_complaints
,
677 _(".debug_line section has line data without a file"));
681 dwarf2_complex_location_expr_complaint (void)
683 complaint (&symfile_complaints
, _("location expression too complex"));
687 dwarf2_const_value_length_mismatch_complaint (const char *arg1
, int arg2
,
690 complaint (&symfile_complaints
,
691 _("const value length mismatch for '%s', got %d, expected %d"), arg1
,
696 dwarf2_macros_too_long_complaint (void)
698 complaint (&symfile_complaints
,
699 _("macro info runs off end of `.debug_macinfo' section"));
703 dwarf2_macro_malformed_definition_complaint (const char *arg1
)
705 complaint (&symfile_complaints
,
706 _("macro debug info contains a malformed macro definition:\n`%s'"),
711 dwarf2_invalid_attrib_class_complaint (const char *arg1
, const char *arg2
)
713 complaint (&symfile_complaints
,
714 _("invalid attribute class or form for '%s' in '%s'"), arg1
, arg2
);
717 /* local function prototypes */
719 static void dwarf2_locate_sections (bfd
*, asection
*, void *);
722 static void dwarf2_build_psymtabs_easy (struct objfile
*, int);
725 static void dwarf2_create_include_psymtab (char *, struct partial_symtab
*,
728 static void dwarf2_build_include_psymtabs (struct dwarf2_cu
*,
729 struct partial_die_info
*,
730 struct partial_symtab
*);
732 static void dwarf2_build_psymtabs_hard (struct objfile
*, int);
734 static void scan_partial_symbols (struct partial_die_info
*,
735 CORE_ADDR
*, CORE_ADDR
*,
738 static void add_partial_symbol (struct partial_die_info
*,
741 static int pdi_needs_namespace (enum dwarf_tag tag
);
743 static void add_partial_namespace (struct partial_die_info
*pdi
,
744 CORE_ADDR
*lowpc
, CORE_ADDR
*highpc
,
745 struct dwarf2_cu
*cu
);
747 static void add_partial_enumeration (struct partial_die_info
*enum_pdi
,
748 struct dwarf2_cu
*cu
);
750 static gdb_byte
*locate_pdi_sibling (struct partial_die_info
*orig_pdi
,
753 struct dwarf2_cu
*cu
);
755 static void dwarf2_psymtab_to_symtab (struct partial_symtab
*);
757 static void psymtab_to_symtab_1 (struct partial_symtab
*);
759 gdb_byte
*dwarf2_read_section (struct objfile
*, asection
*);
761 static void dwarf2_read_abbrevs (bfd
*abfd
, struct dwarf2_cu
*cu
);
763 static void dwarf2_free_abbrev_table (void *);
765 static struct abbrev_info
*peek_die_abbrev (gdb_byte
*, unsigned int *,
768 static struct abbrev_info
*dwarf2_lookup_abbrev (unsigned int,
771 static struct partial_die_info
*load_partial_dies (bfd
*, gdb_byte
*, int,
774 static gdb_byte
*read_partial_die (struct partial_die_info
*,
775 struct abbrev_info
*abbrev
, unsigned int,
776 bfd
*, gdb_byte
*, struct dwarf2_cu
*);
778 static struct partial_die_info
*find_partial_die (unsigned long,
781 static void fixup_partial_die (struct partial_die_info
*,
784 static gdb_byte
*read_full_die (struct die_info
**, bfd
*, gdb_byte
*,
785 struct dwarf2_cu
*, int *);
787 static gdb_byte
*read_attribute (struct attribute
*, struct attr_abbrev
*,
788 bfd
*, gdb_byte
*, struct dwarf2_cu
*);
790 static gdb_byte
*read_attribute_value (struct attribute
*, unsigned,
791 bfd
*, gdb_byte
*, struct dwarf2_cu
*);
793 static unsigned int read_1_byte (bfd
*, gdb_byte
*);
795 static int read_1_signed_byte (bfd
*, gdb_byte
*);
797 static unsigned int read_2_bytes (bfd
*, gdb_byte
*);
799 static unsigned int read_4_bytes (bfd
*, gdb_byte
*);
801 static unsigned long read_8_bytes (bfd
*, gdb_byte
*);
803 static CORE_ADDR
read_address (bfd
*, gdb_byte
*ptr
, struct dwarf2_cu
*,
806 static LONGEST
read_initial_length (bfd
*, gdb_byte
*,
807 struct comp_unit_head
*, unsigned int *);
809 static LONGEST
read_offset (bfd
*, gdb_byte
*, const struct comp_unit_head
*,
812 static gdb_byte
*read_n_bytes (bfd
*, gdb_byte
*, unsigned int);
814 static char *read_string (bfd
*, gdb_byte
*, unsigned int *);
816 static char *read_indirect_string (bfd
*, gdb_byte
*,
817 const struct comp_unit_head
*,
820 static unsigned long read_unsigned_leb128 (bfd
*, gdb_byte
*, unsigned int *);
822 static long read_signed_leb128 (bfd
*, gdb_byte
*, unsigned int *);
824 static gdb_byte
*skip_leb128 (bfd
*, gdb_byte
*);
826 static void set_cu_language (unsigned int, struct dwarf2_cu
*);
828 static struct attribute
*dwarf2_attr (struct die_info
*, unsigned int,
831 static int dwarf2_flag_true_p (struct die_info
*die
, unsigned name
,
832 struct dwarf2_cu
*cu
);
834 static int die_is_declaration (struct die_info
*, struct dwarf2_cu
*cu
);
836 static struct die_info
*die_specification (struct die_info
*die
,
839 static void free_line_header (struct line_header
*lh
);
841 static void add_file_name (struct line_header
*, char *, unsigned int,
842 unsigned int, unsigned int);
844 static struct line_header
*(dwarf_decode_line_header
845 (unsigned int offset
,
846 bfd
*abfd
, struct dwarf2_cu
*cu
));
848 static void dwarf_decode_lines (struct line_header
*, char *, bfd
*,
849 struct dwarf2_cu
*, struct partial_symtab
*);
851 static void dwarf2_start_subfile (char *, char *, char *);
853 static struct symbol
*new_symbol (struct die_info
*, struct type
*,
856 static void dwarf2_const_value (struct attribute
*, struct symbol
*,
859 static void dwarf2_const_value_data (struct attribute
*attr
,
863 static struct type
*die_type (struct die_info
*, struct dwarf2_cu
*);
865 static struct type
*die_containing_type (struct die_info
*,
868 static struct type
*tag_type_to_type (struct die_info
*, struct dwarf2_cu
*);
870 static void read_type_die (struct die_info
*, struct dwarf2_cu
*);
872 static char *determine_prefix (struct die_info
*die
, struct dwarf2_cu
*);
874 static char *typename_concat (struct obstack
*,
879 static void read_typedef (struct die_info
*, struct dwarf2_cu
*);
881 static void read_base_type (struct die_info
*, struct dwarf2_cu
*);
883 static void read_subrange_type (struct die_info
*die
, struct dwarf2_cu
*cu
);
885 static void read_file_scope (struct die_info
*, struct dwarf2_cu
*);
887 static void read_func_scope (struct die_info
*, struct dwarf2_cu
*);
889 static void read_lexical_block_scope (struct die_info
*, struct dwarf2_cu
*);
891 static int dwarf2_get_pc_bounds (struct die_info
*,
892 CORE_ADDR
*, CORE_ADDR
*, struct dwarf2_cu
*);
894 static void get_scope_pc_bounds (struct die_info
*,
895 CORE_ADDR
*, CORE_ADDR
*,
898 static void dwarf2_record_block_ranges (struct die_info
*, struct block
*,
899 CORE_ADDR
, struct dwarf2_cu
*);
901 static void dwarf2_add_field (struct field_info
*, struct die_info
*,
904 static void dwarf2_attach_fields_to_type (struct field_info
*,
905 struct type
*, struct dwarf2_cu
*);
907 static void dwarf2_add_member_fn (struct field_info
*,
908 struct die_info
*, struct type
*,
911 static void dwarf2_attach_fn_fields_to_type (struct field_info
*,
912 struct type
*, struct dwarf2_cu
*);
914 static void read_structure_type (struct die_info
*, struct dwarf2_cu
*);
916 static void process_structure_scope (struct die_info
*, struct dwarf2_cu
*);
918 static char *determine_class_name (struct die_info
*die
, struct dwarf2_cu
*cu
);
920 static void read_common_block (struct die_info
*, struct dwarf2_cu
*);
922 static void read_namespace (struct die_info
*die
, struct dwarf2_cu
*);
924 static const char *namespace_name (struct die_info
*die
,
925 int *is_anonymous
, struct dwarf2_cu
*);
927 static void read_enumeration_type (struct die_info
*, struct dwarf2_cu
*);
929 static void process_enumeration_scope (struct die_info
*, struct dwarf2_cu
*);
931 static CORE_ADDR
decode_locdesc (struct dwarf_block
*, struct dwarf2_cu
*);
933 static void read_array_type (struct die_info
*, struct dwarf2_cu
*);
935 static enum dwarf_array_dim_ordering
read_array_order (struct die_info
*,
938 static void read_tag_pointer_type (struct die_info
*, struct dwarf2_cu
*);
940 static void read_tag_ptr_to_member_type (struct die_info
*,
943 static void read_tag_reference_type (struct die_info
*, struct dwarf2_cu
*);
945 static void read_tag_const_type (struct die_info
*, struct dwarf2_cu
*);
947 static void read_tag_volatile_type (struct die_info
*, struct dwarf2_cu
*);
949 static void read_tag_string_type (struct die_info
*, struct dwarf2_cu
*);
951 static void read_subroutine_type (struct die_info
*, struct dwarf2_cu
*);
953 static struct die_info
*read_comp_unit (gdb_byte
*, bfd
*, struct dwarf2_cu
*);
955 static struct die_info
*read_die_and_children (gdb_byte
*info_ptr
, bfd
*abfd
,
957 gdb_byte
**new_info_ptr
,
958 struct die_info
*parent
);
960 static struct die_info
*read_die_and_siblings (gdb_byte
*info_ptr
, bfd
*abfd
,
962 gdb_byte
**new_info_ptr
,
963 struct die_info
*parent
);
965 static void free_die_list (struct die_info
*);
967 static void process_die (struct die_info
*, struct dwarf2_cu
*);
969 static char *dwarf2_linkage_name (struct die_info
*, struct dwarf2_cu
*);
971 static char *dwarf2_name (struct die_info
*die
, struct dwarf2_cu
*);
973 static struct die_info
*dwarf2_extension (struct die_info
*die
,
976 static char *dwarf_tag_name (unsigned int);
978 static char *dwarf_attr_name (unsigned int);
980 static char *dwarf_form_name (unsigned int);
982 static char *dwarf_stack_op_name (unsigned int);
984 static char *dwarf_bool_name (unsigned int);
986 static char *dwarf_type_encoding_name (unsigned int);
989 static char *dwarf_cfi_name (unsigned int);
991 struct die_info
*copy_die (struct die_info
*);
994 static struct die_info
*sibling_die (struct die_info
*);
996 static void dump_die (struct die_info
*);
998 static void dump_die_list (struct die_info
*);
1000 static void store_in_ref_table (unsigned int, struct die_info
*,
1001 struct dwarf2_cu
*);
1003 static unsigned int dwarf2_get_ref_die_offset (struct attribute
*,
1004 struct dwarf2_cu
*);
1006 static int dwarf2_get_attr_constant_value (struct attribute
*, int);
1008 static struct die_info
*follow_die_ref (struct die_info
*,
1010 struct dwarf2_cu
*);
1012 /* memory allocation interface */
1014 static struct dwarf_block
*dwarf_alloc_block (struct dwarf2_cu
*);
1016 static struct abbrev_info
*dwarf_alloc_abbrev (struct dwarf2_cu
*);
1018 static struct die_info
*dwarf_alloc_die (void);
1020 static void initialize_cu_func_list (struct dwarf2_cu
*);
1022 static void add_to_cu_func_list (const char *, CORE_ADDR
, CORE_ADDR
,
1023 struct dwarf2_cu
*);
1025 static void dwarf_decode_macros (struct line_header
*, unsigned int,
1026 char *, bfd
*, struct dwarf2_cu
*);
1028 static int attr_form_is_block (struct attribute
*);
1030 static int attr_form_is_section_offset (struct attribute
*);
1032 static int attr_form_is_constant (struct attribute
*);
1034 static void dwarf2_symbol_mark_computed (struct attribute
*attr
,
1036 struct dwarf2_cu
*cu
);
1038 static gdb_byte
*skip_one_die (gdb_byte
*info_ptr
, struct abbrev_info
*abbrev
,
1039 struct dwarf2_cu
*cu
);
1041 static void free_stack_comp_unit (void *);
1043 static hashval_t
partial_die_hash (const void *item
);
1045 static int partial_die_eq (const void *item_lhs
, const void *item_rhs
);
1047 static struct dwarf2_per_cu_data
*dwarf2_find_containing_comp_unit
1048 (unsigned long offset
, struct objfile
*objfile
);
1050 static struct dwarf2_per_cu_data
*dwarf2_find_comp_unit
1051 (unsigned long offset
, struct objfile
*objfile
);
1053 static void free_one_comp_unit (void *);
1055 static void free_cached_comp_units (void *);
1057 static void age_cached_comp_units (void);
1059 static void free_one_cached_comp_unit (void *);
1061 static void set_die_type (struct die_info
*, struct type
*,
1062 struct dwarf2_cu
*);
1064 static void reset_die_and_siblings_types (struct die_info
*,
1065 struct dwarf2_cu
*);
1067 static void create_all_comp_units (struct objfile
*);
1069 static struct dwarf2_cu
*load_full_comp_unit (struct dwarf2_per_cu_data
*,
1072 static void process_full_comp_unit (struct dwarf2_per_cu_data
*);
1074 static void dwarf2_add_dependence (struct dwarf2_cu
*,
1075 struct dwarf2_per_cu_data
*);
1077 static void dwarf2_mark (struct dwarf2_cu
*);
1079 static void dwarf2_clear_marks (struct dwarf2_per_cu_data
*);
1081 static void read_set_type (struct die_info
*, struct dwarf2_cu
*);
1084 /* Try to locate the sections we need for DWARF 2 debugging
1085 information and return true if we have enough to do something. */
1088 dwarf2_has_info (struct objfile
*objfile
)
1090 struct dwarf2_per_objfile
*data
;
1092 /* Initialize per-objfile state. */
1093 data
= obstack_alloc (&objfile
->objfile_obstack
, sizeof (*data
));
1094 memset (data
, 0, sizeof (*data
));
1095 set_objfile_data (objfile
, dwarf2_objfile_data_key
, data
);
1096 dwarf2_per_objfile
= data
;
1098 dwarf_info_section
= 0;
1099 dwarf_abbrev_section
= 0;
1100 dwarf_line_section
= 0;
1101 dwarf_str_section
= 0;
1102 dwarf_macinfo_section
= 0;
1103 dwarf_frame_section
= 0;
1104 dwarf_eh_frame_section
= 0;
1105 dwarf_ranges_section
= 0;
1106 dwarf_loc_section
= 0;
1108 bfd_map_over_sections (objfile
->obfd
, dwarf2_locate_sections
, NULL
);
1109 return (dwarf_info_section
!= NULL
&& dwarf_abbrev_section
!= NULL
);
1112 /* This function is mapped across the sections and remembers the
1113 offset and size of each of the debugging sections we are interested
1117 dwarf2_locate_sections (bfd
*abfd
, asection
*sectp
, void *ignore_ptr
)
1119 if (strcmp (sectp
->name
, INFO_SECTION
) == 0)
1121 dwarf2_per_objfile
->info_size
= bfd_get_section_size (sectp
);
1122 dwarf_info_section
= sectp
;
1124 else if (strcmp (sectp
->name
, ABBREV_SECTION
) == 0)
1126 dwarf2_per_objfile
->abbrev_size
= bfd_get_section_size (sectp
);
1127 dwarf_abbrev_section
= sectp
;
1129 else if (strcmp (sectp
->name
, LINE_SECTION
) == 0)
1131 dwarf2_per_objfile
->line_size
= bfd_get_section_size (sectp
);
1132 dwarf_line_section
= sectp
;
1134 else if (strcmp (sectp
->name
, PUBNAMES_SECTION
) == 0)
1136 dwarf2_per_objfile
->pubnames_size
= bfd_get_section_size (sectp
);
1137 dwarf_pubnames_section
= sectp
;
1139 else if (strcmp (sectp
->name
, ARANGES_SECTION
) == 0)
1141 dwarf2_per_objfile
->aranges_size
= bfd_get_section_size (sectp
);
1142 dwarf_aranges_section
= sectp
;
1144 else if (strcmp (sectp
->name
, LOC_SECTION
) == 0)
1146 dwarf2_per_objfile
->loc_size
= bfd_get_section_size (sectp
);
1147 dwarf_loc_section
= sectp
;
1149 else if (strcmp (sectp
->name
, MACINFO_SECTION
) == 0)
1151 dwarf2_per_objfile
->macinfo_size
= bfd_get_section_size (sectp
);
1152 dwarf_macinfo_section
= sectp
;
1154 else if (strcmp (sectp
->name
, STR_SECTION
) == 0)
1156 dwarf2_per_objfile
->str_size
= bfd_get_section_size (sectp
);
1157 dwarf_str_section
= sectp
;
1159 else if (strcmp (sectp
->name
, FRAME_SECTION
) == 0)
1161 dwarf2_per_objfile
->frame_size
= bfd_get_section_size (sectp
);
1162 dwarf_frame_section
= sectp
;
1164 else if (strcmp (sectp
->name
, EH_FRAME_SECTION
) == 0)
1166 flagword aflag
= bfd_get_section_flags (ignore_abfd
, sectp
);
1167 if (aflag
& SEC_HAS_CONTENTS
)
1169 dwarf2_per_objfile
->eh_frame_size
= bfd_get_section_size (sectp
);
1170 dwarf_eh_frame_section
= sectp
;
1173 else if (strcmp (sectp
->name
, RANGES_SECTION
) == 0)
1175 dwarf2_per_objfile
->ranges_size
= bfd_get_section_size (sectp
);
1176 dwarf_ranges_section
= sectp
;
1179 if ((bfd_get_section_flags (abfd
, sectp
) & SEC_LOAD
)
1180 && bfd_section_vma (abfd
, sectp
) == 0)
1181 dwarf2_per_objfile
->has_section_at_zero
= 1;
1184 /* Build a partial symbol table. */
1187 dwarf2_build_psymtabs (struct objfile
*objfile
, int mainline
)
1189 /* We definitely need the .debug_info and .debug_abbrev sections */
1191 dwarf2_per_objfile
->info_buffer
= dwarf2_read_section (objfile
, dwarf_info_section
);
1192 dwarf2_per_objfile
->abbrev_buffer
= dwarf2_read_section (objfile
, dwarf_abbrev_section
);
1194 if (dwarf_line_section
)
1195 dwarf2_per_objfile
->line_buffer
= dwarf2_read_section (objfile
, dwarf_line_section
);
1197 dwarf2_per_objfile
->line_buffer
= NULL
;
1199 if (dwarf_str_section
)
1200 dwarf2_per_objfile
->str_buffer
= dwarf2_read_section (objfile
, dwarf_str_section
);
1202 dwarf2_per_objfile
->str_buffer
= NULL
;
1204 if (dwarf_macinfo_section
)
1205 dwarf2_per_objfile
->macinfo_buffer
= dwarf2_read_section (objfile
,
1206 dwarf_macinfo_section
);
1208 dwarf2_per_objfile
->macinfo_buffer
= NULL
;
1210 if (dwarf_ranges_section
)
1211 dwarf2_per_objfile
->ranges_buffer
= dwarf2_read_section (objfile
, dwarf_ranges_section
);
1213 dwarf2_per_objfile
->ranges_buffer
= NULL
;
1215 if (dwarf_loc_section
)
1216 dwarf2_per_objfile
->loc_buffer
= dwarf2_read_section (objfile
, dwarf_loc_section
);
1218 dwarf2_per_objfile
->loc_buffer
= NULL
;
1221 || (objfile
->global_psymbols
.size
== 0
1222 && objfile
->static_psymbols
.size
== 0))
1224 init_psymbol_list (objfile
, 1024);
1228 if (dwarf_aranges_offset
&& dwarf_pubnames_offset
)
1230 /* Things are significantly easier if we have .debug_aranges and
1231 .debug_pubnames sections */
1233 dwarf2_build_psymtabs_easy (objfile
, mainline
);
1237 /* only test this case for now */
1239 /* In this case we have to work a bit harder */
1240 dwarf2_build_psymtabs_hard (objfile
, mainline
);
1245 /* Build the partial symbol table from the information in the
1246 .debug_pubnames and .debug_aranges sections. */
1249 dwarf2_build_psymtabs_easy (struct objfile
*objfile
, int mainline
)
1251 bfd
*abfd
= objfile
->obfd
;
1252 char *aranges_buffer
, *pubnames_buffer
;
1253 char *aranges_ptr
, *pubnames_ptr
;
1254 unsigned int entry_length
, version
, info_offset
, info_size
;
1256 pubnames_buffer
= dwarf2_read_section (objfile
,
1257 dwarf_pubnames_section
);
1258 pubnames_ptr
= pubnames_buffer
;
1259 while ((pubnames_ptr
- pubnames_buffer
) < dwarf2_per_objfile
->pubnames_size
)
1261 struct comp_unit_head cu_header
;
1262 unsigned int bytes_read
;
1264 entry_length
= read_initial_length (abfd
, pubnames_ptr
, &cu_header
,
1266 pubnames_ptr
+= bytes_read
;
1267 version
= read_1_byte (abfd
, pubnames_ptr
);
1269 info_offset
= read_4_bytes (abfd
, pubnames_ptr
);
1271 info_size
= read_4_bytes (abfd
, pubnames_ptr
);
1275 aranges_buffer
= dwarf2_read_section (objfile
,
1276 dwarf_aranges_section
);
1281 /* Read in the comp unit header information from the debug_info at
1285 read_comp_unit_head (struct comp_unit_head
*cu_header
,
1286 gdb_byte
*info_ptr
, bfd
*abfd
)
1289 unsigned int bytes_read
;
1290 cu_header
->length
= read_initial_length (abfd
, info_ptr
, cu_header
,
1292 info_ptr
+= bytes_read
;
1293 cu_header
->version
= read_2_bytes (abfd
, info_ptr
);
1295 cu_header
->abbrev_offset
= read_offset (abfd
, info_ptr
, cu_header
,
1297 info_ptr
+= bytes_read
;
1298 cu_header
->addr_size
= read_1_byte (abfd
, info_ptr
);
1300 signed_addr
= bfd_get_sign_extend_vma (abfd
);
1301 if (signed_addr
< 0)
1302 internal_error (__FILE__
, __LINE__
,
1303 _("read_comp_unit_head: dwarf from non elf file"));
1304 cu_header
->signed_addr_p
= signed_addr
;
1309 partial_read_comp_unit_head (struct comp_unit_head
*header
, gdb_byte
*info_ptr
,
1312 gdb_byte
*beg_of_comp_unit
= info_ptr
;
1314 info_ptr
= read_comp_unit_head (header
, info_ptr
, abfd
);
1316 if (header
->version
!= 2 && header
->version
!= 3)
1317 error (_("Dwarf Error: wrong version in compilation unit header "
1318 "(is %d, should be %d) [in module %s]"), header
->version
,
1319 2, bfd_get_filename (abfd
));
1321 if (header
->abbrev_offset
>= dwarf2_per_objfile
->abbrev_size
)
1322 error (_("Dwarf Error: bad offset (0x%lx) in compilation unit header "
1323 "(offset 0x%lx + 6) [in module %s]"),
1324 (long) header
->abbrev_offset
,
1325 (long) (beg_of_comp_unit
- dwarf2_per_objfile
->info_buffer
),
1326 bfd_get_filename (abfd
));
1328 if (beg_of_comp_unit
+ header
->length
+ header
->initial_length_size
1329 > dwarf2_per_objfile
->info_buffer
+ dwarf2_per_objfile
->info_size
)
1330 error (_("Dwarf Error: bad length (0x%lx) in compilation unit header "
1331 "(offset 0x%lx + 0) [in module %s]"),
1332 (long) header
->length
,
1333 (long) (beg_of_comp_unit
- dwarf2_per_objfile
->info_buffer
),
1334 bfd_get_filename (abfd
));
1339 /* Allocate a new partial symtab for file named NAME and mark this new
1340 partial symtab as being an include of PST. */
1343 dwarf2_create_include_psymtab (char *name
, struct partial_symtab
*pst
,
1344 struct objfile
*objfile
)
1346 struct partial_symtab
*subpst
= allocate_psymtab (name
, objfile
);
1348 subpst
->section_offsets
= pst
->section_offsets
;
1349 subpst
->textlow
= 0;
1350 subpst
->texthigh
= 0;
1352 subpst
->dependencies
= (struct partial_symtab
**)
1353 obstack_alloc (&objfile
->objfile_obstack
,
1354 sizeof (struct partial_symtab
*));
1355 subpst
->dependencies
[0] = pst
;
1356 subpst
->number_of_dependencies
= 1;
1358 subpst
->globals_offset
= 0;
1359 subpst
->n_global_syms
= 0;
1360 subpst
->statics_offset
= 0;
1361 subpst
->n_static_syms
= 0;
1362 subpst
->symtab
= NULL
;
1363 subpst
->read_symtab
= pst
->read_symtab
;
1366 /* No private part is necessary for include psymtabs. This property
1367 can be used to differentiate between such include psymtabs and
1368 the regular ones. */
1369 subpst
->read_symtab_private
= NULL
;
1372 /* Read the Line Number Program data and extract the list of files
1373 included by the source file represented by PST. Build an include
1374 partial symtab for each of these included files.
1376 This procedure assumes that there *is* a Line Number Program in
1377 the given CU. Callers should check that PDI->HAS_STMT_LIST is set
1378 before calling this procedure. */
1381 dwarf2_build_include_psymtabs (struct dwarf2_cu
*cu
,
1382 struct partial_die_info
*pdi
,
1383 struct partial_symtab
*pst
)
1385 struct objfile
*objfile
= cu
->objfile
;
1386 bfd
*abfd
= objfile
->obfd
;
1387 struct line_header
*lh
;
1389 lh
= dwarf_decode_line_header (pdi
->line_offset
, abfd
, cu
);
1391 return; /* No linetable, so no includes. */
1393 dwarf_decode_lines (lh
, NULL
, abfd
, cu
, pst
);
1395 free_line_header (lh
);
1399 /* Build the partial symbol table by doing a quick pass through the
1400 .debug_info and .debug_abbrev sections. */
1403 dwarf2_build_psymtabs_hard (struct objfile
*objfile
, int mainline
)
1405 /* Instead of reading this into a big buffer, we should probably use
1406 mmap() on architectures that support it. (FIXME) */
1407 bfd
*abfd
= objfile
->obfd
;
1409 gdb_byte
*beg_of_comp_unit
;
1410 struct partial_die_info comp_unit_die
;
1411 struct partial_symtab
*pst
;
1412 struct cleanup
*back_to
;
1413 CORE_ADDR lowpc
, highpc
, baseaddr
;
1415 info_ptr
= dwarf2_per_objfile
->info_buffer
;
1417 /* Any cached compilation units will be linked by the per-objfile
1418 read_in_chain. Make sure to free them when we're done. */
1419 back_to
= make_cleanup (free_cached_comp_units
, NULL
);
1421 create_all_comp_units (objfile
);
1423 /* Since the objects we're extracting from .debug_info vary in
1424 length, only the individual functions to extract them (like
1425 read_comp_unit_head and load_partial_die) can really know whether
1426 the buffer is large enough to hold another complete object.
1428 At the moment, they don't actually check that. If .debug_info
1429 holds just one extra byte after the last compilation unit's dies,
1430 then read_comp_unit_head will happily read off the end of the
1431 buffer. read_partial_die is similarly casual. Those functions
1434 For this loop condition, simply checking whether there's any data
1435 left at all should be sufficient. */
1436 while (info_ptr
< (dwarf2_per_objfile
->info_buffer
1437 + dwarf2_per_objfile
->info_size
))
1439 struct cleanup
*back_to_inner
;
1440 struct dwarf2_cu cu
;
1441 struct abbrev_info
*abbrev
;
1442 unsigned int bytes_read
;
1443 struct dwarf2_per_cu_data
*this_cu
;
1445 beg_of_comp_unit
= info_ptr
;
1447 memset (&cu
, 0, sizeof (cu
));
1449 obstack_init (&cu
.comp_unit_obstack
);
1451 back_to_inner
= make_cleanup (free_stack_comp_unit
, &cu
);
1453 cu
.objfile
= objfile
;
1454 info_ptr
= partial_read_comp_unit_head (&cu
.header
, info_ptr
, abfd
);
1456 /* Complete the cu_header */
1457 cu
.header
.offset
= beg_of_comp_unit
- dwarf2_per_objfile
->info_buffer
;
1458 cu
.header
.first_die_ptr
= info_ptr
;
1459 cu
.header
.cu_head_ptr
= beg_of_comp_unit
;
1461 cu
.list_in_scope
= &file_symbols
;
1463 /* Read the abbrevs for this compilation unit into a table */
1464 dwarf2_read_abbrevs (abfd
, &cu
);
1465 make_cleanup (dwarf2_free_abbrev_table
, &cu
);
1467 this_cu
= dwarf2_find_comp_unit (cu
.header
.offset
, objfile
);
1469 /* Read the compilation unit die */
1470 abbrev
= peek_die_abbrev (info_ptr
, &bytes_read
, &cu
);
1471 info_ptr
= read_partial_die (&comp_unit_die
, abbrev
, bytes_read
,
1472 abfd
, info_ptr
, &cu
);
1474 if (comp_unit_die
.tag
== DW_TAG_partial_unit
)
1476 info_ptr
= (beg_of_comp_unit
+ cu
.header
.length
1477 + cu
.header
.initial_length_size
);
1478 do_cleanups (back_to_inner
);
1482 /* Set the language we're debugging */
1483 set_cu_language (comp_unit_die
.language
, &cu
);
1485 /* Allocate a new partial symbol table structure */
1486 pst
= start_psymtab_common (objfile
, objfile
->section_offsets
,
1487 comp_unit_die
.name
? comp_unit_die
.name
: "",
1488 comp_unit_die
.lowpc
,
1489 objfile
->global_psymbols
.next
,
1490 objfile
->static_psymbols
.next
);
1492 if (comp_unit_die
.dirname
)
1493 pst
->dirname
= xstrdup (comp_unit_die
.dirname
);
1495 pst
->read_symtab_private
= (char *) this_cu
;
1497 baseaddr
= ANOFFSET (objfile
->section_offsets
, SECT_OFF_TEXT (objfile
));
1499 /* Store the function that reads in the rest of the symbol table */
1500 pst
->read_symtab
= dwarf2_psymtab_to_symtab
;
1502 /* If this compilation unit was already read in, free the
1503 cached copy in order to read it in again. This is
1504 necessary because we skipped some symbols when we first
1505 read in the compilation unit (see load_partial_dies).
1506 This problem could be avoided, but the benefit is
1508 if (this_cu
->cu
!= NULL
)
1509 free_one_cached_comp_unit (this_cu
->cu
);
1511 cu
.per_cu
= this_cu
;
1513 /* Note that this is a pointer to our stack frame, being
1514 added to a global data structure. It will be cleaned up
1515 in free_stack_comp_unit when we finish with this
1516 compilation unit. */
1519 this_cu
->psymtab
= pst
;
1521 /* Check if comp unit has_children.
1522 If so, read the rest of the partial symbols from this comp unit.
1523 If not, there's no more debug_info for this comp unit. */
1524 if (comp_unit_die
.has_children
)
1526 struct partial_die_info
*first_die
;
1528 lowpc
= ((CORE_ADDR
) -1);
1529 highpc
= ((CORE_ADDR
) 0);
1531 first_die
= load_partial_dies (abfd
, info_ptr
, 1, &cu
);
1533 scan_partial_symbols (first_die
, &lowpc
, &highpc
, &cu
);
1535 /* If we didn't find a lowpc, set it to highpc to avoid
1536 complaints from `maint check'. */
1537 if (lowpc
== ((CORE_ADDR
) -1))
1540 /* If the compilation unit didn't have an explicit address range,
1541 then use the information extracted from its child dies. */
1542 if (! comp_unit_die
.has_pc_info
)
1544 comp_unit_die
.lowpc
= lowpc
;
1545 comp_unit_die
.highpc
= highpc
;
1548 pst
->textlow
= comp_unit_die
.lowpc
+ baseaddr
;
1549 pst
->texthigh
= comp_unit_die
.highpc
+ baseaddr
;
1551 pst
->n_global_syms
= objfile
->global_psymbols
.next
-
1552 (objfile
->global_psymbols
.list
+ pst
->globals_offset
);
1553 pst
->n_static_syms
= objfile
->static_psymbols
.next
-
1554 (objfile
->static_psymbols
.list
+ pst
->statics_offset
);
1555 sort_pst_symbols (pst
);
1557 /* If there is already a psymtab or symtab for a file of this
1558 name, remove it. (If there is a symtab, more drastic things
1559 also happen.) This happens in VxWorks. */
1560 free_named_symtabs (pst
->filename
);
1562 info_ptr
= beg_of_comp_unit
+ cu
.header
.length
1563 + cu
.header
.initial_length_size
;
1565 if (comp_unit_die
.has_stmt_list
)
1567 /* Get the list of files included in the current compilation unit,
1568 and build a psymtab for each of them. */
1569 dwarf2_build_include_psymtabs (&cu
, &comp_unit_die
, pst
);
1572 do_cleanups (back_to_inner
);
1574 do_cleanups (back_to
);
1577 /* Load the DIEs for a secondary CU into memory. */
1580 load_comp_unit (struct dwarf2_per_cu_data
*this_cu
, struct objfile
*objfile
)
1582 bfd
*abfd
= objfile
->obfd
;
1583 gdb_byte
*info_ptr
, *beg_of_comp_unit
;
1584 struct partial_die_info comp_unit_die
;
1585 struct dwarf2_cu
*cu
;
1586 struct abbrev_info
*abbrev
;
1587 unsigned int bytes_read
;
1588 struct cleanup
*back_to
;
1590 info_ptr
= dwarf2_per_objfile
->info_buffer
+ this_cu
->offset
;
1591 beg_of_comp_unit
= info_ptr
;
1593 cu
= xmalloc (sizeof (struct dwarf2_cu
));
1594 memset (cu
, 0, sizeof (struct dwarf2_cu
));
1596 obstack_init (&cu
->comp_unit_obstack
);
1598 cu
->objfile
= objfile
;
1599 info_ptr
= partial_read_comp_unit_head (&cu
->header
, info_ptr
, abfd
);
1601 /* Complete the cu_header. */
1602 cu
->header
.offset
= beg_of_comp_unit
- dwarf2_per_objfile
->info_buffer
;
1603 cu
->header
.first_die_ptr
= info_ptr
;
1604 cu
->header
.cu_head_ptr
= beg_of_comp_unit
;
1606 /* Read the abbrevs for this compilation unit into a table. */
1607 dwarf2_read_abbrevs (abfd
, cu
);
1608 back_to
= make_cleanup (dwarf2_free_abbrev_table
, cu
);
1610 /* Read the compilation unit die. */
1611 abbrev
= peek_die_abbrev (info_ptr
, &bytes_read
, cu
);
1612 info_ptr
= read_partial_die (&comp_unit_die
, abbrev
, bytes_read
,
1613 abfd
, info_ptr
, cu
);
1615 /* Set the language we're debugging. */
1616 set_cu_language (comp_unit_die
.language
, cu
);
1618 /* Link this compilation unit into the compilation unit tree. */
1620 cu
->per_cu
= this_cu
;
1622 /* Check if comp unit has_children.
1623 If so, read the rest of the partial symbols from this comp unit.
1624 If not, there's no more debug_info for this comp unit. */
1625 if (comp_unit_die
.has_children
)
1626 load_partial_dies (abfd
, info_ptr
, 0, cu
);
1628 do_cleanups (back_to
);
1631 /* Create a list of all compilation units in OBJFILE. We do this only
1632 if an inter-comp-unit reference is found; presumably if there is one,
1633 there will be many, and one will occur early in the .debug_info section.
1634 So there's no point in building this list incrementally. */
1637 create_all_comp_units (struct objfile
*objfile
)
1641 struct dwarf2_per_cu_data
**all_comp_units
;
1642 gdb_byte
*info_ptr
= dwarf2_per_objfile
->info_buffer
;
1646 all_comp_units
= xmalloc (n_allocated
1647 * sizeof (struct dwarf2_per_cu_data
*));
1649 while (info_ptr
< dwarf2_per_objfile
->info_buffer
+ dwarf2_per_objfile
->info_size
)
1651 struct comp_unit_head cu_header
;
1652 gdb_byte
*beg_of_comp_unit
;
1653 struct dwarf2_per_cu_data
*this_cu
;
1654 unsigned long offset
;
1655 unsigned int bytes_read
;
1657 offset
= info_ptr
- dwarf2_per_objfile
->info_buffer
;
1659 /* Read just enough information to find out where the next
1660 compilation unit is. */
1661 cu_header
.initial_length_size
= 0;
1662 cu_header
.length
= read_initial_length (objfile
->obfd
, info_ptr
,
1663 &cu_header
, &bytes_read
);
1665 /* Save the compilation unit for later lookup. */
1666 this_cu
= obstack_alloc (&objfile
->objfile_obstack
,
1667 sizeof (struct dwarf2_per_cu_data
));
1668 memset (this_cu
, 0, sizeof (*this_cu
));
1669 this_cu
->offset
= offset
;
1670 this_cu
->length
= cu_header
.length
+ cu_header
.initial_length_size
;
1672 if (n_comp_units
== n_allocated
)
1675 all_comp_units
= xrealloc (all_comp_units
,
1677 * sizeof (struct dwarf2_per_cu_data
*));
1679 all_comp_units
[n_comp_units
++] = this_cu
;
1681 info_ptr
= info_ptr
+ this_cu
->length
;
1684 dwarf2_per_objfile
->all_comp_units
1685 = obstack_alloc (&objfile
->objfile_obstack
,
1686 n_comp_units
* sizeof (struct dwarf2_per_cu_data
*));
1687 memcpy (dwarf2_per_objfile
->all_comp_units
, all_comp_units
,
1688 n_comp_units
* sizeof (struct dwarf2_per_cu_data
*));
1689 xfree (all_comp_units
);
1690 dwarf2_per_objfile
->n_comp_units
= n_comp_units
;
1693 /* Process all loaded DIEs for compilation unit CU, starting at FIRST_DIE.
1694 Also set *LOWPC and *HIGHPC to the lowest and highest PC values found
1698 scan_partial_symbols (struct partial_die_info
*first_die
, CORE_ADDR
*lowpc
,
1699 CORE_ADDR
*highpc
, struct dwarf2_cu
*cu
)
1701 struct objfile
*objfile
= cu
->objfile
;
1702 bfd
*abfd
= objfile
->obfd
;
1703 struct partial_die_info
*pdi
;
1705 /* Now, march along the PDI's, descending into ones which have
1706 interesting children but skipping the children of the other ones,
1707 until we reach the end of the compilation unit. */
1713 fixup_partial_die (pdi
, cu
);
1715 /* Anonymous namespaces have no name but have interesting
1716 children, so we need to look at them. Ditto for anonymous
1719 if (pdi
->name
!= NULL
|| pdi
->tag
== DW_TAG_namespace
1720 || pdi
->tag
== DW_TAG_enumeration_type
)
1724 case DW_TAG_subprogram
:
1725 if (pdi
->has_pc_info
)
1727 if (pdi
->lowpc
< *lowpc
)
1729 *lowpc
= pdi
->lowpc
;
1731 if (pdi
->highpc
> *highpc
)
1733 *highpc
= pdi
->highpc
;
1735 if (!pdi
->is_declaration
)
1737 add_partial_symbol (pdi
, cu
);
1741 case DW_TAG_variable
:
1742 case DW_TAG_typedef
:
1743 case DW_TAG_union_type
:
1744 if (!pdi
->is_declaration
)
1746 add_partial_symbol (pdi
, cu
);
1749 case DW_TAG_class_type
:
1750 case DW_TAG_interface_type
:
1751 case DW_TAG_structure_type
:
1752 if (!pdi
->is_declaration
)
1754 add_partial_symbol (pdi
, cu
);
1757 case DW_TAG_enumeration_type
:
1758 if (!pdi
->is_declaration
)
1759 add_partial_enumeration (pdi
, cu
);
1761 case DW_TAG_base_type
:
1762 case DW_TAG_subrange_type
:
1763 /* File scope base type definitions are added to the partial
1765 add_partial_symbol (pdi
, cu
);
1767 case DW_TAG_namespace
:
1768 add_partial_namespace (pdi
, lowpc
, highpc
, cu
);
1775 /* If the die has a sibling, skip to the sibling. */
1777 pdi
= pdi
->die_sibling
;
1781 /* Functions used to compute the fully scoped name of a partial DIE.
1783 Normally, this is simple. For C++, the parent DIE's fully scoped
1784 name is concatenated with "::" and the partial DIE's name. For
1785 Java, the same thing occurs except that "." is used instead of "::".
1786 Enumerators are an exception; they use the scope of their parent
1787 enumeration type, i.e. the name of the enumeration type is not
1788 prepended to the enumerator.
1790 There are two complexities. One is DW_AT_specification; in this
1791 case "parent" means the parent of the target of the specification,
1792 instead of the direct parent of the DIE. The other is compilers
1793 which do not emit DW_TAG_namespace; in this case we try to guess
1794 the fully qualified name of structure types from their members'
1795 linkage names. This must be done using the DIE's children rather
1796 than the children of any DW_AT_specification target. We only need
1797 to do this for structures at the top level, i.e. if the target of
1798 any DW_AT_specification (if any; otherwise the DIE itself) does not
1801 /* Compute the scope prefix associated with PDI's parent, in
1802 compilation unit CU. The result will be allocated on CU's
1803 comp_unit_obstack, or a copy of the already allocated PDI->NAME
1804 field. NULL is returned if no prefix is necessary. */
1806 partial_die_parent_scope (struct partial_die_info
*pdi
,
1807 struct dwarf2_cu
*cu
)
1809 char *grandparent_scope
;
1810 struct partial_die_info
*parent
, *real_pdi
;
1812 /* We need to look at our parent DIE; if we have a DW_AT_specification,
1813 then this means the parent of the specification DIE. */
1816 while (real_pdi
->has_specification
)
1817 real_pdi
= find_partial_die (real_pdi
->spec_offset
, cu
);
1819 parent
= real_pdi
->die_parent
;
1823 if (parent
->scope_set
)
1824 return parent
->scope
;
1826 fixup_partial_die (parent
, cu
);
1828 grandparent_scope
= partial_die_parent_scope (parent
, cu
);
1830 if (parent
->tag
== DW_TAG_namespace
1831 || parent
->tag
== DW_TAG_structure_type
1832 || parent
->tag
== DW_TAG_class_type
1833 || parent
->tag
== DW_TAG_interface_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
;
1880 char *actual_name
= NULL
;
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
));
1888 if (pdi_needs_namespace (pdi
->tag
))
1890 actual_name
= partial_die_full_name (pdi
, cu
);
1892 built_actual_name
= 1;
1895 if (actual_name
== NULL
)
1896 actual_name
= pdi
->name
;
1900 case DW_TAG_subprogram
:
1901 if (pdi
->is_external
|| cu
->language
== language_ada
)
1903 /* brobecker/2007-12-26: Normally, only "external" DIEs are part
1904 of the global scope. But in Ada, we want to be able to access
1905 nested procedures globally. So all Ada subprograms are stored
1906 in the global scope. */
1907 /*prim_record_minimal_symbol (actual_name, pdi->lowpc + baseaddr,
1908 mst_text, objfile); */
1909 psym
= add_psymbol_to_list (actual_name
, strlen (actual_name
),
1910 VAR_DOMAIN
, LOC_BLOCK
,
1911 &objfile
->global_psymbols
,
1912 0, pdi
->lowpc
+ baseaddr
,
1913 cu
->language
, objfile
);
1917 /*prim_record_minimal_symbol (actual_name, pdi->lowpc + baseaddr,
1918 mst_file_text, objfile); */
1919 psym
= add_psymbol_to_list (actual_name
, strlen (actual_name
),
1920 VAR_DOMAIN
, LOC_BLOCK
,
1921 &objfile
->static_psymbols
,
1922 0, pdi
->lowpc
+ baseaddr
,
1923 cu
->language
, objfile
);
1926 case DW_TAG_variable
:
1927 if (pdi
->is_external
)
1930 Don't enter into the minimal symbol tables as there is
1931 a minimal symbol table entry from the ELF symbols already.
1932 Enter into partial symbol table if it has a location
1933 descriptor or a type.
1934 If the location descriptor is missing, new_symbol will create
1935 a LOC_UNRESOLVED symbol, the address of the variable will then
1936 be determined from the minimal symbol table whenever the variable
1938 The address for the partial symbol table entry is not
1939 used by GDB, but it comes in handy for debugging partial symbol
1943 addr
= decode_locdesc (pdi
->locdesc
, cu
);
1944 if (pdi
->locdesc
|| pdi
->has_type
)
1945 psym
= add_psymbol_to_list (actual_name
, strlen (actual_name
),
1946 VAR_DOMAIN
, LOC_STATIC
,
1947 &objfile
->global_psymbols
,
1949 cu
->language
, objfile
);
1953 /* Static Variable. Skip symbols without location descriptors. */
1954 if (pdi
->locdesc
== NULL
)
1956 if (built_actual_name
)
1957 xfree (actual_name
);
1960 addr
= decode_locdesc (pdi
->locdesc
, cu
);
1961 /*prim_record_minimal_symbol (actual_name, addr + baseaddr,
1962 mst_file_data, objfile); */
1963 psym
= add_psymbol_to_list (actual_name
, strlen (actual_name
),
1964 VAR_DOMAIN
, LOC_STATIC
,
1965 &objfile
->static_psymbols
,
1967 cu
->language
, objfile
);
1970 case DW_TAG_typedef
:
1971 case DW_TAG_base_type
:
1972 case DW_TAG_subrange_type
:
1973 add_psymbol_to_list (actual_name
, strlen (actual_name
),
1974 VAR_DOMAIN
, LOC_TYPEDEF
,
1975 &objfile
->static_psymbols
,
1976 0, (CORE_ADDR
) 0, cu
->language
, objfile
);
1978 case DW_TAG_namespace
:
1979 add_psymbol_to_list (actual_name
, strlen (actual_name
),
1980 VAR_DOMAIN
, LOC_TYPEDEF
,
1981 &objfile
->global_psymbols
,
1982 0, (CORE_ADDR
) 0, cu
->language
, objfile
);
1984 case DW_TAG_class_type
:
1985 case DW_TAG_interface_type
:
1986 case DW_TAG_structure_type
:
1987 case DW_TAG_union_type
:
1988 case DW_TAG_enumeration_type
:
1989 /* Skip external references. The DWARF standard says in the section
1990 about "Structure, Union, and Class Type Entries": "An incomplete
1991 structure, union or class type is represented by a structure,
1992 union or class entry that does not have a byte size attribute
1993 and that has a DW_AT_declaration attribute." */
1994 if (!pdi
->has_byte_size
&& pdi
->is_declaration
)
1996 if (built_actual_name
)
1997 xfree (actual_name
);
2001 /* NOTE: carlton/2003-10-07: See comment in new_symbol about
2002 static vs. global. */
2003 add_psymbol_to_list (actual_name
, strlen (actual_name
),
2004 STRUCT_DOMAIN
, LOC_TYPEDEF
,
2005 (cu
->language
== language_cplus
2006 || cu
->language
== language_java
)
2007 ? &objfile
->global_psymbols
2008 : &objfile
->static_psymbols
,
2009 0, (CORE_ADDR
) 0, cu
->language
, objfile
);
2011 if (cu
->language
== language_cplus
2012 || cu
->language
== language_java
2013 || cu
->language
== language_ada
)
2015 /* For C++ and Java, these implicitly act as typedefs as well. */
2016 add_psymbol_to_list (actual_name
, strlen (actual_name
),
2017 VAR_DOMAIN
, LOC_TYPEDEF
,
2018 &objfile
->global_psymbols
,
2019 0, (CORE_ADDR
) 0, cu
->language
, objfile
);
2022 case DW_TAG_enumerator
:
2023 add_psymbol_to_list (actual_name
, strlen (actual_name
),
2024 VAR_DOMAIN
, LOC_CONST
,
2025 (cu
->language
== language_cplus
2026 || cu
->language
== language_java
)
2027 ? &objfile
->global_psymbols
2028 : &objfile
->static_psymbols
,
2029 0, (CORE_ADDR
) 0, cu
->language
, objfile
);
2035 /* Check to see if we should scan the name for possible namespace
2036 info. Only do this if this is C++, if we don't have namespace
2037 debugging info in the file, if the psym is of an appropriate type
2038 (otherwise we'll have psym == NULL), and if we actually had a
2039 mangled name to begin with. */
2041 /* FIXME drow/2004-02-22: Why don't we do this for classes, i.e. the
2042 cases which do not set PSYM above? */
2044 if (cu
->language
== language_cplus
2045 && cu
->has_namespace_info
== 0
2047 && SYMBOL_CPLUS_DEMANGLED_NAME (psym
) != NULL
)
2048 cp_check_possible_namespace_symbols (SYMBOL_CPLUS_DEMANGLED_NAME (psym
),
2051 if (built_actual_name
)
2052 xfree (actual_name
);
2055 /* Determine whether a die of type TAG living in a C++ class or
2056 namespace needs to have the name of the scope prepended to the
2057 name listed in the die. */
2060 pdi_needs_namespace (enum dwarf_tag tag
)
2064 case DW_TAG_namespace
:
2065 case DW_TAG_typedef
:
2066 case DW_TAG_class_type
:
2067 case DW_TAG_interface_type
:
2068 case DW_TAG_structure_type
:
2069 case DW_TAG_union_type
:
2070 case DW_TAG_enumeration_type
:
2071 case DW_TAG_enumerator
:
2078 /* Read a partial die corresponding to a namespace; also, add a symbol
2079 corresponding to that namespace to the symbol table. NAMESPACE is
2080 the name of the enclosing namespace. */
2083 add_partial_namespace (struct partial_die_info
*pdi
,
2084 CORE_ADDR
*lowpc
, CORE_ADDR
*highpc
,
2085 struct dwarf2_cu
*cu
)
2087 struct objfile
*objfile
= cu
->objfile
;
2089 /* Add a symbol for the namespace. */
2091 add_partial_symbol (pdi
, cu
);
2093 /* Now scan partial symbols in that namespace. */
2095 if (pdi
->has_children
)
2096 scan_partial_symbols (pdi
->die_child
, lowpc
, highpc
, cu
);
2099 /* See if we can figure out if the class lives in a namespace. We do
2100 this by looking for a member function; its demangled name will
2101 contain namespace info, if there is any. */
2104 guess_structure_name (struct partial_die_info
*struct_pdi
,
2105 struct dwarf2_cu
*cu
)
2107 if ((cu
->language
== language_cplus
2108 || cu
->language
== language_java
)
2109 && cu
->has_namespace_info
== 0
2110 && struct_pdi
->has_children
)
2112 /* NOTE: carlton/2003-10-07: Getting the info this way changes
2113 what template types look like, because the demangler
2114 frequently doesn't give the same name as the debug info. We
2115 could fix this by only using the demangled name to get the
2116 prefix (but see comment in read_structure_type). */
2118 struct partial_die_info
*child_pdi
= struct_pdi
->die_child
;
2119 struct partial_die_info
*real_pdi
;
2121 /* If this DIE (this DIE's specification, if any) has a parent, then
2122 we should not do this. We'll prepend the parent's fully qualified
2123 name when we create the partial symbol. */
2125 real_pdi
= struct_pdi
;
2126 while (real_pdi
->has_specification
)
2127 real_pdi
= find_partial_die (real_pdi
->spec_offset
, cu
);
2129 if (real_pdi
->die_parent
!= NULL
)
2132 while (child_pdi
!= NULL
)
2134 if (child_pdi
->tag
== DW_TAG_subprogram
)
2136 char *actual_class_name
2137 = language_class_name_from_physname (cu
->language_defn
,
2139 if (actual_class_name
!= NULL
)
2142 = obsavestring (actual_class_name
,
2143 strlen (actual_class_name
),
2144 &cu
->comp_unit_obstack
);
2145 xfree (actual_class_name
);
2150 child_pdi
= child_pdi
->die_sibling
;
2155 /* Read a partial die corresponding to an enumeration type. */
2158 add_partial_enumeration (struct partial_die_info
*enum_pdi
,
2159 struct dwarf2_cu
*cu
)
2161 struct objfile
*objfile
= cu
->objfile
;
2162 bfd
*abfd
= objfile
->obfd
;
2163 struct partial_die_info
*pdi
;
2165 if (enum_pdi
->name
!= NULL
)
2166 add_partial_symbol (enum_pdi
, cu
);
2168 pdi
= enum_pdi
->die_child
;
2171 if (pdi
->tag
!= DW_TAG_enumerator
|| pdi
->name
== NULL
)
2172 complaint (&symfile_complaints
, _("malformed enumerator DIE ignored"));
2174 add_partial_symbol (pdi
, cu
);
2175 pdi
= pdi
->die_sibling
;
2179 /* Read the initial uleb128 in the die at INFO_PTR in compilation unit CU.
2180 Return the corresponding abbrev, or NULL if the number is zero (indicating
2181 an empty DIE). In either case *BYTES_READ will be set to the length of
2182 the initial number. */
2184 static struct abbrev_info
*
2185 peek_die_abbrev (gdb_byte
*info_ptr
, unsigned int *bytes_read
,
2186 struct dwarf2_cu
*cu
)
2188 bfd
*abfd
= cu
->objfile
->obfd
;
2189 unsigned int abbrev_number
;
2190 struct abbrev_info
*abbrev
;
2192 abbrev_number
= read_unsigned_leb128 (abfd
, info_ptr
, bytes_read
);
2194 if (abbrev_number
== 0)
2197 abbrev
= dwarf2_lookup_abbrev (abbrev_number
, cu
);
2200 error (_("Dwarf Error: Could not find abbrev number %d [in module %s]"), abbrev_number
,
2201 bfd_get_filename (abfd
));
2207 /* Scan the debug information for CU starting at INFO_PTR. Returns a
2208 pointer to the end of a series of DIEs, terminated by an empty
2209 DIE. Any children of the skipped DIEs will also be skipped. */
2212 skip_children (gdb_byte
*info_ptr
, struct dwarf2_cu
*cu
)
2214 struct abbrev_info
*abbrev
;
2215 unsigned int bytes_read
;
2219 abbrev
= peek_die_abbrev (info_ptr
, &bytes_read
, cu
);
2221 return info_ptr
+ bytes_read
;
2223 info_ptr
= skip_one_die (info_ptr
+ bytes_read
, abbrev
, cu
);
2227 /* Scan the debug information for CU starting at INFO_PTR. INFO_PTR
2228 should point just after the initial uleb128 of a DIE, and the
2229 abbrev corresponding to that skipped uleb128 should be passed in
2230 ABBREV. Returns a pointer to this DIE's sibling, skipping any
2234 skip_one_die (gdb_byte
*info_ptr
, struct abbrev_info
*abbrev
,
2235 struct dwarf2_cu
*cu
)
2237 unsigned int bytes_read
;
2238 struct attribute attr
;
2239 bfd
*abfd
= cu
->objfile
->obfd
;
2240 unsigned int form
, i
;
2242 for (i
= 0; i
< abbrev
->num_attrs
; i
++)
2244 /* The only abbrev we care about is DW_AT_sibling. */
2245 if (abbrev
->attrs
[i
].name
== DW_AT_sibling
)
2247 read_attribute (&attr
, &abbrev
->attrs
[i
],
2248 abfd
, info_ptr
, cu
);
2249 if (attr
.form
== DW_FORM_ref_addr
)
2250 complaint (&symfile_complaints
, _("ignoring absolute DW_AT_sibling"));
2252 return dwarf2_per_objfile
->info_buffer
2253 + dwarf2_get_ref_die_offset (&attr
, cu
);
2256 /* If it isn't DW_AT_sibling, skip this attribute. */
2257 form
= abbrev
->attrs
[i
].form
;
2262 case DW_FORM_ref_addr
:
2263 info_ptr
+= cu
->header
.addr_size
;
2282 case DW_FORM_string
:
2283 read_string (abfd
, info_ptr
, &bytes_read
);
2284 info_ptr
+= bytes_read
;
2287 info_ptr
+= cu
->header
.offset_size
;
2290 info_ptr
+= read_unsigned_leb128 (abfd
, info_ptr
, &bytes_read
);
2291 info_ptr
+= bytes_read
;
2293 case DW_FORM_block1
:
2294 info_ptr
+= 1 + read_1_byte (abfd
, info_ptr
);
2296 case DW_FORM_block2
:
2297 info_ptr
+= 2 + read_2_bytes (abfd
, info_ptr
);
2299 case DW_FORM_block4
:
2300 info_ptr
+= 4 + read_4_bytes (abfd
, info_ptr
);
2304 case DW_FORM_ref_udata
:
2305 info_ptr
= skip_leb128 (abfd
, info_ptr
);
2307 case DW_FORM_indirect
:
2308 form
= read_unsigned_leb128 (abfd
, info_ptr
, &bytes_read
);
2309 info_ptr
+= bytes_read
;
2310 /* We need to continue parsing from here, so just go back to
2312 goto skip_attribute
;
2315 error (_("Dwarf Error: Cannot handle %s in DWARF reader [in module %s]"),
2316 dwarf_form_name (form
),
2317 bfd_get_filename (abfd
));
2321 if (abbrev
->has_children
)
2322 return skip_children (info_ptr
, cu
);
2327 /* Locate ORIG_PDI's sibling; INFO_PTR should point to the start of
2328 the next DIE after ORIG_PDI. */
2331 locate_pdi_sibling (struct partial_die_info
*orig_pdi
, gdb_byte
*info_ptr
,
2332 bfd
*abfd
, struct dwarf2_cu
*cu
)
2334 /* Do we know the sibling already? */
2336 if (orig_pdi
->sibling
)
2337 return orig_pdi
->sibling
;
2339 /* Are there any children to deal with? */
2341 if (!orig_pdi
->has_children
)
2344 /* Skip the children the long way. */
2346 return skip_children (info_ptr
, cu
);
2349 /* Expand this partial symbol table into a full symbol table. */
2352 dwarf2_psymtab_to_symtab (struct partial_symtab
*pst
)
2354 /* FIXME: This is barely more than a stub. */
2359 warning (_("bug: psymtab for %s is already read in."), pst
->filename
);
2365 printf_filtered (_("Reading in symbols for %s..."), pst
->filename
);
2366 gdb_flush (gdb_stdout
);
2369 /* Restore our global data. */
2370 dwarf2_per_objfile
= objfile_data (pst
->objfile
,
2371 dwarf2_objfile_data_key
);
2373 psymtab_to_symtab_1 (pst
);
2375 /* Finish up the debug error message. */
2377 printf_filtered (_("done.\n"));
2382 /* Add PER_CU to the queue. */
2385 queue_comp_unit (struct dwarf2_per_cu_data
*per_cu
)
2387 struct dwarf2_queue_item
*item
;
2390 item
= xmalloc (sizeof (*item
));
2391 item
->per_cu
= per_cu
;
2394 if (dwarf2_queue
== NULL
)
2395 dwarf2_queue
= item
;
2397 dwarf2_queue_tail
->next
= item
;
2399 dwarf2_queue_tail
= item
;
2402 /* Process the queue. */
2405 process_queue (struct objfile
*objfile
)
2407 struct dwarf2_queue_item
*item
, *next_item
;
2409 /* Initially, there is just one item on the queue. Load its DIEs,
2410 and the DIEs of any other compilation units it requires,
2413 for (item
= dwarf2_queue
; item
!= NULL
; item
= item
->next
)
2415 /* Read in this compilation unit. This may add new items to
2416 the end of the queue. */
2417 load_full_comp_unit (item
->per_cu
, objfile
);
2419 item
->per_cu
->cu
->read_in_chain
= dwarf2_per_objfile
->read_in_chain
;
2420 dwarf2_per_objfile
->read_in_chain
= item
->per_cu
;
2422 /* If this compilation unit has already had full symbols created,
2423 reset the TYPE fields in each DIE. */
2424 if (item
->per_cu
->type_hash
)
2425 reset_die_and_siblings_types (item
->per_cu
->cu
->dies
,
2429 /* Now everything left on the queue needs to be read in. Process
2430 them, one at a time, removing from the queue as we finish. */
2431 for (item
= dwarf2_queue
; item
!= NULL
; dwarf2_queue
= item
= next_item
)
2433 if (item
->per_cu
->psymtab
&& !item
->per_cu
->psymtab
->readin
)
2434 process_full_comp_unit (item
->per_cu
);
2436 item
->per_cu
->queued
= 0;
2437 next_item
= item
->next
;
2441 dwarf2_queue_tail
= NULL
;
2444 /* Free all allocated queue entries. This function only releases anything if
2445 an error was thrown; if the queue was processed then it would have been
2446 freed as we went along. */
2449 dwarf2_release_queue (void *dummy
)
2451 struct dwarf2_queue_item
*item
, *last
;
2453 item
= dwarf2_queue
;
2456 /* Anything still marked queued is likely to be in an
2457 inconsistent state, so discard it. */
2458 if (item
->per_cu
->queued
)
2460 if (item
->per_cu
->cu
!= NULL
)
2461 free_one_cached_comp_unit (item
->per_cu
->cu
);
2462 item
->per_cu
->queued
= 0;
2470 dwarf2_queue
= dwarf2_queue_tail
= NULL
;
2473 /* Read in full symbols for PST, and anything it depends on. */
2476 psymtab_to_symtab_1 (struct partial_symtab
*pst
)
2478 struct dwarf2_per_cu_data
*per_cu
;
2479 struct cleanup
*back_to
;
2482 for (i
= 0; i
< pst
->number_of_dependencies
; i
++)
2483 if (!pst
->dependencies
[i
]->readin
)
2485 /* Inform about additional files that need to be read in. */
2488 /* FIXME: i18n: Need to make this a single string. */
2489 fputs_filtered (" ", gdb_stdout
);
2491 fputs_filtered ("and ", gdb_stdout
);
2493 printf_filtered ("%s...", pst
->dependencies
[i
]->filename
);
2494 wrap_here (""); /* Flush output */
2495 gdb_flush (gdb_stdout
);
2497 psymtab_to_symtab_1 (pst
->dependencies
[i
]);
2500 per_cu
= (struct dwarf2_per_cu_data
*) pst
->read_symtab_private
;
2504 /* It's an include file, no symbols to read for it.
2505 Everything is in the parent symtab. */
2510 back_to
= make_cleanup (dwarf2_release_queue
, NULL
);
2512 queue_comp_unit (per_cu
);
2514 process_queue (pst
->objfile
);
2516 /* Age the cache, releasing compilation units that have not
2517 been used recently. */
2518 age_cached_comp_units ();
2520 do_cleanups (back_to
);
2523 /* Load the DIEs associated with PST and PER_CU into memory. */
2525 static struct dwarf2_cu
*
2526 load_full_comp_unit (struct dwarf2_per_cu_data
*per_cu
, struct objfile
*objfile
)
2528 bfd
*abfd
= objfile
->obfd
;
2529 struct dwarf2_cu
*cu
;
2530 unsigned long offset
;
2532 struct cleanup
*back_to
, *free_cu_cleanup
;
2533 struct attribute
*attr
;
2536 /* Set local variables from the partial symbol table info. */
2537 offset
= per_cu
->offset
;
2539 info_ptr
= dwarf2_per_objfile
->info_buffer
+ offset
;
2541 cu
= xmalloc (sizeof (struct dwarf2_cu
));
2542 memset (cu
, 0, sizeof (struct dwarf2_cu
));
2544 /* If an error occurs while loading, release our storage. */
2545 free_cu_cleanup
= make_cleanup (free_one_comp_unit
, cu
);
2547 cu
->objfile
= objfile
;
2549 /* read in the comp_unit header */
2550 info_ptr
= read_comp_unit_head (&cu
->header
, info_ptr
, abfd
);
2552 /* Read the abbrevs for this compilation unit */
2553 dwarf2_read_abbrevs (abfd
, cu
);
2554 back_to
= make_cleanup (dwarf2_free_abbrev_table
, cu
);
2556 cu
->header
.offset
= offset
;
2558 cu
->per_cu
= per_cu
;
2561 /* We use this obstack for block values in dwarf_alloc_block. */
2562 obstack_init (&cu
->comp_unit_obstack
);
2564 cu
->dies
= read_comp_unit (info_ptr
, abfd
, cu
);
2566 /* We try not to read any attributes in this function, because not
2567 all objfiles needed for references have been loaded yet, and symbol
2568 table processing isn't initialized. But we have to set the CU language,
2569 or we won't be able to build types correctly. */
2570 attr
= dwarf2_attr (cu
->dies
, DW_AT_language
, cu
);
2572 set_cu_language (DW_UNSND (attr
), cu
);
2574 set_cu_language (language_minimal
, cu
);
2576 do_cleanups (back_to
);
2578 /* We've successfully allocated this compilation unit. Let our caller
2579 clean it up when finished with it. */
2580 discard_cleanups (free_cu_cleanup
);
2585 /* Generate full symbol information for PST and CU, whose DIEs have
2586 already been loaded into memory. */
2589 process_full_comp_unit (struct dwarf2_per_cu_data
*per_cu
)
2591 struct partial_symtab
*pst
= per_cu
->psymtab
;
2592 struct dwarf2_cu
*cu
= per_cu
->cu
;
2593 struct objfile
*objfile
= pst
->objfile
;
2594 bfd
*abfd
= objfile
->obfd
;
2595 CORE_ADDR lowpc
, highpc
;
2596 struct symtab
*symtab
;
2597 struct cleanup
*back_to
;
2598 struct attribute
*attr
;
2601 baseaddr
= ANOFFSET (objfile
->section_offsets
, SECT_OFF_TEXT (objfile
));
2603 /* We're in the global namespace. */
2604 processing_current_prefix
= "";
2607 back_to
= make_cleanup (really_free_pendings
, NULL
);
2609 cu
->list_in_scope
= &file_symbols
;
2611 /* Find the base address of the compilation unit for range lists and
2612 location lists. It will normally be specified by DW_AT_low_pc.
2613 In DWARF-3 draft 4, the base address could be overridden by
2614 DW_AT_entry_pc. It's been removed, but GCC still uses this for
2615 compilation units with discontinuous ranges. */
2617 cu
->header
.base_known
= 0;
2618 cu
->header
.base_address
= 0;
2620 attr
= dwarf2_attr (cu
->dies
, DW_AT_entry_pc
, cu
);
2623 cu
->header
.base_address
= DW_ADDR (attr
);
2624 cu
->header
.base_known
= 1;
2628 attr
= dwarf2_attr (cu
->dies
, DW_AT_low_pc
, cu
);
2631 cu
->header
.base_address
= DW_ADDR (attr
);
2632 cu
->header
.base_known
= 1;
2636 /* Do line number decoding in read_file_scope () */
2637 process_die (cu
->dies
, cu
);
2639 /* Some compilers don't define a DW_AT_high_pc attribute for the
2640 compilation unit. If the DW_AT_high_pc is missing, synthesize
2641 it, by scanning the DIE's below the compilation unit. */
2642 get_scope_pc_bounds (cu
->dies
, &lowpc
, &highpc
, cu
);
2644 symtab
= end_symtab (highpc
+ baseaddr
, objfile
, SECT_OFF_TEXT (objfile
));
2646 /* Set symtab language to language from DW_AT_language.
2647 If the compilation is from a C file generated by language preprocessors,
2648 do not set the language if it was already deduced by start_subfile. */
2650 && !(cu
->language
== language_c
&& symtab
->language
!= language_c
))
2652 symtab
->language
= cu
->language
;
2654 pst
->symtab
= symtab
;
2657 do_cleanups (back_to
);
2660 /* Process a die and its children. */
2663 process_die (struct die_info
*die
, struct dwarf2_cu
*cu
)
2667 case DW_TAG_padding
:
2669 case DW_TAG_compile_unit
:
2670 read_file_scope (die
, cu
);
2672 case DW_TAG_subprogram
:
2673 read_subroutine_type (die
, cu
);
2674 read_func_scope (die
, cu
);
2676 case DW_TAG_inlined_subroutine
:
2677 /* FIXME: These are ignored for now.
2678 They could be used to set breakpoints on all inlined instances
2679 of a function and make GDB `next' properly over inlined functions. */
2681 case DW_TAG_lexical_block
:
2682 case DW_TAG_try_block
:
2683 case DW_TAG_catch_block
:
2684 read_lexical_block_scope (die
, cu
);
2686 case DW_TAG_class_type
:
2687 case DW_TAG_interface_type
:
2688 case DW_TAG_structure_type
:
2689 case DW_TAG_union_type
:
2690 read_structure_type (die
, cu
);
2691 process_structure_scope (die
, cu
);
2693 case DW_TAG_enumeration_type
:
2694 read_enumeration_type (die
, cu
);
2695 process_enumeration_scope (die
, cu
);
2698 /* FIXME drow/2004-03-14: These initialize die->type, but do not create
2699 a symbol or process any children. Therefore it doesn't do anything
2700 that won't be done on-demand by read_type_die. */
2701 case DW_TAG_subroutine_type
:
2702 read_subroutine_type (die
, cu
);
2704 case DW_TAG_set_type
:
2705 read_set_type (die
, cu
);
2707 case DW_TAG_array_type
:
2708 read_array_type (die
, cu
);
2710 case DW_TAG_pointer_type
:
2711 read_tag_pointer_type (die
, cu
);
2713 case DW_TAG_ptr_to_member_type
:
2714 read_tag_ptr_to_member_type (die
, cu
);
2716 case DW_TAG_reference_type
:
2717 read_tag_reference_type (die
, cu
);
2719 case DW_TAG_string_type
:
2720 read_tag_string_type (die
, cu
);
2724 case DW_TAG_base_type
:
2725 read_base_type (die
, cu
);
2726 /* Add a typedef symbol for the type definition, if it has a
2728 new_symbol (die
, die
->type
, cu
);
2730 case DW_TAG_subrange_type
:
2731 read_subrange_type (die
, cu
);
2732 /* Add a typedef symbol for the type definition, if it has a
2734 new_symbol (die
, die
->type
, cu
);
2736 case DW_TAG_common_block
:
2737 read_common_block (die
, cu
);
2739 case DW_TAG_common_inclusion
:
2741 case DW_TAG_namespace
:
2742 processing_has_namespace_info
= 1;
2743 read_namespace (die
, cu
);
2745 case DW_TAG_imported_declaration
:
2746 case DW_TAG_imported_module
:
2747 /* FIXME: carlton/2002-10-16: Eventually, we should use the
2748 information contained in these. DW_TAG_imported_declaration
2749 dies shouldn't have children; DW_TAG_imported_module dies
2750 shouldn't in the C++ case, but conceivably could in the
2751 Fortran case, so we'll have to replace this gdb_assert if
2752 Fortran compilers start generating that info. */
2753 processing_has_namespace_info
= 1;
2754 gdb_assert (die
->child
== NULL
);
2757 new_symbol (die
, NULL
, cu
);
2763 initialize_cu_func_list (struct dwarf2_cu
*cu
)
2765 cu
->first_fn
= cu
->last_fn
= cu
->cached_fn
= NULL
;
2769 free_cu_line_header (void *arg
)
2771 struct dwarf2_cu
*cu
= arg
;
2773 free_line_header (cu
->line_header
);
2774 cu
->line_header
= NULL
;
2778 read_file_scope (struct die_info
*die
, struct dwarf2_cu
*cu
)
2780 struct objfile
*objfile
= cu
->objfile
;
2781 struct comp_unit_head
*cu_header
= &cu
->header
;
2782 struct cleanup
*back_to
= make_cleanup (null_cleanup
, 0);
2783 CORE_ADDR lowpc
= ((CORE_ADDR
) -1);
2784 CORE_ADDR highpc
= ((CORE_ADDR
) 0);
2785 struct attribute
*attr
;
2787 char *comp_dir
= NULL
;
2788 struct die_info
*child_die
;
2789 bfd
*abfd
= objfile
->obfd
;
2790 struct line_header
*line_header
= 0;
2793 baseaddr
= ANOFFSET (objfile
->section_offsets
, SECT_OFF_TEXT (objfile
));
2795 get_scope_pc_bounds (die
, &lowpc
, &highpc
, cu
);
2797 /* If we didn't find a lowpc, set it to highpc to avoid complaints
2798 from finish_block. */
2799 if (lowpc
== ((CORE_ADDR
) -1))
2804 /* Find the filename. Do not use dwarf2_name here, since the filename
2805 is not a source language identifier. */
2806 attr
= dwarf2_attr (die
, DW_AT_name
, cu
);
2809 name
= DW_STRING (attr
);
2812 attr
= dwarf2_attr (die
, DW_AT_comp_dir
, cu
);
2814 comp_dir
= DW_STRING (attr
);
2815 else if (name
!= NULL
&& IS_ABSOLUTE_PATH (name
))
2817 comp_dir
= ldirname (name
);
2818 if (comp_dir
!= NULL
)
2819 make_cleanup (xfree
, comp_dir
);
2821 if (comp_dir
!= NULL
)
2823 /* Irix 6.2 native cc prepends <machine>.: to the compilation
2824 directory, get rid of it. */
2825 char *cp
= strchr (comp_dir
, ':');
2827 if (cp
&& cp
!= comp_dir
&& cp
[-1] == '.' && cp
[1] == '/')
2834 attr
= dwarf2_attr (die
, DW_AT_language
, cu
);
2837 set_cu_language (DW_UNSND (attr
), cu
);
2840 attr
= dwarf2_attr (die
, DW_AT_producer
, cu
);
2842 cu
->producer
= DW_STRING (attr
);
2844 /* We assume that we're processing GCC output. */
2845 processing_gcc_compilation
= 2;
2847 start_symtab (name
, comp_dir
, lowpc
);
2848 record_debugformat ("DWARF 2");
2849 record_producer (cu
->producer
);
2851 initialize_cu_func_list (cu
);
2853 /* Decode line number information if present. We do this before
2854 processing child DIEs, so that the line header table is available
2855 for DW_AT_decl_file. */
2856 attr
= dwarf2_attr (die
, DW_AT_stmt_list
, cu
);
2859 unsigned int line_offset
= DW_UNSND (attr
);
2860 line_header
= dwarf_decode_line_header (line_offset
, abfd
, cu
);
2863 cu
->line_header
= line_header
;
2864 make_cleanup (free_cu_line_header
, cu
);
2865 dwarf_decode_lines (line_header
, comp_dir
, abfd
, cu
, NULL
);
2869 /* Process all dies in compilation unit. */
2870 if (die
->child
!= NULL
)
2872 child_die
= die
->child
;
2873 while (child_die
&& child_die
->tag
)
2875 process_die (child_die
, cu
);
2876 child_die
= sibling_die (child_die
);
2880 /* Decode macro information, if present. Dwarf 2 macro information
2881 refers to information in the line number info statement program
2882 header, so we can only read it if we've read the header
2884 attr
= dwarf2_attr (die
, DW_AT_macro_info
, cu
);
2885 if (attr
&& line_header
)
2887 unsigned int macro_offset
= DW_UNSND (attr
);
2888 dwarf_decode_macros (line_header
, macro_offset
,
2889 comp_dir
, abfd
, cu
);
2891 do_cleanups (back_to
);
2895 add_to_cu_func_list (const char *name
, CORE_ADDR lowpc
, CORE_ADDR highpc
,
2896 struct dwarf2_cu
*cu
)
2898 struct function_range
*thisfn
;
2900 thisfn
= (struct function_range
*)
2901 obstack_alloc (&cu
->comp_unit_obstack
, sizeof (struct function_range
));
2902 thisfn
->name
= name
;
2903 thisfn
->lowpc
= lowpc
;
2904 thisfn
->highpc
= highpc
;
2905 thisfn
->seen_line
= 0;
2906 thisfn
->next
= NULL
;
2908 if (cu
->last_fn
== NULL
)
2909 cu
->first_fn
= thisfn
;
2911 cu
->last_fn
->next
= thisfn
;
2913 cu
->last_fn
= thisfn
;
2917 read_func_scope (struct die_info
*die
, struct dwarf2_cu
*cu
)
2919 struct objfile
*objfile
= cu
->objfile
;
2920 struct context_stack
*new;
2923 struct die_info
*child_die
;
2924 struct attribute
*attr
;
2926 const char *previous_prefix
= processing_current_prefix
;
2927 struct cleanup
*back_to
= NULL
;
2929 struct block
*block
;
2931 baseaddr
= ANOFFSET (objfile
->section_offsets
, SECT_OFF_TEXT (objfile
));
2933 name
= dwarf2_linkage_name (die
, cu
);
2935 /* Ignore functions with missing or empty names and functions with
2936 missing or invalid low and high pc attributes. */
2937 if (name
== NULL
|| !dwarf2_get_pc_bounds (die
, &lowpc
, &highpc
, cu
))
2940 if (cu
->language
== language_cplus
2941 || cu
->language
== language_java
)
2943 struct die_info
*spec_die
= die_specification (die
, cu
);
2945 /* NOTE: carlton/2004-01-23: We have to be careful in the
2946 presence of DW_AT_specification. For example, with GCC 3.4,
2951 // Definition of N::foo.
2955 then we'll have a tree of DIEs like this:
2957 1: DW_TAG_compile_unit
2958 2: DW_TAG_namespace // N
2959 3: DW_TAG_subprogram // declaration of N::foo
2960 4: DW_TAG_subprogram // definition of N::foo
2961 DW_AT_specification // refers to die #3
2963 Thus, when processing die #4, we have to pretend that we're
2964 in the context of its DW_AT_specification, namely the contex
2967 if (spec_die
!= NULL
)
2969 char *specification_prefix
= determine_prefix (spec_die
, cu
);
2970 processing_current_prefix
= specification_prefix
;
2971 back_to
= make_cleanup (xfree
, specification_prefix
);
2978 /* Record the function range for dwarf_decode_lines. */
2979 add_to_cu_func_list (name
, lowpc
, highpc
, cu
);
2981 new = push_context (0, lowpc
);
2982 new->name
= new_symbol (die
, die
->type
, cu
);
2984 /* If there is a location expression for DW_AT_frame_base, record
2986 attr
= dwarf2_attr (die
, DW_AT_frame_base
, cu
);
2988 /* FIXME: cagney/2004-01-26: The DW_AT_frame_base's location
2989 expression is being recorded directly in the function's symbol
2990 and not in a separate frame-base object. I guess this hack is
2991 to avoid adding some sort of frame-base adjunct/annex to the
2992 function's symbol :-(. The problem with doing this is that it
2993 results in a function symbol with a location expression that
2994 has nothing to do with the location of the function, ouch! The
2995 relationship should be: a function's symbol has-a frame base; a
2996 frame-base has-a location expression. */
2997 dwarf2_symbol_mark_computed (attr
, new->name
, cu
);
2999 cu
->list_in_scope
= &local_symbols
;
3001 if (die
->child
!= NULL
)
3003 child_die
= die
->child
;
3004 while (child_die
&& child_die
->tag
)
3006 process_die (child_die
, cu
);
3007 child_die
= sibling_die (child_die
);
3011 new = pop_context ();
3012 /* Make a block for the local symbols within. */
3013 block
= finish_block (new->name
, &local_symbols
, new->old_blocks
,
3014 lowpc
, highpc
, objfile
);
3016 /* If we have address ranges, record them. */
3017 dwarf2_record_block_ranges (die
, block
, baseaddr
, cu
);
3019 /* In C++, we can have functions nested inside functions (e.g., when
3020 a function declares a class that has methods). This means that
3021 when we finish processing a function scope, we may need to go
3022 back to building a containing block's symbol lists. */
3023 local_symbols
= new->locals
;
3024 param_symbols
= new->params
;
3026 /* If we've finished processing a top-level function, subsequent
3027 symbols go in the file symbol list. */
3028 if (outermost_context_p ())
3029 cu
->list_in_scope
= &file_symbols
;
3031 processing_current_prefix
= previous_prefix
;
3032 if (back_to
!= NULL
)
3033 do_cleanups (back_to
);
3036 /* Process all the DIES contained within a lexical block scope. Start
3037 a new scope, process the dies, and then close the scope. */
3040 read_lexical_block_scope (struct die_info
*die
, struct dwarf2_cu
*cu
)
3042 struct objfile
*objfile
= cu
->objfile
;
3043 struct context_stack
*new;
3044 CORE_ADDR lowpc
, highpc
;
3045 struct die_info
*child_die
;
3048 baseaddr
= ANOFFSET (objfile
->section_offsets
, SECT_OFF_TEXT (objfile
));
3050 /* Ignore blocks with missing or invalid low and high pc attributes. */
3051 /* ??? Perhaps consider discontiguous blocks defined by DW_AT_ranges
3052 as multiple lexical blocks? Handling children in a sane way would
3053 be nasty. Might be easier to properly extend generic blocks to
3055 if (!dwarf2_get_pc_bounds (die
, &lowpc
, &highpc
, cu
))
3060 push_context (0, lowpc
);
3061 if (die
->child
!= NULL
)
3063 child_die
= die
->child
;
3064 while (child_die
&& child_die
->tag
)
3066 process_die (child_die
, cu
);
3067 child_die
= sibling_die (child_die
);
3070 new = pop_context ();
3072 if (local_symbols
!= NULL
)
3075 = finish_block (0, &local_symbols
, new->old_blocks
, new->start_addr
,
3078 /* Note that recording ranges after traversing children, as we
3079 do here, means that recording a parent's ranges entails
3080 walking across all its children's ranges as they appear in
3081 the address map, which is quadratic behavior.
3083 It would be nicer to record the parent's ranges before
3084 traversing its children, simply overriding whatever you find
3085 there. But since we don't even decide whether to create a
3086 block until after we've traversed its children, that's hard
3088 dwarf2_record_block_ranges (die
, block
, baseaddr
, cu
);
3090 local_symbols
= new->locals
;
3093 /* Get low and high pc attributes from DW_AT_ranges attribute value OFFSET.
3094 Return 1 if the attributes are present and valid, otherwise, return 0. */
3097 dwarf2_ranges_read (unsigned offset
, CORE_ADDR
*low_return
,
3098 CORE_ADDR
*high_return
, struct dwarf2_cu
*cu
)
3100 struct objfile
*objfile
= cu
->objfile
;
3101 struct comp_unit_head
*cu_header
= &cu
->header
;
3102 bfd
*obfd
= objfile
->obfd
;
3103 unsigned int addr_size
= cu_header
->addr_size
;
3104 CORE_ADDR mask
= ~(~(CORE_ADDR
)1 << (addr_size
* 8 - 1));
3105 /* Base address selection entry. */
3115 found_base
= cu_header
->base_known
;
3116 base
= cu_header
->base_address
;
3118 if (offset
>= dwarf2_per_objfile
->ranges_size
)
3120 complaint (&symfile_complaints
,
3121 _("Offset %d out of bounds for DW_AT_ranges attribute"),
3125 buffer
= dwarf2_per_objfile
->ranges_buffer
+ offset
;
3127 /* Read in the largest possible address. */
3128 marker
= read_address (obfd
, buffer
, cu
, &dummy
);
3129 if ((marker
& mask
) == mask
)
3131 /* If we found the largest possible address, then
3132 read the base address. */
3133 base
= read_address (obfd
, buffer
+ addr_size
, cu
, &dummy
);
3134 buffer
+= 2 * addr_size
;
3135 offset
+= 2 * addr_size
;
3143 CORE_ADDR range_beginning
, range_end
;
3145 range_beginning
= read_address (obfd
, buffer
, cu
, &dummy
);
3146 buffer
+= addr_size
;
3147 range_end
= read_address (obfd
, buffer
, cu
, &dummy
);
3148 buffer
+= addr_size
;
3149 offset
+= 2 * addr_size
;
3151 /* An end of list marker is a pair of zero addresses. */
3152 if (range_beginning
== 0 && range_end
== 0)
3153 /* Found the end of list entry. */
3156 /* Each base address selection entry is a pair of 2 values.
3157 The first is the largest possible address, the second is
3158 the base address. Check for a base address here. */
3159 if ((range_beginning
& mask
) == mask
)
3161 /* If we found the largest possible address, then
3162 read the base address. */
3163 base
= read_address (obfd
, buffer
+ addr_size
, cu
, &dummy
);
3170 /* We have no valid base address for the ranges
3172 complaint (&symfile_complaints
,
3173 _("Invalid .debug_ranges data (no base address)"));
3177 range_beginning
+= base
;
3180 /* FIXME: This is recording everything as a low-high
3181 segment of consecutive addresses. We should have a
3182 data structure for discontiguous block ranges
3186 low
= range_beginning
;
3192 if (range_beginning
< low
)
3193 low
= range_beginning
;
3194 if (range_end
> high
)
3200 /* If the first entry is an end-of-list marker, the range
3201 describes an empty scope, i.e. no instructions. */
3207 *high_return
= high
;
3211 /* Get low and high pc attributes from a die. Return 1 if the attributes
3212 are present and valid, otherwise, return 0. Return -1 if the range is
3213 discontinuous, i.e. derived from DW_AT_ranges information. */
3215 dwarf2_get_pc_bounds (struct die_info
*die
, CORE_ADDR
*lowpc
,
3216 CORE_ADDR
*highpc
, struct dwarf2_cu
*cu
)
3218 struct attribute
*attr
;
3223 attr
= dwarf2_attr (die
, DW_AT_high_pc
, cu
);
3226 high
= DW_ADDR (attr
);
3227 attr
= dwarf2_attr (die
, DW_AT_low_pc
, cu
);
3229 low
= DW_ADDR (attr
);
3231 /* Found high w/o low attribute. */
3234 /* Found consecutive range of addresses. */
3239 attr
= dwarf2_attr (die
, DW_AT_ranges
, cu
);
3242 /* Value of the DW_AT_ranges attribute is the offset in the
3243 .debug_ranges section. */
3244 if (!dwarf2_ranges_read (DW_UNSND (attr
), &low
, &high
, cu
))
3246 /* Found discontinuous range of addresses. */
3254 /* When using the GNU linker, .gnu.linkonce. sections are used to
3255 eliminate duplicate copies of functions and vtables and such.
3256 The linker will arbitrarily choose one and discard the others.
3257 The AT_*_pc values for such functions refer to local labels in
3258 these sections. If the section from that file was discarded, the
3259 labels are not in the output, so the relocs get a value of 0.
3260 If this is a discarded function, mark the pc bounds as invalid,
3261 so that GDB will ignore it. */
3262 if (low
== 0 && !dwarf2_per_objfile
->has_section_at_zero
)
3270 /* Get the low and high pc's represented by the scope DIE, and store
3271 them in *LOWPC and *HIGHPC. If the correct values can't be
3272 determined, set *LOWPC to -1 and *HIGHPC to 0. */
3275 get_scope_pc_bounds (struct die_info
*die
,
3276 CORE_ADDR
*lowpc
, CORE_ADDR
*highpc
,
3277 struct dwarf2_cu
*cu
)
3279 CORE_ADDR best_low
= (CORE_ADDR
) -1;
3280 CORE_ADDR best_high
= (CORE_ADDR
) 0;
3281 CORE_ADDR current_low
, current_high
;
3283 if (dwarf2_get_pc_bounds (die
, ¤t_low
, ¤t_high
, cu
))
3285 best_low
= current_low
;
3286 best_high
= current_high
;
3290 struct die_info
*child
= die
->child
;
3292 while (child
&& child
->tag
)
3294 switch (child
->tag
) {
3295 case DW_TAG_subprogram
:
3296 if (dwarf2_get_pc_bounds (child
, ¤t_low
, ¤t_high
, cu
))
3298 best_low
= min (best_low
, current_low
);
3299 best_high
= max (best_high
, current_high
);
3302 case DW_TAG_namespace
:
3303 /* FIXME: carlton/2004-01-16: Should we do this for
3304 DW_TAG_class_type/DW_TAG_structure_type, too? I think
3305 that current GCC's always emit the DIEs corresponding
3306 to definitions of methods of classes as children of a
3307 DW_TAG_compile_unit or DW_TAG_namespace (as opposed to
3308 the DIEs giving the declarations, which could be
3309 anywhere). But I don't see any reason why the
3310 standards says that they have to be there. */
3311 get_scope_pc_bounds (child
, ¤t_low
, ¤t_high
, cu
);
3313 if (current_low
!= ((CORE_ADDR
) -1))
3315 best_low
= min (best_low
, current_low
);
3316 best_high
= max (best_high
, current_high
);
3324 child
= sibling_die (child
);
3329 *highpc
= best_high
;
3332 /* Record the address ranges for BLOCK, offset by BASEADDR, as given
3335 dwarf2_record_block_ranges (struct die_info
*die
, struct block
*block
,
3336 CORE_ADDR baseaddr
, struct dwarf2_cu
*cu
)
3338 struct attribute
*attr
;
3340 attr
= dwarf2_attr (die
, DW_AT_high_pc
, cu
);
3343 CORE_ADDR high
= DW_ADDR (attr
);
3344 attr
= dwarf2_attr (die
, DW_AT_low_pc
, cu
);
3347 CORE_ADDR low
= DW_ADDR (attr
);
3348 record_block_range (block
, baseaddr
+ low
, baseaddr
+ high
- 1);
3352 attr
= dwarf2_attr (die
, DW_AT_ranges
, cu
);
3355 bfd
*obfd
= cu
->objfile
->obfd
;
3357 /* The value of the DW_AT_ranges attribute is the offset of the
3358 address range list in the .debug_ranges section. */
3359 unsigned long offset
= DW_UNSND (attr
);
3360 gdb_byte
*buffer
= dwarf2_per_objfile
->ranges_buffer
+ offset
;
3362 /* For some target architectures, but not others, the
3363 read_address function sign-extends the addresses it returns.
3364 To recognize base address selection entries, we need a
3366 unsigned int addr_size
= cu
->header
.addr_size
;
3367 CORE_ADDR base_select_mask
= ~(~(CORE_ADDR
)1 << (addr_size
* 8 - 1));
3369 /* The base address, to which the next pair is relative. Note
3370 that this 'base' is a DWARF concept: most entries in a range
3371 list are relative, to reduce the number of relocs against the
3372 debugging information. This is separate from this function's
3373 'baseaddr' argument, which GDB uses to relocate debugging
3374 information from a shared library based on the address at
3375 which the library was loaded. */
3376 CORE_ADDR base
= cu
->header
.base_address
;
3377 int base_known
= cu
->header
.base_known
;
3379 if (offset
>= dwarf2_per_objfile
->ranges_size
)
3381 complaint (&symfile_complaints
,
3382 _("Offset %lu out of bounds for DW_AT_ranges attribute"),
3389 unsigned int bytes_read
;
3390 CORE_ADDR start
, end
;
3392 start
= read_address (obfd
, buffer
, cu
, &bytes_read
);
3393 buffer
+= bytes_read
;
3394 end
= read_address (obfd
, buffer
, cu
, &bytes_read
);
3395 buffer
+= bytes_read
;
3397 /* Did we find the end of the range list? */
3398 if (start
== 0 && end
== 0)
3401 /* Did we find a base address selection entry? */
3402 else if ((start
& base_select_mask
) == base_select_mask
)
3408 /* We found an ordinary address range. */
3413 complaint (&symfile_complaints
,
3414 _("Invalid .debug_ranges data (no base address)"));
3418 record_block_range (block
,
3419 baseaddr
+ base
+ start
,
3420 baseaddr
+ base
+ end
- 1);
3426 /* Add an aggregate field to the field list. */
3429 dwarf2_add_field (struct field_info
*fip
, struct die_info
*die
,
3430 struct dwarf2_cu
*cu
)
3432 struct objfile
*objfile
= cu
->objfile
;
3433 struct gdbarch
*gdbarch
= get_objfile_arch (objfile
);
3434 struct nextfield
*new_field
;
3435 struct attribute
*attr
;
3437 char *fieldname
= "";
3439 /* Allocate a new field list entry and link it in. */
3440 new_field
= (struct nextfield
*) xmalloc (sizeof (struct nextfield
));
3441 make_cleanup (xfree
, new_field
);
3442 memset (new_field
, 0, sizeof (struct nextfield
));
3443 new_field
->next
= fip
->fields
;
3444 fip
->fields
= new_field
;
3447 /* Handle accessibility and virtuality of field.
3448 The default accessibility for members is public, the default
3449 accessibility for inheritance is private. */
3450 if (die
->tag
!= DW_TAG_inheritance
)
3451 new_field
->accessibility
= DW_ACCESS_public
;
3453 new_field
->accessibility
= DW_ACCESS_private
;
3454 new_field
->virtuality
= DW_VIRTUALITY_none
;
3456 attr
= dwarf2_attr (die
, DW_AT_accessibility
, cu
);
3458 new_field
->accessibility
= DW_UNSND (attr
);
3459 if (new_field
->accessibility
!= DW_ACCESS_public
)
3460 fip
->non_public_fields
= 1;
3461 attr
= dwarf2_attr (die
, DW_AT_virtuality
, cu
);
3463 new_field
->virtuality
= DW_UNSND (attr
);
3465 fp
= &new_field
->field
;
3467 if (die
->tag
== DW_TAG_member
&& ! die_is_declaration (die
, cu
))
3469 /* Data member other than a C++ static data member. */
3471 /* Get type of field. */
3472 fp
->type
= die_type (die
, cu
);
3474 FIELD_STATIC_KIND (*fp
) = 0;
3476 /* Get bit size of field (zero if none). */
3477 attr
= dwarf2_attr (die
, DW_AT_bit_size
, cu
);
3480 FIELD_BITSIZE (*fp
) = DW_UNSND (attr
);
3484 FIELD_BITSIZE (*fp
) = 0;
3487 /* Get bit offset of field. */
3488 attr
= dwarf2_attr (die
, DW_AT_data_member_location
, cu
);
3493 if (attr_form_is_section_offset (attr
))
3495 dwarf2_complex_location_expr_complaint ();
3498 else if (attr_form_is_constant (attr
))
3499 byte_offset
= dwarf2_get_attr_constant_value (attr
, 0);
3501 byte_offset
= decode_locdesc (DW_BLOCK (attr
), cu
);
3503 FIELD_BITPOS (*fp
) = byte_offset
* bits_per_byte
;
3506 FIELD_BITPOS (*fp
) = 0;
3507 attr
= dwarf2_attr (die
, DW_AT_bit_offset
, cu
);
3510 if (gdbarch_bits_big_endian (gdbarch
))
3512 /* For big endian bits, the DW_AT_bit_offset gives the
3513 additional bit offset from the MSB of the containing
3514 anonymous object to the MSB of the field. We don't
3515 have to do anything special since we don't need to
3516 know the size of the anonymous object. */
3517 FIELD_BITPOS (*fp
) += DW_UNSND (attr
);
3521 /* For little endian bits, compute the bit offset to the
3522 MSB of the anonymous object, subtract off the number of
3523 bits from the MSB of the field to the MSB of the
3524 object, and then subtract off the number of bits of
3525 the field itself. The result is the bit offset of
3526 the LSB of the field. */
3528 int bit_offset
= DW_UNSND (attr
);
3530 attr
= dwarf2_attr (die
, DW_AT_byte_size
, cu
);
3533 /* The size of the anonymous object containing
3534 the bit field is explicit, so use the
3535 indicated size (in bytes). */
3536 anonymous_size
= DW_UNSND (attr
);
3540 /* The size of the anonymous object containing
3541 the bit field must be inferred from the type
3542 attribute of the data member containing the
3544 anonymous_size
= TYPE_LENGTH (fp
->type
);
3546 FIELD_BITPOS (*fp
) += anonymous_size
* bits_per_byte
3547 - bit_offset
- FIELD_BITSIZE (*fp
);
3551 /* Get name of field. */
3552 fieldname
= dwarf2_name (die
, cu
);
3553 if (fieldname
== NULL
)
3556 /* The name is already allocated along with this objfile, so we don't
3557 need to duplicate it for the type. */
3558 fp
->name
= fieldname
;
3560 /* Change accessibility for artificial fields (e.g. virtual table
3561 pointer or virtual base class pointer) to private. */
3562 if (dwarf2_attr (die
, DW_AT_artificial
, cu
))
3564 new_field
->accessibility
= DW_ACCESS_private
;
3565 fip
->non_public_fields
= 1;
3568 else if (die
->tag
== DW_TAG_member
|| die
->tag
== DW_TAG_variable
)
3570 /* C++ static member. */
3572 /* NOTE: carlton/2002-11-05: It should be a DW_TAG_member that
3573 is a declaration, but all versions of G++ as of this writing
3574 (so through at least 3.2.1) incorrectly generate
3575 DW_TAG_variable tags. */
3579 /* Get name of field. */
3580 fieldname
= dwarf2_name (die
, cu
);
3581 if (fieldname
== NULL
)
3584 /* Get physical name. */
3585 physname
= dwarf2_linkage_name (die
, cu
);
3587 /* The name is already allocated along with this objfile, so we don't
3588 need to duplicate it for the type. */
3589 SET_FIELD_PHYSNAME (*fp
, physname
? physname
: "");
3590 FIELD_TYPE (*fp
) = die_type (die
, cu
);
3591 FIELD_NAME (*fp
) = fieldname
;
3593 else if (die
->tag
== DW_TAG_inheritance
)
3595 /* C++ base class field. */
3596 attr
= dwarf2_attr (die
, DW_AT_data_member_location
, cu
);
3598 FIELD_BITPOS (*fp
) = (decode_locdesc (DW_BLOCK (attr
), cu
)
3600 FIELD_BITSIZE (*fp
) = 0;
3601 FIELD_STATIC_KIND (*fp
) = 0;
3602 FIELD_TYPE (*fp
) = die_type (die
, cu
);
3603 FIELD_NAME (*fp
) = type_name_no_tag (fp
->type
);
3604 fip
->nbaseclasses
++;
3608 /* Create the vector of fields, and attach it to the type. */
3611 dwarf2_attach_fields_to_type (struct field_info
*fip
, struct type
*type
,
3612 struct dwarf2_cu
*cu
)
3614 int nfields
= fip
->nfields
;
3616 /* Record the field count, allocate space for the array of fields,
3617 and create blank accessibility bitfields if necessary. */
3618 TYPE_NFIELDS (type
) = nfields
;
3619 TYPE_FIELDS (type
) = (struct field
*)
3620 TYPE_ALLOC (type
, sizeof (struct field
) * nfields
);
3621 memset (TYPE_FIELDS (type
), 0, sizeof (struct field
) * nfields
);
3623 if (fip
->non_public_fields
)
3625 ALLOCATE_CPLUS_STRUCT_TYPE (type
);
3627 TYPE_FIELD_PRIVATE_BITS (type
) =
3628 (B_TYPE
*) TYPE_ALLOC (type
, B_BYTES (nfields
));
3629 B_CLRALL (TYPE_FIELD_PRIVATE_BITS (type
), nfields
);
3631 TYPE_FIELD_PROTECTED_BITS (type
) =
3632 (B_TYPE
*) TYPE_ALLOC (type
, B_BYTES (nfields
));
3633 B_CLRALL (TYPE_FIELD_PROTECTED_BITS (type
), nfields
);
3635 TYPE_FIELD_IGNORE_BITS (type
) =
3636 (B_TYPE
*) TYPE_ALLOC (type
, B_BYTES (nfields
));
3637 B_CLRALL (TYPE_FIELD_IGNORE_BITS (type
), nfields
);
3640 /* If the type has baseclasses, allocate and clear a bit vector for
3641 TYPE_FIELD_VIRTUAL_BITS. */
3642 if (fip
->nbaseclasses
)
3644 int num_bytes
= B_BYTES (fip
->nbaseclasses
);
3645 unsigned char *pointer
;
3647 ALLOCATE_CPLUS_STRUCT_TYPE (type
);
3648 pointer
= TYPE_ALLOC (type
, num_bytes
);
3649 TYPE_FIELD_VIRTUAL_BITS (type
) = pointer
;
3650 B_CLRALL (TYPE_FIELD_VIRTUAL_BITS (type
), fip
->nbaseclasses
);
3651 TYPE_N_BASECLASSES (type
) = fip
->nbaseclasses
;
3654 /* Copy the saved-up fields into the field vector. Start from the head
3655 of the list, adding to the tail of the field array, so that they end
3656 up in the same order in the array in which they were added to the list. */
3657 while (nfields
-- > 0)
3659 TYPE_FIELD (type
, nfields
) = fip
->fields
->field
;
3660 switch (fip
->fields
->accessibility
)
3662 case DW_ACCESS_private
:
3663 SET_TYPE_FIELD_PRIVATE (type
, nfields
);
3666 case DW_ACCESS_protected
:
3667 SET_TYPE_FIELD_PROTECTED (type
, nfields
);
3670 case DW_ACCESS_public
:
3674 /* Unknown accessibility. Complain and treat it as public. */
3676 complaint (&symfile_complaints
, _("unsupported accessibility %d"),
3677 fip
->fields
->accessibility
);
3681 if (nfields
< fip
->nbaseclasses
)
3683 switch (fip
->fields
->virtuality
)
3685 case DW_VIRTUALITY_virtual
:
3686 case DW_VIRTUALITY_pure_virtual
:
3687 SET_TYPE_FIELD_VIRTUAL (type
, nfields
);
3691 fip
->fields
= fip
->fields
->next
;
3695 /* Add a member function to the proper fieldlist. */
3698 dwarf2_add_member_fn (struct field_info
*fip
, struct die_info
*die
,
3699 struct type
*type
, struct dwarf2_cu
*cu
)
3701 struct objfile
*objfile
= cu
->objfile
;
3702 struct attribute
*attr
;
3703 struct fnfieldlist
*flp
;
3705 struct fn_field
*fnp
;
3708 struct nextfnfield
*new_fnfield
;
3710 /* Get name of member function. */
3711 fieldname
= dwarf2_name (die
, cu
);
3712 if (fieldname
== NULL
)
3715 /* Get the mangled name. */
3716 physname
= dwarf2_linkage_name (die
, cu
);
3718 /* Look up member function name in fieldlist. */
3719 for (i
= 0; i
< fip
->nfnfields
; i
++)
3721 if (strcmp (fip
->fnfieldlists
[i
].name
, fieldname
) == 0)
3725 /* Create new list element if necessary. */
3726 if (i
< fip
->nfnfields
)
3727 flp
= &fip
->fnfieldlists
[i
];
3730 if ((fip
->nfnfields
% DW_FIELD_ALLOC_CHUNK
) == 0)
3732 fip
->fnfieldlists
= (struct fnfieldlist
*)
3733 xrealloc (fip
->fnfieldlists
,
3734 (fip
->nfnfields
+ DW_FIELD_ALLOC_CHUNK
)
3735 * sizeof (struct fnfieldlist
));
3736 if (fip
->nfnfields
== 0)
3737 make_cleanup (free_current_contents
, &fip
->fnfieldlists
);
3739 flp
= &fip
->fnfieldlists
[fip
->nfnfields
];
3740 flp
->name
= fieldname
;
3746 /* Create a new member function field and chain it to the field list
3748 new_fnfield
= (struct nextfnfield
*) xmalloc (sizeof (struct nextfnfield
));
3749 make_cleanup (xfree
, new_fnfield
);
3750 memset (new_fnfield
, 0, sizeof (struct nextfnfield
));
3751 new_fnfield
->next
= flp
->head
;
3752 flp
->head
= new_fnfield
;
3755 /* Fill in the member function field info. */
3756 fnp
= &new_fnfield
->fnfield
;
3757 /* The name is already allocated along with this objfile, so we don't
3758 need to duplicate it for the type. */
3759 fnp
->physname
= physname
? physname
: "";
3760 fnp
->type
= alloc_type (objfile
);
3761 if (die
->type
&& TYPE_CODE (die
->type
) == TYPE_CODE_FUNC
)
3763 int nparams
= TYPE_NFIELDS (die
->type
);
3765 /* TYPE is the domain of this method, and DIE->TYPE is the type
3766 of the method itself (TYPE_CODE_METHOD). */
3767 smash_to_method_type (fnp
->type
, type
,
3768 TYPE_TARGET_TYPE (die
->type
),
3769 TYPE_FIELDS (die
->type
),
3770 TYPE_NFIELDS (die
->type
),
3771 TYPE_VARARGS (die
->type
));
3773 /* Handle static member functions.
3774 Dwarf2 has no clean way to discern C++ static and non-static
3775 member functions. G++ helps GDB by marking the first
3776 parameter for non-static member functions (which is the
3777 this pointer) as artificial. We obtain this information
3778 from read_subroutine_type via TYPE_FIELD_ARTIFICIAL. */
3779 if (nparams
== 0 || TYPE_FIELD_ARTIFICIAL (die
->type
, 0) == 0)
3780 fnp
->voffset
= VOFFSET_STATIC
;
3783 complaint (&symfile_complaints
, _("member function type missing for '%s'"),
3786 /* Get fcontext from DW_AT_containing_type if present. */
3787 if (dwarf2_attr (die
, DW_AT_containing_type
, cu
) != NULL
)
3788 fnp
->fcontext
= die_containing_type (die
, cu
);
3790 /* dwarf2 doesn't have stubbed physical names, so the setting of is_const
3791 and is_volatile is irrelevant, as it is needed by gdb_mangle_name only. */
3793 /* Get accessibility. */
3794 attr
= dwarf2_attr (die
, DW_AT_accessibility
, cu
);
3797 switch (DW_UNSND (attr
))
3799 case DW_ACCESS_private
:
3800 fnp
->is_private
= 1;
3802 case DW_ACCESS_protected
:
3803 fnp
->is_protected
= 1;
3808 /* Check for artificial methods. */
3809 attr
= dwarf2_attr (die
, DW_AT_artificial
, cu
);
3810 if (attr
&& DW_UNSND (attr
) != 0)
3811 fnp
->is_artificial
= 1;
3813 /* Get index in virtual function table if it is a virtual member function. */
3814 attr
= dwarf2_attr (die
, DW_AT_vtable_elem_location
, cu
);
3817 /* Support the .debug_loc offsets */
3818 if (attr_form_is_block (attr
))
3820 fnp
->voffset
= decode_locdesc (DW_BLOCK (attr
), cu
) + 2;
3822 else if (attr_form_is_section_offset (attr
))
3824 dwarf2_complex_location_expr_complaint ();
3828 dwarf2_invalid_attrib_class_complaint ("DW_AT_vtable_elem_location",
3834 /* Create the vector of member function fields, and attach it to the type. */
3837 dwarf2_attach_fn_fields_to_type (struct field_info
*fip
, struct type
*type
,
3838 struct dwarf2_cu
*cu
)
3840 struct fnfieldlist
*flp
;
3841 int total_length
= 0;
3844 ALLOCATE_CPLUS_STRUCT_TYPE (type
);
3845 TYPE_FN_FIELDLISTS (type
) = (struct fn_fieldlist
*)
3846 TYPE_ALLOC (type
, sizeof (struct fn_fieldlist
) * fip
->nfnfields
);
3848 for (i
= 0, flp
= fip
->fnfieldlists
; i
< fip
->nfnfields
; i
++, flp
++)
3850 struct nextfnfield
*nfp
= flp
->head
;
3851 struct fn_fieldlist
*fn_flp
= &TYPE_FN_FIELDLIST (type
, i
);
3854 TYPE_FN_FIELDLIST_NAME (type
, i
) = flp
->name
;
3855 TYPE_FN_FIELDLIST_LENGTH (type
, i
) = flp
->length
;
3856 fn_flp
->fn_fields
= (struct fn_field
*)
3857 TYPE_ALLOC (type
, sizeof (struct fn_field
) * flp
->length
);
3858 for (k
= flp
->length
; (k
--, nfp
); nfp
= nfp
->next
)
3859 fn_flp
->fn_fields
[k
] = nfp
->fnfield
;
3861 total_length
+= flp
->length
;
3864 TYPE_NFN_FIELDS (type
) = fip
->nfnfields
;
3865 TYPE_NFN_FIELDS_TOTAL (type
) = total_length
;
3868 /* Returns non-zero if NAME is the name of a vtable member in CU's
3869 language, zero otherwise. */
3871 is_vtable_name (const char *name
, struct dwarf2_cu
*cu
)
3873 static const char vptr
[] = "_vptr";
3874 static const char vtable
[] = "vtable";
3876 /* Look for the C++ and Java forms of the vtable. */
3877 if ((cu
->language
== language_java
3878 && strncmp (name
, vtable
, sizeof (vtable
) - 1) == 0)
3879 || (strncmp (name
, vptr
, sizeof (vptr
) - 1) == 0
3880 && is_cplus_marker (name
[sizeof (vptr
) - 1])))
3886 /* GCC outputs unnamed structures that are really pointers to member
3887 functions, with the ABI-specified layout. If DIE (from CU) describes
3888 such a structure, set its type, and return nonzero. Otherwise return
3891 GCC shouldn't do this; it should just output pointer to member DIEs.
3892 This is GCC PR debug/28767. */
3895 quirk_gcc_member_function_pointer (struct die_info
*die
, struct dwarf2_cu
*cu
)
3897 struct objfile
*objfile
= cu
->objfile
;
3899 struct die_info
*pfn_die
, *delta_die
;
3900 struct attribute
*pfn_name
, *delta_name
;
3901 struct type
*pfn_type
, *domain_type
;
3903 /* Check for a structure with no name and two children. */
3904 if (die
->tag
!= DW_TAG_structure_type
3905 || dwarf2_attr (die
, DW_AT_name
, cu
) != NULL
3906 || die
->child
== NULL
3907 || die
->child
->sibling
== NULL
3908 || (die
->child
->sibling
->sibling
!= NULL
3909 && die
->child
->sibling
->sibling
->tag
!= DW_TAG_padding
))
3912 /* Check for __pfn and __delta members. */
3913 pfn_die
= die
->child
;
3914 pfn_name
= dwarf2_attr (pfn_die
, DW_AT_name
, cu
);
3915 if (pfn_die
->tag
!= DW_TAG_member
3917 || DW_STRING (pfn_name
) == NULL
3918 || strcmp ("__pfn", DW_STRING (pfn_name
)) != 0)
3921 delta_die
= pfn_die
->sibling
;
3922 delta_name
= dwarf2_attr (delta_die
, DW_AT_name
, cu
);
3923 if (delta_die
->tag
!= DW_TAG_member
3924 || delta_name
== NULL
3925 || DW_STRING (delta_name
) == NULL
3926 || strcmp ("__delta", DW_STRING (delta_name
)) != 0)
3929 /* Find the type of the method. */
3930 pfn_type
= die_type (pfn_die
, cu
);
3931 if (pfn_type
== NULL
3932 || TYPE_CODE (pfn_type
) != TYPE_CODE_PTR
3933 || TYPE_CODE (TYPE_TARGET_TYPE (pfn_type
)) != TYPE_CODE_FUNC
)
3936 /* Look for the "this" argument. */
3937 pfn_type
= TYPE_TARGET_TYPE (pfn_type
);
3938 if (TYPE_NFIELDS (pfn_type
) == 0
3939 || TYPE_CODE (TYPE_FIELD_TYPE (pfn_type
, 0)) != TYPE_CODE_PTR
)
3942 domain_type
= TYPE_TARGET_TYPE (TYPE_FIELD_TYPE (pfn_type
, 0));
3943 type
= alloc_type (objfile
);
3944 smash_to_method_type (type
, domain_type
, TYPE_TARGET_TYPE (pfn_type
),
3945 TYPE_FIELDS (pfn_type
), TYPE_NFIELDS (pfn_type
),
3946 TYPE_VARARGS (pfn_type
));
3947 type
= lookup_methodptr_type (type
);
3948 set_die_type (die
, type
, cu
);
3953 /* Called when we find the DIE that starts a structure or union scope
3954 (definition) to process all dies that define the members of the
3957 NOTE: we need to call struct_type regardless of whether or not the
3958 DIE has an at_name attribute, since it might be an anonymous
3959 structure or union. This gets the type entered into our set of
3962 However, if the structure is incomplete (an opaque struct/union)
3963 then suppress creating a symbol table entry for it since gdb only
3964 wants to find the one with the complete definition. Note that if
3965 it is complete, we just call new_symbol, which does it's own
3966 checking about whether the struct/union is anonymous or not (and
3967 suppresses creating a symbol table entry itself). */
3970 read_structure_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
3972 struct objfile
*objfile
= cu
->objfile
;
3974 struct attribute
*attr
;
3975 const char *previous_prefix
= processing_current_prefix
;
3976 struct cleanup
*back_to
= NULL
;
3982 if (quirk_gcc_member_function_pointer (die
, cu
))
3985 type
= alloc_type (objfile
);
3986 INIT_CPLUS_SPECIFIC (type
);
3987 name
= dwarf2_name (die
, cu
);
3990 if (cu
->language
== language_cplus
3991 || cu
->language
== language_java
)
3993 char *new_prefix
= determine_class_name (die
, cu
);
3994 TYPE_TAG_NAME (type
) = obsavestring (new_prefix
,
3995 strlen (new_prefix
),
3996 &objfile
->objfile_obstack
);
3997 back_to
= make_cleanup (xfree
, new_prefix
);
3998 processing_current_prefix
= new_prefix
;
4002 /* The name is already allocated along with this objfile, so
4003 we don't need to duplicate it for the type. */
4004 TYPE_TAG_NAME (type
) = name
;
4008 if (die
->tag
== DW_TAG_structure_type
)
4010 TYPE_CODE (type
) = TYPE_CODE_STRUCT
;
4012 else if (die
->tag
== DW_TAG_union_type
)
4014 TYPE_CODE (type
) = TYPE_CODE_UNION
;
4018 /* FIXME: TYPE_CODE_CLASS is currently defined to TYPE_CODE_STRUCT
4020 TYPE_CODE (type
) = TYPE_CODE_CLASS
;
4023 attr
= dwarf2_attr (die
, DW_AT_byte_size
, cu
);
4026 TYPE_LENGTH (type
) = DW_UNSND (attr
);
4030 TYPE_LENGTH (type
) = 0;
4033 TYPE_FLAGS (type
) |= TYPE_FLAG_STUB_SUPPORTED
;
4034 if (die_is_declaration (die
, cu
))
4035 TYPE_FLAGS (type
) |= TYPE_FLAG_STUB
;
4037 /* We need to add the type field to the die immediately so we don't
4038 infinitely recurse when dealing with pointers to the structure
4039 type within the structure itself. */
4040 set_die_type (die
, type
, cu
);
4042 if (die
->child
!= NULL
&& ! die_is_declaration (die
, cu
))
4044 struct field_info fi
;
4045 struct die_info
*child_die
;
4046 struct cleanup
*back_to
= make_cleanup (null_cleanup
, NULL
);
4048 memset (&fi
, 0, sizeof (struct field_info
));
4050 child_die
= die
->child
;
4052 while (child_die
&& child_die
->tag
)
4054 if (child_die
->tag
== DW_TAG_member
4055 || child_die
->tag
== DW_TAG_variable
)
4057 /* NOTE: carlton/2002-11-05: A C++ static data member
4058 should be a DW_TAG_member that is a declaration, but
4059 all versions of G++ as of this writing (so through at
4060 least 3.2.1) incorrectly generate DW_TAG_variable
4061 tags for them instead. */
4062 dwarf2_add_field (&fi
, child_die
, cu
);
4064 else if (child_die
->tag
== DW_TAG_subprogram
)
4066 /* C++ member function. */
4067 read_type_die (child_die
, cu
);
4068 dwarf2_add_member_fn (&fi
, child_die
, type
, cu
);
4070 else if (child_die
->tag
== DW_TAG_inheritance
)
4072 /* C++ base class field. */
4073 dwarf2_add_field (&fi
, child_die
, cu
);
4075 child_die
= sibling_die (child_die
);
4078 /* Attach fields and member functions to the type. */
4080 dwarf2_attach_fields_to_type (&fi
, type
, cu
);
4083 dwarf2_attach_fn_fields_to_type (&fi
, type
, cu
);
4085 /* Get the type which refers to the base class (possibly this
4086 class itself) which contains the vtable pointer for the current
4087 class from the DW_AT_containing_type attribute. */
4089 if (dwarf2_attr (die
, DW_AT_containing_type
, cu
) != NULL
)
4091 struct type
*t
= die_containing_type (die
, cu
);
4093 TYPE_VPTR_BASETYPE (type
) = t
;
4098 /* Our own class provides vtbl ptr. */
4099 for (i
= TYPE_NFIELDS (t
) - 1;
4100 i
>= TYPE_N_BASECLASSES (t
);
4103 char *fieldname
= TYPE_FIELD_NAME (t
, i
);
4105 if (is_vtable_name (fieldname
, cu
))
4107 TYPE_VPTR_FIELDNO (type
) = i
;
4112 /* Complain if virtual function table field not found. */
4113 if (i
< TYPE_N_BASECLASSES (t
))
4114 complaint (&symfile_complaints
,
4115 _("virtual function table pointer not found when defining class '%s'"),
4116 TYPE_TAG_NAME (type
) ? TYPE_TAG_NAME (type
) :
4121 TYPE_VPTR_FIELDNO (type
) = TYPE_VPTR_FIELDNO (t
);
4124 else if (cu
->producer
4125 && strncmp (cu
->producer
,
4126 "IBM(R) XL C/C++ Advanced Edition", 32) == 0)
4128 /* The IBM XLC compiler does not provide direct indication
4129 of the containing type, but the vtable pointer is
4130 always named __vfp. */
4134 for (i
= TYPE_NFIELDS (type
) - 1;
4135 i
>= TYPE_N_BASECLASSES (type
);
4138 if (strcmp (TYPE_FIELD_NAME (type
, i
), "__vfp") == 0)
4140 TYPE_VPTR_FIELDNO (type
) = i
;
4141 TYPE_VPTR_BASETYPE (type
) = type
;
4148 do_cleanups (back_to
);
4151 processing_current_prefix
= previous_prefix
;
4152 if (back_to
!= NULL
)
4153 do_cleanups (back_to
);
4157 process_structure_scope (struct die_info
*die
, struct dwarf2_cu
*cu
)
4159 struct objfile
*objfile
= cu
->objfile
;
4160 const char *previous_prefix
= processing_current_prefix
;
4161 struct die_info
*child_die
= die
->child
;
4163 if (TYPE_TAG_NAME (die
->type
) != NULL
)
4164 processing_current_prefix
= TYPE_TAG_NAME (die
->type
);
4166 /* NOTE: carlton/2004-03-16: GCC 3.4 (or at least one of its
4167 snapshots) has been known to create a die giving a declaration
4168 for a class that has, as a child, a die giving a definition for a
4169 nested class. So we have to process our children even if the
4170 current die is a declaration. Normally, of course, a declaration
4171 won't have any children at all. */
4173 while (child_die
!= NULL
&& child_die
->tag
)
4175 if (child_die
->tag
== DW_TAG_member
4176 || child_die
->tag
== DW_TAG_variable
4177 || child_die
->tag
== DW_TAG_inheritance
)
4182 process_die (child_die
, cu
);
4184 child_die
= sibling_die (child_die
);
4187 /* Do not consider external references. According to the DWARF standard,
4188 these DIEs are identified by the fact that they have no byte_size
4189 attribute, and a declaration attribute. */
4190 if (dwarf2_attr (die
, DW_AT_byte_size
, cu
) != NULL
4191 || !die_is_declaration (die
, cu
))
4192 new_symbol (die
, die
->type
, cu
);
4194 processing_current_prefix
= previous_prefix
;
4197 /* Given a DW_AT_enumeration_type die, set its type. We do not
4198 complete the type's fields yet, or create any symbols. */
4201 read_enumeration_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
4203 struct objfile
*objfile
= cu
->objfile
;
4205 struct attribute
*attr
;
4211 type
= alloc_type (objfile
);
4213 TYPE_CODE (type
) = TYPE_CODE_ENUM
;
4214 name
= dwarf2_name (die
, cu
);
4217 if (processing_has_namespace_info
)
4219 TYPE_TAG_NAME (type
) = typename_concat (&objfile
->objfile_obstack
,
4220 processing_current_prefix
,
4225 /* The name is already allocated along with this objfile, so
4226 we don't need to duplicate it for the type. */
4227 TYPE_TAG_NAME (type
) = name
;
4231 attr
= dwarf2_attr (die
, DW_AT_byte_size
, cu
);
4234 TYPE_LENGTH (type
) = DW_UNSND (attr
);
4238 TYPE_LENGTH (type
) = 0;
4241 /* The enumeration DIE can be incomplete. In Ada, any type can be
4242 declared as private in the package spec, and then defined only
4243 inside the package body. Such types are known as Taft Amendment
4244 Types. When another package uses such a type, an incomplete DIE
4245 may be generated by the compiler. */
4246 if (die_is_declaration (die
, cu
))
4247 TYPE_FLAGS (type
) |= TYPE_FLAG_STUB
;
4249 set_die_type (die
, type
, cu
);
4252 /* Determine the name of the type represented by DIE, which should be
4253 a named C++ or Java compound type. Return the name in question; the caller
4254 is responsible for xfree()'ing it. */
4257 determine_class_name (struct die_info
*die
, struct dwarf2_cu
*cu
)
4259 struct cleanup
*back_to
= NULL
;
4260 struct die_info
*spec_die
= die_specification (die
, cu
);
4261 char *new_prefix
= NULL
;
4263 /* If this is the definition of a class that is declared by another
4264 die, then processing_current_prefix may not be accurate; see
4265 read_func_scope for a similar example. */
4266 if (spec_die
!= NULL
)
4268 char *specification_prefix
= determine_prefix (spec_die
, cu
);
4269 processing_current_prefix
= specification_prefix
;
4270 back_to
= make_cleanup (xfree
, specification_prefix
);
4273 /* If we don't have namespace debug info, guess the name by trying
4274 to demangle the names of members, just like we did in
4275 guess_structure_name. */
4276 if (!processing_has_namespace_info
)
4278 struct die_info
*child
;
4280 for (child
= die
->child
;
4281 child
!= NULL
&& child
->tag
!= 0;
4282 child
= sibling_die (child
))
4284 if (child
->tag
== DW_TAG_subprogram
)
4287 = language_class_name_from_physname (cu
->language_defn
,
4291 if (new_prefix
!= NULL
)
4297 if (new_prefix
== NULL
)
4299 const char *name
= dwarf2_name (die
, cu
);
4300 new_prefix
= typename_concat (NULL
, processing_current_prefix
,
4301 name
? name
: "<<anonymous>>",
4305 if (back_to
!= NULL
)
4306 do_cleanups (back_to
);
4311 /* Given a pointer to a die which begins an enumeration, process all
4312 the dies that define the members of the enumeration, and create the
4313 symbol for the enumeration type.
4315 NOTE: We reverse the order of the element list. */
4318 process_enumeration_scope (struct die_info
*die
, struct dwarf2_cu
*cu
)
4320 struct objfile
*objfile
= cu
->objfile
;
4321 struct die_info
*child_die
;
4322 struct field
*fields
;
4325 int unsigned_enum
= 1;
4330 if (die
->child
!= NULL
)
4332 child_die
= die
->child
;
4333 while (child_die
&& child_die
->tag
)
4335 if (child_die
->tag
!= DW_TAG_enumerator
)
4337 process_die (child_die
, cu
);
4341 name
= dwarf2_name (child_die
, cu
);
4344 sym
= new_symbol (child_die
, die
->type
, cu
);
4345 if (SYMBOL_VALUE (sym
) < 0)
4348 if ((num_fields
% DW_FIELD_ALLOC_CHUNK
) == 0)
4350 fields
= (struct field
*)
4352 (num_fields
+ DW_FIELD_ALLOC_CHUNK
)
4353 * sizeof (struct field
));
4356 FIELD_NAME (fields
[num_fields
]) = DEPRECATED_SYMBOL_NAME (sym
);
4357 FIELD_TYPE (fields
[num_fields
]) = NULL
;
4358 FIELD_BITPOS (fields
[num_fields
]) = SYMBOL_VALUE (sym
);
4359 FIELD_BITSIZE (fields
[num_fields
]) = 0;
4360 FIELD_STATIC_KIND (fields
[num_fields
]) = 0;
4366 child_die
= sibling_die (child_die
);
4371 TYPE_NFIELDS (die
->type
) = num_fields
;
4372 TYPE_FIELDS (die
->type
) = (struct field
*)
4373 TYPE_ALLOC (die
->type
, sizeof (struct field
) * num_fields
);
4374 memcpy (TYPE_FIELDS (die
->type
), fields
,
4375 sizeof (struct field
) * num_fields
);
4379 TYPE_FLAGS (die
->type
) |= TYPE_FLAG_UNSIGNED
;
4382 new_symbol (die
, die
->type
, cu
);
4385 /* Extract all information from a DW_TAG_array_type DIE and put it in
4386 the DIE's type field. For now, this only handles one dimensional
4390 read_array_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
4392 struct objfile
*objfile
= cu
->objfile
;
4393 struct die_info
*child_die
;
4394 struct type
*type
= NULL
;
4395 struct type
*element_type
, *range_type
, *index_type
;
4396 struct type
**range_types
= NULL
;
4397 struct attribute
*attr
;
4399 struct cleanup
*back_to
;
4402 /* Return if we've already decoded this type. */
4408 element_type
= die_type (die
, cu
);
4410 /* Irix 6.2 native cc creates array types without children for
4411 arrays with unspecified length. */
4412 if (die
->child
== NULL
)
4414 index_type
= builtin_type_int32
;
4415 range_type
= create_range_type (NULL
, index_type
, 0, -1);
4416 set_die_type (die
, create_array_type (NULL
, element_type
, range_type
),
4421 back_to
= make_cleanup (null_cleanup
, NULL
);
4422 child_die
= die
->child
;
4423 while (child_die
&& child_die
->tag
)
4425 if (child_die
->tag
== DW_TAG_subrange_type
)
4427 read_subrange_type (child_die
, cu
);
4429 if (child_die
->type
!= NULL
)
4431 /* The range type was succesfully read. Save it for
4432 the array type creation. */
4433 if ((ndim
% DW_FIELD_ALLOC_CHUNK
) == 0)
4435 range_types
= (struct type
**)
4436 xrealloc (range_types
, (ndim
+ DW_FIELD_ALLOC_CHUNK
)
4437 * sizeof (struct type
*));
4439 make_cleanup (free_current_contents
, &range_types
);
4441 range_types
[ndim
++] = child_die
->type
;
4444 child_die
= sibling_die (child_die
);
4447 /* Dwarf2 dimensions are output from left to right, create the
4448 necessary array types in backwards order. */
4450 type
= element_type
;
4452 if (read_array_order (die
, cu
) == DW_ORD_col_major
)
4456 type
= create_array_type (NULL
, type
, range_types
[i
++]);
4461 type
= create_array_type (NULL
, type
, range_types
[ndim
]);
4464 /* Understand Dwarf2 support for vector types (like they occur on
4465 the PowerPC w/ AltiVec). Gcc just adds another attribute to the
4466 array type. This is not part of the Dwarf2/3 standard yet, but a
4467 custom vendor extension. The main difference between a regular
4468 array and the vector variant is that vectors are passed by value
4470 attr
= dwarf2_attr (die
, DW_AT_GNU_vector
, cu
);
4472 make_vector_type (type
);
4474 name
= dwarf2_name (die
, cu
);
4476 TYPE_NAME (type
) = name
;
4478 do_cleanups (back_to
);
4480 /* Install the type in the die. */
4481 set_die_type (die
, type
, cu
);
4484 static enum dwarf_array_dim_ordering
4485 read_array_order (struct die_info
*die
, struct dwarf2_cu
*cu
)
4487 struct attribute
*attr
;
4489 attr
= dwarf2_attr (die
, DW_AT_ordering
, cu
);
4491 if (attr
) return DW_SND (attr
);
4494 GNU F77 is a special case, as at 08/2004 array type info is the
4495 opposite order to the dwarf2 specification, but data is still
4496 laid out as per normal fortran.
4498 FIXME: dsl/2004-8-20: If G77 is ever fixed, this will also need
4502 if (cu
->language
== language_fortran
&&
4503 cu
->producer
&& strstr (cu
->producer
, "GNU F77"))
4505 return DW_ORD_row_major
;
4508 switch (cu
->language_defn
->la_array_ordering
)
4510 case array_column_major
:
4511 return DW_ORD_col_major
;
4512 case array_row_major
:
4514 return DW_ORD_row_major
;
4518 /* Extract all information from a DW_TAG_set_type DIE and put it in
4519 the DIE's type field. */
4522 read_set_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
4524 if (die
->type
== NULL
)
4525 die
->type
= create_set_type ((struct type
*) NULL
, die_type (die
, cu
));
4528 /* First cut: install each common block member as a global variable. */
4531 read_common_block (struct die_info
*die
, struct dwarf2_cu
*cu
)
4533 struct die_info
*child_die
;
4534 struct attribute
*attr
;
4536 CORE_ADDR base
= (CORE_ADDR
) 0;
4538 attr
= dwarf2_attr (die
, DW_AT_location
, cu
);
4541 /* Support the .debug_loc offsets */
4542 if (attr_form_is_block (attr
))
4544 base
= decode_locdesc (DW_BLOCK (attr
), cu
);
4546 else if (attr_form_is_section_offset (attr
))
4548 dwarf2_complex_location_expr_complaint ();
4552 dwarf2_invalid_attrib_class_complaint ("DW_AT_location",
4553 "common block member");
4556 if (die
->child
!= NULL
)
4558 child_die
= die
->child
;
4559 while (child_die
&& child_die
->tag
)
4561 sym
= new_symbol (child_die
, NULL
, cu
);
4562 attr
= dwarf2_attr (child_die
, DW_AT_data_member_location
, cu
);
4565 SYMBOL_VALUE_ADDRESS (sym
) =
4566 base
+ decode_locdesc (DW_BLOCK (attr
), cu
);
4567 add_symbol_to_list (sym
, &global_symbols
);
4569 child_die
= sibling_die (child_die
);
4574 /* Read a C++ namespace. */
4577 read_namespace (struct die_info
*die
, struct dwarf2_cu
*cu
)
4579 struct objfile
*objfile
= cu
->objfile
;
4580 const char *previous_prefix
= processing_current_prefix
;
4583 struct die_info
*current_die
;
4584 struct cleanup
*back_to
= make_cleanup (null_cleanup
, 0);
4586 name
= namespace_name (die
, &is_anonymous
, cu
);
4588 /* Now build the name of the current namespace. */
4590 if (previous_prefix
[0] == '\0')
4592 processing_current_prefix
= name
;
4596 char *temp_name
= typename_concat (NULL
, previous_prefix
, name
, cu
);
4597 make_cleanup (xfree
, temp_name
);
4598 processing_current_prefix
= temp_name
;
4601 /* Add a symbol associated to this if we haven't seen the namespace
4602 before. Also, add a using directive if it's an anonymous
4605 if (dwarf2_extension (die
, cu
) == NULL
)
4609 /* FIXME: carlton/2003-06-27: Once GDB is more const-correct,
4610 this cast will hopefully become unnecessary. */
4611 type
= init_type (TYPE_CODE_NAMESPACE
, 0, 0,
4612 (char *) processing_current_prefix
,
4614 TYPE_TAG_NAME (type
) = TYPE_NAME (type
);
4616 new_symbol (die
, type
, cu
);
4617 set_die_type (die
, type
, cu
);
4620 cp_add_using_directive (processing_current_prefix
,
4621 strlen (previous_prefix
),
4622 strlen (processing_current_prefix
));
4625 if (die
->child
!= NULL
)
4627 struct die_info
*child_die
= die
->child
;
4629 while (child_die
&& child_die
->tag
)
4631 process_die (child_die
, cu
);
4632 child_die
= sibling_die (child_die
);
4636 processing_current_prefix
= previous_prefix
;
4637 do_cleanups (back_to
);
4640 /* Return the name of the namespace represented by DIE. Set
4641 *IS_ANONYMOUS to tell whether or not the namespace is an anonymous
4645 namespace_name (struct die_info
*die
, int *is_anonymous
, struct dwarf2_cu
*cu
)
4647 struct die_info
*current_die
;
4648 const char *name
= NULL
;
4650 /* Loop through the extensions until we find a name. */
4652 for (current_die
= die
;
4653 current_die
!= NULL
;
4654 current_die
= dwarf2_extension (die
, cu
))
4656 name
= dwarf2_name (current_die
, cu
);
4661 /* Is it an anonymous namespace? */
4663 *is_anonymous
= (name
== NULL
);
4665 name
= "(anonymous namespace)";
4670 /* Extract all information from a DW_TAG_pointer_type DIE and add to
4671 the user defined type vector. */
4674 read_tag_pointer_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
4676 struct gdbarch
*gdbarch
= get_objfile_arch (cu
->objfile
);
4677 struct comp_unit_head
*cu_header
= &cu
->header
;
4679 struct attribute
*attr_byte_size
;
4680 struct attribute
*attr_address_class
;
4681 int byte_size
, addr_class
;
4688 type
= lookup_pointer_type (die_type (die
, cu
));
4690 attr_byte_size
= dwarf2_attr (die
, DW_AT_byte_size
, cu
);
4692 byte_size
= DW_UNSND (attr_byte_size
);
4694 byte_size
= cu_header
->addr_size
;
4696 attr_address_class
= dwarf2_attr (die
, DW_AT_address_class
, cu
);
4697 if (attr_address_class
)
4698 addr_class
= DW_UNSND (attr_address_class
);
4700 addr_class
= DW_ADDR_none
;
4702 /* If the pointer size or address class is different than the
4703 default, create a type variant marked as such and set the
4704 length accordingly. */
4705 if (TYPE_LENGTH (type
) != byte_size
|| addr_class
!= DW_ADDR_none
)
4707 if (gdbarch_address_class_type_flags_p (gdbarch
))
4711 type_flags
= gdbarch_address_class_type_flags
4712 (gdbarch
, byte_size
, addr_class
);
4713 gdb_assert ((type_flags
& ~TYPE_FLAG_ADDRESS_CLASS_ALL
) == 0);
4714 type
= make_type_with_address_space (type
, type_flags
);
4716 else if (TYPE_LENGTH (type
) != byte_size
)
4718 complaint (&symfile_complaints
, _("invalid pointer size %d"), byte_size
);
4721 /* Should we also complain about unhandled address classes? */
4725 TYPE_LENGTH (type
) = byte_size
;
4726 set_die_type (die
, type
, cu
);
4729 /* Extract all information from a DW_TAG_ptr_to_member_type DIE and add to
4730 the user defined type vector. */
4733 read_tag_ptr_to_member_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
4735 struct objfile
*objfile
= cu
->objfile
;
4737 struct type
*to_type
;
4738 struct type
*domain
;
4745 to_type
= die_type (die
, cu
);
4746 domain
= die_containing_type (die
, cu
);
4748 if (TYPE_CODE (check_typedef (to_type
)) == TYPE_CODE_METHOD
)
4749 type
= lookup_methodptr_type (to_type
);
4751 type
= lookup_memberptr_type (to_type
, domain
);
4753 set_die_type (die
, type
, cu
);
4756 /* Extract all information from a DW_TAG_reference_type DIE and add to
4757 the user defined type vector. */
4760 read_tag_reference_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
4762 struct comp_unit_head
*cu_header
= &cu
->header
;
4764 struct attribute
*attr
;
4771 type
= lookup_reference_type (die_type (die
, cu
));
4772 attr
= dwarf2_attr (die
, DW_AT_byte_size
, cu
);
4775 TYPE_LENGTH (type
) = DW_UNSND (attr
);
4779 TYPE_LENGTH (type
) = cu_header
->addr_size
;
4781 set_die_type (die
, type
, cu
);
4785 read_tag_const_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
4787 struct type
*base_type
;
4794 base_type
= die_type (die
, cu
);
4795 set_die_type (die
, make_cv_type (1, TYPE_VOLATILE (base_type
), base_type
, 0),
4800 read_tag_volatile_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
4802 struct type
*base_type
;
4809 base_type
= die_type (die
, cu
);
4810 set_die_type (die
, make_cv_type (TYPE_CONST (base_type
), 1, base_type
, 0),
4814 /* Extract all information from a DW_TAG_string_type DIE and add to
4815 the user defined type vector. It isn't really a user defined type,
4816 but it behaves like one, with other DIE's using an AT_user_def_type
4817 attribute to reference it. */
4820 read_tag_string_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
4822 struct objfile
*objfile
= cu
->objfile
;
4823 struct type
*type
, *range_type
, *index_type
, *char_type
;
4824 struct attribute
*attr
;
4825 unsigned int length
;
4832 attr
= dwarf2_attr (die
, DW_AT_string_length
, cu
);
4835 length
= DW_UNSND (attr
);
4839 /* check for the DW_AT_byte_size attribute */
4840 attr
= dwarf2_attr (die
, DW_AT_byte_size
, cu
);
4843 length
= DW_UNSND (attr
);
4851 index_type
= builtin_type_int32
;
4852 range_type
= create_range_type (NULL
, index_type
, 1, length
);
4853 type
= create_string_type (NULL
, range_type
);
4855 set_die_type (die
, type
, cu
);
4858 /* Handle DIES due to C code like:
4862 int (*funcp)(int a, long l);
4866 ('funcp' generates a DW_TAG_subroutine_type DIE)
4870 read_subroutine_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
4872 struct type
*type
; /* Type that this function returns */
4873 struct type
*ftype
; /* Function that returns above type */
4874 struct attribute
*attr
;
4876 /* Decode the type that this subroutine returns */
4881 type
= die_type (die
, cu
);
4882 ftype
= make_function_type (type
, (struct type
**) 0);
4884 /* All functions in C++, Pascal and Java have prototypes. */
4885 attr
= dwarf2_attr (die
, DW_AT_prototyped
, cu
);
4886 if ((attr
&& (DW_UNSND (attr
) != 0))
4887 || cu
->language
== language_cplus
4888 || cu
->language
== language_java
4889 || cu
->language
== language_pascal
)
4890 TYPE_FLAGS (ftype
) |= TYPE_FLAG_PROTOTYPED
;
4892 if (die
->child
!= NULL
)
4894 struct die_info
*child_die
;
4898 /* Count the number of parameters.
4899 FIXME: GDB currently ignores vararg functions, but knows about
4900 vararg member functions. */
4901 child_die
= die
->child
;
4902 while (child_die
&& child_die
->tag
)
4904 if (child_die
->tag
== DW_TAG_formal_parameter
)
4906 else if (child_die
->tag
== DW_TAG_unspecified_parameters
)
4907 TYPE_FLAGS (ftype
) |= TYPE_FLAG_VARARGS
;
4908 child_die
= sibling_die (child_die
);
4911 /* Allocate storage for parameters and fill them in. */
4912 TYPE_NFIELDS (ftype
) = nparams
;
4913 TYPE_FIELDS (ftype
) = (struct field
*)
4914 TYPE_ZALLOC (ftype
, nparams
* sizeof (struct field
));
4916 child_die
= die
->child
;
4917 while (child_die
&& child_die
->tag
)
4919 if (child_die
->tag
== DW_TAG_formal_parameter
)
4921 /* Dwarf2 has no clean way to discern C++ static and non-static
4922 member functions. G++ helps GDB by marking the first
4923 parameter for non-static member functions (which is the
4924 this pointer) as artificial. We pass this information
4925 to dwarf2_add_member_fn via TYPE_FIELD_ARTIFICIAL. */
4926 attr
= dwarf2_attr (child_die
, DW_AT_artificial
, cu
);
4928 TYPE_FIELD_ARTIFICIAL (ftype
, iparams
) = DW_UNSND (attr
);
4930 TYPE_FIELD_ARTIFICIAL (ftype
, iparams
) = 0;
4931 TYPE_FIELD_TYPE (ftype
, iparams
) = die_type (child_die
, cu
);
4934 child_die
= sibling_die (child_die
);
4938 set_die_type (die
, ftype
, cu
);
4942 read_typedef (struct die_info
*die
, struct dwarf2_cu
*cu
)
4944 struct objfile
*objfile
= cu
->objfile
;
4945 struct attribute
*attr
;
4950 name
= dwarf2_name (die
, cu
);
4951 set_die_type (die
, init_type (TYPE_CODE_TYPEDEF
, 0,
4952 TYPE_FLAG_TARGET_STUB
, name
, objfile
),
4954 TYPE_TARGET_TYPE (die
->type
) = die_type (die
, cu
);
4958 /* Find a representation of a given base type and install
4959 it in the TYPE field of the die. */
4962 read_base_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
4964 struct objfile
*objfile
= cu
->objfile
;
4966 struct attribute
*attr
;
4967 int encoding
= 0, size
= 0;
4969 enum type_code code
= TYPE_CODE_INT
;
4971 struct type
*target_type
= NULL
;
4973 /* If we've already decoded this die, this is a no-op. */
4979 attr
= dwarf2_attr (die
, DW_AT_encoding
, cu
);
4982 encoding
= DW_UNSND (attr
);
4984 attr
= dwarf2_attr (die
, DW_AT_byte_size
, cu
);
4987 size
= DW_UNSND (attr
);
4989 name
= dwarf2_name (die
, cu
);
4992 complaint (&symfile_complaints
,
4993 _("DW_AT_name missing from DW_TAG_base_type"));
4998 case DW_ATE_address
:
4999 /* Turn DW_ATE_address into a void * pointer. */
5000 code
= TYPE_CODE_PTR
;
5001 type_flags
|= TYPE_FLAG_UNSIGNED
;
5002 target_type
= init_type (TYPE_CODE_VOID
, 1, 0, NULL
, objfile
);
5004 case DW_ATE_boolean
:
5005 code
= TYPE_CODE_BOOL
;
5006 type_flags
|= TYPE_FLAG_UNSIGNED
;
5008 case DW_ATE_complex_float
:
5009 code
= TYPE_CODE_COMPLEX
;
5010 target_type
= init_type (TYPE_CODE_FLT
, size
/ 2, 0, NULL
, objfile
);
5012 case DW_ATE_decimal_float
:
5013 code
= TYPE_CODE_DECFLOAT
;
5016 code
= TYPE_CODE_FLT
;
5020 case DW_ATE_unsigned
:
5021 type_flags
|= TYPE_FLAG_UNSIGNED
;
5023 case DW_ATE_signed_char
:
5024 if (cu
->language
== language_ada
|| cu
->language
== language_m2
)
5025 code
= TYPE_CODE_CHAR
;
5027 case DW_ATE_unsigned_char
:
5028 if (cu
->language
== language_ada
|| cu
->language
== language_m2
)
5029 code
= TYPE_CODE_CHAR
;
5030 type_flags
|= TYPE_FLAG_UNSIGNED
;
5033 complaint (&symfile_complaints
, _("unsupported DW_AT_encoding: '%s'"),
5034 dwarf_type_encoding_name (encoding
));
5038 type
= init_type (code
, size
, type_flags
, name
, objfile
);
5039 TYPE_TARGET_TYPE (type
) = target_type
;
5041 set_die_type (die
, type
, cu
);
5044 /* Read the given DW_AT_subrange DIE. */
5047 read_subrange_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
5049 struct gdbarch
*gdbarch
= get_objfile_arch (cu
->objfile
);
5050 struct type
*base_type
;
5051 struct type
*range_type
;
5052 struct attribute
*attr
;
5057 /* If we have already decoded this die, then nothing more to do. */
5061 base_type
= die_type (die
, cu
);
5062 if (TYPE_CODE (base_type
) == TYPE_CODE_VOID
)
5064 complaint (&symfile_complaints
,
5065 _("DW_AT_type missing from DW_TAG_subrange_type"));
5067 = init_type (TYPE_CODE_INT
, gdbarch_addr_bit (gdbarch
) / 8,
5068 0, NULL
, cu
->objfile
);
5071 if (cu
->language
== language_fortran
)
5073 /* FORTRAN implies a lower bound of 1, if not given. */
5077 /* FIXME: For variable sized arrays either of these could be
5078 a variable rather than a constant value. We'll allow it,
5079 but we don't know how to handle it. */
5080 attr
= dwarf2_attr (die
, DW_AT_lower_bound
, cu
);
5082 low
= dwarf2_get_attr_constant_value (attr
, 0);
5084 attr
= dwarf2_attr (die
, DW_AT_upper_bound
, cu
);
5087 if (attr
->form
== DW_FORM_block1
)
5089 /* GCC encodes arrays with unspecified or dynamic length
5090 with a DW_FORM_block1 attribute.
5091 FIXME: GDB does not yet know how to handle dynamic
5092 arrays properly, treat them as arrays with unspecified
5095 FIXME: jimb/2003-09-22: GDB does not really know
5096 how to handle arrays of unspecified length
5097 either; we just represent them as zero-length
5098 arrays. Choose an appropriate upper bound given
5099 the lower bound we've computed above. */
5103 high
= dwarf2_get_attr_constant_value (attr
, 1);
5106 range_type
= create_range_type (NULL
, base_type
, low
, high
);
5108 name
= dwarf2_name (die
, cu
);
5110 TYPE_NAME (range_type
) = name
;
5112 attr
= dwarf2_attr (die
, DW_AT_byte_size
, cu
);
5114 TYPE_LENGTH (range_type
) = DW_UNSND (attr
);
5116 set_die_type (die
, range_type
, cu
);
5120 read_unspecified_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
5127 /* For now, we only support the C meaning of an unspecified type: void. */
5129 type
= init_type (TYPE_CODE_VOID
, 0, 0, dwarf2_name (die
, cu
),
5132 set_die_type (die
, type
, cu
);
5135 /* Read a whole compilation unit into a linked list of dies. */
5137 static struct die_info
*
5138 read_comp_unit (gdb_byte
*info_ptr
, bfd
*abfd
, struct dwarf2_cu
*cu
)
5140 return read_die_and_children (info_ptr
, abfd
, cu
, &info_ptr
, NULL
);
5143 /* Read a single die and all its descendents. Set the die's sibling
5144 field to NULL; set other fields in the die correctly, and set all
5145 of the descendents' fields correctly. Set *NEW_INFO_PTR to the
5146 location of the info_ptr after reading all of those dies. PARENT
5147 is the parent of the die in question. */
5149 static struct die_info
*
5150 read_die_and_children (gdb_byte
*info_ptr
, bfd
*abfd
,
5151 struct dwarf2_cu
*cu
,
5152 gdb_byte
**new_info_ptr
,
5153 struct die_info
*parent
)
5155 struct die_info
*die
;
5159 cur_ptr
= read_full_die (&die
, abfd
, info_ptr
, cu
, &has_children
);
5160 store_in_ref_table (die
->offset
, die
, cu
);
5164 die
->child
= read_die_and_siblings (cur_ptr
, abfd
, cu
,
5170 *new_info_ptr
= cur_ptr
;
5173 die
->sibling
= NULL
;
5174 die
->parent
= parent
;
5178 /* Read a die, all of its descendents, and all of its siblings; set
5179 all of the fields of all of the dies correctly. Arguments are as
5180 in read_die_and_children. */
5182 static struct die_info
*
5183 read_die_and_siblings (gdb_byte
*info_ptr
, bfd
*abfd
,
5184 struct dwarf2_cu
*cu
,
5185 gdb_byte
**new_info_ptr
,
5186 struct die_info
*parent
)
5188 struct die_info
*first_die
, *last_sibling
;
5192 first_die
= last_sibling
= NULL
;
5196 struct die_info
*die
5197 = read_die_and_children (cur_ptr
, abfd
, cu
, &cur_ptr
, parent
);
5205 last_sibling
->sibling
= die
;
5210 *new_info_ptr
= cur_ptr
;
5220 /* Free a linked list of dies. */
5223 free_die_list (struct die_info
*dies
)
5225 struct die_info
*die
, *next
;
5230 if (die
->child
!= NULL
)
5231 free_die_list (die
->child
);
5232 next
= die
->sibling
;
5239 /* Read the contents of the section at OFFSET and of size SIZE from the
5240 object file specified by OBJFILE into the objfile_obstack and return it. */
5243 dwarf2_read_section (struct objfile
*objfile
, asection
*sectp
)
5245 bfd
*abfd
= objfile
->obfd
;
5246 gdb_byte
*buf
, *retbuf
;
5247 bfd_size_type size
= bfd_get_section_size (sectp
);
5252 buf
= obstack_alloc (&objfile
->objfile_obstack
, size
);
5253 retbuf
= symfile_relocate_debug_section (abfd
, sectp
, buf
);
5257 if (bfd_seek (abfd
, sectp
->filepos
, SEEK_SET
) != 0
5258 || bfd_bread (buf
, size
, abfd
) != size
)
5259 error (_("Dwarf Error: Can't read DWARF data from '%s'"),
5260 bfd_get_filename (abfd
));
5265 /* In DWARF version 2, the description of the debugging information is
5266 stored in a separate .debug_abbrev section. Before we read any
5267 dies from a section we read in all abbreviations and install them
5268 in a hash table. This function also sets flags in CU describing
5269 the data found in the abbrev table. */
5272 dwarf2_read_abbrevs (bfd
*abfd
, struct dwarf2_cu
*cu
)
5274 struct comp_unit_head
*cu_header
= &cu
->header
;
5275 gdb_byte
*abbrev_ptr
;
5276 struct abbrev_info
*cur_abbrev
;
5277 unsigned int abbrev_number
, bytes_read
, abbrev_name
;
5278 unsigned int abbrev_form
, hash_number
;
5279 struct attr_abbrev
*cur_attrs
;
5280 unsigned int allocated_attrs
;
5282 /* Initialize dwarf2 abbrevs */
5283 obstack_init (&cu
->abbrev_obstack
);
5284 cu
->dwarf2_abbrevs
= obstack_alloc (&cu
->abbrev_obstack
,
5286 * sizeof (struct abbrev_info
*)));
5287 memset (cu
->dwarf2_abbrevs
, 0,
5288 ABBREV_HASH_SIZE
* sizeof (struct abbrev_info
*));
5290 abbrev_ptr
= dwarf2_per_objfile
->abbrev_buffer
+ cu_header
->abbrev_offset
;
5291 abbrev_number
= read_unsigned_leb128 (abfd
, abbrev_ptr
, &bytes_read
);
5292 abbrev_ptr
+= bytes_read
;
5294 allocated_attrs
= ATTR_ALLOC_CHUNK
;
5295 cur_attrs
= xmalloc (allocated_attrs
* sizeof (struct attr_abbrev
));
5297 /* loop until we reach an abbrev number of 0 */
5298 while (abbrev_number
)
5300 cur_abbrev
= dwarf_alloc_abbrev (cu
);
5302 /* read in abbrev header */
5303 cur_abbrev
->number
= abbrev_number
;
5304 cur_abbrev
->tag
= read_unsigned_leb128 (abfd
, abbrev_ptr
, &bytes_read
);
5305 abbrev_ptr
+= bytes_read
;
5306 cur_abbrev
->has_children
= read_1_byte (abfd
, abbrev_ptr
);
5309 if (cur_abbrev
->tag
== DW_TAG_namespace
)
5310 cu
->has_namespace_info
= 1;
5312 /* now read in declarations */
5313 abbrev_name
= read_unsigned_leb128 (abfd
, abbrev_ptr
, &bytes_read
);
5314 abbrev_ptr
+= bytes_read
;
5315 abbrev_form
= read_unsigned_leb128 (abfd
, abbrev_ptr
, &bytes_read
);
5316 abbrev_ptr
+= bytes_read
;
5319 if (cur_abbrev
->num_attrs
== allocated_attrs
)
5321 allocated_attrs
+= ATTR_ALLOC_CHUNK
;
5323 = xrealloc (cur_attrs
, (allocated_attrs
5324 * sizeof (struct attr_abbrev
)));
5327 /* Record whether this compilation unit might have
5328 inter-compilation-unit references. If we don't know what form
5329 this attribute will have, then it might potentially be a
5330 DW_FORM_ref_addr, so we conservatively expect inter-CU
5333 if (abbrev_form
== DW_FORM_ref_addr
5334 || abbrev_form
== DW_FORM_indirect
)
5335 cu
->has_form_ref_addr
= 1;
5337 cur_attrs
[cur_abbrev
->num_attrs
].name
= abbrev_name
;
5338 cur_attrs
[cur_abbrev
->num_attrs
++].form
= abbrev_form
;
5339 abbrev_name
= read_unsigned_leb128 (abfd
, abbrev_ptr
, &bytes_read
);
5340 abbrev_ptr
+= bytes_read
;
5341 abbrev_form
= read_unsigned_leb128 (abfd
, abbrev_ptr
, &bytes_read
);
5342 abbrev_ptr
+= bytes_read
;
5345 cur_abbrev
->attrs
= obstack_alloc (&cu
->abbrev_obstack
,
5346 (cur_abbrev
->num_attrs
5347 * sizeof (struct attr_abbrev
)));
5348 memcpy (cur_abbrev
->attrs
, cur_attrs
,
5349 cur_abbrev
->num_attrs
* sizeof (struct attr_abbrev
));
5351 hash_number
= abbrev_number
% ABBREV_HASH_SIZE
;
5352 cur_abbrev
->next
= cu
->dwarf2_abbrevs
[hash_number
];
5353 cu
->dwarf2_abbrevs
[hash_number
] = cur_abbrev
;
5355 /* Get next abbreviation.
5356 Under Irix6 the abbreviations for a compilation unit are not
5357 always properly terminated with an abbrev number of 0.
5358 Exit loop if we encounter an abbreviation which we have
5359 already read (which means we are about to read the abbreviations
5360 for the next compile unit) or if the end of the abbreviation
5361 table is reached. */
5362 if ((unsigned int) (abbrev_ptr
- dwarf2_per_objfile
->abbrev_buffer
)
5363 >= dwarf2_per_objfile
->abbrev_size
)
5365 abbrev_number
= read_unsigned_leb128 (abfd
, abbrev_ptr
, &bytes_read
);
5366 abbrev_ptr
+= bytes_read
;
5367 if (dwarf2_lookup_abbrev (abbrev_number
, cu
) != NULL
)
5374 /* Release the memory used by the abbrev table for a compilation unit. */
5377 dwarf2_free_abbrev_table (void *ptr_to_cu
)
5379 struct dwarf2_cu
*cu
= ptr_to_cu
;
5381 obstack_free (&cu
->abbrev_obstack
, NULL
);
5382 cu
->dwarf2_abbrevs
= NULL
;
5385 /* Lookup an abbrev_info structure in the abbrev hash table. */
5387 static struct abbrev_info
*
5388 dwarf2_lookup_abbrev (unsigned int number
, struct dwarf2_cu
*cu
)
5390 unsigned int hash_number
;
5391 struct abbrev_info
*abbrev
;
5393 hash_number
= number
% ABBREV_HASH_SIZE
;
5394 abbrev
= cu
->dwarf2_abbrevs
[hash_number
];
5398 if (abbrev
->number
== number
)
5401 abbrev
= abbrev
->next
;
5406 /* Returns nonzero if TAG represents a type that we might generate a partial
5410 is_type_tag_for_partial (int tag
)
5415 /* Some types that would be reasonable to generate partial symbols for,
5416 that we don't at present. */
5417 case DW_TAG_array_type
:
5418 case DW_TAG_file_type
:
5419 case DW_TAG_ptr_to_member_type
:
5420 case DW_TAG_set_type
:
5421 case DW_TAG_string_type
:
5422 case DW_TAG_subroutine_type
:
5424 case DW_TAG_base_type
:
5425 case DW_TAG_class_type
:
5426 case DW_TAG_interface_type
:
5427 case DW_TAG_enumeration_type
:
5428 case DW_TAG_structure_type
:
5429 case DW_TAG_subrange_type
:
5430 case DW_TAG_typedef
:
5431 case DW_TAG_union_type
:
5438 /* Load all DIEs that are interesting for partial symbols into memory. */
5440 static struct partial_die_info
*
5441 load_partial_dies (bfd
*abfd
, gdb_byte
*info_ptr
, int building_psymtab
,
5442 struct dwarf2_cu
*cu
)
5444 struct partial_die_info
*part_die
;
5445 struct partial_die_info
*parent_die
, *last_die
, *first_die
= NULL
;
5446 struct abbrev_info
*abbrev
;
5447 unsigned int bytes_read
;
5448 unsigned int load_all
= 0;
5450 int nesting_level
= 1;
5455 if (cu
->per_cu
&& cu
->per_cu
->load_all_dies
)
5459 = htab_create_alloc_ex (cu
->header
.length
/ 12,
5463 &cu
->comp_unit_obstack
,
5464 hashtab_obstack_allocate
,
5465 dummy_obstack_deallocate
);
5467 part_die
= obstack_alloc (&cu
->comp_unit_obstack
,
5468 sizeof (struct partial_die_info
));
5472 abbrev
= peek_die_abbrev (info_ptr
, &bytes_read
, cu
);
5474 /* A NULL abbrev means the end of a series of children. */
5477 if (--nesting_level
== 0)
5479 /* PART_DIE was probably the last thing allocated on the
5480 comp_unit_obstack, so we could call obstack_free
5481 here. We don't do that because the waste is small,
5482 and will be cleaned up when we're done with this
5483 compilation unit. This way, we're also more robust
5484 against other users of the comp_unit_obstack. */
5487 info_ptr
+= bytes_read
;
5488 last_die
= parent_die
;
5489 parent_die
= parent_die
->die_parent
;
5493 /* Check whether this DIE is interesting enough to save. Normally
5494 we would not be interested in members here, but there may be
5495 later variables referencing them via DW_AT_specification (for
5498 && !is_type_tag_for_partial (abbrev
->tag
)
5499 && abbrev
->tag
!= DW_TAG_enumerator
5500 && abbrev
->tag
!= DW_TAG_subprogram
5501 && abbrev
->tag
!= DW_TAG_variable
5502 && abbrev
->tag
!= DW_TAG_namespace
5503 && abbrev
->tag
!= DW_TAG_member
)
5505 /* Otherwise we skip to the next sibling, if any. */
5506 info_ptr
= skip_one_die (info_ptr
+ bytes_read
, abbrev
, cu
);
5510 info_ptr
= read_partial_die (part_die
, abbrev
, bytes_read
,
5511 abfd
, info_ptr
, cu
);
5513 /* This two-pass algorithm for processing partial symbols has a
5514 high cost in cache pressure. Thus, handle some simple cases
5515 here which cover the majority of C partial symbols. DIEs
5516 which neither have specification tags in them, nor could have
5517 specification tags elsewhere pointing at them, can simply be
5518 processed and discarded.
5520 This segment is also optional; scan_partial_symbols and
5521 add_partial_symbol will handle these DIEs if we chain
5522 them in normally. When compilers which do not emit large
5523 quantities of duplicate debug information are more common,
5524 this code can probably be removed. */
5526 /* Any complete simple types at the top level (pretty much all
5527 of them, for a language without namespaces), can be processed
5529 if (parent_die
== NULL
5530 && part_die
->has_specification
== 0
5531 && part_die
->is_declaration
== 0
5532 && (part_die
->tag
== DW_TAG_typedef
5533 || part_die
->tag
== DW_TAG_base_type
5534 || part_die
->tag
== DW_TAG_subrange_type
))
5536 if (building_psymtab
&& part_die
->name
!= NULL
)
5537 add_psymbol_to_list (part_die
->name
, strlen (part_die
->name
),
5538 VAR_DOMAIN
, LOC_TYPEDEF
,
5539 &cu
->objfile
->static_psymbols
,
5540 0, (CORE_ADDR
) 0, cu
->language
, cu
->objfile
);
5541 info_ptr
= locate_pdi_sibling (part_die
, info_ptr
, abfd
, cu
);
5545 /* If we're at the second level, and we're an enumerator, and
5546 our parent has no specification (meaning possibly lives in a
5547 namespace elsewhere), then we can add the partial symbol now
5548 instead of queueing it. */
5549 if (part_die
->tag
== DW_TAG_enumerator
5550 && parent_die
!= NULL
5551 && parent_die
->die_parent
== NULL
5552 && parent_die
->tag
== DW_TAG_enumeration_type
5553 && parent_die
->has_specification
== 0)
5555 if (part_die
->name
== NULL
)
5556 complaint (&symfile_complaints
, _("malformed enumerator DIE ignored"));
5557 else if (building_psymtab
)
5558 add_psymbol_to_list (part_die
->name
, strlen (part_die
->name
),
5559 VAR_DOMAIN
, LOC_CONST
,
5560 (cu
->language
== language_cplus
5561 || cu
->language
== language_java
)
5562 ? &cu
->objfile
->global_psymbols
5563 : &cu
->objfile
->static_psymbols
,
5564 0, (CORE_ADDR
) 0, cu
->language
, cu
->objfile
);
5566 info_ptr
= locate_pdi_sibling (part_die
, info_ptr
, abfd
, cu
);
5570 /* We'll save this DIE so link it in. */
5571 part_die
->die_parent
= parent_die
;
5572 part_die
->die_sibling
= NULL
;
5573 part_die
->die_child
= NULL
;
5575 if (last_die
&& last_die
== parent_die
)
5576 last_die
->die_child
= part_die
;
5578 last_die
->die_sibling
= part_die
;
5580 last_die
= part_die
;
5582 if (first_die
== NULL
)
5583 first_die
= part_die
;
5585 /* Maybe add the DIE to the hash table. Not all DIEs that we
5586 find interesting need to be in the hash table, because we
5587 also have the parent/sibling/child chains; only those that we
5588 might refer to by offset later during partial symbol reading.
5590 For now this means things that might have be the target of a
5591 DW_AT_specification, DW_AT_abstract_origin, or
5592 DW_AT_extension. DW_AT_extension will refer only to
5593 namespaces; DW_AT_abstract_origin refers to functions (and
5594 many things under the function DIE, but we do not recurse
5595 into function DIEs during partial symbol reading) and
5596 possibly variables as well; DW_AT_specification refers to
5597 declarations. Declarations ought to have the DW_AT_declaration
5598 flag. It happens that GCC forgets to put it in sometimes, but
5599 only for functions, not for types.
5601 Adding more things than necessary to the hash table is harmless
5602 except for the performance cost. Adding too few will result in
5603 wasted time in find_partial_die, when we reread the compilation
5604 unit with load_all_dies set. */
5607 || abbrev
->tag
== DW_TAG_subprogram
5608 || abbrev
->tag
== DW_TAG_variable
5609 || abbrev
->tag
== DW_TAG_namespace
5610 || part_die
->is_declaration
)
5614 slot
= htab_find_slot_with_hash (cu
->partial_dies
, part_die
,
5615 part_die
->offset
, INSERT
);
5619 part_die
= obstack_alloc (&cu
->comp_unit_obstack
,
5620 sizeof (struct partial_die_info
));
5622 /* For some DIEs we want to follow their children (if any). For C
5623 we have no reason to follow the children of structures; for other
5624 languages we have to, both so that we can get at method physnames
5625 to infer fully qualified class names, and for DW_AT_specification. */
5626 if (last_die
->has_children
5628 || last_die
->tag
== DW_TAG_namespace
5629 || last_die
->tag
== DW_TAG_enumeration_type
5630 || (cu
->language
!= language_c
5631 && (last_die
->tag
== DW_TAG_class_type
5632 || last_die
->tag
== DW_TAG_interface_type
5633 || last_die
->tag
== DW_TAG_structure_type
5634 || last_die
->tag
== DW_TAG_union_type
))))
5637 parent_die
= last_die
;
5641 /* Otherwise we skip to the next sibling, if any. */
5642 info_ptr
= locate_pdi_sibling (last_die
, info_ptr
, abfd
, cu
);
5644 /* Back to the top, do it again. */
5648 /* Read a minimal amount of information into the minimal die structure. */
5651 read_partial_die (struct partial_die_info
*part_die
,
5652 struct abbrev_info
*abbrev
,
5653 unsigned int abbrev_len
, bfd
*abfd
,
5654 gdb_byte
*info_ptr
, struct dwarf2_cu
*cu
)
5656 unsigned int bytes_read
, i
;
5657 struct attribute attr
;
5658 int has_low_pc_attr
= 0;
5659 int has_high_pc_attr
= 0;
5661 memset (part_die
, 0, sizeof (struct partial_die_info
));
5663 part_die
->offset
= info_ptr
- dwarf2_per_objfile
->info_buffer
;
5665 info_ptr
+= abbrev_len
;
5670 part_die
->tag
= abbrev
->tag
;
5671 part_die
->has_children
= abbrev
->has_children
;
5673 for (i
= 0; i
< abbrev
->num_attrs
; ++i
)
5675 info_ptr
= read_attribute (&attr
, &abbrev
->attrs
[i
], abfd
, info_ptr
, cu
);
5677 /* Store the data if it is of an attribute we want to keep in a
5678 partial symbol table. */
5683 /* Prefer DW_AT_MIPS_linkage_name over DW_AT_name. */
5684 if (part_die
->name
== NULL
)
5685 part_die
->name
= DW_STRING (&attr
);
5687 case DW_AT_comp_dir
:
5688 if (part_die
->dirname
== NULL
)
5689 part_die
->dirname
= DW_STRING (&attr
);
5691 case DW_AT_MIPS_linkage_name
:
5692 part_die
->name
= DW_STRING (&attr
);
5695 has_low_pc_attr
= 1;
5696 part_die
->lowpc
= DW_ADDR (&attr
);
5699 has_high_pc_attr
= 1;
5700 part_die
->highpc
= DW_ADDR (&attr
);
5703 if (dwarf2_ranges_read (DW_UNSND (&attr
), &part_die
->lowpc
,
5704 &part_die
->highpc
, cu
))
5705 has_low_pc_attr
= has_high_pc_attr
= 1;
5707 case DW_AT_location
:
5708 /* Support the .debug_loc offsets */
5709 if (attr_form_is_block (&attr
))
5711 part_die
->locdesc
= DW_BLOCK (&attr
);
5713 else if (attr_form_is_section_offset (&attr
))
5715 dwarf2_complex_location_expr_complaint ();
5719 dwarf2_invalid_attrib_class_complaint ("DW_AT_location",
5720 "partial symbol information");
5723 case DW_AT_language
:
5724 part_die
->language
= DW_UNSND (&attr
);
5726 case DW_AT_external
:
5727 part_die
->is_external
= DW_UNSND (&attr
);
5729 case DW_AT_declaration
:
5730 part_die
->is_declaration
= DW_UNSND (&attr
);
5733 part_die
->has_type
= 1;
5735 case DW_AT_abstract_origin
:
5736 case DW_AT_specification
:
5737 case DW_AT_extension
:
5738 part_die
->has_specification
= 1;
5739 part_die
->spec_offset
= dwarf2_get_ref_die_offset (&attr
, cu
);
5742 /* Ignore absolute siblings, they might point outside of
5743 the current compile unit. */
5744 if (attr
.form
== DW_FORM_ref_addr
)
5745 complaint (&symfile_complaints
, _("ignoring absolute DW_AT_sibling"));
5747 part_die
->sibling
= dwarf2_per_objfile
->info_buffer
5748 + dwarf2_get_ref_die_offset (&attr
, cu
);
5750 case DW_AT_stmt_list
:
5751 part_die
->has_stmt_list
= 1;
5752 part_die
->line_offset
= DW_UNSND (&attr
);
5754 case DW_AT_byte_size
:
5755 part_die
->has_byte_size
= 1;
5757 case DW_AT_calling_convention
:
5758 /* DWARF doesn't provide a way to identify a program's source-level
5759 entry point. DW_AT_calling_convention attributes are only meant
5760 to describe functions' calling conventions.
5762 However, because it's a necessary piece of information in
5763 Fortran, and because DW_CC_program is the only piece of debugging
5764 information whose definition refers to a 'main program' at all,
5765 several compilers have begun marking Fortran main programs with
5766 DW_CC_program --- even when those functions use the standard
5767 calling conventions.
5769 So until DWARF specifies a way to provide this information and
5770 compilers pick up the new representation, we'll support this
5772 if (DW_UNSND (&attr
) == DW_CC_program
5773 && cu
->language
== language_fortran
)
5774 set_main_name (part_die
->name
);
5781 /* When using the GNU linker, .gnu.linkonce. sections are used to
5782 eliminate duplicate copies of functions and vtables and such.
5783 The linker will arbitrarily choose one and discard the others.
5784 The AT_*_pc values for such functions refer to local labels in
5785 these sections. If the section from that file was discarded, the
5786 labels are not in the output, so the relocs get a value of 0.
5787 If this is a discarded function, mark the pc bounds as invalid,
5788 so that GDB will ignore it. */
5789 if (has_low_pc_attr
&& has_high_pc_attr
5790 && part_die
->lowpc
< part_die
->highpc
5791 && (part_die
->lowpc
!= 0
5792 || dwarf2_per_objfile
->has_section_at_zero
))
5793 part_die
->has_pc_info
= 1;
5797 /* Find a cached partial DIE at OFFSET in CU. */
5799 static struct partial_die_info
*
5800 find_partial_die_in_comp_unit (unsigned long offset
, struct dwarf2_cu
*cu
)
5802 struct partial_die_info
*lookup_die
= NULL
;
5803 struct partial_die_info part_die
;
5805 part_die
.offset
= offset
;
5806 lookup_die
= htab_find_with_hash (cu
->partial_dies
, &part_die
, offset
);
5811 /* Find a partial DIE at OFFSET, which may or may not be in CU. */
5813 static struct partial_die_info
*
5814 find_partial_die (unsigned long offset
, struct dwarf2_cu
*cu
)
5816 struct dwarf2_per_cu_data
*per_cu
= NULL
;
5817 struct partial_die_info
*pd
= NULL
;
5819 if (offset
>= cu
->header
.offset
5820 && offset
< cu
->header
.offset
+ cu
->header
.length
)
5822 pd
= find_partial_die_in_comp_unit (offset
, cu
);
5827 per_cu
= dwarf2_find_containing_comp_unit (offset
, cu
->objfile
);
5829 if (per_cu
->cu
== NULL
)
5831 load_comp_unit (per_cu
, cu
->objfile
);
5832 per_cu
->cu
->read_in_chain
= dwarf2_per_objfile
->read_in_chain
;
5833 dwarf2_per_objfile
->read_in_chain
= per_cu
;
5836 per_cu
->cu
->last_used
= 0;
5837 pd
= find_partial_die_in_comp_unit (offset
, per_cu
->cu
);
5839 if (pd
== NULL
&& per_cu
->load_all_dies
== 0)
5841 struct cleanup
*back_to
;
5842 struct partial_die_info comp_unit_die
;
5843 struct abbrev_info
*abbrev
;
5844 unsigned int bytes_read
;
5847 per_cu
->load_all_dies
= 1;
5849 /* Re-read the DIEs. */
5850 back_to
= make_cleanup (null_cleanup
, 0);
5851 if (per_cu
->cu
->dwarf2_abbrevs
== NULL
)
5853 dwarf2_read_abbrevs (per_cu
->cu
->objfile
->obfd
, per_cu
->cu
);
5854 back_to
= make_cleanup (dwarf2_free_abbrev_table
, per_cu
->cu
);
5856 info_ptr
= per_cu
->cu
->header
.first_die_ptr
;
5857 abbrev
= peek_die_abbrev (info_ptr
, &bytes_read
, per_cu
->cu
);
5858 info_ptr
= read_partial_die (&comp_unit_die
, abbrev
, bytes_read
,
5859 per_cu
->cu
->objfile
->obfd
, info_ptr
,
5861 if (comp_unit_die
.has_children
)
5862 load_partial_dies (per_cu
->cu
->objfile
->obfd
, info_ptr
, 0, per_cu
->cu
);
5863 do_cleanups (back_to
);
5865 pd
= find_partial_die_in_comp_unit (offset
, per_cu
->cu
);
5869 internal_error (__FILE__
, __LINE__
,
5870 _("could not find partial DIE 0x%lx in cache [from module %s]\n"),
5871 offset
, bfd_get_filename (cu
->objfile
->obfd
));
5875 /* Adjust PART_DIE before generating a symbol for it. This function
5876 may set the is_external flag or change the DIE's name. */
5879 fixup_partial_die (struct partial_die_info
*part_die
,
5880 struct dwarf2_cu
*cu
)
5882 /* If we found a reference attribute and the DIE has no name, try
5883 to find a name in the referred to DIE. */
5885 if (part_die
->name
== NULL
&& part_die
->has_specification
)
5887 struct partial_die_info
*spec_die
;
5889 spec_die
= find_partial_die (part_die
->spec_offset
, cu
);
5891 fixup_partial_die (spec_die
, cu
);
5895 part_die
->name
= spec_die
->name
;
5897 /* Copy DW_AT_external attribute if it is set. */
5898 if (spec_die
->is_external
)
5899 part_die
->is_external
= spec_die
->is_external
;
5903 /* Set default names for some unnamed DIEs. */
5904 if (part_die
->name
== NULL
&& (part_die
->tag
== DW_TAG_structure_type
5905 || part_die
->tag
== DW_TAG_class_type
))
5906 part_die
->name
= "(anonymous class)";
5908 if (part_die
->name
== NULL
&& part_die
->tag
== DW_TAG_namespace
)
5909 part_die
->name
= "(anonymous namespace)";
5911 if (part_die
->tag
== DW_TAG_structure_type
5912 || part_die
->tag
== DW_TAG_class_type
5913 || part_die
->tag
== DW_TAG_union_type
)
5914 guess_structure_name (part_die
, cu
);
5917 /* Read the die from the .debug_info section buffer. Set DIEP to
5918 point to a newly allocated die with its information, except for its
5919 child, sibling, and parent fields. Set HAS_CHILDREN to tell
5920 whether the die has children or not. */
5923 read_full_die (struct die_info
**diep
, bfd
*abfd
, gdb_byte
*info_ptr
,
5924 struct dwarf2_cu
*cu
, int *has_children
)
5926 unsigned int abbrev_number
, bytes_read
, i
, offset
;
5927 struct abbrev_info
*abbrev
;
5928 struct die_info
*die
;
5930 offset
= info_ptr
- dwarf2_per_objfile
->info_buffer
;
5931 abbrev_number
= read_unsigned_leb128 (abfd
, info_ptr
, &bytes_read
);
5932 info_ptr
+= bytes_read
;
5935 die
= dwarf_alloc_die ();
5937 die
->abbrev
= abbrev_number
;
5944 abbrev
= dwarf2_lookup_abbrev (abbrev_number
, cu
);
5947 error (_("Dwarf Error: could not find abbrev number %d [in module %s]"),
5949 bfd_get_filename (abfd
));
5951 die
= dwarf_alloc_die ();
5952 die
->offset
= offset
;
5953 die
->tag
= abbrev
->tag
;
5954 die
->abbrev
= abbrev_number
;
5957 die
->num_attrs
= abbrev
->num_attrs
;
5958 die
->attrs
= (struct attribute
*)
5959 xmalloc (die
->num_attrs
* sizeof (struct attribute
));
5961 for (i
= 0; i
< abbrev
->num_attrs
; ++i
)
5963 info_ptr
= read_attribute (&die
->attrs
[i
], &abbrev
->attrs
[i
],
5964 abfd
, info_ptr
, cu
);
5966 /* If this attribute is an absolute reference to a different
5967 compilation unit, make sure that compilation unit is loaded
5969 if (die
->attrs
[i
].form
== DW_FORM_ref_addr
5970 && (DW_ADDR (&die
->attrs
[i
]) < cu
->header
.offset
5971 || (DW_ADDR (&die
->attrs
[i
])
5972 >= cu
->header
.offset
+ cu
->header
.length
)))
5974 struct dwarf2_per_cu_data
*per_cu
;
5975 per_cu
= dwarf2_find_containing_comp_unit (DW_ADDR (&die
->attrs
[i
]),
5978 /* Mark the dependence relation so that we don't flush PER_CU
5980 dwarf2_add_dependence (cu
, per_cu
);
5982 /* If it's already on the queue, we have nothing to do. */
5986 /* If the compilation unit is already loaded, just mark it as
5988 if (per_cu
->cu
!= NULL
)
5990 per_cu
->cu
->last_used
= 0;
5994 /* Add it to the queue. */
5995 queue_comp_unit (per_cu
);
6000 *has_children
= abbrev
->has_children
;
6004 /* Read an attribute value described by an attribute form. */
6007 read_attribute_value (struct attribute
*attr
, unsigned form
,
6008 bfd
*abfd
, gdb_byte
*info_ptr
,
6009 struct dwarf2_cu
*cu
)
6011 struct comp_unit_head
*cu_header
= &cu
->header
;
6012 unsigned int bytes_read
;
6013 struct dwarf_block
*blk
;
6019 case DW_FORM_ref_addr
:
6020 DW_ADDR (attr
) = read_address (abfd
, info_ptr
, cu
, &bytes_read
);
6021 info_ptr
+= bytes_read
;
6023 case DW_FORM_block2
:
6024 blk
= dwarf_alloc_block (cu
);
6025 blk
->size
= read_2_bytes (abfd
, info_ptr
);
6027 blk
->data
= read_n_bytes (abfd
, info_ptr
, blk
->size
);
6028 info_ptr
+= blk
->size
;
6029 DW_BLOCK (attr
) = blk
;
6031 case DW_FORM_block4
:
6032 blk
= dwarf_alloc_block (cu
);
6033 blk
->size
= read_4_bytes (abfd
, info_ptr
);
6035 blk
->data
= read_n_bytes (abfd
, info_ptr
, blk
->size
);
6036 info_ptr
+= blk
->size
;
6037 DW_BLOCK (attr
) = blk
;
6040 DW_UNSND (attr
) = read_2_bytes (abfd
, info_ptr
);
6044 DW_UNSND (attr
) = read_4_bytes (abfd
, info_ptr
);
6048 DW_UNSND (attr
) = read_8_bytes (abfd
, info_ptr
);
6051 case DW_FORM_string
:
6052 DW_STRING (attr
) = read_string (abfd
, info_ptr
, &bytes_read
);
6053 info_ptr
+= bytes_read
;
6056 DW_STRING (attr
) = read_indirect_string (abfd
, info_ptr
, cu_header
,
6058 info_ptr
+= bytes_read
;
6061 blk
= dwarf_alloc_block (cu
);
6062 blk
->size
= read_unsigned_leb128 (abfd
, info_ptr
, &bytes_read
);
6063 info_ptr
+= bytes_read
;
6064 blk
->data
= read_n_bytes (abfd
, info_ptr
, blk
->size
);
6065 info_ptr
+= blk
->size
;
6066 DW_BLOCK (attr
) = blk
;
6068 case DW_FORM_block1
:
6069 blk
= dwarf_alloc_block (cu
);
6070 blk
->size
= read_1_byte (abfd
, info_ptr
);
6072 blk
->data
= read_n_bytes (abfd
, info_ptr
, blk
->size
);
6073 info_ptr
+= blk
->size
;
6074 DW_BLOCK (attr
) = blk
;
6077 DW_UNSND (attr
) = read_1_byte (abfd
, info_ptr
);
6081 DW_UNSND (attr
) = read_1_byte (abfd
, info_ptr
);
6085 DW_SND (attr
) = read_signed_leb128 (abfd
, info_ptr
, &bytes_read
);
6086 info_ptr
+= bytes_read
;
6089 DW_UNSND (attr
) = read_unsigned_leb128 (abfd
, info_ptr
, &bytes_read
);
6090 info_ptr
+= bytes_read
;
6093 DW_ADDR (attr
) = cu
->header
.offset
+ read_1_byte (abfd
, info_ptr
);
6097 DW_ADDR (attr
) = cu
->header
.offset
+ read_2_bytes (abfd
, info_ptr
);
6101 DW_ADDR (attr
) = cu
->header
.offset
+ read_4_bytes (abfd
, info_ptr
);
6105 DW_ADDR (attr
) = cu
->header
.offset
+ read_8_bytes (abfd
, info_ptr
);
6108 case DW_FORM_ref_udata
:
6109 DW_ADDR (attr
) = (cu
->header
.offset
6110 + read_unsigned_leb128 (abfd
, info_ptr
, &bytes_read
));
6111 info_ptr
+= bytes_read
;
6113 case DW_FORM_indirect
:
6114 form
= read_unsigned_leb128 (abfd
, info_ptr
, &bytes_read
);
6115 info_ptr
+= bytes_read
;
6116 info_ptr
= read_attribute_value (attr
, form
, abfd
, info_ptr
, cu
);
6119 error (_("Dwarf Error: Cannot handle %s in DWARF reader [in module %s]"),
6120 dwarf_form_name (form
),
6121 bfd_get_filename (abfd
));
6126 /* Read an attribute described by an abbreviated attribute. */
6129 read_attribute (struct attribute
*attr
, struct attr_abbrev
*abbrev
,
6130 bfd
*abfd
, gdb_byte
*info_ptr
, struct dwarf2_cu
*cu
)
6132 attr
->name
= abbrev
->name
;
6133 return read_attribute_value (attr
, abbrev
->form
, abfd
, info_ptr
, cu
);
6136 /* read dwarf information from a buffer */
6139 read_1_byte (bfd
*abfd
, gdb_byte
*buf
)
6141 return bfd_get_8 (abfd
, buf
);
6145 read_1_signed_byte (bfd
*abfd
, gdb_byte
*buf
)
6147 return bfd_get_signed_8 (abfd
, buf
);
6151 read_2_bytes (bfd
*abfd
, gdb_byte
*buf
)
6153 return bfd_get_16 (abfd
, buf
);
6157 read_2_signed_bytes (bfd
*abfd
, gdb_byte
*buf
)
6159 return bfd_get_signed_16 (abfd
, buf
);
6163 read_4_bytes (bfd
*abfd
, gdb_byte
*buf
)
6165 return bfd_get_32 (abfd
, buf
);
6169 read_4_signed_bytes (bfd
*abfd
, gdb_byte
*buf
)
6171 return bfd_get_signed_32 (abfd
, buf
);
6174 static unsigned long
6175 read_8_bytes (bfd
*abfd
, gdb_byte
*buf
)
6177 return bfd_get_64 (abfd
, buf
);
6181 read_address (bfd
*abfd
, gdb_byte
*buf
, struct dwarf2_cu
*cu
,
6182 unsigned int *bytes_read
)
6184 struct comp_unit_head
*cu_header
= &cu
->header
;
6185 CORE_ADDR retval
= 0;
6187 if (cu_header
->signed_addr_p
)
6189 switch (cu_header
->addr_size
)
6192 retval
= bfd_get_signed_16 (abfd
, buf
);
6195 retval
= bfd_get_signed_32 (abfd
, buf
);
6198 retval
= bfd_get_signed_64 (abfd
, buf
);
6201 internal_error (__FILE__
, __LINE__
,
6202 _("read_address: bad switch, signed [in module %s]"),
6203 bfd_get_filename (abfd
));
6208 switch (cu_header
->addr_size
)
6211 retval
= bfd_get_16 (abfd
, buf
);
6214 retval
= bfd_get_32 (abfd
, buf
);
6217 retval
= bfd_get_64 (abfd
, buf
);
6220 internal_error (__FILE__
, __LINE__
,
6221 _("read_address: bad switch, unsigned [in module %s]"),
6222 bfd_get_filename (abfd
));
6226 *bytes_read
= cu_header
->addr_size
;
6230 /* Read the initial length from a section. The (draft) DWARF 3
6231 specification allows the initial length to take up either 4 bytes
6232 or 12 bytes. If the first 4 bytes are 0xffffffff, then the next 8
6233 bytes describe the length and all offsets will be 8 bytes in length
6236 An older, non-standard 64-bit format is also handled by this
6237 function. The older format in question stores the initial length
6238 as an 8-byte quantity without an escape value. Lengths greater
6239 than 2^32 aren't very common which means that the initial 4 bytes
6240 is almost always zero. Since a length value of zero doesn't make
6241 sense for the 32-bit format, this initial zero can be considered to
6242 be an escape value which indicates the presence of the older 64-bit
6243 format. As written, the code can't detect (old format) lengths
6244 greater than 4GB. If it becomes necessary to handle lengths
6245 somewhat larger than 4GB, we could allow other small values (such
6246 as the non-sensical values of 1, 2, and 3) to also be used as
6247 escape values indicating the presence of the old format.
6249 The value returned via bytes_read should be used to increment the
6250 relevant pointer after calling read_initial_length().
6252 As a side effect, this function sets the fields initial_length_size
6253 and offset_size in cu_header to the values appropriate for the
6254 length field. (The format of the initial length field determines
6255 the width of file offsets to be fetched later with read_offset().)
6257 [ Note: read_initial_length() and read_offset() are based on the
6258 document entitled "DWARF Debugging Information Format", revision
6259 3, draft 8, dated November 19, 2001. This document was obtained
6262 http://reality.sgiweb.org/davea/dwarf3-draft8-011125.pdf
6264 This document is only a draft and is subject to change. (So beware.)
6266 Details regarding the older, non-standard 64-bit format were
6267 determined empirically by examining 64-bit ELF files produced by
6268 the SGI toolchain on an IRIX 6.5 machine.
6270 - Kevin, July 16, 2002
6274 read_initial_length (bfd
*abfd
, gdb_byte
*buf
, struct comp_unit_head
*cu_header
,
6275 unsigned int *bytes_read
)
6277 LONGEST length
= bfd_get_32 (abfd
, buf
);
6279 if (length
== 0xffffffff)
6281 length
= bfd_get_64 (abfd
, buf
+ 4);
6284 else if (length
== 0)
6286 /* Handle the (non-standard) 64-bit DWARF2 format used by IRIX. */
6287 length
= bfd_get_64 (abfd
, buf
);
6297 gdb_assert (cu_header
->initial_length_size
== 0
6298 || cu_header
->initial_length_size
== 4
6299 || cu_header
->initial_length_size
== 8
6300 || cu_header
->initial_length_size
== 12);
6302 if (cu_header
->initial_length_size
!= 0
6303 && cu_header
->initial_length_size
!= *bytes_read
)
6304 complaint (&symfile_complaints
,
6305 _("intermixed 32-bit and 64-bit DWARF sections"));
6307 cu_header
->initial_length_size
= *bytes_read
;
6308 cu_header
->offset_size
= (*bytes_read
== 4) ? 4 : 8;
6314 /* Read an offset from the data stream. The size of the offset is
6315 given by cu_header->offset_size. */
6318 read_offset (bfd
*abfd
, gdb_byte
*buf
, const struct comp_unit_head
*cu_header
,
6319 unsigned int *bytes_read
)
6323 switch (cu_header
->offset_size
)
6326 retval
= bfd_get_32 (abfd
, buf
);
6330 retval
= bfd_get_64 (abfd
, buf
);
6334 internal_error (__FILE__
, __LINE__
,
6335 _("read_offset: bad switch [in module %s]"),
6336 bfd_get_filename (abfd
));
6343 read_n_bytes (bfd
*abfd
, gdb_byte
*buf
, unsigned int size
)
6345 /* If the size of a host char is 8 bits, we can return a pointer
6346 to the buffer, otherwise we have to copy the data to a buffer
6347 allocated on the temporary obstack. */
6348 gdb_assert (HOST_CHAR_BIT
== 8);
6353 read_string (bfd
*abfd
, gdb_byte
*buf
, unsigned int *bytes_read_ptr
)
6355 /* If the size of a host char is 8 bits, we can return a pointer
6356 to the string, otherwise we have to copy the string to a buffer
6357 allocated on the temporary obstack. */
6358 gdb_assert (HOST_CHAR_BIT
== 8);
6361 *bytes_read_ptr
= 1;
6364 *bytes_read_ptr
= strlen ((char *) buf
) + 1;
6365 return (char *) buf
;
6369 read_indirect_string (bfd
*abfd
, gdb_byte
*buf
,
6370 const struct comp_unit_head
*cu_header
,
6371 unsigned int *bytes_read_ptr
)
6373 LONGEST str_offset
= read_offset (abfd
, buf
, cu_header
,
6376 if (dwarf2_per_objfile
->str_buffer
== NULL
)
6378 error (_("DW_FORM_strp used without .debug_str section [in module %s]"),
6379 bfd_get_filename (abfd
));
6382 if (str_offset
>= dwarf2_per_objfile
->str_size
)
6384 error (_("DW_FORM_strp pointing outside of .debug_str section [in module %s]"),
6385 bfd_get_filename (abfd
));
6388 gdb_assert (HOST_CHAR_BIT
== 8);
6389 if (dwarf2_per_objfile
->str_buffer
[str_offset
] == '\0')
6391 return (char *) (dwarf2_per_objfile
->str_buffer
+ str_offset
);
6394 static unsigned long
6395 read_unsigned_leb128 (bfd
*abfd
, gdb_byte
*buf
, unsigned int *bytes_read_ptr
)
6397 unsigned long result
;
6398 unsigned int num_read
;
6408 byte
= bfd_get_8 (abfd
, buf
);
6411 result
|= ((unsigned long)(byte
& 127) << shift
);
6412 if ((byte
& 128) == 0)
6418 *bytes_read_ptr
= num_read
;
6423 read_signed_leb128 (bfd
*abfd
, gdb_byte
*buf
, unsigned int *bytes_read_ptr
)
6426 int i
, shift
, num_read
;
6435 byte
= bfd_get_8 (abfd
, buf
);
6438 result
|= ((long)(byte
& 127) << shift
);
6440 if ((byte
& 128) == 0)
6445 if ((shift
< 8 * sizeof (result
)) && (byte
& 0x40))
6446 result
|= -(((long)1) << shift
);
6447 *bytes_read_ptr
= num_read
;
6451 /* Return a pointer to just past the end of an LEB128 number in BUF. */
6454 skip_leb128 (bfd
*abfd
, gdb_byte
*buf
)
6460 byte
= bfd_get_8 (abfd
, buf
);
6462 if ((byte
& 128) == 0)
6468 set_cu_language (unsigned int lang
, struct dwarf2_cu
*cu
)
6474 cu
->language
= language_c
;
6476 case DW_LANG_C_plus_plus
:
6477 cu
->language
= language_cplus
;
6479 case DW_LANG_Fortran77
:
6480 case DW_LANG_Fortran90
:
6481 case DW_LANG_Fortran95
:
6482 cu
->language
= language_fortran
;
6484 case DW_LANG_Mips_Assembler
:
6485 cu
->language
= language_asm
;
6488 cu
->language
= language_java
;
6492 cu
->language
= language_ada
;
6494 case DW_LANG_Modula2
:
6495 cu
->language
= language_m2
;
6497 case DW_LANG_Pascal83
:
6498 cu
->language
= language_pascal
;
6501 cu
->language
= language_objc
;
6503 case DW_LANG_Cobol74
:
6504 case DW_LANG_Cobol85
:
6506 cu
->language
= language_minimal
;
6509 cu
->language_defn
= language_def (cu
->language
);
6512 /* Return the named attribute or NULL if not there. */
6514 static struct attribute
*
6515 dwarf2_attr (struct die_info
*die
, unsigned int name
, struct dwarf2_cu
*cu
)
6518 struct attribute
*spec
= NULL
;
6520 for (i
= 0; i
< die
->num_attrs
; ++i
)
6522 if (die
->attrs
[i
].name
== name
)
6523 return &die
->attrs
[i
];
6524 if (die
->attrs
[i
].name
== DW_AT_specification
6525 || die
->attrs
[i
].name
== DW_AT_abstract_origin
)
6526 spec
= &die
->attrs
[i
];
6530 return dwarf2_attr (follow_die_ref (die
, spec
, cu
), name
, cu
);
6535 /* Return non-zero iff the attribute NAME is defined for the given DIE,
6536 and holds a non-zero value. This function should only be used for
6537 DW_FORM_flag attributes. */
6540 dwarf2_flag_true_p (struct die_info
*die
, unsigned name
, struct dwarf2_cu
*cu
)
6542 struct attribute
*attr
= dwarf2_attr (die
, name
, cu
);
6544 return (attr
&& DW_UNSND (attr
));
6548 die_is_declaration (struct die_info
*die
, struct dwarf2_cu
*cu
)
6550 /* A DIE is a declaration if it has a DW_AT_declaration attribute
6551 which value is non-zero. However, we have to be careful with
6552 DIEs having a DW_AT_specification attribute, because dwarf2_attr()
6553 (via dwarf2_flag_true_p) follows this attribute. So we may
6554 end up accidently finding a declaration attribute that belongs
6555 to a different DIE referenced by the specification attribute,
6556 even though the given DIE does not have a declaration attribute. */
6557 return (dwarf2_flag_true_p (die
, DW_AT_declaration
, cu
)
6558 && dwarf2_attr (die
, DW_AT_specification
, cu
) == NULL
);
6561 /* Return the die giving the specification for DIE, if there is
6564 static struct die_info
*
6565 die_specification (struct die_info
*die
, struct dwarf2_cu
*cu
)
6567 struct attribute
*spec_attr
= dwarf2_attr (die
, DW_AT_specification
, cu
);
6569 if (spec_attr
== NULL
)
6572 return follow_die_ref (die
, spec_attr
, cu
);
6575 /* Free the line_header structure *LH, and any arrays and strings it
6578 free_line_header (struct line_header
*lh
)
6580 if (lh
->standard_opcode_lengths
)
6581 xfree (lh
->standard_opcode_lengths
);
6583 /* Remember that all the lh->file_names[i].name pointers are
6584 pointers into debug_line_buffer, and don't need to be freed. */
6586 xfree (lh
->file_names
);
6588 /* Similarly for the include directory names. */
6589 if (lh
->include_dirs
)
6590 xfree (lh
->include_dirs
);
6596 /* Add an entry to LH's include directory table. */
6598 add_include_dir (struct line_header
*lh
, char *include_dir
)
6600 /* Grow the array if necessary. */
6601 if (lh
->include_dirs_size
== 0)
6603 lh
->include_dirs_size
= 1; /* for testing */
6604 lh
->include_dirs
= xmalloc (lh
->include_dirs_size
6605 * sizeof (*lh
->include_dirs
));
6607 else if (lh
->num_include_dirs
>= lh
->include_dirs_size
)
6609 lh
->include_dirs_size
*= 2;
6610 lh
->include_dirs
= xrealloc (lh
->include_dirs
,
6611 (lh
->include_dirs_size
6612 * sizeof (*lh
->include_dirs
)));
6615 lh
->include_dirs
[lh
->num_include_dirs
++] = include_dir
;
6619 /* Add an entry to LH's file name table. */
6621 add_file_name (struct line_header
*lh
,
6623 unsigned int dir_index
,
6624 unsigned int mod_time
,
6625 unsigned int length
)
6627 struct file_entry
*fe
;
6629 /* Grow the array if necessary. */
6630 if (lh
->file_names_size
== 0)
6632 lh
->file_names_size
= 1; /* for testing */
6633 lh
->file_names
= xmalloc (lh
->file_names_size
6634 * sizeof (*lh
->file_names
));
6636 else if (lh
->num_file_names
>= lh
->file_names_size
)
6638 lh
->file_names_size
*= 2;
6639 lh
->file_names
= xrealloc (lh
->file_names
,
6640 (lh
->file_names_size
6641 * sizeof (*lh
->file_names
)));
6644 fe
= &lh
->file_names
[lh
->num_file_names
++];
6646 fe
->dir_index
= dir_index
;
6647 fe
->mod_time
= mod_time
;
6648 fe
->length
= length
;
6654 /* Read the statement program header starting at OFFSET in
6655 .debug_line, according to the endianness of ABFD. Return a pointer
6656 to a struct line_header, allocated using xmalloc.
6658 NOTE: the strings in the include directory and file name tables of
6659 the returned object point into debug_line_buffer, and must not be
6661 static struct line_header
*
6662 dwarf_decode_line_header (unsigned int offset
, bfd
*abfd
,
6663 struct dwarf2_cu
*cu
)
6665 struct cleanup
*back_to
;
6666 struct line_header
*lh
;
6668 unsigned int bytes_read
;
6670 char *cur_dir
, *cur_file
;
6672 if (dwarf2_per_objfile
->line_buffer
== NULL
)
6674 complaint (&symfile_complaints
, _("missing .debug_line section"));
6678 /* Make sure that at least there's room for the total_length field.
6679 That could be 12 bytes long, but we're just going to fudge that. */
6680 if (offset
+ 4 >= dwarf2_per_objfile
->line_size
)
6682 dwarf2_statement_list_fits_in_line_number_section_complaint ();
6686 lh
= xmalloc (sizeof (*lh
));
6687 memset (lh
, 0, sizeof (*lh
));
6688 back_to
= make_cleanup ((make_cleanup_ftype
*) free_line_header
,
6691 line_ptr
= dwarf2_per_objfile
->line_buffer
+ offset
;
6693 /* Read in the header. */
6695 read_initial_length (abfd
, line_ptr
, &cu
->header
, &bytes_read
);
6696 line_ptr
+= bytes_read
;
6697 if (line_ptr
+ lh
->total_length
> (dwarf2_per_objfile
->line_buffer
6698 + dwarf2_per_objfile
->line_size
))
6700 dwarf2_statement_list_fits_in_line_number_section_complaint ();
6703 lh
->statement_program_end
= line_ptr
+ lh
->total_length
;
6704 lh
->version
= read_2_bytes (abfd
, line_ptr
);
6706 lh
->header_length
= read_offset (abfd
, line_ptr
, &cu
->header
, &bytes_read
);
6707 line_ptr
+= bytes_read
;
6708 lh
->minimum_instruction_length
= read_1_byte (abfd
, line_ptr
);
6710 lh
->default_is_stmt
= read_1_byte (abfd
, line_ptr
);
6712 lh
->line_base
= read_1_signed_byte (abfd
, line_ptr
);
6714 lh
->line_range
= read_1_byte (abfd
, line_ptr
);
6716 lh
->opcode_base
= read_1_byte (abfd
, line_ptr
);
6718 lh
->standard_opcode_lengths
6719 = xmalloc (lh
->opcode_base
* sizeof (lh
->standard_opcode_lengths
[0]));
6721 lh
->standard_opcode_lengths
[0] = 1; /* This should never be used anyway. */
6722 for (i
= 1; i
< lh
->opcode_base
; ++i
)
6724 lh
->standard_opcode_lengths
[i
] = read_1_byte (abfd
, line_ptr
);
6728 /* Read directory table. */
6729 while ((cur_dir
= read_string (abfd
, line_ptr
, &bytes_read
)) != NULL
)
6731 line_ptr
+= bytes_read
;
6732 add_include_dir (lh
, cur_dir
);
6734 line_ptr
+= bytes_read
;
6736 /* Read file name table. */
6737 while ((cur_file
= read_string (abfd
, line_ptr
, &bytes_read
)) != NULL
)
6739 unsigned int dir_index
, mod_time
, length
;
6741 line_ptr
+= bytes_read
;
6742 dir_index
= read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
6743 line_ptr
+= bytes_read
;
6744 mod_time
= read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
6745 line_ptr
+= bytes_read
;
6746 length
= read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
6747 line_ptr
+= bytes_read
;
6749 add_file_name (lh
, cur_file
, dir_index
, mod_time
, length
);
6751 line_ptr
+= bytes_read
;
6752 lh
->statement_program_start
= line_ptr
;
6754 if (line_ptr
> (dwarf2_per_objfile
->line_buffer
6755 + dwarf2_per_objfile
->line_size
))
6756 complaint (&symfile_complaints
,
6757 _("line number info header doesn't fit in `.debug_line' section"));
6759 discard_cleanups (back_to
);
6763 /* This function exists to work around a bug in certain compilers
6764 (particularly GCC 2.95), in which the first line number marker of a
6765 function does not show up until after the prologue, right before
6766 the second line number marker. This function shifts ADDRESS down
6767 to the beginning of the function if necessary, and is called on
6768 addresses passed to record_line. */
6771 check_cu_functions (CORE_ADDR address
, struct dwarf2_cu
*cu
)
6773 struct function_range
*fn
;
6775 /* Find the function_range containing address. */
6780 cu
->cached_fn
= cu
->first_fn
;
6784 if (fn
->lowpc
<= address
&& fn
->highpc
> address
)
6790 while (fn
&& fn
!= cu
->cached_fn
)
6791 if (fn
->lowpc
<= address
&& fn
->highpc
> address
)
6801 if (address
!= fn
->lowpc
)
6802 complaint (&symfile_complaints
,
6803 _("misplaced first line number at 0x%lx for '%s'"),
6804 (unsigned long) address
, fn
->name
);
6809 /* Decode the Line Number Program (LNP) for the given line_header
6810 structure and CU. The actual information extracted and the type
6811 of structures created from the LNP depends on the value of PST.
6813 1. If PST is NULL, then this procedure uses the data from the program
6814 to create all necessary symbol tables, and their linetables.
6815 The compilation directory of the file is passed in COMP_DIR,
6816 and must not be NULL.
6818 2. If PST is not NULL, this procedure reads the program to determine
6819 the list of files included by the unit represented by PST, and
6820 builds all the associated partial symbol tables. In this case,
6821 the value of COMP_DIR is ignored, and can thus be NULL (the COMP_DIR
6822 is not used to compute the full name of the symtab, and therefore
6823 omitting it when building the partial symtab does not introduce
6824 the potential for inconsistency - a partial symtab and its associated
6825 symbtab having a different fullname -). */
6828 dwarf_decode_lines (struct line_header
*lh
, char *comp_dir
, bfd
*abfd
,
6829 struct dwarf2_cu
*cu
, struct partial_symtab
*pst
)
6831 gdb_byte
*line_ptr
, *extended_end
;
6833 unsigned int bytes_read
, extended_len
;
6834 unsigned char op_code
, extended_op
, adj_opcode
;
6836 struct objfile
*objfile
= cu
->objfile
;
6837 const int decode_for_pst_p
= (pst
!= NULL
);
6838 struct subfile
*last_subfile
= NULL
, *first_subfile
= current_subfile
;
6840 baseaddr
= ANOFFSET (objfile
->section_offsets
, SECT_OFF_TEXT (objfile
));
6842 line_ptr
= lh
->statement_program_start
;
6843 line_end
= lh
->statement_program_end
;
6845 /* Read the statement sequences until there's nothing left. */
6846 while (line_ptr
< line_end
)
6848 /* state machine registers */
6849 CORE_ADDR address
= 0;
6850 unsigned int file
= 1;
6851 unsigned int line
= 1;
6852 unsigned int column
= 0;
6853 int is_stmt
= lh
->default_is_stmt
;
6854 int basic_block
= 0;
6855 int end_sequence
= 0;
6857 if (!decode_for_pst_p
&& lh
->num_file_names
>= file
)
6859 /* Start a subfile for the current file of the state machine. */
6860 /* lh->include_dirs and lh->file_names are 0-based, but the
6861 directory and file name numbers in the statement program
6863 struct file_entry
*fe
= &lh
->file_names
[file
- 1];
6867 dir
= lh
->include_dirs
[fe
->dir_index
- 1];
6869 dwarf2_start_subfile (fe
->name
, dir
, comp_dir
);
6872 /* Decode the table. */
6873 while (!end_sequence
)
6875 op_code
= read_1_byte (abfd
, line_ptr
);
6878 if (op_code
>= lh
->opcode_base
)
6880 /* Special operand. */
6881 adj_opcode
= op_code
- lh
->opcode_base
;
6882 address
+= (adj_opcode
/ lh
->line_range
)
6883 * lh
->minimum_instruction_length
;
6884 line
+= lh
->line_base
+ (adj_opcode
% lh
->line_range
);
6885 if (lh
->num_file_names
< file
)
6886 dwarf2_debug_line_missing_file_complaint ();
6889 lh
->file_names
[file
- 1].included_p
= 1;
6890 if (!decode_for_pst_p
)
6892 if (last_subfile
!= current_subfile
)
6895 record_line (last_subfile
, 0, address
);
6896 last_subfile
= current_subfile
;
6898 /* Append row to matrix using current values. */
6899 record_line (current_subfile
, line
,
6900 check_cu_functions (address
, cu
));
6905 else switch (op_code
)
6907 case DW_LNS_extended_op
:
6908 extended_len
= read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
6909 line_ptr
+= bytes_read
;
6910 extended_end
= line_ptr
+ extended_len
;
6911 extended_op
= read_1_byte (abfd
, line_ptr
);
6913 switch (extended_op
)
6915 case DW_LNE_end_sequence
:
6918 if (lh
->num_file_names
< file
)
6919 dwarf2_debug_line_missing_file_complaint ();
6922 lh
->file_names
[file
- 1].included_p
= 1;
6923 if (!decode_for_pst_p
)
6924 record_line (current_subfile
, 0, address
);
6927 case DW_LNE_set_address
:
6928 address
= read_address (abfd
, line_ptr
, cu
, &bytes_read
);
6929 line_ptr
+= bytes_read
;
6930 address
+= baseaddr
;
6932 case DW_LNE_define_file
:
6935 unsigned int dir_index
, mod_time
, length
;
6937 cur_file
= read_string (abfd
, line_ptr
, &bytes_read
);
6938 line_ptr
+= bytes_read
;
6940 read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
6941 line_ptr
+= bytes_read
;
6943 read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
6944 line_ptr
+= bytes_read
;
6946 read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
6947 line_ptr
+= bytes_read
;
6948 add_file_name (lh
, cur_file
, dir_index
, mod_time
, length
);
6952 complaint (&symfile_complaints
,
6953 _("mangled .debug_line section"));
6956 /* Make sure that we parsed the extended op correctly. If e.g.
6957 we expected a different address size than the producer used,
6958 we may have read the wrong number of bytes. */
6959 if (line_ptr
!= extended_end
)
6961 complaint (&symfile_complaints
,
6962 _("mangled .debug_line section"));
6967 if (lh
->num_file_names
< file
)
6968 dwarf2_debug_line_missing_file_complaint ();
6971 lh
->file_names
[file
- 1].included_p
= 1;
6972 if (!decode_for_pst_p
)
6974 if (last_subfile
!= current_subfile
)
6977 record_line (last_subfile
, 0, address
);
6978 last_subfile
= current_subfile
;
6980 record_line (current_subfile
, line
,
6981 check_cu_functions (address
, cu
));
6986 case DW_LNS_advance_pc
:
6987 address
+= lh
->minimum_instruction_length
6988 * read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
6989 line_ptr
+= bytes_read
;
6991 case DW_LNS_advance_line
:
6992 line
+= read_signed_leb128 (abfd
, line_ptr
, &bytes_read
);
6993 line_ptr
+= bytes_read
;
6995 case DW_LNS_set_file
:
6997 /* The arrays lh->include_dirs and lh->file_names are
6998 0-based, but the directory and file name numbers in
6999 the statement program are 1-based. */
7000 struct file_entry
*fe
;
7003 file
= read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
7004 line_ptr
+= bytes_read
;
7005 if (lh
->num_file_names
< file
)
7006 dwarf2_debug_line_missing_file_complaint ();
7009 fe
= &lh
->file_names
[file
- 1];
7011 dir
= lh
->include_dirs
[fe
->dir_index
- 1];
7012 if (!decode_for_pst_p
)
7014 last_subfile
= current_subfile
;
7015 dwarf2_start_subfile (fe
->name
, dir
, comp_dir
);
7020 case DW_LNS_set_column
:
7021 column
= read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
7022 line_ptr
+= bytes_read
;
7024 case DW_LNS_negate_stmt
:
7025 is_stmt
= (!is_stmt
);
7027 case DW_LNS_set_basic_block
:
7030 /* Add to the address register of the state machine the
7031 address increment value corresponding to special opcode
7032 255. I.e., this value is scaled by the minimum
7033 instruction length since special opcode 255 would have
7034 scaled the the increment. */
7035 case DW_LNS_const_add_pc
:
7036 address
+= (lh
->minimum_instruction_length
7037 * ((255 - lh
->opcode_base
) / lh
->line_range
));
7039 case DW_LNS_fixed_advance_pc
:
7040 address
+= read_2_bytes (abfd
, line_ptr
);
7045 /* Unknown standard opcode, ignore it. */
7048 for (i
= 0; i
< lh
->standard_opcode_lengths
[op_code
]; i
++)
7050 (void) read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
7051 line_ptr
+= bytes_read
;
7058 if (decode_for_pst_p
)
7062 /* Now that we're done scanning the Line Header Program, we can
7063 create the psymtab of each included file. */
7064 for (file_index
= 0; file_index
< lh
->num_file_names
; file_index
++)
7065 if (lh
->file_names
[file_index
].included_p
== 1)
7067 const struct file_entry fe
= lh
->file_names
[file_index
];
7068 char *include_name
= fe
.name
;
7069 char *dir_name
= NULL
;
7070 char *pst_filename
= pst
->filename
;
7073 dir_name
= lh
->include_dirs
[fe
.dir_index
- 1];
7075 if (!IS_ABSOLUTE_PATH (include_name
) && dir_name
!= NULL
)
7077 include_name
= concat (dir_name
, SLASH_STRING
,
7078 include_name
, (char *)NULL
);
7079 make_cleanup (xfree
, include_name
);
7082 if (!IS_ABSOLUTE_PATH (pst_filename
) && pst
->dirname
!= NULL
)
7084 pst_filename
= concat (pst
->dirname
, SLASH_STRING
,
7085 pst_filename
, (char *)NULL
);
7086 make_cleanup (xfree
, pst_filename
);
7089 if (strcmp (include_name
, pst_filename
) != 0)
7090 dwarf2_create_include_psymtab (include_name
, pst
, objfile
);
7095 /* Make sure a symtab is created for every file, even files
7096 which contain only variables (i.e. no code with associated
7100 struct file_entry
*fe
;
7102 for (i
= 0; i
< lh
->num_file_names
; i
++)
7105 fe
= &lh
->file_names
[i
];
7107 dir
= lh
->include_dirs
[fe
->dir_index
- 1];
7108 dwarf2_start_subfile (fe
->name
, dir
, comp_dir
);
7110 /* Skip the main file; we don't need it, and it must be
7111 allocated last, so that it will show up before the
7112 non-primary symtabs in the objfile's symtab list. */
7113 if (current_subfile
== first_subfile
)
7116 if (current_subfile
->symtab
== NULL
)
7117 current_subfile
->symtab
= allocate_symtab (current_subfile
->name
,
7119 fe
->symtab
= current_subfile
->symtab
;
7124 /* Start a subfile for DWARF. FILENAME is the name of the file and
7125 DIRNAME the name of the source directory which contains FILENAME
7126 or NULL if not known. COMP_DIR is the compilation directory for the
7127 linetable's compilation unit or NULL if not known.
7128 This routine tries to keep line numbers from identical absolute and
7129 relative file names in a common subfile.
7131 Using the `list' example from the GDB testsuite, which resides in
7132 /srcdir and compiling it with Irix6.2 cc in /compdir using a filename
7133 of /srcdir/list0.c yields the following debugging information for list0.c:
7135 DW_AT_name: /srcdir/list0.c
7136 DW_AT_comp_dir: /compdir
7137 files.files[0].name: list0.h
7138 files.files[0].dir: /srcdir
7139 files.files[1].name: list0.c
7140 files.files[1].dir: /srcdir
7142 The line number information for list0.c has to end up in a single
7143 subfile, so that `break /srcdir/list0.c:1' works as expected.
7144 start_subfile will ensure that this happens provided that we pass the
7145 concatenation of files.files[1].dir and files.files[1].name as the
7149 dwarf2_start_subfile (char *filename
, char *dirname
, char *comp_dir
)
7153 /* While reading the DIEs, we call start_symtab(DW_AT_name, DW_AT_comp_dir).
7154 `start_symtab' will always pass the contents of DW_AT_comp_dir as
7155 second argument to start_subfile. To be consistent, we do the
7156 same here. In order not to lose the line information directory,
7157 we concatenate it to the filename when it makes sense.
7158 Note that the Dwarf3 standard says (speaking of filenames in line
7159 information): ``The directory index is ignored for file names
7160 that represent full path names''. Thus ignoring dirname in the
7161 `else' branch below isn't an issue. */
7163 if (!IS_ABSOLUTE_PATH (filename
) && dirname
!= NULL
)
7164 fullname
= concat (dirname
, SLASH_STRING
, filename
, (char *)NULL
);
7166 fullname
= filename
;
7168 start_subfile (fullname
, comp_dir
);
7170 if (fullname
!= filename
)
7175 var_decode_location (struct attribute
*attr
, struct symbol
*sym
,
7176 struct dwarf2_cu
*cu
)
7178 struct objfile
*objfile
= cu
->objfile
;
7179 struct comp_unit_head
*cu_header
= &cu
->header
;
7181 /* NOTE drow/2003-01-30: There used to be a comment and some special
7182 code here to turn a symbol with DW_AT_external and a
7183 SYMBOL_VALUE_ADDRESS of 0 into a LOC_UNRESOLVED symbol. This was
7184 necessary for platforms (maybe Alpha, certainly PowerPC GNU/Linux
7185 with some versions of binutils) where shared libraries could have
7186 relocations against symbols in their debug information - the
7187 minimal symbol would have the right address, but the debug info
7188 would not. It's no longer necessary, because we will explicitly
7189 apply relocations when we read in the debug information now. */
7191 /* A DW_AT_location attribute with no contents indicates that a
7192 variable has been optimized away. */
7193 if (attr_form_is_block (attr
) && DW_BLOCK (attr
)->size
== 0)
7195 SYMBOL_CLASS (sym
) = LOC_OPTIMIZED_OUT
;
7199 /* Handle one degenerate form of location expression specially, to
7200 preserve GDB's previous behavior when section offsets are
7201 specified. If this is just a DW_OP_addr then mark this symbol
7204 if (attr_form_is_block (attr
)
7205 && DW_BLOCK (attr
)->size
== 1 + cu_header
->addr_size
7206 && DW_BLOCK (attr
)->data
[0] == DW_OP_addr
)
7210 SYMBOL_VALUE_ADDRESS (sym
) =
7211 read_address (objfile
->obfd
, DW_BLOCK (attr
)->data
+ 1, cu
, &dummy
);
7212 fixup_symbol_section (sym
, objfile
);
7213 SYMBOL_VALUE_ADDRESS (sym
) += ANOFFSET (objfile
->section_offsets
,
7214 SYMBOL_SECTION (sym
));
7215 SYMBOL_CLASS (sym
) = LOC_STATIC
;
7219 /* NOTE drow/2002-01-30: It might be worthwhile to have a static
7220 expression evaluator, and use LOC_COMPUTED only when necessary
7221 (i.e. when the value of a register or memory location is
7222 referenced, or a thread-local block, etc.). Then again, it might
7223 not be worthwhile. I'm assuming that it isn't unless performance
7224 or memory numbers show me otherwise. */
7226 dwarf2_symbol_mark_computed (attr
, sym
, cu
);
7227 SYMBOL_CLASS (sym
) = LOC_COMPUTED
;
7230 /* Given a pointer to a DWARF information entry, figure out if we need
7231 to make a symbol table entry for it, and if so, create a new entry
7232 and return a pointer to it.
7233 If TYPE is NULL, determine symbol type from the die, otherwise
7234 used the passed type. */
7236 static struct symbol
*
7237 new_symbol (struct die_info
*die
, struct type
*type
, struct dwarf2_cu
*cu
)
7239 struct objfile
*objfile
= cu
->objfile
;
7240 struct gdbarch
*gdbarch
= get_objfile_arch (objfile
);
7241 struct symbol
*sym
= NULL
;
7243 struct attribute
*attr
= NULL
;
7244 struct attribute
*attr2
= NULL
;
7247 baseaddr
= ANOFFSET (objfile
->section_offsets
, SECT_OFF_TEXT (objfile
));
7249 if (die
->tag
!= DW_TAG_namespace
)
7250 name
= dwarf2_linkage_name (die
, cu
);
7252 name
= TYPE_NAME (type
);
7256 sym
= (struct symbol
*) obstack_alloc (&objfile
->objfile_obstack
,
7257 sizeof (struct symbol
));
7258 OBJSTAT (objfile
, n_syms
++);
7259 memset (sym
, 0, sizeof (struct symbol
));
7261 /* Cache this symbol's name and the name's demangled form (if any). */
7262 SYMBOL_LANGUAGE (sym
) = cu
->language
;
7263 SYMBOL_SET_NAMES (sym
, name
, strlen (name
), objfile
);
7265 /* Default assumptions.
7266 Use the passed type or decode it from the die. */
7267 SYMBOL_DOMAIN (sym
) = VAR_DOMAIN
;
7268 SYMBOL_CLASS (sym
) = LOC_OPTIMIZED_OUT
;
7270 SYMBOL_TYPE (sym
) = type
;
7272 SYMBOL_TYPE (sym
) = die_type (die
, cu
);
7273 attr
= dwarf2_attr (die
, DW_AT_decl_line
, cu
);
7276 SYMBOL_LINE (sym
) = DW_UNSND (attr
);
7279 attr
= dwarf2_attr (die
, DW_AT_decl_file
, cu
);
7282 int file_index
= DW_UNSND (attr
);
7283 if (cu
->line_header
== NULL
7284 || file_index
> cu
->line_header
->num_file_names
)
7285 complaint (&symfile_complaints
,
7286 _("file index out of range"));
7287 else if (file_index
> 0)
7289 struct file_entry
*fe
;
7290 fe
= &cu
->line_header
->file_names
[file_index
- 1];
7291 SYMBOL_SYMTAB (sym
) = fe
->symtab
;
7298 attr
= dwarf2_attr (die
, DW_AT_low_pc
, cu
);
7301 SYMBOL_VALUE_ADDRESS (sym
) = DW_ADDR (attr
) + baseaddr
;
7303 SYMBOL_CLASS (sym
) = LOC_LABEL
;
7305 case DW_TAG_subprogram
:
7306 /* SYMBOL_BLOCK_VALUE (sym) will be filled in later by
7308 SYMBOL_CLASS (sym
) = LOC_BLOCK
;
7309 attr2
= dwarf2_attr (die
, DW_AT_external
, cu
);
7310 if ((attr2
&& (DW_UNSND (attr2
) != 0))
7311 || cu
->language
== language_ada
)
7313 /* Subprograms marked external are stored as a global symbol.
7314 Ada subprograms, whether marked external or not, are always
7315 stored as a global symbol, because we want to be able to
7316 access them globally. For instance, we want to be able
7317 to break on a nested subprogram without having to
7318 specify the context. */
7319 add_symbol_to_list (sym
, &global_symbols
);
7323 add_symbol_to_list (sym
, cu
->list_in_scope
);
7326 case DW_TAG_variable
:
7327 /* Compilation with minimal debug info may result in variables
7328 with missing type entries. Change the misleading `void' type
7329 to something sensible. */
7330 if (TYPE_CODE (SYMBOL_TYPE (sym
)) == TYPE_CODE_VOID
)
7332 = builtin_type (gdbarch
)->nodebug_data_symbol
;
7334 attr
= dwarf2_attr (die
, DW_AT_const_value
, cu
);
7337 dwarf2_const_value (attr
, sym
, cu
);
7338 attr2
= dwarf2_attr (die
, DW_AT_external
, cu
);
7339 if (attr2
&& (DW_UNSND (attr2
) != 0))
7340 add_symbol_to_list (sym
, &global_symbols
);
7342 add_symbol_to_list (sym
, cu
->list_in_scope
);
7345 attr
= dwarf2_attr (die
, DW_AT_location
, cu
);
7348 var_decode_location (attr
, sym
, cu
);
7349 attr2
= dwarf2_attr (die
, DW_AT_external
, cu
);
7350 if (attr2
&& (DW_UNSND (attr2
) != 0))
7351 add_symbol_to_list (sym
, &global_symbols
);
7353 add_symbol_to_list (sym
, cu
->list_in_scope
);
7357 /* We do not know the address of this symbol.
7358 If it is an external symbol and we have type information
7359 for it, enter the symbol as a LOC_UNRESOLVED symbol.
7360 The address of the variable will then be determined from
7361 the minimal symbol table whenever the variable is
7363 attr2
= dwarf2_attr (die
, DW_AT_external
, cu
);
7364 if (attr2
&& (DW_UNSND (attr2
) != 0)
7365 && dwarf2_attr (die
, DW_AT_type
, cu
) != NULL
)
7367 SYMBOL_CLASS (sym
) = LOC_UNRESOLVED
;
7368 add_symbol_to_list (sym
, &global_symbols
);
7372 case DW_TAG_formal_parameter
:
7373 attr
= dwarf2_attr (die
, DW_AT_location
, cu
);
7376 var_decode_location (attr
, sym
, cu
);
7377 /* FIXME drow/2003-07-31: Is LOC_COMPUTED_ARG necessary? */
7378 if (SYMBOL_CLASS (sym
) == LOC_COMPUTED
)
7379 SYMBOL_CLASS (sym
) = LOC_COMPUTED_ARG
;
7381 attr
= dwarf2_attr (die
, DW_AT_const_value
, cu
);
7384 dwarf2_const_value (attr
, sym
, cu
);
7386 add_symbol_to_list (sym
, cu
->list_in_scope
);
7388 case DW_TAG_unspecified_parameters
:
7389 /* From varargs functions; gdb doesn't seem to have any
7390 interest in this information, so just ignore it for now.
7393 case DW_TAG_class_type
:
7394 case DW_TAG_interface_type
:
7395 case DW_TAG_structure_type
:
7396 case DW_TAG_union_type
:
7397 case DW_TAG_set_type
:
7398 case DW_TAG_enumeration_type
:
7399 SYMBOL_CLASS (sym
) = LOC_TYPEDEF
;
7400 SYMBOL_DOMAIN (sym
) = STRUCT_DOMAIN
;
7402 /* Make sure that the symbol includes appropriate enclosing
7403 classes/namespaces in its name. These are calculated in
7404 read_structure_type, and the correct name is saved in
7407 if (cu
->language
== language_cplus
7408 || cu
->language
== language_java
)
7410 struct type
*type
= SYMBOL_TYPE (sym
);
7412 if (TYPE_TAG_NAME (type
) != NULL
)
7414 /* FIXME: carlton/2003-11-10: Should this use
7415 SYMBOL_SET_NAMES instead? (The same problem also
7416 arises further down in this function.) */
7417 /* The type's name is already allocated along with
7418 this objfile, so we don't need to duplicate it
7420 SYMBOL_LINKAGE_NAME (sym
) = TYPE_TAG_NAME (type
);
7425 /* NOTE: carlton/2003-11-10: C++ and Java class symbols shouldn't
7426 really ever be static objects: otherwise, if you try
7427 to, say, break of a class's method and you're in a file
7428 which doesn't mention that class, it won't work unless
7429 the check for all static symbols in lookup_symbol_aux
7430 saves you. See the OtherFileClass tests in
7431 gdb.c++/namespace.exp. */
7433 struct pending
**list_to_add
;
7435 list_to_add
= (cu
->list_in_scope
== &file_symbols
7436 && (cu
->language
== language_cplus
7437 || cu
->language
== language_java
)
7438 ? &global_symbols
: cu
->list_in_scope
);
7440 add_symbol_to_list (sym
, list_to_add
);
7442 /* The semantics of C++ state that "struct foo { ... }" also
7443 defines a typedef for "foo". A Java class declaration also
7444 defines a typedef for the class. Synthesize a typedef symbol
7445 so that "ptype foo" works as expected. */
7446 if (cu
->language
== language_cplus
7447 || cu
->language
== language_java
7448 || cu
->language
== language_ada
)
7450 struct symbol
*typedef_sym
= (struct symbol
*)
7451 obstack_alloc (&objfile
->objfile_obstack
,
7452 sizeof (struct symbol
));
7453 *typedef_sym
= *sym
;
7454 SYMBOL_DOMAIN (typedef_sym
) = VAR_DOMAIN
;
7455 /* The symbol's name is already allocated along with
7456 this objfile, so we don't need to duplicate it for
7458 if (TYPE_NAME (SYMBOL_TYPE (sym
)) == 0)
7459 TYPE_NAME (SYMBOL_TYPE (sym
)) = SYMBOL_SEARCH_NAME (sym
);
7460 add_symbol_to_list (typedef_sym
, list_to_add
);
7464 case DW_TAG_typedef
:
7465 if (processing_has_namespace_info
7466 && processing_current_prefix
[0] != '\0')
7468 SYMBOL_LINKAGE_NAME (sym
) = typename_concat (&objfile
->objfile_obstack
,
7469 processing_current_prefix
,
7472 SYMBOL_CLASS (sym
) = LOC_TYPEDEF
;
7473 SYMBOL_DOMAIN (sym
) = VAR_DOMAIN
;
7474 add_symbol_to_list (sym
, cu
->list_in_scope
);
7476 case DW_TAG_base_type
:
7477 case DW_TAG_subrange_type
:
7478 SYMBOL_CLASS (sym
) = LOC_TYPEDEF
;
7479 SYMBOL_DOMAIN (sym
) = VAR_DOMAIN
;
7480 add_symbol_to_list (sym
, cu
->list_in_scope
);
7482 case DW_TAG_enumerator
:
7483 if (processing_has_namespace_info
7484 && processing_current_prefix
[0] != '\0')
7486 SYMBOL_LINKAGE_NAME (sym
) = typename_concat (&objfile
->objfile_obstack
,
7487 processing_current_prefix
,
7490 attr
= dwarf2_attr (die
, DW_AT_const_value
, cu
);
7493 dwarf2_const_value (attr
, sym
, cu
);
7496 /* NOTE: carlton/2003-11-10: See comment above in the
7497 DW_TAG_class_type, etc. block. */
7499 struct pending
**list_to_add
;
7501 list_to_add
= (cu
->list_in_scope
== &file_symbols
7502 && (cu
->language
== language_cplus
7503 || cu
->language
== language_java
)
7504 ? &global_symbols
: cu
->list_in_scope
);
7506 add_symbol_to_list (sym
, list_to_add
);
7509 case DW_TAG_namespace
:
7510 SYMBOL_CLASS (sym
) = LOC_TYPEDEF
;
7511 add_symbol_to_list (sym
, &global_symbols
);
7514 /* Not a tag we recognize. Hopefully we aren't processing
7515 trash data, but since we must specifically ignore things
7516 we don't recognize, there is nothing else we should do at
7518 complaint (&symfile_complaints
, _("unsupported tag: '%s'"),
7519 dwarf_tag_name (die
->tag
));
7526 /* Copy constant value from an attribute to a symbol. */
7529 dwarf2_const_value (struct attribute
*attr
, struct symbol
*sym
,
7530 struct dwarf2_cu
*cu
)
7532 struct objfile
*objfile
= cu
->objfile
;
7533 struct comp_unit_head
*cu_header
= &cu
->header
;
7534 struct dwarf_block
*blk
;
7539 if (TYPE_LENGTH (SYMBOL_TYPE (sym
)) != cu_header
->addr_size
)
7540 dwarf2_const_value_length_mismatch_complaint (DEPRECATED_SYMBOL_NAME (sym
),
7541 cu_header
->addr_size
,
7542 TYPE_LENGTH (SYMBOL_TYPE
7544 SYMBOL_VALUE_BYTES (sym
) =
7545 obstack_alloc (&objfile
->objfile_obstack
, cu_header
->addr_size
);
7546 /* NOTE: cagney/2003-05-09: In-lined store_address call with
7547 it's body - store_unsigned_integer. */
7548 store_unsigned_integer (SYMBOL_VALUE_BYTES (sym
), cu_header
->addr_size
,
7550 SYMBOL_CLASS (sym
) = LOC_CONST_BYTES
;
7552 case DW_FORM_block1
:
7553 case DW_FORM_block2
:
7554 case DW_FORM_block4
:
7556 blk
= DW_BLOCK (attr
);
7557 if (TYPE_LENGTH (SYMBOL_TYPE (sym
)) != blk
->size
)
7558 dwarf2_const_value_length_mismatch_complaint (DEPRECATED_SYMBOL_NAME (sym
),
7560 TYPE_LENGTH (SYMBOL_TYPE
7562 SYMBOL_VALUE_BYTES (sym
) =
7563 obstack_alloc (&objfile
->objfile_obstack
, blk
->size
);
7564 memcpy (SYMBOL_VALUE_BYTES (sym
), blk
->data
, blk
->size
);
7565 SYMBOL_CLASS (sym
) = LOC_CONST_BYTES
;
7568 /* The DW_AT_const_value attributes are supposed to carry the
7569 symbol's value "represented as it would be on the target
7570 architecture." By the time we get here, it's already been
7571 converted to host endianness, so we just need to sign- or
7572 zero-extend it as appropriate. */
7574 dwarf2_const_value_data (attr
, sym
, 8);
7577 dwarf2_const_value_data (attr
, sym
, 16);
7580 dwarf2_const_value_data (attr
, sym
, 32);
7583 dwarf2_const_value_data (attr
, sym
, 64);
7587 SYMBOL_VALUE (sym
) = DW_SND (attr
);
7588 SYMBOL_CLASS (sym
) = LOC_CONST
;
7592 SYMBOL_VALUE (sym
) = DW_UNSND (attr
);
7593 SYMBOL_CLASS (sym
) = LOC_CONST
;
7597 complaint (&symfile_complaints
,
7598 _("unsupported const value attribute form: '%s'"),
7599 dwarf_form_name (attr
->form
));
7600 SYMBOL_VALUE (sym
) = 0;
7601 SYMBOL_CLASS (sym
) = LOC_CONST
;
7607 /* Given an attr with a DW_FORM_dataN value in host byte order, sign-
7608 or zero-extend it as appropriate for the symbol's type. */
7610 dwarf2_const_value_data (struct attribute
*attr
,
7614 LONGEST l
= DW_UNSND (attr
);
7616 if (bits
< sizeof (l
) * 8)
7618 if (TYPE_UNSIGNED (SYMBOL_TYPE (sym
)))
7619 l
&= ((LONGEST
) 1 << bits
) - 1;
7621 l
= (l
<< (sizeof (l
) * 8 - bits
)) >> (sizeof (l
) * 8 - bits
);
7624 SYMBOL_VALUE (sym
) = l
;
7625 SYMBOL_CLASS (sym
) = LOC_CONST
;
7629 /* Return the type of the die in question using its DW_AT_type attribute. */
7631 static struct type
*
7632 die_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
7634 struct gdbarch
*gdbarch
= get_objfile_arch (cu
->objfile
);
7636 struct attribute
*type_attr
;
7637 struct die_info
*type_die
;
7639 type_attr
= dwarf2_attr (die
, DW_AT_type
, cu
);
7642 /* A missing DW_AT_type represents a void type. */
7643 return builtin_type (gdbarch
)->builtin_void
;
7646 type_die
= follow_die_ref (die
, type_attr
, cu
);
7648 type
= tag_type_to_type (type_die
, cu
);
7651 dump_die (type_die
);
7652 error (_("Dwarf Error: Problem turning type die at offset into gdb type [in module %s]"),
7658 /* Return the containing type of the die in question using its
7659 DW_AT_containing_type attribute. */
7661 static struct type
*
7662 die_containing_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
7664 struct type
*type
= NULL
;
7665 struct attribute
*type_attr
;
7666 struct die_info
*type_die
= NULL
;
7668 type_attr
= dwarf2_attr (die
, DW_AT_containing_type
, cu
);
7671 type_die
= follow_die_ref (die
, type_attr
, cu
);
7672 type
= tag_type_to_type (type_die
, cu
);
7677 dump_die (type_die
);
7678 error (_("Dwarf Error: Problem turning containing type into gdb type [in module %s]"),
7684 static struct type
*
7685 tag_type_to_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
7693 read_type_die (die
, cu
);
7697 error (_("Dwarf Error: Cannot find type of die [in module %s]"),
7705 read_type_die (struct die_info
*die
, struct dwarf2_cu
*cu
)
7707 char *prefix
= determine_prefix (die
, cu
);
7708 const char *old_prefix
= processing_current_prefix
;
7709 struct cleanup
*back_to
= make_cleanup (xfree
, prefix
);
7710 processing_current_prefix
= prefix
;
7714 case DW_TAG_class_type
:
7715 case DW_TAG_interface_type
:
7716 case DW_TAG_structure_type
:
7717 case DW_TAG_union_type
:
7718 read_structure_type (die
, cu
);
7720 case DW_TAG_enumeration_type
:
7721 read_enumeration_type (die
, cu
);
7723 case DW_TAG_subprogram
:
7724 case DW_TAG_subroutine_type
:
7725 read_subroutine_type (die
, cu
);
7727 case DW_TAG_array_type
:
7728 read_array_type (die
, cu
);
7730 case DW_TAG_set_type
:
7731 read_set_type (die
, cu
);
7733 case DW_TAG_pointer_type
:
7734 read_tag_pointer_type (die
, cu
);
7736 case DW_TAG_ptr_to_member_type
:
7737 read_tag_ptr_to_member_type (die
, cu
);
7739 case DW_TAG_reference_type
:
7740 read_tag_reference_type (die
, cu
);
7742 case DW_TAG_const_type
:
7743 read_tag_const_type (die
, cu
);
7745 case DW_TAG_volatile_type
:
7746 read_tag_volatile_type (die
, cu
);
7748 case DW_TAG_string_type
:
7749 read_tag_string_type (die
, cu
);
7751 case DW_TAG_typedef
:
7752 read_typedef (die
, cu
);
7754 case DW_TAG_subrange_type
:
7755 read_subrange_type (die
, cu
);
7757 case DW_TAG_base_type
:
7758 read_base_type (die
, cu
);
7760 case DW_TAG_unspecified_type
:
7761 read_unspecified_type (die
, cu
);
7764 complaint (&symfile_complaints
, _("unexpected tag in read_type_die: '%s'"),
7765 dwarf_tag_name (die
->tag
));
7769 processing_current_prefix
= old_prefix
;
7770 do_cleanups (back_to
);
7773 /* Return the name of the namespace/class that DIE is defined within,
7774 or "" if we can't tell. The caller should xfree the result. */
7776 /* NOTE: carlton/2004-01-23: See read_func_scope (and the comment
7777 therein) for an example of how to use this function to deal with
7778 DW_AT_specification. */
7781 determine_prefix (struct die_info
*die
, struct dwarf2_cu
*cu
)
7783 struct die_info
*parent
;
7785 if (cu
->language
!= language_cplus
7786 && cu
->language
!= language_java
)
7789 parent
= die
->parent
;
7793 return xstrdup ("");
7797 switch (parent
->tag
) {
7798 case DW_TAG_namespace
:
7800 /* FIXME: carlton/2004-03-05: Should I follow extension dies
7801 before doing this check? */
7802 if (parent
->type
!= NULL
&& TYPE_TAG_NAME (parent
->type
) != NULL
)
7804 return xstrdup (TYPE_TAG_NAME (parent
->type
));
7809 char *parent_prefix
= determine_prefix (parent
, cu
);
7810 char *retval
= typename_concat (NULL
, parent_prefix
,
7811 namespace_name (parent
, &dummy
,
7814 xfree (parent_prefix
);
7819 case DW_TAG_class_type
:
7820 case DW_TAG_interface_type
:
7821 case DW_TAG_structure_type
:
7823 if (parent
->type
!= NULL
&& TYPE_TAG_NAME (parent
->type
) != NULL
)
7825 return xstrdup (TYPE_TAG_NAME (parent
->type
));
7829 const char *old_prefix
= processing_current_prefix
;
7830 char *new_prefix
= determine_prefix (parent
, cu
);
7833 processing_current_prefix
= new_prefix
;
7834 retval
= determine_class_name (parent
, cu
);
7835 processing_current_prefix
= old_prefix
;
7842 return determine_prefix (parent
, cu
);
7847 /* Return a newly-allocated string formed by concatenating PREFIX and
7848 SUFFIX with appropriate separator. If PREFIX or SUFFIX is NULL or empty, then
7849 simply copy the SUFFIX or PREFIX, respectively. If OBS is non-null,
7850 perform an obconcat, otherwise allocate storage for the result. The CU argument
7851 is used to determine the language and hence, the appropriate separator. */
7853 #define MAX_SEP_LEN 2 /* sizeof ("::") */
7856 typename_concat (struct obstack
*obs
, const char *prefix
, const char *suffix
,
7857 struct dwarf2_cu
*cu
)
7861 if (suffix
== NULL
|| suffix
[0] == '\0' || prefix
== NULL
|| prefix
[0] == '\0')
7863 else if (cu
->language
== language_java
)
7870 char *retval
= xmalloc (strlen (prefix
) + MAX_SEP_LEN
+ strlen (suffix
) + 1);
7875 strcpy (retval
, prefix
);
7876 strcat (retval
, sep
);
7879 strcat (retval
, suffix
);
7885 /* We have an obstack. */
7886 return obconcat (obs
, prefix
, sep
, suffix
);
7892 copy_die (struct die_info
*old_die
)
7894 struct die_info
*new_die
;
7897 new_die
= (struct die_info
*) xmalloc (sizeof (struct die_info
));
7898 memset (new_die
, 0, sizeof (struct die_info
));
7900 new_die
->tag
= old_die
->tag
;
7901 new_die
->has_children
= old_die
->has_children
;
7902 new_die
->abbrev
= old_die
->abbrev
;
7903 new_die
->offset
= old_die
->offset
;
7904 new_die
->type
= NULL
;
7906 num_attrs
= old_die
->num_attrs
;
7907 new_die
->num_attrs
= num_attrs
;
7908 new_die
->attrs
= (struct attribute
*)
7909 xmalloc (num_attrs
* sizeof (struct attribute
));
7911 for (i
= 0; i
< old_die
->num_attrs
; ++i
)
7913 new_die
->attrs
[i
].name
= old_die
->attrs
[i
].name
;
7914 new_die
->attrs
[i
].form
= old_die
->attrs
[i
].form
;
7915 new_die
->attrs
[i
].u
.addr
= old_die
->attrs
[i
].u
.addr
;
7918 new_die
->next
= NULL
;
7923 /* Return sibling of die, NULL if no sibling. */
7925 static struct die_info
*
7926 sibling_die (struct die_info
*die
)
7928 return die
->sibling
;
7931 /* Get linkage name of a die, return NULL if not found. */
7934 dwarf2_linkage_name (struct die_info
*die
, struct dwarf2_cu
*cu
)
7936 struct attribute
*attr
;
7938 attr
= dwarf2_attr (die
, DW_AT_MIPS_linkage_name
, cu
);
7939 if (attr
&& DW_STRING (attr
))
7940 return DW_STRING (attr
);
7941 attr
= dwarf2_attr (die
, DW_AT_name
, cu
);
7942 if (attr
&& DW_STRING (attr
))
7943 return DW_STRING (attr
);
7947 /* Get name of a die, return NULL if not found. */
7950 dwarf2_name (struct die_info
*die
, struct dwarf2_cu
*cu
)
7952 struct attribute
*attr
;
7954 attr
= dwarf2_attr (die
, DW_AT_name
, cu
);
7955 if (attr
&& DW_STRING (attr
))
7956 return DW_STRING (attr
);
7960 /* Return the die that this die in an extension of, or NULL if there
7963 static struct die_info
*
7964 dwarf2_extension (struct die_info
*die
, struct dwarf2_cu
*cu
)
7966 struct attribute
*attr
;
7968 attr
= dwarf2_attr (die
, DW_AT_extension
, cu
);
7972 return follow_die_ref (die
, attr
, cu
);
7975 /* Convert a DIE tag into its string name. */
7978 dwarf_tag_name (unsigned tag
)
7982 case DW_TAG_padding
:
7983 return "DW_TAG_padding";
7984 case DW_TAG_array_type
:
7985 return "DW_TAG_array_type";
7986 case DW_TAG_class_type
:
7987 return "DW_TAG_class_type";
7988 case DW_TAG_entry_point
:
7989 return "DW_TAG_entry_point";
7990 case DW_TAG_enumeration_type
:
7991 return "DW_TAG_enumeration_type";
7992 case DW_TAG_formal_parameter
:
7993 return "DW_TAG_formal_parameter";
7994 case DW_TAG_imported_declaration
:
7995 return "DW_TAG_imported_declaration";
7997 return "DW_TAG_label";
7998 case DW_TAG_lexical_block
:
7999 return "DW_TAG_lexical_block";
8001 return "DW_TAG_member";
8002 case DW_TAG_pointer_type
:
8003 return "DW_TAG_pointer_type";
8004 case DW_TAG_reference_type
:
8005 return "DW_TAG_reference_type";
8006 case DW_TAG_compile_unit
:
8007 return "DW_TAG_compile_unit";
8008 case DW_TAG_string_type
:
8009 return "DW_TAG_string_type";
8010 case DW_TAG_structure_type
:
8011 return "DW_TAG_structure_type";
8012 case DW_TAG_subroutine_type
:
8013 return "DW_TAG_subroutine_type";
8014 case DW_TAG_typedef
:
8015 return "DW_TAG_typedef";
8016 case DW_TAG_union_type
:
8017 return "DW_TAG_union_type";
8018 case DW_TAG_unspecified_parameters
:
8019 return "DW_TAG_unspecified_parameters";
8020 case DW_TAG_variant
:
8021 return "DW_TAG_variant";
8022 case DW_TAG_common_block
:
8023 return "DW_TAG_common_block";
8024 case DW_TAG_common_inclusion
:
8025 return "DW_TAG_common_inclusion";
8026 case DW_TAG_inheritance
:
8027 return "DW_TAG_inheritance";
8028 case DW_TAG_inlined_subroutine
:
8029 return "DW_TAG_inlined_subroutine";
8031 return "DW_TAG_module";
8032 case DW_TAG_ptr_to_member_type
:
8033 return "DW_TAG_ptr_to_member_type";
8034 case DW_TAG_set_type
:
8035 return "DW_TAG_set_type";
8036 case DW_TAG_subrange_type
:
8037 return "DW_TAG_subrange_type";
8038 case DW_TAG_with_stmt
:
8039 return "DW_TAG_with_stmt";
8040 case DW_TAG_access_declaration
:
8041 return "DW_TAG_access_declaration";
8042 case DW_TAG_base_type
:
8043 return "DW_TAG_base_type";
8044 case DW_TAG_catch_block
:
8045 return "DW_TAG_catch_block";
8046 case DW_TAG_const_type
:
8047 return "DW_TAG_const_type";
8048 case DW_TAG_constant
:
8049 return "DW_TAG_constant";
8050 case DW_TAG_enumerator
:
8051 return "DW_TAG_enumerator";
8052 case DW_TAG_file_type
:
8053 return "DW_TAG_file_type";
8055 return "DW_TAG_friend";
8056 case DW_TAG_namelist
:
8057 return "DW_TAG_namelist";
8058 case DW_TAG_namelist_item
:
8059 return "DW_TAG_namelist_item";
8060 case DW_TAG_packed_type
:
8061 return "DW_TAG_packed_type";
8062 case DW_TAG_subprogram
:
8063 return "DW_TAG_subprogram";
8064 case DW_TAG_template_type_param
:
8065 return "DW_TAG_template_type_param";
8066 case DW_TAG_template_value_param
:
8067 return "DW_TAG_template_value_param";
8068 case DW_TAG_thrown_type
:
8069 return "DW_TAG_thrown_type";
8070 case DW_TAG_try_block
:
8071 return "DW_TAG_try_block";
8072 case DW_TAG_variant_part
:
8073 return "DW_TAG_variant_part";
8074 case DW_TAG_variable
:
8075 return "DW_TAG_variable";
8076 case DW_TAG_volatile_type
:
8077 return "DW_TAG_volatile_type";
8078 case DW_TAG_dwarf_procedure
:
8079 return "DW_TAG_dwarf_procedure";
8080 case DW_TAG_restrict_type
:
8081 return "DW_TAG_restrict_type";
8082 case DW_TAG_interface_type
:
8083 return "DW_TAG_interface_type";
8084 case DW_TAG_namespace
:
8085 return "DW_TAG_namespace";
8086 case DW_TAG_imported_module
:
8087 return "DW_TAG_imported_module";
8088 case DW_TAG_unspecified_type
:
8089 return "DW_TAG_unspecified_type";
8090 case DW_TAG_partial_unit
:
8091 return "DW_TAG_partial_unit";
8092 case DW_TAG_imported_unit
:
8093 return "DW_TAG_imported_unit";
8094 case DW_TAG_condition
:
8095 return "DW_TAG_condition";
8096 case DW_TAG_shared_type
:
8097 return "DW_TAG_shared_type";
8098 case DW_TAG_MIPS_loop
:
8099 return "DW_TAG_MIPS_loop";
8100 case DW_TAG_HP_array_descriptor
:
8101 return "DW_TAG_HP_array_descriptor";
8102 case DW_TAG_format_label
:
8103 return "DW_TAG_format_label";
8104 case DW_TAG_function_template
:
8105 return "DW_TAG_function_template";
8106 case DW_TAG_class_template
:
8107 return "DW_TAG_class_template";
8108 case DW_TAG_GNU_BINCL
:
8109 return "DW_TAG_GNU_BINCL";
8110 case DW_TAG_GNU_EINCL
:
8111 return "DW_TAG_GNU_EINCL";
8112 case DW_TAG_upc_shared_type
:
8113 return "DW_TAG_upc_shared_type";
8114 case DW_TAG_upc_strict_type
:
8115 return "DW_TAG_upc_strict_type";
8116 case DW_TAG_upc_relaxed_type
:
8117 return "DW_TAG_upc_relaxed_type";
8118 case DW_TAG_PGI_kanji_type
:
8119 return "DW_TAG_PGI_kanji_type";
8120 case DW_TAG_PGI_interface_block
:
8121 return "DW_TAG_PGI_interface_block";
8123 return "DW_TAG_<unknown>";
8127 /* Convert a DWARF attribute code into its string name. */
8130 dwarf_attr_name (unsigned attr
)
8135 return "DW_AT_sibling";
8136 case DW_AT_location
:
8137 return "DW_AT_location";
8139 return "DW_AT_name";
8140 case DW_AT_ordering
:
8141 return "DW_AT_ordering";
8142 case DW_AT_subscr_data
:
8143 return "DW_AT_subscr_data";
8144 case DW_AT_byte_size
:
8145 return "DW_AT_byte_size";
8146 case DW_AT_bit_offset
:
8147 return "DW_AT_bit_offset";
8148 case DW_AT_bit_size
:
8149 return "DW_AT_bit_size";
8150 case DW_AT_element_list
:
8151 return "DW_AT_element_list";
8152 case DW_AT_stmt_list
:
8153 return "DW_AT_stmt_list";
8155 return "DW_AT_low_pc";
8157 return "DW_AT_high_pc";
8158 case DW_AT_language
:
8159 return "DW_AT_language";
8161 return "DW_AT_member";
8163 return "DW_AT_discr";
8164 case DW_AT_discr_value
:
8165 return "DW_AT_discr_value";
8166 case DW_AT_visibility
:
8167 return "DW_AT_visibility";
8169 return "DW_AT_import";
8170 case DW_AT_string_length
:
8171 return "DW_AT_string_length";
8172 case DW_AT_common_reference
:
8173 return "DW_AT_common_reference";
8174 case DW_AT_comp_dir
:
8175 return "DW_AT_comp_dir";
8176 case DW_AT_const_value
:
8177 return "DW_AT_const_value";
8178 case DW_AT_containing_type
:
8179 return "DW_AT_containing_type";
8180 case DW_AT_default_value
:
8181 return "DW_AT_default_value";
8183 return "DW_AT_inline";
8184 case DW_AT_is_optional
:
8185 return "DW_AT_is_optional";
8186 case DW_AT_lower_bound
:
8187 return "DW_AT_lower_bound";
8188 case DW_AT_producer
:
8189 return "DW_AT_producer";
8190 case DW_AT_prototyped
:
8191 return "DW_AT_prototyped";
8192 case DW_AT_return_addr
:
8193 return "DW_AT_return_addr";
8194 case DW_AT_start_scope
:
8195 return "DW_AT_start_scope";
8196 case DW_AT_bit_stride
:
8197 return "DW_AT_bit_stride";
8198 case DW_AT_upper_bound
:
8199 return "DW_AT_upper_bound";
8200 case DW_AT_abstract_origin
:
8201 return "DW_AT_abstract_origin";
8202 case DW_AT_accessibility
:
8203 return "DW_AT_accessibility";
8204 case DW_AT_address_class
:
8205 return "DW_AT_address_class";
8206 case DW_AT_artificial
:
8207 return "DW_AT_artificial";
8208 case DW_AT_base_types
:
8209 return "DW_AT_base_types";
8210 case DW_AT_calling_convention
:
8211 return "DW_AT_calling_convention";
8213 return "DW_AT_count";
8214 case DW_AT_data_member_location
:
8215 return "DW_AT_data_member_location";
8216 case DW_AT_decl_column
:
8217 return "DW_AT_decl_column";
8218 case DW_AT_decl_file
:
8219 return "DW_AT_decl_file";
8220 case DW_AT_decl_line
:
8221 return "DW_AT_decl_line";
8222 case DW_AT_declaration
:
8223 return "DW_AT_declaration";
8224 case DW_AT_discr_list
:
8225 return "DW_AT_discr_list";
8226 case DW_AT_encoding
:
8227 return "DW_AT_encoding";
8228 case DW_AT_external
:
8229 return "DW_AT_external";
8230 case DW_AT_frame_base
:
8231 return "DW_AT_frame_base";
8233 return "DW_AT_friend";
8234 case DW_AT_identifier_case
:
8235 return "DW_AT_identifier_case";
8236 case DW_AT_macro_info
:
8237 return "DW_AT_macro_info";
8238 case DW_AT_namelist_items
:
8239 return "DW_AT_namelist_items";
8240 case DW_AT_priority
:
8241 return "DW_AT_priority";
8243 return "DW_AT_segment";
8244 case DW_AT_specification
:
8245 return "DW_AT_specification";
8246 case DW_AT_static_link
:
8247 return "DW_AT_static_link";
8249 return "DW_AT_type";
8250 case DW_AT_use_location
:
8251 return "DW_AT_use_location";
8252 case DW_AT_variable_parameter
:
8253 return "DW_AT_variable_parameter";
8254 case DW_AT_virtuality
:
8255 return "DW_AT_virtuality";
8256 case DW_AT_vtable_elem_location
:
8257 return "DW_AT_vtable_elem_location";
8258 /* DWARF 3 values. */
8259 case DW_AT_allocated
:
8260 return "DW_AT_allocated";
8261 case DW_AT_associated
:
8262 return "DW_AT_associated";
8263 case DW_AT_data_location
:
8264 return "DW_AT_data_location";
8265 case DW_AT_byte_stride
:
8266 return "DW_AT_byte_stride";
8267 case DW_AT_entry_pc
:
8268 return "DW_AT_entry_pc";
8269 case DW_AT_use_UTF8
:
8270 return "DW_AT_use_UTF8";
8271 case DW_AT_extension
:
8272 return "DW_AT_extension";
8274 return "DW_AT_ranges";
8275 case DW_AT_trampoline
:
8276 return "DW_AT_trampoline";
8277 case DW_AT_call_column
:
8278 return "DW_AT_call_column";
8279 case DW_AT_call_file
:
8280 return "DW_AT_call_file";
8281 case DW_AT_call_line
:
8282 return "DW_AT_call_line";
8283 case DW_AT_description
:
8284 return "DW_AT_description";
8285 case DW_AT_binary_scale
:
8286 return "DW_AT_binary_scale";
8287 case DW_AT_decimal_scale
:
8288 return "DW_AT_decimal_scale";
8290 return "DW_AT_small";
8291 case DW_AT_decimal_sign
:
8292 return "DW_AT_decimal_sign";
8293 case DW_AT_digit_count
:
8294 return "DW_AT_digit_count";
8295 case DW_AT_picture_string
:
8296 return "DW_AT_picture_string";
8298 return "DW_AT_mutable";
8299 case DW_AT_threads_scaled
:
8300 return "DW_AT_threads_scaled";
8301 case DW_AT_explicit
:
8302 return "DW_AT_explicit";
8303 case DW_AT_object_pointer
:
8304 return "DW_AT_object_pointer";
8305 case DW_AT_endianity
:
8306 return "DW_AT_endianity";
8307 case DW_AT_elemental
:
8308 return "DW_AT_elemental";
8310 return "DW_AT_pure";
8311 case DW_AT_recursive
:
8312 return "DW_AT_recursive";
8314 /* SGI/MIPS extensions. */
8315 case DW_AT_MIPS_fde
:
8316 return "DW_AT_MIPS_fde";
8317 case DW_AT_MIPS_loop_begin
:
8318 return "DW_AT_MIPS_loop_begin";
8319 case DW_AT_MIPS_tail_loop_begin
:
8320 return "DW_AT_MIPS_tail_loop_begin";
8321 case DW_AT_MIPS_epilog_begin
:
8322 return "DW_AT_MIPS_epilog_begin";
8323 case DW_AT_MIPS_loop_unroll_factor
:
8324 return "DW_AT_MIPS_loop_unroll_factor";
8325 case DW_AT_MIPS_software_pipeline_depth
:
8326 return "DW_AT_MIPS_software_pipeline_depth";
8327 case DW_AT_MIPS_linkage_name
:
8328 return "DW_AT_MIPS_linkage_name";
8329 case DW_AT_MIPS_stride
:
8330 return "DW_AT_MIPS_stride";
8331 case DW_AT_MIPS_abstract_name
:
8332 return "DW_AT_MIPS_abstract_name";
8333 case DW_AT_MIPS_clone_origin
:
8334 return "DW_AT_MIPS_clone_origin";
8335 case DW_AT_MIPS_has_inlines
:
8336 return "DW_AT_MIPS_has_inlines";
8338 /* HP extensions. */
8339 case DW_AT_HP_block_index
:
8340 return "DW_AT_HP_block_index";
8341 case DW_AT_HP_unmodifiable
:
8342 return "DW_AT_HP_unmodifiable";
8343 case DW_AT_HP_actuals_stmt_list
:
8344 return "DW_AT_HP_actuals_stmt_list";
8345 case DW_AT_HP_proc_per_section
:
8346 return "DW_AT_HP_proc_per_section";
8347 case DW_AT_HP_raw_data_ptr
:
8348 return "DW_AT_HP_raw_data_ptr";
8349 case DW_AT_HP_pass_by_reference
:
8350 return "DW_AT_HP_pass_by_reference";
8351 case DW_AT_HP_opt_level
:
8352 return "DW_AT_HP_opt_level";
8353 case DW_AT_HP_prof_version_id
:
8354 return "DW_AT_HP_prof_version_id";
8355 case DW_AT_HP_opt_flags
:
8356 return "DW_AT_HP_opt_flags";
8357 case DW_AT_HP_cold_region_low_pc
:
8358 return "DW_AT_HP_cold_region_low_pc";
8359 case DW_AT_HP_cold_region_high_pc
:
8360 return "DW_AT_HP_cold_region_high_pc";
8361 case DW_AT_HP_all_variables_modifiable
:
8362 return "DW_AT_HP_all_variables_modifiable";
8363 case DW_AT_HP_linkage_name
:
8364 return "DW_AT_HP_linkage_name";
8365 case DW_AT_HP_prof_flags
:
8366 return "DW_AT_HP_prof_flags";
8367 /* GNU extensions. */
8368 case DW_AT_sf_names
:
8369 return "DW_AT_sf_names";
8370 case DW_AT_src_info
:
8371 return "DW_AT_src_info";
8372 case DW_AT_mac_info
:
8373 return "DW_AT_mac_info";
8374 case DW_AT_src_coords
:
8375 return "DW_AT_src_coords";
8376 case DW_AT_body_begin
:
8377 return "DW_AT_body_begin";
8378 case DW_AT_body_end
:
8379 return "DW_AT_body_end";
8380 case DW_AT_GNU_vector
:
8381 return "DW_AT_GNU_vector";
8382 /* VMS extensions. */
8383 case DW_AT_VMS_rtnbeg_pd_address
:
8384 return "DW_AT_VMS_rtnbeg_pd_address";
8385 /* UPC extension. */
8386 case DW_AT_upc_threads_scaled
:
8387 return "DW_AT_upc_threads_scaled";
8388 /* PGI (STMicroelectronics) extensions. */
8389 case DW_AT_PGI_lbase
:
8390 return "DW_AT_PGI_lbase";
8391 case DW_AT_PGI_soffset
:
8392 return "DW_AT_PGI_soffset";
8393 case DW_AT_PGI_lstride
:
8394 return "DW_AT_PGI_lstride";
8396 return "DW_AT_<unknown>";
8400 /* Convert a DWARF value form code into its string name. */
8403 dwarf_form_name (unsigned form
)
8408 return "DW_FORM_addr";
8409 case DW_FORM_block2
:
8410 return "DW_FORM_block2";
8411 case DW_FORM_block4
:
8412 return "DW_FORM_block4";
8414 return "DW_FORM_data2";
8416 return "DW_FORM_data4";
8418 return "DW_FORM_data8";
8419 case DW_FORM_string
:
8420 return "DW_FORM_string";
8422 return "DW_FORM_block";
8423 case DW_FORM_block1
:
8424 return "DW_FORM_block1";
8426 return "DW_FORM_data1";
8428 return "DW_FORM_flag";
8430 return "DW_FORM_sdata";
8432 return "DW_FORM_strp";
8434 return "DW_FORM_udata";
8435 case DW_FORM_ref_addr
:
8436 return "DW_FORM_ref_addr";
8438 return "DW_FORM_ref1";
8440 return "DW_FORM_ref2";
8442 return "DW_FORM_ref4";
8444 return "DW_FORM_ref8";
8445 case DW_FORM_ref_udata
:
8446 return "DW_FORM_ref_udata";
8447 case DW_FORM_indirect
:
8448 return "DW_FORM_indirect";
8450 return "DW_FORM_<unknown>";
8454 /* Convert a DWARF stack opcode into its string name. */
8457 dwarf_stack_op_name (unsigned op
)
8462 return "DW_OP_addr";
8464 return "DW_OP_deref";
8466 return "DW_OP_const1u";
8468 return "DW_OP_const1s";
8470 return "DW_OP_const2u";
8472 return "DW_OP_const2s";
8474 return "DW_OP_const4u";
8476 return "DW_OP_const4s";
8478 return "DW_OP_const8u";
8480 return "DW_OP_const8s";
8482 return "DW_OP_constu";
8484 return "DW_OP_consts";
8488 return "DW_OP_drop";
8490 return "DW_OP_over";
8492 return "DW_OP_pick";
8494 return "DW_OP_swap";
8498 return "DW_OP_xderef";
8506 return "DW_OP_minus";
8518 return "DW_OP_plus";
8519 case DW_OP_plus_uconst
:
8520 return "DW_OP_plus_uconst";
8526 return "DW_OP_shra";
8544 return "DW_OP_skip";
8546 return "DW_OP_lit0";
8548 return "DW_OP_lit1";
8550 return "DW_OP_lit2";
8552 return "DW_OP_lit3";
8554 return "DW_OP_lit4";
8556 return "DW_OP_lit5";
8558 return "DW_OP_lit6";
8560 return "DW_OP_lit7";
8562 return "DW_OP_lit8";
8564 return "DW_OP_lit9";
8566 return "DW_OP_lit10";
8568 return "DW_OP_lit11";
8570 return "DW_OP_lit12";
8572 return "DW_OP_lit13";
8574 return "DW_OP_lit14";
8576 return "DW_OP_lit15";
8578 return "DW_OP_lit16";
8580 return "DW_OP_lit17";
8582 return "DW_OP_lit18";
8584 return "DW_OP_lit19";
8586 return "DW_OP_lit20";
8588 return "DW_OP_lit21";
8590 return "DW_OP_lit22";
8592 return "DW_OP_lit23";
8594 return "DW_OP_lit24";
8596 return "DW_OP_lit25";
8598 return "DW_OP_lit26";
8600 return "DW_OP_lit27";
8602 return "DW_OP_lit28";
8604 return "DW_OP_lit29";
8606 return "DW_OP_lit30";
8608 return "DW_OP_lit31";
8610 return "DW_OP_reg0";
8612 return "DW_OP_reg1";
8614 return "DW_OP_reg2";
8616 return "DW_OP_reg3";
8618 return "DW_OP_reg4";
8620 return "DW_OP_reg5";
8622 return "DW_OP_reg6";
8624 return "DW_OP_reg7";
8626 return "DW_OP_reg8";
8628 return "DW_OP_reg9";
8630 return "DW_OP_reg10";
8632 return "DW_OP_reg11";
8634 return "DW_OP_reg12";
8636 return "DW_OP_reg13";
8638 return "DW_OP_reg14";
8640 return "DW_OP_reg15";
8642 return "DW_OP_reg16";
8644 return "DW_OP_reg17";
8646 return "DW_OP_reg18";
8648 return "DW_OP_reg19";
8650 return "DW_OP_reg20";
8652 return "DW_OP_reg21";
8654 return "DW_OP_reg22";
8656 return "DW_OP_reg23";
8658 return "DW_OP_reg24";
8660 return "DW_OP_reg25";
8662 return "DW_OP_reg26";
8664 return "DW_OP_reg27";
8666 return "DW_OP_reg28";
8668 return "DW_OP_reg29";
8670 return "DW_OP_reg30";
8672 return "DW_OP_reg31";
8674 return "DW_OP_breg0";
8676 return "DW_OP_breg1";
8678 return "DW_OP_breg2";
8680 return "DW_OP_breg3";
8682 return "DW_OP_breg4";
8684 return "DW_OP_breg5";
8686 return "DW_OP_breg6";
8688 return "DW_OP_breg7";
8690 return "DW_OP_breg8";
8692 return "DW_OP_breg9";
8694 return "DW_OP_breg10";
8696 return "DW_OP_breg11";
8698 return "DW_OP_breg12";
8700 return "DW_OP_breg13";
8702 return "DW_OP_breg14";
8704 return "DW_OP_breg15";
8706 return "DW_OP_breg16";
8708 return "DW_OP_breg17";
8710 return "DW_OP_breg18";
8712 return "DW_OP_breg19";
8714 return "DW_OP_breg20";
8716 return "DW_OP_breg21";
8718 return "DW_OP_breg22";
8720 return "DW_OP_breg23";
8722 return "DW_OP_breg24";
8724 return "DW_OP_breg25";
8726 return "DW_OP_breg26";
8728 return "DW_OP_breg27";
8730 return "DW_OP_breg28";
8732 return "DW_OP_breg29";
8734 return "DW_OP_breg30";
8736 return "DW_OP_breg31";
8738 return "DW_OP_regx";
8740 return "DW_OP_fbreg";
8742 return "DW_OP_bregx";
8744 return "DW_OP_piece";
8745 case DW_OP_deref_size
:
8746 return "DW_OP_deref_size";
8747 case DW_OP_xderef_size
:
8748 return "DW_OP_xderef_size";
8751 /* DWARF 3 extensions. */
8752 case DW_OP_push_object_address
:
8753 return "DW_OP_push_object_address";
8755 return "DW_OP_call2";
8757 return "DW_OP_call4";
8758 case DW_OP_call_ref
:
8759 return "DW_OP_call_ref";
8760 /* GNU extensions. */
8761 case DW_OP_form_tls_address
:
8762 return "DW_OP_form_tls_address";
8763 case DW_OP_call_frame_cfa
:
8764 return "DW_OP_call_frame_cfa";
8765 case DW_OP_bit_piece
:
8766 return "DW_OP_bit_piece";
8767 case DW_OP_GNU_push_tls_address
:
8768 return "DW_OP_GNU_push_tls_address";
8769 case DW_OP_GNU_uninit
:
8770 return "DW_OP_GNU_uninit";
8771 /* HP extensions. */
8772 case DW_OP_HP_is_value
:
8773 return "DW_OP_HP_is_value";
8774 case DW_OP_HP_fltconst4
:
8775 return "DW_OP_HP_fltconst4";
8776 case DW_OP_HP_fltconst8
:
8777 return "DW_OP_HP_fltconst8";
8778 case DW_OP_HP_mod_range
:
8779 return "DW_OP_HP_mod_range";
8780 case DW_OP_HP_unmod_range
:
8781 return "DW_OP_HP_unmod_range";
8783 return "DW_OP_HP_tls";
8785 return "OP_<unknown>";
8790 dwarf_bool_name (unsigned mybool
)
8798 /* Convert a DWARF type code into its string name. */
8801 dwarf_type_encoding_name (unsigned enc
)
8806 return "DW_ATE_void";
8807 case DW_ATE_address
:
8808 return "DW_ATE_address";
8809 case DW_ATE_boolean
:
8810 return "DW_ATE_boolean";
8811 case DW_ATE_complex_float
:
8812 return "DW_ATE_complex_float";
8814 return "DW_ATE_float";
8816 return "DW_ATE_signed";
8817 case DW_ATE_signed_char
:
8818 return "DW_ATE_signed_char";
8819 case DW_ATE_unsigned
:
8820 return "DW_ATE_unsigned";
8821 case DW_ATE_unsigned_char
:
8822 return "DW_ATE_unsigned_char";
8824 case DW_ATE_imaginary_float
:
8825 return "DW_ATE_imaginary_float";
8826 case DW_ATE_packed_decimal
:
8827 return "DW_ATE_packed_decimal";
8828 case DW_ATE_numeric_string
:
8829 return "DW_ATE_numeric_string";
8831 return "DW_ATE_edited";
8832 case DW_ATE_signed_fixed
:
8833 return "DW_ATE_signed_fixed";
8834 case DW_ATE_unsigned_fixed
:
8835 return "DW_ATE_unsigned_fixed";
8836 case DW_ATE_decimal_float
:
8837 return "DW_ATE_decimal_float";
8838 /* HP extensions. */
8839 case DW_ATE_HP_float80
:
8840 return "DW_ATE_HP_float80";
8841 case DW_ATE_HP_complex_float80
:
8842 return "DW_ATE_HP_complex_float80";
8843 case DW_ATE_HP_float128
:
8844 return "DW_ATE_HP_float128";
8845 case DW_ATE_HP_complex_float128
:
8846 return "DW_ATE_HP_complex_float128";
8847 case DW_ATE_HP_floathpintel
:
8848 return "DW_ATE_HP_floathpintel";
8849 case DW_ATE_HP_imaginary_float80
:
8850 return "DW_ATE_HP_imaginary_float80";
8851 case DW_ATE_HP_imaginary_float128
:
8852 return "DW_ATE_HP_imaginary_float128";
8854 return "DW_ATE_<unknown>";
8858 /* Convert a DWARF call frame info operation to its string name. */
8862 dwarf_cfi_name (unsigned cfi_opc
)
8866 case DW_CFA_advance_loc
:
8867 return "DW_CFA_advance_loc";
8869 return "DW_CFA_offset";
8870 case DW_CFA_restore
:
8871 return "DW_CFA_restore";
8873 return "DW_CFA_nop";
8874 case DW_CFA_set_loc
:
8875 return "DW_CFA_set_loc";
8876 case DW_CFA_advance_loc1
:
8877 return "DW_CFA_advance_loc1";
8878 case DW_CFA_advance_loc2
:
8879 return "DW_CFA_advance_loc2";
8880 case DW_CFA_advance_loc4
:
8881 return "DW_CFA_advance_loc4";
8882 case DW_CFA_offset_extended
:
8883 return "DW_CFA_offset_extended";
8884 case DW_CFA_restore_extended
:
8885 return "DW_CFA_restore_extended";
8886 case DW_CFA_undefined
:
8887 return "DW_CFA_undefined";
8888 case DW_CFA_same_value
:
8889 return "DW_CFA_same_value";
8890 case DW_CFA_register
:
8891 return "DW_CFA_register";
8892 case DW_CFA_remember_state
:
8893 return "DW_CFA_remember_state";
8894 case DW_CFA_restore_state
:
8895 return "DW_CFA_restore_state";
8896 case DW_CFA_def_cfa
:
8897 return "DW_CFA_def_cfa";
8898 case DW_CFA_def_cfa_register
:
8899 return "DW_CFA_def_cfa_register";
8900 case DW_CFA_def_cfa_offset
:
8901 return "DW_CFA_def_cfa_offset";
8903 case DW_CFA_def_cfa_expression
:
8904 return "DW_CFA_def_cfa_expression";
8905 case DW_CFA_expression
:
8906 return "DW_CFA_expression";
8907 case DW_CFA_offset_extended_sf
:
8908 return "DW_CFA_offset_extended_sf";
8909 case DW_CFA_def_cfa_sf
:
8910 return "DW_CFA_def_cfa_sf";
8911 case DW_CFA_def_cfa_offset_sf
:
8912 return "DW_CFA_def_cfa_offset_sf";
8913 case DW_CFA_val_offset
:
8914 return "DW_CFA_val_offset";
8915 case DW_CFA_val_offset_sf
:
8916 return "DW_CFA_val_offset_sf";
8917 case DW_CFA_val_expression
:
8918 return "DW_CFA_val_expression";
8919 /* SGI/MIPS specific. */
8920 case DW_CFA_MIPS_advance_loc8
:
8921 return "DW_CFA_MIPS_advance_loc8";
8922 /* GNU extensions. */
8923 case DW_CFA_GNU_window_save
:
8924 return "DW_CFA_GNU_window_save";
8925 case DW_CFA_GNU_args_size
:
8926 return "DW_CFA_GNU_args_size";
8927 case DW_CFA_GNU_negative_offset_extended
:
8928 return "DW_CFA_GNU_negative_offset_extended";
8930 return "DW_CFA_<unknown>";
8936 dump_die (struct die_info
*die
)
8940 fprintf_unfiltered (gdb_stderr
, "Die: %s (abbrev = %d, offset = %d)\n",
8941 dwarf_tag_name (die
->tag
), die
->abbrev
, die
->offset
);
8942 fprintf_unfiltered (gdb_stderr
, "\thas children: %s\n",
8943 dwarf_bool_name (die
->child
!= NULL
));
8945 fprintf_unfiltered (gdb_stderr
, "\tattributes:\n");
8946 for (i
= 0; i
< die
->num_attrs
; ++i
)
8948 fprintf_unfiltered (gdb_stderr
, "\t\t%s (%s) ",
8949 dwarf_attr_name (die
->attrs
[i
].name
),
8950 dwarf_form_name (die
->attrs
[i
].form
));
8951 switch (die
->attrs
[i
].form
)
8953 case DW_FORM_ref_addr
:
8955 fprintf_unfiltered (gdb_stderr
, "address: ");
8956 fputs_filtered (paddress (DW_ADDR (&die
->attrs
[i
])), gdb_stderr
);
8958 case DW_FORM_block2
:
8959 case DW_FORM_block4
:
8961 case DW_FORM_block1
:
8962 fprintf_unfiltered (gdb_stderr
, "block: size %d", DW_BLOCK (&die
->attrs
[i
])->size
);
8967 fprintf_unfiltered (gdb_stderr
, "constant ref: %ld (adjusted)",
8968 (long) (DW_ADDR (&die
->attrs
[i
])));
8976 fprintf_unfiltered (gdb_stderr
, "constant: %ld", DW_UNSND (&die
->attrs
[i
]));
8978 case DW_FORM_string
:
8980 fprintf_unfiltered (gdb_stderr
, "string: \"%s\"",
8981 DW_STRING (&die
->attrs
[i
])
8982 ? DW_STRING (&die
->attrs
[i
]) : "");
8985 if (DW_UNSND (&die
->attrs
[i
]))
8986 fprintf_unfiltered (gdb_stderr
, "flag: TRUE");
8988 fprintf_unfiltered (gdb_stderr
, "flag: FALSE");
8990 case DW_FORM_indirect
:
8991 /* the reader will have reduced the indirect form to
8992 the "base form" so this form should not occur */
8993 fprintf_unfiltered (gdb_stderr
, "unexpected attribute form: DW_FORM_indirect");
8996 fprintf_unfiltered (gdb_stderr
, "unsupported attribute form: %d.",
8997 die
->attrs
[i
].form
);
8999 fprintf_unfiltered (gdb_stderr
, "\n");
9004 dump_die_list (struct die_info
*die
)
9009 if (die
->child
!= NULL
)
9010 dump_die_list (die
->child
);
9011 if (die
->sibling
!= NULL
)
9012 dump_die_list (die
->sibling
);
9017 store_in_ref_table (unsigned int offset
, struct die_info
*die
,
9018 struct dwarf2_cu
*cu
)
9021 struct die_info
*old
;
9023 h
= (offset
% REF_HASH_SIZE
);
9024 old
= cu
->die_ref_table
[h
];
9025 die
->next_ref
= old
;
9026 cu
->die_ref_table
[h
] = die
;
9030 dwarf2_get_ref_die_offset (struct attribute
*attr
, struct dwarf2_cu
*cu
)
9032 unsigned int result
= 0;
9036 case DW_FORM_ref_addr
:
9041 case DW_FORM_ref_udata
:
9042 result
= DW_ADDR (attr
);
9045 complaint (&symfile_complaints
,
9046 _("unsupported die ref attribute form: '%s'"),
9047 dwarf_form_name (attr
->form
));
9052 /* Return the constant value held by the given attribute. Return -1
9053 if the value held by the attribute is not constant. */
9056 dwarf2_get_attr_constant_value (struct attribute
*attr
, int default_value
)
9058 if (attr
->form
== DW_FORM_sdata
)
9059 return DW_SND (attr
);
9060 else if (attr
->form
== DW_FORM_udata
9061 || attr
->form
== DW_FORM_data1
9062 || attr
->form
== DW_FORM_data2
9063 || attr
->form
== DW_FORM_data4
9064 || attr
->form
== DW_FORM_data8
)
9065 return DW_UNSND (attr
);
9068 complaint (&symfile_complaints
, _("Attribute value is not a constant (%s)"),
9069 dwarf_form_name (attr
->form
));
9070 return default_value
;
9074 static struct die_info
*
9075 follow_die_ref (struct die_info
*src_die
, struct attribute
*attr
,
9076 struct dwarf2_cu
*cu
)
9078 struct die_info
*die
;
9079 unsigned int offset
;
9081 struct die_info temp_die
;
9082 struct dwarf2_cu
*target_cu
;
9084 offset
= dwarf2_get_ref_die_offset (attr
, cu
);
9086 if (DW_ADDR (attr
) < cu
->header
.offset
9087 || DW_ADDR (attr
) >= cu
->header
.offset
+ cu
->header
.length
)
9089 struct dwarf2_per_cu_data
*per_cu
;
9090 per_cu
= dwarf2_find_containing_comp_unit (DW_ADDR (attr
),
9092 target_cu
= per_cu
->cu
;
9097 h
= (offset
% REF_HASH_SIZE
);
9098 die
= target_cu
->die_ref_table
[h
];
9101 if (die
->offset
== offset
)
9103 die
= die
->next_ref
;
9106 error (_("Dwarf Error: Cannot find DIE at 0x%lx referenced from DIE "
9107 "at 0x%lx [in module %s]"),
9108 (long) src_die
->offset
, (long) offset
, cu
->objfile
->name
);
9113 /* Decode simple location descriptions.
9114 Given a pointer to a dwarf block that defines a location, compute
9115 the location and return the value.
9117 NOTE drow/2003-11-18: This function is called in two situations
9118 now: for the address of static or global variables (partial symbols
9119 only) and for offsets into structures which are expected to be
9120 (more or less) constant. The partial symbol case should go away,
9121 and only the constant case should remain. That will let this
9122 function complain more accurately. A few special modes are allowed
9123 without complaint for global variables (for instance, global
9124 register values and thread-local values).
9126 A location description containing no operations indicates that the
9127 object is optimized out. The return value is 0 for that case.
9128 FIXME drow/2003-11-16: No callers check for this case any more; soon all
9129 callers will only want a very basic result and this can become a
9132 Note that stack[0] is unused except as a default error return.
9133 Note that stack overflow is not yet handled. */
9136 decode_locdesc (struct dwarf_block
*blk
, struct dwarf2_cu
*cu
)
9138 struct objfile
*objfile
= cu
->objfile
;
9139 struct comp_unit_head
*cu_header
= &cu
->header
;
9141 int size
= blk
->size
;
9142 gdb_byte
*data
= blk
->data
;
9143 CORE_ADDR stack
[64];
9145 unsigned int bytes_read
, unsnd
;
9189 stack
[++stacki
] = op
- DW_OP_lit0
;
9224 stack
[++stacki
] = op
- DW_OP_reg0
;
9226 dwarf2_complex_location_expr_complaint ();
9230 unsnd
= read_unsigned_leb128 (NULL
, (data
+ i
), &bytes_read
);
9232 stack
[++stacki
] = unsnd
;
9234 dwarf2_complex_location_expr_complaint ();
9238 stack
[++stacki
] = read_address (objfile
->obfd
, &data
[i
],
9244 stack
[++stacki
] = read_1_byte (objfile
->obfd
, &data
[i
]);
9249 stack
[++stacki
] = read_1_signed_byte (objfile
->obfd
, &data
[i
]);
9254 stack
[++stacki
] = read_2_bytes (objfile
->obfd
, &data
[i
]);
9259 stack
[++stacki
] = read_2_signed_bytes (objfile
->obfd
, &data
[i
]);
9264 stack
[++stacki
] = read_4_bytes (objfile
->obfd
, &data
[i
]);
9269 stack
[++stacki
] = read_4_signed_bytes (objfile
->obfd
, &data
[i
]);
9274 stack
[++stacki
] = read_unsigned_leb128 (NULL
, (data
+ i
),
9280 stack
[++stacki
] = read_signed_leb128 (NULL
, (data
+ i
), &bytes_read
);
9285 stack
[stacki
+ 1] = stack
[stacki
];
9290 stack
[stacki
- 1] += stack
[stacki
];
9294 case DW_OP_plus_uconst
:
9295 stack
[stacki
] += read_unsigned_leb128 (NULL
, (data
+ i
), &bytes_read
);
9300 stack
[stacki
- 1] -= stack
[stacki
];
9305 /* If we're not the last op, then we definitely can't encode
9306 this using GDB's address_class enum. This is valid for partial
9307 global symbols, although the variable's address will be bogus
9310 dwarf2_complex_location_expr_complaint ();
9313 case DW_OP_GNU_push_tls_address
:
9314 /* The top of the stack has the offset from the beginning
9315 of the thread control block at which the variable is located. */
9316 /* Nothing should follow this operator, so the top of stack would
9318 /* This is valid for partial global symbols, but the variable's
9319 address will be bogus in the psymtab. */
9321 dwarf2_complex_location_expr_complaint ();
9324 case DW_OP_GNU_uninit
:
9328 complaint (&symfile_complaints
, _("unsupported stack op: '%s'"),
9329 dwarf_stack_op_name (op
));
9330 return (stack
[stacki
]);
9333 return (stack
[stacki
]);
9336 /* memory allocation interface */
9338 static struct dwarf_block
*
9339 dwarf_alloc_block (struct dwarf2_cu
*cu
)
9341 struct dwarf_block
*blk
;
9343 blk
= (struct dwarf_block
*)
9344 obstack_alloc (&cu
->comp_unit_obstack
, sizeof (struct dwarf_block
));
9348 static struct abbrev_info
*
9349 dwarf_alloc_abbrev (struct dwarf2_cu
*cu
)
9351 struct abbrev_info
*abbrev
;
9353 abbrev
= (struct abbrev_info
*)
9354 obstack_alloc (&cu
->abbrev_obstack
, sizeof (struct abbrev_info
));
9355 memset (abbrev
, 0, sizeof (struct abbrev_info
));
9359 static struct die_info
*
9360 dwarf_alloc_die (void)
9362 struct die_info
*die
;
9364 die
= (struct die_info
*) xmalloc (sizeof (struct die_info
));
9365 memset (die
, 0, sizeof (struct die_info
));
9370 /* Macro support. */
9373 /* Return the full name of file number I in *LH's file name table.
9374 Use COMP_DIR as the name of the current directory of the
9375 compilation. The result is allocated using xmalloc; the caller is
9376 responsible for freeing it. */
9378 file_full_name (int file
, struct line_header
*lh
, const char *comp_dir
)
9380 /* Is the file number a valid index into the line header's file name
9381 table? Remember that file numbers start with one, not zero. */
9382 if (1 <= file
&& file
<= lh
->num_file_names
)
9384 struct file_entry
*fe
= &lh
->file_names
[file
- 1];
9386 if (IS_ABSOLUTE_PATH (fe
->name
))
9387 return xstrdup (fe
->name
);
9395 dir
= lh
->include_dirs
[fe
->dir_index
- 1];
9401 dir_len
= strlen (dir
);
9402 full_name
= xmalloc (dir_len
+ 1 + strlen (fe
->name
) + 1);
9403 strcpy (full_name
, dir
);
9404 full_name
[dir_len
] = '/';
9405 strcpy (full_name
+ dir_len
+ 1, fe
->name
);
9409 return xstrdup (fe
->name
);
9414 /* The compiler produced a bogus file number. We can at least
9415 record the macro definitions made in the file, even if we
9416 won't be able to find the file by name. */
9418 sprintf (fake_name
, "<bad macro file number %d>", file
);
9420 complaint (&symfile_complaints
,
9421 _("bad file number in macro information (%d)"),
9424 return xstrdup (fake_name
);
9429 static struct macro_source_file
*
9430 macro_start_file (int file
, int line
,
9431 struct macro_source_file
*current_file
,
9432 const char *comp_dir
,
9433 struct line_header
*lh
, struct objfile
*objfile
)
9435 /* The full name of this source file. */
9436 char *full_name
= file_full_name (file
, lh
, comp_dir
);
9438 /* We don't create a macro table for this compilation unit
9439 at all until we actually get a filename. */
9440 if (! pending_macros
)
9441 pending_macros
= new_macro_table (&objfile
->objfile_obstack
,
9442 objfile
->macro_cache
);
9445 /* If we have no current file, then this must be the start_file
9446 directive for the compilation unit's main source file. */
9447 current_file
= macro_set_main (pending_macros
, full_name
);
9449 current_file
= macro_include (current_file
, line
, full_name
);
9453 return current_file
;
9457 /* Copy the LEN characters at BUF to a xmalloc'ed block of memory,
9458 followed by a null byte. */
9460 copy_string (const char *buf
, int len
)
9462 char *s
= xmalloc (len
+ 1);
9463 memcpy (s
, buf
, len
);
9471 consume_improper_spaces (const char *p
, const char *body
)
9475 complaint (&symfile_complaints
,
9476 _("macro definition contains spaces in formal argument list:\n`%s'"),
9488 parse_macro_definition (struct macro_source_file
*file
, int line
,
9493 /* The body string takes one of two forms. For object-like macro
9494 definitions, it should be:
9496 <macro name> " " <definition>
9498 For function-like macro definitions, it should be:
9500 <macro name> "() " <definition>
9502 <macro name> "(" <arg name> ( "," <arg name> ) * ") " <definition>
9504 Spaces may appear only where explicitly indicated, and in the
9507 The Dwarf 2 spec says that an object-like macro's name is always
9508 followed by a space, but versions of GCC around March 2002 omit
9509 the space when the macro's definition is the empty string.
9511 The Dwarf 2 spec says that there should be no spaces between the
9512 formal arguments in a function-like macro's formal argument list,
9513 but versions of GCC around March 2002 include spaces after the
9517 /* Find the extent of the macro name. The macro name is terminated
9518 by either a space or null character (for an object-like macro) or
9519 an opening paren (for a function-like macro). */
9520 for (p
= body
; *p
; p
++)
9521 if (*p
== ' ' || *p
== '(')
9524 if (*p
== ' ' || *p
== '\0')
9526 /* It's an object-like macro. */
9527 int name_len
= p
- body
;
9528 char *name
= copy_string (body
, name_len
);
9529 const char *replacement
;
9532 replacement
= body
+ name_len
+ 1;
9535 dwarf2_macro_malformed_definition_complaint (body
);
9536 replacement
= body
+ name_len
;
9539 macro_define_object (file
, line
, name
, replacement
);
9545 /* It's a function-like macro. */
9546 char *name
= copy_string (body
, p
- body
);
9549 char **argv
= xmalloc (argv_size
* sizeof (*argv
));
9553 p
= consume_improper_spaces (p
, body
);
9555 /* Parse the formal argument list. */
9556 while (*p
&& *p
!= ')')
9558 /* Find the extent of the current argument name. */
9559 const char *arg_start
= p
;
9561 while (*p
&& *p
!= ',' && *p
!= ')' && *p
!= ' ')
9564 if (! *p
|| p
== arg_start
)
9565 dwarf2_macro_malformed_definition_complaint (body
);
9568 /* Make sure argv has room for the new argument. */
9569 if (argc
>= argv_size
)
9572 argv
= xrealloc (argv
, argv_size
* sizeof (*argv
));
9575 argv
[argc
++] = copy_string (arg_start
, p
- arg_start
);
9578 p
= consume_improper_spaces (p
, body
);
9580 /* Consume the comma, if present. */
9585 p
= consume_improper_spaces (p
, body
);
9594 /* Perfectly formed definition, no complaints. */
9595 macro_define_function (file
, line
, name
,
9596 argc
, (const char **) argv
,
9598 else if (*p
== '\0')
9600 /* Complain, but do define it. */
9601 dwarf2_macro_malformed_definition_complaint (body
);
9602 macro_define_function (file
, line
, name
,
9603 argc
, (const char **) argv
,
9607 /* Just complain. */
9608 dwarf2_macro_malformed_definition_complaint (body
);
9611 /* Just complain. */
9612 dwarf2_macro_malformed_definition_complaint (body
);
9618 for (i
= 0; i
< argc
; i
++)
9624 dwarf2_macro_malformed_definition_complaint (body
);
9629 dwarf_decode_macros (struct line_header
*lh
, unsigned int offset
,
9630 char *comp_dir
, bfd
*abfd
,
9631 struct dwarf2_cu
*cu
)
9633 gdb_byte
*mac_ptr
, *mac_end
;
9634 struct macro_source_file
*current_file
= 0;
9636 if (dwarf2_per_objfile
->macinfo_buffer
== NULL
)
9638 complaint (&symfile_complaints
, _("missing .debug_macinfo section"));
9642 mac_ptr
= dwarf2_per_objfile
->macinfo_buffer
+ offset
;
9643 mac_end
= dwarf2_per_objfile
->macinfo_buffer
9644 + dwarf2_per_objfile
->macinfo_size
;
9648 enum dwarf_macinfo_record_type macinfo_type
;
9650 /* Do we at least have room for a macinfo type byte? */
9651 if (mac_ptr
>= mac_end
)
9653 dwarf2_macros_too_long_complaint ();
9657 macinfo_type
= read_1_byte (abfd
, mac_ptr
);
9660 switch (macinfo_type
)
9662 /* A zero macinfo type indicates the end of the macro
9667 case DW_MACINFO_define
:
9668 case DW_MACINFO_undef
:
9670 unsigned int bytes_read
;
9674 line
= read_unsigned_leb128 (abfd
, mac_ptr
, &bytes_read
);
9675 mac_ptr
+= bytes_read
;
9676 body
= read_string (abfd
, mac_ptr
, &bytes_read
);
9677 mac_ptr
+= bytes_read
;
9680 complaint (&symfile_complaints
,
9681 _("debug info gives macro %s outside of any file: %s"),
9683 DW_MACINFO_define
? "definition" : macinfo_type
==
9684 DW_MACINFO_undef
? "undefinition" :
9685 "something-or-other", body
);
9688 if (macinfo_type
== DW_MACINFO_define
)
9689 parse_macro_definition (current_file
, line
, body
);
9690 else if (macinfo_type
== DW_MACINFO_undef
)
9691 macro_undef (current_file
, line
, body
);
9696 case DW_MACINFO_start_file
:
9698 unsigned int bytes_read
;
9701 line
= read_unsigned_leb128 (abfd
, mac_ptr
, &bytes_read
);
9702 mac_ptr
+= bytes_read
;
9703 file
= read_unsigned_leb128 (abfd
, mac_ptr
, &bytes_read
);
9704 mac_ptr
+= bytes_read
;
9706 current_file
= macro_start_file (file
, line
,
9707 current_file
, comp_dir
,
9712 case DW_MACINFO_end_file
:
9714 complaint (&symfile_complaints
,
9715 _("macro debug info has an unmatched `close_file' directive"));
9718 current_file
= current_file
->included_by
;
9721 enum dwarf_macinfo_record_type next_type
;
9723 /* GCC circa March 2002 doesn't produce the zero
9724 type byte marking the end of the compilation
9725 unit. Complain if it's not there, but exit no
9728 /* Do we at least have room for a macinfo type byte? */
9729 if (mac_ptr
>= mac_end
)
9731 dwarf2_macros_too_long_complaint ();
9735 /* We don't increment mac_ptr here, so this is just
9737 next_type
= read_1_byte (abfd
, mac_ptr
);
9739 complaint (&symfile_complaints
,
9740 _("no terminating 0-type entry for macros in `.debug_macinfo' section"));
9747 case DW_MACINFO_vendor_ext
:
9749 unsigned int bytes_read
;
9753 constant
= read_unsigned_leb128 (abfd
, mac_ptr
, &bytes_read
);
9754 mac_ptr
+= bytes_read
;
9755 string
= read_string (abfd
, mac_ptr
, &bytes_read
);
9756 mac_ptr
+= bytes_read
;
9758 /* We don't recognize any vendor extensions. */
9765 /* Check if the attribute's form is a DW_FORM_block*
9766 if so return true else false. */
9768 attr_form_is_block (struct attribute
*attr
)
9770 return (attr
== NULL
? 0 :
9771 attr
->form
== DW_FORM_block1
9772 || attr
->form
== DW_FORM_block2
9773 || attr
->form
== DW_FORM_block4
9774 || attr
->form
== DW_FORM_block
);
9777 /* Return non-zero if ATTR's value is a section offset --- classes
9778 lineptr, loclistptr, macptr or rangelistptr --- or zero, otherwise.
9779 You may use DW_UNSND (attr) to retrieve such offsets.
9781 Section 7.5.4, "Attribute Encodings", explains that no attribute
9782 may have a value that belongs to more than one of these classes; it
9783 would be ambiguous if we did, because we use the same forms for all
9786 attr_form_is_section_offset (struct attribute
*attr
)
9788 return (attr
->form
== DW_FORM_data4
9789 || attr
->form
== DW_FORM_data8
);
9793 /* Return non-zero if ATTR's value falls in the 'constant' class, or
9794 zero otherwise. When this function returns true, you can apply
9795 dwarf2_get_attr_constant_value to it.
9797 However, note that for some attributes you must check
9798 attr_form_is_section_offset before using this test. DW_FORM_data4
9799 and DW_FORM_data8 are members of both the constant class, and of
9800 the classes that contain offsets into other debug sections
9801 (lineptr, loclistptr, macptr or rangelistptr). The DWARF spec says
9802 that, if an attribute's can be either a constant or one of the
9803 section offset classes, DW_FORM_data4 and DW_FORM_data8 should be
9804 taken as section offsets, not constants. */
9806 attr_form_is_constant (struct attribute
*attr
)
9823 dwarf2_symbol_mark_computed (struct attribute
*attr
, struct symbol
*sym
,
9824 struct dwarf2_cu
*cu
)
9826 if (attr_form_is_section_offset (attr
)
9827 /* ".debug_loc" may not exist at all, or the offset may be outside
9828 the section. If so, fall through to the complaint in the
9830 && DW_UNSND (attr
) < dwarf2_per_objfile
->loc_size
)
9832 struct dwarf2_loclist_baton
*baton
;
9834 baton
= obstack_alloc (&cu
->objfile
->objfile_obstack
,
9835 sizeof (struct dwarf2_loclist_baton
));
9836 baton
->per_cu
= cu
->per_cu
;
9837 gdb_assert (baton
->per_cu
);
9839 /* We don't know how long the location list is, but make sure we
9840 don't run off the edge of the section. */
9841 baton
->size
= dwarf2_per_objfile
->loc_size
- DW_UNSND (attr
);
9842 baton
->data
= dwarf2_per_objfile
->loc_buffer
+ DW_UNSND (attr
);
9843 baton
->base_address
= cu
->header
.base_address
;
9844 if (cu
->header
.base_known
== 0)
9845 complaint (&symfile_complaints
,
9846 _("Location list used without specifying the CU base address."));
9848 SYMBOL_OPS (sym
) = &dwarf2_loclist_funcs
;
9849 SYMBOL_LOCATION_BATON (sym
) = baton
;
9853 struct dwarf2_locexpr_baton
*baton
;
9855 baton
= obstack_alloc (&cu
->objfile
->objfile_obstack
,
9856 sizeof (struct dwarf2_locexpr_baton
));
9857 baton
->per_cu
= cu
->per_cu
;
9858 gdb_assert (baton
->per_cu
);
9860 if (attr_form_is_block (attr
))
9862 /* Note that we're just copying the block's data pointer
9863 here, not the actual data. We're still pointing into the
9864 info_buffer for SYM's objfile; right now we never release
9865 that buffer, but when we do clean up properly this may
9867 baton
->size
= DW_BLOCK (attr
)->size
;
9868 baton
->data
= DW_BLOCK (attr
)->data
;
9872 dwarf2_invalid_attrib_class_complaint ("location description",
9873 SYMBOL_NATURAL_NAME (sym
));
9878 SYMBOL_OPS (sym
) = &dwarf2_locexpr_funcs
;
9879 SYMBOL_LOCATION_BATON (sym
) = baton
;
9883 /* Return the OBJFILE associated with the compilation unit CU. */
9886 dwarf2_per_cu_objfile (struct dwarf2_per_cu_data
*per_cu
)
9888 struct objfile
*objfile
= per_cu
->psymtab
->objfile
;
9890 /* Return the master objfile, so that we can report and look up the
9891 correct file containing this variable. */
9892 if (objfile
->separate_debug_objfile_backlink
)
9893 objfile
= objfile
->separate_debug_objfile_backlink
;
9898 /* Return the address size given in the compilation unit header for CU. */
9901 dwarf2_per_cu_addr_size (struct dwarf2_per_cu_data
*per_cu
)
9904 return per_cu
->cu
->header
.addr_size
;
9907 /* If the CU is not currently read in, we re-read its header. */
9908 struct objfile
*objfile
= per_cu
->psymtab
->objfile
;
9909 struct dwarf2_per_objfile
*per_objfile
9910 = objfile_data (objfile
, dwarf2_objfile_data_key
);
9911 gdb_byte
*info_ptr
= per_objfile
->info_buffer
+ per_cu
->offset
;
9913 struct comp_unit_head cu_header
;
9914 memset (&cu_header
, 0, sizeof cu_header
);
9915 read_comp_unit_head (&cu_header
, info_ptr
, objfile
->obfd
);
9916 return cu_header
.addr_size
;
9920 /* Locate the compilation unit from CU's objfile which contains the
9921 DIE at OFFSET. Raises an error on failure. */
9923 static struct dwarf2_per_cu_data
*
9924 dwarf2_find_containing_comp_unit (unsigned long offset
,
9925 struct objfile
*objfile
)
9927 struct dwarf2_per_cu_data
*this_cu
;
9931 high
= dwarf2_per_objfile
->n_comp_units
- 1;
9934 int mid
= low
+ (high
- low
) / 2;
9935 if (dwarf2_per_objfile
->all_comp_units
[mid
]->offset
>= offset
)
9940 gdb_assert (low
== high
);
9941 if (dwarf2_per_objfile
->all_comp_units
[low
]->offset
> offset
)
9944 error (_("Dwarf Error: could not find partial DIE containing "
9945 "offset 0x%lx [in module %s]"),
9946 (long) offset
, bfd_get_filename (objfile
->obfd
));
9948 gdb_assert (dwarf2_per_objfile
->all_comp_units
[low
-1]->offset
<= offset
);
9949 return dwarf2_per_objfile
->all_comp_units
[low
-1];
9953 this_cu
= dwarf2_per_objfile
->all_comp_units
[low
];
9954 if (low
== dwarf2_per_objfile
->n_comp_units
- 1
9955 && offset
>= this_cu
->offset
+ this_cu
->length
)
9956 error (_("invalid dwarf2 offset %ld"), offset
);
9957 gdb_assert (offset
< this_cu
->offset
+ this_cu
->length
);
9962 /* Locate the compilation unit from OBJFILE which is located at exactly
9963 OFFSET. Raises an error on failure. */
9965 static struct dwarf2_per_cu_data
*
9966 dwarf2_find_comp_unit (unsigned long offset
, struct objfile
*objfile
)
9968 struct dwarf2_per_cu_data
*this_cu
;
9969 this_cu
= dwarf2_find_containing_comp_unit (offset
, objfile
);
9970 if (this_cu
->offset
!= offset
)
9971 error (_("no compilation unit with offset %ld."), offset
);
9975 /* Release one cached compilation unit, CU. We unlink it from the tree
9976 of compilation units, but we don't remove it from the read_in_chain;
9977 the caller is responsible for that. */
9980 free_one_comp_unit (void *data
)
9982 struct dwarf2_cu
*cu
= data
;
9984 if (cu
->per_cu
!= NULL
)
9985 cu
->per_cu
->cu
= NULL
;
9988 obstack_free (&cu
->comp_unit_obstack
, NULL
);
9990 free_die_list (cu
->dies
);
9995 /* This cleanup function is passed the address of a dwarf2_cu on the stack
9996 when we're finished with it. We can't free the pointer itself, but be
9997 sure to unlink it from the cache. Also release any associated storage
9998 and perform cache maintenance.
10000 Only used during partial symbol parsing. */
10003 free_stack_comp_unit (void *data
)
10005 struct dwarf2_cu
*cu
= data
;
10007 obstack_free (&cu
->comp_unit_obstack
, NULL
);
10008 cu
->partial_dies
= NULL
;
10010 if (cu
->per_cu
!= NULL
)
10012 /* This compilation unit is on the stack in our caller, so we
10013 should not xfree it. Just unlink it. */
10014 cu
->per_cu
->cu
= NULL
;
10017 /* If we had a per-cu pointer, then we may have other compilation
10018 units loaded, so age them now. */
10019 age_cached_comp_units ();
10023 /* Free all cached compilation units. */
10026 free_cached_comp_units (void *data
)
10028 struct dwarf2_per_cu_data
*per_cu
, **last_chain
;
10030 per_cu
= dwarf2_per_objfile
->read_in_chain
;
10031 last_chain
= &dwarf2_per_objfile
->read_in_chain
;
10032 while (per_cu
!= NULL
)
10034 struct dwarf2_per_cu_data
*next_cu
;
10036 next_cu
= per_cu
->cu
->read_in_chain
;
10038 free_one_comp_unit (per_cu
->cu
);
10039 *last_chain
= next_cu
;
10045 /* Increase the age counter on each cached compilation unit, and free
10046 any that are too old. */
10049 age_cached_comp_units (void)
10051 struct dwarf2_per_cu_data
*per_cu
, **last_chain
;
10053 dwarf2_clear_marks (dwarf2_per_objfile
->read_in_chain
);
10054 per_cu
= dwarf2_per_objfile
->read_in_chain
;
10055 while (per_cu
!= NULL
)
10057 per_cu
->cu
->last_used
++;
10058 if (per_cu
->cu
->last_used
<= dwarf2_max_cache_age
)
10059 dwarf2_mark (per_cu
->cu
);
10060 per_cu
= per_cu
->cu
->read_in_chain
;
10063 per_cu
= dwarf2_per_objfile
->read_in_chain
;
10064 last_chain
= &dwarf2_per_objfile
->read_in_chain
;
10065 while (per_cu
!= NULL
)
10067 struct dwarf2_per_cu_data
*next_cu
;
10069 next_cu
= per_cu
->cu
->read_in_chain
;
10071 if (!per_cu
->cu
->mark
)
10073 free_one_comp_unit (per_cu
->cu
);
10074 *last_chain
= next_cu
;
10077 last_chain
= &per_cu
->cu
->read_in_chain
;
10083 /* Remove a single compilation unit from the cache. */
10086 free_one_cached_comp_unit (void *target_cu
)
10088 struct dwarf2_per_cu_data
*per_cu
, **last_chain
;
10090 per_cu
= dwarf2_per_objfile
->read_in_chain
;
10091 last_chain
= &dwarf2_per_objfile
->read_in_chain
;
10092 while (per_cu
!= NULL
)
10094 struct dwarf2_per_cu_data
*next_cu
;
10096 next_cu
= per_cu
->cu
->read_in_chain
;
10098 if (per_cu
->cu
== target_cu
)
10100 free_one_comp_unit (per_cu
->cu
);
10101 *last_chain
= next_cu
;
10105 last_chain
= &per_cu
->cu
->read_in_chain
;
10111 /* Release all extra memory associated with OBJFILE. */
10114 dwarf2_free_objfile (struct objfile
*objfile
)
10116 dwarf2_per_objfile
= objfile_data (objfile
, dwarf2_objfile_data_key
);
10118 if (dwarf2_per_objfile
== NULL
)
10121 /* Cached DIE trees use xmalloc and the comp_unit_obstack. */
10122 free_cached_comp_units (NULL
);
10124 /* Everything else should be on the objfile obstack. */
10127 /* A pair of DIE offset and GDB type pointer. We store these
10128 in a hash table separate from the DIEs, and preserve them
10129 when the DIEs are flushed out of cache. */
10131 struct dwarf2_offset_and_type
10133 unsigned int offset
;
10137 /* Hash function for a dwarf2_offset_and_type. */
10140 offset_and_type_hash (const void *item
)
10142 const struct dwarf2_offset_and_type
*ofs
= item
;
10143 return ofs
->offset
;
10146 /* Equality function for a dwarf2_offset_and_type. */
10149 offset_and_type_eq (const void *item_lhs
, const void *item_rhs
)
10151 const struct dwarf2_offset_and_type
*ofs_lhs
= item_lhs
;
10152 const struct dwarf2_offset_and_type
*ofs_rhs
= item_rhs
;
10153 return ofs_lhs
->offset
== ofs_rhs
->offset
;
10156 /* Set the type associated with DIE to TYPE. Save it in CU's hash
10157 table if necessary. */
10160 set_die_type (struct die_info
*die
, struct type
*type
, struct dwarf2_cu
*cu
)
10162 struct dwarf2_offset_and_type
**slot
, ofs
;
10166 if (cu
->per_cu
== NULL
)
10169 if (cu
->per_cu
->type_hash
== NULL
)
10170 cu
->per_cu
->type_hash
10171 = htab_create_alloc_ex (cu
->header
.length
/ 24,
10172 offset_and_type_hash
,
10173 offset_and_type_eq
,
10175 &cu
->objfile
->objfile_obstack
,
10176 hashtab_obstack_allocate
,
10177 dummy_obstack_deallocate
);
10179 ofs
.offset
= die
->offset
;
10181 slot
= (struct dwarf2_offset_and_type
**)
10182 htab_find_slot_with_hash (cu
->per_cu
->type_hash
, &ofs
, ofs
.offset
, INSERT
);
10183 *slot
= obstack_alloc (&cu
->objfile
->objfile_obstack
, sizeof (**slot
));
10187 /* Find the type for DIE in TYPE_HASH, or return NULL if DIE does not
10188 have a saved type. */
10190 static struct type
*
10191 get_die_type (struct die_info
*die
, htab_t type_hash
)
10193 struct dwarf2_offset_and_type
*slot
, ofs
;
10195 ofs
.offset
= die
->offset
;
10196 slot
= htab_find_with_hash (type_hash
, &ofs
, ofs
.offset
);
10203 /* Restore the types of the DIE tree starting at START_DIE from the hash
10204 table saved in CU. */
10207 reset_die_and_siblings_types (struct die_info
*start_die
, struct dwarf2_cu
*cu
)
10209 struct die_info
*die
;
10211 if (cu
->per_cu
->type_hash
== NULL
)
10214 for (die
= start_die
; die
!= NULL
; die
= die
->sibling
)
10216 die
->type
= get_die_type (die
, cu
->per_cu
->type_hash
);
10217 if (die
->child
!= NULL
)
10218 reset_die_and_siblings_types (die
->child
, cu
);
10222 /* Set the mark field in CU and in every other compilation unit in the
10223 cache that we must keep because we are keeping CU. */
10225 /* Add a dependence relationship from CU to REF_PER_CU. */
10228 dwarf2_add_dependence (struct dwarf2_cu
*cu
,
10229 struct dwarf2_per_cu_data
*ref_per_cu
)
10233 if (cu
->dependencies
== NULL
)
10235 = htab_create_alloc_ex (5, htab_hash_pointer
, htab_eq_pointer
,
10236 NULL
, &cu
->comp_unit_obstack
,
10237 hashtab_obstack_allocate
,
10238 dummy_obstack_deallocate
);
10240 slot
= htab_find_slot (cu
->dependencies
, ref_per_cu
, INSERT
);
10242 *slot
= ref_per_cu
;
10245 /* Set the mark field in CU and in every other compilation unit in the
10246 cache that we must keep because we are keeping CU. */
10249 dwarf2_mark_helper (void **slot
, void *data
)
10251 struct dwarf2_per_cu_data
*per_cu
;
10253 per_cu
= (struct dwarf2_per_cu_data
*) *slot
;
10254 if (per_cu
->cu
->mark
)
10256 per_cu
->cu
->mark
= 1;
10258 if (per_cu
->cu
->dependencies
!= NULL
)
10259 htab_traverse (per_cu
->cu
->dependencies
, dwarf2_mark_helper
, NULL
);
10265 dwarf2_mark (struct dwarf2_cu
*cu
)
10270 if (cu
->dependencies
!= NULL
)
10271 htab_traverse (cu
->dependencies
, dwarf2_mark_helper
, NULL
);
10275 dwarf2_clear_marks (struct dwarf2_per_cu_data
*per_cu
)
10279 per_cu
->cu
->mark
= 0;
10280 per_cu
= per_cu
->cu
->read_in_chain
;
10284 /* Trivial hash function for partial_die_info: the hash value of a DIE
10285 is its offset in .debug_info for this objfile. */
10288 partial_die_hash (const void *item
)
10290 const struct partial_die_info
*part_die
= item
;
10291 return part_die
->offset
;
10294 /* Trivial comparison function for partial_die_info structures: two DIEs
10295 are equal if they have the same offset. */
10298 partial_die_eq (const void *item_lhs
, const void *item_rhs
)
10300 const struct partial_die_info
*part_die_lhs
= item_lhs
;
10301 const struct partial_die_info
*part_die_rhs
= item_rhs
;
10302 return part_die_lhs
->offset
== part_die_rhs
->offset
;
10305 static struct cmd_list_element
*set_dwarf2_cmdlist
;
10306 static struct cmd_list_element
*show_dwarf2_cmdlist
;
10309 set_dwarf2_cmd (char *args
, int from_tty
)
10311 help_list (set_dwarf2_cmdlist
, "maintenance set dwarf2 ", -1, gdb_stdout
);
10315 show_dwarf2_cmd (char *args
, int from_tty
)
10317 cmd_show_list (show_dwarf2_cmdlist
, from_tty
, "");
10320 void _initialize_dwarf2_read (void);
10323 _initialize_dwarf2_read (void)
10325 dwarf2_objfile_data_key
= register_objfile_data ();
10327 add_prefix_cmd ("dwarf2", class_maintenance
, set_dwarf2_cmd
, _("\
10328 Set DWARF 2 specific variables.\n\
10329 Configure DWARF 2 variables such as the cache size"),
10330 &set_dwarf2_cmdlist
, "maintenance set dwarf2 ",
10331 0/*allow-unknown*/, &maintenance_set_cmdlist
);
10333 add_prefix_cmd ("dwarf2", class_maintenance
, show_dwarf2_cmd
, _("\
10334 Show DWARF 2 specific variables\n\
10335 Show DWARF 2 variables such as the cache size"),
10336 &show_dwarf2_cmdlist
, "maintenance show dwarf2 ",
10337 0/*allow-unknown*/, &maintenance_show_cmdlist
);
10339 add_setshow_zinteger_cmd ("max-cache-age", class_obscure
,
10340 &dwarf2_max_cache_age
, _("\
10341 Set the upper bound on the age of cached dwarf2 compilation units."), _("\
10342 Show the upper bound on the age of cached dwarf2 compilation units."), _("\
10343 A higher limit means that cached compilation units will be stored\n\
10344 in memory longer, and more total memory will be used. Zero disables\n\
10345 caching, which can slow down startup."),
10347 show_dwarf2_max_cache_age
,
10348 &set_dwarf2_cmdlist
,
10349 &show_dwarf2_cmdlist
);