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])))
3712 /* Called when we find the DIE that starts a structure or union scope
3713 (definition) to process all dies that define the members of the
3716 NOTE: we need to call struct_type regardless of whether or not the
3717 DIE has an at_name attribute, since it might be an anonymous
3718 structure or union. This gets the type entered into our set of
3721 However, if the structure is incomplete (an opaque struct/union)
3722 then suppress creating a symbol table entry for it since gdb only
3723 wants to find the one with the complete definition. Note that if
3724 it is complete, we just call new_symbol, which does it's own
3725 checking about whether the struct/union is anonymous or not (and
3726 suppresses creating a symbol table entry itself). */
3729 read_structure_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
3731 struct objfile
*objfile
= cu
->objfile
;
3733 struct attribute
*attr
;
3734 const char *previous_prefix
= processing_current_prefix
;
3735 struct cleanup
*back_to
= NULL
;
3740 type
= alloc_type (objfile
);
3742 INIT_CPLUS_SPECIFIC (type
);
3743 attr
= dwarf2_attr (die
, DW_AT_name
, cu
);
3744 if (attr
&& DW_STRING (attr
))
3746 if (cu
->language
== language_cplus
3747 || cu
->language
== language_java
)
3749 char *new_prefix
= determine_class_name (die
, cu
);
3750 TYPE_TAG_NAME (type
) = obsavestring (new_prefix
,
3751 strlen (new_prefix
),
3752 &objfile
->objfile_obstack
);
3753 back_to
= make_cleanup (xfree
, new_prefix
);
3754 processing_current_prefix
= new_prefix
;
3758 /* The name is already allocated along with this objfile, so
3759 we don't need to duplicate it for the type. */
3760 TYPE_TAG_NAME (type
) = DW_STRING (attr
);
3764 if (die
->tag
== DW_TAG_structure_type
)
3766 TYPE_CODE (type
) = TYPE_CODE_STRUCT
;
3768 else if (die
->tag
== DW_TAG_union_type
)
3770 TYPE_CODE (type
) = TYPE_CODE_UNION
;
3774 /* FIXME: TYPE_CODE_CLASS is currently defined to TYPE_CODE_STRUCT
3776 TYPE_CODE (type
) = TYPE_CODE_CLASS
;
3779 attr
= dwarf2_attr (die
, DW_AT_byte_size
, cu
);
3782 TYPE_LENGTH (type
) = DW_UNSND (attr
);
3786 TYPE_LENGTH (type
) = 0;
3789 if (die_is_declaration (die
, cu
))
3790 TYPE_FLAGS (type
) |= TYPE_FLAG_STUB
;
3792 /* We need to add the type field to the die immediately so we don't
3793 infinitely recurse when dealing with pointers to the structure
3794 type within the structure itself. */
3795 set_die_type (die
, type
, cu
);
3797 if (die
->child
!= NULL
&& ! die_is_declaration (die
, cu
))
3799 struct field_info fi
;
3800 struct die_info
*child_die
;
3801 struct cleanup
*back_to
= make_cleanup (null_cleanup
, NULL
);
3803 memset (&fi
, 0, sizeof (struct field_info
));
3805 child_die
= die
->child
;
3807 while (child_die
&& child_die
->tag
)
3809 if (child_die
->tag
== DW_TAG_member
3810 || child_die
->tag
== DW_TAG_variable
)
3812 /* NOTE: carlton/2002-11-05: A C++ static data member
3813 should be a DW_TAG_member that is a declaration, but
3814 all versions of G++ as of this writing (so through at
3815 least 3.2.1) incorrectly generate DW_TAG_variable
3816 tags for them instead. */
3817 dwarf2_add_field (&fi
, child_die
, cu
);
3819 else if (child_die
->tag
== DW_TAG_subprogram
)
3821 /* C++ member function. */
3822 read_type_die (child_die
, cu
);
3823 dwarf2_add_member_fn (&fi
, child_die
, type
, cu
);
3825 else if (child_die
->tag
== DW_TAG_inheritance
)
3827 /* C++ base class field. */
3828 dwarf2_add_field (&fi
, child_die
, cu
);
3830 child_die
= sibling_die (child_die
);
3833 /* Attach fields and member functions to the type. */
3835 dwarf2_attach_fields_to_type (&fi
, type
, cu
);
3838 dwarf2_attach_fn_fields_to_type (&fi
, type
, cu
);
3840 /* Get the type which refers to the base class (possibly this
3841 class itself) which contains the vtable pointer for the current
3842 class from the DW_AT_containing_type attribute. */
3844 if (dwarf2_attr (die
, DW_AT_containing_type
, cu
) != NULL
)
3846 struct type
*t
= die_containing_type (die
, cu
);
3848 TYPE_VPTR_BASETYPE (type
) = t
;
3853 /* Our own class provides vtbl ptr. */
3854 for (i
= TYPE_NFIELDS (t
) - 1;
3855 i
>= TYPE_N_BASECLASSES (t
);
3858 char *fieldname
= TYPE_FIELD_NAME (t
, i
);
3860 if (is_vtable_name (fieldname
, cu
))
3862 TYPE_VPTR_FIELDNO (type
) = i
;
3867 /* Complain if virtual function table field not found. */
3868 if (i
< TYPE_N_BASECLASSES (t
))
3869 complaint (&symfile_complaints
,
3870 _("virtual function table pointer not found when defining class '%s'"),
3871 TYPE_TAG_NAME (type
) ? TYPE_TAG_NAME (type
) :
3876 TYPE_VPTR_FIELDNO (type
) = TYPE_VPTR_FIELDNO (t
);
3879 else if (cu
->producer
3880 && strncmp (cu
->producer
,
3881 "IBM(R) XL C/C++ Advanced Edition", 32) == 0)
3883 /* The IBM XLC compiler does not provide direct indication
3884 of the containing type, but the vtable pointer is
3885 always named __vfp. */
3889 for (i
= TYPE_NFIELDS (type
) - 1;
3890 i
>= TYPE_N_BASECLASSES (type
);
3893 if (strcmp (TYPE_FIELD_NAME (type
, i
), "__vfp") == 0)
3895 TYPE_VPTR_FIELDNO (type
) = i
;
3896 TYPE_VPTR_BASETYPE (type
) = type
;
3903 do_cleanups (back_to
);
3906 processing_current_prefix
= previous_prefix
;
3907 if (back_to
!= NULL
)
3908 do_cleanups (back_to
);
3912 process_structure_scope (struct die_info
*die
, struct dwarf2_cu
*cu
)
3914 struct objfile
*objfile
= cu
->objfile
;
3915 const char *previous_prefix
= processing_current_prefix
;
3916 struct die_info
*child_die
= die
->child
;
3918 if (TYPE_TAG_NAME (die
->type
) != NULL
)
3919 processing_current_prefix
= TYPE_TAG_NAME (die
->type
);
3921 /* NOTE: carlton/2004-03-16: GCC 3.4 (or at least one of its
3922 snapshots) has been known to create a die giving a declaration
3923 for a class that has, as a child, a die giving a definition for a
3924 nested class. So we have to process our children even if the
3925 current die is a declaration. Normally, of course, a declaration
3926 won't have any children at all. */
3928 while (child_die
!= NULL
&& child_die
->tag
)
3930 if (child_die
->tag
== DW_TAG_member
3931 || child_die
->tag
== DW_TAG_variable
3932 || child_die
->tag
== DW_TAG_inheritance
)
3937 process_die (child_die
, cu
);
3939 child_die
= sibling_die (child_die
);
3942 if (die
->child
!= NULL
&& ! die_is_declaration (die
, cu
))
3943 new_symbol (die
, die
->type
, cu
);
3945 processing_current_prefix
= previous_prefix
;
3948 /* Given a DW_AT_enumeration_type die, set its type. We do not
3949 complete the type's fields yet, or create any symbols. */
3952 read_enumeration_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
3954 struct objfile
*objfile
= cu
->objfile
;
3956 struct attribute
*attr
;
3961 type
= alloc_type (objfile
);
3963 TYPE_CODE (type
) = TYPE_CODE_ENUM
;
3964 attr
= dwarf2_attr (die
, DW_AT_name
, cu
);
3965 if (attr
&& DW_STRING (attr
))
3967 char *name
= DW_STRING (attr
);
3969 if (processing_has_namespace_info
)
3971 TYPE_TAG_NAME (type
) = typename_concat (&objfile
->objfile_obstack
,
3972 processing_current_prefix
,
3977 /* The name is already allocated along with this objfile, so
3978 we don't need to duplicate it for the type. */
3979 TYPE_TAG_NAME (type
) = name
;
3983 attr
= dwarf2_attr (die
, DW_AT_byte_size
, cu
);
3986 TYPE_LENGTH (type
) = DW_UNSND (attr
);
3990 TYPE_LENGTH (type
) = 0;
3993 set_die_type (die
, type
, cu
);
3996 /* Determine the name of the type represented by DIE, which should be
3997 a named C++ or Java compound type. Return the name in question; the caller
3998 is responsible for xfree()'ing it. */
4001 determine_class_name (struct die_info
*die
, struct dwarf2_cu
*cu
)
4003 struct cleanup
*back_to
= NULL
;
4004 struct die_info
*spec_die
= die_specification (die
, cu
);
4005 char *new_prefix
= NULL
;
4007 /* If this is the definition of a class that is declared by another
4008 die, then processing_current_prefix may not be accurate; see
4009 read_func_scope for a similar example. */
4010 if (spec_die
!= NULL
)
4012 char *specification_prefix
= determine_prefix (spec_die
, cu
);
4013 processing_current_prefix
= specification_prefix
;
4014 back_to
= make_cleanup (xfree
, specification_prefix
);
4017 /* If we don't have namespace debug info, guess the name by trying
4018 to demangle the names of members, just like we did in
4019 guess_structure_name. */
4020 if (!processing_has_namespace_info
)
4022 struct die_info
*child
;
4024 for (child
= die
->child
;
4025 child
!= NULL
&& child
->tag
!= 0;
4026 child
= sibling_die (child
))
4028 if (child
->tag
== DW_TAG_subprogram
)
4031 = language_class_name_from_physname (cu
->language_defn
,
4035 if (new_prefix
!= NULL
)
4041 if (new_prefix
== NULL
)
4043 const char *name
= dwarf2_name (die
, cu
);
4044 new_prefix
= typename_concat (NULL
, processing_current_prefix
,
4045 name
? name
: "<<anonymous>>",
4049 if (back_to
!= NULL
)
4050 do_cleanups (back_to
);
4055 /* Given a pointer to a die which begins an enumeration, process all
4056 the dies that define the members of the enumeration, and create the
4057 symbol for the enumeration type.
4059 NOTE: We reverse the order of the element list. */
4062 process_enumeration_scope (struct die_info
*die
, struct dwarf2_cu
*cu
)
4064 struct objfile
*objfile
= cu
->objfile
;
4065 struct die_info
*child_die
;
4066 struct field
*fields
;
4067 struct attribute
*attr
;
4070 int unsigned_enum
= 1;
4074 if (die
->child
!= NULL
)
4076 child_die
= die
->child
;
4077 while (child_die
&& child_die
->tag
)
4079 if (child_die
->tag
!= DW_TAG_enumerator
)
4081 process_die (child_die
, cu
);
4085 attr
= dwarf2_attr (child_die
, DW_AT_name
, cu
);
4088 sym
= new_symbol (child_die
, die
->type
, cu
);
4089 if (SYMBOL_VALUE (sym
) < 0)
4092 if ((num_fields
% DW_FIELD_ALLOC_CHUNK
) == 0)
4094 fields
= (struct field
*)
4096 (num_fields
+ DW_FIELD_ALLOC_CHUNK
)
4097 * sizeof (struct field
));
4100 FIELD_NAME (fields
[num_fields
]) = DEPRECATED_SYMBOL_NAME (sym
);
4101 FIELD_TYPE (fields
[num_fields
]) = NULL
;
4102 FIELD_BITPOS (fields
[num_fields
]) = SYMBOL_VALUE (sym
);
4103 FIELD_BITSIZE (fields
[num_fields
]) = 0;
4104 FIELD_STATIC_KIND (fields
[num_fields
]) = 0;
4110 child_die
= sibling_die (child_die
);
4115 TYPE_NFIELDS (die
->type
) = num_fields
;
4116 TYPE_FIELDS (die
->type
) = (struct field
*)
4117 TYPE_ALLOC (die
->type
, sizeof (struct field
) * num_fields
);
4118 memcpy (TYPE_FIELDS (die
->type
), fields
,
4119 sizeof (struct field
) * num_fields
);
4123 TYPE_FLAGS (die
->type
) |= TYPE_FLAG_UNSIGNED
;
4126 new_symbol (die
, die
->type
, cu
);
4129 /* Extract all information from a DW_TAG_array_type DIE and put it in
4130 the DIE's type field. For now, this only handles one dimensional
4134 read_array_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
4136 struct objfile
*objfile
= cu
->objfile
;
4137 struct die_info
*child_die
;
4138 struct type
*type
= NULL
;
4139 struct type
*element_type
, *range_type
, *index_type
;
4140 struct type
**range_types
= NULL
;
4141 struct attribute
*attr
;
4143 struct cleanup
*back_to
;
4145 /* Return if we've already decoded this type. */
4151 element_type
= die_type (die
, cu
);
4153 /* Irix 6.2 native cc creates array types without children for
4154 arrays with unspecified length. */
4155 if (die
->child
== NULL
)
4157 index_type
= dwarf2_fundamental_type (objfile
, FT_INTEGER
, cu
);
4158 range_type
= create_range_type (NULL
, index_type
, 0, -1);
4159 set_die_type (die
, create_array_type (NULL
, element_type
, range_type
),
4164 back_to
= make_cleanup (null_cleanup
, NULL
);
4165 child_die
= die
->child
;
4166 while (child_die
&& child_die
->tag
)
4168 if (child_die
->tag
== DW_TAG_subrange_type
)
4170 read_subrange_type (child_die
, cu
);
4172 if (child_die
->type
!= NULL
)
4174 /* The range type was succesfully read. Save it for
4175 the array type creation. */
4176 if ((ndim
% DW_FIELD_ALLOC_CHUNK
) == 0)
4178 range_types
= (struct type
**)
4179 xrealloc (range_types
, (ndim
+ DW_FIELD_ALLOC_CHUNK
)
4180 * sizeof (struct type
*));
4182 make_cleanup (free_current_contents
, &range_types
);
4184 range_types
[ndim
++] = child_die
->type
;
4187 child_die
= sibling_die (child_die
);
4190 /* Dwarf2 dimensions are output from left to right, create the
4191 necessary array types in backwards order. */
4193 type
= element_type
;
4195 if (read_array_order (die
, cu
) == DW_ORD_col_major
)
4199 type
= create_array_type (NULL
, type
, range_types
[i
++]);
4204 type
= create_array_type (NULL
, type
, range_types
[ndim
]);
4207 /* Understand Dwarf2 support for vector types (like they occur on
4208 the PowerPC w/ AltiVec). Gcc just adds another attribute to the
4209 array type. This is not part of the Dwarf2/3 standard yet, but a
4210 custom vendor extension. The main difference between a regular
4211 array and the vector variant is that vectors are passed by value
4213 attr
= dwarf2_attr (die
, DW_AT_GNU_vector
, cu
);
4215 TYPE_FLAGS (type
) |= TYPE_FLAG_VECTOR
;
4217 do_cleanups (back_to
);
4219 /* Install the type in the die. */
4220 set_die_type (die
, type
, cu
);
4223 static enum dwarf_array_dim_ordering
4224 read_array_order (struct die_info
*die
, struct dwarf2_cu
*cu
)
4226 struct attribute
*attr
;
4228 attr
= dwarf2_attr (die
, DW_AT_ordering
, cu
);
4230 if (attr
) return DW_SND (attr
);
4233 GNU F77 is a special case, as at 08/2004 array type info is the
4234 opposite order to the dwarf2 specification, but data is still
4235 laid out as per normal fortran.
4237 FIXME: dsl/2004-8-20: If G77 is ever fixed, this will also need
4241 if (cu
->language
== language_fortran
&&
4242 cu
->producer
&& strstr (cu
->producer
, "GNU F77"))
4244 return DW_ORD_row_major
;
4247 switch (cu
->language_defn
->la_array_ordering
)
4249 case array_column_major
:
4250 return DW_ORD_col_major
;
4251 case array_row_major
:
4253 return DW_ORD_row_major
;
4257 /* Extract all information from a DW_TAG_set_type DIE and put it in
4258 the DIE's type field. */
4261 read_set_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
4263 if (die
->type
== NULL
)
4264 die
->type
= create_set_type ((struct type
*) NULL
, die_type (die
, cu
));
4267 /* First cut: install each common block member as a global variable. */
4270 read_common_block (struct die_info
*die
, struct dwarf2_cu
*cu
)
4272 struct die_info
*child_die
;
4273 struct attribute
*attr
;
4275 CORE_ADDR base
= (CORE_ADDR
) 0;
4277 attr
= dwarf2_attr (die
, DW_AT_location
, cu
);
4280 /* Support the .debug_loc offsets */
4281 if (attr_form_is_block (attr
))
4283 base
= decode_locdesc (DW_BLOCK (attr
), cu
);
4285 else if (attr
->form
== DW_FORM_data4
|| attr
->form
== DW_FORM_data8
)
4287 dwarf2_complex_location_expr_complaint ();
4291 dwarf2_invalid_attrib_class_complaint ("DW_AT_location",
4292 "common block member");
4295 if (die
->child
!= NULL
)
4297 child_die
= die
->child
;
4298 while (child_die
&& child_die
->tag
)
4300 sym
= new_symbol (child_die
, NULL
, cu
);
4301 attr
= dwarf2_attr (child_die
, DW_AT_data_member_location
, cu
);
4304 SYMBOL_VALUE_ADDRESS (sym
) =
4305 base
+ decode_locdesc (DW_BLOCK (attr
), cu
);
4306 add_symbol_to_list (sym
, &global_symbols
);
4308 child_die
= sibling_die (child_die
);
4313 /* Read a C++ namespace. */
4316 read_namespace (struct die_info
*die
, struct dwarf2_cu
*cu
)
4318 struct objfile
*objfile
= cu
->objfile
;
4319 const char *previous_prefix
= processing_current_prefix
;
4322 struct die_info
*current_die
;
4323 struct cleanup
*back_to
= make_cleanup (null_cleanup
, 0);
4325 name
= namespace_name (die
, &is_anonymous
, cu
);
4327 /* Now build the name of the current namespace. */
4329 if (previous_prefix
[0] == '\0')
4331 processing_current_prefix
= name
;
4335 char *temp_name
= typename_concat (NULL
, previous_prefix
, name
, cu
);
4336 make_cleanup (xfree
, temp_name
);
4337 processing_current_prefix
= temp_name
;
4340 /* Add a symbol associated to this if we haven't seen the namespace
4341 before. Also, add a using directive if it's an anonymous
4344 if (dwarf2_extension (die
, cu
) == NULL
)
4348 /* FIXME: carlton/2003-06-27: Once GDB is more const-correct,
4349 this cast will hopefully become unnecessary. */
4350 type
= init_type (TYPE_CODE_NAMESPACE
, 0, 0,
4351 (char *) processing_current_prefix
,
4353 TYPE_TAG_NAME (type
) = TYPE_NAME (type
);
4355 new_symbol (die
, type
, cu
);
4356 set_die_type (die
, type
, cu
);
4359 cp_add_using_directive (processing_current_prefix
,
4360 strlen (previous_prefix
),
4361 strlen (processing_current_prefix
));
4364 if (die
->child
!= NULL
)
4366 struct die_info
*child_die
= die
->child
;
4368 while (child_die
&& child_die
->tag
)
4370 process_die (child_die
, cu
);
4371 child_die
= sibling_die (child_die
);
4375 processing_current_prefix
= previous_prefix
;
4376 do_cleanups (back_to
);
4379 /* Return the name of the namespace represented by DIE. Set
4380 *IS_ANONYMOUS to tell whether or not the namespace is an anonymous
4384 namespace_name (struct die_info
*die
, int *is_anonymous
, struct dwarf2_cu
*cu
)
4386 struct die_info
*current_die
;
4387 const char *name
= NULL
;
4389 /* Loop through the extensions until we find a name. */
4391 for (current_die
= die
;
4392 current_die
!= NULL
;
4393 current_die
= dwarf2_extension (die
, cu
))
4395 name
= dwarf2_name (current_die
, cu
);
4400 /* Is it an anonymous namespace? */
4402 *is_anonymous
= (name
== NULL
);
4404 name
= "(anonymous namespace)";
4409 /* Extract all information from a DW_TAG_pointer_type DIE and add to
4410 the user defined type vector. */
4413 read_tag_pointer_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
4415 struct comp_unit_head
*cu_header
= &cu
->header
;
4417 struct attribute
*attr_byte_size
;
4418 struct attribute
*attr_address_class
;
4419 int byte_size
, addr_class
;
4426 type
= lookup_pointer_type (die_type (die
, cu
));
4428 attr_byte_size
= dwarf2_attr (die
, DW_AT_byte_size
, cu
);
4430 byte_size
= DW_UNSND (attr_byte_size
);
4432 byte_size
= cu_header
->addr_size
;
4434 attr_address_class
= dwarf2_attr (die
, DW_AT_address_class
, cu
);
4435 if (attr_address_class
)
4436 addr_class
= DW_UNSND (attr_address_class
);
4438 addr_class
= DW_ADDR_none
;
4440 /* If the pointer size or address class is different than the
4441 default, create a type variant marked as such and set the
4442 length accordingly. */
4443 if (TYPE_LENGTH (type
) != byte_size
|| addr_class
!= DW_ADDR_none
)
4445 if (ADDRESS_CLASS_TYPE_FLAGS_P ())
4449 type_flags
= ADDRESS_CLASS_TYPE_FLAGS (byte_size
, addr_class
);
4450 gdb_assert ((type_flags
& ~TYPE_FLAG_ADDRESS_CLASS_ALL
) == 0);
4451 type
= make_type_with_address_space (type
, type_flags
);
4453 else if (TYPE_LENGTH (type
) != byte_size
)
4455 complaint (&symfile_complaints
, _("invalid pointer size %d"), byte_size
);
4458 /* Should we also complain about unhandled address classes? */
4462 TYPE_LENGTH (type
) = byte_size
;
4463 set_die_type (die
, type
, cu
);
4466 /* Extract all information from a DW_TAG_ptr_to_member_type DIE and add to
4467 the user defined type vector. */
4470 read_tag_ptr_to_member_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
4472 struct objfile
*objfile
= cu
->objfile
;
4474 struct type
*to_type
;
4475 struct type
*domain
;
4482 type
= alloc_type (objfile
);
4483 to_type
= die_type (die
, cu
);
4484 domain
= die_containing_type (die
, cu
);
4485 smash_to_member_type (type
, domain
, to_type
);
4487 set_die_type (die
, type
, cu
);
4490 /* Extract all information from a DW_TAG_reference_type DIE and add to
4491 the user defined type vector. */
4494 read_tag_reference_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
4496 struct comp_unit_head
*cu_header
= &cu
->header
;
4498 struct attribute
*attr
;
4505 type
= lookup_reference_type (die_type (die
, cu
));
4506 attr
= dwarf2_attr (die
, DW_AT_byte_size
, cu
);
4509 TYPE_LENGTH (type
) = DW_UNSND (attr
);
4513 TYPE_LENGTH (type
) = cu_header
->addr_size
;
4515 set_die_type (die
, type
, cu
);
4519 read_tag_const_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
4521 struct type
*base_type
;
4528 base_type
= die_type (die
, cu
);
4529 set_die_type (die
, make_cv_type (1, TYPE_VOLATILE (base_type
), base_type
, 0),
4534 read_tag_volatile_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
4536 struct type
*base_type
;
4543 base_type
= die_type (die
, cu
);
4544 set_die_type (die
, make_cv_type (TYPE_CONST (base_type
), 1, base_type
, 0),
4548 /* Extract all information from a DW_TAG_string_type DIE and add to
4549 the user defined type vector. It isn't really a user defined type,
4550 but it behaves like one, with other DIE's using an AT_user_def_type
4551 attribute to reference it. */
4554 read_tag_string_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
4556 struct objfile
*objfile
= cu
->objfile
;
4557 struct type
*type
, *range_type
, *index_type
, *char_type
;
4558 struct attribute
*attr
;
4559 unsigned int length
;
4566 attr
= dwarf2_attr (die
, DW_AT_string_length
, cu
);
4569 length
= DW_UNSND (attr
);
4573 /* check for the DW_AT_byte_size attribute */
4574 attr
= dwarf2_attr (die
, DW_AT_byte_size
, cu
);
4577 length
= DW_UNSND (attr
);
4584 index_type
= dwarf2_fundamental_type (objfile
, FT_INTEGER
, cu
);
4585 range_type
= create_range_type (NULL
, index_type
, 1, length
);
4586 if (cu
->language
== language_fortran
)
4588 /* Need to create a unique string type for bounds
4590 type
= create_string_type (0, range_type
);
4594 char_type
= dwarf2_fundamental_type (objfile
, FT_CHAR
, cu
);
4595 type
= create_string_type (char_type
, range_type
);
4597 set_die_type (die
, type
, cu
);
4600 /* Handle DIES due to C code like:
4604 int (*funcp)(int a, long l);
4608 ('funcp' generates a DW_TAG_subroutine_type DIE)
4612 read_subroutine_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
4614 struct type
*type
; /* Type that this function returns */
4615 struct type
*ftype
; /* Function that returns above type */
4616 struct attribute
*attr
;
4618 /* Decode the type that this subroutine returns */
4623 type
= die_type (die
, cu
);
4624 ftype
= make_function_type (type
, (struct type
**) 0);
4626 /* All functions in C++ and Java have prototypes. */
4627 attr
= dwarf2_attr (die
, DW_AT_prototyped
, cu
);
4628 if ((attr
&& (DW_UNSND (attr
) != 0))
4629 || cu
->language
== language_cplus
4630 || cu
->language
== language_java
)
4631 TYPE_FLAGS (ftype
) |= TYPE_FLAG_PROTOTYPED
;
4633 if (die
->child
!= NULL
)
4635 struct die_info
*child_die
;
4639 /* Count the number of parameters.
4640 FIXME: GDB currently ignores vararg functions, but knows about
4641 vararg member functions. */
4642 child_die
= die
->child
;
4643 while (child_die
&& child_die
->tag
)
4645 if (child_die
->tag
== DW_TAG_formal_parameter
)
4647 else if (child_die
->tag
== DW_TAG_unspecified_parameters
)
4648 TYPE_FLAGS (ftype
) |= TYPE_FLAG_VARARGS
;
4649 child_die
= sibling_die (child_die
);
4652 /* Allocate storage for parameters and fill them in. */
4653 TYPE_NFIELDS (ftype
) = nparams
;
4654 TYPE_FIELDS (ftype
) = (struct field
*)
4655 TYPE_ZALLOC (ftype
, nparams
* sizeof (struct field
));
4657 child_die
= die
->child
;
4658 while (child_die
&& child_die
->tag
)
4660 if (child_die
->tag
== DW_TAG_formal_parameter
)
4662 /* Dwarf2 has no clean way to discern C++ static and non-static
4663 member functions. G++ helps GDB by marking the first
4664 parameter for non-static member functions (which is the
4665 this pointer) as artificial. We pass this information
4666 to dwarf2_add_member_fn via TYPE_FIELD_ARTIFICIAL. */
4667 attr
= dwarf2_attr (child_die
, DW_AT_artificial
, cu
);
4669 TYPE_FIELD_ARTIFICIAL (ftype
, iparams
) = DW_UNSND (attr
);
4671 TYPE_FIELD_ARTIFICIAL (ftype
, iparams
) = 0;
4672 TYPE_FIELD_TYPE (ftype
, iparams
) = die_type (child_die
, cu
);
4675 child_die
= sibling_die (child_die
);
4679 set_die_type (die
, ftype
, cu
);
4683 read_typedef (struct die_info
*die
, struct dwarf2_cu
*cu
)
4685 struct objfile
*objfile
= cu
->objfile
;
4686 struct attribute
*attr
;
4691 attr
= dwarf2_attr (die
, DW_AT_name
, cu
);
4692 if (attr
&& DW_STRING (attr
))
4694 name
= DW_STRING (attr
);
4696 set_die_type (die
, init_type (TYPE_CODE_TYPEDEF
, 0,
4697 TYPE_FLAG_TARGET_STUB
, name
, objfile
),
4699 TYPE_TARGET_TYPE (die
->type
) = die_type (die
, cu
);
4703 /* Find a representation of a given base type and install
4704 it in the TYPE field of the die. */
4707 read_base_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
4709 struct objfile
*objfile
= cu
->objfile
;
4711 struct attribute
*attr
;
4712 int encoding
= 0, size
= 0;
4714 /* If we've already decoded this die, this is a no-op. */
4720 attr
= dwarf2_attr (die
, DW_AT_encoding
, cu
);
4723 encoding
= DW_UNSND (attr
);
4725 attr
= dwarf2_attr (die
, DW_AT_byte_size
, cu
);
4728 size
= DW_UNSND (attr
);
4730 attr
= dwarf2_attr (die
, DW_AT_name
, cu
);
4731 if (attr
&& DW_STRING (attr
))
4733 enum type_code code
= TYPE_CODE_INT
;
4738 case DW_ATE_address
:
4739 /* Turn DW_ATE_address into a void * pointer. */
4740 code
= TYPE_CODE_PTR
;
4741 type_flags
|= TYPE_FLAG_UNSIGNED
;
4743 case DW_ATE_boolean
:
4744 code
= TYPE_CODE_BOOL
;
4745 type_flags
|= TYPE_FLAG_UNSIGNED
;
4747 case DW_ATE_complex_float
:
4748 code
= TYPE_CODE_COMPLEX
;
4751 code
= TYPE_CODE_FLT
;
4755 case DW_ATE_unsigned
:
4756 type_flags
|= TYPE_FLAG_UNSIGNED
;
4758 case DW_ATE_signed_char
:
4759 if (cu
->language
== language_m2
)
4760 code
= TYPE_CODE_CHAR
;
4762 case DW_ATE_unsigned_char
:
4763 if (cu
->language
== language_m2
)
4764 code
= TYPE_CODE_CHAR
;
4765 type_flags
|= TYPE_FLAG_UNSIGNED
;
4768 complaint (&symfile_complaints
, _("unsupported DW_AT_encoding: '%s'"),
4769 dwarf_type_encoding_name (encoding
));
4772 type
= init_type (code
, size
, type_flags
, DW_STRING (attr
), objfile
);
4773 if (encoding
== DW_ATE_address
)
4774 TYPE_TARGET_TYPE (type
) = dwarf2_fundamental_type (objfile
, FT_VOID
,
4776 else if (encoding
== DW_ATE_complex_float
)
4779 TYPE_TARGET_TYPE (type
)
4780 = dwarf2_fundamental_type (objfile
, FT_EXT_PREC_FLOAT
, cu
);
4781 else if (size
== 16)
4782 TYPE_TARGET_TYPE (type
)
4783 = dwarf2_fundamental_type (objfile
, FT_DBL_PREC_FLOAT
, cu
);
4785 TYPE_TARGET_TYPE (type
)
4786 = dwarf2_fundamental_type (objfile
, FT_FLOAT
, cu
);
4791 type
= dwarf_base_type (encoding
, size
, cu
);
4793 set_die_type (die
, type
, cu
);
4796 /* Read the given DW_AT_subrange DIE. */
4799 read_subrange_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
4801 struct type
*base_type
;
4802 struct type
*range_type
;
4803 struct attribute
*attr
;
4807 /* If we have already decoded this die, then nothing more to do. */
4811 base_type
= die_type (die
, cu
);
4812 if (base_type
== NULL
)
4814 complaint (&symfile_complaints
,
4815 _("DW_AT_type missing from DW_TAG_subrange_type"));
4819 if (TYPE_CODE (base_type
) == TYPE_CODE_VOID
)
4820 base_type
= alloc_type (NULL
);
4822 if (cu
->language
== language_fortran
)
4824 /* FORTRAN implies a lower bound of 1, if not given. */
4828 /* FIXME: For variable sized arrays either of these could be
4829 a variable rather than a constant value. We'll allow it,
4830 but we don't know how to handle it. */
4831 attr
= dwarf2_attr (die
, DW_AT_lower_bound
, cu
);
4833 low
= dwarf2_get_attr_constant_value (attr
, 0);
4835 attr
= dwarf2_attr (die
, DW_AT_upper_bound
, cu
);
4838 if (attr
->form
== DW_FORM_block1
)
4840 /* GCC encodes arrays with unspecified or dynamic length
4841 with a DW_FORM_block1 attribute.
4842 FIXME: GDB does not yet know how to handle dynamic
4843 arrays properly, treat them as arrays with unspecified
4846 FIXME: jimb/2003-09-22: GDB does not really know
4847 how to handle arrays of unspecified length
4848 either; we just represent them as zero-length
4849 arrays. Choose an appropriate upper bound given
4850 the lower bound we've computed above. */
4854 high
= dwarf2_get_attr_constant_value (attr
, 1);
4857 range_type
= create_range_type (NULL
, base_type
, low
, high
);
4859 attr
= dwarf2_attr (die
, DW_AT_name
, cu
);
4860 if (attr
&& DW_STRING (attr
))
4861 TYPE_NAME (range_type
) = DW_STRING (attr
);
4863 attr
= dwarf2_attr (die
, DW_AT_byte_size
, cu
);
4865 TYPE_LENGTH (range_type
) = DW_UNSND (attr
);
4867 set_die_type (die
, range_type
, cu
);
4871 read_unspecified_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
4874 struct attribute
*attr
;
4879 /* For now, we only support the C meaning of an unspecified type: void. */
4881 attr
= dwarf2_attr (die
, DW_AT_name
, cu
);
4882 type
= init_type (TYPE_CODE_VOID
, 0, 0, attr
? DW_STRING (attr
) : "",
4885 set_die_type (die
, type
, cu
);
4888 /* Read a whole compilation unit into a linked list of dies. */
4890 static struct die_info
*
4891 read_comp_unit (gdb_byte
*info_ptr
, bfd
*abfd
, struct dwarf2_cu
*cu
)
4893 return read_die_and_children (info_ptr
, abfd
, cu
, &info_ptr
, NULL
);
4896 /* Read a single die and all its descendents. Set the die's sibling
4897 field to NULL; set other fields in the die correctly, and set all
4898 of the descendents' fields correctly. Set *NEW_INFO_PTR to the
4899 location of the info_ptr after reading all of those dies. PARENT
4900 is the parent of the die in question. */
4902 static struct die_info
*
4903 read_die_and_children (gdb_byte
*info_ptr
, bfd
*abfd
,
4904 struct dwarf2_cu
*cu
,
4905 gdb_byte
**new_info_ptr
,
4906 struct die_info
*parent
)
4908 struct die_info
*die
;
4912 cur_ptr
= read_full_die (&die
, abfd
, info_ptr
, cu
, &has_children
);
4913 store_in_ref_table (die
->offset
, die
, cu
);
4917 die
->child
= read_die_and_siblings (cur_ptr
, abfd
, cu
,
4923 *new_info_ptr
= cur_ptr
;
4926 die
->sibling
= NULL
;
4927 die
->parent
= parent
;
4931 /* Read a die, all of its descendents, and all of its siblings; set
4932 all of the fields of all of the dies correctly. Arguments are as
4933 in read_die_and_children. */
4935 static struct die_info
*
4936 read_die_and_siblings (gdb_byte
*info_ptr
, bfd
*abfd
,
4937 struct dwarf2_cu
*cu
,
4938 gdb_byte
**new_info_ptr
,
4939 struct die_info
*parent
)
4941 struct die_info
*first_die
, *last_sibling
;
4945 first_die
= last_sibling
= NULL
;
4949 struct die_info
*die
4950 = read_die_and_children (cur_ptr
, abfd
, cu
, &cur_ptr
, parent
);
4958 last_sibling
->sibling
= die
;
4963 *new_info_ptr
= cur_ptr
;
4973 /* Free a linked list of dies. */
4976 free_die_list (struct die_info
*dies
)
4978 struct die_info
*die
, *next
;
4983 if (die
->child
!= NULL
)
4984 free_die_list (die
->child
);
4985 next
= die
->sibling
;
4992 /* Read the contents of the section at OFFSET and of size SIZE from the
4993 object file specified by OBJFILE into the objfile_obstack and return it. */
4996 dwarf2_read_section (struct objfile
*objfile
, asection
*sectp
)
4998 bfd
*abfd
= objfile
->obfd
;
4999 gdb_byte
*buf
, *retbuf
;
5000 bfd_size_type size
= bfd_get_section_size (sectp
);
5005 buf
= obstack_alloc (&objfile
->objfile_obstack
, size
);
5006 retbuf
= symfile_relocate_debug_section (abfd
, sectp
, buf
);
5010 if (bfd_seek (abfd
, sectp
->filepos
, SEEK_SET
) != 0
5011 || bfd_bread (buf
, size
, abfd
) != size
)
5012 error (_("Dwarf Error: Can't read DWARF data from '%s'"),
5013 bfd_get_filename (abfd
));
5018 /* In DWARF version 2, the description of the debugging information is
5019 stored in a separate .debug_abbrev section. Before we read any
5020 dies from a section we read in all abbreviations and install them
5021 in a hash table. This function also sets flags in CU describing
5022 the data found in the abbrev table. */
5025 dwarf2_read_abbrevs (bfd
*abfd
, struct dwarf2_cu
*cu
)
5027 struct comp_unit_head
*cu_header
= &cu
->header
;
5028 gdb_byte
*abbrev_ptr
;
5029 struct abbrev_info
*cur_abbrev
;
5030 unsigned int abbrev_number
, bytes_read
, abbrev_name
;
5031 unsigned int abbrev_form
, hash_number
;
5032 struct attr_abbrev
*cur_attrs
;
5033 unsigned int allocated_attrs
;
5035 /* Initialize dwarf2 abbrevs */
5036 obstack_init (&cu
->abbrev_obstack
);
5037 cu
->dwarf2_abbrevs
= obstack_alloc (&cu
->abbrev_obstack
,
5039 * sizeof (struct abbrev_info
*)));
5040 memset (cu
->dwarf2_abbrevs
, 0,
5041 ABBREV_HASH_SIZE
* sizeof (struct abbrev_info
*));
5043 abbrev_ptr
= dwarf2_per_objfile
->abbrev_buffer
+ cu_header
->abbrev_offset
;
5044 abbrev_number
= read_unsigned_leb128 (abfd
, abbrev_ptr
, &bytes_read
);
5045 abbrev_ptr
+= bytes_read
;
5047 allocated_attrs
= ATTR_ALLOC_CHUNK
;
5048 cur_attrs
= xmalloc (allocated_attrs
* sizeof (struct attr_abbrev
));
5050 /* loop until we reach an abbrev number of 0 */
5051 while (abbrev_number
)
5053 cur_abbrev
= dwarf_alloc_abbrev (cu
);
5055 /* read in abbrev header */
5056 cur_abbrev
->number
= abbrev_number
;
5057 cur_abbrev
->tag
= read_unsigned_leb128 (abfd
, abbrev_ptr
, &bytes_read
);
5058 abbrev_ptr
+= bytes_read
;
5059 cur_abbrev
->has_children
= read_1_byte (abfd
, abbrev_ptr
);
5062 if (cur_abbrev
->tag
== DW_TAG_namespace
)
5063 cu
->has_namespace_info
= 1;
5065 /* now read in declarations */
5066 abbrev_name
= read_unsigned_leb128 (abfd
, abbrev_ptr
, &bytes_read
);
5067 abbrev_ptr
+= bytes_read
;
5068 abbrev_form
= read_unsigned_leb128 (abfd
, abbrev_ptr
, &bytes_read
);
5069 abbrev_ptr
+= bytes_read
;
5072 if (cur_abbrev
->num_attrs
== allocated_attrs
)
5074 allocated_attrs
+= ATTR_ALLOC_CHUNK
;
5076 = xrealloc (cur_attrs
, (allocated_attrs
5077 * sizeof (struct attr_abbrev
)));
5080 /* Record whether this compilation unit might have
5081 inter-compilation-unit references. If we don't know what form
5082 this attribute will have, then it might potentially be a
5083 DW_FORM_ref_addr, so we conservatively expect inter-CU
5086 if (abbrev_form
== DW_FORM_ref_addr
5087 || abbrev_form
== DW_FORM_indirect
)
5088 cu
->has_form_ref_addr
= 1;
5090 cur_attrs
[cur_abbrev
->num_attrs
].name
= abbrev_name
;
5091 cur_attrs
[cur_abbrev
->num_attrs
++].form
= abbrev_form
;
5092 abbrev_name
= read_unsigned_leb128 (abfd
, abbrev_ptr
, &bytes_read
);
5093 abbrev_ptr
+= bytes_read
;
5094 abbrev_form
= read_unsigned_leb128 (abfd
, abbrev_ptr
, &bytes_read
);
5095 abbrev_ptr
+= bytes_read
;
5098 cur_abbrev
->attrs
= obstack_alloc (&cu
->abbrev_obstack
,
5099 (cur_abbrev
->num_attrs
5100 * sizeof (struct attr_abbrev
)));
5101 memcpy (cur_abbrev
->attrs
, cur_attrs
,
5102 cur_abbrev
->num_attrs
* sizeof (struct attr_abbrev
));
5104 hash_number
= abbrev_number
% ABBREV_HASH_SIZE
;
5105 cur_abbrev
->next
= cu
->dwarf2_abbrevs
[hash_number
];
5106 cu
->dwarf2_abbrevs
[hash_number
] = cur_abbrev
;
5108 /* Get next abbreviation.
5109 Under Irix6 the abbreviations for a compilation unit are not
5110 always properly terminated with an abbrev number of 0.
5111 Exit loop if we encounter an abbreviation which we have
5112 already read (which means we are about to read the abbreviations
5113 for the next compile unit) or if the end of the abbreviation
5114 table is reached. */
5115 if ((unsigned int) (abbrev_ptr
- dwarf2_per_objfile
->abbrev_buffer
)
5116 >= dwarf2_per_objfile
->abbrev_size
)
5118 abbrev_number
= read_unsigned_leb128 (abfd
, abbrev_ptr
, &bytes_read
);
5119 abbrev_ptr
+= bytes_read
;
5120 if (dwarf2_lookup_abbrev (abbrev_number
, cu
) != NULL
)
5127 /* Release the memory used by the abbrev table for a compilation unit. */
5130 dwarf2_free_abbrev_table (void *ptr_to_cu
)
5132 struct dwarf2_cu
*cu
= ptr_to_cu
;
5134 obstack_free (&cu
->abbrev_obstack
, NULL
);
5135 cu
->dwarf2_abbrevs
= NULL
;
5138 /* Lookup an abbrev_info structure in the abbrev hash table. */
5140 static struct abbrev_info
*
5141 dwarf2_lookup_abbrev (unsigned int number
, struct dwarf2_cu
*cu
)
5143 unsigned int hash_number
;
5144 struct abbrev_info
*abbrev
;
5146 hash_number
= number
% ABBREV_HASH_SIZE
;
5147 abbrev
= cu
->dwarf2_abbrevs
[hash_number
];
5151 if (abbrev
->number
== number
)
5154 abbrev
= abbrev
->next
;
5159 /* Returns nonzero if TAG represents a type that we might generate a partial
5163 is_type_tag_for_partial (int tag
)
5168 /* Some types that would be reasonable to generate partial symbols for,
5169 that we don't at present. */
5170 case DW_TAG_array_type
:
5171 case DW_TAG_file_type
:
5172 case DW_TAG_ptr_to_member_type
:
5173 case DW_TAG_set_type
:
5174 case DW_TAG_string_type
:
5175 case DW_TAG_subroutine_type
:
5177 case DW_TAG_base_type
:
5178 case DW_TAG_class_type
:
5179 case DW_TAG_enumeration_type
:
5180 case DW_TAG_structure_type
:
5181 case DW_TAG_subrange_type
:
5182 case DW_TAG_typedef
:
5183 case DW_TAG_union_type
:
5190 /* Load all DIEs that are interesting for partial symbols into memory. */
5192 static struct partial_die_info
*
5193 load_partial_dies (bfd
*abfd
, gdb_byte
*info_ptr
, int building_psymtab
,
5194 struct dwarf2_cu
*cu
)
5196 struct partial_die_info
*part_die
;
5197 struct partial_die_info
*parent_die
, *last_die
, *first_die
= NULL
;
5198 struct abbrev_info
*abbrev
;
5199 unsigned int bytes_read
;
5200 unsigned int load_all
= 0;
5202 int nesting_level
= 1;
5207 if (cu
->per_cu
&& cu
->per_cu
->load_all_dies
)
5211 = htab_create_alloc_ex (cu
->header
.length
/ 12,
5215 &cu
->comp_unit_obstack
,
5216 hashtab_obstack_allocate
,
5217 dummy_obstack_deallocate
);
5219 part_die
= obstack_alloc (&cu
->comp_unit_obstack
,
5220 sizeof (struct partial_die_info
));
5224 abbrev
= peek_die_abbrev (info_ptr
, &bytes_read
, cu
);
5226 /* A NULL abbrev means the end of a series of children. */
5229 if (--nesting_level
== 0)
5231 /* PART_DIE was probably the last thing allocated on the
5232 comp_unit_obstack, so we could call obstack_free
5233 here. We don't do that because the waste is small,
5234 and will be cleaned up when we're done with this
5235 compilation unit. This way, we're also more robust
5236 against other users of the comp_unit_obstack. */
5239 info_ptr
+= bytes_read
;
5240 last_die
= parent_die
;
5241 parent_die
= parent_die
->die_parent
;
5245 /* Check whether this DIE is interesting enough to save. Normally
5246 we would not be interested in members here, but there may be
5247 later variables referencing them via DW_AT_specification (for
5250 && !is_type_tag_for_partial (abbrev
->tag
)
5251 && abbrev
->tag
!= DW_TAG_enumerator
5252 && abbrev
->tag
!= DW_TAG_subprogram
5253 && abbrev
->tag
!= DW_TAG_variable
5254 && abbrev
->tag
!= DW_TAG_namespace
5255 && abbrev
->tag
!= DW_TAG_member
)
5257 /* Otherwise we skip to the next sibling, if any. */
5258 info_ptr
= skip_one_die (info_ptr
+ bytes_read
, abbrev
, cu
);
5262 info_ptr
= read_partial_die (part_die
, abbrev
, bytes_read
,
5263 abfd
, info_ptr
, cu
);
5265 /* This two-pass algorithm for processing partial symbols has a
5266 high cost in cache pressure. Thus, handle some simple cases
5267 here which cover the majority of C partial symbols. DIEs
5268 which neither have specification tags in them, nor could have
5269 specification tags elsewhere pointing at them, can simply be
5270 processed and discarded.
5272 This segment is also optional; scan_partial_symbols and
5273 add_partial_symbol will handle these DIEs if we chain
5274 them in normally. When compilers which do not emit large
5275 quantities of duplicate debug information are more common,
5276 this code can probably be removed. */
5278 /* Any complete simple types at the top level (pretty much all
5279 of them, for a language without namespaces), can be processed
5281 if (parent_die
== NULL
5282 && part_die
->has_specification
== 0
5283 && part_die
->is_declaration
== 0
5284 && (part_die
->tag
== DW_TAG_typedef
5285 || part_die
->tag
== DW_TAG_base_type
5286 || part_die
->tag
== DW_TAG_subrange_type
))
5288 if (building_psymtab
&& part_die
->name
!= NULL
)
5289 add_psymbol_to_list (part_die
->name
, strlen (part_die
->name
),
5290 VAR_DOMAIN
, LOC_TYPEDEF
,
5291 &cu
->objfile
->static_psymbols
,
5292 0, (CORE_ADDR
) 0, cu
->language
, cu
->objfile
);
5293 info_ptr
= locate_pdi_sibling (part_die
, info_ptr
, abfd
, cu
);
5297 /* If we're at the second level, and we're an enumerator, and
5298 our parent has no specification (meaning possibly lives in a
5299 namespace elsewhere), then we can add the partial symbol now
5300 instead of queueing it. */
5301 if (part_die
->tag
== DW_TAG_enumerator
5302 && parent_die
!= NULL
5303 && parent_die
->die_parent
== NULL
5304 && parent_die
->tag
== DW_TAG_enumeration_type
5305 && parent_die
->has_specification
== 0)
5307 if (part_die
->name
== NULL
)
5308 complaint (&symfile_complaints
, _("malformed enumerator DIE ignored"));
5309 else if (building_psymtab
)
5310 add_psymbol_to_list (part_die
->name
, strlen (part_die
->name
),
5311 VAR_DOMAIN
, LOC_CONST
,
5312 (cu
->language
== language_cplus
5313 || cu
->language
== language_java
)
5314 ? &cu
->objfile
->global_psymbols
5315 : &cu
->objfile
->static_psymbols
,
5316 0, (CORE_ADDR
) 0, cu
->language
, cu
->objfile
);
5318 info_ptr
= locate_pdi_sibling (part_die
, info_ptr
, abfd
, cu
);
5322 /* We'll save this DIE so link it in. */
5323 part_die
->die_parent
= parent_die
;
5324 part_die
->die_sibling
= NULL
;
5325 part_die
->die_child
= NULL
;
5327 if (last_die
&& last_die
== parent_die
)
5328 last_die
->die_child
= part_die
;
5330 last_die
->die_sibling
= part_die
;
5332 last_die
= part_die
;
5334 if (first_die
== NULL
)
5335 first_die
= part_die
;
5337 /* Maybe add the DIE to the hash table. Not all DIEs that we
5338 find interesting need to be in the hash table, because we
5339 also have the parent/sibling/child chains; only those that we
5340 might refer to by offset later during partial symbol reading.
5342 For now this means things that might have be the target of a
5343 DW_AT_specification, DW_AT_abstract_origin, or
5344 DW_AT_extension. DW_AT_extension will refer only to
5345 namespaces; DW_AT_abstract_origin refers to functions (and
5346 many things under the function DIE, but we do not recurse
5347 into function DIEs during partial symbol reading) and
5348 possibly variables as well; DW_AT_specification refers to
5349 declarations. Declarations ought to have the DW_AT_declaration
5350 flag. It happens that GCC forgets to put it in sometimes, but
5351 only for functions, not for types.
5353 Adding more things than necessary to the hash table is harmless
5354 except for the performance cost. Adding too few will result in
5355 wasted time in find_partial_die, when we reread the compilation
5356 unit with load_all_dies set. */
5359 || abbrev
->tag
== DW_TAG_subprogram
5360 || abbrev
->tag
== DW_TAG_variable
5361 || abbrev
->tag
== DW_TAG_namespace
5362 || part_die
->is_declaration
)
5366 slot
= htab_find_slot_with_hash (cu
->partial_dies
, part_die
,
5367 part_die
->offset
, INSERT
);
5371 part_die
= obstack_alloc (&cu
->comp_unit_obstack
,
5372 sizeof (struct partial_die_info
));
5374 /* For some DIEs we want to follow their children (if any). For C
5375 we have no reason to follow the children of structures; for other
5376 languages we have to, both so that we can get at method physnames
5377 to infer fully qualified class names, and for DW_AT_specification. */
5378 if (last_die
->has_children
5380 || last_die
->tag
== DW_TAG_namespace
5381 || last_die
->tag
== DW_TAG_enumeration_type
5382 || (cu
->language
!= language_c
5383 && (last_die
->tag
== DW_TAG_class_type
5384 || last_die
->tag
== DW_TAG_structure_type
5385 || last_die
->tag
== DW_TAG_union_type
))))
5388 parent_die
= last_die
;
5392 /* Otherwise we skip to the next sibling, if any. */
5393 info_ptr
= locate_pdi_sibling (last_die
, info_ptr
, abfd
, cu
);
5395 /* Back to the top, do it again. */
5399 /* Read a minimal amount of information into the minimal die structure. */
5402 read_partial_die (struct partial_die_info
*part_die
,
5403 struct abbrev_info
*abbrev
,
5404 unsigned int abbrev_len
, bfd
*abfd
,
5405 gdb_byte
*info_ptr
, struct dwarf2_cu
*cu
)
5407 unsigned int bytes_read
, i
;
5408 struct attribute attr
;
5409 int has_low_pc_attr
= 0;
5410 int has_high_pc_attr
= 0;
5412 memset (part_die
, 0, sizeof (struct partial_die_info
));
5414 part_die
->offset
= info_ptr
- dwarf2_per_objfile
->info_buffer
;
5416 info_ptr
+= abbrev_len
;
5421 part_die
->tag
= abbrev
->tag
;
5422 part_die
->has_children
= abbrev
->has_children
;
5424 for (i
= 0; i
< abbrev
->num_attrs
; ++i
)
5426 info_ptr
= read_attribute (&attr
, &abbrev
->attrs
[i
], abfd
, info_ptr
, cu
);
5428 /* Store the data if it is of an attribute we want to keep in a
5429 partial symbol table. */
5434 /* Prefer DW_AT_MIPS_linkage_name over DW_AT_name. */
5435 if (part_die
->name
== NULL
)
5436 part_die
->name
= DW_STRING (&attr
);
5438 case DW_AT_comp_dir
:
5439 if (part_die
->dirname
== NULL
)
5440 part_die
->dirname
= DW_STRING (&attr
);
5442 case DW_AT_MIPS_linkage_name
:
5443 part_die
->name
= DW_STRING (&attr
);
5446 has_low_pc_attr
= 1;
5447 part_die
->lowpc
= DW_ADDR (&attr
);
5450 has_high_pc_attr
= 1;
5451 part_die
->highpc
= DW_ADDR (&attr
);
5453 case DW_AT_location
:
5454 /* Support the .debug_loc offsets */
5455 if (attr_form_is_block (&attr
))
5457 part_die
->locdesc
= DW_BLOCK (&attr
);
5459 else if (attr
.form
== DW_FORM_data4
|| attr
.form
== DW_FORM_data8
)
5461 dwarf2_complex_location_expr_complaint ();
5465 dwarf2_invalid_attrib_class_complaint ("DW_AT_location",
5466 "partial symbol information");
5469 case DW_AT_language
:
5470 part_die
->language
= DW_UNSND (&attr
);
5472 case DW_AT_external
:
5473 part_die
->is_external
= DW_UNSND (&attr
);
5475 case DW_AT_declaration
:
5476 part_die
->is_declaration
= DW_UNSND (&attr
);
5479 part_die
->has_type
= 1;
5481 case DW_AT_abstract_origin
:
5482 case DW_AT_specification
:
5483 case DW_AT_extension
:
5484 part_die
->has_specification
= 1;
5485 part_die
->spec_offset
= dwarf2_get_ref_die_offset (&attr
, cu
);
5488 /* Ignore absolute siblings, they might point outside of
5489 the current compile unit. */
5490 if (attr
.form
== DW_FORM_ref_addr
)
5491 complaint (&symfile_complaints
, _("ignoring absolute DW_AT_sibling"));
5493 part_die
->sibling
= dwarf2_per_objfile
->info_buffer
5494 + dwarf2_get_ref_die_offset (&attr
, cu
);
5496 case DW_AT_stmt_list
:
5497 part_die
->has_stmt_list
= 1;
5498 part_die
->line_offset
= DW_UNSND (&attr
);
5505 /* When using the GNU linker, .gnu.linkonce. sections are used to
5506 eliminate duplicate copies of functions and vtables and such.
5507 The linker will arbitrarily choose one and discard the others.
5508 The AT_*_pc values for such functions refer to local labels in
5509 these sections. If the section from that file was discarded, the
5510 labels are not in the output, so the relocs get a value of 0.
5511 If this is a discarded function, mark the pc bounds as invalid,
5512 so that GDB will ignore it. */
5513 if (has_low_pc_attr
&& has_high_pc_attr
5514 && part_die
->lowpc
< part_die
->highpc
5515 && (part_die
->lowpc
!= 0
5516 || dwarf2_per_objfile
->has_section_at_zero
))
5517 part_die
->has_pc_info
= 1;
5521 /* Find a cached partial DIE at OFFSET in CU. */
5523 static struct partial_die_info
*
5524 find_partial_die_in_comp_unit (unsigned long offset
, struct dwarf2_cu
*cu
)
5526 struct partial_die_info
*lookup_die
= NULL
;
5527 struct partial_die_info part_die
;
5529 part_die
.offset
= offset
;
5530 lookup_die
= htab_find_with_hash (cu
->partial_dies
, &part_die
, offset
);
5535 /* Find a partial DIE at OFFSET, which may or may not be in CU. */
5537 static struct partial_die_info
*
5538 find_partial_die (unsigned long offset
, struct dwarf2_cu
*cu
)
5540 struct dwarf2_per_cu_data
*per_cu
= NULL
;
5541 struct partial_die_info
*pd
= NULL
;
5543 if (offset
>= cu
->header
.offset
5544 && offset
< cu
->header
.offset
+ cu
->header
.length
)
5546 pd
= find_partial_die_in_comp_unit (offset
, cu
);
5551 per_cu
= dwarf2_find_containing_comp_unit (offset
, cu
->objfile
);
5553 if (per_cu
->cu
== NULL
)
5555 load_comp_unit (per_cu
, cu
->objfile
);
5556 per_cu
->cu
->read_in_chain
= dwarf2_per_objfile
->read_in_chain
;
5557 dwarf2_per_objfile
->read_in_chain
= per_cu
;
5560 per_cu
->cu
->last_used
= 0;
5561 pd
= find_partial_die_in_comp_unit (offset
, per_cu
->cu
);
5563 if (pd
== NULL
&& per_cu
->load_all_dies
== 0)
5565 struct cleanup
*back_to
;
5566 struct partial_die_info comp_unit_die
;
5567 struct abbrev_info
*abbrev
;
5568 unsigned int bytes_read
;
5571 per_cu
->load_all_dies
= 1;
5573 /* Re-read the DIEs. */
5574 back_to
= make_cleanup (null_cleanup
, 0);
5575 if (per_cu
->cu
->dwarf2_abbrevs
== NULL
)
5577 dwarf2_read_abbrevs (per_cu
->cu
->objfile
->obfd
, per_cu
->cu
);
5578 back_to
= make_cleanup (dwarf2_free_abbrev_table
, per_cu
->cu
);
5580 info_ptr
= per_cu
->cu
->header
.first_die_ptr
;
5581 abbrev
= peek_die_abbrev (info_ptr
, &bytes_read
, per_cu
->cu
);
5582 info_ptr
= read_partial_die (&comp_unit_die
, abbrev
, bytes_read
,
5583 per_cu
->cu
->objfile
->obfd
, info_ptr
,
5585 if (comp_unit_die
.has_children
)
5586 load_partial_dies (per_cu
->cu
->objfile
->obfd
, info_ptr
, 0, per_cu
->cu
);
5587 do_cleanups (back_to
);
5589 pd
= find_partial_die_in_comp_unit (offset
, per_cu
->cu
);
5593 internal_error (__FILE__
, __LINE__
,
5594 _("could not find partial DIE 0x%lx in cache [from module %s]\n"),
5595 offset
, bfd_get_filename (cu
->objfile
->obfd
));
5599 /* Adjust PART_DIE before generating a symbol for it. This function
5600 may set the is_external flag or change the DIE's name. */
5603 fixup_partial_die (struct partial_die_info
*part_die
,
5604 struct dwarf2_cu
*cu
)
5606 /* If we found a reference attribute and the DIE has no name, try
5607 to find a name in the referred to DIE. */
5609 if (part_die
->name
== NULL
&& part_die
->has_specification
)
5611 struct partial_die_info
*spec_die
;
5613 spec_die
= find_partial_die (part_die
->spec_offset
, cu
);
5615 fixup_partial_die (spec_die
, cu
);
5619 part_die
->name
= spec_die
->name
;
5621 /* Copy DW_AT_external attribute if it is set. */
5622 if (spec_die
->is_external
)
5623 part_die
->is_external
= spec_die
->is_external
;
5627 /* Set default names for some unnamed DIEs. */
5628 if (part_die
->name
== NULL
&& (part_die
->tag
== DW_TAG_structure_type
5629 || part_die
->tag
== DW_TAG_class_type
))
5630 part_die
->name
= "(anonymous class)";
5632 if (part_die
->name
== NULL
&& part_die
->tag
== DW_TAG_namespace
)
5633 part_die
->name
= "(anonymous namespace)";
5635 if (part_die
->tag
== DW_TAG_structure_type
5636 || part_die
->tag
== DW_TAG_class_type
5637 || part_die
->tag
== DW_TAG_union_type
)
5638 guess_structure_name (part_die
, cu
);
5641 /* Read the die from the .debug_info section buffer. Set DIEP to
5642 point to a newly allocated die with its information, except for its
5643 child, sibling, and parent fields. Set HAS_CHILDREN to tell
5644 whether the die has children or not. */
5647 read_full_die (struct die_info
**diep
, bfd
*abfd
, gdb_byte
*info_ptr
,
5648 struct dwarf2_cu
*cu
, int *has_children
)
5650 unsigned int abbrev_number
, bytes_read
, i
, offset
;
5651 struct abbrev_info
*abbrev
;
5652 struct die_info
*die
;
5654 offset
= info_ptr
- dwarf2_per_objfile
->info_buffer
;
5655 abbrev_number
= read_unsigned_leb128 (abfd
, info_ptr
, &bytes_read
);
5656 info_ptr
+= bytes_read
;
5659 die
= dwarf_alloc_die ();
5661 die
->abbrev
= abbrev_number
;
5668 abbrev
= dwarf2_lookup_abbrev (abbrev_number
, cu
);
5671 error (_("Dwarf Error: could not find abbrev number %d [in module %s]"),
5673 bfd_get_filename (abfd
));
5675 die
= dwarf_alloc_die ();
5676 die
->offset
= offset
;
5677 die
->tag
= abbrev
->tag
;
5678 die
->abbrev
= abbrev_number
;
5681 die
->num_attrs
= abbrev
->num_attrs
;
5682 die
->attrs
= (struct attribute
*)
5683 xmalloc (die
->num_attrs
* sizeof (struct attribute
));
5685 for (i
= 0; i
< abbrev
->num_attrs
; ++i
)
5687 info_ptr
= read_attribute (&die
->attrs
[i
], &abbrev
->attrs
[i
],
5688 abfd
, info_ptr
, cu
);
5690 /* If this attribute is an absolute reference to a different
5691 compilation unit, make sure that compilation unit is loaded
5693 if (die
->attrs
[i
].form
== DW_FORM_ref_addr
5694 && (DW_ADDR (&die
->attrs
[i
]) < cu
->header
.offset
5695 || (DW_ADDR (&die
->attrs
[i
])
5696 >= cu
->header
.offset
+ cu
->header
.length
)))
5698 struct dwarf2_per_cu_data
*per_cu
;
5699 per_cu
= dwarf2_find_containing_comp_unit (DW_ADDR (&die
->attrs
[i
]),
5702 /* Mark the dependence relation so that we don't flush PER_CU
5704 dwarf2_add_dependence (cu
, per_cu
);
5706 /* If it's already on the queue, we have nothing to do. */
5710 /* If the compilation unit is already loaded, just mark it as
5712 if (per_cu
->cu
!= NULL
)
5714 per_cu
->cu
->last_used
= 0;
5718 /* Add it to the queue. */
5719 queue_comp_unit (per_cu
);
5724 *has_children
= abbrev
->has_children
;
5728 /* Read an attribute value described by an attribute form. */
5731 read_attribute_value (struct attribute
*attr
, unsigned form
,
5732 bfd
*abfd
, gdb_byte
*info_ptr
,
5733 struct dwarf2_cu
*cu
)
5735 struct comp_unit_head
*cu_header
= &cu
->header
;
5736 unsigned int bytes_read
;
5737 struct dwarf_block
*blk
;
5743 case DW_FORM_ref_addr
:
5744 DW_ADDR (attr
) = read_address (abfd
, info_ptr
, cu
, &bytes_read
);
5745 info_ptr
+= bytes_read
;
5747 case DW_FORM_block2
:
5748 blk
= dwarf_alloc_block (cu
);
5749 blk
->size
= read_2_bytes (abfd
, info_ptr
);
5751 blk
->data
= read_n_bytes (abfd
, info_ptr
, blk
->size
);
5752 info_ptr
+= blk
->size
;
5753 DW_BLOCK (attr
) = blk
;
5755 case DW_FORM_block4
:
5756 blk
= dwarf_alloc_block (cu
);
5757 blk
->size
= read_4_bytes (abfd
, info_ptr
);
5759 blk
->data
= read_n_bytes (abfd
, info_ptr
, blk
->size
);
5760 info_ptr
+= blk
->size
;
5761 DW_BLOCK (attr
) = blk
;
5764 DW_UNSND (attr
) = read_2_bytes (abfd
, info_ptr
);
5768 DW_UNSND (attr
) = read_4_bytes (abfd
, info_ptr
);
5772 DW_UNSND (attr
) = read_8_bytes (abfd
, info_ptr
);
5775 case DW_FORM_string
:
5776 DW_STRING (attr
) = read_string (abfd
, info_ptr
, &bytes_read
);
5777 info_ptr
+= bytes_read
;
5780 DW_STRING (attr
) = read_indirect_string (abfd
, info_ptr
, cu_header
,
5782 info_ptr
+= bytes_read
;
5785 blk
= dwarf_alloc_block (cu
);
5786 blk
->size
= read_unsigned_leb128 (abfd
, info_ptr
, &bytes_read
);
5787 info_ptr
+= bytes_read
;
5788 blk
->data
= read_n_bytes (abfd
, info_ptr
, blk
->size
);
5789 info_ptr
+= blk
->size
;
5790 DW_BLOCK (attr
) = blk
;
5792 case DW_FORM_block1
:
5793 blk
= dwarf_alloc_block (cu
);
5794 blk
->size
= read_1_byte (abfd
, info_ptr
);
5796 blk
->data
= read_n_bytes (abfd
, info_ptr
, blk
->size
);
5797 info_ptr
+= blk
->size
;
5798 DW_BLOCK (attr
) = blk
;
5801 DW_UNSND (attr
) = read_1_byte (abfd
, info_ptr
);
5805 DW_UNSND (attr
) = read_1_byte (abfd
, info_ptr
);
5809 DW_SND (attr
) = read_signed_leb128 (abfd
, info_ptr
, &bytes_read
);
5810 info_ptr
+= bytes_read
;
5813 DW_UNSND (attr
) = read_unsigned_leb128 (abfd
, info_ptr
, &bytes_read
);
5814 info_ptr
+= bytes_read
;
5817 DW_ADDR (attr
) = cu
->header
.offset
+ read_1_byte (abfd
, info_ptr
);
5821 DW_ADDR (attr
) = cu
->header
.offset
+ read_2_bytes (abfd
, info_ptr
);
5825 DW_ADDR (attr
) = cu
->header
.offset
+ read_4_bytes (abfd
, info_ptr
);
5829 DW_ADDR (attr
) = cu
->header
.offset
+ read_8_bytes (abfd
, info_ptr
);
5832 case DW_FORM_ref_udata
:
5833 DW_ADDR (attr
) = (cu
->header
.offset
5834 + read_unsigned_leb128 (abfd
, info_ptr
, &bytes_read
));
5835 info_ptr
+= bytes_read
;
5837 case DW_FORM_indirect
:
5838 form
= read_unsigned_leb128 (abfd
, info_ptr
, &bytes_read
);
5839 info_ptr
+= bytes_read
;
5840 info_ptr
= read_attribute_value (attr
, form
, abfd
, info_ptr
, cu
);
5843 error (_("Dwarf Error: Cannot handle %s in DWARF reader [in module %s]"),
5844 dwarf_form_name (form
),
5845 bfd_get_filename (abfd
));
5850 /* Read an attribute described by an abbreviated attribute. */
5853 read_attribute (struct attribute
*attr
, struct attr_abbrev
*abbrev
,
5854 bfd
*abfd
, gdb_byte
*info_ptr
, struct dwarf2_cu
*cu
)
5856 attr
->name
= abbrev
->name
;
5857 return read_attribute_value (attr
, abbrev
->form
, abfd
, info_ptr
, cu
);
5860 /* read dwarf information from a buffer */
5863 read_1_byte (bfd
*abfd
, gdb_byte
*buf
)
5865 return bfd_get_8 (abfd
, buf
);
5869 read_1_signed_byte (bfd
*abfd
, gdb_byte
*buf
)
5871 return bfd_get_signed_8 (abfd
, buf
);
5875 read_2_bytes (bfd
*abfd
, gdb_byte
*buf
)
5877 return bfd_get_16 (abfd
, buf
);
5881 read_2_signed_bytes (bfd
*abfd
, gdb_byte
*buf
)
5883 return bfd_get_signed_16 (abfd
, buf
);
5887 read_4_bytes (bfd
*abfd
, gdb_byte
*buf
)
5889 return bfd_get_32 (abfd
, buf
);
5893 read_4_signed_bytes (bfd
*abfd
, gdb_byte
*buf
)
5895 return bfd_get_signed_32 (abfd
, buf
);
5898 static unsigned long
5899 read_8_bytes (bfd
*abfd
, gdb_byte
*buf
)
5901 return bfd_get_64 (abfd
, buf
);
5905 read_address (bfd
*abfd
, gdb_byte
*buf
, struct dwarf2_cu
*cu
,
5906 unsigned int *bytes_read
)
5908 struct comp_unit_head
*cu_header
= &cu
->header
;
5909 CORE_ADDR retval
= 0;
5911 if (cu_header
->signed_addr_p
)
5913 switch (cu_header
->addr_size
)
5916 retval
= bfd_get_signed_16 (abfd
, buf
);
5919 retval
= bfd_get_signed_32 (abfd
, buf
);
5922 retval
= bfd_get_signed_64 (abfd
, buf
);
5925 internal_error (__FILE__
, __LINE__
,
5926 _("read_address: bad switch, signed [in module %s]"),
5927 bfd_get_filename (abfd
));
5932 switch (cu_header
->addr_size
)
5935 retval
= bfd_get_16 (abfd
, buf
);
5938 retval
= bfd_get_32 (abfd
, buf
);
5941 retval
= bfd_get_64 (abfd
, buf
);
5944 internal_error (__FILE__
, __LINE__
,
5945 _("read_address: bad switch, unsigned [in module %s]"),
5946 bfd_get_filename (abfd
));
5950 *bytes_read
= cu_header
->addr_size
;
5954 /* Read the initial length from a section. The (draft) DWARF 3
5955 specification allows the initial length to take up either 4 bytes
5956 or 12 bytes. If the first 4 bytes are 0xffffffff, then the next 8
5957 bytes describe the length and all offsets will be 8 bytes in length
5960 An older, non-standard 64-bit format is also handled by this
5961 function. The older format in question stores the initial length
5962 as an 8-byte quantity without an escape value. Lengths greater
5963 than 2^32 aren't very common which means that the initial 4 bytes
5964 is almost always zero. Since a length value of zero doesn't make
5965 sense for the 32-bit format, this initial zero can be considered to
5966 be an escape value which indicates the presence of the older 64-bit
5967 format. As written, the code can't detect (old format) lengths
5968 greater than 4GB. If it becomes necessary to handle lengths
5969 somewhat larger than 4GB, we could allow other small values (such
5970 as the non-sensical values of 1, 2, and 3) to also be used as
5971 escape values indicating the presence of the old format.
5973 The value returned via bytes_read should be used to increment the
5974 relevant pointer after calling read_initial_length().
5976 As a side effect, this function sets the fields initial_length_size
5977 and offset_size in cu_header to the values appropriate for the
5978 length field. (The format of the initial length field determines
5979 the width of file offsets to be fetched later with read_offset().)
5981 [ Note: read_initial_length() and read_offset() are based on the
5982 document entitled "DWARF Debugging Information Format", revision
5983 3, draft 8, dated November 19, 2001. This document was obtained
5986 http://reality.sgiweb.org/davea/dwarf3-draft8-011125.pdf
5988 This document is only a draft and is subject to change. (So beware.)
5990 Details regarding the older, non-standard 64-bit format were
5991 determined empirically by examining 64-bit ELF files produced by
5992 the SGI toolchain on an IRIX 6.5 machine.
5994 - Kevin, July 16, 2002
5998 read_initial_length (bfd
*abfd
, gdb_byte
*buf
, struct comp_unit_head
*cu_header
,
5999 unsigned int *bytes_read
)
6001 LONGEST length
= bfd_get_32 (abfd
, buf
);
6003 if (length
== 0xffffffff)
6005 length
= bfd_get_64 (abfd
, buf
+ 4);
6008 else if (length
== 0)
6010 /* Handle the (non-standard) 64-bit DWARF2 format used by IRIX. */
6011 length
= bfd_get_64 (abfd
, buf
);
6021 gdb_assert (cu_header
->initial_length_size
== 0
6022 || cu_header
->initial_length_size
== 4
6023 || cu_header
->initial_length_size
== 8
6024 || cu_header
->initial_length_size
== 12);
6026 if (cu_header
->initial_length_size
!= 0
6027 && cu_header
->initial_length_size
!= *bytes_read
)
6028 complaint (&symfile_complaints
,
6029 _("intermixed 32-bit and 64-bit DWARF sections"));
6031 cu_header
->initial_length_size
= *bytes_read
;
6032 cu_header
->offset_size
= (*bytes_read
== 4) ? 4 : 8;
6038 /* Read an offset from the data stream. The size of the offset is
6039 given by cu_header->offset_size. */
6042 read_offset (bfd
*abfd
, gdb_byte
*buf
, const struct comp_unit_head
*cu_header
,
6043 unsigned int *bytes_read
)
6047 switch (cu_header
->offset_size
)
6050 retval
= bfd_get_32 (abfd
, buf
);
6054 retval
= bfd_get_64 (abfd
, buf
);
6058 internal_error (__FILE__
, __LINE__
,
6059 _("read_offset: bad switch [in module %s]"),
6060 bfd_get_filename (abfd
));
6067 read_n_bytes (bfd
*abfd
, gdb_byte
*buf
, unsigned int size
)
6069 /* If the size of a host char is 8 bits, we can return a pointer
6070 to the buffer, otherwise we have to copy the data to a buffer
6071 allocated on the temporary obstack. */
6072 gdb_assert (HOST_CHAR_BIT
== 8);
6077 read_string (bfd
*abfd
, gdb_byte
*buf
, unsigned int *bytes_read_ptr
)
6079 /* If the size of a host char is 8 bits, we can return a pointer
6080 to the string, otherwise we have to copy the string to a buffer
6081 allocated on the temporary obstack. */
6082 gdb_assert (HOST_CHAR_BIT
== 8);
6085 *bytes_read_ptr
= 1;
6088 *bytes_read_ptr
= strlen ((char *) buf
) + 1;
6089 return (char *) buf
;
6093 read_indirect_string (bfd
*abfd
, gdb_byte
*buf
,
6094 const struct comp_unit_head
*cu_header
,
6095 unsigned int *bytes_read_ptr
)
6097 LONGEST str_offset
= read_offset (abfd
, buf
, cu_header
,
6100 if (dwarf2_per_objfile
->str_buffer
== NULL
)
6102 error (_("DW_FORM_strp used without .debug_str section [in module %s]"),
6103 bfd_get_filename (abfd
));
6106 if (str_offset
>= dwarf2_per_objfile
->str_size
)
6108 error (_("DW_FORM_strp pointing outside of .debug_str section [in module %s]"),
6109 bfd_get_filename (abfd
));
6112 gdb_assert (HOST_CHAR_BIT
== 8);
6113 if (dwarf2_per_objfile
->str_buffer
[str_offset
] == '\0')
6115 return (char *) (dwarf2_per_objfile
->str_buffer
+ str_offset
);
6118 static unsigned long
6119 read_unsigned_leb128 (bfd
*abfd
, gdb_byte
*buf
, unsigned int *bytes_read_ptr
)
6121 unsigned long result
;
6122 unsigned int num_read
;
6132 byte
= bfd_get_8 (abfd
, buf
);
6135 result
|= ((unsigned long)(byte
& 127) << shift
);
6136 if ((byte
& 128) == 0)
6142 *bytes_read_ptr
= num_read
;
6147 read_signed_leb128 (bfd
*abfd
, gdb_byte
*buf
, unsigned int *bytes_read_ptr
)
6150 int i
, shift
, num_read
;
6159 byte
= bfd_get_8 (abfd
, buf
);
6162 result
|= ((long)(byte
& 127) << shift
);
6164 if ((byte
& 128) == 0)
6169 if ((shift
< 8 * sizeof (result
)) && (byte
& 0x40))
6170 result
|= -(((long)1) << shift
);
6171 *bytes_read_ptr
= num_read
;
6175 /* Return a pointer to just past the end of an LEB128 number in BUF. */
6178 skip_leb128 (bfd
*abfd
, gdb_byte
*buf
)
6184 byte
= bfd_get_8 (abfd
, buf
);
6186 if ((byte
& 128) == 0)
6192 set_cu_language (unsigned int lang
, struct dwarf2_cu
*cu
)
6198 cu
->language
= language_c
;
6200 case DW_LANG_C_plus_plus
:
6201 cu
->language
= language_cplus
;
6203 case DW_LANG_Fortran77
:
6204 case DW_LANG_Fortran90
:
6205 case DW_LANG_Fortran95
:
6206 cu
->language
= language_fortran
;
6208 case DW_LANG_Mips_Assembler
:
6209 cu
->language
= language_asm
;
6212 cu
->language
= language_java
;
6216 cu
->language
= language_ada
;
6218 case DW_LANG_Modula2
:
6219 cu
->language
= language_m2
;
6221 case DW_LANG_Cobol74
:
6222 case DW_LANG_Cobol85
:
6223 case DW_LANG_Pascal83
:
6225 cu
->language
= language_minimal
;
6228 cu
->language_defn
= language_def (cu
->language
);
6231 /* Return the named attribute or NULL if not there. */
6233 static struct attribute
*
6234 dwarf2_attr (struct die_info
*die
, unsigned int name
, struct dwarf2_cu
*cu
)
6237 struct attribute
*spec
= NULL
;
6239 for (i
= 0; i
< die
->num_attrs
; ++i
)
6241 if (die
->attrs
[i
].name
== name
)
6242 return &die
->attrs
[i
];
6243 if (die
->attrs
[i
].name
== DW_AT_specification
6244 || die
->attrs
[i
].name
== DW_AT_abstract_origin
)
6245 spec
= &die
->attrs
[i
];
6249 return dwarf2_attr (follow_die_ref (die
, spec
, cu
), name
, cu
);
6254 /* Return non-zero iff the attribute NAME is defined for the given DIE,
6255 and holds a non-zero value. This function should only be used for
6256 DW_FORM_flag attributes. */
6259 dwarf2_flag_true_p (struct die_info
*die
, unsigned name
, struct dwarf2_cu
*cu
)
6261 struct attribute
*attr
= dwarf2_attr (die
, name
, cu
);
6263 return (attr
&& DW_UNSND (attr
));
6267 die_is_declaration (struct die_info
*die
, struct dwarf2_cu
*cu
)
6269 /* A DIE is a declaration if it has a DW_AT_declaration attribute
6270 which value is non-zero. However, we have to be careful with
6271 DIEs having a DW_AT_specification attribute, because dwarf2_attr()
6272 (via dwarf2_flag_true_p) follows this attribute. So we may
6273 end up accidently finding a declaration attribute that belongs
6274 to a different DIE referenced by the specification attribute,
6275 even though the given DIE does not have a declaration attribute. */
6276 return (dwarf2_flag_true_p (die
, DW_AT_declaration
, cu
)
6277 && dwarf2_attr (die
, DW_AT_specification
, cu
) == NULL
);
6280 /* Return the die giving the specification for DIE, if there is
6283 static struct die_info
*
6284 die_specification (struct die_info
*die
, struct dwarf2_cu
*cu
)
6286 struct attribute
*spec_attr
= dwarf2_attr (die
, DW_AT_specification
, cu
);
6288 if (spec_attr
== NULL
)
6291 return follow_die_ref (die
, spec_attr
, cu
);
6294 /* Free the line_header structure *LH, and any arrays and strings it
6297 free_line_header (struct line_header
*lh
)
6299 if (lh
->standard_opcode_lengths
)
6300 xfree (lh
->standard_opcode_lengths
);
6302 /* Remember that all the lh->file_names[i].name pointers are
6303 pointers into debug_line_buffer, and don't need to be freed. */
6305 xfree (lh
->file_names
);
6307 /* Similarly for the include directory names. */
6308 if (lh
->include_dirs
)
6309 xfree (lh
->include_dirs
);
6315 /* Add an entry to LH's include directory table. */
6317 add_include_dir (struct line_header
*lh
, char *include_dir
)
6319 /* Grow the array if necessary. */
6320 if (lh
->include_dirs_size
== 0)
6322 lh
->include_dirs_size
= 1; /* for testing */
6323 lh
->include_dirs
= xmalloc (lh
->include_dirs_size
6324 * sizeof (*lh
->include_dirs
));
6326 else if (lh
->num_include_dirs
>= lh
->include_dirs_size
)
6328 lh
->include_dirs_size
*= 2;
6329 lh
->include_dirs
= xrealloc (lh
->include_dirs
,
6330 (lh
->include_dirs_size
6331 * sizeof (*lh
->include_dirs
)));
6334 lh
->include_dirs
[lh
->num_include_dirs
++] = include_dir
;
6338 /* Add an entry to LH's file name table. */
6340 add_file_name (struct line_header
*lh
,
6342 unsigned int dir_index
,
6343 unsigned int mod_time
,
6344 unsigned int length
)
6346 struct file_entry
*fe
;
6348 /* Grow the array if necessary. */
6349 if (lh
->file_names_size
== 0)
6351 lh
->file_names_size
= 1; /* for testing */
6352 lh
->file_names
= xmalloc (lh
->file_names_size
6353 * sizeof (*lh
->file_names
));
6355 else if (lh
->num_file_names
>= lh
->file_names_size
)
6357 lh
->file_names_size
*= 2;
6358 lh
->file_names
= xrealloc (lh
->file_names
,
6359 (lh
->file_names_size
6360 * sizeof (*lh
->file_names
)));
6363 fe
= &lh
->file_names
[lh
->num_file_names
++];
6365 fe
->dir_index
= dir_index
;
6366 fe
->mod_time
= mod_time
;
6367 fe
->length
= length
;
6372 /* Read the statement program header starting at OFFSET in
6373 .debug_line, according to the endianness of ABFD. Return a pointer
6374 to a struct line_header, allocated using xmalloc.
6376 NOTE: the strings in the include directory and file name tables of
6377 the returned object point into debug_line_buffer, and must not be
6379 static struct line_header
*
6380 dwarf_decode_line_header (unsigned int offset
, bfd
*abfd
,
6381 struct dwarf2_cu
*cu
)
6383 struct cleanup
*back_to
;
6384 struct line_header
*lh
;
6386 unsigned int bytes_read
;
6388 char *cur_dir
, *cur_file
;
6390 if (dwarf2_per_objfile
->line_buffer
== NULL
)
6392 complaint (&symfile_complaints
, _("missing .debug_line section"));
6396 /* Make sure that at least there's room for the total_length field.
6397 That could be 12 bytes long, but we're just going to fudge that. */
6398 if (offset
+ 4 >= dwarf2_per_objfile
->line_size
)
6400 dwarf2_statement_list_fits_in_line_number_section_complaint ();
6404 lh
= xmalloc (sizeof (*lh
));
6405 memset (lh
, 0, sizeof (*lh
));
6406 back_to
= make_cleanup ((make_cleanup_ftype
*) free_line_header
,
6409 line_ptr
= dwarf2_per_objfile
->line_buffer
+ offset
;
6411 /* Read in the header. */
6413 read_initial_length (abfd
, line_ptr
, &cu
->header
, &bytes_read
);
6414 line_ptr
+= bytes_read
;
6415 if (line_ptr
+ lh
->total_length
> (dwarf2_per_objfile
->line_buffer
6416 + dwarf2_per_objfile
->line_size
))
6418 dwarf2_statement_list_fits_in_line_number_section_complaint ();
6421 lh
->statement_program_end
= line_ptr
+ lh
->total_length
;
6422 lh
->version
= read_2_bytes (abfd
, line_ptr
);
6424 lh
->header_length
= read_offset (abfd
, line_ptr
, &cu
->header
, &bytes_read
);
6425 line_ptr
+= bytes_read
;
6426 lh
->minimum_instruction_length
= read_1_byte (abfd
, line_ptr
);
6428 lh
->default_is_stmt
= read_1_byte (abfd
, line_ptr
);
6430 lh
->line_base
= read_1_signed_byte (abfd
, line_ptr
);
6432 lh
->line_range
= read_1_byte (abfd
, line_ptr
);
6434 lh
->opcode_base
= read_1_byte (abfd
, line_ptr
);
6436 lh
->standard_opcode_lengths
6437 = xmalloc (lh
->opcode_base
* sizeof (lh
->standard_opcode_lengths
[0]));
6439 lh
->standard_opcode_lengths
[0] = 1; /* This should never be used anyway. */
6440 for (i
= 1; i
< lh
->opcode_base
; ++i
)
6442 lh
->standard_opcode_lengths
[i
] = read_1_byte (abfd
, line_ptr
);
6446 /* Read directory table. */
6447 while ((cur_dir
= read_string (abfd
, line_ptr
, &bytes_read
)) != NULL
)
6449 line_ptr
+= bytes_read
;
6450 add_include_dir (lh
, cur_dir
);
6452 line_ptr
+= bytes_read
;
6454 /* Read file name table. */
6455 while ((cur_file
= read_string (abfd
, line_ptr
, &bytes_read
)) != NULL
)
6457 unsigned int dir_index
, mod_time
, length
;
6459 line_ptr
+= bytes_read
;
6460 dir_index
= read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
6461 line_ptr
+= bytes_read
;
6462 mod_time
= read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
6463 line_ptr
+= bytes_read
;
6464 length
= read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
6465 line_ptr
+= bytes_read
;
6467 add_file_name (lh
, cur_file
, dir_index
, mod_time
, length
);
6469 line_ptr
+= bytes_read
;
6470 lh
->statement_program_start
= line_ptr
;
6472 if (line_ptr
> (dwarf2_per_objfile
->line_buffer
6473 + dwarf2_per_objfile
->line_size
))
6474 complaint (&symfile_complaints
,
6475 _("line number info header doesn't fit in `.debug_line' section"));
6477 discard_cleanups (back_to
);
6481 /* This function exists to work around a bug in certain compilers
6482 (particularly GCC 2.95), in which the first line number marker of a
6483 function does not show up until after the prologue, right before
6484 the second line number marker. This function shifts ADDRESS down
6485 to the beginning of the function if necessary, and is called on
6486 addresses passed to record_line. */
6489 check_cu_functions (CORE_ADDR address
, struct dwarf2_cu
*cu
)
6491 struct function_range
*fn
;
6493 /* Find the function_range containing address. */
6498 cu
->cached_fn
= cu
->first_fn
;
6502 if (fn
->lowpc
<= address
&& fn
->highpc
> address
)
6508 while (fn
&& fn
!= cu
->cached_fn
)
6509 if (fn
->lowpc
<= address
&& fn
->highpc
> address
)
6519 if (address
!= fn
->lowpc
)
6520 complaint (&symfile_complaints
,
6521 _("misplaced first line number at 0x%lx for '%s'"),
6522 (unsigned long) address
, fn
->name
);
6527 /* Decode the Line Number Program (LNP) for the given line_header
6528 structure and CU. The actual information extracted and the type
6529 of structures created from the LNP depends on the value of PST.
6531 1. If PST is NULL, then this procedure uses the data from the program
6532 to create all necessary symbol tables, and their linetables.
6533 The compilation directory of the file is passed in COMP_DIR,
6534 and must not be NULL.
6536 2. If PST is not NULL, this procedure reads the program to determine
6537 the list of files included by the unit represented by PST, and
6538 builds all the associated partial symbol tables. In this case,
6539 the value of COMP_DIR is ignored, and can thus be NULL (the COMP_DIR
6540 is not used to compute the full name of the symtab, and therefore
6541 omitting it when building the partial symtab does not introduce
6542 the potential for inconsistency - a partial symtab and its associated
6543 symbtab having a different fullname -). */
6546 dwarf_decode_lines (struct line_header
*lh
, char *comp_dir
, bfd
*abfd
,
6547 struct dwarf2_cu
*cu
, struct partial_symtab
*pst
)
6551 unsigned int bytes_read
;
6552 unsigned char op_code
, extended_op
, adj_opcode
;
6554 struct objfile
*objfile
= cu
->objfile
;
6555 const int decode_for_pst_p
= (pst
!= NULL
);
6557 baseaddr
= ANOFFSET (objfile
->section_offsets
, SECT_OFF_TEXT (objfile
));
6559 line_ptr
= lh
->statement_program_start
;
6560 line_end
= lh
->statement_program_end
;
6562 /* Read the statement sequences until there's nothing left. */
6563 while (line_ptr
< line_end
)
6565 /* state machine registers */
6566 CORE_ADDR address
= 0;
6567 unsigned int file
= 1;
6568 unsigned int line
= 1;
6569 unsigned int column
= 0;
6570 int is_stmt
= lh
->default_is_stmt
;
6571 int basic_block
= 0;
6572 int end_sequence
= 0;
6574 if (!decode_for_pst_p
&& lh
->num_file_names
>= file
)
6576 /* Start a subfile for the current file of the state machine. */
6577 /* lh->include_dirs and lh->file_names are 0-based, but the
6578 directory and file name numbers in the statement program
6580 struct file_entry
*fe
= &lh
->file_names
[file
- 1];
6584 dir
= lh
->include_dirs
[fe
->dir_index
- 1];
6586 dwarf2_start_subfile (fe
->name
, dir
, comp_dir
);
6589 /* Decode the table. */
6590 while (!end_sequence
)
6592 op_code
= read_1_byte (abfd
, line_ptr
);
6595 if (op_code
>= lh
->opcode_base
)
6597 /* Special operand. */
6598 adj_opcode
= op_code
- lh
->opcode_base
;
6599 address
+= (adj_opcode
/ lh
->line_range
)
6600 * lh
->minimum_instruction_length
;
6601 line
+= lh
->line_base
+ (adj_opcode
% lh
->line_range
);
6602 lh
->file_names
[file
- 1].included_p
= 1;
6603 if (!decode_for_pst_p
)
6605 /* Append row to matrix using current values. */
6606 record_line (current_subfile
, line
,
6607 check_cu_functions (address
, cu
));
6611 else switch (op_code
)
6613 case DW_LNS_extended_op
:
6614 read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
6615 line_ptr
+= bytes_read
;
6616 extended_op
= read_1_byte (abfd
, line_ptr
);
6618 switch (extended_op
)
6620 case DW_LNE_end_sequence
:
6622 lh
->file_names
[file
- 1].included_p
= 1;
6623 if (!decode_for_pst_p
)
6624 record_line (current_subfile
, 0, address
);
6626 case DW_LNE_set_address
:
6627 address
= read_address (abfd
, line_ptr
, cu
, &bytes_read
);
6628 line_ptr
+= bytes_read
;
6629 address
+= baseaddr
;
6631 case DW_LNE_define_file
:
6634 unsigned int dir_index
, mod_time
, length
;
6636 cur_file
= read_string (abfd
, line_ptr
, &bytes_read
);
6637 line_ptr
+= bytes_read
;
6639 read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
6640 line_ptr
+= bytes_read
;
6642 read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
6643 line_ptr
+= bytes_read
;
6645 read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
6646 line_ptr
+= bytes_read
;
6647 add_file_name (lh
, cur_file
, dir_index
, mod_time
, length
);
6651 complaint (&symfile_complaints
,
6652 _("mangled .debug_line section"));
6657 lh
->file_names
[file
- 1].included_p
= 1;
6658 if (!decode_for_pst_p
)
6659 record_line (current_subfile
, line
,
6660 check_cu_functions (address
, cu
));
6663 case DW_LNS_advance_pc
:
6664 address
+= lh
->minimum_instruction_length
6665 * read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
6666 line_ptr
+= bytes_read
;
6668 case DW_LNS_advance_line
:
6669 line
+= read_signed_leb128 (abfd
, line_ptr
, &bytes_read
);
6670 line_ptr
+= bytes_read
;
6672 case DW_LNS_set_file
:
6674 /* The arrays lh->include_dirs and lh->file_names are
6675 0-based, but the directory and file name numbers in
6676 the statement program are 1-based. */
6677 struct file_entry
*fe
;
6680 file
= read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
6681 line_ptr
+= bytes_read
;
6682 fe
= &lh
->file_names
[file
- 1];
6684 dir
= lh
->include_dirs
[fe
->dir_index
- 1];
6686 if (!decode_for_pst_p
)
6687 dwarf2_start_subfile (fe
->name
, dir
, comp_dir
);
6690 case DW_LNS_set_column
:
6691 column
= read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
6692 line_ptr
+= bytes_read
;
6694 case DW_LNS_negate_stmt
:
6695 is_stmt
= (!is_stmt
);
6697 case DW_LNS_set_basic_block
:
6700 /* Add to the address register of the state machine the
6701 address increment value corresponding to special opcode
6702 255. I.e., this value is scaled by the minimum
6703 instruction length since special opcode 255 would have
6704 scaled the the increment. */
6705 case DW_LNS_const_add_pc
:
6706 address
+= (lh
->minimum_instruction_length
6707 * ((255 - lh
->opcode_base
) / lh
->line_range
));
6709 case DW_LNS_fixed_advance_pc
:
6710 address
+= read_2_bytes (abfd
, line_ptr
);
6715 /* Unknown standard opcode, ignore it. */
6718 for (i
= 0; i
< lh
->standard_opcode_lengths
[op_code
]; i
++)
6720 (void) read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
6721 line_ptr
+= bytes_read
;
6728 if (decode_for_pst_p
)
6732 /* Now that we're done scanning the Line Header Program, we can
6733 create the psymtab of each included file. */
6734 for (file_index
= 0; file_index
< lh
->num_file_names
; file_index
++)
6735 if (lh
->file_names
[file_index
].included_p
== 1)
6737 const struct file_entry fe
= lh
->file_names
[file_index
];
6738 char *include_name
= fe
.name
;
6739 char *dir_name
= NULL
;
6740 char *pst_filename
= pst
->filename
;
6743 dir_name
= lh
->include_dirs
[fe
.dir_index
- 1];
6745 if (!IS_ABSOLUTE_PATH (include_name
) && dir_name
!= NULL
)
6747 include_name
= concat (dir_name
, SLASH_STRING
,
6748 include_name
, (char *)NULL
);
6749 make_cleanup (xfree
, include_name
);
6752 if (!IS_ABSOLUTE_PATH (pst_filename
) && pst
->dirname
!= NULL
)
6754 pst_filename
= concat (pst
->dirname
, SLASH_STRING
,
6755 pst_filename
, (char *)NULL
);
6756 make_cleanup (xfree
, pst_filename
);
6759 if (strcmp (include_name
, pst_filename
) != 0)
6760 dwarf2_create_include_psymtab (include_name
, pst
, objfile
);
6765 /* Start a subfile for DWARF. FILENAME is the name of the file and
6766 DIRNAME the name of the source directory which contains FILENAME
6767 or NULL if not known. COMP_DIR is the compilation directory for the
6768 linetable's compilation unit or NULL if not known.
6769 This routine tries to keep line numbers from identical absolute and
6770 relative file names in a common subfile.
6772 Using the `list' example from the GDB testsuite, which resides in
6773 /srcdir and compiling it with Irix6.2 cc in /compdir using a filename
6774 of /srcdir/list0.c yields the following debugging information for list0.c:
6776 DW_AT_name: /srcdir/list0.c
6777 DW_AT_comp_dir: /compdir
6778 files.files[0].name: list0.h
6779 files.files[0].dir: /srcdir
6780 files.files[1].name: list0.c
6781 files.files[1].dir: /srcdir
6783 The line number information for list0.c has to end up in a single
6784 subfile, so that `break /srcdir/list0.c:1' works as expected.
6785 start_subfile will ensure that this happens provided that we pass the
6786 concatenation of files.files[1].dir and files.files[1].name as the
6790 dwarf2_start_subfile (char *filename
, char *dirname
, char *comp_dir
)
6794 /* While reading the DIEs, we call start_symtab(DW_AT_name, DW_AT_comp_dir).
6795 `start_symtab' will always pass the contents of DW_AT_comp_dir as
6796 second argument to start_subfile. To be consistent, we do the
6797 same here. In order not to lose the line information directory,
6798 we concatenate it to the filename when it makes sense.
6799 Note that the Dwarf3 standard says (speaking of filenames in line
6800 information): ``The directory index is ignored for file names
6801 that represent full path names''. Thus ignoring dirname in the
6802 `else' branch below isn't an issue. */
6804 if (!IS_ABSOLUTE_PATH (filename
) && dirname
!= NULL
)
6805 fullname
= concat (dirname
, SLASH_STRING
, filename
, (char *)NULL
);
6807 fullname
= filename
;
6809 start_subfile (fullname
, comp_dir
);
6811 if (fullname
!= filename
)
6816 var_decode_location (struct attribute
*attr
, struct symbol
*sym
,
6817 struct dwarf2_cu
*cu
)
6819 struct objfile
*objfile
= cu
->objfile
;
6820 struct comp_unit_head
*cu_header
= &cu
->header
;
6822 /* NOTE drow/2003-01-30: There used to be a comment and some special
6823 code here to turn a symbol with DW_AT_external and a
6824 SYMBOL_VALUE_ADDRESS of 0 into a LOC_UNRESOLVED symbol. This was
6825 necessary for platforms (maybe Alpha, certainly PowerPC GNU/Linux
6826 with some versions of binutils) where shared libraries could have
6827 relocations against symbols in their debug information - the
6828 minimal symbol would have the right address, but the debug info
6829 would not. It's no longer necessary, because we will explicitly
6830 apply relocations when we read in the debug information now. */
6832 /* A DW_AT_location attribute with no contents indicates that a
6833 variable has been optimized away. */
6834 if (attr_form_is_block (attr
) && DW_BLOCK (attr
)->size
== 0)
6836 SYMBOL_CLASS (sym
) = LOC_OPTIMIZED_OUT
;
6840 /* Handle one degenerate form of location expression specially, to
6841 preserve GDB's previous behavior when section offsets are
6842 specified. If this is just a DW_OP_addr then mark this symbol
6845 if (attr_form_is_block (attr
)
6846 && DW_BLOCK (attr
)->size
== 1 + cu_header
->addr_size
6847 && DW_BLOCK (attr
)->data
[0] == DW_OP_addr
)
6851 SYMBOL_VALUE_ADDRESS (sym
) =
6852 read_address (objfile
->obfd
, DW_BLOCK (attr
)->data
+ 1, cu
, &dummy
);
6853 fixup_symbol_section (sym
, objfile
);
6854 SYMBOL_VALUE_ADDRESS (sym
) += ANOFFSET (objfile
->section_offsets
,
6855 SYMBOL_SECTION (sym
));
6856 SYMBOL_CLASS (sym
) = LOC_STATIC
;
6860 /* NOTE drow/2002-01-30: It might be worthwhile to have a static
6861 expression evaluator, and use LOC_COMPUTED only when necessary
6862 (i.e. when the value of a register or memory location is
6863 referenced, or a thread-local block, etc.). Then again, it might
6864 not be worthwhile. I'm assuming that it isn't unless performance
6865 or memory numbers show me otherwise. */
6867 dwarf2_symbol_mark_computed (attr
, sym
, cu
);
6868 SYMBOL_CLASS (sym
) = LOC_COMPUTED
;
6871 /* Given a pointer to a DWARF information entry, figure out if we need
6872 to make a symbol table entry for it, and if so, create a new entry
6873 and return a pointer to it.
6874 If TYPE is NULL, determine symbol type from the die, otherwise
6875 used the passed type. */
6877 static struct symbol
*
6878 new_symbol (struct die_info
*die
, struct type
*type
, struct dwarf2_cu
*cu
)
6880 struct objfile
*objfile
= cu
->objfile
;
6881 struct symbol
*sym
= NULL
;
6883 struct attribute
*attr
= NULL
;
6884 struct attribute
*attr2
= NULL
;
6887 baseaddr
= ANOFFSET (objfile
->section_offsets
, SECT_OFF_TEXT (objfile
));
6889 if (die
->tag
!= DW_TAG_namespace
)
6890 name
= dwarf2_linkage_name (die
, cu
);
6892 name
= TYPE_NAME (type
);
6896 sym
= (struct symbol
*) obstack_alloc (&objfile
->objfile_obstack
,
6897 sizeof (struct symbol
));
6898 OBJSTAT (objfile
, n_syms
++);
6899 memset (sym
, 0, sizeof (struct symbol
));
6901 /* Cache this symbol's name and the name's demangled form (if any). */
6902 SYMBOL_LANGUAGE (sym
) = cu
->language
;
6903 SYMBOL_SET_NAMES (sym
, name
, strlen (name
), objfile
);
6905 /* Default assumptions.
6906 Use the passed type or decode it from the die. */
6907 SYMBOL_DOMAIN (sym
) = VAR_DOMAIN
;
6908 SYMBOL_CLASS (sym
) = LOC_OPTIMIZED_OUT
;
6910 SYMBOL_TYPE (sym
) = type
;
6912 SYMBOL_TYPE (sym
) = die_type (die
, cu
);
6913 attr
= dwarf2_attr (die
, DW_AT_decl_line
, cu
);
6916 SYMBOL_LINE (sym
) = DW_UNSND (attr
);
6921 attr
= dwarf2_attr (die
, DW_AT_low_pc
, cu
);
6924 SYMBOL_VALUE_ADDRESS (sym
) = DW_ADDR (attr
) + baseaddr
;
6926 SYMBOL_CLASS (sym
) = LOC_LABEL
;
6928 case DW_TAG_subprogram
:
6929 /* SYMBOL_BLOCK_VALUE (sym) will be filled in later by
6931 SYMBOL_CLASS (sym
) = LOC_BLOCK
;
6932 attr2
= dwarf2_attr (die
, DW_AT_external
, cu
);
6933 if (attr2
&& (DW_UNSND (attr2
) != 0))
6935 add_symbol_to_list (sym
, &global_symbols
);
6939 add_symbol_to_list (sym
, cu
->list_in_scope
);
6942 case DW_TAG_variable
:
6943 /* Compilation with minimal debug info may result in variables
6944 with missing type entries. Change the misleading `void' type
6945 to something sensible. */
6946 if (TYPE_CODE (SYMBOL_TYPE (sym
)) == TYPE_CODE_VOID
)
6947 SYMBOL_TYPE (sym
) = init_type (TYPE_CODE_INT
,
6948 TARGET_INT_BIT
/ HOST_CHAR_BIT
, 0,
6949 "<variable, no debug info>",
6951 attr
= dwarf2_attr (die
, DW_AT_const_value
, cu
);
6954 dwarf2_const_value (attr
, sym
, cu
);
6955 attr2
= dwarf2_attr (die
, DW_AT_external
, cu
);
6956 if (attr2
&& (DW_UNSND (attr2
) != 0))
6957 add_symbol_to_list (sym
, &global_symbols
);
6959 add_symbol_to_list (sym
, cu
->list_in_scope
);
6962 attr
= dwarf2_attr (die
, DW_AT_location
, cu
);
6965 var_decode_location (attr
, sym
, cu
);
6966 attr2
= dwarf2_attr (die
, DW_AT_external
, cu
);
6967 if (attr2
&& (DW_UNSND (attr2
) != 0))
6968 add_symbol_to_list (sym
, &global_symbols
);
6970 add_symbol_to_list (sym
, cu
->list_in_scope
);
6974 /* We do not know the address of this symbol.
6975 If it is an external symbol and we have type information
6976 for it, enter the symbol as a LOC_UNRESOLVED symbol.
6977 The address of the variable will then be determined from
6978 the minimal symbol table whenever the variable is
6980 attr2
= dwarf2_attr (die
, DW_AT_external
, cu
);
6981 if (attr2
&& (DW_UNSND (attr2
) != 0)
6982 && dwarf2_attr (die
, DW_AT_type
, cu
) != NULL
)
6984 SYMBOL_CLASS (sym
) = LOC_UNRESOLVED
;
6985 add_symbol_to_list (sym
, &global_symbols
);
6989 case DW_TAG_formal_parameter
:
6990 attr
= dwarf2_attr (die
, DW_AT_location
, cu
);
6993 var_decode_location (attr
, sym
, cu
);
6994 /* FIXME drow/2003-07-31: Is LOC_COMPUTED_ARG necessary? */
6995 if (SYMBOL_CLASS (sym
) == LOC_COMPUTED
)
6996 SYMBOL_CLASS (sym
) = LOC_COMPUTED_ARG
;
6998 attr
= dwarf2_attr (die
, DW_AT_const_value
, cu
);
7001 dwarf2_const_value (attr
, sym
, cu
);
7003 add_symbol_to_list (sym
, cu
->list_in_scope
);
7005 case DW_TAG_unspecified_parameters
:
7006 /* From varargs functions; gdb doesn't seem to have any
7007 interest in this information, so just ignore it for now.
7010 case DW_TAG_class_type
:
7011 case DW_TAG_structure_type
:
7012 case DW_TAG_union_type
:
7013 case DW_TAG_set_type
:
7014 case DW_TAG_enumeration_type
:
7015 SYMBOL_CLASS (sym
) = LOC_TYPEDEF
;
7016 SYMBOL_DOMAIN (sym
) = STRUCT_DOMAIN
;
7018 /* Make sure that the symbol includes appropriate enclosing
7019 classes/namespaces in its name. These are calculated in
7020 read_structure_type, and the correct name is saved in
7023 if (cu
->language
== language_cplus
7024 || cu
->language
== language_java
)
7026 struct type
*type
= SYMBOL_TYPE (sym
);
7028 if (TYPE_TAG_NAME (type
) != NULL
)
7030 /* FIXME: carlton/2003-11-10: Should this use
7031 SYMBOL_SET_NAMES instead? (The same problem also
7032 arises further down in this function.) */
7033 /* The type's name is already allocated along with
7034 this objfile, so we don't need to duplicate it
7036 SYMBOL_LINKAGE_NAME (sym
) = TYPE_TAG_NAME (type
);
7041 /* NOTE: carlton/2003-11-10: C++ and Java class symbols shouldn't
7042 really ever be static objects: otherwise, if you try
7043 to, say, break of a class's method and you're in a file
7044 which doesn't mention that class, it won't work unless
7045 the check for all static symbols in lookup_symbol_aux
7046 saves you. See the OtherFileClass tests in
7047 gdb.c++/namespace.exp. */
7049 struct pending
**list_to_add
;
7051 list_to_add
= (cu
->list_in_scope
== &file_symbols
7052 && (cu
->language
== language_cplus
7053 || cu
->language
== language_java
)
7054 ? &global_symbols
: cu
->list_in_scope
);
7056 add_symbol_to_list (sym
, list_to_add
);
7058 /* The semantics of C++ state that "struct foo { ... }" also
7059 defines a typedef for "foo". A Java class declaration also
7060 defines a typedef for the class. Synthesize a typedef symbol
7061 so that "ptype foo" works as expected. */
7062 if (cu
->language
== language_cplus
7063 || cu
->language
== language_java
)
7065 struct symbol
*typedef_sym
= (struct symbol
*)
7066 obstack_alloc (&objfile
->objfile_obstack
,
7067 sizeof (struct symbol
));
7068 *typedef_sym
= *sym
;
7069 SYMBOL_DOMAIN (typedef_sym
) = VAR_DOMAIN
;
7070 /* The symbol's name is already allocated along with
7071 this objfile, so we don't need to duplicate it for
7073 if (TYPE_NAME (SYMBOL_TYPE (sym
)) == 0)
7074 TYPE_NAME (SYMBOL_TYPE (sym
)) = SYMBOL_SEARCH_NAME (sym
);
7075 add_symbol_to_list (typedef_sym
, list_to_add
);
7079 case DW_TAG_typedef
:
7080 if (processing_has_namespace_info
7081 && processing_current_prefix
[0] != '\0')
7083 SYMBOL_LINKAGE_NAME (sym
) = typename_concat (&objfile
->objfile_obstack
,
7084 processing_current_prefix
,
7087 SYMBOL_CLASS (sym
) = LOC_TYPEDEF
;
7088 SYMBOL_DOMAIN (sym
) = VAR_DOMAIN
;
7089 add_symbol_to_list (sym
, cu
->list_in_scope
);
7091 case DW_TAG_base_type
:
7092 case DW_TAG_subrange_type
:
7093 SYMBOL_CLASS (sym
) = LOC_TYPEDEF
;
7094 SYMBOL_DOMAIN (sym
) = VAR_DOMAIN
;
7095 add_symbol_to_list (sym
, cu
->list_in_scope
);
7097 case DW_TAG_enumerator
:
7098 if (processing_has_namespace_info
7099 && processing_current_prefix
[0] != '\0')
7101 SYMBOL_LINKAGE_NAME (sym
) = typename_concat (&objfile
->objfile_obstack
,
7102 processing_current_prefix
,
7105 attr
= dwarf2_attr (die
, DW_AT_const_value
, cu
);
7108 dwarf2_const_value (attr
, sym
, cu
);
7111 /* NOTE: carlton/2003-11-10: See comment above in the
7112 DW_TAG_class_type, etc. block. */
7114 struct pending
**list_to_add
;
7116 list_to_add
= (cu
->list_in_scope
== &file_symbols
7117 && (cu
->language
== language_cplus
7118 || cu
->language
== language_java
)
7119 ? &global_symbols
: cu
->list_in_scope
);
7121 add_symbol_to_list (sym
, list_to_add
);
7124 case DW_TAG_namespace
:
7125 SYMBOL_CLASS (sym
) = LOC_TYPEDEF
;
7126 add_symbol_to_list (sym
, &global_symbols
);
7129 /* Not a tag we recognize. Hopefully we aren't processing
7130 trash data, but since we must specifically ignore things
7131 we don't recognize, there is nothing else we should do at
7133 complaint (&symfile_complaints
, _("unsupported tag: '%s'"),
7134 dwarf_tag_name (die
->tag
));
7141 /* Copy constant value from an attribute to a symbol. */
7144 dwarf2_const_value (struct attribute
*attr
, struct symbol
*sym
,
7145 struct dwarf2_cu
*cu
)
7147 struct objfile
*objfile
= cu
->objfile
;
7148 struct comp_unit_head
*cu_header
= &cu
->header
;
7149 struct dwarf_block
*blk
;
7154 if (TYPE_LENGTH (SYMBOL_TYPE (sym
)) != cu_header
->addr_size
)
7155 dwarf2_const_value_length_mismatch_complaint (DEPRECATED_SYMBOL_NAME (sym
),
7156 cu_header
->addr_size
,
7157 TYPE_LENGTH (SYMBOL_TYPE
7159 SYMBOL_VALUE_BYTES (sym
) =
7160 obstack_alloc (&objfile
->objfile_obstack
, cu_header
->addr_size
);
7161 /* NOTE: cagney/2003-05-09: In-lined store_address call with
7162 it's body - store_unsigned_integer. */
7163 store_unsigned_integer (SYMBOL_VALUE_BYTES (sym
), cu_header
->addr_size
,
7165 SYMBOL_CLASS (sym
) = LOC_CONST_BYTES
;
7167 case DW_FORM_block1
:
7168 case DW_FORM_block2
:
7169 case DW_FORM_block4
:
7171 blk
= DW_BLOCK (attr
);
7172 if (TYPE_LENGTH (SYMBOL_TYPE (sym
)) != blk
->size
)
7173 dwarf2_const_value_length_mismatch_complaint (DEPRECATED_SYMBOL_NAME (sym
),
7175 TYPE_LENGTH (SYMBOL_TYPE
7177 SYMBOL_VALUE_BYTES (sym
) =
7178 obstack_alloc (&objfile
->objfile_obstack
, blk
->size
);
7179 memcpy (SYMBOL_VALUE_BYTES (sym
), blk
->data
, blk
->size
);
7180 SYMBOL_CLASS (sym
) = LOC_CONST_BYTES
;
7183 /* The DW_AT_const_value attributes are supposed to carry the
7184 symbol's value "represented as it would be on the target
7185 architecture." By the time we get here, it's already been
7186 converted to host endianness, so we just need to sign- or
7187 zero-extend it as appropriate. */
7189 dwarf2_const_value_data (attr
, sym
, 8);
7192 dwarf2_const_value_data (attr
, sym
, 16);
7195 dwarf2_const_value_data (attr
, sym
, 32);
7198 dwarf2_const_value_data (attr
, sym
, 64);
7202 SYMBOL_VALUE (sym
) = DW_SND (attr
);
7203 SYMBOL_CLASS (sym
) = LOC_CONST
;
7207 SYMBOL_VALUE (sym
) = DW_UNSND (attr
);
7208 SYMBOL_CLASS (sym
) = LOC_CONST
;
7212 complaint (&symfile_complaints
,
7213 _("unsupported const value attribute form: '%s'"),
7214 dwarf_form_name (attr
->form
));
7215 SYMBOL_VALUE (sym
) = 0;
7216 SYMBOL_CLASS (sym
) = LOC_CONST
;
7222 /* Given an attr with a DW_FORM_dataN value in host byte order, sign-
7223 or zero-extend it as appropriate for the symbol's type. */
7225 dwarf2_const_value_data (struct attribute
*attr
,
7229 LONGEST l
= DW_UNSND (attr
);
7231 if (bits
< sizeof (l
) * 8)
7233 if (TYPE_UNSIGNED (SYMBOL_TYPE (sym
)))
7234 l
&= ((LONGEST
) 1 << bits
) - 1;
7236 l
= (l
<< (sizeof (l
) * 8 - bits
)) >> (sizeof (l
) * 8 - bits
);
7239 SYMBOL_VALUE (sym
) = l
;
7240 SYMBOL_CLASS (sym
) = LOC_CONST
;
7244 /* Return the type of the die in question using its DW_AT_type attribute. */
7246 static struct type
*
7247 die_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
7250 struct attribute
*type_attr
;
7251 struct die_info
*type_die
;
7253 type_attr
= dwarf2_attr (die
, DW_AT_type
, cu
);
7256 /* A missing DW_AT_type represents a void type. */
7257 return dwarf2_fundamental_type (cu
->objfile
, FT_VOID
, cu
);
7260 type_die
= follow_die_ref (die
, type_attr
, cu
);
7262 type
= tag_type_to_type (type_die
, cu
);
7265 dump_die (type_die
);
7266 error (_("Dwarf Error: Problem turning type die at offset into gdb type [in module %s]"),
7272 /* Return the containing type of the die in question using its
7273 DW_AT_containing_type attribute. */
7275 static struct type
*
7276 die_containing_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
7278 struct type
*type
= NULL
;
7279 struct attribute
*type_attr
;
7280 struct die_info
*type_die
= NULL
;
7282 type_attr
= dwarf2_attr (die
, DW_AT_containing_type
, cu
);
7285 type_die
= follow_die_ref (die
, type_attr
, cu
);
7286 type
= tag_type_to_type (type_die
, cu
);
7291 dump_die (type_die
);
7292 error (_("Dwarf Error: Problem turning containing type into gdb type [in module %s]"),
7298 static struct type
*
7299 tag_type_to_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
7307 read_type_die (die
, cu
);
7311 error (_("Dwarf Error: Cannot find type of die [in module %s]"),
7319 read_type_die (struct die_info
*die
, struct dwarf2_cu
*cu
)
7321 char *prefix
= determine_prefix (die
, cu
);
7322 const char *old_prefix
= processing_current_prefix
;
7323 struct cleanup
*back_to
= make_cleanup (xfree
, prefix
);
7324 processing_current_prefix
= prefix
;
7328 case DW_TAG_class_type
:
7329 case DW_TAG_structure_type
:
7330 case DW_TAG_union_type
:
7331 read_structure_type (die
, cu
);
7333 case DW_TAG_enumeration_type
:
7334 read_enumeration_type (die
, cu
);
7336 case DW_TAG_subprogram
:
7337 case DW_TAG_subroutine_type
:
7338 read_subroutine_type (die
, cu
);
7340 case DW_TAG_array_type
:
7341 read_array_type (die
, cu
);
7343 case DW_TAG_set_type
:
7344 read_set_type (die
, cu
);
7346 case DW_TAG_pointer_type
:
7347 read_tag_pointer_type (die
, cu
);
7349 case DW_TAG_ptr_to_member_type
:
7350 read_tag_ptr_to_member_type (die
, cu
);
7352 case DW_TAG_reference_type
:
7353 read_tag_reference_type (die
, cu
);
7355 case DW_TAG_const_type
:
7356 read_tag_const_type (die
, cu
);
7358 case DW_TAG_volatile_type
:
7359 read_tag_volatile_type (die
, cu
);
7361 case DW_TAG_string_type
:
7362 read_tag_string_type (die
, cu
);
7364 case DW_TAG_typedef
:
7365 read_typedef (die
, cu
);
7367 case DW_TAG_subrange_type
:
7368 read_subrange_type (die
, cu
);
7370 case DW_TAG_base_type
:
7371 read_base_type (die
, cu
);
7373 case DW_TAG_unspecified_type
:
7374 read_unspecified_type (die
, cu
);
7377 complaint (&symfile_complaints
, _("unexpected tag in read_type_die: '%s'"),
7378 dwarf_tag_name (die
->tag
));
7382 processing_current_prefix
= old_prefix
;
7383 do_cleanups (back_to
);
7386 /* Return the name of the namespace/class that DIE is defined within,
7387 or "" if we can't tell. The caller should xfree the result. */
7389 /* NOTE: carlton/2004-01-23: See read_func_scope (and the comment
7390 therein) for an example of how to use this function to deal with
7391 DW_AT_specification. */
7394 determine_prefix (struct die_info
*die
, struct dwarf2_cu
*cu
)
7396 struct die_info
*parent
;
7398 if (cu
->language
!= language_cplus
7399 && cu
->language
!= language_java
)
7402 parent
= die
->parent
;
7406 return xstrdup ("");
7410 switch (parent
->tag
) {
7411 case DW_TAG_namespace
:
7413 /* FIXME: carlton/2004-03-05: Should I follow extension dies
7414 before doing this check? */
7415 if (parent
->type
!= NULL
&& TYPE_TAG_NAME (parent
->type
) != NULL
)
7417 return xstrdup (TYPE_TAG_NAME (parent
->type
));
7422 char *parent_prefix
= determine_prefix (parent
, cu
);
7423 char *retval
= typename_concat (NULL
, parent_prefix
,
7424 namespace_name (parent
, &dummy
,
7427 xfree (parent_prefix
);
7432 case DW_TAG_class_type
:
7433 case DW_TAG_structure_type
:
7435 if (parent
->type
!= NULL
&& TYPE_TAG_NAME (parent
->type
) != NULL
)
7437 return xstrdup (TYPE_TAG_NAME (parent
->type
));
7441 const char *old_prefix
= processing_current_prefix
;
7442 char *new_prefix
= determine_prefix (parent
, cu
);
7445 processing_current_prefix
= new_prefix
;
7446 retval
= determine_class_name (parent
, cu
);
7447 processing_current_prefix
= old_prefix
;
7454 return determine_prefix (parent
, cu
);
7459 /* Return a newly-allocated string formed by concatenating PREFIX and
7460 SUFFIX with appropriate separator. If PREFIX or SUFFIX is NULL or empty, then
7461 simply copy the SUFFIX or PREFIX, respectively. If OBS is non-null,
7462 perform an obconcat, otherwise allocate storage for the result. The CU argument
7463 is used to determine the language and hence, the appropriate separator. */
7465 #define MAX_SEP_LEN 2 /* sizeof ("::") */
7468 typename_concat (struct obstack
*obs
, const char *prefix
, const char *suffix
,
7469 struct dwarf2_cu
*cu
)
7473 if (suffix
== NULL
|| suffix
[0] == '\0' || prefix
== NULL
|| prefix
[0] == '\0')
7475 else if (cu
->language
== language_java
)
7482 char *retval
= xmalloc (strlen (prefix
) + MAX_SEP_LEN
+ strlen (suffix
) + 1);
7487 strcpy (retval
, prefix
);
7488 strcat (retval
, sep
);
7491 strcat (retval
, suffix
);
7497 /* We have an obstack. */
7498 return obconcat (obs
, prefix
, sep
, suffix
);
7502 static struct type
*
7503 dwarf_base_type (int encoding
, int size
, struct dwarf2_cu
*cu
)
7505 struct objfile
*objfile
= cu
->objfile
;
7507 /* FIXME - this should not produce a new (struct type *)
7508 every time. It should cache base types. */
7512 case DW_ATE_address
:
7513 type
= dwarf2_fundamental_type (objfile
, FT_VOID
, cu
);
7515 case DW_ATE_boolean
:
7516 type
= dwarf2_fundamental_type (objfile
, FT_BOOLEAN
, cu
);
7518 case DW_ATE_complex_float
:
7521 type
= dwarf2_fundamental_type (objfile
, FT_DBL_PREC_COMPLEX
, cu
);
7525 type
= dwarf2_fundamental_type (objfile
, FT_COMPLEX
, cu
);
7531 type
= dwarf2_fundamental_type (objfile
, FT_DBL_PREC_FLOAT
, cu
);
7535 type
= dwarf2_fundamental_type (objfile
, FT_FLOAT
, cu
);
7542 type
= dwarf2_fundamental_type (objfile
, FT_SIGNED_CHAR
, cu
);
7545 type
= dwarf2_fundamental_type (objfile
, FT_SIGNED_SHORT
, cu
);
7549 type
= dwarf2_fundamental_type (objfile
, FT_SIGNED_INTEGER
, cu
);
7553 case DW_ATE_signed_char
:
7554 type
= dwarf2_fundamental_type (objfile
, FT_SIGNED_CHAR
, cu
);
7556 case DW_ATE_unsigned
:
7560 type
= dwarf2_fundamental_type (objfile
, FT_UNSIGNED_CHAR
, cu
);
7563 type
= dwarf2_fundamental_type (objfile
, FT_UNSIGNED_SHORT
, cu
);
7567 type
= dwarf2_fundamental_type (objfile
, FT_UNSIGNED_INTEGER
, cu
);
7571 case DW_ATE_unsigned_char
:
7572 type
= dwarf2_fundamental_type (objfile
, FT_UNSIGNED_CHAR
, cu
);
7575 type
= dwarf2_fundamental_type (objfile
, FT_SIGNED_INTEGER
, cu
);
7582 copy_die (struct die_info
*old_die
)
7584 struct die_info
*new_die
;
7587 new_die
= (struct die_info
*) xmalloc (sizeof (struct die_info
));
7588 memset (new_die
, 0, sizeof (struct die_info
));
7590 new_die
->tag
= old_die
->tag
;
7591 new_die
->has_children
= old_die
->has_children
;
7592 new_die
->abbrev
= old_die
->abbrev
;
7593 new_die
->offset
= old_die
->offset
;
7594 new_die
->type
= NULL
;
7596 num_attrs
= old_die
->num_attrs
;
7597 new_die
->num_attrs
= num_attrs
;
7598 new_die
->attrs
= (struct attribute
*)
7599 xmalloc (num_attrs
* sizeof (struct attribute
));
7601 for (i
= 0; i
< old_die
->num_attrs
; ++i
)
7603 new_die
->attrs
[i
].name
= old_die
->attrs
[i
].name
;
7604 new_die
->attrs
[i
].form
= old_die
->attrs
[i
].form
;
7605 new_die
->attrs
[i
].u
.addr
= old_die
->attrs
[i
].u
.addr
;
7608 new_die
->next
= NULL
;
7613 /* Return sibling of die, NULL if no sibling. */
7615 static struct die_info
*
7616 sibling_die (struct die_info
*die
)
7618 return die
->sibling
;
7621 /* Get linkage name of a die, return NULL if not found. */
7624 dwarf2_linkage_name (struct die_info
*die
, struct dwarf2_cu
*cu
)
7626 struct attribute
*attr
;
7628 attr
= dwarf2_attr (die
, DW_AT_MIPS_linkage_name
, cu
);
7629 if (attr
&& DW_STRING (attr
))
7630 return DW_STRING (attr
);
7631 attr
= dwarf2_attr (die
, DW_AT_name
, cu
);
7632 if (attr
&& DW_STRING (attr
))
7633 return DW_STRING (attr
);
7637 /* Get name of a die, return NULL if not found. */
7640 dwarf2_name (struct die_info
*die
, struct dwarf2_cu
*cu
)
7642 struct attribute
*attr
;
7644 attr
= dwarf2_attr (die
, DW_AT_name
, cu
);
7645 if (attr
&& DW_STRING (attr
))
7646 return DW_STRING (attr
);
7650 /* Return the die that this die in an extension of, or NULL if there
7653 static struct die_info
*
7654 dwarf2_extension (struct die_info
*die
, struct dwarf2_cu
*cu
)
7656 struct attribute
*attr
;
7658 attr
= dwarf2_attr (die
, DW_AT_extension
, cu
);
7662 return follow_die_ref (die
, attr
, cu
);
7665 /* Convert a DIE tag into its string name. */
7668 dwarf_tag_name (unsigned tag
)
7672 case DW_TAG_padding
:
7673 return "DW_TAG_padding";
7674 case DW_TAG_array_type
:
7675 return "DW_TAG_array_type";
7676 case DW_TAG_class_type
:
7677 return "DW_TAG_class_type";
7678 case DW_TAG_entry_point
:
7679 return "DW_TAG_entry_point";
7680 case DW_TAG_enumeration_type
:
7681 return "DW_TAG_enumeration_type";
7682 case DW_TAG_formal_parameter
:
7683 return "DW_TAG_formal_parameter";
7684 case DW_TAG_imported_declaration
:
7685 return "DW_TAG_imported_declaration";
7687 return "DW_TAG_label";
7688 case DW_TAG_lexical_block
:
7689 return "DW_TAG_lexical_block";
7691 return "DW_TAG_member";
7692 case DW_TAG_pointer_type
:
7693 return "DW_TAG_pointer_type";
7694 case DW_TAG_reference_type
:
7695 return "DW_TAG_reference_type";
7696 case DW_TAG_compile_unit
:
7697 return "DW_TAG_compile_unit";
7698 case DW_TAG_string_type
:
7699 return "DW_TAG_string_type";
7700 case DW_TAG_structure_type
:
7701 return "DW_TAG_structure_type";
7702 case DW_TAG_subroutine_type
:
7703 return "DW_TAG_subroutine_type";
7704 case DW_TAG_typedef
:
7705 return "DW_TAG_typedef";
7706 case DW_TAG_union_type
:
7707 return "DW_TAG_union_type";
7708 case DW_TAG_unspecified_parameters
:
7709 return "DW_TAG_unspecified_parameters";
7710 case DW_TAG_variant
:
7711 return "DW_TAG_variant";
7712 case DW_TAG_common_block
:
7713 return "DW_TAG_common_block";
7714 case DW_TAG_common_inclusion
:
7715 return "DW_TAG_common_inclusion";
7716 case DW_TAG_inheritance
:
7717 return "DW_TAG_inheritance";
7718 case DW_TAG_inlined_subroutine
:
7719 return "DW_TAG_inlined_subroutine";
7721 return "DW_TAG_module";
7722 case DW_TAG_ptr_to_member_type
:
7723 return "DW_TAG_ptr_to_member_type";
7724 case DW_TAG_set_type
:
7725 return "DW_TAG_set_type";
7726 case DW_TAG_subrange_type
:
7727 return "DW_TAG_subrange_type";
7728 case DW_TAG_with_stmt
:
7729 return "DW_TAG_with_stmt";
7730 case DW_TAG_access_declaration
:
7731 return "DW_TAG_access_declaration";
7732 case DW_TAG_base_type
:
7733 return "DW_TAG_base_type";
7734 case DW_TAG_catch_block
:
7735 return "DW_TAG_catch_block";
7736 case DW_TAG_const_type
:
7737 return "DW_TAG_const_type";
7738 case DW_TAG_constant
:
7739 return "DW_TAG_constant";
7740 case DW_TAG_enumerator
:
7741 return "DW_TAG_enumerator";
7742 case DW_TAG_file_type
:
7743 return "DW_TAG_file_type";
7745 return "DW_TAG_friend";
7746 case DW_TAG_namelist
:
7747 return "DW_TAG_namelist";
7748 case DW_TAG_namelist_item
:
7749 return "DW_TAG_namelist_item";
7750 case DW_TAG_packed_type
:
7751 return "DW_TAG_packed_type";
7752 case DW_TAG_subprogram
:
7753 return "DW_TAG_subprogram";
7754 case DW_TAG_template_type_param
:
7755 return "DW_TAG_template_type_param";
7756 case DW_TAG_template_value_param
:
7757 return "DW_TAG_template_value_param";
7758 case DW_TAG_thrown_type
:
7759 return "DW_TAG_thrown_type";
7760 case DW_TAG_try_block
:
7761 return "DW_TAG_try_block";
7762 case DW_TAG_variant_part
:
7763 return "DW_TAG_variant_part";
7764 case DW_TAG_variable
:
7765 return "DW_TAG_variable";
7766 case DW_TAG_volatile_type
:
7767 return "DW_TAG_volatile_type";
7768 case DW_TAG_dwarf_procedure
:
7769 return "DW_TAG_dwarf_procedure";
7770 case DW_TAG_restrict_type
:
7771 return "DW_TAG_restrict_type";
7772 case DW_TAG_interface_type
:
7773 return "DW_TAG_interface_type";
7774 case DW_TAG_namespace
:
7775 return "DW_TAG_namespace";
7776 case DW_TAG_imported_module
:
7777 return "DW_TAG_imported_module";
7778 case DW_TAG_unspecified_type
:
7779 return "DW_TAG_unspecified_type";
7780 case DW_TAG_partial_unit
:
7781 return "DW_TAG_partial_unit";
7782 case DW_TAG_imported_unit
:
7783 return "DW_TAG_imported_unit";
7784 case DW_TAG_MIPS_loop
:
7785 return "DW_TAG_MIPS_loop";
7786 case DW_TAG_format_label
:
7787 return "DW_TAG_format_label";
7788 case DW_TAG_function_template
:
7789 return "DW_TAG_function_template";
7790 case DW_TAG_class_template
:
7791 return "DW_TAG_class_template";
7793 return "DW_TAG_<unknown>";
7797 /* Convert a DWARF attribute code into its string name. */
7800 dwarf_attr_name (unsigned attr
)
7805 return "DW_AT_sibling";
7806 case DW_AT_location
:
7807 return "DW_AT_location";
7809 return "DW_AT_name";
7810 case DW_AT_ordering
:
7811 return "DW_AT_ordering";
7812 case DW_AT_subscr_data
:
7813 return "DW_AT_subscr_data";
7814 case DW_AT_byte_size
:
7815 return "DW_AT_byte_size";
7816 case DW_AT_bit_offset
:
7817 return "DW_AT_bit_offset";
7818 case DW_AT_bit_size
:
7819 return "DW_AT_bit_size";
7820 case DW_AT_element_list
:
7821 return "DW_AT_element_list";
7822 case DW_AT_stmt_list
:
7823 return "DW_AT_stmt_list";
7825 return "DW_AT_low_pc";
7827 return "DW_AT_high_pc";
7828 case DW_AT_language
:
7829 return "DW_AT_language";
7831 return "DW_AT_member";
7833 return "DW_AT_discr";
7834 case DW_AT_discr_value
:
7835 return "DW_AT_discr_value";
7836 case DW_AT_visibility
:
7837 return "DW_AT_visibility";
7839 return "DW_AT_import";
7840 case DW_AT_string_length
:
7841 return "DW_AT_string_length";
7842 case DW_AT_common_reference
:
7843 return "DW_AT_common_reference";
7844 case DW_AT_comp_dir
:
7845 return "DW_AT_comp_dir";
7846 case DW_AT_const_value
:
7847 return "DW_AT_const_value";
7848 case DW_AT_containing_type
:
7849 return "DW_AT_containing_type";
7850 case DW_AT_default_value
:
7851 return "DW_AT_default_value";
7853 return "DW_AT_inline";
7854 case DW_AT_is_optional
:
7855 return "DW_AT_is_optional";
7856 case DW_AT_lower_bound
:
7857 return "DW_AT_lower_bound";
7858 case DW_AT_producer
:
7859 return "DW_AT_producer";
7860 case DW_AT_prototyped
:
7861 return "DW_AT_prototyped";
7862 case DW_AT_return_addr
:
7863 return "DW_AT_return_addr";
7864 case DW_AT_start_scope
:
7865 return "DW_AT_start_scope";
7866 case DW_AT_stride_size
:
7867 return "DW_AT_stride_size";
7868 case DW_AT_upper_bound
:
7869 return "DW_AT_upper_bound";
7870 case DW_AT_abstract_origin
:
7871 return "DW_AT_abstract_origin";
7872 case DW_AT_accessibility
:
7873 return "DW_AT_accessibility";
7874 case DW_AT_address_class
:
7875 return "DW_AT_address_class";
7876 case DW_AT_artificial
:
7877 return "DW_AT_artificial";
7878 case DW_AT_base_types
:
7879 return "DW_AT_base_types";
7880 case DW_AT_calling_convention
:
7881 return "DW_AT_calling_convention";
7883 return "DW_AT_count";
7884 case DW_AT_data_member_location
:
7885 return "DW_AT_data_member_location";
7886 case DW_AT_decl_column
:
7887 return "DW_AT_decl_column";
7888 case DW_AT_decl_file
:
7889 return "DW_AT_decl_file";
7890 case DW_AT_decl_line
:
7891 return "DW_AT_decl_line";
7892 case DW_AT_declaration
:
7893 return "DW_AT_declaration";
7894 case DW_AT_discr_list
:
7895 return "DW_AT_discr_list";
7896 case DW_AT_encoding
:
7897 return "DW_AT_encoding";
7898 case DW_AT_external
:
7899 return "DW_AT_external";
7900 case DW_AT_frame_base
:
7901 return "DW_AT_frame_base";
7903 return "DW_AT_friend";
7904 case DW_AT_identifier_case
:
7905 return "DW_AT_identifier_case";
7906 case DW_AT_macro_info
:
7907 return "DW_AT_macro_info";
7908 case DW_AT_namelist_items
:
7909 return "DW_AT_namelist_items";
7910 case DW_AT_priority
:
7911 return "DW_AT_priority";
7913 return "DW_AT_segment";
7914 case DW_AT_specification
:
7915 return "DW_AT_specification";
7916 case DW_AT_static_link
:
7917 return "DW_AT_static_link";
7919 return "DW_AT_type";
7920 case DW_AT_use_location
:
7921 return "DW_AT_use_location";
7922 case DW_AT_variable_parameter
:
7923 return "DW_AT_variable_parameter";
7924 case DW_AT_virtuality
:
7925 return "DW_AT_virtuality";
7926 case DW_AT_vtable_elem_location
:
7927 return "DW_AT_vtable_elem_location";
7928 case DW_AT_allocated
:
7929 return "DW_AT_allocated";
7930 case DW_AT_associated
:
7931 return "DW_AT_associated";
7932 case DW_AT_data_location
:
7933 return "DW_AT_data_location";
7935 return "DW_AT_stride";
7936 case DW_AT_entry_pc
:
7937 return "DW_AT_entry_pc";
7938 case DW_AT_use_UTF8
:
7939 return "DW_AT_use_UTF8";
7940 case DW_AT_extension
:
7941 return "DW_AT_extension";
7943 return "DW_AT_ranges";
7944 case DW_AT_trampoline
:
7945 return "DW_AT_trampoline";
7946 case DW_AT_call_column
:
7947 return "DW_AT_call_column";
7948 case DW_AT_call_file
:
7949 return "DW_AT_call_file";
7950 case DW_AT_call_line
:
7951 return "DW_AT_call_line";
7953 case DW_AT_MIPS_fde
:
7954 return "DW_AT_MIPS_fde";
7955 case DW_AT_MIPS_loop_begin
:
7956 return "DW_AT_MIPS_loop_begin";
7957 case DW_AT_MIPS_tail_loop_begin
:
7958 return "DW_AT_MIPS_tail_loop_begin";
7959 case DW_AT_MIPS_epilog_begin
:
7960 return "DW_AT_MIPS_epilog_begin";
7961 case DW_AT_MIPS_loop_unroll_factor
:
7962 return "DW_AT_MIPS_loop_unroll_factor";
7963 case DW_AT_MIPS_software_pipeline_depth
:
7964 return "DW_AT_MIPS_software_pipeline_depth";
7966 case DW_AT_MIPS_linkage_name
:
7967 return "DW_AT_MIPS_linkage_name";
7969 case DW_AT_sf_names
:
7970 return "DW_AT_sf_names";
7971 case DW_AT_src_info
:
7972 return "DW_AT_src_info";
7973 case DW_AT_mac_info
:
7974 return "DW_AT_mac_info";
7975 case DW_AT_src_coords
:
7976 return "DW_AT_src_coords";
7977 case DW_AT_body_begin
:
7978 return "DW_AT_body_begin";
7979 case DW_AT_body_end
:
7980 return "DW_AT_body_end";
7981 case DW_AT_GNU_vector
:
7982 return "DW_AT_GNU_vector";
7984 return "DW_AT_<unknown>";
7988 /* Convert a DWARF value form code into its string name. */
7991 dwarf_form_name (unsigned form
)
7996 return "DW_FORM_addr";
7997 case DW_FORM_block2
:
7998 return "DW_FORM_block2";
7999 case DW_FORM_block4
:
8000 return "DW_FORM_block4";
8002 return "DW_FORM_data2";
8004 return "DW_FORM_data4";
8006 return "DW_FORM_data8";
8007 case DW_FORM_string
:
8008 return "DW_FORM_string";
8010 return "DW_FORM_block";
8011 case DW_FORM_block1
:
8012 return "DW_FORM_block1";
8014 return "DW_FORM_data1";
8016 return "DW_FORM_flag";
8018 return "DW_FORM_sdata";
8020 return "DW_FORM_strp";
8022 return "DW_FORM_udata";
8023 case DW_FORM_ref_addr
:
8024 return "DW_FORM_ref_addr";
8026 return "DW_FORM_ref1";
8028 return "DW_FORM_ref2";
8030 return "DW_FORM_ref4";
8032 return "DW_FORM_ref8";
8033 case DW_FORM_ref_udata
:
8034 return "DW_FORM_ref_udata";
8035 case DW_FORM_indirect
:
8036 return "DW_FORM_indirect";
8038 return "DW_FORM_<unknown>";
8042 /* Convert a DWARF stack opcode into its string name. */
8045 dwarf_stack_op_name (unsigned op
)
8050 return "DW_OP_addr";
8052 return "DW_OP_deref";
8054 return "DW_OP_const1u";
8056 return "DW_OP_const1s";
8058 return "DW_OP_const2u";
8060 return "DW_OP_const2s";
8062 return "DW_OP_const4u";
8064 return "DW_OP_const4s";
8066 return "DW_OP_const8u";
8068 return "DW_OP_const8s";
8070 return "DW_OP_constu";
8072 return "DW_OP_consts";
8076 return "DW_OP_drop";
8078 return "DW_OP_over";
8080 return "DW_OP_pick";
8082 return "DW_OP_swap";
8086 return "DW_OP_xderef";
8094 return "DW_OP_minus";
8106 return "DW_OP_plus";
8107 case DW_OP_plus_uconst
:
8108 return "DW_OP_plus_uconst";
8114 return "DW_OP_shra";
8132 return "DW_OP_skip";
8134 return "DW_OP_lit0";
8136 return "DW_OP_lit1";
8138 return "DW_OP_lit2";
8140 return "DW_OP_lit3";
8142 return "DW_OP_lit4";
8144 return "DW_OP_lit5";
8146 return "DW_OP_lit6";
8148 return "DW_OP_lit7";
8150 return "DW_OP_lit8";
8152 return "DW_OP_lit9";
8154 return "DW_OP_lit10";
8156 return "DW_OP_lit11";
8158 return "DW_OP_lit12";
8160 return "DW_OP_lit13";
8162 return "DW_OP_lit14";
8164 return "DW_OP_lit15";
8166 return "DW_OP_lit16";
8168 return "DW_OP_lit17";
8170 return "DW_OP_lit18";
8172 return "DW_OP_lit19";
8174 return "DW_OP_lit20";
8176 return "DW_OP_lit21";
8178 return "DW_OP_lit22";
8180 return "DW_OP_lit23";
8182 return "DW_OP_lit24";
8184 return "DW_OP_lit25";
8186 return "DW_OP_lit26";
8188 return "DW_OP_lit27";
8190 return "DW_OP_lit28";
8192 return "DW_OP_lit29";
8194 return "DW_OP_lit30";
8196 return "DW_OP_lit31";
8198 return "DW_OP_reg0";
8200 return "DW_OP_reg1";
8202 return "DW_OP_reg2";
8204 return "DW_OP_reg3";
8206 return "DW_OP_reg4";
8208 return "DW_OP_reg5";
8210 return "DW_OP_reg6";
8212 return "DW_OP_reg7";
8214 return "DW_OP_reg8";
8216 return "DW_OP_reg9";
8218 return "DW_OP_reg10";
8220 return "DW_OP_reg11";
8222 return "DW_OP_reg12";
8224 return "DW_OP_reg13";
8226 return "DW_OP_reg14";
8228 return "DW_OP_reg15";
8230 return "DW_OP_reg16";
8232 return "DW_OP_reg17";
8234 return "DW_OP_reg18";
8236 return "DW_OP_reg19";
8238 return "DW_OP_reg20";
8240 return "DW_OP_reg21";
8242 return "DW_OP_reg22";
8244 return "DW_OP_reg23";
8246 return "DW_OP_reg24";
8248 return "DW_OP_reg25";
8250 return "DW_OP_reg26";
8252 return "DW_OP_reg27";
8254 return "DW_OP_reg28";
8256 return "DW_OP_reg29";
8258 return "DW_OP_reg30";
8260 return "DW_OP_reg31";
8262 return "DW_OP_breg0";
8264 return "DW_OP_breg1";
8266 return "DW_OP_breg2";
8268 return "DW_OP_breg3";
8270 return "DW_OP_breg4";
8272 return "DW_OP_breg5";
8274 return "DW_OP_breg6";
8276 return "DW_OP_breg7";
8278 return "DW_OP_breg8";
8280 return "DW_OP_breg9";
8282 return "DW_OP_breg10";
8284 return "DW_OP_breg11";
8286 return "DW_OP_breg12";
8288 return "DW_OP_breg13";
8290 return "DW_OP_breg14";
8292 return "DW_OP_breg15";
8294 return "DW_OP_breg16";
8296 return "DW_OP_breg17";
8298 return "DW_OP_breg18";
8300 return "DW_OP_breg19";
8302 return "DW_OP_breg20";
8304 return "DW_OP_breg21";
8306 return "DW_OP_breg22";
8308 return "DW_OP_breg23";
8310 return "DW_OP_breg24";
8312 return "DW_OP_breg25";
8314 return "DW_OP_breg26";
8316 return "DW_OP_breg27";
8318 return "DW_OP_breg28";
8320 return "DW_OP_breg29";
8322 return "DW_OP_breg30";
8324 return "DW_OP_breg31";
8326 return "DW_OP_regx";
8328 return "DW_OP_fbreg";
8330 return "DW_OP_bregx";
8332 return "DW_OP_piece";
8333 case DW_OP_deref_size
:
8334 return "DW_OP_deref_size";
8335 case DW_OP_xderef_size
:
8336 return "DW_OP_xderef_size";
8339 /* DWARF 3 extensions. */
8340 case DW_OP_push_object_address
:
8341 return "DW_OP_push_object_address";
8343 return "DW_OP_call2";
8345 return "DW_OP_call4";
8346 case DW_OP_call_ref
:
8347 return "DW_OP_call_ref";
8348 /* GNU extensions. */
8349 case DW_OP_GNU_push_tls_address
:
8350 return "DW_OP_GNU_push_tls_address";
8352 return "OP_<unknown>";
8357 dwarf_bool_name (unsigned mybool
)
8365 /* Convert a DWARF type code into its string name. */
8368 dwarf_type_encoding_name (unsigned enc
)
8372 case DW_ATE_address
:
8373 return "DW_ATE_address";
8374 case DW_ATE_boolean
:
8375 return "DW_ATE_boolean";
8376 case DW_ATE_complex_float
:
8377 return "DW_ATE_complex_float";
8379 return "DW_ATE_float";
8381 return "DW_ATE_signed";
8382 case DW_ATE_signed_char
:
8383 return "DW_ATE_signed_char";
8384 case DW_ATE_unsigned
:
8385 return "DW_ATE_unsigned";
8386 case DW_ATE_unsigned_char
:
8387 return "DW_ATE_unsigned_char";
8388 case DW_ATE_imaginary_float
:
8389 return "DW_ATE_imaginary_float";
8391 return "DW_ATE_<unknown>";
8395 /* Convert a DWARF call frame info operation to its string name. */
8399 dwarf_cfi_name (unsigned cfi_opc
)
8403 case DW_CFA_advance_loc
:
8404 return "DW_CFA_advance_loc";
8406 return "DW_CFA_offset";
8407 case DW_CFA_restore
:
8408 return "DW_CFA_restore";
8410 return "DW_CFA_nop";
8411 case DW_CFA_set_loc
:
8412 return "DW_CFA_set_loc";
8413 case DW_CFA_advance_loc1
:
8414 return "DW_CFA_advance_loc1";
8415 case DW_CFA_advance_loc2
:
8416 return "DW_CFA_advance_loc2";
8417 case DW_CFA_advance_loc4
:
8418 return "DW_CFA_advance_loc4";
8419 case DW_CFA_offset_extended
:
8420 return "DW_CFA_offset_extended";
8421 case DW_CFA_restore_extended
:
8422 return "DW_CFA_restore_extended";
8423 case DW_CFA_undefined
:
8424 return "DW_CFA_undefined";
8425 case DW_CFA_same_value
:
8426 return "DW_CFA_same_value";
8427 case DW_CFA_register
:
8428 return "DW_CFA_register";
8429 case DW_CFA_remember_state
:
8430 return "DW_CFA_remember_state";
8431 case DW_CFA_restore_state
:
8432 return "DW_CFA_restore_state";
8433 case DW_CFA_def_cfa
:
8434 return "DW_CFA_def_cfa";
8435 case DW_CFA_def_cfa_register
:
8436 return "DW_CFA_def_cfa_register";
8437 case DW_CFA_def_cfa_offset
:
8438 return "DW_CFA_def_cfa_offset";
8441 case DW_CFA_def_cfa_expression
:
8442 return "DW_CFA_def_cfa_expression";
8443 case DW_CFA_expression
:
8444 return "DW_CFA_expression";
8445 case DW_CFA_offset_extended_sf
:
8446 return "DW_CFA_offset_extended_sf";
8447 case DW_CFA_def_cfa_sf
:
8448 return "DW_CFA_def_cfa_sf";
8449 case DW_CFA_def_cfa_offset_sf
:
8450 return "DW_CFA_def_cfa_offset_sf";
8452 /* SGI/MIPS specific */
8453 case DW_CFA_MIPS_advance_loc8
:
8454 return "DW_CFA_MIPS_advance_loc8";
8456 /* GNU extensions */
8457 case DW_CFA_GNU_window_save
:
8458 return "DW_CFA_GNU_window_save";
8459 case DW_CFA_GNU_args_size
:
8460 return "DW_CFA_GNU_args_size";
8461 case DW_CFA_GNU_negative_offset_extended
:
8462 return "DW_CFA_GNU_negative_offset_extended";
8465 return "DW_CFA_<unknown>";
8471 dump_die (struct die_info
*die
)
8475 fprintf_unfiltered (gdb_stderr
, "Die: %s (abbrev = %d, offset = %d)\n",
8476 dwarf_tag_name (die
->tag
), die
->abbrev
, die
->offset
);
8477 fprintf_unfiltered (gdb_stderr
, "\thas children: %s\n",
8478 dwarf_bool_name (die
->child
!= NULL
));
8480 fprintf_unfiltered (gdb_stderr
, "\tattributes:\n");
8481 for (i
= 0; i
< die
->num_attrs
; ++i
)
8483 fprintf_unfiltered (gdb_stderr
, "\t\t%s (%s) ",
8484 dwarf_attr_name (die
->attrs
[i
].name
),
8485 dwarf_form_name (die
->attrs
[i
].form
));
8486 switch (die
->attrs
[i
].form
)
8488 case DW_FORM_ref_addr
:
8490 fprintf_unfiltered (gdb_stderr
, "address: ");
8491 deprecated_print_address_numeric (DW_ADDR (&die
->attrs
[i
]), 1, gdb_stderr
);
8493 case DW_FORM_block2
:
8494 case DW_FORM_block4
:
8496 case DW_FORM_block1
:
8497 fprintf_unfiltered (gdb_stderr
, "block: size %d", DW_BLOCK (&die
->attrs
[i
])->size
);
8502 fprintf_unfiltered (gdb_stderr
, "constant ref: %ld (adjusted)",
8503 (long) (DW_ADDR (&die
->attrs
[i
])));
8511 fprintf_unfiltered (gdb_stderr
, "constant: %ld", DW_UNSND (&die
->attrs
[i
]));
8513 case DW_FORM_string
:
8515 fprintf_unfiltered (gdb_stderr
, "string: \"%s\"",
8516 DW_STRING (&die
->attrs
[i
])
8517 ? DW_STRING (&die
->attrs
[i
]) : "");
8520 if (DW_UNSND (&die
->attrs
[i
]))
8521 fprintf_unfiltered (gdb_stderr
, "flag: TRUE");
8523 fprintf_unfiltered (gdb_stderr
, "flag: FALSE");
8525 case DW_FORM_indirect
:
8526 /* the reader will have reduced the indirect form to
8527 the "base form" so this form should not occur */
8528 fprintf_unfiltered (gdb_stderr
, "unexpected attribute form: DW_FORM_indirect");
8531 fprintf_unfiltered (gdb_stderr
, "unsupported attribute form: %d.",
8532 die
->attrs
[i
].form
);
8534 fprintf_unfiltered (gdb_stderr
, "\n");
8539 dump_die_list (struct die_info
*die
)
8544 if (die
->child
!= NULL
)
8545 dump_die_list (die
->child
);
8546 if (die
->sibling
!= NULL
)
8547 dump_die_list (die
->sibling
);
8552 store_in_ref_table (unsigned int offset
, struct die_info
*die
,
8553 struct dwarf2_cu
*cu
)
8556 struct die_info
*old
;
8558 h
= (offset
% REF_HASH_SIZE
);
8559 old
= cu
->die_ref_table
[h
];
8560 die
->next_ref
= old
;
8561 cu
->die_ref_table
[h
] = die
;
8565 dwarf2_get_ref_die_offset (struct attribute
*attr
, struct dwarf2_cu
*cu
)
8567 unsigned int result
= 0;
8571 case DW_FORM_ref_addr
:
8576 case DW_FORM_ref_udata
:
8577 result
= DW_ADDR (attr
);
8580 complaint (&symfile_complaints
,
8581 _("unsupported die ref attribute form: '%s'"),
8582 dwarf_form_name (attr
->form
));
8587 /* Return the constant value held by the given attribute. Return -1
8588 if the value held by the attribute is not constant. */
8591 dwarf2_get_attr_constant_value (struct attribute
*attr
, int default_value
)
8593 if (attr
->form
== DW_FORM_sdata
)
8594 return DW_SND (attr
);
8595 else if (attr
->form
== DW_FORM_udata
8596 || attr
->form
== DW_FORM_data1
8597 || attr
->form
== DW_FORM_data2
8598 || attr
->form
== DW_FORM_data4
8599 || attr
->form
== DW_FORM_data8
)
8600 return DW_UNSND (attr
);
8603 complaint (&symfile_complaints
, _("Attribute value is not a constant (%s)"),
8604 dwarf_form_name (attr
->form
));
8605 return default_value
;
8609 static struct die_info
*
8610 follow_die_ref (struct die_info
*src_die
, struct attribute
*attr
,
8611 struct dwarf2_cu
*cu
)
8613 struct die_info
*die
;
8614 unsigned int offset
;
8616 struct die_info temp_die
;
8617 struct dwarf2_cu
*target_cu
;
8619 offset
= dwarf2_get_ref_die_offset (attr
, cu
);
8621 if (DW_ADDR (attr
) < cu
->header
.offset
8622 || DW_ADDR (attr
) >= cu
->header
.offset
+ cu
->header
.length
)
8624 struct dwarf2_per_cu_data
*per_cu
;
8625 per_cu
= dwarf2_find_containing_comp_unit (DW_ADDR (attr
),
8627 target_cu
= per_cu
->cu
;
8632 h
= (offset
% REF_HASH_SIZE
);
8633 die
= target_cu
->die_ref_table
[h
];
8636 if (die
->offset
== offset
)
8638 die
= die
->next_ref
;
8641 error (_("Dwarf Error: Cannot find DIE at 0x%lx referenced from DIE "
8642 "at 0x%lx [in module %s]"),
8643 (long) src_die
->offset
, (long) offset
, cu
->objfile
->name
);
8648 static struct type
*
8649 dwarf2_fundamental_type (struct objfile
*objfile
, int typeid,
8650 struct dwarf2_cu
*cu
)
8652 if (typeid < 0 || typeid >= FT_NUM_MEMBERS
)
8654 error (_("Dwarf Error: internal error - invalid fundamental type id %d [in module %s]"),
8655 typeid, objfile
->name
);
8658 /* Look for this particular type in the fundamental type vector. If
8659 one is not found, create and install one appropriate for the
8660 current language and the current target machine. */
8662 if (cu
->ftypes
[typeid] == NULL
)
8664 cu
->ftypes
[typeid] = cu
->language_defn
->la_fund_type (objfile
, typeid);
8667 return (cu
->ftypes
[typeid]);
8670 /* Decode simple location descriptions.
8671 Given a pointer to a dwarf block that defines a location, compute
8672 the location and return the value.
8674 NOTE drow/2003-11-18: This function is called in two situations
8675 now: for the address of static or global variables (partial symbols
8676 only) and for offsets into structures which are expected to be
8677 (more or less) constant. The partial symbol case should go away,
8678 and only the constant case should remain. That will let this
8679 function complain more accurately. A few special modes are allowed
8680 without complaint for global variables (for instance, global
8681 register values and thread-local values).
8683 A location description containing no operations indicates that the
8684 object is optimized out. The return value is 0 for that case.
8685 FIXME drow/2003-11-16: No callers check for this case any more; soon all
8686 callers will only want a very basic result and this can become a
8689 Note that stack[0] is unused except as a default error return.
8690 Note that stack overflow is not yet handled. */
8693 decode_locdesc (struct dwarf_block
*blk
, struct dwarf2_cu
*cu
)
8695 struct objfile
*objfile
= cu
->objfile
;
8696 struct comp_unit_head
*cu_header
= &cu
->header
;
8698 int size
= blk
->size
;
8699 gdb_byte
*data
= blk
->data
;
8700 CORE_ADDR stack
[64];
8702 unsigned int bytes_read
, unsnd
;
8746 stack
[++stacki
] = op
- DW_OP_lit0
;
8781 stack
[++stacki
] = op
- DW_OP_reg0
;
8783 dwarf2_complex_location_expr_complaint ();
8787 unsnd
= read_unsigned_leb128 (NULL
, (data
+ i
), &bytes_read
);
8789 stack
[++stacki
] = unsnd
;
8791 dwarf2_complex_location_expr_complaint ();
8795 stack
[++stacki
] = read_address (objfile
->obfd
, &data
[i
],
8801 stack
[++stacki
] = read_1_byte (objfile
->obfd
, &data
[i
]);
8806 stack
[++stacki
] = read_1_signed_byte (objfile
->obfd
, &data
[i
]);
8811 stack
[++stacki
] = read_2_bytes (objfile
->obfd
, &data
[i
]);
8816 stack
[++stacki
] = read_2_signed_bytes (objfile
->obfd
, &data
[i
]);
8821 stack
[++stacki
] = read_4_bytes (objfile
->obfd
, &data
[i
]);
8826 stack
[++stacki
] = read_4_signed_bytes (objfile
->obfd
, &data
[i
]);
8831 stack
[++stacki
] = read_unsigned_leb128 (NULL
, (data
+ i
),
8837 stack
[++stacki
] = read_signed_leb128 (NULL
, (data
+ i
), &bytes_read
);
8842 stack
[stacki
+ 1] = stack
[stacki
];
8847 stack
[stacki
- 1] += stack
[stacki
];
8851 case DW_OP_plus_uconst
:
8852 stack
[stacki
] += read_unsigned_leb128 (NULL
, (data
+ i
), &bytes_read
);
8857 stack
[stacki
- 1] -= stack
[stacki
];
8862 /* If we're not the last op, then we definitely can't encode
8863 this using GDB's address_class enum. This is valid for partial
8864 global symbols, although the variable's address will be bogus
8867 dwarf2_complex_location_expr_complaint ();
8870 case DW_OP_GNU_push_tls_address
:
8871 /* The top of the stack has the offset from the beginning
8872 of the thread control block at which the variable is located. */
8873 /* Nothing should follow this operator, so the top of stack would
8875 /* This is valid for partial global symbols, but the variable's
8876 address will be bogus in the psymtab. */
8878 dwarf2_complex_location_expr_complaint ();
8882 complaint (&symfile_complaints
, _("unsupported stack op: '%s'"),
8883 dwarf_stack_op_name (op
));
8884 return (stack
[stacki
]);
8887 return (stack
[stacki
]);
8890 /* memory allocation interface */
8892 static struct dwarf_block
*
8893 dwarf_alloc_block (struct dwarf2_cu
*cu
)
8895 struct dwarf_block
*blk
;
8897 blk
= (struct dwarf_block
*)
8898 obstack_alloc (&cu
->comp_unit_obstack
, sizeof (struct dwarf_block
));
8902 static struct abbrev_info
*
8903 dwarf_alloc_abbrev (struct dwarf2_cu
*cu
)
8905 struct abbrev_info
*abbrev
;
8907 abbrev
= (struct abbrev_info
*)
8908 obstack_alloc (&cu
->abbrev_obstack
, sizeof (struct abbrev_info
));
8909 memset (abbrev
, 0, sizeof (struct abbrev_info
));
8913 static struct die_info
*
8914 dwarf_alloc_die (void)
8916 struct die_info
*die
;
8918 die
= (struct die_info
*) xmalloc (sizeof (struct die_info
));
8919 memset (die
, 0, sizeof (struct die_info
));
8924 /* Macro support. */
8927 /* Return the full name of file number I in *LH's file name table.
8928 Use COMP_DIR as the name of the current directory of the
8929 compilation. The result is allocated using xmalloc; the caller is
8930 responsible for freeing it. */
8932 file_full_name (int file
, struct line_header
*lh
, const char *comp_dir
)
8934 /* Is the file number a valid index into the line header's file name
8935 table? Remember that file numbers start with one, not zero. */
8936 if (1 <= file
&& file
<= lh
->num_file_names
)
8938 struct file_entry
*fe
= &lh
->file_names
[file
- 1];
8940 if (IS_ABSOLUTE_PATH (fe
->name
))
8941 return xstrdup (fe
->name
);
8949 dir
= lh
->include_dirs
[fe
->dir_index
- 1];
8955 dir_len
= strlen (dir
);
8956 full_name
= xmalloc (dir_len
+ 1 + strlen (fe
->name
) + 1);
8957 strcpy (full_name
, dir
);
8958 full_name
[dir_len
] = '/';
8959 strcpy (full_name
+ dir_len
+ 1, fe
->name
);
8963 return xstrdup (fe
->name
);
8968 /* The compiler produced a bogus file number. We can at least
8969 record the macro definitions made in the file, even if we
8970 won't be able to find the file by name. */
8972 sprintf (fake_name
, "<bad macro file number %d>", file
);
8974 complaint (&symfile_complaints
,
8975 _("bad file number in macro information (%d)"),
8978 return xstrdup (fake_name
);
8983 static struct macro_source_file
*
8984 macro_start_file (int file
, int line
,
8985 struct macro_source_file
*current_file
,
8986 const char *comp_dir
,
8987 struct line_header
*lh
, struct objfile
*objfile
)
8989 /* The full name of this source file. */
8990 char *full_name
= file_full_name (file
, lh
, comp_dir
);
8992 /* We don't create a macro table for this compilation unit
8993 at all until we actually get a filename. */
8994 if (! pending_macros
)
8995 pending_macros
= new_macro_table (&objfile
->objfile_obstack
,
8996 objfile
->macro_cache
);
8999 /* If we have no current file, then this must be the start_file
9000 directive for the compilation unit's main source file. */
9001 current_file
= macro_set_main (pending_macros
, full_name
);
9003 current_file
= macro_include (current_file
, line
, full_name
);
9007 return current_file
;
9011 /* Copy the LEN characters at BUF to a xmalloc'ed block of memory,
9012 followed by a null byte. */
9014 copy_string (const char *buf
, int len
)
9016 char *s
= xmalloc (len
+ 1);
9017 memcpy (s
, buf
, len
);
9025 consume_improper_spaces (const char *p
, const char *body
)
9029 complaint (&symfile_complaints
,
9030 _("macro definition contains spaces in formal argument list:\n`%s'"),
9042 parse_macro_definition (struct macro_source_file
*file
, int line
,
9047 /* The body string takes one of two forms. For object-like macro
9048 definitions, it should be:
9050 <macro name> " " <definition>
9052 For function-like macro definitions, it should be:
9054 <macro name> "() " <definition>
9056 <macro name> "(" <arg name> ( "," <arg name> ) * ") " <definition>
9058 Spaces may appear only where explicitly indicated, and in the
9061 The Dwarf 2 spec says that an object-like macro's name is always
9062 followed by a space, but versions of GCC around March 2002 omit
9063 the space when the macro's definition is the empty string.
9065 The Dwarf 2 spec says that there should be no spaces between the
9066 formal arguments in a function-like macro's formal argument list,
9067 but versions of GCC around March 2002 include spaces after the
9071 /* Find the extent of the macro name. The macro name is terminated
9072 by either a space or null character (for an object-like macro) or
9073 an opening paren (for a function-like macro). */
9074 for (p
= body
; *p
; p
++)
9075 if (*p
== ' ' || *p
== '(')
9078 if (*p
== ' ' || *p
== '\0')
9080 /* It's an object-like macro. */
9081 int name_len
= p
- body
;
9082 char *name
= copy_string (body
, name_len
);
9083 const char *replacement
;
9086 replacement
= body
+ name_len
+ 1;
9089 dwarf2_macro_malformed_definition_complaint (body
);
9090 replacement
= body
+ name_len
;
9093 macro_define_object (file
, line
, name
, replacement
);
9099 /* It's a function-like macro. */
9100 char *name
= copy_string (body
, p
- body
);
9103 char **argv
= xmalloc (argv_size
* sizeof (*argv
));
9107 p
= consume_improper_spaces (p
, body
);
9109 /* Parse the formal argument list. */
9110 while (*p
&& *p
!= ')')
9112 /* Find the extent of the current argument name. */
9113 const char *arg_start
= p
;
9115 while (*p
&& *p
!= ',' && *p
!= ')' && *p
!= ' ')
9118 if (! *p
|| p
== arg_start
)
9119 dwarf2_macro_malformed_definition_complaint (body
);
9122 /* Make sure argv has room for the new argument. */
9123 if (argc
>= argv_size
)
9126 argv
= xrealloc (argv
, argv_size
* sizeof (*argv
));
9129 argv
[argc
++] = copy_string (arg_start
, p
- arg_start
);
9132 p
= consume_improper_spaces (p
, body
);
9134 /* Consume the comma, if present. */
9139 p
= consume_improper_spaces (p
, body
);
9148 /* Perfectly formed definition, no complaints. */
9149 macro_define_function (file
, line
, name
,
9150 argc
, (const char **) argv
,
9152 else if (*p
== '\0')
9154 /* Complain, but do define it. */
9155 dwarf2_macro_malformed_definition_complaint (body
);
9156 macro_define_function (file
, line
, name
,
9157 argc
, (const char **) argv
,
9161 /* Just complain. */
9162 dwarf2_macro_malformed_definition_complaint (body
);
9165 /* Just complain. */
9166 dwarf2_macro_malformed_definition_complaint (body
);
9172 for (i
= 0; i
< argc
; i
++)
9178 dwarf2_macro_malformed_definition_complaint (body
);
9183 dwarf_decode_macros (struct line_header
*lh
, unsigned int offset
,
9184 char *comp_dir
, bfd
*abfd
,
9185 struct dwarf2_cu
*cu
)
9187 gdb_byte
*mac_ptr
, *mac_end
;
9188 struct macro_source_file
*current_file
= 0;
9190 if (dwarf2_per_objfile
->macinfo_buffer
== NULL
)
9192 complaint (&symfile_complaints
, _("missing .debug_macinfo section"));
9196 mac_ptr
= dwarf2_per_objfile
->macinfo_buffer
+ offset
;
9197 mac_end
= dwarf2_per_objfile
->macinfo_buffer
9198 + dwarf2_per_objfile
->macinfo_size
;
9202 enum dwarf_macinfo_record_type macinfo_type
;
9204 /* Do we at least have room for a macinfo type byte? */
9205 if (mac_ptr
>= mac_end
)
9207 dwarf2_macros_too_long_complaint ();
9211 macinfo_type
= read_1_byte (abfd
, mac_ptr
);
9214 switch (macinfo_type
)
9216 /* A zero macinfo type indicates the end of the macro
9221 case DW_MACINFO_define
:
9222 case DW_MACINFO_undef
:
9224 unsigned int bytes_read
;
9228 line
= read_unsigned_leb128 (abfd
, mac_ptr
, &bytes_read
);
9229 mac_ptr
+= bytes_read
;
9230 body
= read_string (abfd
, mac_ptr
, &bytes_read
);
9231 mac_ptr
+= bytes_read
;
9234 complaint (&symfile_complaints
,
9235 _("debug info gives macro %s outside of any file: %s"),
9237 DW_MACINFO_define
? "definition" : macinfo_type
==
9238 DW_MACINFO_undef
? "undefinition" :
9239 "something-or-other", body
);
9242 if (macinfo_type
== DW_MACINFO_define
)
9243 parse_macro_definition (current_file
, line
, body
);
9244 else if (macinfo_type
== DW_MACINFO_undef
)
9245 macro_undef (current_file
, line
, body
);
9250 case DW_MACINFO_start_file
:
9252 unsigned int bytes_read
;
9255 line
= read_unsigned_leb128 (abfd
, mac_ptr
, &bytes_read
);
9256 mac_ptr
+= bytes_read
;
9257 file
= read_unsigned_leb128 (abfd
, mac_ptr
, &bytes_read
);
9258 mac_ptr
+= bytes_read
;
9260 current_file
= macro_start_file (file
, line
,
9261 current_file
, comp_dir
,
9266 case DW_MACINFO_end_file
:
9268 complaint (&symfile_complaints
,
9269 _("macro debug info has an unmatched `close_file' directive"));
9272 current_file
= current_file
->included_by
;
9275 enum dwarf_macinfo_record_type next_type
;
9277 /* GCC circa March 2002 doesn't produce the zero
9278 type byte marking the end of the compilation
9279 unit. Complain if it's not there, but exit no
9282 /* Do we at least have room for a macinfo type byte? */
9283 if (mac_ptr
>= mac_end
)
9285 dwarf2_macros_too_long_complaint ();
9289 /* We don't increment mac_ptr here, so this is just
9291 next_type
= read_1_byte (abfd
, mac_ptr
);
9293 complaint (&symfile_complaints
,
9294 _("no terminating 0-type entry for macros in `.debug_macinfo' section"));
9301 case DW_MACINFO_vendor_ext
:
9303 unsigned int bytes_read
;
9307 constant
= read_unsigned_leb128 (abfd
, mac_ptr
, &bytes_read
);
9308 mac_ptr
+= bytes_read
;
9309 string
= read_string (abfd
, mac_ptr
, &bytes_read
);
9310 mac_ptr
+= bytes_read
;
9312 /* We don't recognize any vendor extensions. */
9319 /* Check if the attribute's form is a DW_FORM_block*
9320 if so return true else false. */
9322 attr_form_is_block (struct attribute
*attr
)
9324 return (attr
== NULL
? 0 :
9325 attr
->form
== DW_FORM_block1
9326 || attr
->form
== DW_FORM_block2
9327 || attr
->form
== DW_FORM_block4
9328 || attr
->form
== DW_FORM_block
);
9332 dwarf2_symbol_mark_computed (struct attribute
*attr
, struct symbol
*sym
,
9333 struct dwarf2_cu
*cu
)
9335 if ((attr
->form
== DW_FORM_data4
|| attr
->form
== DW_FORM_data8
)
9336 /* ".debug_loc" may not exist at all, or the offset may be outside
9337 the section. If so, fall through to the complaint in the
9339 && DW_UNSND (attr
) < dwarf2_per_objfile
->loc_size
)
9341 struct dwarf2_loclist_baton
*baton
;
9343 baton
= obstack_alloc (&cu
->objfile
->objfile_obstack
,
9344 sizeof (struct dwarf2_loclist_baton
));
9345 baton
->objfile
= cu
->objfile
;
9347 /* We don't know how long the location list is, but make sure we
9348 don't run off the edge of the section. */
9349 baton
->size
= dwarf2_per_objfile
->loc_size
- DW_UNSND (attr
);
9350 baton
->data
= dwarf2_per_objfile
->loc_buffer
+ DW_UNSND (attr
);
9351 baton
->base_address
= cu
->header
.base_address
;
9352 if (cu
->header
.base_known
== 0)
9353 complaint (&symfile_complaints
,
9354 _("Location list used without specifying the CU base address."));
9356 SYMBOL_OPS (sym
) = &dwarf2_loclist_funcs
;
9357 SYMBOL_LOCATION_BATON (sym
) = baton
;
9361 struct dwarf2_locexpr_baton
*baton
;
9363 baton
= obstack_alloc (&cu
->objfile
->objfile_obstack
,
9364 sizeof (struct dwarf2_locexpr_baton
));
9365 baton
->objfile
= cu
->objfile
;
9367 if (attr_form_is_block (attr
))
9369 /* Note that we're just copying the block's data pointer
9370 here, not the actual data. We're still pointing into the
9371 info_buffer for SYM's objfile; right now we never release
9372 that buffer, but when we do clean up properly this may
9374 baton
->size
= DW_BLOCK (attr
)->size
;
9375 baton
->data
= DW_BLOCK (attr
)->data
;
9379 dwarf2_invalid_attrib_class_complaint ("location description",
9380 SYMBOL_NATURAL_NAME (sym
));
9385 SYMBOL_OPS (sym
) = &dwarf2_locexpr_funcs
;
9386 SYMBOL_LOCATION_BATON (sym
) = baton
;
9390 /* Locate the compilation unit from CU's objfile which contains the
9391 DIE at OFFSET. Raises an error on failure. */
9393 static struct dwarf2_per_cu_data
*
9394 dwarf2_find_containing_comp_unit (unsigned long offset
,
9395 struct objfile
*objfile
)
9397 struct dwarf2_per_cu_data
*this_cu
;
9401 high
= dwarf2_per_objfile
->n_comp_units
- 1;
9404 int mid
= low
+ (high
- low
) / 2;
9405 if (dwarf2_per_objfile
->all_comp_units
[mid
]->offset
>= offset
)
9410 gdb_assert (low
== high
);
9411 if (dwarf2_per_objfile
->all_comp_units
[low
]->offset
> offset
)
9414 error (_("Dwarf Error: could not find partial DIE containing "
9415 "offset 0x%lx [in module %s]"),
9416 (long) offset
, bfd_get_filename (objfile
->obfd
));
9418 gdb_assert (dwarf2_per_objfile
->all_comp_units
[low
-1]->offset
<= offset
);
9419 return dwarf2_per_objfile
->all_comp_units
[low
-1];
9423 this_cu
= dwarf2_per_objfile
->all_comp_units
[low
];
9424 if (low
== dwarf2_per_objfile
->n_comp_units
- 1
9425 && offset
>= this_cu
->offset
+ this_cu
->length
)
9426 error (_("invalid dwarf2 offset %ld"), offset
);
9427 gdb_assert (offset
< this_cu
->offset
+ this_cu
->length
);
9432 /* Locate the compilation unit from OBJFILE which is located at exactly
9433 OFFSET. Raises an error on failure. */
9435 static struct dwarf2_per_cu_data
*
9436 dwarf2_find_comp_unit (unsigned long offset
, struct objfile
*objfile
)
9438 struct dwarf2_per_cu_data
*this_cu
;
9439 this_cu
= dwarf2_find_containing_comp_unit (offset
, objfile
);
9440 if (this_cu
->offset
!= offset
)
9441 error (_("no compilation unit with offset %ld."), offset
);
9445 /* Release one cached compilation unit, CU. We unlink it from the tree
9446 of compilation units, but we don't remove it from the read_in_chain;
9447 the caller is responsible for that. */
9450 free_one_comp_unit (void *data
)
9452 struct dwarf2_cu
*cu
= data
;
9454 if (cu
->per_cu
!= NULL
)
9455 cu
->per_cu
->cu
= NULL
;
9458 obstack_free (&cu
->comp_unit_obstack
, NULL
);
9460 free_die_list (cu
->dies
);
9465 /* This cleanup function is passed the address of a dwarf2_cu on the stack
9466 when we're finished with it. We can't free the pointer itself, but be
9467 sure to unlink it from the cache. Also release any associated storage
9468 and perform cache maintenance.
9470 Only used during partial symbol parsing. */
9473 free_stack_comp_unit (void *data
)
9475 struct dwarf2_cu
*cu
= data
;
9477 obstack_free (&cu
->comp_unit_obstack
, NULL
);
9478 cu
->partial_dies
= NULL
;
9480 if (cu
->per_cu
!= NULL
)
9482 /* This compilation unit is on the stack in our caller, so we
9483 should not xfree it. Just unlink it. */
9484 cu
->per_cu
->cu
= NULL
;
9487 /* If we had a per-cu pointer, then we may have other compilation
9488 units loaded, so age them now. */
9489 age_cached_comp_units ();
9493 /* Free all cached compilation units. */
9496 free_cached_comp_units (void *data
)
9498 struct dwarf2_per_cu_data
*per_cu
, **last_chain
;
9500 per_cu
= dwarf2_per_objfile
->read_in_chain
;
9501 last_chain
= &dwarf2_per_objfile
->read_in_chain
;
9502 while (per_cu
!= NULL
)
9504 struct dwarf2_per_cu_data
*next_cu
;
9506 next_cu
= per_cu
->cu
->read_in_chain
;
9508 free_one_comp_unit (per_cu
->cu
);
9509 *last_chain
= next_cu
;
9515 /* Increase the age counter on each cached compilation unit, and free
9516 any that are too old. */
9519 age_cached_comp_units (void)
9521 struct dwarf2_per_cu_data
*per_cu
, **last_chain
;
9523 dwarf2_clear_marks (dwarf2_per_objfile
->read_in_chain
);
9524 per_cu
= dwarf2_per_objfile
->read_in_chain
;
9525 while (per_cu
!= NULL
)
9527 per_cu
->cu
->last_used
++;
9528 if (per_cu
->cu
->last_used
<= dwarf2_max_cache_age
)
9529 dwarf2_mark (per_cu
->cu
);
9530 per_cu
= per_cu
->cu
->read_in_chain
;
9533 per_cu
= dwarf2_per_objfile
->read_in_chain
;
9534 last_chain
= &dwarf2_per_objfile
->read_in_chain
;
9535 while (per_cu
!= NULL
)
9537 struct dwarf2_per_cu_data
*next_cu
;
9539 next_cu
= per_cu
->cu
->read_in_chain
;
9541 if (!per_cu
->cu
->mark
)
9543 free_one_comp_unit (per_cu
->cu
);
9544 *last_chain
= next_cu
;
9547 last_chain
= &per_cu
->cu
->read_in_chain
;
9553 /* Remove a single compilation unit from the cache. */
9556 free_one_cached_comp_unit (void *target_cu
)
9558 struct dwarf2_per_cu_data
*per_cu
, **last_chain
;
9560 per_cu
= dwarf2_per_objfile
->read_in_chain
;
9561 last_chain
= &dwarf2_per_objfile
->read_in_chain
;
9562 while (per_cu
!= NULL
)
9564 struct dwarf2_per_cu_data
*next_cu
;
9566 next_cu
= per_cu
->cu
->read_in_chain
;
9568 if (per_cu
->cu
== target_cu
)
9570 free_one_comp_unit (per_cu
->cu
);
9571 *last_chain
= next_cu
;
9575 last_chain
= &per_cu
->cu
->read_in_chain
;
9581 /* A pair of DIE offset and GDB type pointer. We store these
9582 in a hash table separate from the DIEs, and preserve them
9583 when the DIEs are flushed out of cache. */
9585 struct dwarf2_offset_and_type
9587 unsigned int offset
;
9591 /* Hash function for a dwarf2_offset_and_type. */
9594 offset_and_type_hash (const void *item
)
9596 const struct dwarf2_offset_and_type
*ofs
= item
;
9600 /* Equality function for a dwarf2_offset_and_type. */
9603 offset_and_type_eq (const void *item_lhs
, const void *item_rhs
)
9605 const struct dwarf2_offset_and_type
*ofs_lhs
= item_lhs
;
9606 const struct dwarf2_offset_and_type
*ofs_rhs
= item_rhs
;
9607 return ofs_lhs
->offset
== ofs_rhs
->offset
;
9610 /* Set the type associated with DIE to TYPE. Save it in CU's hash
9611 table if necessary. */
9614 set_die_type (struct die_info
*die
, struct type
*type
, struct dwarf2_cu
*cu
)
9616 struct dwarf2_offset_and_type
**slot
, ofs
;
9620 if (cu
->per_cu
== NULL
)
9623 if (cu
->per_cu
->type_hash
== NULL
)
9624 cu
->per_cu
->type_hash
9625 = htab_create_alloc_ex (cu
->header
.length
/ 24,
9626 offset_and_type_hash
,
9629 &cu
->objfile
->objfile_obstack
,
9630 hashtab_obstack_allocate
,
9631 dummy_obstack_deallocate
);
9633 ofs
.offset
= die
->offset
;
9635 slot
= (struct dwarf2_offset_and_type
**)
9636 htab_find_slot_with_hash (cu
->per_cu
->type_hash
, &ofs
, ofs
.offset
, INSERT
);
9637 *slot
= obstack_alloc (&cu
->objfile
->objfile_obstack
, sizeof (**slot
));
9641 /* Find the type for DIE in TYPE_HASH, or return NULL if DIE does not
9642 have a saved type. */
9644 static struct type
*
9645 get_die_type (struct die_info
*die
, htab_t type_hash
)
9647 struct dwarf2_offset_and_type
*slot
, ofs
;
9649 ofs
.offset
= die
->offset
;
9650 slot
= htab_find_with_hash (type_hash
, &ofs
, ofs
.offset
);
9657 /* Restore the types of the DIE tree starting at START_DIE from the hash
9658 table saved in CU. */
9661 reset_die_and_siblings_types (struct die_info
*start_die
, struct dwarf2_cu
*cu
)
9663 struct die_info
*die
;
9665 if (cu
->per_cu
->type_hash
== NULL
)
9668 for (die
= start_die
; die
!= NULL
; die
= die
->sibling
)
9670 die
->type
= get_die_type (die
, cu
->per_cu
->type_hash
);
9671 if (die
->child
!= NULL
)
9672 reset_die_and_siblings_types (die
->child
, cu
);
9676 /* Set the mark field in CU and in every other compilation unit in the
9677 cache that we must keep because we are keeping CU. */
9679 /* Add a dependence relationship from CU to REF_PER_CU. */
9682 dwarf2_add_dependence (struct dwarf2_cu
*cu
,
9683 struct dwarf2_per_cu_data
*ref_per_cu
)
9687 if (cu
->dependencies
== NULL
)
9689 = htab_create_alloc_ex (5, htab_hash_pointer
, htab_eq_pointer
,
9690 NULL
, &cu
->comp_unit_obstack
,
9691 hashtab_obstack_allocate
,
9692 dummy_obstack_deallocate
);
9694 slot
= htab_find_slot (cu
->dependencies
, ref_per_cu
, INSERT
);
9699 /* Set the mark field in CU and in every other compilation unit in the
9700 cache that we must keep because we are keeping CU. */
9703 dwarf2_mark_helper (void **slot
, void *data
)
9705 struct dwarf2_per_cu_data
*per_cu
;
9707 per_cu
= (struct dwarf2_per_cu_data
*) *slot
;
9708 if (per_cu
->cu
->mark
)
9710 per_cu
->cu
->mark
= 1;
9712 if (per_cu
->cu
->dependencies
!= NULL
)
9713 htab_traverse (per_cu
->cu
->dependencies
, dwarf2_mark_helper
, NULL
);
9719 dwarf2_mark (struct dwarf2_cu
*cu
)
9724 if (cu
->dependencies
!= NULL
)
9725 htab_traverse (cu
->dependencies
, dwarf2_mark_helper
, NULL
);
9729 dwarf2_clear_marks (struct dwarf2_per_cu_data
*per_cu
)
9733 per_cu
->cu
->mark
= 0;
9734 per_cu
= per_cu
->cu
->read_in_chain
;
9738 /* Trivial hash function for partial_die_info: the hash value of a DIE
9739 is its offset in .debug_info for this objfile. */
9742 partial_die_hash (const void *item
)
9744 const struct partial_die_info
*part_die
= item
;
9745 return part_die
->offset
;
9748 /* Trivial comparison function for partial_die_info structures: two DIEs
9749 are equal if they have the same offset. */
9752 partial_die_eq (const void *item_lhs
, const void *item_rhs
)
9754 const struct partial_die_info
*part_die_lhs
= item_lhs
;
9755 const struct partial_die_info
*part_die_rhs
= item_rhs
;
9756 return part_die_lhs
->offset
== part_die_rhs
->offset
;
9759 static struct cmd_list_element
*set_dwarf2_cmdlist
;
9760 static struct cmd_list_element
*show_dwarf2_cmdlist
;
9763 set_dwarf2_cmd (char *args
, int from_tty
)
9765 help_list (set_dwarf2_cmdlist
, "maintenance set dwarf2 ", -1, gdb_stdout
);
9769 show_dwarf2_cmd (char *args
, int from_tty
)
9771 cmd_show_list (show_dwarf2_cmdlist
, from_tty
, "");
9774 void _initialize_dwarf2_read (void);
9777 _initialize_dwarf2_read (void)
9779 dwarf2_objfile_data_key
= register_objfile_data ();
9781 add_prefix_cmd ("dwarf2", class_maintenance
, set_dwarf2_cmd
, _("\
9782 Set DWARF 2 specific variables.\n\
9783 Configure DWARF 2 variables such as the cache size"),
9784 &set_dwarf2_cmdlist
, "maintenance set dwarf2 ",
9785 0/*allow-unknown*/, &maintenance_set_cmdlist
);
9787 add_prefix_cmd ("dwarf2", class_maintenance
, show_dwarf2_cmd
, _("\
9788 Show DWARF 2 specific variables\n\
9789 Show DWARF 2 variables such as the cache size"),
9790 &show_dwarf2_cmdlist
, "maintenance show dwarf2 ",
9791 0/*allow-unknown*/, &maintenance_show_cmdlist
);
9793 add_setshow_zinteger_cmd ("max-cache-age", class_obscure
,
9794 &dwarf2_max_cache_age
, _("\
9795 Set the upper bound on the age of cached dwarf2 compilation units."), _("\
9796 Show the upper bound on the age of cached dwarf2 compilation units."), _("\
9797 A higher limit means that cached compilation units will be stored\n\
9798 in memory longer, and more total memory will be used. Zero disables\n\
9799 caching, which can slow down startup."),
9801 show_dwarf2_max_cache_age
,
9802 &set_dwarf2_cmdlist
,
9803 &show_dwarf2_cmdlist
);