1 /* DWARF 2 debugging format support for GDB.
3 Copyright (C) 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2001,
4 2002, 2003, 2004, 2005, 2006
5 Free Software Foundation, Inc.
7 Adapted by Gary Funck (gary@intrepid.com), Intrepid Technology,
8 Inc. with support from Florida State University (under contract
9 with the Ada Joint Program Office), and Silicon Graphics, Inc.
10 Initial contribution by Brent Benson, Harris Computer Systems, Inc.,
11 based on Fred Fish's (Cygnus Support) implementation of DWARF 1
12 support in dwarfread.c
14 This file is part of GDB.
16 This program is free software; you can redistribute it and/or modify
17 it under the terms of the GNU General Public License as published by
18 the Free Software Foundation; either version 2 of the License, or (at
19 your option) any later version.
21 This program is distributed in the hope that it will be useful, but
22 WITHOUT ANY WARRANTY; without even the implied warranty of
23 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
24 General Public License for more details.
26 You should have received a copy of the GNU General Public License
27 along with this program; if not, write to the Free Software
28 Foundation, Inc., 51 Franklin Street, Fifth Floor,
29 Boston, MA 02110-1301, USA. */
36 #include "elf/dwarf2.h"
39 #include "expression.h"
40 #include "filenames.h" /* for DOSish file names */
43 #include "complaints.h"
45 #include "dwarf2expr.h"
46 #include "dwarf2loc.h"
47 #include "cp-support.h"
53 #include "gdb_string.h"
54 #include "gdb_assert.h"
55 #include <sys/types.h>
57 /* A note on memory usage for this file.
59 At the present time, this code reads the debug info sections into
60 the objfile's objfile_obstack. A definite improvement for startup
61 time, on platforms which do not emit relocations for debug
62 sections, would be to use mmap instead. The object's complete
63 debug information is loaded into memory, partly to simplify
64 absolute DIE references.
66 Whether using obstacks or mmap, the sections should remain loaded
67 until the objfile is released, and pointers into the section data
68 can be used for any other data associated to the objfile (symbol
69 names, type names, location expressions to name a few). */
71 #ifndef DWARF2_REG_TO_REGNUM
72 #define DWARF2_REG_TO_REGNUM(REG) (REG)
76 /* .debug_info header for a compilation unit
77 Because of alignment constraints, this structure has padding and cannot
78 be mapped directly onto the beginning of the .debug_info section. */
79 typedef struct comp_unit_header
81 unsigned int length
; /* length of the .debug_info
83 unsigned short version
; /* version number -- 2 for DWARF
85 unsigned int abbrev_offset
; /* offset into .debug_abbrev section */
86 unsigned char addr_size
; /* byte size of an address -- 4 */
89 #define _ACTUAL_COMP_UNIT_HEADER_SIZE 11
92 /* .debug_pubnames header
93 Because of alignment constraints, this structure has padding and cannot
94 be mapped directly onto the beginning of the .debug_info section. */
95 typedef struct pubnames_header
97 unsigned int length
; /* length of the .debug_pubnames
99 unsigned char version
; /* version number -- 2 for DWARF
101 unsigned int info_offset
; /* offset into .debug_info section */
102 unsigned int info_size
; /* byte size of .debug_info section
106 #define _ACTUAL_PUBNAMES_HEADER_SIZE 13
108 /* .debug_pubnames header
109 Because of alignment constraints, this structure has padding and cannot
110 be mapped directly onto the beginning of the .debug_info section. */
111 typedef struct aranges_header
113 unsigned int length
; /* byte len of the .debug_aranges
115 unsigned short version
; /* version number -- 2 for DWARF
117 unsigned int info_offset
; /* offset into .debug_info section */
118 unsigned char addr_size
; /* byte size of an address */
119 unsigned char seg_size
; /* byte size of segment descriptor */
122 #define _ACTUAL_ARANGES_HEADER_SIZE 12
124 /* .debug_line statement program prologue
125 Because of alignment constraints, this structure has padding and cannot
126 be mapped directly onto the beginning of the .debug_info section. */
127 typedef struct statement_prologue
129 unsigned int total_length
; /* byte length of the statement
131 unsigned short version
; /* version number -- 2 for DWARF
133 unsigned int prologue_length
; /* # bytes between prologue &
135 unsigned char minimum_instruction_length
; /* byte size of
137 unsigned char default_is_stmt
; /* initial value of is_stmt
140 unsigned char line_range
;
141 unsigned char opcode_base
; /* number assigned to first special
143 unsigned char *standard_opcode_lengths
;
147 static const struct objfile_data
*dwarf2_objfile_data_key
;
149 struct dwarf2_per_objfile
151 /* Sizes of debugging sections. */
152 unsigned int info_size
;
153 unsigned int abbrev_size
;
154 unsigned int line_size
;
155 unsigned int pubnames_size
;
156 unsigned int aranges_size
;
157 unsigned int loc_size
;
158 unsigned int macinfo_size
;
159 unsigned int str_size
;
160 unsigned int ranges_size
;
161 unsigned int frame_size
;
162 unsigned int eh_frame_size
;
164 /* Loaded data from the sections. */
165 gdb_byte
*info_buffer
;
166 gdb_byte
*abbrev_buffer
;
167 gdb_byte
*line_buffer
;
168 gdb_byte
*str_buffer
;
169 gdb_byte
*macinfo_buffer
;
170 gdb_byte
*ranges_buffer
;
171 gdb_byte
*loc_buffer
;
173 /* A list of all the compilation units. This is used to locate
174 the target compilation unit of a particular reference. */
175 struct dwarf2_per_cu_data
**all_comp_units
;
177 /* The number of compilation units in ALL_COMP_UNITS. */
180 /* A chain of compilation units that are currently read in, so that
181 they can be freed later. */
182 struct dwarf2_per_cu_data
*read_in_chain
;
184 /* A flag indicating wether this objfile has a section loaded at a
186 int has_section_at_zero
;
189 static struct dwarf2_per_objfile
*dwarf2_per_objfile
;
191 static asection
*dwarf_info_section
;
192 static asection
*dwarf_abbrev_section
;
193 static asection
*dwarf_line_section
;
194 static asection
*dwarf_pubnames_section
;
195 static asection
*dwarf_aranges_section
;
196 static asection
*dwarf_loc_section
;
197 static asection
*dwarf_macinfo_section
;
198 static asection
*dwarf_str_section
;
199 static asection
*dwarf_ranges_section
;
200 asection
*dwarf_frame_section
;
201 asection
*dwarf_eh_frame_section
;
203 /* names of the debugging sections */
205 #define INFO_SECTION ".debug_info"
206 #define ABBREV_SECTION ".debug_abbrev"
207 #define LINE_SECTION ".debug_line"
208 #define PUBNAMES_SECTION ".debug_pubnames"
209 #define ARANGES_SECTION ".debug_aranges"
210 #define LOC_SECTION ".debug_loc"
211 #define MACINFO_SECTION ".debug_macinfo"
212 #define STR_SECTION ".debug_str"
213 #define RANGES_SECTION ".debug_ranges"
214 #define FRAME_SECTION ".debug_frame"
215 #define EH_FRAME_SECTION ".eh_frame"
217 /* local data types */
219 /* We hold several abbreviation tables in memory at the same time. */
220 #ifndef ABBREV_HASH_SIZE
221 #define ABBREV_HASH_SIZE 121
224 /* The data in a compilation unit header, after target2host
225 translation, looks like this. */
226 struct comp_unit_head
228 unsigned long length
;
230 unsigned int abbrev_offset
;
231 unsigned char addr_size
;
232 unsigned char signed_addr_p
;
234 /* Size of file offsets; either 4 or 8. */
235 unsigned int offset_size
;
237 /* Size of the length field; either 4 or 12. */
238 unsigned int initial_length_size
;
240 /* Offset to the first byte of this compilation unit header in the
241 .debug_info section, for resolving relative reference dies. */
244 /* Pointer to this compilation unit header in the .debug_info
246 gdb_byte
*cu_head_ptr
;
248 /* Pointer to the first die of this compilation unit. This will be
249 the first byte following the compilation unit header. */
250 gdb_byte
*first_die_ptr
;
252 /* Pointer to the next compilation unit header in the program. */
253 struct comp_unit_head
*next
;
255 /* Base address of this compilation unit. */
256 CORE_ADDR base_address
;
258 /* Non-zero if base_address has been set. */
262 /* Fixed size for the DIE hash table. */
263 #ifndef REF_HASH_SIZE
264 #define REF_HASH_SIZE 1021
267 /* Internal state when decoding a particular compilation unit. */
270 /* The objfile containing this compilation unit. */
271 struct objfile
*objfile
;
273 /* The header of the compilation unit.
275 FIXME drow/2003-11-10: Some of the things from the comp_unit_head
276 should logically be moved to the dwarf2_cu structure. */
277 struct comp_unit_head header
;
279 struct function_range
*first_fn
, *last_fn
, *cached_fn
;
281 /* The language we are debugging. */
282 enum language language
;
283 const struct language_defn
*language_defn
;
285 const char *producer
;
287 /* The generic symbol table building routines have separate lists for
288 file scope symbols and all all other scopes (local scopes). So
289 we need to select the right one to pass to add_symbol_to_list().
290 We do it by keeping a pointer to the correct list in list_in_scope.
292 FIXME: The original dwarf code just treated the file scope as the
293 first local scope, and all other local scopes as nested local
294 scopes, and worked fine. Check to see if we really need to
295 distinguish these in buildsym.c. */
296 struct pending
**list_in_scope
;
298 /* Maintain an array of referenced fundamental types for the current
299 compilation unit being read. For DWARF version 1, we have to construct
300 the fundamental types on the fly, since no information about the
301 fundamental types is supplied. Each such fundamental type is created by
302 calling a language dependent routine to create the type, and then a
303 pointer to that type is then placed in the array at the index specified
304 by it's FT_<TYPENAME> value. The array has a fixed size set by the
305 FT_NUM_MEMBERS compile time constant, which is the number of predefined
306 fundamental types gdb knows how to construct. */
307 struct type
*ftypes
[FT_NUM_MEMBERS
]; /* Fundamental types */
309 /* DWARF abbreviation table associated with this compilation unit. */
310 struct abbrev_info
**dwarf2_abbrevs
;
312 /* Storage for the abbrev table. */
313 struct obstack abbrev_obstack
;
315 /* Hash table holding all the loaded partial DIEs. */
318 /* Storage for things with the same lifetime as this read-in compilation
319 unit, including partial DIEs. */
320 struct obstack comp_unit_obstack
;
322 /* When multiple dwarf2_cu structures are living in memory, this field
323 chains them all together, so that they can be released efficiently.
324 We will probably also want a generation counter so that most-recently-used
325 compilation units are cached... */
326 struct dwarf2_per_cu_data
*read_in_chain
;
328 /* Backchain to our per_cu entry if the tree has been built. */
329 struct dwarf2_per_cu_data
*per_cu
;
331 /* How many compilation units ago was this CU last referenced? */
334 /* A hash table of die offsets for following references. */
335 struct die_info
*die_ref_table
[REF_HASH_SIZE
];
337 /* Full DIEs if read in. */
338 struct die_info
*dies
;
340 /* A set of pointers to dwarf2_per_cu_data objects for compilation
341 units referenced by this one. Only set during full symbol processing;
342 partial symbol tables do not have dependencies. */
345 /* Mark used when releasing cached dies. */
346 unsigned int mark
: 1;
348 /* This flag will be set if this compilation unit might include
349 inter-compilation-unit references. */
350 unsigned int has_form_ref_addr
: 1;
352 /* This flag will be set if this compilation unit includes any
353 DW_TAG_namespace DIEs. If we know that there are explicit
354 DIEs for namespaces, we don't need to try to infer them
355 from mangled names. */
356 unsigned int has_namespace_info
: 1;
359 /* Persistent data held for a compilation unit, even when not
360 processing it. We put a pointer to this structure in the
361 read_symtab_private field of the psymtab. If we encounter
362 inter-compilation-unit references, we also maintain a sorted
363 list of all compilation units. */
365 struct dwarf2_per_cu_data
367 /* The start offset and length of this compilation unit. 2**30-1
368 bytes should suffice to store the length of any compilation unit
369 - if it doesn't, GDB will fall over anyway. */
370 unsigned long offset
;
371 unsigned long length
: 30;
373 /* Flag indicating this compilation unit will be read in before
374 any of the current compilation units are processed. */
375 unsigned long queued
: 1;
377 /* This flag will be set if we need to load absolutely all DIEs
378 for this compilation unit, instead of just the ones we think
379 are interesting. It gets set if we look for a DIE in the
380 hash table and don't find it. */
381 unsigned int load_all_dies
: 1;
383 /* Set iff currently read in. */
384 struct dwarf2_cu
*cu
;
386 /* If full symbols for this CU have been read in, then this field
387 holds a map of DIE offsets to types. It isn't always possible
388 to reconstruct this information later, so we have to preserve
392 /* The partial symbol table associated with this compilation unit. */
393 struct partial_symtab
*psymtab
;
396 /* The line number information for a compilation unit (found in the
397 .debug_line section) begins with a "statement program header",
398 which contains the following information. */
401 unsigned int total_length
;
402 unsigned short version
;
403 unsigned int header_length
;
404 unsigned char minimum_instruction_length
;
405 unsigned char default_is_stmt
;
407 unsigned char line_range
;
408 unsigned char opcode_base
;
410 /* standard_opcode_lengths[i] is the number of operands for the
411 standard opcode whose value is i. This means that
412 standard_opcode_lengths[0] is unused, and the last meaningful
413 element is standard_opcode_lengths[opcode_base - 1]. */
414 unsigned char *standard_opcode_lengths
;
416 /* The include_directories table. NOTE! These strings are not
417 allocated with xmalloc; instead, they are pointers into
418 debug_line_buffer. If you try to free them, `free' will get
420 unsigned int num_include_dirs
, include_dirs_size
;
423 /* The file_names table. NOTE! These strings are not allocated
424 with xmalloc; instead, they are pointers into debug_line_buffer.
425 Don't try to free them directly. */
426 unsigned int num_file_names
, file_names_size
;
430 unsigned int dir_index
;
431 unsigned int mod_time
;
433 int included_p
; /* Non-zero if referenced by the Line Number Program. */
436 /* The start and end of the statement program following this
437 header. These point into dwarf2_per_objfile->line_buffer. */
438 gdb_byte
*statement_program_start
, *statement_program_end
;
441 /* When we construct a partial symbol table entry we only
442 need this much information. */
443 struct partial_die_info
445 /* Offset of this DIE. */
448 /* DWARF-2 tag for this DIE. */
449 ENUM_BITFIELD(dwarf_tag
) tag
: 16;
451 /* Language code associated with this DIE. This is only used
452 for the compilation unit DIE. */
453 unsigned int language
: 8;
455 /* Assorted flags describing the data found in this DIE. */
456 unsigned int has_children
: 1;
457 unsigned int is_external
: 1;
458 unsigned int is_declaration
: 1;
459 unsigned int has_type
: 1;
460 unsigned int has_specification
: 1;
461 unsigned int has_stmt_list
: 1;
462 unsigned int has_pc_info
: 1;
464 /* Flag set if the SCOPE field of this structure has been
466 unsigned int scope_set
: 1;
468 /* The name of this DIE. Normally the value of DW_AT_name, but
469 sometimes DW_TAG_MIPS_linkage_name or a string computed in some
474 /* The scope to prepend to our children. This is generally
475 allocated on the comp_unit_obstack, so will disappear
476 when this compilation unit leaves the cache. */
479 /* The location description associated with this DIE, if any. */
480 struct dwarf_block
*locdesc
;
482 /* If HAS_PC_INFO, the PC range associated with this DIE. */
486 /* Pointer into the info_buffer pointing at the target of
487 DW_AT_sibling, if any. */
490 /* If HAS_SPECIFICATION, the offset of the DIE referred to by
491 DW_AT_specification (or DW_AT_abstract_origin or
493 unsigned int spec_offset
;
495 /* If HAS_STMT_LIST, the offset of the Line Number Information data. */
496 unsigned int line_offset
;
498 /* Pointers to this DIE's parent, first child, and next sibling,
500 struct partial_die_info
*die_parent
, *die_child
, *die_sibling
;
503 /* This data structure holds the information of an abbrev. */
506 unsigned int number
; /* number identifying abbrev */
507 enum dwarf_tag tag
; /* dwarf tag */
508 unsigned short has_children
; /* boolean */
509 unsigned short num_attrs
; /* number of attributes */
510 struct attr_abbrev
*attrs
; /* an array of attribute descriptions */
511 struct abbrev_info
*next
; /* next in chain */
516 enum dwarf_attribute name
;
517 enum dwarf_form form
;
520 /* This data structure holds a complete die structure. */
523 enum dwarf_tag tag
; /* Tag indicating type of die */
524 unsigned int abbrev
; /* Abbrev number */
525 unsigned int offset
; /* Offset in .debug_info section */
526 unsigned int num_attrs
; /* Number of attributes */
527 struct attribute
*attrs
; /* An array of attributes */
528 struct die_info
*next_ref
; /* Next die in ref hash table */
530 /* The dies in a compilation unit form an n-ary tree. PARENT
531 points to this die's parent; CHILD points to the first child of
532 this node; and all the children of a given node are chained
533 together via their SIBLING fields, terminated by a die whose
535 struct die_info
*child
; /* Its first child, if any. */
536 struct die_info
*sibling
; /* Its next sibling, if any. */
537 struct die_info
*parent
; /* Its parent, if any. */
539 struct type
*type
; /* Cached type information */
542 /* Attributes have a name and a value */
545 enum dwarf_attribute name
;
546 enum dwarf_form form
;
550 struct dwarf_block
*blk
;
558 struct function_range
561 CORE_ADDR lowpc
, highpc
;
563 struct function_range
*next
;
566 /* Get at parts of an attribute structure */
568 #define DW_STRING(attr) ((attr)->u.str)
569 #define DW_UNSND(attr) ((attr)->u.unsnd)
570 #define DW_BLOCK(attr) ((attr)->u.blk)
571 #define DW_SND(attr) ((attr)->u.snd)
572 #define DW_ADDR(attr) ((attr)->u.addr)
574 /* Blocks are a bunch of untyped bytes. */
581 #ifndef ATTR_ALLOC_CHUNK
582 #define ATTR_ALLOC_CHUNK 4
585 /* Allocate fields for structs, unions and enums in this size. */
586 #ifndef DW_FIELD_ALLOC_CHUNK
587 #define DW_FIELD_ALLOC_CHUNK 4
590 /* A zeroed version of a partial die for initialization purposes. */
591 static struct partial_die_info zeroed_partial_die
;
593 /* FIXME: We might want to set this from BFD via bfd_arch_bits_per_byte,
594 but this would require a corresponding change in unpack_field_as_long
596 static int bits_per_byte
= 8;
598 /* The routines that read and process dies for a C struct or C++ class
599 pass lists of data member fields and lists of member function fields
600 in an instance of a field_info structure, as defined below. */
603 /* List of data member and baseclasses fields. */
606 struct nextfield
*next
;
613 /* Number of fields. */
616 /* Number of baseclasses. */
619 /* Set if the accesibility of one of the fields is not public. */
620 int non_public_fields
;
622 /* Member function fields array, entries are allocated in the order they
623 are encountered in the object file. */
626 struct nextfnfield
*next
;
627 struct fn_field fnfield
;
631 /* Member function fieldlist array, contains name of possibly overloaded
632 member function, number of overloaded member functions and a pointer
633 to the head of the member function field chain. */
638 struct nextfnfield
*head
;
642 /* Number of entries in the fnfieldlists array. */
646 /* One item on the queue of compilation units to read in full symbols
648 struct dwarf2_queue_item
650 struct dwarf2_per_cu_data
*per_cu
;
651 struct dwarf2_queue_item
*next
;
654 /* The current queue. */
655 static struct dwarf2_queue_item
*dwarf2_queue
, *dwarf2_queue_tail
;
657 /* Loaded secondary compilation units are kept in memory until they
658 have not been referenced for the processing of this many
659 compilation units. Set this to zero to disable caching. Cache
660 sizes of up to at least twenty will improve startup time for
661 typical inter-CU-reference binaries, at an obvious memory cost. */
662 static int dwarf2_max_cache_age
= 5;
664 show_dwarf2_max_cache_age (struct ui_file
*file
, int from_tty
,
665 struct cmd_list_element
*c
, const char *value
)
667 fprintf_filtered (file
, _("\
668 The upper bound on the age of cached dwarf2 compilation units is %s.\n"),
673 /* Various complaints about symbol reading that don't abort the process */
676 dwarf2_statement_list_fits_in_line_number_section_complaint (void)
678 complaint (&symfile_complaints
,
679 _("statement list doesn't fit in .debug_line section"));
683 dwarf2_complex_location_expr_complaint (void)
685 complaint (&symfile_complaints
, _("location expression too complex"));
689 dwarf2_const_value_length_mismatch_complaint (const char *arg1
, int arg2
,
692 complaint (&symfile_complaints
,
693 _("const value length mismatch for '%s', got %d, expected %d"), arg1
,
698 dwarf2_macros_too_long_complaint (void)
700 complaint (&symfile_complaints
,
701 _("macro info runs off end of `.debug_macinfo' section"));
705 dwarf2_macro_malformed_definition_complaint (const char *arg1
)
707 complaint (&symfile_complaints
,
708 _("macro debug info contains a malformed macro definition:\n`%s'"),
713 dwarf2_invalid_attrib_class_complaint (const char *arg1
, const char *arg2
)
715 complaint (&symfile_complaints
,
716 _("invalid attribute class or form for '%s' in '%s'"), arg1
, arg2
);
719 /* local function prototypes */
721 static void dwarf2_locate_sections (bfd
*, asection
*, void *);
724 static void dwarf2_build_psymtabs_easy (struct objfile
*, int);
727 static void dwarf2_create_include_psymtab (char *, struct partial_symtab
*,
730 static void dwarf2_build_include_psymtabs (struct dwarf2_cu
*,
731 struct partial_die_info
*,
732 struct partial_symtab
*);
734 static void dwarf2_build_psymtabs_hard (struct objfile
*, int);
736 static void scan_partial_symbols (struct partial_die_info
*,
737 CORE_ADDR
*, CORE_ADDR
*,
740 static void add_partial_symbol (struct partial_die_info
*,
743 static int pdi_needs_namespace (enum dwarf_tag tag
);
745 static void add_partial_namespace (struct partial_die_info
*pdi
,
746 CORE_ADDR
*lowpc
, CORE_ADDR
*highpc
,
747 struct dwarf2_cu
*cu
);
749 static void add_partial_enumeration (struct partial_die_info
*enum_pdi
,
750 struct dwarf2_cu
*cu
);
752 static gdb_byte
*locate_pdi_sibling (struct partial_die_info
*orig_pdi
,
755 struct dwarf2_cu
*cu
);
757 static void dwarf2_psymtab_to_symtab (struct partial_symtab
*);
759 static void psymtab_to_symtab_1 (struct partial_symtab
*);
761 gdb_byte
*dwarf2_read_section (struct objfile
*, asection
*);
763 static void dwarf2_read_abbrevs (bfd
*abfd
, struct dwarf2_cu
*cu
);
765 static void dwarf2_free_abbrev_table (void *);
767 static struct abbrev_info
*peek_die_abbrev (gdb_byte
*, unsigned int *,
770 static struct abbrev_info
*dwarf2_lookup_abbrev (unsigned int,
773 static struct partial_die_info
*load_partial_dies (bfd
*, gdb_byte
*, int,
776 static gdb_byte
*read_partial_die (struct partial_die_info
*,
777 struct abbrev_info
*abbrev
, unsigned int,
778 bfd
*, gdb_byte
*, struct dwarf2_cu
*);
780 static struct partial_die_info
*find_partial_die (unsigned long,
783 static void fixup_partial_die (struct partial_die_info
*,
786 static gdb_byte
*read_full_die (struct die_info
**, bfd
*, gdb_byte
*,
787 struct dwarf2_cu
*, int *);
789 static gdb_byte
*read_attribute (struct attribute
*, struct attr_abbrev
*,
790 bfd
*, gdb_byte
*, struct dwarf2_cu
*);
792 static gdb_byte
*read_attribute_value (struct attribute
*, unsigned,
793 bfd
*, gdb_byte
*, struct dwarf2_cu
*);
795 static unsigned int read_1_byte (bfd
*, gdb_byte
*);
797 static int read_1_signed_byte (bfd
*, gdb_byte
*);
799 static unsigned int read_2_bytes (bfd
*, gdb_byte
*);
801 static unsigned int read_4_bytes (bfd
*, gdb_byte
*);
803 static unsigned long read_8_bytes (bfd
*, gdb_byte
*);
805 static CORE_ADDR
read_address (bfd
*, gdb_byte
*ptr
, struct dwarf2_cu
*,
808 static LONGEST
read_initial_length (bfd
*, gdb_byte
*,
809 struct comp_unit_head
*, unsigned int *);
811 static LONGEST
read_offset (bfd
*, gdb_byte
*, const struct comp_unit_head
*,
814 static gdb_byte
*read_n_bytes (bfd
*, gdb_byte
*, unsigned int);
816 static char *read_string (bfd
*, gdb_byte
*, unsigned int *);
818 static char *read_indirect_string (bfd
*, gdb_byte
*,
819 const struct comp_unit_head
*,
822 static unsigned long read_unsigned_leb128 (bfd
*, gdb_byte
*, unsigned int *);
824 static long read_signed_leb128 (bfd
*, gdb_byte
*, unsigned int *);
826 static gdb_byte
*skip_leb128 (bfd
*, gdb_byte
*);
828 static void set_cu_language (unsigned int, struct dwarf2_cu
*);
830 static struct attribute
*dwarf2_attr (struct die_info
*, unsigned int,
833 static int dwarf2_flag_true_p (struct die_info
*die
, unsigned name
,
834 struct dwarf2_cu
*cu
);
836 static int die_is_declaration (struct die_info
*, struct dwarf2_cu
*cu
);
838 static struct die_info
*die_specification (struct die_info
*die
,
841 static void free_line_header (struct line_header
*lh
);
843 static void add_file_name (struct line_header
*, char *, unsigned int,
844 unsigned int, unsigned int);
846 static struct line_header
*(dwarf_decode_line_header
847 (unsigned int offset
,
848 bfd
*abfd
, struct dwarf2_cu
*cu
));
850 static void dwarf_decode_lines (struct line_header
*, char *, bfd
*,
851 struct dwarf2_cu
*, struct partial_symtab
*);
853 static void dwarf2_start_subfile (char *, char *, char *);
855 static struct symbol
*new_symbol (struct die_info
*, struct type
*,
858 static void dwarf2_const_value (struct attribute
*, struct symbol
*,
861 static void dwarf2_const_value_data (struct attribute
*attr
,
865 static struct type
*die_type (struct die_info
*, struct dwarf2_cu
*);
867 static struct type
*die_containing_type (struct die_info
*,
870 static struct type
*tag_type_to_type (struct die_info
*, struct dwarf2_cu
*);
872 static void read_type_die (struct die_info
*, struct dwarf2_cu
*);
874 static char *determine_prefix (struct die_info
*die
, struct dwarf2_cu
*);
876 static char *typename_concat (struct obstack
*,
881 static void read_typedef (struct die_info
*, struct dwarf2_cu
*);
883 static void read_base_type (struct die_info
*, struct dwarf2_cu
*);
885 static void read_subrange_type (struct die_info
*die
, struct dwarf2_cu
*cu
);
887 static void read_file_scope (struct die_info
*, struct dwarf2_cu
*);
889 static void read_func_scope (struct die_info
*, struct dwarf2_cu
*);
891 static void read_lexical_block_scope (struct die_info
*, struct dwarf2_cu
*);
893 static int dwarf2_get_pc_bounds (struct die_info
*,
894 CORE_ADDR
*, CORE_ADDR
*, struct dwarf2_cu
*);
896 static void get_scope_pc_bounds (struct die_info
*,
897 CORE_ADDR
*, CORE_ADDR
*,
900 static void dwarf2_add_field (struct field_info
*, struct die_info
*,
903 static void dwarf2_attach_fields_to_type (struct field_info
*,
904 struct type
*, struct dwarf2_cu
*);
906 static void dwarf2_add_member_fn (struct field_info
*,
907 struct die_info
*, struct type
*,
910 static void dwarf2_attach_fn_fields_to_type (struct field_info
*,
911 struct type
*, struct dwarf2_cu
*);
913 static void read_structure_type (struct die_info
*, struct dwarf2_cu
*);
915 static void process_structure_scope (struct die_info
*, struct dwarf2_cu
*);
917 static char *determine_class_name (struct die_info
*die
, struct dwarf2_cu
*cu
);
919 static void read_common_block (struct die_info
*, struct dwarf2_cu
*);
921 static void read_namespace (struct die_info
*die
, struct dwarf2_cu
*);
923 static const char *namespace_name (struct die_info
*die
,
924 int *is_anonymous
, struct dwarf2_cu
*);
926 static void read_enumeration_type (struct die_info
*, struct dwarf2_cu
*);
928 static void process_enumeration_scope (struct die_info
*, struct dwarf2_cu
*);
930 static struct type
*dwarf_base_type (int, int, struct dwarf2_cu
*);
932 static CORE_ADDR
decode_locdesc (struct dwarf_block
*, struct dwarf2_cu
*);
934 static void read_array_type (struct die_info
*, struct dwarf2_cu
*);
936 static enum dwarf_array_dim_ordering
read_array_order (struct die_info
*,
939 static void read_tag_pointer_type (struct die_info
*, struct dwarf2_cu
*);
941 static void read_tag_ptr_to_member_type (struct die_info
*,
944 static void read_tag_reference_type (struct die_info
*, struct dwarf2_cu
*);
946 static void read_tag_const_type (struct die_info
*, struct dwarf2_cu
*);
948 static void read_tag_volatile_type (struct die_info
*, struct dwarf2_cu
*);
950 static void read_tag_string_type (struct die_info
*, struct dwarf2_cu
*);
952 static void read_subroutine_type (struct die_info
*, struct dwarf2_cu
*);
954 static struct die_info
*read_comp_unit (gdb_byte
*, bfd
*, struct dwarf2_cu
*);
956 static struct die_info
*read_die_and_children (gdb_byte
*info_ptr
, bfd
*abfd
,
958 gdb_byte
**new_info_ptr
,
959 struct die_info
*parent
);
961 static struct die_info
*read_die_and_siblings (gdb_byte
*info_ptr
, bfd
*abfd
,
963 gdb_byte
**new_info_ptr
,
964 struct die_info
*parent
);
966 static void free_die_list (struct die_info
*);
968 static void process_die (struct die_info
*, struct dwarf2_cu
*);
970 static char *dwarf2_linkage_name (struct die_info
*, struct dwarf2_cu
*);
972 static char *dwarf2_name (struct die_info
*die
, struct dwarf2_cu
*);
974 static struct die_info
*dwarf2_extension (struct die_info
*die
,
977 static char *dwarf_tag_name (unsigned int);
979 static char *dwarf_attr_name (unsigned int);
981 static char *dwarf_form_name (unsigned int);
983 static char *dwarf_stack_op_name (unsigned int);
985 static char *dwarf_bool_name (unsigned int);
987 static char *dwarf_type_encoding_name (unsigned int);
990 static char *dwarf_cfi_name (unsigned int);
992 struct die_info
*copy_die (struct die_info
*);
995 static struct die_info
*sibling_die (struct die_info
*);
997 static void dump_die (struct die_info
*);
999 static void dump_die_list (struct die_info
*);
1001 static void store_in_ref_table (unsigned int, struct die_info
*,
1002 struct dwarf2_cu
*);
1004 static unsigned int dwarf2_get_ref_die_offset (struct attribute
*,
1005 struct dwarf2_cu
*);
1007 static int dwarf2_get_attr_constant_value (struct attribute
*, int);
1009 static struct die_info
*follow_die_ref (struct die_info
*,
1011 struct dwarf2_cu
*);
1013 static struct type
*dwarf2_fundamental_type (struct objfile
*, int,
1014 struct dwarf2_cu
*);
1016 /* memory allocation interface */
1018 static struct dwarf_block
*dwarf_alloc_block (struct dwarf2_cu
*);
1020 static struct abbrev_info
*dwarf_alloc_abbrev (struct dwarf2_cu
*);
1022 static struct die_info
*dwarf_alloc_die (void);
1024 static void initialize_cu_func_list (struct dwarf2_cu
*);
1026 static void add_to_cu_func_list (const char *, CORE_ADDR
, CORE_ADDR
,
1027 struct dwarf2_cu
*);
1029 static void dwarf_decode_macros (struct line_header
*, unsigned int,
1030 char *, bfd
*, struct dwarf2_cu
*);
1032 static int attr_form_is_block (struct attribute
*);
1035 dwarf2_symbol_mark_computed (struct attribute
*attr
, struct symbol
*sym
,
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
*);
1071 static void process_full_comp_unit (struct dwarf2_per_cu_data
*);
1073 static void dwarf2_add_dependence (struct dwarf2_cu
*,
1074 struct dwarf2_per_cu_data
*);
1076 static void dwarf2_mark (struct dwarf2_cu
*);
1078 static void dwarf2_clear_marks (struct dwarf2_per_cu_data
*);
1080 static void read_set_type (struct die_info
*, struct dwarf2_cu
*);
1083 /* Try to locate the sections we need for DWARF 2 debugging
1084 information and return true if we have enough to do something. */
1087 dwarf2_has_info (struct objfile
*objfile
)
1089 struct dwarf2_per_objfile
*data
;
1091 /* Initialize per-objfile state. */
1092 data
= obstack_alloc (&objfile
->objfile_obstack
, sizeof (*data
));
1093 memset (data
, 0, sizeof (*data
));
1094 set_objfile_data (objfile
, dwarf2_objfile_data_key
, data
);
1095 dwarf2_per_objfile
= data
;
1097 dwarf_info_section
= 0;
1098 dwarf_abbrev_section
= 0;
1099 dwarf_line_section
= 0;
1100 dwarf_str_section
= 0;
1101 dwarf_macinfo_section
= 0;
1102 dwarf_frame_section
= 0;
1103 dwarf_eh_frame_section
= 0;
1104 dwarf_ranges_section
= 0;
1105 dwarf_loc_section
= 0;
1107 bfd_map_over_sections (objfile
->obfd
, dwarf2_locate_sections
, NULL
);
1108 return (dwarf_info_section
!= NULL
&& dwarf_abbrev_section
!= NULL
);
1111 /* This function is mapped across the sections and remembers the
1112 offset and size of each of the debugging sections we are interested
1116 dwarf2_locate_sections (bfd
*abfd
, asection
*sectp
, void *ignore_ptr
)
1118 if (strcmp (sectp
->name
, INFO_SECTION
) == 0)
1120 dwarf2_per_objfile
->info_size
= bfd_get_section_size (sectp
);
1121 dwarf_info_section
= sectp
;
1123 else if (strcmp (sectp
->name
, ABBREV_SECTION
) == 0)
1125 dwarf2_per_objfile
->abbrev_size
= bfd_get_section_size (sectp
);
1126 dwarf_abbrev_section
= sectp
;
1128 else if (strcmp (sectp
->name
, LINE_SECTION
) == 0)
1130 dwarf2_per_objfile
->line_size
= bfd_get_section_size (sectp
);
1131 dwarf_line_section
= sectp
;
1133 else if (strcmp (sectp
->name
, PUBNAMES_SECTION
) == 0)
1135 dwarf2_per_objfile
->pubnames_size
= bfd_get_section_size (sectp
);
1136 dwarf_pubnames_section
= sectp
;
1138 else if (strcmp (sectp
->name
, ARANGES_SECTION
) == 0)
1140 dwarf2_per_objfile
->aranges_size
= bfd_get_section_size (sectp
);
1141 dwarf_aranges_section
= sectp
;
1143 else if (strcmp (sectp
->name
, LOC_SECTION
) == 0)
1145 dwarf2_per_objfile
->loc_size
= bfd_get_section_size (sectp
);
1146 dwarf_loc_section
= sectp
;
1148 else if (strcmp (sectp
->name
, MACINFO_SECTION
) == 0)
1150 dwarf2_per_objfile
->macinfo_size
= bfd_get_section_size (sectp
);
1151 dwarf_macinfo_section
= sectp
;
1153 else if (strcmp (sectp
->name
, STR_SECTION
) == 0)
1155 dwarf2_per_objfile
->str_size
= bfd_get_section_size (sectp
);
1156 dwarf_str_section
= sectp
;
1158 else if (strcmp (sectp
->name
, FRAME_SECTION
) == 0)
1160 dwarf2_per_objfile
->frame_size
= bfd_get_section_size (sectp
);
1161 dwarf_frame_section
= sectp
;
1163 else if (strcmp (sectp
->name
, EH_FRAME_SECTION
) == 0)
1165 flagword aflag
= bfd_get_section_flags (ignore_abfd
, sectp
);
1166 if (aflag
& SEC_HAS_CONTENTS
)
1168 dwarf2_per_objfile
->eh_frame_size
= bfd_get_section_size (sectp
);
1169 dwarf_eh_frame_section
= sectp
;
1172 else if (strcmp (sectp
->name
, RANGES_SECTION
) == 0)
1174 dwarf2_per_objfile
->ranges_size
= bfd_get_section_size (sectp
);
1175 dwarf_ranges_section
= sectp
;
1178 if ((bfd_get_section_flags (abfd
, sectp
) & SEC_LOAD
)
1179 && bfd_section_vma (abfd
, sectp
) == 0)
1180 dwarf2_per_objfile
->has_section_at_zero
= 1;
1183 /* Build a partial symbol table. */
1186 dwarf2_build_psymtabs (struct objfile
*objfile
, int mainline
)
1188 /* We definitely need the .debug_info and .debug_abbrev sections */
1190 dwarf2_per_objfile
->info_buffer
= dwarf2_read_section (objfile
, dwarf_info_section
);
1191 dwarf2_per_objfile
->abbrev_buffer
= dwarf2_read_section (objfile
, dwarf_abbrev_section
);
1193 if (dwarf_line_section
)
1194 dwarf2_per_objfile
->line_buffer
= dwarf2_read_section (objfile
, dwarf_line_section
);
1196 dwarf2_per_objfile
->line_buffer
= NULL
;
1198 if (dwarf_str_section
)
1199 dwarf2_per_objfile
->str_buffer
= dwarf2_read_section (objfile
, dwarf_str_section
);
1201 dwarf2_per_objfile
->str_buffer
= NULL
;
1203 if (dwarf_macinfo_section
)
1204 dwarf2_per_objfile
->macinfo_buffer
= dwarf2_read_section (objfile
,
1205 dwarf_macinfo_section
);
1207 dwarf2_per_objfile
->macinfo_buffer
= NULL
;
1209 if (dwarf_ranges_section
)
1210 dwarf2_per_objfile
->ranges_buffer
= dwarf2_read_section (objfile
, dwarf_ranges_section
);
1212 dwarf2_per_objfile
->ranges_buffer
= NULL
;
1214 if (dwarf_loc_section
)
1215 dwarf2_per_objfile
->loc_buffer
= dwarf2_read_section (objfile
, dwarf_loc_section
);
1217 dwarf2_per_objfile
->loc_buffer
= NULL
;
1220 || (objfile
->global_psymbols
.size
== 0
1221 && objfile
->static_psymbols
.size
== 0))
1223 init_psymbol_list (objfile
, 1024);
1227 if (dwarf_aranges_offset
&& dwarf_pubnames_offset
)
1229 /* Things are significantly easier if we have .debug_aranges and
1230 .debug_pubnames sections */
1232 dwarf2_build_psymtabs_easy (objfile
, mainline
);
1236 /* only test this case for now */
1238 /* In this case we have to work a bit harder */
1239 dwarf2_build_psymtabs_hard (objfile
, mainline
);
1244 /* Build the partial symbol table from the information in the
1245 .debug_pubnames and .debug_aranges sections. */
1248 dwarf2_build_psymtabs_easy (struct objfile
*objfile
, int mainline
)
1250 bfd
*abfd
= objfile
->obfd
;
1251 char *aranges_buffer
, *pubnames_buffer
;
1252 char *aranges_ptr
, *pubnames_ptr
;
1253 unsigned int entry_length
, version
, info_offset
, info_size
;
1255 pubnames_buffer
= dwarf2_read_section (objfile
,
1256 dwarf_pubnames_section
);
1257 pubnames_ptr
= pubnames_buffer
;
1258 while ((pubnames_ptr
- pubnames_buffer
) < dwarf2_per_objfile
->pubnames_size
)
1260 struct comp_unit_head cu_header
;
1261 unsigned int bytes_read
;
1263 entry_length
= read_initial_length (abfd
, pubnames_ptr
, &cu_header
,
1265 pubnames_ptr
+= bytes_read
;
1266 version
= read_1_byte (abfd
, pubnames_ptr
);
1268 info_offset
= read_4_bytes (abfd
, pubnames_ptr
);
1270 info_size
= read_4_bytes (abfd
, pubnames_ptr
);
1274 aranges_buffer
= dwarf2_read_section (objfile
,
1275 dwarf_aranges_section
);
1280 /* Read in the comp unit header information from the debug_info at
1284 read_comp_unit_head (struct comp_unit_head
*cu_header
,
1285 gdb_byte
*info_ptr
, bfd
*abfd
)
1288 unsigned int bytes_read
;
1289 cu_header
->length
= read_initial_length (abfd
, info_ptr
, cu_header
,
1291 info_ptr
+= bytes_read
;
1292 cu_header
->version
= read_2_bytes (abfd
, info_ptr
);
1294 cu_header
->abbrev_offset
= read_offset (abfd
, info_ptr
, cu_header
,
1296 info_ptr
+= bytes_read
;
1297 cu_header
->addr_size
= read_1_byte (abfd
, info_ptr
);
1299 signed_addr
= bfd_get_sign_extend_vma (abfd
);
1300 if (signed_addr
< 0)
1301 internal_error (__FILE__
, __LINE__
,
1302 _("read_comp_unit_head: dwarf from non elf file"));
1303 cu_header
->signed_addr_p
= signed_addr
;
1308 partial_read_comp_unit_head (struct comp_unit_head
*header
, gdb_byte
*info_ptr
,
1311 gdb_byte
*beg_of_comp_unit
= info_ptr
;
1313 info_ptr
= read_comp_unit_head (header
, info_ptr
, abfd
);
1315 if (header
->version
!= 2 && header
->version
!= 3)
1316 error (_("Dwarf Error: wrong version in compilation unit header "
1317 "(is %d, should be %d) [in module %s]"), header
->version
,
1318 2, bfd_get_filename (abfd
));
1320 if (header
->abbrev_offset
>= dwarf2_per_objfile
->abbrev_size
)
1321 error (_("Dwarf Error: bad offset (0x%lx) in compilation unit header "
1322 "(offset 0x%lx + 6) [in module %s]"),
1323 (long) header
->abbrev_offset
,
1324 (long) (beg_of_comp_unit
- dwarf2_per_objfile
->info_buffer
),
1325 bfd_get_filename (abfd
));
1327 if (beg_of_comp_unit
+ header
->length
+ header
->initial_length_size
1328 > dwarf2_per_objfile
->info_buffer
+ dwarf2_per_objfile
->info_size
)
1329 error (_("Dwarf Error: bad length (0x%lx) in compilation unit header "
1330 "(offset 0x%lx + 0) [in module %s]"),
1331 (long) header
->length
,
1332 (long) (beg_of_comp_unit
- dwarf2_per_objfile
->info_buffer
),
1333 bfd_get_filename (abfd
));
1338 /* Allocate a new partial symtab for file named NAME and mark this new
1339 partial symtab as being an include of PST. */
1342 dwarf2_create_include_psymtab (char *name
, struct partial_symtab
*pst
,
1343 struct objfile
*objfile
)
1345 struct partial_symtab
*subpst
= allocate_psymtab (name
, objfile
);
1347 subpst
->section_offsets
= pst
->section_offsets
;
1348 subpst
->textlow
= 0;
1349 subpst
->texthigh
= 0;
1351 subpst
->dependencies
= (struct partial_symtab
**)
1352 obstack_alloc (&objfile
->objfile_obstack
,
1353 sizeof (struct partial_symtab
*));
1354 subpst
->dependencies
[0] = pst
;
1355 subpst
->number_of_dependencies
= 1;
1357 subpst
->globals_offset
= 0;
1358 subpst
->n_global_syms
= 0;
1359 subpst
->statics_offset
= 0;
1360 subpst
->n_static_syms
= 0;
1361 subpst
->symtab
= NULL
;
1362 subpst
->read_symtab
= pst
->read_symtab
;
1365 /* No private part is necessary for include psymtabs. This property
1366 can be used to differentiate between such include psymtabs and
1367 the regular ones. */
1368 subpst
->read_symtab_private
= NULL
;
1371 /* Read the Line Number Program data and extract the list of files
1372 included by the source file represented by PST. Build an include
1373 partial symtab for each of these included files.
1375 This procedure assumes that there *is* a Line Number Program in
1376 the given CU. Callers should check that PDI->HAS_STMT_LIST is set
1377 before calling this procedure. */
1380 dwarf2_build_include_psymtabs (struct dwarf2_cu
*cu
,
1381 struct partial_die_info
*pdi
,
1382 struct partial_symtab
*pst
)
1384 struct objfile
*objfile
= cu
->objfile
;
1385 bfd
*abfd
= objfile
->obfd
;
1386 struct line_header
*lh
;
1388 lh
= dwarf_decode_line_header (pdi
->line_offset
, abfd
, cu
);
1390 return; /* No linetable, so no includes. */
1392 dwarf_decode_lines (lh
, NULL
, abfd
, cu
, pst
);
1394 free_line_header (lh
);
1398 /* Build the partial symbol table by doing a quick pass through the
1399 .debug_info and .debug_abbrev sections. */
1402 dwarf2_build_psymtabs_hard (struct objfile
*objfile
, int mainline
)
1404 /* Instead of reading this into a big buffer, we should probably use
1405 mmap() on architectures that support it. (FIXME) */
1406 bfd
*abfd
= objfile
->obfd
;
1408 gdb_byte
*beg_of_comp_unit
;
1409 struct partial_die_info comp_unit_die
;
1410 struct partial_symtab
*pst
;
1411 struct cleanup
*back_to
;
1412 CORE_ADDR lowpc
, highpc
, baseaddr
;
1414 info_ptr
= dwarf2_per_objfile
->info_buffer
;
1416 /* Any cached compilation units will be linked by the per-objfile
1417 read_in_chain. Make sure to free them when we're done. */
1418 back_to
= make_cleanup (free_cached_comp_units
, NULL
);
1420 create_all_comp_units (objfile
);
1422 /* Since the objects we're extracting from .debug_info vary in
1423 length, only the individual functions to extract them (like
1424 read_comp_unit_head and load_partial_die) can really know whether
1425 the buffer is large enough to hold another complete object.
1427 At the moment, they don't actually check that. If .debug_info
1428 holds just one extra byte after the last compilation unit's dies,
1429 then read_comp_unit_head will happily read off the end of the
1430 buffer. read_partial_die is similarly casual. Those functions
1433 For this loop condition, simply checking whether there's any data
1434 left at all should be sufficient. */
1435 while (info_ptr
< (dwarf2_per_objfile
->info_buffer
1436 + dwarf2_per_objfile
->info_size
))
1438 struct cleanup
*back_to_inner
;
1439 struct dwarf2_cu cu
;
1440 struct abbrev_info
*abbrev
;
1441 unsigned int bytes_read
;
1442 struct dwarf2_per_cu_data
*this_cu
;
1444 beg_of_comp_unit
= info_ptr
;
1446 memset (&cu
, 0, sizeof (cu
));
1448 obstack_init (&cu
.comp_unit_obstack
);
1450 back_to_inner
= make_cleanup (free_stack_comp_unit
, &cu
);
1452 cu
.objfile
= objfile
;
1453 info_ptr
= partial_read_comp_unit_head (&cu
.header
, info_ptr
, abfd
);
1455 /* Complete the cu_header */
1456 cu
.header
.offset
= beg_of_comp_unit
- dwarf2_per_objfile
->info_buffer
;
1457 cu
.header
.first_die_ptr
= info_ptr
;
1458 cu
.header
.cu_head_ptr
= beg_of_comp_unit
;
1460 cu
.list_in_scope
= &file_symbols
;
1462 /* Read the abbrevs for this compilation unit into a table */
1463 dwarf2_read_abbrevs (abfd
, &cu
);
1464 make_cleanup (dwarf2_free_abbrev_table
, &cu
);
1466 this_cu
= dwarf2_find_comp_unit (cu
.header
.offset
, objfile
);
1468 /* Read the compilation unit die */
1469 abbrev
= peek_die_abbrev (info_ptr
, &bytes_read
, &cu
);
1470 info_ptr
= read_partial_die (&comp_unit_die
, abbrev
, bytes_read
,
1471 abfd
, info_ptr
, &cu
);
1473 /* Set the language we're debugging */
1474 set_cu_language (comp_unit_die
.language
, &cu
);
1476 /* Allocate a new partial symbol table structure */
1477 pst
= start_psymtab_common (objfile
, objfile
->section_offsets
,
1478 comp_unit_die
.name
? comp_unit_die
.name
: "",
1479 comp_unit_die
.lowpc
,
1480 objfile
->global_psymbols
.next
,
1481 objfile
->static_psymbols
.next
);
1483 if (comp_unit_die
.dirname
)
1484 pst
->dirname
= xstrdup (comp_unit_die
.dirname
);
1486 pst
->read_symtab_private
= (char *) this_cu
;
1488 baseaddr
= ANOFFSET (objfile
->section_offsets
, SECT_OFF_TEXT (objfile
));
1490 /* Store the function that reads in the rest of the symbol table */
1491 pst
->read_symtab
= dwarf2_psymtab_to_symtab
;
1493 /* If this compilation unit was already read in, free the
1494 cached copy in order to read it in again. This is
1495 necessary because we skipped some symbols when we first
1496 read in the compilation unit (see load_partial_dies).
1497 This problem could be avoided, but the benefit is
1499 if (this_cu
->cu
!= NULL
)
1500 free_one_cached_comp_unit (this_cu
->cu
);
1502 cu
.per_cu
= this_cu
;
1504 /* Note that this is a pointer to our stack frame, being
1505 added to a global data structure. It will be cleaned up
1506 in free_stack_comp_unit when we finish with this
1507 compilation unit. */
1510 this_cu
->psymtab
= pst
;
1512 /* Check if comp unit has_children.
1513 If so, read the rest of the partial symbols from this comp unit.
1514 If not, there's no more debug_info for this comp unit. */
1515 if (comp_unit_die
.has_children
)
1517 struct partial_die_info
*first_die
;
1519 lowpc
= ((CORE_ADDR
) -1);
1520 highpc
= ((CORE_ADDR
) 0);
1522 first_die
= load_partial_dies (abfd
, info_ptr
, 1, &cu
);
1524 scan_partial_symbols (first_die
, &lowpc
, &highpc
, &cu
);
1526 /* If we didn't find a lowpc, set it to highpc to avoid
1527 complaints from `maint check'. */
1528 if (lowpc
== ((CORE_ADDR
) -1))
1531 /* If the compilation unit didn't have an explicit address range,
1532 then use the information extracted from its child dies. */
1533 if (! comp_unit_die
.has_pc_info
)
1535 comp_unit_die
.lowpc
= lowpc
;
1536 comp_unit_die
.highpc
= highpc
;
1539 pst
->textlow
= comp_unit_die
.lowpc
+ baseaddr
;
1540 pst
->texthigh
= comp_unit_die
.highpc
+ baseaddr
;
1542 pst
->n_global_syms
= objfile
->global_psymbols
.next
-
1543 (objfile
->global_psymbols
.list
+ pst
->globals_offset
);
1544 pst
->n_static_syms
= objfile
->static_psymbols
.next
-
1545 (objfile
->static_psymbols
.list
+ pst
->statics_offset
);
1546 sort_pst_symbols (pst
);
1548 /* If there is already a psymtab or symtab for a file of this
1549 name, remove it. (If there is a symtab, more drastic things
1550 also happen.) This happens in VxWorks. */
1551 free_named_symtabs (pst
->filename
);
1553 info_ptr
= beg_of_comp_unit
+ cu
.header
.length
1554 + cu
.header
.initial_length_size
;
1556 if (comp_unit_die
.has_stmt_list
)
1558 /* Get the list of files included in the current compilation unit,
1559 and build a psymtab for each of them. */
1560 dwarf2_build_include_psymtabs (&cu
, &comp_unit_die
, pst
);
1563 do_cleanups (back_to_inner
);
1565 do_cleanups (back_to
);
1568 /* Load the DIEs for a secondary CU into memory. */
1571 load_comp_unit (struct dwarf2_per_cu_data
*this_cu
, struct objfile
*objfile
)
1573 bfd
*abfd
= objfile
->obfd
;
1574 gdb_byte
*info_ptr
, *beg_of_comp_unit
;
1575 struct partial_die_info comp_unit_die
;
1576 struct dwarf2_cu
*cu
;
1577 struct abbrev_info
*abbrev
;
1578 unsigned int bytes_read
;
1579 struct cleanup
*back_to
;
1581 info_ptr
= dwarf2_per_objfile
->info_buffer
+ this_cu
->offset
;
1582 beg_of_comp_unit
= info_ptr
;
1584 cu
= xmalloc (sizeof (struct dwarf2_cu
));
1585 memset (cu
, 0, sizeof (struct dwarf2_cu
));
1587 obstack_init (&cu
->comp_unit_obstack
);
1589 cu
->objfile
= objfile
;
1590 info_ptr
= partial_read_comp_unit_head (&cu
->header
, info_ptr
, abfd
);
1592 /* Complete the cu_header. */
1593 cu
->header
.offset
= beg_of_comp_unit
- dwarf2_per_objfile
->info_buffer
;
1594 cu
->header
.first_die_ptr
= info_ptr
;
1595 cu
->header
.cu_head_ptr
= beg_of_comp_unit
;
1597 /* Read the abbrevs for this compilation unit into a table. */
1598 dwarf2_read_abbrevs (abfd
, cu
);
1599 back_to
= make_cleanup (dwarf2_free_abbrev_table
, cu
);
1601 /* Read the compilation unit die. */
1602 abbrev
= peek_die_abbrev (info_ptr
, &bytes_read
, cu
);
1603 info_ptr
= read_partial_die (&comp_unit_die
, abbrev
, bytes_read
,
1604 abfd
, info_ptr
, cu
);
1606 /* Set the language we're debugging. */
1607 set_cu_language (comp_unit_die
.language
, cu
);
1609 /* Link this compilation unit into the compilation unit tree. */
1611 cu
->per_cu
= this_cu
;
1613 /* Check if comp unit has_children.
1614 If so, read the rest of the partial symbols from this comp unit.
1615 If not, there's no more debug_info for this comp unit. */
1616 if (comp_unit_die
.has_children
)
1617 load_partial_dies (abfd
, info_ptr
, 0, cu
);
1619 do_cleanups (back_to
);
1622 /* Create a list of all compilation units in OBJFILE. We do this only
1623 if an inter-comp-unit reference is found; presumably if there is one,
1624 there will be many, and one will occur early in the .debug_info section.
1625 So there's no point in building this list incrementally. */
1628 create_all_comp_units (struct objfile
*objfile
)
1632 struct dwarf2_per_cu_data
**all_comp_units
;
1633 gdb_byte
*info_ptr
= dwarf2_per_objfile
->info_buffer
;
1637 all_comp_units
= xmalloc (n_allocated
1638 * sizeof (struct dwarf2_per_cu_data
*));
1640 while (info_ptr
< dwarf2_per_objfile
->info_buffer
+ dwarf2_per_objfile
->info_size
)
1642 struct comp_unit_head cu_header
;
1643 gdb_byte
*beg_of_comp_unit
;
1644 struct dwarf2_per_cu_data
*this_cu
;
1645 unsigned long offset
;
1646 unsigned int bytes_read
;
1648 offset
= info_ptr
- dwarf2_per_objfile
->info_buffer
;
1650 /* Read just enough information to find out where the next
1651 compilation unit is. */
1652 cu_header
.initial_length_size
= 0;
1653 cu_header
.length
= read_initial_length (objfile
->obfd
, info_ptr
,
1654 &cu_header
, &bytes_read
);
1656 /* Save the compilation unit for later lookup. */
1657 this_cu
= obstack_alloc (&objfile
->objfile_obstack
,
1658 sizeof (struct dwarf2_per_cu_data
));
1659 memset (this_cu
, 0, sizeof (*this_cu
));
1660 this_cu
->offset
= offset
;
1661 this_cu
->length
= cu_header
.length
+ cu_header
.initial_length_size
;
1663 if (n_comp_units
== n_allocated
)
1666 all_comp_units
= xrealloc (all_comp_units
,
1668 * sizeof (struct dwarf2_per_cu_data
*));
1670 all_comp_units
[n_comp_units
++] = this_cu
;
1672 info_ptr
= info_ptr
+ this_cu
->length
;
1675 dwarf2_per_objfile
->all_comp_units
1676 = obstack_alloc (&objfile
->objfile_obstack
,
1677 n_comp_units
* sizeof (struct dwarf2_per_cu_data
*));
1678 memcpy (dwarf2_per_objfile
->all_comp_units
, all_comp_units
,
1679 n_comp_units
* sizeof (struct dwarf2_per_cu_data
*));
1680 xfree (all_comp_units
);
1681 dwarf2_per_objfile
->n_comp_units
= n_comp_units
;
1684 /* Process all loaded DIEs for compilation unit CU, starting at FIRST_DIE.
1685 Also set *LOWPC and *HIGHPC to the lowest and highest PC values found
1689 scan_partial_symbols (struct partial_die_info
*first_die
, CORE_ADDR
*lowpc
,
1690 CORE_ADDR
*highpc
, struct dwarf2_cu
*cu
)
1692 struct objfile
*objfile
= cu
->objfile
;
1693 bfd
*abfd
= objfile
->obfd
;
1694 struct partial_die_info
*pdi
;
1696 /* Now, march along the PDI's, descending into ones which have
1697 interesting children but skipping the children of the other ones,
1698 until we reach the end of the compilation unit. */
1704 fixup_partial_die (pdi
, cu
);
1706 /* Anonymous namespaces have no name but have interesting
1707 children, so we need to look at them. Ditto for anonymous
1710 if (pdi
->name
!= NULL
|| pdi
->tag
== DW_TAG_namespace
1711 || pdi
->tag
== DW_TAG_enumeration_type
)
1715 case DW_TAG_subprogram
:
1716 if (pdi
->has_pc_info
)
1718 if (pdi
->lowpc
< *lowpc
)
1720 *lowpc
= pdi
->lowpc
;
1722 if (pdi
->highpc
> *highpc
)
1724 *highpc
= pdi
->highpc
;
1726 if (!pdi
->is_declaration
)
1728 add_partial_symbol (pdi
, cu
);
1732 case DW_TAG_variable
:
1733 case DW_TAG_typedef
:
1734 case DW_TAG_union_type
:
1735 if (!pdi
->is_declaration
)
1737 add_partial_symbol (pdi
, cu
);
1740 case DW_TAG_class_type
:
1741 case DW_TAG_structure_type
:
1742 if (!pdi
->is_declaration
)
1744 add_partial_symbol (pdi
, cu
);
1747 case DW_TAG_enumeration_type
:
1748 if (!pdi
->is_declaration
)
1749 add_partial_enumeration (pdi
, cu
);
1751 case DW_TAG_base_type
:
1752 case DW_TAG_subrange_type
:
1753 /* File scope base type definitions are added to the partial
1755 add_partial_symbol (pdi
, cu
);
1757 case DW_TAG_namespace
:
1758 add_partial_namespace (pdi
, lowpc
, highpc
, cu
);
1765 /* If the die has a sibling, skip to the sibling. */
1767 pdi
= pdi
->die_sibling
;
1771 /* Functions used to compute the fully scoped name of a partial DIE.
1773 Normally, this is simple. For C++, the parent DIE's fully scoped
1774 name is concatenated with "::" and the partial DIE's name. For
1775 Java, the same thing occurs except that "." is used instead of "::".
1776 Enumerators are an exception; they use the scope of their parent
1777 enumeration type, i.e. the name of the enumeration type is not
1778 prepended to the enumerator.
1780 There are two complexities. One is DW_AT_specification; in this
1781 case "parent" means the parent of the target of the specification,
1782 instead of the direct parent of the DIE. The other is compilers
1783 which do not emit DW_TAG_namespace; in this case we try to guess
1784 the fully qualified name of structure types from their members'
1785 linkage names. This must be done using the DIE's children rather
1786 than the children of any DW_AT_specification target. We only need
1787 to do this for structures at the top level, i.e. if the target of
1788 any DW_AT_specification (if any; otherwise the DIE itself) does not
1791 /* Compute the scope prefix associated with PDI's parent, in
1792 compilation unit CU. The result will be allocated on CU's
1793 comp_unit_obstack, or a copy of the already allocated PDI->NAME
1794 field. NULL is returned if no prefix is necessary. */
1796 partial_die_parent_scope (struct partial_die_info
*pdi
,
1797 struct dwarf2_cu
*cu
)
1799 char *grandparent_scope
;
1800 struct partial_die_info
*parent
, *real_pdi
;
1802 /* We need to look at our parent DIE; if we have a DW_AT_specification,
1803 then this means the parent of the specification DIE. */
1806 while (real_pdi
->has_specification
)
1807 real_pdi
= find_partial_die (real_pdi
->spec_offset
, cu
);
1809 parent
= real_pdi
->die_parent
;
1813 if (parent
->scope_set
)
1814 return parent
->scope
;
1816 fixup_partial_die (parent
, cu
);
1818 grandparent_scope
= partial_die_parent_scope (parent
, cu
);
1820 if (parent
->tag
== DW_TAG_namespace
1821 || parent
->tag
== DW_TAG_structure_type
1822 || parent
->tag
== DW_TAG_class_type
1823 || parent
->tag
== DW_TAG_union_type
)
1825 if (grandparent_scope
== NULL
)
1826 parent
->scope
= parent
->name
;
1828 parent
->scope
= typename_concat (&cu
->comp_unit_obstack
, grandparent_scope
,
1831 else if (parent
->tag
== DW_TAG_enumeration_type
)
1832 /* Enumerators should not get the name of the enumeration as a prefix. */
1833 parent
->scope
= grandparent_scope
;
1836 /* FIXME drow/2004-04-01: What should we be doing with
1837 function-local names? For partial symbols, we should probably be
1839 complaint (&symfile_complaints
,
1840 _("unhandled containing DIE tag %d for DIE at %d"),
1841 parent
->tag
, pdi
->offset
);
1842 parent
->scope
= grandparent_scope
;
1845 parent
->scope_set
= 1;
1846 return parent
->scope
;
1849 /* Return the fully scoped name associated with PDI, from compilation unit
1850 CU. The result will be allocated with malloc. */
1852 partial_die_full_name (struct partial_die_info
*pdi
,
1853 struct dwarf2_cu
*cu
)
1857 parent_scope
= partial_die_parent_scope (pdi
, cu
);
1858 if (parent_scope
== NULL
)
1861 return typename_concat (NULL
, parent_scope
, pdi
->name
, cu
);
1865 add_partial_symbol (struct partial_die_info
*pdi
, struct dwarf2_cu
*cu
)
1867 struct objfile
*objfile
= cu
->objfile
;
1870 const char *my_prefix
;
1871 const struct partial_symbol
*psym
= NULL
;
1873 int built_actual_name
= 0;
1875 baseaddr
= ANOFFSET (objfile
->section_offsets
, SECT_OFF_TEXT (objfile
));
1879 if (pdi_needs_namespace (pdi
->tag
))
1881 actual_name
= partial_die_full_name (pdi
, cu
);
1883 built_actual_name
= 1;
1886 if (actual_name
== NULL
)
1887 actual_name
= pdi
->name
;
1891 case DW_TAG_subprogram
:
1892 if (pdi
->is_external
)
1894 /*prim_record_minimal_symbol (actual_name, pdi->lowpc + baseaddr,
1895 mst_text, objfile); */
1896 psym
= add_psymbol_to_list (actual_name
, strlen (actual_name
),
1897 VAR_DOMAIN
, LOC_BLOCK
,
1898 &objfile
->global_psymbols
,
1899 0, pdi
->lowpc
+ baseaddr
,
1900 cu
->language
, objfile
);
1904 /*prim_record_minimal_symbol (actual_name, pdi->lowpc + baseaddr,
1905 mst_file_text, objfile); */
1906 psym
= add_psymbol_to_list (actual_name
, strlen (actual_name
),
1907 VAR_DOMAIN
, LOC_BLOCK
,
1908 &objfile
->static_psymbols
,
1909 0, pdi
->lowpc
+ baseaddr
,
1910 cu
->language
, objfile
);
1913 case DW_TAG_variable
:
1914 if (pdi
->is_external
)
1917 Don't enter into the minimal symbol tables as there is
1918 a minimal symbol table entry from the ELF symbols already.
1919 Enter into partial symbol table if it has a location
1920 descriptor or a type.
1921 If the location descriptor is missing, new_symbol will create
1922 a LOC_UNRESOLVED symbol, the address of the variable will then
1923 be determined from the minimal symbol table whenever the variable
1925 The address for the partial symbol table entry is not
1926 used by GDB, but it comes in handy for debugging partial symbol
1930 addr
= decode_locdesc (pdi
->locdesc
, cu
);
1931 if (pdi
->locdesc
|| pdi
->has_type
)
1932 psym
= add_psymbol_to_list (actual_name
, strlen (actual_name
),
1933 VAR_DOMAIN
, LOC_STATIC
,
1934 &objfile
->global_psymbols
,
1936 cu
->language
, objfile
);
1940 /* Static Variable. Skip symbols without location descriptors. */
1941 if (pdi
->locdesc
== NULL
)
1943 addr
= decode_locdesc (pdi
->locdesc
, cu
);
1944 /*prim_record_minimal_symbol (actual_name, addr + baseaddr,
1945 mst_file_data, objfile); */
1946 psym
= add_psymbol_to_list (actual_name
, strlen (actual_name
),
1947 VAR_DOMAIN
, LOC_STATIC
,
1948 &objfile
->static_psymbols
,
1950 cu
->language
, objfile
);
1953 case DW_TAG_typedef
:
1954 case DW_TAG_base_type
:
1955 case DW_TAG_subrange_type
:
1956 add_psymbol_to_list (actual_name
, strlen (actual_name
),
1957 VAR_DOMAIN
, LOC_TYPEDEF
,
1958 &objfile
->static_psymbols
,
1959 0, (CORE_ADDR
) 0, cu
->language
, objfile
);
1961 case DW_TAG_namespace
:
1962 add_psymbol_to_list (actual_name
, strlen (actual_name
),
1963 VAR_DOMAIN
, LOC_TYPEDEF
,
1964 &objfile
->global_psymbols
,
1965 0, (CORE_ADDR
) 0, cu
->language
, objfile
);
1967 case DW_TAG_class_type
:
1968 case DW_TAG_structure_type
:
1969 case DW_TAG_union_type
:
1970 case DW_TAG_enumeration_type
:
1971 /* Skip aggregate types without children, these are external
1973 /* NOTE: carlton/2003-10-07: See comment in new_symbol about
1974 static vs. global. */
1975 if (pdi
->has_children
== 0)
1977 add_psymbol_to_list (actual_name
, strlen (actual_name
),
1978 STRUCT_DOMAIN
, LOC_TYPEDEF
,
1979 (cu
->language
== language_cplus
1980 || cu
->language
== language_java
)
1981 ? &objfile
->global_psymbols
1982 : &objfile
->static_psymbols
,
1983 0, (CORE_ADDR
) 0, cu
->language
, objfile
);
1985 if (cu
->language
== language_cplus
1986 || cu
->language
== language_java
)
1988 /* For C++ and Java, these implicitly act as typedefs as well. */
1989 add_psymbol_to_list (actual_name
, strlen (actual_name
),
1990 VAR_DOMAIN
, LOC_TYPEDEF
,
1991 &objfile
->global_psymbols
,
1992 0, (CORE_ADDR
) 0, cu
->language
, objfile
);
1995 case DW_TAG_enumerator
:
1996 add_psymbol_to_list (actual_name
, strlen (actual_name
),
1997 VAR_DOMAIN
, LOC_CONST
,
1998 (cu
->language
== language_cplus
1999 || cu
->language
== language_java
)
2000 ? &objfile
->global_psymbols
2001 : &objfile
->static_psymbols
,
2002 0, (CORE_ADDR
) 0, cu
->language
, objfile
);
2008 /* Check to see if we should scan the name for possible namespace
2009 info. Only do this if this is C++, if we don't have namespace
2010 debugging info in the file, if the psym is of an appropriate type
2011 (otherwise we'll have psym == NULL), and if we actually had a
2012 mangled name to begin with. */
2014 /* FIXME drow/2004-02-22: Why don't we do this for classes, i.e. the
2015 cases which do not set PSYM above? */
2017 if (cu
->language
== language_cplus
2018 && cu
->has_namespace_info
== 0
2020 && SYMBOL_CPLUS_DEMANGLED_NAME (psym
) != NULL
)
2021 cp_check_possible_namespace_symbols (SYMBOL_CPLUS_DEMANGLED_NAME (psym
),
2024 if (built_actual_name
)
2025 xfree (actual_name
);
2028 /* Determine whether a die of type TAG living in a C++ class or
2029 namespace needs to have the name of the scope prepended to the
2030 name listed in the die. */
2033 pdi_needs_namespace (enum dwarf_tag tag
)
2037 case DW_TAG_namespace
:
2038 case DW_TAG_typedef
:
2039 case DW_TAG_class_type
:
2040 case DW_TAG_structure_type
:
2041 case DW_TAG_union_type
:
2042 case DW_TAG_enumeration_type
:
2043 case DW_TAG_enumerator
:
2050 /* Read a partial die corresponding to a namespace; also, add a symbol
2051 corresponding to that namespace to the symbol table. NAMESPACE is
2052 the name of the enclosing namespace. */
2055 add_partial_namespace (struct partial_die_info
*pdi
,
2056 CORE_ADDR
*lowpc
, CORE_ADDR
*highpc
,
2057 struct dwarf2_cu
*cu
)
2059 struct objfile
*objfile
= cu
->objfile
;
2061 /* Add a symbol for the namespace. */
2063 add_partial_symbol (pdi
, cu
);
2065 /* Now scan partial symbols in that namespace. */
2067 if (pdi
->has_children
)
2068 scan_partial_symbols (pdi
->die_child
, lowpc
, highpc
, cu
);
2071 /* See if we can figure out if the class lives in a namespace. We do
2072 this by looking for a member function; its demangled name will
2073 contain namespace info, if there is any. */
2076 guess_structure_name (struct partial_die_info
*struct_pdi
,
2077 struct dwarf2_cu
*cu
)
2079 if ((cu
->language
== language_cplus
2080 || cu
->language
== language_java
)
2081 && cu
->has_namespace_info
== 0
2082 && struct_pdi
->has_children
)
2084 /* NOTE: carlton/2003-10-07: Getting the info this way changes
2085 what template types look like, because the demangler
2086 frequently doesn't give the same name as the debug info. We
2087 could fix this by only using the demangled name to get the
2088 prefix (but see comment in read_structure_type). */
2090 struct partial_die_info
*child_pdi
= struct_pdi
->die_child
;
2091 struct partial_die_info
*real_pdi
;
2093 /* If this DIE (this DIE's specification, if any) has a parent, then
2094 we should not do this. We'll prepend the parent's fully qualified
2095 name when we create the partial symbol. */
2097 real_pdi
= struct_pdi
;
2098 while (real_pdi
->has_specification
)
2099 real_pdi
= find_partial_die (real_pdi
->spec_offset
, cu
);
2101 if (real_pdi
->die_parent
!= NULL
)
2104 while (child_pdi
!= NULL
)
2106 if (child_pdi
->tag
== DW_TAG_subprogram
)
2108 char *actual_class_name
2109 = language_class_name_from_physname (cu
->language_defn
,
2111 if (actual_class_name
!= NULL
)
2114 = obsavestring (actual_class_name
,
2115 strlen (actual_class_name
),
2116 &cu
->comp_unit_obstack
);
2117 xfree (actual_class_name
);
2122 child_pdi
= child_pdi
->die_sibling
;
2127 /* Read a partial die corresponding to an enumeration type. */
2130 add_partial_enumeration (struct partial_die_info
*enum_pdi
,
2131 struct dwarf2_cu
*cu
)
2133 struct objfile
*objfile
= cu
->objfile
;
2134 bfd
*abfd
= objfile
->obfd
;
2135 struct partial_die_info
*pdi
;
2137 if (enum_pdi
->name
!= NULL
)
2138 add_partial_symbol (enum_pdi
, cu
);
2140 pdi
= enum_pdi
->die_child
;
2143 if (pdi
->tag
!= DW_TAG_enumerator
|| pdi
->name
== NULL
)
2144 complaint (&symfile_complaints
, _("malformed enumerator DIE ignored"));
2146 add_partial_symbol (pdi
, cu
);
2147 pdi
= pdi
->die_sibling
;
2151 /* Read the initial uleb128 in the die at INFO_PTR in compilation unit CU.
2152 Return the corresponding abbrev, or NULL if the number is zero (indicating
2153 an empty DIE). In either case *BYTES_READ will be set to the length of
2154 the initial number. */
2156 static struct abbrev_info
*
2157 peek_die_abbrev (gdb_byte
*info_ptr
, unsigned int *bytes_read
,
2158 struct dwarf2_cu
*cu
)
2160 bfd
*abfd
= cu
->objfile
->obfd
;
2161 unsigned int abbrev_number
;
2162 struct abbrev_info
*abbrev
;
2164 abbrev_number
= read_unsigned_leb128 (abfd
, info_ptr
, bytes_read
);
2166 if (abbrev_number
== 0)
2169 abbrev
= dwarf2_lookup_abbrev (abbrev_number
, cu
);
2172 error (_("Dwarf Error: Could not find abbrev number %d [in module %s]"), abbrev_number
,
2173 bfd_get_filename (abfd
));
2179 /* Scan the debug information for CU starting at INFO_PTR. Returns a
2180 pointer to the end of a series of DIEs, terminated by an empty
2181 DIE. Any children of the skipped DIEs will also be skipped. */
2184 skip_children (gdb_byte
*info_ptr
, struct dwarf2_cu
*cu
)
2186 struct abbrev_info
*abbrev
;
2187 unsigned int bytes_read
;
2191 abbrev
= peek_die_abbrev (info_ptr
, &bytes_read
, cu
);
2193 return info_ptr
+ bytes_read
;
2195 info_ptr
= skip_one_die (info_ptr
+ bytes_read
, abbrev
, cu
);
2199 /* Scan the debug information for CU starting at INFO_PTR. INFO_PTR
2200 should point just after the initial uleb128 of a DIE, and the
2201 abbrev corresponding to that skipped uleb128 should be passed in
2202 ABBREV. Returns a pointer to this DIE's sibling, skipping any
2206 skip_one_die (gdb_byte
*info_ptr
, struct abbrev_info
*abbrev
,
2207 struct dwarf2_cu
*cu
)
2209 unsigned int bytes_read
;
2210 struct attribute attr
;
2211 bfd
*abfd
= cu
->objfile
->obfd
;
2212 unsigned int form
, i
;
2214 for (i
= 0; i
< abbrev
->num_attrs
; i
++)
2216 /* The only abbrev we care about is DW_AT_sibling. */
2217 if (abbrev
->attrs
[i
].name
== DW_AT_sibling
)
2219 read_attribute (&attr
, &abbrev
->attrs
[i
],
2220 abfd
, info_ptr
, cu
);
2221 if (attr
.form
== DW_FORM_ref_addr
)
2222 complaint (&symfile_complaints
, _("ignoring absolute DW_AT_sibling"));
2224 return dwarf2_per_objfile
->info_buffer
2225 + dwarf2_get_ref_die_offset (&attr
, cu
);
2228 /* If it isn't DW_AT_sibling, skip this attribute. */
2229 form
= abbrev
->attrs
[i
].form
;
2234 case DW_FORM_ref_addr
:
2235 info_ptr
+= cu
->header
.addr_size
;
2254 case DW_FORM_string
:
2255 read_string (abfd
, info_ptr
, &bytes_read
);
2256 info_ptr
+= bytes_read
;
2259 info_ptr
+= cu
->header
.offset_size
;
2262 info_ptr
+= read_unsigned_leb128 (abfd
, info_ptr
, &bytes_read
);
2263 info_ptr
+= bytes_read
;
2265 case DW_FORM_block1
:
2266 info_ptr
+= 1 + read_1_byte (abfd
, info_ptr
);
2268 case DW_FORM_block2
:
2269 info_ptr
+= 2 + read_2_bytes (abfd
, info_ptr
);
2271 case DW_FORM_block4
:
2272 info_ptr
+= 4 + read_4_bytes (abfd
, info_ptr
);
2276 case DW_FORM_ref_udata
:
2277 info_ptr
= skip_leb128 (abfd
, info_ptr
);
2279 case DW_FORM_indirect
:
2280 form
= read_unsigned_leb128 (abfd
, info_ptr
, &bytes_read
);
2281 info_ptr
+= bytes_read
;
2282 /* We need to continue parsing from here, so just go back to
2284 goto skip_attribute
;
2287 error (_("Dwarf Error: Cannot handle %s in DWARF reader [in module %s]"),
2288 dwarf_form_name (form
),
2289 bfd_get_filename (abfd
));
2293 if (abbrev
->has_children
)
2294 return skip_children (info_ptr
, cu
);
2299 /* Locate ORIG_PDI's sibling; INFO_PTR should point to the start of
2300 the next DIE after ORIG_PDI. */
2303 locate_pdi_sibling (struct partial_die_info
*orig_pdi
, gdb_byte
*info_ptr
,
2304 bfd
*abfd
, struct dwarf2_cu
*cu
)
2306 /* Do we know the sibling already? */
2308 if (orig_pdi
->sibling
)
2309 return orig_pdi
->sibling
;
2311 /* Are there any children to deal with? */
2313 if (!orig_pdi
->has_children
)
2316 /* Skip the children the long way. */
2318 return skip_children (info_ptr
, cu
);
2321 /* Expand this partial symbol table into a full symbol table. */
2324 dwarf2_psymtab_to_symtab (struct partial_symtab
*pst
)
2326 /* FIXME: This is barely more than a stub. */
2331 warning (_("bug: psymtab for %s is already read in."), pst
->filename
);
2337 printf_filtered (_("Reading in symbols for %s..."), pst
->filename
);
2338 gdb_flush (gdb_stdout
);
2341 /* Restore our global data. */
2342 dwarf2_per_objfile
= objfile_data (pst
->objfile
,
2343 dwarf2_objfile_data_key
);
2345 psymtab_to_symtab_1 (pst
);
2347 /* Finish up the debug error message. */
2349 printf_filtered (_("done.\n"));
2354 /* Add PER_CU to the queue. */
2357 queue_comp_unit (struct dwarf2_per_cu_data
*per_cu
)
2359 struct dwarf2_queue_item
*item
;
2362 item
= xmalloc (sizeof (*item
));
2363 item
->per_cu
= per_cu
;
2366 if (dwarf2_queue
== NULL
)
2367 dwarf2_queue
= item
;
2369 dwarf2_queue_tail
->next
= item
;
2371 dwarf2_queue_tail
= item
;
2374 /* Process the queue. */
2377 process_queue (struct objfile
*objfile
)
2379 struct dwarf2_queue_item
*item
, *next_item
;
2381 /* Initially, there is just one item on the queue. Load its DIEs,
2382 and the DIEs of any other compilation units it requires,
2385 for (item
= dwarf2_queue
; item
!= NULL
; item
= item
->next
)
2387 /* Read in this compilation unit. This may add new items to
2388 the end of the queue. */
2389 load_full_comp_unit (item
->per_cu
);
2391 item
->per_cu
->cu
->read_in_chain
= dwarf2_per_objfile
->read_in_chain
;
2392 dwarf2_per_objfile
->read_in_chain
= item
->per_cu
;
2394 /* If this compilation unit has already had full symbols created,
2395 reset the TYPE fields in each DIE. */
2396 if (item
->per_cu
->psymtab
->readin
)
2397 reset_die_and_siblings_types (item
->per_cu
->cu
->dies
,
2401 /* Now everything left on the queue needs to be read in. Process
2402 them, one at a time, removing from the queue as we finish. */
2403 for (item
= dwarf2_queue
; item
!= NULL
; dwarf2_queue
= item
= next_item
)
2405 if (!item
->per_cu
->psymtab
->readin
)
2406 process_full_comp_unit (item
->per_cu
);
2408 item
->per_cu
->queued
= 0;
2409 next_item
= item
->next
;
2413 dwarf2_queue_tail
= NULL
;
2416 /* Free all allocated queue entries. This function only releases anything if
2417 an error was thrown; if the queue was processed then it would have been
2418 freed as we went along. */
2421 dwarf2_release_queue (void *dummy
)
2423 struct dwarf2_queue_item
*item
, *last
;
2425 item
= dwarf2_queue
;
2428 /* Anything still marked queued is likely to be in an
2429 inconsistent state, so discard it. */
2430 if (item
->per_cu
->queued
)
2432 if (item
->per_cu
->cu
!= NULL
)
2433 free_one_cached_comp_unit (item
->per_cu
->cu
);
2434 item
->per_cu
->queued
= 0;
2442 dwarf2_queue
= dwarf2_queue_tail
= NULL
;
2445 /* Read in full symbols for PST, and anything it depends on. */
2448 psymtab_to_symtab_1 (struct partial_symtab
*pst
)
2450 struct dwarf2_per_cu_data
*per_cu
;
2451 struct cleanup
*back_to
;
2454 for (i
= 0; i
< pst
->number_of_dependencies
; i
++)
2455 if (!pst
->dependencies
[i
]->readin
)
2457 /* Inform about additional files that need to be read in. */
2460 /* FIXME: i18n: Need to make this a single string. */
2461 fputs_filtered (" ", gdb_stdout
);
2463 fputs_filtered ("and ", gdb_stdout
);
2465 printf_filtered ("%s...", pst
->dependencies
[i
]->filename
);
2466 wrap_here (""); /* Flush output */
2467 gdb_flush (gdb_stdout
);
2469 psymtab_to_symtab_1 (pst
->dependencies
[i
]);
2472 per_cu
= (struct dwarf2_per_cu_data
*) pst
->read_symtab_private
;
2476 /* It's an include file, no symbols to read for it.
2477 Everything is in the parent symtab. */
2482 back_to
= make_cleanup (dwarf2_release_queue
, NULL
);
2484 queue_comp_unit (per_cu
);
2486 process_queue (pst
->objfile
);
2488 /* Age the cache, releasing compilation units that have not
2489 been used recently. */
2490 age_cached_comp_units ();
2492 do_cleanups (back_to
);
2495 /* Load the DIEs associated with PST and PER_CU into memory. */
2497 static struct dwarf2_cu
*
2498 load_full_comp_unit (struct dwarf2_per_cu_data
*per_cu
)
2500 struct partial_symtab
*pst
= per_cu
->psymtab
;
2501 bfd
*abfd
= pst
->objfile
->obfd
;
2502 struct dwarf2_cu
*cu
;
2503 unsigned long offset
;
2505 struct cleanup
*back_to
, *free_cu_cleanup
;
2506 struct attribute
*attr
;
2509 /* Set local variables from the partial symbol table info. */
2510 offset
= per_cu
->offset
;
2512 info_ptr
= dwarf2_per_objfile
->info_buffer
+ offset
;
2514 cu
= xmalloc (sizeof (struct dwarf2_cu
));
2515 memset (cu
, 0, sizeof (struct dwarf2_cu
));
2517 /* If an error occurs while loading, release our storage. */
2518 free_cu_cleanup
= make_cleanup (free_one_comp_unit
, cu
);
2520 cu
->objfile
= pst
->objfile
;
2522 /* read in the comp_unit header */
2523 info_ptr
= read_comp_unit_head (&cu
->header
, info_ptr
, abfd
);
2525 /* Read the abbrevs for this compilation unit */
2526 dwarf2_read_abbrevs (abfd
, cu
);
2527 back_to
= make_cleanup (dwarf2_free_abbrev_table
, cu
);
2529 cu
->header
.offset
= offset
;
2531 cu
->per_cu
= per_cu
;
2534 /* We use this obstack for block values in dwarf_alloc_block. */
2535 obstack_init (&cu
->comp_unit_obstack
);
2537 cu
->dies
= read_comp_unit (info_ptr
, abfd
, cu
);
2539 /* We try not to read any attributes in this function, because not
2540 all objfiles needed for references have been loaded yet, and symbol
2541 table processing isn't initialized. But we have to set the CU language,
2542 or we won't be able to build types correctly. */
2543 attr
= dwarf2_attr (cu
->dies
, DW_AT_language
, cu
);
2545 set_cu_language (DW_UNSND (attr
), cu
);
2547 set_cu_language (language_minimal
, cu
);
2549 do_cleanups (back_to
);
2551 /* We've successfully allocated this compilation unit. Let our caller
2552 clean it up when finished with it. */
2553 discard_cleanups (free_cu_cleanup
);
2558 /* Generate full symbol information for PST and CU, whose DIEs have
2559 already been loaded into memory. */
2562 process_full_comp_unit (struct dwarf2_per_cu_data
*per_cu
)
2564 struct partial_symtab
*pst
= per_cu
->psymtab
;
2565 struct dwarf2_cu
*cu
= per_cu
->cu
;
2566 struct objfile
*objfile
= pst
->objfile
;
2567 bfd
*abfd
= objfile
->obfd
;
2568 CORE_ADDR lowpc
, highpc
;
2569 struct symtab
*symtab
;
2570 struct cleanup
*back_to
;
2571 struct attribute
*attr
;
2574 baseaddr
= ANOFFSET (objfile
->section_offsets
, SECT_OFF_TEXT (objfile
));
2576 /* We're in the global namespace. */
2577 processing_current_prefix
= "";
2580 back_to
= make_cleanup (really_free_pendings
, NULL
);
2582 cu
->list_in_scope
= &file_symbols
;
2584 /* Find the base address of the compilation unit for range lists and
2585 location lists. It will normally be specified by DW_AT_low_pc.
2586 In DWARF-3 draft 4, the base address could be overridden by
2587 DW_AT_entry_pc. It's been removed, but GCC still uses this for
2588 compilation units with discontinuous ranges. */
2590 cu
->header
.base_known
= 0;
2591 cu
->header
.base_address
= 0;
2593 attr
= dwarf2_attr (cu
->dies
, DW_AT_entry_pc
, cu
);
2596 cu
->header
.base_address
= DW_ADDR (attr
);
2597 cu
->header
.base_known
= 1;
2601 attr
= dwarf2_attr (cu
->dies
, DW_AT_low_pc
, cu
);
2604 cu
->header
.base_address
= DW_ADDR (attr
);
2605 cu
->header
.base_known
= 1;
2609 /* Do line number decoding in read_file_scope () */
2610 process_die (cu
->dies
, cu
);
2612 /* Some compilers don't define a DW_AT_high_pc attribute for the
2613 compilation unit. If the DW_AT_high_pc is missing, synthesize
2614 it, by scanning the DIE's below the compilation unit. */
2615 get_scope_pc_bounds (cu
->dies
, &lowpc
, &highpc
, cu
);
2617 symtab
= end_symtab (highpc
+ baseaddr
, objfile
, SECT_OFF_TEXT (objfile
));
2619 /* Set symtab language to language from DW_AT_language.
2620 If the compilation is from a C file generated by language preprocessors,
2621 do not set the language if it was already deduced by start_subfile. */
2623 && !(cu
->language
== language_c
&& symtab
->language
!= language_c
))
2625 symtab
->language
= cu
->language
;
2627 pst
->symtab
= symtab
;
2630 do_cleanups (back_to
);
2633 /* Process a die and its children. */
2636 process_die (struct die_info
*die
, struct dwarf2_cu
*cu
)
2640 case DW_TAG_padding
:
2642 case DW_TAG_compile_unit
:
2643 read_file_scope (die
, cu
);
2645 case DW_TAG_subprogram
:
2646 read_subroutine_type (die
, cu
);
2647 read_func_scope (die
, cu
);
2649 case DW_TAG_inlined_subroutine
:
2650 /* FIXME: These are ignored for now.
2651 They could be used to set breakpoints on all inlined instances
2652 of a function and make GDB `next' properly over inlined functions. */
2654 case DW_TAG_lexical_block
:
2655 case DW_TAG_try_block
:
2656 case DW_TAG_catch_block
:
2657 read_lexical_block_scope (die
, cu
);
2659 case DW_TAG_class_type
:
2660 case DW_TAG_structure_type
:
2661 case DW_TAG_union_type
:
2662 read_structure_type (die
, cu
);
2663 process_structure_scope (die
, cu
);
2665 case DW_TAG_enumeration_type
:
2666 read_enumeration_type (die
, cu
);
2667 process_enumeration_scope (die
, cu
);
2670 /* FIXME drow/2004-03-14: These initialize die->type, but do not create
2671 a symbol or process any children. Therefore it doesn't do anything
2672 that won't be done on-demand by read_type_die. */
2673 case DW_TAG_subroutine_type
:
2674 read_subroutine_type (die
, cu
);
2676 case DW_TAG_set_type
:
2677 read_set_type (die
, cu
);
2679 case DW_TAG_array_type
:
2680 read_array_type (die
, cu
);
2682 case DW_TAG_pointer_type
:
2683 read_tag_pointer_type (die
, cu
);
2685 case DW_TAG_ptr_to_member_type
:
2686 read_tag_ptr_to_member_type (die
, cu
);
2688 case DW_TAG_reference_type
:
2689 read_tag_reference_type (die
, cu
);
2691 case DW_TAG_string_type
:
2692 read_tag_string_type (die
, cu
);
2696 case DW_TAG_base_type
:
2697 read_base_type (die
, cu
);
2698 /* Add a typedef symbol for the type definition, if it has a
2700 new_symbol (die
, die
->type
, cu
);
2702 case DW_TAG_subrange_type
:
2703 read_subrange_type (die
, cu
);
2704 /* Add a typedef symbol for the type definition, if it has a
2706 new_symbol (die
, die
->type
, cu
);
2708 case DW_TAG_common_block
:
2709 read_common_block (die
, cu
);
2711 case DW_TAG_common_inclusion
:
2713 case DW_TAG_namespace
:
2714 processing_has_namespace_info
= 1;
2715 read_namespace (die
, cu
);
2717 case DW_TAG_imported_declaration
:
2718 case DW_TAG_imported_module
:
2719 /* FIXME: carlton/2002-10-16: Eventually, we should use the
2720 information contained in these. DW_TAG_imported_declaration
2721 dies shouldn't have children; DW_TAG_imported_module dies
2722 shouldn't in the C++ case, but conceivably could in the
2723 Fortran case, so we'll have to replace this gdb_assert if
2724 Fortran compilers start generating that info. */
2725 processing_has_namespace_info
= 1;
2726 gdb_assert (die
->child
== NULL
);
2729 new_symbol (die
, NULL
, cu
);
2735 initialize_cu_func_list (struct dwarf2_cu
*cu
)
2737 cu
->first_fn
= cu
->last_fn
= cu
->cached_fn
= NULL
;
2741 read_file_scope (struct die_info
*die
, struct dwarf2_cu
*cu
)
2743 struct objfile
*objfile
= cu
->objfile
;
2744 struct comp_unit_head
*cu_header
= &cu
->header
;
2745 struct cleanup
*back_to
= make_cleanup (null_cleanup
, 0);
2746 CORE_ADDR lowpc
= ((CORE_ADDR
) -1);
2747 CORE_ADDR highpc
= ((CORE_ADDR
) 0);
2748 struct attribute
*attr
;
2749 char *name
= "<unknown>";
2750 char *comp_dir
= NULL
;
2751 struct die_info
*child_die
;
2752 bfd
*abfd
= objfile
->obfd
;
2753 struct line_header
*line_header
= 0;
2756 baseaddr
= ANOFFSET (objfile
->section_offsets
, SECT_OFF_TEXT (objfile
));
2758 get_scope_pc_bounds (die
, &lowpc
, &highpc
, cu
);
2760 /* If we didn't find a lowpc, set it to highpc to avoid complaints
2761 from finish_block. */
2762 if (lowpc
== ((CORE_ADDR
) -1))
2767 attr
= dwarf2_attr (die
, DW_AT_name
, cu
);
2770 name
= DW_STRING (attr
);
2772 attr
= dwarf2_attr (die
, DW_AT_comp_dir
, cu
);
2775 comp_dir
= DW_STRING (attr
);
2778 /* Irix 6.2 native cc prepends <machine>.: to the compilation
2779 directory, get rid of it. */
2780 char *cp
= strchr (comp_dir
, ':');
2782 if (cp
&& cp
!= comp_dir
&& cp
[-1] == '.' && cp
[1] == '/')
2787 attr
= dwarf2_attr (die
, DW_AT_language
, cu
);
2790 set_cu_language (DW_UNSND (attr
), cu
);
2793 attr
= dwarf2_attr (die
, DW_AT_producer
, cu
);
2795 cu
->producer
= DW_STRING (attr
);
2797 /* We assume that we're processing GCC output. */
2798 processing_gcc_compilation
= 2;
2800 /* FIXME:Do something here. */
2801 if (dip
->at_producer
!= NULL
)
2803 handle_producer (dip
->at_producer
);
2807 /* The compilation unit may be in a different language or objfile,
2808 zero out all remembered fundamental types. */
2809 memset (cu
->ftypes
, 0, FT_NUM_MEMBERS
* sizeof (struct type
*));
2811 start_symtab (name
, comp_dir
, lowpc
);
2812 record_debugformat ("DWARF 2");
2814 initialize_cu_func_list (cu
);
2816 /* Process all dies in compilation unit. */
2817 if (die
->child
!= NULL
)
2819 child_die
= die
->child
;
2820 while (child_die
&& child_die
->tag
)
2822 process_die (child_die
, cu
);
2823 child_die
= sibling_die (child_die
);
2827 /* Decode line number information if present. */
2828 attr
= dwarf2_attr (die
, DW_AT_stmt_list
, cu
);
2831 unsigned int line_offset
= DW_UNSND (attr
);
2832 line_header
= dwarf_decode_line_header (line_offset
, abfd
, cu
);
2835 make_cleanup ((make_cleanup_ftype
*) free_line_header
,
2836 (void *) line_header
);
2837 dwarf_decode_lines (line_header
, comp_dir
, abfd
, cu
, NULL
);
2841 /* Decode macro information, if present. Dwarf 2 macro information
2842 refers to information in the line number info statement program
2843 header, so we can only read it if we've read the header
2845 attr
= dwarf2_attr (die
, DW_AT_macro_info
, cu
);
2846 if (attr
&& line_header
)
2848 unsigned int macro_offset
= DW_UNSND (attr
);
2849 dwarf_decode_macros (line_header
, macro_offset
,
2850 comp_dir
, abfd
, cu
);
2852 do_cleanups (back_to
);
2856 add_to_cu_func_list (const char *name
, CORE_ADDR lowpc
, CORE_ADDR highpc
,
2857 struct dwarf2_cu
*cu
)
2859 struct function_range
*thisfn
;
2861 thisfn
= (struct function_range
*)
2862 obstack_alloc (&cu
->comp_unit_obstack
, sizeof (struct function_range
));
2863 thisfn
->name
= name
;
2864 thisfn
->lowpc
= lowpc
;
2865 thisfn
->highpc
= highpc
;
2866 thisfn
->seen_line
= 0;
2867 thisfn
->next
= NULL
;
2869 if (cu
->last_fn
== NULL
)
2870 cu
->first_fn
= thisfn
;
2872 cu
->last_fn
->next
= thisfn
;
2874 cu
->last_fn
= thisfn
;
2878 read_func_scope (struct die_info
*die
, struct dwarf2_cu
*cu
)
2880 struct objfile
*objfile
= cu
->objfile
;
2881 struct context_stack
*new;
2884 struct die_info
*child_die
;
2885 struct attribute
*attr
;
2887 const char *previous_prefix
= processing_current_prefix
;
2888 struct cleanup
*back_to
= NULL
;
2891 baseaddr
= ANOFFSET (objfile
->section_offsets
, SECT_OFF_TEXT (objfile
));
2893 name
= dwarf2_linkage_name (die
, cu
);
2895 /* Ignore functions with missing or empty names and functions with
2896 missing or invalid low and high pc attributes. */
2897 if (name
== NULL
|| !dwarf2_get_pc_bounds (die
, &lowpc
, &highpc
, cu
))
2900 if (cu
->language
== language_cplus
2901 || cu
->language
== language_java
)
2903 struct die_info
*spec_die
= die_specification (die
, cu
);
2905 /* NOTE: carlton/2004-01-23: We have to be careful in the
2906 presence of DW_AT_specification. For example, with GCC 3.4,
2911 // Definition of N::foo.
2915 then we'll have a tree of DIEs like this:
2917 1: DW_TAG_compile_unit
2918 2: DW_TAG_namespace // N
2919 3: DW_TAG_subprogram // declaration of N::foo
2920 4: DW_TAG_subprogram // definition of N::foo
2921 DW_AT_specification // refers to die #3
2923 Thus, when processing die #4, we have to pretend that we're
2924 in the context of its DW_AT_specification, namely the contex
2927 if (spec_die
!= NULL
)
2929 char *specification_prefix
= determine_prefix (spec_die
, cu
);
2930 processing_current_prefix
= specification_prefix
;
2931 back_to
= make_cleanup (xfree
, specification_prefix
);
2938 /* Record the function range for dwarf_decode_lines. */
2939 add_to_cu_func_list (name
, lowpc
, highpc
, cu
);
2941 new = push_context (0, lowpc
);
2942 new->name
= new_symbol (die
, die
->type
, cu
);
2944 /* If there is a location expression for DW_AT_frame_base, record
2946 attr
= dwarf2_attr (die
, DW_AT_frame_base
, cu
);
2948 /* FIXME: cagney/2004-01-26: The DW_AT_frame_base's location
2949 expression is being recorded directly in the function's symbol
2950 and not in a separate frame-base object. I guess this hack is
2951 to avoid adding some sort of frame-base adjunct/annex to the
2952 function's symbol :-(. The problem with doing this is that it
2953 results in a function symbol with a location expression that
2954 has nothing to do with the location of the function, ouch! The
2955 relationship should be: a function's symbol has-a frame base; a
2956 frame-base has-a location expression. */
2957 dwarf2_symbol_mark_computed (attr
, new->name
, cu
);
2959 cu
->list_in_scope
= &local_symbols
;
2961 if (die
->child
!= NULL
)
2963 child_die
= die
->child
;
2964 while (child_die
&& child_die
->tag
)
2966 process_die (child_die
, cu
);
2967 child_die
= sibling_die (child_die
);
2971 new = pop_context ();
2972 /* Make a block for the local symbols within. */
2973 finish_block (new->name
, &local_symbols
, new->old_blocks
,
2974 lowpc
, highpc
, objfile
);
2976 /* In C++, we can have functions nested inside functions (e.g., when
2977 a function declares a class that has methods). This means that
2978 when we finish processing a function scope, we may need to go
2979 back to building a containing block's symbol lists. */
2980 local_symbols
= new->locals
;
2981 param_symbols
= new->params
;
2983 /* If we've finished processing a top-level function, subsequent
2984 symbols go in the file symbol list. */
2985 if (outermost_context_p ())
2986 cu
->list_in_scope
= &file_symbols
;
2988 processing_current_prefix
= previous_prefix
;
2989 if (back_to
!= NULL
)
2990 do_cleanups (back_to
);
2993 /* Process all the DIES contained within a lexical block scope. Start
2994 a new scope, process the dies, and then close the scope. */
2997 read_lexical_block_scope (struct die_info
*die
, struct dwarf2_cu
*cu
)
2999 struct objfile
*objfile
= cu
->objfile
;
3000 struct context_stack
*new;
3001 CORE_ADDR lowpc
, highpc
;
3002 struct die_info
*child_die
;
3005 baseaddr
= ANOFFSET (objfile
->section_offsets
, SECT_OFF_TEXT (objfile
));
3007 /* Ignore blocks with missing or invalid low and high pc attributes. */
3008 /* ??? Perhaps consider discontiguous blocks defined by DW_AT_ranges
3009 as multiple lexical blocks? Handling children in a sane way would
3010 be nasty. Might be easier to properly extend generic blocks to
3012 if (!dwarf2_get_pc_bounds (die
, &lowpc
, &highpc
, cu
))
3017 push_context (0, lowpc
);
3018 if (die
->child
!= NULL
)
3020 child_die
= die
->child
;
3021 while (child_die
&& child_die
->tag
)
3023 process_die (child_die
, cu
);
3024 child_die
= sibling_die (child_die
);
3027 new = pop_context ();
3029 if (local_symbols
!= NULL
)
3031 finish_block (0, &local_symbols
, new->old_blocks
, new->start_addr
,
3034 local_symbols
= new->locals
;
3037 /* Get low and high pc attributes from a die. Return 1 if the attributes
3038 are present and valid, otherwise, return 0. Return -1 if the range is
3039 discontinuous, i.e. derived from DW_AT_ranges information. */
3041 dwarf2_get_pc_bounds (struct die_info
*die
, CORE_ADDR
*lowpc
,
3042 CORE_ADDR
*highpc
, struct dwarf2_cu
*cu
)
3044 struct objfile
*objfile
= cu
->objfile
;
3045 struct comp_unit_head
*cu_header
= &cu
->header
;
3046 struct attribute
*attr
;
3047 bfd
*obfd
= objfile
->obfd
;
3052 attr
= dwarf2_attr (die
, DW_AT_high_pc
, cu
);
3055 high
= DW_ADDR (attr
);
3056 attr
= dwarf2_attr (die
, DW_AT_low_pc
, cu
);
3058 low
= DW_ADDR (attr
);
3060 /* Found high w/o low attribute. */
3063 /* Found consecutive range of addresses. */
3068 attr
= dwarf2_attr (die
, DW_AT_ranges
, cu
);
3071 unsigned int addr_size
= cu_header
->addr_size
;
3072 CORE_ADDR mask
= ~(~(CORE_ADDR
)1 << (addr_size
* 8 - 1));
3073 /* Value of the DW_AT_ranges attribute is the offset in the
3074 .debug_ranges section. */
3075 unsigned int offset
= DW_UNSND (attr
);
3076 /* Base address selection entry. */
3084 found_base
= cu_header
->base_known
;
3085 base
= cu_header
->base_address
;
3087 if (offset
>= dwarf2_per_objfile
->ranges_size
)
3089 complaint (&symfile_complaints
,
3090 _("Offset %d out of bounds for DW_AT_ranges attribute"),
3094 buffer
= dwarf2_per_objfile
->ranges_buffer
+ offset
;
3096 /* Read in the largest possible address. */
3097 marker
= read_address (obfd
, buffer
, cu
, &dummy
);
3098 if ((marker
& mask
) == mask
)
3100 /* If we found the largest possible address, then
3101 read the base address. */
3102 base
= read_address (obfd
, buffer
+ addr_size
, cu
, &dummy
);
3103 buffer
+= 2 * addr_size
;
3104 offset
+= 2 * addr_size
;
3112 CORE_ADDR range_beginning
, range_end
;
3114 range_beginning
= read_address (obfd
, buffer
, cu
, &dummy
);
3115 buffer
+= addr_size
;
3116 range_end
= read_address (obfd
, buffer
, cu
, &dummy
);
3117 buffer
+= addr_size
;
3118 offset
+= 2 * addr_size
;
3120 /* An end of list marker is a pair of zero addresses. */
3121 if (range_beginning
== 0 && range_end
== 0)
3122 /* Found the end of list entry. */
3125 /* Each base address selection entry is a pair of 2 values.
3126 The first is the largest possible address, the second is
3127 the base address. Check for a base address here. */
3128 if ((range_beginning
& mask
) == mask
)
3130 /* If we found the largest possible address, then
3131 read the base address. */
3132 base
= read_address (obfd
, buffer
+ addr_size
, cu
, &dummy
);
3139 /* We have no valid base address for the ranges
3141 complaint (&symfile_complaints
,
3142 _("Invalid .debug_ranges data (no base address)"));
3146 range_beginning
+= base
;
3149 /* FIXME: This is recording everything as a low-high
3150 segment of consecutive addresses. We should have a
3151 data structure for discontiguous block ranges
3155 low
= range_beginning
;
3161 if (range_beginning
< low
)
3162 low
= range_beginning
;
3163 if (range_end
> high
)
3169 /* If the first entry is an end-of-list marker, the range
3170 describes an empty scope, i.e. no instructions. */
3180 /* When using the GNU linker, .gnu.linkonce. sections are used to
3181 eliminate duplicate copies of functions and vtables and such.
3182 The linker will arbitrarily choose one and discard the others.
3183 The AT_*_pc values for such functions refer to local labels in
3184 these sections. If the section from that file was discarded, the
3185 labels are not in the output, so the relocs get a value of 0.
3186 If this is a discarded function, mark the pc bounds as invalid,
3187 so that GDB will ignore it. */
3188 if (low
== 0 && !dwarf2_per_objfile
->has_section_at_zero
)
3196 /* Get the low and high pc's represented by the scope DIE, and store
3197 them in *LOWPC and *HIGHPC. If the correct values can't be
3198 determined, set *LOWPC to -1 and *HIGHPC to 0. */
3201 get_scope_pc_bounds (struct die_info
*die
,
3202 CORE_ADDR
*lowpc
, CORE_ADDR
*highpc
,
3203 struct dwarf2_cu
*cu
)
3205 CORE_ADDR best_low
= (CORE_ADDR
) -1;
3206 CORE_ADDR best_high
= (CORE_ADDR
) 0;
3207 CORE_ADDR current_low
, current_high
;
3209 if (dwarf2_get_pc_bounds (die
, ¤t_low
, ¤t_high
, cu
))
3211 best_low
= current_low
;
3212 best_high
= current_high
;
3216 struct die_info
*child
= die
->child
;
3218 while (child
&& child
->tag
)
3220 switch (child
->tag
) {
3221 case DW_TAG_subprogram
:
3222 if (dwarf2_get_pc_bounds (child
, ¤t_low
, ¤t_high
, cu
))
3224 best_low
= min (best_low
, current_low
);
3225 best_high
= max (best_high
, current_high
);
3228 case DW_TAG_namespace
:
3229 /* FIXME: carlton/2004-01-16: Should we do this for
3230 DW_TAG_class_type/DW_TAG_structure_type, too? I think
3231 that current GCC's always emit the DIEs corresponding
3232 to definitions of methods of classes as children of a
3233 DW_TAG_compile_unit or DW_TAG_namespace (as opposed to
3234 the DIEs giving the declarations, which could be
3235 anywhere). But I don't see any reason why the
3236 standards says that they have to be there. */
3237 get_scope_pc_bounds (child
, ¤t_low
, ¤t_high
, cu
);
3239 if (current_low
!= ((CORE_ADDR
) -1))
3241 best_low
= min (best_low
, current_low
);
3242 best_high
= max (best_high
, current_high
);
3250 child
= sibling_die (child
);
3255 *highpc
= best_high
;
3258 /* Add an aggregate field to the field list. */
3261 dwarf2_add_field (struct field_info
*fip
, struct die_info
*die
,
3262 struct dwarf2_cu
*cu
)
3264 struct objfile
*objfile
= cu
->objfile
;
3265 struct nextfield
*new_field
;
3266 struct attribute
*attr
;
3268 char *fieldname
= "";
3270 /* Allocate a new field list entry and link it in. */
3271 new_field
= (struct nextfield
*) xmalloc (sizeof (struct nextfield
));
3272 make_cleanup (xfree
, new_field
);
3273 memset (new_field
, 0, sizeof (struct nextfield
));
3274 new_field
->next
= fip
->fields
;
3275 fip
->fields
= new_field
;
3278 /* Handle accessibility and virtuality of field.
3279 The default accessibility for members is public, the default
3280 accessibility for inheritance is private. */
3281 if (die
->tag
!= DW_TAG_inheritance
)
3282 new_field
->accessibility
= DW_ACCESS_public
;
3284 new_field
->accessibility
= DW_ACCESS_private
;
3285 new_field
->virtuality
= DW_VIRTUALITY_none
;
3287 attr
= dwarf2_attr (die
, DW_AT_accessibility
, cu
);
3289 new_field
->accessibility
= DW_UNSND (attr
);
3290 if (new_field
->accessibility
!= DW_ACCESS_public
)
3291 fip
->non_public_fields
= 1;
3292 attr
= dwarf2_attr (die
, DW_AT_virtuality
, cu
);
3294 new_field
->virtuality
= DW_UNSND (attr
);
3296 fp
= &new_field
->field
;
3298 if (die
->tag
== DW_TAG_member
&& ! die_is_declaration (die
, cu
))
3300 /* Data member other than a C++ static data member. */
3302 /* Get type of field. */
3303 fp
->type
= die_type (die
, cu
);
3305 FIELD_STATIC_KIND (*fp
) = 0;
3307 /* Get bit size of field (zero if none). */
3308 attr
= dwarf2_attr (die
, DW_AT_bit_size
, cu
);
3311 FIELD_BITSIZE (*fp
) = DW_UNSND (attr
);
3315 FIELD_BITSIZE (*fp
) = 0;
3318 /* Get bit offset of field. */
3319 attr
= dwarf2_attr (die
, DW_AT_data_member_location
, cu
);
3322 FIELD_BITPOS (*fp
) =
3323 decode_locdesc (DW_BLOCK (attr
), cu
) * bits_per_byte
;
3326 FIELD_BITPOS (*fp
) = 0;
3327 attr
= dwarf2_attr (die
, DW_AT_bit_offset
, cu
);
3330 if (BITS_BIG_ENDIAN
)
3332 /* For big endian bits, the DW_AT_bit_offset gives the
3333 additional bit offset from the MSB of the containing
3334 anonymous object to the MSB of the field. We don't
3335 have to do anything special since we don't need to
3336 know the size of the anonymous object. */
3337 FIELD_BITPOS (*fp
) += DW_UNSND (attr
);
3341 /* For little endian bits, compute the bit offset to the
3342 MSB of the anonymous object, subtract off the number of
3343 bits from the MSB of the field to the MSB of the
3344 object, and then subtract off the number of bits of
3345 the field itself. The result is the bit offset of
3346 the LSB of the field. */
3348 int bit_offset
= DW_UNSND (attr
);
3350 attr
= dwarf2_attr (die
, DW_AT_byte_size
, cu
);
3353 /* The size of the anonymous object containing
3354 the bit field is explicit, so use the
3355 indicated size (in bytes). */
3356 anonymous_size
= DW_UNSND (attr
);
3360 /* The size of the anonymous object containing
3361 the bit field must be inferred from the type
3362 attribute of the data member containing the
3364 anonymous_size
= TYPE_LENGTH (fp
->type
);
3366 FIELD_BITPOS (*fp
) += anonymous_size
* bits_per_byte
3367 - bit_offset
- FIELD_BITSIZE (*fp
);
3371 /* Get name of field. */
3372 attr
= dwarf2_attr (die
, DW_AT_name
, cu
);
3373 if (attr
&& DW_STRING (attr
))
3374 fieldname
= DW_STRING (attr
);
3376 /* The name is already allocated along with this objfile, so we don't
3377 need to duplicate it for the type. */
3378 fp
->name
= fieldname
;
3380 /* Change accessibility for artificial fields (e.g. virtual table
3381 pointer or virtual base class pointer) to private. */
3382 if (dwarf2_attr (die
, DW_AT_artificial
, cu
))
3384 new_field
->accessibility
= DW_ACCESS_private
;
3385 fip
->non_public_fields
= 1;
3388 else if (die
->tag
== DW_TAG_member
|| die
->tag
== DW_TAG_variable
)
3390 /* C++ static member. */
3392 /* NOTE: carlton/2002-11-05: It should be a DW_TAG_member that
3393 is a declaration, but all versions of G++ as of this writing
3394 (so through at least 3.2.1) incorrectly generate
3395 DW_TAG_variable tags. */
3399 /* Get name of field. */
3400 attr
= dwarf2_attr (die
, DW_AT_name
, cu
);
3401 if (attr
&& DW_STRING (attr
))
3402 fieldname
= DW_STRING (attr
);
3406 /* Get physical name. */
3407 physname
= dwarf2_linkage_name (die
, cu
);
3409 /* The name is already allocated along with this objfile, so we don't
3410 need to duplicate it for the type. */
3411 SET_FIELD_PHYSNAME (*fp
, physname
? physname
: "");
3412 FIELD_TYPE (*fp
) = die_type (die
, cu
);
3413 FIELD_NAME (*fp
) = fieldname
;
3415 else if (die
->tag
== DW_TAG_inheritance
)
3417 /* C++ base class field. */
3418 attr
= dwarf2_attr (die
, DW_AT_data_member_location
, cu
);
3420 FIELD_BITPOS (*fp
) = (decode_locdesc (DW_BLOCK (attr
), cu
)
3422 FIELD_BITSIZE (*fp
) = 0;
3423 FIELD_STATIC_KIND (*fp
) = 0;
3424 FIELD_TYPE (*fp
) = die_type (die
, cu
);
3425 FIELD_NAME (*fp
) = type_name_no_tag (fp
->type
);
3426 fip
->nbaseclasses
++;
3430 /* Create the vector of fields, and attach it to the type. */
3433 dwarf2_attach_fields_to_type (struct field_info
*fip
, struct type
*type
,
3434 struct dwarf2_cu
*cu
)
3436 int nfields
= fip
->nfields
;
3438 /* Record the field count, allocate space for the array of fields,
3439 and create blank accessibility bitfields if necessary. */
3440 TYPE_NFIELDS (type
) = nfields
;
3441 TYPE_FIELDS (type
) = (struct field
*)
3442 TYPE_ALLOC (type
, sizeof (struct field
) * nfields
);
3443 memset (TYPE_FIELDS (type
), 0, sizeof (struct field
) * nfields
);
3445 if (fip
->non_public_fields
)
3447 ALLOCATE_CPLUS_STRUCT_TYPE (type
);
3449 TYPE_FIELD_PRIVATE_BITS (type
) =
3450 (B_TYPE
*) TYPE_ALLOC (type
, B_BYTES (nfields
));
3451 B_CLRALL (TYPE_FIELD_PRIVATE_BITS (type
), nfields
);
3453 TYPE_FIELD_PROTECTED_BITS (type
) =
3454 (B_TYPE
*) TYPE_ALLOC (type
, B_BYTES (nfields
));
3455 B_CLRALL (TYPE_FIELD_PROTECTED_BITS (type
), nfields
);
3457 TYPE_FIELD_IGNORE_BITS (type
) =
3458 (B_TYPE
*) TYPE_ALLOC (type
, B_BYTES (nfields
));
3459 B_CLRALL (TYPE_FIELD_IGNORE_BITS (type
), nfields
);
3462 /* If the type has baseclasses, allocate and clear a bit vector for
3463 TYPE_FIELD_VIRTUAL_BITS. */
3464 if (fip
->nbaseclasses
)
3466 int num_bytes
= B_BYTES (fip
->nbaseclasses
);
3467 unsigned char *pointer
;
3469 ALLOCATE_CPLUS_STRUCT_TYPE (type
);
3470 pointer
= TYPE_ALLOC (type
, num_bytes
);
3471 TYPE_FIELD_VIRTUAL_BITS (type
) = pointer
;
3472 B_CLRALL (TYPE_FIELD_VIRTUAL_BITS (type
), fip
->nbaseclasses
);
3473 TYPE_N_BASECLASSES (type
) = fip
->nbaseclasses
;
3476 /* Copy the saved-up fields into the field vector. Start from the head
3477 of the list, adding to the tail of the field array, so that they end
3478 up in the same order in the array in which they were added to the list. */
3479 while (nfields
-- > 0)
3481 TYPE_FIELD (type
, nfields
) = fip
->fields
->field
;
3482 switch (fip
->fields
->accessibility
)
3484 case DW_ACCESS_private
:
3485 SET_TYPE_FIELD_PRIVATE (type
, nfields
);
3488 case DW_ACCESS_protected
:
3489 SET_TYPE_FIELD_PROTECTED (type
, nfields
);
3492 case DW_ACCESS_public
:
3496 /* Unknown accessibility. Complain and treat it as public. */
3498 complaint (&symfile_complaints
, _("unsupported accessibility %d"),
3499 fip
->fields
->accessibility
);
3503 if (nfields
< fip
->nbaseclasses
)
3505 switch (fip
->fields
->virtuality
)
3507 case DW_VIRTUALITY_virtual
:
3508 case DW_VIRTUALITY_pure_virtual
:
3509 SET_TYPE_FIELD_VIRTUAL (type
, nfields
);
3513 fip
->fields
= fip
->fields
->next
;
3517 /* Add a member function to the proper fieldlist. */
3520 dwarf2_add_member_fn (struct field_info
*fip
, struct die_info
*die
,
3521 struct type
*type
, struct dwarf2_cu
*cu
)
3523 struct objfile
*objfile
= cu
->objfile
;
3524 struct attribute
*attr
;
3525 struct fnfieldlist
*flp
;
3527 struct fn_field
*fnp
;
3530 struct nextfnfield
*new_fnfield
;
3532 /* Get name of member function. */
3533 attr
= dwarf2_attr (die
, DW_AT_name
, cu
);
3534 if (attr
&& DW_STRING (attr
))
3535 fieldname
= DW_STRING (attr
);
3539 /* Get the mangled name. */
3540 physname
= dwarf2_linkage_name (die
, cu
);
3542 /* Look up member function name in fieldlist. */
3543 for (i
= 0; i
< fip
->nfnfields
; i
++)
3545 if (strcmp (fip
->fnfieldlists
[i
].name
, fieldname
) == 0)
3549 /* Create new list element if necessary. */
3550 if (i
< fip
->nfnfields
)
3551 flp
= &fip
->fnfieldlists
[i
];
3554 if ((fip
->nfnfields
% DW_FIELD_ALLOC_CHUNK
) == 0)
3556 fip
->fnfieldlists
= (struct fnfieldlist
*)
3557 xrealloc (fip
->fnfieldlists
,
3558 (fip
->nfnfields
+ DW_FIELD_ALLOC_CHUNK
)
3559 * sizeof (struct fnfieldlist
));
3560 if (fip
->nfnfields
== 0)
3561 make_cleanup (free_current_contents
, &fip
->fnfieldlists
);
3563 flp
= &fip
->fnfieldlists
[fip
->nfnfields
];
3564 flp
->name
= fieldname
;
3570 /* Create a new member function field and chain it to the field list
3572 new_fnfield
= (struct nextfnfield
*) xmalloc (sizeof (struct nextfnfield
));
3573 make_cleanup (xfree
, new_fnfield
);
3574 memset (new_fnfield
, 0, sizeof (struct nextfnfield
));
3575 new_fnfield
->next
= flp
->head
;
3576 flp
->head
= new_fnfield
;
3579 /* Fill in the member function field info. */
3580 fnp
= &new_fnfield
->fnfield
;
3581 /* The name is already allocated along with this objfile, so we don't
3582 need to duplicate it for the type. */
3583 fnp
->physname
= physname
? physname
: "";
3584 fnp
->type
= alloc_type (objfile
);
3585 if (die
->type
&& TYPE_CODE (die
->type
) == TYPE_CODE_FUNC
)
3587 int nparams
= TYPE_NFIELDS (die
->type
);
3589 /* TYPE is the domain of this method, and DIE->TYPE is the type
3590 of the method itself (TYPE_CODE_METHOD). */
3591 smash_to_method_type (fnp
->type
, type
,
3592 TYPE_TARGET_TYPE (die
->type
),
3593 TYPE_FIELDS (die
->type
),
3594 TYPE_NFIELDS (die
->type
),
3595 TYPE_VARARGS (die
->type
));
3597 /* Handle static member functions.
3598 Dwarf2 has no clean way to discern C++ static and non-static
3599 member functions. G++ helps GDB by marking the first
3600 parameter for non-static member functions (which is the
3601 this pointer) as artificial. We obtain this information
3602 from read_subroutine_type via TYPE_FIELD_ARTIFICIAL. */
3603 if (nparams
== 0 || TYPE_FIELD_ARTIFICIAL (die
->type
, 0) == 0)
3604 fnp
->voffset
= VOFFSET_STATIC
;
3607 complaint (&symfile_complaints
, _("member function type missing for '%s'"),
3610 /* Get fcontext from DW_AT_containing_type if present. */
3611 if (dwarf2_attr (die
, DW_AT_containing_type
, cu
) != NULL
)
3612 fnp
->fcontext
= die_containing_type (die
, cu
);
3614 /* dwarf2 doesn't have stubbed physical names, so the setting of is_const
3615 and is_volatile is irrelevant, as it is needed by gdb_mangle_name only. */
3617 /* Get accessibility. */
3618 attr
= dwarf2_attr (die
, DW_AT_accessibility
, cu
);
3621 switch (DW_UNSND (attr
))
3623 case DW_ACCESS_private
:
3624 fnp
->is_private
= 1;
3626 case DW_ACCESS_protected
:
3627 fnp
->is_protected
= 1;
3632 /* Check for artificial methods. */
3633 attr
= dwarf2_attr (die
, DW_AT_artificial
, cu
);
3634 if (attr
&& DW_UNSND (attr
) != 0)
3635 fnp
->is_artificial
= 1;
3637 /* Get index in virtual function table if it is a virtual member function. */
3638 attr
= dwarf2_attr (die
, DW_AT_vtable_elem_location
, cu
);
3641 /* Support the .debug_loc offsets */
3642 if (attr_form_is_block (attr
))
3644 fnp
->voffset
= decode_locdesc (DW_BLOCK (attr
), cu
) + 2;
3646 else if (attr
->form
== DW_FORM_data4
|| attr
->form
== DW_FORM_data8
)
3648 dwarf2_complex_location_expr_complaint ();
3652 dwarf2_invalid_attrib_class_complaint ("DW_AT_vtable_elem_location",
3658 /* Create the vector of member function fields, and attach it to the type. */
3661 dwarf2_attach_fn_fields_to_type (struct field_info
*fip
, struct type
*type
,
3662 struct dwarf2_cu
*cu
)
3664 struct fnfieldlist
*flp
;
3665 int total_length
= 0;
3668 ALLOCATE_CPLUS_STRUCT_TYPE (type
);
3669 TYPE_FN_FIELDLISTS (type
) = (struct fn_fieldlist
*)
3670 TYPE_ALLOC (type
, sizeof (struct fn_fieldlist
) * fip
->nfnfields
);
3672 for (i
= 0, flp
= fip
->fnfieldlists
; i
< fip
->nfnfields
; i
++, flp
++)
3674 struct nextfnfield
*nfp
= flp
->head
;
3675 struct fn_fieldlist
*fn_flp
= &TYPE_FN_FIELDLIST (type
, i
);
3678 TYPE_FN_FIELDLIST_NAME (type
, i
) = flp
->name
;
3679 TYPE_FN_FIELDLIST_LENGTH (type
, i
) = flp
->length
;
3680 fn_flp
->fn_fields
= (struct fn_field
*)
3681 TYPE_ALLOC (type
, sizeof (struct fn_field
) * flp
->length
);
3682 for (k
= flp
->length
; (k
--, nfp
); nfp
= nfp
->next
)
3683 fn_flp
->fn_fields
[k
] = nfp
->fnfield
;
3685 total_length
+= flp
->length
;
3688 TYPE_NFN_FIELDS (type
) = fip
->nfnfields
;
3689 TYPE_NFN_FIELDS_TOTAL (type
) = total_length
;
3693 /* Returns non-zero if NAME is the name of a vtable member in CU's
3694 language, zero otherwise. */
3696 is_vtable_name (const char *name
, struct dwarf2_cu
*cu
)
3698 static const char vptr
[] = "_vptr";
3699 static const char vtable
[] = "vtable";
3701 /* Look for the C++ and Java forms of the vtable. */
3702 if ((cu
->language
== language_java
3703 && strncmp (name
, vtable
, sizeof (vtable
) - 1) == 0)
3704 || (strncmp (name
, vptr
, sizeof (vptr
) - 1) == 0
3705 && is_cplus_marker (name
[sizeof (vptr
) - 1])))
3711 /* GCC outputs unnamed structures that are really pointers to member
3712 functions, with the ABI-specified layout. If DIE (from CU) describes
3713 such a structure, set its type, and return nonzero. Otherwise return
3716 GCC shouldn't do this; it should just output pointer to member DIEs.
3717 This is GCC PR debug/28767. */
3720 quirk_gcc_member_function_pointer (struct die_info
*die
, struct dwarf2_cu
*cu
)
3722 struct objfile
*objfile
= cu
->objfile
;
3724 struct die_info
*pfn_die
, *delta_die
;
3725 struct attribute
*pfn_name
, *delta_name
;
3726 struct type
*pfn_type
, *domain_type
;
3728 /* Check for a structure with no name and two children. */
3729 if (die
->tag
!= DW_TAG_structure_type
3730 || dwarf2_attr (die
, DW_AT_name
, cu
) != NULL
3731 || die
->child
== NULL
3732 || die
->child
->sibling
== NULL
3733 || (die
->child
->sibling
->sibling
!= NULL
3734 && die
->child
->sibling
->sibling
->tag
!= DW_TAG_padding
))
3737 /* Check for __pfn and __delta members. */
3738 pfn_die
= die
->child
;
3739 pfn_name
= dwarf2_attr (pfn_die
, DW_AT_name
, cu
);
3740 if (pfn_die
->tag
!= DW_TAG_member
3742 || DW_STRING (pfn_name
) == NULL
3743 || strcmp ("__pfn", DW_STRING (pfn_name
)) != 0)
3746 delta_die
= pfn_die
->sibling
;
3747 delta_name
= dwarf2_attr (delta_die
, DW_AT_name
, cu
);
3748 if (delta_die
->tag
!= DW_TAG_member
3749 || delta_name
== NULL
3750 || DW_STRING (delta_name
) == NULL
3751 || strcmp ("__delta", DW_STRING (delta_name
)) != 0)
3754 /* Find the type of the method. */
3755 pfn_type
= die_type (pfn_die
, cu
);
3756 if (pfn_type
== NULL
3757 || TYPE_CODE (pfn_type
) != TYPE_CODE_PTR
3758 || TYPE_CODE (TYPE_TARGET_TYPE (pfn_type
)) != TYPE_CODE_FUNC
)
3761 /* Look for the "this" argument. */
3762 pfn_type
= TYPE_TARGET_TYPE (pfn_type
);
3763 if (TYPE_NFIELDS (pfn_type
) == 0
3764 || TYPE_CODE (TYPE_FIELD_TYPE (pfn_type
, 0)) != TYPE_CODE_PTR
)
3767 domain_type
= TYPE_TARGET_TYPE (TYPE_FIELD_TYPE (pfn_type
, 0));
3768 type
= alloc_type (objfile
);
3769 smash_to_method_type (type
, domain_type
, TYPE_TARGET_TYPE (pfn_type
),
3770 TYPE_FIELDS (pfn_type
), TYPE_NFIELDS (pfn_type
),
3771 TYPE_VARARGS (pfn_type
));
3772 type
= lookup_pointer_type (type
);
3773 set_die_type (die
, type
, cu
);
3778 /* Called when we find the DIE that starts a structure or union scope
3779 (definition) to process all dies that define the members of the
3782 NOTE: we need to call struct_type regardless of whether or not the
3783 DIE has an at_name attribute, since it might be an anonymous
3784 structure or union. This gets the type entered into our set of
3787 However, if the structure is incomplete (an opaque struct/union)
3788 then suppress creating a symbol table entry for it since gdb only
3789 wants to find the one with the complete definition. Note that if
3790 it is complete, we just call new_symbol, which does it's own
3791 checking about whether the struct/union is anonymous or not (and
3792 suppresses creating a symbol table entry itself). */
3795 read_structure_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
3797 struct objfile
*objfile
= cu
->objfile
;
3799 struct attribute
*attr
;
3800 const char *previous_prefix
= processing_current_prefix
;
3801 struct cleanup
*back_to
= NULL
;
3806 if (quirk_gcc_member_function_pointer (die
, cu
))
3809 type
= alloc_type (objfile
);
3810 INIT_CPLUS_SPECIFIC (type
);
3811 attr
= dwarf2_attr (die
, DW_AT_name
, cu
);
3812 if (attr
&& DW_STRING (attr
))
3814 if (cu
->language
== language_cplus
3815 || cu
->language
== language_java
)
3817 char *new_prefix
= determine_class_name (die
, cu
);
3818 TYPE_TAG_NAME (type
) = obsavestring (new_prefix
,
3819 strlen (new_prefix
),
3820 &objfile
->objfile_obstack
);
3821 back_to
= make_cleanup (xfree
, new_prefix
);
3822 processing_current_prefix
= new_prefix
;
3826 /* The name is already allocated along with this objfile, so
3827 we don't need to duplicate it for the type. */
3828 TYPE_TAG_NAME (type
) = DW_STRING (attr
);
3832 if (die
->tag
== DW_TAG_structure_type
)
3834 TYPE_CODE (type
) = TYPE_CODE_STRUCT
;
3836 else if (die
->tag
== DW_TAG_union_type
)
3838 TYPE_CODE (type
) = TYPE_CODE_UNION
;
3842 /* FIXME: TYPE_CODE_CLASS is currently defined to TYPE_CODE_STRUCT
3844 TYPE_CODE (type
) = TYPE_CODE_CLASS
;
3847 attr
= dwarf2_attr (die
, DW_AT_byte_size
, cu
);
3850 TYPE_LENGTH (type
) = DW_UNSND (attr
);
3854 TYPE_LENGTH (type
) = 0;
3857 if (die_is_declaration (die
, cu
))
3858 TYPE_FLAGS (type
) |= TYPE_FLAG_STUB
;
3860 /* We need to add the type field to the die immediately so we don't
3861 infinitely recurse when dealing with pointers to the structure
3862 type within the structure itself. */
3863 set_die_type (die
, type
, cu
);
3865 if (die
->child
!= NULL
&& ! die_is_declaration (die
, cu
))
3867 struct field_info fi
;
3868 struct die_info
*child_die
;
3869 struct cleanup
*back_to
= make_cleanup (null_cleanup
, NULL
);
3871 memset (&fi
, 0, sizeof (struct field_info
));
3873 child_die
= die
->child
;
3875 while (child_die
&& child_die
->tag
)
3877 if (child_die
->tag
== DW_TAG_member
3878 || child_die
->tag
== DW_TAG_variable
)
3880 /* NOTE: carlton/2002-11-05: A C++ static data member
3881 should be a DW_TAG_member that is a declaration, but
3882 all versions of G++ as of this writing (so through at
3883 least 3.2.1) incorrectly generate DW_TAG_variable
3884 tags for them instead. */
3885 dwarf2_add_field (&fi
, child_die
, cu
);
3887 else if (child_die
->tag
== DW_TAG_subprogram
)
3889 /* C++ member function. */
3890 read_type_die (child_die
, cu
);
3891 dwarf2_add_member_fn (&fi
, child_die
, type
, cu
);
3893 else if (child_die
->tag
== DW_TAG_inheritance
)
3895 /* C++ base class field. */
3896 dwarf2_add_field (&fi
, child_die
, cu
);
3898 child_die
= sibling_die (child_die
);
3901 /* Attach fields and member functions to the type. */
3903 dwarf2_attach_fields_to_type (&fi
, type
, cu
);
3906 dwarf2_attach_fn_fields_to_type (&fi
, type
, cu
);
3908 /* Get the type which refers to the base class (possibly this
3909 class itself) which contains the vtable pointer for the current
3910 class from the DW_AT_containing_type attribute. */
3912 if (dwarf2_attr (die
, DW_AT_containing_type
, cu
) != NULL
)
3914 struct type
*t
= die_containing_type (die
, cu
);
3916 TYPE_VPTR_BASETYPE (type
) = t
;
3921 /* Our own class provides vtbl ptr. */
3922 for (i
= TYPE_NFIELDS (t
) - 1;
3923 i
>= TYPE_N_BASECLASSES (t
);
3926 char *fieldname
= TYPE_FIELD_NAME (t
, i
);
3928 if (is_vtable_name (fieldname
, cu
))
3930 TYPE_VPTR_FIELDNO (type
) = i
;
3935 /* Complain if virtual function table field not found. */
3936 if (i
< TYPE_N_BASECLASSES (t
))
3937 complaint (&symfile_complaints
,
3938 _("virtual function table pointer not found when defining class '%s'"),
3939 TYPE_TAG_NAME (type
) ? TYPE_TAG_NAME (type
) :
3944 TYPE_VPTR_FIELDNO (type
) = TYPE_VPTR_FIELDNO (t
);
3947 else if (cu
->producer
3948 && strncmp (cu
->producer
,
3949 "IBM(R) XL C/C++ Advanced Edition", 32) == 0)
3951 /* The IBM XLC compiler does not provide direct indication
3952 of the containing type, but the vtable pointer is
3953 always named __vfp. */
3957 for (i
= TYPE_NFIELDS (type
) - 1;
3958 i
>= TYPE_N_BASECLASSES (type
);
3961 if (strcmp (TYPE_FIELD_NAME (type
, i
), "__vfp") == 0)
3963 TYPE_VPTR_FIELDNO (type
) = i
;
3964 TYPE_VPTR_BASETYPE (type
) = type
;
3971 do_cleanups (back_to
);
3974 processing_current_prefix
= previous_prefix
;
3975 if (back_to
!= NULL
)
3976 do_cleanups (back_to
);
3980 process_structure_scope (struct die_info
*die
, struct dwarf2_cu
*cu
)
3982 struct objfile
*objfile
= cu
->objfile
;
3983 const char *previous_prefix
= processing_current_prefix
;
3984 struct die_info
*child_die
= die
->child
;
3986 if (TYPE_TAG_NAME (die
->type
) != NULL
)
3987 processing_current_prefix
= TYPE_TAG_NAME (die
->type
);
3989 /* NOTE: carlton/2004-03-16: GCC 3.4 (or at least one of its
3990 snapshots) has been known to create a die giving a declaration
3991 for a class that has, as a child, a die giving a definition for a
3992 nested class. So we have to process our children even if the
3993 current die is a declaration. Normally, of course, a declaration
3994 won't have any children at all. */
3996 while (child_die
!= NULL
&& child_die
->tag
)
3998 if (child_die
->tag
== DW_TAG_member
3999 || child_die
->tag
== DW_TAG_variable
4000 || child_die
->tag
== DW_TAG_inheritance
)
4005 process_die (child_die
, cu
);
4007 child_die
= sibling_die (child_die
);
4010 if (die
->child
!= NULL
&& ! die_is_declaration (die
, cu
))
4011 new_symbol (die
, die
->type
, cu
);
4013 processing_current_prefix
= previous_prefix
;
4016 /* Given a DW_AT_enumeration_type die, set its type. We do not
4017 complete the type's fields yet, or create any symbols. */
4020 read_enumeration_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
4022 struct objfile
*objfile
= cu
->objfile
;
4024 struct attribute
*attr
;
4029 type
= alloc_type (objfile
);
4031 TYPE_CODE (type
) = TYPE_CODE_ENUM
;
4032 attr
= dwarf2_attr (die
, DW_AT_name
, cu
);
4033 if (attr
&& DW_STRING (attr
))
4035 char *name
= DW_STRING (attr
);
4037 if (processing_has_namespace_info
)
4039 TYPE_TAG_NAME (type
) = typename_concat (&objfile
->objfile_obstack
,
4040 processing_current_prefix
,
4045 /* The name is already allocated along with this objfile, so
4046 we don't need to duplicate it for the type. */
4047 TYPE_TAG_NAME (type
) = name
;
4051 attr
= dwarf2_attr (die
, DW_AT_byte_size
, cu
);
4054 TYPE_LENGTH (type
) = DW_UNSND (attr
);
4058 TYPE_LENGTH (type
) = 0;
4061 set_die_type (die
, type
, cu
);
4064 /* Determine the name of the type represented by DIE, which should be
4065 a named C++ or Java compound type. Return the name in question; the caller
4066 is responsible for xfree()'ing it. */
4069 determine_class_name (struct die_info
*die
, struct dwarf2_cu
*cu
)
4071 struct cleanup
*back_to
= NULL
;
4072 struct die_info
*spec_die
= die_specification (die
, cu
);
4073 char *new_prefix
= NULL
;
4075 /* If this is the definition of a class that is declared by another
4076 die, then processing_current_prefix may not be accurate; see
4077 read_func_scope for a similar example. */
4078 if (spec_die
!= NULL
)
4080 char *specification_prefix
= determine_prefix (spec_die
, cu
);
4081 processing_current_prefix
= specification_prefix
;
4082 back_to
= make_cleanup (xfree
, specification_prefix
);
4085 /* If we don't have namespace debug info, guess the name by trying
4086 to demangle the names of members, just like we did in
4087 guess_structure_name. */
4088 if (!processing_has_namespace_info
)
4090 struct die_info
*child
;
4092 for (child
= die
->child
;
4093 child
!= NULL
&& child
->tag
!= 0;
4094 child
= sibling_die (child
))
4096 if (child
->tag
== DW_TAG_subprogram
)
4099 = language_class_name_from_physname (cu
->language_defn
,
4103 if (new_prefix
!= NULL
)
4109 if (new_prefix
== NULL
)
4111 const char *name
= dwarf2_name (die
, cu
);
4112 new_prefix
= typename_concat (NULL
, processing_current_prefix
,
4113 name
? name
: "<<anonymous>>",
4117 if (back_to
!= NULL
)
4118 do_cleanups (back_to
);
4123 /* Given a pointer to a die which begins an enumeration, process all
4124 the dies that define the members of the enumeration, and create the
4125 symbol for the enumeration type.
4127 NOTE: We reverse the order of the element list. */
4130 process_enumeration_scope (struct die_info
*die
, struct dwarf2_cu
*cu
)
4132 struct objfile
*objfile
= cu
->objfile
;
4133 struct die_info
*child_die
;
4134 struct field
*fields
;
4135 struct attribute
*attr
;
4138 int unsigned_enum
= 1;
4142 if (die
->child
!= NULL
)
4144 child_die
= die
->child
;
4145 while (child_die
&& child_die
->tag
)
4147 if (child_die
->tag
!= DW_TAG_enumerator
)
4149 process_die (child_die
, cu
);
4153 attr
= dwarf2_attr (child_die
, DW_AT_name
, cu
);
4156 sym
= new_symbol (child_die
, die
->type
, cu
);
4157 if (SYMBOL_VALUE (sym
) < 0)
4160 if ((num_fields
% DW_FIELD_ALLOC_CHUNK
) == 0)
4162 fields
= (struct field
*)
4164 (num_fields
+ DW_FIELD_ALLOC_CHUNK
)
4165 * sizeof (struct field
));
4168 FIELD_NAME (fields
[num_fields
]) = DEPRECATED_SYMBOL_NAME (sym
);
4169 FIELD_TYPE (fields
[num_fields
]) = NULL
;
4170 FIELD_BITPOS (fields
[num_fields
]) = SYMBOL_VALUE (sym
);
4171 FIELD_BITSIZE (fields
[num_fields
]) = 0;
4172 FIELD_STATIC_KIND (fields
[num_fields
]) = 0;
4178 child_die
= sibling_die (child_die
);
4183 TYPE_NFIELDS (die
->type
) = num_fields
;
4184 TYPE_FIELDS (die
->type
) = (struct field
*)
4185 TYPE_ALLOC (die
->type
, sizeof (struct field
) * num_fields
);
4186 memcpy (TYPE_FIELDS (die
->type
), fields
,
4187 sizeof (struct field
) * num_fields
);
4191 TYPE_FLAGS (die
->type
) |= TYPE_FLAG_UNSIGNED
;
4194 new_symbol (die
, die
->type
, cu
);
4197 /* Extract all information from a DW_TAG_array_type DIE and put it in
4198 the DIE's type field. For now, this only handles one dimensional
4202 read_array_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
4204 struct objfile
*objfile
= cu
->objfile
;
4205 struct die_info
*child_die
;
4206 struct type
*type
= NULL
;
4207 struct type
*element_type
, *range_type
, *index_type
;
4208 struct type
**range_types
= NULL
;
4209 struct attribute
*attr
;
4211 struct cleanup
*back_to
;
4213 /* Return if we've already decoded this type. */
4219 element_type
= die_type (die
, cu
);
4221 /* Irix 6.2 native cc creates array types without children for
4222 arrays with unspecified length. */
4223 if (die
->child
== NULL
)
4225 index_type
= dwarf2_fundamental_type (objfile
, FT_INTEGER
, cu
);
4226 range_type
= create_range_type (NULL
, index_type
, 0, -1);
4227 set_die_type (die
, create_array_type (NULL
, element_type
, range_type
),
4232 back_to
= make_cleanup (null_cleanup
, NULL
);
4233 child_die
= die
->child
;
4234 while (child_die
&& child_die
->tag
)
4236 if (child_die
->tag
== DW_TAG_subrange_type
)
4238 read_subrange_type (child_die
, cu
);
4240 if (child_die
->type
!= NULL
)
4242 /* The range type was succesfully read. Save it for
4243 the array type creation. */
4244 if ((ndim
% DW_FIELD_ALLOC_CHUNK
) == 0)
4246 range_types
= (struct type
**)
4247 xrealloc (range_types
, (ndim
+ DW_FIELD_ALLOC_CHUNK
)
4248 * sizeof (struct type
*));
4250 make_cleanup (free_current_contents
, &range_types
);
4252 range_types
[ndim
++] = child_die
->type
;
4255 child_die
= sibling_die (child_die
);
4258 /* Dwarf2 dimensions are output from left to right, create the
4259 necessary array types in backwards order. */
4261 type
= element_type
;
4263 if (read_array_order (die
, cu
) == DW_ORD_col_major
)
4267 type
= create_array_type (NULL
, type
, range_types
[i
++]);
4272 type
= create_array_type (NULL
, type
, range_types
[ndim
]);
4275 /* Understand Dwarf2 support for vector types (like they occur on
4276 the PowerPC w/ AltiVec). Gcc just adds another attribute to the
4277 array type. This is not part of the Dwarf2/3 standard yet, but a
4278 custom vendor extension. The main difference between a regular
4279 array and the vector variant is that vectors are passed by value
4281 attr
= dwarf2_attr (die
, DW_AT_GNU_vector
, cu
);
4283 TYPE_FLAGS (type
) |= TYPE_FLAG_VECTOR
;
4285 attr
= dwarf2_attr (die
, DW_AT_name
, cu
);
4286 if (attr
&& DW_STRING (attr
))
4287 TYPE_NAME (type
) = DW_STRING (attr
);
4289 do_cleanups (back_to
);
4291 /* Install the type in the die. */
4292 set_die_type (die
, type
, cu
);
4295 static enum dwarf_array_dim_ordering
4296 read_array_order (struct die_info
*die
, struct dwarf2_cu
*cu
)
4298 struct attribute
*attr
;
4300 attr
= dwarf2_attr (die
, DW_AT_ordering
, cu
);
4302 if (attr
) return DW_SND (attr
);
4305 GNU F77 is a special case, as at 08/2004 array type info is the
4306 opposite order to the dwarf2 specification, but data is still
4307 laid out as per normal fortran.
4309 FIXME: dsl/2004-8-20: If G77 is ever fixed, this will also need
4313 if (cu
->language
== language_fortran
&&
4314 cu
->producer
&& strstr (cu
->producer
, "GNU F77"))
4316 return DW_ORD_row_major
;
4319 switch (cu
->language_defn
->la_array_ordering
)
4321 case array_column_major
:
4322 return DW_ORD_col_major
;
4323 case array_row_major
:
4325 return DW_ORD_row_major
;
4329 /* Extract all information from a DW_TAG_set_type DIE and put it in
4330 the DIE's type field. */
4333 read_set_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
4335 if (die
->type
== NULL
)
4336 die
->type
= create_set_type ((struct type
*) NULL
, die_type (die
, cu
));
4339 /* First cut: install each common block member as a global variable. */
4342 read_common_block (struct die_info
*die
, struct dwarf2_cu
*cu
)
4344 struct die_info
*child_die
;
4345 struct attribute
*attr
;
4347 CORE_ADDR base
= (CORE_ADDR
) 0;
4349 attr
= dwarf2_attr (die
, DW_AT_location
, cu
);
4352 /* Support the .debug_loc offsets */
4353 if (attr_form_is_block (attr
))
4355 base
= decode_locdesc (DW_BLOCK (attr
), cu
);
4357 else if (attr
->form
== DW_FORM_data4
|| attr
->form
== DW_FORM_data8
)
4359 dwarf2_complex_location_expr_complaint ();
4363 dwarf2_invalid_attrib_class_complaint ("DW_AT_location",
4364 "common block member");
4367 if (die
->child
!= NULL
)
4369 child_die
= die
->child
;
4370 while (child_die
&& child_die
->tag
)
4372 sym
= new_symbol (child_die
, NULL
, cu
);
4373 attr
= dwarf2_attr (child_die
, DW_AT_data_member_location
, cu
);
4376 SYMBOL_VALUE_ADDRESS (sym
) =
4377 base
+ decode_locdesc (DW_BLOCK (attr
), cu
);
4378 add_symbol_to_list (sym
, &global_symbols
);
4380 child_die
= sibling_die (child_die
);
4385 /* Read a C++ namespace. */
4388 read_namespace (struct die_info
*die
, struct dwarf2_cu
*cu
)
4390 struct objfile
*objfile
= cu
->objfile
;
4391 const char *previous_prefix
= processing_current_prefix
;
4394 struct die_info
*current_die
;
4395 struct cleanup
*back_to
= make_cleanup (null_cleanup
, 0);
4397 name
= namespace_name (die
, &is_anonymous
, cu
);
4399 /* Now build the name of the current namespace. */
4401 if (previous_prefix
[0] == '\0')
4403 processing_current_prefix
= name
;
4407 char *temp_name
= typename_concat (NULL
, previous_prefix
, name
, cu
);
4408 make_cleanup (xfree
, temp_name
);
4409 processing_current_prefix
= temp_name
;
4412 /* Add a symbol associated to this if we haven't seen the namespace
4413 before. Also, add a using directive if it's an anonymous
4416 if (dwarf2_extension (die
, cu
) == NULL
)
4420 /* FIXME: carlton/2003-06-27: Once GDB is more const-correct,
4421 this cast will hopefully become unnecessary. */
4422 type
= init_type (TYPE_CODE_NAMESPACE
, 0, 0,
4423 (char *) processing_current_prefix
,
4425 TYPE_TAG_NAME (type
) = TYPE_NAME (type
);
4427 new_symbol (die
, type
, cu
);
4428 set_die_type (die
, type
, cu
);
4431 cp_add_using_directive (processing_current_prefix
,
4432 strlen (previous_prefix
),
4433 strlen (processing_current_prefix
));
4436 if (die
->child
!= NULL
)
4438 struct die_info
*child_die
= die
->child
;
4440 while (child_die
&& child_die
->tag
)
4442 process_die (child_die
, cu
);
4443 child_die
= sibling_die (child_die
);
4447 processing_current_prefix
= previous_prefix
;
4448 do_cleanups (back_to
);
4451 /* Return the name of the namespace represented by DIE. Set
4452 *IS_ANONYMOUS to tell whether or not the namespace is an anonymous
4456 namespace_name (struct die_info
*die
, int *is_anonymous
, struct dwarf2_cu
*cu
)
4458 struct die_info
*current_die
;
4459 const char *name
= NULL
;
4461 /* Loop through the extensions until we find a name. */
4463 for (current_die
= die
;
4464 current_die
!= NULL
;
4465 current_die
= dwarf2_extension (die
, cu
))
4467 name
= dwarf2_name (current_die
, cu
);
4472 /* Is it an anonymous namespace? */
4474 *is_anonymous
= (name
== NULL
);
4476 name
= "(anonymous namespace)";
4481 /* Extract all information from a DW_TAG_pointer_type DIE and add to
4482 the user defined type vector. */
4485 read_tag_pointer_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
4487 struct comp_unit_head
*cu_header
= &cu
->header
;
4489 struct attribute
*attr_byte_size
;
4490 struct attribute
*attr_address_class
;
4491 int byte_size
, addr_class
;
4498 type
= lookup_pointer_type (die_type (die
, cu
));
4500 attr_byte_size
= dwarf2_attr (die
, DW_AT_byte_size
, cu
);
4502 byte_size
= DW_UNSND (attr_byte_size
);
4504 byte_size
= cu_header
->addr_size
;
4506 attr_address_class
= dwarf2_attr (die
, DW_AT_address_class
, cu
);
4507 if (attr_address_class
)
4508 addr_class
= DW_UNSND (attr_address_class
);
4510 addr_class
= DW_ADDR_none
;
4512 /* If the pointer size or address class is different than the
4513 default, create a type variant marked as such and set the
4514 length accordingly. */
4515 if (TYPE_LENGTH (type
) != byte_size
|| addr_class
!= DW_ADDR_none
)
4517 if (ADDRESS_CLASS_TYPE_FLAGS_P ())
4521 type_flags
= ADDRESS_CLASS_TYPE_FLAGS (byte_size
, addr_class
);
4522 gdb_assert ((type_flags
& ~TYPE_FLAG_ADDRESS_CLASS_ALL
) == 0);
4523 type
= make_type_with_address_space (type
, type_flags
);
4525 else if (TYPE_LENGTH (type
) != byte_size
)
4527 complaint (&symfile_complaints
, _("invalid pointer size %d"), byte_size
);
4530 /* Should we also complain about unhandled address classes? */
4534 TYPE_LENGTH (type
) = byte_size
;
4535 set_die_type (die
, type
, cu
);
4538 /* Extract all information from a DW_TAG_ptr_to_member_type DIE and add to
4539 the user defined type vector. */
4542 read_tag_ptr_to_member_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
4544 struct objfile
*objfile
= cu
->objfile
;
4546 struct type
*to_type
;
4547 struct type
*domain
;
4554 type
= alloc_type (objfile
);
4555 to_type
= die_type (die
, cu
);
4556 domain
= die_containing_type (die
, cu
);
4557 smash_to_member_type (type
, domain
, to_type
);
4559 set_die_type (die
, type
, cu
);
4562 /* Extract all information from a DW_TAG_reference_type DIE and add to
4563 the user defined type vector. */
4566 read_tag_reference_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
4568 struct comp_unit_head
*cu_header
= &cu
->header
;
4570 struct attribute
*attr
;
4577 type
= lookup_reference_type (die_type (die
, cu
));
4578 attr
= dwarf2_attr (die
, DW_AT_byte_size
, cu
);
4581 TYPE_LENGTH (type
) = DW_UNSND (attr
);
4585 TYPE_LENGTH (type
) = cu_header
->addr_size
;
4587 set_die_type (die
, type
, cu
);
4591 read_tag_const_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
4593 struct type
*base_type
;
4600 base_type
= die_type (die
, cu
);
4601 set_die_type (die
, make_cv_type (1, TYPE_VOLATILE (base_type
), base_type
, 0),
4606 read_tag_volatile_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
4608 struct type
*base_type
;
4615 base_type
= die_type (die
, cu
);
4616 set_die_type (die
, make_cv_type (TYPE_CONST (base_type
), 1, base_type
, 0),
4620 /* Extract all information from a DW_TAG_string_type DIE and add to
4621 the user defined type vector. It isn't really a user defined type,
4622 but it behaves like one, with other DIE's using an AT_user_def_type
4623 attribute to reference it. */
4626 read_tag_string_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
4628 struct objfile
*objfile
= cu
->objfile
;
4629 struct type
*type
, *range_type
, *index_type
, *char_type
;
4630 struct attribute
*attr
;
4631 unsigned int length
;
4638 attr
= dwarf2_attr (die
, DW_AT_string_length
, cu
);
4641 length
= DW_UNSND (attr
);
4645 /* check for the DW_AT_byte_size attribute */
4646 attr
= dwarf2_attr (die
, DW_AT_byte_size
, cu
);
4649 length
= DW_UNSND (attr
);
4656 index_type
= dwarf2_fundamental_type (objfile
, FT_INTEGER
, cu
);
4657 range_type
= create_range_type (NULL
, index_type
, 1, length
);
4658 if (cu
->language
== language_fortran
)
4660 /* Need to create a unique string type for bounds
4662 type
= create_string_type (0, range_type
);
4666 char_type
= dwarf2_fundamental_type (objfile
, FT_CHAR
, cu
);
4667 type
= create_string_type (char_type
, range_type
);
4669 set_die_type (die
, type
, cu
);
4672 /* Handle DIES due to C code like:
4676 int (*funcp)(int a, long l);
4680 ('funcp' generates a DW_TAG_subroutine_type DIE)
4684 read_subroutine_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
4686 struct type
*type
; /* Type that this function returns */
4687 struct type
*ftype
; /* Function that returns above type */
4688 struct attribute
*attr
;
4690 /* Decode the type that this subroutine returns */
4695 type
= die_type (die
, cu
);
4696 ftype
= make_function_type (type
, (struct type
**) 0);
4698 /* All functions in C++ and Java have prototypes. */
4699 attr
= dwarf2_attr (die
, DW_AT_prototyped
, cu
);
4700 if ((attr
&& (DW_UNSND (attr
) != 0))
4701 || cu
->language
== language_cplus
4702 || cu
->language
== language_java
)
4703 TYPE_FLAGS (ftype
) |= TYPE_FLAG_PROTOTYPED
;
4705 if (die
->child
!= NULL
)
4707 struct die_info
*child_die
;
4711 /* Count the number of parameters.
4712 FIXME: GDB currently ignores vararg functions, but knows about
4713 vararg member functions. */
4714 child_die
= die
->child
;
4715 while (child_die
&& child_die
->tag
)
4717 if (child_die
->tag
== DW_TAG_formal_parameter
)
4719 else if (child_die
->tag
== DW_TAG_unspecified_parameters
)
4720 TYPE_FLAGS (ftype
) |= TYPE_FLAG_VARARGS
;
4721 child_die
= sibling_die (child_die
);
4724 /* Allocate storage for parameters and fill them in. */
4725 TYPE_NFIELDS (ftype
) = nparams
;
4726 TYPE_FIELDS (ftype
) = (struct field
*)
4727 TYPE_ZALLOC (ftype
, nparams
* sizeof (struct field
));
4729 child_die
= die
->child
;
4730 while (child_die
&& child_die
->tag
)
4732 if (child_die
->tag
== DW_TAG_formal_parameter
)
4734 /* Dwarf2 has no clean way to discern C++ static and non-static
4735 member functions. G++ helps GDB by marking the first
4736 parameter for non-static member functions (which is the
4737 this pointer) as artificial. We pass this information
4738 to dwarf2_add_member_fn via TYPE_FIELD_ARTIFICIAL. */
4739 attr
= dwarf2_attr (child_die
, DW_AT_artificial
, cu
);
4741 TYPE_FIELD_ARTIFICIAL (ftype
, iparams
) = DW_UNSND (attr
);
4743 TYPE_FIELD_ARTIFICIAL (ftype
, iparams
) = 0;
4744 TYPE_FIELD_TYPE (ftype
, iparams
) = die_type (child_die
, cu
);
4747 child_die
= sibling_die (child_die
);
4751 set_die_type (die
, ftype
, cu
);
4755 read_typedef (struct die_info
*die
, struct dwarf2_cu
*cu
)
4757 struct objfile
*objfile
= cu
->objfile
;
4758 struct attribute
*attr
;
4763 attr
= dwarf2_attr (die
, DW_AT_name
, cu
);
4764 if (attr
&& DW_STRING (attr
))
4766 name
= DW_STRING (attr
);
4768 set_die_type (die
, init_type (TYPE_CODE_TYPEDEF
, 0,
4769 TYPE_FLAG_TARGET_STUB
, name
, objfile
),
4771 TYPE_TARGET_TYPE (die
->type
) = die_type (die
, cu
);
4775 /* Find a representation of a given base type and install
4776 it in the TYPE field of the die. */
4779 read_base_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
4781 struct objfile
*objfile
= cu
->objfile
;
4783 struct attribute
*attr
;
4784 int encoding
= 0, size
= 0;
4786 /* If we've already decoded this die, this is a no-op. */
4792 attr
= dwarf2_attr (die
, DW_AT_encoding
, cu
);
4795 encoding
= DW_UNSND (attr
);
4797 attr
= dwarf2_attr (die
, DW_AT_byte_size
, cu
);
4800 size
= DW_UNSND (attr
);
4802 attr
= dwarf2_attr (die
, DW_AT_name
, cu
);
4803 if (attr
&& DW_STRING (attr
))
4805 enum type_code code
= TYPE_CODE_INT
;
4810 case DW_ATE_address
:
4811 /* Turn DW_ATE_address into a void * pointer. */
4812 code
= TYPE_CODE_PTR
;
4813 type_flags
|= TYPE_FLAG_UNSIGNED
;
4815 case DW_ATE_boolean
:
4816 code
= TYPE_CODE_BOOL
;
4817 type_flags
|= TYPE_FLAG_UNSIGNED
;
4819 case DW_ATE_complex_float
:
4820 code
= TYPE_CODE_COMPLEX
;
4823 code
= TYPE_CODE_FLT
;
4827 case DW_ATE_unsigned
:
4828 type_flags
|= TYPE_FLAG_UNSIGNED
;
4830 case DW_ATE_signed_char
:
4831 if (cu
->language
== language_m2
)
4832 code
= TYPE_CODE_CHAR
;
4834 case DW_ATE_unsigned_char
:
4835 if (cu
->language
== language_m2
)
4836 code
= TYPE_CODE_CHAR
;
4837 type_flags
|= TYPE_FLAG_UNSIGNED
;
4840 complaint (&symfile_complaints
, _("unsupported DW_AT_encoding: '%s'"),
4841 dwarf_type_encoding_name (encoding
));
4844 type
= init_type (code
, size
, type_flags
, DW_STRING (attr
), objfile
);
4845 if (encoding
== DW_ATE_address
)
4846 TYPE_TARGET_TYPE (type
) = dwarf2_fundamental_type (objfile
, FT_VOID
,
4848 else if (encoding
== DW_ATE_complex_float
)
4851 TYPE_TARGET_TYPE (type
)
4852 = dwarf2_fundamental_type (objfile
, FT_EXT_PREC_FLOAT
, cu
);
4853 else if (size
== 16)
4854 TYPE_TARGET_TYPE (type
)
4855 = dwarf2_fundamental_type (objfile
, FT_DBL_PREC_FLOAT
, cu
);
4857 TYPE_TARGET_TYPE (type
)
4858 = dwarf2_fundamental_type (objfile
, FT_FLOAT
, cu
);
4863 type
= dwarf_base_type (encoding
, size
, cu
);
4865 set_die_type (die
, type
, cu
);
4868 /* Read the given DW_AT_subrange DIE. */
4871 read_subrange_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
4873 struct type
*base_type
;
4874 struct type
*range_type
;
4875 struct attribute
*attr
;
4879 /* If we have already decoded this die, then nothing more to do. */
4883 base_type
= die_type (die
, cu
);
4884 if (base_type
== NULL
)
4886 complaint (&symfile_complaints
,
4887 _("DW_AT_type missing from DW_TAG_subrange_type"));
4891 if (TYPE_CODE (base_type
) == TYPE_CODE_VOID
)
4892 base_type
= alloc_type (NULL
);
4894 if (cu
->language
== language_fortran
)
4896 /* FORTRAN implies a lower bound of 1, if not given. */
4900 /* FIXME: For variable sized arrays either of these could be
4901 a variable rather than a constant value. We'll allow it,
4902 but we don't know how to handle it. */
4903 attr
= dwarf2_attr (die
, DW_AT_lower_bound
, cu
);
4905 low
= dwarf2_get_attr_constant_value (attr
, 0);
4907 attr
= dwarf2_attr (die
, DW_AT_upper_bound
, cu
);
4910 if (attr
->form
== DW_FORM_block1
)
4912 /* GCC encodes arrays with unspecified or dynamic length
4913 with a DW_FORM_block1 attribute.
4914 FIXME: GDB does not yet know how to handle dynamic
4915 arrays properly, treat them as arrays with unspecified
4918 FIXME: jimb/2003-09-22: GDB does not really know
4919 how to handle arrays of unspecified length
4920 either; we just represent them as zero-length
4921 arrays. Choose an appropriate upper bound given
4922 the lower bound we've computed above. */
4926 high
= dwarf2_get_attr_constant_value (attr
, 1);
4929 range_type
= create_range_type (NULL
, base_type
, low
, high
);
4931 attr
= dwarf2_attr (die
, DW_AT_name
, cu
);
4932 if (attr
&& DW_STRING (attr
))
4933 TYPE_NAME (range_type
) = DW_STRING (attr
);
4935 attr
= dwarf2_attr (die
, DW_AT_byte_size
, cu
);
4937 TYPE_LENGTH (range_type
) = DW_UNSND (attr
);
4939 set_die_type (die
, range_type
, cu
);
4943 read_unspecified_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
4946 struct attribute
*attr
;
4951 /* For now, we only support the C meaning of an unspecified type: void. */
4953 attr
= dwarf2_attr (die
, DW_AT_name
, cu
);
4954 type
= init_type (TYPE_CODE_VOID
, 0, 0, attr
? DW_STRING (attr
) : "",
4957 set_die_type (die
, type
, cu
);
4960 /* Read a whole compilation unit into a linked list of dies. */
4962 static struct die_info
*
4963 read_comp_unit (gdb_byte
*info_ptr
, bfd
*abfd
, struct dwarf2_cu
*cu
)
4965 return read_die_and_children (info_ptr
, abfd
, cu
, &info_ptr
, NULL
);
4968 /* Read a single die and all its descendents. Set the die's sibling
4969 field to NULL; set other fields in the die correctly, and set all
4970 of the descendents' fields correctly. Set *NEW_INFO_PTR to the
4971 location of the info_ptr after reading all of those dies. PARENT
4972 is the parent of the die in question. */
4974 static struct die_info
*
4975 read_die_and_children (gdb_byte
*info_ptr
, bfd
*abfd
,
4976 struct dwarf2_cu
*cu
,
4977 gdb_byte
**new_info_ptr
,
4978 struct die_info
*parent
)
4980 struct die_info
*die
;
4984 cur_ptr
= read_full_die (&die
, abfd
, info_ptr
, cu
, &has_children
);
4985 store_in_ref_table (die
->offset
, die
, cu
);
4989 die
->child
= read_die_and_siblings (cur_ptr
, abfd
, cu
,
4995 *new_info_ptr
= cur_ptr
;
4998 die
->sibling
= NULL
;
4999 die
->parent
= parent
;
5003 /* Read a die, all of its descendents, and all of its siblings; set
5004 all of the fields of all of the dies correctly. Arguments are as
5005 in read_die_and_children. */
5007 static struct die_info
*
5008 read_die_and_siblings (gdb_byte
*info_ptr
, bfd
*abfd
,
5009 struct dwarf2_cu
*cu
,
5010 gdb_byte
**new_info_ptr
,
5011 struct die_info
*parent
)
5013 struct die_info
*first_die
, *last_sibling
;
5017 first_die
= last_sibling
= NULL
;
5021 struct die_info
*die
5022 = read_die_and_children (cur_ptr
, abfd
, cu
, &cur_ptr
, parent
);
5030 last_sibling
->sibling
= die
;
5035 *new_info_ptr
= cur_ptr
;
5045 /* Free a linked list of dies. */
5048 free_die_list (struct die_info
*dies
)
5050 struct die_info
*die
, *next
;
5055 if (die
->child
!= NULL
)
5056 free_die_list (die
->child
);
5057 next
= die
->sibling
;
5064 /* Read the contents of the section at OFFSET and of size SIZE from the
5065 object file specified by OBJFILE into the objfile_obstack and return it. */
5068 dwarf2_read_section (struct objfile
*objfile
, asection
*sectp
)
5070 bfd
*abfd
= objfile
->obfd
;
5071 gdb_byte
*buf
, *retbuf
;
5072 bfd_size_type size
= bfd_get_section_size (sectp
);
5077 buf
= obstack_alloc (&objfile
->objfile_obstack
, size
);
5078 retbuf
= symfile_relocate_debug_section (abfd
, sectp
, buf
);
5082 if (bfd_seek (abfd
, sectp
->filepos
, SEEK_SET
) != 0
5083 || bfd_bread (buf
, size
, abfd
) != size
)
5084 error (_("Dwarf Error: Can't read DWARF data from '%s'"),
5085 bfd_get_filename (abfd
));
5090 /* In DWARF version 2, the description of the debugging information is
5091 stored in a separate .debug_abbrev section. Before we read any
5092 dies from a section we read in all abbreviations and install them
5093 in a hash table. This function also sets flags in CU describing
5094 the data found in the abbrev table. */
5097 dwarf2_read_abbrevs (bfd
*abfd
, struct dwarf2_cu
*cu
)
5099 struct comp_unit_head
*cu_header
= &cu
->header
;
5100 gdb_byte
*abbrev_ptr
;
5101 struct abbrev_info
*cur_abbrev
;
5102 unsigned int abbrev_number
, bytes_read
, abbrev_name
;
5103 unsigned int abbrev_form
, hash_number
;
5104 struct attr_abbrev
*cur_attrs
;
5105 unsigned int allocated_attrs
;
5107 /* Initialize dwarf2 abbrevs */
5108 obstack_init (&cu
->abbrev_obstack
);
5109 cu
->dwarf2_abbrevs
= obstack_alloc (&cu
->abbrev_obstack
,
5111 * sizeof (struct abbrev_info
*)));
5112 memset (cu
->dwarf2_abbrevs
, 0,
5113 ABBREV_HASH_SIZE
* sizeof (struct abbrev_info
*));
5115 abbrev_ptr
= dwarf2_per_objfile
->abbrev_buffer
+ cu_header
->abbrev_offset
;
5116 abbrev_number
= read_unsigned_leb128 (abfd
, abbrev_ptr
, &bytes_read
);
5117 abbrev_ptr
+= bytes_read
;
5119 allocated_attrs
= ATTR_ALLOC_CHUNK
;
5120 cur_attrs
= xmalloc (allocated_attrs
* sizeof (struct attr_abbrev
));
5122 /* loop until we reach an abbrev number of 0 */
5123 while (abbrev_number
)
5125 cur_abbrev
= dwarf_alloc_abbrev (cu
);
5127 /* read in abbrev header */
5128 cur_abbrev
->number
= abbrev_number
;
5129 cur_abbrev
->tag
= read_unsigned_leb128 (abfd
, abbrev_ptr
, &bytes_read
);
5130 abbrev_ptr
+= bytes_read
;
5131 cur_abbrev
->has_children
= read_1_byte (abfd
, abbrev_ptr
);
5134 if (cur_abbrev
->tag
== DW_TAG_namespace
)
5135 cu
->has_namespace_info
= 1;
5137 /* now read in declarations */
5138 abbrev_name
= read_unsigned_leb128 (abfd
, abbrev_ptr
, &bytes_read
);
5139 abbrev_ptr
+= bytes_read
;
5140 abbrev_form
= read_unsigned_leb128 (abfd
, abbrev_ptr
, &bytes_read
);
5141 abbrev_ptr
+= bytes_read
;
5144 if (cur_abbrev
->num_attrs
== allocated_attrs
)
5146 allocated_attrs
+= ATTR_ALLOC_CHUNK
;
5148 = xrealloc (cur_attrs
, (allocated_attrs
5149 * sizeof (struct attr_abbrev
)));
5152 /* Record whether this compilation unit might have
5153 inter-compilation-unit references. If we don't know what form
5154 this attribute will have, then it might potentially be a
5155 DW_FORM_ref_addr, so we conservatively expect inter-CU
5158 if (abbrev_form
== DW_FORM_ref_addr
5159 || abbrev_form
== DW_FORM_indirect
)
5160 cu
->has_form_ref_addr
= 1;
5162 cur_attrs
[cur_abbrev
->num_attrs
].name
= abbrev_name
;
5163 cur_attrs
[cur_abbrev
->num_attrs
++].form
= abbrev_form
;
5164 abbrev_name
= read_unsigned_leb128 (abfd
, abbrev_ptr
, &bytes_read
);
5165 abbrev_ptr
+= bytes_read
;
5166 abbrev_form
= read_unsigned_leb128 (abfd
, abbrev_ptr
, &bytes_read
);
5167 abbrev_ptr
+= bytes_read
;
5170 cur_abbrev
->attrs
= obstack_alloc (&cu
->abbrev_obstack
,
5171 (cur_abbrev
->num_attrs
5172 * sizeof (struct attr_abbrev
)));
5173 memcpy (cur_abbrev
->attrs
, cur_attrs
,
5174 cur_abbrev
->num_attrs
* sizeof (struct attr_abbrev
));
5176 hash_number
= abbrev_number
% ABBREV_HASH_SIZE
;
5177 cur_abbrev
->next
= cu
->dwarf2_abbrevs
[hash_number
];
5178 cu
->dwarf2_abbrevs
[hash_number
] = cur_abbrev
;
5180 /* Get next abbreviation.
5181 Under Irix6 the abbreviations for a compilation unit are not
5182 always properly terminated with an abbrev number of 0.
5183 Exit loop if we encounter an abbreviation which we have
5184 already read (which means we are about to read the abbreviations
5185 for the next compile unit) or if the end of the abbreviation
5186 table is reached. */
5187 if ((unsigned int) (abbrev_ptr
- dwarf2_per_objfile
->abbrev_buffer
)
5188 >= dwarf2_per_objfile
->abbrev_size
)
5190 abbrev_number
= read_unsigned_leb128 (abfd
, abbrev_ptr
, &bytes_read
);
5191 abbrev_ptr
+= bytes_read
;
5192 if (dwarf2_lookup_abbrev (abbrev_number
, cu
) != NULL
)
5199 /* Release the memory used by the abbrev table for a compilation unit. */
5202 dwarf2_free_abbrev_table (void *ptr_to_cu
)
5204 struct dwarf2_cu
*cu
= ptr_to_cu
;
5206 obstack_free (&cu
->abbrev_obstack
, NULL
);
5207 cu
->dwarf2_abbrevs
= NULL
;
5210 /* Lookup an abbrev_info structure in the abbrev hash table. */
5212 static struct abbrev_info
*
5213 dwarf2_lookup_abbrev (unsigned int number
, struct dwarf2_cu
*cu
)
5215 unsigned int hash_number
;
5216 struct abbrev_info
*abbrev
;
5218 hash_number
= number
% ABBREV_HASH_SIZE
;
5219 abbrev
= cu
->dwarf2_abbrevs
[hash_number
];
5223 if (abbrev
->number
== number
)
5226 abbrev
= abbrev
->next
;
5231 /* Returns nonzero if TAG represents a type that we might generate a partial
5235 is_type_tag_for_partial (int tag
)
5240 /* Some types that would be reasonable to generate partial symbols for,
5241 that we don't at present. */
5242 case DW_TAG_array_type
:
5243 case DW_TAG_file_type
:
5244 case DW_TAG_ptr_to_member_type
:
5245 case DW_TAG_set_type
:
5246 case DW_TAG_string_type
:
5247 case DW_TAG_subroutine_type
:
5249 case DW_TAG_base_type
:
5250 case DW_TAG_class_type
:
5251 case DW_TAG_enumeration_type
:
5252 case DW_TAG_structure_type
:
5253 case DW_TAG_subrange_type
:
5254 case DW_TAG_typedef
:
5255 case DW_TAG_union_type
:
5262 /* Load all DIEs that are interesting for partial symbols into memory. */
5264 static struct partial_die_info
*
5265 load_partial_dies (bfd
*abfd
, gdb_byte
*info_ptr
, int building_psymtab
,
5266 struct dwarf2_cu
*cu
)
5268 struct partial_die_info
*part_die
;
5269 struct partial_die_info
*parent_die
, *last_die
, *first_die
= NULL
;
5270 struct abbrev_info
*abbrev
;
5271 unsigned int bytes_read
;
5272 unsigned int load_all
= 0;
5274 int nesting_level
= 1;
5279 if (cu
->per_cu
&& cu
->per_cu
->load_all_dies
)
5283 = htab_create_alloc_ex (cu
->header
.length
/ 12,
5287 &cu
->comp_unit_obstack
,
5288 hashtab_obstack_allocate
,
5289 dummy_obstack_deallocate
);
5291 part_die
= obstack_alloc (&cu
->comp_unit_obstack
,
5292 sizeof (struct partial_die_info
));
5296 abbrev
= peek_die_abbrev (info_ptr
, &bytes_read
, cu
);
5298 /* A NULL abbrev means the end of a series of children. */
5301 if (--nesting_level
== 0)
5303 /* PART_DIE was probably the last thing allocated on the
5304 comp_unit_obstack, so we could call obstack_free
5305 here. We don't do that because the waste is small,
5306 and will be cleaned up when we're done with this
5307 compilation unit. This way, we're also more robust
5308 against other users of the comp_unit_obstack. */
5311 info_ptr
+= bytes_read
;
5312 last_die
= parent_die
;
5313 parent_die
= parent_die
->die_parent
;
5317 /* Check whether this DIE is interesting enough to save. Normally
5318 we would not be interested in members here, but there may be
5319 later variables referencing them via DW_AT_specification (for
5322 && !is_type_tag_for_partial (abbrev
->tag
)
5323 && abbrev
->tag
!= DW_TAG_enumerator
5324 && abbrev
->tag
!= DW_TAG_subprogram
5325 && abbrev
->tag
!= DW_TAG_variable
5326 && abbrev
->tag
!= DW_TAG_namespace
5327 && abbrev
->tag
!= DW_TAG_member
)
5329 /* Otherwise we skip to the next sibling, if any. */
5330 info_ptr
= skip_one_die (info_ptr
+ bytes_read
, abbrev
, cu
);
5334 info_ptr
= read_partial_die (part_die
, abbrev
, bytes_read
,
5335 abfd
, info_ptr
, cu
);
5337 /* This two-pass algorithm for processing partial symbols has a
5338 high cost in cache pressure. Thus, handle some simple cases
5339 here which cover the majority of C partial symbols. DIEs
5340 which neither have specification tags in them, nor could have
5341 specification tags elsewhere pointing at them, can simply be
5342 processed and discarded.
5344 This segment is also optional; scan_partial_symbols and
5345 add_partial_symbol will handle these DIEs if we chain
5346 them in normally. When compilers which do not emit large
5347 quantities of duplicate debug information are more common,
5348 this code can probably be removed. */
5350 /* Any complete simple types at the top level (pretty much all
5351 of them, for a language without namespaces), can be processed
5353 if (parent_die
== NULL
5354 && part_die
->has_specification
== 0
5355 && part_die
->is_declaration
== 0
5356 && (part_die
->tag
== DW_TAG_typedef
5357 || part_die
->tag
== DW_TAG_base_type
5358 || part_die
->tag
== DW_TAG_subrange_type
))
5360 if (building_psymtab
&& part_die
->name
!= NULL
)
5361 add_psymbol_to_list (part_die
->name
, strlen (part_die
->name
),
5362 VAR_DOMAIN
, LOC_TYPEDEF
,
5363 &cu
->objfile
->static_psymbols
,
5364 0, (CORE_ADDR
) 0, cu
->language
, cu
->objfile
);
5365 info_ptr
= locate_pdi_sibling (part_die
, info_ptr
, abfd
, cu
);
5369 /* If we're at the second level, and we're an enumerator, and
5370 our parent has no specification (meaning possibly lives in a
5371 namespace elsewhere), then we can add the partial symbol now
5372 instead of queueing it. */
5373 if (part_die
->tag
== DW_TAG_enumerator
5374 && parent_die
!= NULL
5375 && parent_die
->die_parent
== NULL
5376 && parent_die
->tag
== DW_TAG_enumeration_type
5377 && parent_die
->has_specification
== 0)
5379 if (part_die
->name
== NULL
)
5380 complaint (&symfile_complaints
, _("malformed enumerator DIE ignored"));
5381 else if (building_psymtab
)
5382 add_psymbol_to_list (part_die
->name
, strlen (part_die
->name
),
5383 VAR_DOMAIN
, LOC_CONST
,
5384 (cu
->language
== language_cplus
5385 || cu
->language
== language_java
)
5386 ? &cu
->objfile
->global_psymbols
5387 : &cu
->objfile
->static_psymbols
,
5388 0, (CORE_ADDR
) 0, cu
->language
, cu
->objfile
);
5390 info_ptr
= locate_pdi_sibling (part_die
, info_ptr
, abfd
, cu
);
5394 /* We'll save this DIE so link it in. */
5395 part_die
->die_parent
= parent_die
;
5396 part_die
->die_sibling
= NULL
;
5397 part_die
->die_child
= NULL
;
5399 if (last_die
&& last_die
== parent_die
)
5400 last_die
->die_child
= part_die
;
5402 last_die
->die_sibling
= part_die
;
5404 last_die
= part_die
;
5406 if (first_die
== NULL
)
5407 first_die
= part_die
;
5409 /* Maybe add the DIE to the hash table. Not all DIEs that we
5410 find interesting need to be in the hash table, because we
5411 also have the parent/sibling/child chains; only those that we
5412 might refer to by offset later during partial symbol reading.
5414 For now this means things that might have be the target of a
5415 DW_AT_specification, DW_AT_abstract_origin, or
5416 DW_AT_extension. DW_AT_extension will refer only to
5417 namespaces; DW_AT_abstract_origin refers to functions (and
5418 many things under the function DIE, but we do not recurse
5419 into function DIEs during partial symbol reading) and
5420 possibly variables as well; DW_AT_specification refers to
5421 declarations. Declarations ought to have the DW_AT_declaration
5422 flag. It happens that GCC forgets to put it in sometimes, but
5423 only for functions, not for types.
5425 Adding more things than necessary to the hash table is harmless
5426 except for the performance cost. Adding too few will result in
5427 wasted time in find_partial_die, when we reread the compilation
5428 unit with load_all_dies set. */
5431 || abbrev
->tag
== DW_TAG_subprogram
5432 || abbrev
->tag
== DW_TAG_variable
5433 || abbrev
->tag
== DW_TAG_namespace
5434 || part_die
->is_declaration
)
5438 slot
= htab_find_slot_with_hash (cu
->partial_dies
, part_die
,
5439 part_die
->offset
, INSERT
);
5443 part_die
= obstack_alloc (&cu
->comp_unit_obstack
,
5444 sizeof (struct partial_die_info
));
5446 /* For some DIEs we want to follow their children (if any). For C
5447 we have no reason to follow the children of structures; for other
5448 languages we have to, both so that we can get at method physnames
5449 to infer fully qualified class names, and for DW_AT_specification. */
5450 if (last_die
->has_children
5452 || last_die
->tag
== DW_TAG_namespace
5453 || last_die
->tag
== DW_TAG_enumeration_type
5454 || (cu
->language
!= language_c
5455 && (last_die
->tag
== DW_TAG_class_type
5456 || last_die
->tag
== DW_TAG_structure_type
5457 || last_die
->tag
== DW_TAG_union_type
))))
5460 parent_die
= last_die
;
5464 /* Otherwise we skip to the next sibling, if any. */
5465 info_ptr
= locate_pdi_sibling (last_die
, info_ptr
, abfd
, cu
);
5467 /* Back to the top, do it again. */
5471 /* Read a minimal amount of information into the minimal die structure. */
5474 read_partial_die (struct partial_die_info
*part_die
,
5475 struct abbrev_info
*abbrev
,
5476 unsigned int abbrev_len
, bfd
*abfd
,
5477 gdb_byte
*info_ptr
, struct dwarf2_cu
*cu
)
5479 unsigned int bytes_read
, i
;
5480 struct attribute attr
;
5481 int has_low_pc_attr
= 0;
5482 int has_high_pc_attr
= 0;
5484 memset (part_die
, 0, sizeof (struct partial_die_info
));
5486 part_die
->offset
= info_ptr
- dwarf2_per_objfile
->info_buffer
;
5488 info_ptr
+= abbrev_len
;
5493 part_die
->tag
= abbrev
->tag
;
5494 part_die
->has_children
= abbrev
->has_children
;
5496 for (i
= 0; i
< abbrev
->num_attrs
; ++i
)
5498 info_ptr
= read_attribute (&attr
, &abbrev
->attrs
[i
], abfd
, info_ptr
, cu
);
5500 /* Store the data if it is of an attribute we want to keep in a
5501 partial symbol table. */
5506 /* Prefer DW_AT_MIPS_linkage_name over DW_AT_name. */
5507 if (part_die
->name
== NULL
)
5508 part_die
->name
= DW_STRING (&attr
);
5510 case DW_AT_comp_dir
:
5511 if (part_die
->dirname
== NULL
)
5512 part_die
->dirname
= DW_STRING (&attr
);
5514 case DW_AT_MIPS_linkage_name
:
5515 part_die
->name
= DW_STRING (&attr
);
5518 has_low_pc_attr
= 1;
5519 part_die
->lowpc
= DW_ADDR (&attr
);
5522 has_high_pc_attr
= 1;
5523 part_die
->highpc
= DW_ADDR (&attr
);
5525 case DW_AT_location
:
5526 /* Support the .debug_loc offsets */
5527 if (attr_form_is_block (&attr
))
5529 part_die
->locdesc
= DW_BLOCK (&attr
);
5531 else if (attr
.form
== DW_FORM_data4
|| attr
.form
== DW_FORM_data8
)
5533 dwarf2_complex_location_expr_complaint ();
5537 dwarf2_invalid_attrib_class_complaint ("DW_AT_location",
5538 "partial symbol information");
5541 case DW_AT_language
:
5542 part_die
->language
= DW_UNSND (&attr
);
5544 case DW_AT_external
:
5545 part_die
->is_external
= DW_UNSND (&attr
);
5547 case DW_AT_declaration
:
5548 part_die
->is_declaration
= DW_UNSND (&attr
);
5551 part_die
->has_type
= 1;
5553 case DW_AT_abstract_origin
:
5554 case DW_AT_specification
:
5555 case DW_AT_extension
:
5556 part_die
->has_specification
= 1;
5557 part_die
->spec_offset
= dwarf2_get_ref_die_offset (&attr
, cu
);
5560 /* Ignore absolute siblings, they might point outside of
5561 the current compile unit. */
5562 if (attr
.form
== DW_FORM_ref_addr
)
5563 complaint (&symfile_complaints
, _("ignoring absolute DW_AT_sibling"));
5565 part_die
->sibling
= dwarf2_per_objfile
->info_buffer
5566 + dwarf2_get_ref_die_offset (&attr
, cu
);
5568 case DW_AT_stmt_list
:
5569 part_die
->has_stmt_list
= 1;
5570 part_die
->line_offset
= DW_UNSND (&attr
);
5577 /* When using the GNU linker, .gnu.linkonce. sections are used to
5578 eliminate duplicate copies of functions and vtables and such.
5579 The linker will arbitrarily choose one and discard the others.
5580 The AT_*_pc values for such functions refer to local labels in
5581 these sections. If the section from that file was discarded, the
5582 labels are not in the output, so the relocs get a value of 0.
5583 If this is a discarded function, mark the pc bounds as invalid,
5584 so that GDB will ignore it. */
5585 if (has_low_pc_attr
&& has_high_pc_attr
5586 && part_die
->lowpc
< part_die
->highpc
5587 && (part_die
->lowpc
!= 0
5588 || dwarf2_per_objfile
->has_section_at_zero
))
5589 part_die
->has_pc_info
= 1;
5593 /* Find a cached partial DIE at OFFSET in CU. */
5595 static struct partial_die_info
*
5596 find_partial_die_in_comp_unit (unsigned long offset
, struct dwarf2_cu
*cu
)
5598 struct partial_die_info
*lookup_die
= NULL
;
5599 struct partial_die_info part_die
;
5601 part_die
.offset
= offset
;
5602 lookup_die
= htab_find_with_hash (cu
->partial_dies
, &part_die
, offset
);
5607 /* Find a partial DIE at OFFSET, which may or may not be in CU. */
5609 static struct partial_die_info
*
5610 find_partial_die (unsigned long offset
, struct dwarf2_cu
*cu
)
5612 struct dwarf2_per_cu_data
*per_cu
= NULL
;
5613 struct partial_die_info
*pd
= NULL
;
5615 if (offset
>= cu
->header
.offset
5616 && offset
< cu
->header
.offset
+ cu
->header
.length
)
5618 pd
= find_partial_die_in_comp_unit (offset
, cu
);
5623 per_cu
= dwarf2_find_containing_comp_unit (offset
, cu
->objfile
);
5625 if (per_cu
->cu
== NULL
)
5627 load_comp_unit (per_cu
, cu
->objfile
);
5628 per_cu
->cu
->read_in_chain
= dwarf2_per_objfile
->read_in_chain
;
5629 dwarf2_per_objfile
->read_in_chain
= per_cu
;
5632 per_cu
->cu
->last_used
= 0;
5633 pd
= find_partial_die_in_comp_unit (offset
, per_cu
->cu
);
5635 if (pd
== NULL
&& per_cu
->load_all_dies
== 0)
5637 struct cleanup
*back_to
;
5638 struct partial_die_info comp_unit_die
;
5639 struct abbrev_info
*abbrev
;
5640 unsigned int bytes_read
;
5643 per_cu
->load_all_dies
= 1;
5645 /* Re-read the DIEs. */
5646 back_to
= make_cleanup (null_cleanup
, 0);
5647 if (per_cu
->cu
->dwarf2_abbrevs
== NULL
)
5649 dwarf2_read_abbrevs (per_cu
->cu
->objfile
->obfd
, per_cu
->cu
);
5650 back_to
= make_cleanup (dwarf2_free_abbrev_table
, per_cu
->cu
);
5652 info_ptr
= per_cu
->cu
->header
.first_die_ptr
;
5653 abbrev
= peek_die_abbrev (info_ptr
, &bytes_read
, per_cu
->cu
);
5654 info_ptr
= read_partial_die (&comp_unit_die
, abbrev
, bytes_read
,
5655 per_cu
->cu
->objfile
->obfd
, info_ptr
,
5657 if (comp_unit_die
.has_children
)
5658 load_partial_dies (per_cu
->cu
->objfile
->obfd
, info_ptr
, 0, per_cu
->cu
);
5659 do_cleanups (back_to
);
5661 pd
= find_partial_die_in_comp_unit (offset
, per_cu
->cu
);
5665 internal_error (__FILE__
, __LINE__
,
5666 _("could not find partial DIE 0x%lx in cache [from module %s]\n"),
5667 offset
, bfd_get_filename (cu
->objfile
->obfd
));
5671 /* Adjust PART_DIE before generating a symbol for it. This function
5672 may set the is_external flag or change the DIE's name. */
5675 fixup_partial_die (struct partial_die_info
*part_die
,
5676 struct dwarf2_cu
*cu
)
5678 /* If we found a reference attribute and the DIE has no name, try
5679 to find a name in the referred to DIE. */
5681 if (part_die
->name
== NULL
&& part_die
->has_specification
)
5683 struct partial_die_info
*spec_die
;
5685 spec_die
= find_partial_die (part_die
->spec_offset
, cu
);
5687 fixup_partial_die (spec_die
, cu
);
5691 part_die
->name
= spec_die
->name
;
5693 /* Copy DW_AT_external attribute if it is set. */
5694 if (spec_die
->is_external
)
5695 part_die
->is_external
= spec_die
->is_external
;
5699 /* Set default names for some unnamed DIEs. */
5700 if (part_die
->name
== NULL
&& (part_die
->tag
== DW_TAG_structure_type
5701 || part_die
->tag
== DW_TAG_class_type
))
5702 part_die
->name
= "(anonymous class)";
5704 if (part_die
->name
== NULL
&& part_die
->tag
== DW_TAG_namespace
)
5705 part_die
->name
= "(anonymous namespace)";
5707 if (part_die
->tag
== DW_TAG_structure_type
5708 || part_die
->tag
== DW_TAG_class_type
5709 || part_die
->tag
== DW_TAG_union_type
)
5710 guess_structure_name (part_die
, cu
);
5713 /* Read the die from the .debug_info section buffer. Set DIEP to
5714 point to a newly allocated die with its information, except for its
5715 child, sibling, and parent fields. Set HAS_CHILDREN to tell
5716 whether the die has children or not. */
5719 read_full_die (struct die_info
**diep
, bfd
*abfd
, gdb_byte
*info_ptr
,
5720 struct dwarf2_cu
*cu
, int *has_children
)
5722 unsigned int abbrev_number
, bytes_read
, i
, offset
;
5723 struct abbrev_info
*abbrev
;
5724 struct die_info
*die
;
5726 offset
= info_ptr
- dwarf2_per_objfile
->info_buffer
;
5727 abbrev_number
= read_unsigned_leb128 (abfd
, info_ptr
, &bytes_read
);
5728 info_ptr
+= bytes_read
;
5731 die
= dwarf_alloc_die ();
5733 die
->abbrev
= abbrev_number
;
5740 abbrev
= dwarf2_lookup_abbrev (abbrev_number
, cu
);
5743 error (_("Dwarf Error: could not find abbrev number %d [in module %s]"),
5745 bfd_get_filename (abfd
));
5747 die
= dwarf_alloc_die ();
5748 die
->offset
= offset
;
5749 die
->tag
= abbrev
->tag
;
5750 die
->abbrev
= abbrev_number
;
5753 die
->num_attrs
= abbrev
->num_attrs
;
5754 die
->attrs
= (struct attribute
*)
5755 xmalloc (die
->num_attrs
* sizeof (struct attribute
));
5757 for (i
= 0; i
< abbrev
->num_attrs
; ++i
)
5759 info_ptr
= read_attribute (&die
->attrs
[i
], &abbrev
->attrs
[i
],
5760 abfd
, info_ptr
, cu
);
5762 /* If this attribute is an absolute reference to a different
5763 compilation unit, make sure that compilation unit is loaded
5765 if (die
->attrs
[i
].form
== DW_FORM_ref_addr
5766 && (DW_ADDR (&die
->attrs
[i
]) < cu
->header
.offset
5767 || (DW_ADDR (&die
->attrs
[i
])
5768 >= cu
->header
.offset
+ cu
->header
.length
)))
5770 struct dwarf2_per_cu_data
*per_cu
;
5771 per_cu
= dwarf2_find_containing_comp_unit (DW_ADDR (&die
->attrs
[i
]),
5774 /* Mark the dependence relation so that we don't flush PER_CU
5776 dwarf2_add_dependence (cu
, per_cu
);
5778 /* If it's already on the queue, we have nothing to do. */
5782 /* If the compilation unit is already loaded, just mark it as
5784 if (per_cu
->cu
!= NULL
)
5786 per_cu
->cu
->last_used
= 0;
5790 /* Add it to the queue. */
5791 queue_comp_unit (per_cu
);
5796 *has_children
= abbrev
->has_children
;
5800 /* Read an attribute value described by an attribute form. */
5803 read_attribute_value (struct attribute
*attr
, unsigned form
,
5804 bfd
*abfd
, gdb_byte
*info_ptr
,
5805 struct dwarf2_cu
*cu
)
5807 struct comp_unit_head
*cu_header
= &cu
->header
;
5808 unsigned int bytes_read
;
5809 struct dwarf_block
*blk
;
5815 case DW_FORM_ref_addr
:
5816 DW_ADDR (attr
) = read_address (abfd
, info_ptr
, cu
, &bytes_read
);
5817 info_ptr
+= bytes_read
;
5819 case DW_FORM_block2
:
5820 blk
= dwarf_alloc_block (cu
);
5821 blk
->size
= read_2_bytes (abfd
, info_ptr
);
5823 blk
->data
= read_n_bytes (abfd
, info_ptr
, blk
->size
);
5824 info_ptr
+= blk
->size
;
5825 DW_BLOCK (attr
) = blk
;
5827 case DW_FORM_block4
:
5828 blk
= dwarf_alloc_block (cu
);
5829 blk
->size
= read_4_bytes (abfd
, info_ptr
);
5831 blk
->data
= read_n_bytes (abfd
, info_ptr
, blk
->size
);
5832 info_ptr
+= blk
->size
;
5833 DW_BLOCK (attr
) = blk
;
5836 DW_UNSND (attr
) = read_2_bytes (abfd
, info_ptr
);
5840 DW_UNSND (attr
) = read_4_bytes (abfd
, info_ptr
);
5844 DW_UNSND (attr
) = read_8_bytes (abfd
, info_ptr
);
5847 case DW_FORM_string
:
5848 DW_STRING (attr
) = read_string (abfd
, info_ptr
, &bytes_read
);
5849 info_ptr
+= bytes_read
;
5852 DW_STRING (attr
) = read_indirect_string (abfd
, info_ptr
, cu_header
,
5854 info_ptr
+= bytes_read
;
5857 blk
= dwarf_alloc_block (cu
);
5858 blk
->size
= read_unsigned_leb128 (abfd
, info_ptr
, &bytes_read
);
5859 info_ptr
+= bytes_read
;
5860 blk
->data
= read_n_bytes (abfd
, info_ptr
, blk
->size
);
5861 info_ptr
+= blk
->size
;
5862 DW_BLOCK (attr
) = blk
;
5864 case DW_FORM_block1
:
5865 blk
= dwarf_alloc_block (cu
);
5866 blk
->size
= read_1_byte (abfd
, info_ptr
);
5868 blk
->data
= read_n_bytes (abfd
, info_ptr
, blk
->size
);
5869 info_ptr
+= blk
->size
;
5870 DW_BLOCK (attr
) = blk
;
5873 DW_UNSND (attr
) = read_1_byte (abfd
, info_ptr
);
5877 DW_UNSND (attr
) = read_1_byte (abfd
, info_ptr
);
5881 DW_SND (attr
) = read_signed_leb128 (abfd
, info_ptr
, &bytes_read
);
5882 info_ptr
+= bytes_read
;
5885 DW_UNSND (attr
) = read_unsigned_leb128 (abfd
, info_ptr
, &bytes_read
);
5886 info_ptr
+= bytes_read
;
5889 DW_ADDR (attr
) = cu
->header
.offset
+ read_1_byte (abfd
, info_ptr
);
5893 DW_ADDR (attr
) = cu
->header
.offset
+ read_2_bytes (abfd
, info_ptr
);
5897 DW_ADDR (attr
) = cu
->header
.offset
+ read_4_bytes (abfd
, info_ptr
);
5901 DW_ADDR (attr
) = cu
->header
.offset
+ read_8_bytes (abfd
, info_ptr
);
5904 case DW_FORM_ref_udata
:
5905 DW_ADDR (attr
) = (cu
->header
.offset
5906 + read_unsigned_leb128 (abfd
, info_ptr
, &bytes_read
));
5907 info_ptr
+= bytes_read
;
5909 case DW_FORM_indirect
:
5910 form
= read_unsigned_leb128 (abfd
, info_ptr
, &bytes_read
);
5911 info_ptr
+= bytes_read
;
5912 info_ptr
= read_attribute_value (attr
, form
, abfd
, info_ptr
, cu
);
5915 error (_("Dwarf Error: Cannot handle %s in DWARF reader [in module %s]"),
5916 dwarf_form_name (form
),
5917 bfd_get_filename (abfd
));
5922 /* Read an attribute described by an abbreviated attribute. */
5925 read_attribute (struct attribute
*attr
, struct attr_abbrev
*abbrev
,
5926 bfd
*abfd
, gdb_byte
*info_ptr
, struct dwarf2_cu
*cu
)
5928 attr
->name
= abbrev
->name
;
5929 return read_attribute_value (attr
, abbrev
->form
, abfd
, info_ptr
, cu
);
5932 /* read dwarf information from a buffer */
5935 read_1_byte (bfd
*abfd
, gdb_byte
*buf
)
5937 return bfd_get_8 (abfd
, buf
);
5941 read_1_signed_byte (bfd
*abfd
, gdb_byte
*buf
)
5943 return bfd_get_signed_8 (abfd
, buf
);
5947 read_2_bytes (bfd
*abfd
, gdb_byte
*buf
)
5949 return bfd_get_16 (abfd
, buf
);
5953 read_2_signed_bytes (bfd
*abfd
, gdb_byte
*buf
)
5955 return bfd_get_signed_16 (abfd
, buf
);
5959 read_4_bytes (bfd
*abfd
, gdb_byte
*buf
)
5961 return bfd_get_32 (abfd
, buf
);
5965 read_4_signed_bytes (bfd
*abfd
, gdb_byte
*buf
)
5967 return bfd_get_signed_32 (abfd
, buf
);
5970 static unsigned long
5971 read_8_bytes (bfd
*abfd
, gdb_byte
*buf
)
5973 return bfd_get_64 (abfd
, buf
);
5977 read_address (bfd
*abfd
, gdb_byte
*buf
, struct dwarf2_cu
*cu
,
5978 unsigned int *bytes_read
)
5980 struct comp_unit_head
*cu_header
= &cu
->header
;
5981 CORE_ADDR retval
= 0;
5983 if (cu_header
->signed_addr_p
)
5985 switch (cu_header
->addr_size
)
5988 retval
= bfd_get_signed_16 (abfd
, buf
);
5991 retval
= bfd_get_signed_32 (abfd
, buf
);
5994 retval
= bfd_get_signed_64 (abfd
, buf
);
5997 internal_error (__FILE__
, __LINE__
,
5998 _("read_address: bad switch, signed [in module %s]"),
5999 bfd_get_filename (abfd
));
6004 switch (cu_header
->addr_size
)
6007 retval
= bfd_get_16 (abfd
, buf
);
6010 retval
= bfd_get_32 (abfd
, buf
);
6013 retval
= bfd_get_64 (abfd
, buf
);
6016 internal_error (__FILE__
, __LINE__
,
6017 _("read_address: bad switch, unsigned [in module %s]"),
6018 bfd_get_filename (abfd
));
6022 *bytes_read
= cu_header
->addr_size
;
6026 /* Read the initial length from a section. The (draft) DWARF 3
6027 specification allows the initial length to take up either 4 bytes
6028 or 12 bytes. If the first 4 bytes are 0xffffffff, then the next 8
6029 bytes describe the length and all offsets will be 8 bytes in length
6032 An older, non-standard 64-bit format is also handled by this
6033 function. The older format in question stores the initial length
6034 as an 8-byte quantity without an escape value. Lengths greater
6035 than 2^32 aren't very common which means that the initial 4 bytes
6036 is almost always zero. Since a length value of zero doesn't make
6037 sense for the 32-bit format, this initial zero can be considered to
6038 be an escape value which indicates the presence of the older 64-bit
6039 format. As written, the code can't detect (old format) lengths
6040 greater than 4GB. If it becomes necessary to handle lengths
6041 somewhat larger than 4GB, we could allow other small values (such
6042 as the non-sensical values of 1, 2, and 3) to also be used as
6043 escape values indicating the presence of the old format.
6045 The value returned via bytes_read should be used to increment the
6046 relevant pointer after calling read_initial_length().
6048 As a side effect, this function sets the fields initial_length_size
6049 and offset_size in cu_header to the values appropriate for the
6050 length field. (The format of the initial length field determines
6051 the width of file offsets to be fetched later with read_offset().)
6053 [ Note: read_initial_length() and read_offset() are based on the
6054 document entitled "DWARF Debugging Information Format", revision
6055 3, draft 8, dated November 19, 2001. This document was obtained
6058 http://reality.sgiweb.org/davea/dwarf3-draft8-011125.pdf
6060 This document is only a draft and is subject to change. (So beware.)
6062 Details regarding the older, non-standard 64-bit format were
6063 determined empirically by examining 64-bit ELF files produced by
6064 the SGI toolchain on an IRIX 6.5 machine.
6066 - Kevin, July 16, 2002
6070 read_initial_length (bfd
*abfd
, gdb_byte
*buf
, struct comp_unit_head
*cu_header
,
6071 unsigned int *bytes_read
)
6073 LONGEST length
= bfd_get_32 (abfd
, buf
);
6075 if (length
== 0xffffffff)
6077 length
= bfd_get_64 (abfd
, buf
+ 4);
6080 else if (length
== 0)
6082 /* Handle the (non-standard) 64-bit DWARF2 format used by IRIX. */
6083 length
= bfd_get_64 (abfd
, buf
);
6093 gdb_assert (cu_header
->initial_length_size
== 0
6094 || cu_header
->initial_length_size
== 4
6095 || cu_header
->initial_length_size
== 8
6096 || cu_header
->initial_length_size
== 12);
6098 if (cu_header
->initial_length_size
!= 0
6099 && cu_header
->initial_length_size
!= *bytes_read
)
6100 complaint (&symfile_complaints
,
6101 _("intermixed 32-bit and 64-bit DWARF sections"));
6103 cu_header
->initial_length_size
= *bytes_read
;
6104 cu_header
->offset_size
= (*bytes_read
== 4) ? 4 : 8;
6110 /* Read an offset from the data stream. The size of the offset is
6111 given by cu_header->offset_size. */
6114 read_offset (bfd
*abfd
, gdb_byte
*buf
, const struct comp_unit_head
*cu_header
,
6115 unsigned int *bytes_read
)
6119 switch (cu_header
->offset_size
)
6122 retval
= bfd_get_32 (abfd
, buf
);
6126 retval
= bfd_get_64 (abfd
, buf
);
6130 internal_error (__FILE__
, __LINE__
,
6131 _("read_offset: bad switch [in module %s]"),
6132 bfd_get_filename (abfd
));
6139 read_n_bytes (bfd
*abfd
, gdb_byte
*buf
, unsigned int size
)
6141 /* If the size of a host char is 8 bits, we can return a pointer
6142 to the buffer, otherwise we have to copy the data to a buffer
6143 allocated on the temporary obstack. */
6144 gdb_assert (HOST_CHAR_BIT
== 8);
6149 read_string (bfd
*abfd
, gdb_byte
*buf
, unsigned int *bytes_read_ptr
)
6151 /* If the size of a host char is 8 bits, we can return a pointer
6152 to the string, otherwise we have to copy the string to a buffer
6153 allocated on the temporary obstack. */
6154 gdb_assert (HOST_CHAR_BIT
== 8);
6157 *bytes_read_ptr
= 1;
6160 *bytes_read_ptr
= strlen ((char *) buf
) + 1;
6161 return (char *) buf
;
6165 read_indirect_string (bfd
*abfd
, gdb_byte
*buf
,
6166 const struct comp_unit_head
*cu_header
,
6167 unsigned int *bytes_read_ptr
)
6169 LONGEST str_offset
= read_offset (abfd
, buf
, cu_header
,
6172 if (dwarf2_per_objfile
->str_buffer
== NULL
)
6174 error (_("DW_FORM_strp used without .debug_str section [in module %s]"),
6175 bfd_get_filename (abfd
));
6178 if (str_offset
>= dwarf2_per_objfile
->str_size
)
6180 error (_("DW_FORM_strp pointing outside of .debug_str section [in module %s]"),
6181 bfd_get_filename (abfd
));
6184 gdb_assert (HOST_CHAR_BIT
== 8);
6185 if (dwarf2_per_objfile
->str_buffer
[str_offset
] == '\0')
6187 return (char *) (dwarf2_per_objfile
->str_buffer
+ str_offset
);
6190 static unsigned long
6191 read_unsigned_leb128 (bfd
*abfd
, gdb_byte
*buf
, unsigned int *bytes_read_ptr
)
6193 unsigned long result
;
6194 unsigned int num_read
;
6204 byte
= bfd_get_8 (abfd
, buf
);
6207 result
|= ((unsigned long)(byte
& 127) << shift
);
6208 if ((byte
& 128) == 0)
6214 *bytes_read_ptr
= num_read
;
6219 read_signed_leb128 (bfd
*abfd
, gdb_byte
*buf
, unsigned int *bytes_read_ptr
)
6222 int i
, shift
, num_read
;
6231 byte
= bfd_get_8 (abfd
, buf
);
6234 result
|= ((long)(byte
& 127) << shift
);
6236 if ((byte
& 128) == 0)
6241 if ((shift
< 8 * sizeof (result
)) && (byte
& 0x40))
6242 result
|= -(((long)1) << shift
);
6243 *bytes_read_ptr
= num_read
;
6247 /* Return a pointer to just past the end of an LEB128 number in BUF. */
6250 skip_leb128 (bfd
*abfd
, gdb_byte
*buf
)
6256 byte
= bfd_get_8 (abfd
, buf
);
6258 if ((byte
& 128) == 0)
6264 set_cu_language (unsigned int lang
, struct dwarf2_cu
*cu
)
6270 cu
->language
= language_c
;
6272 case DW_LANG_C_plus_plus
:
6273 cu
->language
= language_cplus
;
6275 case DW_LANG_Fortran77
:
6276 case DW_LANG_Fortran90
:
6277 case DW_LANG_Fortran95
:
6278 cu
->language
= language_fortran
;
6280 case DW_LANG_Mips_Assembler
:
6281 cu
->language
= language_asm
;
6284 cu
->language
= language_java
;
6288 cu
->language
= language_ada
;
6290 case DW_LANG_Modula2
:
6291 cu
->language
= language_m2
;
6293 case DW_LANG_Cobol74
:
6294 case DW_LANG_Cobol85
:
6295 case DW_LANG_Pascal83
:
6297 cu
->language
= language_minimal
;
6300 cu
->language_defn
= language_def (cu
->language
);
6303 /* Return the named attribute or NULL if not there. */
6305 static struct attribute
*
6306 dwarf2_attr (struct die_info
*die
, unsigned int name
, struct dwarf2_cu
*cu
)
6309 struct attribute
*spec
= NULL
;
6311 for (i
= 0; i
< die
->num_attrs
; ++i
)
6313 if (die
->attrs
[i
].name
== name
)
6314 return &die
->attrs
[i
];
6315 if (die
->attrs
[i
].name
== DW_AT_specification
6316 || die
->attrs
[i
].name
== DW_AT_abstract_origin
)
6317 spec
= &die
->attrs
[i
];
6321 return dwarf2_attr (follow_die_ref (die
, spec
, cu
), name
, cu
);
6326 /* Return non-zero iff the attribute NAME is defined for the given DIE,
6327 and holds a non-zero value. This function should only be used for
6328 DW_FORM_flag attributes. */
6331 dwarf2_flag_true_p (struct die_info
*die
, unsigned name
, struct dwarf2_cu
*cu
)
6333 struct attribute
*attr
= dwarf2_attr (die
, name
, cu
);
6335 return (attr
&& DW_UNSND (attr
));
6339 die_is_declaration (struct die_info
*die
, struct dwarf2_cu
*cu
)
6341 /* A DIE is a declaration if it has a DW_AT_declaration attribute
6342 which value is non-zero. However, we have to be careful with
6343 DIEs having a DW_AT_specification attribute, because dwarf2_attr()
6344 (via dwarf2_flag_true_p) follows this attribute. So we may
6345 end up accidently finding a declaration attribute that belongs
6346 to a different DIE referenced by the specification attribute,
6347 even though the given DIE does not have a declaration attribute. */
6348 return (dwarf2_flag_true_p (die
, DW_AT_declaration
, cu
)
6349 && dwarf2_attr (die
, DW_AT_specification
, cu
) == NULL
);
6352 /* Return the die giving the specification for DIE, if there is
6355 static struct die_info
*
6356 die_specification (struct die_info
*die
, struct dwarf2_cu
*cu
)
6358 struct attribute
*spec_attr
= dwarf2_attr (die
, DW_AT_specification
, cu
);
6360 if (spec_attr
== NULL
)
6363 return follow_die_ref (die
, spec_attr
, cu
);
6366 /* Free the line_header structure *LH, and any arrays and strings it
6369 free_line_header (struct line_header
*lh
)
6371 if (lh
->standard_opcode_lengths
)
6372 xfree (lh
->standard_opcode_lengths
);
6374 /* Remember that all the lh->file_names[i].name pointers are
6375 pointers into debug_line_buffer, and don't need to be freed. */
6377 xfree (lh
->file_names
);
6379 /* Similarly for the include directory names. */
6380 if (lh
->include_dirs
)
6381 xfree (lh
->include_dirs
);
6387 /* Add an entry to LH's include directory table. */
6389 add_include_dir (struct line_header
*lh
, char *include_dir
)
6391 /* Grow the array if necessary. */
6392 if (lh
->include_dirs_size
== 0)
6394 lh
->include_dirs_size
= 1; /* for testing */
6395 lh
->include_dirs
= xmalloc (lh
->include_dirs_size
6396 * sizeof (*lh
->include_dirs
));
6398 else if (lh
->num_include_dirs
>= lh
->include_dirs_size
)
6400 lh
->include_dirs_size
*= 2;
6401 lh
->include_dirs
= xrealloc (lh
->include_dirs
,
6402 (lh
->include_dirs_size
6403 * sizeof (*lh
->include_dirs
)));
6406 lh
->include_dirs
[lh
->num_include_dirs
++] = include_dir
;
6410 /* Add an entry to LH's file name table. */
6412 add_file_name (struct line_header
*lh
,
6414 unsigned int dir_index
,
6415 unsigned int mod_time
,
6416 unsigned int length
)
6418 struct file_entry
*fe
;
6420 /* Grow the array if necessary. */
6421 if (lh
->file_names_size
== 0)
6423 lh
->file_names_size
= 1; /* for testing */
6424 lh
->file_names
= xmalloc (lh
->file_names_size
6425 * sizeof (*lh
->file_names
));
6427 else if (lh
->num_file_names
>= lh
->file_names_size
)
6429 lh
->file_names_size
*= 2;
6430 lh
->file_names
= xrealloc (lh
->file_names
,
6431 (lh
->file_names_size
6432 * sizeof (*lh
->file_names
)));
6435 fe
= &lh
->file_names
[lh
->num_file_names
++];
6437 fe
->dir_index
= dir_index
;
6438 fe
->mod_time
= mod_time
;
6439 fe
->length
= length
;
6444 /* Read the statement program header starting at OFFSET in
6445 .debug_line, according to the endianness of ABFD. Return a pointer
6446 to a struct line_header, allocated using xmalloc.
6448 NOTE: the strings in the include directory and file name tables of
6449 the returned object point into debug_line_buffer, and must not be
6451 static struct line_header
*
6452 dwarf_decode_line_header (unsigned int offset
, bfd
*abfd
,
6453 struct dwarf2_cu
*cu
)
6455 struct cleanup
*back_to
;
6456 struct line_header
*lh
;
6458 unsigned int bytes_read
;
6460 char *cur_dir
, *cur_file
;
6462 if (dwarf2_per_objfile
->line_buffer
== NULL
)
6464 complaint (&symfile_complaints
, _("missing .debug_line section"));
6468 /* Make sure that at least there's room for the total_length field.
6469 That could be 12 bytes long, but we're just going to fudge that. */
6470 if (offset
+ 4 >= dwarf2_per_objfile
->line_size
)
6472 dwarf2_statement_list_fits_in_line_number_section_complaint ();
6476 lh
= xmalloc (sizeof (*lh
));
6477 memset (lh
, 0, sizeof (*lh
));
6478 back_to
= make_cleanup ((make_cleanup_ftype
*) free_line_header
,
6481 line_ptr
= dwarf2_per_objfile
->line_buffer
+ offset
;
6483 /* Read in the header. */
6485 read_initial_length (abfd
, line_ptr
, &cu
->header
, &bytes_read
);
6486 line_ptr
+= bytes_read
;
6487 if (line_ptr
+ lh
->total_length
> (dwarf2_per_objfile
->line_buffer
6488 + dwarf2_per_objfile
->line_size
))
6490 dwarf2_statement_list_fits_in_line_number_section_complaint ();
6493 lh
->statement_program_end
= line_ptr
+ lh
->total_length
;
6494 lh
->version
= read_2_bytes (abfd
, line_ptr
);
6496 lh
->header_length
= read_offset (abfd
, line_ptr
, &cu
->header
, &bytes_read
);
6497 line_ptr
+= bytes_read
;
6498 lh
->minimum_instruction_length
= read_1_byte (abfd
, line_ptr
);
6500 lh
->default_is_stmt
= read_1_byte (abfd
, line_ptr
);
6502 lh
->line_base
= read_1_signed_byte (abfd
, line_ptr
);
6504 lh
->line_range
= read_1_byte (abfd
, line_ptr
);
6506 lh
->opcode_base
= read_1_byte (abfd
, line_ptr
);
6508 lh
->standard_opcode_lengths
6509 = xmalloc (lh
->opcode_base
* sizeof (lh
->standard_opcode_lengths
[0]));
6511 lh
->standard_opcode_lengths
[0] = 1; /* This should never be used anyway. */
6512 for (i
= 1; i
< lh
->opcode_base
; ++i
)
6514 lh
->standard_opcode_lengths
[i
] = read_1_byte (abfd
, line_ptr
);
6518 /* Read directory table. */
6519 while ((cur_dir
= read_string (abfd
, line_ptr
, &bytes_read
)) != NULL
)
6521 line_ptr
+= bytes_read
;
6522 add_include_dir (lh
, cur_dir
);
6524 line_ptr
+= bytes_read
;
6526 /* Read file name table. */
6527 while ((cur_file
= read_string (abfd
, line_ptr
, &bytes_read
)) != NULL
)
6529 unsigned int dir_index
, mod_time
, length
;
6531 line_ptr
+= bytes_read
;
6532 dir_index
= read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
6533 line_ptr
+= bytes_read
;
6534 mod_time
= read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
6535 line_ptr
+= bytes_read
;
6536 length
= read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
6537 line_ptr
+= bytes_read
;
6539 add_file_name (lh
, cur_file
, dir_index
, mod_time
, length
);
6541 line_ptr
+= bytes_read
;
6542 lh
->statement_program_start
= line_ptr
;
6544 if (line_ptr
> (dwarf2_per_objfile
->line_buffer
6545 + dwarf2_per_objfile
->line_size
))
6546 complaint (&symfile_complaints
,
6547 _("line number info header doesn't fit in `.debug_line' section"));
6549 discard_cleanups (back_to
);
6553 /* This function exists to work around a bug in certain compilers
6554 (particularly GCC 2.95), in which the first line number marker of a
6555 function does not show up until after the prologue, right before
6556 the second line number marker. This function shifts ADDRESS down
6557 to the beginning of the function if necessary, and is called on
6558 addresses passed to record_line. */
6561 check_cu_functions (CORE_ADDR address
, struct dwarf2_cu
*cu
)
6563 struct function_range
*fn
;
6565 /* Find the function_range containing address. */
6570 cu
->cached_fn
= cu
->first_fn
;
6574 if (fn
->lowpc
<= address
&& fn
->highpc
> address
)
6580 while (fn
&& fn
!= cu
->cached_fn
)
6581 if (fn
->lowpc
<= address
&& fn
->highpc
> address
)
6591 if (address
!= fn
->lowpc
)
6592 complaint (&symfile_complaints
,
6593 _("misplaced first line number at 0x%lx for '%s'"),
6594 (unsigned long) address
, fn
->name
);
6599 /* Decode the Line Number Program (LNP) for the given line_header
6600 structure and CU. The actual information extracted and the type
6601 of structures created from the LNP depends on the value of PST.
6603 1. If PST is NULL, then this procedure uses the data from the program
6604 to create all necessary symbol tables, and their linetables.
6605 The compilation directory of the file is passed in COMP_DIR,
6606 and must not be NULL.
6608 2. If PST is not NULL, this procedure reads the program to determine
6609 the list of files included by the unit represented by PST, and
6610 builds all the associated partial symbol tables. In this case,
6611 the value of COMP_DIR is ignored, and can thus be NULL (the COMP_DIR
6612 is not used to compute the full name of the symtab, and therefore
6613 omitting it when building the partial symtab does not introduce
6614 the potential for inconsistency - a partial symtab and its associated
6615 symbtab having a different fullname -). */
6618 dwarf_decode_lines (struct line_header
*lh
, char *comp_dir
, bfd
*abfd
,
6619 struct dwarf2_cu
*cu
, struct partial_symtab
*pst
)
6623 unsigned int bytes_read
;
6624 unsigned char op_code
, extended_op
, adj_opcode
;
6626 struct objfile
*objfile
= cu
->objfile
;
6627 const int decode_for_pst_p
= (pst
!= NULL
);
6629 baseaddr
= ANOFFSET (objfile
->section_offsets
, SECT_OFF_TEXT (objfile
));
6631 line_ptr
= lh
->statement_program_start
;
6632 line_end
= lh
->statement_program_end
;
6634 /* Read the statement sequences until there's nothing left. */
6635 while (line_ptr
< line_end
)
6637 /* state machine registers */
6638 CORE_ADDR address
= 0;
6639 unsigned int file
= 1;
6640 unsigned int line
= 1;
6641 unsigned int column
= 0;
6642 int is_stmt
= lh
->default_is_stmt
;
6643 int basic_block
= 0;
6644 int end_sequence
= 0;
6646 if (!decode_for_pst_p
&& lh
->num_file_names
>= file
)
6648 /* Start a subfile for the current file of the state machine. */
6649 /* lh->include_dirs and lh->file_names are 0-based, but the
6650 directory and file name numbers in the statement program
6652 struct file_entry
*fe
= &lh
->file_names
[file
- 1];
6656 dir
= lh
->include_dirs
[fe
->dir_index
- 1];
6658 dwarf2_start_subfile (fe
->name
, dir
, comp_dir
);
6661 /* Decode the table. */
6662 while (!end_sequence
)
6664 op_code
= read_1_byte (abfd
, line_ptr
);
6667 if (op_code
>= lh
->opcode_base
)
6669 /* Special operand. */
6670 adj_opcode
= op_code
- lh
->opcode_base
;
6671 address
+= (adj_opcode
/ lh
->line_range
)
6672 * lh
->minimum_instruction_length
;
6673 line
+= lh
->line_base
+ (adj_opcode
% lh
->line_range
);
6674 lh
->file_names
[file
- 1].included_p
= 1;
6675 if (!decode_for_pst_p
)
6677 /* Append row to matrix using current values. */
6678 record_line (current_subfile
, line
,
6679 check_cu_functions (address
, cu
));
6683 else switch (op_code
)
6685 case DW_LNS_extended_op
:
6686 read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
6687 line_ptr
+= bytes_read
;
6688 extended_op
= read_1_byte (abfd
, line_ptr
);
6690 switch (extended_op
)
6692 case DW_LNE_end_sequence
:
6694 lh
->file_names
[file
- 1].included_p
= 1;
6695 if (!decode_for_pst_p
)
6696 record_line (current_subfile
, 0, address
);
6698 case DW_LNE_set_address
:
6699 address
= read_address (abfd
, line_ptr
, cu
, &bytes_read
);
6700 line_ptr
+= bytes_read
;
6701 address
+= baseaddr
;
6703 case DW_LNE_define_file
:
6706 unsigned int dir_index
, mod_time
, length
;
6708 cur_file
= read_string (abfd
, line_ptr
, &bytes_read
);
6709 line_ptr
+= bytes_read
;
6711 read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
6712 line_ptr
+= bytes_read
;
6714 read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
6715 line_ptr
+= bytes_read
;
6717 read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
6718 line_ptr
+= bytes_read
;
6719 add_file_name (lh
, cur_file
, dir_index
, mod_time
, length
);
6723 complaint (&symfile_complaints
,
6724 _("mangled .debug_line section"));
6729 lh
->file_names
[file
- 1].included_p
= 1;
6730 if (!decode_for_pst_p
)
6731 record_line (current_subfile
, line
,
6732 check_cu_functions (address
, cu
));
6735 case DW_LNS_advance_pc
:
6736 address
+= lh
->minimum_instruction_length
6737 * read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
6738 line_ptr
+= bytes_read
;
6740 case DW_LNS_advance_line
:
6741 line
+= read_signed_leb128 (abfd
, line_ptr
, &bytes_read
);
6742 line_ptr
+= bytes_read
;
6744 case DW_LNS_set_file
:
6746 /* The arrays lh->include_dirs and lh->file_names are
6747 0-based, but the directory and file name numbers in
6748 the statement program are 1-based. */
6749 struct file_entry
*fe
;
6752 file
= read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
6753 line_ptr
+= bytes_read
;
6754 fe
= &lh
->file_names
[file
- 1];
6756 dir
= lh
->include_dirs
[fe
->dir_index
- 1];
6758 if (!decode_for_pst_p
)
6759 dwarf2_start_subfile (fe
->name
, dir
, comp_dir
);
6762 case DW_LNS_set_column
:
6763 column
= read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
6764 line_ptr
+= bytes_read
;
6766 case DW_LNS_negate_stmt
:
6767 is_stmt
= (!is_stmt
);
6769 case DW_LNS_set_basic_block
:
6772 /* Add to the address register of the state machine the
6773 address increment value corresponding to special opcode
6774 255. I.e., this value is scaled by the minimum
6775 instruction length since special opcode 255 would have
6776 scaled the the increment. */
6777 case DW_LNS_const_add_pc
:
6778 address
+= (lh
->minimum_instruction_length
6779 * ((255 - lh
->opcode_base
) / lh
->line_range
));
6781 case DW_LNS_fixed_advance_pc
:
6782 address
+= read_2_bytes (abfd
, line_ptr
);
6787 /* Unknown standard opcode, ignore it. */
6790 for (i
= 0; i
< lh
->standard_opcode_lengths
[op_code
]; i
++)
6792 (void) read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
6793 line_ptr
+= bytes_read
;
6800 if (decode_for_pst_p
)
6804 /* Now that we're done scanning the Line Header Program, we can
6805 create the psymtab of each included file. */
6806 for (file_index
= 0; file_index
< lh
->num_file_names
; file_index
++)
6807 if (lh
->file_names
[file_index
].included_p
== 1)
6809 const struct file_entry fe
= lh
->file_names
[file_index
];
6810 char *include_name
= fe
.name
;
6811 char *dir_name
= NULL
;
6812 char *pst_filename
= pst
->filename
;
6815 dir_name
= lh
->include_dirs
[fe
.dir_index
- 1];
6817 if (!IS_ABSOLUTE_PATH (include_name
) && dir_name
!= NULL
)
6819 include_name
= concat (dir_name
, SLASH_STRING
,
6820 include_name
, (char *)NULL
);
6821 make_cleanup (xfree
, include_name
);
6824 if (!IS_ABSOLUTE_PATH (pst_filename
) && pst
->dirname
!= NULL
)
6826 pst_filename
= concat (pst
->dirname
, SLASH_STRING
,
6827 pst_filename
, (char *)NULL
);
6828 make_cleanup (xfree
, pst_filename
);
6831 if (strcmp (include_name
, pst_filename
) != 0)
6832 dwarf2_create_include_psymtab (include_name
, pst
, objfile
);
6837 /* Start a subfile for DWARF. FILENAME is the name of the file and
6838 DIRNAME the name of the source directory which contains FILENAME
6839 or NULL if not known. COMP_DIR is the compilation directory for the
6840 linetable's compilation unit or NULL if not known.
6841 This routine tries to keep line numbers from identical absolute and
6842 relative file names in a common subfile.
6844 Using the `list' example from the GDB testsuite, which resides in
6845 /srcdir and compiling it with Irix6.2 cc in /compdir using a filename
6846 of /srcdir/list0.c yields the following debugging information for list0.c:
6848 DW_AT_name: /srcdir/list0.c
6849 DW_AT_comp_dir: /compdir
6850 files.files[0].name: list0.h
6851 files.files[0].dir: /srcdir
6852 files.files[1].name: list0.c
6853 files.files[1].dir: /srcdir
6855 The line number information for list0.c has to end up in a single
6856 subfile, so that `break /srcdir/list0.c:1' works as expected.
6857 start_subfile will ensure that this happens provided that we pass the
6858 concatenation of files.files[1].dir and files.files[1].name as the
6862 dwarf2_start_subfile (char *filename
, char *dirname
, char *comp_dir
)
6866 /* While reading the DIEs, we call start_symtab(DW_AT_name, DW_AT_comp_dir).
6867 `start_symtab' will always pass the contents of DW_AT_comp_dir as
6868 second argument to start_subfile. To be consistent, we do the
6869 same here. In order not to lose the line information directory,
6870 we concatenate it to the filename when it makes sense.
6871 Note that the Dwarf3 standard says (speaking of filenames in line
6872 information): ``The directory index is ignored for file names
6873 that represent full path names''. Thus ignoring dirname in the
6874 `else' branch below isn't an issue. */
6876 if (!IS_ABSOLUTE_PATH (filename
) && dirname
!= NULL
)
6877 fullname
= concat (dirname
, SLASH_STRING
, filename
, (char *)NULL
);
6879 fullname
= filename
;
6881 start_subfile (fullname
, comp_dir
);
6883 if (fullname
!= filename
)
6888 var_decode_location (struct attribute
*attr
, struct symbol
*sym
,
6889 struct dwarf2_cu
*cu
)
6891 struct objfile
*objfile
= cu
->objfile
;
6892 struct comp_unit_head
*cu_header
= &cu
->header
;
6894 /* NOTE drow/2003-01-30: There used to be a comment and some special
6895 code here to turn a symbol with DW_AT_external and a
6896 SYMBOL_VALUE_ADDRESS of 0 into a LOC_UNRESOLVED symbol. This was
6897 necessary for platforms (maybe Alpha, certainly PowerPC GNU/Linux
6898 with some versions of binutils) where shared libraries could have
6899 relocations against symbols in their debug information - the
6900 minimal symbol would have the right address, but the debug info
6901 would not. It's no longer necessary, because we will explicitly
6902 apply relocations when we read in the debug information now. */
6904 /* A DW_AT_location attribute with no contents indicates that a
6905 variable has been optimized away. */
6906 if (attr_form_is_block (attr
) && DW_BLOCK (attr
)->size
== 0)
6908 SYMBOL_CLASS (sym
) = LOC_OPTIMIZED_OUT
;
6912 /* Handle one degenerate form of location expression specially, to
6913 preserve GDB's previous behavior when section offsets are
6914 specified. If this is just a DW_OP_addr then mark this symbol
6917 if (attr_form_is_block (attr
)
6918 && DW_BLOCK (attr
)->size
== 1 + cu_header
->addr_size
6919 && DW_BLOCK (attr
)->data
[0] == DW_OP_addr
)
6923 SYMBOL_VALUE_ADDRESS (sym
) =
6924 read_address (objfile
->obfd
, DW_BLOCK (attr
)->data
+ 1, cu
, &dummy
);
6925 fixup_symbol_section (sym
, objfile
);
6926 SYMBOL_VALUE_ADDRESS (sym
) += ANOFFSET (objfile
->section_offsets
,
6927 SYMBOL_SECTION (sym
));
6928 SYMBOL_CLASS (sym
) = LOC_STATIC
;
6932 /* NOTE drow/2002-01-30: It might be worthwhile to have a static
6933 expression evaluator, and use LOC_COMPUTED only when necessary
6934 (i.e. when the value of a register or memory location is
6935 referenced, or a thread-local block, etc.). Then again, it might
6936 not be worthwhile. I'm assuming that it isn't unless performance
6937 or memory numbers show me otherwise. */
6939 dwarf2_symbol_mark_computed (attr
, sym
, cu
);
6940 SYMBOL_CLASS (sym
) = LOC_COMPUTED
;
6943 /* Given a pointer to a DWARF information entry, figure out if we need
6944 to make a symbol table entry for it, and if so, create a new entry
6945 and return a pointer to it.
6946 If TYPE is NULL, determine symbol type from the die, otherwise
6947 used the passed type. */
6949 static struct symbol
*
6950 new_symbol (struct die_info
*die
, struct type
*type
, struct dwarf2_cu
*cu
)
6952 struct objfile
*objfile
= cu
->objfile
;
6953 struct symbol
*sym
= NULL
;
6955 struct attribute
*attr
= NULL
;
6956 struct attribute
*attr2
= NULL
;
6959 baseaddr
= ANOFFSET (objfile
->section_offsets
, SECT_OFF_TEXT (objfile
));
6961 if (die
->tag
!= DW_TAG_namespace
)
6962 name
= dwarf2_linkage_name (die
, cu
);
6964 name
= TYPE_NAME (type
);
6968 sym
= (struct symbol
*) obstack_alloc (&objfile
->objfile_obstack
,
6969 sizeof (struct symbol
));
6970 OBJSTAT (objfile
, n_syms
++);
6971 memset (sym
, 0, sizeof (struct symbol
));
6973 /* Cache this symbol's name and the name's demangled form (if any). */
6974 SYMBOL_LANGUAGE (sym
) = cu
->language
;
6975 SYMBOL_SET_NAMES (sym
, name
, strlen (name
), objfile
);
6977 /* Default assumptions.
6978 Use the passed type or decode it from the die. */
6979 SYMBOL_DOMAIN (sym
) = VAR_DOMAIN
;
6980 SYMBOL_CLASS (sym
) = LOC_OPTIMIZED_OUT
;
6982 SYMBOL_TYPE (sym
) = type
;
6984 SYMBOL_TYPE (sym
) = die_type (die
, cu
);
6985 attr
= dwarf2_attr (die
, DW_AT_decl_line
, cu
);
6988 SYMBOL_LINE (sym
) = DW_UNSND (attr
);
6993 attr
= dwarf2_attr (die
, DW_AT_low_pc
, cu
);
6996 SYMBOL_VALUE_ADDRESS (sym
) = DW_ADDR (attr
) + baseaddr
;
6998 SYMBOL_CLASS (sym
) = LOC_LABEL
;
7000 case DW_TAG_subprogram
:
7001 /* SYMBOL_BLOCK_VALUE (sym) will be filled in later by
7003 SYMBOL_CLASS (sym
) = LOC_BLOCK
;
7004 attr2
= dwarf2_attr (die
, DW_AT_external
, cu
);
7005 if (attr2
&& (DW_UNSND (attr2
) != 0))
7007 add_symbol_to_list (sym
, &global_symbols
);
7011 add_symbol_to_list (sym
, cu
->list_in_scope
);
7014 case DW_TAG_variable
:
7015 /* Compilation with minimal debug info may result in variables
7016 with missing type entries. Change the misleading `void' type
7017 to something sensible. */
7018 if (TYPE_CODE (SYMBOL_TYPE (sym
)) == TYPE_CODE_VOID
)
7019 SYMBOL_TYPE (sym
) = init_type (TYPE_CODE_INT
,
7020 TARGET_INT_BIT
/ HOST_CHAR_BIT
, 0,
7021 "<variable, no debug info>",
7023 attr
= dwarf2_attr (die
, DW_AT_const_value
, cu
);
7026 dwarf2_const_value (attr
, sym
, cu
);
7027 attr2
= dwarf2_attr (die
, DW_AT_external
, cu
);
7028 if (attr2
&& (DW_UNSND (attr2
) != 0))
7029 add_symbol_to_list (sym
, &global_symbols
);
7031 add_symbol_to_list (sym
, cu
->list_in_scope
);
7034 attr
= dwarf2_attr (die
, DW_AT_location
, cu
);
7037 var_decode_location (attr
, sym
, cu
);
7038 attr2
= dwarf2_attr (die
, DW_AT_external
, cu
);
7039 if (attr2
&& (DW_UNSND (attr2
) != 0))
7040 add_symbol_to_list (sym
, &global_symbols
);
7042 add_symbol_to_list (sym
, cu
->list_in_scope
);
7046 /* We do not know the address of this symbol.
7047 If it is an external symbol and we have type information
7048 for it, enter the symbol as a LOC_UNRESOLVED symbol.
7049 The address of the variable will then be determined from
7050 the minimal symbol table whenever the variable is
7052 attr2
= dwarf2_attr (die
, DW_AT_external
, cu
);
7053 if (attr2
&& (DW_UNSND (attr2
) != 0)
7054 && dwarf2_attr (die
, DW_AT_type
, cu
) != NULL
)
7056 SYMBOL_CLASS (sym
) = LOC_UNRESOLVED
;
7057 add_symbol_to_list (sym
, &global_symbols
);
7061 case DW_TAG_formal_parameter
:
7062 attr
= dwarf2_attr (die
, DW_AT_location
, cu
);
7065 var_decode_location (attr
, sym
, cu
);
7066 /* FIXME drow/2003-07-31: Is LOC_COMPUTED_ARG necessary? */
7067 if (SYMBOL_CLASS (sym
) == LOC_COMPUTED
)
7068 SYMBOL_CLASS (sym
) = LOC_COMPUTED_ARG
;
7070 attr
= dwarf2_attr (die
, DW_AT_const_value
, cu
);
7073 dwarf2_const_value (attr
, sym
, cu
);
7075 add_symbol_to_list (sym
, cu
->list_in_scope
);
7077 case DW_TAG_unspecified_parameters
:
7078 /* From varargs functions; gdb doesn't seem to have any
7079 interest in this information, so just ignore it for now.
7082 case DW_TAG_class_type
:
7083 case DW_TAG_structure_type
:
7084 case DW_TAG_union_type
:
7085 case DW_TAG_set_type
:
7086 case DW_TAG_enumeration_type
:
7087 SYMBOL_CLASS (sym
) = LOC_TYPEDEF
;
7088 SYMBOL_DOMAIN (sym
) = STRUCT_DOMAIN
;
7090 /* Make sure that the symbol includes appropriate enclosing
7091 classes/namespaces in its name. These are calculated in
7092 read_structure_type, and the correct name is saved in
7095 if (cu
->language
== language_cplus
7096 || cu
->language
== language_java
)
7098 struct type
*type
= SYMBOL_TYPE (sym
);
7100 if (TYPE_TAG_NAME (type
) != NULL
)
7102 /* FIXME: carlton/2003-11-10: Should this use
7103 SYMBOL_SET_NAMES instead? (The same problem also
7104 arises further down in this function.) */
7105 /* The type's name is already allocated along with
7106 this objfile, so we don't need to duplicate it
7108 SYMBOL_LINKAGE_NAME (sym
) = TYPE_TAG_NAME (type
);
7113 /* NOTE: carlton/2003-11-10: C++ and Java class symbols shouldn't
7114 really ever be static objects: otherwise, if you try
7115 to, say, break of a class's method and you're in a file
7116 which doesn't mention that class, it won't work unless
7117 the check for all static symbols in lookup_symbol_aux
7118 saves you. See the OtherFileClass tests in
7119 gdb.c++/namespace.exp. */
7121 struct pending
**list_to_add
;
7123 list_to_add
= (cu
->list_in_scope
== &file_symbols
7124 && (cu
->language
== language_cplus
7125 || cu
->language
== language_java
)
7126 ? &global_symbols
: cu
->list_in_scope
);
7128 add_symbol_to_list (sym
, list_to_add
);
7130 /* The semantics of C++ state that "struct foo { ... }" also
7131 defines a typedef for "foo". A Java class declaration also
7132 defines a typedef for the class. Synthesize a typedef symbol
7133 so that "ptype foo" works as expected. */
7134 if (cu
->language
== language_cplus
7135 || cu
->language
== language_java
)
7137 struct symbol
*typedef_sym
= (struct symbol
*)
7138 obstack_alloc (&objfile
->objfile_obstack
,
7139 sizeof (struct symbol
));
7140 *typedef_sym
= *sym
;
7141 SYMBOL_DOMAIN (typedef_sym
) = VAR_DOMAIN
;
7142 /* The symbol's name is already allocated along with
7143 this objfile, so we don't need to duplicate it for
7145 if (TYPE_NAME (SYMBOL_TYPE (sym
)) == 0)
7146 TYPE_NAME (SYMBOL_TYPE (sym
)) = SYMBOL_SEARCH_NAME (sym
);
7147 add_symbol_to_list (typedef_sym
, list_to_add
);
7151 case DW_TAG_typedef
:
7152 if (processing_has_namespace_info
7153 && processing_current_prefix
[0] != '\0')
7155 SYMBOL_LINKAGE_NAME (sym
) = typename_concat (&objfile
->objfile_obstack
,
7156 processing_current_prefix
,
7159 SYMBOL_CLASS (sym
) = LOC_TYPEDEF
;
7160 SYMBOL_DOMAIN (sym
) = VAR_DOMAIN
;
7161 add_symbol_to_list (sym
, cu
->list_in_scope
);
7163 case DW_TAG_base_type
:
7164 case DW_TAG_subrange_type
:
7165 SYMBOL_CLASS (sym
) = LOC_TYPEDEF
;
7166 SYMBOL_DOMAIN (sym
) = VAR_DOMAIN
;
7167 add_symbol_to_list (sym
, cu
->list_in_scope
);
7169 case DW_TAG_enumerator
:
7170 if (processing_has_namespace_info
7171 && processing_current_prefix
[0] != '\0')
7173 SYMBOL_LINKAGE_NAME (sym
) = typename_concat (&objfile
->objfile_obstack
,
7174 processing_current_prefix
,
7177 attr
= dwarf2_attr (die
, DW_AT_const_value
, cu
);
7180 dwarf2_const_value (attr
, sym
, cu
);
7183 /* NOTE: carlton/2003-11-10: See comment above in the
7184 DW_TAG_class_type, etc. block. */
7186 struct pending
**list_to_add
;
7188 list_to_add
= (cu
->list_in_scope
== &file_symbols
7189 && (cu
->language
== language_cplus
7190 || cu
->language
== language_java
)
7191 ? &global_symbols
: cu
->list_in_scope
);
7193 add_symbol_to_list (sym
, list_to_add
);
7196 case DW_TAG_namespace
:
7197 SYMBOL_CLASS (sym
) = LOC_TYPEDEF
;
7198 add_symbol_to_list (sym
, &global_symbols
);
7201 /* Not a tag we recognize. Hopefully we aren't processing
7202 trash data, but since we must specifically ignore things
7203 we don't recognize, there is nothing else we should do at
7205 complaint (&symfile_complaints
, _("unsupported tag: '%s'"),
7206 dwarf_tag_name (die
->tag
));
7213 /* Copy constant value from an attribute to a symbol. */
7216 dwarf2_const_value (struct attribute
*attr
, struct symbol
*sym
,
7217 struct dwarf2_cu
*cu
)
7219 struct objfile
*objfile
= cu
->objfile
;
7220 struct comp_unit_head
*cu_header
= &cu
->header
;
7221 struct dwarf_block
*blk
;
7226 if (TYPE_LENGTH (SYMBOL_TYPE (sym
)) != cu_header
->addr_size
)
7227 dwarf2_const_value_length_mismatch_complaint (DEPRECATED_SYMBOL_NAME (sym
),
7228 cu_header
->addr_size
,
7229 TYPE_LENGTH (SYMBOL_TYPE
7231 SYMBOL_VALUE_BYTES (sym
) =
7232 obstack_alloc (&objfile
->objfile_obstack
, cu_header
->addr_size
);
7233 /* NOTE: cagney/2003-05-09: In-lined store_address call with
7234 it's body - store_unsigned_integer. */
7235 store_unsigned_integer (SYMBOL_VALUE_BYTES (sym
), cu_header
->addr_size
,
7237 SYMBOL_CLASS (sym
) = LOC_CONST_BYTES
;
7239 case DW_FORM_block1
:
7240 case DW_FORM_block2
:
7241 case DW_FORM_block4
:
7243 blk
= DW_BLOCK (attr
);
7244 if (TYPE_LENGTH (SYMBOL_TYPE (sym
)) != blk
->size
)
7245 dwarf2_const_value_length_mismatch_complaint (DEPRECATED_SYMBOL_NAME (sym
),
7247 TYPE_LENGTH (SYMBOL_TYPE
7249 SYMBOL_VALUE_BYTES (sym
) =
7250 obstack_alloc (&objfile
->objfile_obstack
, blk
->size
);
7251 memcpy (SYMBOL_VALUE_BYTES (sym
), blk
->data
, blk
->size
);
7252 SYMBOL_CLASS (sym
) = LOC_CONST_BYTES
;
7255 /* The DW_AT_const_value attributes are supposed to carry the
7256 symbol's value "represented as it would be on the target
7257 architecture." By the time we get here, it's already been
7258 converted to host endianness, so we just need to sign- or
7259 zero-extend it as appropriate. */
7261 dwarf2_const_value_data (attr
, sym
, 8);
7264 dwarf2_const_value_data (attr
, sym
, 16);
7267 dwarf2_const_value_data (attr
, sym
, 32);
7270 dwarf2_const_value_data (attr
, sym
, 64);
7274 SYMBOL_VALUE (sym
) = DW_SND (attr
);
7275 SYMBOL_CLASS (sym
) = LOC_CONST
;
7279 SYMBOL_VALUE (sym
) = DW_UNSND (attr
);
7280 SYMBOL_CLASS (sym
) = LOC_CONST
;
7284 complaint (&symfile_complaints
,
7285 _("unsupported const value attribute form: '%s'"),
7286 dwarf_form_name (attr
->form
));
7287 SYMBOL_VALUE (sym
) = 0;
7288 SYMBOL_CLASS (sym
) = LOC_CONST
;
7294 /* Given an attr with a DW_FORM_dataN value in host byte order, sign-
7295 or zero-extend it as appropriate for the symbol's type. */
7297 dwarf2_const_value_data (struct attribute
*attr
,
7301 LONGEST l
= DW_UNSND (attr
);
7303 if (bits
< sizeof (l
) * 8)
7305 if (TYPE_UNSIGNED (SYMBOL_TYPE (sym
)))
7306 l
&= ((LONGEST
) 1 << bits
) - 1;
7308 l
= (l
<< (sizeof (l
) * 8 - bits
)) >> (sizeof (l
) * 8 - bits
);
7311 SYMBOL_VALUE (sym
) = l
;
7312 SYMBOL_CLASS (sym
) = LOC_CONST
;
7316 /* Return the type of the die in question using its DW_AT_type attribute. */
7318 static struct type
*
7319 die_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
7322 struct attribute
*type_attr
;
7323 struct die_info
*type_die
;
7325 type_attr
= dwarf2_attr (die
, DW_AT_type
, cu
);
7328 /* A missing DW_AT_type represents a void type. */
7329 return dwarf2_fundamental_type (cu
->objfile
, FT_VOID
, cu
);
7332 type_die
= follow_die_ref (die
, type_attr
, cu
);
7334 type
= tag_type_to_type (type_die
, cu
);
7337 dump_die (type_die
);
7338 error (_("Dwarf Error: Problem turning type die at offset into gdb type [in module %s]"),
7344 /* Return the containing type of the die in question using its
7345 DW_AT_containing_type attribute. */
7347 static struct type
*
7348 die_containing_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
7350 struct type
*type
= NULL
;
7351 struct attribute
*type_attr
;
7352 struct die_info
*type_die
= NULL
;
7354 type_attr
= dwarf2_attr (die
, DW_AT_containing_type
, cu
);
7357 type_die
= follow_die_ref (die
, type_attr
, cu
);
7358 type
= tag_type_to_type (type_die
, cu
);
7363 dump_die (type_die
);
7364 error (_("Dwarf Error: Problem turning containing type into gdb type [in module %s]"),
7370 static struct type
*
7371 tag_type_to_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
7379 read_type_die (die
, cu
);
7383 error (_("Dwarf Error: Cannot find type of die [in module %s]"),
7391 read_type_die (struct die_info
*die
, struct dwarf2_cu
*cu
)
7393 char *prefix
= determine_prefix (die
, cu
);
7394 const char *old_prefix
= processing_current_prefix
;
7395 struct cleanup
*back_to
= make_cleanup (xfree
, prefix
);
7396 processing_current_prefix
= prefix
;
7400 case DW_TAG_class_type
:
7401 case DW_TAG_structure_type
:
7402 case DW_TAG_union_type
:
7403 read_structure_type (die
, cu
);
7405 case DW_TAG_enumeration_type
:
7406 read_enumeration_type (die
, cu
);
7408 case DW_TAG_subprogram
:
7409 case DW_TAG_subroutine_type
:
7410 read_subroutine_type (die
, cu
);
7412 case DW_TAG_array_type
:
7413 read_array_type (die
, cu
);
7415 case DW_TAG_set_type
:
7416 read_set_type (die
, cu
);
7418 case DW_TAG_pointer_type
:
7419 read_tag_pointer_type (die
, cu
);
7421 case DW_TAG_ptr_to_member_type
:
7422 read_tag_ptr_to_member_type (die
, cu
);
7424 case DW_TAG_reference_type
:
7425 read_tag_reference_type (die
, cu
);
7427 case DW_TAG_const_type
:
7428 read_tag_const_type (die
, cu
);
7430 case DW_TAG_volatile_type
:
7431 read_tag_volatile_type (die
, cu
);
7433 case DW_TAG_string_type
:
7434 read_tag_string_type (die
, cu
);
7436 case DW_TAG_typedef
:
7437 read_typedef (die
, cu
);
7439 case DW_TAG_subrange_type
:
7440 read_subrange_type (die
, cu
);
7442 case DW_TAG_base_type
:
7443 read_base_type (die
, cu
);
7445 case DW_TAG_unspecified_type
:
7446 read_unspecified_type (die
, cu
);
7449 complaint (&symfile_complaints
, _("unexpected tag in read_type_die: '%s'"),
7450 dwarf_tag_name (die
->tag
));
7454 processing_current_prefix
= old_prefix
;
7455 do_cleanups (back_to
);
7458 /* Return the name of the namespace/class that DIE is defined within,
7459 or "" if we can't tell. The caller should xfree the result. */
7461 /* NOTE: carlton/2004-01-23: See read_func_scope (and the comment
7462 therein) for an example of how to use this function to deal with
7463 DW_AT_specification. */
7466 determine_prefix (struct die_info
*die
, struct dwarf2_cu
*cu
)
7468 struct die_info
*parent
;
7470 if (cu
->language
!= language_cplus
7471 && cu
->language
!= language_java
)
7474 parent
= die
->parent
;
7478 return xstrdup ("");
7482 switch (parent
->tag
) {
7483 case DW_TAG_namespace
:
7485 /* FIXME: carlton/2004-03-05: Should I follow extension dies
7486 before doing this check? */
7487 if (parent
->type
!= NULL
&& TYPE_TAG_NAME (parent
->type
) != NULL
)
7489 return xstrdup (TYPE_TAG_NAME (parent
->type
));
7494 char *parent_prefix
= determine_prefix (parent
, cu
);
7495 char *retval
= typename_concat (NULL
, parent_prefix
,
7496 namespace_name (parent
, &dummy
,
7499 xfree (parent_prefix
);
7504 case DW_TAG_class_type
:
7505 case DW_TAG_structure_type
:
7507 if (parent
->type
!= NULL
&& TYPE_TAG_NAME (parent
->type
) != NULL
)
7509 return xstrdup (TYPE_TAG_NAME (parent
->type
));
7513 const char *old_prefix
= processing_current_prefix
;
7514 char *new_prefix
= determine_prefix (parent
, cu
);
7517 processing_current_prefix
= new_prefix
;
7518 retval
= determine_class_name (parent
, cu
);
7519 processing_current_prefix
= old_prefix
;
7526 return determine_prefix (parent
, cu
);
7531 /* Return a newly-allocated string formed by concatenating PREFIX and
7532 SUFFIX with appropriate separator. If PREFIX or SUFFIX is NULL or empty, then
7533 simply copy the SUFFIX or PREFIX, respectively. If OBS is non-null,
7534 perform an obconcat, otherwise allocate storage for the result. The CU argument
7535 is used to determine the language and hence, the appropriate separator. */
7537 #define MAX_SEP_LEN 2 /* sizeof ("::") */
7540 typename_concat (struct obstack
*obs
, const char *prefix
, const char *suffix
,
7541 struct dwarf2_cu
*cu
)
7545 if (suffix
== NULL
|| suffix
[0] == '\0' || prefix
== NULL
|| prefix
[0] == '\0')
7547 else if (cu
->language
== language_java
)
7554 char *retval
= xmalloc (strlen (prefix
) + MAX_SEP_LEN
+ strlen (suffix
) + 1);
7559 strcpy (retval
, prefix
);
7560 strcat (retval
, sep
);
7563 strcat (retval
, suffix
);
7569 /* We have an obstack. */
7570 return obconcat (obs
, prefix
, sep
, suffix
);
7574 static struct type
*
7575 dwarf_base_type (int encoding
, int size
, struct dwarf2_cu
*cu
)
7577 struct objfile
*objfile
= cu
->objfile
;
7579 /* FIXME - this should not produce a new (struct type *)
7580 every time. It should cache base types. */
7584 case DW_ATE_address
:
7585 type
= dwarf2_fundamental_type (objfile
, FT_VOID
, cu
);
7587 case DW_ATE_boolean
:
7588 type
= dwarf2_fundamental_type (objfile
, FT_BOOLEAN
, cu
);
7590 case DW_ATE_complex_float
:
7593 type
= dwarf2_fundamental_type (objfile
, FT_DBL_PREC_COMPLEX
, cu
);
7597 type
= dwarf2_fundamental_type (objfile
, FT_COMPLEX
, cu
);
7603 type
= dwarf2_fundamental_type (objfile
, FT_DBL_PREC_FLOAT
, cu
);
7607 type
= dwarf2_fundamental_type (objfile
, FT_FLOAT
, cu
);
7614 type
= dwarf2_fundamental_type (objfile
, FT_SIGNED_CHAR
, cu
);
7617 type
= dwarf2_fundamental_type (objfile
, FT_SIGNED_SHORT
, cu
);
7621 type
= dwarf2_fundamental_type (objfile
, FT_SIGNED_INTEGER
, cu
);
7625 case DW_ATE_signed_char
:
7626 type
= dwarf2_fundamental_type (objfile
, FT_SIGNED_CHAR
, cu
);
7628 case DW_ATE_unsigned
:
7632 type
= dwarf2_fundamental_type (objfile
, FT_UNSIGNED_CHAR
, cu
);
7635 type
= dwarf2_fundamental_type (objfile
, FT_UNSIGNED_SHORT
, cu
);
7639 type
= dwarf2_fundamental_type (objfile
, FT_UNSIGNED_INTEGER
, cu
);
7643 case DW_ATE_unsigned_char
:
7644 type
= dwarf2_fundamental_type (objfile
, FT_UNSIGNED_CHAR
, cu
);
7647 type
= dwarf2_fundamental_type (objfile
, FT_SIGNED_INTEGER
, cu
);
7654 copy_die (struct die_info
*old_die
)
7656 struct die_info
*new_die
;
7659 new_die
= (struct die_info
*) xmalloc (sizeof (struct die_info
));
7660 memset (new_die
, 0, sizeof (struct die_info
));
7662 new_die
->tag
= old_die
->tag
;
7663 new_die
->has_children
= old_die
->has_children
;
7664 new_die
->abbrev
= old_die
->abbrev
;
7665 new_die
->offset
= old_die
->offset
;
7666 new_die
->type
= NULL
;
7668 num_attrs
= old_die
->num_attrs
;
7669 new_die
->num_attrs
= num_attrs
;
7670 new_die
->attrs
= (struct attribute
*)
7671 xmalloc (num_attrs
* sizeof (struct attribute
));
7673 for (i
= 0; i
< old_die
->num_attrs
; ++i
)
7675 new_die
->attrs
[i
].name
= old_die
->attrs
[i
].name
;
7676 new_die
->attrs
[i
].form
= old_die
->attrs
[i
].form
;
7677 new_die
->attrs
[i
].u
.addr
= old_die
->attrs
[i
].u
.addr
;
7680 new_die
->next
= NULL
;
7685 /* Return sibling of die, NULL if no sibling. */
7687 static struct die_info
*
7688 sibling_die (struct die_info
*die
)
7690 return die
->sibling
;
7693 /* Get linkage name of a die, return NULL if not found. */
7696 dwarf2_linkage_name (struct die_info
*die
, struct dwarf2_cu
*cu
)
7698 struct attribute
*attr
;
7700 attr
= dwarf2_attr (die
, DW_AT_MIPS_linkage_name
, cu
);
7701 if (attr
&& DW_STRING (attr
))
7702 return DW_STRING (attr
);
7703 attr
= dwarf2_attr (die
, DW_AT_name
, cu
);
7704 if (attr
&& DW_STRING (attr
))
7705 return DW_STRING (attr
);
7709 /* Get name of a die, return NULL if not found. */
7712 dwarf2_name (struct die_info
*die
, struct dwarf2_cu
*cu
)
7714 struct attribute
*attr
;
7716 attr
= dwarf2_attr (die
, DW_AT_name
, cu
);
7717 if (attr
&& DW_STRING (attr
))
7718 return DW_STRING (attr
);
7722 /* Return the die that this die in an extension of, or NULL if there
7725 static struct die_info
*
7726 dwarf2_extension (struct die_info
*die
, struct dwarf2_cu
*cu
)
7728 struct attribute
*attr
;
7730 attr
= dwarf2_attr (die
, DW_AT_extension
, cu
);
7734 return follow_die_ref (die
, attr
, cu
);
7737 /* Convert a DIE tag into its string name. */
7740 dwarf_tag_name (unsigned tag
)
7744 case DW_TAG_padding
:
7745 return "DW_TAG_padding";
7746 case DW_TAG_array_type
:
7747 return "DW_TAG_array_type";
7748 case DW_TAG_class_type
:
7749 return "DW_TAG_class_type";
7750 case DW_TAG_entry_point
:
7751 return "DW_TAG_entry_point";
7752 case DW_TAG_enumeration_type
:
7753 return "DW_TAG_enumeration_type";
7754 case DW_TAG_formal_parameter
:
7755 return "DW_TAG_formal_parameter";
7756 case DW_TAG_imported_declaration
:
7757 return "DW_TAG_imported_declaration";
7759 return "DW_TAG_label";
7760 case DW_TAG_lexical_block
:
7761 return "DW_TAG_lexical_block";
7763 return "DW_TAG_member";
7764 case DW_TAG_pointer_type
:
7765 return "DW_TAG_pointer_type";
7766 case DW_TAG_reference_type
:
7767 return "DW_TAG_reference_type";
7768 case DW_TAG_compile_unit
:
7769 return "DW_TAG_compile_unit";
7770 case DW_TAG_string_type
:
7771 return "DW_TAG_string_type";
7772 case DW_TAG_structure_type
:
7773 return "DW_TAG_structure_type";
7774 case DW_TAG_subroutine_type
:
7775 return "DW_TAG_subroutine_type";
7776 case DW_TAG_typedef
:
7777 return "DW_TAG_typedef";
7778 case DW_TAG_union_type
:
7779 return "DW_TAG_union_type";
7780 case DW_TAG_unspecified_parameters
:
7781 return "DW_TAG_unspecified_parameters";
7782 case DW_TAG_variant
:
7783 return "DW_TAG_variant";
7784 case DW_TAG_common_block
:
7785 return "DW_TAG_common_block";
7786 case DW_TAG_common_inclusion
:
7787 return "DW_TAG_common_inclusion";
7788 case DW_TAG_inheritance
:
7789 return "DW_TAG_inheritance";
7790 case DW_TAG_inlined_subroutine
:
7791 return "DW_TAG_inlined_subroutine";
7793 return "DW_TAG_module";
7794 case DW_TAG_ptr_to_member_type
:
7795 return "DW_TAG_ptr_to_member_type";
7796 case DW_TAG_set_type
:
7797 return "DW_TAG_set_type";
7798 case DW_TAG_subrange_type
:
7799 return "DW_TAG_subrange_type";
7800 case DW_TAG_with_stmt
:
7801 return "DW_TAG_with_stmt";
7802 case DW_TAG_access_declaration
:
7803 return "DW_TAG_access_declaration";
7804 case DW_TAG_base_type
:
7805 return "DW_TAG_base_type";
7806 case DW_TAG_catch_block
:
7807 return "DW_TAG_catch_block";
7808 case DW_TAG_const_type
:
7809 return "DW_TAG_const_type";
7810 case DW_TAG_constant
:
7811 return "DW_TAG_constant";
7812 case DW_TAG_enumerator
:
7813 return "DW_TAG_enumerator";
7814 case DW_TAG_file_type
:
7815 return "DW_TAG_file_type";
7817 return "DW_TAG_friend";
7818 case DW_TAG_namelist
:
7819 return "DW_TAG_namelist";
7820 case DW_TAG_namelist_item
:
7821 return "DW_TAG_namelist_item";
7822 case DW_TAG_packed_type
:
7823 return "DW_TAG_packed_type";
7824 case DW_TAG_subprogram
:
7825 return "DW_TAG_subprogram";
7826 case DW_TAG_template_type_param
:
7827 return "DW_TAG_template_type_param";
7828 case DW_TAG_template_value_param
:
7829 return "DW_TAG_template_value_param";
7830 case DW_TAG_thrown_type
:
7831 return "DW_TAG_thrown_type";
7832 case DW_TAG_try_block
:
7833 return "DW_TAG_try_block";
7834 case DW_TAG_variant_part
:
7835 return "DW_TAG_variant_part";
7836 case DW_TAG_variable
:
7837 return "DW_TAG_variable";
7838 case DW_TAG_volatile_type
:
7839 return "DW_TAG_volatile_type";
7840 case DW_TAG_dwarf_procedure
:
7841 return "DW_TAG_dwarf_procedure";
7842 case DW_TAG_restrict_type
:
7843 return "DW_TAG_restrict_type";
7844 case DW_TAG_interface_type
:
7845 return "DW_TAG_interface_type";
7846 case DW_TAG_namespace
:
7847 return "DW_TAG_namespace";
7848 case DW_TAG_imported_module
:
7849 return "DW_TAG_imported_module";
7850 case DW_TAG_unspecified_type
:
7851 return "DW_TAG_unspecified_type";
7852 case DW_TAG_partial_unit
:
7853 return "DW_TAG_partial_unit";
7854 case DW_TAG_imported_unit
:
7855 return "DW_TAG_imported_unit";
7856 case DW_TAG_MIPS_loop
:
7857 return "DW_TAG_MIPS_loop";
7858 case DW_TAG_format_label
:
7859 return "DW_TAG_format_label";
7860 case DW_TAG_function_template
:
7861 return "DW_TAG_function_template";
7862 case DW_TAG_class_template
:
7863 return "DW_TAG_class_template";
7865 return "DW_TAG_<unknown>";
7869 /* Convert a DWARF attribute code into its string name. */
7872 dwarf_attr_name (unsigned attr
)
7877 return "DW_AT_sibling";
7878 case DW_AT_location
:
7879 return "DW_AT_location";
7881 return "DW_AT_name";
7882 case DW_AT_ordering
:
7883 return "DW_AT_ordering";
7884 case DW_AT_subscr_data
:
7885 return "DW_AT_subscr_data";
7886 case DW_AT_byte_size
:
7887 return "DW_AT_byte_size";
7888 case DW_AT_bit_offset
:
7889 return "DW_AT_bit_offset";
7890 case DW_AT_bit_size
:
7891 return "DW_AT_bit_size";
7892 case DW_AT_element_list
:
7893 return "DW_AT_element_list";
7894 case DW_AT_stmt_list
:
7895 return "DW_AT_stmt_list";
7897 return "DW_AT_low_pc";
7899 return "DW_AT_high_pc";
7900 case DW_AT_language
:
7901 return "DW_AT_language";
7903 return "DW_AT_member";
7905 return "DW_AT_discr";
7906 case DW_AT_discr_value
:
7907 return "DW_AT_discr_value";
7908 case DW_AT_visibility
:
7909 return "DW_AT_visibility";
7911 return "DW_AT_import";
7912 case DW_AT_string_length
:
7913 return "DW_AT_string_length";
7914 case DW_AT_common_reference
:
7915 return "DW_AT_common_reference";
7916 case DW_AT_comp_dir
:
7917 return "DW_AT_comp_dir";
7918 case DW_AT_const_value
:
7919 return "DW_AT_const_value";
7920 case DW_AT_containing_type
:
7921 return "DW_AT_containing_type";
7922 case DW_AT_default_value
:
7923 return "DW_AT_default_value";
7925 return "DW_AT_inline";
7926 case DW_AT_is_optional
:
7927 return "DW_AT_is_optional";
7928 case DW_AT_lower_bound
:
7929 return "DW_AT_lower_bound";
7930 case DW_AT_producer
:
7931 return "DW_AT_producer";
7932 case DW_AT_prototyped
:
7933 return "DW_AT_prototyped";
7934 case DW_AT_return_addr
:
7935 return "DW_AT_return_addr";
7936 case DW_AT_start_scope
:
7937 return "DW_AT_start_scope";
7938 case DW_AT_stride_size
:
7939 return "DW_AT_stride_size";
7940 case DW_AT_upper_bound
:
7941 return "DW_AT_upper_bound";
7942 case DW_AT_abstract_origin
:
7943 return "DW_AT_abstract_origin";
7944 case DW_AT_accessibility
:
7945 return "DW_AT_accessibility";
7946 case DW_AT_address_class
:
7947 return "DW_AT_address_class";
7948 case DW_AT_artificial
:
7949 return "DW_AT_artificial";
7950 case DW_AT_base_types
:
7951 return "DW_AT_base_types";
7952 case DW_AT_calling_convention
:
7953 return "DW_AT_calling_convention";
7955 return "DW_AT_count";
7956 case DW_AT_data_member_location
:
7957 return "DW_AT_data_member_location";
7958 case DW_AT_decl_column
:
7959 return "DW_AT_decl_column";
7960 case DW_AT_decl_file
:
7961 return "DW_AT_decl_file";
7962 case DW_AT_decl_line
:
7963 return "DW_AT_decl_line";
7964 case DW_AT_declaration
:
7965 return "DW_AT_declaration";
7966 case DW_AT_discr_list
:
7967 return "DW_AT_discr_list";
7968 case DW_AT_encoding
:
7969 return "DW_AT_encoding";
7970 case DW_AT_external
:
7971 return "DW_AT_external";
7972 case DW_AT_frame_base
:
7973 return "DW_AT_frame_base";
7975 return "DW_AT_friend";
7976 case DW_AT_identifier_case
:
7977 return "DW_AT_identifier_case";
7978 case DW_AT_macro_info
:
7979 return "DW_AT_macro_info";
7980 case DW_AT_namelist_items
:
7981 return "DW_AT_namelist_items";
7982 case DW_AT_priority
:
7983 return "DW_AT_priority";
7985 return "DW_AT_segment";
7986 case DW_AT_specification
:
7987 return "DW_AT_specification";
7988 case DW_AT_static_link
:
7989 return "DW_AT_static_link";
7991 return "DW_AT_type";
7992 case DW_AT_use_location
:
7993 return "DW_AT_use_location";
7994 case DW_AT_variable_parameter
:
7995 return "DW_AT_variable_parameter";
7996 case DW_AT_virtuality
:
7997 return "DW_AT_virtuality";
7998 case DW_AT_vtable_elem_location
:
7999 return "DW_AT_vtable_elem_location";
8000 case DW_AT_allocated
:
8001 return "DW_AT_allocated";
8002 case DW_AT_associated
:
8003 return "DW_AT_associated";
8004 case DW_AT_data_location
:
8005 return "DW_AT_data_location";
8007 return "DW_AT_stride";
8008 case DW_AT_entry_pc
:
8009 return "DW_AT_entry_pc";
8010 case DW_AT_use_UTF8
:
8011 return "DW_AT_use_UTF8";
8012 case DW_AT_extension
:
8013 return "DW_AT_extension";
8015 return "DW_AT_ranges";
8016 case DW_AT_trampoline
:
8017 return "DW_AT_trampoline";
8018 case DW_AT_call_column
:
8019 return "DW_AT_call_column";
8020 case DW_AT_call_file
:
8021 return "DW_AT_call_file";
8022 case DW_AT_call_line
:
8023 return "DW_AT_call_line";
8025 case DW_AT_MIPS_fde
:
8026 return "DW_AT_MIPS_fde";
8027 case DW_AT_MIPS_loop_begin
:
8028 return "DW_AT_MIPS_loop_begin";
8029 case DW_AT_MIPS_tail_loop_begin
:
8030 return "DW_AT_MIPS_tail_loop_begin";
8031 case DW_AT_MIPS_epilog_begin
:
8032 return "DW_AT_MIPS_epilog_begin";
8033 case DW_AT_MIPS_loop_unroll_factor
:
8034 return "DW_AT_MIPS_loop_unroll_factor";
8035 case DW_AT_MIPS_software_pipeline_depth
:
8036 return "DW_AT_MIPS_software_pipeline_depth";
8038 case DW_AT_MIPS_linkage_name
:
8039 return "DW_AT_MIPS_linkage_name";
8041 case DW_AT_sf_names
:
8042 return "DW_AT_sf_names";
8043 case DW_AT_src_info
:
8044 return "DW_AT_src_info";
8045 case DW_AT_mac_info
:
8046 return "DW_AT_mac_info";
8047 case DW_AT_src_coords
:
8048 return "DW_AT_src_coords";
8049 case DW_AT_body_begin
:
8050 return "DW_AT_body_begin";
8051 case DW_AT_body_end
:
8052 return "DW_AT_body_end";
8053 case DW_AT_GNU_vector
:
8054 return "DW_AT_GNU_vector";
8056 return "DW_AT_<unknown>";
8060 /* Convert a DWARF value form code into its string name. */
8063 dwarf_form_name (unsigned form
)
8068 return "DW_FORM_addr";
8069 case DW_FORM_block2
:
8070 return "DW_FORM_block2";
8071 case DW_FORM_block4
:
8072 return "DW_FORM_block4";
8074 return "DW_FORM_data2";
8076 return "DW_FORM_data4";
8078 return "DW_FORM_data8";
8079 case DW_FORM_string
:
8080 return "DW_FORM_string";
8082 return "DW_FORM_block";
8083 case DW_FORM_block1
:
8084 return "DW_FORM_block1";
8086 return "DW_FORM_data1";
8088 return "DW_FORM_flag";
8090 return "DW_FORM_sdata";
8092 return "DW_FORM_strp";
8094 return "DW_FORM_udata";
8095 case DW_FORM_ref_addr
:
8096 return "DW_FORM_ref_addr";
8098 return "DW_FORM_ref1";
8100 return "DW_FORM_ref2";
8102 return "DW_FORM_ref4";
8104 return "DW_FORM_ref8";
8105 case DW_FORM_ref_udata
:
8106 return "DW_FORM_ref_udata";
8107 case DW_FORM_indirect
:
8108 return "DW_FORM_indirect";
8110 return "DW_FORM_<unknown>";
8114 /* Convert a DWARF stack opcode into its string name. */
8117 dwarf_stack_op_name (unsigned op
)
8122 return "DW_OP_addr";
8124 return "DW_OP_deref";
8126 return "DW_OP_const1u";
8128 return "DW_OP_const1s";
8130 return "DW_OP_const2u";
8132 return "DW_OP_const2s";
8134 return "DW_OP_const4u";
8136 return "DW_OP_const4s";
8138 return "DW_OP_const8u";
8140 return "DW_OP_const8s";
8142 return "DW_OP_constu";
8144 return "DW_OP_consts";
8148 return "DW_OP_drop";
8150 return "DW_OP_over";
8152 return "DW_OP_pick";
8154 return "DW_OP_swap";
8158 return "DW_OP_xderef";
8166 return "DW_OP_minus";
8178 return "DW_OP_plus";
8179 case DW_OP_plus_uconst
:
8180 return "DW_OP_plus_uconst";
8186 return "DW_OP_shra";
8204 return "DW_OP_skip";
8206 return "DW_OP_lit0";
8208 return "DW_OP_lit1";
8210 return "DW_OP_lit2";
8212 return "DW_OP_lit3";
8214 return "DW_OP_lit4";
8216 return "DW_OP_lit5";
8218 return "DW_OP_lit6";
8220 return "DW_OP_lit7";
8222 return "DW_OP_lit8";
8224 return "DW_OP_lit9";
8226 return "DW_OP_lit10";
8228 return "DW_OP_lit11";
8230 return "DW_OP_lit12";
8232 return "DW_OP_lit13";
8234 return "DW_OP_lit14";
8236 return "DW_OP_lit15";
8238 return "DW_OP_lit16";
8240 return "DW_OP_lit17";
8242 return "DW_OP_lit18";
8244 return "DW_OP_lit19";
8246 return "DW_OP_lit20";
8248 return "DW_OP_lit21";
8250 return "DW_OP_lit22";
8252 return "DW_OP_lit23";
8254 return "DW_OP_lit24";
8256 return "DW_OP_lit25";
8258 return "DW_OP_lit26";
8260 return "DW_OP_lit27";
8262 return "DW_OP_lit28";
8264 return "DW_OP_lit29";
8266 return "DW_OP_lit30";
8268 return "DW_OP_lit31";
8270 return "DW_OP_reg0";
8272 return "DW_OP_reg1";
8274 return "DW_OP_reg2";
8276 return "DW_OP_reg3";
8278 return "DW_OP_reg4";
8280 return "DW_OP_reg5";
8282 return "DW_OP_reg6";
8284 return "DW_OP_reg7";
8286 return "DW_OP_reg8";
8288 return "DW_OP_reg9";
8290 return "DW_OP_reg10";
8292 return "DW_OP_reg11";
8294 return "DW_OP_reg12";
8296 return "DW_OP_reg13";
8298 return "DW_OP_reg14";
8300 return "DW_OP_reg15";
8302 return "DW_OP_reg16";
8304 return "DW_OP_reg17";
8306 return "DW_OP_reg18";
8308 return "DW_OP_reg19";
8310 return "DW_OP_reg20";
8312 return "DW_OP_reg21";
8314 return "DW_OP_reg22";
8316 return "DW_OP_reg23";
8318 return "DW_OP_reg24";
8320 return "DW_OP_reg25";
8322 return "DW_OP_reg26";
8324 return "DW_OP_reg27";
8326 return "DW_OP_reg28";
8328 return "DW_OP_reg29";
8330 return "DW_OP_reg30";
8332 return "DW_OP_reg31";
8334 return "DW_OP_breg0";
8336 return "DW_OP_breg1";
8338 return "DW_OP_breg2";
8340 return "DW_OP_breg3";
8342 return "DW_OP_breg4";
8344 return "DW_OP_breg5";
8346 return "DW_OP_breg6";
8348 return "DW_OP_breg7";
8350 return "DW_OP_breg8";
8352 return "DW_OP_breg9";
8354 return "DW_OP_breg10";
8356 return "DW_OP_breg11";
8358 return "DW_OP_breg12";
8360 return "DW_OP_breg13";
8362 return "DW_OP_breg14";
8364 return "DW_OP_breg15";
8366 return "DW_OP_breg16";
8368 return "DW_OP_breg17";
8370 return "DW_OP_breg18";
8372 return "DW_OP_breg19";
8374 return "DW_OP_breg20";
8376 return "DW_OP_breg21";
8378 return "DW_OP_breg22";
8380 return "DW_OP_breg23";
8382 return "DW_OP_breg24";
8384 return "DW_OP_breg25";
8386 return "DW_OP_breg26";
8388 return "DW_OP_breg27";
8390 return "DW_OP_breg28";
8392 return "DW_OP_breg29";
8394 return "DW_OP_breg30";
8396 return "DW_OP_breg31";
8398 return "DW_OP_regx";
8400 return "DW_OP_fbreg";
8402 return "DW_OP_bregx";
8404 return "DW_OP_piece";
8405 case DW_OP_deref_size
:
8406 return "DW_OP_deref_size";
8407 case DW_OP_xderef_size
:
8408 return "DW_OP_xderef_size";
8411 /* DWARF 3 extensions. */
8412 case DW_OP_push_object_address
:
8413 return "DW_OP_push_object_address";
8415 return "DW_OP_call2";
8417 return "DW_OP_call4";
8418 case DW_OP_call_ref
:
8419 return "DW_OP_call_ref";
8420 /* GNU extensions. */
8421 case DW_OP_GNU_push_tls_address
:
8422 return "DW_OP_GNU_push_tls_address";
8424 return "OP_<unknown>";
8429 dwarf_bool_name (unsigned mybool
)
8437 /* Convert a DWARF type code into its string name. */
8440 dwarf_type_encoding_name (unsigned enc
)
8444 case DW_ATE_address
:
8445 return "DW_ATE_address";
8446 case DW_ATE_boolean
:
8447 return "DW_ATE_boolean";
8448 case DW_ATE_complex_float
:
8449 return "DW_ATE_complex_float";
8451 return "DW_ATE_float";
8453 return "DW_ATE_signed";
8454 case DW_ATE_signed_char
:
8455 return "DW_ATE_signed_char";
8456 case DW_ATE_unsigned
:
8457 return "DW_ATE_unsigned";
8458 case DW_ATE_unsigned_char
:
8459 return "DW_ATE_unsigned_char";
8460 case DW_ATE_imaginary_float
:
8461 return "DW_ATE_imaginary_float";
8463 return "DW_ATE_<unknown>";
8467 /* Convert a DWARF call frame info operation to its string name. */
8471 dwarf_cfi_name (unsigned cfi_opc
)
8475 case DW_CFA_advance_loc
:
8476 return "DW_CFA_advance_loc";
8478 return "DW_CFA_offset";
8479 case DW_CFA_restore
:
8480 return "DW_CFA_restore";
8482 return "DW_CFA_nop";
8483 case DW_CFA_set_loc
:
8484 return "DW_CFA_set_loc";
8485 case DW_CFA_advance_loc1
:
8486 return "DW_CFA_advance_loc1";
8487 case DW_CFA_advance_loc2
:
8488 return "DW_CFA_advance_loc2";
8489 case DW_CFA_advance_loc4
:
8490 return "DW_CFA_advance_loc4";
8491 case DW_CFA_offset_extended
:
8492 return "DW_CFA_offset_extended";
8493 case DW_CFA_restore_extended
:
8494 return "DW_CFA_restore_extended";
8495 case DW_CFA_undefined
:
8496 return "DW_CFA_undefined";
8497 case DW_CFA_same_value
:
8498 return "DW_CFA_same_value";
8499 case DW_CFA_register
:
8500 return "DW_CFA_register";
8501 case DW_CFA_remember_state
:
8502 return "DW_CFA_remember_state";
8503 case DW_CFA_restore_state
:
8504 return "DW_CFA_restore_state";
8505 case DW_CFA_def_cfa
:
8506 return "DW_CFA_def_cfa";
8507 case DW_CFA_def_cfa_register
:
8508 return "DW_CFA_def_cfa_register";
8509 case DW_CFA_def_cfa_offset
:
8510 return "DW_CFA_def_cfa_offset";
8513 case DW_CFA_def_cfa_expression
:
8514 return "DW_CFA_def_cfa_expression";
8515 case DW_CFA_expression
:
8516 return "DW_CFA_expression";
8517 case DW_CFA_offset_extended_sf
:
8518 return "DW_CFA_offset_extended_sf";
8519 case DW_CFA_def_cfa_sf
:
8520 return "DW_CFA_def_cfa_sf";
8521 case DW_CFA_def_cfa_offset_sf
:
8522 return "DW_CFA_def_cfa_offset_sf";
8524 /* SGI/MIPS specific */
8525 case DW_CFA_MIPS_advance_loc8
:
8526 return "DW_CFA_MIPS_advance_loc8";
8528 /* GNU extensions */
8529 case DW_CFA_GNU_window_save
:
8530 return "DW_CFA_GNU_window_save";
8531 case DW_CFA_GNU_args_size
:
8532 return "DW_CFA_GNU_args_size";
8533 case DW_CFA_GNU_negative_offset_extended
:
8534 return "DW_CFA_GNU_negative_offset_extended";
8537 return "DW_CFA_<unknown>";
8543 dump_die (struct die_info
*die
)
8547 fprintf_unfiltered (gdb_stderr
, "Die: %s (abbrev = %d, offset = %d)\n",
8548 dwarf_tag_name (die
->tag
), die
->abbrev
, die
->offset
);
8549 fprintf_unfiltered (gdb_stderr
, "\thas children: %s\n",
8550 dwarf_bool_name (die
->child
!= NULL
));
8552 fprintf_unfiltered (gdb_stderr
, "\tattributes:\n");
8553 for (i
= 0; i
< die
->num_attrs
; ++i
)
8555 fprintf_unfiltered (gdb_stderr
, "\t\t%s (%s) ",
8556 dwarf_attr_name (die
->attrs
[i
].name
),
8557 dwarf_form_name (die
->attrs
[i
].form
));
8558 switch (die
->attrs
[i
].form
)
8560 case DW_FORM_ref_addr
:
8562 fprintf_unfiltered (gdb_stderr
, "address: ");
8563 deprecated_print_address_numeric (DW_ADDR (&die
->attrs
[i
]), 1, gdb_stderr
);
8565 case DW_FORM_block2
:
8566 case DW_FORM_block4
:
8568 case DW_FORM_block1
:
8569 fprintf_unfiltered (gdb_stderr
, "block: size %d", DW_BLOCK (&die
->attrs
[i
])->size
);
8574 fprintf_unfiltered (gdb_stderr
, "constant ref: %ld (adjusted)",
8575 (long) (DW_ADDR (&die
->attrs
[i
])));
8583 fprintf_unfiltered (gdb_stderr
, "constant: %ld", DW_UNSND (&die
->attrs
[i
]));
8585 case DW_FORM_string
:
8587 fprintf_unfiltered (gdb_stderr
, "string: \"%s\"",
8588 DW_STRING (&die
->attrs
[i
])
8589 ? DW_STRING (&die
->attrs
[i
]) : "");
8592 if (DW_UNSND (&die
->attrs
[i
]))
8593 fprintf_unfiltered (gdb_stderr
, "flag: TRUE");
8595 fprintf_unfiltered (gdb_stderr
, "flag: FALSE");
8597 case DW_FORM_indirect
:
8598 /* the reader will have reduced the indirect form to
8599 the "base form" so this form should not occur */
8600 fprintf_unfiltered (gdb_stderr
, "unexpected attribute form: DW_FORM_indirect");
8603 fprintf_unfiltered (gdb_stderr
, "unsupported attribute form: %d.",
8604 die
->attrs
[i
].form
);
8606 fprintf_unfiltered (gdb_stderr
, "\n");
8611 dump_die_list (struct die_info
*die
)
8616 if (die
->child
!= NULL
)
8617 dump_die_list (die
->child
);
8618 if (die
->sibling
!= NULL
)
8619 dump_die_list (die
->sibling
);
8624 store_in_ref_table (unsigned int offset
, struct die_info
*die
,
8625 struct dwarf2_cu
*cu
)
8628 struct die_info
*old
;
8630 h
= (offset
% REF_HASH_SIZE
);
8631 old
= cu
->die_ref_table
[h
];
8632 die
->next_ref
= old
;
8633 cu
->die_ref_table
[h
] = die
;
8637 dwarf2_get_ref_die_offset (struct attribute
*attr
, struct dwarf2_cu
*cu
)
8639 unsigned int result
= 0;
8643 case DW_FORM_ref_addr
:
8648 case DW_FORM_ref_udata
:
8649 result
= DW_ADDR (attr
);
8652 complaint (&symfile_complaints
,
8653 _("unsupported die ref attribute form: '%s'"),
8654 dwarf_form_name (attr
->form
));
8659 /* Return the constant value held by the given attribute. Return -1
8660 if the value held by the attribute is not constant. */
8663 dwarf2_get_attr_constant_value (struct attribute
*attr
, int default_value
)
8665 if (attr
->form
== DW_FORM_sdata
)
8666 return DW_SND (attr
);
8667 else if (attr
->form
== DW_FORM_udata
8668 || attr
->form
== DW_FORM_data1
8669 || attr
->form
== DW_FORM_data2
8670 || attr
->form
== DW_FORM_data4
8671 || attr
->form
== DW_FORM_data8
)
8672 return DW_UNSND (attr
);
8675 complaint (&symfile_complaints
, _("Attribute value is not a constant (%s)"),
8676 dwarf_form_name (attr
->form
));
8677 return default_value
;
8681 static struct die_info
*
8682 follow_die_ref (struct die_info
*src_die
, struct attribute
*attr
,
8683 struct dwarf2_cu
*cu
)
8685 struct die_info
*die
;
8686 unsigned int offset
;
8688 struct die_info temp_die
;
8689 struct dwarf2_cu
*target_cu
;
8691 offset
= dwarf2_get_ref_die_offset (attr
, cu
);
8693 if (DW_ADDR (attr
) < cu
->header
.offset
8694 || DW_ADDR (attr
) >= cu
->header
.offset
+ cu
->header
.length
)
8696 struct dwarf2_per_cu_data
*per_cu
;
8697 per_cu
= dwarf2_find_containing_comp_unit (DW_ADDR (attr
),
8699 target_cu
= per_cu
->cu
;
8704 h
= (offset
% REF_HASH_SIZE
);
8705 die
= target_cu
->die_ref_table
[h
];
8708 if (die
->offset
== offset
)
8710 die
= die
->next_ref
;
8713 error (_("Dwarf Error: Cannot find DIE at 0x%lx referenced from DIE "
8714 "at 0x%lx [in module %s]"),
8715 (long) src_die
->offset
, (long) offset
, cu
->objfile
->name
);
8720 static struct type
*
8721 dwarf2_fundamental_type (struct objfile
*objfile
, int typeid,
8722 struct dwarf2_cu
*cu
)
8724 if (typeid < 0 || typeid >= FT_NUM_MEMBERS
)
8726 error (_("Dwarf Error: internal error - invalid fundamental type id %d [in module %s]"),
8727 typeid, objfile
->name
);
8730 /* Look for this particular type in the fundamental type vector. If
8731 one is not found, create and install one appropriate for the
8732 current language and the current target machine. */
8734 if (cu
->ftypes
[typeid] == NULL
)
8736 cu
->ftypes
[typeid] = cu
->language_defn
->la_fund_type (objfile
, typeid);
8739 return (cu
->ftypes
[typeid]);
8742 /* Decode simple location descriptions.
8743 Given a pointer to a dwarf block that defines a location, compute
8744 the location and return the value.
8746 NOTE drow/2003-11-18: This function is called in two situations
8747 now: for the address of static or global variables (partial symbols
8748 only) and for offsets into structures which are expected to be
8749 (more or less) constant. The partial symbol case should go away,
8750 and only the constant case should remain. That will let this
8751 function complain more accurately. A few special modes are allowed
8752 without complaint for global variables (for instance, global
8753 register values and thread-local values).
8755 A location description containing no operations indicates that the
8756 object is optimized out. The return value is 0 for that case.
8757 FIXME drow/2003-11-16: No callers check for this case any more; soon all
8758 callers will only want a very basic result and this can become a
8761 Note that stack[0] is unused except as a default error return.
8762 Note that stack overflow is not yet handled. */
8765 decode_locdesc (struct dwarf_block
*blk
, struct dwarf2_cu
*cu
)
8767 struct objfile
*objfile
= cu
->objfile
;
8768 struct comp_unit_head
*cu_header
= &cu
->header
;
8770 int size
= blk
->size
;
8771 gdb_byte
*data
= blk
->data
;
8772 CORE_ADDR stack
[64];
8774 unsigned int bytes_read
, unsnd
;
8818 stack
[++stacki
] = op
- DW_OP_lit0
;
8853 stack
[++stacki
] = op
- DW_OP_reg0
;
8855 dwarf2_complex_location_expr_complaint ();
8859 unsnd
= read_unsigned_leb128 (NULL
, (data
+ i
), &bytes_read
);
8861 stack
[++stacki
] = unsnd
;
8863 dwarf2_complex_location_expr_complaint ();
8867 stack
[++stacki
] = read_address (objfile
->obfd
, &data
[i
],
8873 stack
[++stacki
] = read_1_byte (objfile
->obfd
, &data
[i
]);
8878 stack
[++stacki
] = read_1_signed_byte (objfile
->obfd
, &data
[i
]);
8883 stack
[++stacki
] = read_2_bytes (objfile
->obfd
, &data
[i
]);
8888 stack
[++stacki
] = read_2_signed_bytes (objfile
->obfd
, &data
[i
]);
8893 stack
[++stacki
] = read_4_bytes (objfile
->obfd
, &data
[i
]);
8898 stack
[++stacki
] = read_4_signed_bytes (objfile
->obfd
, &data
[i
]);
8903 stack
[++stacki
] = read_unsigned_leb128 (NULL
, (data
+ i
),
8909 stack
[++stacki
] = read_signed_leb128 (NULL
, (data
+ i
), &bytes_read
);
8914 stack
[stacki
+ 1] = stack
[stacki
];
8919 stack
[stacki
- 1] += stack
[stacki
];
8923 case DW_OP_plus_uconst
:
8924 stack
[stacki
] += read_unsigned_leb128 (NULL
, (data
+ i
), &bytes_read
);
8929 stack
[stacki
- 1] -= stack
[stacki
];
8934 /* If we're not the last op, then we definitely can't encode
8935 this using GDB's address_class enum. This is valid for partial
8936 global symbols, although the variable's address will be bogus
8939 dwarf2_complex_location_expr_complaint ();
8942 case DW_OP_GNU_push_tls_address
:
8943 /* The top of the stack has the offset from the beginning
8944 of the thread control block at which the variable is located. */
8945 /* Nothing should follow this operator, so the top of stack would
8947 /* This is valid for partial global symbols, but the variable's
8948 address will be bogus in the psymtab. */
8950 dwarf2_complex_location_expr_complaint ();
8954 complaint (&symfile_complaints
, _("unsupported stack op: '%s'"),
8955 dwarf_stack_op_name (op
));
8956 return (stack
[stacki
]);
8959 return (stack
[stacki
]);
8962 /* memory allocation interface */
8964 static struct dwarf_block
*
8965 dwarf_alloc_block (struct dwarf2_cu
*cu
)
8967 struct dwarf_block
*blk
;
8969 blk
= (struct dwarf_block
*)
8970 obstack_alloc (&cu
->comp_unit_obstack
, sizeof (struct dwarf_block
));
8974 static struct abbrev_info
*
8975 dwarf_alloc_abbrev (struct dwarf2_cu
*cu
)
8977 struct abbrev_info
*abbrev
;
8979 abbrev
= (struct abbrev_info
*)
8980 obstack_alloc (&cu
->abbrev_obstack
, sizeof (struct abbrev_info
));
8981 memset (abbrev
, 0, sizeof (struct abbrev_info
));
8985 static struct die_info
*
8986 dwarf_alloc_die (void)
8988 struct die_info
*die
;
8990 die
= (struct die_info
*) xmalloc (sizeof (struct die_info
));
8991 memset (die
, 0, sizeof (struct die_info
));
8996 /* Macro support. */
8999 /* Return the full name of file number I in *LH's file name table.
9000 Use COMP_DIR as the name of the current directory of the
9001 compilation. The result is allocated using xmalloc; the caller is
9002 responsible for freeing it. */
9004 file_full_name (int file
, struct line_header
*lh
, const char *comp_dir
)
9006 /* Is the file number a valid index into the line header's file name
9007 table? Remember that file numbers start with one, not zero. */
9008 if (1 <= file
&& file
<= lh
->num_file_names
)
9010 struct file_entry
*fe
= &lh
->file_names
[file
- 1];
9012 if (IS_ABSOLUTE_PATH (fe
->name
))
9013 return xstrdup (fe
->name
);
9021 dir
= lh
->include_dirs
[fe
->dir_index
- 1];
9027 dir_len
= strlen (dir
);
9028 full_name
= xmalloc (dir_len
+ 1 + strlen (fe
->name
) + 1);
9029 strcpy (full_name
, dir
);
9030 full_name
[dir_len
] = '/';
9031 strcpy (full_name
+ dir_len
+ 1, fe
->name
);
9035 return xstrdup (fe
->name
);
9040 /* The compiler produced a bogus file number. We can at least
9041 record the macro definitions made in the file, even if we
9042 won't be able to find the file by name. */
9044 sprintf (fake_name
, "<bad macro file number %d>", file
);
9046 complaint (&symfile_complaints
,
9047 _("bad file number in macro information (%d)"),
9050 return xstrdup (fake_name
);
9055 static struct macro_source_file
*
9056 macro_start_file (int file
, int line
,
9057 struct macro_source_file
*current_file
,
9058 const char *comp_dir
,
9059 struct line_header
*lh
, struct objfile
*objfile
)
9061 /* The full name of this source file. */
9062 char *full_name
= file_full_name (file
, lh
, comp_dir
);
9064 /* We don't create a macro table for this compilation unit
9065 at all until we actually get a filename. */
9066 if (! pending_macros
)
9067 pending_macros
= new_macro_table (&objfile
->objfile_obstack
,
9068 objfile
->macro_cache
);
9071 /* If we have no current file, then this must be the start_file
9072 directive for the compilation unit's main source file. */
9073 current_file
= macro_set_main (pending_macros
, full_name
);
9075 current_file
= macro_include (current_file
, line
, full_name
);
9079 return current_file
;
9083 /* Copy the LEN characters at BUF to a xmalloc'ed block of memory,
9084 followed by a null byte. */
9086 copy_string (const char *buf
, int len
)
9088 char *s
= xmalloc (len
+ 1);
9089 memcpy (s
, buf
, len
);
9097 consume_improper_spaces (const char *p
, const char *body
)
9101 complaint (&symfile_complaints
,
9102 _("macro definition contains spaces in formal argument list:\n`%s'"),
9114 parse_macro_definition (struct macro_source_file
*file
, int line
,
9119 /* The body string takes one of two forms. For object-like macro
9120 definitions, it should be:
9122 <macro name> " " <definition>
9124 For function-like macro definitions, it should be:
9126 <macro name> "() " <definition>
9128 <macro name> "(" <arg name> ( "," <arg name> ) * ") " <definition>
9130 Spaces may appear only where explicitly indicated, and in the
9133 The Dwarf 2 spec says that an object-like macro's name is always
9134 followed by a space, but versions of GCC around March 2002 omit
9135 the space when the macro's definition is the empty string.
9137 The Dwarf 2 spec says that there should be no spaces between the
9138 formal arguments in a function-like macro's formal argument list,
9139 but versions of GCC around March 2002 include spaces after the
9143 /* Find the extent of the macro name. The macro name is terminated
9144 by either a space or null character (for an object-like macro) or
9145 an opening paren (for a function-like macro). */
9146 for (p
= body
; *p
; p
++)
9147 if (*p
== ' ' || *p
== '(')
9150 if (*p
== ' ' || *p
== '\0')
9152 /* It's an object-like macro. */
9153 int name_len
= p
- body
;
9154 char *name
= copy_string (body
, name_len
);
9155 const char *replacement
;
9158 replacement
= body
+ name_len
+ 1;
9161 dwarf2_macro_malformed_definition_complaint (body
);
9162 replacement
= body
+ name_len
;
9165 macro_define_object (file
, line
, name
, replacement
);
9171 /* It's a function-like macro. */
9172 char *name
= copy_string (body
, p
- body
);
9175 char **argv
= xmalloc (argv_size
* sizeof (*argv
));
9179 p
= consume_improper_spaces (p
, body
);
9181 /* Parse the formal argument list. */
9182 while (*p
&& *p
!= ')')
9184 /* Find the extent of the current argument name. */
9185 const char *arg_start
= p
;
9187 while (*p
&& *p
!= ',' && *p
!= ')' && *p
!= ' ')
9190 if (! *p
|| p
== arg_start
)
9191 dwarf2_macro_malformed_definition_complaint (body
);
9194 /* Make sure argv has room for the new argument. */
9195 if (argc
>= argv_size
)
9198 argv
= xrealloc (argv
, argv_size
* sizeof (*argv
));
9201 argv
[argc
++] = copy_string (arg_start
, p
- arg_start
);
9204 p
= consume_improper_spaces (p
, body
);
9206 /* Consume the comma, if present. */
9211 p
= consume_improper_spaces (p
, body
);
9220 /* Perfectly formed definition, no complaints. */
9221 macro_define_function (file
, line
, name
,
9222 argc
, (const char **) argv
,
9224 else if (*p
== '\0')
9226 /* Complain, but do define it. */
9227 dwarf2_macro_malformed_definition_complaint (body
);
9228 macro_define_function (file
, line
, name
,
9229 argc
, (const char **) argv
,
9233 /* Just complain. */
9234 dwarf2_macro_malformed_definition_complaint (body
);
9237 /* Just complain. */
9238 dwarf2_macro_malformed_definition_complaint (body
);
9244 for (i
= 0; i
< argc
; i
++)
9250 dwarf2_macro_malformed_definition_complaint (body
);
9255 dwarf_decode_macros (struct line_header
*lh
, unsigned int offset
,
9256 char *comp_dir
, bfd
*abfd
,
9257 struct dwarf2_cu
*cu
)
9259 gdb_byte
*mac_ptr
, *mac_end
;
9260 struct macro_source_file
*current_file
= 0;
9262 if (dwarf2_per_objfile
->macinfo_buffer
== NULL
)
9264 complaint (&symfile_complaints
, _("missing .debug_macinfo section"));
9268 mac_ptr
= dwarf2_per_objfile
->macinfo_buffer
+ offset
;
9269 mac_end
= dwarf2_per_objfile
->macinfo_buffer
9270 + dwarf2_per_objfile
->macinfo_size
;
9274 enum dwarf_macinfo_record_type macinfo_type
;
9276 /* Do we at least have room for a macinfo type byte? */
9277 if (mac_ptr
>= mac_end
)
9279 dwarf2_macros_too_long_complaint ();
9283 macinfo_type
= read_1_byte (abfd
, mac_ptr
);
9286 switch (macinfo_type
)
9288 /* A zero macinfo type indicates the end of the macro
9293 case DW_MACINFO_define
:
9294 case DW_MACINFO_undef
:
9296 unsigned int bytes_read
;
9300 line
= read_unsigned_leb128 (abfd
, mac_ptr
, &bytes_read
);
9301 mac_ptr
+= bytes_read
;
9302 body
= read_string (abfd
, mac_ptr
, &bytes_read
);
9303 mac_ptr
+= bytes_read
;
9306 complaint (&symfile_complaints
,
9307 _("debug info gives macro %s outside of any file: %s"),
9309 DW_MACINFO_define
? "definition" : macinfo_type
==
9310 DW_MACINFO_undef
? "undefinition" :
9311 "something-or-other", body
);
9314 if (macinfo_type
== DW_MACINFO_define
)
9315 parse_macro_definition (current_file
, line
, body
);
9316 else if (macinfo_type
== DW_MACINFO_undef
)
9317 macro_undef (current_file
, line
, body
);
9322 case DW_MACINFO_start_file
:
9324 unsigned int bytes_read
;
9327 line
= read_unsigned_leb128 (abfd
, mac_ptr
, &bytes_read
);
9328 mac_ptr
+= bytes_read
;
9329 file
= read_unsigned_leb128 (abfd
, mac_ptr
, &bytes_read
);
9330 mac_ptr
+= bytes_read
;
9332 current_file
= macro_start_file (file
, line
,
9333 current_file
, comp_dir
,
9338 case DW_MACINFO_end_file
:
9340 complaint (&symfile_complaints
,
9341 _("macro debug info has an unmatched `close_file' directive"));
9344 current_file
= current_file
->included_by
;
9347 enum dwarf_macinfo_record_type next_type
;
9349 /* GCC circa March 2002 doesn't produce the zero
9350 type byte marking the end of the compilation
9351 unit. Complain if it's not there, but exit no
9354 /* Do we at least have room for a macinfo type byte? */
9355 if (mac_ptr
>= mac_end
)
9357 dwarf2_macros_too_long_complaint ();
9361 /* We don't increment mac_ptr here, so this is just
9363 next_type
= read_1_byte (abfd
, mac_ptr
);
9365 complaint (&symfile_complaints
,
9366 _("no terminating 0-type entry for macros in `.debug_macinfo' section"));
9373 case DW_MACINFO_vendor_ext
:
9375 unsigned int bytes_read
;
9379 constant
= read_unsigned_leb128 (abfd
, mac_ptr
, &bytes_read
);
9380 mac_ptr
+= bytes_read
;
9381 string
= read_string (abfd
, mac_ptr
, &bytes_read
);
9382 mac_ptr
+= bytes_read
;
9384 /* We don't recognize any vendor extensions. */
9391 /* Check if the attribute's form is a DW_FORM_block*
9392 if so return true else false. */
9394 attr_form_is_block (struct attribute
*attr
)
9396 return (attr
== NULL
? 0 :
9397 attr
->form
== DW_FORM_block1
9398 || attr
->form
== DW_FORM_block2
9399 || attr
->form
== DW_FORM_block4
9400 || attr
->form
== DW_FORM_block
);
9404 dwarf2_symbol_mark_computed (struct attribute
*attr
, struct symbol
*sym
,
9405 struct dwarf2_cu
*cu
)
9407 if ((attr
->form
== DW_FORM_data4
|| attr
->form
== DW_FORM_data8
)
9408 /* ".debug_loc" may not exist at all, or the offset may be outside
9409 the section. If so, fall through to the complaint in the
9411 && DW_UNSND (attr
) < dwarf2_per_objfile
->loc_size
)
9413 struct dwarf2_loclist_baton
*baton
;
9415 baton
= obstack_alloc (&cu
->objfile
->objfile_obstack
,
9416 sizeof (struct dwarf2_loclist_baton
));
9417 baton
->objfile
= cu
->objfile
;
9419 /* We don't know how long the location list is, but make sure we
9420 don't run off the edge of the section. */
9421 baton
->size
= dwarf2_per_objfile
->loc_size
- DW_UNSND (attr
);
9422 baton
->data
= dwarf2_per_objfile
->loc_buffer
+ DW_UNSND (attr
);
9423 baton
->base_address
= cu
->header
.base_address
;
9424 if (cu
->header
.base_known
== 0)
9425 complaint (&symfile_complaints
,
9426 _("Location list used without specifying the CU base address."));
9428 SYMBOL_OPS (sym
) = &dwarf2_loclist_funcs
;
9429 SYMBOL_LOCATION_BATON (sym
) = baton
;
9433 struct dwarf2_locexpr_baton
*baton
;
9435 baton
= obstack_alloc (&cu
->objfile
->objfile_obstack
,
9436 sizeof (struct dwarf2_locexpr_baton
));
9437 baton
->objfile
= cu
->objfile
;
9439 if (attr_form_is_block (attr
))
9441 /* Note that we're just copying the block's data pointer
9442 here, not the actual data. We're still pointing into the
9443 info_buffer for SYM's objfile; right now we never release
9444 that buffer, but when we do clean up properly this may
9446 baton
->size
= DW_BLOCK (attr
)->size
;
9447 baton
->data
= DW_BLOCK (attr
)->data
;
9451 dwarf2_invalid_attrib_class_complaint ("location description",
9452 SYMBOL_NATURAL_NAME (sym
));
9457 SYMBOL_OPS (sym
) = &dwarf2_locexpr_funcs
;
9458 SYMBOL_LOCATION_BATON (sym
) = baton
;
9462 /* Locate the compilation unit from CU's objfile which contains the
9463 DIE at OFFSET. Raises an error on failure. */
9465 static struct dwarf2_per_cu_data
*
9466 dwarf2_find_containing_comp_unit (unsigned long offset
,
9467 struct objfile
*objfile
)
9469 struct dwarf2_per_cu_data
*this_cu
;
9473 high
= dwarf2_per_objfile
->n_comp_units
- 1;
9476 int mid
= low
+ (high
- low
) / 2;
9477 if (dwarf2_per_objfile
->all_comp_units
[mid
]->offset
>= offset
)
9482 gdb_assert (low
== high
);
9483 if (dwarf2_per_objfile
->all_comp_units
[low
]->offset
> offset
)
9486 error (_("Dwarf Error: could not find partial DIE containing "
9487 "offset 0x%lx [in module %s]"),
9488 (long) offset
, bfd_get_filename (objfile
->obfd
));
9490 gdb_assert (dwarf2_per_objfile
->all_comp_units
[low
-1]->offset
<= offset
);
9491 return dwarf2_per_objfile
->all_comp_units
[low
-1];
9495 this_cu
= dwarf2_per_objfile
->all_comp_units
[low
];
9496 if (low
== dwarf2_per_objfile
->n_comp_units
- 1
9497 && offset
>= this_cu
->offset
+ this_cu
->length
)
9498 error (_("invalid dwarf2 offset %ld"), offset
);
9499 gdb_assert (offset
< this_cu
->offset
+ this_cu
->length
);
9504 /* Locate the compilation unit from OBJFILE which is located at exactly
9505 OFFSET. Raises an error on failure. */
9507 static struct dwarf2_per_cu_data
*
9508 dwarf2_find_comp_unit (unsigned long offset
, struct objfile
*objfile
)
9510 struct dwarf2_per_cu_data
*this_cu
;
9511 this_cu
= dwarf2_find_containing_comp_unit (offset
, objfile
);
9512 if (this_cu
->offset
!= offset
)
9513 error (_("no compilation unit with offset %ld."), offset
);
9517 /* Release one cached compilation unit, CU. We unlink it from the tree
9518 of compilation units, but we don't remove it from the read_in_chain;
9519 the caller is responsible for that. */
9522 free_one_comp_unit (void *data
)
9524 struct dwarf2_cu
*cu
= data
;
9526 if (cu
->per_cu
!= NULL
)
9527 cu
->per_cu
->cu
= NULL
;
9530 obstack_free (&cu
->comp_unit_obstack
, NULL
);
9532 free_die_list (cu
->dies
);
9537 /* This cleanup function is passed the address of a dwarf2_cu on the stack
9538 when we're finished with it. We can't free the pointer itself, but be
9539 sure to unlink it from the cache. Also release any associated storage
9540 and perform cache maintenance.
9542 Only used during partial symbol parsing. */
9545 free_stack_comp_unit (void *data
)
9547 struct dwarf2_cu
*cu
= data
;
9549 obstack_free (&cu
->comp_unit_obstack
, NULL
);
9550 cu
->partial_dies
= NULL
;
9552 if (cu
->per_cu
!= NULL
)
9554 /* This compilation unit is on the stack in our caller, so we
9555 should not xfree it. Just unlink it. */
9556 cu
->per_cu
->cu
= NULL
;
9559 /* If we had a per-cu pointer, then we may have other compilation
9560 units loaded, so age them now. */
9561 age_cached_comp_units ();
9565 /* Free all cached compilation units. */
9568 free_cached_comp_units (void *data
)
9570 struct dwarf2_per_cu_data
*per_cu
, **last_chain
;
9572 per_cu
= dwarf2_per_objfile
->read_in_chain
;
9573 last_chain
= &dwarf2_per_objfile
->read_in_chain
;
9574 while (per_cu
!= NULL
)
9576 struct dwarf2_per_cu_data
*next_cu
;
9578 next_cu
= per_cu
->cu
->read_in_chain
;
9580 free_one_comp_unit (per_cu
->cu
);
9581 *last_chain
= next_cu
;
9587 /* Increase the age counter on each cached compilation unit, and free
9588 any that are too old. */
9591 age_cached_comp_units (void)
9593 struct dwarf2_per_cu_data
*per_cu
, **last_chain
;
9595 dwarf2_clear_marks (dwarf2_per_objfile
->read_in_chain
);
9596 per_cu
= dwarf2_per_objfile
->read_in_chain
;
9597 while (per_cu
!= NULL
)
9599 per_cu
->cu
->last_used
++;
9600 if (per_cu
->cu
->last_used
<= dwarf2_max_cache_age
)
9601 dwarf2_mark (per_cu
->cu
);
9602 per_cu
= per_cu
->cu
->read_in_chain
;
9605 per_cu
= dwarf2_per_objfile
->read_in_chain
;
9606 last_chain
= &dwarf2_per_objfile
->read_in_chain
;
9607 while (per_cu
!= NULL
)
9609 struct dwarf2_per_cu_data
*next_cu
;
9611 next_cu
= per_cu
->cu
->read_in_chain
;
9613 if (!per_cu
->cu
->mark
)
9615 free_one_comp_unit (per_cu
->cu
);
9616 *last_chain
= next_cu
;
9619 last_chain
= &per_cu
->cu
->read_in_chain
;
9625 /* Remove a single compilation unit from the cache. */
9628 free_one_cached_comp_unit (void *target_cu
)
9630 struct dwarf2_per_cu_data
*per_cu
, **last_chain
;
9632 per_cu
= dwarf2_per_objfile
->read_in_chain
;
9633 last_chain
= &dwarf2_per_objfile
->read_in_chain
;
9634 while (per_cu
!= NULL
)
9636 struct dwarf2_per_cu_data
*next_cu
;
9638 next_cu
= per_cu
->cu
->read_in_chain
;
9640 if (per_cu
->cu
== target_cu
)
9642 free_one_comp_unit (per_cu
->cu
);
9643 *last_chain
= next_cu
;
9647 last_chain
= &per_cu
->cu
->read_in_chain
;
9653 /* A pair of DIE offset and GDB type pointer. We store these
9654 in a hash table separate from the DIEs, and preserve them
9655 when the DIEs are flushed out of cache. */
9657 struct dwarf2_offset_and_type
9659 unsigned int offset
;
9663 /* Hash function for a dwarf2_offset_and_type. */
9666 offset_and_type_hash (const void *item
)
9668 const struct dwarf2_offset_and_type
*ofs
= item
;
9672 /* Equality function for a dwarf2_offset_and_type. */
9675 offset_and_type_eq (const void *item_lhs
, const void *item_rhs
)
9677 const struct dwarf2_offset_and_type
*ofs_lhs
= item_lhs
;
9678 const struct dwarf2_offset_and_type
*ofs_rhs
= item_rhs
;
9679 return ofs_lhs
->offset
== ofs_rhs
->offset
;
9682 /* Set the type associated with DIE to TYPE. Save it in CU's hash
9683 table if necessary. */
9686 set_die_type (struct die_info
*die
, struct type
*type
, struct dwarf2_cu
*cu
)
9688 struct dwarf2_offset_and_type
**slot
, ofs
;
9692 if (cu
->per_cu
== NULL
)
9695 if (cu
->per_cu
->type_hash
== NULL
)
9696 cu
->per_cu
->type_hash
9697 = htab_create_alloc_ex (cu
->header
.length
/ 24,
9698 offset_and_type_hash
,
9701 &cu
->objfile
->objfile_obstack
,
9702 hashtab_obstack_allocate
,
9703 dummy_obstack_deallocate
);
9705 ofs
.offset
= die
->offset
;
9707 slot
= (struct dwarf2_offset_and_type
**)
9708 htab_find_slot_with_hash (cu
->per_cu
->type_hash
, &ofs
, ofs
.offset
, INSERT
);
9709 *slot
= obstack_alloc (&cu
->objfile
->objfile_obstack
, sizeof (**slot
));
9713 /* Find the type for DIE in TYPE_HASH, or return NULL if DIE does not
9714 have a saved type. */
9716 static struct type
*
9717 get_die_type (struct die_info
*die
, htab_t type_hash
)
9719 struct dwarf2_offset_and_type
*slot
, ofs
;
9721 ofs
.offset
= die
->offset
;
9722 slot
= htab_find_with_hash (type_hash
, &ofs
, ofs
.offset
);
9729 /* Restore the types of the DIE tree starting at START_DIE from the hash
9730 table saved in CU. */
9733 reset_die_and_siblings_types (struct die_info
*start_die
, struct dwarf2_cu
*cu
)
9735 struct die_info
*die
;
9737 if (cu
->per_cu
->type_hash
== NULL
)
9740 for (die
= start_die
; die
!= NULL
; die
= die
->sibling
)
9742 die
->type
= get_die_type (die
, cu
->per_cu
->type_hash
);
9743 if (die
->child
!= NULL
)
9744 reset_die_and_siblings_types (die
->child
, cu
);
9748 /* Set the mark field in CU and in every other compilation unit in the
9749 cache that we must keep because we are keeping CU. */
9751 /* Add a dependence relationship from CU to REF_PER_CU. */
9754 dwarf2_add_dependence (struct dwarf2_cu
*cu
,
9755 struct dwarf2_per_cu_data
*ref_per_cu
)
9759 if (cu
->dependencies
== NULL
)
9761 = htab_create_alloc_ex (5, htab_hash_pointer
, htab_eq_pointer
,
9762 NULL
, &cu
->comp_unit_obstack
,
9763 hashtab_obstack_allocate
,
9764 dummy_obstack_deallocate
);
9766 slot
= htab_find_slot (cu
->dependencies
, ref_per_cu
, INSERT
);
9771 /* Set the mark field in CU and in every other compilation unit in the
9772 cache that we must keep because we are keeping CU. */
9775 dwarf2_mark_helper (void **slot
, void *data
)
9777 struct dwarf2_per_cu_data
*per_cu
;
9779 per_cu
= (struct dwarf2_per_cu_data
*) *slot
;
9780 if (per_cu
->cu
->mark
)
9782 per_cu
->cu
->mark
= 1;
9784 if (per_cu
->cu
->dependencies
!= NULL
)
9785 htab_traverse (per_cu
->cu
->dependencies
, dwarf2_mark_helper
, NULL
);
9791 dwarf2_mark (struct dwarf2_cu
*cu
)
9796 if (cu
->dependencies
!= NULL
)
9797 htab_traverse (cu
->dependencies
, dwarf2_mark_helper
, NULL
);
9801 dwarf2_clear_marks (struct dwarf2_per_cu_data
*per_cu
)
9805 per_cu
->cu
->mark
= 0;
9806 per_cu
= per_cu
->cu
->read_in_chain
;
9810 /* Trivial hash function for partial_die_info: the hash value of a DIE
9811 is its offset in .debug_info for this objfile. */
9814 partial_die_hash (const void *item
)
9816 const struct partial_die_info
*part_die
= item
;
9817 return part_die
->offset
;
9820 /* Trivial comparison function for partial_die_info structures: two DIEs
9821 are equal if they have the same offset. */
9824 partial_die_eq (const void *item_lhs
, const void *item_rhs
)
9826 const struct partial_die_info
*part_die_lhs
= item_lhs
;
9827 const struct partial_die_info
*part_die_rhs
= item_rhs
;
9828 return part_die_lhs
->offset
== part_die_rhs
->offset
;
9831 static struct cmd_list_element
*set_dwarf2_cmdlist
;
9832 static struct cmd_list_element
*show_dwarf2_cmdlist
;
9835 set_dwarf2_cmd (char *args
, int from_tty
)
9837 help_list (set_dwarf2_cmdlist
, "maintenance set dwarf2 ", -1, gdb_stdout
);
9841 show_dwarf2_cmd (char *args
, int from_tty
)
9843 cmd_show_list (show_dwarf2_cmdlist
, from_tty
, "");
9846 void _initialize_dwarf2_read (void);
9849 _initialize_dwarf2_read (void)
9851 dwarf2_objfile_data_key
= register_objfile_data ();
9853 add_prefix_cmd ("dwarf2", class_maintenance
, set_dwarf2_cmd
, _("\
9854 Set DWARF 2 specific variables.\n\
9855 Configure DWARF 2 variables such as the cache size"),
9856 &set_dwarf2_cmdlist
, "maintenance set dwarf2 ",
9857 0/*allow-unknown*/, &maintenance_set_cmdlist
);
9859 add_prefix_cmd ("dwarf2", class_maintenance
, show_dwarf2_cmd
, _("\
9860 Show DWARF 2 specific variables\n\
9861 Show DWARF 2 variables such as the cache size"),
9862 &show_dwarf2_cmdlist
, "maintenance show dwarf2 ",
9863 0/*allow-unknown*/, &maintenance_show_cmdlist
);
9865 add_setshow_zinteger_cmd ("max-cache-age", class_obscure
,
9866 &dwarf2_max_cache_age
, _("\
9867 Set the upper bound on the age of cached dwarf2 compilation units."), _("\
9868 Show the upper bound on the age of cached dwarf2 compilation units."), _("\
9869 A higher limit means that cached compilation units will be stored\n\
9870 in memory longer, and more total memory will be used. Zero disables\n\
9871 caching, which can slow down startup."),
9873 show_dwarf2_max_cache_age
,
9874 &set_dwarf2_cmdlist
,
9875 &show_dwarf2_cmdlist
);