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 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
)
1903 /*prim_record_minimal_symbol (actual_name, pdi->lowpc + baseaddr,
1904 mst_text, objfile); */
1905 psym
= add_psymbol_to_list (actual_name
, strlen (actual_name
),
1906 VAR_DOMAIN
, LOC_BLOCK
,
1907 &objfile
->global_psymbols
,
1908 0, pdi
->lowpc
+ baseaddr
,
1909 cu
->language
, objfile
);
1913 /*prim_record_minimal_symbol (actual_name, pdi->lowpc + baseaddr,
1914 mst_file_text, objfile); */
1915 psym
= add_psymbol_to_list (actual_name
, strlen (actual_name
),
1916 VAR_DOMAIN
, LOC_BLOCK
,
1917 &objfile
->static_psymbols
,
1918 0, pdi
->lowpc
+ baseaddr
,
1919 cu
->language
, objfile
);
1922 case DW_TAG_variable
:
1923 if (pdi
->is_external
)
1926 Don't enter into the minimal symbol tables as there is
1927 a minimal symbol table entry from the ELF symbols already.
1928 Enter into partial symbol table if it has a location
1929 descriptor or a type.
1930 If the location descriptor is missing, new_symbol will create
1931 a LOC_UNRESOLVED symbol, the address of the variable will then
1932 be determined from the minimal symbol table whenever the variable
1934 The address for the partial symbol table entry is not
1935 used by GDB, but it comes in handy for debugging partial symbol
1939 addr
= decode_locdesc (pdi
->locdesc
, cu
);
1940 if (pdi
->locdesc
|| pdi
->has_type
)
1941 psym
= add_psymbol_to_list (actual_name
, strlen (actual_name
),
1942 VAR_DOMAIN
, LOC_STATIC
,
1943 &objfile
->global_psymbols
,
1945 cu
->language
, objfile
);
1949 /* Static Variable. Skip symbols without location descriptors. */
1950 if (pdi
->locdesc
== NULL
)
1952 if (built_actual_name
)
1953 xfree (actual_name
);
1956 addr
= decode_locdesc (pdi
->locdesc
, cu
);
1957 /*prim_record_minimal_symbol (actual_name, addr + baseaddr,
1958 mst_file_data, objfile); */
1959 psym
= add_psymbol_to_list (actual_name
, strlen (actual_name
),
1960 VAR_DOMAIN
, LOC_STATIC
,
1961 &objfile
->static_psymbols
,
1963 cu
->language
, objfile
);
1966 case DW_TAG_typedef
:
1967 case DW_TAG_base_type
:
1968 case DW_TAG_subrange_type
:
1969 add_psymbol_to_list (actual_name
, strlen (actual_name
),
1970 VAR_DOMAIN
, LOC_TYPEDEF
,
1971 &objfile
->static_psymbols
,
1972 0, (CORE_ADDR
) 0, cu
->language
, objfile
);
1974 case DW_TAG_namespace
:
1975 add_psymbol_to_list (actual_name
, strlen (actual_name
),
1976 VAR_DOMAIN
, LOC_TYPEDEF
,
1977 &objfile
->global_psymbols
,
1978 0, (CORE_ADDR
) 0, cu
->language
, objfile
);
1980 case DW_TAG_class_type
:
1981 case DW_TAG_interface_type
:
1982 case DW_TAG_structure_type
:
1983 case DW_TAG_union_type
:
1984 case DW_TAG_enumeration_type
:
1985 /* Skip external references. The DWARF standard says in the section
1986 about "Structure, Union, and Class Type Entries": "An incomplete
1987 structure, union or class type is represented by a structure,
1988 union or class entry that does not have a byte size attribute
1989 and that has a DW_AT_declaration attribute." */
1990 if (!pdi
->has_byte_size
&& pdi
->is_declaration
)
1992 if (built_actual_name
)
1993 xfree (actual_name
);
1997 /* NOTE: carlton/2003-10-07: See comment in new_symbol about
1998 static vs. global. */
1999 add_psymbol_to_list (actual_name
, strlen (actual_name
),
2000 STRUCT_DOMAIN
, LOC_TYPEDEF
,
2001 (cu
->language
== language_cplus
2002 || cu
->language
== language_java
)
2003 ? &objfile
->global_psymbols
2004 : &objfile
->static_psymbols
,
2005 0, (CORE_ADDR
) 0, cu
->language
, objfile
);
2007 if (cu
->language
== language_cplus
2008 || cu
->language
== language_java
2009 || cu
->language
== language_ada
)
2011 /* For C++ and Java, these implicitly act as typedefs as well. */
2012 add_psymbol_to_list (actual_name
, strlen (actual_name
),
2013 VAR_DOMAIN
, LOC_TYPEDEF
,
2014 &objfile
->global_psymbols
,
2015 0, (CORE_ADDR
) 0, cu
->language
, objfile
);
2018 case DW_TAG_enumerator
:
2019 add_psymbol_to_list (actual_name
, strlen (actual_name
),
2020 VAR_DOMAIN
, LOC_CONST
,
2021 (cu
->language
== language_cplus
2022 || cu
->language
== language_java
)
2023 ? &objfile
->global_psymbols
2024 : &objfile
->static_psymbols
,
2025 0, (CORE_ADDR
) 0, cu
->language
, objfile
);
2031 /* Check to see if we should scan the name for possible namespace
2032 info. Only do this if this is C++, if we don't have namespace
2033 debugging info in the file, if the psym is of an appropriate type
2034 (otherwise we'll have psym == NULL), and if we actually had a
2035 mangled name to begin with. */
2037 /* FIXME drow/2004-02-22: Why don't we do this for classes, i.e. the
2038 cases which do not set PSYM above? */
2040 if (cu
->language
== language_cplus
2041 && cu
->has_namespace_info
== 0
2043 && SYMBOL_CPLUS_DEMANGLED_NAME (psym
) != NULL
)
2044 cp_check_possible_namespace_symbols (SYMBOL_CPLUS_DEMANGLED_NAME (psym
),
2047 if (built_actual_name
)
2048 xfree (actual_name
);
2051 /* Determine whether a die of type TAG living in a C++ class or
2052 namespace needs to have the name of the scope prepended to the
2053 name listed in the die. */
2056 pdi_needs_namespace (enum dwarf_tag tag
)
2060 case DW_TAG_namespace
:
2061 case DW_TAG_typedef
:
2062 case DW_TAG_class_type
:
2063 case DW_TAG_interface_type
:
2064 case DW_TAG_structure_type
:
2065 case DW_TAG_union_type
:
2066 case DW_TAG_enumeration_type
:
2067 case DW_TAG_enumerator
:
2074 /* Read a partial die corresponding to a namespace; also, add a symbol
2075 corresponding to that namespace to the symbol table. NAMESPACE is
2076 the name of the enclosing namespace. */
2079 add_partial_namespace (struct partial_die_info
*pdi
,
2080 CORE_ADDR
*lowpc
, CORE_ADDR
*highpc
,
2081 struct dwarf2_cu
*cu
)
2083 struct objfile
*objfile
= cu
->objfile
;
2085 /* Add a symbol for the namespace. */
2087 add_partial_symbol (pdi
, cu
);
2089 /* Now scan partial symbols in that namespace. */
2091 if (pdi
->has_children
)
2092 scan_partial_symbols (pdi
->die_child
, lowpc
, highpc
, cu
);
2095 /* See if we can figure out if the class lives in a namespace. We do
2096 this by looking for a member function; its demangled name will
2097 contain namespace info, if there is any. */
2100 guess_structure_name (struct partial_die_info
*struct_pdi
,
2101 struct dwarf2_cu
*cu
)
2103 if ((cu
->language
== language_cplus
2104 || cu
->language
== language_java
)
2105 && cu
->has_namespace_info
== 0
2106 && struct_pdi
->has_children
)
2108 /* NOTE: carlton/2003-10-07: Getting the info this way changes
2109 what template types look like, because the demangler
2110 frequently doesn't give the same name as the debug info. We
2111 could fix this by only using the demangled name to get the
2112 prefix (but see comment in read_structure_type). */
2114 struct partial_die_info
*child_pdi
= struct_pdi
->die_child
;
2115 struct partial_die_info
*real_pdi
;
2117 /* If this DIE (this DIE's specification, if any) has a parent, then
2118 we should not do this. We'll prepend the parent's fully qualified
2119 name when we create the partial symbol. */
2121 real_pdi
= struct_pdi
;
2122 while (real_pdi
->has_specification
)
2123 real_pdi
= find_partial_die (real_pdi
->spec_offset
, cu
);
2125 if (real_pdi
->die_parent
!= NULL
)
2128 while (child_pdi
!= NULL
)
2130 if (child_pdi
->tag
== DW_TAG_subprogram
)
2132 char *actual_class_name
2133 = language_class_name_from_physname (cu
->language_defn
,
2135 if (actual_class_name
!= NULL
)
2138 = obsavestring (actual_class_name
,
2139 strlen (actual_class_name
),
2140 &cu
->comp_unit_obstack
);
2141 xfree (actual_class_name
);
2146 child_pdi
= child_pdi
->die_sibling
;
2151 /* Read a partial die corresponding to an enumeration type. */
2154 add_partial_enumeration (struct partial_die_info
*enum_pdi
,
2155 struct dwarf2_cu
*cu
)
2157 struct objfile
*objfile
= cu
->objfile
;
2158 bfd
*abfd
= objfile
->obfd
;
2159 struct partial_die_info
*pdi
;
2161 if (enum_pdi
->name
!= NULL
)
2162 add_partial_symbol (enum_pdi
, cu
);
2164 pdi
= enum_pdi
->die_child
;
2167 if (pdi
->tag
!= DW_TAG_enumerator
|| pdi
->name
== NULL
)
2168 complaint (&symfile_complaints
, _("malformed enumerator DIE ignored"));
2170 add_partial_symbol (pdi
, cu
);
2171 pdi
= pdi
->die_sibling
;
2175 /* Read the initial uleb128 in the die at INFO_PTR in compilation unit CU.
2176 Return the corresponding abbrev, or NULL if the number is zero (indicating
2177 an empty DIE). In either case *BYTES_READ will be set to the length of
2178 the initial number. */
2180 static struct abbrev_info
*
2181 peek_die_abbrev (gdb_byte
*info_ptr
, unsigned int *bytes_read
,
2182 struct dwarf2_cu
*cu
)
2184 bfd
*abfd
= cu
->objfile
->obfd
;
2185 unsigned int abbrev_number
;
2186 struct abbrev_info
*abbrev
;
2188 abbrev_number
= read_unsigned_leb128 (abfd
, info_ptr
, bytes_read
);
2190 if (abbrev_number
== 0)
2193 abbrev
= dwarf2_lookup_abbrev (abbrev_number
, cu
);
2196 error (_("Dwarf Error: Could not find abbrev number %d [in module %s]"), abbrev_number
,
2197 bfd_get_filename (abfd
));
2203 /* Scan the debug information for CU starting at INFO_PTR. Returns a
2204 pointer to the end of a series of DIEs, terminated by an empty
2205 DIE. Any children of the skipped DIEs will also be skipped. */
2208 skip_children (gdb_byte
*info_ptr
, struct dwarf2_cu
*cu
)
2210 struct abbrev_info
*abbrev
;
2211 unsigned int bytes_read
;
2215 abbrev
= peek_die_abbrev (info_ptr
, &bytes_read
, cu
);
2217 return info_ptr
+ bytes_read
;
2219 info_ptr
= skip_one_die (info_ptr
+ bytes_read
, abbrev
, cu
);
2223 /* Scan the debug information for CU starting at INFO_PTR. INFO_PTR
2224 should point just after the initial uleb128 of a DIE, and the
2225 abbrev corresponding to that skipped uleb128 should be passed in
2226 ABBREV. Returns a pointer to this DIE's sibling, skipping any
2230 skip_one_die (gdb_byte
*info_ptr
, struct abbrev_info
*abbrev
,
2231 struct dwarf2_cu
*cu
)
2233 unsigned int bytes_read
;
2234 struct attribute attr
;
2235 bfd
*abfd
= cu
->objfile
->obfd
;
2236 unsigned int form
, i
;
2238 for (i
= 0; i
< abbrev
->num_attrs
; i
++)
2240 /* The only abbrev we care about is DW_AT_sibling. */
2241 if (abbrev
->attrs
[i
].name
== DW_AT_sibling
)
2243 read_attribute (&attr
, &abbrev
->attrs
[i
],
2244 abfd
, info_ptr
, cu
);
2245 if (attr
.form
== DW_FORM_ref_addr
)
2246 complaint (&symfile_complaints
, _("ignoring absolute DW_AT_sibling"));
2248 return dwarf2_per_objfile
->info_buffer
2249 + dwarf2_get_ref_die_offset (&attr
, cu
);
2252 /* If it isn't DW_AT_sibling, skip this attribute. */
2253 form
= abbrev
->attrs
[i
].form
;
2258 case DW_FORM_ref_addr
:
2259 info_ptr
+= cu
->header
.addr_size
;
2278 case DW_FORM_string
:
2279 read_string (abfd
, info_ptr
, &bytes_read
);
2280 info_ptr
+= bytes_read
;
2283 info_ptr
+= cu
->header
.offset_size
;
2286 info_ptr
+= read_unsigned_leb128 (abfd
, info_ptr
, &bytes_read
);
2287 info_ptr
+= bytes_read
;
2289 case DW_FORM_block1
:
2290 info_ptr
+= 1 + read_1_byte (abfd
, info_ptr
);
2292 case DW_FORM_block2
:
2293 info_ptr
+= 2 + read_2_bytes (abfd
, info_ptr
);
2295 case DW_FORM_block4
:
2296 info_ptr
+= 4 + read_4_bytes (abfd
, info_ptr
);
2300 case DW_FORM_ref_udata
:
2301 info_ptr
= skip_leb128 (abfd
, info_ptr
);
2303 case DW_FORM_indirect
:
2304 form
= read_unsigned_leb128 (abfd
, info_ptr
, &bytes_read
);
2305 info_ptr
+= bytes_read
;
2306 /* We need to continue parsing from here, so just go back to
2308 goto skip_attribute
;
2311 error (_("Dwarf Error: Cannot handle %s in DWARF reader [in module %s]"),
2312 dwarf_form_name (form
),
2313 bfd_get_filename (abfd
));
2317 if (abbrev
->has_children
)
2318 return skip_children (info_ptr
, cu
);
2323 /* Locate ORIG_PDI's sibling; INFO_PTR should point to the start of
2324 the next DIE after ORIG_PDI. */
2327 locate_pdi_sibling (struct partial_die_info
*orig_pdi
, gdb_byte
*info_ptr
,
2328 bfd
*abfd
, struct dwarf2_cu
*cu
)
2330 /* Do we know the sibling already? */
2332 if (orig_pdi
->sibling
)
2333 return orig_pdi
->sibling
;
2335 /* Are there any children to deal with? */
2337 if (!orig_pdi
->has_children
)
2340 /* Skip the children the long way. */
2342 return skip_children (info_ptr
, cu
);
2345 /* Expand this partial symbol table into a full symbol table. */
2348 dwarf2_psymtab_to_symtab (struct partial_symtab
*pst
)
2350 /* FIXME: This is barely more than a stub. */
2355 warning (_("bug: psymtab for %s is already read in."), pst
->filename
);
2361 printf_filtered (_("Reading in symbols for %s..."), pst
->filename
);
2362 gdb_flush (gdb_stdout
);
2365 /* Restore our global data. */
2366 dwarf2_per_objfile
= objfile_data (pst
->objfile
,
2367 dwarf2_objfile_data_key
);
2369 psymtab_to_symtab_1 (pst
);
2371 /* Finish up the debug error message. */
2373 printf_filtered (_("done.\n"));
2378 /* Add PER_CU to the queue. */
2381 queue_comp_unit (struct dwarf2_per_cu_data
*per_cu
)
2383 struct dwarf2_queue_item
*item
;
2386 item
= xmalloc (sizeof (*item
));
2387 item
->per_cu
= per_cu
;
2390 if (dwarf2_queue
== NULL
)
2391 dwarf2_queue
= item
;
2393 dwarf2_queue_tail
->next
= item
;
2395 dwarf2_queue_tail
= item
;
2398 /* Process the queue. */
2401 process_queue (struct objfile
*objfile
)
2403 struct dwarf2_queue_item
*item
, *next_item
;
2405 /* Initially, there is just one item on the queue. Load its DIEs,
2406 and the DIEs of any other compilation units it requires,
2409 for (item
= dwarf2_queue
; item
!= NULL
; item
= item
->next
)
2411 /* Read in this compilation unit. This may add new items to
2412 the end of the queue. */
2413 load_full_comp_unit (item
->per_cu
, objfile
);
2415 item
->per_cu
->cu
->read_in_chain
= dwarf2_per_objfile
->read_in_chain
;
2416 dwarf2_per_objfile
->read_in_chain
= item
->per_cu
;
2418 /* If this compilation unit has already had full symbols created,
2419 reset the TYPE fields in each DIE. */
2420 if (item
->per_cu
->type_hash
)
2421 reset_die_and_siblings_types (item
->per_cu
->cu
->dies
,
2425 /* Now everything left on the queue needs to be read in. Process
2426 them, one at a time, removing from the queue as we finish. */
2427 for (item
= dwarf2_queue
; item
!= NULL
; dwarf2_queue
= item
= next_item
)
2429 if (item
->per_cu
->psymtab
&& !item
->per_cu
->psymtab
->readin
)
2430 process_full_comp_unit (item
->per_cu
);
2432 item
->per_cu
->queued
= 0;
2433 next_item
= item
->next
;
2437 dwarf2_queue_tail
= NULL
;
2440 /* Free all allocated queue entries. This function only releases anything if
2441 an error was thrown; if the queue was processed then it would have been
2442 freed as we went along. */
2445 dwarf2_release_queue (void *dummy
)
2447 struct dwarf2_queue_item
*item
, *last
;
2449 item
= dwarf2_queue
;
2452 /* Anything still marked queued is likely to be in an
2453 inconsistent state, so discard it. */
2454 if (item
->per_cu
->queued
)
2456 if (item
->per_cu
->cu
!= NULL
)
2457 free_one_cached_comp_unit (item
->per_cu
->cu
);
2458 item
->per_cu
->queued
= 0;
2466 dwarf2_queue
= dwarf2_queue_tail
= NULL
;
2469 /* Read in full symbols for PST, and anything it depends on. */
2472 psymtab_to_symtab_1 (struct partial_symtab
*pst
)
2474 struct dwarf2_per_cu_data
*per_cu
;
2475 struct cleanup
*back_to
;
2478 for (i
= 0; i
< pst
->number_of_dependencies
; i
++)
2479 if (!pst
->dependencies
[i
]->readin
)
2481 /* Inform about additional files that need to be read in. */
2484 /* FIXME: i18n: Need to make this a single string. */
2485 fputs_filtered (" ", gdb_stdout
);
2487 fputs_filtered ("and ", gdb_stdout
);
2489 printf_filtered ("%s...", pst
->dependencies
[i
]->filename
);
2490 wrap_here (""); /* Flush output */
2491 gdb_flush (gdb_stdout
);
2493 psymtab_to_symtab_1 (pst
->dependencies
[i
]);
2496 per_cu
= (struct dwarf2_per_cu_data
*) pst
->read_symtab_private
;
2500 /* It's an include file, no symbols to read for it.
2501 Everything is in the parent symtab. */
2506 back_to
= make_cleanup (dwarf2_release_queue
, NULL
);
2508 queue_comp_unit (per_cu
);
2510 process_queue (pst
->objfile
);
2512 /* Age the cache, releasing compilation units that have not
2513 been used recently. */
2514 age_cached_comp_units ();
2516 do_cleanups (back_to
);
2519 /* Load the DIEs associated with PST and PER_CU into memory. */
2521 static struct dwarf2_cu
*
2522 load_full_comp_unit (struct dwarf2_per_cu_data
*per_cu
, struct objfile
*objfile
)
2524 bfd
*abfd
= objfile
->obfd
;
2525 struct dwarf2_cu
*cu
;
2526 unsigned long offset
;
2528 struct cleanup
*back_to
, *free_cu_cleanup
;
2529 struct attribute
*attr
;
2532 /* Set local variables from the partial symbol table info. */
2533 offset
= per_cu
->offset
;
2535 info_ptr
= dwarf2_per_objfile
->info_buffer
+ offset
;
2537 cu
= xmalloc (sizeof (struct dwarf2_cu
));
2538 memset (cu
, 0, sizeof (struct dwarf2_cu
));
2540 /* If an error occurs while loading, release our storage. */
2541 free_cu_cleanup
= make_cleanup (free_one_comp_unit
, cu
);
2543 cu
->objfile
= objfile
;
2545 /* read in the comp_unit header */
2546 info_ptr
= read_comp_unit_head (&cu
->header
, info_ptr
, abfd
);
2548 /* Read the abbrevs for this compilation unit */
2549 dwarf2_read_abbrevs (abfd
, cu
);
2550 back_to
= make_cleanup (dwarf2_free_abbrev_table
, cu
);
2552 cu
->header
.offset
= offset
;
2554 cu
->per_cu
= per_cu
;
2557 /* We use this obstack for block values in dwarf_alloc_block. */
2558 obstack_init (&cu
->comp_unit_obstack
);
2560 cu
->dies
= read_comp_unit (info_ptr
, abfd
, cu
);
2562 /* We try not to read any attributes in this function, because not
2563 all objfiles needed for references have been loaded yet, and symbol
2564 table processing isn't initialized. But we have to set the CU language,
2565 or we won't be able to build types correctly. */
2566 attr
= dwarf2_attr (cu
->dies
, DW_AT_language
, cu
);
2568 set_cu_language (DW_UNSND (attr
), cu
);
2570 set_cu_language (language_minimal
, cu
);
2572 do_cleanups (back_to
);
2574 /* We've successfully allocated this compilation unit. Let our caller
2575 clean it up when finished with it. */
2576 discard_cleanups (free_cu_cleanup
);
2581 /* Generate full symbol information for PST and CU, whose DIEs have
2582 already been loaded into memory. */
2585 process_full_comp_unit (struct dwarf2_per_cu_data
*per_cu
)
2587 struct partial_symtab
*pst
= per_cu
->psymtab
;
2588 struct dwarf2_cu
*cu
= per_cu
->cu
;
2589 struct objfile
*objfile
= pst
->objfile
;
2590 bfd
*abfd
= objfile
->obfd
;
2591 CORE_ADDR lowpc
, highpc
;
2592 struct symtab
*symtab
;
2593 struct cleanup
*back_to
;
2594 struct attribute
*attr
;
2597 baseaddr
= ANOFFSET (objfile
->section_offsets
, SECT_OFF_TEXT (objfile
));
2599 /* We're in the global namespace. */
2600 processing_current_prefix
= "";
2603 back_to
= make_cleanup (really_free_pendings
, NULL
);
2605 cu
->list_in_scope
= &file_symbols
;
2607 /* Find the base address of the compilation unit for range lists and
2608 location lists. It will normally be specified by DW_AT_low_pc.
2609 In DWARF-3 draft 4, the base address could be overridden by
2610 DW_AT_entry_pc. It's been removed, but GCC still uses this for
2611 compilation units with discontinuous ranges. */
2613 cu
->header
.base_known
= 0;
2614 cu
->header
.base_address
= 0;
2616 attr
= dwarf2_attr (cu
->dies
, DW_AT_entry_pc
, cu
);
2619 cu
->header
.base_address
= DW_ADDR (attr
);
2620 cu
->header
.base_known
= 1;
2624 attr
= dwarf2_attr (cu
->dies
, DW_AT_low_pc
, cu
);
2627 cu
->header
.base_address
= DW_ADDR (attr
);
2628 cu
->header
.base_known
= 1;
2632 /* Do line number decoding in read_file_scope () */
2633 process_die (cu
->dies
, cu
);
2635 /* Some compilers don't define a DW_AT_high_pc attribute for the
2636 compilation unit. If the DW_AT_high_pc is missing, synthesize
2637 it, by scanning the DIE's below the compilation unit. */
2638 get_scope_pc_bounds (cu
->dies
, &lowpc
, &highpc
, cu
);
2640 symtab
= end_symtab (highpc
+ baseaddr
, objfile
, SECT_OFF_TEXT (objfile
));
2642 /* Set symtab language to language from DW_AT_language.
2643 If the compilation is from a C file generated by language preprocessors,
2644 do not set the language if it was already deduced by start_subfile. */
2646 && !(cu
->language
== language_c
&& symtab
->language
!= language_c
))
2648 symtab
->language
= cu
->language
;
2650 pst
->symtab
= symtab
;
2653 do_cleanups (back_to
);
2656 /* Process a die and its children. */
2659 process_die (struct die_info
*die
, struct dwarf2_cu
*cu
)
2663 case DW_TAG_padding
:
2665 case DW_TAG_compile_unit
:
2666 read_file_scope (die
, cu
);
2668 case DW_TAG_subprogram
:
2669 read_subroutine_type (die
, cu
);
2670 read_func_scope (die
, cu
);
2672 case DW_TAG_inlined_subroutine
:
2673 /* FIXME: These are ignored for now.
2674 They could be used to set breakpoints on all inlined instances
2675 of a function and make GDB `next' properly over inlined functions. */
2677 case DW_TAG_lexical_block
:
2678 case DW_TAG_try_block
:
2679 case DW_TAG_catch_block
:
2680 read_lexical_block_scope (die
, cu
);
2682 case DW_TAG_class_type
:
2683 case DW_TAG_interface_type
:
2684 case DW_TAG_structure_type
:
2685 case DW_TAG_union_type
:
2686 read_structure_type (die
, cu
);
2687 process_structure_scope (die
, cu
);
2689 case DW_TAG_enumeration_type
:
2690 read_enumeration_type (die
, cu
);
2691 process_enumeration_scope (die
, cu
);
2694 /* FIXME drow/2004-03-14: These initialize die->type, but do not create
2695 a symbol or process any children. Therefore it doesn't do anything
2696 that won't be done on-demand by read_type_die. */
2697 case DW_TAG_subroutine_type
:
2698 read_subroutine_type (die
, cu
);
2700 case DW_TAG_set_type
:
2701 read_set_type (die
, cu
);
2703 case DW_TAG_array_type
:
2704 read_array_type (die
, cu
);
2706 case DW_TAG_pointer_type
:
2707 read_tag_pointer_type (die
, cu
);
2709 case DW_TAG_ptr_to_member_type
:
2710 read_tag_ptr_to_member_type (die
, cu
);
2712 case DW_TAG_reference_type
:
2713 read_tag_reference_type (die
, cu
);
2715 case DW_TAG_string_type
:
2716 read_tag_string_type (die
, cu
);
2720 case DW_TAG_base_type
:
2721 read_base_type (die
, cu
);
2722 /* Add a typedef symbol for the type definition, if it has a
2724 new_symbol (die
, die
->type
, cu
);
2726 case DW_TAG_subrange_type
:
2727 read_subrange_type (die
, cu
);
2728 /* Add a typedef symbol for the type definition, if it has a
2730 new_symbol (die
, die
->type
, cu
);
2732 case DW_TAG_common_block
:
2733 read_common_block (die
, cu
);
2735 case DW_TAG_common_inclusion
:
2737 case DW_TAG_namespace
:
2738 processing_has_namespace_info
= 1;
2739 read_namespace (die
, cu
);
2741 case DW_TAG_imported_declaration
:
2742 case DW_TAG_imported_module
:
2743 /* FIXME: carlton/2002-10-16: Eventually, we should use the
2744 information contained in these. DW_TAG_imported_declaration
2745 dies shouldn't have children; DW_TAG_imported_module dies
2746 shouldn't in the C++ case, but conceivably could in the
2747 Fortran case, so we'll have to replace this gdb_assert if
2748 Fortran compilers start generating that info. */
2749 processing_has_namespace_info
= 1;
2750 gdb_assert (die
->child
== NULL
);
2753 new_symbol (die
, NULL
, cu
);
2759 initialize_cu_func_list (struct dwarf2_cu
*cu
)
2761 cu
->first_fn
= cu
->last_fn
= cu
->cached_fn
= NULL
;
2765 free_cu_line_header (void *arg
)
2767 struct dwarf2_cu
*cu
= arg
;
2769 free_line_header (cu
->line_header
);
2770 cu
->line_header
= NULL
;
2774 read_file_scope (struct die_info
*die
, struct dwarf2_cu
*cu
)
2776 struct objfile
*objfile
= cu
->objfile
;
2777 struct comp_unit_head
*cu_header
= &cu
->header
;
2778 struct cleanup
*back_to
= make_cleanup (null_cleanup
, 0);
2779 CORE_ADDR lowpc
= ((CORE_ADDR
) -1);
2780 CORE_ADDR highpc
= ((CORE_ADDR
) 0);
2781 struct attribute
*attr
;
2783 char *comp_dir
= NULL
;
2784 struct die_info
*child_die
;
2785 bfd
*abfd
= objfile
->obfd
;
2786 struct line_header
*line_header
= 0;
2789 baseaddr
= ANOFFSET (objfile
->section_offsets
, SECT_OFF_TEXT (objfile
));
2791 get_scope_pc_bounds (die
, &lowpc
, &highpc
, cu
);
2793 /* If we didn't find a lowpc, set it to highpc to avoid complaints
2794 from finish_block. */
2795 if (lowpc
== ((CORE_ADDR
) -1))
2800 /* Find the filename. Do not use dwarf2_name here, since the filename
2801 is not a source language identifier. */
2802 attr
= dwarf2_attr (die
, DW_AT_name
, cu
);
2805 name
= DW_STRING (attr
);
2808 attr
= dwarf2_attr (die
, DW_AT_comp_dir
, cu
);
2810 comp_dir
= DW_STRING (attr
);
2811 else if (name
!= NULL
&& IS_ABSOLUTE_PATH (name
))
2813 comp_dir
= ldirname (name
);
2814 if (comp_dir
!= NULL
)
2815 make_cleanup (xfree
, comp_dir
);
2817 if (comp_dir
!= NULL
)
2819 /* Irix 6.2 native cc prepends <machine>.: to the compilation
2820 directory, get rid of it. */
2821 char *cp
= strchr (comp_dir
, ':');
2823 if (cp
&& cp
!= comp_dir
&& cp
[-1] == '.' && cp
[1] == '/')
2830 attr
= dwarf2_attr (die
, DW_AT_language
, cu
);
2833 set_cu_language (DW_UNSND (attr
), cu
);
2836 attr
= dwarf2_attr (die
, DW_AT_producer
, cu
);
2838 cu
->producer
= DW_STRING (attr
);
2840 /* We assume that we're processing GCC output. */
2841 processing_gcc_compilation
= 2;
2843 start_symtab (name
, comp_dir
, lowpc
);
2844 record_debugformat ("DWARF 2");
2845 record_producer (cu
->producer
);
2847 initialize_cu_func_list (cu
);
2849 /* Decode line number information if present. We do this before
2850 processing child DIEs, so that the line header table is available
2851 for DW_AT_decl_file. */
2852 attr
= dwarf2_attr (die
, DW_AT_stmt_list
, cu
);
2855 unsigned int line_offset
= DW_UNSND (attr
);
2856 line_header
= dwarf_decode_line_header (line_offset
, abfd
, cu
);
2859 cu
->line_header
= line_header
;
2860 make_cleanup (free_cu_line_header
, cu
);
2861 dwarf_decode_lines (line_header
, comp_dir
, abfd
, cu
, NULL
);
2865 /* Process all dies in compilation unit. */
2866 if (die
->child
!= NULL
)
2868 child_die
= die
->child
;
2869 while (child_die
&& child_die
->tag
)
2871 process_die (child_die
, cu
);
2872 child_die
= sibling_die (child_die
);
2876 /* Decode macro information, if present. Dwarf 2 macro information
2877 refers to information in the line number info statement program
2878 header, so we can only read it if we've read the header
2880 attr
= dwarf2_attr (die
, DW_AT_macro_info
, cu
);
2881 if (attr
&& line_header
)
2883 unsigned int macro_offset
= DW_UNSND (attr
);
2884 dwarf_decode_macros (line_header
, macro_offset
,
2885 comp_dir
, abfd
, cu
);
2887 do_cleanups (back_to
);
2891 add_to_cu_func_list (const char *name
, CORE_ADDR lowpc
, CORE_ADDR highpc
,
2892 struct dwarf2_cu
*cu
)
2894 struct function_range
*thisfn
;
2896 thisfn
= (struct function_range
*)
2897 obstack_alloc (&cu
->comp_unit_obstack
, sizeof (struct function_range
));
2898 thisfn
->name
= name
;
2899 thisfn
->lowpc
= lowpc
;
2900 thisfn
->highpc
= highpc
;
2901 thisfn
->seen_line
= 0;
2902 thisfn
->next
= NULL
;
2904 if (cu
->last_fn
== NULL
)
2905 cu
->first_fn
= thisfn
;
2907 cu
->last_fn
->next
= thisfn
;
2909 cu
->last_fn
= thisfn
;
2913 read_func_scope (struct die_info
*die
, struct dwarf2_cu
*cu
)
2915 struct objfile
*objfile
= cu
->objfile
;
2916 struct context_stack
*new;
2919 struct die_info
*child_die
;
2920 struct attribute
*attr
;
2922 const char *previous_prefix
= processing_current_prefix
;
2923 struct cleanup
*back_to
= NULL
;
2925 struct block
*block
;
2927 baseaddr
= ANOFFSET (objfile
->section_offsets
, SECT_OFF_TEXT (objfile
));
2929 name
= dwarf2_linkage_name (die
, cu
);
2931 /* Ignore functions with missing or empty names and functions with
2932 missing or invalid low and high pc attributes. */
2933 if (name
== NULL
|| !dwarf2_get_pc_bounds (die
, &lowpc
, &highpc
, cu
))
2936 if (cu
->language
== language_cplus
2937 || cu
->language
== language_java
)
2939 struct die_info
*spec_die
= die_specification (die
, cu
);
2941 /* NOTE: carlton/2004-01-23: We have to be careful in the
2942 presence of DW_AT_specification. For example, with GCC 3.4,
2947 // Definition of N::foo.
2951 then we'll have a tree of DIEs like this:
2953 1: DW_TAG_compile_unit
2954 2: DW_TAG_namespace // N
2955 3: DW_TAG_subprogram // declaration of N::foo
2956 4: DW_TAG_subprogram // definition of N::foo
2957 DW_AT_specification // refers to die #3
2959 Thus, when processing die #4, we have to pretend that we're
2960 in the context of its DW_AT_specification, namely the contex
2963 if (spec_die
!= NULL
)
2965 char *specification_prefix
= determine_prefix (spec_die
, cu
);
2966 processing_current_prefix
= specification_prefix
;
2967 back_to
= make_cleanup (xfree
, specification_prefix
);
2974 /* Record the function range for dwarf_decode_lines. */
2975 add_to_cu_func_list (name
, lowpc
, highpc
, cu
);
2977 new = push_context (0, lowpc
);
2978 new->name
= new_symbol (die
, die
->type
, cu
);
2980 /* If there is a location expression for DW_AT_frame_base, record
2982 attr
= dwarf2_attr (die
, DW_AT_frame_base
, cu
);
2984 /* FIXME: cagney/2004-01-26: The DW_AT_frame_base's location
2985 expression is being recorded directly in the function's symbol
2986 and not in a separate frame-base object. I guess this hack is
2987 to avoid adding some sort of frame-base adjunct/annex to the
2988 function's symbol :-(. The problem with doing this is that it
2989 results in a function symbol with a location expression that
2990 has nothing to do with the location of the function, ouch! The
2991 relationship should be: a function's symbol has-a frame base; a
2992 frame-base has-a location expression. */
2993 dwarf2_symbol_mark_computed (attr
, new->name
, cu
);
2995 cu
->list_in_scope
= &local_symbols
;
2997 if (die
->child
!= NULL
)
2999 child_die
= die
->child
;
3000 while (child_die
&& child_die
->tag
)
3002 process_die (child_die
, cu
);
3003 child_die
= sibling_die (child_die
);
3007 new = pop_context ();
3008 /* Make a block for the local symbols within. */
3009 block
= finish_block (new->name
, &local_symbols
, new->old_blocks
,
3010 lowpc
, highpc
, objfile
);
3012 /* If we have address ranges, record them. */
3013 dwarf2_record_block_ranges (die
, block
, baseaddr
, cu
);
3015 /* In C++, we can have functions nested inside functions (e.g., when
3016 a function declares a class that has methods). This means that
3017 when we finish processing a function scope, we may need to go
3018 back to building a containing block's symbol lists. */
3019 local_symbols
= new->locals
;
3020 param_symbols
= new->params
;
3022 /* If we've finished processing a top-level function, subsequent
3023 symbols go in the file symbol list. */
3024 if (outermost_context_p ())
3025 cu
->list_in_scope
= &file_symbols
;
3027 processing_current_prefix
= previous_prefix
;
3028 if (back_to
!= NULL
)
3029 do_cleanups (back_to
);
3032 /* Process all the DIES contained within a lexical block scope. Start
3033 a new scope, process the dies, and then close the scope. */
3036 read_lexical_block_scope (struct die_info
*die
, struct dwarf2_cu
*cu
)
3038 struct objfile
*objfile
= cu
->objfile
;
3039 struct context_stack
*new;
3040 CORE_ADDR lowpc
, highpc
;
3041 struct die_info
*child_die
;
3044 baseaddr
= ANOFFSET (objfile
->section_offsets
, SECT_OFF_TEXT (objfile
));
3046 /* Ignore blocks with missing or invalid low and high pc attributes. */
3047 /* ??? Perhaps consider discontiguous blocks defined by DW_AT_ranges
3048 as multiple lexical blocks? Handling children in a sane way would
3049 be nasty. Might be easier to properly extend generic blocks to
3051 if (!dwarf2_get_pc_bounds (die
, &lowpc
, &highpc
, cu
))
3056 push_context (0, lowpc
);
3057 if (die
->child
!= NULL
)
3059 child_die
= die
->child
;
3060 while (child_die
&& child_die
->tag
)
3062 process_die (child_die
, cu
);
3063 child_die
= sibling_die (child_die
);
3066 new = pop_context ();
3068 if (local_symbols
!= NULL
)
3071 = finish_block (0, &local_symbols
, new->old_blocks
, new->start_addr
,
3074 /* Note that recording ranges after traversing children, as we
3075 do here, means that recording a parent's ranges entails
3076 walking across all its children's ranges as they appear in
3077 the address map, which is quadratic behavior.
3079 It would be nicer to record the parent's ranges before
3080 traversing its children, simply overriding whatever you find
3081 there. But since we don't even decide whether to create a
3082 block until after we've traversed its children, that's hard
3084 dwarf2_record_block_ranges (die
, block
, baseaddr
, cu
);
3086 local_symbols
= new->locals
;
3089 /* Get low and high pc attributes from DW_AT_ranges attribute value OFFSET.
3090 Return 1 if the attributes are present and valid, otherwise, return 0. */
3093 dwarf2_ranges_read (unsigned offset
, CORE_ADDR
*low_return
,
3094 CORE_ADDR
*high_return
, struct dwarf2_cu
*cu
)
3096 struct objfile
*objfile
= cu
->objfile
;
3097 struct comp_unit_head
*cu_header
= &cu
->header
;
3098 bfd
*obfd
= objfile
->obfd
;
3099 unsigned int addr_size
= cu_header
->addr_size
;
3100 CORE_ADDR mask
= ~(~(CORE_ADDR
)1 << (addr_size
* 8 - 1));
3101 /* Base address selection entry. */
3111 found_base
= cu_header
->base_known
;
3112 base
= cu_header
->base_address
;
3114 if (offset
>= dwarf2_per_objfile
->ranges_size
)
3116 complaint (&symfile_complaints
,
3117 _("Offset %d out of bounds for DW_AT_ranges attribute"),
3121 buffer
= dwarf2_per_objfile
->ranges_buffer
+ offset
;
3123 /* Read in the largest possible address. */
3124 marker
= read_address (obfd
, buffer
, cu
, &dummy
);
3125 if ((marker
& mask
) == mask
)
3127 /* If we found the largest possible address, then
3128 read the base address. */
3129 base
= read_address (obfd
, buffer
+ addr_size
, cu
, &dummy
);
3130 buffer
+= 2 * addr_size
;
3131 offset
+= 2 * addr_size
;
3139 CORE_ADDR range_beginning
, range_end
;
3141 range_beginning
= read_address (obfd
, buffer
, cu
, &dummy
);
3142 buffer
+= addr_size
;
3143 range_end
= read_address (obfd
, buffer
, cu
, &dummy
);
3144 buffer
+= addr_size
;
3145 offset
+= 2 * addr_size
;
3147 /* An end of list marker is a pair of zero addresses. */
3148 if (range_beginning
== 0 && range_end
== 0)
3149 /* Found the end of list entry. */
3152 /* Each base address selection entry is a pair of 2 values.
3153 The first is the largest possible address, the second is
3154 the base address. Check for a base address here. */
3155 if ((range_beginning
& mask
) == mask
)
3157 /* If we found the largest possible address, then
3158 read the base address. */
3159 base
= read_address (obfd
, buffer
+ addr_size
, cu
, &dummy
);
3166 /* We have no valid base address for the ranges
3168 complaint (&symfile_complaints
,
3169 _("Invalid .debug_ranges data (no base address)"));
3173 range_beginning
+= base
;
3176 /* FIXME: This is recording everything as a low-high
3177 segment of consecutive addresses. We should have a
3178 data structure for discontiguous block ranges
3182 low
= range_beginning
;
3188 if (range_beginning
< low
)
3189 low
= range_beginning
;
3190 if (range_end
> high
)
3196 /* If the first entry is an end-of-list marker, the range
3197 describes an empty scope, i.e. no instructions. */
3203 *high_return
= high
;
3207 /* Get low and high pc attributes from a die. Return 1 if the attributes
3208 are present and valid, otherwise, return 0. Return -1 if the range is
3209 discontinuous, i.e. derived from DW_AT_ranges information. */
3211 dwarf2_get_pc_bounds (struct die_info
*die
, CORE_ADDR
*lowpc
,
3212 CORE_ADDR
*highpc
, struct dwarf2_cu
*cu
)
3214 struct attribute
*attr
;
3219 attr
= dwarf2_attr (die
, DW_AT_high_pc
, cu
);
3222 high
= DW_ADDR (attr
);
3223 attr
= dwarf2_attr (die
, DW_AT_low_pc
, cu
);
3225 low
= DW_ADDR (attr
);
3227 /* Found high w/o low attribute. */
3230 /* Found consecutive range of addresses. */
3235 attr
= dwarf2_attr (die
, DW_AT_ranges
, cu
);
3238 /* Value of the DW_AT_ranges attribute is the offset in the
3239 .debug_ranges section. */
3240 if (!dwarf2_ranges_read (DW_UNSND (attr
), &low
, &high
, cu
))
3242 /* Found discontinuous range of addresses. */
3250 /* When using the GNU linker, .gnu.linkonce. sections are used to
3251 eliminate duplicate copies of functions and vtables and such.
3252 The linker will arbitrarily choose one and discard the others.
3253 The AT_*_pc values for such functions refer to local labels in
3254 these sections. If the section from that file was discarded, the
3255 labels are not in the output, so the relocs get a value of 0.
3256 If this is a discarded function, mark the pc bounds as invalid,
3257 so that GDB will ignore it. */
3258 if (low
== 0 && !dwarf2_per_objfile
->has_section_at_zero
)
3266 /* Get the low and high pc's represented by the scope DIE, and store
3267 them in *LOWPC and *HIGHPC. If the correct values can't be
3268 determined, set *LOWPC to -1 and *HIGHPC to 0. */
3271 get_scope_pc_bounds (struct die_info
*die
,
3272 CORE_ADDR
*lowpc
, CORE_ADDR
*highpc
,
3273 struct dwarf2_cu
*cu
)
3275 CORE_ADDR best_low
= (CORE_ADDR
) -1;
3276 CORE_ADDR best_high
= (CORE_ADDR
) 0;
3277 CORE_ADDR current_low
, current_high
;
3279 if (dwarf2_get_pc_bounds (die
, ¤t_low
, ¤t_high
, cu
))
3281 best_low
= current_low
;
3282 best_high
= current_high
;
3286 struct die_info
*child
= die
->child
;
3288 while (child
&& child
->tag
)
3290 switch (child
->tag
) {
3291 case DW_TAG_subprogram
:
3292 if (dwarf2_get_pc_bounds (child
, ¤t_low
, ¤t_high
, cu
))
3294 best_low
= min (best_low
, current_low
);
3295 best_high
= max (best_high
, current_high
);
3298 case DW_TAG_namespace
:
3299 /* FIXME: carlton/2004-01-16: Should we do this for
3300 DW_TAG_class_type/DW_TAG_structure_type, too? I think
3301 that current GCC's always emit the DIEs corresponding
3302 to definitions of methods of classes as children of a
3303 DW_TAG_compile_unit or DW_TAG_namespace (as opposed to
3304 the DIEs giving the declarations, which could be
3305 anywhere). But I don't see any reason why the
3306 standards says that they have to be there. */
3307 get_scope_pc_bounds (child
, ¤t_low
, ¤t_high
, cu
);
3309 if (current_low
!= ((CORE_ADDR
) -1))
3311 best_low
= min (best_low
, current_low
);
3312 best_high
= max (best_high
, current_high
);
3320 child
= sibling_die (child
);
3325 *highpc
= best_high
;
3328 /* Record the address ranges for BLOCK, offset by BASEADDR, as given
3331 dwarf2_record_block_ranges (struct die_info
*die
, struct block
*block
,
3332 CORE_ADDR baseaddr
, struct dwarf2_cu
*cu
)
3334 struct attribute
*attr
;
3336 attr
= dwarf2_attr (die
, DW_AT_high_pc
, cu
);
3339 CORE_ADDR high
= DW_ADDR (attr
);
3340 attr
= dwarf2_attr (die
, DW_AT_low_pc
, cu
);
3343 CORE_ADDR low
= DW_ADDR (attr
);
3344 record_block_range (block
, baseaddr
+ low
, baseaddr
+ high
- 1);
3348 attr
= dwarf2_attr (die
, DW_AT_ranges
, cu
);
3351 bfd
*obfd
= cu
->objfile
->obfd
;
3353 /* The value of the DW_AT_ranges attribute is the offset of the
3354 address range list in the .debug_ranges section. */
3355 unsigned long offset
= DW_UNSND (attr
);
3356 gdb_byte
*buffer
= dwarf2_per_objfile
->ranges_buffer
+ offset
;
3358 /* For some target architectures, but not others, the
3359 read_address function sign-extends the addresses it returns.
3360 To recognize base address selection entries, we need a
3362 unsigned int addr_size
= cu
->header
.addr_size
;
3363 CORE_ADDR base_select_mask
= ~(~(CORE_ADDR
)1 << (addr_size
* 8 - 1));
3365 /* The base address, to which the next pair is relative. Note
3366 that this 'base' is a DWARF concept: most entries in a range
3367 list are relative, to reduce the number of relocs against the
3368 debugging information. This is separate from this function's
3369 'baseaddr' argument, which GDB uses to relocate debugging
3370 information from a shared library based on the address at
3371 which the library was loaded. */
3372 CORE_ADDR base
= cu
->header
.base_address
;
3373 int base_known
= cu
->header
.base_known
;
3375 if (offset
>= dwarf2_per_objfile
->ranges_size
)
3377 complaint (&symfile_complaints
,
3378 _("Offset %lu out of bounds for DW_AT_ranges attribute"),
3385 unsigned int bytes_read
;
3386 CORE_ADDR start
, end
;
3388 start
= read_address (obfd
, buffer
, cu
, &bytes_read
);
3389 buffer
+= bytes_read
;
3390 end
= read_address (obfd
, buffer
, cu
, &bytes_read
);
3391 buffer
+= bytes_read
;
3393 /* Did we find the end of the range list? */
3394 if (start
== 0 && end
== 0)
3397 /* Did we find a base address selection entry? */
3398 else if ((start
& base_select_mask
) == base_select_mask
)
3404 /* We found an ordinary address range. */
3409 complaint (&symfile_complaints
,
3410 _("Invalid .debug_ranges data (no base address)"));
3414 record_block_range (block
,
3415 baseaddr
+ base
+ start
,
3416 baseaddr
+ base
+ end
- 1);
3422 /* Add an aggregate field to the field list. */
3425 dwarf2_add_field (struct field_info
*fip
, struct die_info
*die
,
3426 struct dwarf2_cu
*cu
)
3428 struct objfile
*objfile
= cu
->objfile
;
3429 struct nextfield
*new_field
;
3430 struct attribute
*attr
;
3432 char *fieldname
= "";
3434 /* Allocate a new field list entry and link it in. */
3435 new_field
= (struct nextfield
*) xmalloc (sizeof (struct nextfield
));
3436 make_cleanup (xfree
, new_field
);
3437 memset (new_field
, 0, sizeof (struct nextfield
));
3438 new_field
->next
= fip
->fields
;
3439 fip
->fields
= new_field
;
3442 /* Handle accessibility and virtuality of field.
3443 The default accessibility for members is public, the default
3444 accessibility for inheritance is private. */
3445 if (die
->tag
!= DW_TAG_inheritance
)
3446 new_field
->accessibility
= DW_ACCESS_public
;
3448 new_field
->accessibility
= DW_ACCESS_private
;
3449 new_field
->virtuality
= DW_VIRTUALITY_none
;
3451 attr
= dwarf2_attr (die
, DW_AT_accessibility
, cu
);
3453 new_field
->accessibility
= DW_UNSND (attr
);
3454 if (new_field
->accessibility
!= DW_ACCESS_public
)
3455 fip
->non_public_fields
= 1;
3456 attr
= dwarf2_attr (die
, DW_AT_virtuality
, cu
);
3458 new_field
->virtuality
= DW_UNSND (attr
);
3460 fp
= &new_field
->field
;
3462 if (die
->tag
== DW_TAG_member
&& ! die_is_declaration (die
, cu
))
3464 /* Data member other than a C++ static data member. */
3466 /* Get type of field. */
3467 fp
->type
= die_type (die
, cu
);
3469 FIELD_STATIC_KIND (*fp
) = 0;
3471 /* Get bit size of field (zero if none). */
3472 attr
= dwarf2_attr (die
, DW_AT_bit_size
, cu
);
3475 FIELD_BITSIZE (*fp
) = DW_UNSND (attr
);
3479 FIELD_BITSIZE (*fp
) = 0;
3482 /* Get bit offset of field. */
3483 attr
= dwarf2_attr (die
, DW_AT_data_member_location
, cu
);
3488 if (attr_form_is_section_offset (attr
))
3490 dwarf2_complex_location_expr_complaint ();
3493 else if (attr_form_is_constant (attr
))
3494 byte_offset
= dwarf2_get_attr_constant_value (attr
, 0);
3496 byte_offset
= decode_locdesc (DW_BLOCK (attr
), cu
);
3498 FIELD_BITPOS (*fp
) = byte_offset
* bits_per_byte
;
3501 FIELD_BITPOS (*fp
) = 0;
3502 attr
= dwarf2_attr (die
, DW_AT_bit_offset
, cu
);
3505 if (BITS_BIG_ENDIAN
)
3507 /* For big endian bits, the DW_AT_bit_offset gives the
3508 additional bit offset from the MSB of the containing
3509 anonymous object to the MSB of the field. We don't
3510 have to do anything special since we don't need to
3511 know the size of the anonymous object. */
3512 FIELD_BITPOS (*fp
) += DW_UNSND (attr
);
3516 /* For little endian bits, compute the bit offset to the
3517 MSB of the anonymous object, subtract off the number of
3518 bits from the MSB of the field to the MSB of the
3519 object, and then subtract off the number of bits of
3520 the field itself. The result is the bit offset of
3521 the LSB of the field. */
3523 int bit_offset
= DW_UNSND (attr
);
3525 attr
= dwarf2_attr (die
, DW_AT_byte_size
, cu
);
3528 /* The size of the anonymous object containing
3529 the bit field is explicit, so use the
3530 indicated size (in bytes). */
3531 anonymous_size
= DW_UNSND (attr
);
3535 /* The size of the anonymous object containing
3536 the bit field must be inferred from the type
3537 attribute of the data member containing the
3539 anonymous_size
= TYPE_LENGTH (fp
->type
);
3541 FIELD_BITPOS (*fp
) += anonymous_size
* bits_per_byte
3542 - bit_offset
- FIELD_BITSIZE (*fp
);
3546 /* Get name of field. */
3547 fieldname
= dwarf2_name (die
, cu
);
3548 if (fieldname
== NULL
)
3551 /* The name is already allocated along with this objfile, so we don't
3552 need to duplicate it for the type. */
3553 fp
->name
= fieldname
;
3555 /* Change accessibility for artificial fields (e.g. virtual table
3556 pointer or virtual base class pointer) to private. */
3557 if (dwarf2_attr (die
, DW_AT_artificial
, cu
))
3559 new_field
->accessibility
= DW_ACCESS_private
;
3560 fip
->non_public_fields
= 1;
3563 else if (die
->tag
== DW_TAG_member
|| die
->tag
== DW_TAG_variable
)
3565 /* C++ static member. */
3567 /* NOTE: carlton/2002-11-05: It should be a DW_TAG_member that
3568 is a declaration, but all versions of G++ as of this writing
3569 (so through at least 3.2.1) incorrectly generate
3570 DW_TAG_variable tags. */
3574 /* Get name of field. */
3575 fieldname
= dwarf2_name (die
, cu
);
3576 if (fieldname
== NULL
)
3579 /* Get physical name. */
3580 physname
= dwarf2_linkage_name (die
, cu
);
3582 /* The name is already allocated along with this objfile, so we don't
3583 need to duplicate it for the type. */
3584 SET_FIELD_PHYSNAME (*fp
, physname
? physname
: "");
3585 FIELD_TYPE (*fp
) = die_type (die
, cu
);
3586 FIELD_NAME (*fp
) = fieldname
;
3588 else if (die
->tag
== DW_TAG_inheritance
)
3590 /* C++ base class field. */
3591 attr
= dwarf2_attr (die
, DW_AT_data_member_location
, cu
);
3593 FIELD_BITPOS (*fp
) = (decode_locdesc (DW_BLOCK (attr
), cu
)
3595 FIELD_BITSIZE (*fp
) = 0;
3596 FIELD_STATIC_KIND (*fp
) = 0;
3597 FIELD_TYPE (*fp
) = die_type (die
, cu
);
3598 FIELD_NAME (*fp
) = type_name_no_tag (fp
->type
);
3599 fip
->nbaseclasses
++;
3603 /* Create the vector of fields, and attach it to the type. */
3606 dwarf2_attach_fields_to_type (struct field_info
*fip
, struct type
*type
,
3607 struct dwarf2_cu
*cu
)
3609 int nfields
= fip
->nfields
;
3611 /* Record the field count, allocate space for the array of fields,
3612 and create blank accessibility bitfields if necessary. */
3613 TYPE_NFIELDS (type
) = nfields
;
3614 TYPE_FIELDS (type
) = (struct field
*)
3615 TYPE_ALLOC (type
, sizeof (struct field
) * nfields
);
3616 memset (TYPE_FIELDS (type
), 0, sizeof (struct field
) * nfields
);
3618 if (fip
->non_public_fields
)
3620 ALLOCATE_CPLUS_STRUCT_TYPE (type
);
3622 TYPE_FIELD_PRIVATE_BITS (type
) =
3623 (B_TYPE
*) TYPE_ALLOC (type
, B_BYTES (nfields
));
3624 B_CLRALL (TYPE_FIELD_PRIVATE_BITS (type
), nfields
);
3626 TYPE_FIELD_PROTECTED_BITS (type
) =
3627 (B_TYPE
*) TYPE_ALLOC (type
, B_BYTES (nfields
));
3628 B_CLRALL (TYPE_FIELD_PROTECTED_BITS (type
), nfields
);
3630 TYPE_FIELD_IGNORE_BITS (type
) =
3631 (B_TYPE
*) TYPE_ALLOC (type
, B_BYTES (nfields
));
3632 B_CLRALL (TYPE_FIELD_IGNORE_BITS (type
), nfields
);
3635 /* If the type has baseclasses, allocate and clear a bit vector for
3636 TYPE_FIELD_VIRTUAL_BITS. */
3637 if (fip
->nbaseclasses
)
3639 int num_bytes
= B_BYTES (fip
->nbaseclasses
);
3640 unsigned char *pointer
;
3642 ALLOCATE_CPLUS_STRUCT_TYPE (type
);
3643 pointer
= TYPE_ALLOC (type
, num_bytes
);
3644 TYPE_FIELD_VIRTUAL_BITS (type
) = pointer
;
3645 B_CLRALL (TYPE_FIELD_VIRTUAL_BITS (type
), fip
->nbaseclasses
);
3646 TYPE_N_BASECLASSES (type
) = fip
->nbaseclasses
;
3649 /* Copy the saved-up fields into the field vector. Start from the head
3650 of the list, adding to the tail of the field array, so that they end
3651 up in the same order in the array in which they were added to the list. */
3652 while (nfields
-- > 0)
3654 TYPE_FIELD (type
, nfields
) = fip
->fields
->field
;
3655 switch (fip
->fields
->accessibility
)
3657 case DW_ACCESS_private
:
3658 SET_TYPE_FIELD_PRIVATE (type
, nfields
);
3661 case DW_ACCESS_protected
:
3662 SET_TYPE_FIELD_PROTECTED (type
, nfields
);
3665 case DW_ACCESS_public
:
3669 /* Unknown accessibility. Complain and treat it as public. */
3671 complaint (&symfile_complaints
, _("unsupported accessibility %d"),
3672 fip
->fields
->accessibility
);
3676 if (nfields
< fip
->nbaseclasses
)
3678 switch (fip
->fields
->virtuality
)
3680 case DW_VIRTUALITY_virtual
:
3681 case DW_VIRTUALITY_pure_virtual
:
3682 SET_TYPE_FIELD_VIRTUAL (type
, nfields
);
3686 fip
->fields
= fip
->fields
->next
;
3690 /* Add a member function to the proper fieldlist. */
3693 dwarf2_add_member_fn (struct field_info
*fip
, struct die_info
*die
,
3694 struct type
*type
, struct dwarf2_cu
*cu
)
3696 struct objfile
*objfile
= cu
->objfile
;
3697 struct attribute
*attr
;
3698 struct fnfieldlist
*flp
;
3700 struct fn_field
*fnp
;
3703 struct nextfnfield
*new_fnfield
;
3705 /* Get name of member function. */
3706 fieldname
= dwarf2_name (die
, cu
);
3707 if (fieldname
== NULL
)
3710 /* Get the mangled name. */
3711 physname
= dwarf2_linkage_name (die
, cu
);
3713 /* Look up member function name in fieldlist. */
3714 for (i
= 0; i
< fip
->nfnfields
; i
++)
3716 if (strcmp (fip
->fnfieldlists
[i
].name
, fieldname
) == 0)
3720 /* Create new list element if necessary. */
3721 if (i
< fip
->nfnfields
)
3722 flp
= &fip
->fnfieldlists
[i
];
3725 if ((fip
->nfnfields
% DW_FIELD_ALLOC_CHUNK
) == 0)
3727 fip
->fnfieldlists
= (struct fnfieldlist
*)
3728 xrealloc (fip
->fnfieldlists
,
3729 (fip
->nfnfields
+ DW_FIELD_ALLOC_CHUNK
)
3730 * sizeof (struct fnfieldlist
));
3731 if (fip
->nfnfields
== 0)
3732 make_cleanup (free_current_contents
, &fip
->fnfieldlists
);
3734 flp
= &fip
->fnfieldlists
[fip
->nfnfields
];
3735 flp
->name
= fieldname
;
3741 /* Create a new member function field and chain it to the field list
3743 new_fnfield
= (struct nextfnfield
*) xmalloc (sizeof (struct nextfnfield
));
3744 make_cleanup (xfree
, new_fnfield
);
3745 memset (new_fnfield
, 0, sizeof (struct nextfnfield
));
3746 new_fnfield
->next
= flp
->head
;
3747 flp
->head
= new_fnfield
;
3750 /* Fill in the member function field info. */
3751 fnp
= &new_fnfield
->fnfield
;
3752 /* The name is already allocated along with this objfile, so we don't
3753 need to duplicate it for the type. */
3754 fnp
->physname
= physname
? physname
: "";
3755 fnp
->type
= alloc_type (objfile
);
3756 if (die
->type
&& TYPE_CODE (die
->type
) == TYPE_CODE_FUNC
)
3758 int nparams
= TYPE_NFIELDS (die
->type
);
3760 /* TYPE is the domain of this method, and DIE->TYPE is the type
3761 of the method itself (TYPE_CODE_METHOD). */
3762 smash_to_method_type (fnp
->type
, type
,
3763 TYPE_TARGET_TYPE (die
->type
),
3764 TYPE_FIELDS (die
->type
),
3765 TYPE_NFIELDS (die
->type
),
3766 TYPE_VARARGS (die
->type
));
3768 /* Handle static member functions.
3769 Dwarf2 has no clean way to discern C++ static and non-static
3770 member functions. G++ helps GDB by marking the first
3771 parameter for non-static member functions (which is the
3772 this pointer) as artificial. We obtain this information
3773 from read_subroutine_type via TYPE_FIELD_ARTIFICIAL. */
3774 if (nparams
== 0 || TYPE_FIELD_ARTIFICIAL (die
->type
, 0) == 0)
3775 fnp
->voffset
= VOFFSET_STATIC
;
3778 complaint (&symfile_complaints
, _("member function type missing for '%s'"),
3781 /* Get fcontext from DW_AT_containing_type if present. */
3782 if (dwarf2_attr (die
, DW_AT_containing_type
, cu
) != NULL
)
3783 fnp
->fcontext
= die_containing_type (die
, cu
);
3785 /* dwarf2 doesn't have stubbed physical names, so the setting of is_const
3786 and is_volatile is irrelevant, as it is needed by gdb_mangle_name only. */
3788 /* Get accessibility. */
3789 attr
= dwarf2_attr (die
, DW_AT_accessibility
, cu
);
3792 switch (DW_UNSND (attr
))
3794 case DW_ACCESS_private
:
3795 fnp
->is_private
= 1;
3797 case DW_ACCESS_protected
:
3798 fnp
->is_protected
= 1;
3803 /* Check for artificial methods. */
3804 attr
= dwarf2_attr (die
, DW_AT_artificial
, cu
);
3805 if (attr
&& DW_UNSND (attr
) != 0)
3806 fnp
->is_artificial
= 1;
3808 /* Get index in virtual function table if it is a virtual member function. */
3809 attr
= dwarf2_attr (die
, DW_AT_vtable_elem_location
, cu
);
3812 /* Support the .debug_loc offsets */
3813 if (attr_form_is_block (attr
))
3815 fnp
->voffset
= decode_locdesc (DW_BLOCK (attr
), cu
) + 2;
3817 else if (attr_form_is_section_offset (attr
))
3819 dwarf2_complex_location_expr_complaint ();
3823 dwarf2_invalid_attrib_class_complaint ("DW_AT_vtable_elem_location",
3829 /* Create the vector of member function fields, and attach it to the type. */
3832 dwarf2_attach_fn_fields_to_type (struct field_info
*fip
, struct type
*type
,
3833 struct dwarf2_cu
*cu
)
3835 struct fnfieldlist
*flp
;
3836 int total_length
= 0;
3839 ALLOCATE_CPLUS_STRUCT_TYPE (type
);
3840 TYPE_FN_FIELDLISTS (type
) = (struct fn_fieldlist
*)
3841 TYPE_ALLOC (type
, sizeof (struct fn_fieldlist
) * fip
->nfnfields
);
3843 for (i
= 0, flp
= fip
->fnfieldlists
; i
< fip
->nfnfields
; i
++, flp
++)
3845 struct nextfnfield
*nfp
= flp
->head
;
3846 struct fn_fieldlist
*fn_flp
= &TYPE_FN_FIELDLIST (type
, i
);
3849 TYPE_FN_FIELDLIST_NAME (type
, i
) = flp
->name
;
3850 TYPE_FN_FIELDLIST_LENGTH (type
, i
) = flp
->length
;
3851 fn_flp
->fn_fields
= (struct fn_field
*)
3852 TYPE_ALLOC (type
, sizeof (struct fn_field
) * flp
->length
);
3853 for (k
= flp
->length
; (k
--, nfp
); nfp
= nfp
->next
)
3854 fn_flp
->fn_fields
[k
] = nfp
->fnfield
;
3856 total_length
+= flp
->length
;
3859 TYPE_NFN_FIELDS (type
) = fip
->nfnfields
;
3860 TYPE_NFN_FIELDS_TOTAL (type
) = total_length
;
3863 /* Returns non-zero if NAME is the name of a vtable member in CU's
3864 language, zero otherwise. */
3866 is_vtable_name (const char *name
, struct dwarf2_cu
*cu
)
3868 static const char vptr
[] = "_vptr";
3869 static const char vtable
[] = "vtable";
3871 /* Look for the C++ and Java forms of the vtable. */
3872 if ((cu
->language
== language_java
3873 && strncmp (name
, vtable
, sizeof (vtable
) - 1) == 0)
3874 || (strncmp (name
, vptr
, sizeof (vptr
) - 1) == 0
3875 && is_cplus_marker (name
[sizeof (vptr
) - 1])))
3881 /* GCC outputs unnamed structures that are really pointers to member
3882 functions, with the ABI-specified layout. If DIE (from CU) describes
3883 such a structure, set its type, and return nonzero. Otherwise return
3886 GCC shouldn't do this; it should just output pointer to member DIEs.
3887 This is GCC PR debug/28767. */
3890 quirk_gcc_member_function_pointer (struct die_info
*die
, struct dwarf2_cu
*cu
)
3892 struct objfile
*objfile
= cu
->objfile
;
3894 struct die_info
*pfn_die
, *delta_die
;
3895 struct attribute
*pfn_name
, *delta_name
;
3896 struct type
*pfn_type
, *domain_type
;
3898 /* Check for a structure with no name and two children. */
3899 if (die
->tag
!= DW_TAG_structure_type
3900 || dwarf2_attr (die
, DW_AT_name
, cu
) != NULL
3901 || die
->child
== NULL
3902 || die
->child
->sibling
== NULL
3903 || (die
->child
->sibling
->sibling
!= NULL
3904 && die
->child
->sibling
->sibling
->tag
!= DW_TAG_padding
))
3907 /* Check for __pfn and __delta members. */
3908 pfn_die
= die
->child
;
3909 pfn_name
= dwarf2_attr (pfn_die
, DW_AT_name
, cu
);
3910 if (pfn_die
->tag
!= DW_TAG_member
3912 || DW_STRING (pfn_name
) == NULL
3913 || strcmp ("__pfn", DW_STRING (pfn_name
)) != 0)
3916 delta_die
= pfn_die
->sibling
;
3917 delta_name
= dwarf2_attr (delta_die
, DW_AT_name
, cu
);
3918 if (delta_die
->tag
!= DW_TAG_member
3919 || delta_name
== NULL
3920 || DW_STRING (delta_name
) == NULL
3921 || strcmp ("__delta", DW_STRING (delta_name
)) != 0)
3924 /* Find the type of the method. */
3925 pfn_type
= die_type (pfn_die
, cu
);
3926 if (pfn_type
== NULL
3927 || TYPE_CODE (pfn_type
) != TYPE_CODE_PTR
3928 || TYPE_CODE (TYPE_TARGET_TYPE (pfn_type
)) != TYPE_CODE_FUNC
)
3931 /* Look for the "this" argument. */
3932 pfn_type
= TYPE_TARGET_TYPE (pfn_type
);
3933 if (TYPE_NFIELDS (pfn_type
) == 0
3934 || TYPE_CODE (TYPE_FIELD_TYPE (pfn_type
, 0)) != TYPE_CODE_PTR
)
3937 domain_type
= TYPE_TARGET_TYPE (TYPE_FIELD_TYPE (pfn_type
, 0));
3938 type
= alloc_type (objfile
);
3939 smash_to_method_type (type
, domain_type
, TYPE_TARGET_TYPE (pfn_type
),
3940 TYPE_FIELDS (pfn_type
), TYPE_NFIELDS (pfn_type
),
3941 TYPE_VARARGS (pfn_type
));
3942 type
= lookup_methodptr_type (type
);
3943 set_die_type (die
, type
, cu
);
3948 /* Called when we find the DIE that starts a structure or union scope
3949 (definition) to process all dies that define the members of the
3952 NOTE: we need to call struct_type regardless of whether or not the
3953 DIE has an at_name attribute, since it might be an anonymous
3954 structure or union. This gets the type entered into our set of
3957 However, if the structure is incomplete (an opaque struct/union)
3958 then suppress creating a symbol table entry for it since gdb only
3959 wants to find the one with the complete definition. Note that if
3960 it is complete, we just call new_symbol, which does it's own
3961 checking about whether the struct/union is anonymous or not (and
3962 suppresses creating a symbol table entry itself). */
3965 read_structure_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
3967 struct objfile
*objfile
= cu
->objfile
;
3969 struct attribute
*attr
;
3970 const char *previous_prefix
= processing_current_prefix
;
3971 struct cleanup
*back_to
= NULL
;
3977 if (quirk_gcc_member_function_pointer (die
, cu
))
3980 type
= alloc_type (objfile
);
3981 INIT_CPLUS_SPECIFIC (type
);
3982 name
= dwarf2_name (die
, cu
);
3985 if (cu
->language
== language_cplus
3986 || cu
->language
== language_java
)
3988 char *new_prefix
= determine_class_name (die
, cu
);
3989 TYPE_TAG_NAME (type
) = obsavestring (new_prefix
,
3990 strlen (new_prefix
),
3991 &objfile
->objfile_obstack
);
3992 back_to
= make_cleanup (xfree
, new_prefix
);
3993 processing_current_prefix
= new_prefix
;
3997 /* The name is already allocated along with this objfile, so
3998 we don't need to duplicate it for the type. */
3999 TYPE_TAG_NAME (type
) = name
;
4003 if (die
->tag
== DW_TAG_structure_type
)
4005 TYPE_CODE (type
) = TYPE_CODE_STRUCT
;
4007 else if (die
->tag
== DW_TAG_union_type
)
4009 TYPE_CODE (type
) = TYPE_CODE_UNION
;
4013 /* FIXME: TYPE_CODE_CLASS is currently defined to TYPE_CODE_STRUCT
4015 TYPE_CODE (type
) = TYPE_CODE_CLASS
;
4018 attr
= dwarf2_attr (die
, DW_AT_byte_size
, cu
);
4021 TYPE_LENGTH (type
) = DW_UNSND (attr
);
4025 TYPE_LENGTH (type
) = 0;
4028 TYPE_FLAGS (type
) |= TYPE_FLAG_STUB_SUPPORTED
;
4029 if (die_is_declaration (die
, cu
))
4030 TYPE_FLAGS (type
) |= TYPE_FLAG_STUB
;
4032 /* We need to add the type field to the die immediately so we don't
4033 infinitely recurse when dealing with pointers to the structure
4034 type within the structure itself. */
4035 set_die_type (die
, type
, cu
);
4037 if (die
->child
!= NULL
&& ! die_is_declaration (die
, cu
))
4039 struct field_info fi
;
4040 struct die_info
*child_die
;
4041 struct cleanup
*back_to
= make_cleanup (null_cleanup
, NULL
);
4043 memset (&fi
, 0, sizeof (struct field_info
));
4045 child_die
= die
->child
;
4047 while (child_die
&& child_die
->tag
)
4049 if (child_die
->tag
== DW_TAG_member
4050 || child_die
->tag
== DW_TAG_variable
)
4052 /* NOTE: carlton/2002-11-05: A C++ static data member
4053 should be a DW_TAG_member that is a declaration, but
4054 all versions of G++ as of this writing (so through at
4055 least 3.2.1) incorrectly generate DW_TAG_variable
4056 tags for them instead. */
4057 dwarf2_add_field (&fi
, child_die
, cu
);
4059 else if (child_die
->tag
== DW_TAG_subprogram
)
4061 /* C++ member function. */
4062 read_type_die (child_die
, cu
);
4063 dwarf2_add_member_fn (&fi
, child_die
, type
, cu
);
4065 else if (child_die
->tag
== DW_TAG_inheritance
)
4067 /* C++ base class field. */
4068 dwarf2_add_field (&fi
, child_die
, cu
);
4070 child_die
= sibling_die (child_die
);
4073 /* Attach fields and member functions to the type. */
4075 dwarf2_attach_fields_to_type (&fi
, type
, cu
);
4078 dwarf2_attach_fn_fields_to_type (&fi
, type
, cu
);
4080 /* Get the type which refers to the base class (possibly this
4081 class itself) which contains the vtable pointer for the current
4082 class from the DW_AT_containing_type attribute. */
4084 if (dwarf2_attr (die
, DW_AT_containing_type
, cu
) != NULL
)
4086 struct type
*t
= die_containing_type (die
, cu
);
4088 TYPE_VPTR_BASETYPE (type
) = t
;
4093 /* Our own class provides vtbl ptr. */
4094 for (i
= TYPE_NFIELDS (t
) - 1;
4095 i
>= TYPE_N_BASECLASSES (t
);
4098 char *fieldname
= TYPE_FIELD_NAME (t
, i
);
4100 if (is_vtable_name (fieldname
, cu
))
4102 TYPE_VPTR_FIELDNO (type
) = i
;
4107 /* Complain if virtual function table field not found. */
4108 if (i
< TYPE_N_BASECLASSES (t
))
4109 complaint (&symfile_complaints
,
4110 _("virtual function table pointer not found when defining class '%s'"),
4111 TYPE_TAG_NAME (type
) ? TYPE_TAG_NAME (type
) :
4116 TYPE_VPTR_FIELDNO (type
) = TYPE_VPTR_FIELDNO (t
);
4119 else if (cu
->producer
4120 && strncmp (cu
->producer
,
4121 "IBM(R) XL C/C++ Advanced Edition", 32) == 0)
4123 /* The IBM XLC compiler does not provide direct indication
4124 of the containing type, but the vtable pointer is
4125 always named __vfp. */
4129 for (i
= TYPE_NFIELDS (type
) - 1;
4130 i
>= TYPE_N_BASECLASSES (type
);
4133 if (strcmp (TYPE_FIELD_NAME (type
, i
), "__vfp") == 0)
4135 TYPE_VPTR_FIELDNO (type
) = i
;
4136 TYPE_VPTR_BASETYPE (type
) = type
;
4143 do_cleanups (back_to
);
4146 processing_current_prefix
= previous_prefix
;
4147 if (back_to
!= NULL
)
4148 do_cleanups (back_to
);
4152 process_structure_scope (struct die_info
*die
, struct dwarf2_cu
*cu
)
4154 struct objfile
*objfile
= cu
->objfile
;
4155 const char *previous_prefix
= processing_current_prefix
;
4156 struct die_info
*child_die
= die
->child
;
4158 if (TYPE_TAG_NAME (die
->type
) != NULL
)
4159 processing_current_prefix
= TYPE_TAG_NAME (die
->type
);
4161 /* NOTE: carlton/2004-03-16: GCC 3.4 (or at least one of its
4162 snapshots) has been known to create a die giving a declaration
4163 for a class that has, as a child, a die giving a definition for a
4164 nested class. So we have to process our children even if the
4165 current die is a declaration. Normally, of course, a declaration
4166 won't have any children at all. */
4168 while (child_die
!= NULL
&& child_die
->tag
)
4170 if (child_die
->tag
== DW_TAG_member
4171 || child_die
->tag
== DW_TAG_variable
4172 || child_die
->tag
== DW_TAG_inheritance
)
4177 process_die (child_die
, cu
);
4179 child_die
= sibling_die (child_die
);
4182 /* Do not consider external references. According to the DWARF standard,
4183 these DIEs are identified by the fact that they have no byte_size
4184 attribute, and a declaration attribute. */
4185 if (dwarf2_attr (die
, DW_AT_byte_size
, cu
) != NULL
4186 || !die_is_declaration (die
, cu
))
4187 new_symbol (die
, die
->type
, cu
);
4189 processing_current_prefix
= previous_prefix
;
4192 /* Given a DW_AT_enumeration_type die, set its type. We do not
4193 complete the type's fields yet, or create any symbols. */
4196 read_enumeration_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
4198 struct objfile
*objfile
= cu
->objfile
;
4200 struct attribute
*attr
;
4206 type
= alloc_type (objfile
);
4208 TYPE_CODE (type
) = TYPE_CODE_ENUM
;
4209 name
= dwarf2_name (die
, cu
);
4212 if (processing_has_namespace_info
)
4214 TYPE_TAG_NAME (type
) = typename_concat (&objfile
->objfile_obstack
,
4215 processing_current_prefix
,
4220 /* The name is already allocated along with this objfile, so
4221 we don't need to duplicate it for the type. */
4222 TYPE_TAG_NAME (type
) = name
;
4226 attr
= dwarf2_attr (die
, DW_AT_byte_size
, cu
);
4229 TYPE_LENGTH (type
) = DW_UNSND (attr
);
4233 TYPE_LENGTH (type
) = 0;
4236 set_die_type (die
, type
, cu
);
4239 /* Determine the name of the type represented by DIE, which should be
4240 a named C++ or Java compound type. Return the name in question; the caller
4241 is responsible for xfree()'ing it. */
4244 determine_class_name (struct die_info
*die
, struct dwarf2_cu
*cu
)
4246 struct cleanup
*back_to
= NULL
;
4247 struct die_info
*spec_die
= die_specification (die
, cu
);
4248 char *new_prefix
= NULL
;
4250 /* If this is the definition of a class that is declared by another
4251 die, then processing_current_prefix may not be accurate; see
4252 read_func_scope for a similar example. */
4253 if (spec_die
!= NULL
)
4255 char *specification_prefix
= determine_prefix (spec_die
, cu
);
4256 processing_current_prefix
= specification_prefix
;
4257 back_to
= make_cleanup (xfree
, specification_prefix
);
4260 /* If we don't have namespace debug info, guess the name by trying
4261 to demangle the names of members, just like we did in
4262 guess_structure_name. */
4263 if (!processing_has_namespace_info
)
4265 struct die_info
*child
;
4267 for (child
= die
->child
;
4268 child
!= NULL
&& child
->tag
!= 0;
4269 child
= sibling_die (child
))
4271 if (child
->tag
== DW_TAG_subprogram
)
4274 = language_class_name_from_physname (cu
->language_defn
,
4278 if (new_prefix
!= NULL
)
4284 if (new_prefix
== NULL
)
4286 const char *name
= dwarf2_name (die
, cu
);
4287 new_prefix
= typename_concat (NULL
, processing_current_prefix
,
4288 name
? name
: "<<anonymous>>",
4292 if (back_to
!= NULL
)
4293 do_cleanups (back_to
);
4298 /* Given a pointer to a die which begins an enumeration, process all
4299 the dies that define the members of the enumeration, and create the
4300 symbol for the enumeration type.
4302 NOTE: We reverse the order of the element list. */
4305 process_enumeration_scope (struct die_info
*die
, struct dwarf2_cu
*cu
)
4307 struct objfile
*objfile
= cu
->objfile
;
4308 struct die_info
*child_die
;
4309 struct field
*fields
;
4312 int unsigned_enum
= 1;
4317 if (die
->child
!= NULL
)
4319 child_die
= die
->child
;
4320 while (child_die
&& child_die
->tag
)
4322 if (child_die
->tag
!= DW_TAG_enumerator
)
4324 process_die (child_die
, cu
);
4328 name
= dwarf2_name (child_die
, cu
);
4331 sym
= new_symbol (child_die
, die
->type
, cu
);
4332 if (SYMBOL_VALUE (sym
) < 0)
4335 if ((num_fields
% DW_FIELD_ALLOC_CHUNK
) == 0)
4337 fields
= (struct field
*)
4339 (num_fields
+ DW_FIELD_ALLOC_CHUNK
)
4340 * sizeof (struct field
));
4343 FIELD_NAME (fields
[num_fields
]) = DEPRECATED_SYMBOL_NAME (sym
);
4344 FIELD_TYPE (fields
[num_fields
]) = NULL
;
4345 FIELD_BITPOS (fields
[num_fields
]) = SYMBOL_VALUE (sym
);
4346 FIELD_BITSIZE (fields
[num_fields
]) = 0;
4347 FIELD_STATIC_KIND (fields
[num_fields
]) = 0;
4353 child_die
= sibling_die (child_die
);
4358 TYPE_NFIELDS (die
->type
) = num_fields
;
4359 TYPE_FIELDS (die
->type
) = (struct field
*)
4360 TYPE_ALLOC (die
->type
, sizeof (struct field
) * num_fields
);
4361 memcpy (TYPE_FIELDS (die
->type
), fields
,
4362 sizeof (struct field
) * num_fields
);
4366 TYPE_FLAGS (die
->type
) |= TYPE_FLAG_UNSIGNED
;
4369 new_symbol (die
, die
->type
, cu
);
4372 /* Extract all information from a DW_TAG_array_type DIE and put it in
4373 the DIE's type field. For now, this only handles one dimensional
4377 read_array_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
4379 struct objfile
*objfile
= cu
->objfile
;
4380 struct die_info
*child_die
;
4381 struct type
*type
= NULL
;
4382 struct type
*element_type
, *range_type
, *index_type
;
4383 struct type
**range_types
= NULL
;
4384 struct attribute
*attr
;
4386 struct cleanup
*back_to
;
4389 /* Return if we've already decoded this type. */
4395 element_type
= die_type (die
, cu
);
4397 /* Irix 6.2 native cc creates array types without children for
4398 arrays with unspecified length. */
4399 if (die
->child
== NULL
)
4401 index_type
= builtin_type_int32
;
4402 range_type
= create_range_type (NULL
, index_type
, 0, -1);
4403 set_die_type (die
, create_array_type (NULL
, element_type
, range_type
),
4408 back_to
= make_cleanup (null_cleanup
, NULL
);
4409 child_die
= die
->child
;
4410 while (child_die
&& child_die
->tag
)
4412 if (child_die
->tag
== DW_TAG_subrange_type
)
4414 read_subrange_type (child_die
, cu
);
4416 if (child_die
->type
!= NULL
)
4418 /* The range type was succesfully read. Save it for
4419 the array type creation. */
4420 if ((ndim
% DW_FIELD_ALLOC_CHUNK
) == 0)
4422 range_types
= (struct type
**)
4423 xrealloc (range_types
, (ndim
+ DW_FIELD_ALLOC_CHUNK
)
4424 * sizeof (struct type
*));
4426 make_cleanup (free_current_contents
, &range_types
);
4428 range_types
[ndim
++] = child_die
->type
;
4431 child_die
= sibling_die (child_die
);
4434 /* Dwarf2 dimensions are output from left to right, create the
4435 necessary array types in backwards order. */
4437 type
= element_type
;
4439 if (read_array_order (die
, cu
) == DW_ORD_col_major
)
4443 type
= create_array_type (NULL
, type
, range_types
[i
++]);
4448 type
= create_array_type (NULL
, type
, range_types
[ndim
]);
4451 /* Understand Dwarf2 support for vector types (like they occur on
4452 the PowerPC w/ AltiVec). Gcc just adds another attribute to the
4453 array type. This is not part of the Dwarf2/3 standard yet, but a
4454 custom vendor extension. The main difference between a regular
4455 array and the vector variant is that vectors are passed by value
4457 attr
= dwarf2_attr (die
, DW_AT_GNU_vector
, cu
);
4459 make_vector_type (type
);
4461 name
= dwarf2_name (die
, cu
);
4463 TYPE_NAME (type
) = name
;
4465 do_cleanups (back_to
);
4467 /* Install the type in the die. */
4468 set_die_type (die
, type
, cu
);
4471 static enum dwarf_array_dim_ordering
4472 read_array_order (struct die_info
*die
, struct dwarf2_cu
*cu
)
4474 struct attribute
*attr
;
4476 attr
= dwarf2_attr (die
, DW_AT_ordering
, cu
);
4478 if (attr
) return DW_SND (attr
);
4481 GNU F77 is a special case, as at 08/2004 array type info is the
4482 opposite order to the dwarf2 specification, but data is still
4483 laid out as per normal fortran.
4485 FIXME: dsl/2004-8-20: If G77 is ever fixed, this will also need
4489 if (cu
->language
== language_fortran
&&
4490 cu
->producer
&& strstr (cu
->producer
, "GNU F77"))
4492 return DW_ORD_row_major
;
4495 switch (cu
->language_defn
->la_array_ordering
)
4497 case array_column_major
:
4498 return DW_ORD_col_major
;
4499 case array_row_major
:
4501 return DW_ORD_row_major
;
4505 /* Extract all information from a DW_TAG_set_type DIE and put it in
4506 the DIE's type field. */
4509 read_set_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
4511 if (die
->type
== NULL
)
4512 die
->type
= create_set_type ((struct type
*) NULL
, die_type (die
, cu
));
4515 /* First cut: install each common block member as a global variable. */
4518 read_common_block (struct die_info
*die
, struct dwarf2_cu
*cu
)
4520 struct die_info
*child_die
;
4521 struct attribute
*attr
;
4523 CORE_ADDR base
= (CORE_ADDR
) 0;
4525 attr
= dwarf2_attr (die
, DW_AT_location
, cu
);
4528 /* Support the .debug_loc offsets */
4529 if (attr_form_is_block (attr
))
4531 base
= decode_locdesc (DW_BLOCK (attr
), cu
);
4533 else if (attr_form_is_section_offset (attr
))
4535 dwarf2_complex_location_expr_complaint ();
4539 dwarf2_invalid_attrib_class_complaint ("DW_AT_location",
4540 "common block member");
4543 if (die
->child
!= NULL
)
4545 child_die
= die
->child
;
4546 while (child_die
&& child_die
->tag
)
4548 sym
= new_symbol (child_die
, NULL
, cu
);
4549 attr
= dwarf2_attr (child_die
, DW_AT_data_member_location
, cu
);
4552 SYMBOL_VALUE_ADDRESS (sym
) =
4553 base
+ decode_locdesc (DW_BLOCK (attr
), cu
);
4554 add_symbol_to_list (sym
, &global_symbols
);
4556 child_die
= sibling_die (child_die
);
4561 /* Read a C++ namespace. */
4564 read_namespace (struct die_info
*die
, struct dwarf2_cu
*cu
)
4566 struct objfile
*objfile
= cu
->objfile
;
4567 const char *previous_prefix
= processing_current_prefix
;
4570 struct die_info
*current_die
;
4571 struct cleanup
*back_to
= make_cleanup (null_cleanup
, 0);
4573 name
= namespace_name (die
, &is_anonymous
, cu
);
4575 /* Now build the name of the current namespace. */
4577 if (previous_prefix
[0] == '\0')
4579 processing_current_prefix
= name
;
4583 char *temp_name
= typename_concat (NULL
, previous_prefix
, name
, cu
);
4584 make_cleanup (xfree
, temp_name
);
4585 processing_current_prefix
= temp_name
;
4588 /* Add a symbol associated to this if we haven't seen the namespace
4589 before. Also, add a using directive if it's an anonymous
4592 if (dwarf2_extension (die
, cu
) == NULL
)
4596 /* FIXME: carlton/2003-06-27: Once GDB is more const-correct,
4597 this cast will hopefully become unnecessary. */
4598 type
= init_type (TYPE_CODE_NAMESPACE
, 0, 0,
4599 (char *) processing_current_prefix
,
4601 TYPE_TAG_NAME (type
) = TYPE_NAME (type
);
4603 new_symbol (die
, type
, cu
);
4604 set_die_type (die
, type
, cu
);
4607 cp_add_using_directive (processing_current_prefix
,
4608 strlen (previous_prefix
),
4609 strlen (processing_current_prefix
));
4612 if (die
->child
!= NULL
)
4614 struct die_info
*child_die
= die
->child
;
4616 while (child_die
&& child_die
->tag
)
4618 process_die (child_die
, cu
);
4619 child_die
= sibling_die (child_die
);
4623 processing_current_prefix
= previous_prefix
;
4624 do_cleanups (back_to
);
4627 /* Return the name of the namespace represented by DIE. Set
4628 *IS_ANONYMOUS to tell whether or not the namespace is an anonymous
4632 namespace_name (struct die_info
*die
, int *is_anonymous
, struct dwarf2_cu
*cu
)
4634 struct die_info
*current_die
;
4635 const char *name
= NULL
;
4637 /* Loop through the extensions until we find a name. */
4639 for (current_die
= die
;
4640 current_die
!= NULL
;
4641 current_die
= dwarf2_extension (die
, cu
))
4643 name
= dwarf2_name (current_die
, cu
);
4648 /* Is it an anonymous namespace? */
4650 *is_anonymous
= (name
== NULL
);
4652 name
= "(anonymous namespace)";
4657 /* Extract all information from a DW_TAG_pointer_type DIE and add to
4658 the user defined type vector. */
4661 read_tag_pointer_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
4663 struct comp_unit_head
*cu_header
= &cu
->header
;
4665 struct attribute
*attr_byte_size
;
4666 struct attribute
*attr_address_class
;
4667 int byte_size
, addr_class
;
4674 type
= lookup_pointer_type (die_type (die
, cu
));
4676 attr_byte_size
= dwarf2_attr (die
, DW_AT_byte_size
, cu
);
4678 byte_size
= DW_UNSND (attr_byte_size
);
4680 byte_size
= cu_header
->addr_size
;
4682 attr_address_class
= dwarf2_attr (die
, DW_AT_address_class
, cu
);
4683 if (attr_address_class
)
4684 addr_class
= DW_UNSND (attr_address_class
);
4686 addr_class
= DW_ADDR_none
;
4688 /* If the pointer size or address class is different than the
4689 default, create a type variant marked as such and set the
4690 length accordingly. */
4691 if (TYPE_LENGTH (type
) != byte_size
|| addr_class
!= DW_ADDR_none
)
4693 if (gdbarch_address_class_type_flags_p (current_gdbarch
))
4697 type_flags
= gdbarch_address_class_type_flags
4698 (current_gdbarch
, byte_size
, addr_class
);
4699 gdb_assert ((type_flags
& ~TYPE_FLAG_ADDRESS_CLASS_ALL
) == 0);
4700 type
= make_type_with_address_space (type
, type_flags
);
4702 else if (TYPE_LENGTH (type
) != byte_size
)
4704 complaint (&symfile_complaints
, _("invalid pointer size %d"), byte_size
);
4707 /* Should we also complain about unhandled address classes? */
4711 TYPE_LENGTH (type
) = byte_size
;
4712 set_die_type (die
, type
, cu
);
4715 /* Extract all information from a DW_TAG_ptr_to_member_type DIE and add to
4716 the user defined type vector. */
4719 read_tag_ptr_to_member_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
4721 struct objfile
*objfile
= cu
->objfile
;
4723 struct type
*to_type
;
4724 struct type
*domain
;
4731 to_type
= die_type (die
, cu
);
4732 domain
= die_containing_type (die
, cu
);
4734 if (TYPE_CODE (check_typedef (to_type
)) == TYPE_CODE_METHOD
)
4735 type
= lookup_methodptr_type (to_type
);
4737 type
= lookup_memberptr_type (to_type
, domain
);
4739 set_die_type (die
, type
, cu
);
4742 /* Extract all information from a DW_TAG_reference_type DIE and add to
4743 the user defined type vector. */
4746 read_tag_reference_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
4748 struct comp_unit_head
*cu_header
= &cu
->header
;
4750 struct attribute
*attr
;
4757 type
= lookup_reference_type (die_type (die
, cu
));
4758 attr
= dwarf2_attr (die
, DW_AT_byte_size
, cu
);
4761 TYPE_LENGTH (type
) = DW_UNSND (attr
);
4765 TYPE_LENGTH (type
) = cu_header
->addr_size
;
4767 set_die_type (die
, type
, cu
);
4771 read_tag_const_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
4773 struct type
*base_type
;
4780 base_type
= die_type (die
, cu
);
4781 set_die_type (die
, make_cv_type (1, TYPE_VOLATILE (base_type
), base_type
, 0),
4786 read_tag_volatile_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
4788 struct type
*base_type
;
4795 base_type
= die_type (die
, cu
);
4796 set_die_type (die
, make_cv_type (TYPE_CONST (base_type
), 1, base_type
, 0),
4800 /* Extract all information from a DW_TAG_string_type DIE and add to
4801 the user defined type vector. It isn't really a user defined type,
4802 but it behaves like one, with other DIE's using an AT_user_def_type
4803 attribute to reference it. */
4806 read_tag_string_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
4808 struct objfile
*objfile
= cu
->objfile
;
4809 struct type
*type
, *range_type
, *index_type
, *char_type
;
4810 struct attribute
*attr
;
4811 unsigned int length
;
4818 attr
= dwarf2_attr (die
, DW_AT_string_length
, cu
);
4821 length
= DW_UNSND (attr
);
4825 /* check for the DW_AT_byte_size attribute */
4826 attr
= dwarf2_attr (die
, DW_AT_byte_size
, cu
);
4829 length
= DW_UNSND (attr
);
4837 index_type
= builtin_type_int32
;
4838 range_type
= create_range_type (NULL
, index_type
, 1, length
);
4839 type
= create_string_type (NULL
, range_type
);
4841 set_die_type (die
, type
, cu
);
4844 /* Handle DIES due to C code like:
4848 int (*funcp)(int a, long l);
4852 ('funcp' generates a DW_TAG_subroutine_type DIE)
4856 read_subroutine_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
4858 struct type
*type
; /* Type that this function returns */
4859 struct type
*ftype
; /* Function that returns above type */
4860 struct attribute
*attr
;
4862 /* Decode the type that this subroutine returns */
4867 type
= die_type (die
, cu
);
4868 ftype
= make_function_type (type
, (struct type
**) 0);
4870 /* All functions in C++, Pascal and Java have prototypes. */
4871 attr
= dwarf2_attr (die
, DW_AT_prototyped
, cu
);
4872 if ((attr
&& (DW_UNSND (attr
) != 0))
4873 || cu
->language
== language_cplus
4874 || cu
->language
== language_java
4875 || cu
->language
== language_pascal
)
4876 TYPE_FLAGS (ftype
) |= TYPE_FLAG_PROTOTYPED
;
4878 if (die
->child
!= NULL
)
4880 struct die_info
*child_die
;
4884 /* Count the number of parameters.
4885 FIXME: GDB currently ignores vararg functions, but knows about
4886 vararg member functions. */
4887 child_die
= die
->child
;
4888 while (child_die
&& child_die
->tag
)
4890 if (child_die
->tag
== DW_TAG_formal_parameter
)
4892 else if (child_die
->tag
== DW_TAG_unspecified_parameters
)
4893 TYPE_FLAGS (ftype
) |= TYPE_FLAG_VARARGS
;
4894 child_die
= sibling_die (child_die
);
4897 /* Allocate storage for parameters and fill them in. */
4898 TYPE_NFIELDS (ftype
) = nparams
;
4899 TYPE_FIELDS (ftype
) = (struct field
*)
4900 TYPE_ZALLOC (ftype
, nparams
* sizeof (struct field
));
4902 child_die
= die
->child
;
4903 while (child_die
&& child_die
->tag
)
4905 if (child_die
->tag
== DW_TAG_formal_parameter
)
4907 /* Dwarf2 has no clean way to discern C++ static and non-static
4908 member functions. G++ helps GDB by marking the first
4909 parameter for non-static member functions (which is the
4910 this pointer) as artificial. We pass this information
4911 to dwarf2_add_member_fn via TYPE_FIELD_ARTIFICIAL. */
4912 attr
= dwarf2_attr (child_die
, DW_AT_artificial
, cu
);
4914 TYPE_FIELD_ARTIFICIAL (ftype
, iparams
) = DW_UNSND (attr
);
4916 TYPE_FIELD_ARTIFICIAL (ftype
, iparams
) = 0;
4917 TYPE_FIELD_TYPE (ftype
, iparams
) = die_type (child_die
, cu
);
4920 child_die
= sibling_die (child_die
);
4924 set_die_type (die
, ftype
, cu
);
4928 read_typedef (struct die_info
*die
, struct dwarf2_cu
*cu
)
4930 struct objfile
*objfile
= cu
->objfile
;
4931 struct attribute
*attr
;
4936 name
= dwarf2_name (die
, cu
);
4937 set_die_type (die
, init_type (TYPE_CODE_TYPEDEF
, 0,
4938 TYPE_FLAG_TARGET_STUB
, name
, objfile
),
4940 TYPE_TARGET_TYPE (die
->type
) = die_type (die
, cu
);
4944 /* Find a representation of a given base type and install
4945 it in the TYPE field of the die. */
4948 read_base_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
4950 struct objfile
*objfile
= cu
->objfile
;
4952 struct attribute
*attr
;
4953 int encoding
= 0, size
= 0;
4955 enum type_code code
= TYPE_CODE_INT
;
4957 struct type
*target_type
= NULL
;
4959 /* If we've already decoded this die, this is a no-op. */
4965 attr
= dwarf2_attr (die
, DW_AT_encoding
, cu
);
4968 encoding
= DW_UNSND (attr
);
4970 attr
= dwarf2_attr (die
, DW_AT_byte_size
, cu
);
4973 size
= DW_UNSND (attr
);
4975 name
= dwarf2_name (die
, cu
);
4978 complaint (&symfile_complaints
,
4979 _("DW_AT_name missing from DW_TAG_base_type"));
4984 case DW_ATE_address
:
4985 /* Turn DW_ATE_address into a void * pointer. */
4986 code
= TYPE_CODE_PTR
;
4987 type_flags
|= TYPE_FLAG_UNSIGNED
;
4988 target_type
= init_type (TYPE_CODE_VOID
, 1, 0, NULL
, objfile
);
4990 case DW_ATE_boolean
:
4991 code
= TYPE_CODE_BOOL
;
4992 type_flags
|= TYPE_FLAG_UNSIGNED
;
4994 case DW_ATE_complex_float
:
4995 code
= TYPE_CODE_COMPLEX
;
4996 target_type
= init_type (TYPE_CODE_FLT
, size
/ 2, 0, NULL
, objfile
);
4998 case DW_ATE_decimal_float
:
4999 code
= TYPE_CODE_DECFLOAT
;
5002 code
= TYPE_CODE_FLT
;
5006 case DW_ATE_unsigned
:
5007 type_flags
|= TYPE_FLAG_UNSIGNED
;
5009 case DW_ATE_signed_char
:
5010 if (cu
->language
== language_ada
|| cu
->language
== language_m2
)
5011 code
= TYPE_CODE_CHAR
;
5013 case DW_ATE_unsigned_char
:
5014 if (cu
->language
== language_ada
|| cu
->language
== language_m2
)
5015 code
= TYPE_CODE_CHAR
;
5016 type_flags
|= TYPE_FLAG_UNSIGNED
;
5019 complaint (&symfile_complaints
, _("unsupported DW_AT_encoding: '%s'"),
5020 dwarf_type_encoding_name (encoding
));
5024 type
= init_type (code
, size
, type_flags
, name
, objfile
);
5025 TYPE_TARGET_TYPE (type
) = target_type
;
5027 set_die_type (die
, type
, cu
);
5030 /* Read the given DW_AT_subrange DIE. */
5033 read_subrange_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
5035 struct type
*base_type
;
5036 struct type
*range_type
;
5037 struct attribute
*attr
;
5042 /* If we have already decoded this die, then nothing more to do. */
5046 base_type
= die_type (die
, cu
);
5047 if (TYPE_CODE (base_type
) == TYPE_CODE_VOID
)
5049 complaint (&symfile_complaints
,
5050 _("DW_AT_type missing from DW_TAG_subrange_type"));
5052 = init_type (TYPE_CODE_INT
, gdbarch_addr_bit (current_gdbarch
) / 8,
5053 0, NULL
, cu
->objfile
);
5056 if (cu
->language
== language_fortran
)
5058 /* FORTRAN implies a lower bound of 1, if not given. */
5062 /* FIXME: For variable sized arrays either of these could be
5063 a variable rather than a constant value. We'll allow it,
5064 but we don't know how to handle it. */
5065 attr
= dwarf2_attr (die
, DW_AT_lower_bound
, cu
);
5067 low
= dwarf2_get_attr_constant_value (attr
, 0);
5069 attr
= dwarf2_attr (die
, DW_AT_upper_bound
, cu
);
5072 if (attr
->form
== DW_FORM_block1
)
5074 /* GCC encodes arrays with unspecified or dynamic length
5075 with a DW_FORM_block1 attribute.
5076 FIXME: GDB does not yet know how to handle dynamic
5077 arrays properly, treat them as arrays with unspecified
5080 FIXME: jimb/2003-09-22: GDB does not really know
5081 how to handle arrays of unspecified length
5082 either; we just represent them as zero-length
5083 arrays. Choose an appropriate upper bound given
5084 the lower bound we've computed above. */
5088 high
= dwarf2_get_attr_constant_value (attr
, 1);
5091 range_type
= create_range_type (NULL
, base_type
, low
, high
);
5093 name
= dwarf2_name (die
, cu
);
5095 TYPE_NAME (range_type
) = name
;
5097 attr
= dwarf2_attr (die
, DW_AT_byte_size
, cu
);
5099 TYPE_LENGTH (range_type
) = DW_UNSND (attr
);
5101 set_die_type (die
, range_type
, cu
);
5105 read_unspecified_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
5112 /* For now, we only support the C meaning of an unspecified type: void. */
5114 type
= init_type (TYPE_CODE_VOID
, 0, 0, dwarf2_name (die
, cu
),
5117 set_die_type (die
, type
, cu
);
5120 /* Read a whole compilation unit into a linked list of dies. */
5122 static struct die_info
*
5123 read_comp_unit (gdb_byte
*info_ptr
, bfd
*abfd
, struct dwarf2_cu
*cu
)
5125 return read_die_and_children (info_ptr
, abfd
, cu
, &info_ptr
, NULL
);
5128 /* Read a single die and all its descendents. Set the die's sibling
5129 field to NULL; set other fields in the die correctly, and set all
5130 of the descendents' fields correctly. Set *NEW_INFO_PTR to the
5131 location of the info_ptr after reading all of those dies. PARENT
5132 is the parent of the die in question. */
5134 static struct die_info
*
5135 read_die_and_children (gdb_byte
*info_ptr
, bfd
*abfd
,
5136 struct dwarf2_cu
*cu
,
5137 gdb_byte
**new_info_ptr
,
5138 struct die_info
*parent
)
5140 struct die_info
*die
;
5144 cur_ptr
= read_full_die (&die
, abfd
, info_ptr
, cu
, &has_children
);
5145 store_in_ref_table (die
->offset
, die
, cu
);
5149 die
->child
= read_die_and_siblings (cur_ptr
, abfd
, cu
,
5155 *new_info_ptr
= cur_ptr
;
5158 die
->sibling
= NULL
;
5159 die
->parent
= parent
;
5163 /* Read a die, all of its descendents, and all of its siblings; set
5164 all of the fields of all of the dies correctly. Arguments are as
5165 in read_die_and_children. */
5167 static struct die_info
*
5168 read_die_and_siblings (gdb_byte
*info_ptr
, bfd
*abfd
,
5169 struct dwarf2_cu
*cu
,
5170 gdb_byte
**new_info_ptr
,
5171 struct die_info
*parent
)
5173 struct die_info
*first_die
, *last_sibling
;
5177 first_die
= last_sibling
= NULL
;
5181 struct die_info
*die
5182 = read_die_and_children (cur_ptr
, abfd
, cu
, &cur_ptr
, parent
);
5190 last_sibling
->sibling
= die
;
5195 *new_info_ptr
= cur_ptr
;
5205 /* Free a linked list of dies. */
5208 free_die_list (struct die_info
*dies
)
5210 struct die_info
*die
, *next
;
5215 if (die
->child
!= NULL
)
5216 free_die_list (die
->child
);
5217 next
= die
->sibling
;
5224 /* Read the contents of the section at OFFSET and of size SIZE from the
5225 object file specified by OBJFILE into the objfile_obstack and return it. */
5228 dwarf2_read_section (struct objfile
*objfile
, asection
*sectp
)
5230 bfd
*abfd
= objfile
->obfd
;
5231 gdb_byte
*buf
, *retbuf
;
5232 bfd_size_type size
= bfd_get_section_size (sectp
);
5237 buf
= obstack_alloc (&objfile
->objfile_obstack
, size
);
5238 retbuf
= symfile_relocate_debug_section (abfd
, sectp
, buf
);
5242 if (bfd_seek (abfd
, sectp
->filepos
, SEEK_SET
) != 0
5243 || bfd_bread (buf
, size
, abfd
) != size
)
5244 error (_("Dwarf Error: Can't read DWARF data from '%s'"),
5245 bfd_get_filename (abfd
));
5250 /* In DWARF version 2, the description of the debugging information is
5251 stored in a separate .debug_abbrev section. Before we read any
5252 dies from a section we read in all abbreviations and install them
5253 in a hash table. This function also sets flags in CU describing
5254 the data found in the abbrev table. */
5257 dwarf2_read_abbrevs (bfd
*abfd
, struct dwarf2_cu
*cu
)
5259 struct comp_unit_head
*cu_header
= &cu
->header
;
5260 gdb_byte
*abbrev_ptr
;
5261 struct abbrev_info
*cur_abbrev
;
5262 unsigned int abbrev_number
, bytes_read
, abbrev_name
;
5263 unsigned int abbrev_form
, hash_number
;
5264 struct attr_abbrev
*cur_attrs
;
5265 unsigned int allocated_attrs
;
5267 /* Initialize dwarf2 abbrevs */
5268 obstack_init (&cu
->abbrev_obstack
);
5269 cu
->dwarf2_abbrevs
= obstack_alloc (&cu
->abbrev_obstack
,
5271 * sizeof (struct abbrev_info
*)));
5272 memset (cu
->dwarf2_abbrevs
, 0,
5273 ABBREV_HASH_SIZE
* sizeof (struct abbrev_info
*));
5275 abbrev_ptr
= dwarf2_per_objfile
->abbrev_buffer
+ cu_header
->abbrev_offset
;
5276 abbrev_number
= read_unsigned_leb128 (abfd
, abbrev_ptr
, &bytes_read
);
5277 abbrev_ptr
+= bytes_read
;
5279 allocated_attrs
= ATTR_ALLOC_CHUNK
;
5280 cur_attrs
= xmalloc (allocated_attrs
* sizeof (struct attr_abbrev
));
5282 /* loop until we reach an abbrev number of 0 */
5283 while (abbrev_number
)
5285 cur_abbrev
= dwarf_alloc_abbrev (cu
);
5287 /* read in abbrev header */
5288 cur_abbrev
->number
= abbrev_number
;
5289 cur_abbrev
->tag
= read_unsigned_leb128 (abfd
, abbrev_ptr
, &bytes_read
);
5290 abbrev_ptr
+= bytes_read
;
5291 cur_abbrev
->has_children
= read_1_byte (abfd
, abbrev_ptr
);
5294 if (cur_abbrev
->tag
== DW_TAG_namespace
)
5295 cu
->has_namespace_info
= 1;
5297 /* now read in declarations */
5298 abbrev_name
= read_unsigned_leb128 (abfd
, abbrev_ptr
, &bytes_read
);
5299 abbrev_ptr
+= bytes_read
;
5300 abbrev_form
= read_unsigned_leb128 (abfd
, abbrev_ptr
, &bytes_read
);
5301 abbrev_ptr
+= bytes_read
;
5304 if (cur_abbrev
->num_attrs
== allocated_attrs
)
5306 allocated_attrs
+= ATTR_ALLOC_CHUNK
;
5308 = xrealloc (cur_attrs
, (allocated_attrs
5309 * sizeof (struct attr_abbrev
)));
5312 /* Record whether this compilation unit might have
5313 inter-compilation-unit references. If we don't know what form
5314 this attribute will have, then it might potentially be a
5315 DW_FORM_ref_addr, so we conservatively expect inter-CU
5318 if (abbrev_form
== DW_FORM_ref_addr
5319 || abbrev_form
== DW_FORM_indirect
)
5320 cu
->has_form_ref_addr
= 1;
5322 cur_attrs
[cur_abbrev
->num_attrs
].name
= abbrev_name
;
5323 cur_attrs
[cur_abbrev
->num_attrs
++].form
= abbrev_form
;
5324 abbrev_name
= read_unsigned_leb128 (abfd
, abbrev_ptr
, &bytes_read
);
5325 abbrev_ptr
+= bytes_read
;
5326 abbrev_form
= read_unsigned_leb128 (abfd
, abbrev_ptr
, &bytes_read
);
5327 abbrev_ptr
+= bytes_read
;
5330 cur_abbrev
->attrs
= obstack_alloc (&cu
->abbrev_obstack
,
5331 (cur_abbrev
->num_attrs
5332 * sizeof (struct attr_abbrev
)));
5333 memcpy (cur_abbrev
->attrs
, cur_attrs
,
5334 cur_abbrev
->num_attrs
* sizeof (struct attr_abbrev
));
5336 hash_number
= abbrev_number
% ABBREV_HASH_SIZE
;
5337 cur_abbrev
->next
= cu
->dwarf2_abbrevs
[hash_number
];
5338 cu
->dwarf2_abbrevs
[hash_number
] = cur_abbrev
;
5340 /* Get next abbreviation.
5341 Under Irix6 the abbreviations for a compilation unit are not
5342 always properly terminated with an abbrev number of 0.
5343 Exit loop if we encounter an abbreviation which we have
5344 already read (which means we are about to read the abbreviations
5345 for the next compile unit) or if the end of the abbreviation
5346 table is reached. */
5347 if ((unsigned int) (abbrev_ptr
- dwarf2_per_objfile
->abbrev_buffer
)
5348 >= dwarf2_per_objfile
->abbrev_size
)
5350 abbrev_number
= read_unsigned_leb128 (abfd
, abbrev_ptr
, &bytes_read
);
5351 abbrev_ptr
+= bytes_read
;
5352 if (dwarf2_lookup_abbrev (abbrev_number
, cu
) != NULL
)
5359 /* Release the memory used by the abbrev table for a compilation unit. */
5362 dwarf2_free_abbrev_table (void *ptr_to_cu
)
5364 struct dwarf2_cu
*cu
= ptr_to_cu
;
5366 obstack_free (&cu
->abbrev_obstack
, NULL
);
5367 cu
->dwarf2_abbrevs
= NULL
;
5370 /* Lookup an abbrev_info structure in the abbrev hash table. */
5372 static struct abbrev_info
*
5373 dwarf2_lookup_abbrev (unsigned int number
, struct dwarf2_cu
*cu
)
5375 unsigned int hash_number
;
5376 struct abbrev_info
*abbrev
;
5378 hash_number
= number
% ABBREV_HASH_SIZE
;
5379 abbrev
= cu
->dwarf2_abbrevs
[hash_number
];
5383 if (abbrev
->number
== number
)
5386 abbrev
= abbrev
->next
;
5391 /* Returns nonzero if TAG represents a type that we might generate a partial
5395 is_type_tag_for_partial (int tag
)
5400 /* Some types that would be reasonable to generate partial symbols for,
5401 that we don't at present. */
5402 case DW_TAG_array_type
:
5403 case DW_TAG_file_type
:
5404 case DW_TAG_ptr_to_member_type
:
5405 case DW_TAG_set_type
:
5406 case DW_TAG_string_type
:
5407 case DW_TAG_subroutine_type
:
5409 case DW_TAG_base_type
:
5410 case DW_TAG_class_type
:
5411 case DW_TAG_interface_type
:
5412 case DW_TAG_enumeration_type
:
5413 case DW_TAG_structure_type
:
5414 case DW_TAG_subrange_type
:
5415 case DW_TAG_typedef
:
5416 case DW_TAG_union_type
:
5423 /* Load all DIEs that are interesting for partial symbols into memory. */
5425 static struct partial_die_info
*
5426 load_partial_dies (bfd
*abfd
, gdb_byte
*info_ptr
, int building_psymtab
,
5427 struct dwarf2_cu
*cu
)
5429 struct partial_die_info
*part_die
;
5430 struct partial_die_info
*parent_die
, *last_die
, *first_die
= NULL
;
5431 struct abbrev_info
*abbrev
;
5432 unsigned int bytes_read
;
5433 unsigned int load_all
= 0;
5435 int nesting_level
= 1;
5440 if (cu
->per_cu
&& cu
->per_cu
->load_all_dies
)
5444 = htab_create_alloc_ex (cu
->header
.length
/ 12,
5448 &cu
->comp_unit_obstack
,
5449 hashtab_obstack_allocate
,
5450 dummy_obstack_deallocate
);
5452 part_die
= obstack_alloc (&cu
->comp_unit_obstack
,
5453 sizeof (struct partial_die_info
));
5457 abbrev
= peek_die_abbrev (info_ptr
, &bytes_read
, cu
);
5459 /* A NULL abbrev means the end of a series of children. */
5462 if (--nesting_level
== 0)
5464 /* PART_DIE was probably the last thing allocated on the
5465 comp_unit_obstack, so we could call obstack_free
5466 here. We don't do that because the waste is small,
5467 and will be cleaned up when we're done with this
5468 compilation unit. This way, we're also more robust
5469 against other users of the comp_unit_obstack. */
5472 info_ptr
+= bytes_read
;
5473 last_die
= parent_die
;
5474 parent_die
= parent_die
->die_parent
;
5478 /* Check whether this DIE is interesting enough to save. Normally
5479 we would not be interested in members here, but there may be
5480 later variables referencing them via DW_AT_specification (for
5483 && !is_type_tag_for_partial (abbrev
->tag
)
5484 && abbrev
->tag
!= DW_TAG_enumerator
5485 && abbrev
->tag
!= DW_TAG_subprogram
5486 && abbrev
->tag
!= DW_TAG_variable
5487 && abbrev
->tag
!= DW_TAG_namespace
5488 && abbrev
->tag
!= DW_TAG_member
)
5490 /* Otherwise we skip to the next sibling, if any. */
5491 info_ptr
= skip_one_die (info_ptr
+ bytes_read
, abbrev
, cu
);
5495 info_ptr
= read_partial_die (part_die
, abbrev
, bytes_read
,
5496 abfd
, info_ptr
, cu
);
5498 /* This two-pass algorithm for processing partial symbols has a
5499 high cost in cache pressure. Thus, handle some simple cases
5500 here which cover the majority of C partial symbols. DIEs
5501 which neither have specification tags in them, nor could have
5502 specification tags elsewhere pointing at them, can simply be
5503 processed and discarded.
5505 This segment is also optional; scan_partial_symbols and
5506 add_partial_symbol will handle these DIEs if we chain
5507 them in normally. When compilers which do not emit large
5508 quantities of duplicate debug information are more common,
5509 this code can probably be removed. */
5511 /* Any complete simple types at the top level (pretty much all
5512 of them, for a language without namespaces), can be processed
5514 if (parent_die
== NULL
5515 && part_die
->has_specification
== 0
5516 && part_die
->is_declaration
== 0
5517 && (part_die
->tag
== DW_TAG_typedef
5518 || part_die
->tag
== DW_TAG_base_type
5519 || part_die
->tag
== DW_TAG_subrange_type
))
5521 if (building_psymtab
&& part_die
->name
!= NULL
)
5522 add_psymbol_to_list (part_die
->name
, strlen (part_die
->name
),
5523 VAR_DOMAIN
, LOC_TYPEDEF
,
5524 &cu
->objfile
->static_psymbols
,
5525 0, (CORE_ADDR
) 0, cu
->language
, cu
->objfile
);
5526 info_ptr
= locate_pdi_sibling (part_die
, info_ptr
, abfd
, cu
);
5530 /* If we're at the second level, and we're an enumerator, and
5531 our parent has no specification (meaning possibly lives in a
5532 namespace elsewhere), then we can add the partial symbol now
5533 instead of queueing it. */
5534 if (part_die
->tag
== DW_TAG_enumerator
5535 && parent_die
!= NULL
5536 && parent_die
->die_parent
== NULL
5537 && parent_die
->tag
== DW_TAG_enumeration_type
5538 && parent_die
->has_specification
== 0)
5540 if (part_die
->name
== NULL
)
5541 complaint (&symfile_complaints
, _("malformed enumerator DIE ignored"));
5542 else if (building_psymtab
)
5543 add_psymbol_to_list (part_die
->name
, strlen (part_die
->name
),
5544 VAR_DOMAIN
, LOC_CONST
,
5545 (cu
->language
== language_cplus
5546 || cu
->language
== language_java
)
5547 ? &cu
->objfile
->global_psymbols
5548 : &cu
->objfile
->static_psymbols
,
5549 0, (CORE_ADDR
) 0, cu
->language
, cu
->objfile
);
5551 info_ptr
= locate_pdi_sibling (part_die
, info_ptr
, abfd
, cu
);
5555 /* We'll save this DIE so link it in. */
5556 part_die
->die_parent
= parent_die
;
5557 part_die
->die_sibling
= NULL
;
5558 part_die
->die_child
= NULL
;
5560 if (last_die
&& last_die
== parent_die
)
5561 last_die
->die_child
= part_die
;
5563 last_die
->die_sibling
= part_die
;
5565 last_die
= part_die
;
5567 if (first_die
== NULL
)
5568 first_die
= part_die
;
5570 /* Maybe add the DIE to the hash table. Not all DIEs that we
5571 find interesting need to be in the hash table, because we
5572 also have the parent/sibling/child chains; only those that we
5573 might refer to by offset later during partial symbol reading.
5575 For now this means things that might have be the target of a
5576 DW_AT_specification, DW_AT_abstract_origin, or
5577 DW_AT_extension. DW_AT_extension will refer only to
5578 namespaces; DW_AT_abstract_origin refers to functions (and
5579 many things under the function DIE, but we do not recurse
5580 into function DIEs during partial symbol reading) and
5581 possibly variables as well; DW_AT_specification refers to
5582 declarations. Declarations ought to have the DW_AT_declaration
5583 flag. It happens that GCC forgets to put it in sometimes, but
5584 only for functions, not for types.
5586 Adding more things than necessary to the hash table is harmless
5587 except for the performance cost. Adding too few will result in
5588 wasted time in find_partial_die, when we reread the compilation
5589 unit with load_all_dies set. */
5592 || abbrev
->tag
== DW_TAG_subprogram
5593 || abbrev
->tag
== DW_TAG_variable
5594 || abbrev
->tag
== DW_TAG_namespace
5595 || part_die
->is_declaration
)
5599 slot
= htab_find_slot_with_hash (cu
->partial_dies
, part_die
,
5600 part_die
->offset
, INSERT
);
5604 part_die
= obstack_alloc (&cu
->comp_unit_obstack
,
5605 sizeof (struct partial_die_info
));
5607 /* For some DIEs we want to follow their children (if any). For C
5608 we have no reason to follow the children of structures; for other
5609 languages we have to, both so that we can get at method physnames
5610 to infer fully qualified class names, and for DW_AT_specification. */
5611 if (last_die
->has_children
5613 || last_die
->tag
== DW_TAG_namespace
5614 || last_die
->tag
== DW_TAG_enumeration_type
5615 || (cu
->language
!= language_c
5616 && (last_die
->tag
== DW_TAG_class_type
5617 || last_die
->tag
== DW_TAG_interface_type
5618 || last_die
->tag
== DW_TAG_structure_type
5619 || last_die
->tag
== DW_TAG_union_type
))))
5622 parent_die
= last_die
;
5626 /* Otherwise we skip to the next sibling, if any. */
5627 info_ptr
= locate_pdi_sibling (last_die
, info_ptr
, abfd
, cu
);
5629 /* Back to the top, do it again. */
5633 /* Read a minimal amount of information into the minimal die structure. */
5636 read_partial_die (struct partial_die_info
*part_die
,
5637 struct abbrev_info
*abbrev
,
5638 unsigned int abbrev_len
, bfd
*abfd
,
5639 gdb_byte
*info_ptr
, struct dwarf2_cu
*cu
)
5641 unsigned int bytes_read
, i
;
5642 struct attribute attr
;
5643 int has_low_pc_attr
= 0;
5644 int has_high_pc_attr
= 0;
5646 memset (part_die
, 0, sizeof (struct partial_die_info
));
5648 part_die
->offset
= info_ptr
- dwarf2_per_objfile
->info_buffer
;
5650 info_ptr
+= abbrev_len
;
5655 part_die
->tag
= abbrev
->tag
;
5656 part_die
->has_children
= abbrev
->has_children
;
5658 for (i
= 0; i
< abbrev
->num_attrs
; ++i
)
5660 info_ptr
= read_attribute (&attr
, &abbrev
->attrs
[i
], abfd
, info_ptr
, cu
);
5662 /* Store the data if it is of an attribute we want to keep in a
5663 partial symbol table. */
5668 /* Prefer DW_AT_MIPS_linkage_name over DW_AT_name. */
5669 if (part_die
->name
== NULL
)
5670 part_die
->name
= DW_STRING (&attr
);
5672 case DW_AT_comp_dir
:
5673 if (part_die
->dirname
== NULL
)
5674 part_die
->dirname
= DW_STRING (&attr
);
5676 case DW_AT_MIPS_linkage_name
:
5677 part_die
->name
= DW_STRING (&attr
);
5680 has_low_pc_attr
= 1;
5681 part_die
->lowpc
= DW_ADDR (&attr
);
5684 has_high_pc_attr
= 1;
5685 part_die
->highpc
= DW_ADDR (&attr
);
5688 if (dwarf2_ranges_read (DW_UNSND (&attr
), &part_die
->lowpc
,
5689 &part_die
->highpc
, cu
))
5690 has_low_pc_attr
= has_high_pc_attr
= 1;
5692 case DW_AT_location
:
5693 /* Support the .debug_loc offsets */
5694 if (attr_form_is_block (&attr
))
5696 part_die
->locdesc
= DW_BLOCK (&attr
);
5698 else if (attr_form_is_section_offset (&attr
))
5700 dwarf2_complex_location_expr_complaint ();
5704 dwarf2_invalid_attrib_class_complaint ("DW_AT_location",
5705 "partial symbol information");
5708 case DW_AT_language
:
5709 part_die
->language
= DW_UNSND (&attr
);
5711 case DW_AT_external
:
5712 part_die
->is_external
= DW_UNSND (&attr
);
5714 case DW_AT_declaration
:
5715 part_die
->is_declaration
= DW_UNSND (&attr
);
5718 part_die
->has_type
= 1;
5720 case DW_AT_abstract_origin
:
5721 case DW_AT_specification
:
5722 case DW_AT_extension
:
5723 part_die
->has_specification
= 1;
5724 part_die
->spec_offset
= dwarf2_get_ref_die_offset (&attr
, cu
);
5727 /* Ignore absolute siblings, they might point outside of
5728 the current compile unit. */
5729 if (attr
.form
== DW_FORM_ref_addr
)
5730 complaint (&symfile_complaints
, _("ignoring absolute DW_AT_sibling"));
5732 part_die
->sibling
= dwarf2_per_objfile
->info_buffer
5733 + dwarf2_get_ref_die_offset (&attr
, cu
);
5735 case DW_AT_stmt_list
:
5736 part_die
->has_stmt_list
= 1;
5737 part_die
->line_offset
= DW_UNSND (&attr
);
5739 case DW_AT_byte_size
:
5740 part_die
->has_byte_size
= 1;
5742 case DW_AT_calling_convention
:
5743 /* DWARF doesn't provide a way to identify a program's source-level
5744 entry point. DW_AT_calling_convention attributes are only meant
5745 to describe functions' calling conventions.
5747 However, because it's a necessary piece of information in
5748 Fortran, and because DW_CC_program is the only piece of debugging
5749 information whose definition refers to a 'main program' at all,
5750 several compilers have begun marking Fortran main programs with
5751 DW_CC_program --- even when those functions use the standard
5752 calling conventions.
5754 So until DWARF specifies a way to provide this information and
5755 compilers pick up the new representation, we'll support this
5757 if (DW_UNSND (&attr
) == DW_CC_program
5758 && cu
->language
== language_fortran
)
5759 set_main_name (part_die
->name
);
5766 /* When using the GNU linker, .gnu.linkonce. sections are used to
5767 eliminate duplicate copies of functions and vtables and such.
5768 The linker will arbitrarily choose one and discard the others.
5769 The AT_*_pc values for such functions refer to local labels in
5770 these sections. If the section from that file was discarded, the
5771 labels are not in the output, so the relocs get a value of 0.
5772 If this is a discarded function, mark the pc bounds as invalid,
5773 so that GDB will ignore it. */
5774 if (has_low_pc_attr
&& has_high_pc_attr
5775 && part_die
->lowpc
< part_die
->highpc
5776 && (part_die
->lowpc
!= 0
5777 || dwarf2_per_objfile
->has_section_at_zero
))
5778 part_die
->has_pc_info
= 1;
5782 /* Find a cached partial DIE at OFFSET in CU. */
5784 static struct partial_die_info
*
5785 find_partial_die_in_comp_unit (unsigned long offset
, struct dwarf2_cu
*cu
)
5787 struct partial_die_info
*lookup_die
= NULL
;
5788 struct partial_die_info part_die
;
5790 part_die
.offset
= offset
;
5791 lookup_die
= htab_find_with_hash (cu
->partial_dies
, &part_die
, offset
);
5796 /* Find a partial DIE at OFFSET, which may or may not be in CU. */
5798 static struct partial_die_info
*
5799 find_partial_die (unsigned long offset
, struct dwarf2_cu
*cu
)
5801 struct dwarf2_per_cu_data
*per_cu
= NULL
;
5802 struct partial_die_info
*pd
= NULL
;
5804 if (offset
>= cu
->header
.offset
5805 && offset
< cu
->header
.offset
+ cu
->header
.length
)
5807 pd
= find_partial_die_in_comp_unit (offset
, cu
);
5812 per_cu
= dwarf2_find_containing_comp_unit (offset
, cu
->objfile
);
5814 if (per_cu
->cu
== NULL
)
5816 load_comp_unit (per_cu
, cu
->objfile
);
5817 per_cu
->cu
->read_in_chain
= dwarf2_per_objfile
->read_in_chain
;
5818 dwarf2_per_objfile
->read_in_chain
= per_cu
;
5821 per_cu
->cu
->last_used
= 0;
5822 pd
= find_partial_die_in_comp_unit (offset
, per_cu
->cu
);
5824 if (pd
== NULL
&& per_cu
->load_all_dies
== 0)
5826 struct cleanup
*back_to
;
5827 struct partial_die_info comp_unit_die
;
5828 struct abbrev_info
*abbrev
;
5829 unsigned int bytes_read
;
5832 per_cu
->load_all_dies
= 1;
5834 /* Re-read the DIEs. */
5835 back_to
= make_cleanup (null_cleanup
, 0);
5836 if (per_cu
->cu
->dwarf2_abbrevs
== NULL
)
5838 dwarf2_read_abbrevs (per_cu
->cu
->objfile
->obfd
, per_cu
->cu
);
5839 back_to
= make_cleanup (dwarf2_free_abbrev_table
, per_cu
->cu
);
5841 info_ptr
= per_cu
->cu
->header
.first_die_ptr
;
5842 abbrev
= peek_die_abbrev (info_ptr
, &bytes_read
, per_cu
->cu
);
5843 info_ptr
= read_partial_die (&comp_unit_die
, abbrev
, bytes_read
,
5844 per_cu
->cu
->objfile
->obfd
, info_ptr
,
5846 if (comp_unit_die
.has_children
)
5847 load_partial_dies (per_cu
->cu
->objfile
->obfd
, info_ptr
, 0, per_cu
->cu
);
5848 do_cleanups (back_to
);
5850 pd
= find_partial_die_in_comp_unit (offset
, per_cu
->cu
);
5854 internal_error (__FILE__
, __LINE__
,
5855 _("could not find partial DIE 0x%lx in cache [from module %s]\n"),
5856 offset
, bfd_get_filename (cu
->objfile
->obfd
));
5860 /* Adjust PART_DIE before generating a symbol for it. This function
5861 may set the is_external flag or change the DIE's name. */
5864 fixup_partial_die (struct partial_die_info
*part_die
,
5865 struct dwarf2_cu
*cu
)
5867 /* If we found a reference attribute and the DIE has no name, try
5868 to find a name in the referred to DIE. */
5870 if (part_die
->name
== NULL
&& part_die
->has_specification
)
5872 struct partial_die_info
*spec_die
;
5874 spec_die
= find_partial_die (part_die
->spec_offset
, cu
);
5876 fixup_partial_die (spec_die
, cu
);
5880 part_die
->name
= spec_die
->name
;
5882 /* Copy DW_AT_external attribute if it is set. */
5883 if (spec_die
->is_external
)
5884 part_die
->is_external
= spec_die
->is_external
;
5888 /* Set default names for some unnamed DIEs. */
5889 if (part_die
->name
== NULL
&& (part_die
->tag
== DW_TAG_structure_type
5890 || part_die
->tag
== DW_TAG_class_type
))
5891 part_die
->name
= "(anonymous class)";
5893 if (part_die
->name
== NULL
&& part_die
->tag
== DW_TAG_namespace
)
5894 part_die
->name
= "(anonymous namespace)";
5896 if (part_die
->tag
== DW_TAG_structure_type
5897 || part_die
->tag
== DW_TAG_class_type
5898 || part_die
->tag
== DW_TAG_union_type
)
5899 guess_structure_name (part_die
, cu
);
5902 /* Read the die from the .debug_info section buffer. Set DIEP to
5903 point to a newly allocated die with its information, except for its
5904 child, sibling, and parent fields. Set HAS_CHILDREN to tell
5905 whether the die has children or not. */
5908 read_full_die (struct die_info
**diep
, bfd
*abfd
, gdb_byte
*info_ptr
,
5909 struct dwarf2_cu
*cu
, int *has_children
)
5911 unsigned int abbrev_number
, bytes_read
, i
, offset
;
5912 struct abbrev_info
*abbrev
;
5913 struct die_info
*die
;
5915 offset
= info_ptr
- dwarf2_per_objfile
->info_buffer
;
5916 abbrev_number
= read_unsigned_leb128 (abfd
, info_ptr
, &bytes_read
);
5917 info_ptr
+= bytes_read
;
5920 die
= dwarf_alloc_die ();
5922 die
->abbrev
= abbrev_number
;
5929 abbrev
= dwarf2_lookup_abbrev (abbrev_number
, cu
);
5932 error (_("Dwarf Error: could not find abbrev number %d [in module %s]"),
5934 bfd_get_filename (abfd
));
5936 die
= dwarf_alloc_die ();
5937 die
->offset
= offset
;
5938 die
->tag
= abbrev
->tag
;
5939 die
->abbrev
= abbrev_number
;
5942 die
->num_attrs
= abbrev
->num_attrs
;
5943 die
->attrs
= (struct attribute
*)
5944 xmalloc (die
->num_attrs
* sizeof (struct attribute
));
5946 for (i
= 0; i
< abbrev
->num_attrs
; ++i
)
5948 info_ptr
= read_attribute (&die
->attrs
[i
], &abbrev
->attrs
[i
],
5949 abfd
, info_ptr
, cu
);
5951 /* If this attribute is an absolute reference to a different
5952 compilation unit, make sure that compilation unit is loaded
5954 if (die
->attrs
[i
].form
== DW_FORM_ref_addr
5955 && (DW_ADDR (&die
->attrs
[i
]) < cu
->header
.offset
5956 || (DW_ADDR (&die
->attrs
[i
])
5957 >= cu
->header
.offset
+ cu
->header
.length
)))
5959 struct dwarf2_per_cu_data
*per_cu
;
5960 per_cu
= dwarf2_find_containing_comp_unit (DW_ADDR (&die
->attrs
[i
]),
5963 /* Mark the dependence relation so that we don't flush PER_CU
5965 dwarf2_add_dependence (cu
, per_cu
);
5967 /* If it's already on the queue, we have nothing to do. */
5971 /* If the compilation unit is already loaded, just mark it as
5973 if (per_cu
->cu
!= NULL
)
5975 per_cu
->cu
->last_used
= 0;
5979 /* Add it to the queue. */
5980 queue_comp_unit (per_cu
);
5985 *has_children
= abbrev
->has_children
;
5989 /* Read an attribute value described by an attribute form. */
5992 read_attribute_value (struct attribute
*attr
, unsigned form
,
5993 bfd
*abfd
, gdb_byte
*info_ptr
,
5994 struct dwarf2_cu
*cu
)
5996 struct comp_unit_head
*cu_header
= &cu
->header
;
5997 unsigned int bytes_read
;
5998 struct dwarf_block
*blk
;
6004 case DW_FORM_ref_addr
:
6005 DW_ADDR (attr
) = read_address (abfd
, info_ptr
, cu
, &bytes_read
);
6006 info_ptr
+= bytes_read
;
6008 case DW_FORM_block2
:
6009 blk
= dwarf_alloc_block (cu
);
6010 blk
->size
= read_2_bytes (abfd
, info_ptr
);
6012 blk
->data
= read_n_bytes (abfd
, info_ptr
, blk
->size
);
6013 info_ptr
+= blk
->size
;
6014 DW_BLOCK (attr
) = blk
;
6016 case DW_FORM_block4
:
6017 blk
= dwarf_alloc_block (cu
);
6018 blk
->size
= read_4_bytes (abfd
, info_ptr
);
6020 blk
->data
= read_n_bytes (abfd
, info_ptr
, blk
->size
);
6021 info_ptr
+= blk
->size
;
6022 DW_BLOCK (attr
) = blk
;
6025 DW_UNSND (attr
) = read_2_bytes (abfd
, info_ptr
);
6029 DW_UNSND (attr
) = read_4_bytes (abfd
, info_ptr
);
6033 DW_UNSND (attr
) = read_8_bytes (abfd
, info_ptr
);
6036 case DW_FORM_string
:
6037 DW_STRING (attr
) = read_string (abfd
, info_ptr
, &bytes_read
);
6038 info_ptr
+= bytes_read
;
6041 DW_STRING (attr
) = read_indirect_string (abfd
, info_ptr
, cu_header
,
6043 info_ptr
+= bytes_read
;
6046 blk
= dwarf_alloc_block (cu
);
6047 blk
->size
= read_unsigned_leb128 (abfd
, info_ptr
, &bytes_read
);
6048 info_ptr
+= bytes_read
;
6049 blk
->data
= read_n_bytes (abfd
, info_ptr
, blk
->size
);
6050 info_ptr
+= blk
->size
;
6051 DW_BLOCK (attr
) = blk
;
6053 case DW_FORM_block1
:
6054 blk
= dwarf_alloc_block (cu
);
6055 blk
->size
= read_1_byte (abfd
, info_ptr
);
6057 blk
->data
= read_n_bytes (abfd
, info_ptr
, blk
->size
);
6058 info_ptr
+= blk
->size
;
6059 DW_BLOCK (attr
) = blk
;
6062 DW_UNSND (attr
) = read_1_byte (abfd
, info_ptr
);
6066 DW_UNSND (attr
) = read_1_byte (abfd
, info_ptr
);
6070 DW_SND (attr
) = read_signed_leb128 (abfd
, info_ptr
, &bytes_read
);
6071 info_ptr
+= bytes_read
;
6074 DW_UNSND (attr
) = read_unsigned_leb128 (abfd
, info_ptr
, &bytes_read
);
6075 info_ptr
+= bytes_read
;
6078 DW_ADDR (attr
) = cu
->header
.offset
+ read_1_byte (abfd
, info_ptr
);
6082 DW_ADDR (attr
) = cu
->header
.offset
+ read_2_bytes (abfd
, info_ptr
);
6086 DW_ADDR (attr
) = cu
->header
.offset
+ read_4_bytes (abfd
, info_ptr
);
6090 DW_ADDR (attr
) = cu
->header
.offset
+ read_8_bytes (abfd
, info_ptr
);
6093 case DW_FORM_ref_udata
:
6094 DW_ADDR (attr
) = (cu
->header
.offset
6095 + read_unsigned_leb128 (abfd
, info_ptr
, &bytes_read
));
6096 info_ptr
+= bytes_read
;
6098 case DW_FORM_indirect
:
6099 form
= read_unsigned_leb128 (abfd
, info_ptr
, &bytes_read
);
6100 info_ptr
+= bytes_read
;
6101 info_ptr
= read_attribute_value (attr
, form
, abfd
, info_ptr
, cu
);
6104 error (_("Dwarf Error: Cannot handle %s in DWARF reader [in module %s]"),
6105 dwarf_form_name (form
),
6106 bfd_get_filename (abfd
));
6111 /* Read an attribute described by an abbreviated attribute. */
6114 read_attribute (struct attribute
*attr
, struct attr_abbrev
*abbrev
,
6115 bfd
*abfd
, gdb_byte
*info_ptr
, struct dwarf2_cu
*cu
)
6117 attr
->name
= abbrev
->name
;
6118 return read_attribute_value (attr
, abbrev
->form
, abfd
, info_ptr
, cu
);
6121 /* read dwarf information from a buffer */
6124 read_1_byte (bfd
*abfd
, gdb_byte
*buf
)
6126 return bfd_get_8 (abfd
, buf
);
6130 read_1_signed_byte (bfd
*abfd
, gdb_byte
*buf
)
6132 return bfd_get_signed_8 (abfd
, buf
);
6136 read_2_bytes (bfd
*abfd
, gdb_byte
*buf
)
6138 return bfd_get_16 (abfd
, buf
);
6142 read_2_signed_bytes (bfd
*abfd
, gdb_byte
*buf
)
6144 return bfd_get_signed_16 (abfd
, buf
);
6148 read_4_bytes (bfd
*abfd
, gdb_byte
*buf
)
6150 return bfd_get_32 (abfd
, buf
);
6154 read_4_signed_bytes (bfd
*abfd
, gdb_byte
*buf
)
6156 return bfd_get_signed_32 (abfd
, buf
);
6159 static unsigned long
6160 read_8_bytes (bfd
*abfd
, gdb_byte
*buf
)
6162 return bfd_get_64 (abfd
, buf
);
6166 read_address (bfd
*abfd
, gdb_byte
*buf
, struct dwarf2_cu
*cu
,
6167 unsigned int *bytes_read
)
6169 struct comp_unit_head
*cu_header
= &cu
->header
;
6170 CORE_ADDR retval
= 0;
6172 if (cu_header
->signed_addr_p
)
6174 switch (cu_header
->addr_size
)
6177 retval
= bfd_get_signed_16 (abfd
, buf
);
6180 retval
= bfd_get_signed_32 (abfd
, buf
);
6183 retval
= bfd_get_signed_64 (abfd
, buf
);
6186 internal_error (__FILE__
, __LINE__
,
6187 _("read_address: bad switch, signed [in module %s]"),
6188 bfd_get_filename (abfd
));
6193 switch (cu_header
->addr_size
)
6196 retval
= bfd_get_16 (abfd
, buf
);
6199 retval
= bfd_get_32 (abfd
, buf
);
6202 retval
= bfd_get_64 (abfd
, buf
);
6205 internal_error (__FILE__
, __LINE__
,
6206 _("read_address: bad switch, unsigned [in module %s]"),
6207 bfd_get_filename (abfd
));
6211 *bytes_read
= cu_header
->addr_size
;
6215 /* Read the initial length from a section. The (draft) DWARF 3
6216 specification allows the initial length to take up either 4 bytes
6217 or 12 bytes. If the first 4 bytes are 0xffffffff, then the next 8
6218 bytes describe the length and all offsets will be 8 bytes in length
6221 An older, non-standard 64-bit format is also handled by this
6222 function. The older format in question stores the initial length
6223 as an 8-byte quantity without an escape value. Lengths greater
6224 than 2^32 aren't very common which means that the initial 4 bytes
6225 is almost always zero. Since a length value of zero doesn't make
6226 sense for the 32-bit format, this initial zero can be considered to
6227 be an escape value which indicates the presence of the older 64-bit
6228 format. As written, the code can't detect (old format) lengths
6229 greater than 4GB. If it becomes necessary to handle lengths
6230 somewhat larger than 4GB, we could allow other small values (such
6231 as the non-sensical values of 1, 2, and 3) to also be used as
6232 escape values indicating the presence of the old format.
6234 The value returned via bytes_read should be used to increment the
6235 relevant pointer after calling read_initial_length().
6237 As a side effect, this function sets the fields initial_length_size
6238 and offset_size in cu_header to the values appropriate for the
6239 length field. (The format of the initial length field determines
6240 the width of file offsets to be fetched later with read_offset().)
6242 [ Note: read_initial_length() and read_offset() are based on the
6243 document entitled "DWARF Debugging Information Format", revision
6244 3, draft 8, dated November 19, 2001. This document was obtained
6247 http://reality.sgiweb.org/davea/dwarf3-draft8-011125.pdf
6249 This document is only a draft and is subject to change. (So beware.)
6251 Details regarding the older, non-standard 64-bit format were
6252 determined empirically by examining 64-bit ELF files produced by
6253 the SGI toolchain on an IRIX 6.5 machine.
6255 - Kevin, July 16, 2002
6259 read_initial_length (bfd
*abfd
, gdb_byte
*buf
, struct comp_unit_head
*cu_header
,
6260 unsigned int *bytes_read
)
6262 LONGEST length
= bfd_get_32 (abfd
, buf
);
6264 if (length
== 0xffffffff)
6266 length
= bfd_get_64 (abfd
, buf
+ 4);
6269 else if (length
== 0)
6271 /* Handle the (non-standard) 64-bit DWARF2 format used by IRIX. */
6272 length
= bfd_get_64 (abfd
, buf
);
6282 gdb_assert (cu_header
->initial_length_size
== 0
6283 || cu_header
->initial_length_size
== 4
6284 || cu_header
->initial_length_size
== 8
6285 || cu_header
->initial_length_size
== 12);
6287 if (cu_header
->initial_length_size
!= 0
6288 && cu_header
->initial_length_size
!= *bytes_read
)
6289 complaint (&symfile_complaints
,
6290 _("intermixed 32-bit and 64-bit DWARF sections"));
6292 cu_header
->initial_length_size
= *bytes_read
;
6293 cu_header
->offset_size
= (*bytes_read
== 4) ? 4 : 8;
6299 /* Read an offset from the data stream. The size of the offset is
6300 given by cu_header->offset_size. */
6303 read_offset (bfd
*abfd
, gdb_byte
*buf
, const struct comp_unit_head
*cu_header
,
6304 unsigned int *bytes_read
)
6308 switch (cu_header
->offset_size
)
6311 retval
= bfd_get_32 (abfd
, buf
);
6315 retval
= bfd_get_64 (abfd
, buf
);
6319 internal_error (__FILE__
, __LINE__
,
6320 _("read_offset: bad switch [in module %s]"),
6321 bfd_get_filename (abfd
));
6328 read_n_bytes (bfd
*abfd
, gdb_byte
*buf
, unsigned int size
)
6330 /* If the size of a host char is 8 bits, we can return a pointer
6331 to the buffer, otherwise we have to copy the data to a buffer
6332 allocated on the temporary obstack. */
6333 gdb_assert (HOST_CHAR_BIT
== 8);
6338 read_string (bfd
*abfd
, gdb_byte
*buf
, unsigned int *bytes_read_ptr
)
6340 /* If the size of a host char is 8 bits, we can return a pointer
6341 to the string, otherwise we have to copy the string to a buffer
6342 allocated on the temporary obstack. */
6343 gdb_assert (HOST_CHAR_BIT
== 8);
6346 *bytes_read_ptr
= 1;
6349 *bytes_read_ptr
= strlen ((char *) buf
) + 1;
6350 return (char *) buf
;
6354 read_indirect_string (bfd
*abfd
, gdb_byte
*buf
,
6355 const struct comp_unit_head
*cu_header
,
6356 unsigned int *bytes_read_ptr
)
6358 LONGEST str_offset
= read_offset (abfd
, buf
, cu_header
,
6361 if (dwarf2_per_objfile
->str_buffer
== NULL
)
6363 error (_("DW_FORM_strp used without .debug_str section [in module %s]"),
6364 bfd_get_filename (abfd
));
6367 if (str_offset
>= dwarf2_per_objfile
->str_size
)
6369 error (_("DW_FORM_strp pointing outside of .debug_str section [in module %s]"),
6370 bfd_get_filename (abfd
));
6373 gdb_assert (HOST_CHAR_BIT
== 8);
6374 if (dwarf2_per_objfile
->str_buffer
[str_offset
] == '\0')
6376 return (char *) (dwarf2_per_objfile
->str_buffer
+ str_offset
);
6379 static unsigned long
6380 read_unsigned_leb128 (bfd
*abfd
, gdb_byte
*buf
, unsigned int *bytes_read_ptr
)
6382 unsigned long result
;
6383 unsigned int num_read
;
6393 byte
= bfd_get_8 (abfd
, buf
);
6396 result
|= ((unsigned long)(byte
& 127) << shift
);
6397 if ((byte
& 128) == 0)
6403 *bytes_read_ptr
= num_read
;
6408 read_signed_leb128 (bfd
*abfd
, gdb_byte
*buf
, unsigned int *bytes_read_ptr
)
6411 int i
, shift
, num_read
;
6420 byte
= bfd_get_8 (abfd
, buf
);
6423 result
|= ((long)(byte
& 127) << shift
);
6425 if ((byte
& 128) == 0)
6430 if ((shift
< 8 * sizeof (result
)) && (byte
& 0x40))
6431 result
|= -(((long)1) << shift
);
6432 *bytes_read_ptr
= num_read
;
6436 /* Return a pointer to just past the end of an LEB128 number in BUF. */
6439 skip_leb128 (bfd
*abfd
, gdb_byte
*buf
)
6445 byte
= bfd_get_8 (abfd
, buf
);
6447 if ((byte
& 128) == 0)
6453 set_cu_language (unsigned int lang
, struct dwarf2_cu
*cu
)
6459 cu
->language
= language_c
;
6461 case DW_LANG_C_plus_plus
:
6462 cu
->language
= language_cplus
;
6464 case DW_LANG_Fortran77
:
6465 case DW_LANG_Fortran90
:
6466 case DW_LANG_Fortran95
:
6467 cu
->language
= language_fortran
;
6469 case DW_LANG_Mips_Assembler
:
6470 cu
->language
= language_asm
;
6473 cu
->language
= language_java
;
6477 cu
->language
= language_ada
;
6479 case DW_LANG_Modula2
:
6480 cu
->language
= language_m2
;
6482 case DW_LANG_Pascal83
:
6483 cu
->language
= language_pascal
;
6485 case DW_LANG_Cobol74
:
6486 case DW_LANG_Cobol85
:
6488 cu
->language
= language_minimal
;
6491 cu
->language_defn
= language_def (cu
->language
);
6494 /* Return the named attribute or NULL if not there. */
6496 static struct attribute
*
6497 dwarf2_attr (struct die_info
*die
, unsigned int name
, struct dwarf2_cu
*cu
)
6500 struct attribute
*spec
= NULL
;
6502 for (i
= 0; i
< die
->num_attrs
; ++i
)
6504 if (die
->attrs
[i
].name
== name
)
6505 return &die
->attrs
[i
];
6506 if (die
->attrs
[i
].name
== DW_AT_specification
6507 || die
->attrs
[i
].name
== DW_AT_abstract_origin
)
6508 spec
= &die
->attrs
[i
];
6512 return dwarf2_attr (follow_die_ref (die
, spec
, cu
), name
, cu
);
6517 /* Return non-zero iff the attribute NAME is defined for the given DIE,
6518 and holds a non-zero value. This function should only be used for
6519 DW_FORM_flag attributes. */
6522 dwarf2_flag_true_p (struct die_info
*die
, unsigned name
, struct dwarf2_cu
*cu
)
6524 struct attribute
*attr
= dwarf2_attr (die
, name
, cu
);
6526 return (attr
&& DW_UNSND (attr
));
6530 die_is_declaration (struct die_info
*die
, struct dwarf2_cu
*cu
)
6532 /* A DIE is a declaration if it has a DW_AT_declaration attribute
6533 which value is non-zero. However, we have to be careful with
6534 DIEs having a DW_AT_specification attribute, because dwarf2_attr()
6535 (via dwarf2_flag_true_p) follows this attribute. So we may
6536 end up accidently finding a declaration attribute that belongs
6537 to a different DIE referenced by the specification attribute,
6538 even though the given DIE does not have a declaration attribute. */
6539 return (dwarf2_flag_true_p (die
, DW_AT_declaration
, cu
)
6540 && dwarf2_attr (die
, DW_AT_specification
, cu
) == NULL
);
6543 /* Return the die giving the specification for DIE, if there is
6546 static struct die_info
*
6547 die_specification (struct die_info
*die
, struct dwarf2_cu
*cu
)
6549 struct attribute
*spec_attr
= dwarf2_attr (die
, DW_AT_specification
, cu
);
6551 if (spec_attr
== NULL
)
6554 return follow_die_ref (die
, spec_attr
, cu
);
6557 /* Free the line_header structure *LH, and any arrays and strings it
6560 free_line_header (struct line_header
*lh
)
6562 if (lh
->standard_opcode_lengths
)
6563 xfree (lh
->standard_opcode_lengths
);
6565 /* Remember that all the lh->file_names[i].name pointers are
6566 pointers into debug_line_buffer, and don't need to be freed. */
6568 xfree (lh
->file_names
);
6570 /* Similarly for the include directory names. */
6571 if (lh
->include_dirs
)
6572 xfree (lh
->include_dirs
);
6578 /* Add an entry to LH's include directory table. */
6580 add_include_dir (struct line_header
*lh
, char *include_dir
)
6582 /* Grow the array if necessary. */
6583 if (lh
->include_dirs_size
== 0)
6585 lh
->include_dirs_size
= 1; /* for testing */
6586 lh
->include_dirs
= xmalloc (lh
->include_dirs_size
6587 * sizeof (*lh
->include_dirs
));
6589 else if (lh
->num_include_dirs
>= lh
->include_dirs_size
)
6591 lh
->include_dirs_size
*= 2;
6592 lh
->include_dirs
= xrealloc (lh
->include_dirs
,
6593 (lh
->include_dirs_size
6594 * sizeof (*lh
->include_dirs
)));
6597 lh
->include_dirs
[lh
->num_include_dirs
++] = include_dir
;
6601 /* Add an entry to LH's file name table. */
6603 add_file_name (struct line_header
*lh
,
6605 unsigned int dir_index
,
6606 unsigned int mod_time
,
6607 unsigned int length
)
6609 struct file_entry
*fe
;
6611 /* Grow the array if necessary. */
6612 if (lh
->file_names_size
== 0)
6614 lh
->file_names_size
= 1; /* for testing */
6615 lh
->file_names
= xmalloc (lh
->file_names_size
6616 * sizeof (*lh
->file_names
));
6618 else if (lh
->num_file_names
>= lh
->file_names_size
)
6620 lh
->file_names_size
*= 2;
6621 lh
->file_names
= xrealloc (lh
->file_names
,
6622 (lh
->file_names_size
6623 * sizeof (*lh
->file_names
)));
6626 fe
= &lh
->file_names
[lh
->num_file_names
++];
6628 fe
->dir_index
= dir_index
;
6629 fe
->mod_time
= mod_time
;
6630 fe
->length
= length
;
6636 /* Read the statement program header starting at OFFSET in
6637 .debug_line, according to the endianness of ABFD. Return a pointer
6638 to a struct line_header, allocated using xmalloc.
6640 NOTE: the strings in the include directory and file name tables of
6641 the returned object point into debug_line_buffer, and must not be
6643 static struct line_header
*
6644 dwarf_decode_line_header (unsigned int offset
, bfd
*abfd
,
6645 struct dwarf2_cu
*cu
)
6647 struct cleanup
*back_to
;
6648 struct line_header
*lh
;
6650 unsigned int bytes_read
;
6652 char *cur_dir
, *cur_file
;
6654 if (dwarf2_per_objfile
->line_buffer
== NULL
)
6656 complaint (&symfile_complaints
, _("missing .debug_line section"));
6660 /* Make sure that at least there's room for the total_length field.
6661 That could be 12 bytes long, but we're just going to fudge that. */
6662 if (offset
+ 4 >= dwarf2_per_objfile
->line_size
)
6664 dwarf2_statement_list_fits_in_line_number_section_complaint ();
6668 lh
= xmalloc (sizeof (*lh
));
6669 memset (lh
, 0, sizeof (*lh
));
6670 back_to
= make_cleanup ((make_cleanup_ftype
*) free_line_header
,
6673 line_ptr
= dwarf2_per_objfile
->line_buffer
+ offset
;
6675 /* Read in the header. */
6677 read_initial_length (abfd
, line_ptr
, &cu
->header
, &bytes_read
);
6678 line_ptr
+= bytes_read
;
6679 if (line_ptr
+ lh
->total_length
> (dwarf2_per_objfile
->line_buffer
6680 + dwarf2_per_objfile
->line_size
))
6682 dwarf2_statement_list_fits_in_line_number_section_complaint ();
6685 lh
->statement_program_end
= line_ptr
+ lh
->total_length
;
6686 lh
->version
= read_2_bytes (abfd
, line_ptr
);
6688 lh
->header_length
= read_offset (abfd
, line_ptr
, &cu
->header
, &bytes_read
);
6689 line_ptr
+= bytes_read
;
6690 lh
->minimum_instruction_length
= read_1_byte (abfd
, line_ptr
);
6692 lh
->default_is_stmt
= read_1_byte (abfd
, line_ptr
);
6694 lh
->line_base
= read_1_signed_byte (abfd
, line_ptr
);
6696 lh
->line_range
= read_1_byte (abfd
, line_ptr
);
6698 lh
->opcode_base
= read_1_byte (abfd
, line_ptr
);
6700 lh
->standard_opcode_lengths
6701 = xmalloc (lh
->opcode_base
* sizeof (lh
->standard_opcode_lengths
[0]));
6703 lh
->standard_opcode_lengths
[0] = 1; /* This should never be used anyway. */
6704 for (i
= 1; i
< lh
->opcode_base
; ++i
)
6706 lh
->standard_opcode_lengths
[i
] = read_1_byte (abfd
, line_ptr
);
6710 /* Read directory table. */
6711 while ((cur_dir
= read_string (abfd
, line_ptr
, &bytes_read
)) != NULL
)
6713 line_ptr
+= bytes_read
;
6714 add_include_dir (lh
, cur_dir
);
6716 line_ptr
+= bytes_read
;
6718 /* Read file name table. */
6719 while ((cur_file
= read_string (abfd
, line_ptr
, &bytes_read
)) != NULL
)
6721 unsigned int dir_index
, mod_time
, length
;
6723 line_ptr
+= bytes_read
;
6724 dir_index
= read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
6725 line_ptr
+= bytes_read
;
6726 mod_time
= read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
6727 line_ptr
+= bytes_read
;
6728 length
= read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
6729 line_ptr
+= bytes_read
;
6731 add_file_name (lh
, cur_file
, dir_index
, mod_time
, length
);
6733 line_ptr
+= bytes_read
;
6734 lh
->statement_program_start
= line_ptr
;
6736 if (line_ptr
> (dwarf2_per_objfile
->line_buffer
6737 + dwarf2_per_objfile
->line_size
))
6738 complaint (&symfile_complaints
,
6739 _("line number info header doesn't fit in `.debug_line' section"));
6741 discard_cleanups (back_to
);
6745 /* This function exists to work around a bug in certain compilers
6746 (particularly GCC 2.95), in which the first line number marker of a
6747 function does not show up until after the prologue, right before
6748 the second line number marker. This function shifts ADDRESS down
6749 to the beginning of the function if necessary, and is called on
6750 addresses passed to record_line. */
6753 check_cu_functions (CORE_ADDR address
, struct dwarf2_cu
*cu
)
6755 struct function_range
*fn
;
6757 /* Find the function_range containing address. */
6762 cu
->cached_fn
= cu
->first_fn
;
6766 if (fn
->lowpc
<= address
&& fn
->highpc
> address
)
6772 while (fn
&& fn
!= cu
->cached_fn
)
6773 if (fn
->lowpc
<= address
&& fn
->highpc
> address
)
6783 if (address
!= fn
->lowpc
)
6784 complaint (&symfile_complaints
,
6785 _("misplaced first line number at 0x%lx for '%s'"),
6786 (unsigned long) address
, fn
->name
);
6791 /* Decode the Line Number Program (LNP) for the given line_header
6792 structure and CU. The actual information extracted and the type
6793 of structures created from the LNP depends on the value of PST.
6795 1. If PST is NULL, then this procedure uses the data from the program
6796 to create all necessary symbol tables, and their linetables.
6797 The compilation directory of the file is passed in COMP_DIR,
6798 and must not be NULL.
6800 2. If PST is not NULL, this procedure reads the program to determine
6801 the list of files included by the unit represented by PST, and
6802 builds all the associated partial symbol tables. In this case,
6803 the value of COMP_DIR is ignored, and can thus be NULL (the COMP_DIR
6804 is not used to compute the full name of the symtab, and therefore
6805 omitting it when building the partial symtab does not introduce
6806 the potential for inconsistency - a partial symtab and its associated
6807 symbtab having a different fullname -). */
6810 dwarf_decode_lines (struct line_header
*lh
, char *comp_dir
, bfd
*abfd
,
6811 struct dwarf2_cu
*cu
, struct partial_symtab
*pst
)
6813 gdb_byte
*line_ptr
, *extended_end
;
6815 unsigned int bytes_read
, extended_len
;
6816 unsigned char op_code
, extended_op
, adj_opcode
;
6818 struct objfile
*objfile
= cu
->objfile
;
6819 const int decode_for_pst_p
= (pst
!= NULL
);
6820 struct subfile
*last_subfile
= NULL
, *first_subfile
= current_subfile
;
6822 baseaddr
= ANOFFSET (objfile
->section_offsets
, SECT_OFF_TEXT (objfile
));
6824 line_ptr
= lh
->statement_program_start
;
6825 line_end
= lh
->statement_program_end
;
6827 /* Read the statement sequences until there's nothing left. */
6828 while (line_ptr
< line_end
)
6830 /* state machine registers */
6831 CORE_ADDR address
= 0;
6832 unsigned int file
= 1;
6833 unsigned int line
= 1;
6834 unsigned int column
= 0;
6835 int is_stmt
= lh
->default_is_stmt
;
6836 int basic_block
= 0;
6837 int end_sequence
= 0;
6839 if (!decode_for_pst_p
&& lh
->num_file_names
>= file
)
6841 /* Start a subfile for the current file of the state machine. */
6842 /* lh->include_dirs and lh->file_names are 0-based, but the
6843 directory and file name numbers in the statement program
6845 struct file_entry
*fe
= &lh
->file_names
[file
- 1];
6849 dir
= lh
->include_dirs
[fe
->dir_index
- 1];
6851 dwarf2_start_subfile (fe
->name
, dir
, comp_dir
);
6854 /* Decode the table. */
6855 while (!end_sequence
)
6857 op_code
= read_1_byte (abfd
, line_ptr
);
6860 if (op_code
>= lh
->opcode_base
)
6862 /* Special operand. */
6863 adj_opcode
= op_code
- lh
->opcode_base
;
6864 address
+= (adj_opcode
/ lh
->line_range
)
6865 * lh
->minimum_instruction_length
;
6866 line
+= lh
->line_base
+ (adj_opcode
% lh
->line_range
);
6867 if (lh
->num_file_names
< file
)
6868 dwarf2_debug_line_missing_file_complaint ();
6871 lh
->file_names
[file
- 1].included_p
= 1;
6872 if (!decode_for_pst_p
)
6874 if (last_subfile
!= current_subfile
)
6877 record_line (last_subfile
, 0, address
);
6878 last_subfile
= current_subfile
;
6880 /* Append row to matrix using current values. */
6881 record_line (current_subfile
, line
,
6882 check_cu_functions (address
, cu
));
6887 else switch (op_code
)
6889 case DW_LNS_extended_op
:
6890 extended_len
= read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
6891 line_ptr
+= bytes_read
;
6892 extended_end
= line_ptr
+ extended_len
;
6893 extended_op
= read_1_byte (abfd
, line_ptr
);
6895 switch (extended_op
)
6897 case DW_LNE_end_sequence
:
6900 if (lh
->num_file_names
< file
)
6901 dwarf2_debug_line_missing_file_complaint ();
6904 lh
->file_names
[file
- 1].included_p
= 1;
6905 if (!decode_for_pst_p
)
6906 record_line (current_subfile
, 0, address
);
6909 case DW_LNE_set_address
:
6910 address
= read_address (abfd
, line_ptr
, cu
, &bytes_read
);
6911 line_ptr
+= bytes_read
;
6912 address
+= baseaddr
;
6914 case DW_LNE_define_file
:
6917 unsigned int dir_index
, mod_time
, length
;
6919 cur_file
= read_string (abfd
, line_ptr
, &bytes_read
);
6920 line_ptr
+= bytes_read
;
6922 read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
6923 line_ptr
+= bytes_read
;
6925 read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
6926 line_ptr
+= bytes_read
;
6928 read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
6929 line_ptr
+= bytes_read
;
6930 add_file_name (lh
, cur_file
, dir_index
, mod_time
, length
);
6934 complaint (&symfile_complaints
,
6935 _("mangled .debug_line section"));
6938 /* Make sure that we parsed the extended op correctly. If e.g.
6939 we expected a different address size than the producer used,
6940 we may have read the wrong number of bytes. */
6941 if (line_ptr
!= extended_end
)
6943 complaint (&symfile_complaints
,
6944 _("mangled .debug_line section"));
6949 if (lh
->num_file_names
< file
)
6950 dwarf2_debug_line_missing_file_complaint ();
6953 lh
->file_names
[file
- 1].included_p
= 1;
6954 if (!decode_for_pst_p
)
6956 if (last_subfile
!= current_subfile
)
6959 record_line (last_subfile
, 0, address
);
6960 last_subfile
= current_subfile
;
6962 record_line (current_subfile
, line
,
6963 check_cu_functions (address
, cu
));
6968 case DW_LNS_advance_pc
:
6969 address
+= lh
->minimum_instruction_length
6970 * read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
6971 line_ptr
+= bytes_read
;
6973 case DW_LNS_advance_line
:
6974 line
+= read_signed_leb128 (abfd
, line_ptr
, &bytes_read
);
6975 line_ptr
+= bytes_read
;
6977 case DW_LNS_set_file
:
6979 /* The arrays lh->include_dirs and lh->file_names are
6980 0-based, but the directory and file name numbers in
6981 the statement program are 1-based. */
6982 struct file_entry
*fe
;
6985 file
= read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
6986 line_ptr
+= bytes_read
;
6987 if (lh
->num_file_names
< file
)
6988 dwarf2_debug_line_missing_file_complaint ();
6991 fe
= &lh
->file_names
[file
- 1];
6993 dir
= lh
->include_dirs
[fe
->dir_index
- 1];
6994 if (!decode_for_pst_p
)
6996 last_subfile
= current_subfile
;
6997 dwarf2_start_subfile (fe
->name
, dir
, comp_dir
);
7002 case DW_LNS_set_column
:
7003 column
= read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
7004 line_ptr
+= bytes_read
;
7006 case DW_LNS_negate_stmt
:
7007 is_stmt
= (!is_stmt
);
7009 case DW_LNS_set_basic_block
:
7012 /* Add to the address register of the state machine the
7013 address increment value corresponding to special opcode
7014 255. I.e., this value is scaled by the minimum
7015 instruction length since special opcode 255 would have
7016 scaled the the increment. */
7017 case DW_LNS_const_add_pc
:
7018 address
+= (lh
->minimum_instruction_length
7019 * ((255 - lh
->opcode_base
) / lh
->line_range
));
7021 case DW_LNS_fixed_advance_pc
:
7022 address
+= read_2_bytes (abfd
, line_ptr
);
7027 /* Unknown standard opcode, ignore it. */
7030 for (i
= 0; i
< lh
->standard_opcode_lengths
[op_code
]; i
++)
7032 (void) read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
7033 line_ptr
+= bytes_read
;
7040 if (decode_for_pst_p
)
7044 /* Now that we're done scanning the Line Header Program, we can
7045 create the psymtab of each included file. */
7046 for (file_index
= 0; file_index
< lh
->num_file_names
; file_index
++)
7047 if (lh
->file_names
[file_index
].included_p
== 1)
7049 const struct file_entry fe
= lh
->file_names
[file_index
];
7050 char *include_name
= fe
.name
;
7051 char *dir_name
= NULL
;
7052 char *pst_filename
= pst
->filename
;
7055 dir_name
= lh
->include_dirs
[fe
.dir_index
- 1];
7057 if (!IS_ABSOLUTE_PATH (include_name
) && dir_name
!= NULL
)
7059 include_name
= concat (dir_name
, SLASH_STRING
,
7060 include_name
, (char *)NULL
);
7061 make_cleanup (xfree
, include_name
);
7064 if (!IS_ABSOLUTE_PATH (pst_filename
) && pst
->dirname
!= NULL
)
7066 pst_filename
= concat (pst
->dirname
, SLASH_STRING
,
7067 pst_filename
, (char *)NULL
);
7068 make_cleanup (xfree
, pst_filename
);
7071 if (strcmp (include_name
, pst_filename
) != 0)
7072 dwarf2_create_include_psymtab (include_name
, pst
, objfile
);
7077 /* Make sure a symtab is created for every file, even files
7078 which contain only variables (i.e. no code with associated
7082 struct file_entry
*fe
;
7084 for (i
= 0; i
< lh
->num_file_names
; i
++)
7087 fe
= &lh
->file_names
[i
];
7089 dir
= lh
->include_dirs
[fe
->dir_index
- 1];
7090 dwarf2_start_subfile (fe
->name
, dir
, comp_dir
);
7092 /* Skip the main file; we don't need it, and it must be
7093 allocated last, so that it will show up before the
7094 non-primary symtabs in the objfile's symtab list. */
7095 if (current_subfile
== first_subfile
)
7098 if (current_subfile
->symtab
== NULL
)
7099 current_subfile
->symtab
= allocate_symtab (current_subfile
->name
,
7101 fe
->symtab
= current_subfile
->symtab
;
7106 /* Start a subfile for DWARF. FILENAME is the name of the file and
7107 DIRNAME the name of the source directory which contains FILENAME
7108 or NULL if not known. COMP_DIR is the compilation directory for the
7109 linetable's compilation unit or NULL if not known.
7110 This routine tries to keep line numbers from identical absolute and
7111 relative file names in a common subfile.
7113 Using the `list' example from the GDB testsuite, which resides in
7114 /srcdir and compiling it with Irix6.2 cc in /compdir using a filename
7115 of /srcdir/list0.c yields the following debugging information for list0.c:
7117 DW_AT_name: /srcdir/list0.c
7118 DW_AT_comp_dir: /compdir
7119 files.files[0].name: list0.h
7120 files.files[0].dir: /srcdir
7121 files.files[1].name: list0.c
7122 files.files[1].dir: /srcdir
7124 The line number information for list0.c has to end up in a single
7125 subfile, so that `break /srcdir/list0.c:1' works as expected.
7126 start_subfile will ensure that this happens provided that we pass the
7127 concatenation of files.files[1].dir and files.files[1].name as the
7131 dwarf2_start_subfile (char *filename
, char *dirname
, char *comp_dir
)
7135 /* While reading the DIEs, we call start_symtab(DW_AT_name, DW_AT_comp_dir).
7136 `start_symtab' will always pass the contents of DW_AT_comp_dir as
7137 second argument to start_subfile. To be consistent, we do the
7138 same here. In order not to lose the line information directory,
7139 we concatenate it to the filename when it makes sense.
7140 Note that the Dwarf3 standard says (speaking of filenames in line
7141 information): ``The directory index is ignored for file names
7142 that represent full path names''. Thus ignoring dirname in the
7143 `else' branch below isn't an issue. */
7145 if (!IS_ABSOLUTE_PATH (filename
) && dirname
!= NULL
)
7146 fullname
= concat (dirname
, SLASH_STRING
, filename
, (char *)NULL
);
7148 fullname
= filename
;
7150 start_subfile (fullname
, comp_dir
);
7152 if (fullname
!= filename
)
7157 var_decode_location (struct attribute
*attr
, struct symbol
*sym
,
7158 struct dwarf2_cu
*cu
)
7160 struct objfile
*objfile
= cu
->objfile
;
7161 struct comp_unit_head
*cu_header
= &cu
->header
;
7163 /* NOTE drow/2003-01-30: There used to be a comment and some special
7164 code here to turn a symbol with DW_AT_external and a
7165 SYMBOL_VALUE_ADDRESS of 0 into a LOC_UNRESOLVED symbol. This was
7166 necessary for platforms (maybe Alpha, certainly PowerPC GNU/Linux
7167 with some versions of binutils) where shared libraries could have
7168 relocations against symbols in their debug information - the
7169 minimal symbol would have the right address, but the debug info
7170 would not. It's no longer necessary, because we will explicitly
7171 apply relocations when we read in the debug information now. */
7173 /* A DW_AT_location attribute with no contents indicates that a
7174 variable has been optimized away. */
7175 if (attr_form_is_block (attr
) && DW_BLOCK (attr
)->size
== 0)
7177 SYMBOL_CLASS (sym
) = LOC_OPTIMIZED_OUT
;
7181 /* Handle one degenerate form of location expression specially, to
7182 preserve GDB's previous behavior when section offsets are
7183 specified. If this is just a DW_OP_addr then mark this symbol
7186 if (attr_form_is_block (attr
)
7187 && DW_BLOCK (attr
)->size
== 1 + cu_header
->addr_size
7188 && DW_BLOCK (attr
)->data
[0] == DW_OP_addr
)
7192 SYMBOL_VALUE_ADDRESS (sym
) =
7193 read_address (objfile
->obfd
, DW_BLOCK (attr
)->data
+ 1, cu
, &dummy
);
7194 fixup_symbol_section (sym
, objfile
);
7195 SYMBOL_VALUE_ADDRESS (sym
) += ANOFFSET (objfile
->section_offsets
,
7196 SYMBOL_SECTION (sym
));
7197 SYMBOL_CLASS (sym
) = LOC_STATIC
;
7201 /* NOTE drow/2002-01-30: It might be worthwhile to have a static
7202 expression evaluator, and use LOC_COMPUTED only when necessary
7203 (i.e. when the value of a register or memory location is
7204 referenced, or a thread-local block, etc.). Then again, it might
7205 not be worthwhile. I'm assuming that it isn't unless performance
7206 or memory numbers show me otherwise. */
7208 dwarf2_symbol_mark_computed (attr
, sym
, cu
);
7209 SYMBOL_CLASS (sym
) = LOC_COMPUTED
;
7212 /* Given a pointer to a DWARF information entry, figure out if we need
7213 to make a symbol table entry for it, and if so, create a new entry
7214 and return a pointer to it.
7215 If TYPE is NULL, determine symbol type from the die, otherwise
7216 used the passed type. */
7218 static struct symbol
*
7219 new_symbol (struct die_info
*die
, struct type
*type
, struct dwarf2_cu
*cu
)
7221 struct objfile
*objfile
= cu
->objfile
;
7222 struct symbol
*sym
= NULL
;
7224 struct attribute
*attr
= NULL
;
7225 struct attribute
*attr2
= NULL
;
7228 baseaddr
= ANOFFSET (objfile
->section_offsets
, SECT_OFF_TEXT (objfile
));
7230 if (die
->tag
!= DW_TAG_namespace
)
7231 name
= dwarf2_linkage_name (die
, cu
);
7233 name
= TYPE_NAME (type
);
7237 sym
= (struct symbol
*) obstack_alloc (&objfile
->objfile_obstack
,
7238 sizeof (struct symbol
));
7239 OBJSTAT (objfile
, n_syms
++);
7240 memset (sym
, 0, sizeof (struct symbol
));
7242 /* Cache this symbol's name and the name's demangled form (if any). */
7243 SYMBOL_LANGUAGE (sym
) = cu
->language
;
7244 SYMBOL_SET_NAMES (sym
, name
, strlen (name
), objfile
);
7246 /* Default assumptions.
7247 Use the passed type or decode it from the die. */
7248 SYMBOL_DOMAIN (sym
) = VAR_DOMAIN
;
7249 SYMBOL_CLASS (sym
) = LOC_OPTIMIZED_OUT
;
7251 SYMBOL_TYPE (sym
) = type
;
7253 SYMBOL_TYPE (sym
) = die_type (die
, cu
);
7254 attr
= dwarf2_attr (die
, DW_AT_decl_line
, cu
);
7257 SYMBOL_LINE (sym
) = DW_UNSND (attr
);
7260 attr
= dwarf2_attr (die
, DW_AT_decl_file
, cu
);
7263 int file_index
= DW_UNSND (attr
);
7264 if (cu
->line_header
== NULL
7265 || file_index
> cu
->line_header
->num_file_names
)
7266 complaint (&symfile_complaints
,
7267 _("file index out of range"));
7268 else if (file_index
> 0)
7270 struct file_entry
*fe
;
7271 fe
= &cu
->line_header
->file_names
[file_index
- 1];
7272 SYMBOL_SYMTAB (sym
) = fe
->symtab
;
7279 attr
= dwarf2_attr (die
, DW_AT_low_pc
, cu
);
7282 SYMBOL_VALUE_ADDRESS (sym
) = DW_ADDR (attr
) + baseaddr
;
7284 SYMBOL_CLASS (sym
) = LOC_LABEL
;
7286 case DW_TAG_subprogram
:
7287 /* SYMBOL_BLOCK_VALUE (sym) will be filled in later by
7289 SYMBOL_CLASS (sym
) = LOC_BLOCK
;
7290 attr2
= dwarf2_attr (die
, DW_AT_external
, cu
);
7291 if (attr2
&& (DW_UNSND (attr2
) != 0))
7293 add_symbol_to_list (sym
, &global_symbols
);
7297 add_symbol_to_list (sym
, cu
->list_in_scope
);
7300 case DW_TAG_variable
:
7301 /* Compilation with minimal debug info may result in variables
7302 with missing type entries. Change the misleading `void' type
7303 to something sensible. */
7304 if (TYPE_CODE (SYMBOL_TYPE (sym
)) == TYPE_CODE_VOID
)
7306 = builtin_type (current_gdbarch
)->nodebug_data_symbol
;
7308 attr
= dwarf2_attr (die
, DW_AT_const_value
, cu
);
7311 dwarf2_const_value (attr
, sym
, cu
);
7312 attr2
= dwarf2_attr (die
, DW_AT_external
, cu
);
7313 if (attr2
&& (DW_UNSND (attr2
) != 0))
7314 add_symbol_to_list (sym
, &global_symbols
);
7316 add_symbol_to_list (sym
, cu
->list_in_scope
);
7319 attr
= dwarf2_attr (die
, DW_AT_location
, cu
);
7322 var_decode_location (attr
, sym
, cu
);
7323 attr2
= dwarf2_attr (die
, DW_AT_external
, cu
);
7324 if (attr2
&& (DW_UNSND (attr2
) != 0))
7325 add_symbol_to_list (sym
, &global_symbols
);
7327 add_symbol_to_list (sym
, cu
->list_in_scope
);
7331 /* We do not know the address of this symbol.
7332 If it is an external symbol and we have type information
7333 for it, enter the symbol as a LOC_UNRESOLVED symbol.
7334 The address of the variable will then be determined from
7335 the minimal symbol table whenever the variable is
7337 attr2
= dwarf2_attr (die
, DW_AT_external
, cu
);
7338 if (attr2
&& (DW_UNSND (attr2
) != 0)
7339 && dwarf2_attr (die
, DW_AT_type
, cu
) != NULL
)
7341 SYMBOL_CLASS (sym
) = LOC_UNRESOLVED
;
7342 add_symbol_to_list (sym
, &global_symbols
);
7346 case DW_TAG_formal_parameter
:
7347 attr
= dwarf2_attr (die
, DW_AT_location
, cu
);
7350 var_decode_location (attr
, sym
, cu
);
7351 /* FIXME drow/2003-07-31: Is LOC_COMPUTED_ARG necessary? */
7352 if (SYMBOL_CLASS (sym
) == LOC_COMPUTED
)
7353 SYMBOL_CLASS (sym
) = LOC_COMPUTED_ARG
;
7355 attr
= dwarf2_attr (die
, DW_AT_const_value
, cu
);
7358 dwarf2_const_value (attr
, sym
, cu
);
7360 add_symbol_to_list (sym
, cu
->list_in_scope
);
7362 case DW_TAG_unspecified_parameters
:
7363 /* From varargs functions; gdb doesn't seem to have any
7364 interest in this information, so just ignore it for now.
7367 case DW_TAG_class_type
:
7368 case DW_TAG_interface_type
:
7369 case DW_TAG_structure_type
:
7370 case DW_TAG_union_type
:
7371 case DW_TAG_set_type
:
7372 case DW_TAG_enumeration_type
:
7373 SYMBOL_CLASS (sym
) = LOC_TYPEDEF
;
7374 SYMBOL_DOMAIN (sym
) = STRUCT_DOMAIN
;
7376 /* Make sure that the symbol includes appropriate enclosing
7377 classes/namespaces in its name. These are calculated in
7378 read_structure_type, and the correct name is saved in
7381 if (cu
->language
== language_cplus
7382 || cu
->language
== language_java
)
7384 struct type
*type
= SYMBOL_TYPE (sym
);
7386 if (TYPE_TAG_NAME (type
) != NULL
)
7388 /* FIXME: carlton/2003-11-10: Should this use
7389 SYMBOL_SET_NAMES instead? (The same problem also
7390 arises further down in this function.) */
7391 /* The type's name is already allocated along with
7392 this objfile, so we don't need to duplicate it
7394 SYMBOL_LINKAGE_NAME (sym
) = TYPE_TAG_NAME (type
);
7399 /* NOTE: carlton/2003-11-10: C++ and Java class symbols shouldn't
7400 really ever be static objects: otherwise, if you try
7401 to, say, break of a class's method and you're in a file
7402 which doesn't mention that class, it won't work unless
7403 the check for all static symbols in lookup_symbol_aux
7404 saves you. See the OtherFileClass tests in
7405 gdb.c++/namespace.exp. */
7407 struct pending
**list_to_add
;
7409 list_to_add
= (cu
->list_in_scope
== &file_symbols
7410 && (cu
->language
== language_cplus
7411 || cu
->language
== language_java
)
7412 ? &global_symbols
: cu
->list_in_scope
);
7414 add_symbol_to_list (sym
, list_to_add
);
7416 /* The semantics of C++ state that "struct foo { ... }" also
7417 defines a typedef for "foo". A Java class declaration also
7418 defines a typedef for the class. Synthesize a typedef symbol
7419 so that "ptype foo" works as expected. */
7420 if (cu
->language
== language_cplus
7421 || cu
->language
== language_java
7422 || cu
->language
== language_ada
)
7424 struct symbol
*typedef_sym
= (struct symbol
*)
7425 obstack_alloc (&objfile
->objfile_obstack
,
7426 sizeof (struct symbol
));
7427 *typedef_sym
= *sym
;
7428 SYMBOL_DOMAIN (typedef_sym
) = VAR_DOMAIN
;
7429 /* The symbol's name is already allocated along with
7430 this objfile, so we don't need to duplicate it for
7432 if (TYPE_NAME (SYMBOL_TYPE (sym
)) == 0)
7433 TYPE_NAME (SYMBOL_TYPE (sym
)) = SYMBOL_SEARCH_NAME (sym
);
7434 add_symbol_to_list (typedef_sym
, list_to_add
);
7438 case DW_TAG_typedef
:
7439 if (processing_has_namespace_info
7440 && processing_current_prefix
[0] != '\0')
7442 SYMBOL_LINKAGE_NAME (sym
) = typename_concat (&objfile
->objfile_obstack
,
7443 processing_current_prefix
,
7446 SYMBOL_CLASS (sym
) = LOC_TYPEDEF
;
7447 SYMBOL_DOMAIN (sym
) = VAR_DOMAIN
;
7448 add_symbol_to_list (sym
, cu
->list_in_scope
);
7450 case DW_TAG_base_type
:
7451 case DW_TAG_subrange_type
:
7452 SYMBOL_CLASS (sym
) = LOC_TYPEDEF
;
7453 SYMBOL_DOMAIN (sym
) = VAR_DOMAIN
;
7454 add_symbol_to_list (sym
, cu
->list_in_scope
);
7456 case DW_TAG_enumerator
:
7457 if (processing_has_namespace_info
7458 && processing_current_prefix
[0] != '\0')
7460 SYMBOL_LINKAGE_NAME (sym
) = typename_concat (&objfile
->objfile_obstack
,
7461 processing_current_prefix
,
7464 attr
= dwarf2_attr (die
, DW_AT_const_value
, cu
);
7467 dwarf2_const_value (attr
, sym
, cu
);
7470 /* NOTE: carlton/2003-11-10: See comment above in the
7471 DW_TAG_class_type, etc. block. */
7473 struct pending
**list_to_add
;
7475 list_to_add
= (cu
->list_in_scope
== &file_symbols
7476 && (cu
->language
== language_cplus
7477 || cu
->language
== language_java
)
7478 ? &global_symbols
: cu
->list_in_scope
);
7480 add_symbol_to_list (sym
, list_to_add
);
7483 case DW_TAG_namespace
:
7484 SYMBOL_CLASS (sym
) = LOC_TYPEDEF
;
7485 add_symbol_to_list (sym
, &global_symbols
);
7488 /* Not a tag we recognize. Hopefully we aren't processing
7489 trash data, but since we must specifically ignore things
7490 we don't recognize, there is nothing else we should do at
7492 complaint (&symfile_complaints
, _("unsupported tag: '%s'"),
7493 dwarf_tag_name (die
->tag
));
7500 /* Copy constant value from an attribute to a symbol. */
7503 dwarf2_const_value (struct attribute
*attr
, struct symbol
*sym
,
7504 struct dwarf2_cu
*cu
)
7506 struct objfile
*objfile
= cu
->objfile
;
7507 struct comp_unit_head
*cu_header
= &cu
->header
;
7508 struct dwarf_block
*blk
;
7513 if (TYPE_LENGTH (SYMBOL_TYPE (sym
)) != cu_header
->addr_size
)
7514 dwarf2_const_value_length_mismatch_complaint (DEPRECATED_SYMBOL_NAME (sym
),
7515 cu_header
->addr_size
,
7516 TYPE_LENGTH (SYMBOL_TYPE
7518 SYMBOL_VALUE_BYTES (sym
) =
7519 obstack_alloc (&objfile
->objfile_obstack
, cu_header
->addr_size
);
7520 /* NOTE: cagney/2003-05-09: In-lined store_address call with
7521 it's body - store_unsigned_integer. */
7522 store_unsigned_integer (SYMBOL_VALUE_BYTES (sym
), cu_header
->addr_size
,
7524 SYMBOL_CLASS (sym
) = LOC_CONST_BYTES
;
7526 case DW_FORM_block1
:
7527 case DW_FORM_block2
:
7528 case DW_FORM_block4
:
7530 blk
= DW_BLOCK (attr
);
7531 if (TYPE_LENGTH (SYMBOL_TYPE (sym
)) != blk
->size
)
7532 dwarf2_const_value_length_mismatch_complaint (DEPRECATED_SYMBOL_NAME (sym
),
7534 TYPE_LENGTH (SYMBOL_TYPE
7536 SYMBOL_VALUE_BYTES (sym
) =
7537 obstack_alloc (&objfile
->objfile_obstack
, blk
->size
);
7538 memcpy (SYMBOL_VALUE_BYTES (sym
), blk
->data
, blk
->size
);
7539 SYMBOL_CLASS (sym
) = LOC_CONST_BYTES
;
7542 /* The DW_AT_const_value attributes are supposed to carry the
7543 symbol's value "represented as it would be on the target
7544 architecture." By the time we get here, it's already been
7545 converted to host endianness, so we just need to sign- or
7546 zero-extend it as appropriate. */
7548 dwarf2_const_value_data (attr
, sym
, 8);
7551 dwarf2_const_value_data (attr
, sym
, 16);
7554 dwarf2_const_value_data (attr
, sym
, 32);
7557 dwarf2_const_value_data (attr
, sym
, 64);
7561 SYMBOL_VALUE (sym
) = DW_SND (attr
);
7562 SYMBOL_CLASS (sym
) = LOC_CONST
;
7566 SYMBOL_VALUE (sym
) = DW_UNSND (attr
);
7567 SYMBOL_CLASS (sym
) = LOC_CONST
;
7571 complaint (&symfile_complaints
,
7572 _("unsupported const value attribute form: '%s'"),
7573 dwarf_form_name (attr
->form
));
7574 SYMBOL_VALUE (sym
) = 0;
7575 SYMBOL_CLASS (sym
) = LOC_CONST
;
7581 /* Given an attr with a DW_FORM_dataN value in host byte order, sign-
7582 or zero-extend it as appropriate for the symbol's type. */
7584 dwarf2_const_value_data (struct attribute
*attr
,
7588 LONGEST l
= DW_UNSND (attr
);
7590 if (bits
< sizeof (l
) * 8)
7592 if (TYPE_UNSIGNED (SYMBOL_TYPE (sym
)))
7593 l
&= ((LONGEST
) 1 << bits
) - 1;
7595 l
= (l
<< (sizeof (l
) * 8 - bits
)) >> (sizeof (l
) * 8 - bits
);
7598 SYMBOL_VALUE (sym
) = l
;
7599 SYMBOL_CLASS (sym
) = LOC_CONST
;
7603 /* Return the type of the die in question using its DW_AT_type attribute. */
7605 static struct type
*
7606 die_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
7609 struct attribute
*type_attr
;
7610 struct die_info
*type_die
;
7612 type_attr
= dwarf2_attr (die
, DW_AT_type
, cu
);
7615 /* A missing DW_AT_type represents a void type. */
7616 return builtin_type (current_gdbarch
)->builtin_void
;
7619 type_die
= follow_die_ref (die
, type_attr
, cu
);
7621 type
= tag_type_to_type (type_die
, cu
);
7624 dump_die (type_die
);
7625 error (_("Dwarf Error: Problem turning type die at offset into gdb type [in module %s]"),
7631 /* Return the containing type of the die in question using its
7632 DW_AT_containing_type attribute. */
7634 static struct type
*
7635 die_containing_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
7637 struct type
*type
= NULL
;
7638 struct attribute
*type_attr
;
7639 struct die_info
*type_die
= NULL
;
7641 type_attr
= dwarf2_attr (die
, DW_AT_containing_type
, cu
);
7644 type_die
= follow_die_ref (die
, type_attr
, cu
);
7645 type
= tag_type_to_type (type_die
, cu
);
7650 dump_die (type_die
);
7651 error (_("Dwarf Error: Problem turning containing type into gdb type [in module %s]"),
7657 static struct type
*
7658 tag_type_to_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
7666 read_type_die (die
, cu
);
7670 error (_("Dwarf Error: Cannot find type of die [in module %s]"),
7678 read_type_die (struct die_info
*die
, struct dwarf2_cu
*cu
)
7680 char *prefix
= determine_prefix (die
, cu
);
7681 const char *old_prefix
= processing_current_prefix
;
7682 struct cleanup
*back_to
= make_cleanup (xfree
, prefix
);
7683 processing_current_prefix
= prefix
;
7687 case DW_TAG_class_type
:
7688 case DW_TAG_interface_type
:
7689 case DW_TAG_structure_type
:
7690 case DW_TAG_union_type
:
7691 read_structure_type (die
, cu
);
7693 case DW_TAG_enumeration_type
:
7694 read_enumeration_type (die
, cu
);
7696 case DW_TAG_subprogram
:
7697 case DW_TAG_subroutine_type
:
7698 read_subroutine_type (die
, cu
);
7700 case DW_TAG_array_type
:
7701 read_array_type (die
, cu
);
7703 case DW_TAG_set_type
:
7704 read_set_type (die
, cu
);
7706 case DW_TAG_pointer_type
:
7707 read_tag_pointer_type (die
, cu
);
7709 case DW_TAG_ptr_to_member_type
:
7710 read_tag_ptr_to_member_type (die
, cu
);
7712 case DW_TAG_reference_type
:
7713 read_tag_reference_type (die
, cu
);
7715 case DW_TAG_const_type
:
7716 read_tag_const_type (die
, cu
);
7718 case DW_TAG_volatile_type
:
7719 read_tag_volatile_type (die
, cu
);
7721 case DW_TAG_string_type
:
7722 read_tag_string_type (die
, cu
);
7724 case DW_TAG_typedef
:
7725 read_typedef (die
, cu
);
7727 case DW_TAG_subrange_type
:
7728 read_subrange_type (die
, cu
);
7730 case DW_TAG_base_type
:
7731 read_base_type (die
, cu
);
7733 case DW_TAG_unspecified_type
:
7734 read_unspecified_type (die
, cu
);
7737 complaint (&symfile_complaints
, _("unexpected tag in read_type_die: '%s'"),
7738 dwarf_tag_name (die
->tag
));
7742 processing_current_prefix
= old_prefix
;
7743 do_cleanups (back_to
);
7746 /* Return the name of the namespace/class that DIE is defined within,
7747 or "" if we can't tell. The caller should xfree the result. */
7749 /* NOTE: carlton/2004-01-23: See read_func_scope (and the comment
7750 therein) for an example of how to use this function to deal with
7751 DW_AT_specification. */
7754 determine_prefix (struct die_info
*die
, struct dwarf2_cu
*cu
)
7756 struct die_info
*parent
;
7758 if (cu
->language
!= language_cplus
7759 && cu
->language
!= language_java
)
7762 parent
= die
->parent
;
7766 return xstrdup ("");
7770 switch (parent
->tag
) {
7771 case DW_TAG_namespace
:
7773 /* FIXME: carlton/2004-03-05: Should I follow extension dies
7774 before doing this check? */
7775 if (parent
->type
!= NULL
&& TYPE_TAG_NAME (parent
->type
) != NULL
)
7777 return xstrdup (TYPE_TAG_NAME (parent
->type
));
7782 char *parent_prefix
= determine_prefix (parent
, cu
);
7783 char *retval
= typename_concat (NULL
, parent_prefix
,
7784 namespace_name (parent
, &dummy
,
7787 xfree (parent_prefix
);
7792 case DW_TAG_class_type
:
7793 case DW_TAG_interface_type
:
7794 case DW_TAG_structure_type
:
7796 if (parent
->type
!= NULL
&& TYPE_TAG_NAME (parent
->type
) != NULL
)
7798 return xstrdup (TYPE_TAG_NAME (parent
->type
));
7802 const char *old_prefix
= processing_current_prefix
;
7803 char *new_prefix
= determine_prefix (parent
, cu
);
7806 processing_current_prefix
= new_prefix
;
7807 retval
= determine_class_name (parent
, cu
);
7808 processing_current_prefix
= old_prefix
;
7815 return determine_prefix (parent
, cu
);
7820 /* Return a newly-allocated string formed by concatenating PREFIX and
7821 SUFFIX with appropriate separator. If PREFIX or SUFFIX is NULL or empty, then
7822 simply copy the SUFFIX or PREFIX, respectively. If OBS is non-null,
7823 perform an obconcat, otherwise allocate storage for the result. The CU argument
7824 is used to determine the language and hence, the appropriate separator. */
7826 #define MAX_SEP_LEN 2 /* sizeof ("::") */
7829 typename_concat (struct obstack
*obs
, const char *prefix
, const char *suffix
,
7830 struct dwarf2_cu
*cu
)
7834 if (suffix
== NULL
|| suffix
[0] == '\0' || prefix
== NULL
|| prefix
[0] == '\0')
7836 else if (cu
->language
== language_java
)
7843 char *retval
= xmalloc (strlen (prefix
) + MAX_SEP_LEN
+ strlen (suffix
) + 1);
7848 strcpy (retval
, prefix
);
7849 strcat (retval
, sep
);
7852 strcat (retval
, suffix
);
7858 /* We have an obstack. */
7859 return obconcat (obs
, prefix
, sep
, suffix
);
7865 copy_die (struct die_info
*old_die
)
7867 struct die_info
*new_die
;
7870 new_die
= (struct die_info
*) xmalloc (sizeof (struct die_info
));
7871 memset (new_die
, 0, sizeof (struct die_info
));
7873 new_die
->tag
= old_die
->tag
;
7874 new_die
->has_children
= old_die
->has_children
;
7875 new_die
->abbrev
= old_die
->abbrev
;
7876 new_die
->offset
= old_die
->offset
;
7877 new_die
->type
= NULL
;
7879 num_attrs
= old_die
->num_attrs
;
7880 new_die
->num_attrs
= num_attrs
;
7881 new_die
->attrs
= (struct attribute
*)
7882 xmalloc (num_attrs
* sizeof (struct attribute
));
7884 for (i
= 0; i
< old_die
->num_attrs
; ++i
)
7886 new_die
->attrs
[i
].name
= old_die
->attrs
[i
].name
;
7887 new_die
->attrs
[i
].form
= old_die
->attrs
[i
].form
;
7888 new_die
->attrs
[i
].u
.addr
= old_die
->attrs
[i
].u
.addr
;
7891 new_die
->next
= NULL
;
7896 /* Return sibling of die, NULL if no sibling. */
7898 static struct die_info
*
7899 sibling_die (struct die_info
*die
)
7901 return die
->sibling
;
7904 /* Get linkage name of a die, return NULL if not found. */
7907 dwarf2_linkage_name (struct die_info
*die
, struct dwarf2_cu
*cu
)
7909 struct attribute
*attr
;
7911 attr
= dwarf2_attr (die
, DW_AT_MIPS_linkage_name
, cu
);
7912 if (attr
&& DW_STRING (attr
))
7913 return DW_STRING (attr
);
7914 attr
= dwarf2_attr (die
, DW_AT_name
, cu
);
7915 if (attr
&& DW_STRING (attr
))
7916 return DW_STRING (attr
);
7920 /* Get name of a die, return NULL if not found. */
7923 dwarf2_name (struct die_info
*die
, struct dwarf2_cu
*cu
)
7925 struct attribute
*attr
;
7927 attr
= dwarf2_attr (die
, DW_AT_name
, cu
);
7928 if (attr
&& DW_STRING (attr
))
7929 return DW_STRING (attr
);
7933 /* Return the die that this die in an extension of, or NULL if there
7936 static struct die_info
*
7937 dwarf2_extension (struct die_info
*die
, struct dwarf2_cu
*cu
)
7939 struct attribute
*attr
;
7941 attr
= dwarf2_attr (die
, DW_AT_extension
, cu
);
7945 return follow_die_ref (die
, attr
, cu
);
7948 /* Convert a DIE tag into its string name. */
7951 dwarf_tag_name (unsigned tag
)
7955 case DW_TAG_padding
:
7956 return "DW_TAG_padding";
7957 case DW_TAG_array_type
:
7958 return "DW_TAG_array_type";
7959 case DW_TAG_class_type
:
7960 return "DW_TAG_class_type";
7961 case DW_TAG_entry_point
:
7962 return "DW_TAG_entry_point";
7963 case DW_TAG_enumeration_type
:
7964 return "DW_TAG_enumeration_type";
7965 case DW_TAG_formal_parameter
:
7966 return "DW_TAG_formal_parameter";
7967 case DW_TAG_imported_declaration
:
7968 return "DW_TAG_imported_declaration";
7970 return "DW_TAG_label";
7971 case DW_TAG_lexical_block
:
7972 return "DW_TAG_lexical_block";
7974 return "DW_TAG_member";
7975 case DW_TAG_pointer_type
:
7976 return "DW_TAG_pointer_type";
7977 case DW_TAG_reference_type
:
7978 return "DW_TAG_reference_type";
7979 case DW_TAG_compile_unit
:
7980 return "DW_TAG_compile_unit";
7981 case DW_TAG_string_type
:
7982 return "DW_TAG_string_type";
7983 case DW_TAG_structure_type
:
7984 return "DW_TAG_structure_type";
7985 case DW_TAG_subroutine_type
:
7986 return "DW_TAG_subroutine_type";
7987 case DW_TAG_typedef
:
7988 return "DW_TAG_typedef";
7989 case DW_TAG_union_type
:
7990 return "DW_TAG_union_type";
7991 case DW_TAG_unspecified_parameters
:
7992 return "DW_TAG_unspecified_parameters";
7993 case DW_TAG_variant
:
7994 return "DW_TAG_variant";
7995 case DW_TAG_common_block
:
7996 return "DW_TAG_common_block";
7997 case DW_TAG_common_inclusion
:
7998 return "DW_TAG_common_inclusion";
7999 case DW_TAG_inheritance
:
8000 return "DW_TAG_inheritance";
8001 case DW_TAG_inlined_subroutine
:
8002 return "DW_TAG_inlined_subroutine";
8004 return "DW_TAG_module";
8005 case DW_TAG_ptr_to_member_type
:
8006 return "DW_TAG_ptr_to_member_type";
8007 case DW_TAG_set_type
:
8008 return "DW_TAG_set_type";
8009 case DW_TAG_subrange_type
:
8010 return "DW_TAG_subrange_type";
8011 case DW_TAG_with_stmt
:
8012 return "DW_TAG_with_stmt";
8013 case DW_TAG_access_declaration
:
8014 return "DW_TAG_access_declaration";
8015 case DW_TAG_base_type
:
8016 return "DW_TAG_base_type";
8017 case DW_TAG_catch_block
:
8018 return "DW_TAG_catch_block";
8019 case DW_TAG_const_type
:
8020 return "DW_TAG_const_type";
8021 case DW_TAG_constant
:
8022 return "DW_TAG_constant";
8023 case DW_TAG_enumerator
:
8024 return "DW_TAG_enumerator";
8025 case DW_TAG_file_type
:
8026 return "DW_TAG_file_type";
8028 return "DW_TAG_friend";
8029 case DW_TAG_namelist
:
8030 return "DW_TAG_namelist";
8031 case DW_TAG_namelist_item
:
8032 return "DW_TAG_namelist_item";
8033 case DW_TAG_packed_type
:
8034 return "DW_TAG_packed_type";
8035 case DW_TAG_subprogram
:
8036 return "DW_TAG_subprogram";
8037 case DW_TAG_template_type_param
:
8038 return "DW_TAG_template_type_param";
8039 case DW_TAG_template_value_param
:
8040 return "DW_TAG_template_value_param";
8041 case DW_TAG_thrown_type
:
8042 return "DW_TAG_thrown_type";
8043 case DW_TAG_try_block
:
8044 return "DW_TAG_try_block";
8045 case DW_TAG_variant_part
:
8046 return "DW_TAG_variant_part";
8047 case DW_TAG_variable
:
8048 return "DW_TAG_variable";
8049 case DW_TAG_volatile_type
:
8050 return "DW_TAG_volatile_type";
8051 case DW_TAG_dwarf_procedure
:
8052 return "DW_TAG_dwarf_procedure";
8053 case DW_TAG_restrict_type
:
8054 return "DW_TAG_restrict_type";
8055 case DW_TAG_interface_type
:
8056 return "DW_TAG_interface_type";
8057 case DW_TAG_namespace
:
8058 return "DW_TAG_namespace";
8059 case DW_TAG_imported_module
:
8060 return "DW_TAG_imported_module";
8061 case DW_TAG_unspecified_type
:
8062 return "DW_TAG_unspecified_type";
8063 case DW_TAG_partial_unit
:
8064 return "DW_TAG_partial_unit";
8065 case DW_TAG_imported_unit
:
8066 return "DW_TAG_imported_unit";
8067 case DW_TAG_condition
:
8068 return "DW_TAG_condition";
8069 case DW_TAG_shared_type
:
8070 return "DW_TAG_shared_type";
8071 case DW_TAG_MIPS_loop
:
8072 return "DW_TAG_MIPS_loop";
8073 case DW_TAG_HP_array_descriptor
:
8074 return "DW_TAG_HP_array_descriptor";
8075 case DW_TAG_format_label
:
8076 return "DW_TAG_format_label";
8077 case DW_TAG_function_template
:
8078 return "DW_TAG_function_template";
8079 case DW_TAG_class_template
:
8080 return "DW_TAG_class_template";
8081 case DW_TAG_GNU_BINCL
:
8082 return "DW_TAG_GNU_BINCL";
8083 case DW_TAG_GNU_EINCL
:
8084 return "DW_TAG_GNU_EINCL";
8085 case DW_TAG_upc_shared_type
:
8086 return "DW_TAG_upc_shared_type";
8087 case DW_TAG_upc_strict_type
:
8088 return "DW_TAG_upc_strict_type";
8089 case DW_TAG_upc_relaxed_type
:
8090 return "DW_TAG_upc_relaxed_type";
8091 case DW_TAG_PGI_kanji_type
:
8092 return "DW_TAG_PGI_kanji_type";
8093 case DW_TAG_PGI_interface_block
:
8094 return "DW_TAG_PGI_interface_block";
8096 return "DW_TAG_<unknown>";
8100 /* Convert a DWARF attribute code into its string name. */
8103 dwarf_attr_name (unsigned attr
)
8108 return "DW_AT_sibling";
8109 case DW_AT_location
:
8110 return "DW_AT_location";
8112 return "DW_AT_name";
8113 case DW_AT_ordering
:
8114 return "DW_AT_ordering";
8115 case DW_AT_subscr_data
:
8116 return "DW_AT_subscr_data";
8117 case DW_AT_byte_size
:
8118 return "DW_AT_byte_size";
8119 case DW_AT_bit_offset
:
8120 return "DW_AT_bit_offset";
8121 case DW_AT_bit_size
:
8122 return "DW_AT_bit_size";
8123 case DW_AT_element_list
:
8124 return "DW_AT_element_list";
8125 case DW_AT_stmt_list
:
8126 return "DW_AT_stmt_list";
8128 return "DW_AT_low_pc";
8130 return "DW_AT_high_pc";
8131 case DW_AT_language
:
8132 return "DW_AT_language";
8134 return "DW_AT_member";
8136 return "DW_AT_discr";
8137 case DW_AT_discr_value
:
8138 return "DW_AT_discr_value";
8139 case DW_AT_visibility
:
8140 return "DW_AT_visibility";
8142 return "DW_AT_import";
8143 case DW_AT_string_length
:
8144 return "DW_AT_string_length";
8145 case DW_AT_common_reference
:
8146 return "DW_AT_common_reference";
8147 case DW_AT_comp_dir
:
8148 return "DW_AT_comp_dir";
8149 case DW_AT_const_value
:
8150 return "DW_AT_const_value";
8151 case DW_AT_containing_type
:
8152 return "DW_AT_containing_type";
8153 case DW_AT_default_value
:
8154 return "DW_AT_default_value";
8156 return "DW_AT_inline";
8157 case DW_AT_is_optional
:
8158 return "DW_AT_is_optional";
8159 case DW_AT_lower_bound
:
8160 return "DW_AT_lower_bound";
8161 case DW_AT_producer
:
8162 return "DW_AT_producer";
8163 case DW_AT_prototyped
:
8164 return "DW_AT_prototyped";
8165 case DW_AT_return_addr
:
8166 return "DW_AT_return_addr";
8167 case DW_AT_start_scope
:
8168 return "DW_AT_start_scope";
8169 case DW_AT_bit_stride
:
8170 return "DW_AT_bit_stride";
8171 case DW_AT_upper_bound
:
8172 return "DW_AT_upper_bound";
8173 case DW_AT_abstract_origin
:
8174 return "DW_AT_abstract_origin";
8175 case DW_AT_accessibility
:
8176 return "DW_AT_accessibility";
8177 case DW_AT_address_class
:
8178 return "DW_AT_address_class";
8179 case DW_AT_artificial
:
8180 return "DW_AT_artificial";
8181 case DW_AT_base_types
:
8182 return "DW_AT_base_types";
8183 case DW_AT_calling_convention
:
8184 return "DW_AT_calling_convention";
8186 return "DW_AT_count";
8187 case DW_AT_data_member_location
:
8188 return "DW_AT_data_member_location";
8189 case DW_AT_decl_column
:
8190 return "DW_AT_decl_column";
8191 case DW_AT_decl_file
:
8192 return "DW_AT_decl_file";
8193 case DW_AT_decl_line
:
8194 return "DW_AT_decl_line";
8195 case DW_AT_declaration
:
8196 return "DW_AT_declaration";
8197 case DW_AT_discr_list
:
8198 return "DW_AT_discr_list";
8199 case DW_AT_encoding
:
8200 return "DW_AT_encoding";
8201 case DW_AT_external
:
8202 return "DW_AT_external";
8203 case DW_AT_frame_base
:
8204 return "DW_AT_frame_base";
8206 return "DW_AT_friend";
8207 case DW_AT_identifier_case
:
8208 return "DW_AT_identifier_case";
8209 case DW_AT_macro_info
:
8210 return "DW_AT_macro_info";
8211 case DW_AT_namelist_items
:
8212 return "DW_AT_namelist_items";
8213 case DW_AT_priority
:
8214 return "DW_AT_priority";
8216 return "DW_AT_segment";
8217 case DW_AT_specification
:
8218 return "DW_AT_specification";
8219 case DW_AT_static_link
:
8220 return "DW_AT_static_link";
8222 return "DW_AT_type";
8223 case DW_AT_use_location
:
8224 return "DW_AT_use_location";
8225 case DW_AT_variable_parameter
:
8226 return "DW_AT_variable_parameter";
8227 case DW_AT_virtuality
:
8228 return "DW_AT_virtuality";
8229 case DW_AT_vtable_elem_location
:
8230 return "DW_AT_vtable_elem_location";
8231 /* DWARF 3 values. */
8232 case DW_AT_allocated
:
8233 return "DW_AT_allocated";
8234 case DW_AT_associated
:
8235 return "DW_AT_associated";
8236 case DW_AT_data_location
:
8237 return "DW_AT_data_location";
8238 case DW_AT_byte_stride
:
8239 return "DW_AT_byte_stride";
8240 case DW_AT_entry_pc
:
8241 return "DW_AT_entry_pc";
8242 case DW_AT_use_UTF8
:
8243 return "DW_AT_use_UTF8";
8244 case DW_AT_extension
:
8245 return "DW_AT_extension";
8247 return "DW_AT_ranges";
8248 case DW_AT_trampoline
:
8249 return "DW_AT_trampoline";
8250 case DW_AT_call_column
:
8251 return "DW_AT_call_column";
8252 case DW_AT_call_file
:
8253 return "DW_AT_call_file";
8254 case DW_AT_call_line
:
8255 return "DW_AT_call_line";
8256 case DW_AT_description
:
8257 return "DW_AT_description";
8258 case DW_AT_binary_scale
:
8259 return "DW_AT_binary_scale";
8260 case DW_AT_decimal_scale
:
8261 return "DW_AT_decimal_scale";
8263 return "DW_AT_small";
8264 case DW_AT_decimal_sign
:
8265 return "DW_AT_decimal_sign";
8266 case DW_AT_digit_count
:
8267 return "DW_AT_digit_count";
8268 case DW_AT_picture_string
:
8269 return "DW_AT_picture_string";
8271 return "DW_AT_mutable";
8272 case DW_AT_threads_scaled
:
8273 return "DW_AT_threads_scaled";
8274 case DW_AT_explicit
:
8275 return "DW_AT_explicit";
8276 case DW_AT_object_pointer
:
8277 return "DW_AT_object_pointer";
8278 case DW_AT_endianity
:
8279 return "DW_AT_endianity";
8280 case DW_AT_elemental
:
8281 return "DW_AT_elemental";
8283 return "DW_AT_pure";
8284 case DW_AT_recursive
:
8285 return "DW_AT_recursive";
8287 /* SGI/MIPS extensions. */
8288 case DW_AT_MIPS_fde
:
8289 return "DW_AT_MIPS_fde";
8290 case DW_AT_MIPS_loop_begin
:
8291 return "DW_AT_MIPS_loop_begin";
8292 case DW_AT_MIPS_tail_loop_begin
:
8293 return "DW_AT_MIPS_tail_loop_begin";
8294 case DW_AT_MIPS_epilog_begin
:
8295 return "DW_AT_MIPS_epilog_begin";
8296 case DW_AT_MIPS_loop_unroll_factor
:
8297 return "DW_AT_MIPS_loop_unroll_factor";
8298 case DW_AT_MIPS_software_pipeline_depth
:
8299 return "DW_AT_MIPS_software_pipeline_depth";
8300 case DW_AT_MIPS_linkage_name
:
8301 return "DW_AT_MIPS_linkage_name";
8302 case DW_AT_MIPS_stride
:
8303 return "DW_AT_MIPS_stride";
8304 case DW_AT_MIPS_abstract_name
:
8305 return "DW_AT_MIPS_abstract_name";
8306 case DW_AT_MIPS_clone_origin
:
8307 return "DW_AT_MIPS_clone_origin";
8308 case DW_AT_MIPS_has_inlines
:
8309 return "DW_AT_MIPS_has_inlines";
8311 /* HP extensions. */
8312 case DW_AT_HP_block_index
:
8313 return "DW_AT_HP_block_index";
8314 case DW_AT_HP_unmodifiable
:
8315 return "DW_AT_HP_unmodifiable";
8316 case DW_AT_HP_actuals_stmt_list
:
8317 return "DW_AT_HP_actuals_stmt_list";
8318 case DW_AT_HP_proc_per_section
:
8319 return "DW_AT_HP_proc_per_section";
8320 case DW_AT_HP_raw_data_ptr
:
8321 return "DW_AT_HP_raw_data_ptr";
8322 case DW_AT_HP_pass_by_reference
:
8323 return "DW_AT_HP_pass_by_reference";
8324 case DW_AT_HP_opt_level
:
8325 return "DW_AT_HP_opt_level";
8326 case DW_AT_HP_prof_version_id
:
8327 return "DW_AT_HP_prof_version_id";
8328 case DW_AT_HP_opt_flags
:
8329 return "DW_AT_HP_opt_flags";
8330 case DW_AT_HP_cold_region_low_pc
:
8331 return "DW_AT_HP_cold_region_low_pc";
8332 case DW_AT_HP_cold_region_high_pc
:
8333 return "DW_AT_HP_cold_region_high_pc";
8334 case DW_AT_HP_all_variables_modifiable
:
8335 return "DW_AT_HP_all_variables_modifiable";
8336 case DW_AT_HP_linkage_name
:
8337 return "DW_AT_HP_linkage_name";
8338 case DW_AT_HP_prof_flags
:
8339 return "DW_AT_HP_prof_flags";
8340 /* GNU extensions. */
8341 case DW_AT_sf_names
:
8342 return "DW_AT_sf_names";
8343 case DW_AT_src_info
:
8344 return "DW_AT_src_info";
8345 case DW_AT_mac_info
:
8346 return "DW_AT_mac_info";
8347 case DW_AT_src_coords
:
8348 return "DW_AT_src_coords";
8349 case DW_AT_body_begin
:
8350 return "DW_AT_body_begin";
8351 case DW_AT_body_end
:
8352 return "DW_AT_body_end";
8353 case DW_AT_GNU_vector
:
8354 return "DW_AT_GNU_vector";
8355 /* VMS extensions. */
8356 case DW_AT_VMS_rtnbeg_pd_address
:
8357 return "DW_AT_VMS_rtnbeg_pd_address";
8358 /* UPC extension. */
8359 case DW_AT_upc_threads_scaled
:
8360 return "DW_AT_upc_threads_scaled";
8361 /* PGI (STMicroelectronics) extensions. */
8362 case DW_AT_PGI_lbase
:
8363 return "DW_AT_PGI_lbase";
8364 case DW_AT_PGI_soffset
:
8365 return "DW_AT_PGI_soffset";
8366 case DW_AT_PGI_lstride
:
8367 return "DW_AT_PGI_lstride";
8369 return "DW_AT_<unknown>";
8373 /* Convert a DWARF value form code into its string name. */
8376 dwarf_form_name (unsigned form
)
8381 return "DW_FORM_addr";
8382 case DW_FORM_block2
:
8383 return "DW_FORM_block2";
8384 case DW_FORM_block4
:
8385 return "DW_FORM_block4";
8387 return "DW_FORM_data2";
8389 return "DW_FORM_data4";
8391 return "DW_FORM_data8";
8392 case DW_FORM_string
:
8393 return "DW_FORM_string";
8395 return "DW_FORM_block";
8396 case DW_FORM_block1
:
8397 return "DW_FORM_block1";
8399 return "DW_FORM_data1";
8401 return "DW_FORM_flag";
8403 return "DW_FORM_sdata";
8405 return "DW_FORM_strp";
8407 return "DW_FORM_udata";
8408 case DW_FORM_ref_addr
:
8409 return "DW_FORM_ref_addr";
8411 return "DW_FORM_ref1";
8413 return "DW_FORM_ref2";
8415 return "DW_FORM_ref4";
8417 return "DW_FORM_ref8";
8418 case DW_FORM_ref_udata
:
8419 return "DW_FORM_ref_udata";
8420 case DW_FORM_indirect
:
8421 return "DW_FORM_indirect";
8423 return "DW_FORM_<unknown>";
8427 /* Convert a DWARF stack opcode into its string name. */
8430 dwarf_stack_op_name (unsigned op
)
8435 return "DW_OP_addr";
8437 return "DW_OP_deref";
8439 return "DW_OP_const1u";
8441 return "DW_OP_const1s";
8443 return "DW_OP_const2u";
8445 return "DW_OP_const2s";
8447 return "DW_OP_const4u";
8449 return "DW_OP_const4s";
8451 return "DW_OP_const8u";
8453 return "DW_OP_const8s";
8455 return "DW_OP_constu";
8457 return "DW_OP_consts";
8461 return "DW_OP_drop";
8463 return "DW_OP_over";
8465 return "DW_OP_pick";
8467 return "DW_OP_swap";
8471 return "DW_OP_xderef";
8479 return "DW_OP_minus";
8491 return "DW_OP_plus";
8492 case DW_OP_plus_uconst
:
8493 return "DW_OP_plus_uconst";
8499 return "DW_OP_shra";
8517 return "DW_OP_skip";
8519 return "DW_OP_lit0";
8521 return "DW_OP_lit1";
8523 return "DW_OP_lit2";
8525 return "DW_OP_lit3";
8527 return "DW_OP_lit4";
8529 return "DW_OP_lit5";
8531 return "DW_OP_lit6";
8533 return "DW_OP_lit7";
8535 return "DW_OP_lit8";
8537 return "DW_OP_lit9";
8539 return "DW_OP_lit10";
8541 return "DW_OP_lit11";
8543 return "DW_OP_lit12";
8545 return "DW_OP_lit13";
8547 return "DW_OP_lit14";
8549 return "DW_OP_lit15";
8551 return "DW_OP_lit16";
8553 return "DW_OP_lit17";
8555 return "DW_OP_lit18";
8557 return "DW_OP_lit19";
8559 return "DW_OP_lit20";
8561 return "DW_OP_lit21";
8563 return "DW_OP_lit22";
8565 return "DW_OP_lit23";
8567 return "DW_OP_lit24";
8569 return "DW_OP_lit25";
8571 return "DW_OP_lit26";
8573 return "DW_OP_lit27";
8575 return "DW_OP_lit28";
8577 return "DW_OP_lit29";
8579 return "DW_OP_lit30";
8581 return "DW_OP_lit31";
8583 return "DW_OP_reg0";
8585 return "DW_OP_reg1";
8587 return "DW_OP_reg2";
8589 return "DW_OP_reg3";
8591 return "DW_OP_reg4";
8593 return "DW_OP_reg5";
8595 return "DW_OP_reg6";
8597 return "DW_OP_reg7";
8599 return "DW_OP_reg8";
8601 return "DW_OP_reg9";
8603 return "DW_OP_reg10";
8605 return "DW_OP_reg11";
8607 return "DW_OP_reg12";
8609 return "DW_OP_reg13";
8611 return "DW_OP_reg14";
8613 return "DW_OP_reg15";
8615 return "DW_OP_reg16";
8617 return "DW_OP_reg17";
8619 return "DW_OP_reg18";
8621 return "DW_OP_reg19";
8623 return "DW_OP_reg20";
8625 return "DW_OP_reg21";
8627 return "DW_OP_reg22";
8629 return "DW_OP_reg23";
8631 return "DW_OP_reg24";
8633 return "DW_OP_reg25";
8635 return "DW_OP_reg26";
8637 return "DW_OP_reg27";
8639 return "DW_OP_reg28";
8641 return "DW_OP_reg29";
8643 return "DW_OP_reg30";
8645 return "DW_OP_reg31";
8647 return "DW_OP_breg0";
8649 return "DW_OP_breg1";
8651 return "DW_OP_breg2";
8653 return "DW_OP_breg3";
8655 return "DW_OP_breg4";
8657 return "DW_OP_breg5";
8659 return "DW_OP_breg6";
8661 return "DW_OP_breg7";
8663 return "DW_OP_breg8";
8665 return "DW_OP_breg9";
8667 return "DW_OP_breg10";
8669 return "DW_OP_breg11";
8671 return "DW_OP_breg12";
8673 return "DW_OP_breg13";
8675 return "DW_OP_breg14";
8677 return "DW_OP_breg15";
8679 return "DW_OP_breg16";
8681 return "DW_OP_breg17";
8683 return "DW_OP_breg18";
8685 return "DW_OP_breg19";
8687 return "DW_OP_breg20";
8689 return "DW_OP_breg21";
8691 return "DW_OP_breg22";
8693 return "DW_OP_breg23";
8695 return "DW_OP_breg24";
8697 return "DW_OP_breg25";
8699 return "DW_OP_breg26";
8701 return "DW_OP_breg27";
8703 return "DW_OP_breg28";
8705 return "DW_OP_breg29";
8707 return "DW_OP_breg30";
8709 return "DW_OP_breg31";
8711 return "DW_OP_regx";
8713 return "DW_OP_fbreg";
8715 return "DW_OP_bregx";
8717 return "DW_OP_piece";
8718 case DW_OP_deref_size
:
8719 return "DW_OP_deref_size";
8720 case DW_OP_xderef_size
:
8721 return "DW_OP_xderef_size";
8724 /* DWARF 3 extensions. */
8725 case DW_OP_push_object_address
:
8726 return "DW_OP_push_object_address";
8728 return "DW_OP_call2";
8730 return "DW_OP_call4";
8731 case DW_OP_call_ref
:
8732 return "DW_OP_call_ref";
8733 /* GNU extensions. */
8734 case DW_OP_form_tls_address
:
8735 return "DW_OP_form_tls_address";
8736 case DW_OP_call_frame_cfa
:
8737 return "DW_OP_call_frame_cfa";
8738 case DW_OP_bit_piece
:
8739 return "DW_OP_bit_piece";
8740 case DW_OP_GNU_push_tls_address
:
8741 return "DW_OP_GNU_push_tls_address";
8742 case DW_OP_GNU_uninit
:
8743 return "DW_OP_GNU_uninit";
8744 /* HP extensions. */
8745 case DW_OP_HP_is_value
:
8746 return "DW_OP_HP_is_value";
8747 case DW_OP_HP_fltconst4
:
8748 return "DW_OP_HP_fltconst4";
8749 case DW_OP_HP_fltconst8
:
8750 return "DW_OP_HP_fltconst8";
8751 case DW_OP_HP_mod_range
:
8752 return "DW_OP_HP_mod_range";
8753 case DW_OP_HP_unmod_range
:
8754 return "DW_OP_HP_unmod_range";
8756 return "DW_OP_HP_tls";
8758 return "OP_<unknown>";
8763 dwarf_bool_name (unsigned mybool
)
8771 /* Convert a DWARF type code into its string name. */
8774 dwarf_type_encoding_name (unsigned enc
)
8779 return "DW_ATE_void";
8780 case DW_ATE_address
:
8781 return "DW_ATE_address";
8782 case DW_ATE_boolean
:
8783 return "DW_ATE_boolean";
8784 case DW_ATE_complex_float
:
8785 return "DW_ATE_complex_float";
8787 return "DW_ATE_float";
8789 return "DW_ATE_signed";
8790 case DW_ATE_signed_char
:
8791 return "DW_ATE_signed_char";
8792 case DW_ATE_unsigned
:
8793 return "DW_ATE_unsigned";
8794 case DW_ATE_unsigned_char
:
8795 return "DW_ATE_unsigned_char";
8797 case DW_ATE_imaginary_float
:
8798 return "DW_ATE_imaginary_float";
8799 case DW_ATE_packed_decimal
:
8800 return "DW_ATE_packed_decimal";
8801 case DW_ATE_numeric_string
:
8802 return "DW_ATE_numeric_string";
8804 return "DW_ATE_edited";
8805 case DW_ATE_signed_fixed
:
8806 return "DW_ATE_signed_fixed";
8807 case DW_ATE_unsigned_fixed
:
8808 return "DW_ATE_unsigned_fixed";
8809 case DW_ATE_decimal_float
:
8810 return "DW_ATE_decimal_float";
8811 /* HP extensions. */
8812 case DW_ATE_HP_float80
:
8813 return "DW_ATE_HP_float80";
8814 case DW_ATE_HP_complex_float80
:
8815 return "DW_ATE_HP_complex_float80";
8816 case DW_ATE_HP_float128
:
8817 return "DW_ATE_HP_float128";
8818 case DW_ATE_HP_complex_float128
:
8819 return "DW_ATE_HP_complex_float128";
8820 case DW_ATE_HP_floathpintel
:
8821 return "DW_ATE_HP_floathpintel";
8822 case DW_ATE_HP_imaginary_float80
:
8823 return "DW_ATE_HP_imaginary_float80";
8824 case DW_ATE_HP_imaginary_float128
:
8825 return "DW_ATE_HP_imaginary_float128";
8827 return "DW_ATE_<unknown>";
8831 /* Convert a DWARF call frame info operation to its string name. */
8835 dwarf_cfi_name (unsigned cfi_opc
)
8839 case DW_CFA_advance_loc
:
8840 return "DW_CFA_advance_loc";
8842 return "DW_CFA_offset";
8843 case DW_CFA_restore
:
8844 return "DW_CFA_restore";
8846 return "DW_CFA_nop";
8847 case DW_CFA_set_loc
:
8848 return "DW_CFA_set_loc";
8849 case DW_CFA_advance_loc1
:
8850 return "DW_CFA_advance_loc1";
8851 case DW_CFA_advance_loc2
:
8852 return "DW_CFA_advance_loc2";
8853 case DW_CFA_advance_loc4
:
8854 return "DW_CFA_advance_loc4";
8855 case DW_CFA_offset_extended
:
8856 return "DW_CFA_offset_extended";
8857 case DW_CFA_restore_extended
:
8858 return "DW_CFA_restore_extended";
8859 case DW_CFA_undefined
:
8860 return "DW_CFA_undefined";
8861 case DW_CFA_same_value
:
8862 return "DW_CFA_same_value";
8863 case DW_CFA_register
:
8864 return "DW_CFA_register";
8865 case DW_CFA_remember_state
:
8866 return "DW_CFA_remember_state";
8867 case DW_CFA_restore_state
:
8868 return "DW_CFA_restore_state";
8869 case DW_CFA_def_cfa
:
8870 return "DW_CFA_def_cfa";
8871 case DW_CFA_def_cfa_register
:
8872 return "DW_CFA_def_cfa_register";
8873 case DW_CFA_def_cfa_offset
:
8874 return "DW_CFA_def_cfa_offset";
8876 case DW_CFA_def_cfa_expression
:
8877 return "DW_CFA_def_cfa_expression";
8878 case DW_CFA_expression
:
8879 return "DW_CFA_expression";
8880 case DW_CFA_offset_extended_sf
:
8881 return "DW_CFA_offset_extended_sf";
8882 case DW_CFA_def_cfa_sf
:
8883 return "DW_CFA_def_cfa_sf";
8884 case DW_CFA_def_cfa_offset_sf
:
8885 return "DW_CFA_def_cfa_offset_sf";
8886 case DW_CFA_val_offset
:
8887 return "DW_CFA_val_offset";
8888 case DW_CFA_val_offset_sf
:
8889 return "DW_CFA_val_offset_sf";
8890 case DW_CFA_val_expression
:
8891 return "DW_CFA_val_expression";
8892 /* SGI/MIPS specific. */
8893 case DW_CFA_MIPS_advance_loc8
:
8894 return "DW_CFA_MIPS_advance_loc8";
8895 /* GNU extensions. */
8896 case DW_CFA_GNU_window_save
:
8897 return "DW_CFA_GNU_window_save";
8898 case DW_CFA_GNU_args_size
:
8899 return "DW_CFA_GNU_args_size";
8900 case DW_CFA_GNU_negative_offset_extended
:
8901 return "DW_CFA_GNU_negative_offset_extended";
8903 return "DW_CFA_<unknown>";
8909 dump_die (struct die_info
*die
)
8913 fprintf_unfiltered (gdb_stderr
, "Die: %s (abbrev = %d, offset = %d)\n",
8914 dwarf_tag_name (die
->tag
), die
->abbrev
, die
->offset
);
8915 fprintf_unfiltered (gdb_stderr
, "\thas children: %s\n",
8916 dwarf_bool_name (die
->child
!= NULL
));
8918 fprintf_unfiltered (gdb_stderr
, "\tattributes:\n");
8919 for (i
= 0; i
< die
->num_attrs
; ++i
)
8921 fprintf_unfiltered (gdb_stderr
, "\t\t%s (%s) ",
8922 dwarf_attr_name (die
->attrs
[i
].name
),
8923 dwarf_form_name (die
->attrs
[i
].form
));
8924 switch (die
->attrs
[i
].form
)
8926 case DW_FORM_ref_addr
:
8928 fprintf_unfiltered (gdb_stderr
, "address: ");
8929 deprecated_print_address_numeric (DW_ADDR (&die
->attrs
[i
]), 1, gdb_stderr
);
8931 case DW_FORM_block2
:
8932 case DW_FORM_block4
:
8934 case DW_FORM_block1
:
8935 fprintf_unfiltered (gdb_stderr
, "block: size %d", DW_BLOCK (&die
->attrs
[i
])->size
);
8940 fprintf_unfiltered (gdb_stderr
, "constant ref: %ld (adjusted)",
8941 (long) (DW_ADDR (&die
->attrs
[i
])));
8949 fprintf_unfiltered (gdb_stderr
, "constant: %ld", DW_UNSND (&die
->attrs
[i
]));
8951 case DW_FORM_string
:
8953 fprintf_unfiltered (gdb_stderr
, "string: \"%s\"",
8954 DW_STRING (&die
->attrs
[i
])
8955 ? DW_STRING (&die
->attrs
[i
]) : "");
8958 if (DW_UNSND (&die
->attrs
[i
]))
8959 fprintf_unfiltered (gdb_stderr
, "flag: TRUE");
8961 fprintf_unfiltered (gdb_stderr
, "flag: FALSE");
8963 case DW_FORM_indirect
:
8964 /* the reader will have reduced the indirect form to
8965 the "base form" so this form should not occur */
8966 fprintf_unfiltered (gdb_stderr
, "unexpected attribute form: DW_FORM_indirect");
8969 fprintf_unfiltered (gdb_stderr
, "unsupported attribute form: %d.",
8970 die
->attrs
[i
].form
);
8972 fprintf_unfiltered (gdb_stderr
, "\n");
8977 dump_die_list (struct die_info
*die
)
8982 if (die
->child
!= NULL
)
8983 dump_die_list (die
->child
);
8984 if (die
->sibling
!= NULL
)
8985 dump_die_list (die
->sibling
);
8990 store_in_ref_table (unsigned int offset
, struct die_info
*die
,
8991 struct dwarf2_cu
*cu
)
8994 struct die_info
*old
;
8996 h
= (offset
% REF_HASH_SIZE
);
8997 old
= cu
->die_ref_table
[h
];
8998 die
->next_ref
= old
;
8999 cu
->die_ref_table
[h
] = die
;
9003 dwarf2_get_ref_die_offset (struct attribute
*attr
, struct dwarf2_cu
*cu
)
9005 unsigned int result
= 0;
9009 case DW_FORM_ref_addr
:
9014 case DW_FORM_ref_udata
:
9015 result
= DW_ADDR (attr
);
9018 complaint (&symfile_complaints
,
9019 _("unsupported die ref attribute form: '%s'"),
9020 dwarf_form_name (attr
->form
));
9025 /* Return the constant value held by the given attribute. Return -1
9026 if the value held by the attribute is not constant. */
9029 dwarf2_get_attr_constant_value (struct attribute
*attr
, int default_value
)
9031 if (attr
->form
== DW_FORM_sdata
)
9032 return DW_SND (attr
);
9033 else if (attr
->form
== DW_FORM_udata
9034 || attr
->form
== DW_FORM_data1
9035 || attr
->form
== DW_FORM_data2
9036 || attr
->form
== DW_FORM_data4
9037 || attr
->form
== DW_FORM_data8
)
9038 return DW_UNSND (attr
);
9041 complaint (&symfile_complaints
, _("Attribute value is not a constant (%s)"),
9042 dwarf_form_name (attr
->form
));
9043 return default_value
;
9047 static struct die_info
*
9048 follow_die_ref (struct die_info
*src_die
, struct attribute
*attr
,
9049 struct dwarf2_cu
*cu
)
9051 struct die_info
*die
;
9052 unsigned int offset
;
9054 struct die_info temp_die
;
9055 struct dwarf2_cu
*target_cu
;
9057 offset
= dwarf2_get_ref_die_offset (attr
, cu
);
9059 if (DW_ADDR (attr
) < cu
->header
.offset
9060 || DW_ADDR (attr
) >= cu
->header
.offset
+ cu
->header
.length
)
9062 struct dwarf2_per_cu_data
*per_cu
;
9063 per_cu
= dwarf2_find_containing_comp_unit (DW_ADDR (attr
),
9065 target_cu
= per_cu
->cu
;
9070 h
= (offset
% REF_HASH_SIZE
);
9071 die
= target_cu
->die_ref_table
[h
];
9074 if (die
->offset
== offset
)
9076 die
= die
->next_ref
;
9079 error (_("Dwarf Error: Cannot find DIE at 0x%lx referenced from DIE "
9080 "at 0x%lx [in module %s]"),
9081 (long) src_die
->offset
, (long) offset
, cu
->objfile
->name
);
9086 /* Decode simple location descriptions.
9087 Given a pointer to a dwarf block that defines a location, compute
9088 the location and return the value.
9090 NOTE drow/2003-11-18: This function is called in two situations
9091 now: for the address of static or global variables (partial symbols
9092 only) and for offsets into structures which are expected to be
9093 (more or less) constant. The partial symbol case should go away,
9094 and only the constant case should remain. That will let this
9095 function complain more accurately. A few special modes are allowed
9096 without complaint for global variables (for instance, global
9097 register values and thread-local values).
9099 A location description containing no operations indicates that the
9100 object is optimized out. The return value is 0 for that case.
9101 FIXME drow/2003-11-16: No callers check for this case any more; soon all
9102 callers will only want a very basic result and this can become a
9105 Note that stack[0] is unused except as a default error return.
9106 Note that stack overflow is not yet handled. */
9109 decode_locdesc (struct dwarf_block
*blk
, struct dwarf2_cu
*cu
)
9111 struct objfile
*objfile
= cu
->objfile
;
9112 struct comp_unit_head
*cu_header
= &cu
->header
;
9114 int size
= blk
->size
;
9115 gdb_byte
*data
= blk
->data
;
9116 CORE_ADDR stack
[64];
9118 unsigned int bytes_read
, unsnd
;
9162 stack
[++stacki
] = op
- DW_OP_lit0
;
9197 stack
[++stacki
] = op
- DW_OP_reg0
;
9199 dwarf2_complex_location_expr_complaint ();
9203 unsnd
= read_unsigned_leb128 (NULL
, (data
+ i
), &bytes_read
);
9205 stack
[++stacki
] = unsnd
;
9207 dwarf2_complex_location_expr_complaint ();
9211 stack
[++stacki
] = read_address (objfile
->obfd
, &data
[i
],
9217 stack
[++stacki
] = read_1_byte (objfile
->obfd
, &data
[i
]);
9222 stack
[++stacki
] = read_1_signed_byte (objfile
->obfd
, &data
[i
]);
9227 stack
[++stacki
] = read_2_bytes (objfile
->obfd
, &data
[i
]);
9232 stack
[++stacki
] = read_2_signed_bytes (objfile
->obfd
, &data
[i
]);
9237 stack
[++stacki
] = read_4_bytes (objfile
->obfd
, &data
[i
]);
9242 stack
[++stacki
] = read_4_signed_bytes (objfile
->obfd
, &data
[i
]);
9247 stack
[++stacki
] = read_unsigned_leb128 (NULL
, (data
+ i
),
9253 stack
[++stacki
] = read_signed_leb128 (NULL
, (data
+ i
), &bytes_read
);
9258 stack
[stacki
+ 1] = stack
[stacki
];
9263 stack
[stacki
- 1] += stack
[stacki
];
9267 case DW_OP_plus_uconst
:
9268 stack
[stacki
] += read_unsigned_leb128 (NULL
, (data
+ i
), &bytes_read
);
9273 stack
[stacki
- 1] -= stack
[stacki
];
9278 /* If we're not the last op, then we definitely can't encode
9279 this using GDB's address_class enum. This is valid for partial
9280 global symbols, although the variable's address will be bogus
9283 dwarf2_complex_location_expr_complaint ();
9286 case DW_OP_GNU_push_tls_address
:
9287 /* The top of the stack has the offset from the beginning
9288 of the thread control block at which the variable is located. */
9289 /* Nothing should follow this operator, so the top of stack would
9291 /* This is valid for partial global symbols, but the variable's
9292 address will be bogus in the psymtab. */
9294 dwarf2_complex_location_expr_complaint ();
9297 case DW_OP_GNU_uninit
:
9301 complaint (&symfile_complaints
, _("unsupported stack op: '%s'"),
9302 dwarf_stack_op_name (op
));
9303 return (stack
[stacki
]);
9306 return (stack
[stacki
]);
9309 /* memory allocation interface */
9311 static struct dwarf_block
*
9312 dwarf_alloc_block (struct dwarf2_cu
*cu
)
9314 struct dwarf_block
*blk
;
9316 blk
= (struct dwarf_block
*)
9317 obstack_alloc (&cu
->comp_unit_obstack
, sizeof (struct dwarf_block
));
9321 static struct abbrev_info
*
9322 dwarf_alloc_abbrev (struct dwarf2_cu
*cu
)
9324 struct abbrev_info
*abbrev
;
9326 abbrev
= (struct abbrev_info
*)
9327 obstack_alloc (&cu
->abbrev_obstack
, sizeof (struct abbrev_info
));
9328 memset (abbrev
, 0, sizeof (struct abbrev_info
));
9332 static struct die_info
*
9333 dwarf_alloc_die (void)
9335 struct die_info
*die
;
9337 die
= (struct die_info
*) xmalloc (sizeof (struct die_info
));
9338 memset (die
, 0, sizeof (struct die_info
));
9343 /* Macro support. */
9346 /* Return the full name of file number I in *LH's file name table.
9347 Use COMP_DIR as the name of the current directory of the
9348 compilation. The result is allocated using xmalloc; the caller is
9349 responsible for freeing it. */
9351 file_full_name (int file
, struct line_header
*lh
, const char *comp_dir
)
9353 /* Is the file number a valid index into the line header's file name
9354 table? Remember that file numbers start with one, not zero. */
9355 if (1 <= file
&& file
<= lh
->num_file_names
)
9357 struct file_entry
*fe
= &lh
->file_names
[file
- 1];
9359 if (IS_ABSOLUTE_PATH (fe
->name
))
9360 return xstrdup (fe
->name
);
9368 dir
= lh
->include_dirs
[fe
->dir_index
- 1];
9374 dir_len
= strlen (dir
);
9375 full_name
= xmalloc (dir_len
+ 1 + strlen (fe
->name
) + 1);
9376 strcpy (full_name
, dir
);
9377 full_name
[dir_len
] = '/';
9378 strcpy (full_name
+ dir_len
+ 1, fe
->name
);
9382 return xstrdup (fe
->name
);
9387 /* The compiler produced a bogus file number. We can at least
9388 record the macro definitions made in the file, even if we
9389 won't be able to find the file by name. */
9391 sprintf (fake_name
, "<bad macro file number %d>", file
);
9393 complaint (&symfile_complaints
,
9394 _("bad file number in macro information (%d)"),
9397 return xstrdup (fake_name
);
9402 static struct macro_source_file
*
9403 macro_start_file (int file
, int line
,
9404 struct macro_source_file
*current_file
,
9405 const char *comp_dir
,
9406 struct line_header
*lh
, struct objfile
*objfile
)
9408 /* The full name of this source file. */
9409 char *full_name
= file_full_name (file
, lh
, comp_dir
);
9411 /* We don't create a macro table for this compilation unit
9412 at all until we actually get a filename. */
9413 if (! pending_macros
)
9414 pending_macros
= new_macro_table (&objfile
->objfile_obstack
,
9415 objfile
->macro_cache
);
9418 /* If we have no current file, then this must be the start_file
9419 directive for the compilation unit's main source file. */
9420 current_file
= macro_set_main (pending_macros
, full_name
);
9422 current_file
= macro_include (current_file
, line
, full_name
);
9426 return current_file
;
9430 /* Copy the LEN characters at BUF to a xmalloc'ed block of memory,
9431 followed by a null byte. */
9433 copy_string (const char *buf
, int len
)
9435 char *s
= xmalloc (len
+ 1);
9436 memcpy (s
, buf
, len
);
9444 consume_improper_spaces (const char *p
, const char *body
)
9448 complaint (&symfile_complaints
,
9449 _("macro definition contains spaces in formal argument list:\n`%s'"),
9461 parse_macro_definition (struct macro_source_file
*file
, int line
,
9466 /* The body string takes one of two forms. For object-like macro
9467 definitions, it should be:
9469 <macro name> " " <definition>
9471 For function-like macro definitions, it should be:
9473 <macro name> "() " <definition>
9475 <macro name> "(" <arg name> ( "," <arg name> ) * ") " <definition>
9477 Spaces may appear only where explicitly indicated, and in the
9480 The Dwarf 2 spec says that an object-like macro's name is always
9481 followed by a space, but versions of GCC around March 2002 omit
9482 the space when the macro's definition is the empty string.
9484 The Dwarf 2 spec says that there should be no spaces between the
9485 formal arguments in a function-like macro's formal argument list,
9486 but versions of GCC around March 2002 include spaces after the
9490 /* Find the extent of the macro name. The macro name is terminated
9491 by either a space or null character (for an object-like macro) or
9492 an opening paren (for a function-like macro). */
9493 for (p
= body
; *p
; p
++)
9494 if (*p
== ' ' || *p
== '(')
9497 if (*p
== ' ' || *p
== '\0')
9499 /* It's an object-like macro. */
9500 int name_len
= p
- body
;
9501 char *name
= copy_string (body
, name_len
);
9502 const char *replacement
;
9505 replacement
= body
+ name_len
+ 1;
9508 dwarf2_macro_malformed_definition_complaint (body
);
9509 replacement
= body
+ name_len
;
9512 macro_define_object (file
, line
, name
, replacement
);
9518 /* It's a function-like macro. */
9519 char *name
= copy_string (body
, p
- body
);
9522 char **argv
= xmalloc (argv_size
* sizeof (*argv
));
9526 p
= consume_improper_spaces (p
, body
);
9528 /* Parse the formal argument list. */
9529 while (*p
&& *p
!= ')')
9531 /* Find the extent of the current argument name. */
9532 const char *arg_start
= p
;
9534 while (*p
&& *p
!= ',' && *p
!= ')' && *p
!= ' ')
9537 if (! *p
|| p
== arg_start
)
9538 dwarf2_macro_malformed_definition_complaint (body
);
9541 /* Make sure argv has room for the new argument. */
9542 if (argc
>= argv_size
)
9545 argv
= xrealloc (argv
, argv_size
* sizeof (*argv
));
9548 argv
[argc
++] = copy_string (arg_start
, p
- arg_start
);
9551 p
= consume_improper_spaces (p
, body
);
9553 /* Consume the comma, if present. */
9558 p
= consume_improper_spaces (p
, body
);
9567 /* Perfectly formed definition, no complaints. */
9568 macro_define_function (file
, line
, name
,
9569 argc
, (const char **) argv
,
9571 else if (*p
== '\0')
9573 /* Complain, but do define it. */
9574 dwarf2_macro_malformed_definition_complaint (body
);
9575 macro_define_function (file
, line
, name
,
9576 argc
, (const char **) argv
,
9580 /* Just complain. */
9581 dwarf2_macro_malformed_definition_complaint (body
);
9584 /* Just complain. */
9585 dwarf2_macro_malformed_definition_complaint (body
);
9591 for (i
= 0; i
< argc
; i
++)
9597 dwarf2_macro_malformed_definition_complaint (body
);
9602 dwarf_decode_macros (struct line_header
*lh
, unsigned int offset
,
9603 char *comp_dir
, bfd
*abfd
,
9604 struct dwarf2_cu
*cu
)
9606 gdb_byte
*mac_ptr
, *mac_end
;
9607 struct macro_source_file
*current_file
= 0;
9609 if (dwarf2_per_objfile
->macinfo_buffer
== NULL
)
9611 complaint (&symfile_complaints
, _("missing .debug_macinfo section"));
9615 mac_ptr
= dwarf2_per_objfile
->macinfo_buffer
+ offset
;
9616 mac_end
= dwarf2_per_objfile
->macinfo_buffer
9617 + dwarf2_per_objfile
->macinfo_size
;
9621 enum dwarf_macinfo_record_type macinfo_type
;
9623 /* Do we at least have room for a macinfo type byte? */
9624 if (mac_ptr
>= mac_end
)
9626 dwarf2_macros_too_long_complaint ();
9630 macinfo_type
= read_1_byte (abfd
, mac_ptr
);
9633 switch (macinfo_type
)
9635 /* A zero macinfo type indicates the end of the macro
9640 case DW_MACINFO_define
:
9641 case DW_MACINFO_undef
:
9643 unsigned int bytes_read
;
9647 line
= read_unsigned_leb128 (abfd
, mac_ptr
, &bytes_read
);
9648 mac_ptr
+= bytes_read
;
9649 body
= read_string (abfd
, mac_ptr
, &bytes_read
);
9650 mac_ptr
+= bytes_read
;
9653 complaint (&symfile_complaints
,
9654 _("debug info gives macro %s outside of any file: %s"),
9656 DW_MACINFO_define
? "definition" : macinfo_type
==
9657 DW_MACINFO_undef
? "undefinition" :
9658 "something-or-other", body
);
9661 if (macinfo_type
== DW_MACINFO_define
)
9662 parse_macro_definition (current_file
, line
, body
);
9663 else if (macinfo_type
== DW_MACINFO_undef
)
9664 macro_undef (current_file
, line
, body
);
9669 case DW_MACINFO_start_file
:
9671 unsigned int bytes_read
;
9674 line
= read_unsigned_leb128 (abfd
, mac_ptr
, &bytes_read
);
9675 mac_ptr
+= bytes_read
;
9676 file
= read_unsigned_leb128 (abfd
, mac_ptr
, &bytes_read
);
9677 mac_ptr
+= bytes_read
;
9679 current_file
= macro_start_file (file
, line
,
9680 current_file
, comp_dir
,
9685 case DW_MACINFO_end_file
:
9687 complaint (&symfile_complaints
,
9688 _("macro debug info has an unmatched `close_file' directive"));
9691 current_file
= current_file
->included_by
;
9694 enum dwarf_macinfo_record_type next_type
;
9696 /* GCC circa March 2002 doesn't produce the zero
9697 type byte marking the end of the compilation
9698 unit. Complain if it's not there, but exit no
9701 /* Do we at least have room for a macinfo type byte? */
9702 if (mac_ptr
>= mac_end
)
9704 dwarf2_macros_too_long_complaint ();
9708 /* We don't increment mac_ptr here, so this is just
9710 next_type
= read_1_byte (abfd
, mac_ptr
);
9712 complaint (&symfile_complaints
,
9713 _("no terminating 0-type entry for macros in `.debug_macinfo' section"));
9720 case DW_MACINFO_vendor_ext
:
9722 unsigned int bytes_read
;
9726 constant
= read_unsigned_leb128 (abfd
, mac_ptr
, &bytes_read
);
9727 mac_ptr
+= bytes_read
;
9728 string
= read_string (abfd
, mac_ptr
, &bytes_read
);
9729 mac_ptr
+= bytes_read
;
9731 /* We don't recognize any vendor extensions. */
9738 /* Check if the attribute's form is a DW_FORM_block*
9739 if so return true else false. */
9741 attr_form_is_block (struct attribute
*attr
)
9743 return (attr
== NULL
? 0 :
9744 attr
->form
== DW_FORM_block1
9745 || attr
->form
== DW_FORM_block2
9746 || attr
->form
== DW_FORM_block4
9747 || attr
->form
== DW_FORM_block
);
9750 /* Return non-zero if ATTR's value is a section offset --- classes
9751 lineptr, loclistptr, macptr or rangelistptr --- or zero, otherwise.
9752 You may use DW_UNSND (attr) to retrieve such offsets.
9754 Section 7.5.4, "Attribute Encodings", explains that no attribute
9755 may have a value that belongs to more than one of these classes; it
9756 would be ambiguous if we did, because we use the same forms for all
9759 attr_form_is_section_offset (struct attribute
*attr
)
9761 return (attr
->form
== DW_FORM_data4
9762 || attr
->form
== DW_FORM_data8
);
9766 /* Return non-zero if ATTR's value falls in the 'constant' class, or
9767 zero otherwise. When this function returns true, you can apply
9768 dwarf2_get_attr_constant_value to it.
9770 However, note that for some attributes you must check
9771 attr_form_is_section_offset before using this test. DW_FORM_data4
9772 and DW_FORM_data8 are members of both the constant class, and of
9773 the classes that contain offsets into other debug sections
9774 (lineptr, loclistptr, macptr or rangelistptr). The DWARF spec says
9775 that, if an attribute's can be either a constant or one of the
9776 section offset classes, DW_FORM_data4 and DW_FORM_data8 should be
9777 taken as section offsets, not constants. */
9779 attr_form_is_constant (struct attribute
*attr
)
9796 dwarf2_symbol_mark_computed (struct attribute
*attr
, struct symbol
*sym
,
9797 struct dwarf2_cu
*cu
)
9799 struct objfile
*objfile
= cu
->objfile
;
9801 /* Save the master objfile, so that we can report and look up the
9802 correct file containing this variable. */
9803 if (objfile
->separate_debug_objfile_backlink
)
9804 objfile
= objfile
->separate_debug_objfile_backlink
;
9806 if (attr_form_is_section_offset (attr
)
9807 /* ".debug_loc" may not exist at all, or the offset may be outside
9808 the section. If so, fall through to the complaint in the
9810 && DW_UNSND (attr
) < dwarf2_per_objfile
->loc_size
)
9812 struct dwarf2_loclist_baton
*baton
;
9814 baton
= obstack_alloc (&cu
->objfile
->objfile_obstack
,
9815 sizeof (struct dwarf2_loclist_baton
));
9816 baton
->objfile
= objfile
;
9818 /* We don't know how long the location list is, but make sure we
9819 don't run off the edge of the section. */
9820 baton
->size
= dwarf2_per_objfile
->loc_size
- DW_UNSND (attr
);
9821 baton
->data
= dwarf2_per_objfile
->loc_buffer
+ DW_UNSND (attr
);
9822 baton
->base_address
= cu
->header
.base_address
;
9823 if (cu
->header
.base_known
== 0)
9824 complaint (&symfile_complaints
,
9825 _("Location list used without specifying the CU base address."));
9827 SYMBOL_OPS (sym
) = &dwarf2_loclist_funcs
;
9828 SYMBOL_LOCATION_BATON (sym
) = baton
;
9832 struct dwarf2_locexpr_baton
*baton
;
9834 baton
= obstack_alloc (&cu
->objfile
->objfile_obstack
,
9835 sizeof (struct dwarf2_locexpr_baton
));
9836 baton
->objfile
= objfile
;
9838 if (attr_form_is_block (attr
))
9840 /* Note that we're just copying the block's data pointer
9841 here, not the actual data. We're still pointing into the
9842 info_buffer for SYM's objfile; right now we never release
9843 that buffer, but when we do clean up properly this may
9845 baton
->size
= DW_BLOCK (attr
)->size
;
9846 baton
->data
= DW_BLOCK (attr
)->data
;
9850 dwarf2_invalid_attrib_class_complaint ("location description",
9851 SYMBOL_NATURAL_NAME (sym
));
9856 SYMBOL_OPS (sym
) = &dwarf2_locexpr_funcs
;
9857 SYMBOL_LOCATION_BATON (sym
) = baton
;
9861 /* Locate the compilation unit from CU's objfile which contains the
9862 DIE at OFFSET. Raises an error on failure. */
9864 static struct dwarf2_per_cu_data
*
9865 dwarf2_find_containing_comp_unit (unsigned long offset
,
9866 struct objfile
*objfile
)
9868 struct dwarf2_per_cu_data
*this_cu
;
9872 high
= dwarf2_per_objfile
->n_comp_units
- 1;
9875 int mid
= low
+ (high
- low
) / 2;
9876 if (dwarf2_per_objfile
->all_comp_units
[mid
]->offset
>= offset
)
9881 gdb_assert (low
== high
);
9882 if (dwarf2_per_objfile
->all_comp_units
[low
]->offset
> offset
)
9885 error (_("Dwarf Error: could not find partial DIE containing "
9886 "offset 0x%lx [in module %s]"),
9887 (long) offset
, bfd_get_filename (objfile
->obfd
));
9889 gdb_assert (dwarf2_per_objfile
->all_comp_units
[low
-1]->offset
<= offset
);
9890 return dwarf2_per_objfile
->all_comp_units
[low
-1];
9894 this_cu
= dwarf2_per_objfile
->all_comp_units
[low
];
9895 if (low
== dwarf2_per_objfile
->n_comp_units
- 1
9896 && offset
>= this_cu
->offset
+ this_cu
->length
)
9897 error (_("invalid dwarf2 offset %ld"), offset
);
9898 gdb_assert (offset
< this_cu
->offset
+ this_cu
->length
);
9903 /* Locate the compilation unit from OBJFILE which is located at exactly
9904 OFFSET. Raises an error on failure. */
9906 static struct dwarf2_per_cu_data
*
9907 dwarf2_find_comp_unit (unsigned long offset
, struct objfile
*objfile
)
9909 struct dwarf2_per_cu_data
*this_cu
;
9910 this_cu
= dwarf2_find_containing_comp_unit (offset
, objfile
);
9911 if (this_cu
->offset
!= offset
)
9912 error (_("no compilation unit with offset %ld."), offset
);
9916 /* Release one cached compilation unit, CU. We unlink it from the tree
9917 of compilation units, but we don't remove it from the read_in_chain;
9918 the caller is responsible for that. */
9921 free_one_comp_unit (void *data
)
9923 struct dwarf2_cu
*cu
= data
;
9925 if (cu
->per_cu
!= NULL
)
9926 cu
->per_cu
->cu
= NULL
;
9929 obstack_free (&cu
->comp_unit_obstack
, NULL
);
9931 free_die_list (cu
->dies
);
9936 /* This cleanup function is passed the address of a dwarf2_cu on the stack
9937 when we're finished with it. We can't free the pointer itself, but be
9938 sure to unlink it from the cache. Also release any associated storage
9939 and perform cache maintenance.
9941 Only used during partial symbol parsing. */
9944 free_stack_comp_unit (void *data
)
9946 struct dwarf2_cu
*cu
= data
;
9948 obstack_free (&cu
->comp_unit_obstack
, NULL
);
9949 cu
->partial_dies
= NULL
;
9951 if (cu
->per_cu
!= NULL
)
9953 /* This compilation unit is on the stack in our caller, so we
9954 should not xfree it. Just unlink it. */
9955 cu
->per_cu
->cu
= NULL
;
9958 /* If we had a per-cu pointer, then we may have other compilation
9959 units loaded, so age them now. */
9960 age_cached_comp_units ();
9964 /* Free all cached compilation units. */
9967 free_cached_comp_units (void *data
)
9969 struct dwarf2_per_cu_data
*per_cu
, **last_chain
;
9971 per_cu
= dwarf2_per_objfile
->read_in_chain
;
9972 last_chain
= &dwarf2_per_objfile
->read_in_chain
;
9973 while (per_cu
!= NULL
)
9975 struct dwarf2_per_cu_data
*next_cu
;
9977 next_cu
= per_cu
->cu
->read_in_chain
;
9979 free_one_comp_unit (per_cu
->cu
);
9980 *last_chain
= next_cu
;
9986 /* Increase the age counter on each cached compilation unit, and free
9987 any that are too old. */
9990 age_cached_comp_units (void)
9992 struct dwarf2_per_cu_data
*per_cu
, **last_chain
;
9994 dwarf2_clear_marks (dwarf2_per_objfile
->read_in_chain
);
9995 per_cu
= dwarf2_per_objfile
->read_in_chain
;
9996 while (per_cu
!= NULL
)
9998 per_cu
->cu
->last_used
++;
9999 if (per_cu
->cu
->last_used
<= dwarf2_max_cache_age
)
10000 dwarf2_mark (per_cu
->cu
);
10001 per_cu
= per_cu
->cu
->read_in_chain
;
10004 per_cu
= dwarf2_per_objfile
->read_in_chain
;
10005 last_chain
= &dwarf2_per_objfile
->read_in_chain
;
10006 while (per_cu
!= NULL
)
10008 struct dwarf2_per_cu_data
*next_cu
;
10010 next_cu
= per_cu
->cu
->read_in_chain
;
10012 if (!per_cu
->cu
->mark
)
10014 free_one_comp_unit (per_cu
->cu
);
10015 *last_chain
= next_cu
;
10018 last_chain
= &per_cu
->cu
->read_in_chain
;
10024 /* Remove a single compilation unit from the cache. */
10027 free_one_cached_comp_unit (void *target_cu
)
10029 struct dwarf2_per_cu_data
*per_cu
, **last_chain
;
10031 per_cu
= dwarf2_per_objfile
->read_in_chain
;
10032 last_chain
= &dwarf2_per_objfile
->read_in_chain
;
10033 while (per_cu
!= NULL
)
10035 struct dwarf2_per_cu_data
*next_cu
;
10037 next_cu
= per_cu
->cu
->read_in_chain
;
10039 if (per_cu
->cu
== target_cu
)
10041 free_one_comp_unit (per_cu
->cu
);
10042 *last_chain
= next_cu
;
10046 last_chain
= &per_cu
->cu
->read_in_chain
;
10052 /* Release all extra memory associated with OBJFILE. */
10055 dwarf2_free_objfile (struct objfile
*objfile
)
10057 dwarf2_per_objfile
= objfile_data (objfile
, dwarf2_objfile_data_key
);
10059 if (dwarf2_per_objfile
== NULL
)
10062 /* Cached DIE trees use xmalloc and the comp_unit_obstack. */
10063 free_cached_comp_units (NULL
);
10065 /* Everything else should be on the objfile obstack. */
10068 /* A pair of DIE offset and GDB type pointer. We store these
10069 in a hash table separate from the DIEs, and preserve them
10070 when the DIEs are flushed out of cache. */
10072 struct dwarf2_offset_and_type
10074 unsigned int offset
;
10078 /* Hash function for a dwarf2_offset_and_type. */
10081 offset_and_type_hash (const void *item
)
10083 const struct dwarf2_offset_and_type
*ofs
= item
;
10084 return ofs
->offset
;
10087 /* Equality function for a dwarf2_offset_and_type. */
10090 offset_and_type_eq (const void *item_lhs
, const void *item_rhs
)
10092 const struct dwarf2_offset_and_type
*ofs_lhs
= item_lhs
;
10093 const struct dwarf2_offset_and_type
*ofs_rhs
= item_rhs
;
10094 return ofs_lhs
->offset
== ofs_rhs
->offset
;
10097 /* Set the type associated with DIE to TYPE. Save it in CU's hash
10098 table if necessary. */
10101 set_die_type (struct die_info
*die
, struct type
*type
, struct dwarf2_cu
*cu
)
10103 struct dwarf2_offset_and_type
**slot
, ofs
;
10107 if (cu
->per_cu
== NULL
)
10110 if (cu
->per_cu
->type_hash
== NULL
)
10111 cu
->per_cu
->type_hash
10112 = htab_create_alloc_ex (cu
->header
.length
/ 24,
10113 offset_and_type_hash
,
10114 offset_and_type_eq
,
10116 &cu
->objfile
->objfile_obstack
,
10117 hashtab_obstack_allocate
,
10118 dummy_obstack_deallocate
);
10120 ofs
.offset
= die
->offset
;
10122 slot
= (struct dwarf2_offset_and_type
**)
10123 htab_find_slot_with_hash (cu
->per_cu
->type_hash
, &ofs
, ofs
.offset
, INSERT
);
10124 *slot
= obstack_alloc (&cu
->objfile
->objfile_obstack
, sizeof (**slot
));
10128 /* Find the type for DIE in TYPE_HASH, or return NULL if DIE does not
10129 have a saved type. */
10131 static struct type
*
10132 get_die_type (struct die_info
*die
, htab_t type_hash
)
10134 struct dwarf2_offset_and_type
*slot
, ofs
;
10136 ofs
.offset
= die
->offset
;
10137 slot
= htab_find_with_hash (type_hash
, &ofs
, ofs
.offset
);
10144 /* Restore the types of the DIE tree starting at START_DIE from the hash
10145 table saved in CU. */
10148 reset_die_and_siblings_types (struct die_info
*start_die
, struct dwarf2_cu
*cu
)
10150 struct die_info
*die
;
10152 if (cu
->per_cu
->type_hash
== NULL
)
10155 for (die
= start_die
; die
!= NULL
; die
= die
->sibling
)
10157 die
->type
= get_die_type (die
, cu
->per_cu
->type_hash
);
10158 if (die
->child
!= NULL
)
10159 reset_die_and_siblings_types (die
->child
, cu
);
10163 /* Set the mark field in CU and in every other compilation unit in the
10164 cache that we must keep because we are keeping CU. */
10166 /* Add a dependence relationship from CU to REF_PER_CU. */
10169 dwarf2_add_dependence (struct dwarf2_cu
*cu
,
10170 struct dwarf2_per_cu_data
*ref_per_cu
)
10174 if (cu
->dependencies
== NULL
)
10176 = htab_create_alloc_ex (5, htab_hash_pointer
, htab_eq_pointer
,
10177 NULL
, &cu
->comp_unit_obstack
,
10178 hashtab_obstack_allocate
,
10179 dummy_obstack_deallocate
);
10181 slot
= htab_find_slot (cu
->dependencies
, ref_per_cu
, INSERT
);
10183 *slot
= ref_per_cu
;
10186 /* Set the mark field in CU and in every other compilation unit in the
10187 cache that we must keep because we are keeping CU. */
10190 dwarf2_mark_helper (void **slot
, void *data
)
10192 struct dwarf2_per_cu_data
*per_cu
;
10194 per_cu
= (struct dwarf2_per_cu_data
*) *slot
;
10195 if (per_cu
->cu
->mark
)
10197 per_cu
->cu
->mark
= 1;
10199 if (per_cu
->cu
->dependencies
!= NULL
)
10200 htab_traverse (per_cu
->cu
->dependencies
, dwarf2_mark_helper
, NULL
);
10206 dwarf2_mark (struct dwarf2_cu
*cu
)
10211 if (cu
->dependencies
!= NULL
)
10212 htab_traverse (cu
->dependencies
, dwarf2_mark_helper
, NULL
);
10216 dwarf2_clear_marks (struct dwarf2_per_cu_data
*per_cu
)
10220 per_cu
->cu
->mark
= 0;
10221 per_cu
= per_cu
->cu
->read_in_chain
;
10225 /* Trivial hash function for partial_die_info: the hash value of a DIE
10226 is its offset in .debug_info for this objfile. */
10229 partial_die_hash (const void *item
)
10231 const struct partial_die_info
*part_die
= item
;
10232 return part_die
->offset
;
10235 /* Trivial comparison function for partial_die_info structures: two DIEs
10236 are equal if they have the same offset. */
10239 partial_die_eq (const void *item_lhs
, const void *item_rhs
)
10241 const struct partial_die_info
*part_die_lhs
= item_lhs
;
10242 const struct partial_die_info
*part_die_rhs
= item_rhs
;
10243 return part_die_lhs
->offset
== part_die_rhs
->offset
;
10246 static struct cmd_list_element
*set_dwarf2_cmdlist
;
10247 static struct cmd_list_element
*show_dwarf2_cmdlist
;
10250 set_dwarf2_cmd (char *args
, int from_tty
)
10252 help_list (set_dwarf2_cmdlist
, "maintenance set dwarf2 ", -1, gdb_stdout
);
10256 show_dwarf2_cmd (char *args
, int from_tty
)
10258 cmd_show_list (show_dwarf2_cmdlist
, from_tty
, "");
10261 void _initialize_dwarf2_read (void);
10264 _initialize_dwarf2_read (void)
10266 dwarf2_objfile_data_key
= register_objfile_data ();
10268 add_prefix_cmd ("dwarf2", class_maintenance
, set_dwarf2_cmd
, _("\
10269 Set DWARF 2 specific variables.\n\
10270 Configure DWARF 2 variables such as the cache size"),
10271 &set_dwarf2_cmdlist
, "maintenance set dwarf2 ",
10272 0/*allow-unknown*/, &maintenance_set_cmdlist
);
10274 add_prefix_cmd ("dwarf2", class_maintenance
, show_dwarf2_cmd
, _("\
10275 Show DWARF 2 specific variables\n\
10276 Show DWARF 2 variables such as the cache size"),
10277 &show_dwarf2_cmdlist
, "maintenance show dwarf2 ",
10278 0/*allow-unknown*/, &maintenance_show_cmdlist
);
10280 add_setshow_zinteger_cmd ("max-cache-age", class_obscure
,
10281 &dwarf2_max_cache_age
, _("\
10282 Set the upper bound on the age of cached dwarf2 compilation units."), _("\
10283 Show the upper bound on the age of cached dwarf2 compilation units."), _("\
10284 A higher limit means that cached compilation units will be stored\n\
10285 in memory longer, and more total memory will be used. Zero disables\n\
10286 caching, which can slow down startup."),
10288 show_dwarf2_max_cache_age
,
10289 &set_dwarf2_cmdlist
,
10290 &show_dwarf2_cmdlist
);