1 /* DWARF 2 debugging format support for GDB.
3 Copyright (C) 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003,
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
;
185 static struct dwarf2_per_objfile
*dwarf2_per_objfile
;
187 static asection
*dwarf_info_section
;
188 static asection
*dwarf_abbrev_section
;
189 static asection
*dwarf_line_section
;
190 static asection
*dwarf_pubnames_section
;
191 static asection
*dwarf_aranges_section
;
192 static asection
*dwarf_loc_section
;
193 static asection
*dwarf_macinfo_section
;
194 static asection
*dwarf_str_section
;
195 static asection
*dwarf_ranges_section
;
196 asection
*dwarf_frame_section
;
197 asection
*dwarf_eh_frame_section
;
199 /* names of the debugging sections */
201 #define INFO_SECTION ".debug_info"
202 #define ABBREV_SECTION ".debug_abbrev"
203 #define LINE_SECTION ".debug_line"
204 #define PUBNAMES_SECTION ".debug_pubnames"
205 #define ARANGES_SECTION ".debug_aranges"
206 #define LOC_SECTION ".debug_loc"
207 #define MACINFO_SECTION ".debug_macinfo"
208 #define STR_SECTION ".debug_str"
209 #define RANGES_SECTION ".debug_ranges"
210 #define FRAME_SECTION ".debug_frame"
211 #define EH_FRAME_SECTION ".eh_frame"
213 /* local data types */
215 /* We hold several abbreviation tables in memory at the same time. */
216 #ifndef ABBREV_HASH_SIZE
217 #define ABBREV_HASH_SIZE 121
220 /* The data in a compilation unit header, after target2host
221 translation, looks like this. */
222 struct comp_unit_head
224 unsigned long length
;
226 unsigned int abbrev_offset
;
227 unsigned char addr_size
;
228 unsigned char signed_addr_p
;
230 /* Size of file offsets; either 4 or 8. */
231 unsigned int offset_size
;
233 /* Size of the length field; either 4 or 12. */
234 unsigned int initial_length_size
;
236 /* Offset to the first byte of this compilation unit header in the
237 .debug_info section, for resolving relative reference dies. */
240 /* Pointer to this compilation unit header in the .debug_info
242 gdb_byte
*cu_head_ptr
;
244 /* Pointer to the first die of this compilation unit. This will be
245 the first byte following the compilation unit header. */
246 gdb_byte
*first_die_ptr
;
248 /* Pointer to the next compilation unit header in the program. */
249 struct comp_unit_head
*next
;
251 /* Base address of this compilation unit. */
252 CORE_ADDR base_address
;
254 /* Non-zero if base_address has been set. */
258 /* Fixed size for the DIE hash table. */
259 #ifndef REF_HASH_SIZE
260 #define REF_HASH_SIZE 1021
263 /* Internal state when decoding a particular compilation unit. */
266 /* The objfile containing this compilation unit. */
267 struct objfile
*objfile
;
269 /* The header of the compilation unit.
271 FIXME drow/2003-11-10: Some of the things from the comp_unit_head
272 should logically be moved to the dwarf2_cu structure. */
273 struct comp_unit_head header
;
275 struct function_range
*first_fn
, *last_fn
, *cached_fn
;
277 /* The language we are debugging. */
278 enum language language
;
279 const struct language_defn
*language_defn
;
281 const char *producer
;
283 /* The generic symbol table building routines have separate lists for
284 file scope symbols and all all other scopes (local scopes). So
285 we need to select the right one to pass to add_symbol_to_list().
286 We do it by keeping a pointer to the correct list in list_in_scope.
288 FIXME: The original dwarf code just treated the file scope as the
289 first local scope, and all other local scopes as nested local
290 scopes, and worked fine. Check to see if we really need to
291 distinguish these in buildsym.c. */
292 struct pending
**list_in_scope
;
294 /* Maintain an array of referenced fundamental types for the current
295 compilation unit being read. For DWARF version 1, we have to construct
296 the fundamental types on the fly, since no information about the
297 fundamental types is supplied. Each such fundamental type is created by
298 calling a language dependent routine to create the type, and then a
299 pointer to that type is then placed in the array at the index specified
300 by it's FT_<TYPENAME> value. The array has a fixed size set by the
301 FT_NUM_MEMBERS compile time constant, which is the number of predefined
302 fundamental types gdb knows how to construct. */
303 struct type
*ftypes
[FT_NUM_MEMBERS
]; /* Fundamental types */
305 /* DWARF abbreviation table associated with this compilation unit. */
306 struct abbrev_info
**dwarf2_abbrevs
;
308 /* Storage for the abbrev table. */
309 struct obstack abbrev_obstack
;
311 /* Hash table holding all the loaded partial DIEs. */
314 /* Storage for things with the same lifetime as this read-in compilation
315 unit, including partial DIEs. */
316 struct obstack comp_unit_obstack
;
318 /* When multiple dwarf2_cu structures are living in memory, this field
319 chains them all together, so that they can be released efficiently.
320 We will probably also want a generation counter so that most-recently-used
321 compilation units are cached... */
322 struct dwarf2_per_cu_data
*read_in_chain
;
324 /* Backchain to our per_cu entry if the tree has been built. */
325 struct dwarf2_per_cu_data
*per_cu
;
327 /* How many compilation units ago was this CU last referenced? */
330 /* A hash table of die offsets for following references. */
331 struct die_info
*die_ref_table
[REF_HASH_SIZE
];
333 /* Full DIEs if read in. */
334 struct die_info
*dies
;
336 /* A set of pointers to dwarf2_per_cu_data objects for compilation
337 units referenced by this one. Only set during full symbol processing;
338 partial symbol tables do not have dependencies. */
341 /* Mark used when releasing cached dies. */
342 unsigned int mark
: 1;
344 /* This flag will be set if this compilation unit might include
345 inter-compilation-unit references. */
346 unsigned int has_form_ref_addr
: 1;
348 /* This flag will be set if this compilation unit includes any
349 DW_TAG_namespace DIEs. If we know that there are explicit
350 DIEs for namespaces, we don't need to try to infer them
351 from mangled names. */
352 unsigned int has_namespace_info
: 1;
355 /* Persistent data held for a compilation unit, even when not
356 processing it. We put a pointer to this structure in the
357 read_symtab_private field of the psymtab. If we encounter
358 inter-compilation-unit references, we also maintain a sorted
359 list of all compilation units. */
361 struct dwarf2_per_cu_data
363 /* The start offset and length of this compilation unit. 2**30-1
364 bytes should suffice to store the length of any compilation unit
365 - if it doesn't, GDB will fall over anyway. */
366 unsigned long offset
;
367 unsigned long length
: 30;
369 /* Flag indicating this compilation unit will be read in before
370 any of the current compilation units are processed. */
371 unsigned long queued
: 1;
373 /* This flag will be set if we need to load absolutely all DIEs
374 for this compilation unit, instead of just the ones we think
375 are interesting. It gets set if we look for a DIE in the
376 hash table and don't find it. */
377 unsigned int load_all_dies
: 1;
379 /* Set iff currently read in. */
380 struct dwarf2_cu
*cu
;
382 /* If full symbols for this CU have been read in, then this field
383 holds a map of DIE offsets to types. It isn't always possible
384 to reconstruct this information later, so we have to preserve
388 /* The partial symbol table associated with this compilation unit. */
389 struct partial_symtab
*psymtab
;
392 /* The line number information for a compilation unit (found in the
393 .debug_line section) begins with a "statement program header",
394 which contains the following information. */
397 unsigned int total_length
;
398 unsigned short version
;
399 unsigned int header_length
;
400 unsigned char minimum_instruction_length
;
401 unsigned char default_is_stmt
;
403 unsigned char line_range
;
404 unsigned char opcode_base
;
406 /* standard_opcode_lengths[i] is the number of operands for the
407 standard opcode whose value is i. This means that
408 standard_opcode_lengths[0] is unused, and the last meaningful
409 element is standard_opcode_lengths[opcode_base - 1]. */
410 unsigned char *standard_opcode_lengths
;
412 /* The include_directories table. NOTE! These strings are not
413 allocated with xmalloc; instead, they are pointers into
414 debug_line_buffer. If you try to free them, `free' will get
416 unsigned int num_include_dirs
, include_dirs_size
;
419 /* The file_names table. NOTE! These strings are not allocated
420 with xmalloc; instead, they are pointers into debug_line_buffer.
421 Don't try to free them directly. */
422 unsigned int num_file_names
, file_names_size
;
426 unsigned int dir_index
;
427 unsigned int mod_time
;
429 int included_p
; /* Non-zero if referenced by the Line Number Program. */
432 /* The start and end of the statement program following this
433 header. These point into dwarf2_per_objfile->line_buffer. */
434 gdb_byte
*statement_program_start
, *statement_program_end
;
437 /* When we construct a partial symbol table entry we only
438 need this much information. */
439 struct partial_die_info
441 /* Offset of this DIE. */
444 /* DWARF-2 tag for this DIE. */
445 ENUM_BITFIELD(dwarf_tag
) tag
: 16;
447 /* Language code associated with this DIE. This is only used
448 for the compilation unit DIE. */
449 unsigned int language
: 8;
451 /* Assorted flags describing the data found in this DIE. */
452 unsigned int has_children
: 1;
453 unsigned int is_external
: 1;
454 unsigned int is_declaration
: 1;
455 unsigned int has_type
: 1;
456 unsigned int has_specification
: 1;
457 unsigned int has_stmt_list
: 1;
458 unsigned int has_pc_info
: 1;
460 /* Flag set if the SCOPE field of this structure has been
462 unsigned int scope_set
: 1;
464 /* The name of this DIE. Normally the value of DW_AT_name, but
465 sometimes DW_TAG_MIPS_linkage_name or a string computed in some
470 /* The scope to prepend to our children. This is generally
471 allocated on the comp_unit_obstack, so will disappear
472 when this compilation unit leaves the cache. */
475 /* The location description associated with this DIE, if any. */
476 struct dwarf_block
*locdesc
;
478 /* If HAS_PC_INFO, the PC range associated with this DIE. */
482 /* Pointer into the info_buffer pointing at the target of
483 DW_AT_sibling, if any. */
486 /* If HAS_SPECIFICATION, the offset of the DIE referred to by
487 DW_AT_specification (or DW_AT_abstract_origin or
489 unsigned int spec_offset
;
491 /* If HAS_STMT_LIST, the offset of the Line Number Information data. */
492 unsigned int line_offset
;
494 /* Pointers to this DIE's parent, first child, and next sibling,
496 struct partial_die_info
*die_parent
, *die_child
, *die_sibling
;
499 /* This data structure holds the information of an abbrev. */
502 unsigned int number
; /* number identifying abbrev */
503 enum dwarf_tag tag
; /* dwarf tag */
504 unsigned short has_children
; /* boolean */
505 unsigned short num_attrs
; /* number of attributes */
506 struct attr_abbrev
*attrs
; /* an array of attribute descriptions */
507 struct abbrev_info
*next
; /* next in chain */
512 enum dwarf_attribute name
;
513 enum dwarf_form form
;
516 /* This data structure holds a complete die structure. */
519 enum dwarf_tag tag
; /* Tag indicating type of die */
520 unsigned int abbrev
; /* Abbrev number */
521 unsigned int offset
; /* Offset in .debug_info section */
522 unsigned int num_attrs
; /* Number of attributes */
523 struct attribute
*attrs
; /* An array of attributes */
524 struct die_info
*next_ref
; /* Next die in ref hash table */
526 /* The dies in a compilation unit form an n-ary tree. PARENT
527 points to this die's parent; CHILD points to the first child of
528 this node; and all the children of a given node are chained
529 together via their SIBLING fields, terminated by a die whose
531 struct die_info
*child
; /* Its first child, if any. */
532 struct die_info
*sibling
; /* Its next sibling, if any. */
533 struct die_info
*parent
; /* Its parent, if any. */
535 struct type
*type
; /* Cached type information */
538 /* Attributes have a name and a value */
541 enum dwarf_attribute name
;
542 enum dwarf_form form
;
546 struct dwarf_block
*blk
;
554 struct function_range
557 CORE_ADDR lowpc
, highpc
;
559 struct function_range
*next
;
562 /* Get at parts of an attribute structure */
564 #define DW_STRING(attr) ((attr)->u.str)
565 #define DW_UNSND(attr) ((attr)->u.unsnd)
566 #define DW_BLOCK(attr) ((attr)->u.blk)
567 #define DW_SND(attr) ((attr)->u.snd)
568 #define DW_ADDR(attr) ((attr)->u.addr)
570 /* Blocks are a bunch of untyped bytes. */
577 #ifndef ATTR_ALLOC_CHUNK
578 #define ATTR_ALLOC_CHUNK 4
581 /* Allocate fields for structs, unions and enums in this size. */
582 #ifndef DW_FIELD_ALLOC_CHUNK
583 #define DW_FIELD_ALLOC_CHUNK 4
586 /* A zeroed version of a partial die for initialization purposes. */
587 static struct partial_die_info zeroed_partial_die
;
589 /* FIXME: We might want to set this from BFD via bfd_arch_bits_per_byte,
590 but this would require a corresponding change in unpack_field_as_long
592 static int bits_per_byte
= 8;
594 /* The routines that read and process dies for a C struct or C++ class
595 pass lists of data member fields and lists of member function fields
596 in an instance of a field_info structure, as defined below. */
599 /* List of data member and baseclasses fields. */
602 struct nextfield
*next
;
609 /* Number of fields. */
612 /* Number of baseclasses. */
615 /* Set if the accesibility of one of the fields is not public. */
616 int non_public_fields
;
618 /* Member function fields array, entries are allocated in the order they
619 are encountered in the object file. */
622 struct nextfnfield
*next
;
623 struct fn_field fnfield
;
627 /* Member function fieldlist array, contains name of possibly overloaded
628 member function, number of overloaded member functions and a pointer
629 to the head of the member function field chain. */
634 struct nextfnfield
*head
;
638 /* Number of entries in the fnfieldlists array. */
642 /* One item on the queue of compilation units to read in full symbols
644 struct dwarf2_queue_item
646 struct dwarf2_per_cu_data
*per_cu
;
647 struct dwarf2_queue_item
*next
;
650 /* The current queue. */
651 static struct dwarf2_queue_item
*dwarf2_queue
, *dwarf2_queue_tail
;
653 /* Loaded secondary compilation units are kept in memory until they
654 have not been referenced for the processing of this many
655 compilation units. Set this to zero to disable caching. Cache
656 sizes of up to at least twenty will improve startup time for
657 typical inter-CU-reference binaries, at an obvious memory cost. */
658 static int dwarf2_max_cache_age
= 5;
660 show_dwarf2_max_cache_age (struct ui_file
*file
, int from_tty
,
661 struct cmd_list_element
*c
, const char *value
)
663 fprintf_filtered (file
, _("\
664 The upper bound on the age of cached dwarf2 compilation units is %s.\n"),
669 /* Various complaints about symbol reading that don't abort the process */
672 dwarf2_statement_list_fits_in_line_number_section_complaint (void)
674 complaint (&symfile_complaints
,
675 _("statement list doesn't fit in .debug_line section"));
679 dwarf2_complex_location_expr_complaint (void)
681 complaint (&symfile_complaints
, _("location expression too complex"));
685 dwarf2_const_value_length_mismatch_complaint (const char *arg1
, int arg2
,
688 complaint (&symfile_complaints
,
689 _("const value length mismatch for '%s', got %d, expected %d"), arg1
,
694 dwarf2_macros_too_long_complaint (void)
696 complaint (&symfile_complaints
,
697 _("macro info runs off end of `.debug_macinfo' section"));
701 dwarf2_macro_malformed_definition_complaint (const char *arg1
)
703 complaint (&symfile_complaints
,
704 _("macro debug info contains a malformed macro definition:\n`%s'"),
709 dwarf2_invalid_attrib_class_complaint (const char *arg1
, const char *arg2
)
711 complaint (&symfile_complaints
,
712 _("invalid attribute class or form for '%s' in '%s'"), arg1
, arg2
);
715 /* local function prototypes */
717 static void dwarf2_locate_sections (bfd
*, asection
*, void *);
720 static void dwarf2_build_psymtabs_easy (struct objfile
*, int);
723 static void dwarf2_create_include_psymtab (char *, struct partial_symtab
*,
726 static void dwarf2_build_include_psymtabs (struct dwarf2_cu
*,
727 struct partial_die_info
*,
728 struct partial_symtab
*);
730 static void dwarf2_build_psymtabs_hard (struct objfile
*, int);
732 static void scan_partial_symbols (struct partial_die_info
*,
733 CORE_ADDR
*, CORE_ADDR
*,
736 static void add_partial_symbol (struct partial_die_info
*,
739 static int pdi_needs_namespace (enum dwarf_tag tag
);
741 static void add_partial_namespace (struct partial_die_info
*pdi
,
742 CORE_ADDR
*lowpc
, CORE_ADDR
*highpc
,
743 struct dwarf2_cu
*cu
);
745 static void add_partial_enumeration (struct partial_die_info
*enum_pdi
,
746 struct dwarf2_cu
*cu
);
748 static gdb_byte
*locate_pdi_sibling (struct partial_die_info
*orig_pdi
,
751 struct dwarf2_cu
*cu
);
753 static void dwarf2_psymtab_to_symtab (struct partial_symtab
*);
755 static void psymtab_to_symtab_1 (struct partial_symtab
*);
757 gdb_byte
*dwarf2_read_section (struct objfile
*, asection
*);
759 static void dwarf2_read_abbrevs (bfd
*abfd
, struct dwarf2_cu
*cu
);
761 static void dwarf2_free_abbrev_table (void *);
763 static struct abbrev_info
*peek_die_abbrev (gdb_byte
*, unsigned int *,
766 static struct abbrev_info
*dwarf2_lookup_abbrev (unsigned int,
769 static struct partial_die_info
*load_partial_dies (bfd
*, gdb_byte
*, int,
772 static gdb_byte
*read_partial_die (struct partial_die_info
*,
773 struct abbrev_info
*abbrev
, unsigned int,
774 bfd
*, gdb_byte
*, struct dwarf2_cu
*);
776 static struct partial_die_info
*find_partial_die (unsigned long,
779 static void fixup_partial_die (struct partial_die_info
*,
782 static gdb_byte
*read_full_die (struct die_info
**, bfd
*, gdb_byte
*,
783 struct dwarf2_cu
*, int *);
785 static gdb_byte
*read_attribute (struct attribute
*, struct attr_abbrev
*,
786 bfd
*, gdb_byte
*, struct dwarf2_cu
*);
788 static gdb_byte
*read_attribute_value (struct attribute
*, unsigned,
789 bfd
*, gdb_byte
*, struct dwarf2_cu
*);
791 static unsigned int read_1_byte (bfd
*, gdb_byte
*);
793 static int read_1_signed_byte (bfd
*, gdb_byte
*);
795 static unsigned int read_2_bytes (bfd
*, gdb_byte
*);
797 static unsigned int read_4_bytes (bfd
*, gdb_byte
*);
799 static unsigned long read_8_bytes (bfd
*, gdb_byte
*);
801 static CORE_ADDR
read_address (bfd
*, gdb_byte
*ptr
, struct dwarf2_cu
*,
804 static LONGEST
read_initial_length (bfd
*, gdb_byte
*,
805 struct comp_unit_head
*, unsigned int *);
807 static LONGEST
read_offset (bfd
*, gdb_byte
*, const struct comp_unit_head
*,
810 static gdb_byte
*read_n_bytes (bfd
*, gdb_byte
*, unsigned int);
812 static char *read_string (bfd
*, gdb_byte
*, unsigned int *);
814 static char *read_indirect_string (bfd
*, gdb_byte
*,
815 const struct comp_unit_head
*,
818 static unsigned long read_unsigned_leb128 (bfd
*, gdb_byte
*, unsigned int *);
820 static long read_signed_leb128 (bfd
*, gdb_byte
*, unsigned int *);
822 static gdb_byte
*skip_leb128 (bfd
*, gdb_byte
*);
824 static void set_cu_language (unsigned int, struct dwarf2_cu
*);
826 static struct attribute
*dwarf2_attr (struct die_info
*, unsigned int,
829 static int dwarf2_flag_true_p (struct die_info
*die
, unsigned name
,
830 struct dwarf2_cu
*cu
);
832 static int die_is_declaration (struct die_info
*, struct dwarf2_cu
*cu
);
834 static struct die_info
*die_specification (struct die_info
*die
,
837 static void free_line_header (struct line_header
*lh
);
839 static void add_file_name (struct line_header
*, char *, unsigned int,
840 unsigned int, unsigned int);
842 static struct line_header
*(dwarf_decode_line_header
843 (unsigned int offset
,
844 bfd
*abfd
, struct dwarf2_cu
*cu
));
846 static void dwarf_decode_lines (struct line_header
*, char *, bfd
*,
847 struct dwarf2_cu
*, struct partial_symtab
*);
849 static void dwarf2_start_subfile (char *, char *);
851 static struct symbol
*new_symbol (struct die_info
*, struct type
*,
854 static void dwarf2_const_value (struct attribute
*, struct symbol
*,
857 static void dwarf2_const_value_data (struct attribute
*attr
,
861 static struct type
*die_type (struct die_info
*, struct dwarf2_cu
*);
863 static struct type
*die_containing_type (struct die_info
*,
866 static struct type
*tag_type_to_type (struct die_info
*, struct dwarf2_cu
*);
868 static void read_type_die (struct die_info
*, struct dwarf2_cu
*);
870 static char *determine_prefix (struct die_info
*die
, struct dwarf2_cu
*);
872 static char *typename_concat (struct obstack
*,
877 static void read_typedef (struct die_info
*, struct dwarf2_cu
*);
879 static void read_base_type (struct die_info
*, struct dwarf2_cu
*);
881 static void read_subrange_type (struct die_info
*die
, struct dwarf2_cu
*cu
);
883 static void read_file_scope (struct die_info
*, struct dwarf2_cu
*);
885 static void read_func_scope (struct die_info
*, struct dwarf2_cu
*);
887 static void read_lexical_block_scope (struct die_info
*, struct dwarf2_cu
*);
889 static int dwarf2_get_pc_bounds (struct die_info
*,
890 CORE_ADDR
*, CORE_ADDR
*, struct dwarf2_cu
*);
892 static void get_scope_pc_bounds (struct die_info
*,
893 CORE_ADDR
*, CORE_ADDR
*,
896 static void dwarf2_add_field (struct field_info
*, struct die_info
*,
899 static void dwarf2_attach_fields_to_type (struct field_info
*,
900 struct type
*, struct dwarf2_cu
*);
902 static void dwarf2_add_member_fn (struct field_info
*,
903 struct die_info
*, struct type
*,
906 static void dwarf2_attach_fn_fields_to_type (struct field_info
*,
907 struct type
*, struct dwarf2_cu
*);
909 static void read_structure_type (struct die_info
*, struct dwarf2_cu
*);
911 static void process_structure_scope (struct die_info
*, struct dwarf2_cu
*);
913 static char *determine_class_name (struct die_info
*die
, struct dwarf2_cu
*cu
);
915 static void read_common_block (struct die_info
*, struct dwarf2_cu
*);
917 static void read_namespace (struct die_info
*die
, struct dwarf2_cu
*);
919 static const char *namespace_name (struct die_info
*die
,
920 int *is_anonymous
, struct dwarf2_cu
*);
922 static void read_enumeration_type (struct die_info
*, struct dwarf2_cu
*);
924 static void process_enumeration_scope (struct die_info
*, struct dwarf2_cu
*);
926 static struct type
*dwarf_base_type (int, int, struct dwarf2_cu
*);
928 static CORE_ADDR
decode_locdesc (struct dwarf_block
*, struct dwarf2_cu
*);
930 static void read_array_type (struct die_info
*, struct dwarf2_cu
*);
932 static enum dwarf_array_dim_ordering
read_array_order (struct die_info
*,
935 static void read_tag_pointer_type (struct die_info
*, struct dwarf2_cu
*);
937 static void read_tag_ptr_to_member_type (struct die_info
*,
940 static void read_tag_reference_type (struct die_info
*, struct dwarf2_cu
*);
942 static void read_tag_const_type (struct die_info
*, struct dwarf2_cu
*);
944 static void read_tag_volatile_type (struct die_info
*, struct dwarf2_cu
*);
946 static void read_tag_string_type (struct die_info
*, struct dwarf2_cu
*);
948 static void read_subroutine_type (struct die_info
*, struct dwarf2_cu
*);
950 static struct die_info
*read_comp_unit (gdb_byte
*, bfd
*, struct dwarf2_cu
*);
952 static struct die_info
*read_die_and_children (gdb_byte
*info_ptr
, bfd
*abfd
,
954 gdb_byte
**new_info_ptr
,
955 struct die_info
*parent
);
957 static struct die_info
*read_die_and_siblings (gdb_byte
*info_ptr
, bfd
*abfd
,
959 gdb_byte
**new_info_ptr
,
960 struct die_info
*parent
);
962 static void free_die_list (struct die_info
*);
964 static void process_die (struct die_info
*, struct dwarf2_cu
*);
966 static char *dwarf2_linkage_name (struct die_info
*, struct dwarf2_cu
*);
968 static char *dwarf2_name (struct die_info
*die
, struct dwarf2_cu
*);
970 static struct die_info
*dwarf2_extension (struct die_info
*die
,
973 static char *dwarf_tag_name (unsigned int);
975 static char *dwarf_attr_name (unsigned int);
977 static char *dwarf_form_name (unsigned int);
979 static char *dwarf_stack_op_name (unsigned int);
981 static char *dwarf_bool_name (unsigned int);
983 static char *dwarf_type_encoding_name (unsigned int);
986 static char *dwarf_cfi_name (unsigned int);
988 struct die_info
*copy_die (struct die_info
*);
991 static struct die_info
*sibling_die (struct die_info
*);
993 static void dump_die (struct die_info
*);
995 static void dump_die_list (struct die_info
*);
997 static void store_in_ref_table (unsigned int, struct die_info
*,
1000 static unsigned int dwarf2_get_ref_die_offset (struct attribute
*,
1001 struct dwarf2_cu
*);
1003 static int dwarf2_get_attr_constant_value (struct attribute
*, int);
1005 static struct die_info
*follow_die_ref (struct die_info
*,
1007 struct dwarf2_cu
*);
1009 static struct type
*dwarf2_fundamental_type (struct objfile
*, int,
1010 struct dwarf2_cu
*);
1012 /* memory allocation interface */
1014 static struct dwarf_block
*dwarf_alloc_block (struct dwarf2_cu
*);
1016 static struct abbrev_info
*dwarf_alloc_abbrev (struct dwarf2_cu
*);
1018 static struct die_info
*dwarf_alloc_die (void);
1020 static void initialize_cu_func_list (struct dwarf2_cu
*);
1022 static void add_to_cu_func_list (const char *, CORE_ADDR
, CORE_ADDR
,
1023 struct dwarf2_cu
*);
1025 static void dwarf_decode_macros (struct line_header
*, unsigned int,
1026 char *, bfd
*, struct dwarf2_cu
*);
1028 static int attr_form_is_block (struct attribute
*);
1031 dwarf2_symbol_mark_computed (struct attribute
*attr
, struct symbol
*sym
,
1032 struct dwarf2_cu
*cu
);
1034 static gdb_byte
*skip_one_die (gdb_byte
*info_ptr
, struct abbrev_info
*abbrev
,
1035 struct dwarf2_cu
*cu
);
1037 static void free_stack_comp_unit (void *);
1039 static hashval_t
partial_die_hash (const void *item
);
1041 static int partial_die_eq (const void *item_lhs
, const void *item_rhs
);
1043 static struct dwarf2_per_cu_data
*dwarf2_find_containing_comp_unit
1044 (unsigned long offset
, struct objfile
*objfile
);
1046 static struct dwarf2_per_cu_data
*dwarf2_find_comp_unit
1047 (unsigned long offset
, struct objfile
*objfile
);
1049 static void free_one_comp_unit (void *);
1051 static void free_cached_comp_units (void *);
1053 static void age_cached_comp_units (void);
1055 static void free_one_cached_comp_unit (void *);
1057 static void set_die_type (struct die_info
*, struct type
*,
1058 struct dwarf2_cu
*);
1060 static void reset_die_and_siblings_types (struct die_info
*,
1061 struct dwarf2_cu
*);
1063 static void create_all_comp_units (struct objfile
*);
1065 static struct dwarf2_cu
*load_full_comp_unit (struct dwarf2_per_cu_data
*);
1067 static void process_full_comp_unit (struct dwarf2_per_cu_data
*);
1069 static void dwarf2_add_dependence (struct dwarf2_cu
*,
1070 struct dwarf2_per_cu_data
*);
1072 static void dwarf2_mark (struct dwarf2_cu
*);
1074 static void dwarf2_clear_marks (struct dwarf2_per_cu_data
*);
1076 /* Try to locate the sections we need for DWARF 2 debugging
1077 information and return true if we have enough to do something. */
1080 dwarf2_has_info (struct objfile
*objfile
)
1082 struct dwarf2_per_objfile
*data
;
1084 /* Initialize per-objfile state. */
1085 data
= obstack_alloc (&objfile
->objfile_obstack
, sizeof (*data
));
1086 memset (data
, 0, sizeof (*data
));
1087 set_objfile_data (objfile
, dwarf2_objfile_data_key
, data
);
1088 dwarf2_per_objfile
= data
;
1090 dwarf_info_section
= 0;
1091 dwarf_abbrev_section
= 0;
1092 dwarf_line_section
= 0;
1093 dwarf_str_section
= 0;
1094 dwarf_macinfo_section
= 0;
1095 dwarf_frame_section
= 0;
1096 dwarf_eh_frame_section
= 0;
1097 dwarf_ranges_section
= 0;
1098 dwarf_loc_section
= 0;
1100 bfd_map_over_sections (objfile
->obfd
, dwarf2_locate_sections
, NULL
);
1101 return (dwarf_info_section
!= NULL
&& dwarf_abbrev_section
!= NULL
);
1104 /* This function is mapped across the sections and remembers the
1105 offset and size of each of the debugging sections we are interested
1109 dwarf2_locate_sections (bfd
*ignore_abfd
, asection
*sectp
, void *ignore_ptr
)
1111 if (strcmp (sectp
->name
, INFO_SECTION
) == 0)
1113 dwarf2_per_objfile
->info_size
= bfd_get_section_size (sectp
);
1114 dwarf_info_section
= sectp
;
1116 else if (strcmp (sectp
->name
, ABBREV_SECTION
) == 0)
1118 dwarf2_per_objfile
->abbrev_size
= bfd_get_section_size (sectp
);
1119 dwarf_abbrev_section
= sectp
;
1121 else if (strcmp (sectp
->name
, LINE_SECTION
) == 0)
1123 dwarf2_per_objfile
->line_size
= bfd_get_section_size (sectp
);
1124 dwarf_line_section
= sectp
;
1126 else if (strcmp (sectp
->name
, PUBNAMES_SECTION
) == 0)
1128 dwarf2_per_objfile
->pubnames_size
= bfd_get_section_size (sectp
);
1129 dwarf_pubnames_section
= sectp
;
1131 else if (strcmp (sectp
->name
, ARANGES_SECTION
) == 0)
1133 dwarf2_per_objfile
->aranges_size
= bfd_get_section_size (sectp
);
1134 dwarf_aranges_section
= sectp
;
1136 else if (strcmp (sectp
->name
, LOC_SECTION
) == 0)
1138 dwarf2_per_objfile
->loc_size
= bfd_get_section_size (sectp
);
1139 dwarf_loc_section
= sectp
;
1141 else if (strcmp (sectp
->name
, MACINFO_SECTION
) == 0)
1143 dwarf2_per_objfile
->macinfo_size
= bfd_get_section_size (sectp
);
1144 dwarf_macinfo_section
= sectp
;
1146 else if (strcmp (sectp
->name
, STR_SECTION
) == 0)
1148 dwarf2_per_objfile
->str_size
= bfd_get_section_size (sectp
);
1149 dwarf_str_section
= sectp
;
1151 else if (strcmp (sectp
->name
, FRAME_SECTION
) == 0)
1153 dwarf2_per_objfile
->frame_size
= bfd_get_section_size (sectp
);
1154 dwarf_frame_section
= sectp
;
1156 else if (strcmp (sectp
->name
, EH_FRAME_SECTION
) == 0)
1158 flagword aflag
= bfd_get_section_flags (ignore_abfd
, sectp
);
1159 if (aflag
& SEC_HAS_CONTENTS
)
1161 dwarf2_per_objfile
->eh_frame_size
= bfd_get_section_size (sectp
);
1162 dwarf_eh_frame_section
= sectp
;
1165 else if (strcmp (sectp
->name
, RANGES_SECTION
) == 0)
1167 dwarf2_per_objfile
->ranges_size
= bfd_get_section_size (sectp
);
1168 dwarf_ranges_section
= sectp
;
1172 /* Build a partial symbol table. */
1175 dwarf2_build_psymtabs (struct objfile
*objfile
, int mainline
)
1177 /* We definitely need the .debug_info and .debug_abbrev sections */
1179 dwarf2_per_objfile
->info_buffer
= dwarf2_read_section (objfile
, dwarf_info_section
);
1180 dwarf2_per_objfile
->abbrev_buffer
= dwarf2_read_section (objfile
, dwarf_abbrev_section
);
1182 if (dwarf_line_section
)
1183 dwarf2_per_objfile
->line_buffer
= dwarf2_read_section (objfile
, dwarf_line_section
);
1185 dwarf2_per_objfile
->line_buffer
= NULL
;
1187 if (dwarf_str_section
)
1188 dwarf2_per_objfile
->str_buffer
= dwarf2_read_section (objfile
, dwarf_str_section
);
1190 dwarf2_per_objfile
->str_buffer
= NULL
;
1192 if (dwarf_macinfo_section
)
1193 dwarf2_per_objfile
->macinfo_buffer
= dwarf2_read_section (objfile
,
1194 dwarf_macinfo_section
);
1196 dwarf2_per_objfile
->macinfo_buffer
= NULL
;
1198 if (dwarf_ranges_section
)
1199 dwarf2_per_objfile
->ranges_buffer
= dwarf2_read_section (objfile
, dwarf_ranges_section
);
1201 dwarf2_per_objfile
->ranges_buffer
= NULL
;
1203 if (dwarf_loc_section
)
1204 dwarf2_per_objfile
->loc_buffer
= dwarf2_read_section (objfile
, dwarf_loc_section
);
1206 dwarf2_per_objfile
->loc_buffer
= NULL
;
1209 || (objfile
->global_psymbols
.size
== 0
1210 && objfile
->static_psymbols
.size
== 0))
1212 init_psymbol_list (objfile
, 1024);
1216 if (dwarf_aranges_offset
&& dwarf_pubnames_offset
)
1218 /* Things are significantly easier if we have .debug_aranges and
1219 .debug_pubnames sections */
1221 dwarf2_build_psymtabs_easy (objfile
, mainline
);
1225 /* only test this case for now */
1227 /* In this case we have to work a bit harder */
1228 dwarf2_build_psymtabs_hard (objfile
, mainline
);
1233 /* Build the partial symbol table from the information in the
1234 .debug_pubnames and .debug_aranges sections. */
1237 dwarf2_build_psymtabs_easy (struct objfile
*objfile
, int mainline
)
1239 bfd
*abfd
= objfile
->obfd
;
1240 char *aranges_buffer
, *pubnames_buffer
;
1241 char *aranges_ptr
, *pubnames_ptr
;
1242 unsigned int entry_length
, version
, info_offset
, info_size
;
1244 pubnames_buffer
= dwarf2_read_section (objfile
,
1245 dwarf_pubnames_section
);
1246 pubnames_ptr
= pubnames_buffer
;
1247 while ((pubnames_ptr
- pubnames_buffer
) < dwarf2_per_objfile
->pubnames_size
)
1249 struct comp_unit_head cu_header
;
1250 unsigned int bytes_read
;
1252 entry_length
= read_initial_length (abfd
, pubnames_ptr
, &cu_header
,
1254 pubnames_ptr
+= bytes_read
;
1255 version
= read_1_byte (abfd
, pubnames_ptr
);
1257 info_offset
= read_4_bytes (abfd
, pubnames_ptr
);
1259 info_size
= read_4_bytes (abfd
, pubnames_ptr
);
1263 aranges_buffer
= dwarf2_read_section (objfile
,
1264 dwarf_aranges_section
);
1269 /* Read in the comp unit header information from the debug_info at
1273 read_comp_unit_head (struct comp_unit_head
*cu_header
,
1274 gdb_byte
*info_ptr
, bfd
*abfd
)
1277 unsigned int bytes_read
;
1278 cu_header
->length
= read_initial_length (abfd
, info_ptr
, cu_header
,
1280 info_ptr
+= bytes_read
;
1281 cu_header
->version
= read_2_bytes (abfd
, info_ptr
);
1283 cu_header
->abbrev_offset
= read_offset (abfd
, info_ptr
, cu_header
,
1285 info_ptr
+= bytes_read
;
1286 cu_header
->addr_size
= read_1_byte (abfd
, info_ptr
);
1288 signed_addr
= bfd_get_sign_extend_vma (abfd
);
1289 if (signed_addr
< 0)
1290 internal_error (__FILE__
, __LINE__
,
1291 _("read_comp_unit_head: dwarf from non elf file"));
1292 cu_header
->signed_addr_p
= signed_addr
;
1297 partial_read_comp_unit_head (struct comp_unit_head
*header
, gdb_byte
*info_ptr
,
1300 gdb_byte
*beg_of_comp_unit
= info_ptr
;
1302 info_ptr
= read_comp_unit_head (header
, info_ptr
, abfd
);
1304 if (header
->version
!= 2)
1305 error (_("Dwarf Error: wrong version in compilation unit header "
1306 "(is %d, should be %d) [in module %s]"), header
->version
,
1307 2, bfd_get_filename (abfd
));
1309 if (header
->abbrev_offset
>= dwarf2_per_objfile
->abbrev_size
)
1310 error (_("Dwarf Error: bad offset (0x%lx) in compilation unit header "
1311 "(offset 0x%lx + 6) [in module %s]"),
1312 (long) header
->abbrev_offset
,
1313 (long) (beg_of_comp_unit
- dwarf2_per_objfile
->info_buffer
),
1314 bfd_get_filename (abfd
));
1316 if (beg_of_comp_unit
+ header
->length
+ header
->initial_length_size
1317 > dwarf2_per_objfile
->info_buffer
+ dwarf2_per_objfile
->info_size
)
1318 error (_("Dwarf Error: bad length (0x%lx) in compilation unit header "
1319 "(offset 0x%lx + 0) [in module %s]"),
1320 (long) header
->length
,
1321 (long) (beg_of_comp_unit
- dwarf2_per_objfile
->info_buffer
),
1322 bfd_get_filename (abfd
));
1327 /* Allocate a new partial symtab for file named NAME and mark this new
1328 partial symtab as being an include of PST. */
1331 dwarf2_create_include_psymtab (char *name
, struct partial_symtab
*pst
,
1332 struct objfile
*objfile
)
1334 struct partial_symtab
*subpst
= allocate_psymtab (name
, objfile
);
1336 subpst
->section_offsets
= pst
->section_offsets
;
1337 subpst
->textlow
= 0;
1338 subpst
->texthigh
= 0;
1340 subpst
->dependencies
= (struct partial_symtab
**)
1341 obstack_alloc (&objfile
->objfile_obstack
,
1342 sizeof (struct partial_symtab
*));
1343 subpst
->dependencies
[0] = pst
;
1344 subpst
->number_of_dependencies
= 1;
1346 subpst
->globals_offset
= 0;
1347 subpst
->n_global_syms
= 0;
1348 subpst
->statics_offset
= 0;
1349 subpst
->n_static_syms
= 0;
1350 subpst
->symtab
= NULL
;
1351 subpst
->read_symtab
= pst
->read_symtab
;
1354 /* No private part is necessary for include psymtabs. This property
1355 can be used to differentiate between such include psymtabs and
1356 the regular ones. */
1357 subpst
->read_symtab_private
= NULL
;
1360 /* Read the Line Number Program data and extract the list of files
1361 included by the source file represented by PST. Build an include
1362 partial symtab for each of these included files.
1364 This procedure assumes that there *is* a Line Number Program in
1365 the given CU. Callers should check that PDI->HAS_STMT_LIST is set
1366 before calling this procedure. */
1369 dwarf2_build_include_psymtabs (struct dwarf2_cu
*cu
,
1370 struct partial_die_info
*pdi
,
1371 struct partial_symtab
*pst
)
1373 struct objfile
*objfile
= cu
->objfile
;
1374 bfd
*abfd
= objfile
->obfd
;
1375 struct line_header
*lh
;
1377 lh
= dwarf_decode_line_header (pdi
->line_offset
, abfd
, cu
);
1379 return; /* No linetable, so no includes. */
1381 dwarf_decode_lines (lh
, NULL
, abfd
, cu
, pst
);
1383 free_line_header (lh
);
1387 /* Build the partial symbol table by doing a quick pass through the
1388 .debug_info and .debug_abbrev sections. */
1391 dwarf2_build_psymtabs_hard (struct objfile
*objfile
, int mainline
)
1393 /* Instead of reading this into a big buffer, we should probably use
1394 mmap() on architectures that support it. (FIXME) */
1395 bfd
*abfd
= objfile
->obfd
;
1397 gdb_byte
*beg_of_comp_unit
;
1398 struct partial_die_info comp_unit_die
;
1399 struct partial_symtab
*pst
;
1400 struct cleanup
*back_to
;
1401 CORE_ADDR lowpc
, highpc
, baseaddr
;
1403 info_ptr
= dwarf2_per_objfile
->info_buffer
;
1405 /* Any cached compilation units will be linked by the per-objfile
1406 read_in_chain. Make sure to free them when we're done. */
1407 back_to
= make_cleanup (free_cached_comp_units
, NULL
);
1409 create_all_comp_units (objfile
);
1411 /* Since the objects we're extracting from .debug_info vary in
1412 length, only the individual functions to extract them (like
1413 read_comp_unit_head and load_partial_die) can really know whether
1414 the buffer is large enough to hold another complete object.
1416 At the moment, they don't actually check that. If .debug_info
1417 holds just one extra byte after the last compilation unit's dies,
1418 then read_comp_unit_head will happily read off the end of the
1419 buffer. read_partial_die is similarly casual. Those functions
1422 For this loop condition, simply checking whether there's any data
1423 left at all should be sufficient. */
1424 while (info_ptr
< (dwarf2_per_objfile
->info_buffer
1425 + dwarf2_per_objfile
->info_size
))
1427 struct cleanup
*back_to_inner
;
1428 struct dwarf2_cu cu
;
1429 struct abbrev_info
*abbrev
;
1430 unsigned int bytes_read
;
1431 struct dwarf2_per_cu_data
*this_cu
;
1433 beg_of_comp_unit
= info_ptr
;
1435 memset (&cu
, 0, sizeof (cu
));
1437 obstack_init (&cu
.comp_unit_obstack
);
1439 back_to_inner
= make_cleanup (free_stack_comp_unit
, &cu
);
1441 cu
.objfile
= objfile
;
1442 info_ptr
= partial_read_comp_unit_head (&cu
.header
, info_ptr
, abfd
);
1444 /* Complete the cu_header */
1445 cu
.header
.offset
= beg_of_comp_unit
- dwarf2_per_objfile
->info_buffer
;
1446 cu
.header
.first_die_ptr
= info_ptr
;
1447 cu
.header
.cu_head_ptr
= beg_of_comp_unit
;
1449 cu
.list_in_scope
= &file_symbols
;
1451 /* Read the abbrevs for this compilation unit into a table */
1452 dwarf2_read_abbrevs (abfd
, &cu
);
1453 make_cleanup (dwarf2_free_abbrev_table
, &cu
);
1455 this_cu
= dwarf2_find_comp_unit (cu
.header
.offset
, objfile
);
1457 /* Read the compilation unit die */
1458 abbrev
= peek_die_abbrev (info_ptr
, &bytes_read
, &cu
);
1459 info_ptr
= read_partial_die (&comp_unit_die
, abbrev
, bytes_read
,
1460 abfd
, info_ptr
, &cu
);
1462 /* Set the language we're debugging */
1463 set_cu_language (comp_unit_die
.language
, &cu
);
1465 /* Allocate a new partial symbol table structure */
1466 pst
= start_psymtab_common (objfile
, objfile
->section_offsets
,
1467 comp_unit_die
.name
? comp_unit_die
.name
: "",
1468 comp_unit_die
.lowpc
,
1469 objfile
->global_psymbols
.next
,
1470 objfile
->static_psymbols
.next
);
1472 if (comp_unit_die
.dirname
)
1473 pst
->dirname
= xstrdup (comp_unit_die
.dirname
);
1475 pst
->read_symtab_private
= (char *) this_cu
;
1477 baseaddr
= ANOFFSET (objfile
->section_offsets
, SECT_OFF_TEXT (objfile
));
1479 /* Store the function that reads in the rest of the symbol table */
1480 pst
->read_symtab
= dwarf2_psymtab_to_symtab
;
1482 /* If this compilation unit was already read in, free the
1483 cached copy in order to read it in again. This is
1484 necessary because we skipped some symbols when we first
1485 read in the compilation unit (see load_partial_dies).
1486 This problem could be avoided, but the benefit is
1488 if (this_cu
->cu
!= NULL
)
1489 free_one_cached_comp_unit (this_cu
->cu
);
1491 cu
.per_cu
= this_cu
;
1493 /* Note that this is a pointer to our stack frame, being
1494 added to a global data structure. It will be cleaned up
1495 in free_stack_comp_unit when we finish with this
1496 compilation unit. */
1499 this_cu
->psymtab
= pst
;
1501 /* Check if comp unit has_children.
1502 If so, read the rest of the partial symbols from this comp unit.
1503 If not, there's no more debug_info for this comp unit. */
1504 if (comp_unit_die
.has_children
)
1506 struct partial_die_info
*first_die
;
1508 lowpc
= ((CORE_ADDR
) -1);
1509 highpc
= ((CORE_ADDR
) 0);
1511 first_die
= load_partial_dies (abfd
, info_ptr
, 1, &cu
);
1513 scan_partial_symbols (first_die
, &lowpc
, &highpc
, &cu
);
1515 /* If we didn't find a lowpc, set it to highpc to avoid
1516 complaints from `maint check'. */
1517 if (lowpc
== ((CORE_ADDR
) -1))
1520 /* If the compilation unit didn't have an explicit address range,
1521 then use the information extracted from its child dies. */
1522 if (! comp_unit_die
.has_pc_info
)
1524 comp_unit_die
.lowpc
= lowpc
;
1525 comp_unit_die
.highpc
= highpc
;
1528 pst
->textlow
= comp_unit_die
.lowpc
+ baseaddr
;
1529 pst
->texthigh
= comp_unit_die
.highpc
+ baseaddr
;
1531 pst
->n_global_syms
= objfile
->global_psymbols
.next
-
1532 (objfile
->global_psymbols
.list
+ pst
->globals_offset
);
1533 pst
->n_static_syms
= objfile
->static_psymbols
.next
-
1534 (objfile
->static_psymbols
.list
+ pst
->statics_offset
);
1535 sort_pst_symbols (pst
);
1537 /* If there is already a psymtab or symtab for a file of this
1538 name, remove it. (If there is a symtab, more drastic things
1539 also happen.) This happens in VxWorks. */
1540 free_named_symtabs (pst
->filename
);
1542 info_ptr
= beg_of_comp_unit
+ cu
.header
.length
1543 + cu
.header
.initial_length_size
;
1545 if (comp_unit_die
.has_stmt_list
)
1547 /* Get the list of files included in the current compilation unit,
1548 and build a psymtab for each of them. */
1549 dwarf2_build_include_psymtabs (&cu
, &comp_unit_die
, pst
);
1552 do_cleanups (back_to_inner
);
1554 do_cleanups (back_to
);
1557 /* Load the DIEs for a secondary CU into memory. */
1560 load_comp_unit (struct dwarf2_per_cu_data
*this_cu
, struct objfile
*objfile
)
1562 bfd
*abfd
= objfile
->obfd
;
1563 gdb_byte
*info_ptr
, *beg_of_comp_unit
;
1564 struct partial_die_info comp_unit_die
;
1565 struct dwarf2_cu
*cu
;
1566 struct abbrev_info
*abbrev
;
1567 unsigned int bytes_read
;
1568 struct cleanup
*back_to
;
1570 info_ptr
= dwarf2_per_objfile
->info_buffer
+ this_cu
->offset
;
1571 beg_of_comp_unit
= info_ptr
;
1573 cu
= xmalloc (sizeof (struct dwarf2_cu
));
1574 memset (cu
, 0, sizeof (struct dwarf2_cu
));
1576 obstack_init (&cu
->comp_unit_obstack
);
1578 cu
->objfile
= objfile
;
1579 info_ptr
= partial_read_comp_unit_head (&cu
->header
, info_ptr
, abfd
);
1581 /* Complete the cu_header. */
1582 cu
->header
.offset
= beg_of_comp_unit
- dwarf2_per_objfile
->info_buffer
;
1583 cu
->header
.first_die_ptr
= info_ptr
;
1584 cu
->header
.cu_head_ptr
= beg_of_comp_unit
;
1586 /* Read the abbrevs for this compilation unit into a table. */
1587 dwarf2_read_abbrevs (abfd
, cu
);
1588 back_to
= make_cleanup (dwarf2_free_abbrev_table
, cu
);
1590 /* Read the compilation unit die. */
1591 abbrev
= peek_die_abbrev (info_ptr
, &bytes_read
, cu
);
1592 info_ptr
= read_partial_die (&comp_unit_die
, abbrev
, bytes_read
,
1593 abfd
, info_ptr
, cu
);
1595 /* Set the language we're debugging. */
1596 set_cu_language (comp_unit_die
.language
, cu
);
1598 /* Link this compilation unit into the compilation unit tree. */
1600 cu
->per_cu
= this_cu
;
1602 /* Check if comp unit has_children.
1603 If so, read the rest of the partial symbols from this comp unit.
1604 If not, there's no more debug_info for this comp unit. */
1605 if (comp_unit_die
.has_children
)
1606 load_partial_dies (abfd
, info_ptr
, 0, cu
);
1608 do_cleanups (back_to
);
1611 /* Create a list of all compilation units in OBJFILE. We do this only
1612 if an inter-comp-unit reference is found; presumably if there is one,
1613 there will be many, and one will occur early in the .debug_info section.
1614 So there's no point in building this list incrementally. */
1617 create_all_comp_units (struct objfile
*objfile
)
1621 struct dwarf2_per_cu_data
**all_comp_units
;
1622 gdb_byte
*info_ptr
= dwarf2_per_objfile
->info_buffer
;
1626 all_comp_units
= xmalloc (n_allocated
1627 * sizeof (struct dwarf2_per_cu_data
*));
1629 while (info_ptr
< dwarf2_per_objfile
->info_buffer
+ dwarf2_per_objfile
->info_size
)
1631 struct comp_unit_head cu_header
;
1632 gdb_byte
*beg_of_comp_unit
;
1633 struct dwarf2_per_cu_data
*this_cu
;
1634 unsigned long offset
;
1635 unsigned int bytes_read
;
1637 offset
= info_ptr
- dwarf2_per_objfile
->info_buffer
;
1639 /* Read just enough information to find out where the next
1640 compilation unit is. */
1641 cu_header
.initial_length_size
= 0;
1642 cu_header
.length
= read_initial_length (objfile
->obfd
, info_ptr
,
1643 &cu_header
, &bytes_read
);
1645 /* Save the compilation unit for later lookup. */
1646 this_cu
= obstack_alloc (&objfile
->objfile_obstack
,
1647 sizeof (struct dwarf2_per_cu_data
));
1648 memset (this_cu
, 0, sizeof (*this_cu
));
1649 this_cu
->offset
= offset
;
1650 this_cu
->length
= cu_header
.length
+ cu_header
.initial_length_size
;
1652 if (n_comp_units
== n_allocated
)
1655 all_comp_units
= xrealloc (all_comp_units
,
1657 * sizeof (struct dwarf2_per_cu_data
*));
1659 all_comp_units
[n_comp_units
++] = this_cu
;
1661 info_ptr
= info_ptr
+ this_cu
->length
;
1664 dwarf2_per_objfile
->all_comp_units
1665 = obstack_alloc (&objfile
->objfile_obstack
,
1666 n_comp_units
* sizeof (struct dwarf2_per_cu_data
*));
1667 memcpy (dwarf2_per_objfile
->all_comp_units
, all_comp_units
,
1668 n_comp_units
* sizeof (struct dwarf2_per_cu_data
*));
1669 xfree (all_comp_units
);
1670 dwarf2_per_objfile
->n_comp_units
= n_comp_units
;
1673 /* Process all loaded DIEs for compilation unit CU, starting at FIRST_DIE.
1674 Also set *LOWPC and *HIGHPC to the lowest and highest PC values found
1678 scan_partial_symbols (struct partial_die_info
*first_die
, CORE_ADDR
*lowpc
,
1679 CORE_ADDR
*highpc
, struct dwarf2_cu
*cu
)
1681 struct objfile
*objfile
= cu
->objfile
;
1682 bfd
*abfd
= objfile
->obfd
;
1683 struct partial_die_info
*pdi
;
1685 /* Now, march along the PDI's, descending into ones which have
1686 interesting children but skipping the children of the other ones,
1687 until we reach the end of the compilation unit. */
1693 fixup_partial_die (pdi
, cu
);
1695 /* Anonymous namespaces have no name but have interesting
1696 children, so we need to look at them. Ditto for anonymous
1699 if (pdi
->name
!= NULL
|| pdi
->tag
== DW_TAG_namespace
1700 || pdi
->tag
== DW_TAG_enumeration_type
)
1704 case DW_TAG_subprogram
:
1705 if (pdi
->has_pc_info
)
1707 if (pdi
->lowpc
< *lowpc
)
1709 *lowpc
= pdi
->lowpc
;
1711 if (pdi
->highpc
> *highpc
)
1713 *highpc
= pdi
->highpc
;
1715 if (!pdi
->is_declaration
)
1717 add_partial_symbol (pdi
, cu
);
1721 case DW_TAG_variable
:
1722 case DW_TAG_typedef
:
1723 case DW_TAG_union_type
:
1724 if (!pdi
->is_declaration
)
1726 add_partial_symbol (pdi
, cu
);
1729 case DW_TAG_class_type
:
1730 case DW_TAG_structure_type
:
1731 if (!pdi
->is_declaration
)
1733 add_partial_symbol (pdi
, cu
);
1736 case DW_TAG_enumeration_type
:
1737 if (!pdi
->is_declaration
)
1738 add_partial_enumeration (pdi
, cu
);
1740 case DW_TAG_base_type
:
1741 case DW_TAG_subrange_type
:
1742 /* File scope base type definitions are added to the partial
1744 add_partial_symbol (pdi
, cu
);
1746 case DW_TAG_namespace
:
1747 add_partial_namespace (pdi
, lowpc
, highpc
, cu
);
1754 /* If the die has a sibling, skip to the sibling. */
1756 pdi
= pdi
->die_sibling
;
1760 /* Functions used to compute the fully scoped name of a partial DIE.
1762 Normally, this is simple. For C++, the parent DIE's fully scoped
1763 name is concatenated with "::" and the partial DIE's name. For
1764 Java, the same thing occurs except that "." is used instead of "::".
1765 Enumerators are an exception; they use the scope of their parent
1766 enumeration type, i.e. the name of the enumeration type is not
1767 prepended to the enumerator.
1769 There are two complexities. One is DW_AT_specification; in this
1770 case "parent" means the parent of the target of the specification,
1771 instead of the direct parent of the DIE. The other is compilers
1772 which do not emit DW_TAG_namespace; in this case we try to guess
1773 the fully qualified name of structure types from their members'
1774 linkage names. This must be done using the DIE's children rather
1775 than the children of any DW_AT_specification target. We only need
1776 to do this for structures at the top level, i.e. if the target of
1777 any DW_AT_specification (if any; otherwise the DIE itself) does not
1780 /* Compute the scope prefix associated with PDI's parent, in
1781 compilation unit CU. The result will be allocated on CU's
1782 comp_unit_obstack, or a copy of the already allocated PDI->NAME
1783 field. NULL is returned if no prefix is necessary. */
1785 partial_die_parent_scope (struct partial_die_info
*pdi
,
1786 struct dwarf2_cu
*cu
)
1788 char *grandparent_scope
;
1789 struct partial_die_info
*parent
, *real_pdi
;
1791 /* We need to look at our parent DIE; if we have a DW_AT_specification,
1792 then this means the parent of the specification DIE. */
1795 while (real_pdi
->has_specification
)
1796 real_pdi
= find_partial_die (real_pdi
->spec_offset
, cu
);
1798 parent
= real_pdi
->die_parent
;
1802 if (parent
->scope_set
)
1803 return parent
->scope
;
1805 fixup_partial_die (parent
, cu
);
1807 grandparent_scope
= partial_die_parent_scope (parent
, cu
);
1809 if (parent
->tag
== DW_TAG_namespace
1810 || parent
->tag
== DW_TAG_structure_type
1811 || parent
->tag
== DW_TAG_class_type
1812 || parent
->tag
== DW_TAG_union_type
)
1814 if (grandparent_scope
== NULL
)
1815 parent
->scope
= parent
->name
;
1817 parent
->scope
= typename_concat (&cu
->comp_unit_obstack
, grandparent_scope
,
1820 else if (parent
->tag
== DW_TAG_enumeration_type
)
1821 /* Enumerators should not get the name of the enumeration as a prefix. */
1822 parent
->scope
= grandparent_scope
;
1825 /* FIXME drow/2004-04-01: What should we be doing with
1826 function-local names? For partial symbols, we should probably be
1828 complaint (&symfile_complaints
,
1829 _("unhandled containing DIE tag %d for DIE at %d"),
1830 parent
->tag
, pdi
->offset
);
1831 parent
->scope
= grandparent_scope
;
1834 parent
->scope_set
= 1;
1835 return parent
->scope
;
1838 /* Return the fully scoped name associated with PDI, from compilation unit
1839 CU. The result will be allocated with malloc. */
1841 partial_die_full_name (struct partial_die_info
*pdi
,
1842 struct dwarf2_cu
*cu
)
1846 parent_scope
= partial_die_parent_scope (pdi
, cu
);
1847 if (parent_scope
== NULL
)
1850 return typename_concat (NULL
, parent_scope
, pdi
->name
, cu
);
1854 add_partial_symbol (struct partial_die_info
*pdi
, struct dwarf2_cu
*cu
)
1856 struct objfile
*objfile
= cu
->objfile
;
1859 const char *my_prefix
;
1860 const struct partial_symbol
*psym
= NULL
;
1862 int built_actual_name
= 0;
1864 baseaddr
= ANOFFSET (objfile
->section_offsets
, SECT_OFF_TEXT (objfile
));
1868 if (pdi_needs_namespace (pdi
->tag
))
1870 actual_name
= partial_die_full_name (pdi
, cu
);
1872 built_actual_name
= 1;
1875 if (actual_name
== NULL
)
1876 actual_name
= pdi
->name
;
1880 case DW_TAG_subprogram
:
1881 if (pdi
->is_external
)
1883 /*prim_record_minimal_symbol (actual_name, pdi->lowpc + baseaddr,
1884 mst_text, objfile); */
1885 psym
= add_psymbol_to_list (actual_name
, strlen (actual_name
),
1886 VAR_DOMAIN
, LOC_BLOCK
,
1887 &objfile
->global_psymbols
,
1888 0, pdi
->lowpc
+ baseaddr
,
1889 cu
->language
, objfile
);
1893 /*prim_record_minimal_symbol (actual_name, pdi->lowpc + baseaddr,
1894 mst_file_text, objfile); */
1895 psym
= add_psymbol_to_list (actual_name
, strlen (actual_name
),
1896 VAR_DOMAIN
, LOC_BLOCK
,
1897 &objfile
->static_psymbols
,
1898 0, pdi
->lowpc
+ baseaddr
,
1899 cu
->language
, objfile
);
1902 case DW_TAG_variable
:
1903 if (pdi
->is_external
)
1906 Don't enter into the minimal symbol tables as there is
1907 a minimal symbol table entry from the ELF symbols already.
1908 Enter into partial symbol table if it has a location
1909 descriptor or a type.
1910 If the location descriptor is missing, new_symbol will create
1911 a LOC_UNRESOLVED symbol, the address of the variable will then
1912 be determined from the minimal symbol table whenever the variable
1914 The address for the partial symbol table entry is not
1915 used by GDB, but it comes in handy for debugging partial symbol
1919 addr
= decode_locdesc (pdi
->locdesc
, cu
);
1920 if (pdi
->locdesc
|| pdi
->has_type
)
1921 psym
= add_psymbol_to_list (actual_name
, strlen (actual_name
),
1922 VAR_DOMAIN
, LOC_STATIC
,
1923 &objfile
->global_psymbols
,
1925 cu
->language
, objfile
);
1929 /* Static Variable. Skip symbols without location descriptors. */
1930 if (pdi
->locdesc
== NULL
)
1932 addr
= decode_locdesc (pdi
->locdesc
, cu
);
1933 /*prim_record_minimal_symbol (actual_name, addr + baseaddr,
1934 mst_file_data, objfile); */
1935 psym
= add_psymbol_to_list (actual_name
, strlen (actual_name
),
1936 VAR_DOMAIN
, LOC_STATIC
,
1937 &objfile
->static_psymbols
,
1939 cu
->language
, objfile
);
1942 case DW_TAG_typedef
:
1943 case DW_TAG_base_type
:
1944 case DW_TAG_subrange_type
:
1945 add_psymbol_to_list (actual_name
, strlen (actual_name
),
1946 VAR_DOMAIN
, LOC_TYPEDEF
,
1947 &objfile
->static_psymbols
,
1948 0, (CORE_ADDR
) 0, cu
->language
, objfile
);
1950 case DW_TAG_namespace
:
1951 add_psymbol_to_list (actual_name
, strlen (actual_name
),
1952 VAR_DOMAIN
, LOC_TYPEDEF
,
1953 &objfile
->global_psymbols
,
1954 0, (CORE_ADDR
) 0, cu
->language
, objfile
);
1956 case DW_TAG_class_type
:
1957 case DW_TAG_structure_type
:
1958 case DW_TAG_union_type
:
1959 case DW_TAG_enumeration_type
:
1960 /* Skip aggregate types without children, these are external
1962 /* NOTE: carlton/2003-10-07: See comment in new_symbol about
1963 static vs. global. */
1964 if (pdi
->has_children
== 0)
1966 add_psymbol_to_list (actual_name
, strlen (actual_name
),
1967 STRUCT_DOMAIN
, LOC_TYPEDEF
,
1968 (cu
->language
== language_cplus
1969 || cu
->language
== language_java
)
1970 ? &objfile
->global_psymbols
1971 : &objfile
->static_psymbols
,
1972 0, (CORE_ADDR
) 0, cu
->language
, objfile
);
1974 if (cu
->language
== language_cplus
1975 || cu
->language
== language_java
)
1977 /* For C++ and Java, these implicitly act as typedefs as well. */
1978 add_psymbol_to_list (actual_name
, strlen (actual_name
),
1979 VAR_DOMAIN
, LOC_TYPEDEF
,
1980 &objfile
->global_psymbols
,
1981 0, (CORE_ADDR
) 0, cu
->language
, objfile
);
1984 case DW_TAG_enumerator
:
1985 add_psymbol_to_list (actual_name
, strlen (actual_name
),
1986 VAR_DOMAIN
, LOC_CONST
,
1987 (cu
->language
== language_cplus
1988 || cu
->language
== language_java
)
1989 ? &objfile
->global_psymbols
1990 : &objfile
->static_psymbols
,
1991 0, (CORE_ADDR
) 0, cu
->language
, objfile
);
1997 /* Check to see if we should scan the name for possible namespace
1998 info. Only do this if this is C++, if we don't have namespace
1999 debugging info in the file, if the psym is of an appropriate type
2000 (otherwise we'll have psym == NULL), and if we actually had a
2001 mangled name to begin with. */
2003 /* FIXME drow/2004-02-22: Why don't we do this for classes, i.e. the
2004 cases which do not set PSYM above? */
2006 if (cu
->language
== language_cplus
2007 && cu
->has_namespace_info
== 0
2009 && SYMBOL_CPLUS_DEMANGLED_NAME (psym
) != NULL
)
2010 cp_check_possible_namespace_symbols (SYMBOL_CPLUS_DEMANGLED_NAME (psym
),
2013 if (built_actual_name
)
2014 xfree (actual_name
);
2017 /* Determine whether a die of type TAG living in a C++ class or
2018 namespace needs to have the name of the scope prepended to the
2019 name listed in the die. */
2022 pdi_needs_namespace (enum dwarf_tag tag
)
2026 case DW_TAG_namespace
:
2027 case DW_TAG_typedef
:
2028 case DW_TAG_class_type
:
2029 case DW_TAG_structure_type
:
2030 case DW_TAG_union_type
:
2031 case DW_TAG_enumeration_type
:
2032 case DW_TAG_enumerator
:
2039 /* Read a partial die corresponding to a namespace; also, add a symbol
2040 corresponding to that namespace to the symbol table. NAMESPACE is
2041 the name of the enclosing namespace. */
2044 add_partial_namespace (struct partial_die_info
*pdi
,
2045 CORE_ADDR
*lowpc
, CORE_ADDR
*highpc
,
2046 struct dwarf2_cu
*cu
)
2048 struct objfile
*objfile
= cu
->objfile
;
2050 /* Add a symbol for the namespace. */
2052 add_partial_symbol (pdi
, cu
);
2054 /* Now scan partial symbols in that namespace. */
2056 if (pdi
->has_children
)
2057 scan_partial_symbols (pdi
->die_child
, lowpc
, highpc
, cu
);
2060 /* See if we can figure out if the class lives in a namespace. We do
2061 this by looking for a member function; its demangled name will
2062 contain namespace info, if there is any. */
2065 guess_structure_name (struct partial_die_info
*struct_pdi
,
2066 struct dwarf2_cu
*cu
)
2068 if ((cu
->language
== language_cplus
2069 || cu
->language
== language_java
)
2070 && cu
->has_namespace_info
== 0
2071 && struct_pdi
->has_children
)
2073 /* NOTE: carlton/2003-10-07: Getting the info this way changes
2074 what template types look like, because the demangler
2075 frequently doesn't give the same name as the debug info. We
2076 could fix this by only using the demangled name to get the
2077 prefix (but see comment in read_structure_type). */
2079 struct partial_die_info
*child_pdi
= struct_pdi
->die_child
;
2080 struct partial_die_info
*real_pdi
;
2082 /* If this DIE (this DIE's specification, if any) has a parent, then
2083 we should not do this. We'll prepend the parent's fully qualified
2084 name when we create the partial symbol. */
2086 real_pdi
= struct_pdi
;
2087 while (real_pdi
->has_specification
)
2088 real_pdi
= find_partial_die (real_pdi
->spec_offset
, cu
);
2090 if (real_pdi
->die_parent
!= NULL
)
2093 while (child_pdi
!= NULL
)
2095 if (child_pdi
->tag
== DW_TAG_subprogram
)
2097 char *actual_class_name
2098 = language_class_name_from_physname (cu
->language_defn
,
2100 if (actual_class_name
!= NULL
)
2103 = obsavestring (actual_class_name
,
2104 strlen (actual_class_name
),
2105 &cu
->comp_unit_obstack
);
2106 xfree (actual_class_name
);
2111 child_pdi
= child_pdi
->die_sibling
;
2116 /* Read a partial die corresponding to an enumeration type. */
2119 add_partial_enumeration (struct partial_die_info
*enum_pdi
,
2120 struct dwarf2_cu
*cu
)
2122 struct objfile
*objfile
= cu
->objfile
;
2123 bfd
*abfd
= objfile
->obfd
;
2124 struct partial_die_info
*pdi
;
2126 if (enum_pdi
->name
!= NULL
)
2127 add_partial_symbol (enum_pdi
, cu
);
2129 pdi
= enum_pdi
->die_child
;
2132 if (pdi
->tag
!= DW_TAG_enumerator
|| pdi
->name
== NULL
)
2133 complaint (&symfile_complaints
, _("malformed enumerator DIE ignored"));
2135 add_partial_symbol (pdi
, cu
);
2136 pdi
= pdi
->die_sibling
;
2140 /* Read the initial uleb128 in the die at INFO_PTR in compilation unit CU.
2141 Return the corresponding abbrev, or NULL if the number is zero (indicating
2142 an empty DIE). In either case *BYTES_READ will be set to the length of
2143 the initial number. */
2145 static struct abbrev_info
*
2146 peek_die_abbrev (gdb_byte
*info_ptr
, unsigned int *bytes_read
,
2147 struct dwarf2_cu
*cu
)
2149 bfd
*abfd
= cu
->objfile
->obfd
;
2150 unsigned int abbrev_number
;
2151 struct abbrev_info
*abbrev
;
2153 abbrev_number
= read_unsigned_leb128 (abfd
, info_ptr
, bytes_read
);
2155 if (abbrev_number
== 0)
2158 abbrev
= dwarf2_lookup_abbrev (abbrev_number
, cu
);
2161 error (_("Dwarf Error: Could not find abbrev number %d [in module %s]"), abbrev_number
,
2162 bfd_get_filename (abfd
));
2168 /* Scan the debug information for CU starting at INFO_PTR. Returns a
2169 pointer to the end of a series of DIEs, terminated by an empty
2170 DIE. Any children of the skipped DIEs will also be skipped. */
2173 skip_children (gdb_byte
*info_ptr
, struct dwarf2_cu
*cu
)
2175 struct abbrev_info
*abbrev
;
2176 unsigned int bytes_read
;
2180 abbrev
= peek_die_abbrev (info_ptr
, &bytes_read
, cu
);
2182 return info_ptr
+ bytes_read
;
2184 info_ptr
= skip_one_die (info_ptr
+ bytes_read
, abbrev
, cu
);
2188 /* Scan the debug information for CU starting at INFO_PTR. INFO_PTR
2189 should point just after the initial uleb128 of a DIE, and the
2190 abbrev corresponding to that skipped uleb128 should be passed in
2191 ABBREV. Returns a pointer to this DIE's sibling, skipping any
2195 skip_one_die (gdb_byte
*info_ptr
, struct abbrev_info
*abbrev
,
2196 struct dwarf2_cu
*cu
)
2198 unsigned int bytes_read
;
2199 struct attribute attr
;
2200 bfd
*abfd
= cu
->objfile
->obfd
;
2201 unsigned int form
, i
;
2203 for (i
= 0; i
< abbrev
->num_attrs
; i
++)
2205 /* The only abbrev we care about is DW_AT_sibling. */
2206 if (abbrev
->attrs
[i
].name
== DW_AT_sibling
)
2208 read_attribute (&attr
, &abbrev
->attrs
[i
],
2209 abfd
, info_ptr
, cu
);
2210 if (attr
.form
== DW_FORM_ref_addr
)
2211 complaint (&symfile_complaints
, _("ignoring absolute DW_AT_sibling"));
2213 return dwarf2_per_objfile
->info_buffer
2214 + dwarf2_get_ref_die_offset (&attr
, cu
);
2217 /* If it isn't DW_AT_sibling, skip this attribute. */
2218 form
= abbrev
->attrs
[i
].form
;
2223 case DW_FORM_ref_addr
:
2224 info_ptr
+= cu
->header
.addr_size
;
2243 case DW_FORM_string
:
2244 read_string (abfd
, info_ptr
, &bytes_read
);
2245 info_ptr
+= bytes_read
;
2248 info_ptr
+= cu
->header
.offset_size
;
2251 info_ptr
+= read_unsigned_leb128 (abfd
, info_ptr
, &bytes_read
);
2252 info_ptr
+= bytes_read
;
2254 case DW_FORM_block1
:
2255 info_ptr
+= 1 + read_1_byte (abfd
, info_ptr
);
2257 case DW_FORM_block2
:
2258 info_ptr
+= 2 + read_2_bytes (abfd
, info_ptr
);
2260 case DW_FORM_block4
:
2261 info_ptr
+= 4 + read_4_bytes (abfd
, info_ptr
);
2265 case DW_FORM_ref_udata
:
2266 info_ptr
= skip_leb128 (abfd
, info_ptr
);
2268 case DW_FORM_indirect
:
2269 form
= read_unsigned_leb128 (abfd
, info_ptr
, &bytes_read
);
2270 info_ptr
+= bytes_read
;
2271 /* We need to continue parsing from here, so just go back to
2273 goto skip_attribute
;
2276 error (_("Dwarf Error: Cannot handle %s in DWARF reader [in module %s]"),
2277 dwarf_form_name (form
),
2278 bfd_get_filename (abfd
));
2282 if (abbrev
->has_children
)
2283 return skip_children (info_ptr
, cu
);
2288 /* Locate ORIG_PDI's sibling; INFO_PTR should point to the start of
2289 the next DIE after ORIG_PDI. */
2292 locate_pdi_sibling (struct partial_die_info
*orig_pdi
, gdb_byte
*info_ptr
,
2293 bfd
*abfd
, struct dwarf2_cu
*cu
)
2295 /* Do we know the sibling already? */
2297 if (orig_pdi
->sibling
)
2298 return orig_pdi
->sibling
;
2300 /* Are there any children to deal with? */
2302 if (!orig_pdi
->has_children
)
2305 /* Skip the children the long way. */
2307 return skip_children (info_ptr
, cu
);
2310 /* Expand this partial symbol table into a full symbol table. */
2313 dwarf2_psymtab_to_symtab (struct partial_symtab
*pst
)
2315 /* FIXME: This is barely more than a stub. */
2320 warning (_("bug: psymtab for %s is already read in."), pst
->filename
);
2326 printf_filtered (_("Reading in symbols for %s..."), pst
->filename
);
2327 gdb_flush (gdb_stdout
);
2330 /* Restore our global data. */
2331 dwarf2_per_objfile
= objfile_data (pst
->objfile
,
2332 dwarf2_objfile_data_key
);
2334 psymtab_to_symtab_1 (pst
);
2336 /* Finish up the debug error message. */
2338 printf_filtered (_("done.\n"));
2343 /* Add PER_CU to the queue. */
2346 queue_comp_unit (struct dwarf2_per_cu_data
*per_cu
)
2348 struct dwarf2_queue_item
*item
;
2351 item
= xmalloc (sizeof (*item
));
2352 item
->per_cu
= per_cu
;
2355 if (dwarf2_queue
== NULL
)
2356 dwarf2_queue
= item
;
2358 dwarf2_queue_tail
->next
= item
;
2360 dwarf2_queue_tail
= item
;
2363 /* Process the queue. */
2366 process_queue (struct objfile
*objfile
)
2368 struct dwarf2_queue_item
*item
, *next_item
;
2370 /* Initially, there is just one item on the queue. Load its DIEs,
2371 and the DIEs of any other compilation units it requires,
2374 for (item
= dwarf2_queue
; item
!= NULL
; item
= item
->next
)
2376 /* Read in this compilation unit. This may add new items to
2377 the end of the queue. */
2378 load_full_comp_unit (item
->per_cu
);
2380 item
->per_cu
->cu
->read_in_chain
= dwarf2_per_objfile
->read_in_chain
;
2381 dwarf2_per_objfile
->read_in_chain
= item
->per_cu
;
2383 /* If this compilation unit has already had full symbols created,
2384 reset the TYPE fields in each DIE. */
2385 if (item
->per_cu
->psymtab
->readin
)
2386 reset_die_and_siblings_types (item
->per_cu
->cu
->dies
,
2390 /* Now everything left on the queue needs to be read in. Process
2391 them, one at a time, removing from the queue as we finish. */
2392 for (item
= dwarf2_queue
; item
!= NULL
; dwarf2_queue
= item
= next_item
)
2394 if (!item
->per_cu
->psymtab
->readin
)
2395 process_full_comp_unit (item
->per_cu
);
2397 item
->per_cu
->queued
= 0;
2398 next_item
= item
->next
;
2402 dwarf2_queue_tail
= NULL
;
2405 /* Free all allocated queue entries. This function only releases anything if
2406 an error was thrown; if the queue was processed then it would have been
2407 freed as we went along. */
2410 dwarf2_release_queue (void *dummy
)
2412 struct dwarf2_queue_item
*item
, *last
;
2414 item
= dwarf2_queue
;
2417 /* Anything still marked queued is likely to be in an
2418 inconsistent state, so discard it. */
2419 if (item
->per_cu
->queued
)
2421 if (item
->per_cu
->cu
!= NULL
)
2422 free_one_cached_comp_unit (item
->per_cu
->cu
);
2423 item
->per_cu
->queued
= 0;
2431 dwarf2_queue
= dwarf2_queue_tail
= NULL
;
2434 /* Read in full symbols for PST, and anything it depends on. */
2437 psymtab_to_symtab_1 (struct partial_symtab
*pst
)
2439 struct dwarf2_per_cu_data
*per_cu
;
2440 struct cleanup
*back_to
;
2443 for (i
= 0; i
< pst
->number_of_dependencies
; i
++)
2444 if (!pst
->dependencies
[i
]->readin
)
2446 /* Inform about additional files that need to be read in. */
2449 /* FIXME: i18n: Need to make this a single string. */
2450 fputs_filtered (" ", gdb_stdout
);
2452 fputs_filtered ("and ", gdb_stdout
);
2454 printf_filtered ("%s...", pst
->dependencies
[i
]->filename
);
2455 wrap_here (""); /* Flush output */
2456 gdb_flush (gdb_stdout
);
2458 psymtab_to_symtab_1 (pst
->dependencies
[i
]);
2461 per_cu
= (struct dwarf2_per_cu_data
*) pst
->read_symtab_private
;
2465 /* It's an include file, no symbols to read for it.
2466 Everything is in the parent symtab. */
2471 back_to
= make_cleanup (dwarf2_release_queue
, NULL
);
2473 queue_comp_unit (per_cu
);
2475 process_queue (pst
->objfile
);
2477 /* Age the cache, releasing compilation units that have not
2478 been used recently. */
2479 age_cached_comp_units ();
2481 do_cleanups (back_to
);
2484 /* Load the DIEs associated with PST and PER_CU into memory. */
2486 static struct dwarf2_cu
*
2487 load_full_comp_unit (struct dwarf2_per_cu_data
*per_cu
)
2489 struct partial_symtab
*pst
= per_cu
->psymtab
;
2490 bfd
*abfd
= pst
->objfile
->obfd
;
2491 struct dwarf2_cu
*cu
;
2492 unsigned long offset
;
2494 struct cleanup
*back_to
, *free_cu_cleanup
;
2495 struct attribute
*attr
;
2498 /* Set local variables from the partial symbol table info. */
2499 offset
= per_cu
->offset
;
2501 info_ptr
= dwarf2_per_objfile
->info_buffer
+ offset
;
2503 cu
= xmalloc (sizeof (struct dwarf2_cu
));
2504 memset (cu
, 0, sizeof (struct dwarf2_cu
));
2506 /* If an error occurs while loading, release our storage. */
2507 free_cu_cleanup
= make_cleanup (free_one_comp_unit
, cu
);
2509 cu
->objfile
= pst
->objfile
;
2511 /* read in the comp_unit header */
2512 info_ptr
= read_comp_unit_head (&cu
->header
, info_ptr
, abfd
);
2514 /* Read the abbrevs for this compilation unit */
2515 dwarf2_read_abbrevs (abfd
, cu
);
2516 back_to
= make_cleanup (dwarf2_free_abbrev_table
, cu
);
2518 cu
->header
.offset
= offset
;
2520 cu
->per_cu
= per_cu
;
2523 /* We use this obstack for block values in dwarf_alloc_block. */
2524 obstack_init (&cu
->comp_unit_obstack
);
2526 cu
->dies
= read_comp_unit (info_ptr
, abfd
, cu
);
2528 /* We try not to read any attributes in this function, because not
2529 all objfiles needed for references have been loaded yet, and symbol
2530 table processing isn't initialized. But we have to set the CU language,
2531 or we won't be able to build types correctly. */
2532 attr
= dwarf2_attr (cu
->dies
, DW_AT_language
, cu
);
2534 set_cu_language (DW_UNSND (attr
), cu
);
2536 set_cu_language (language_minimal
, cu
);
2538 do_cleanups (back_to
);
2540 /* We've successfully allocated this compilation unit. Let our caller
2541 clean it up when finished with it. */
2542 discard_cleanups (free_cu_cleanup
);
2547 /* Generate full symbol information for PST and CU, whose DIEs have
2548 already been loaded into memory. */
2551 process_full_comp_unit (struct dwarf2_per_cu_data
*per_cu
)
2553 struct partial_symtab
*pst
= per_cu
->psymtab
;
2554 struct dwarf2_cu
*cu
= per_cu
->cu
;
2555 struct objfile
*objfile
= pst
->objfile
;
2556 bfd
*abfd
= objfile
->obfd
;
2557 CORE_ADDR lowpc
, highpc
;
2558 struct symtab
*symtab
;
2559 struct cleanup
*back_to
;
2560 struct attribute
*attr
;
2563 baseaddr
= ANOFFSET (objfile
->section_offsets
, SECT_OFF_TEXT (objfile
));
2565 /* We're in the global namespace. */
2566 processing_current_prefix
= "";
2569 back_to
= make_cleanup (really_free_pendings
, NULL
);
2571 cu
->list_in_scope
= &file_symbols
;
2573 /* Find the base address of the compilation unit for range lists and
2574 location lists. It will normally be specified by DW_AT_low_pc.
2575 In DWARF-3 draft 4, the base address could be overridden by
2576 DW_AT_entry_pc. It's been removed, but GCC still uses this for
2577 compilation units with discontinuous ranges. */
2579 cu
->header
.base_known
= 0;
2580 cu
->header
.base_address
= 0;
2582 attr
= dwarf2_attr (cu
->dies
, DW_AT_entry_pc
, cu
);
2585 cu
->header
.base_address
= DW_ADDR (attr
);
2586 cu
->header
.base_known
= 1;
2590 attr
= dwarf2_attr (cu
->dies
, DW_AT_low_pc
, cu
);
2593 cu
->header
.base_address
= DW_ADDR (attr
);
2594 cu
->header
.base_known
= 1;
2598 /* Do line number decoding in read_file_scope () */
2599 process_die (cu
->dies
, cu
);
2601 /* Some compilers don't define a DW_AT_high_pc attribute for the
2602 compilation unit. If the DW_AT_high_pc is missing, synthesize
2603 it, by scanning the DIE's below the compilation unit. */
2604 get_scope_pc_bounds (cu
->dies
, &lowpc
, &highpc
, cu
);
2606 symtab
= end_symtab (highpc
+ baseaddr
, objfile
, SECT_OFF_TEXT (objfile
));
2608 /* Set symtab language to language from DW_AT_language.
2609 If the compilation is from a C file generated by language preprocessors,
2610 do not set the language if it was already deduced by start_subfile. */
2612 && !(cu
->language
== language_c
&& symtab
->language
!= language_c
))
2614 symtab
->language
= cu
->language
;
2616 pst
->symtab
= symtab
;
2619 do_cleanups (back_to
);
2622 /* Process a die and its children. */
2625 process_die (struct die_info
*die
, struct dwarf2_cu
*cu
)
2629 case DW_TAG_padding
:
2631 case DW_TAG_compile_unit
:
2632 read_file_scope (die
, cu
);
2634 case DW_TAG_subprogram
:
2635 read_subroutine_type (die
, cu
);
2636 read_func_scope (die
, cu
);
2638 case DW_TAG_inlined_subroutine
:
2639 /* FIXME: These are ignored for now.
2640 They could be used to set breakpoints on all inlined instances
2641 of a function and make GDB `next' properly over inlined functions. */
2643 case DW_TAG_lexical_block
:
2644 case DW_TAG_try_block
:
2645 case DW_TAG_catch_block
:
2646 read_lexical_block_scope (die
, cu
);
2648 case DW_TAG_class_type
:
2649 case DW_TAG_structure_type
:
2650 case DW_TAG_union_type
:
2651 read_structure_type (die
, cu
);
2652 process_structure_scope (die
, cu
);
2654 case DW_TAG_enumeration_type
:
2655 read_enumeration_type (die
, cu
);
2656 process_enumeration_scope (die
, cu
);
2659 /* FIXME drow/2004-03-14: These initialize die->type, but do not create
2660 a symbol or process any children. Therefore it doesn't do anything
2661 that won't be done on-demand by read_type_die. */
2662 case DW_TAG_subroutine_type
:
2663 read_subroutine_type (die
, cu
);
2665 case DW_TAG_array_type
:
2666 read_array_type (die
, cu
);
2668 case DW_TAG_pointer_type
:
2669 read_tag_pointer_type (die
, cu
);
2671 case DW_TAG_ptr_to_member_type
:
2672 read_tag_ptr_to_member_type (die
, cu
);
2674 case DW_TAG_reference_type
:
2675 read_tag_reference_type (die
, cu
);
2677 case DW_TAG_string_type
:
2678 read_tag_string_type (die
, cu
);
2682 case DW_TAG_base_type
:
2683 read_base_type (die
, cu
);
2684 /* Add a typedef symbol for the type definition, if it has a
2686 new_symbol (die
, die
->type
, cu
);
2688 case DW_TAG_subrange_type
:
2689 read_subrange_type (die
, cu
);
2690 /* Add a typedef symbol for the type definition, if it has a
2692 new_symbol (die
, die
->type
, cu
);
2694 case DW_TAG_common_block
:
2695 read_common_block (die
, cu
);
2697 case DW_TAG_common_inclusion
:
2699 case DW_TAG_namespace
:
2700 processing_has_namespace_info
= 1;
2701 read_namespace (die
, cu
);
2703 case DW_TAG_imported_declaration
:
2704 case DW_TAG_imported_module
:
2705 /* FIXME: carlton/2002-10-16: Eventually, we should use the
2706 information contained in these. DW_TAG_imported_declaration
2707 dies shouldn't have children; DW_TAG_imported_module dies
2708 shouldn't in the C++ case, but conceivably could in the
2709 Fortran case, so we'll have to replace this gdb_assert if
2710 Fortran compilers start generating that info. */
2711 processing_has_namespace_info
= 1;
2712 gdb_assert (die
->child
== NULL
);
2715 new_symbol (die
, NULL
, cu
);
2721 initialize_cu_func_list (struct dwarf2_cu
*cu
)
2723 cu
->first_fn
= cu
->last_fn
= cu
->cached_fn
= NULL
;
2727 read_file_scope (struct die_info
*die
, struct dwarf2_cu
*cu
)
2729 struct objfile
*objfile
= cu
->objfile
;
2730 struct comp_unit_head
*cu_header
= &cu
->header
;
2731 struct cleanup
*back_to
= make_cleanup (null_cleanup
, 0);
2732 CORE_ADDR lowpc
= ((CORE_ADDR
) -1);
2733 CORE_ADDR highpc
= ((CORE_ADDR
) 0);
2734 struct attribute
*attr
;
2735 char *name
= "<unknown>";
2736 char *comp_dir
= NULL
;
2737 struct die_info
*child_die
;
2738 bfd
*abfd
= objfile
->obfd
;
2739 struct line_header
*line_header
= 0;
2742 baseaddr
= ANOFFSET (objfile
->section_offsets
, SECT_OFF_TEXT (objfile
));
2744 get_scope_pc_bounds (die
, &lowpc
, &highpc
, cu
);
2746 /* If we didn't find a lowpc, set it to highpc to avoid complaints
2747 from finish_block. */
2748 if (lowpc
== ((CORE_ADDR
) -1))
2753 attr
= dwarf2_attr (die
, DW_AT_name
, cu
);
2756 name
= DW_STRING (attr
);
2758 attr
= dwarf2_attr (die
, DW_AT_comp_dir
, cu
);
2761 comp_dir
= DW_STRING (attr
);
2764 /* Irix 6.2 native cc prepends <machine>.: to the compilation
2765 directory, get rid of it. */
2766 char *cp
= strchr (comp_dir
, ':');
2768 if (cp
&& cp
!= comp_dir
&& cp
[-1] == '.' && cp
[1] == '/')
2773 attr
= dwarf2_attr (die
, DW_AT_language
, cu
);
2776 set_cu_language (DW_UNSND (attr
), cu
);
2779 attr
= dwarf2_attr (die
, DW_AT_producer
, cu
);
2781 cu
->producer
= DW_STRING (attr
);
2783 /* We assume that we're processing GCC output. */
2784 processing_gcc_compilation
= 2;
2786 /* FIXME:Do something here. */
2787 if (dip
->at_producer
!= NULL
)
2789 handle_producer (dip
->at_producer
);
2793 /* The compilation unit may be in a different language or objfile,
2794 zero out all remembered fundamental types. */
2795 memset (cu
->ftypes
, 0, FT_NUM_MEMBERS
* sizeof (struct type
*));
2797 start_symtab (name
, comp_dir
, lowpc
);
2798 record_debugformat ("DWARF 2");
2800 initialize_cu_func_list (cu
);
2802 /* Process all dies in compilation unit. */
2803 if (die
->child
!= NULL
)
2805 child_die
= die
->child
;
2806 while (child_die
&& child_die
->tag
)
2808 process_die (child_die
, cu
);
2809 child_die
= sibling_die (child_die
);
2813 /* Decode line number information if present. */
2814 attr
= dwarf2_attr (die
, DW_AT_stmt_list
, cu
);
2817 unsigned int line_offset
= DW_UNSND (attr
);
2818 line_header
= dwarf_decode_line_header (line_offset
, abfd
, cu
);
2821 make_cleanup ((make_cleanup_ftype
*) free_line_header
,
2822 (void *) line_header
);
2823 dwarf_decode_lines (line_header
, comp_dir
, abfd
, cu
, NULL
);
2827 /* Decode macro information, if present. Dwarf 2 macro information
2828 refers to information in the line number info statement program
2829 header, so we can only read it if we've read the header
2831 attr
= dwarf2_attr (die
, DW_AT_macro_info
, cu
);
2832 if (attr
&& line_header
)
2834 unsigned int macro_offset
= DW_UNSND (attr
);
2835 dwarf_decode_macros (line_header
, macro_offset
,
2836 comp_dir
, abfd
, cu
);
2838 do_cleanups (back_to
);
2842 add_to_cu_func_list (const char *name
, CORE_ADDR lowpc
, CORE_ADDR highpc
,
2843 struct dwarf2_cu
*cu
)
2845 struct function_range
*thisfn
;
2847 thisfn
= (struct function_range
*)
2848 obstack_alloc (&cu
->comp_unit_obstack
, sizeof (struct function_range
));
2849 thisfn
->name
= name
;
2850 thisfn
->lowpc
= lowpc
;
2851 thisfn
->highpc
= highpc
;
2852 thisfn
->seen_line
= 0;
2853 thisfn
->next
= NULL
;
2855 if (cu
->last_fn
== NULL
)
2856 cu
->first_fn
= thisfn
;
2858 cu
->last_fn
->next
= thisfn
;
2860 cu
->last_fn
= thisfn
;
2864 read_func_scope (struct die_info
*die
, struct dwarf2_cu
*cu
)
2866 struct objfile
*objfile
= cu
->objfile
;
2867 struct context_stack
*new;
2870 struct die_info
*child_die
;
2871 struct attribute
*attr
;
2873 const char *previous_prefix
= processing_current_prefix
;
2874 struct cleanup
*back_to
= NULL
;
2877 baseaddr
= ANOFFSET (objfile
->section_offsets
, SECT_OFF_TEXT (objfile
));
2879 name
= dwarf2_linkage_name (die
, cu
);
2881 /* Ignore functions with missing or empty names and functions with
2882 missing or invalid low and high pc attributes. */
2883 if (name
== NULL
|| !dwarf2_get_pc_bounds (die
, &lowpc
, &highpc
, cu
))
2886 if (cu
->language
== language_cplus
2887 || cu
->language
== language_java
)
2889 struct die_info
*spec_die
= die_specification (die
, cu
);
2891 /* NOTE: carlton/2004-01-23: We have to be careful in the
2892 presence of DW_AT_specification. For example, with GCC 3.4,
2897 // Definition of N::foo.
2901 then we'll have a tree of DIEs like this:
2903 1: DW_TAG_compile_unit
2904 2: DW_TAG_namespace // N
2905 3: DW_TAG_subprogram // declaration of N::foo
2906 4: DW_TAG_subprogram // definition of N::foo
2907 DW_AT_specification // refers to die #3
2909 Thus, when processing die #4, we have to pretend that we're
2910 in the context of its DW_AT_specification, namely the contex
2913 if (spec_die
!= NULL
)
2915 char *specification_prefix
= determine_prefix (spec_die
, cu
);
2916 processing_current_prefix
= specification_prefix
;
2917 back_to
= make_cleanup (xfree
, specification_prefix
);
2924 /* Record the function range for dwarf_decode_lines. */
2925 add_to_cu_func_list (name
, lowpc
, highpc
, cu
);
2927 new = push_context (0, lowpc
);
2928 new->name
= new_symbol (die
, die
->type
, cu
);
2930 /* If there is a location expression for DW_AT_frame_base, record
2932 attr
= dwarf2_attr (die
, DW_AT_frame_base
, cu
);
2934 /* FIXME: cagney/2004-01-26: The DW_AT_frame_base's location
2935 expression is being recorded directly in the function's symbol
2936 and not in a separate frame-base object. I guess this hack is
2937 to avoid adding some sort of frame-base adjunct/annex to the
2938 function's symbol :-(. The problem with doing this is that it
2939 results in a function symbol with a location expression that
2940 has nothing to do with the location of the function, ouch! The
2941 relationship should be: a function's symbol has-a frame base; a
2942 frame-base has-a location expression. */
2943 dwarf2_symbol_mark_computed (attr
, new->name
, cu
);
2945 cu
->list_in_scope
= &local_symbols
;
2947 if (die
->child
!= NULL
)
2949 child_die
= die
->child
;
2950 while (child_die
&& child_die
->tag
)
2952 process_die (child_die
, cu
);
2953 child_die
= sibling_die (child_die
);
2957 new = pop_context ();
2958 /* Make a block for the local symbols within. */
2959 finish_block (new->name
, &local_symbols
, new->old_blocks
,
2960 lowpc
, highpc
, objfile
);
2962 /* In C++, we can have functions nested inside functions (e.g., when
2963 a function declares a class that has methods). This means that
2964 when we finish processing a function scope, we may need to go
2965 back to building a containing block's symbol lists. */
2966 local_symbols
= new->locals
;
2967 param_symbols
= new->params
;
2969 /* If we've finished processing a top-level function, subsequent
2970 symbols go in the file symbol list. */
2971 if (outermost_context_p ())
2972 cu
->list_in_scope
= &file_symbols
;
2974 processing_current_prefix
= previous_prefix
;
2975 if (back_to
!= NULL
)
2976 do_cleanups (back_to
);
2979 /* Process all the DIES contained within a lexical block scope. Start
2980 a new scope, process the dies, and then close the scope. */
2983 read_lexical_block_scope (struct die_info
*die
, struct dwarf2_cu
*cu
)
2985 struct objfile
*objfile
= cu
->objfile
;
2986 struct context_stack
*new;
2987 CORE_ADDR lowpc
, highpc
;
2988 struct die_info
*child_die
;
2991 baseaddr
= ANOFFSET (objfile
->section_offsets
, SECT_OFF_TEXT (objfile
));
2993 /* Ignore blocks with missing or invalid low and high pc attributes. */
2994 /* ??? Perhaps consider discontiguous blocks defined by DW_AT_ranges
2995 as multiple lexical blocks? Handling children in a sane way would
2996 be nasty. Might be easier to properly extend generic blocks to
2998 if (!dwarf2_get_pc_bounds (die
, &lowpc
, &highpc
, cu
))
3003 push_context (0, lowpc
);
3004 if (die
->child
!= NULL
)
3006 child_die
= die
->child
;
3007 while (child_die
&& child_die
->tag
)
3009 process_die (child_die
, cu
);
3010 child_die
= sibling_die (child_die
);
3013 new = pop_context ();
3015 if (local_symbols
!= NULL
)
3017 finish_block (0, &local_symbols
, new->old_blocks
, new->start_addr
,
3020 local_symbols
= new->locals
;
3023 /* Get low and high pc attributes from a die. Return 1 if the attributes
3024 are present and valid, otherwise, return 0. Return -1 if the range is
3025 discontinuous, i.e. derived from DW_AT_ranges information. */
3027 dwarf2_get_pc_bounds (struct die_info
*die
, CORE_ADDR
*lowpc
,
3028 CORE_ADDR
*highpc
, struct dwarf2_cu
*cu
)
3030 struct objfile
*objfile
= cu
->objfile
;
3031 struct comp_unit_head
*cu_header
= &cu
->header
;
3032 struct attribute
*attr
;
3033 bfd
*obfd
= objfile
->obfd
;
3038 attr
= dwarf2_attr (die
, DW_AT_high_pc
, cu
);
3041 high
= DW_ADDR (attr
);
3042 attr
= dwarf2_attr (die
, DW_AT_low_pc
, cu
);
3044 low
= DW_ADDR (attr
);
3046 /* Found high w/o low attribute. */
3049 /* Found consecutive range of addresses. */
3054 attr
= dwarf2_attr (die
, DW_AT_ranges
, cu
);
3057 unsigned int addr_size
= cu_header
->addr_size
;
3058 CORE_ADDR mask
= ~(~(CORE_ADDR
)1 << (addr_size
* 8 - 1));
3059 /* Value of the DW_AT_ranges attribute is the offset in the
3060 .debug_ranges section. */
3061 unsigned int offset
= DW_UNSND (attr
);
3062 /* Base address selection entry. */
3070 found_base
= cu_header
->base_known
;
3071 base
= cu_header
->base_address
;
3073 if (offset
>= dwarf2_per_objfile
->ranges_size
)
3075 complaint (&symfile_complaints
,
3076 _("Offset %d out of bounds for DW_AT_ranges attribute"),
3080 buffer
= dwarf2_per_objfile
->ranges_buffer
+ offset
;
3082 /* Read in the largest possible address. */
3083 marker
= read_address (obfd
, buffer
, cu
, &dummy
);
3084 if ((marker
& mask
) == mask
)
3086 /* If we found the largest possible address, then
3087 read the base address. */
3088 base
= read_address (obfd
, buffer
+ addr_size
, cu
, &dummy
);
3089 buffer
+= 2 * addr_size
;
3090 offset
+= 2 * addr_size
;
3098 CORE_ADDR range_beginning
, range_end
;
3100 range_beginning
= read_address (obfd
, buffer
, cu
, &dummy
);
3101 buffer
+= addr_size
;
3102 range_end
= read_address (obfd
, buffer
, cu
, &dummy
);
3103 buffer
+= addr_size
;
3104 offset
+= 2 * addr_size
;
3106 /* An end of list marker is a pair of zero addresses. */
3107 if (range_beginning
== 0 && range_end
== 0)
3108 /* Found the end of list entry. */
3111 /* Each base address selection entry is a pair of 2 values.
3112 The first is the largest possible address, the second is
3113 the base address. Check for a base address here. */
3114 if ((range_beginning
& mask
) == mask
)
3116 /* If we found the largest possible address, then
3117 read the base address. */
3118 base
= read_address (obfd
, buffer
+ addr_size
, cu
, &dummy
);
3125 /* We have no valid base address for the ranges
3127 complaint (&symfile_complaints
,
3128 _("Invalid .debug_ranges data (no base address)"));
3132 range_beginning
+= base
;
3135 /* FIXME: This is recording everything as a low-high
3136 segment of consecutive addresses. We should have a
3137 data structure for discontiguous block ranges
3141 low
= range_beginning
;
3147 if (range_beginning
< low
)
3148 low
= range_beginning
;
3149 if (range_end
> high
)
3155 /* If the first entry is an end-of-list marker, the range
3156 describes an empty scope, i.e. no instructions. */
3166 /* When using the GNU linker, .gnu.linkonce. sections are used to
3167 eliminate duplicate copies of functions and vtables and such.
3168 The linker will arbitrarily choose one and discard the others.
3169 The AT_*_pc values for such functions refer to local labels in
3170 these sections. If the section from that file was discarded, the
3171 labels are not in the output, so the relocs get a value of 0.
3172 If this is a discarded function, mark the pc bounds as invalid,
3173 so that GDB will ignore it. */
3174 if (low
== 0 && (bfd_get_file_flags (obfd
) & HAS_RELOC
) == 0)
3182 /* Get the low and high pc's represented by the scope DIE, and store
3183 them in *LOWPC and *HIGHPC. If the correct values can't be
3184 determined, set *LOWPC to -1 and *HIGHPC to 0. */
3187 get_scope_pc_bounds (struct die_info
*die
,
3188 CORE_ADDR
*lowpc
, CORE_ADDR
*highpc
,
3189 struct dwarf2_cu
*cu
)
3191 CORE_ADDR best_low
= (CORE_ADDR
) -1;
3192 CORE_ADDR best_high
= (CORE_ADDR
) 0;
3193 CORE_ADDR current_low
, current_high
;
3195 if (dwarf2_get_pc_bounds (die
, ¤t_low
, ¤t_high
, cu
))
3197 best_low
= current_low
;
3198 best_high
= current_high
;
3202 struct die_info
*child
= die
->child
;
3204 while (child
&& child
->tag
)
3206 switch (child
->tag
) {
3207 case DW_TAG_subprogram
:
3208 if (dwarf2_get_pc_bounds (child
, ¤t_low
, ¤t_high
, cu
))
3210 best_low
= min (best_low
, current_low
);
3211 best_high
= max (best_high
, current_high
);
3214 case DW_TAG_namespace
:
3215 /* FIXME: carlton/2004-01-16: Should we do this for
3216 DW_TAG_class_type/DW_TAG_structure_type, too? I think
3217 that current GCC's always emit the DIEs corresponding
3218 to definitions of methods of classes as children of a
3219 DW_TAG_compile_unit or DW_TAG_namespace (as opposed to
3220 the DIEs giving the declarations, which could be
3221 anywhere). But I don't see any reason why the
3222 standards says that they have to be there. */
3223 get_scope_pc_bounds (child
, ¤t_low
, ¤t_high
, cu
);
3225 if (current_low
!= ((CORE_ADDR
) -1))
3227 best_low
= min (best_low
, current_low
);
3228 best_high
= max (best_high
, current_high
);
3236 child
= sibling_die (child
);
3241 *highpc
= best_high
;
3244 /* Add an aggregate field to the field list. */
3247 dwarf2_add_field (struct field_info
*fip
, struct die_info
*die
,
3248 struct dwarf2_cu
*cu
)
3250 struct objfile
*objfile
= cu
->objfile
;
3251 struct nextfield
*new_field
;
3252 struct attribute
*attr
;
3254 char *fieldname
= "";
3256 /* Allocate a new field list entry and link it in. */
3257 new_field
= (struct nextfield
*) xmalloc (sizeof (struct nextfield
));
3258 make_cleanup (xfree
, new_field
);
3259 memset (new_field
, 0, sizeof (struct nextfield
));
3260 new_field
->next
= fip
->fields
;
3261 fip
->fields
= new_field
;
3264 /* Handle accessibility and virtuality of field.
3265 The default accessibility for members is public, the default
3266 accessibility for inheritance is private. */
3267 if (die
->tag
!= DW_TAG_inheritance
)
3268 new_field
->accessibility
= DW_ACCESS_public
;
3270 new_field
->accessibility
= DW_ACCESS_private
;
3271 new_field
->virtuality
= DW_VIRTUALITY_none
;
3273 attr
= dwarf2_attr (die
, DW_AT_accessibility
, cu
);
3275 new_field
->accessibility
= DW_UNSND (attr
);
3276 if (new_field
->accessibility
!= DW_ACCESS_public
)
3277 fip
->non_public_fields
= 1;
3278 attr
= dwarf2_attr (die
, DW_AT_virtuality
, cu
);
3280 new_field
->virtuality
= DW_UNSND (attr
);
3282 fp
= &new_field
->field
;
3284 if (die
->tag
== DW_TAG_member
&& ! die_is_declaration (die
, cu
))
3286 /* Data member other than a C++ static data member. */
3288 /* Get type of field. */
3289 fp
->type
= die_type (die
, cu
);
3291 FIELD_STATIC_KIND (*fp
) = 0;
3293 /* Get bit size of field (zero if none). */
3294 attr
= dwarf2_attr (die
, DW_AT_bit_size
, cu
);
3297 FIELD_BITSIZE (*fp
) = DW_UNSND (attr
);
3301 FIELD_BITSIZE (*fp
) = 0;
3304 /* Get bit offset of field. */
3305 attr
= dwarf2_attr (die
, DW_AT_data_member_location
, cu
);
3308 FIELD_BITPOS (*fp
) =
3309 decode_locdesc (DW_BLOCK (attr
), cu
) * bits_per_byte
;
3312 FIELD_BITPOS (*fp
) = 0;
3313 attr
= dwarf2_attr (die
, DW_AT_bit_offset
, cu
);
3316 if (BITS_BIG_ENDIAN
)
3318 /* For big endian bits, the DW_AT_bit_offset gives the
3319 additional bit offset from the MSB of the containing
3320 anonymous object to the MSB of the field. We don't
3321 have to do anything special since we don't need to
3322 know the size of the anonymous object. */
3323 FIELD_BITPOS (*fp
) += DW_UNSND (attr
);
3327 /* For little endian bits, compute the bit offset to the
3328 MSB of the anonymous object, subtract off the number of
3329 bits from the MSB of the field to the MSB of the
3330 object, and then subtract off the number of bits of
3331 the field itself. The result is the bit offset of
3332 the LSB of the field. */
3334 int bit_offset
= DW_UNSND (attr
);
3336 attr
= dwarf2_attr (die
, DW_AT_byte_size
, cu
);
3339 /* The size of the anonymous object containing
3340 the bit field is explicit, so use the
3341 indicated size (in bytes). */
3342 anonymous_size
= DW_UNSND (attr
);
3346 /* The size of the anonymous object containing
3347 the bit field must be inferred from the type
3348 attribute of the data member containing the
3350 anonymous_size
= TYPE_LENGTH (fp
->type
);
3352 FIELD_BITPOS (*fp
) += anonymous_size
* bits_per_byte
3353 - bit_offset
- FIELD_BITSIZE (*fp
);
3357 /* Get name of field. */
3358 attr
= dwarf2_attr (die
, DW_AT_name
, cu
);
3359 if (attr
&& DW_STRING (attr
))
3360 fieldname
= DW_STRING (attr
);
3362 /* The name is already allocated along with this objfile, so we don't
3363 need to duplicate it for the type. */
3364 fp
->name
= fieldname
;
3366 /* Change accessibility for artificial fields (e.g. virtual table
3367 pointer or virtual base class pointer) to private. */
3368 if (dwarf2_attr (die
, DW_AT_artificial
, cu
))
3370 new_field
->accessibility
= DW_ACCESS_private
;
3371 fip
->non_public_fields
= 1;
3374 else if (die
->tag
== DW_TAG_member
|| die
->tag
== DW_TAG_variable
)
3376 /* C++ static member. */
3378 /* NOTE: carlton/2002-11-05: It should be a DW_TAG_member that
3379 is a declaration, but all versions of G++ as of this writing
3380 (so through at least 3.2.1) incorrectly generate
3381 DW_TAG_variable tags. */
3385 /* Get name of field. */
3386 attr
= dwarf2_attr (die
, DW_AT_name
, cu
);
3387 if (attr
&& DW_STRING (attr
))
3388 fieldname
= DW_STRING (attr
);
3392 /* Get physical name. */
3393 physname
= dwarf2_linkage_name (die
, cu
);
3395 /* The name is already allocated along with this objfile, so we don't
3396 need to duplicate it for the type. */
3397 SET_FIELD_PHYSNAME (*fp
, physname
? physname
: "");
3398 FIELD_TYPE (*fp
) = die_type (die
, cu
);
3399 FIELD_NAME (*fp
) = fieldname
;
3401 else if (die
->tag
== DW_TAG_inheritance
)
3403 /* C++ base class field. */
3404 attr
= dwarf2_attr (die
, DW_AT_data_member_location
, cu
);
3406 FIELD_BITPOS (*fp
) = (decode_locdesc (DW_BLOCK (attr
), cu
)
3408 FIELD_BITSIZE (*fp
) = 0;
3409 FIELD_STATIC_KIND (*fp
) = 0;
3410 FIELD_TYPE (*fp
) = die_type (die
, cu
);
3411 FIELD_NAME (*fp
) = type_name_no_tag (fp
->type
);
3412 fip
->nbaseclasses
++;
3416 /* Create the vector of fields, and attach it to the type. */
3419 dwarf2_attach_fields_to_type (struct field_info
*fip
, struct type
*type
,
3420 struct dwarf2_cu
*cu
)
3422 int nfields
= fip
->nfields
;
3424 /* Record the field count, allocate space for the array of fields,
3425 and create blank accessibility bitfields if necessary. */
3426 TYPE_NFIELDS (type
) = nfields
;
3427 TYPE_FIELDS (type
) = (struct field
*)
3428 TYPE_ALLOC (type
, sizeof (struct field
) * nfields
);
3429 memset (TYPE_FIELDS (type
), 0, sizeof (struct field
) * nfields
);
3431 if (fip
->non_public_fields
)
3433 ALLOCATE_CPLUS_STRUCT_TYPE (type
);
3435 TYPE_FIELD_PRIVATE_BITS (type
) =
3436 (B_TYPE
*) TYPE_ALLOC (type
, B_BYTES (nfields
));
3437 B_CLRALL (TYPE_FIELD_PRIVATE_BITS (type
), nfields
);
3439 TYPE_FIELD_PROTECTED_BITS (type
) =
3440 (B_TYPE
*) TYPE_ALLOC (type
, B_BYTES (nfields
));
3441 B_CLRALL (TYPE_FIELD_PROTECTED_BITS (type
), nfields
);
3443 TYPE_FIELD_IGNORE_BITS (type
) =
3444 (B_TYPE
*) TYPE_ALLOC (type
, B_BYTES (nfields
));
3445 B_CLRALL (TYPE_FIELD_IGNORE_BITS (type
), nfields
);
3448 /* If the type has baseclasses, allocate and clear a bit vector for
3449 TYPE_FIELD_VIRTUAL_BITS. */
3450 if (fip
->nbaseclasses
)
3452 int num_bytes
= B_BYTES (fip
->nbaseclasses
);
3453 unsigned char *pointer
;
3455 ALLOCATE_CPLUS_STRUCT_TYPE (type
);
3456 pointer
= TYPE_ALLOC (type
, num_bytes
);
3457 TYPE_FIELD_VIRTUAL_BITS (type
) = pointer
;
3458 B_CLRALL (TYPE_FIELD_VIRTUAL_BITS (type
), fip
->nbaseclasses
);
3459 TYPE_N_BASECLASSES (type
) = fip
->nbaseclasses
;
3462 /* Copy the saved-up fields into the field vector. Start from the head
3463 of the list, adding to the tail of the field array, so that they end
3464 up in the same order in the array in which they were added to the list. */
3465 while (nfields
-- > 0)
3467 TYPE_FIELD (type
, nfields
) = fip
->fields
->field
;
3468 switch (fip
->fields
->accessibility
)
3470 case DW_ACCESS_private
:
3471 SET_TYPE_FIELD_PRIVATE (type
, nfields
);
3474 case DW_ACCESS_protected
:
3475 SET_TYPE_FIELD_PROTECTED (type
, nfields
);
3478 case DW_ACCESS_public
:
3482 /* Unknown accessibility. Complain and treat it as public. */
3484 complaint (&symfile_complaints
, _("unsupported accessibility %d"),
3485 fip
->fields
->accessibility
);
3489 if (nfields
< fip
->nbaseclasses
)
3491 switch (fip
->fields
->virtuality
)
3493 case DW_VIRTUALITY_virtual
:
3494 case DW_VIRTUALITY_pure_virtual
:
3495 SET_TYPE_FIELD_VIRTUAL (type
, nfields
);
3499 fip
->fields
= fip
->fields
->next
;
3503 /* Add a member function to the proper fieldlist. */
3506 dwarf2_add_member_fn (struct field_info
*fip
, struct die_info
*die
,
3507 struct type
*type
, struct dwarf2_cu
*cu
)
3509 struct objfile
*objfile
= cu
->objfile
;
3510 struct attribute
*attr
;
3511 struct fnfieldlist
*flp
;
3513 struct fn_field
*fnp
;
3516 struct nextfnfield
*new_fnfield
;
3518 /* Get name of member function. */
3519 attr
= dwarf2_attr (die
, DW_AT_name
, cu
);
3520 if (attr
&& DW_STRING (attr
))
3521 fieldname
= DW_STRING (attr
);
3525 /* Get the mangled name. */
3526 physname
= dwarf2_linkage_name (die
, cu
);
3528 /* Look up member function name in fieldlist. */
3529 for (i
= 0; i
< fip
->nfnfields
; i
++)
3531 if (strcmp (fip
->fnfieldlists
[i
].name
, fieldname
) == 0)
3535 /* Create new list element if necessary. */
3536 if (i
< fip
->nfnfields
)
3537 flp
= &fip
->fnfieldlists
[i
];
3540 if ((fip
->nfnfields
% DW_FIELD_ALLOC_CHUNK
) == 0)
3542 fip
->fnfieldlists
= (struct fnfieldlist
*)
3543 xrealloc (fip
->fnfieldlists
,
3544 (fip
->nfnfields
+ DW_FIELD_ALLOC_CHUNK
)
3545 * sizeof (struct fnfieldlist
));
3546 if (fip
->nfnfields
== 0)
3547 make_cleanup (free_current_contents
, &fip
->fnfieldlists
);
3549 flp
= &fip
->fnfieldlists
[fip
->nfnfields
];
3550 flp
->name
= fieldname
;
3556 /* Create a new member function field and chain it to the field list
3558 new_fnfield
= (struct nextfnfield
*) xmalloc (sizeof (struct nextfnfield
));
3559 make_cleanup (xfree
, new_fnfield
);
3560 memset (new_fnfield
, 0, sizeof (struct nextfnfield
));
3561 new_fnfield
->next
= flp
->head
;
3562 flp
->head
= new_fnfield
;
3565 /* Fill in the member function field info. */
3566 fnp
= &new_fnfield
->fnfield
;
3567 /* The name is already allocated along with this objfile, so we don't
3568 need to duplicate it for the type. */
3569 fnp
->physname
= physname
? physname
: "";
3570 fnp
->type
= alloc_type (objfile
);
3571 if (die
->type
&& TYPE_CODE (die
->type
) == TYPE_CODE_FUNC
)
3573 int nparams
= TYPE_NFIELDS (die
->type
);
3575 /* TYPE is the domain of this method, and DIE->TYPE is the type
3576 of the method itself (TYPE_CODE_METHOD). */
3577 smash_to_method_type (fnp
->type
, type
,
3578 TYPE_TARGET_TYPE (die
->type
),
3579 TYPE_FIELDS (die
->type
),
3580 TYPE_NFIELDS (die
->type
),
3581 TYPE_VARARGS (die
->type
));
3583 /* Handle static member functions.
3584 Dwarf2 has no clean way to discern C++ static and non-static
3585 member functions. G++ helps GDB by marking the first
3586 parameter for non-static member functions (which is the
3587 this pointer) as artificial. We obtain this information
3588 from read_subroutine_type via TYPE_FIELD_ARTIFICIAL. */
3589 if (nparams
== 0 || TYPE_FIELD_ARTIFICIAL (die
->type
, 0) == 0)
3590 fnp
->voffset
= VOFFSET_STATIC
;
3593 complaint (&symfile_complaints
, _("member function type missing for '%s'"),
3596 /* Get fcontext from DW_AT_containing_type if present. */
3597 if (dwarf2_attr (die
, DW_AT_containing_type
, cu
) != NULL
)
3598 fnp
->fcontext
= die_containing_type (die
, cu
);
3600 /* dwarf2 doesn't have stubbed physical names, so the setting of is_const
3601 and is_volatile is irrelevant, as it is needed by gdb_mangle_name only. */
3603 /* Get accessibility. */
3604 attr
= dwarf2_attr (die
, DW_AT_accessibility
, cu
);
3607 switch (DW_UNSND (attr
))
3609 case DW_ACCESS_private
:
3610 fnp
->is_private
= 1;
3612 case DW_ACCESS_protected
:
3613 fnp
->is_protected
= 1;
3618 /* Check for artificial methods. */
3619 attr
= dwarf2_attr (die
, DW_AT_artificial
, cu
);
3620 if (attr
&& DW_UNSND (attr
) != 0)
3621 fnp
->is_artificial
= 1;
3623 /* Get index in virtual function table if it is a virtual member function. */
3624 attr
= dwarf2_attr (die
, DW_AT_vtable_elem_location
, cu
);
3627 /* Support the .debug_loc offsets */
3628 if (attr_form_is_block (attr
))
3630 fnp
->voffset
= decode_locdesc (DW_BLOCK (attr
), cu
) + 2;
3632 else if (attr
->form
== DW_FORM_data4
|| attr
->form
== DW_FORM_data8
)
3634 dwarf2_complex_location_expr_complaint ();
3638 dwarf2_invalid_attrib_class_complaint ("DW_AT_vtable_elem_location",
3644 /* Create the vector of member function fields, and attach it to the type. */
3647 dwarf2_attach_fn_fields_to_type (struct field_info
*fip
, struct type
*type
,
3648 struct dwarf2_cu
*cu
)
3650 struct fnfieldlist
*flp
;
3651 int total_length
= 0;
3654 ALLOCATE_CPLUS_STRUCT_TYPE (type
);
3655 TYPE_FN_FIELDLISTS (type
) = (struct fn_fieldlist
*)
3656 TYPE_ALLOC (type
, sizeof (struct fn_fieldlist
) * fip
->nfnfields
);
3658 for (i
= 0, flp
= fip
->fnfieldlists
; i
< fip
->nfnfields
; i
++, flp
++)
3660 struct nextfnfield
*nfp
= flp
->head
;
3661 struct fn_fieldlist
*fn_flp
= &TYPE_FN_FIELDLIST (type
, i
);
3664 TYPE_FN_FIELDLIST_NAME (type
, i
) = flp
->name
;
3665 TYPE_FN_FIELDLIST_LENGTH (type
, i
) = flp
->length
;
3666 fn_flp
->fn_fields
= (struct fn_field
*)
3667 TYPE_ALLOC (type
, sizeof (struct fn_field
) * flp
->length
);
3668 for (k
= flp
->length
; (k
--, nfp
); nfp
= nfp
->next
)
3669 fn_flp
->fn_fields
[k
] = nfp
->fnfield
;
3671 total_length
+= flp
->length
;
3674 TYPE_NFN_FIELDS (type
) = fip
->nfnfields
;
3675 TYPE_NFN_FIELDS_TOTAL (type
) = total_length
;
3679 /* Returns non-zero if NAME is the name of a vtable member in CU's
3680 language, zero otherwise. */
3682 is_vtable_name (const char *name
, struct dwarf2_cu
*cu
)
3684 static const char vptr
[] = "_vptr";
3685 static const char vtable
[] = "vtable";
3687 /* Look for the C++ and Java forms of the vtable. */
3688 if ((cu
->language
== language_java
3689 && strncmp (name
, vtable
, sizeof (vtable
) - 1) == 0)
3690 || (strncmp (name
, vptr
, sizeof (vptr
) - 1) == 0
3691 && is_cplus_marker (name
[sizeof (vptr
) - 1])))
3698 /* Called when we find the DIE that starts a structure or union scope
3699 (definition) to process all dies that define the members of the
3702 NOTE: we need to call struct_type regardless of whether or not the
3703 DIE has an at_name attribute, since it might be an anonymous
3704 structure or union. This gets the type entered into our set of
3707 However, if the structure is incomplete (an opaque struct/union)
3708 then suppress creating a symbol table entry for it since gdb only
3709 wants to find the one with the complete definition. Note that if
3710 it is complete, we just call new_symbol, which does it's own
3711 checking about whether the struct/union is anonymous or not (and
3712 suppresses creating a symbol table entry itself). */
3715 read_structure_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
3717 struct objfile
*objfile
= cu
->objfile
;
3719 struct attribute
*attr
;
3720 const char *previous_prefix
= processing_current_prefix
;
3721 struct cleanup
*back_to
= NULL
;
3726 type
= alloc_type (objfile
);
3728 INIT_CPLUS_SPECIFIC (type
);
3729 attr
= dwarf2_attr (die
, DW_AT_name
, cu
);
3730 if (attr
&& DW_STRING (attr
))
3732 if (cu
->language
== language_cplus
3733 || cu
->language
== language_java
)
3735 char *new_prefix
= determine_class_name (die
, cu
);
3736 TYPE_TAG_NAME (type
) = obsavestring (new_prefix
,
3737 strlen (new_prefix
),
3738 &objfile
->objfile_obstack
);
3739 back_to
= make_cleanup (xfree
, new_prefix
);
3740 processing_current_prefix
= new_prefix
;
3744 /* The name is already allocated along with this objfile, so
3745 we don't need to duplicate it for the type. */
3746 TYPE_TAG_NAME (type
) = DW_STRING (attr
);
3750 if (die
->tag
== DW_TAG_structure_type
)
3752 TYPE_CODE (type
) = TYPE_CODE_STRUCT
;
3754 else if (die
->tag
== DW_TAG_union_type
)
3756 TYPE_CODE (type
) = TYPE_CODE_UNION
;
3760 /* FIXME: TYPE_CODE_CLASS is currently defined to TYPE_CODE_STRUCT
3762 TYPE_CODE (type
) = TYPE_CODE_CLASS
;
3765 attr
= dwarf2_attr (die
, DW_AT_byte_size
, cu
);
3768 TYPE_LENGTH (type
) = DW_UNSND (attr
);
3772 TYPE_LENGTH (type
) = 0;
3775 if (die_is_declaration (die
, cu
))
3776 TYPE_FLAGS (type
) |= TYPE_FLAG_STUB
;
3778 /* We need to add the type field to the die immediately so we don't
3779 infinitely recurse when dealing with pointers to the structure
3780 type within the structure itself. */
3781 set_die_type (die
, type
, cu
);
3783 if (die
->child
!= NULL
&& ! die_is_declaration (die
, cu
))
3785 struct field_info fi
;
3786 struct die_info
*child_die
;
3787 struct cleanup
*back_to
= make_cleanup (null_cleanup
, NULL
);
3789 memset (&fi
, 0, sizeof (struct field_info
));
3791 child_die
= die
->child
;
3793 while (child_die
&& child_die
->tag
)
3795 if (child_die
->tag
== DW_TAG_member
3796 || child_die
->tag
== DW_TAG_variable
)
3798 /* NOTE: carlton/2002-11-05: A C++ static data member
3799 should be a DW_TAG_member that is a declaration, but
3800 all versions of G++ as of this writing (so through at
3801 least 3.2.1) incorrectly generate DW_TAG_variable
3802 tags for them instead. */
3803 dwarf2_add_field (&fi
, child_die
, cu
);
3805 else if (child_die
->tag
== DW_TAG_subprogram
)
3807 /* C++ member function. */
3808 read_type_die (child_die
, cu
);
3809 dwarf2_add_member_fn (&fi
, child_die
, type
, cu
);
3811 else if (child_die
->tag
== DW_TAG_inheritance
)
3813 /* C++ base class field. */
3814 dwarf2_add_field (&fi
, child_die
, cu
);
3816 child_die
= sibling_die (child_die
);
3819 /* Attach fields and member functions to the type. */
3821 dwarf2_attach_fields_to_type (&fi
, type
, cu
);
3824 dwarf2_attach_fn_fields_to_type (&fi
, type
, cu
);
3826 /* Get the type which refers to the base class (possibly this
3827 class itself) which contains the vtable pointer for the current
3828 class from the DW_AT_containing_type attribute. */
3830 if (dwarf2_attr (die
, DW_AT_containing_type
, cu
) != NULL
)
3832 struct type
*t
= die_containing_type (die
, cu
);
3834 TYPE_VPTR_BASETYPE (type
) = t
;
3839 /* Our own class provides vtbl ptr. */
3840 for (i
= TYPE_NFIELDS (t
) - 1;
3841 i
>= TYPE_N_BASECLASSES (t
);
3844 char *fieldname
= TYPE_FIELD_NAME (t
, i
);
3846 if (is_vtable_name (fieldname
, cu
))
3848 TYPE_VPTR_FIELDNO (type
) = i
;
3853 /* Complain if virtual function table field not found. */
3854 if (i
< TYPE_N_BASECLASSES (t
))
3855 complaint (&symfile_complaints
,
3856 _("virtual function table pointer not found when defining class '%s'"),
3857 TYPE_TAG_NAME (type
) ? TYPE_TAG_NAME (type
) :
3862 TYPE_VPTR_FIELDNO (type
) = TYPE_VPTR_FIELDNO (t
);
3865 else if (cu
->producer
3866 && strncmp (cu
->producer
,
3867 "IBM(R) XL C/C++ Advanced Edition", 32) == 0)
3869 /* The IBM XLC compiler does not provide direct indication
3870 of the containing type, but the vtable pointer is
3871 always named __vfp. */
3875 for (i
= TYPE_NFIELDS (type
) - 1;
3876 i
>= TYPE_N_BASECLASSES (type
);
3879 if (strcmp (TYPE_FIELD_NAME (type
, i
), "__vfp") == 0)
3881 TYPE_VPTR_FIELDNO (type
) = i
;
3882 TYPE_VPTR_BASETYPE (type
) = type
;
3889 do_cleanups (back_to
);
3892 processing_current_prefix
= previous_prefix
;
3893 if (back_to
!= NULL
)
3894 do_cleanups (back_to
);
3898 process_structure_scope (struct die_info
*die
, struct dwarf2_cu
*cu
)
3900 struct objfile
*objfile
= cu
->objfile
;
3901 const char *previous_prefix
= processing_current_prefix
;
3902 struct die_info
*child_die
= die
->child
;
3904 if (TYPE_TAG_NAME (die
->type
) != NULL
)
3905 processing_current_prefix
= TYPE_TAG_NAME (die
->type
);
3907 /* NOTE: carlton/2004-03-16: GCC 3.4 (or at least one of its
3908 snapshots) has been known to create a die giving a declaration
3909 for a class that has, as a child, a die giving a definition for a
3910 nested class. So we have to process our children even if the
3911 current die is a declaration. Normally, of course, a declaration
3912 won't have any children at all. */
3914 while (child_die
!= NULL
&& child_die
->tag
)
3916 if (child_die
->tag
== DW_TAG_member
3917 || child_die
->tag
== DW_TAG_variable
3918 || child_die
->tag
== DW_TAG_inheritance
)
3923 process_die (child_die
, cu
);
3925 child_die
= sibling_die (child_die
);
3928 if (die
->child
!= NULL
&& ! die_is_declaration (die
, cu
))
3929 new_symbol (die
, die
->type
, cu
);
3931 processing_current_prefix
= previous_prefix
;
3934 /* Given a DW_AT_enumeration_type die, set its type. We do not
3935 complete the type's fields yet, or create any symbols. */
3938 read_enumeration_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
3940 struct objfile
*objfile
= cu
->objfile
;
3942 struct attribute
*attr
;
3947 type
= alloc_type (objfile
);
3949 TYPE_CODE (type
) = TYPE_CODE_ENUM
;
3950 attr
= dwarf2_attr (die
, DW_AT_name
, cu
);
3951 if (attr
&& DW_STRING (attr
))
3953 char *name
= DW_STRING (attr
);
3955 if (processing_has_namespace_info
)
3957 TYPE_TAG_NAME (type
) = typename_concat (&objfile
->objfile_obstack
,
3958 processing_current_prefix
,
3963 /* The name is already allocated along with this objfile, so
3964 we don't need to duplicate it for the type. */
3965 TYPE_TAG_NAME (type
) = name
;
3969 attr
= dwarf2_attr (die
, DW_AT_byte_size
, cu
);
3972 TYPE_LENGTH (type
) = DW_UNSND (attr
);
3976 TYPE_LENGTH (type
) = 0;
3979 set_die_type (die
, type
, cu
);
3982 /* Determine the name of the type represented by DIE, which should be
3983 a named C++ or Java compound type. Return the name in question; the caller
3984 is responsible for xfree()'ing it. */
3987 determine_class_name (struct die_info
*die
, struct dwarf2_cu
*cu
)
3989 struct cleanup
*back_to
= NULL
;
3990 struct die_info
*spec_die
= die_specification (die
, cu
);
3991 char *new_prefix
= NULL
;
3993 /* If this is the definition of a class that is declared by another
3994 die, then processing_current_prefix may not be accurate; see
3995 read_func_scope for a similar example. */
3996 if (spec_die
!= NULL
)
3998 char *specification_prefix
= determine_prefix (spec_die
, cu
);
3999 processing_current_prefix
= specification_prefix
;
4000 back_to
= make_cleanup (xfree
, specification_prefix
);
4003 /* If we don't have namespace debug info, guess the name by trying
4004 to demangle the names of members, just like we did in
4005 guess_structure_name. */
4006 if (!processing_has_namespace_info
)
4008 struct die_info
*child
;
4010 for (child
= die
->child
;
4011 child
!= NULL
&& child
->tag
!= 0;
4012 child
= sibling_die (child
))
4014 if (child
->tag
== DW_TAG_subprogram
)
4017 = language_class_name_from_physname (cu
->language_defn
,
4021 if (new_prefix
!= NULL
)
4027 if (new_prefix
== NULL
)
4029 const char *name
= dwarf2_name (die
, cu
);
4030 new_prefix
= typename_concat (NULL
, processing_current_prefix
,
4031 name
? name
: "<<anonymous>>",
4035 if (back_to
!= NULL
)
4036 do_cleanups (back_to
);
4041 /* Given a pointer to a die which begins an enumeration, process all
4042 the dies that define the members of the enumeration, and create the
4043 symbol for the enumeration type.
4045 NOTE: We reverse the order of the element list. */
4048 process_enumeration_scope (struct die_info
*die
, struct dwarf2_cu
*cu
)
4050 struct objfile
*objfile
= cu
->objfile
;
4051 struct die_info
*child_die
;
4052 struct field
*fields
;
4053 struct attribute
*attr
;
4056 int unsigned_enum
= 1;
4060 if (die
->child
!= NULL
)
4062 child_die
= die
->child
;
4063 while (child_die
&& child_die
->tag
)
4065 if (child_die
->tag
!= DW_TAG_enumerator
)
4067 process_die (child_die
, cu
);
4071 attr
= dwarf2_attr (child_die
, DW_AT_name
, cu
);
4074 sym
= new_symbol (child_die
, die
->type
, cu
);
4075 if (SYMBOL_VALUE (sym
) < 0)
4078 if ((num_fields
% DW_FIELD_ALLOC_CHUNK
) == 0)
4080 fields
= (struct field
*)
4082 (num_fields
+ DW_FIELD_ALLOC_CHUNK
)
4083 * sizeof (struct field
));
4086 FIELD_NAME (fields
[num_fields
]) = DEPRECATED_SYMBOL_NAME (sym
);
4087 FIELD_TYPE (fields
[num_fields
]) = NULL
;
4088 FIELD_BITPOS (fields
[num_fields
]) = SYMBOL_VALUE (sym
);
4089 FIELD_BITSIZE (fields
[num_fields
]) = 0;
4090 FIELD_STATIC_KIND (fields
[num_fields
]) = 0;
4096 child_die
= sibling_die (child_die
);
4101 TYPE_NFIELDS (die
->type
) = num_fields
;
4102 TYPE_FIELDS (die
->type
) = (struct field
*)
4103 TYPE_ALLOC (die
->type
, sizeof (struct field
) * num_fields
);
4104 memcpy (TYPE_FIELDS (die
->type
), fields
,
4105 sizeof (struct field
) * num_fields
);
4109 TYPE_FLAGS (die
->type
) |= TYPE_FLAG_UNSIGNED
;
4112 new_symbol (die
, die
->type
, cu
);
4115 /* Extract all information from a DW_TAG_array_type DIE and put it in
4116 the DIE's type field. For now, this only handles one dimensional
4120 read_array_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
4122 struct objfile
*objfile
= cu
->objfile
;
4123 struct die_info
*child_die
;
4124 struct type
*type
= NULL
;
4125 struct type
*element_type
, *range_type
, *index_type
;
4126 struct type
**range_types
= NULL
;
4127 struct attribute
*attr
;
4129 struct cleanup
*back_to
;
4131 /* Return if we've already decoded this type. */
4137 element_type
= die_type (die
, cu
);
4139 /* Irix 6.2 native cc creates array types without children for
4140 arrays with unspecified length. */
4141 if (die
->child
== NULL
)
4143 index_type
= dwarf2_fundamental_type (objfile
, FT_INTEGER
, cu
);
4144 range_type
= create_range_type (NULL
, index_type
, 0, -1);
4145 set_die_type (die
, create_array_type (NULL
, element_type
, range_type
),
4150 back_to
= make_cleanup (null_cleanup
, NULL
);
4151 child_die
= die
->child
;
4152 while (child_die
&& child_die
->tag
)
4154 if (child_die
->tag
== DW_TAG_subrange_type
)
4156 read_subrange_type (child_die
, cu
);
4158 if (child_die
->type
!= NULL
)
4160 /* The range type was succesfully read. Save it for
4161 the array type creation. */
4162 if ((ndim
% DW_FIELD_ALLOC_CHUNK
) == 0)
4164 range_types
= (struct type
**)
4165 xrealloc (range_types
, (ndim
+ DW_FIELD_ALLOC_CHUNK
)
4166 * sizeof (struct type
*));
4168 make_cleanup (free_current_contents
, &range_types
);
4170 range_types
[ndim
++] = child_die
->type
;
4173 child_die
= sibling_die (child_die
);
4176 /* Dwarf2 dimensions are output from left to right, create the
4177 necessary array types in backwards order. */
4179 type
= element_type
;
4181 if (read_array_order (die
, cu
) == DW_ORD_col_major
)
4185 type
= create_array_type (NULL
, type
, range_types
[i
++]);
4190 type
= create_array_type (NULL
, type
, range_types
[ndim
]);
4193 /* Understand Dwarf2 support for vector types (like they occur on
4194 the PowerPC w/ AltiVec). Gcc just adds another attribute to the
4195 array type. This is not part of the Dwarf2/3 standard yet, but a
4196 custom vendor extension. The main difference between a regular
4197 array and the vector variant is that vectors are passed by value
4199 attr
= dwarf2_attr (die
, DW_AT_GNU_vector
, cu
);
4201 TYPE_FLAGS (type
) |= TYPE_FLAG_VECTOR
;
4203 do_cleanups (back_to
);
4205 /* Install the type in the die. */
4206 set_die_type (die
, type
, cu
);
4209 static enum dwarf_array_dim_ordering
4210 read_array_order (struct die_info
*die
, struct dwarf2_cu
*cu
)
4212 struct attribute
*attr
;
4214 attr
= dwarf2_attr (die
, DW_AT_ordering
, cu
);
4216 if (attr
) return DW_SND (attr
);
4219 GNU F77 is a special case, as at 08/2004 array type info is the
4220 opposite order to the dwarf2 specification, but data is still
4221 laid out as per normal fortran.
4223 FIXME: dsl/2004-8-20: If G77 is ever fixed, this will also need
4227 if (cu
->language
== language_fortran
&&
4228 cu
->producer
&& strstr (cu
->producer
, "GNU F77"))
4230 return DW_ORD_row_major
;
4233 switch (cu
->language_defn
->la_array_ordering
)
4235 case array_column_major
:
4236 return DW_ORD_col_major
;
4237 case array_row_major
:
4239 return DW_ORD_row_major
;
4244 /* First cut: install each common block member as a global variable. */
4247 read_common_block (struct die_info
*die
, struct dwarf2_cu
*cu
)
4249 struct die_info
*child_die
;
4250 struct attribute
*attr
;
4252 CORE_ADDR base
= (CORE_ADDR
) 0;
4254 attr
= dwarf2_attr (die
, DW_AT_location
, cu
);
4257 /* Support the .debug_loc offsets */
4258 if (attr_form_is_block (attr
))
4260 base
= decode_locdesc (DW_BLOCK (attr
), cu
);
4262 else if (attr
->form
== DW_FORM_data4
|| attr
->form
== DW_FORM_data8
)
4264 dwarf2_complex_location_expr_complaint ();
4268 dwarf2_invalid_attrib_class_complaint ("DW_AT_location",
4269 "common block member");
4272 if (die
->child
!= NULL
)
4274 child_die
= die
->child
;
4275 while (child_die
&& child_die
->tag
)
4277 sym
= new_symbol (child_die
, NULL
, cu
);
4278 attr
= dwarf2_attr (child_die
, DW_AT_data_member_location
, cu
);
4281 SYMBOL_VALUE_ADDRESS (sym
) =
4282 base
+ decode_locdesc (DW_BLOCK (attr
), cu
);
4283 add_symbol_to_list (sym
, &global_symbols
);
4285 child_die
= sibling_die (child_die
);
4290 /* Read a C++ namespace. */
4293 read_namespace (struct die_info
*die
, struct dwarf2_cu
*cu
)
4295 struct objfile
*objfile
= cu
->objfile
;
4296 const char *previous_prefix
= processing_current_prefix
;
4299 struct die_info
*current_die
;
4300 struct cleanup
*back_to
= make_cleanup (null_cleanup
, 0);
4302 name
= namespace_name (die
, &is_anonymous
, cu
);
4304 /* Now build the name of the current namespace. */
4306 if (previous_prefix
[0] == '\0')
4308 processing_current_prefix
= name
;
4312 char *temp_name
= typename_concat (NULL
, previous_prefix
, name
, cu
);
4313 make_cleanup (xfree
, temp_name
);
4314 processing_current_prefix
= temp_name
;
4317 /* Add a symbol associated to this if we haven't seen the namespace
4318 before. Also, add a using directive if it's an anonymous
4321 if (dwarf2_extension (die
, cu
) == NULL
)
4325 /* FIXME: carlton/2003-06-27: Once GDB is more const-correct,
4326 this cast will hopefully become unnecessary. */
4327 type
= init_type (TYPE_CODE_NAMESPACE
, 0, 0,
4328 (char *) processing_current_prefix
,
4330 TYPE_TAG_NAME (type
) = TYPE_NAME (type
);
4332 new_symbol (die
, type
, cu
);
4333 set_die_type (die
, type
, cu
);
4336 cp_add_using_directive (processing_current_prefix
,
4337 strlen (previous_prefix
),
4338 strlen (processing_current_prefix
));
4341 if (die
->child
!= NULL
)
4343 struct die_info
*child_die
= die
->child
;
4345 while (child_die
&& child_die
->tag
)
4347 process_die (child_die
, cu
);
4348 child_die
= sibling_die (child_die
);
4352 processing_current_prefix
= previous_prefix
;
4353 do_cleanups (back_to
);
4356 /* Return the name of the namespace represented by DIE. Set
4357 *IS_ANONYMOUS to tell whether or not the namespace is an anonymous
4361 namespace_name (struct die_info
*die
, int *is_anonymous
, struct dwarf2_cu
*cu
)
4363 struct die_info
*current_die
;
4364 const char *name
= NULL
;
4366 /* Loop through the extensions until we find a name. */
4368 for (current_die
= die
;
4369 current_die
!= NULL
;
4370 current_die
= dwarf2_extension (die
, cu
))
4372 name
= dwarf2_name (current_die
, cu
);
4377 /* Is it an anonymous namespace? */
4379 *is_anonymous
= (name
== NULL
);
4381 name
= "(anonymous namespace)";
4386 /* Extract all information from a DW_TAG_pointer_type DIE and add to
4387 the user defined type vector. */
4390 read_tag_pointer_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
4392 struct comp_unit_head
*cu_header
= &cu
->header
;
4394 struct attribute
*attr_byte_size
;
4395 struct attribute
*attr_address_class
;
4396 int byte_size
, addr_class
;
4403 type
= lookup_pointer_type (die_type (die
, cu
));
4405 attr_byte_size
= dwarf2_attr (die
, DW_AT_byte_size
, cu
);
4407 byte_size
= DW_UNSND (attr_byte_size
);
4409 byte_size
= cu_header
->addr_size
;
4411 attr_address_class
= dwarf2_attr (die
, DW_AT_address_class
, cu
);
4412 if (attr_address_class
)
4413 addr_class
= DW_UNSND (attr_address_class
);
4415 addr_class
= DW_ADDR_none
;
4417 /* If the pointer size or address class is different than the
4418 default, create a type variant marked as such and set the
4419 length accordingly. */
4420 if (TYPE_LENGTH (type
) != byte_size
|| addr_class
!= DW_ADDR_none
)
4422 if (ADDRESS_CLASS_TYPE_FLAGS_P ())
4426 type_flags
= ADDRESS_CLASS_TYPE_FLAGS (byte_size
, addr_class
);
4427 gdb_assert ((type_flags
& ~TYPE_FLAG_ADDRESS_CLASS_ALL
) == 0);
4428 type
= make_type_with_address_space (type
, type_flags
);
4430 else if (TYPE_LENGTH (type
) != byte_size
)
4432 complaint (&symfile_complaints
, _("invalid pointer size %d"), byte_size
);
4435 /* Should we also complain about unhandled address classes? */
4439 TYPE_LENGTH (type
) = byte_size
;
4440 set_die_type (die
, type
, cu
);
4443 /* Extract all information from a DW_TAG_ptr_to_member_type DIE and add to
4444 the user defined type vector. */
4447 read_tag_ptr_to_member_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
4449 struct objfile
*objfile
= cu
->objfile
;
4451 struct type
*to_type
;
4452 struct type
*domain
;
4459 type
= alloc_type (objfile
);
4460 to_type
= die_type (die
, cu
);
4461 domain
= die_containing_type (die
, cu
);
4462 smash_to_member_type (type
, domain
, to_type
);
4464 set_die_type (die
, type
, cu
);
4467 /* Extract all information from a DW_TAG_reference_type DIE and add to
4468 the user defined type vector. */
4471 read_tag_reference_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
4473 struct comp_unit_head
*cu_header
= &cu
->header
;
4475 struct attribute
*attr
;
4482 type
= lookup_reference_type (die_type (die
, cu
));
4483 attr
= dwarf2_attr (die
, DW_AT_byte_size
, cu
);
4486 TYPE_LENGTH (type
) = DW_UNSND (attr
);
4490 TYPE_LENGTH (type
) = cu_header
->addr_size
;
4492 set_die_type (die
, type
, cu
);
4496 read_tag_const_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
4498 struct type
*base_type
;
4505 base_type
= die_type (die
, cu
);
4506 set_die_type (die
, make_cv_type (1, TYPE_VOLATILE (base_type
), base_type
, 0),
4511 read_tag_volatile_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
4513 struct type
*base_type
;
4520 base_type
= die_type (die
, cu
);
4521 set_die_type (die
, make_cv_type (TYPE_CONST (base_type
), 1, base_type
, 0),
4525 /* Extract all information from a DW_TAG_string_type DIE and add to
4526 the user defined type vector. It isn't really a user defined type,
4527 but it behaves like one, with other DIE's using an AT_user_def_type
4528 attribute to reference it. */
4531 read_tag_string_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
4533 struct objfile
*objfile
= cu
->objfile
;
4534 struct type
*type
, *range_type
, *index_type
, *char_type
;
4535 struct attribute
*attr
;
4536 unsigned int length
;
4543 attr
= dwarf2_attr (die
, DW_AT_string_length
, cu
);
4546 length
= DW_UNSND (attr
);
4550 /* check for the DW_AT_byte_size attribute */
4551 attr
= dwarf2_attr (die
, DW_AT_byte_size
, cu
);
4554 length
= DW_UNSND (attr
);
4561 index_type
= dwarf2_fundamental_type (objfile
, FT_INTEGER
, cu
);
4562 range_type
= create_range_type (NULL
, index_type
, 1, length
);
4563 if (cu
->language
== language_fortran
)
4565 /* Need to create a unique string type for bounds
4567 type
= create_string_type (0, range_type
);
4571 char_type
= dwarf2_fundamental_type (objfile
, FT_CHAR
, cu
);
4572 type
= create_string_type (char_type
, range_type
);
4574 set_die_type (die
, type
, cu
);
4577 /* Handle DIES due to C code like:
4581 int (*funcp)(int a, long l);
4585 ('funcp' generates a DW_TAG_subroutine_type DIE)
4589 read_subroutine_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
4591 struct type
*type
; /* Type that this function returns */
4592 struct type
*ftype
; /* Function that returns above type */
4593 struct attribute
*attr
;
4595 /* Decode the type that this subroutine returns */
4600 type
= die_type (die
, cu
);
4601 ftype
= make_function_type (type
, (struct type
**) 0);
4603 /* All functions in C++ and Java have prototypes. */
4604 attr
= dwarf2_attr (die
, DW_AT_prototyped
, cu
);
4605 if ((attr
&& (DW_UNSND (attr
) != 0))
4606 || cu
->language
== language_cplus
4607 || cu
->language
== language_java
)
4608 TYPE_FLAGS (ftype
) |= TYPE_FLAG_PROTOTYPED
;
4610 if (die
->child
!= NULL
)
4612 struct die_info
*child_die
;
4616 /* Count the number of parameters.
4617 FIXME: GDB currently ignores vararg functions, but knows about
4618 vararg member functions. */
4619 child_die
= die
->child
;
4620 while (child_die
&& child_die
->tag
)
4622 if (child_die
->tag
== DW_TAG_formal_parameter
)
4624 else if (child_die
->tag
== DW_TAG_unspecified_parameters
)
4625 TYPE_FLAGS (ftype
) |= TYPE_FLAG_VARARGS
;
4626 child_die
= sibling_die (child_die
);
4629 /* Allocate storage for parameters and fill them in. */
4630 TYPE_NFIELDS (ftype
) = nparams
;
4631 TYPE_FIELDS (ftype
) = (struct field
*)
4632 TYPE_ZALLOC (ftype
, nparams
* sizeof (struct field
));
4634 child_die
= die
->child
;
4635 while (child_die
&& child_die
->tag
)
4637 if (child_die
->tag
== DW_TAG_formal_parameter
)
4639 /* Dwarf2 has no clean way to discern C++ static and non-static
4640 member functions. G++ helps GDB by marking the first
4641 parameter for non-static member functions (which is the
4642 this pointer) as artificial. We pass this information
4643 to dwarf2_add_member_fn via TYPE_FIELD_ARTIFICIAL. */
4644 attr
= dwarf2_attr (child_die
, DW_AT_artificial
, cu
);
4646 TYPE_FIELD_ARTIFICIAL (ftype
, iparams
) = DW_UNSND (attr
);
4648 TYPE_FIELD_ARTIFICIAL (ftype
, iparams
) = 0;
4649 TYPE_FIELD_TYPE (ftype
, iparams
) = die_type (child_die
, cu
);
4652 child_die
= sibling_die (child_die
);
4656 set_die_type (die
, ftype
, cu
);
4660 read_typedef (struct die_info
*die
, struct dwarf2_cu
*cu
)
4662 struct objfile
*objfile
= cu
->objfile
;
4663 struct attribute
*attr
;
4668 attr
= dwarf2_attr (die
, DW_AT_name
, cu
);
4669 if (attr
&& DW_STRING (attr
))
4671 name
= DW_STRING (attr
);
4673 set_die_type (die
, init_type (TYPE_CODE_TYPEDEF
, 0,
4674 TYPE_FLAG_TARGET_STUB
, name
, objfile
),
4676 TYPE_TARGET_TYPE (die
->type
) = die_type (die
, cu
);
4680 /* Find a representation of a given base type and install
4681 it in the TYPE field of the die. */
4684 read_base_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
4686 struct objfile
*objfile
= cu
->objfile
;
4688 struct attribute
*attr
;
4689 int encoding
= 0, size
= 0;
4691 /* If we've already decoded this die, this is a no-op. */
4697 attr
= dwarf2_attr (die
, DW_AT_encoding
, cu
);
4700 encoding
= DW_UNSND (attr
);
4702 attr
= dwarf2_attr (die
, DW_AT_byte_size
, cu
);
4705 size
= DW_UNSND (attr
);
4707 attr
= dwarf2_attr (die
, DW_AT_name
, cu
);
4708 if (attr
&& DW_STRING (attr
))
4710 enum type_code code
= TYPE_CODE_INT
;
4715 case DW_ATE_address
:
4716 /* Turn DW_ATE_address into a void * pointer. */
4717 code
= TYPE_CODE_PTR
;
4718 type_flags
|= TYPE_FLAG_UNSIGNED
;
4720 case DW_ATE_boolean
:
4721 code
= TYPE_CODE_BOOL
;
4722 type_flags
|= TYPE_FLAG_UNSIGNED
;
4724 case DW_ATE_complex_float
:
4725 code
= TYPE_CODE_COMPLEX
;
4728 code
= TYPE_CODE_FLT
;
4731 case DW_ATE_signed_char
:
4733 case DW_ATE_unsigned
:
4734 case DW_ATE_unsigned_char
:
4735 type_flags
|= TYPE_FLAG_UNSIGNED
;
4738 complaint (&symfile_complaints
, _("unsupported DW_AT_encoding: '%s'"),
4739 dwarf_type_encoding_name (encoding
));
4742 type
= init_type (code
, size
, type_flags
, DW_STRING (attr
), objfile
);
4743 if (encoding
== DW_ATE_address
)
4744 TYPE_TARGET_TYPE (type
) = dwarf2_fundamental_type (objfile
, FT_VOID
,
4746 else if (encoding
== DW_ATE_complex_float
)
4749 TYPE_TARGET_TYPE (type
)
4750 = dwarf2_fundamental_type (objfile
, FT_EXT_PREC_FLOAT
, cu
);
4751 else if (size
== 16)
4752 TYPE_TARGET_TYPE (type
)
4753 = dwarf2_fundamental_type (objfile
, FT_DBL_PREC_FLOAT
, cu
);
4755 TYPE_TARGET_TYPE (type
)
4756 = dwarf2_fundamental_type (objfile
, FT_FLOAT
, cu
);
4761 type
= dwarf_base_type (encoding
, size
, cu
);
4763 set_die_type (die
, type
, cu
);
4766 /* Read the given DW_AT_subrange DIE. */
4769 read_subrange_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
4771 struct type
*base_type
;
4772 struct type
*range_type
;
4773 struct attribute
*attr
;
4777 /* If we have already decoded this die, then nothing more to do. */
4781 base_type
= die_type (die
, cu
);
4782 if (base_type
== NULL
)
4784 complaint (&symfile_complaints
,
4785 _("DW_AT_type missing from DW_TAG_subrange_type"));
4789 if (TYPE_CODE (base_type
) == TYPE_CODE_VOID
)
4790 base_type
= alloc_type (NULL
);
4792 if (cu
->language
== language_fortran
)
4794 /* FORTRAN implies a lower bound of 1, if not given. */
4798 /* FIXME: For variable sized arrays either of these could be
4799 a variable rather than a constant value. We'll allow it,
4800 but we don't know how to handle it. */
4801 attr
= dwarf2_attr (die
, DW_AT_lower_bound
, cu
);
4803 low
= dwarf2_get_attr_constant_value (attr
, 0);
4805 attr
= dwarf2_attr (die
, DW_AT_upper_bound
, cu
);
4808 if (attr
->form
== DW_FORM_block1
)
4810 /* GCC encodes arrays with unspecified or dynamic length
4811 with a DW_FORM_block1 attribute.
4812 FIXME: GDB does not yet know how to handle dynamic
4813 arrays properly, treat them as arrays with unspecified
4816 FIXME: jimb/2003-09-22: GDB does not really know
4817 how to handle arrays of unspecified length
4818 either; we just represent them as zero-length
4819 arrays. Choose an appropriate upper bound given
4820 the lower bound we've computed above. */
4824 high
= dwarf2_get_attr_constant_value (attr
, 1);
4827 range_type
= create_range_type (NULL
, base_type
, low
, high
);
4829 attr
= dwarf2_attr (die
, DW_AT_name
, cu
);
4830 if (attr
&& DW_STRING (attr
))
4831 TYPE_NAME (range_type
) = DW_STRING (attr
);
4833 attr
= dwarf2_attr (die
, DW_AT_byte_size
, cu
);
4835 TYPE_LENGTH (range_type
) = DW_UNSND (attr
);
4837 set_die_type (die
, range_type
, cu
);
4841 /* Read a whole compilation unit into a linked list of dies. */
4843 static struct die_info
*
4844 read_comp_unit (gdb_byte
*info_ptr
, bfd
*abfd
, struct dwarf2_cu
*cu
)
4846 return read_die_and_children (info_ptr
, abfd
, cu
, &info_ptr
, NULL
);
4849 /* Read a single die and all its descendents. Set the die's sibling
4850 field to NULL; set other fields in the die correctly, and set all
4851 of the descendents' fields correctly. Set *NEW_INFO_PTR to the
4852 location of the info_ptr after reading all of those dies. PARENT
4853 is the parent of the die in question. */
4855 static struct die_info
*
4856 read_die_and_children (gdb_byte
*info_ptr
, bfd
*abfd
,
4857 struct dwarf2_cu
*cu
,
4858 gdb_byte
**new_info_ptr
,
4859 struct die_info
*parent
)
4861 struct die_info
*die
;
4865 cur_ptr
= read_full_die (&die
, abfd
, info_ptr
, cu
, &has_children
);
4866 store_in_ref_table (die
->offset
, die
, cu
);
4870 die
->child
= read_die_and_siblings (cur_ptr
, abfd
, cu
,
4876 *new_info_ptr
= cur_ptr
;
4879 die
->sibling
= NULL
;
4880 die
->parent
= parent
;
4884 /* Read a die, all of its descendents, and all of its siblings; set
4885 all of the fields of all of the dies correctly. Arguments are as
4886 in read_die_and_children. */
4888 static struct die_info
*
4889 read_die_and_siblings (gdb_byte
*info_ptr
, bfd
*abfd
,
4890 struct dwarf2_cu
*cu
,
4891 gdb_byte
**new_info_ptr
,
4892 struct die_info
*parent
)
4894 struct die_info
*first_die
, *last_sibling
;
4898 first_die
= last_sibling
= NULL
;
4902 struct die_info
*die
4903 = read_die_and_children (cur_ptr
, abfd
, cu
, &cur_ptr
, parent
);
4911 last_sibling
->sibling
= die
;
4916 *new_info_ptr
= cur_ptr
;
4926 /* Free a linked list of dies. */
4929 free_die_list (struct die_info
*dies
)
4931 struct die_info
*die
, *next
;
4936 if (die
->child
!= NULL
)
4937 free_die_list (die
->child
);
4938 next
= die
->sibling
;
4945 /* Read the contents of the section at OFFSET and of size SIZE from the
4946 object file specified by OBJFILE into the objfile_obstack and return it. */
4949 dwarf2_read_section (struct objfile
*objfile
, asection
*sectp
)
4951 bfd
*abfd
= objfile
->obfd
;
4952 gdb_byte
*buf
, *retbuf
;
4953 bfd_size_type size
= bfd_get_section_size (sectp
);
4958 buf
= obstack_alloc (&objfile
->objfile_obstack
, size
);
4959 retbuf
= symfile_relocate_debug_section (abfd
, sectp
, buf
);
4963 if (bfd_seek (abfd
, sectp
->filepos
, SEEK_SET
) != 0
4964 || bfd_bread (buf
, size
, abfd
) != size
)
4965 error (_("Dwarf Error: Can't read DWARF data from '%s'"),
4966 bfd_get_filename (abfd
));
4971 /* In DWARF version 2, the description of the debugging information is
4972 stored in a separate .debug_abbrev section. Before we read any
4973 dies from a section we read in all abbreviations and install them
4974 in a hash table. This function also sets flags in CU describing
4975 the data found in the abbrev table. */
4978 dwarf2_read_abbrevs (bfd
*abfd
, struct dwarf2_cu
*cu
)
4980 struct comp_unit_head
*cu_header
= &cu
->header
;
4981 gdb_byte
*abbrev_ptr
;
4982 struct abbrev_info
*cur_abbrev
;
4983 unsigned int abbrev_number
, bytes_read
, abbrev_name
;
4984 unsigned int abbrev_form
, hash_number
;
4985 struct attr_abbrev
*cur_attrs
;
4986 unsigned int allocated_attrs
;
4988 /* Initialize dwarf2 abbrevs */
4989 obstack_init (&cu
->abbrev_obstack
);
4990 cu
->dwarf2_abbrevs
= obstack_alloc (&cu
->abbrev_obstack
,
4992 * sizeof (struct abbrev_info
*)));
4993 memset (cu
->dwarf2_abbrevs
, 0,
4994 ABBREV_HASH_SIZE
* sizeof (struct abbrev_info
*));
4996 abbrev_ptr
= dwarf2_per_objfile
->abbrev_buffer
+ cu_header
->abbrev_offset
;
4997 abbrev_number
= read_unsigned_leb128 (abfd
, abbrev_ptr
, &bytes_read
);
4998 abbrev_ptr
+= bytes_read
;
5000 allocated_attrs
= ATTR_ALLOC_CHUNK
;
5001 cur_attrs
= xmalloc (allocated_attrs
* sizeof (struct attr_abbrev
));
5003 /* loop until we reach an abbrev number of 0 */
5004 while (abbrev_number
)
5006 cur_abbrev
= dwarf_alloc_abbrev (cu
);
5008 /* read in abbrev header */
5009 cur_abbrev
->number
= abbrev_number
;
5010 cur_abbrev
->tag
= read_unsigned_leb128 (abfd
, abbrev_ptr
, &bytes_read
);
5011 abbrev_ptr
+= bytes_read
;
5012 cur_abbrev
->has_children
= read_1_byte (abfd
, abbrev_ptr
);
5015 if (cur_abbrev
->tag
== DW_TAG_namespace
)
5016 cu
->has_namespace_info
= 1;
5018 /* now read in declarations */
5019 abbrev_name
= read_unsigned_leb128 (abfd
, abbrev_ptr
, &bytes_read
);
5020 abbrev_ptr
+= bytes_read
;
5021 abbrev_form
= read_unsigned_leb128 (abfd
, abbrev_ptr
, &bytes_read
);
5022 abbrev_ptr
+= bytes_read
;
5025 if (cur_abbrev
->num_attrs
== allocated_attrs
)
5027 allocated_attrs
+= ATTR_ALLOC_CHUNK
;
5029 = xrealloc (cur_attrs
, (allocated_attrs
5030 * sizeof (struct attr_abbrev
)));
5033 /* Record whether this compilation unit might have
5034 inter-compilation-unit references. If we don't know what form
5035 this attribute will have, then it might potentially be a
5036 DW_FORM_ref_addr, so we conservatively expect inter-CU
5039 if (abbrev_form
== DW_FORM_ref_addr
5040 || abbrev_form
== DW_FORM_indirect
)
5041 cu
->has_form_ref_addr
= 1;
5043 cur_attrs
[cur_abbrev
->num_attrs
].name
= abbrev_name
;
5044 cur_attrs
[cur_abbrev
->num_attrs
++].form
= abbrev_form
;
5045 abbrev_name
= read_unsigned_leb128 (abfd
, abbrev_ptr
, &bytes_read
);
5046 abbrev_ptr
+= bytes_read
;
5047 abbrev_form
= read_unsigned_leb128 (abfd
, abbrev_ptr
, &bytes_read
);
5048 abbrev_ptr
+= bytes_read
;
5051 cur_abbrev
->attrs
= obstack_alloc (&cu
->abbrev_obstack
,
5052 (cur_abbrev
->num_attrs
5053 * sizeof (struct attr_abbrev
)));
5054 memcpy (cur_abbrev
->attrs
, cur_attrs
,
5055 cur_abbrev
->num_attrs
* sizeof (struct attr_abbrev
));
5057 hash_number
= abbrev_number
% ABBREV_HASH_SIZE
;
5058 cur_abbrev
->next
= cu
->dwarf2_abbrevs
[hash_number
];
5059 cu
->dwarf2_abbrevs
[hash_number
] = cur_abbrev
;
5061 /* Get next abbreviation.
5062 Under Irix6 the abbreviations for a compilation unit are not
5063 always properly terminated with an abbrev number of 0.
5064 Exit loop if we encounter an abbreviation which we have
5065 already read (which means we are about to read the abbreviations
5066 for the next compile unit) or if the end of the abbreviation
5067 table is reached. */
5068 if ((unsigned int) (abbrev_ptr
- dwarf2_per_objfile
->abbrev_buffer
)
5069 >= dwarf2_per_objfile
->abbrev_size
)
5071 abbrev_number
= read_unsigned_leb128 (abfd
, abbrev_ptr
, &bytes_read
);
5072 abbrev_ptr
+= bytes_read
;
5073 if (dwarf2_lookup_abbrev (abbrev_number
, cu
) != NULL
)
5080 /* Release the memory used by the abbrev table for a compilation unit. */
5083 dwarf2_free_abbrev_table (void *ptr_to_cu
)
5085 struct dwarf2_cu
*cu
= ptr_to_cu
;
5087 obstack_free (&cu
->abbrev_obstack
, NULL
);
5088 cu
->dwarf2_abbrevs
= NULL
;
5091 /* Lookup an abbrev_info structure in the abbrev hash table. */
5093 static struct abbrev_info
*
5094 dwarf2_lookup_abbrev (unsigned int number
, struct dwarf2_cu
*cu
)
5096 unsigned int hash_number
;
5097 struct abbrev_info
*abbrev
;
5099 hash_number
= number
% ABBREV_HASH_SIZE
;
5100 abbrev
= cu
->dwarf2_abbrevs
[hash_number
];
5104 if (abbrev
->number
== number
)
5107 abbrev
= abbrev
->next
;
5112 /* Returns nonzero if TAG represents a type that we might generate a partial
5116 is_type_tag_for_partial (int tag
)
5121 /* Some types that would be reasonable to generate partial symbols for,
5122 that we don't at present. */
5123 case DW_TAG_array_type
:
5124 case DW_TAG_file_type
:
5125 case DW_TAG_ptr_to_member_type
:
5126 case DW_TAG_set_type
:
5127 case DW_TAG_string_type
:
5128 case DW_TAG_subroutine_type
:
5130 case DW_TAG_base_type
:
5131 case DW_TAG_class_type
:
5132 case DW_TAG_enumeration_type
:
5133 case DW_TAG_structure_type
:
5134 case DW_TAG_subrange_type
:
5135 case DW_TAG_typedef
:
5136 case DW_TAG_union_type
:
5143 /* Load all DIEs that are interesting for partial symbols into memory. */
5145 static struct partial_die_info
*
5146 load_partial_dies (bfd
*abfd
, gdb_byte
*info_ptr
, int building_psymtab
,
5147 struct dwarf2_cu
*cu
)
5149 struct partial_die_info
*part_die
;
5150 struct partial_die_info
*parent_die
, *last_die
, *first_die
= NULL
;
5151 struct abbrev_info
*abbrev
;
5152 unsigned int bytes_read
;
5153 unsigned int load_all
= 0;
5155 int nesting_level
= 1;
5160 if (cu
->per_cu
&& cu
->per_cu
->load_all_dies
)
5164 = htab_create_alloc_ex (cu
->header
.length
/ 12,
5168 &cu
->comp_unit_obstack
,
5169 hashtab_obstack_allocate
,
5170 dummy_obstack_deallocate
);
5172 part_die
= obstack_alloc (&cu
->comp_unit_obstack
,
5173 sizeof (struct partial_die_info
));
5177 abbrev
= peek_die_abbrev (info_ptr
, &bytes_read
, cu
);
5179 /* A NULL abbrev means the end of a series of children. */
5182 if (--nesting_level
== 0)
5184 /* PART_DIE was probably the last thing allocated on the
5185 comp_unit_obstack, so we could call obstack_free
5186 here. We don't do that because the waste is small,
5187 and will be cleaned up when we're done with this
5188 compilation unit. This way, we're also more robust
5189 against other users of the comp_unit_obstack. */
5192 info_ptr
+= bytes_read
;
5193 last_die
= parent_die
;
5194 parent_die
= parent_die
->die_parent
;
5198 /* Check whether this DIE is interesting enough to save. Normally
5199 we would not be interested in members here, but there may be
5200 later variables referencing them via DW_AT_specification (for
5203 && !is_type_tag_for_partial (abbrev
->tag
)
5204 && abbrev
->tag
!= DW_TAG_enumerator
5205 && abbrev
->tag
!= DW_TAG_subprogram
5206 && abbrev
->tag
!= DW_TAG_variable
5207 && abbrev
->tag
!= DW_TAG_namespace
5208 && abbrev
->tag
!= DW_TAG_member
)
5210 /* Otherwise we skip to the next sibling, if any. */
5211 info_ptr
= skip_one_die (info_ptr
+ bytes_read
, abbrev
, cu
);
5215 info_ptr
= read_partial_die (part_die
, abbrev
, bytes_read
,
5216 abfd
, info_ptr
, cu
);
5218 /* This two-pass algorithm for processing partial symbols has a
5219 high cost in cache pressure. Thus, handle some simple cases
5220 here which cover the majority of C partial symbols. DIEs
5221 which neither have specification tags in them, nor could have
5222 specification tags elsewhere pointing at them, can simply be
5223 processed and discarded.
5225 This segment is also optional; scan_partial_symbols and
5226 add_partial_symbol will handle these DIEs if we chain
5227 them in normally. When compilers which do not emit large
5228 quantities of duplicate debug information are more common,
5229 this code can probably be removed. */
5231 /* Any complete simple types at the top level (pretty much all
5232 of them, for a language without namespaces), can be processed
5234 if (parent_die
== NULL
5235 && part_die
->has_specification
== 0
5236 && part_die
->is_declaration
== 0
5237 && (part_die
->tag
== DW_TAG_typedef
5238 || part_die
->tag
== DW_TAG_base_type
5239 || part_die
->tag
== DW_TAG_subrange_type
))
5241 if (building_psymtab
&& part_die
->name
!= NULL
)
5242 add_psymbol_to_list (part_die
->name
, strlen (part_die
->name
),
5243 VAR_DOMAIN
, LOC_TYPEDEF
,
5244 &cu
->objfile
->static_psymbols
,
5245 0, (CORE_ADDR
) 0, cu
->language
, cu
->objfile
);
5246 info_ptr
= locate_pdi_sibling (part_die
, info_ptr
, abfd
, cu
);
5250 /* If we're at the second level, and we're an enumerator, and
5251 our parent has no specification (meaning possibly lives in a
5252 namespace elsewhere), then we can add the partial symbol now
5253 instead of queueing it. */
5254 if (part_die
->tag
== DW_TAG_enumerator
5255 && parent_die
!= NULL
5256 && parent_die
->die_parent
== NULL
5257 && parent_die
->tag
== DW_TAG_enumeration_type
5258 && parent_die
->has_specification
== 0)
5260 if (part_die
->name
== NULL
)
5261 complaint (&symfile_complaints
, _("malformed enumerator DIE ignored"));
5262 else if (building_psymtab
)
5263 add_psymbol_to_list (part_die
->name
, strlen (part_die
->name
),
5264 VAR_DOMAIN
, LOC_CONST
,
5265 (cu
->language
== language_cplus
5266 || cu
->language
== language_java
)
5267 ? &cu
->objfile
->global_psymbols
5268 : &cu
->objfile
->static_psymbols
,
5269 0, (CORE_ADDR
) 0, cu
->language
, cu
->objfile
);
5271 info_ptr
= locate_pdi_sibling (part_die
, info_ptr
, abfd
, cu
);
5275 /* We'll save this DIE so link it in. */
5276 part_die
->die_parent
= parent_die
;
5277 part_die
->die_sibling
= NULL
;
5278 part_die
->die_child
= NULL
;
5280 if (last_die
&& last_die
== parent_die
)
5281 last_die
->die_child
= part_die
;
5283 last_die
->die_sibling
= part_die
;
5285 last_die
= part_die
;
5287 if (first_die
== NULL
)
5288 first_die
= part_die
;
5290 /* Maybe add the DIE to the hash table. Not all DIEs that we
5291 find interesting need to be in the hash table, because we
5292 also have the parent/sibling/child chains; only those that we
5293 might refer to by offset later during partial symbol reading.
5295 For now this means things that might have be the target of a
5296 DW_AT_specification, DW_AT_abstract_origin, or
5297 DW_AT_extension. DW_AT_extension will refer only to
5298 namespaces; DW_AT_abstract_origin refers to functions (and
5299 many things under the function DIE, but we do not recurse
5300 into function DIEs during partial symbol reading) and
5301 possibly variables as well; DW_AT_specification refers to
5302 declarations. Declarations ought to have the DW_AT_declaration
5303 flag. It happens that GCC forgets to put it in sometimes, but
5304 only for functions, not for types.
5306 Adding more things than necessary to the hash table is harmless
5307 except for the performance cost. Adding too few will result in
5308 wasted time in find_partial_die, when we reread the compilation
5309 unit with load_all_dies set. */
5312 || abbrev
->tag
== DW_TAG_subprogram
5313 || abbrev
->tag
== DW_TAG_variable
5314 || abbrev
->tag
== DW_TAG_namespace
5315 || part_die
->is_declaration
)
5319 slot
= htab_find_slot_with_hash (cu
->partial_dies
, part_die
,
5320 part_die
->offset
, INSERT
);
5324 part_die
= obstack_alloc (&cu
->comp_unit_obstack
,
5325 sizeof (struct partial_die_info
));
5327 /* For some DIEs we want to follow their children (if any). For C
5328 we have no reason to follow the children of structures; for other
5329 languages we have to, both so that we can get at method physnames
5330 to infer fully qualified class names, and for DW_AT_specification. */
5331 if (last_die
->has_children
5333 || last_die
->tag
== DW_TAG_namespace
5334 || last_die
->tag
== DW_TAG_enumeration_type
5335 || (cu
->language
!= language_c
5336 && (last_die
->tag
== DW_TAG_class_type
5337 || last_die
->tag
== DW_TAG_structure_type
5338 || last_die
->tag
== DW_TAG_union_type
))))
5341 parent_die
= last_die
;
5345 /* Otherwise we skip to the next sibling, if any. */
5346 info_ptr
= locate_pdi_sibling (last_die
, info_ptr
, abfd
, cu
);
5348 /* Back to the top, do it again. */
5352 /* Read a minimal amount of information into the minimal die structure. */
5355 read_partial_die (struct partial_die_info
*part_die
,
5356 struct abbrev_info
*abbrev
,
5357 unsigned int abbrev_len
, bfd
*abfd
,
5358 gdb_byte
*info_ptr
, struct dwarf2_cu
*cu
)
5360 unsigned int bytes_read
, i
;
5361 struct attribute attr
;
5362 int has_low_pc_attr
= 0;
5363 int has_high_pc_attr
= 0;
5365 memset (part_die
, 0, sizeof (struct partial_die_info
));
5367 part_die
->offset
= info_ptr
- dwarf2_per_objfile
->info_buffer
;
5369 info_ptr
+= abbrev_len
;
5374 part_die
->tag
= abbrev
->tag
;
5375 part_die
->has_children
= abbrev
->has_children
;
5377 for (i
= 0; i
< abbrev
->num_attrs
; ++i
)
5379 info_ptr
= read_attribute (&attr
, &abbrev
->attrs
[i
], abfd
, info_ptr
, cu
);
5381 /* Store the data if it is of an attribute we want to keep in a
5382 partial symbol table. */
5387 /* Prefer DW_AT_MIPS_linkage_name over DW_AT_name. */
5388 if (part_die
->name
== NULL
)
5389 part_die
->name
= DW_STRING (&attr
);
5391 case DW_AT_comp_dir
:
5392 if (part_die
->dirname
== NULL
)
5393 part_die
->dirname
= DW_STRING (&attr
);
5395 case DW_AT_MIPS_linkage_name
:
5396 part_die
->name
= DW_STRING (&attr
);
5399 has_low_pc_attr
= 1;
5400 part_die
->lowpc
= DW_ADDR (&attr
);
5403 has_high_pc_attr
= 1;
5404 part_die
->highpc
= DW_ADDR (&attr
);
5406 case DW_AT_location
:
5407 /* Support the .debug_loc offsets */
5408 if (attr_form_is_block (&attr
))
5410 part_die
->locdesc
= DW_BLOCK (&attr
);
5412 else if (attr
.form
== DW_FORM_data4
|| attr
.form
== DW_FORM_data8
)
5414 dwarf2_complex_location_expr_complaint ();
5418 dwarf2_invalid_attrib_class_complaint ("DW_AT_location",
5419 "partial symbol information");
5422 case DW_AT_language
:
5423 part_die
->language
= DW_UNSND (&attr
);
5425 case DW_AT_external
:
5426 part_die
->is_external
= DW_UNSND (&attr
);
5428 case DW_AT_declaration
:
5429 part_die
->is_declaration
= DW_UNSND (&attr
);
5432 part_die
->has_type
= 1;
5434 case DW_AT_abstract_origin
:
5435 case DW_AT_specification
:
5436 case DW_AT_extension
:
5437 part_die
->has_specification
= 1;
5438 part_die
->spec_offset
= dwarf2_get_ref_die_offset (&attr
, cu
);
5441 /* Ignore absolute siblings, they might point outside of
5442 the current compile unit. */
5443 if (attr
.form
== DW_FORM_ref_addr
)
5444 complaint (&symfile_complaints
, _("ignoring absolute DW_AT_sibling"));
5446 part_die
->sibling
= dwarf2_per_objfile
->info_buffer
5447 + dwarf2_get_ref_die_offset (&attr
, cu
);
5449 case DW_AT_stmt_list
:
5450 part_die
->has_stmt_list
= 1;
5451 part_die
->line_offset
= DW_UNSND (&attr
);
5458 /* When using the GNU linker, .gnu.linkonce. sections are used to
5459 eliminate duplicate copies of functions and vtables and such.
5460 The linker will arbitrarily choose one and discard the others.
5461 The AT_*_pc values for such functions refer to local labels in
5462 these sections. If the section from that file was discarded, the
5463 labels are not in the output, so the relocs get a value of 0.
5464 If this is a discarded function, mark the pc bounds as invalid,
5465 so that GDB will ignore it. */
5466 if (has_low_pc_attr
&& has_high_pc_attr
5467 && part_die
->lowpc
< part_die
->highpc
5468 && (part_die
->lowpc
!= 0
5469 || (bfd_get_file_flags (abfd
) & HAS_RELOC
)))
5470 part_die
->has_pc_info
= 1;
5474 /* Find a cached partial DIE at OFFSET in CU. */
5476 static struct partial_die_info
*
5477 find_partial_die_in_comp_unit (unsigned long offset
, struct dwarf2_cu
*cu
)
5479 struct partial_die_info
*lookup_die
= NULL
;
5480 struct partial_die_info part_die
;
5482 part_die
.offset
= offset
;
5483 lookup_die
= htab_find_with_hash (cu
->partial_dies
, &part_die
, offset
);
5488 /* Find a partial DIE at OFFSET, which may or may not be in CU. */
5490 static struct partial_die_info
*
5491 find_partial_die (unsigned long offset
, struct dwarf2_cu
*cu
)
5493 struct dwarf2_per_cu_data
*per_cu
= NULL
;
5494 struct partial_die_info
*pd
= NULL
;
5496 if (offset
>= cu
->header
.offset
5497 && offset
< cu
->header
.offset
+ cu
->header
.length
)
5499 pd
= find_partial_die_in_comp_unit (offset
, cu
);
5504 per_cu
= dwarf2_find_containing_comp_unit (offset
, cu
->objfile
);
5506 if (per_cu
->cu
== NULL
)
5508 load_comp_unit (per_cu
, cu
->objfile
);
5509 per_cu
->cu
->read_in_chain
= dwarf2_per_objfile
->read_in_chain
;
5510 dwarf2_per_objfile
->read_in_chain
= per_cu
;
5513 per_cu
->cu
->last_used
= 0;
5514 pd
= find_partial_die_in_comp_unit (offset
, per_cu
->cu
);
5516 if (pd
== NULL
&& per_cu
->load_all_dies
== 0)
5518 struct cleanup
*back_to
;
5519 struct partial_die_info comp_unit_die
;
5520 struct abbrev_info
*abbrev
;
5521 unsigned int bytes_read
;
5524 per_cu
->load_all_dies
= 1;
5526 /* Re-read the DIEs. */
5527 back_to
= make_cleanup (null_cleanup
, 0);
5528 if (per_cu
->cu
->dwarf2_abbrevs
== NULL
)
5530 dwarf2_read_abbrevs (per_cu
->cu
->objfile
->obfd
, per_cu
->cu
);
5531 back_to
= make_cleanup (dwarf2_free_abbrev_table
, per_cu
->cu
);
5533 info_ptr
= per_cu
->cu
->header
.first_die_ptr
;
5534 abbrev
= peek_die_abbrev (info_ptr
, &bytes_read
, per_cu
->cu
);
5535 info_ptr
= read_partial_die (&comp_unit_die
, abbrev
, bytes_read
,
5536 per_cu
->cu
->objfile
->obfd
, info_ptr
,
5538 if (comp_unit_die
.has_children
)
5539 load_partial_dies (per_cu
->cu
->objfile
->obfd
, info_ptr
, 0, per_cu
->cu
);
5540 do_cleanups (back_to
);
5542 pd
= find_partial_die_in_comp_unit (offset
, per_cu
->cu
);
5546 internal_error (__FILE__
, __LINE__
,
5547 _("could not find partial DIE 0x%lx in cache [from module %s]\n"),
5548 offset
, bfd_get_filename (cu
->objfile
->obfd
));
5552 /* Adjust PART_DIE before generating a symbol for it. This function
5553 may set the is_external flag or change the DIE's name. */
5556 fixup_partial_die (struct partial_die_info
*part_die
,
5557 struct dwarf2_cu
*cu
)
5559 /* If we found a reference attribute and the DIE has no name, try
5560 to find a name in the referred to DIE. */
5562 if (part_die
->name
== NULL
&& part_die
->has_specification
)
5564 struct partial_die_info
*spec_die
;
5566 spec_die
= find_partial_die (part_die
->spec_offset
, cu
);
5568 fixup_partial_die (spec_die
, cu
);
5572 part_die
->name
= spec_die
->name
;
5574 /* Copy DW_AT_external attribute if it is set. */
5575 if (spec_die
->is_external
)
5576 part_die
->is_external
= spec_die
->is_external
;
5580 /* Set default names for some unnamed DIEs. */
5581 if (part_die
->name
== NULL
&& (part_die
->tag
== DW_TAG_structure_type
5582 || part_die
->tag
== DW_TAG_class_type
))
5583 part_die
->name
= "(anonymous class)";
5585 if (part_die
->name
== NULL
&& part_die
->tag
== DW_TAG_namespace
)
5586 part_die
->name
= "(anonymous namespace)";
5588 if (part_die
->tag
== DW_TAG_structure_type
5589 || part_die
->tag
== DW_TAG_class_type
5590 || part_die
->tag
== DW_TAG_union_type
)
5591 guess_structure_name (part_die
, cu
);
5594 /* Read the die from the .debug_info section buffer. Set DIEP to
5595 point to a newly allocated die with its information, except for its
5596 child, sibling, and parent fields. Set HAS_CHILDREN to tell
5597 whether the die has children or not. */
5600 read_full_die (struct die_info
**diep
, bfd
*abfd
, gdb_byte
*info_ptr
,
5601 struct dwarf2_cu
*cu
, int *has_children
)
5603 unsigned int abbrev_number
, bytes_read
, i
, offset
;
5604 struct abbrev_info
*abbrev
;
5605 struct die_info
*die
;
5607 offset
= info_ptr
- dwarf2_per_objfile
->info_buffer
;
5608 abbrev_number
= read_unsigned_leb128 (abfd
, info_ptr
, &bytes_read
);
5609 info_ptr
+= bytes_read
;
5612 die
= dwarf_alloc_die ();
5614 die
->abbrev
= abbrev_number
;
5621 abbrev
= dwarf2_lookup_abbrev (abbrev_number
, cu
);
5624 error (_("Dwarf Error: could not find abbrev number %d [in module %s]"),
5626 bfd_get_filename (abfd
));
5628 die
= dwarf_alloc_die ();
5629 die
->offset
= offset
;
5630 die
->tag
= abbrev
->tag
;
5631 die
->abbrev
= abbrev_number
;
5634 die
->num_attrs
= abbrev
->num_attrs
;
5635 die
->attrs
= (struct attribute
*)
5636 xmalloc (die
->num_attrs
* sizeof (struct attribute
));
5638 for (i
= 0; i
< abbrev
->num_attrs
; ++i
)
5640 info_ptr
= read_attribute (&die
->attrs
[i
], &abbrev
->attrs
[i
],
5641 abfd
, info_ptr
, cu
);
5643 /* If this attribute is an absolute reference to a different
5644 compilation unit, make sure that compilation unit is loaded
5646 if (die
->attrs
[i
].form
== DW_FORM_ref_addr
5647 && (DW_ADDR (&die
->attrs
[i
]) < cu
->header
.offset
5648 || (DW_ADDR (&die
->attrs
[i
])
5649 >= cu
->header
.offset
+ cu
->header
.length
)))
5651 struct dwarf2_per_cu_data
*per_cu
;
5652 per_cu
= dwarf2_find_containing_comp_unit (DW_ADDR (&die
->attrs
[i
]),
5655 /* Mark the dependence relation so that we don't flush PER_CU
5657 dwarf2_add_dependence (cu
, per_cu
);
5659 /* If it's already on the queue, we have nothing to do. */
5663 /* If the compilation unit is already loaded, just mark it as
5665 if (per_cu
->cu
!= NULL
)
5667 per_cu
->cu
->last_used
= 0;
5671 /* Add it to the queue. */
5672 queue_comp_unit (per_cu
);
5677 *has_children
= abbrev
->has_children
;
5681 /* Read an attribute value described by an attribute form. */
5684 read_attribute_value (struct attribute
*attr
, unsigned form
,
5685 bfd
*abfd
, gdb_byte
*info_ptr
,
5686 struct dwarf2_cu
*cu
)
5688 struct comp_unit_head
*cu_header
= &cu
->header
;
5689 unsigned int bytes_read
;
5690 struct dwarf_block
*blk
;
5696 case DW_FORM_ref_addr
:
5697 DW_ADDR (attr
) = read_address (abfd
, info_ptr
, cu
, &bytes_read
);
5698 info_ptr
+= bytes_read
;
5700 case DW_FORM_block2
:
5701 blk
= dwarf_alloc_block (cu
);
5702 blk
->size
= read_2_bytes (abfd
, info_ptr
);
5704 blk
->data
= read_n_bytes (abfd
, info_ptr
, blk
->size
);
5705 info_ptr
+= blk
->size
;
5706 DW_BLOCK (attr
) = blk
;
5708 case DW_FORM_block4
:
5709 blk
= dwarf_alloc_block (cu
);
5710 blk
->size
= read_4_bytes (abfd
, info_ptr
);
5712 blk
->data
= read_n_bytes (abfd
, info_ptr
, blk
->size
);
5713 info_ptr
+= blk
->size
;
5714 DW_BLOCK (attr
) = blk
;
5717 DW_UNSND (attr
) = read_2_bytes (abfd
, info_ptr
);
5721 DW_UNSND (attr
) = read_4_bytes (abfd
, info_ptr
);
5725 DW_UNSND (attr
) = read_8_bytes (abfd
, info_ptr
);
5728 case DW_FORM_string
:
5729 DW_STRING (attr
) = read_string (abfd
, info_ptr
, &bytes_read
);
5730 info_ptr
+= bytes_read
;
5733 DW_STRING (attr
) = read_indirect_string (abfd
, info_ptr
, cu_header
,
5735 info_ptr
+= bytes_read
;
5738 blk
= dwarf_alloc_block (cu
);
5739 blk
->size
= read_unsigned_leb128 (abfd
, info_ptr
, &bytes_read
);
5740 info_ptr
+= bytes_read
;
5741 blk
->data
= read_n_bytes (abfd
, info_ptr
, blk
->size
);
5742 info_ptr
+= blk
->size
;
5743 DW_BLOCK (attr
) = blk
;
5745 case DW_FORM_block1
:
5746 blk
= dwarf_alloc_block (cu
);
5747 blk
->size
= read_1_byte (abfd
, info_ptr
);
5749 blk
->data
= read_n_bytes (abfd
, info_ptr
, blk
->size
);
5750 info_ptr
+= blk
->size
;
5751 DW_BLOCK (attr
) = blk
;
5754 DW_UNSND (attr
) = read_1_byte (abfd
, info_ptr
);
5758 DW_UNSND (attr
) = read_1_byte (abfd
, info_ptr
);
5762 DW_SND (attr
) = read_signed_leb128 (abfd
, info_ptr
, &bytes_read
);
5763 info_ptr
+= bytes_read
;
5766 DW_UNSND (attr
) = read_unsigned_leb128 (abfd
, info_ptr
, &bytes_read
);
5767 info_ptr
+= bytes_read
;
5770 DW_ADDR (attr
) = cu
->header
.offset
+ read_1_byte (abfd
, info_ptr
);
5774 DW_ADDR (attr
) = cu
->header
.offset
+ read_2_bytes (abfd
, info_ptr
);
5778 DW_ADDR (attr
) = cu
->header
.offset
+ read_4_bytes (abfd
, info_ptr
);
5782 DW_ADDR (attr
) = cu
->header
.offset
+ read_8_bytes (abfd
, info_ptr
);
5785 case DW_FORM_ref_udata
:
5786 DW_ADDR (attr
) = (cu
->header
.offset
5787 + read_unsigned_leb128 (abfd
, info_ptr
, &bytes_read
));
5788 info_ptr
+= bytes_read
;
5790 case DW_FORM_indirect
:
5791 form
= read_unsigned_leb128 (abfd
, info_ptr
, &bytes_read
);
5792 info_ptr
+= bytes_read
;
5793 info_ptr
= read_attribute_value (attr
, form
, abfd
, info_ptr
, cu
);
5796 error (_("Dwarf Error: Cannot handle %s in DWARF reader [in module %s]"),
5797 dwarf_form_name (form
),
5798 bfd_get_filename (abfd
));
5803 /* Read an attribute described by an abbreviated attribute. */
5806 read_attribute (struct attribute
*attr
, struct attr_abbrev
*abbrev
,
5807 bfd
*abfd
, gdb_byte
*info_ptr
, struct dwarf2_cu
*cu
)
5809 attr
->name
= abbrev
->name
;
5810 return read_attribute_value (attr
, abbrev
->form
, abfd
, info_ptr
, cu
);
5813 /* read dwarf information from a buffer */
5816 read_1_byte (bfd
*abfd
, gdb_byte
*buf
)
5818 return bfd_get_8 (abfd
, buf
);
5822 read_1_signed_byte (bfd
*abfd
, gdb_byte
*buf
)
5824 return bfd_get_signed_8 (abfd
, buf
);
5828 read_2_bytes (bfd
*abfd
, gdb_byte
*buf
)
5830 return bfd_get_16 (abfd
, buf
);
5834 read_2_signed_bytes (bfd
*abfd
, gdb_byte
*buf
)
5836 return bfd_get_signed_16 (abfd
, buf
);
5840 read_4_bytes (bfd
*abfd
, gdb_byte
*buf
)
5842 return bfd_get_32 (abfd
, buf
);
5846 read_4_signed_bytes (bfd
*abfd
, gdb_byte
*buf
)
5848 return bfd_get_signed_32 (abfd
, buf
);
5851 static unsigned long
5852 read_8_bytes (bfd
*abfd
, gdb_byte
*buf
)
5854 return bfd_get_64 (abfd
, buf
);
5858 read_address (bfd
*abfd
, gdb_byte
*buf
, struct dwarf2_cu
*cu
,
5859 unsigned int *bytes_read
)
5861 struct comp_unit_head
*cu_header
= &cu
->header
;
5862 CORE_ADDR retval
= 0;
5864 if (cu_header
->signed_addr_p
)
5866 switch (cu_header
->addr_size
)
5869 retval
= bfd_get_signed_16 (abfd
, buf
);
5872 retval
= bfd_get_signed_32 (abfd
, buf
);
5875 retval
= bfd_get_signed_64 (abfd
, buf
);
5878 internal_error (__FILE__
, __LINE__
,
5879 _("read_address: bad switch, signed [in module %s]"),
5880 bfd_get_filename (abfd
));
5885 switch (cu_header
->addr_size
)
5888 retval
= bfd_get_16 (abfd
, buf
);
5891 retval
= bfd_get_32 (abfd
, buf
);
5894 retval
= bfd_get_64 (abfd
, buf
);
5897 internal_error (__FILE__
, __LINE__
,
5898 _("read_address: bad switch, unsigned [in module %s]"),
5899 bfd_get_filename (abfd
));
5903 *bytes_read
= cu_header
->addr_size
;
5907 /* Read the initial length from a section. The (draft) DWARF 3
5908 specification allows the initial length to take up either 4 bytes
5909 or 12 bytes. If the first 4 bytes are 0xffffffff, then the next 8
5910 bytes describe the length and all offsets will be 8 bytes in length
5913 An older, non-standard 64-bit format is also handled by this
5914 function. The older format in question stores the initial length
5915 as an 8-byte quantity without an escape value. Lengths greater
5916 than 2^32 aren't very common which means that the initial 4 bytes
5917 is almost always zero. Since a length value of zero doesn't make
5918 sense for the 32-bit format, this initial zero can be considered to
5919 be an escape value which indicates the presence of the older 64-bit
5920 format. As written, the code can't detect (old format) lengths
5921 greater than 4GB. If it becomes necessary to handle lengths
5922 somewhat larger than 4GB, we could allow other small values (such
5923 as the non-sensical values of 1, 2, and 3) to also be used as
5924 escape values indicating the presence of the old format.
5926 The value returned via bytes_read should be used to increment the
5927 relevant pointer after calling read_initial_length().
5929 As a side effect, this function sets the fields initial_length_size
5930 and offset_size in cu_header to the values appropriate for the
5931 length field. (The format of the initial length field determines
5932 the width of file offsets to be fetched later with read_offset().)
5934 [ Note: read_initial_length() and read_offset() are based on the
5935 document entitled "DWARF Debugging Information Format", revision
5936 3, draft 8, dated November 19, 2001. This document was obtained
5939 http://reality.sgiweb.org/davea/dwarf3-draft8-011125.pdf
5941 This document is only a draft and is subject to change. (So beware.)
5943 Details regarding the older, non-standard 64-bit format were
5944 determined empirically by examining 64-bit ELF files produced by
5945 the SGI toolchain on an IRIX 6.5 machine.
5947 - Kevin, July 16, 2002
5951 read_initial_length (bfd
*abfd
, gdb_byte
*buf
, struct comp_unit_head
*cu_header
,
5952 unsigned int *bytes_read
)
5954 LONGEST length
= bfd_get_32 (abfd
, buf
);
5956 if (length
== 0xffffffff)
5958 length
= bfd_get_64 (abfd
, buf
+ 4);
5961 else if (length
== 0)
5963 /* Handle the (non-standard) 64-bit DWARF2 format used by IRIX. */
5964 length
= bfd_get_64 (abfd
, buf
);
5974 gdb_assert (cu_header
->initial_length_size
== 0
5975 || cu_header
->initial_length_size
== 4
5976 || cu_header
->initial_length_size
== 8
5977 || cu_header
->initial_length_size
== 12);
5979 if (cu_header
->initial_length_size
!= 0
5980 && cu_header
->initial_length_size
!= *bytes_read
)
5981 complaint (&symfile_complaints
,
5982 _("intermixed 32-bit and 64-bit DWARF sections"));
5984 cu_header
->initial_length_size
= *bytes_read
;
5985 cu_header
->offset_size
= (*bytes_read
== 4) ? 4 : 8;
5991 /* Read an offset from the data stream. The size of the offset is
5992 given by cu_header->offset_size. */
5995 read_offset (bfd
*abfd
, gdb_byte
*buf
, const struct comp_unit_head
*cu_header
,
5996 unsigned int *bytes_read
)
6000 switch (cu_header
->offset_size
)
6003 retval
= bfd_get_32 (abfd
, buf
);
6007 retval
= bfd_get_64 (abfd
, buf
);
6011 internal_error (__FILE__
, __LINE__
,
6012 _("read_offset: bad switch [in module %s]"),
6013 bfd_get_filename (abfd
));
6020 read_n_bytes (bfd
*abfd
, gdb_byte
*buf
, unsigned int size
)
6022 /* If the size of a host char is 8 bits, we can return a pointer
6023 to the buffer, otherwise we have to copy the data to a buffer
6024 allocated on the temporary obstack. */
6025 gdb_assert (HOST_CHAR_BIT
== 8);
6030 read_string (bfd
*abfd
, gdb_byte
*buf
, unsigned int *bytes_read_ptr
)
6032 /* If the size of a host char is 8 bits, we can return a pointer
6033 to the string, otherwise we have to copy the string to a buffer
6034 allocated on the temporary obstack. */
6035 gdb_assert (HOST_CHAR_BIT
== 8);
6038 *bytes_read_ptr
= 1;
6041 *bytes_read_ptr
= strlen ((char *) buf
) + 1;
6042 return (char *) buf
;
6046 read_indirect_string (bfd
*abfd
, gdb_byte
*buf
,
6047 const struct comp_unit_head
*cu_header
,
6048 unsigned int *bytes_read_ptr
)
6050 LONGEST str_offset
= read_offset (abfd
, buf
, cu_header
,
6053 if (dwarf2_per_objfile
->str_buffer
== NULL
)
6055 error (_("DW_FORM_strp used without .debug_str section [in module %s]"),
6056 bfd_get_filename (abfd
));
6059 if (str_offset
>= dwarf2_per_objfile
->str_size
)
6061 error (_("DW_FORM_strp pointing outside of .debug_str section [in module %s]"),
6062 bfd_get_filename (abfd
));
6065 gdb_assert (HOST_CHAR_BIT
== 8);
6066 if (dwarf2_per_objfile
->str_buffer
[str_offset
] == '\0')
6068 return (char *) (dwarf2_per_objfile
->str_buffer
+ str_offset
);
6071 static unsigned long
6072 read_unsigned_leb128 (bfd
*abfd
, gdb_byte
*buf
, unsigned int *bytes_read_ptr
)
6074 unsigned long result
;
6075 unsigned int num_read
;
6085 byte
= bfd_get_8 (abfd
, buf
);
6088 result
|= ((unsigned long)(byte
& 127) << shift
);
6089 if ((byte
& 128) == 0)
6095 *bytes_read_ptr
= num_read
;
6100 read_signed_leb128 (bfd
*abfd
, gdb_byte
*buf
, unsigned int *bytes_read_ptr
)
6103 int i
, shift
, num_read
;
6112 byte
= bfd_get_8 (abfd
, buf
);
6115 result
|= ((long)(byte
& 127) << shift
);
6117 if ((byte
& 128) == 0)
6122 if ((shift
< 8 * sizeof (result
)) && (byte
& 0x40))
6123 result
|= -(((long)1) << shift
);
6124 *bytes_read_ptr
= num_read
;
6128 /* Return a pointer to just past the end of an LEB128 number in BUF. */
6131 skip_leb128 (bfd
*abfd
, gdb_byte
*buf
)
6137 byte
= bfd_get_8 (abfd
, buf
);
6139 if ((byte
& 128) == 0)
6145 set_cu_language (unsigned int lang
, struct dwarf2_cu
*cu
)
6151 cu
->language
= language_c
;
6153 case DW_LANG_C_plus_plus
:
6154 cu
->language
= language_cplus
;
6156 case DW_LANG_Fortran77
:
6157 case DW_LANG_Fortran90
:
6158 case DW_LANG_Fortran95
:
6159 cu
->language
= language_fortran
;
6161 case DW_LANG_Mips_Assembler
:
6162 cu
->language
= language_asm
;
6165 cu
->language
= language_java
;
6169 cu
->language
= language_ada
;
6171 case DW_LANG_Cobol74
:
6172 case DW_LANG_Cobol85
:
6173 case DW_LANG_Pascal83
:
6174 case DW_LANG_Modula2
:
6176 cu
->language
= language_minimal
;
6179 cu
->language_defn
= language_def (cu
->language
);
6182 /* Return the named attribute or NULL if not there. */
6184 static struct attribute
*
6185 dwarf2_attr (struct die_info
*die
, unsigned int name
, struct dwarf2_cu
*cu
)
6188 struct attribute
*spec
= NULL
;
6190 for (i
= 0; i
< die
->num_attrs
; ++i
)
6192 if (die
->attrs
[i
].name
== name
)
6193 return &die
->attrs
[i
];
6194 if (die
->attrs
[i
].name
== DW_AT_specification
6195 || die
->attrs
[i
].name
== DW_AT_abstract_origin
)
6196 spec
= &die
->attrs
[i
];
6200 return dwarf2_attr (follow_die_ref (die
, spec
, cu
), name
, cu
);
6205 /* Return non-zero iff the attribute NAME is defined for the given DIE,
6206 and holds a non-zero value. This function should only be used for
6207 DW_FORM_flag attributes. */
6210 dwarf2_flag_true_p (struct die_info
*die
, unsigned name
, struct dwarf2_cu
*cu
)
6212 struct attribute
*attr
= dwarf2_attr (die
, name
, cu
);
6214 return (attr
&& DW_UNSND (attr
));
6218 die_is_declaration (struct die_info
*die
, struct dwarf2_cu
*cu
)
6220 /* A DIE is a declaration if it has a DW_AT_declaration attribute
6221 which value is non-zero. However, we have to be careful with
6222 DIEs having a DW_AT_specification attribute, because dwarf2_attr()
6223 (via dwarf2_flag_true_p) follows this attribute. So we may
6224 end up accidently finding a declaration attribute that belongs
6225 to a different DIE referenced by the specification attribute,
6226 even though the given DIE does not have a declaration attribute. */
6227 return (dwarf2_flag_true_p (die
, DW_AT_declaration
, cu
)
6228 && dwarf2_attr (die
, DW_AT_specification
, cu
) == NULL
);
6231 /* Return the die giving the specification for DIE, if there is
6234 static struct die_info
*
6235 die_specification (struct die_info
*die
, struct dwarf2_cu
*cu
)
6237 struct attribute
*spec_attr
= dwarf2_attr (die
, DW_AT_specification
, cu
);
6239 if (spec_attr
== NULL
)
6242 return follow_die_ref (die
, spec_attr
, cu
);
6245 /* Free the line_header structure *LH, and any arrays and strings it
6248 free_line_header (struct line_header
*lh
)
6250 if (lh
->standard_opcode_lengths
)
6251 xfree (lh
->standard_opcode_lengths
);
6253 /* Remember that all the lh->file_names[i].name pointers are
6254 pointers into debug_line_buffer, and don't need to be freed. */
6256 xfree (lh
->file_names
);
6258 /* Similarly for the include directory names. */
6259 if (lh
->include_dirs
)
6260 xfree (lh
->include_dirs
);
6266 /* Add an entry to LH's include directory table. */
6268 add_include_dir (struct line_header
*lh
, char *include_dir
)
6270 /* Grow the array if necessary. */
6271 if (lh
->include_dirs_size
== 0)
6273 lh
->include_dirs_size
= 1; /* for testing */
6274 lh
->include_dirs
= xmalloc (lh
->include_dirs_size
6275 * sizeof (*lh
->include_dirs
));
6277 else if (lh
->num_include_dirs
>= lh
->include_dirs_size
)
6279 lh
->include_dirs_size
*= 2;
6280 lh
->include_dirs
= xrealloc (lh
->include_dirs
,
6281 (lh
->include_dirs_size
6282 * sizeof (*lh
->include_dirs
)));
6285 lh
->include_dirs
[lh
->num_include_dirs
++] = include_dir
;
6289 /* Add an entry to LH's file name table. */
6291 add_file_name (struct line_header
*lh
,
6293 unsigned int dir_index
,
6294 unsigned int mod_time
,
6295 unsigned int length
)
6297 struct file_entry
*fe
;
6299 /* Grow the array if necessary. */
6300 if (lh
->file_names_size
== 0)
6302 lh
->file_names_size
= 1; /* for testing */
6303 lh
->file_names
= xmalloc (lh
->file_names_size
6304 * sizeof (*lh
->file_names
));
6306 else if (lh
->num_file_names
>= lh
->file_names_size
)
6308 lh
->file_names_size
*= 2;
6309 lh
->file_names
= xrealloc (lh
->file_names
,
6310 (lh
->file_names_size
6311 * sizeof (*lh
->file_names
)));
6314 fe
= &lh
->file_names
[lh
->num_file_names
++];
6316 fe
->dir_index
= dir_index
;
6317 fe
->mod_time
= mod_time
;
6318 fe
->length
= length
;
6323 /* Read the statement program header starting at OFFSET in
6324 .debug_line, according to the endianness of ABFD. Return a pointer
6325 to a struct line_header, allocated using xmalloc.
6327 NOTE: the strings in the include directory and file name tables of
6328 the returned object point into debug_line_buffer, and must not be
6330 static struct line_header
*
6331 dwarf_decode_line_header (unsigned int offset
, bfd
*abfd
,
6332 struct dwarf2_cu
*cu
)
6334 struct cleanup
*back_to
;
6335 struct line_header
*lh
;
6337 unsigned int bytes_read
;
6339 char *cur_dir
, *cur_file
;
6341 if (dwarf2_per_objfile
->line_buffer
== NULL
)
6343 complaint (&symfile_complaints
, _("missing .debug_line section"));
6347 /* Make sure that at least there's room for the total_length field.
6348 That could be 12 bytes long, but we're just going to fudge that. */
6349 if (offset
+ 4 >= dwarf2_per_objfile
->line_size
)
6351 dwarf2_statement_list_fits_in_line_number_section_complaint ();
6355 lh
= xmalloc (sizeof (*lh
));
6356 memset (lh
, 0, sizeof (*lh
));
6357 back_to
= make_cleanup ((make_cleanup_ftype
*) free_line_header
,
6360 line_ptr
= dwarf2_per_objfile
->line_buffer
+ offset
;
6362 /* Read in the header. */
6364 read_initial_length (abfd
, line_ptr
, &cu
->header
, &bytes_read
);
6365 line_ptr
+= bytes_read
;
6366 if (line_ptr
+ lh
->total_length
> (dwarf2_per_objfile
->line_buffer
6367 + dwarf2_per_objfile
->line_size
))
6369 dwarf2_statement_list_fits_in_line_number_section_complaint ();
6372 lh
->statement_program_end
= line_ptr
+ lh
->total_length
;
6373 lh
->version
= read_2_bytes (abfd
, line_ptr
);
6375 lh
->header_length
= read_offset (abfd
, line_ptr
, &cu
->header
, &bytes_read
);
6376 line_ptr
+= bytes_read
;
6377 lh
->minimum_instruction_length
= read_1_byte (abfd
, line_ptr
);
6379 lh
->default_is_stmt
= read_1_byte (abfd
, line_ptr
);
6381 lh
->line_base
= read_1_signed_byte (abfd
, line_ptr
);
6383 lh
->line_range
= read_1_byte (abfd
, line_ptr
);
6385 lh
->opcode_base
= read_1_byte (abfd
, line_ptr
);
6387 lh
->standard_opcode_lengths
6388 = xmalloc (lh
->opcode_base
* sizeof (lh
->standard_opcode_lengths
[0]));
6390 lh
->standard_opcode_lengths
[0] = 1; /* This should never be used anyway. */
6391 for (i
= 1; i
< lh
->opcode_base
; ++i
)
6393 lh
->standard_opcode_lengths
[i
] = read_1_byte (abfd
, line_ptr
);
6397 /* Read directory table. */
6398 while ((cur_dir
= read_string (abfd
, line_ptr
, &bytes_read
)) != NULL
)
6400 line_ptr
+= bytes_read
;
6401 add_include_dir (lh
, cur_dir
);
6403 line_ptr
+= bytes_read
;
6405 /* Read file name table. */
6406 while ((cur_file
= read_string (abfd
, line_ptr
, &bytes_read
)) != NULL
)
6408 unsigned int dir_index
, mod_time
, length
;
6410 line_ptr
+= bytes_read
;
6411 dir_index
= read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
6412 line_ptr
+= bytes_read
;
6413 mod_time
= read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
6414 line_ptr
+= bytes_read
;
6415 length
= read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
6416 line_ptr
+= bytes_read
;
6418 add_file_name (lh
, cur_file
, dir_index
, mod_time
, length
);
6420 line_ptr
+= bytes_read
;
6421 lh
->statement_program_start
= line_ptr
;
6423 if (line_ptr
> (dwarf2_per_objfile
->line_buffer
6424 + dwarf2_per_objfile
->line_size
))
6425 complaint (&symfile_complaints
,
6426 _("line number info header doesn't fit in `.debug_line' section"));
6428 discard_cleanups (back_to
);
6432 /* This function exists to work around a bug in certain compilers
6433 (particularly GCC 2.95), in which the first line number marker of a
6434 function does not show up until after the prologue, right before
6435 the second line number marker. This function shifts ADDRESS down
6436 to the beginning of the function if necessary, and is called on
6437 addresses passed to record_line. */
6440 check_cu_functions (CORE_ADDR address
, struct dwarf2_cu
*cu
)
6442 struct function_range
*fn
;
6444 /* Find the function_range containing address. */
6449 cu
->cached_fn
= cu
->first_fn
;
6453 if (fn
->lowpc
<= address
&& fn
->highpc
> address
)
6459 while (fn
&& fn
!= cu
->cached_fn
)
6460 if (fn
->lowpc
<= address
&& fn
->highpc
> address
)
6470 if (address
!= fn
->lowpc
)
6471 complaint (&symfile_complaints
,
6472 _("misplaced first line number at 0x%lx for '%s'"),
6473 (unsigned long) address
, fn
->name
);
6478 /* Decode the Line Number Program (LNP) for the given line_header
6479 structure and CU. The actual information extracted and the type
6480 of structures created from the LNP depends on the value of PST.
6482 1. If PST is NULL, then this procedure uses the data from the program
6483 to create all necessary symbol tables, and their linetables.
6484 The compilation directory of the file is passed in COMP_DIR,
6485 and must not be NULL.
6487 2. If PST is not NULL, this procedure reads the program to determine
6488 the list of files included by the unit represented by PST, and
6489 builds all the associated partial symbol tables. In this case,
6490 the value of COMP_DIR is ignored, and can thus be NULL (the COMP_DIR
6491 is not used to compute the full name of the symtab, and therefore
6492 omitting it when building the partial symtab does not introduce
6493 the potential for inconsistency - a partial symtab and its associated
6494 symbtab having a different fullname -). */
6497 dwarf_decode_lines (struct line_header
*lh
, char *comp_dir
, bfd
*abfd
,
6498 struct dwarf2_cu
*cu
, struct partial_symtab
*pst
)
6502 unsigned int bytes_read
;
6503 unsigned char op_code
, extended_op
, adj_opcode
;
6505 struct objfile
*objfile
= cu
->objfile
;
6506 const int decode_for_pst_p
= (pst
!= NULL
);
6508 baseaddr
= ANOFFSET (objfile
->section_offsets
, SECT_OFF_TEXT (objfile
));
6510 line_ptr
= lh
->statement_program_start
;
6511 line_end
= lh
->statement_program_end
;
6513 /* Read the statement sequences until there's nothing left. */
6514 while (line_ptr
< line_end
)
6516 /* state machine registers */
6517 CORE_ADDR address
= 0;
6518 unsigned int file
= 1;
6519 unsigned int line
= 1;
6520 unsigned int column
= 0;
6521 int is_stmt
= lh
->default_is_stmt
;
6522 int basic_block
= 0;
6523 int end_sequence
= 0;
6525 if (!decode_for_pst_p
&& lh
->num_file_names
>= file
)
6527 /* Start a subfile for the current file of the state machine. */
6528 /* lh->include_dirs and lh->file_names are 0-based, but the
6529 directory and file name numbers in the statement program
6531 struct file_entry
*fe
= &lh
->file_names
[file
- 1];
6535 dir
= lh
->include_dirs
[fe
->dir_index
- 1];
6538 dwarf2_start_subfile (fe
->name
, dir
);
6541 /* Decode the table. */
6542 while (!end_sequence
)
6544 op_code
= read_1_byte (abfd
, line_ptr
);
6547 if (op_code
>= lh
->opcode_base
)
6549 /* Special operand. */
6550 adj_opcode
= op_code
- lh
->opcode_base
;
6551 address
+= (adj_opcode
/ lh
->line_range
)
6552 * lh
->minimum_instruction_length
;
6553 line
+= lh
->line_base
+ (adj_opcode
% lh
->line_range
);
6554 lh
->file_names
[file
- 1].included_p
= 1;
6555 if (!decode_for_pst_p
)
6557 /* Append row to matrix using current values. */
6558 record_line (current_subfile
, line
,
6559 check_cu_functions (address
, cu
));
6563 else switch (op_code
)
6565 case DW_LNS_extended_op
:
6566 read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
6567 line_ptr
+= bytes_read
;
6568 extended_op
= read_1_byte (abfd
, line_ptr
);
6570 switch (extended_op
)
6572 case DW_LNE_end_sequence
:
6574 lh
->file_names
[file
- 1].included_p
= 1;
6575 if (!decode_for_pst_p
)
6576 record_line (current_subfile
, 0, address
);
6578 case DW_LNE_set_address
:
6579 address
= read_address (abfd
, line_ptr
, cu
, &bytes_read
);
6580 line_ptr
+= bytes_read
;
6581 address
+= baseaddr
;
6583 case DW_LNE_define_file
:
6586 unsigned int dir_index
, mod_time
, length
;
6588 cur_file
= read_string (abfd
, line_ptr
, &bytes_read
);
6589 line_ptr
+= bytes_read
;
6591 read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
6592 line_ptr
+= bytes_read
;
6594 read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
6595 line_ptr
+= bytes_read
;
6597 read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
6598 line_ptr
+= bytes_read
;
6599 add_file_name (lh
, cur_file
, dir_index
, mod_time
, length
);
6603 complaint (&symfile_complaints
,
6604 _("mangled .debug_line section"));
6609 lh
->file_names
[file
- 1].included_p
= 1;
6610 if (!decode_for_pst_p
)
6611 record_line (current_subfile
, line
,
6612 check_cu_functions (address
, cu
));
6615 case DW_LNS_advance_pc
:
6616 address
+= lh
->minimum_instruction_length
6617 * read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
6618 line_ptr
+= bytes_read
;
6620 case DW_LNS_advance_line
:
6621 line
+= read_signed_leb128 (abfd
, line_ptr
, &bytes_read
);
6622 line_ptr
+= bytes_read
;
6624 case DW_LNS_set_file
:
6626 /* The arrays lh->include_dirs and lh->file_names are
6627 0-based, but the directory and file name numbers in
6628 the statement program are 1-based. */
6629 struct file_entry
*fe
;
6632 file
= read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
6633 line_ptr
+= bytes_read
;
6634 fe
= &lh
->file_names
[file
- 1];
6636 dir
= lh
->include_dirs
[fe
->dir_index
- 1];
6639 if (!decode_for_pst_p
)
6640 dwarf2_start_subfile (fe
->name
, dir
);
6643 case DW_LNS_set_column
:
6644 column
= read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
6645 line_ptr
+= bytes_read
;
6647 case DW_LNS_negate_stmt
:
6648 is_stmt
= (!is_stmt
);
6650 case DW_LNS_set_basic_block
:
6653 /* Add to the address register of the state machine the
6654 address increment value corresponding to special opcode
6655 255. I.e., this value is scaled by the minimum
6656 instruction length since special opcode 255 would have
6657 scaled the the increment. */
6658 case DW_LNS_const_add_pc
:
6659 address
+= (lh
->minimum_instruction_length
6660 * ((255 - lh
->opcode_base
) / lh
->line_range
));
6662 case DW_LNS_fixed_advance_pc
:
6663 address
+= read_2_bytes (abfd
, line_ptr
);
6668 /* Unknown standard opcode, ignore it. */
6671 for (i
= 0; i
< lh
->standard_opcode_lengths
[op_code
]; i
++)
6673 (void) read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
6674 line_ptr
+= bytes_read
;
6681 if (decode_for_pst_p
)
6685 /* Now that we're done scanning the Line Header Program, we can
6686 create the psymtab of each included file. */
6687 for (file_index
= 0; file_index
< lh
->num_file_names
; file_index
++)
6688 if (lh
->file_names
[file_index
].included_p
== 1)
6690 const struct file_entry fe
= lh
->file_names
[file_index
];
6691 char *include_name
= fe
.name
;
6692 char *dir_name
= NULL
;
6693 char *pst_filename
= pst
->filename
;
6696 dir_name
= lh
->include_dirs
[fe
.dir_index
- 1];
6698 if (!IS_ABSOLUTE_PATH (include_name
) && dir_name
!= NULL
)
6700 include_name
= concat (dir_name
, SLASH_STRING
,
6701 include_name
, (char *)NULL
);
6702 make_cleanup (xfree
, include_name
);
6705 if (!IS_ABSOLUTE_PATH (pst_filename
) && pst
->dirname
!= NULL
)
6707 pst_filename
= concat (pst
->dirname
, SLASH_STRING
,
6708 pst_filename
, (char *)NULL
);
6709 make_cleanup (xfree
, pst_filename
);
6712 if (strcmp (include_name
, pst_filename
) != 0)
6713 dwarf2_create_include_psymtab (include_name
, pst
, objfile
);
6718 /* Start a subfile for DWARF. FILENAME is the name of the file and
6719 DIRNAME the name of the source directory which contains FILENAME
6720 or NULL if not known.
6721 This routine tries to keep line numbers from identical absolute and
6722 relative file names in a common subfile.
6724 Using the `list' example from the GDB testsuite, which resides in
6725 /srcdir and compiling it with Irix6.2 cc in /compdir using a filename
6726 of /srcdir/list0.c yields the following debugging information for list0.c:
6728 DW_AT_name: /srcdir/list0.c
6729 DW_AT_comp_dir: /compdir
6730 files.files[0].name: list0.h
6731 files.files[0].dir: /srcdir
6732 files.files[1].name: list0.c
6733 files.files[1].dir: /srcdir
6735 The line number information for list0.c has to end up in a single
6736 subfile, so that `break /srcdir/list0.c:1' works as expected. */
6739 dwarf2_start_subfile (char *filename
, char *dirname
)
6741 /* If the filename isn't absolute, try to match an existing subfile
6742 with the full pathname. */
6744 if (!IS_ABSOLUTE_PATH (filename
) && dirname
!= NULL
)
6746 struct subfile
*subfile
;
6747 char *fullname
= concat (dirname
, "/", filename
, (char *)NULL
);
6749 for (subfile
= subfiles
; subfile
; subfile
= subfile
->next
)
6751 if (FILENAME_CMP (subfile
->name
, fullname
) == 0)
6753 current_subfile
= subfile
;
6760 start_subfile (filename
, dirname
);
6764 var_decode_location (struct attribute
*attr
, struct symbol
*sym
,
6765 struct dwarf2_cu
*cu
)
6767 struct objfile
*objfile
= cu
->objfile
;
6768 struct comp_unit_head
*cu_header
= &cu
->header
;
6770 /* NOTE drow/2003-01-30: There used to be a comment and some special
6771 code here to turn a symbol with DW_AT_external and a
6772 SYMBOL_VALUE_ADDRESS of 0 into a LOC_UNRESOLVED symbol. This was
6773 necessary for platforms (maybe Alpha, certainly PowerPC GNU/Linux
6774 with some versions of binutils) where shared libraries could have
6775 relocations against symbols in their debug information - the
6776 minimal symbol would have the right address, but the debug info
6777 would not. It's no longer necessary, because we will explicitly
6778 apply relocations when we read in the debug information now. */
6780 /* A DW_AT_location attribute with no contents indicates that a
6781 variable has been optimized away. */
6782 if (attr_form_is_block (attr
) && DW_BLOCK (attr
)->size
== 0)
6784 SYMBOL_CLASS (sym
) = LOC_OPTIMIZED_OUT
;
6788 /* Handle one degenerate form of location expression specially, to
6789 preserve GDB's previous behavior when section offsets are
6790 specified. If this is just a DW_OP_addr then mark this symbol
6793 if (attr_form_is_block (attr
)
6794 && DW_BLOCK (attr
)->size
== 1 + cu_header
->addr_size
6795 && DW_BLOCK (attr
)->data
[0] == DW_OP_addr
)
6799 SYMBOL_VALUE_ADDRESS (sym
) =
6800 read_address (objfile
->obfd
, DW_BLOCK (attr
)->data
+ 1, cu
, &dummy
);
6801 fixup_symbol_section (sym
, objfile
);
6802 SYMBOL_VALUE_ADDRESS (sym
) += ANOFFSET (objfile
->section_offsets
,
6803 SYMBOL_SECTION (sym
));
6804 SYMBOL_CLASS (sym
) = LOC_STATIC
;
6808 /* NOTE drow/2002-01-30: It might be worthwhile to have a static
6809 expression evaluator, and use LOC_COMPUTED only when necessary
6810 (i.e. when the value of a register or memory location is
6811 referenced, or a thread-local block, etc.). Then again, it might
6812 not be worthwhile. I'm assuming that it isn't unless performance
6813 or memory numbers show me otherwise. */
6815 dwarf2_symbol_mark_computed (attr
, sym
, cu
);
6816 SYMBOL_CLASS (sym
) = LOC_COMPUTED
;
6819 /* Given a pointer to a DWARF information entry, figure out if we need
6820 to make a symbol table entry for it, and if so, create a new entry
6821 and return a pointer to it.
6822 If TYPE is NULL, determine symbol type from the die, otherwise
6823 used the passed type. */
6825 static struct symbol
*
6826 new_symbol (struct die_info
*die
, struct type
*type
, struct dwarf2_cu
*cu
)
6828 struct objfile
*objfile
= cu
->objfile
;
6829 struct symbol
*sym
= NULL
;
6831 struct attribute
*attr
= NULL
;
6832 struct attribute
*attr2
= NULL
;
6835 baseaddr
= ANOFFSET (objfile
->section_offsets
, SECT_OFF_TEXT (objfile
));
6837 if (die
->tag
!= DW_TAG_namespace
)
6838 name
= dwarf2_linkage_name (die
, cu
);
6840 name
= TYPE_NAME (type
);
6844 sym
= (struct symbol
*) obstack_alloc (&objfile
->objfile_obstack
,
6845 sizeof (struct symbol
));
6846 OBJSTAT (objfile
, n_syms
++);
6847 memset (sym
, 0, sizeof (struct symbol
));
6849 /* Cache this symbol's name and the name's demangled form (if any). */
6850 SYMBOL_LANGUAGE (sym
) = cu
->language
;
6851 SYMBOL_SET_NAMES (sym
, name
, strlen (name
), objfile
);
6853 /* Default assumptions.
6854 Use the passed type or decode it from the die. */
6855 SYMBOL_DOMAIN (sym
) = VAR_DOMAIN
;
6856 SYMBOL_CLASS (sym
) = LOC_STATIC
;
6858 SYMBOL_TYPE (sym
) = type
;
6860 SYMBOL_TYPE (sym
) = die_type (die
, cu
);
6861 attr
= dwarf2_attr (die
, DW_AT_decl_line
, cu
);
6864 SYMBOL_LINE (sym
) = DW_UNSND (attr
);
6869 attr
= dwarf2_attr (die
, DW_AT_low_pc
, cu
);
6872 SYMBOL_VALUE_ADDRESS (sym
) = DW_ADDR (attr
) + baseaddr
;
6874 SYMBOL_CLASS (sym
) = LOC_LABEL
;
6876 case DW_TAG_subprogram
:
6877 /* SYMBOL_BLOCK_VALUE (sym) will be filled in later by
6879 SYMBOL_CLASS (sym
) = LOC_BLOCK
;
6880 attr2
= dwarf2_attr (die
, DW_AT_external
, cu
);
6881 if (attr2
&& (DW_UNSND (attr2
) != 0))
6883 add_symbol_to_list (sym
, &global_symbols
);
6887 add_symbol_to_list (sym
, cu
->list_in_scope
);
6890 case DW_TAG_variable
:
6891 /* Compilation with minimal debug info may result in variables
6892 with missing type entries. Change the misleading `void' type
6893 to something sensible. */
6894 if (TYPE_CODE (SYMBOL_TYPE (sym
)) == TYPE_CODE_VOID
)
6895 SYMBOL_TYPE (sym
) = init_type (TYPE_CODE_INT
,
6896 TARGET_INT_BIT
/ HOST_CHAR_BIT
, 0,
6897 "<variable, no debug info>",
6899 attr
= dwarf2_attr (die
, DW_AT_const_value
, cu
);
6902 dwarf2_const_value (attr
, sym
, cu
);
6903 attr2
= dwarf2_attr (die
, DW_AT_external
, cu
);
6904 if (attr2
&& (DW_UNSND (attr2
) != 0))
6905 add_symbol_to_list (sym
, &global_symbols
);
6907 add_symbol_to_list (sym
, cu
->list_in_scope
);
6910 attr
= dwarf2_attr (die
, DW_AT_location
, cu
);
6913 var_decode_location (attr
, sym
, cu
);
6914 attr2
= dwarf2_attr (die
, DW_AT_external
, cu
);
6915 if (attr2
&& (DW_UNSND (attr2
) != 0))
6916 add_symbol_to_list (sym
, &global_symbols
);
6918 add_symbol_to_list (sym
, cu
->list_in_scope
);
6922 /* We do not know the address of this symbol.
6923 If it is an external symbol and we have type information
6924 for it, enter the symbol as a LOC_UNRESOLVED symbol.
6925 The address of the variable will then be determined from
6926 the minimal symbol table whenever the variable is
6928 attr2
= dwarf2_attr (die
, DW_AT_external
, cu
);
6929 if (attr2
&& (DW_UNSND (attr2
) != 0)
6930 && dwarf2_attr (die
, DW_AT_type
, cu
) != NULL
)
6932 SYMBOL_CLASS (sym
) = LOC_UNRESOLVED
;
6933 add_symbol_to_list (sym
, &global_symbols
);
6937 case DW_TAG_formal_parameter
:
6938 attr
= dwarf2_attr (die
, DW_AT_location
, cu
);
6941 var_decode_location (attr
, sym
, cu
);
6942 /* FIXME drow/2003-07-31: Is LOC_COMPUTED_ARG necessary? */
6943 if (SYMBOL_CLASS (sym
) == LOC_COMPUTED
)
6944 SYMBOL_CLASS (sym
) = LOC_COMPUTED_ARG
;
6946 attr
= dwarf2_attr (die
, DW_AT_const_value
, cu
);
6949 dwarf2_const_value (attr
, sym
, cu
);
6951 add_symbol_to_list (sym
, cu
->list_in_scope
);
6953 case DW_TAG_unspecified_parameters
:
6954 /* From varargs functions; gdb doesn't seem to have any
6955 interest in this information, so just ignore it for now.
6958 case DW_TAG_class_type
:
6959 case DW_TAG_structure_type
:
6960 case DW_TAG_union_type
:
6961 case DW_TAG_enumeration_type
:
6962 SYMBOL_CLASS (sym
) = LOC_TYPEDEF
;
6963 SYMBOL_DOMAIN (sym
) = STRUCT_DOMAIN
;
6965 /* Make sure that the symbol includes appropriate enclosing
6966 classes/namespaces in its name. These are calculated in
6967 read_structure_type, and the correct name is saved in
6970 if (cu
->language
== language_cplus
6971 || cu
->language
== language_java
)
6973 struct type
*type
= SYMBOL_TYPE (sym
);
6975 if (TYPE_TAG_NAME (type
) != NULL
)
6977 /* FIXME: carlton/2003-11-10: Should this use
6978 SYMBOL_SET_NAMES instead? (The same problem also
6979 arises further down in this function.) */
6980 /* The type's name is already allocated along with
6981 this objfile, so we don't need to duplicate it
6983 SYMBOL_LINKAGE_NAME (sym
) = TYPE_TAG_NAME (type
);
6988 /* NOTE: carlton/2003-11-10: C++ and Java class symbols shouldn't
6989 really ever be static objects: otherwise, if you try
6990 to, say, break of a class's method and you're in a file
6991 which doesn't mention that class, it won't work unless
6992 the check for all static symbols in lookup_symbol_aux
6993 saves you. See the OtherFileClass tests in
6994 gdb.c++/namespace.exp. */
6996 struct pending
**list_to_add
;
6998 list_to_add
= (cu
->list_in_scope
== &file_symbols
6999 && (cu
->language
== language_cplus
7000 || cu
->language
== language_java
)
7001 ? &global_symbols
: cu
->list_in_scope
);
7003 add_symbol_to_list (sym
, list_to_add
);
7005 /* The semantics of C++ state that "struct foo { ... }" also
7006 defines a typedef for "foo". A Java class declaration also
7007 defines a typedef for the class. Synthesize a typedef symbol
7008 so that "ptype foo" works as expected. */
7009 if (cu
->language
== language_cplus
7010 || cu
->language
== language_java
)
7012 struct symbol
*typedef_sym
= (struct symbol
*)
7013 obstack_alloc (&objfile
->objfile_obstack
,
7014 sizeof (struct symbol
));
7015 *typedef_sym
= *sym
;
7016 SYMBOL_DOMAIN (typedef_sym
) = VAR_DOMAIN
;
7017 /* The symbol's name is already allocated along with
7018 this objfile, so we don't need to duplicate it for
7020 if (TYPE_NAME (SYMBOL_TYPE (sym
)) == 0)
7021 TYPE_NAME (SYMBOL_TYPE (sym
)) = SYMBOL_SEARCH_NAME (sym
);
7022 add_symbol_to_list (typedef_sym
, list_to_add
);
7026 case DW_TAG_typedef
:
7027 if (processing_has_namespace_info
7028 && processing_current_prefix
[0] != '\0')
7030 SYMBOL_LINKAGE_NAME (sym
) = typename_concat (&objfile
->objfile_obstack
,
7031 processing_current_prefix
,
7034 SYMBOL_CLASS (sym
) = LOC_TYPEDEF
;
7035 SYMBOL_DOMAIN (sym
) = VAR_DOMAIN
;
7036 add_symbol_to_list (sym
, cu
->list_in_scope
);
7038 case DW_TAG_base_type
:
7039 case DW_TAG_subrange_type
:
7040 SYMBOL_CLASS (sym
) = LOC_TYPEDEF
;
7041 SYMBOL_DOMAIN (sym
) = VAR_DOMAIN
;
7042 add_symbol_to_list (sym
, cu
->list_in_scope
);
7044 case DW_TAG_enumerator
:
7045 if (processing_has_namespace_info
7046 && processing_current_prefix
[0] != '\0')
7048 SYMBOL_LINKAGE_NAME (sym
) = typename_concat (&objfile
->objfile_obstack
,
7049 processing_current_prefix
,
7052 attr
= dwarf2_attr (die
, DW_AT_const_value
, cu
);
7055 dwarf2_const_value (attr
, sym
, cu
);
7058 /* NOTE: carlton/2003-11-10: See comment above in the
7059 DW_TAG_class_type, etc. block. */
7061 struct pending
**list_to_add
;
7063 list_to_add
= (cu
->list_in_scope
== &file_symbols
7064 && (cu
->language
== language_cplus
7065 || cu
->language
== language_java
)
7066 ? &global_symbols
: cu
->list_in_scope
);
7068 add_symbol_to_list (sym
, list_to_add
);
7071 case DW_TAG_namespace
:
7072 SYMBOL_CLASS (sym
) = LOC_TYPEDEF
;
7073 add_symbol_to_list (sym
, &global_symbols
);
7076 /* Not a tag we recognize. Hopefully we aren't processing
7077 trash data, but since we must specifically ignore things
7078 we don't recognize, there is nothing else we should do at
7080 complaint (&symfile_complaints
, _("unsupported tag: '%s'"),
7081 dwarf_tag_name (die
->tag
));
7088 /* Copy constant value from an attribute to a symbol. */
7091 dwarf2_const_value (struct attribute
*attr
, struct symbol
*sym
,
7092 struct dwarf2_cu
*cu
)
7094 struct objfile
*objfile
= cu
->objfile
;
7095 struct comp_unit_head
*cu_header
= &cu
->header
;
7096 struct dwarf_block
*blk
;
7101 if (TYPE_LENGTH (SYMBOL_TYPE (sym
)) != cu_header
->addr_size
)
7102 dwarf2_const_value_length_mismatch_complaint (DEPRECATED_SYMBOL_NAME (sym
),
7103 cu_header
->addr_size
,
7104 TYPE_LENGTH (SYMBOL_TYPE
7106 SYMBOL_VALUE_BYTES (sym
) =
7107 obstack_alloc (&objfile
->objfile_obstack
, cu_header
->addr_size
);
7108 /* NOTE: cagney/2003-05-09: In-lined store_address call with
7109 it's body - store_unsigned_integer. */
7110 store_unsigned_integer (SYMBOL_VALUE_BYTES (sym
), cu_header
->addr_size
,
7112 SYMBOL_CLASS (sym
) = LOC_CONST_BYTES
;
7114 case DW_FORM_block1
:
7115 case DW_FORM_block2
:
7116 case DW_FORM_block4
:
7118 blk
= DW_BLOCK (attr
);
7119 if (TYPE_LENGTH (SYMBOL_TYPE (sym
)) != blk
->size
)
7120 dwarf2_const_value_length_mismatch_complaint (DEPRECATED_SYMBOL_NAME (sym
),
7122 TYPE_LENGTH (SYMBOL_TYPE
7124 SYMBOL_VALUE_BYTES (sym
) =
7125 obstack_alloc (&objfile
->objfile_obstack
, blk
->size
);
7126 memcpy (SYMBOL_VALUE_BYTES (sym
), blk
->data
, blk
->size
);
7127 SYMBOL_CLASS (sym
) = LOC_CONST_BYTES
;
7130 /* The DW_AT_const_value attributes are supposed to carry the
7131 symbol's value "represented as it would be on the target
7132 architecture." By the time we get here, it's already been
7133 converted to host endianness, so we just need to sign- or
7134 zero-extend it as appropriate. */
7136 dwarf2_const_value_data (attr
, sym
, 8);
7139 dwarf2_const_value_data (attr
, sym
, 16);
7142 dwarf2_const_value_data (attr
, sym
, 32);
7145 dwarf2_const_value_data (attr
, sym
, 64);
7149 SYMBOL_VALUE (sym
) = DW_SND (attr
);
7150 SYMBOL_CLASS (sym
) = LOC_CONST
;
7154 SYMBOL_VALUE (sym
) = DW_UNSND (attr
);
7155 SYMBOL_CLASS (sym
) = LOC_CONST
;
7159 complaint (&symfile_complaints
,
7160 _("unsupported const value attribute form: '%s'"),
7161 dwarf_form_name (attr
->form
));
7162 SYMBOL_VALUE (sym
) = 0;
7163 SYMBOL_CLASS (sym
) = LOC_CONST
;
7169 /* Given an attr with a DW_FORM_dataN value in host byte order, sign-
7170 or zero-extend it as appropriate for the symbol's type. */
7172 dwarf2_const_value_data (struct attribute
*attr
,
7176 LONGEST l
= DW_UNSND (attr
);
7178 if (bits
< sizeof (l
) * 8)
7180 if (TYPE_UNSIGNED (SYMBOL_TYPE (sym
)))
7181 l
&= ((LONGEST
) 1 << bits
) - 1;
7183 l
= (l
<< (sizeof (l
) * 8 - bits
)) >> (sizeof (l
) * 8 - bits
);
7186 SYMBOL_VALUE (sym
) = l
;
7187 SYMBOL_CLASS (sym
) = LOC_CONST
;
7191 /* Return the type of the die in question using its DW_AT_type attribute. */
7193 static struct type
*
7194 die_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
7197 struct attribute
*type_attr
;
7198 struct die_info
*type_die
;
7200 type_attr
= dwarf2_attr (die
, DW_AT_type
, cu
);
7203 /* A missing DW_AT_type represents a void type. */
7204 return dwarf2_fundamental_type (cu
->objfile
, FT_VOID
, cu
);
7207 type_die
= follow_die_ref (die
, type_attr
, cu
);
7209 type
= tag_type_to_type (type_die
, cu
);
7212 dump_die (type_die
);
7213 error (_("Dwarf Error: Problem turning type die at offset into gdb type [in module %s]"),
7219 /* Return the containing type of the die in question using its
7220 DW_AT_containing_type attribute. */
7222 static struct type
*
7223 die_containing_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
7225 struct type
*type
= NULL
;
7226 struct attribute
*type_attr
;
7227 struct die_info
*type_die
= NULL
;
7229 type_attr
= dwarf2_attr (die
, DW_AT_containing_type
, cu
);
7232 type_die
= follow_die_ref (die
, type_attr
, cu
);
7233 type
= tag_type_to_type (type_die
, cu
);
7238 dump_die (type_die
);
7239 error (_("Dwarf Error: Problem turning containing type into gdb type [in module %s]"),
7245 static struct type
*
7246 tag_type_to_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
7254 read_type_die (die
, cu
);
7258 error (_("Dwarf Error: Cannot find type of die [in module %s]"),
7266 read_type_die (struct die_info
*die
, struct dwarf2_cu
*cu
)
7268 char *prefix
= determine_prefix (die
, cu
);
7269 const char *old_prefix
= processing_current_prefix
;
7270 struct cleanup
*back_to
= make_cleanup (xfree
, prefix
);
7271 processing_current_prefix
= prefix
;
7275 case DW_TAG_class_type
:
7276 case DW_TAG_structure_type
:
7277 case DW_TAG_union_type
:
7278 read_structure_type (die
, cu
);
7280 case DW_TAG_enumeration_type
:
7281 read_enumeration_type (die
, cu
);
7283 case DW_TAG_subprogram
:
7284 case DW_TAG_subroutine_type
:
7285 read_subroutine_type (die
, cu
);
7287 case DW_TAG_array_type
:
7288 read_array_type (die
, cu
);
7290 case DW_TAG_pointer_type
:
7291 read_tag_pointer_type (die
, cu
);
7293 case DW_TAG_ptr_to_member_type
:
7294 read_tag_ptr_to_member_type (die
, cu
);
7296 case DW_TAG_reference_type
:
7297 read_tag_reference_type (die
, cu
);
7299 case DW_TAG_const_type
:
7300 read_tag_const_type (die
, cu
);
7302 case DW_TAG_volatile_type
:
7303 read_tag_volatile_type (die
, cu
);
7305 case DW_TAG_string_type
:
7306 read_tag_string_type (die
, cu
);
7308 case DW_TAG_typedef
:
7309 read_typedef (die
, cu
);
7311 case DW_TAG_subrange_type
:
7312 read_subrange_type (die
, cu
);
7314 case DW_TAG_base_type
:
7315 read_base_type (die
, cu
);
7318 complaint (&symfile_complaints
, _("unexepected tag in read_type_die: '%s'"),
7319 dwarf_tag_name (die
->tag
));
7323 processing_current_prefix
= old_prefix
;
7324 do_cleanups (back_to
);
7327 /* Return the name of the namespace/class that DIE is defined within,
7328 or "" if we can't tell. The caller should xfree the result. */
7330 /* NOTE: carlton/2004-01-23: See read_func_scope (and the comment
7331 therein) for an example of how to use this function to deal with
7332 DW_AT_specification. */
7335 determine_prefix (struct die_info
*die
, struct dwarf2_cu
*cu
)
7337 struct die_info
*parent
;
7339 if (cu
->language
!= language_cplus
7340 && cu
->language
!= language_java
)
7343 parent
= die
->parent
;
7347 return xstrdup ("");
7351 switch (parent
->tag
) {
7352 case DW_TAG_namespace
:
7354 /* FIXME: carlton/2004-03-05: Should I follow extension dies
7355 before doing this check? */
7356 if (parent
->type
!= NULL
&& TYPE_TAG_NAME (parent
->type
) != NULL
)
7358 return xstrdup (TYPE_TAG_NAME (parent
->type
));
7363 char *parent_prefix
= determine_prefix (parent
, cu
);
7364 char *retval
= typename_concat (NULL
, parent_prefix
,
7365 namespace_name (parent
, &dummy
,
7368 xfree (parent_prefix
);
7373 case DW_TAG_class_type
:
7374 case DW_TAG_structure_type
:
7376 if (parent
->type
!= NULL
&& TYPE_TAG_NAME (parent
->type
) != NULL
)
7378 return xstrdup (TYPE_TAG_NAME (parent
->type
));
7382 const char *old_prefix
= processing_current_prefix
;
7383 char *new_prefix
= determine_prefix (parent
, cu
);
7386 processing_current_prefix
= new_prefix
;
7387 retval
= determine_class_name (parent
, cu
);
7388 processing_current_prefix
= old_prefix
;
7395 return determine_prefix (parent
, cu
);
7400 /* Return a newly-allocated string formed by concatenating PREFIX and
7401 SUFFIX with appropriate separator. If PREFIX or SUFFIX is NULL or empty, then
7402 simply copy the SUFFIX or PREFIX, respectively. If OBS is non-null,
7403 perform an obconcat, otherwise allocate storage for the result. The CU argument
7404 is used to determine the language and hence, the appropriate separator. */
7406 #define MAX_SEP_LEN 2 /* sizeof ("::") */
7409 typename_concat (struct obstack
*obs
, const char *prefix
, const char *suffix
,
7410 struct dwarf2_cu
*cu
)
7414 if (suffix
== NULL
|| suffix
[0] == '\0' || prefix
== NULL
|| prefix
[0] == '\0')
7416 else if (cu
->language
== language_java
)
7423 char *retval
= xmalloc (strlen (prefix
) + MAX_SEP_LEN
+ strlen (suffix
) + 1);
7428 strcpy (retval
, prefix
);
7429 strcat (retval
, sep
);
7432 strcat (retval
, suffix
);
7438 /* We have an obstack. */
7439 return obconcat (obs
, prefix
, sep
, suffix
);
7443 static struct type
*
7444 dwarf_base_type (int encoding
, int size
, struct dwarf2_cu
*cu
)
7446 struct objfile
*objfile
= cu
->objfile
;
7448 /* FIXME - this should not produce a new (struct type *)
7449 every time. It should cache base types. */
7453 case DW_ATE_address
:
7454 type
= dwarf2_fundamental_type (objfile
, FT_VOID
, cu
);
7456 case DW_ATE_boolean
:
7457 type
= dwarf2_fundamental_type (objfile
, FT_BOOLEAN
, cu
);
7459 case DW_ATE_complex_float
:
7462 type
= dwarf2_fundamental_type (objfile
, FT_DBL_PREC_COMPLEX
, cu
);
7466 type
= dwarf2_fundamental_type (objfile
, FT_COMPLEX
, cu
);
7472 type
= dwarf2_fundamental_type (objfile
, FT_DBL_PREC_FLOAT
, cu
);
7476 type
= dwarf2_fundamental_type (objfile
, FT_FLOAT
, cu
);
7483 type
= dwarf2_fundamental_type (objfile
, FT_SIGNED_CHAR
, cu
);
7486 type
= dwarf2_fundamental_type (objfile
, FT_SIGNED_SHORT
, cu
);
7490 type
= dwarf2_fundamental_type (objfile
, FT_SIGNED_INTEGER
, cu
);
7494 case DW_ATE_signed_char
:
7495 type
= dwarf2_fundamental_type (objfile
, FT_SIGNED_CHAR
, cu
);
7497 case DW_ATE_unsigned
:
7501 type
= dwarf2_fundamental_type (objfile
, FT_UNSIGNED_CHAR
, cu
);
7504 type
= dwarf2_fundamental_type (objfile
, FT_UNSIGNED_SHORT
, cu
);
7508 type
= dwarf2_fundamental_type (objfile
, FT_UNSIGNED_INTEGER
, cu
);
7512 case DW_ATE_unsigned_char
:
7513 type
= dwarf2_fundamental_type (objfile
, FT_UNSIGNED_CHAR
, cu
);
7516 type
= dwarf2_fundamental_type (objfile
, FT_SIGNED_INTEGER
, cu
);
7523 copy_die (struct die_info
*old_die
)
7525 struct die_info
*new_die
;
7528 new_die
= (struct die_info
*) xmalloc (sizeof (struct die_info
));
7529 memset (new_die
, 0, sizeof (struct die_info
));
7531 new_die
->tag
= old_die
->tag
;
7532 new_die
->has_children
= old_die
->has_children
;
7533 new_die
->abbrev
= old_die
->abbrev
;
7534 new_die
->offset
= old_die
->offset
;
7535 new_die
->type
= NULL
;
7537 num_attrs
= old_die
->num_attrs
;
7538 new_die
->num_attrs
= num_attrs
;
7539 new_die
->attrs
= (struct attribute
*)
7540 xmalloc (num_attrs
* sizeof (struct attribute
));
7542 for (i
= 0; i
< old_die
->num_attrs
; ++i
)
7544 new_die
->attrs
[i
].name
= old_die
->attrs
[i
].name
;
7545 new_die
->attrs
[i
].form
= old_die
->attrs
[i
].form
;
7546 new_die
->attrs
[i
].u
.addr
= old_die
->attrs
[i
].u
.addr
;
7549 new_die
->next
= NULL
;
7554 /* Return sibling of die, NULL if no sibling. */
7556 static struct die_info
*
7557 sibling_die (struct die_info
*die
)
7559 return die
->sibling
;
7562 /* Get linkage name of a die, return NULL if not found. */
7565 dwarf2_linkage_name (struct die_info
*die
, struct dwarf2_cu
*cu
)
7567 struct attribute
*attr
;
7569 attr
= dwarf2_attr (die
, DW_AT_MIPS_linkage_name
, cu
);
7570 if (attr
&& DW_STRING (attr
))
7571 return DW_STRING (attr
);
7572 attr
= dwarf2_attr (die
, DW_AT_name
, cu
);
7573 if (attr
&& DW_STRING (attr
))
7574 return DW_STRING (attr
);
7578 /* Get name of a die, return NULL if not found. */
7581 dwarf2_name (struct die_info
*die
, struct dwarf2_cu
*cu
)
7583 struct attribute
*attr
;
7585 attr
= dwarf2_attr (die
, DW_AT_name
, cu
);
7586 if (attr
&& DW_STRING (attr
))
7587 return DW_STRING (attr
);
7591 /* Return the die that this die in an extension of, or NULL if there
7594 static struct die_info
*
7595 dwarf2_extension (struct die_info
*die
, struct dwarf2_cu
*cu
)
7597 struct attribute
*attr
;
7599 attr
= dwarf2_attr (die
, DW_AT_extension
, cu
);
7603 return follow_die_ref (die
, attr
, cu
);
7606 /* Convert a DIE tag into its string name. */
7609 dwarf_tag_name (unsigned tag
)
7613 case DW_TAG_padding
:
7614 return "DW_TAG_padding";
7615 case DW_TAG_array_type
:
7616 return "DW_TAG_array_type";
7617 case DW_TAG_class_type
:
7618 return "DW_TAG_class_type";
7619 case DW_TAG_entry_point
:
7620 return "DW_TAG_entry_point";
7621 case DW_TAG_enumeration_type
:
7622 return "DW_TAG_enumeration_type";
7623 case DW_TAG_formal_parameter
:
7624 return "DW_TAG_formal_parameter";
7625 case DW_TAG_imported_declaration
:
7626 return "DW_TAG_imported_declaration";
7628 return "DW_TAG_label";
7629 case DW_TAG_lexical_block
:
7630 return "DW_TAG_lexical_block";
7632 return "DW_TAG_member";
7633 case DW_TAG_pointer_type
:
7634 return "DW_TAG_pointer_type";
7635 case DW_TAG_reference_type
:
7636 return "DW_TAG_reference_type";
7637 case DW_TAG_compile_unit
:
7638 return "DW_TAG_compile_unit";
7639 case DW_TAG_string_type
:
7640 return "DW_TAG_string_type";
7641 case DW_TAG_structure_type
:
7642 return "DW_TAG_structure_type";
7643 case DW_TAG_subroutine_type
:
7644 return "DW_TAG_subroutine_type";
7645 case DW_TAG_typedef
:
7646 return "DW_TAG_typedef";
7647 case DW_TAG_union_type
:
7648 return "DW_TAG_union_type";
7649 case DW_TAG_unspecified_parameters
:
7650 return "DW_TAG_unspecified_parameters";
7651 case DW_TAG_variant
:
7652 return "DW_TAG_variant";
7653 case DW_TAG_common_block
:
7654 return "DW_TAG_common_block";
7655 case DW_TAG_common_inclusion
:
7656 return "DW_TAG_common_inclusion";
7657 case DW_TAG_inheritance
:
7658 return "DW_TAG_inheritance";
7659 case DW_TAG_inlined_subroutine
:
7660 return "DW_TAG_inlined_subroutine";
7662 return "DW_TAG_module";
7663 case DW_TAG_ptr_to_member_type
:
7664 return "DW_TAG_ptr_to_member_type";
7665 case DW_TAG_set_type
:
7666 return "DW_TAG_set_type";
7667 case DW_TAG_subrange_type
:
7668 return "DW_TAG_subrange_type";
7669 case DW_TAG_with_stmt
:
7670 return "DW_TAG_with_stmt";
7671 case DW_TAG_access_declaration
:
7672 return "DW_TAG_access_declaration";
7673 case DW_TAG_base_type
:
7674 return "DW_TAG_base_type";
7675 case DW_TAG_catch_block
:
7676 return "DW_TAG_catch_block";
7677 case DW_TAG_const_type
:
7678 return "DW_TAG_const_type";
7679 case DW_TAG_constant
:
7680 return "DW_TAG_constant";
7681 case DW_TAG_enumerator
:
7682 return "DW_TAG_enumerator";
7683 case DW_TAG_file_type
:
7684 return "DW_TAG_file_type";
7686 return "DW_TAG_friend";
7687 case DW_TAG_namelist
:
7688 return "DW_TAG_namelist";
7689 case DW_TAG_namelist_item
:
7690 return "DW_TAG_namelist_item";
7691 case DW_TAG_packed_type
:
7692 return "DW_TAG_packed_type";
7693 case DW_TAG_subprogram
:
7694 return "DW_TAG_subprogram";
7695 case DW_TAG_template_type_param
:
7696 return "DW_TAG_template_type_param";
7697 case DW_TAG_template_value_param
:
7698 return "DW_TAG_template_value_param";
7699 case DW_TAG_thrown_type
:
7700 return "DW_TAG_thrown_type";
7701 case DW_TAG_try_block
:
7702 return "DW_TAG_try_block";
7703 case DW_TAG_variant_part
:
7704 return "DW_TAG_variant_part";
7705 case DW_TAG_variable
:
7706 return "DW_TAG_variable";
7707 case DW_TAG_volatile_type
:
7708 return "DW_TAG_volatile_type";
7709 case DW_TAG_dwarf_procedure
:
7710 return "DW_TAG_dwarf_procedure";
7711 case DW_TAG_restrict_type
:
7712 return "DW_TAG_restrict_type";
7713 case DW_TAG_interface_type
:
7714 return "DW_TAG_interface_type";
7715 case DW_TAG_namespace
:
7716 return "DW_TAG_namespace";
7717 case DW_TAG_imported_module
:
7718 return "DW_TAG_imported_module";
7719 case DW_TAG_unspecified_type
:
7720 return "DW_TAG_unspecified_type";
7721 case DW_TAG_partial_unit
:
7722 return "DW_TAG_partial_unit";
7723 case DW_TAG_imported_unit
:
7724 return "DW_TAG_imported_unit";
7725 case DW_TAG_MIPS_loop
:
7726 return "DW_TAG_MIPS_loop";
7727 case DW_TAG_format_label
:
7728 return "DW_TAG_format_label";
7729 case DW_TAG_function_template
:
7730 return "DW_TAG_function_template";
7731 case DW_TAG_class_template
:
7732 return "DW_TAG_class_template";
7734 return "DW_TAG_<unknown>";
7738 /* Convert a DWARF attribute code into its string name. */
7741 dwarf_attr_name (unsigned attr
)
7746 return "DW_AT_sibling";
7747 case DW_AT_location
:
7748 return "DW_AT_location";
7750 return "DW_AT_name";
7751 case DW_AT_ordering
:
7752 return "DW_AT_ordering";
7753 case DW_AT_subscr_data
:
7754 return "DW_AT_subscr_data";
7755 case DW_AT_byte_size
:
7756 return "DW_AT_byte_size";
7757 case DW_AT_bit_offset
:
7758 return "DW_AT_bit_offset";
7759 case DW_AT_bit_size
:
7760 return "DW_AT_bit_size";
7761 case DW_AT_element_list
:
7762 return "DW_AT_element_list";
7763 case DW_AT_stmt_list
:
7764 return "DW_AT_stmt_list";
7766 return "DW_AT_low_pc";
7768 return "DW_AT_high_pc";
7769 case DW_AT_language
:
7770 return "DW_AT_language";
7772 return "DW_AT_member";
7774 return "DW_AT_discr";
7775 case DW_AT_discr_value
:
7776 return "DW_AT_discr_value";
7777 case DW_AT_visibility
:
7778 return "DW_AT_visibility";
7780 return "DW_AT_import";
7781 case DW_AT_string_length
:
7782 return "DW_AT_string_length";
7783 case DW_AT_common_reference
:
7784 return "DW_AT_common_reference";
7785 case DW_AT_comp_dir
:
7786 return "DW_AT_comp_dir";
7787 case DW_AT_const_value
:
7788 return "DW_AT_const_value";
7789 case DW_AT_containing_type
:
7790 return "DW_AT_containing_type";
7791 case DW_AT_default_value
:
7792 return "DW_AT_default_value";
7794 return "DW_AT_inline";
7795 case DW_AT_is_optional
:
7796 return "DW_AT_is_optional";
7797 case DW_AT_lower_bound
:
7798 return "DW_AT_lower_bound";
7799 case DW_AT_producer
:
7800 return "DW_AT_producer";
7801 case DW_AT_prototyped
:
7802 return "DW_AT_prototyped";
7803 case DW_AT_return_addr
:
7804 return "DW_AT_return_addr";
7805 case DW_AT_start_scope
:
7806 return "DW_AT_start_scope";
7807 case DW_AT_stride_size
:
7808 return "DW_AT_stride_size";
7809 case DW_AT_upper_bound
:
7810 return "DW_AT_upper_bound";
7811 case DW_AT_abstract_origin
:
7812 return "DW_AT_abstract_origin";
7813 case DW_AT_accessibility
:
7814 return "DW_AT_accessibility";
7815 case DW_AT_address_class
:
7816 return "DW_AT_address_class";
7817 case DW_AT_artificial
:
7818 return "DW_AT_artificial";
7819 case DW_AT_base_types
:
7820 return "DW_AT_base_types";
7821 case DW_AT_calling_convention
:
7822 return "DW_AT_calling_convention";
7824 return "DW_AT_count";
7825 case DW_AT_data_member_location
:
7826 return "DW_AT_data_member_location";
7827 case DW_AT_decl_column
:
7828 return "DW_AT_decl_column";
7829 case DW_AT_decl_file
:
7830 return "DW_AT_decl_file";
7831 case DW_AT_decl_line
:
7832 return "DW_AT_decl_line";
7833 case DW_AT_declaration
:
7834 return "DW_AT_declaration";
7835 case DW_AT_discr_list
:
7836 return "DW_AT_discr_list";
7837 case DW_AT_encoding
:
7838 return "DW_AT_encoding";
7839 case DW_AT_external
:
7840 return "DW_AT_external";
7841 case DW_AT_frame_base
:
7842 return "DW_AT_frame_base";
7844 return "DW_AT_friend";
7845 case DW_AT_identifier_case
:
7846 return "DW_AT_identifier_case";
7847 case DW_AT_macro_info
:
7848 return "DW_AT_macro_info";
7849 case DW_AT_namelist_items
:
7850 return "DW_AT_namelist_items";
7851 case DW_AT_priority
:
7852 return "DW_AT_priority";
7854 return "DW_AT_segment";
7855 case DW_AT_specification
:
7856 return "DW_AT_specification";
7857 case DW_AT_static_link
:
7858 return "DW_AT_static_link";
7860 return "DW_AT_type";
7861 case DW_AT_use_location
:
7862 return "DW_AT_use_location";
7863 case DW_AT_variable_parameter
:
7864 return "DW_AT_variable_parameter";
7865 case DW_AT_virtuality
:
7866 return "DW_AT_virtuality";
7867 case DW_AT_vtable_elem_location
:
7868 return "DW_AT_vtable_elem_location";
7869 case DW_AT_allocated
:
7870 return "DW_AT_allocated";
7871 case DW_AT_associated
:
7872 return "DW_AT_associated";
7873 case DW_AT_data_location
:
7874 return "DW_AT_data_location";
7876 return "DW_AT_stride";
7877 case DW_AT_entry_pc
:
7878 return "DW_AT_entry_pc";
7879 case DW_AT_use_UTF8
:
7880 return "DW_AT_use_UTF8";
7881 case DW_AT_extension
:
7882 return "DW_AT_extension";
7884 return "DW_AT_ranges";
7885 case DW_AT_trampoline
:
7886 return "DW_AT_trampoline";
7887 case DW_AT_call_column
:
7888 return "DW_AT_call_column";
7889 case DW_AT_call_file
:
7890 return "DW_AT_call_file";
7891 case DW_AT_call_line
:
7892 return "DW_AT_call_line";
7894 case DW_AT_MIPS_fde
:
7895 return "DW_AT_MIPS_fde";
7896 case DW_AT_MIPS_loop_begin
:
7897 return "DW_AT_MIPS_loop_begin";
7898 case DW_AT_MIPS_tail_loop_begin
:
7899 return "DW_AT_MIPS_tail_loop_begin";
7900 case DW_AT_MIPS_epilog_begin
:
7901 return "DW_AT_MIPS_epilog_begin";
7902 case DW_AT_MIPS_loop_unroll_factor
:
7903 return "DW_AT_MIPS_loop_unroll_factor";
7904 case DW_AT_MIPS_software_pipeline_depth
:
7905 return "DW_AT_MIPS_software_pipeline_depth";
7907 case DW_AT_MIPS_linkage_name
:
7908 return "DW_AT_MIPS_linkage_name";
7910 case DW_AT_sf_names
:
7911 return "DW_AT_sf_names";
7912 case DW_AT_src_info
:
7913 return "DW_AT_src_info";
7914 case DW_AT_mac_info
:
7915 return "DW_AT_mac_info";
7916 case DW_AT_src_coords
:
7917 return "DW_AT_src_coords";
7918 case DW_AT_body_begin
:
7919 return "DW_AT_body_begin";
7920 case DW_AT_body_end
:
7921 return "DW_AT_body_end";
7922 case DW_AT_GNU_vector
:
7923 return "DW_AT_GNU_vector";
7925 return "DW_AT_<unknown>";
7929 /* Convert a DWARF value form code into its string name. */
7932 dwarf_form_name (unsigned form
)
7937 return "DW_FORM_addr";
7938 case DW_FORM_block2
:
7939 return "DW_FORM_block2";
7940 case DW_FORM_block4
:
7941 return "DW_FORM_block4";
7943 return "DW_FORM_data2";
7945 return "DW_FORM_data4";
7947 return "DW_FORM_data8";
7948 case DW_FORM_string
:
7949 return "DW_FORM_string";
7951 return "DW_FORM_block";
7952 case DW_FORM_block1
:
7953 return "DW_FORM_block1";
7955 return "DW_FORM_data1";
7957 return "DW_FORM_flag";
7959 return "DW_FORM_sdata";
7961 return "DW_FORM_strp";
7963 return "DW_FORM_udata";
7964 case DW_FORM_ref_addr
:
7965 return "DW_FORM_ref_addr";
7967 return "DW_FORM_ref1";
7969 return "DW_FORM_ref2";
7971 return "DW_FORM_ref4";
7973 return "DW_FORM_ref8";
7974 case DW_FORM_ref_udata
:
7975 return "DW_FORM_ref_udata";
7976 case DW_FORM_indirect
:
7977 return "DW_FORM_indirect";
7979 return "DW_FORM_<unknown>";
7983 /* Convert a DWARF stack opcode into its string name. */
7986 dwarf_stack_op_name (unsigned op
)
7991 return "DW_OP_addr";
7993 return "DW_OP_deref";
7995 return "DW_OP_const1u";
7997 return "DW_OP_const1s";
7999 return "DW_OP_const2u";
8001 return "DW_OP_const2s";
8003 return "DW_OP_const4u";
8005 return "DW_OP_const4s";
8007 return "DW_OP_const8u";
8009 return "DW_OP_const8s";
8011 return "DW_OP_constu";
8013 return "DW_OP_consts";
8017 return "DW_OP_drop";
8019 return "DW_OP_over";
8021 return "DW_OP_pick";
8023 return "DW_OP_swap";
8027 return "DW_OP_xderef";
8035 return "DW_OP_minus";
8047 return "DW_OP_plus";
8048 case DW_OP_plus_uconst
:
8049 return "DW_OP_plus_uconst";
8055 return "DW_OP_shra";
8073 return "DW_OP_skip";
8075 return "DW_OP_lit0";
8077 return "DW_OP_lit1";
8079 return "DW_OP_lit2";
8081 return "DW_OP_lit3";
8083 return "DW_OP_lit4";
8085 return "DW_OP_lit5";
8087 return "DW_OP_lit6";
8089 return "DW_OP_lit7";
8091 return "DW_OP_lit8";
8093 return "DW_OP_lit9";
8095 return "DW_OP_lit10";
8097 return "DW_OP_lit11";
8099 return "DW_OP_lit12";
8101 return "DW_OP_lit13";
8103 return "DW_OP_lit14";
8105 return "DW_OP_lit15";
8107 return "DW_OP_lit16";
8109 return "DW_OP_lit17";
8111 return "DW_OP_lit18";
8113 return "DW_OP_lit19";
8115 return "DW_OP_lit20";
8117 return "DW_OP_lit21";
8119 return "DW_OP_lit22";
8121 return "DW_OP_lit23";
8123 return "DW_OP_lit24";
8125 return "DW_OP_lit25";
8127 return "DW_OP_lit26";
8129 return "DW_OP_lit27";
8131 return "DW_OP_lit28";
8133 return "DW_OP_lit29";
8135 return "DW_OP_lit30";
8137 return "DW_OP_lit31";
8139 return "DW_OP_reg0";
8141 return "DW_OP_reg1";
8143 return "DW_OP_reg2";
8145 return "DW_OP_reg3";
8147 return "DW_OP_reg4";
8149 return "DW_OP_reg5";
8151 return "DW_OP_reg6";
8153 return "DW_OP_reg7";
8155 return "DW_OP_reg8";
8157 return "DW_OP_reg9";
8159 return "DW_OP_reg10";
8161 return "DW_OP_reg11";
8163 return "DW_OP_reg12";
8165 return "DW_OP_reg13";
8167 return "DW_OP_reg14";
8169 return "DW_OP_reg15";
8171 return "DW_OP_reg16";
8173 return "DW_OP_reg17";
8175 return "DW_OP_reg18";
8177 return "DW_OP_reg19";
8179 return "DW_OP_reg20";
8181 return "DW_OP_reg21";
8183 return "DW_OP_reg22";
8185 return "DW_OP_reg23";
8187 return "DW_OP_reg24";
8189 return "DW_OP_reg25";
8191 return "DW_OP_reg26";
8193 return "DW_OP_reg27";
8195 return "DW_OP_reg28";
8197 return "DW_OP_reg29";
8199 return "DW_OP_reg30";
8201 return "DW_OP_reg31";
8203 return "DW_OP_breg0";
8205 return "DW_OP_breg1";
8207 return "DW_OP_breg2";
8209 return "DW_OP_breg3";
8211 return "DW_OP_breg4";
8213 return "DW_OP_breg5";
8215 return "DW_OP_breg6";
8217 return "DW_OP_breg7";
8219 return "DW_OP_breg8";
8221 return "DW_OP_breg9";
8223 return "DW_OP_breg10";
8225 return "DW_OP_breg11";
8227 return "DW_OP_breg12";
8229 return "DW_OP_breg13";
8231 return "DW_OP_breg14";
8233 return "DW_OP_breg15";
8235 return "DW_OP_breg16";
8237 return "DW_OP_breg17";
8239 return "DW_OP_breg18";
8241 return "DW_OP_breg19";
8243 return "DW_OP_breg20";
8245 return "DW_OP_breg21";
8247 return "DW_OP_breg22";
8249 return "DW_OP_breg23";
8251 return "DW_OP_breg24";
8253 return "DW_OP_breg25";
8255 return "DW_OP_breg26";
8257 return "DW_OP_breg27";
8259 return "DW_OP_breg28";
8261 return "DW_OP_breg29";
8263 return "DW_OP_breg30";
8265 return "DW_OP_breg31";
8267 return "DW_OP_regx";
8269 return "DW_OP_fbreg";
8271 return "DW_OP_bregx";
8273 return "DW_OP_piece";
8274 case DW_OP_deref_size
:
8275 return "DW_OP_deref_size";
8276 case DW_OP_xderef_size
:
8277 return "DW_OP_xderef_size";
8280 /* DWARF 3 extensions. */
8281 case DW_OP_push_object_address
:
8282 return "DW_OP_push_object_address";
8284 return "DW_OP_call2";
8286 return "DW_OP_call4";
8287 case DW_OP_call_ref
:
8288 return "DW_OP_call_ref";
8289 /* GNU extensions. */
8290 case DW_OP_GNU_push_tls_address
:
8291 return "DW_OP_GNU_push_tls_address";
8293 return "OP_<unknown>";
8298 dwarf_bool_name (unsigned mybool
)
8306 /* Convert a DWARF type code into its string name. */
8309 dwarf_type_encoding_name (unsigned enc
)
8313 case DW_ATE_address
:
8314 return "DW_ATE_address";
8315 case DW_ATE_boolean
:
8316 return "DW_ATE_boolean";
8317 case DW_ATE_complex_float
:
8318 return "DW_ATE_complex_float";
8320 return "DW_ATE_float";
8322 return "DW_ATE_signed";
8323 case DW_ATE_signed_char
:
8324 return "DW_ATE_signed_char";
8325 case DW_ATE_unsigned
:
8326 return "DW_ATE_unsigned";
8327 case DW_ATE_unsigned_char
:
8328 return "DW_ATE_unsigned_char";
8329 case DW_ATE_imaginary_float
:
8330 return "DW_ATE_imaginary_float";
8332 return "DW_ATE_<unknown>";
8336 /* Convert a DWARF call frame info operation to its string name. */
8340 dwarf_cfi_name (unsigned cfi_opc
)
8344 case DW_CFA_advance_loc
:
8345 return "DW_CFA_advance_loc";
8347 return "DW_CFA_offset";
8348 case DW_CFA_restore
:
8349 return "DW_CFA_restore";
8351 return "DW_CFA_nop";
8352 case DW_CFA_set_loc
:
8353 return "DW_CFA_set_loc";
8354 case DW_CFA_advance_loc1
:
8355 return "DW_CFA_advance_loc1";
8356 case DW_CFA_advance_loc2
:
8357 return "DW_CFA_advance_loc2";
8358 case DW_CFA_advance_loc4
:
8359 return "DW_CFA_advance_loc4";
8360 case DW_CFA_offset_extended
:
8361 return "DW_CFA_offset_extended";
8362 case DW_CFA_restore_extended
:
8363 return "DW_CFA_restore_extended";
8364 case DW_CFA_undefined
:
8365 return "DW_CFA_undefined";
8366 case DW_CFA_same_value
:
8367 return "DW_CFA_same_value";
8368 case DW_CFA_register
:
8369 return "DW_CFA_register";
8370 case DW_CFA_remember_state
:
8371 return "DW_CFA_remember_state";
8372 case DW_CFA_restore_state
:
8373 return "DW_CFA_restore_state";
8374 case DW_CFA_def_cfa
:
8375 return "DW_CFA_def_cfa";
8376 case DW_CFA_def_cfa_register
:
8377 return "DW_CFA_def_cfa_register";
8378 case DW_CFA_def_cfa_offset
:
8379 return "DW_CFA_def_cfa_offset";
8382 case DW_CFA_def_cfa_expression
:
8383 return "DW_CFA_def_cfa_expression";
8384 case DW_CFA_expression
:
8385 return "DW_CFA_expression";
8386 case DW_CFA_offset_extended_sf
:
8387 return "DW_CFA_offset_extended_sf";
8388 case DW_CFA_def_cfa_sf
:
8389 return "DW_CFA_def_cfa_sf";
8390 case DW_CFA_def_cfa_offset_sf
:
8391 return "DW_CFA_def_cfa_offset_sf";
8393 /* SGI/MIPS specific */
8394 case DW_CFA_MIPS_advance_loc8
:
8395 return "DW_CFA_MIPS_advance_loc8";
8397 /* GNU extensions */
8398 case DW_CFA_GNU_window_save
:
8399 return "DW_CFA_GNU_window_save";
8400 case DW_CFA_GNU_args_size
:
8401 return "DW_CFA_GNU_args_size";
8402 case DW_CFA_GNU_negative_offset_extended
:
8403 return "DW_CFA_GNU_negative_offset_extended";
8406 return "DW_CFA_<unknown>";
8412 dump_die (struct die_info
*die
)
8416 fprintf_unfiltered (gdb_stderr
, "Die: %s (abbrev = %d, offset = %d)\n",
8417 dwarf_tag_name (die
->tag
), die
->abbrev
, die
->offset
);
8418 fprintf_unfiltered (gdb_stderr
, "\thas children: %s\n",
8419 dwarf_bool_name (die
->child
!= NULL
));
8421 fprintf_unfiltered (gdb_stderr
, "\tattributes:\n");
8422 for (i
= 0; i
< die
->num_attrs
; ++i
)
8424 fprintf_unfiltered (gdb_stderr
, "\t\t%s (%s) ",
8425 dwarf_attr_name (die
->attrs
[i
].name
),
8426 dwarf_form_name (die
->attrs
[i
].form
));
8427 switch (die
->attrs
[i
].form
)
8429 case DW_FORM_ref_addr
:
8431 fprintf_unfiltered (gdb_stderr
, "address: ");
8432 deprecated_print_address_numeric (DW_ADDR (&die
->attrs
[i
]), 1, gdb_stderr
);
8434 case DW_FORM_block2
:
8435 case DW_FORM_block4
:
8437 case DW_FORM_block1
:
8438 fprintf_unfiltered (gdb_stderr
, "block: size %d", DW_BLOCK (&die
->attrs
[i
])->size
);
8443 fprintf_unfiltered (gdb_stderr
, "constant ref: %ld (adjusted)",
8444 (long) (DW_ADDR (&die
->attrs
[i
])));
8452 fprintf_unfiltered (gdb_stderr
, "constant: %ld", DW_UNSND (&die
->attrs
[i
]));
8454 case DW_FORM_string
:
8456 fprintf_unfiltered (gdb_stderr
, "string: \"%s\"",
8457 DW_STRING (&die
->attrs
[i
])
8458 ? DW_STRING (&die
->attrs
[i
]) : "");
8461 if (DW_UNSND (&die
->attrs
[i
]))
8462 fprintf_unfiltered (gdb_stderr
, "flag: TRUE");
8464 fprintf_unfiltered (gdb_stderr
, "flag: FALSE");
8466 case DW_FORM_indirect
:
8467 /* the reader will have reduced the indirect form to
8468 the "base form" so this form should not occur */
8469 fprintf_unfiltered (gdb_stderr
, "unexpected attribute form: DW_FORM_indirect");
8472 fprintf_unfiltered (gdb_stderr
, "unsupported attribute form: %d.",
8473 die
->attrs
[i
].form
);
8475 fprintf_unfiltered (gdb_stderr
, "\n");
8480 dump_die_list (struct die_info
*die
)
8485 if (die
->child
!= NULL
)
8486 dump_die_list (die
->child
);
8487 if (die
->sibling
!= NULL
)
8488 dump_die_list (die
->sibling
);
8493 store_in_ref_table (unsigned int offset
, struct die_info
*die
,
8494 struct dwarf2_cu
*cu
)
8497 struct die_info
*old
;
8499 h
= (offset
% REF_HASH_SIZE
);
8500 old
= cu
->die_ref_table
[h
];
8501 die
->next_ref
= old
;
8502 cu
->die_ref_table
[h
] = die
;
8506 dwarf2_get_ref_die_offset (struct attribute
*attr
, struct dwarf2_cu
*cu
)
8508 unsigned int result
= 0;
8512 case DW_FORM_ref_addr
:
8517 case DW_FORM_ref_udata
:
8518 result
= DW_ADDR (attr
);
8521 complaint (&symfile_complaints
,
8522 _("unsupported die ref attribute form: '%s'"),
8523 dwarf_form_name (attr
->form
));
8528 /* Return the constant value held by the given attribute. Return -1
8529 if the value held by the attribute is not constant. */
8532 dwarf2_get_attr_constant_value (struct attribute
*attr
, int default_value
)
8534 if (attr
->form
== DW_FORM_sdata
)
8535 return DW_SND (attr
);
8536 else if (attr
->form
== DW_FORM_udata
8537 || attr
->form
== DW_FORM_data1
8538 || attr
->form
== DW_FORM_data2
8539 || attr
->form
== DW_FORM_data4
8540 || attr
->form
== DW_FORM_data8
)
8541 return DW_UNSND (attr
);
8544 complaint (&symfile_complaints
, _("Attribute value is not a constant (%s)"),
8545 dwarf_form_name (attr
->form
));
8546 return default_value
;
8550 static struct die_info
*
8551 follow_die_ref (struct die_info
*src_die
, struct attribute
*attr
,
8552 struct dwarf2_cu
*cu
)
8554 struct die_info
*die
;
8555 unsigned int offset
;
8557 struct die_info temp_die
;
8558 struct dwarf2_cu
*target_cu
;
8560 offset
= dwarf2_get_ref_die_offset (attr
, cu
);
8562 if (DW_ADDR (attr
) < cu
->header
.offset
8563 || DW_ADDR (attr
) >= cu
->header
.offset
+ cu
->header
.length
)
8565 struct dwarf2_per_cu_data
*per_cu
;
8566 per_cu
= dwarf2_find_containing_comp_unit (DW_ADDR (attr
),
8568 target_cu
= per_cu
->cu
;
8573 h
= (offset
% REF_HASH_SIZE
);
8574 die
= target_cu
->die_ref_table
[h
];
8577 if (die
->offset
== offset
)
8579 die
= die
->next_ref
;
8582 error (_("Dwarf Error: Cannot find DIE at 0x%lx referenced from DIE "
8583 "at 0x%lx [in module %s]"),
8584 (long) src_die
->offset
, (long) offset
, cu
->objfile
->name
);
8589 static struct type
*
8590 dwarf2_fundamental_type (struct objfile
*objfile
, int typeid,
8591 struct dwarf2_cu
*cu
)
8593 if (typeid < 0 || typeid >= FT_NUM_MEMBERS
)
8595 error (_("Dwarf Error: internal error - invalid fundamental type id %d [in module %s]"),
8596 typeid, objfile
->name
);
8599 /* Look for this particular type in the fundamental type vector. If
8600 one is not found, create and install one appropriate for the
8601 current language and the current target machine. */
8603 if (cu
->ftypes
[typeid] == NULL
)
8605 cu
->ftypes
[typeid] = cu
->language_defn
->la_fund_type (objfile
, typeid);
8608 return (cu
->ftypes
[typeid]);
8611 /* Decode simple location descriptions.
8612 Given a pointer to a dwarf block that defines a location, compute
8613 the location and return the value.
8615 NOTE drow/2003-11-18: This function is called in two situations
8616 now: for the address of static or global variables (partial symbols
8617 only) and for offsets into structures which are expected to be
8618 (more or less) constant. The partial symbol case should go away,
8619 and only the constant case should remain. That will let this
8620 function complain more accurately. A few special modes are allowed
8621 without complaint for global variables (for instance, global
8622 register values and thread-local values).
8624 A location description containing no operations indicates that the
8625 object is optimized out. The return value is 0 for that case.
8626 FIXME drow/2003-11-16: No callers check for this case any more; soon all
8627 callers will only want a very basic result and this can become a
8630 Note that stack[0] is unused except as a default error return.
8631 Note that stack overflow is not yet handled. */
8634 decode_locdesc (struct dwarf_block
*blk
, struct dwarf2_cu
*cu
)
8636 struct objfile
*objfile
= cu
->objfile
;
8637 struct comp_unit_head
*cu_header
= &cu
->header
;
8639 int size
= blk
->size
;
8640 gdb_byte
*data
= blk
->data
;
8641 CORE_ADDR stack
[64];
8643 unsigned int bytes_read
, unsnd
;
8687 stack
[++stacki
] = op
- DW_OP_lit0
;
8722 stack
[++stacki
] = op
- DW_OP_reg0
;
8724 dwarf2_complex_location_expr_complaint ();
8728 unsnd
= read_unsigned_leb128 (NULL
, (data
+ i
), &bytes_read
);
8730 stack
[++stacki
] = unsnd
;
8732 dwarf2_complex_location_expr_complaint ();
8736 stack
[++stacki
] = read_address (objfile
->obfd
, &data
[i
],
8742 stack
[++stacki
] = read_1_byte (objfile
->obfd
, &data
[i
]);
8747 stack
[++stacki
] = read_1_signed_byte (objfile
->obfd
, &data
[i
]);
8752 stack
[++stacki
] = read_2_bytes (objfile
->obfd
, &data
[i
]);
8757 stack
[++stacki
] = read_2_signed_bytes (objfile
->obfd
, &data
[i
]);
8762 stack
[++stacki
] = read_4_bytes (objfile
->obfd
, &data
[i
]);
8767 stack
[++stacki
] = read_4_signed_bytes (objfile
->obfd
, &data
[i
]);
8772 stack
[++stacki
] = read_unsigned_leb128 (NULL
, (data
+ i
),
8778 stack
[++stacki
] = read_signed_leb128 (NULL
, (data
+ i
), &bytes_read
);
8783 stack
[stacki
+ 1] = stack
[stacki
];
8788 stack
[stacki
- 1] += stack
[stacki
];
8792 case DW_OP_plus_uconst
:
8793 stack
[stacki
] += read_unsigned_leb128 (NULL
, (data
+ i
), &bytes_read
);
8798 stack
[stacki
- 1] -= stack
[stacki
];
8803 /* If we're not the last op, then we definitely can't encode
8804 this using GDB's address_class enum. This is valid for partial
8805 global symbols, although the variable's address will be bogus
8808 dwarf2_complex_location_expr_complaint ();
8811 case DW_OP_GNU_push_tls_address
:
8812 /* The top of the stack has the offset from the beginning
8813 of the thread control block at which the variable is located. */
8814 /* Nothing should follow this operator, so the top of stack would
8816 /* This is valid for partial global symbols, but the variable's
8817 address will be bogus in the psymtab. */
8819 dwarf2_complex_location_expr_complaint ();
8823 complaint (&symfile_complaints
, _("unsupported stack op: '%s'"),
8824 dwarf_stack_op_name (op
));
8825 return (stack
[stacki
]);
8828 return (stack
[stacki
]);
8831 /* memory allocation interface */
8833 static struct dwarf_block
*
8834 dwarf_alloc_block (struct dwarf2_cu
*cu
)
8836 struct dwarf_block
*blk
;
8838 blk
= (struct dwarf_block
*)
8839 obstack_alloc (&cu
->comp_unit_obstack
, sizeof (struct dwarf_block
));
8843 static struct abbrev_info
*
8844 dwarf_alloc_abbrev (struct dwarf2_cu
*cu
)
8846 struct abbrev_info
*abbrev
;
8848 abbrev
= (struct abbrev_info
*)
8849 obstack_alloc (&cu
->abbrev_obstack
, sizeof (struct abbrev_info
));
8850 memset (abbrev
, 0, sizeof (struct abbrev_info
));
8854 static struct die_info
*
8855 dwarf_alloc_die (void)
8857 struct die_info
*die
;
8859 die
= (struct die_info
*) xmalloc (sizeof (struct die_info
));
8860 memset (die
, 0, sizeof (struct die_info
));
8865 /* Macro support. */
8868 /* Return the full name of file number I in *LH's file name table.
8869 Use COMP_DIR as the name of the current directory of the
8870 compilation. The result is allocated using xmalloc; the caller is
8871 responsible for freeing it. */
8873 file_full_name (int file
, struct line_header
*lh
, const char *comp_dir
)
8875 /* Is the file number a valid index into the line header's file name
8876 table? Remember that file numbers start with one, not zero. */
8877 if (1 <= file
&& file
<= lh
->num_file_names
)
8879 struct file_entry
*fe
= &lh
->file_names
[file
- 1];
8881 if (IS_ABSOLUTE_PATH (fe
->name
))
8882 return xstrdup (fe
->name
);
8890 dir
= lh
->include_dirs
[fe
->dir_index
- 1];
8896 dir_len
= strlen (dir
);
8897 full_name
= xmalloc (dir_len
+ 1 + strlen (fe
->name
) + 1);
8898 strcpy (full_name
, dir
);
8899 full_name
[dir_len
] = '/';
8900 strcpy (full_name
+ dir_len
+ 1, fe
->name
);
8904 return xstrdup (fe
->name
);
8909 /* The compiler produced a bogus file number. We can at least
8910 record the macro definitions made in the file, even if we
8911 won't be able to find the file by name. */
8913 sprintf (fake_name
, "<bad macro file number %d>", file
);
8915 complaint (&symfile_complaints
,
8916 _("bad file number in macro information (%d)"),
8919 return xstrdup (fake_name
);
8924 static struct macro_source_file
*
8925 macro_start_file (int file
, int line
,
8926 struct macro_source_file
*current_file
,
8927 const char *comp_dir
,
8928 struct line_header
*lh
, struct objfile
*objfile
)
8930 /* The full name of this source file. */
8931 char *full_name
= file_full_name (file
, lh
, comp_dir
);
8933 /* We don't create a macro table for this compilation unit
8934 at all until we actually get a filename. */
8935 if (! pending_macros
)
8936 pending_macros
= new_macro_table (&objfile
->objfile_obstack
,
8937 objfile
->macro_cache
);
8940 /* If we have no current file, then this must be the start_file
8941 directive for the compilation unit's main source file. */
8942 current_file
= macro_set_main (pending_macros
, full_name
);
8944 current_file
= macro_include (current_file
, line
, full_name
);
8948 return current_file
;
8952 /* Copy the LEN characters at BUF to a xmalloc'ed block of memory,
8953 followed by a null byte. */
8955 copy_string (const char *buf
, int len
)
8957 char *s
= xmalloc (len
+ 1);
8958 memcpy (s
, buf
, len
);
8966 consume_improper_spaces (const char *p
, const char *body
)
8970 complaint (&symfile_complaints
,
8971 _("macro definition contains spaces in formal argument list:\n`%s'"),
8983 parse_macro_definition (struct macro_source_file
*file
, int line
,
8988 /* The body string takes one of two forms. For object-like macro
8989 definitions, it should be:
8991 <macro name> " " <definition>
8993 For function-like macro definitions, it should be:
8995 <macro name> "() " <definition>
8997 <macro name> "(" <arg name> ( "," <arg name> ) * ") " <definition>
8999 Spaces may appear only where explicitly indicated, and in the
9002 The Dwarf 2 spec says that an object-like macro's name is always
9003 followed by a space, but versions of GCC around March 2002 omit
9004 the space when the macro's definition is the empty string.
9006 The Dwarf 2 spec says that there should be no spaces between the
9007 formal arguments in a function-like macro's formal argument list,
9008 but versions of GCC around March 2002 include spaces after the
9012 /* Find the extent of the macro name. The macro name is terminated
9013 by either a space or null character (for an object-like macro) or
9014 an opening paren (for a function-like macro). */
9015 for (p
= body
; *p
; p
++)
9016 if (*p
== ' ' || *p
== '(')
9019 if (*p
== ' ' || *p
== '\0')
9021 /* It's an object-like macro. */
9022 int name_len
= p
- body
;
9023 char *name
= copy_string (body
, name_len
);
9024 const char *replacement
;
9027 replacement
= body
+ name_len
+ 1;
9030 dwarf2_macro_malformed_definition_complaint (body
);
9031 replacement
= body
+ name_len
;
9034 macro_define_object (file
, line
, name
, replacement
);
9040 /* It's a function-like macro. */
9041 char *name
= copy_string (body
, p
- body
);
9044 char **argv
= xmalloc (argv_size
* sizeof (*argv
));
9048 p
= consume_improper_spaces (p
, body
);
9050 /* Parse the formal argument list. */
9051 while (*p
&& *p
!= ')')
9053 /* Find the extent of the current argument name. */
9054 const char *arg_start
= p
;
9056 while (*p
&& *p
!= ',' && *p
!= ')' && *p
!= ' ')
9059 if (! *p
|| p
== arg_start
)
9060 dwarf2_macro_malformed_definition_complaint (body
);
9063 /* Make sure argv has room for the new argument. */
9064 if (argc
>= argv_size
)
9067 argv
= xrealloc (argv
, argv_size
* sizeof (*argv
));
9070 argv
[argc
++] = copy_string (arg_start
, p
- arg_start
);
9073 p
= consume_improper_spaces (p
, body
);
9075 /* Consume the comma, if present. */
9080 p
= consume_improper_spaces (p
, body
);
9089 /* Perfectly formed definition, no complaints. */
9090 macro_define_function (file
, line
, name
,
9091 argc
, (const char **) argv
,
9093 else if (*p
== '\0')
9095 /* Complain, but do define it. */
9096 dwarf2_macro_malformed_definition_complaint (body
);
9097 macro_define_function (file
, line
, name
,
9098 argc
, (const char **) argv
,
9102 /* Just complain. */
9103 dwarf2_macro_malformed_definition_complaint (body
);
9106 /* Just complain. */
9107 dwarf2_macro_malformed_definition_complaint (body
);
9113 for (i
= 0; i
< argc
; i
++)
9119 dwarf2_macro_malformed_definition_complaint (body
);
9124 dwarf_decode_macros (struct line_header
*lh
, unsigned int offset
,
9125 char *comp_dir
, bfd
*abfd
,
9126 struct dwarf2_cu
*cu
)
9128 gdb_byte
*mac_ptr
, *mac_end
;
9129 struct macro_source_file
*current_file
= 0;
9131 if (dwarf2_per_objfile
->macinfo_buffer
== NULL
)
9133 complaint (&symfile_complaints
, _("missing .debug_macinfo section"));
9137 mac_ptr
= dwarf2_per_objfile
->macinfo_buffer
+ offset
;
9138 mac_end
= dwarf2_per_objfile
->macinfo_buffer
9139 + dwarf2_per_objfile
->macinfo_size
;
9143 enum dwarf_macinfo_record_type macinfo_type
;
9145 /* Do we at least have room for a macinfo type byte? */
9146 if (mac_ptr
>= mac_end
)
9148 dwarf2_macros_too_long_complaint ();
9152 macinfo_type
= read_1_byte (abfd
, mac_ptr
);
9155 switch (macinfo_type
)
9157 /* A zero macinfo type indicates the end of the macro
9162 case DW_MACINFO_define
:
9163 case DW_MACINFO_undef
:
9165 unsigned int bytes_read
;
9169 line
= read_unsigned_leb128 (abfd
, mac_ptr
, &bytes_read
);
9170 mac_ptr
+= bytes_read
;
9171 body
= read_string (abfd
, mac_ptr
, &bytes_read
);
9172 mac_ptr
+= bytes_read
;
9175 complaint (&symfile_complaints
,
9176 _("debug info gives macro %s outside of any file: %s"),
9178 DW_MACINFO_define
? "definition" : macinfo_type
==
9179 DW_MACINFO_undef
? "undefinition" :
9180 "something-or-other", body
);
9183 if (macinfo_type
== DW_MACINFO_define
)
9184 parse_macro_definition (current_file
, line
, body
);
9185 else if (macinfo_type
== DW_MACINFO_undef
)
9186 macro_undef (current_file
, line
, body
);
9191 case DW_MACINFO_start_file
:
9193 unsigned int bytes_read
;
9196 line
= read_unsigned_leb128 (abfd
, mac_ptr
, &bytes_read
);
9197 mac_ptr
+= bytes_read
;
9198 file
= read_unsigned_leb128 (abfd
, mac_ptr
, &bytes_read
);
9199 mac_ptr
+= bytes_read
;
9201 current_file
= macro_start_file (file
, line
,
9202 current_file
, comp_dir
,
9207 case DW_MACINFO_end_file
:
9209 complaint (&symfile_complaints
,
9210 _("macro debug info has an unmatched `close_file' directive"));
9213 current_file
= current_file
->included_by
;
9216 enum dwarf_macinfo_record_type next_type
;
9218 /* GCC circa March 2002 doesn't produce the zero
9219 type byte marking the end of the compilation
9220 unit. Complain if it's not there, but exit no
9223 /* Do we at least have room for a macinfo type byte? */
9224 if (mac_ptr
>= mac_end
)
9226 dwarf2_macros_too_long_complaint ();
9230 /* We don't increment mac_ptr here, so this is just
9232 next_type
= read_1_byte (abfd
, mac_ptr
);
9234 complaint (&symfile_complaints
,
9235 _("no terminating 0-type entry for macros in `.debug_macinfo' section"));
9242 case DW_MACINFO_vendor_ext
:
9244 unsigned int bytes_read
;
9248 constant
= read_unsigned_leb128 (abfd
, mac_ptr
, &bytes_read
);
9249 mac_ptr
+= bytes_read
;
9250 string
= read_string (abfd
, mac_ptr
, &bytes_read
);
9251 mac_ptr
+= bytes_read
;
9253 /* We don't recognize any vendor extensions. */
9260 /* Check if the attribute's form is a DW_FORM_block*
9261 if so return true else false. */
9263 attr_form_is_block (struct attribute
*attr
)
9265 return (attr
== NULL
? 0 :
9266 attr
->form
== DW_FORM_block1
9267 || attr
->form
== DW_FORM_block2
9268 || attr
->form
== DW_FORM_block4
9269 || attr
->form
== DW_FORM_block
);
9273 dwarf2_symbol_mark_computed (struct attribute
*attr
, struct symbol
*sym
,
9274 struct dwarf2_cu
*cu
)
9276 if (attr
->form
== DW_FORM_data4
|| attr
->form
== DW_FORM_data8
)
9278 struct dwarf2_loclist_baton
*baton
;
9280 baton
= obstack_alloc (&cu
->objfile
->objfile_obstack
,
9281 sizeof (struct dwarf2_loclist_baton
));
9282 baton
->objfile
= cu
->objfile
;
9284 /* We don't know how long the location list is, but make sure we
9285 don't run off the edge of the section. */
9286 baton
->size
= dwarf2_per_objfile
->loc_size
- DW_UNSND (attr
);
9287 baton
->data
= dwarf2_per_objfile
->loc_buffer
+ DW_UNSND (attr
);
9288 baton
->base_address
= cu
->header
.base_address
;
9289 if (cu
->header
.base_known
== 0)
9290 complaint (&symfile_complaints
,
9291 _("Location list used without specifying the CU base address."));
9293 SYMBOL_OPS (sym
) = &dwarf2_loclist_funcs
;
9294 SYMBOL_LOCATION_BATON (sym
) = baton
;
9298 struct dwarf2_locexpr_baton
*baton
;
9300 baton
= obstack_alloc (&cu
->objfile
->objfile_obstack
,
9301 sizeof (struct dwarf2_locexpr_baton
));
9302 baton
->objfile
= cu
->objfile
;
9304 if (attr_form_is_block (attr
))
9306 /* Note that we're just copying the block's data pointer
9307 here, not the actual data. We're still pointing into the
9308 info_buffer for SYM's objfile; right now we never release
9309 that buffer, but when we do clean up properly this may
9311 baton
->size
= DW_BLOCK (attr
)->size
;
9312 baton
->data
= DW_BLOCK (attr
)->data
;
9316 dwarf2_invalid_attrib_class_complaint ("location description",
9317 SYMBOL_NATURAL_NAME (sym
));
9322 SYMBOL_OPS (sym
) = &dwarf2_locexpr_funcs
;
9323 SYMBOL_LOCATION_BATON (sym
) = baton
;
9327 /* Locate the compilation unit from CU's objfile which contains the
9328 DIE at OFFSET. Raises an error on failure. */
9330 static struct dwarf2_per_cu_data
*
9331 dwarf2_find_containing_comp_unit (unsigned long offset
,
9332 struct objfile
*objfile
)
9334 struct dwarf2_per_cu_data
*this_cu
;
9338 high
= dwarf2_per_objfile
->n_comp_units
- 1;
9341 int mid
= low
+ (high
- low
) / 2;
9342 if (dwarf2_per_objfile
->all_comp_units
[mid
]->offset
>= offset
)
9347 gdb_assert (low
== high
);
9348 if (dwarf2_per_objfile
->all_comp_units
[low
]->offset
> offset
)
9351 error (_("Dwarf Error: could not find partial DIE containing "
9352 "offset 0x%lx [in module %s]"),
9353 (long) offset
, bfd_get_filename (objfile
->obfd
));
9355 gdb_assert (dwarf2_per_objfile
->all_comp_units
[low
-1]->offset
<= offset
);
9356 return dwarf2_per_objfile
->all_comp_units
[low
-1];
9360 this_cu
= dwarf2_per_objfile
->all_comp_units
[low
];
9361 if (low
== dwarf2_per_objfile
->n_comp_units
- 1
9362 && offset
>= this_cu
->offset
+ this_cu
->length
)
9363 error (_("invalid dwarf2 offset %ld"), offset
);
9364 gdb_assert (offset
< this_cu
->offset
+ this_cu
->length
);
9369 /* Locate the compilation unit from OBJFILE which is located at exactly
9370 OFFSET. Raises an error on failure. */
9372 static struct dwarf2_per_cu_data
*
9373 dwarf2_find_comp_unit (unsigned long offset
, struct objfile
*objfile
)
9375 struct dwarf2_per_cu_data
*this_cu
;
9376 this_cu
= dwarf2_find_containing_comp_unit (offset
, objfile
);
9377 if (this_cu
->offset
!= offset
)
9378 error (_("no compilation unit with offset %ld."), offset
);
9382 /* Release one cached compilation unit, CU. We unlink it from the tree
9383 of compilation units, but we don't remove it from the read_in_chain;
9384 the caller is responsible for that. */
9387 free_one_comp_unit (void *data
)
9389 struct dwarf2_cu
*cu
= data
;
9391 if (cu
->per_cu
!= NULL
)
9392 cu
->per_cu
->cu
= NULL
;
9395 obstack_free (&cu
->comp_unit_obstack
, NULL
);
9397 free_die_list (cu
->dies
);
9402 /* This cleanup function is passed the address of a dwarf2_cu on the stack
9403 when we're finished with it. We can't free the pointer itself, but be
9404 sure to unlink it from the cache. Also release any associated storage
9405 and perform cache maintenance.
9407 Only used during partial symbol parsing. */
9410 free_stack_comp_unit (void *data
)
9412 struct dwarf2_cu
*cu
= data
;
9414 obstack_free (&cu
->comp_unit_obstack
, NULL
);
9415 cu
->partial_dies
= NULL
;
9417 if (cu
->per_cu
!= NULL
)
9419 /* This compilation unit is on the stack in our caller, so we
9420 should not xfree it. Just unlink it. */
9421 cu
->per_cu
->cu
= NULL
;
9424 /* If we had a per-cu pointer, then we may have other compilation
9425 units loaded, so age them now. */
9426 age_cached_comp_units ();
9430 /* Free all cached compilation units. */
9433 free_cached_comp_units (void *data
)
9435 struct dwarf2_per_cu_data
*per_cu
, **last_chain
;
9437 per_cu
= dwarf2_per_objfile
->read_in_chain
;
9438 last_chain
= &dwarf2_per_objfile
->read_in_chain
;
9439 while (per_cu
!= NULL
)
9441 struct dwarf2_per_cu_data
*next_cu
;
9443 next_cu
= per_cu
->cu
->read_in_chain
;
9445 free_one_comp_unit (per_cu
->cu
);
9446 *last_chain
= next_cu
;
9452 /* Increase the age counter on each cached compilation unit, and free
9453 any that are too old. */
9456 age_cached_comp_units (void)
9458 struct dwarf2_per_cu_data
*per_cu
, **last_chain
;
9460 dwarf2_clear_marks (dwarf2_per_objfile
->read_in_chain
);
9461 per_cu
= dwarf2_per_objfile
->read_in_chain
;
9462 while (per_cu
!= NULL
)
9464 per_cu
->cu
->last_used
++;
9465 if (per_cu
->cu
->last_used
<= dwarf2_max_cache_age
)
9466 dwarf2_mark (per_cu
->cu
);
9467 per_cu
= per_cu
->cu
->read_in_chain
;
9470 per_cu
= dwarf2_per_objfile
->read_in_chain
;
9471 last_chain
= &dwarf2_per_objfile
->read_in_chain
;
9472 while (per_cu
!= NULL
)
9474 struct dwarf2_per_cu_data
*next_cu
;
9476 next_cu
= per_cu
->cu
->read_in_chain
;
9478 if (!per_cu
->cu
->mark
)
9480 free_one_comp_unit (per_cu
->cu
);
9481 *last_chain
= next_cu
;
9484 last_chain
= &per_cu
->cu
->read_in_chain
;
9490 /* Remove a single compilation unit from the cache. */
9493 free_one_cached_comp_unit (void *target_cu
)
9495 struct dwarf2_per_cu_data
*per_cu
, **last_chain
;
9497 per_cu
= dwarf2_per_objfile
->read_in_chain
;
9498 last_chain
= &dwarf2_per_objfile
->read_in_chain
;
9499 while (per_cu
!= NULL
)
9501 struct dwarf2_per_cu_data
*next_cu
;
9503 next_cu
= per_cu
->cu
->read_in_chain
;
9505 if (per_cu
->cu
== target_cu
)
9507 free_one_comp_unit (per_cu
->cu
);
9508 *last_chain
= next_cu
;
9512 last_chain
= &per_cu
->cu
->read_in_chain
;
9518 /* A pair of DIE offset and GDB type pointer. We store these
9519 in a hash table separate from the DIEs, and preserve them
9520 when the DIEs are flushed out of cache. */
9522 struct dwarf2_offset_and_type
9524 unsigned int offset
;
9528 /* Hash function for a dwarf2_offset_and_type. */
9531 offset_and_type_hash (const void *item
)
9533 const struct dwarf2_offset_and_type
*ofs
= item
;
9537 /* Equality function for a dwarf2_offset_and_type. */
9540 offset_and_type_eq (const void *item_lhs
, const void *item_rhs
)
9542 const struct dwarf2_offset_and_type
*ofs_lhs
= item_lhs
;
9543 const struct dwarf2_offset_and_type
*ofs_rhs
= item_rhs
;
9544 return ofs_lhs
->offset
== ofs_rhs
->offset
;
9547 /* Set the type associated with DIE to TYPE. Save it in CU's hash
9548 table if necessary. */
9551 set_die_type (struct die_info
*die
, struct type
*type
, struct dwarf2_cu
*cu
)
9553 struct dwarf2_offset_and_type
**slot
, ofs
;
9557 if (cu
->per_cu
== NULL
)
9560 if (cu
->per_cu
->type_hash
== NULL
)
9561 cu
->per_cu
->type_hash
9562 = htab_create_alloc_ex (cu
->header
.length
/ 24,
9563 offset_and_type_hash
,
9566 &cu
->objfile
->objfile_obstack
,
9567 hashtab_obstack_allocate
,
9568 dummy_obstack_deallocate
);
9570 ofs
.offset
= die
->offset
;
9572 slot
= (struct dwarf2_offset_and_type
**)
9573 htab_find_slot_with_hash (cu
->per_cu
->type_hash
, &ofs
, ofs
.offset
, INSERT
);
9574 *slot
= obstack_alloc (&cu
->objfile
->objfile_obstack
, sizeof (**slot
));
9578 /* Find the type for DIE in TYPE_HASH, or return NULL if DIE does not
9579 have a saved type. */
9581 static struct type
*
9582 get_die_type (struct die_info
*die
, htab_t type_hash
)
9584 struct dwarf2_offset_and_type
*slot
, ofs
;
9586 ofs
.offset
= die
->offset
;
9587 slot
= htab_find_with_hash (type_hash
, &ofs
, ofs
.offset
);
9594 /* Restore the types of the DIE tree starting at START_DIE from the hash
9595 table saved in CU. */
9598 reset_die_and_siblings_types (struct die_info
*start_die
, struct dwarf2_cu
*cu
)
9600 struct die_info
*die
;
9602 if (cu
->per_cu
->type_hash
== NULL
)
9605 for (die
= start_die
; die
!= NULL
; die
= die
->sibling
)
9607 die
->type
= get_die_type (die
, cu
->per_cu
->type_hash
);
9608 if (die
->child
!= NULL
)
9609 reset_die_and_siblings_types (die
->child
, cu
);
9613 /* Set the mark field in CU and in every other compilation unit in the
9614 cache that we must keep because we are keeping CU. */
9616 /* Add a dependence relationship from CU to REF_PER_CU. */
9619 dwarf2_add_dependence (struct dwarf2_cu
*cu
,
9620 struct dwarf2_per_cu_data
*ref_per_cu
)
9624 if (cu
->dependencies
== NULL
)
9626 = htab_create_alloc_ex (5, htab_hash_pointer
, htab_eq_pointer
,
9627 NULL
, &cu
->comp_unit_obstack
,
9628 hashtab_obstack_allocate
,
9629 dummy_obstack_deallocate
);
9631 slot
= htab_find_slot (cu
->dependencies
, ref_per_cu
, INSERT
);
9636 /* Set the mark field in CU and in every other compilation unit in the
9637 cache that we must keep because we are keeping CU. */
9640 dwarf2_mark_helper (void **slot
, void *data
)
9642 struct dwarf2_per_cu_data
*per_cu
;
9644 per_cu
= (struct dwarf2_per_cu_data
*) *slot
;
9645 if (per_cu
->cu
->mark
)
9647 per_cu
->cu
->mark
= 1;
9649 if (per_cu
->cu
->dependencies
!= NULL
)
9650 htab_traverse (per_cu
->cu
->dependencies
, dwarf2_mark_helper
, NULL
);
9656 dwarf2_mark (struct dwarf2_cu
*cu
)
9661 if (cu
->dependencies
!= NULL
)
9662 htab_traverse (cu
->dependencies
, dwarf2_mark_helper
, NULL
);
9666 dwarf2_clear_marks (struct dwarf2_per_cu_data
*per_cu
)
9670 per_cu
->cu
->mark
= 0;
9671 per_cu
= per_cu
->cu
->read_in_chain
;
9675 /* Trivial hash function for partial_die_info: the hash value of a DIE
9676 is its offset in .debug_info for this objfile. */
9679 partial_die_hash (const void *item
)
9681 const struct partial_die_info
*part_die
= item
;
9682 return part_die
->offset
;
9685 /* Trivial comparison function for partial_die_info structures: two DIEs
9686 are equal if they have the same offset. */
9689 partial_die_eq (const void *item_lhs
, const void *item_rhs
)
9691 const struct partial_die_info
*part_die_lhs
= item_lhs
;
9692 const struct partial_die_info
*part_die_rhs
= item_rhs
;
9693 return part_die_lhs
->offset
== part_die_rhs
->offset
;
9696 static struct cmd_list_element
*set_dwarf2_cmdlist
;
9697 static struct cmd_list_element
*show_dwarf2_cmdlist
;
9700 set_dwarf2_cmd (char *args
, int from_tty
)
9702 help_list (set_dwarf2_cmdlist
, "maintenance set dwarf2 ", -1, gdb_stdout
);
9706 show_dwarf2_cmd (char *args
, int from_tty
)
9708 cmd_show_list (show_dwarf2_cmdlist
, from_tty
, "");
9711 void _initialize_dwarf2_read (void);
9714 _initialize_dwarf2_read (void)
9716 dwarf2_objfile_data_key
= register_objfile_data ();
9718 add_prefix_cmd ("dwarf2", class_maintenance
, set_dwarf2_cmd
, _("\
9719 Set DWARF 2 specific variables.\n\
9720 Configure DWARF 2 variables such as the cache size"),
9721 &set_dwarf2_cmdlist
, "maintenance set dwarf2 ",
9722 0/*allow-unknown*/, &maintenance_set_cmdlist
);
9724 add_prefix_cmd ("dwarf2", class_maintenance
, show_dwarf2_cmd
, _("\
9725 Show DWARF 2 specific variables\n\
9726 Show DWARF 2 variables such as the cache size"),
9727 &show_dwarf2_cmdlist
, "maintenance show dwarf2 ",
9728 0/*allow-unknown*/, &maintenance_show_cmdlist
);
9730 add_setshow_zinteger_cmd ("max-cache-age", class_obscure
,
9731 &dwarf2_max_cache_age
, _("\
9732 Set the upper bound on the age of cached dwarf2 compilation units."), _("\
9733 Show the upper bound on the age of cached dwarf2 compilation units."), _("\
9734 A higher limit means that cached compilation units will be stored\n\
9735 in memory longer, and more total memory will be used. Zero disables\n\
9736 caching, which can slow down startup."),
9738 show_dwarf2_max_cache_age
,
9739 &set_dwarf2_cmdlist
,
9740 &show_dwarf2_cmdlist
);