1 /* DWARF 2 debugging format support for GDB.
3 Copyright (C) 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2001,
4 2002, 2003, 2004, 2005, 2006
5 Free Software Foundation, Inc.
7 Adapted by Gary Funck (gary@intrepid.com), Intrepid Technology,
8 Inc. with support from Florida State University (under contract
9 with the Ada Joint Program Office), and Silicon Graphics, Inc.
10 Initial contribution by Brent Benson, Harris Computer Systems, Inc.,
11 based on Fred Fish's (Cygnus Support) implementation of DWARF 1
12 support in dwarfread.c
14 This file is part of GDB.
16 This program is free software; you can redistribute it and/or modify
17 it under the terms of the GNU General Public License as published by
18 the Free Software Foundation; either version 2 of the License, or (at
19 your option) any later version.
21 This program is distributed in the hope that it will be useful, but
22 WITHOUT ANY WARRANTY; without even the implied warranty of
23 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
24 General Public License for more details.
26 You should have received a copy of the GNU General Public License
27 along with this program; if not, write to the Free Software
28 Foundation, Inc., 51 Franklin Street, Fifth Floor,
29 Boston, MA 02110-1301, USA. */
36 #include "elf/dwarf2.h"
39 #include "expression.h"
40 #include "filenames.h" /* for DOSish file names */
43 #include "complaints.h"
45 #include "dwarf2expr.h"
46 #include "dwarf2loc.h"
47 #include "cp-support.h"
53 #include "gdb_string.h"
54 #include "gdb_assert.h"
55 #include <sys/types.h>
57 /* A note on memory usage for this file.
59 At the present time, this code reads the debug info sections into
60 the objfile's objfile_obstack. A definite improvement for startup
61 time, on platforms which do not emit relocations for debug
62 sections, would be to use mmap instead. The object's complete
63 debug information is loaded into memory, partly to simplify
64 absolute DIE references.
66 Whether using obstacks or mmap, the sections should remain loaded
67 until the objfile is released, and pointers into the section data
68 can be used for any other data associated to the objfile (symbol
69 names, type names, location expressions to name a few). */
71 #ifndef DWARF2_REG_TO_REGNUM
72 #define DWARF2_REG_TO_REGNUM(REG) (REG)
76 /* .debug_info header for a compilation unit
77 Because of alignment constraints, this structure has padding and cannot
78 be mapped directly onto the beginning of the .debug_info section. */
79 typedef struct comp_unit_header
81 unsigned int length
; /* length of the .debug_info
83 unsigned short version
; /* version number -- 2 for DWARF
85 unsigned int abbrev_offset
; /* offset into .debug_abbrev section */
86 unsigned char addr_size
; /* byte size of an address -- 4 */
89 #define _ACTUAL_COMP_UNIT_HEADER_SIZE 11
92 /* .debug_pubnames header
93 Because of alignment constraints, this structure has padding and cannot
94 be mapped directly onto the beginning of the .debug_info section. */
95 typedef struct pubnames_header
97 unsigned int length
; /* length of the .debug_pubnames
99 unsigned char version
; /* version number -- 2 for DWARF
101 unsigned int info_offset
; /* offset into .debug_info section */
102 unsigned int info_size
; /* byte size of .debug_info section
106 #define _ACTUAL_PUBNAMES_HEADER_SIZE 13
108 /* .debug_pubnames header
109 Because of alignment constraints, this structure has padding and cannot
110 be mapped directly onto the beginning of the .debug_info section. */
111 typedef struct aranges_header
113 unsigned int length
; /* byte len of the .debug_aranges
115 unsigned short version
; /* version number -- 2 for DWARF
117 unsigned int info_offset
; /* offset into .debug_info section */
118 unsigned char addr_size
; /* byte size of an address */
119 unsigned char seg_size
; /* byte size of segment descriptor */
122 #define _ACTUAL_ARANGES_HEADER_SIZE 12
124 /* .debug_line statement program prologue
125 Because of alignment constraints, this structure has padding and cannot
126 be mapped directly onto the beginning of the .debug_info section. */
127 typedef struct statement_prologue
129 unsigned int total_length
; /* byte length of the statement
131 unsigned short version
; /* version number -- 2 for DWARF
133 unsigned int prologue_length
; /* # bytes between prologue &
135 unsigned char minimum_instruction_length
; /* byte size of
137 unsigned char default_is_stmt
; /* initial value of is_stmt
140 unsigned char line_range
;
141 unsigned char opcode_base
; /* number assigned to first special
143 unsigned char *standard_opcode_lengths
;
147 static const struct objfile_data
*dwarf2_objfile_data_key
;
149 struct dwarf2_per_objfile
151 /* Sizes of debugging sections. */
152 unsigned int info_size
;
153 unsigned int abbrev_size
;
154 unsigned int line_size
;
155 unsigned int pubnames_size
;
156 unsigned int aranges_size
;
157 unsigned int loc_size
;
158 unsigned int macinfo_size
;
159 unsigned int str_size
;
160 unsigned int ranges_size
;
161 unsigned int frame_size
;
162 unsigned int eh_frame_size
;
164 /* Loaded data from the sections. */
165 gdb_byte
*info_buffer
;
166 gdb_byte
*abbrev_buffer
;
167 gdb_byte
*line_buffer
;
168 gdb_byte
*str_buffer
;
169 gdb_byte
*macinfo_buffer
;
170 gdb_byte
*ranges_buffer
;
171 gdb_byte
*loc_buffer
;
173 /* A list of all the compilation units. This is used to locate
174 the target compilation unit of a particular reference. */
175 struct dwarf2_per_cu_data
**all_comp_units
;
177 /* The number of compilation units in ALL_COMP_UNITS. */
180 /* A chain of compilation units that are currently read in, so that
181 they can be freed later. */
182 struct dwarf2_per_cu_data
*read_in_chain
;
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 *, 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 static void read_set_type (struct die_info
*, struct dwarf2_cu
*);
1079 /* Try to locate the sections we need for DWARF 2 debugging
1080 information and return true if we have enough to do something. */
1083 dwarf2_has_info (struct objfile
*objfile
)
1085 struct dwarf2_per_objfile
*data
;
1087 /* Initialize per-objfile state. */
1088 data
= obstack_alloc (&objfile
->objfile_obstack
, sizeof (*data
));
1089 memset (data
, 0, sizeof (*data
));
1090 set_objfile_data (objfile
, dwarf2_objfile_data_key
, data
);
1091 dwarf2_per_objfile
= data
;
1093 dwarf_info_section
= 0;
1094 dwarf_abbrev_section
= 0;
1095 dwarf_line_section
= 0;
1096 dwarf_str_section
= 0;
1097 dwarf_macinfo_section
= 0;
1098 dwarf_frame_section
= 0;
1099 dwarf_eh_frame_section
= 0;
1100 dwarf_ranges_section
= 0;
1101 dwarf_loc_section
= 0;
1103 bfd_map_over_sections (objfile
->obfd
, dwarf2_locate_sections
, NULL
);
1104 return (dwarf_info_section
!= NULL
&& dwarf_abbrev_section
!= NULL
);
1107 /* This function is mapped across the sections and remembers the
1108 offset and size of each of the debugging sections we are interested
1112 dwarf2_locate_sections (bfd
*ignore_abfd
, asection
*sectp
, void *ignore_ptr
)
1114 if (strcmp (sectp
->name
, INFO_SECTION
) == 0)
1116 dwarf2_per_objfile
->info_size
= bfd_get_section_size (sectp
);
1117 dwarf_info_section
= sectp
;
1119 else if (strcmp (sectp
->name
, ABBREV_SECTION
) == 0)
1121 dwarf2_per_objfile
->abbrev_size
= bfd_get_section_size (sectp
);
1122 dwarf_abbrev_section
= sectp
;
1124 else if (strcmp (sectp
->name
, LINE_SECTION
) == 0)
1126 dwarf2_per_objfile
->line_size
= bfd_get_section_size (sectp
);
1127 dwarf_line_section
= sectp
;
1129 else if (strcmp (sectp
->name
, PUBNAMES_SECTION
) == 0)
1131 dwarf2_per_objfile
->pubnames_size
= bfd_get_section_size (sectp
);
1132 dwarf_pubnames_section
= sectp
;
1134 else if (strcmp (sectp
->name
, ARANGES_SECTION
) == 0)
1136 dwarf2_per_objfile
->aranges_size
= bfd_get_section_size (sectp
);
1137 dwarf_aranges_section
= sectp
;
1139 else if (strcmp (sectp
->name
, LOC_SECTION
) == 0)
1141 dwarf2_per_objfile
->loc_size
= bfd_get_section_size (sectp
);
1142 dwarf_loc_section
= sectp
;
1144 else if (strcmp (sectp
->name
, MACINFO_SECTION
) == 0)
1146 dwarf2_per_objfile
->macinfo_size
= bfd_get_section_size (sectp
);
1147 dwarf_macinfo_section
= sectp
;
1149 else if (strcmp (sectp
->name
, STR_SECTION
) == 0)
1151 dwarf2_per_objfile
->str_size
= bfd_get_section_size (sectp
);
1152 dwarf_str_section
= sectp
;
1154 else if (strcmp (sectp
->name
, FRAME_SECTION
) == 0)
1156 dwarf2_per_objfile
->frame_size
= bfd_get_section_size (sectp
);
1157 dwarf_frame_section
= sectp
;
1159 else if (strcmp (sectp
->name
, EH_FRAME_SECTION
) == 0)
1161 flagword aflag
= bfd_get_section_flags (ignore_abfd
, sectp
);
1162 if (aflag
& SEC_HAS_CONTENTS
)
1164 dwarf2_per_objfile
->eh_frame_size
= bfd_get_section_size (sectp
);
1165 dwarf_eh_frame_section
= sectp
;
1168 else if (strcmp (sectp
->name
, RANGES_SECTION
) == 0)
1170 dwarf2_per_objfile
->ranges_size
= bfd_get_section_size (sectp
);
1171 dwarf_ranges_section
= sectp
;
1175 /* Build a partial symbol table. */
1178 dwarf2_build_psymtabs (struct objfile
*objfile
, int mainline
)
1180 /* We definitely need the .debug_info and .debug_abbrev sections */
1182 dwarf2_per_objfile
->info_buffer
= dwarf2_read_section (objfile
, dwarf_info_section
);
1183 dwarf2_per_objfile
->abbrev_buffer
= dwarf2_read_section (objfile
, dwarf_abbrev_section
);
1185 if (dwarf_line_section
)
1186 dwarf2_per_objfile
->line_buffer
= dwarf2_read_section (objfile
, dwarf_line_section
);
1188 dwarf2_per_objfile
->line_buffer
= NULL
;
1190 if (dwarf_str_section
)
1191 dwarf2_per_objfile
->str_buffer
= dwarf2_read_section (objfile
, dwarf_str_section
);
1193 dwarf2_per_objfile
->str_buffer
= NULL
;
1195 if (dwarf_macinfo_section
)
1196 dwarf2_per_objfile
->macinfo_buffer
= dwarf2_read_section (objfile
,
1197 dwarf_macinfo_section
);
1199 dwarf2_per_objfile
->macinfo_buffer
= NULL
;
1201 if (dwarf_ranges_section
)
1202 dwarf2_per_objfile
->ranges_buffer
= dwarf2_read_section (objfile
, dwarf_ranges_section
);
1204 dwarf2_per_objfile
->ranges_buffer
= NULL
;
1206 if (dwarf_loc_section
)
1207 dwarf2_per_objfile
->loc_buffer
= dwarf2_read_section (objfile
, dwarf_loc_section
);
1209 dwarf2_per_objfile
->loc_buffer
= NULL
;
1212 || (objfile
->global_psymbols
.size
== 0
1213 && objfile
->static_psymbols
.size
== 0))
1215 init_psymbol_list (objfile
, 1024);
1219 if (dwarf_aranges_offset
&& dwarf_pubnames_offset
)
1221 /* Things are significantly easier if we have .debug_aranges and
1222 .debug_pubnames sections */
1224 dwarf2_build_psymtabs_easy (objfile
, mainline
);
1228 /* only test this case for now */
1230 /* In this case we have to work a bit harder */
1231 dwarf2_build_psymtabs_hard (objfile
, mainline
);
1236 /* Build the partial symbol table from the information in the
1237 .debug_pubnames and .debug_aranges sections. */
1240 dwarf2_build_psymtabs_easy (struct objfile
*objfile
, int mainline
)
1242 bfd
*abfd
= objfile
->obfd
;
1243 char *aranges_buffer
, *pubnames_buffer
;
1244 char *aranges_ptr
, *pubnames_ptr
;
1245 unsigned int entry_length
, version
, info_offset
, info_size
;
1247 pubnames_buffer
= dwarf2_read_section (objfile
,
1248 dwarf_pubnames_section
);
1249 pubnames_ptr
= pubnames_buffer
;
1250 while ((pubnames_ptr
- pubnames_buffer
) < dwarf2_per_objfile
->pubnames_size
)
1252 struct comp_unit_head cu_header
;
1253 unsigned int bytes_read
;
1255 entry_length
= read_initial_length (abfd
, pubnames_ptr
, &cu_header
,
1257 pubnames_ptr
+= bytes_read
;
1258 version
= read_1_byte (abfd
, pubnames_ptr
);
1260 info_offset
= read_4_bytes (abfd
, pubnames_ptr
);
1262 info_size
= read_4_bytes (abfd
, pubnames_ptr
);
1266 aranges_buffer
= dwarf2_read_section (objfile
,
1267 dwarf_aranges_section
);
1272 /* Read in the comp unit header information from the debug_info at
1276 read_comp_unit_head (struct comp_unit_head
*cu_header
,
1277 gdb_byte
*info_ptr
, bfd
*abfd
)
1280 unsigned int bytes_read
;
1281 cu_header
->length
= read_initial_length (abfd
, info_ptr
, cu_header
,
1283 info_ptr
+= bytes_read
;
1284 cu_header
->version
= read_2_bytes (abfd
, info_ptr
);
1286 cu_header
->abbrev_offset
= read_offset (abfd
, info_ptr
, cu_header
,
1288 info_ptr
+= bytes_read
;
1289 cu_header
->addr_size
= read_1_byte (abfd
, info_ptr
);
1291 signed_addr
= bfd_get_sign_extend_vma (abfd
);
1292 if (signed_addr
< 0)
1293 internal_error (__FILE__
, __LINE__
,
1294 _("read_comp_unit_head: dwarf from non elf file"));
1295 cu_header
->signed_addr_p
= signed_addr
;
1300 partial_read_comp_unit_head (struct comp_unit_head
*header
, gdb_byte
*info_ptr
,
1303 gdb_byte
*beg_of_comp_unit
= info_ptr
;
1305 info_ptr
= read_comp_unit_head (header
, info_ptr
, abfd
);
1307 if (header
->version
!= 2 && header
->version
!= 3)
1308 error (_("Dwarf Error: wrong version in compilation unit header "
1309 "(is %d, should be %d) [in module %s]"), header
->version
,
1310 2, bfd_get_filename (abfd
));
1312 if (header
->abbrev_offset
>= dwarf2_per_objfile
->abbrev_size
)
1313 error (_("Dwarf Error: bad offset (0x%lx) in compilation unit header "
1314 "(offset 0x%lx + 6) [in module %s]"),
1315 (long) header
->abbrev_offset
,
1316 (long) (beg_of_comp_unit
- dwarf2_per_objfile
->info_buffer
),
1317 bfd_get_filename (abfd
));
1319 if (beg_of_comp_unit
+ header
->length
+ header
->initial_length_size
1320 > dwarf2_per_objfile
->info_buffer
+ dwarf2_per_objfile
->info_size
)
1321 error (_("Dwarf Error: bad length (0x%lx) in compilation unit header "
1322 "(offset 0x%lx + 0) [in module %s]"),
1323 (long) header
->length
,
1324 (long) (beg_of_comp_unit
- dwarf2_per_objfile
->info_buffer
),
1325 bfd_get_filename (abfd
));
1330 /* Allocate a new partial symtab for file named NAME and mark this new
1331 partial symtab as being an include of PST. */
1334 dwarf2_create_include_psymtab (char *name
, struct partial_symtab
*pst
,
1335 struct objfile
*objfile
)
1337 struct partial_symtab
*subpst
= allocate_psymtab (name
, objfile
);
1339 subpst
->section_offsets
= pst
->section_offsets
;
1340 subpst
->textlow
= 0;
1341 subpst
->texthigh
= 0;
1343 subpst
->dependencies
= (struct partial_symtab
**)
1344 obstack_alloc (&objfile
->objfile_obstack
,
1345 sizeof (struct partial_symtab
*));
1346 subpst
->dependencies
[0] = pst
;
1347 subpst
->number_of_dependencies
= 1;
1349 subpst
->globals_offset
= 0;
1350 subpst
->n_global_syms
= 0;
1351 subpst
->statics_offset
= 0;
1352 subpst
->n_static_syms
= 0;
1353 subpst
->symtab
= NULL
;
1354 subpst
->read_symtab
= pst
->read_symtab
;
1357 /* No private part is necessary for include psymtabs. This property
1358 can be used to differentiate between such include psymtabs and
1359 the regular ones. */
1360 subpst
->read_symtab_private
= NULL
;
1363 /* Read the Line Number Program data and extract the list of files
1364 included by the source file represented by PST. Build an include
1365 partial symtab for each of these included files.
1367 This procedure assumes that there *is* a Line Number Program in
1368 the given CU. Callers should check that PDI->HAS_STMT_LIST is set
1369 before calling this procedure. */
1372 dwarf2_build_include_psymtabs (struct dwarf2_cu
*cu
,
1373 struct partial_die_info
*pdi
,
1374 struct partial_symtab
*pst
)
1376 struct objfile
*objfile
= cu
->objfile
;
1377 bfd
*abfd
= objfile
->obfd
;
1378 struct line_header
*lh
;
1380 lh
= dwarf_decode_line_header (pdi
->line_offset
, abfd
, cu
);
1382 return; /* No linetable, so no includes. */
1384 dwarf_decode_lines (lh
, NULL
, abfd
, cu
, pst
);
1386 free_line_header (lh
);
1390 /* Build the partial symbol table by doing a quick pass through the
1391 .debug_info and .debug_abbrev sections. */
1394 dwarf2_build_psymtabs_hard (struct objfile
*objfile
, int mainline
)
1396 /* Instead of reading this into a big buffer, we should probably use
1397 mmap() on architectures that support it. (FIXME) */
1398 bfd
*abfd
= objfile
->obfd
;
1400 gdb_byte
*beg_of_comp_unit
;
1401 struct partial_die_info comp_unit_die
;
1402 struct partial_symtab
*pst
;
1403 struct cleanup
*back_to
;
1404 CORE_ADDR lowpc
, highpc
, baseaddr
;
1406 info_ptr
= dwarf2_per_objfile
->info_buffer
;
1408 /* Any cached compilation units will be linked by the per-objfile
1409 read_in_chain. Make sure to free them when we're done. */
1410 back_to
= make_cleanup (free_cached_comp_units
, NULL
);
1412 create_all_comp_units (objfile
);
1414 /* Since the objects we're extracting from .debug_info vary in
1415 length, only the individual functions to extract them (like
1416 read_comp_unit_head and load_partial_die) can really know whether
1417 the buffer is large enough to hold another complete object.
1419 At the moment, they don't actually check that. If .debug_info
1420 holds just one extra byte after the last compilation unit's dies,
1421 then read_comp_unit_head will happily read off the end of the
1422 buffer. read_partial_die is similarly casual. Those functions
1425 For this loop condition, simply checking whether there's any data
1426 left at all should be sufficient. */
1427 while (info_ptr
< (dwarf2_per_objfile
->info_buffer
1428 + dwarf2_per_objfile
->info_size
))
1430 struct cleanup
*back_to_inner
;
1431 struct dwarf2_cu cu
;
1432 struct abbrev_info
*abbrev
;
1433 unsigned int bytes_read
;
1434 struct dwarf2_per_cu_data
*this_cu
;
1436 beg_of_comp_unit
= info_ptr
;
1438 memset (&cu
, 0, sizeof (cu
));
1440 obstack_init (&cu
.comp_unit_obstack
);
1442 back_to_inner
= make_cleanup (free_stack_comp_unit
, &cu
);
1444 cu
.objfile
= objfile
;
1445 info_ptr
= partial_read_comp_unit_head (&cu
.header
, info_ptr
, abfd
);
1447 /* Complete the cu_header */
1448 cu
.header
.offset
= beg_of_comp_unit
- dwarf2_per_objfile
->info_buffer
;
1449 cu
.header
.first_die_ptr
= info_ptr
;
1450 cu
.header
.cu_head_ptr
= beg_of_comp_unit
;
1452 cu
.list_in_scope
= &file_symbols
;
1454 /* Read the abbrevs for this compilation unit into a table */
1455 dwarf2_read_abbrevs (abfd
, &cu
);
1456 make_cleanup (dwarf2_free_abbrev_table
, &cu
);
1458 this_cu
= dwarf2_find_comp_unit (cu
.header
.offset
, objfile
);
1460 /* Read the compilation unit die */
1461 abbrev
= peek_die_abbrev (info_ptr
, &bytes_read
, &cu
);
1462 info_ptr
= read_partial_die (&comp_unit_die
, abbrev
, bytes_read
,
1463 abfd
, info_ptr
, &cu
);
1465 /* Set the language we're debugging */
1466 set_cu_language (comp_unit_die
.language
, &cu
);
1468 /* Allocate a new partial symbol table structure */
1469 pst
= start_psymtab_common (objfile
, objfile
->section_offsets
,
1470 comp_unit_die
.name
? comp_unit_die
.name
: "",
1471 comp_unit_die
.lowpc
,
1472 objfile
->global_psymbols
.next
,
1473 objfile
->static_psymbols
.next
);
1475 if (comp_unit_die
.dirname
)
1476 pst
->dirname
= xstrdup (comp_unit_die
.dirname
);
1478 pst
->read_symtab_private
= (char *) this_cu
;
1480 baseaddr
= ANOFFSET (objfile
->section_offsets
, SECT_OFF_TEXT (objfile
));
1482 /* Store the function that reads in the rest of the symbol table */
1483 pst
->read_symtab
= dwarf2_psymtab_to_symtab
;
1485 /* If this compilation unit was already read in, free the
1486 cached copy in order to read it in again. This is
1487 necessary because we skipped some symbols when we first
1488 read in the compilation unit (see load_partial_dies).
1489 This problem could be avoided, but the benefit is
1491 if (this_cu
->cu
!= NULL
)
1492 free_one_cached_comp_unit (this_cu
->cu
);
1494 cu
.per_cu
= this_cu
;
1496 /* Note that this is a pointer to our stack frame, being
1497 added to a global data structure. It will be cleaned up
1498 in free_stack_comp_unit when we finish with this
1499 compilation unit. */
1502 this_cu
->psymtab
= pst
;
1504 /* Check if comp unit has_children.
1505 If so, read the rest of the partial symbols from this comp unit.
1506 If not, there's no more debug_info for this comp unit. */
1507 if (comp_unit_die
.has_children
)
1509 struct partial_die_info
*first_die
;
1511 lowpc
= ((CORE_ADDR
) -1);
1512 highpc
= ((CORE_ADDR
) 0);
1514 first_die
= load_partial_dies (abfd
, info_ptr
, 1, &cu
);
1516 scan_partial_symbols (first_die
, &lowpc
, &highpc
, &cu
);
1518 /* If we didn't find a lowpc, set it to highpc to avoid
1519 complaints from `maint check'. */
1520 if (lowpc
== ((CORE_ADDR
) -1))
1523 /* If the compilation unit didn't have an explicit address range,
1524 then use the information extracted from its child dies. */
1525 if (! comp_unit_die
.has_pc_info
)
1527 comp_unit_die
.lowpc
= lowpc
;
1528 comp_unit_die
.highpc
= highpc
;
1531 pst
->textlow
= comp_unit_die
.lowpc
+ baseaddr
;
1532 pst
->texthigh
= comp_unit_die
.highpc
+ baseaddr
;
1534 pst
->n_global_syms
= objfile
->global_psymbols
.next
-
1535 (objfile
->global_psymbols
.list
+ pst
->globals_offset
);
1536 pst
->n_static_syms
= objfile
->static_psymbols
.next
-
1537 (objfile
->static_psymbols
.list
+ pst
->statics_offset
);
1538 sort_pst_symbols (pst
);
1540 /* If there is already a psymtab or symtab for a file of this
1541 name, remove it. (If there is a symtab, more drastic things
1542 also happen.) This happens in VxWorks. */
1543 free_named_symtabs (pst
->filename
);
1545 info_ptr
= beg_of_comp_unit
+ cu
.header
.length
1546 + cu
.header
.initial_length_size
;
1548 if (comp_unit_die
.has_stmt_list
)
1550 /* Get the list of files included in the current compilation unit,
1551 and build a psymtab for each of them. */
1552 dwarf2_build_include_psymtabs (&cu
, &comp_unit_die
, pst
);
1555 do_cleanups (back_to_inner
);
1557 do_cleanups (back_to
);
1560 /* Load the DIEs for a secondary CU into memory. */
1563 load_comp_unit (struct dwarf2_per_cu_data
*this_cu
, struct objfile
*objfile
)
1565 bfd
*abfd
= objfile
->obfd
;
1566 gdb_byte
*info_ptr
, *beg_of_comp_unit
;
1567 struct partial_die_info comp_unit_die
;
1568 struct dwarf2_cu
*cu
;
1569 struct abbrev_info
*abbrev
;
1570 unsigned int bytes_read
;
1571 struct cleanup
*back_to
;
1573 info_ptr
= dwarf2_per_objfile
->info_buffer
+ this_cu
->offset
;
1574 beg_of_comp_unit
= info_ptr
;
1576 cu
= xmalloc (sizeof (struct dwarf2_cu
));
1577 memset (cu
, 0, sizeof (struct dwarf2_cu
));
1579 obstack_init (&cu
->comp_unit_obstack
);
1581 cu
->objfile
= objfile
;
1582 info_ptr
= partial_read_comp_unit_head (&cu
->header
, info_ptr
, abfd
);
1584 /* Complete the cu_header. */
1585 cu
->header
.offset
= beg_of_comp_unit
- dwarf2_per_objfile
->info_buffer
;
1586 cu
->header
.first_die_ptr
= info_ptr
;
1587 cu
->header
.cu_head_ptr
= beg_of_comp_unit
;
1589 /* Read the abbrevs for this compilation unit into a table. */
1590 dwarf2_read_abbrevs (abfd
, cu
);
1591 back_to
= make_cleanup (dwarf2_free_abbrev_table
, cu
);
1593 /* Read the compilation unit die. */
1594 abbrev
= peek_die_abbrev (info_ptr
, &bytes_read
, cu
);
1595 info_ptr
= read_partial_die (&comp_unit_die
, abbrev
, bytes_read
,
1596 abfd
, info_ptr
, cu
);
1598 /* Set the language we're debugging. */
1599 set_cu_language (comp_unit_die
.language
, cu
);
1601 /* Link this compilation unit into the compilation unit tree. */
1603 cu
->per_cu
= this_cu
;
1605 /* Check if comp unit has_children.
1606 If so, read the rest of the partial symbols from this comp unit.
1607 If not, there's no more debug_info for this comp unit. */
1608 if (comp_unit_die
.has_children
)
1609 load_partial_dies (abfd
, info_ptr
, 0, cu
);
1611 do_cleanups (back_to
);
1614 /* Create a list of all compilation units in OBJFILE. We do this only
1615 if an inter-comp-unit reference is found; presumably if there is one,
1616 there will be many, and one will occur early in the .debug_info section.
1617 So there's no point in building this list incrementally. */
1620 create_all_comp_units (struct objfile
*objfile
)
1624 struct dwarf2_per_cu_data
**all_comp_units
;
1625 gdb_byte
*info_ptr
= dwarf2_per_objfile
->info_buffer
;
1629 all_comp_units
= xmalloc (n_allocated
1630 * sizeof (struct dwarf2_per_cu_data
*));
1632 while (info_ptr
< dwarf2_per_objfile
->info_buffer
+ dwarf2_per_objfile
->info_size
)
1634 struct comp_unit_head cu_header
;
1635 gdb_byte
*beg_of_comp_unit
;
1636 struct dwarf2_per_cu_data
*this_cu
;
1637 unsigned long offset
;
1638 unsigned int bytes_read
;
1640 offset
= info_ptr
- dwarf2_per_objfile
->info_buffer
;
1642 /* Read just enough information to find out where the next
1643 compilation unit is. */
1644 cu_header
.initial_length_size
= 0;
1645 cu_header
.length
= read_initial_length (objfile
->obfd
, info_ptr
,
1646 &cu_header
, &bytes_read
);
1648 /* Save the compilation unit for later lookup. */
1649 this_cu
= obstack_alloc (&objfile
->objfile_obstack
,
1650 sizeof (struct dwarf2_per_cu_data
));
1651 memset (this_cu
, 0, sizeof (*this_cu
));
1652 this_cu
->offset
= offset
;
1653 this_cu
->length
= cu_header
.length
+ cu_header
.initial_length_size
;
1655 if (n_comp_units
== n_allocated
)
1658 all_comp_units
= xrealloc (all_comp_units
,
1660 * sizeof (struct dwarf2_per_cu_data
*));
1662 all_comp_units
[n_comp_units
++] = this_cu
;
1664 info_ptr
= info_ptr
+ this_cu
->length
;
1667 dwarf2_per_objfile
->all_comp_units
1668 = obstack_alloc (&objfile
->objfile_obstack
,
1669 n_comp_units
* sizeof (struct dwarf2_per_cu_data
*));
1670 memcpy (dwarf2_per_objfile
->all_comp_units
, all_comp_units
,
1671 n_comp_units
* sizeof (struct dwarf2_per_cu_data
*));
1672 xfree (all_comp_units
);
1673 dwarf2_per_objfile
->n_comp_units
= n_comp_units
;
1676 /* Process all loaded DIEs for compilation unit CU, starting at FIRST_DIE.
1677 Also set *LOWPC and *HIGHPC to the lowest and highest PC values found
1681 scan_partial_symbols (struct partial_die_info
*first_die
, CORE_ADDR
*lowpc
,
1682 CORE_ADDR
*highpc
, struct dwarf2_cu
*cu
)
1684 struct objfile
*objfile
= cu
->objfile
;
1685 bfd
*abfd
= objfile
->obfd
;
1686 struct partial_die_info
*pdi
;
1688 /* Now, march along the PDI's, descending into ones which have
1689 interesting children but skipping the children of the other ones,
1690 until we reach the end of the compilation unit. */
1696 fixup_partial_die (pdi
, cu
);
1698 /* Anonymous namespaces have no name but have interesting
1699 children, so we need to look at them. Ditto for anonymous
1702 if (pdi
->name
!= NULL
|| pdi
->tag
== DW_TAG_namespace
1703 || pdi
->tag
== DW_TAG_enumeration_type
)
1707 case DW_TAG_subprogram
:
1708 if (pdi
->has_pc_info
)
1710 if (pdi
->lowpc
< *lowpc
)
1712 *lowpc
= pdi
->lowpc
;
1714 if (pdi
->highpc
> *highpc
)
1716 *highpc
= pdi
->highpc
;
1718 if (!pdi
->is_declaration
)
1720 add_partial_symbol (pdi
, cu
);
1724 case DW_TAG_variable
:
1725 case DW_TAG_typedef
:
1726 case DW_TAG_union_type
:
1727 if (!pdi
->is_declaration
)
1729 add_partial_symbol (pdi
, cu
);
1732 case DW_TAG_class_type
:
1733 case DW_TAG_structure_type
:
1734 if (!pdi
->is_declaration
)
1736 add_partial_symbol (pdi
, cu
);
1739 case DW_TAG_enumeration_type
:
1740 if (!pdi
->is_declaration
)
1741 add_partial_enumeration (pdi
, cu
);
1743 case DW_TAG_base_type
:
1744 case DW_TAG_subrange_type
:
1745 /* File scope base type definitions are added to the partial
1747 add_partial_symbol (pdi
, cu
);
1749 case DW_TAG_namespace
:
1750 add_partial_namespace (pdi
, lowpc
, highpc
, cu
);
1757 /* If the die has a sibling, skip to the sibling. */
1759 pdi
= pdi
->die_sibling
;
1763 /* Functions used to compute the fully scoped name of a partial DIE.
1765 Normally, this is simple. For C++, the parent DIE's fully scoped
1766 name is concatenated with "::" and the partial DIE's name. For
1767 Java, the same thing occurs except that "." is used instead of "::".
1768 Enumerators are an exception; they use the scope of their parent
1769 enumeration type, i.e. the name of the enumeration type is not
1770 prepended to the enumerator.
1772 There are two complexities. One is DW_AT_specification; in this
1773 case "parent" means the parent of the target of the specification,
1774 instead of the direct parent of the DIE. The other is compilers
1775 which do not emit DW_TAG_namespace; in this case we try to guess
1776 the fully qualified name of structure types from their members'
1777 linkage names. This must be done using the DIE's children rather
1778 than the children of any DW_AT_specification target. We only need
1779 to do this for structures at the top level, i.e. if the target of
1780 any DW_AT_specification (if any; otherwise the DIE itself) does not
1783 /* Compute the scope prefix associated with PDI's parent, in
1784 compilation unit CU. The result will be allocated on CU's
1785 comp_unit_obstack, or a copy of the already allocated PDI->NAME
1786 field. NULL is returned if no prefix is necessary. */
1788 partial_die_parent_scope (struct partial_die_info
*pdi
,
1789 struct dwarf2_cu
*cu
)
1791 char *grandparent_scope
;
1792 struct partial_die_info
*parent
, *real_pdi
;
1794 /* We need to look at our parent DIE; if we have a DW_AT_specification,
1795 then this means the parent of the specification DIE. */
1798 while (real_pdi
->has_specification
)
1799 real_pdi
= find_partial_die (real_pdi
->spec_offset
, cu
);
1801 parent
= real_pdi
->die_parent
;
1805 if (parent
->scope_set
)
1806 return parent
->scope
;
1808 fixup_partial_die (parent
, cu
);
1810 grandparent_scope
= partial_die_parent_scope (parent
, cu
);
1812 if (parent
->tag
== DW_TAG_namespace
1813 || parent
->tag
== DW_TAG_structure_type
1814 || parent
->tag
== DW_TAG_class_type
1815 || parent
->tag
== DW_TAG_union_type
)
1817 if (grandparent_scope
== NULL
)
1818 parent
->scope
= parent
->name
;
1820 parent
->scope
= typename_concat (&cu
->comp_unit_obstack
, grandparent_scope
,
1823 else if (parent
->tag
== DW_TAG_enumeration_type
)
1824 /* Enumerators should not get the name of the enumeration as a prefix. */
1825 parent
->scope
= grandparent_scope
;
1828 /* FIXME drow/2004-04-01: What should we be doing with
1829 function-local names? For partial symbols, we should probably be
1831 complaint (&symfile_complaints
,
1832 _("unhandled containing DIE tag %d for DIE at %d"),
1833 parent
->tag
, pdi
->offset
);
1834 parent
->scope
= grandparent_scope
;
1837 parent
->scope_set
= 1;
1838 return parent
->scope
;
1841 /* Return the fully scoped name associated with PDI, from compilation unit
1842 CU. The result will be allocated with malloc. */
1844 partial_die_full_name (struct partial_die_info
*pdi
,
1845 struct dwarf2_cu
*cu
)
1849 parent_scope
= partial_die_parent_scope (pdi
, cu
);
1850 if (parent_scope
== NULL
)
1853 return typename_concat (NULL
, parent_scope
, pdi
->name
, cu
);
1857 add_partial_symbol (struct partial_die_info
*pdi
, struct dwarf2_cu
*cu
)
1859 struct objfile
*objfile
= cu
->objfile
;
1862 const char *my_prefix
;
1863 const struct partial_symbol
*psym
= NULL
;
1865 int built_actual_name
= 0;
1867 baseaddr
= ANOFFSET (objfile
->section_offsets
, SECT_OFF_TEXT (objfile
));
1871 if (pdi_needs_namespace (pdi
->tag
))
1873 actual_name
= partial_die_full_name (pdi
, cu
);
1875 built_actual_name
= 1;
1878 if (actual_name
== NULL
)
1879 actual_name
= pdi
->name
;
1883 case DW_TAG_subprogram
:
1884 if (pdi
->is_external
)
1886 /*prim_record_minimal_symbol (actual_name, pdi->lowpc + baseaddr,
1887 mst_text, objfile); */
1888 psym
= add_psymbol_to_list (actual_name
, strlen (actual_name
),
1889 VAR_DOMAIN
, LOC_BLOCK
,
1890 &objfile
->global_psymbols
,
1891 0, pdi
->lowpc
+ baseaddr
,
1892 cu
->language
, objfile
);
1896 /*prim_record_minimal_symbol (actual_name, pdi->lowpc + baseaddr,
1897 mst_file_text, objfile); */
1898 psym
= add_psymbol_to_list (actual_name
, strlen (actual_name
),
1899 VAR_DOMAIN
, LOC_BLOCK
,
1900 &objfile
->static_psymbols
,
1901 0, pdi
->lowpc
+ baseaddr
,
1902 cu
->language
, objfile
);
1905 case DW_TAG_variable
:
1906 if (pdi
->is_external
)
1909 Don't enter into the minimal symbol tables as there is
1910 a minimal symbol table entry from the ELF symbols already.
1911 Enter into partial symbol table if it has a location
1912 descriptor or a type.
1913 If the location descriptor is missing, new_symbol will create
1914 a LOC_UNRESOLVED symbol, the address of the variable will then
1915 be determined from the minimal symbol table whenever the variable
1917 The address for the partial symbol table entry is not
1918 used by GDB, but it comes in handy for debugging partial symbol
1922 addr
= decode_locdesc (pdi
->locdesc
, cu
);
1923 if (pdi
->locdesc
|| pdi
->has_type
)
1924 psym
= add_psymbol_to_list (actual_name
, strlen (actual_name
),
1925 VAR_DOMAIN
, LOC_STATIC
,
1926 &objfile
->global_psymbols
,
1928 cu
->language
, objfile
);
1932 /* Static Variable. Skip symbols without location descriptors. */
1933 if (pdi
->locdesc
== NULL
)
1935 addr
= decode_locdesc (pdi
->locdesc
, cu
);
1936 /*prim_record_minimal_symbol (actual_name, addr + baseaddr,
1937 mst_file_data, objfile); */
1938 psym
= add_psymbol_to_list (actual_name
, strlen (actual_name
),
1939 VAR_DOMAIN
, LOC_STATIC
,
1940 &objfile
->static_psymbols
,
1942 cu
->language
, objfile
);
1945 case DW_TAG_typedef
:
1946 case DW_TAG_base_type
:
1947 case DW_TAG_subrange_type
:
1948 add_psymbol_to_list (actual_name
, strlen (actual_name
),
1949 VAR_DOMAIN
, LOC_TYPEDEF
,
1950 &objfile
->static_psymbols
,
1951 0, (CORE_ADDR
) 0, cu
->language
, objfile
);
1953 case DW_TAG_namespace
:
1954 add_psymbol_to_list (actual_name
, strlen (actual_name
),
1955 VAR_DOMAIN
, LOC_TYPEDEF
,
1956 &objfile
->global_psymbols
,
1957 0, (CORE_ADDR
) 0, cu
->language
, objfile
);
1959 case DW_TAG_class_type
:
1960 case DW_TAG_structure_type
:
1961 case DW_TAG_union_type
:
1962 case DW_TAG_enumeration_type
:
1963 /* Skip aggregate types without children, these are external
1965 /* NOTE: carlton/2003-10-07: See comment in new_symbol about
1966 static vs. global. */
1967 if (pdi
->has_children
== 0)
1969 add_psymbol_to_list (actual_name
, strlen (actual_name
),
1970 STRUCT_DOMAIN
, LOC_TYPEDEF
,
1971 (cu
->language
== language_cplus
1972 || cu
->language
== language_java
)
1973 ? &objfile
->global_psymbols
1974 : &objfile
->static_psymbols
,
1975 0, (CORE_ADDR
) 0, cu
->language
, objfile
);
1977 if (cu
->language
== language_cplus
1978 || cu
->language
== language_java
)
1980 /* For C++ and Java, these implicitly act as typedefs as well. */
1981 add_psymbol_to_list (actual_name
, strlen (actual_name
),
1982 VAR_DOMAIN
, LOC_TYPEDEF
,
1983 &objfile
->global_psymbols
,
1984 0, (CORE_ADDR
) 0, cu
->language
, objfile
);
1987 case DW_TAG_enumerator
:
1988 add_psymbol_to_list (actual_name
, strlen (actual_name
),
1989 VAR_DOMAIN
, LOC_CONST
,
1990 (cu
->language
== language_cplus
1991 || cu
->language
== language_java
)
1992 ? &objfile
->global_psymbols
1993 : &objfile
->static_psymbols
,
1994 0, (CORE_ADDR
) 0, cu
->language
, objfile
);
2000 /* Check to see if we should scan the name for possible namespace
2001 info. Only do this if this is C++, if we don't have namespace
2002 debugging info in the file, if the psym is of an appropriate type
2003 (otherwise we'll have psym == NULL), and if we actually had a
2004 mangled name to begin with. */
2006 /* FIXME drow/2004-02-22: Why don't we do this for classes, i.e. the
2007 cases which do not set PSYM above? */
2009 if (cu
->language
== language_cplus
2010 && cu
->has_namespace_info
== 0
2012 && SYMBOL_CPLUS_DEMANGLED_NAME (psym
) != NULL
)
2013 cp_check_possible_namespace_symbols (SYMBOL_CPLUS_DEMANGLED_NAME (psym
),
2016 if (built_actual_name
)
2017 xfree (actual_name
);
2020 /* Determine whether a die of type TAG living in a C++ class or
2021 namespace needs to have the name of the scope prepended to the
2022 name listed in the die. */
2025 pdi_needs_namespace (enum dwarf_tag tag
)
2029 case DW_TAG_namespace
:
2030 case DW_TAG_typedef
:
2031 case DW_TAG_class_type
:
2032 case DW_TAG_structure_type
:
2033 case DW_TAG_union_type
:
2034 case DW_TAG_enumeration_type
:
2035 case DW_TAG_enumerator
:
2042 /* Read a partial die corresponding to a namespace; also, add a symbol
2043 corresponding to that namespace to the symbol table. NAMESPACE is
2044 the name of the enclosing namespace. */
2047 add_partial_namespace (struct partial_die_info
*pdi
,
2048 CORE_ADDR
*lowpc
, CORE_ADDR
*highpc
,
2049 struct dwarf2_cu
*cu
)
2051 struct objfile
*objfile
= cu
->objfile
;
2053 /* Add a symbol for the namespace. */
2055 add_partial_symbol (pdi
, cu
);
2057 /* Now scan partial symbols in that namespace. */
2059 if (pdi
->has_children
)
2060 scan_partial_symbols (pdi
->die_child
, lowpc
, highpc
, cu
);
2063 /* See if we can figure out if the class lives in a namespace. We do
2064 this by looking for a member function; its demangled name will
2065 contain namespace info, if there is any. */
2068 guess_structure_name (struct partial_die_info
*struct_pdi
,
2069 struct dwarf2_cu
*cu
)
2071 if ((cu
->language
== language_cplus
2072 || cu
->language
== language_java
)
2073 && cu
->has_namespace_info
== 0
2074 && struct_pdi
->has_children
)
2076 /* NOTE: carlton/2003-10-07: Getting the info this way changes
2077 what template types look like, because the demangler
2078 frequently doesn't give the same name as the debug info. We
2079 could fix this by only using the demangled name to get the
2080 prefix (but see comment in read_structure_type). */
2082 struct partial_die_info
*child_pdi
= struct_pdi
->die_child
;
2083 struct partial_die_info
*real_pdi
;
2085 /* If this DIE (this DIE's specification, if any) has a parent, then
2086 we should not do this. We'll prepend the parent's fully qualified
2087 name when we create the partial symbol. */
2089 real_pdi
= struct_pdi
;
2090 while (real_pdi
->has_specification
)
2091 real_pdi
= find_partial_die (real_pdi
->spec_offset
, cu
);
2093 if (real_pdi
->die_parent
!= NULL
)
2096 while (child_pdi
!= NULL
)
2098 if (child_pdi
->tag
== DW_TAG_subprogram
)
2100 char *actual_class_name
2101 = language_class_name_from_physname (cu
->language_defn
,
2103 if (actual_class_name
!= NULL
)
2106 = obsavestring (actual_class_name
,
2107 strlen (actual_class_name
),
2108 &cu
->comp_unit_obstack
);
2109 xfree (actual_class_name
);
2114 child_pdi
= child_pdi
->die_sibling
;
2119 /* Read a partial die corresponding to an enumeration type. */
2122 add_partial_enumeration (struct partial_die_info
*enum_pdi
,
2123 struct dwarf2_cu
*cu
)
2125 struct objfile
*objfile
= cu
->objfile
;
2126 bfd
*abfd
= objfile
->obfd
;
2127 struct partial_die_info
*pdi
;
2129 if (enum_pdi
->name
!= NULL
)
2130 add_partial_symbol (enum_pdi
, cu
);
2132 pdi
= enum_pdi
->die_child
;
2135 if (pdi
->tag
!= DW_TAG_enumerator
|| pdi
->name
== NULL
)
2136 complaint (&symfile_complaints
, _("malformed enumerator DIE ignored"));
2138 add_partial_symbol (pdi
, cu
);
2139 pdi
= pdi
->die_sibling
;
2143 /* Read the initial uleb128 in the die at INFO_PTR in compilation unit CU.
2144 Return the corresponding abbrev, or NULL if the number is zero (indicating
2145 an empty DIE). In either case *BYTES_READ will be set to the length of
2146 the initial number. */
2148 static struct abbrev_info
*
2149 peek_die_abbrev (gdb_byte
*info_ptr
, unsigned int *bytes_read
,
2150 struct dwarf2_cu
*cu
)
2152 bfd
*abfd
= cu
->objfile
->obfd
;
2153 unsigned int abbrev_number
;
2154 struct abbrev_info
*abbrev
;
2156 abbrev_number
= read_unsigned_leb128 (abfd
, info_ptr
, bytes_read
);
2158 if (abbrev_number
== 0)
2161 abbrev
= dwarf2_lookup_abbrev (abbrev_number
, cu
);
2164 error (_("Dwarf Error: Could not find abbrev number %d [in module %s]"), abbrev_number
,
2165 bfd_get_filename (abfd
));
2171 /* Scan the debug information for CU starting at INFO_PTR. Returns a
2172 pointer to the end of a series of DIEs, terminated by an empty
2173 DIE. Any children of the skipped DIEs will also be skipped. */
2176 skip_children (gdb_byte
*info_ptr
, struct dwarf2_cu
*cu
)
2178 struct abbrev_info
*abbrev
;
2179 unsigned int bytes_read
;
2183 abbrev
= peek_die_abbrev (info_ptr
, &bytes_read
, cu
);
2185 return info_ptr
+ bytes_read
;
2187 info_ptr
= skip_one_die (info_ptr
+ bytes_read
, abbrev
, cu
);
2191 /* Scan the debug information for CU starting at INFO_PTR. INFO_PTR
2192 should point just after the initial uleb128 of a DIE, and the
2193 abbrev corresponding to that skipped uleb128 should be passed in
2194 ABBREV. Returns a pointer to this DIE's sibling, skipping any
2198 skip_one_die (gdb_byte
*info_ptr
, struct abbrev_info
*abbrev
,
2199 struct dwarf2_cu
*cu
)
2201 unsigned int bytes_read
;
2202 struct attribute attr
;
2203 bfd
*abfd
= cu
->objfile
->obfd
;
2204 unsigned int form
, i
;
2206 for (i
= 0; i
< abbrev
->num_attrs
; i
++)
2208 /* The only abbrev we care about is DW_AT_sibling. */
2209 if (abbrev
->attrs
[i
].name
== DW_AT_sibling
)
2211 read_attribute (&attr
, &abbrev
->attrs
[i
],
2212 abfd
, info_ptr
, cu
);
2213 if (attr
.form
== DW_FORM_ref_addr
)
2214 complaint (&symfile_complaints
, _("ignoring absolute DW_AT_sibling"));
2216 return dwarf2_per_objfile
->info_buffer
2217 + dwarf2_get_ref_die_offset (&attr
, cu
);
2220 /* If it isn't DW_AT_sibling, skip this attribute. */
2221 form
= abbrev
->attrs
[i
].form
;
2226 case DW_FORM_ref_addr
:
2227 info_ptr
+= cu
->header
.addr_size
;
2246 case DW_FORM_string
:
2247 read_string (abfd
, info_ptr
, &bytes_read
);
2248 info_ptr
+= bytes_read
;
2251 info_ptr
+= cu
->header
.offset_size
;
2254 info_ptr
+= read_unsigned_leb128 (abfd
, info_ptr
, &bytes_read
);
2255 info_ptr
+= bytes_read
;
2257 case DW_FORM_block1
:
2258 info_ptr
+= 1 + read_1_byte (abfd
, info_ptr
);
2260 case DW_FORM_block2
:
2261 info_ptr
+= 2 + read_2_bytes (abfd
, info_ptr
);
2263 case DW_FORM_block4
:
2264 info_ptr
+= 4 + read_4_bytes (abfd
, info_ptr
);
2268 case DW_FORM_ref_udata
:
2269 info_ptr
= skip_leb128 (abfd
, info_ptr
);
2271 case DW_FORM_indirect
:
2272 form
= read_unsigned_leb128 (abfd
, info_ptr
, &bytes_read
);
2273 info_ptr
+= bytes_read
;
2274 /* We need to continue parsing from here, so just go back to
2276 goto skip_attribute
;
2279 error (_("Dwarf Error: Cannot handle %s in DWARF reader [in module %s]"),
2280 dwarf_form_name (form
),
2281 bfd_get_filename (abfd
));
2285 if (abbrev
->has_children
)
2286 return skip_children (info_ptr
, cu
);
2291 /* Locate ORIG_PDI's sibling; INFO_PTR should point to the start of
2292 the next DIE after ORIG_PDI. */
2295 locate_pdi_sibling (struct partial_die_info
*orig_pdi
, gdb_byte
*info_ptr
,
2296 bfd
*abfd
, struct dwarf2_cu
*cu
)
2298 /* Do we know the sibling already? */
2300 if (orig_pdi
->sibling
)
2301 return orig_pdi
->sibling
;
2303 /* Are there any children to deal with? */
2305 if (!orig_pdi
->has_children
)
2308 /* Skip the children the long way. */
2310 return skip_children (info_ptr
, cu
);
2313 /* Expand this partial symbol table into a full symbol table. */
2316 dwarf2_psymtab_to_symtab (struct partial_symtab
*pst
)
2318 /* FIXME: This is barely more than a stub. */
2323 warning (_("bug: psymtab for %s is already read in."), pst
->filename
);
2329 printf_filtered (_("Reading in symbols for %s..."), pst
->filename
);
2330 gdb_flush (gdb_stdout
);
2333 /* Restore our global data. */
2334 dwarf2_per_objfile
= objfile_data (pst
->objfile
,
2335 dwarf2_objfile_data_key
);
2337 psymtab_to_symtab_1 (pst
);
2339 /* Finish up the debug error message. */
2341 printf_filtered (_("done.\n"));
2346 /* Add PER_CU to the queue. */
2349 queue_comp_unit (struct dwarf2_per_cu_data
*per_cu
)
2351 struct dwarf2_queue_item
*item
;
2354 item
= xmalloc (sizeof (*item
));
2355 item
->per_cu
= per_cu
;
2358 if (dwarf2_queue
== NULL
)
2359 dwarf2_queue
= item
;
2361 dwarf2_queue_tail
->next
= item
;
2363 dwarf2_queue_tail
= item
;
2366 /* Process the queue. */
2369 process_queue (struct objfile
*objfile
)
2371 struct dwarf2_queue_item
*item
, *next_item
;
2373 /* Initially, there is just one item on the queue. Load its DIEs,
2374 and the DIEs of any other compilation units it requires,
2377 for (item
= dwarf2_queue
; item
!= NULL
; item
= item
->next
)
2379 /* Read in this compilation unit. This may add new items to
2380 the end of the queue. */
2381 load_full_comp_unit (item
->per_cu
);
2383 item
->per_cu
->cu
->read_in_chain
= dwarf2_per_objfile
->read_in_chain
;
2384 dwarf2_per_objfile
->read_in_chain
= item
->per_cu
;
2386 /* If this compilation unit has already had full symbols created,
2387 reset the TYPE fields in each DIE. */
2388 if (item
->per_cu
->psymtab
->readin
)
2389 reset_die_and_siblings_types (item
->per_cu
->cu
->dies
,
2393 /* Now everything left on the queue needs to be read in. Process
2394 them, one at a time, removing from the queue as we finish. */
2395 for (item
= dwarf2_queue
; item
!= NULL
; dwarf2_queue
= item
= next_item
)
2397 if (!item
->per_cu
->psymtab
->readin
)
2398 process_full_comp_unit (item
->per_cu
);
2400 item
->per_cu
->queued
= 0;
2401 next_item
= item
->next
;
2405 dwarf2_queue_tail
= NULL
;
2408 /* Free all allocated queue entries. This function only releases anything if
2409 an error was thrown; if the queue was processed then it would have been
2410 freed as we went along. */
2413 dwarf2_release_queue (void *dummy
)
2415 struct dwarf2_queue_item
*item
, *last
;
2417 item
= dwarf2_queue
;
2420 /* Anything still marked queued is likely to be in an
2421 inconsistent state, so discard it. */
2422 if (item
->per_cu
->queued
)
2424 if (item
->per_cu
->cu
!= NULL
)
2425 free_one_cached_comp_unit (item
->per_cu
->cu
);
2426 item
->per_cu
->queued
= 0;
2434 dwarf2_queue
= dwarf2_queue_tail
= NULL
;
2437 /* Read in full symbols for PST, and anything it depends on. */
2440 psymtab_to_symtab_1 (struct partial_symtab
*pst
)
2442 struct dwarf2_per_cu_data
*per_cu
;
2443 struct cleanup
*back_to
;
2446 for (i
= 0; i
< pst
->number_of_dependencies
; i
++)
2447 if (!pst
->dependencies
[i
]->readin
)
2449 /* Inform about additional files that need to be read in. */
2452 /* FIXME: i18n: Need to make this a single string. */
2453 fputs_filtered (" ", gdb_stdout
);
2455 fputs_filtered ("and ", gdb_stdout
);
2457 printf_filtered ("%s...", pst
->dependencies
[i
]->filename
);
2458 wrap_here (""); /* Flush output */
2459 gdb_flush (gdb_stdout
);
2461 psymtab_to_symtab_1 (pst
->dependencies
[i
]);
2464 per_cu
= (struct dwarf2_per_cu_data
*) pst
->read_symtab_private
;
2468 /* It's an include file, no symbols to read for it.
2469 Everything is in the parent symtab. */
2474 back_to
= make_cleanup (dwarf2_release_queue
, NULL
);
2476 queue_comp_unit (per_cu
);
2478 process_queue (pst
->objfile
);
2480 /* Age the cache, releasing compilation units that have not
2481 been used recently. */
2482 age_cached_comp_units ();
2484 do_cleanups (back_to
);
2487 /* Load the DIEs associated with PST and PER_CU into memory. */
2489 static struct dwarf2_cu
*
2490 load_full_comp_unit (struct dwarf2_per_cu_data
*per_cu
)
2492 struct partial_symtab
*pst
= per_cu
->psymtab
;
2493 bfd
*abfd
= pst
->objfile
->obfd
;
2494 struct dwarf2_cu
*cu
;
2495 unsigned long offset
;
2497 struct cleanup
*back_to
, *free_cu_cleanup
;
2498 struct attribute
*attr
;
2501 /* Set local variables from the partial symbol table info. */
2502 offset
= per_cu
->offset
;
2504 info_ptr
= dwarf2_per_objfile
->info_buffer
+ offset
;
2506 cu
= xmalloc (sizeof (struct dwarf2_cu
));
2507 memset (cu
, 0, sizeof (struct dwarf2_cu
));
2509 /* If an error occurs while loading, release our storage. */
2510 free_cu_cleanup
= make_cleanup (free_one_comp_unit
, cu
);
2512 cu
->objfile
= pst
->objfile
;
2514 /* read in the comp_unit header */
2515 info_ptr
= read_comp_unit_head (&cu
->header
, info_ptr
, abfd
);
2517 /* Read the abbrevs for this compilation unit */
2518 dwarf2_read_abbrevs (abfd
, cu
);
2519 back_to
= make_cleanup (dwarf2_free_abbrev_table
, cu
);
2521 cu
->header
.offset
= offset
;
2523 cu
->per_cu
= per_cu
;
2526 /* We use this obstack for block values in dwarf_alloc_block. */
2527 obstack_init (&cu
->comp_unit_obstack
);
2529 cu
->dies
= read_comp_unit (info_ptr
, abfd
, cu
);
2531 /* We try not to read any attributes in this function, because not
2532 all objfiles needed for references have been loaded yet, and symbol
2533 table processing isn't initialized. But we have to set the CU language,
2534 or we won't be able to build types correctly. */
2535 attr
= dwarf2_attr (cu
->dies
, DW_AT_language
, cu
);
2537 set_cu_language (DW_UNSND (attr
), cu
);
2539 set_cu_language (language_minimal
, cu
);
2541 do_cleanups (back_to
);
2543 /* We've successfully allocated this compilation unit. Let our caller
2544 clean it up when finished with it. */
2545 discard_cleanups (free_cu_cleanup
);
2550 /* Generate full symbol information for PST and CU, whose DIEs have
2551 already been loaded into memory. */
2554 process_full_comp_unit (struct dwarf2_per_cu_data
*per_cu
)
2556 struct partial_symtab
*pst
= per_cu
->psymtab
;
2557 struct dwarf2_cu
*cu
= per_cu
->cu
;
2558 struct objfile
*objfile
= pst
->objfile
;
2559 bfd
*abfd
= objfile
->obfd
;
2560 CORE_ADDR lowpc
, highpc
;
2561 struct symtab
*symtab
;
2562 struct cleanup
*back_to
;
2563 struct attribute
*attr
;
2566 baseaddr
= ANOFFSET (objfile
->section_offsets
, SECT_OFF_TEXT (objfile
));
2568 /* We're in the global namespace. */
2569 processing_current_prefix
= "";
2572 back_to
= make_cleanup (really_free_pendings
, NULL
);
2574 cu
->list_in_scope
= &file_symbols
;
2576 /* Find the base address of the compilation unit for range lists and
2577 location lists. It will normally be specified by DW_AT_low_pc.
2578 In DWARF-3 draft 4, the base address could be overridden by
2579 DW_AT_entry_pc. It's been removed, but GCC still uses this for
2580 compilation units with discontinuous ranges. */
2582 cu
->header
.base_known
= 0;
2583 cu
->header
.base_address
= 0;
2585 attr
= dwarf2_attr (cu
->dies
, DW_AT_entry_pc
, cu
);
2588 cu
->header
.base_address
= DW_ADDR (attr
);
2589 cu
->header
.base_known
= 1;
2593 attr
= dwarf2_attr (cu
->dies
, DW_AT_low_pc
, cu
);
2596 cu
->header
.base_address
= DW_ADDR (attr
);
2597 cu
->header
.base_known
= 1;
2601 /* Do line number decoding in read_file_scope () */
2602 process_die (cu
->dies
, cu
);
2604 /* Some compilers don't define a DW_AT_high_pc attribute for the
2605 compilation unit. If the DW_AT_high_pc is missing, synthesize
2606 it, by scanning the DIE's below the compilation unit. */
2607 get_scope_pc_bounds (cu
->dies
, &lowpc
, &highpc
, cu
);
2609 symtab
= end_symtab (highpc
+ baseaddr
, objfile
, SECT_OFF_TEXT (objfile
));
2611 /* Set symtab language to language from DW_AT_language.
2612 If the compilation is from a C file generated by language preprocessors,
2613 do not set the language if it was already deduced by start_subfile. */
2615 && !(cu
->language
== language_c
&& symtab
->language
!= language_c
))
2617 symtab
->language
= cu
->language
;
2619 pst
->symtab
= symtab
;
2622 do_cleanups (back_to
);
2625 /* Process a die and its children. */
2628 process_die (struct die_info
*die
, struct dwarf2_cu
*cu
)
2632 case DW_TAG_padding
:
2634 case DW_TAG_compile_unit
:
2635 read_file_scope (die
, cu
);
2637 case DW_TAG_subprogram
:
2638 read_subroutine_type (die
, cu
);
2639 read_func_scope (die
, cu
);
2641 case DW_TAG_inlined_subroutine
:
2642 /* FIXME: These are ignored for now.
2643 They could be used to set breakpoints on all inlined instances
2644 of a function and make GDB `next' properly over inlined functions. */
2646 case DW_TAG_lexical_block
:
2647 case DW_TAG_try_block
:
2648 case DW_TAG_catch_block
:
2649 read_lexical_block_scope (die
, cu
);
2651 case DW_TAG_class_type
:
2652 case DW_TAG_structure_type
:
2653 case DW_TAG_union_type
:
2654 read_structure_type (die
, cu
);
2655 process_structure_scope (die
, cu
);
2657 case DW_TAG_enumeration_type
:
2658 read_enumeration_type (die
, cu
);
2659 process_enumeration_scope (die
, cu
);
2662 /* FIXME drow/2004-03-14: These initialize die->type, but do not create
2663 a symbol or process any children. Therefore it doesn't do anything
2664 that won't be done on-demand by read_type_die. */
2665 case DW_TAG_subroutine_type
:
2666 read_subroutine_type (die
, cu
);
2668 case DW_TAG_set_type
:
2669 read_set_type (die
, cu
);
2671 case DW_TAG_array_type
:
2672 read_array_type (die
, cu
);
2674 case DW_TAG_pointer_type
:
2675 read_tag_pointer_type (die
, cu
);
2677 case DW_TAG_ptr_to_member_type
:
2678 read_tag_ptr_to_member_type (die
, cu
);
2680 case DW_TAG_reference_type
:
2681 read_tag_reference_type (die
, cu
);
2683 case DW_TAG_string_type
:
2684 read_tag_string_type (die
, cu
);
2688 case DW_TAG_base_type
:
2689 read_base_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_subrange_type
:
2695 read_subrange_type (die
, cu
);
2696 /* Add a typedef symbol for the type definition, if it has a
2698 new_symbol (die
, die
->type
, cu
);
2700 case DW_TAG_common_block
:
2701 read_common_block (die
, cu
);
2703 case DW_TAG_common_inclusion
:
2705 case DW_TAG_namespace
:
2706 processing_has_namespace_info
= 1;
2707 read_namespace (die
, cu
);
2709 case DW_TAG_imported_declaration
:
2710 case DW_TAG_imported_module
:
2711 /* FIXME: carlton/2002-10-16: Eventually, we should use the
2712 information contained in these. DW_TAG_imported_declaration
2713 dies shouldn't have children; DW_TAG_imported_module dies
2714 shouldn't in the C++ case, but conceivably could in the
2715 Fortran case, so we'll have to replace this gdb_assert if
2716 Fortran compilers start generating that info. */
2717 processing_has_namespace_info
= 1;
2718 gdb_assert (die
->child
== NULL
);
2721 new_symbol (die
, NULL
, cu
);
2727 initialize_cu_func_list (struct dwarf2_cu
*cu
)
2729 cu
->first_fn
= cu
->last_fn
= cu
->cached_fn
= NULL
;
2733 read_file_scope (struct die_info
*die
, struct dwarf2_cu
*cu
)
2735 struct objfile
*objfile
= cu
->objfile
;
2736 struct comp_unit_head
*cu_header
= &cu
->header
;
2737 struct cleanup
*back_to
= make_cleanup (null_cleanup
, 0);
2738 CORE_ADDR lowpc
= ((CORE_ADDR
) -1);
2739 CORE_ADDR highpc
= ((CORE_ADDR
) 0);
2740 struct attribute
*attr
;
2741 char *name
= "<unknown>";
2742 char *comp_dir
= NULL
;
2743 struct die_info
*child_die
;
2744 bfd
*abfd
= objfile
->obfd
;
2745 struct line_header
*line_header
= 0;
2748 baseaddr
= ANOFFSET (objfile
->section_offsets
, SECT_OFF_TEXT (objfile
));
2750 get_scope_pc_bounds (die
, &lowpc
, &highpc
, cu
);
2752 /* If we didn't find a lowpc, set it to highpc to avoid complaints
2753 from finish_block. */
2754 if (lowpc
== ((CORE_ADDR
) -1))
2759 attr
= dwarf2_attr (die
, DW_AT_name
, cu
);
2762 name
= DW_STRING (attr
);
2764 attr
= dwarf2_attr (die
, DW_AT_comp_dir
, cu
);
2767 comp_dir
= DW_STRING (attr
);
2770 /* Irix 6.2 native cc prepends <machine>.: to the compilation
2771 directory, get rid of it. */
2772 char *cp
= strchr (comp_dir
, ':');
2774 if (cp
&& cp
!= comp_dir
&& cp
[-1] == '.' && cp
[1] == '/')
2779 attr
= dwarf2_attr (die
, DW_AT_language
, cu
);
2782 set_cu_language (DW_UNSND (attr
), cu
);
2785 attr
= dwarf2_attr (die
, DW_AT_producer
, cu
);
2787 cu
->producer
= DW_STRING (attr
);
2789 /* We assume that we're processing GCC output. */
2790 processing_gcc_compilation
= 2;
2792 /* FIXME:Do something here. */
2793 if (dip
->at_producer
!= NULL
)
2795 handle_producer (dip
->at_producer
);
2799 /* The compilation unit may be in a different language or objfile,
2800 zero out all remembered fundamental types. */
2801 memset (cu
->ftypes
, 0, FT_NUM_MEMBERS
* sizeof (struct type
*));
2803 start_symtab (name
, comp_dir
, lowpc
);
2804 record_debugformat ("DWARF 2");
2806 initialize_cu_func_list (cu
);
2808 /* Process all dies in compilation unit. */
2809 if (die
->child
!= NULL
)
2811 child_die
= die
->child
;
2812 while (child_die
&& child_die
->tag
)
2814 process_die (child_die
, cu
);
2815 child_die
= sibling_die (child_die
);
2819 /* Decode line number information if present. */
2820 attr
= dwarf2_attr (die
, DW_AT_stmt_list
, cu
);
2823 unsigned int line_offset
= DW_UNSND (attr
);
2824 line_header
= dwarf_decode_line_header (line_offset
, abfd
, cu
);
2827 make_cleanup ((make_cleanup_ftype
*) free_line_header
,
2828 (void *) line_header
);
2829 dwarf_decode_lines (line_header
, comp_dir
, abfd
, cu
, NULL
);
2833 /* Decode macro information, if present. Dwarf 2 macro information
2834 refers to information in the line number info statement program
2835 header, so we can only read it if we've read the header
2837 attr
= dwarf2_attr (die
, DW_AT_macro_info
, cu
);
2838 if (attr
&& line_header
)
2840 unsigned int macro_offset
= DW_UNSND (attr
);
2841 dwarf_decode_macros (line_header
, macro_offset
,
2842 comp_dir
, abfd
, cu
);
2844 do_cleanups (back_to
);
2848 add_to_cu_func_list (const char *name
, CORE_ADDR lowpc
, CORE_ADDR highpc
,
2849 struct dwarf2_cu
*cu
)
2851 struct function_range
*thisfn
;
2853 thisfn
= (struct function_range
*)
2854 obstack_alloc (&cu
->comp_unit_obstack
, sizeof (struct function_range
));
2855 thisfn
->name
= name
;
2856 thisfn
->lowpc
= lowpc
;
2857 thisfn
->highpc
= highpc
;
2858 thisfn
->seen_line
= 0;
2859 thisfn
->next
= NULL
;
2861 if (cu
->last_fn
== NULL
)
2862 cu
->first_fn
= thisfn
;
2864 cu
->last_fn
->next
= thisfn
;
2866 cu
->last_fn
= thisfn
;
2870 read_func_scope (struct die_info
*die
, struct dwarf2_cu
*cu
)
2872 struct objfile
*objfile
= cu
->objfile
;
2873 struct context_stack
*new;
2876 struct die_info
*child_die
;
2877 struct attribute
*attr
;
2879 const char *previous_prefix
= processing_current_prefix
;
2880 struct cleanup
*back_to
= NULL
;
2883 baseaddr
= ANOFFSET (objfile
->section_offsets
, SECT_OFF_TEXT (objfile
));
2885 name
= dwarf2_linkage_name (die
, cu
);
2887 /* Ignore functions with missing or empty names and functions with
2888 missing or invalid low and high pc attributes. */
2889 if (name
== NULL
|| !dwarf2_get_pc_bounds (die
, &lowpc
, &highpc
, cu
))
2892 if (cu
->language
== language_cplus
2893 || cu
->language
== language_java
)
2895 struct die_info
*spec_die
= die_specification (die
, cu
);
2897 /* NOTE: carlton/2004-01-23: We have to be careful in the
2898 presence of DW_AT_specification. For example, with GCC 3.4,
2903 // Definition of N::foo.
2907 then we'll have a tree of DIEs like this:
2909 1: DW_TAG_compile_unit
2910 2: DW_TAG_namespace // N
2911 3: DW_TAG_subprogram // declaration of N::foo
2912 4: DW_TAG_subprogram // definition of N::foo
2913 DW_AT_specification // refers to die #3
2915 Thus, when processing die #4, we have to pretend that we're
2916 in the context of its DW_AT_specification, namely the contex
2919 if (spec_die
!= NULL
)
2921 char *specification_prefix
= determine_prefix (spec_die
, cu
);
2922 processing_current_prefix
= specification_prefix
;
2923 back_to
= make_cleanup (xfree
, specification_prefix
);
2930 /* Record the function range for dwarf_decode_lines. */
2931 add_to_cu_func_list (name
, lowpc
, highpc
, cu
);
2933 new = push_context (0, lowpc
);
2934 new->name
= new_symbol (die
, die
->type
, cu
);
2936 /* If there is a location expression for DW_AT_frame_base, record
2938 attr
= dwarf2_attr (die
, DW_AT_frame_base
, cu
);
2940 /* FIXME: cagney/2004-01-26: The DW_AT_frame_base's location
2941 expression is being recorded directly in the function's symbol
2942 and not in a separate frame-base object. I guess this hack is
2943 to avoid adding some sort of frame-base adjunct/annex to the
2944 function's symbol :-(. The problem with doing this is that it
2945 results in a function symbol with a location expression that
2946 has nothing to do with the location of the function, ouch! The
2947 relationship should be: a function's symbol has-a frame base; a
2948 frame-base has-a location expression. */
2949 dwarf2_symbol_mark_computed (attr
, new->name
, cu
);
2951 cu
->list_in_scope
= &local_symbols
;
2953 if (die
->child
!= NULL
)
2955 child_die
= die
->child
;
2956 while (child_die
&& child_die
->tag
)
2958 process_die (child_die
, cu
);
2959 child_die
= sibling_die (child_die
);
2963 new = pop_context ();
2964 /* Make a block for the local symbols within. */
2965 finish_block (new->name
, &local_symbols
, new->old_blocks
,
2966 lowpc
, highpc
, objfile
);
2968 /* In C++, we can have functions nested inside functions (e.g., when
2969 a function declares a class that has methods). This means that
2970 when we finish processing a function scope, we may need to go
2971 back to building a containing block's symbol lists. */
2972 local_symbols
= new->locals
;
2973 param_symbols
= new->params
;
2975 /* If we've finished processing a top-level function, subsequent
2976 symbols go in the file symbol list. */
2977 if (outermost_context_p ())
2978 cu
->list_in_scope
= &file_symbols
;
2980 processing_current_prefix
= previous_prefix
;
2981 if (back_to
!= NULL
)
2982 do_cleanups (back_to
);
2985 /* Process all the DIES contained within a lexical block scope. Start
2986 a new scope, process the dies, and then close the scope. */
2989 read_lexical_block_scope (struct die_info
*die
, struct dwarf2_cu
*cu
)
2991 struct objfile
*objfile
= cu
->objfile
;
2992 struct context_stack
*new;
2993 CORE_ADDR lowpc
, highpc
;
2994 struct die_info
*child_die
;
2997 baseaddr
= ANOFFSET (objfile
->section_offsets
, SECT_OFF_TEXT (objfile
));
2999 /* Ignore blocks with missing or invalid low and high pc attributes. */
3000 /* ??? Perhaps consider discontiguous blocks defined by DW_AT_ranges
3001 as multiple lexical blocks? Handling children in a sane way would
3002 be nasty. Might be easier to properly extend generic blocks to
3004 if (!dwarf2_get_pc_bounds (die
, &lowpc
, &highpc
, cu
))
3009 push_context (0, lowpc
);
3010 if (die
->child
!= NULL
)
3012 child_die
= die
->child
;
3013 while (child_die
&& child_die
->tag
)
3015 process_die (child_die
, cu
);
3016 child_die
= sibling_die (child_die
);
3019 new = pop_context ();
3021 if (local_symbols
!= NULL
)
3023 finish_block (0, &local_symbols
, new->old_blocks
, new->start_addr
,
3026 local_symbols
= new->locals
;
3029 /* Get low and high pc attributes from a die. Return 1 if the attributes
3030 are present and valid, otherwise, return 0. Return -1 if the range is
3031 discontinuous, i.e. derived from DW_AT_ranges information. */
3033 dwarf2_get_pc_bounds (struct die_info
*die
, CORE_ADDR
*lowpc
,
3034 CORE_ADDR
*highpc
, struct dwarf2_cu
*cu
)
3036 struct objfile
*objfile
= cu
->objfile
;
3037 struct comp_unit_head
*cu_header
= &cu
->header
;
3038 struct attribute
*attr
;
3039 bfd
*obfd
= objfile
->obfd
;
3044 attr
= dwarf2_attr (die
, DW_AT_high_pc
, cu
);
3047 high
= DW_ADDR (attr
);
3048 attr
= dwarf2_attr (die
, DW_AT_low_pc
, cu
);
3050 low
= DW_ADDR (attr
);
3052 /* Found high w/o low attribute. */
3055 /* Found consecutive range of addresses. */
3060 attr
= dwarf2_attr (die
, DW_AT_ranges
, cu
);
3063 unsigned int addr_size
= cu_header
->addr_size
;
3064 CORE_ADDR mask
= ~(~(CORE_ADDR
)1 << (addr_size
* 8 - 1));
3065 /* Value of the DW_AT_ranges attribute is the offset in the
3066 .debug_ranges section. */
3067 unsigned int offset
= DW_UNSND (attr
);
3068 /* Base address selection entry. */
3076 found_base
= cu_header
->base_known
;
3077 base
= cu_header
->base_address
;
3079 if (offset
>= dwarf2_per_objfile
->ranges_size
)
3081 complaint (&symfile_complaints
,
3082 _("Offset %d out of bounds for DW_AT_ranges attribute"),
3086 buffer
= dwarf2_per_objfile
->ranges_buffer
+ offset
;
3088 /* Read in the largest possible address. */
3089 marker
= read_address (obfd
, buffer
, cu
, &dummy
);
3090 if ((marker
& mask
) == mask
)
3092 /* If we found the largest possible address, then
3093 read the base address. */
3094 base
= read_address (obfd
, buffer
+ addr_size
, cu
, &dummy
);
3095 buffer
+= 2 * addr_size
;
3096 offset
+= 2 * addr_size
;
3104 CORE_ADDR range_beginning
, range_end
;
3106 range_beginning
= read_address (obfd
, buffer
, cu
, &dummy
);
3107 buffer
+= addr_size
;
3108 range_end
= read_address (obfd
, buffer
, cu
, &dummy
);
3109 buffer
+= addr_size
;
3110 offset
+= 2 * addr_size
;
3112 /* An end of list marker is a pair of zero addresses. */
3113 if (range_beginning
== 0 && range_end
== 0)
3114 /* Found the end of list entry. */
3117 /* Each base address selection entry is a pair of 2 values.
3118 The first is the largest possible address, the second is
3119 the base address. Check for a base address here. */
3120 if ((range_beginning
& mask
) == mask
)
3122 /* If we found the largest possible address, then
3123 read the base address. */
3124 base
= read_address (obfd
, buffer
+ addr_size
, cu
, &dummy
);
3131 /* We have no valid base address for the ranges
3133 complaint (&symfile_complaints
,
3134 _("Invalid .debug_ranges data (no base address)"));
3138 range_beginning
+= base
;
3141 /* FIXME: This is recording everything as a low-high
3142 segment of consecutive addresses. We should have a
3143 data structure for discontiguous block ranges
3147 low
= range_beginning
;
3153 if (range_beginning
< low
)
3154 low
= range_beginning
;
3155 if (range_end
> high
)
3161 /* If the first entry is an end-of-list marker, the range
3162 describes an empty scope, i.e. no instructions. */
3172 /* When using the GNU linker, .gnu.linkonce. sections are used to
3173 eliminate duplicate copies of functions and vtables and such.
3174 The linker will arbitrarily choose one and discard the others.
3175 The AT_*_pc values for such functions refer to local labels in
3176 these sections. If the section from that file was discarded, the
3177 labels are not in the output, so the relocs get a value of 0.
3178 If this is a discarded function, mark the pc bounds as invalid,
3179 so that GDB will ignore it. */
3180 if (low
== 0 && (bfd_get_file_flags (obfd
) & HAS_RELOC
) == 0)
3188 /* Get the low and high pc's represented by the scope DIE, and store
3189 them in *LOWPC and *HIGHPC. If the correct values can't be
3190 determined, set *LOWPC to -1 and *HIGHPC to 0. */
3193 get_scope_pc_bounds (struct die_info
*die
,
3194 CORE_ADDR
*lowpc
, CORE_ADDR
*highpc
,
3195 struct dwarf2_cu
*cu
)
3197 CORE_ADDR best_low
= (CORE_ADDR
) -1;
3198 CORE_ADDR best_high
= (CORE_ADDR
) 0;
3199 CORE_ADDR current_low
, current_high
;
3201 if (dwarf2_get_pc_bounds (die
, ¤t_low
, ¤t_high
, cu
))
3203 best_low
= current_low
;
3204 best_high
= current_high
;
3208 struct die_info
*child
= die
->child
;
3210 while (child
&& child
->tag
)
3212 switch (child
->tag
) {
3213 case DW_TAG_subprogram
:
3214 if (dwarf2_get_pc_bounds (child
, ¤t_low
, ¤t_high
, cu
))
3216 best_low
= min (best_low
, current_low
);
3217 best_high
= max (best_high
, current_high
);
3220 case DW_TAG_namespace
:
3221 /* FIXME: carlton/2004-01-16: Should we do this for
3222 DW_TAG_class_type/DW_TAG_structure_type, too? I think
3223 that current GCC's always emit the DIEs corresponding
3224 to definitions of methods of classes as children of a
3225 DW_TAG_compile_unit or DW_TAG_namespace (as opposed to
3226 the DIEs giving the declarations, which could be
3227 anywhere). But I don't see any reason why the
3228 standards says that they have to be there. */
3229 get_scope_pc_bounds (child
, ¤t_low
, ¤t_high
, cu
);
3231 if (current_low
!= ((CORE_ADDR
) -1))
3233 best_low
= min (best_low
, current_low
);
3234 best_high
= max (best_high
, current_high
);
3242 child
= sibling_die (child
);
3247 *highpc
= best_high
;
3250 /* Add an aggregate field to the field list. */
3253 dwarf2_add_field (struct field_info
*fip
, struct die_info
*die
,
3254 struct dwarf2_cu
*cu
)
3256 struct objfile
*objfile
= cu
->objfile
;
3257 struct nextfield
*new_field
;
3258 struct attribute
*attr
;
3260 char *fieldname
= "";
3262 /* Allocate a new field list entry and link it in. */
3263 new_field
= (struct nextfield
*) xmalloc (sizeof (struct nextfield
));
3264 make_cleanup (xfree
, new_field
);
3265 memset (new_field
, 0, sizeof (struct nextfield
));
3266 new_field
->next
= fip
->fields
;
3267 fip
->fields
= new_field
;
3270 /* Handle accessibility and virtuality of field.
3271 The default accessibility for members is public, the default
3272 accessibility for inheritance is private. */
3273 if (die
->tag
!= DW_TAG_inheritance
)
3274 new_field
->accessibility
= DW_ACCESS_public
;
3276 new_field
->accessibility
= DW_ACCESS_private
;
3277 new_field
->virtuality
= DW_VIRTUALITY_none
;
3279 attr
= dwarf2_attr (die
, DW_AT_accessibility
, cu
);
3281 new_field
->accessibility
= DW_UNSND (attr
);
3282 if (new_field
->accessibility
!= DW_ACCESS_public
)
3283 fip
->non_public_fields
= 1;
3284 attr
= dwarf2_attr (die
, DW_AT_virtuality
, cu
);
3286 new_field
->virtuality
= DW_UNSND (attr
);
3288 fp
= &new_field
->field
;
3290 if (die
->tag
== DW_TAG_member
&& ! die_is_declaration (die
, cu
))
3292 /* Data member other than a C++ static data member. */
3294 /* Get type of field. */
3295 fp
->type
= die_type (die
, cu
);
3297 FIELD_STATIC_KIND (*fp
) = 0;
3299 /* Get bit size of field (zero if none). */
3300 attr
= dwarf2_attr (die
, DW_AT_bit_size
, cu
);
3303 FIELD_BITSIZE (*fp
) = DW_UNSND (attr
);
3307 FIELD_BITSIZE (*fp
) = 0;
3310 /* Get bit offset of field. */
3311 attr
= dwarf2_attr (die
, DW_AT_data_member_location
, cu
);
3314 FIELD_BITPOS (*fp
) =
3315 decode_locdesc (DW_BLOCK (attr
), cu
) * bits_per_byte
;
3318 FIELD_BITPOS (*fp
) = 0;
3319 attr
= dwarf2_attr (die
, DW_AT_bit_offset
, cu
);
3322 if (BITS_BIG_ENDIAN
)
3324 /* For big endian bits, the DW_AT_bit_offset gives the
3325 additional bit offset from the MSB of the containing
3326 anonymous object to the MSB of the field. We don't
3327 have to do anything special since we don't need to
3328 know the size of the anonymous object. */
3329 FIELD_BITPOS (*fp
) += DW_UNSND (attr
);
3333 /* For little endian bits, compute the bit offset to the
3334 MSB of the anonymous object, subtract off the number of
3335 bits from the MSB of the field to the MSB of the
3336 object, and then subtract off the number of bits of
3337 the field itself. The result is the bit offset of
3338 the LSB of the field. */
3340 int bit_offset
= DW_UNSND (attr
);
3342 attr
= dwarf2_attr (die
, DW_AT_byte_size
, cu
);
3345 /* The size of the anonymous object containing
3346 the bit field is explicit, so use the
3347 indicated size (in bytes). */
3348 anonymous_size
= DW_UNSND (attr
);
3352 /* The size of the anonymous object containing
3353 the bit field must be inferred from the type
3354 attribute of the data member containing the
3356 anonymous_size
= TYPE_LENGTH (fp
->type
);
3358 FIELD_BITPOS (*fp
) += anonymous_size
* bits_per_byte
3359 - bit_offset
- FIELD_BITSIZE (*fp
);
3363 /* Get name of field. */
3364 attr
= dwarf2_attr (die
, DW_AT_name
, cu
);
3365 if (attr
&& DW_STRING (attr
))
3366 fieldname
= DW_STRING (attr
);
3368 /* The name is already allocated along with this objfile, so we don't
3369 need to duplicate it for the type. */
3370 fp
->name
= fieldname
;
3372 /* Change accessibility for artificial fields (e.g. virtual table
3373 pointer or virtual base class pointer) to private. */
3374 if (dwarf2_attr (die
, DW_AT_artificial
, cu
))
3376 new_field
->accessibility
= DW_ACCESS_private
;
3377 fip
->non_public_fields
= 1;
3380 else if (die
->tag
== DW_TAG_member
|| die
->tag
== DW_TAG_variable
)
3382 /* C++ static member. */
3384 /* NOTE: carlton/2002-11-05: It should be a DW_TAG_member that
3385 is a declaration, but all versions of G++ as of this writing
3386 (so through at least 3.2.1) incorrectly generate
3387 DW_TAG_variable tags. */
3391 /* Get name of field. */
3392 attr
= dwarf2_attr (die
, DW_AT_name
, cu
);
3393 if (attr
&& DW_STRING (attr
))
3394 fieldname
= DW_STRING (attr
);
3398 /* Get physical name. */
3399 physname
= dwarf2_linkage_name (die
, cu
);
3401 /* The name is already allocated along with this objfile, so we don't
3402 need to duplicate it for the type. */
3403 SET_FIELD_PHYSNAME (*fp
, physname
? physname
: "");
3404 FIELD_TYPE (*fp
) = die_type (die
, cu
);
3405 FIELD_NAME (*fp
) = fieldname
;
3407 else if (die
->tag
== DW_TAG_inheritance
)
3409 /* C++ base class field. */
3410 attr
= dwarf2_attr (die
, DW_AT_data_member_location
, cu
);
3412 FIELD_BITPOS (*fp
) = (decode_locdesc (DW_BLOCK (attr
), cu
)
3414 FIELD_BITSIZE (*fp
) = 0;
3415 FIELD_STATIC_KIND (*fp
) = 0;
3416 FIELD_TYPE (*fp
) = die_type (die
, cu
);
3417 FIELD_NAME (*fp
) = type_name_no_tag (fp
->type
);
3418 fip
->nbaseclasses
++;
3422 /* Create the vector of fields, and attach it to the type. */
3425 dwarf2_attach_fields_to_type (struct field_info
*fip
, struct type
*type
,
3426 struct dwarf2_cu
*cu
)
3428 int nfields
= fip
->nfields
;
3430 /* Record the field count, allocate space for the array of fields,
3431 and create blank accessibility bitfields if necessary. */
3432 TYPE_NFIELDS (type
) = nfields
;
3433 TYPE_FIELDS (type
) = (struct field
*)
3434 TYPE_ALLOC (type
, sizeof (struct field
) * nfields
);
3435 memset (TYPE_FIELDS (type
), 0, sizeof (struct field
) * nfields
);
3437 if (fip
->non_public_fields
)
3439 ALLOCATE_CPLUS_STRUCT_TYPE (type
);
3441 TYPE_FIELD_PRIVATE_BITS (type
) =
3442 (B_TYPE
*) TYPE_ALLOC (type
, B_BYTES (nfields
));
3443 B_CLRALL (TYPE_FIELD_PRIVATE_BITS (type
), nfields
);
3445 TYPE_FIELD_PROTECTED_BITS (type
) =
3446 (B_TYPE
*) TYPE_ALLOC (type
, B_BYTES (nfields
));
3447 B_CLRALL (TYPE_FIELD_PROTECTED_BITS (type
), nfields
);
3449 TYPE_FIELD_IGNORE_BITS (type
) =
3450 (B_TYPE
*) TYPE_ALLOC (type
, B_BYTES (nfields
));
3451 B_CLRALL (TYPE_FIELD_IGNORE_BITS (type
), nfields
);
3454 /* If the type has baseclasses, allocate and clear a bit vector for
3455 TYPE_FIELD_VIRTUAL_BITS. */
3456 if (fip
->nbaseclasses
)
3458 int num_bytes
= B_BYTES (fip
->nbaseclasses
);
3459 unsigned char *pointer
;
3461 ALLOCATE_CPLUS_STRUCT_TYPE (type
);
3462 pointer
= TYPE_ALLOC (type
, num_bytes
);
3463 TYPE_FIELD_VIRTUAL_BITS (type
) = pointer
;
3464 B_CLRALL (TYPE_FIELD_VIRTUAL_BITS (type
), fip
->nbaseclasses
);
3465 TYPE_N_BASECLASSES (type
) = fip
->nbaseclasses
;
3468 /* Copy the saved-up fields into the field vector. Start from the head
3469 of the list, adding to the tail of the field array, so that they end
3470 up in the same order in the array in which they were added to the list. */
3471 while (nfields
-- > 0)
3473 TYPE_FIELD (type
, nfields
) = fip
->fields
->field
;
3474 switch (fip
->fields
->accessibility
)
3476 case DW_ACCESS_private
:
3477 SET_TYPE_FIELD_PRIVATE (type
, nfields
);
3480 case DW_ACCESS_protected
:
3481 SET_TYPE_FIELD_PROTECTED (type
, nfields
);
3484 case DW_ACCESS_public
:
3488 /* Unknown accessibility. Complain and treat it as public. */
3490 complaint (&symfile_complaints
, _("unsupported accessibility %d"),
3491 fip
->fields
->accessibility
);
3495 if (nfields
< fip
->nbaseclasses
)
3497 switch (fip
->fields
->virtuality
)
3499 case DW_VIRTUALITY_virtual
:
3500 case DW_VIRTUALITY_pure_virtual
:
3501 SET_TYPE_FIELD_VIRTUAL (type
, nfields
);
3505 fip
->fields
= fip
->fields
->next
;
3509 /* Add a member function to the proper fieldlist. */
3512 dwarf2_add_member_fn (struct field_info
*fip
, struct die_info
*die
,
3513 struct type
*type
, struct dwarf2_cu
*cu
)
3515 struct objfile
*objfile
= cu
->objfile
;
3516 struct attribute
*attr
;
3517 struct fnfieldlist
*flp
;
3519 struct fn_field
*fnp
;
3522 struct nextfnfield
*new_fnfield
;
3524 /* Get name of member function. */
3525 attr
= dwarf2_attr (die
, DW_AT_name
, cu
);
3526 if (attr
&& DW_STRING (attr
))
3527 fieldname
= DW_STRING (attr
);
3531 /* Get the mangled name. */
3532 physname
= dwarf2_linkage_name (die
, cu
);
3534 /* Look up member function name in fieldlist. */
3535 for (i
= 0; i
< fip
->nfnfields
; i
++)
3537 if (strcmp (fip
->fnfieldlists
[i
].name
, fieldname
) == 0)
3541 /* Create new list element if necessary. */
3542 if (i
< fip
->nfnfields
)
3543 flp
= &fip
->fnfieldlists
[i
];
3546 if ((fip
->nfnfields
% DW_FIELD_ALLOC_CHUNK
) == 0)
3548 fip
->fnfieldlists
= (struct fnfieldlist
*)
3549 xrealloc (fip
->fnfieldlists
,
3550 (fip
->nfnfields
+ DW_FIELD_ALLOC_CHUNK
)
3551 * sizeof (struct fnfieldlist
));
3552 if (fip
->nfnfields
== 0)
3553 make_cleanup (free_current_contents
, &fip
->fnfieldlists
);
3555 flp
= &fip
->fnfieldlists
[fip
->nfnfields
];
3556 flp
->name
= fieldname
;
3562 /* Create a new member function field and chain it to the field list
3564 new_fnfield
= (struct nextfnfield
*) xmalloc (sizeof (struct nextfnfield
));
3565 make_cleanup (xfree
, new_fnfield
);
3566 memset (new_fnfield
, 0, sizeof (struct nextfnfield
));
3567 new_fnfield
->next
= flp
->head
;
3568 flp
->head
= new_fnfield
;
3571 /* Fill in the member function field info. */
3572 fnp
= &new_fnfield
->fnfield
;
3573 /* The name is already allocated along with this objfile, so we don't
3574 need to duplicate it for the type. */
3575 fnp
->physname
= physname
? physname
: "";
3576 fnp
->type
= alloc_type (objfile
);
3577 if (die
->type
&& TYPE_CODE (die
->type
) == TYPE_CODE_FUNC
)
3579 int nparams
= TYPE_NFIELDS (die
->type
);
3581 /* TYPE is the domain of this method, and DIE->TYPE is the type
3582 of the method itself (TYPE_CODE_METHOD). */
3583 smash_to_method_type (fnp
->type
, type
,
3584 TYPE_TARGET_TYPE (die
->type
),
3585 TYPE_FIELDS (die
->type
),
3586 TYPE_NFIELDS (die
->type
),
3587 TYPE_VARARGS (die
->type
));
3589 /* Handle static member functions.
3590 Dwarf2 has no clean way to discern C++ static and non-static
3591 member functions. G++ helps GDB by marking the first
3592 parameter for non-static member functions (which is the
3593 this pointer) as artificial. We obtain this information
3594 from read_subroutine_type via TYPE_FIELD_ARTIFICIAL. */
3595 if (nparams
== 0 || TYPE_FIELD_ARTIFICIAL (die
->type
, 0) == 0)
3596 fnp
->voffset
= VOFFSET_STATIC
;
3599 complaint (&symfile_complaints
, _("member function type missing for '%s'"),
3602 /* Get fcontext from DW_AT_containing_type if present. */
3603 if (dwarf2_attr (die
, DW_AT_containing_type
, cu
) != NULL
)
3604 fnp
->fcontext
= die_containing_type (die
, cu
);
3606 /* dwarf2 doesn't have stubbed physical names, so the setting of is_const
3607 and is_volatile is irrelevant, as it is needed by gdb_mangle_name only. */
3609 /* Get accessibility. */
3610 attr
= dwarf2_attr (die
, DW_AT_accessibility
, cu
);
3613 switch (DW_UNSND (attr
))
3615 case DW_ACCESS_private
:
3616 fnp
->is_private
= 1;
3618 case DW_ACCESS_protected
:
3619 fnp
->is_protected
= 1;
3624 /* Check for artificial methods. */
3625 attr
= dwarf2_attr (die
, DW_AT_artificial
, cu
);
3626 if (attr
&& DW_UNSND (attr
) != 0)
3627 fnp
->is_artificial
= 1;
3629 /* Get index in virtual function table if it is a virtual member function. */
3630 attr
= dwarf2_attr (die
, DW_AT_vtable_elem_location
, cu
);
3633 /* Support the .debug_loc offsets */
3634 if (attr_form_is_block (attr
))
3636 fnp
->voffset
= decode_locdesc (DW_BLOCK (attr
), cu
) + 2;
3638 else if (attr
->form
== DW_FORM_data4
|| attr
->form
== DW_FORM_data8
)
3640 dwarf2_complex_location_expr_complaint ();
3644 dwarf2_invalid_attrib_class_complaint ("DW_AT_vtable_elem_location",
3650 /* Create the vector of member function fields, and attach it to the type. */
3653 dwarf2_attach_fn_fields_to_type (struct field_info
*fip
, struct type
*type
,
3654 struct dwarf2_cu
*cu
)
3656 struct fnfieldlist
*flp
;
3657 int total_length
= 0;
3660 ALLOCATE_CPLUS_STRUCT_TYPE (type
);
3661 TYPE_FN_FIELDLISTS (type
) = (struct fn_fieldlist
*)
3662 TYPE_ALLOC (type
, sizeof (struct fn_fieldlist
) * fip
->nfnfields
);
3664 for (i
= 0, flp
= fip
->fnfieldlists
; i
< fip
->nfnfields
; i
++, flp
++)
3666 struct nextfnfield
*nfp
= flp
->head
;
3667 struct fn_fieldlist
*fn_flp
= &TYPE_FN_FIELDLIST (type
, i
);
3670 TYPE_FN_FIELDLIST_NAME (type
, i
) = flp
->name
;
3671 TYPE_FN_FIELDLIST_LENGTH (type
, i
) = flp
->length
;
3672 fn_flp
->fn_fields
= (struct fn_field
*)
3673 TYPE_ALLOC (type
, sizeof (struct fn_field
) * flp
->length
);
3674 for (k
= flp
->length
; (k
--, nfp
); nfp
= nfp
->next
)
3675 fn_flp
->fn_fields
[k
] = nfp
->fnfield
;
3677 total_length
+= flp
->length
;
3680 TYPE_NFN_FIELDS (type
) = fip
->nfnfields
;
3681 TYPE_NFN_FIELDS_TOTAL (type
) = total_length
;
3685 /* Returns non-zero if NAME is the name of a vtable member in CU's
3686 language, zero otherwise. */
3688 is_vtable_name (const char *name
, struct dwarf2_cu
*cu
)
3690 static const char vptr
[] = "_vptr";
3691 static const char vtable
[] = "vtable";
3693 /* Look for the C++ and Java forms of the vtable. */
3694 if ((cu
->language
== language_java
3695 && strncmp (name
, vtable
, sizeof (vtable
) - 1) == 0)
3696 || (strncmp (name
, vptr
, sizeof (vptr
) - 1) == 0
3697 && is_cplus_marker (name
[sizeof (vptr
) - 1])))
3704 /* Called when we find the DIE that starts a structure or union scope
3705 (definition) to process all dies that define the members of the
3708 NOTE: we need to call struct_type regardless of whether or not the
3709 DIE has an at_name attribute, since it might be an anonymous
3710 structure or union. This gets the type entered into our set of
3713 However, if the structure is incomplete (an opaque struct/union)
3714 then suppress creating a symbol table entry for it since gdb only
3715 wants to find the one with the complete definition. Note that if
3716 it is complete, we just call new_symbol, which does it's own
3717 checking about whether the struct/union is anonymous or not (and
3718 suppresses creating a symbol table entry itself). */
3721 read_structure_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
3723 struct objfile
*objfile
= cu
->objfile
;
3725 struct attribute
*attr
;
3726 const char *previous_prefix
= processing_current_prefix
;
3727 struct cleanup
*back_to
= NULL
;
3732 type
= alloc_type (objfile
);
3734 INIT_CPLUS_SPECIFIC (type
);
3735 attr
= dwarf2_attr (die
, DW_AT_name
, cu
);
3736 if (attr
&& DW_STRING (attr
))
3738 if (cu
->language
== language_cplus
3739 || cu
->language
== language_java
)
3741 char *new_prefix
= determine_class_name (die
, cu
);
3742 TYPE_TAG_NAME (type
) = obsavestring (new_prefix
,
3743 strlen (new_prefix
),
3744 &objfile
->objfile_obstack
);
3745 back_to
= make_cleanup (xfree
, new_prefix
);
3746 processing_current_prefix
= new_prefix
;
3750 /* The name is already allocated along with this objfile, so
3751 we don't need to duplicate it for the type. */
3752 TYPE_TAG_NAME (type
) = DW_STRING (attr
);
3756 if (die
->tag
== DW_TAG_structure_type
)
3758 TYPE_CODE (type
) = TYPE_CODE_STRUCT
;
3760 else if (die
->tag
== DW_TAG_union_type
)
3762 TYPE_CODE (type
) = TYPE_CODE_UNION
;
3766 /* FIXME: TYPE_CODE_CLASS is currently defined to TYPE_CODE_STRUCT
3768 TYPE_CODE (type
) = TYPE_CODE_CLASS
;
3771 attr
= dwarf2_attr (die
, DW_AT_byte_size
, cu
);
3774 TYPE_LENGTH (type
) = DW_UNSND (attr
);
3778 TYPE_LENGTH (type
) = 0;
3781 if (die_is_declaration (die
, cu
))
3782 TYPE_FLAGS (type
) |= TYPE_FLAG_STUB
;
3784 /* We need to add the type field to the die immediately so we don't
3785 infinitely recurse when dealing with pointers to the structure
3786 type within the structure itself. */
3787 set_die_type (die
, type
, cu
);
3789 if (die
->child
!= NULL
&& ! die_is_declaration (die
, cu
))
3791 struct field_info fi
;
3792 struct die_info
*child_die
;
3793 struct cleanup
*back_to
= make_cleanup (null_cleanup
, NULL
);
3795 memset (&fi
, 0, sizeof (struct field_info
));
3797 child_die
= die
->child
;
3799 while (child_die
&& child_die
->tag
)
3801 if (child_die
->tag
== DW_TAG_member
3802 || child_die
->tag
== DW_TAG_variable
)
3804 /* NOTE: carlton/2002-11-05: A C++ static data member
3805 should be a DW_TAG_member that is a declaration, but
3806 all versions of G++ as of this writing (so through at
3807 least 3.2.1) incorrectly generate DW_TAG_variable
3808 tags for them instead. */
3809 dwarf2_add_field (&fi
, child_die
, cu
);
3811 else if (child_die
->tag
== DW_TAG_subprogram
)
3813 /* C++ member function. */
3814 read_type_die (child_die
, cu
);
3815 dwarf2_add_member_fn (&fi
, child_die
, type
, cu
);
3817 else if (child_die
->tag
== DW_TAG_inheritance
)
3819 /* C++ base class field. */
3820 dwarf2_add_field (&fi
, child_die
, cu
);
3822 child_die
= sibling_die (child_die
);
3825 /* Attach fields and member functions to the type. */
3827 dwarf2_attach_fields_to_type (&fi
, type
, cu
);
3830 dwarf2_attach_fn_fields_to_type (&fi
, type
, cu
);
3832 /* Get the type which refers to the base class (possibly this
3833 class itself) which contains the vtable pointer for the current
3834 class from the DW_AT_containing_type attribute. */
3836 if (dwarf2_attr (die
, DW_AT_containing_type
, cu
) != NULL
)
3838 struct type
*t
= die_containing_type (die
, cu
);
3840 TYPE_VPTR_BASETYPE (type
) = t
;
3845 /* Our own class provides vtbl ptr. */
3846 for (i
= TYPE_NFIELDS (t
) - 1;
3847 i
>= TYPE_N_BASECLASSES (t
);
3850 char *fieldname
= TYPE_FIELD_NAME (t
, i
);
3852 if (is_vtable_name (fieldname
, cu
))
3854 TYPE_VPTR_FIELDNO (type
) = i
;
3859 /* Complain if virtual function table field not found. */
3860 if (i
< TYPE_N_BASECLASSES (t
))
3861 complaint (&symfile_complaints
,
3862 _("virtual function table pointer not found when defining class '%s'"),
3863 TYPE_TAG_NAME (type
) ? TYPE_TAG_NAME (type
) :
3868 TYPE_VPTR_FIELDNO (type
) = TYPE_VPTR_FIELDNO (t
);
3871 else if (cu
->producer
3872 && strncmp (cu
->producer
,
3873 "IBM(R) XL C/C++ Advanced Edition", 32) == 0)
3875 /* The IBM XLC compiler does not provide direct indication
3876 of the containing type, but the vtable pointer is
3877 always named __vfp. */
3881 for (i
= TYPE_NFIELDS (type
) - 1;
3882 i
>= TYPE_N_BASECLASSES (type
);
3885 if (strcmp (TYPE_FIELD_NAME (type
, i
), "__vfp") == 0)
3887 TYPE_VPTR_FIELDNO (type
) = i
;
3888 TYPE_VPTR_BASETYPE (type
) = type
;
3895 do_cleanups (back_to
);
3898 processing_current_prefix
= previous_prefix
;
3899 if (back_to
!= NULL
)
3900 do_cleanups (back_to
);
3904 process_structure_scope (struct die_info
*die
, struct dwarf2_cu
*cu
)
3906 struct objfile
*objfile
= cu
->objfile
;
3907 const char *previous_prefix
= processing_current_prefix
;
3908 struct die_info
*child_die
= die
->child
;
3910 if (TYPE_TAG_NAME (die
->type
) != NULL
)
3911 processing_current_prefix
= TYPE_TAG_NAME (die
->type
);
3913 /* NOTE: carlton/2004-03-16: GCC 3.4 (or at least one of its
3914 snapshots) has been known to create a die giving a declaration
3915 for a class that has, as a child, a die giving a definition for a
3916 nested class. So we have to process our children even if the
3917 current die is a declaration. Normally, of course, a declaration
3918 won't have any children at all. */
3920 while (child_die
!= NULL
&& child_die
->tag
)
3922 if (child_die
->tag
== DW_TAG_member
3923 || child_die
->tag
== DW_TAG_variable
3924 || child_die
->tag
== DW_TAG_inheritance
)
3929 process_die (child_die
, cu
);
3931 child_die
= sibling_die (child_die
);
3934 if (die
->child
!= NULL
&& ! die_is_declaration (die
, cu
))
3935 new_symbol (die
, die
->type
, cu
);
3937 processing_current_prefix
= previous_prefix
;
3940 /* Given a DW_AT_enumeration_type die, set its type. We do not
3941 complete the type's fields yet, or create any symbols. */
3944 read_enumeration_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
3946 struct objfile
*objfile
= cu
->objfile
;
3948 struct attribute
*attr
;
3953 type
= alloc_type (objfile
);
3955 TYPE_CODE (type
) = TYPE_CODE_ENUM
;
3956 attr
= dwarf2_attr (die
, DW_AT_name
, cu
);
3957 if (attr
&& DW_STRING (attr
))
3959 char *name
= DW_STRING (attr
);
3961 if (processing_has_namespace_info
)
3963 TYPE_TAG_NAME (type
) = typename_concat (&objfile
->objfile_obstack
,
3964 processing_current_prefix
,
3969 /* The name is already allocated along with this objfile, so
3970 we don't need to duplicate it for the type. */
3971 TYPE_TAG_NAME (type
) = name
;
3975 attr
= dwarf2_attr (die
, DW_AT_byte_size
, cu
);
3978 TYPE_LENGTH (type
) = DW_UNSND (attr
);
3982 TYPE_LENGTH (type
) = 0;
3985 set_die_type (die
, type
, cu
);
3988 /* Determine the name of the type represented by DIE, which should be
3989 a named C++ or Java compound type. Return the name in question; the caller
3990 is responsible for xfree()'ing it. */
3993 determine_class_name (struct die_info
*die
, struct dwarf2_cu
*cu
)
3995 struct cleanup
*back_to
= NULL
;
3996 struct die_info
*spec_die
= die_specification (die
, cu
);
3997 char *new_prefix
= NULL
;
3999 /* If this is the definition of a class that is declared by another
4000 die, then processing_current_prefix may not be accurate; see
4001 read_func_scope for a similar example. */
4002 if (spec_die
!= NULL
)
4004 char *specification_prefix
= determine_prefix (spec_die
, cu
);
4005 processing_current_prefix
= specification_prefix
;
4006 back_to
= make_cleanup (xfree
, specification_prefix
);
4009 /* If we don't have namespace debug info, guess the name by trying
4010 to demangle the names of members, just like we did in
4011 guess_structure_name. */
4012 if (!processing_has_namespace_info
)
4014 struct die_info
*child
;
4016 for (child
= die
->child
;
4017 child
!= NULL
&& child
->tag
!= 0;
4018 child
= sibling_die (child
))
4020 if (child
->tag
== DW_TAG_subprogram
)
4023 = language_class_name_from_physname (cu
->language_defn
,
4027 if (new_prefix
!= NULL
)
4033 if (new_prefix
== NULL
)
4035 const char *name
= dwarf2_name (die
, cu
);
4036 new_prefix
= typename_concat (NULL
, processing_current_prefix
,
4037 name
? name
: "<<anonymous>>",
4041 if (back_to
!= NULL
)
4042 do_cleanups (back_to
);
4047 /* Given a pointer to a die which begins an enumeration, process all
4048 the dies that define the members of the enumeration, and create the
4049 symbol for the enumeration type.
4051 NOTE: We reverse the order of the element list. */
4054 process_enumeration_scope (struct die_info
*die
, struct dwarf2_cu
*cu
)
4056 struct objfile
*objfile
= cu
->objfile
;
4057 struct die_info
*child_die
;
4058 struct field
*fields
;
4059 struct attribute
*attr
;
4062 int unsigned_enum
= 1;
4066 if (die
->child
!= NULL
)
4068 child_die
= die
->child
;
4069 while (child_die
&& child_die
->tag
)
4071 if (child_die
->tag
!= DW_TAG_enumerator
)
4073 process_die (child_die
, cu
);
4077 attr
= dwarf2_attr (child_die
, DW_AT_name
, cu
);
4080 sym
= new_symbol (child_die
, die
->type
, cu
);
4081 if (SYMBOL_VALUE (sym
) < 0)
4084 if ((num_fields
% DW_FIELD_ALLOC_CHUNK
) == 0)
4086 fields
= (struct field
*)
4088 (num_fields
+ DW_FIELD_ALLOC_CHUNK
)
4089 * sizeof (struct field
));
4092 FIELD_NAME (fields
[num_fields
]) = DEPRECATED_SYMBOL_NAME (sym
);
4093 FIELD_TYPE (fields
[num_fields
]) = NULL
;
4094 FIELD_BITPOS (fields
[num_fields
]) = SYMBOL_VALUE (sym
);
4095 FIELD_BITSIZE (fields
[num_fields
]) = 0;
4096 FIELD_STATIC_KIND (fields
[num_fields
]) = 0;
4102 child_die
= sibling_die (child_die
);
4107 TYPE_NFIELDS (die
->type
) = num_fields
;
4108 TYPE_FIELDS (die
->type
) = (struct field
*)
4109 TYPE_ALLOC (die
->type
, sizeof (struct field
) * num_fields
);
4110 memcpy (TYPE_FIELDS (die
->type
), fields
,
4111 sizeof (struct field
) * num_fields
);
4115 TYPE_FLAGS (die
->type
) |= TYPE_FLAG_UNSIGNED
;
4118 new_symbol (die
, die
->type
, cu
);
4121 /* Extract all information from a DW_TAG_array_type DIE and put it in
4122 the DIE's type field. For now, this only handles one dimensional
4126 read_array_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
4128 struct objfile
*objfile
= cu
->objfile
;
4129 struct die_info
*child_die
;
4130 struct type
*type
= NULL
;
4131 struct type
*element_type
, *range_type
, *index_type
;
4132 struct type
**range_types
= NULL
;
4133 struct attribute
*attr
;
4135 struct cleanup
*back_to
;
4137 /* Return if we've already decoded this type. */
4143 element_type
= die_type (die
, cu
);
4145 /* Irix 6.2 native cc creates array types without children for
4146 arrays with unspecified length. */
4147 if (die
->child
== NULL
)
4149 index_type
= dwarf2_fundamental_type (objfile
, FT_INTEGER
, cu
);
4150 range_type
= create_range_type (NULL
, index_type
, 0, -1);
4151 set_die_type (die
, create_array_type (NULL
, element_type
, range_type
),
4156 back_to
= make_cleanup (null_cleanup
, NULL
);
4157 child_die
= die
->child
;
4158 while (child_die
&& child_die
->tag
)
4160 if (child_die
->tag
== DW_TAG_subrange_type
)
4162 read_subrange_type (child_die
, cu
);
4164 if (child_die
->type
!= NULL
)
4166 /* The range type was succesfully read. Save it for
4167 the array type creation. */
4168 if ((ndim
% DW_FIELD_ALLOC_CHUNK
) == 0)
4170 range_types
= (struct type
**)
4171 xrealloc (range_types
, (ndim
+ DW_FIELD_ALLOC_CHUNK
)
4172 * sizeof (struct type
*));
4174 make_cleanup (free_current_contents
, &range_types
);
4176 range_types
[ndim
++] = child_die
->type
;
4179 child_die
= sibling_die (child_die
);
4182 /* Dwarf2 dimensions are output from left to right, create the
4183 necessary array types in backwards order. */
4185 type
= element_type
;
4187 if (read_array_order (die
, cu
) == DW_ORD_col_major
)
4191 type
= create_array_type (NULL
, type
, range_types
[i
++]);
4196 type
= create_array_type (NULL
, type
, range_types
[ndim
]);
4199 /* Understand Dwarf2 support for vector types (like they occur on
4200 the PowerPC w/ AltiVec). Gcc just adds another attribute to the
4201 array type. This is not part of the Dwarf2/3 standard yet, but a
4202 custom vendor extension. The main difference between a regular
4203 array and the vector variant is that vectors are passed by value
4205 attr
= dwarf2_attr (die
, DW_AT_GNU_vector
, cu
);
4207 TYPE_FLAGS (type
) |= TYPE_FLAG_VECTOR
;
4209 do_cleanups (back_to
);
4211 /* Install the type in the die. */
4212 set_die_type (die
, type
, cu
);
4215 static enum dwarf_array_dim_ordering
4216 read_array_order (struct die_info
*die
, struct dwarf2_cu
*cu
)
4218 struct attribute
*attr
;
4220 attr
= dwarf2_attr (die
, DW_AT_ordering
, cu
);
4222 if (attr
) return DW_SND (attr
);
4225 GNU F77 is a special case, as at 08/2004 array type info is the
4226 opposite order to the dwarf2 specification, but data is still
4227 laid out as per normal fortran.
4229 FIXME: dsl/2004-8-20: If G77 is ever fixed, this will also need
4233 if (cu
->language
== language_fortran
&&
4234 cu
->producer
&& strstr (cu
->producer
, "GNU F77"))
4236 return DW_ORD_row_major
;
4239 switch (cu
->language_defn
->la_array_ordering
)
4241 case array_column_major
:
4242 return DW_ORD_col_major
;
4243 case array_row_major
:
4245 return DW_ORD_row_major
;
4249 /* Extract all information from a DW_TAG_set_type DIE and put it in
4250 the DIE's type field. */
4253 read_set_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
4255 if (die
->type
== NULL
)
4256 die
->type
= create_set_type ((struct type
*) NULL
, die_type (die
, cu
));
4259 /* First cut: install each common block member as a global variable. */
4262 read_common_block (struct die_info
*die
, struct dwarf2_cu
*cu
)
4264 struct die_info
*child_die
;
4265 struct attribute
*attr
;
4267 CORE_ADDR base
= (CORE_ADDR
) 0;
4269 attr
= dwarf2_attr (die
, DW_AT_location
, cu
);
4272 /* Support the .debug_loc offsets */
4273 if (attr_form_is_block (attr
))
4275 base
= decode_locdesc (DW_BLOCK (attr
), cu
);
4277 else if (attr
->form
== DW_FORM_data4
|| attr
->form
== DW_FORM_data8
)
4279 dwarf2_complex_location_expr_complaint ();
4283 dwarf2_invalid_attrib_class_complaint ("DW_AT_location",
4284 "common block member");
4287 if (die
->child
!= NULL
)
4289 child_die
= die
->child
;
4290 while (child_die
&& child_die
->tag
)
4292 sym
= new_symbol (child_die
, NULL
, cu
);
4293 attr
= dwarf2_attr (child_die
, DW_AT_data_member_location
, cu
);
4296 SYMBOL_VALUE_ADDRESS (sym
) =
4297 base
+ decode_locdesc (DW_BLOCK (attr
), cu
);
4298 add_symbol_to_list (sym
, &global_symbols
);
4300 child_die
= sibling_die (child_die
);
4305 /* Read a C++ namespace. */
4308 read_namespace (struct die_info
*die
, struct dwarf2_cu
*cu
)
4310 struct objfile
*objfile
= cu
->objfile
;
4311 const char *previous_prefix
= processing_current_prefix
;
4314 struct die_info
*current_die
;
4315 struct cleanup
*back_to
= make_cleanup (null_cleanup
, 0);
4317 name
= namespace_name (die
, &is_anonymous
, cu
);
4319 /* Now build the name of the current namespace. */
4321 if (previous_prefix
[0] == '\0')
4323 processing_current_prefix
= name
;
4327 char *temp_name
= typename_concat (NULL
, previous_prefix
, name
, cu
);
4328 make_cleanup (xfree
, temp_name
);
4329 processing_current_prefix
= temp_name
;
4332 /* Add a symbol associated to this if we haven't seen the namespace
4333 before. Also, add a using directive if it's an anonymous
4336 if (dwarf2_extension (die
, cu
) == NULL
)
4340 /* FIXME: carlton/2003-06-27: Once GDB is more const-correct,
4341 this cast will hopefully become unnecessary. */
4342 type
= init_type (TYPE_CODE_NAMESPACE
, 0, 0,
4343 (char *) processing_current_prefix
,
4345 TYPE_TAG_NAME (type
) = TYPE_NAME (type
);
4347 new_symbol (die
, type
, cu
);
4348 set_die_type (die
, type
, cu
);
4351 cp_add_using_directive (processing_current_prefix
,
4352 strlen (previous_prefix
),
4353 strlen (processing_current_prefix
));
4356 if (die
->child
!= NULL
)
4358 struct die_info
*child_die
= die
->child
;
4360 while (child_die
&& child_die
->tag
)
4362 process_die (child_die
, cu
);
4363 child_die
= sibling_die (child_die
);
4367 processing_current_prefix
= previous_prefix
;
4368 do_cleanups (back_to
);
4371 /* Return the name of the namespace represented by DIE. Set
4372 *IS_ANONYMOUS to tell whether or not the namespace is an anonymous
4376 namespace_name (struct die_info
*die
, int *is_anonymous
, struct dwarf2_cu
*cu
)
4378 struct die_info
*current_die
;
4379 const char *name
= NULL
;
4381 /* Loop through the extensions until we find a name. */
4383 for (current_die
= die
;
4384 current_die
!= NULL
;
4385 current_die
= dwarf2_extension (die
, cu
))
4387 name
= dwarf2_name (current_die
, cu
);
4392 /* Is it an anonymous namespace? */
4394 *is_anonymous
= (name
== NULL
);
4396 name
= "(anonymous namespace)";
4401 /* Extract all information from a DW_TAG_pointer_type DIE and add to
4402 the user defined type vector. */
4405 read_tag_pointer_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
4407 struct comp_unit_head
*cu_header
= &cu
->header
;
4409 struct attribute
*attr_byte_size
;
4410 struct attribute
*attr_address_class
;
4411 int byte_size
, addr_class
;
4418 type
= lookup_pointer_type (die_type (die
, cu
));
4420 attr_byte_size
= dwarf2_attr (die
, DW_AT_byte_size
, cu
);
4422 byte_size
= DW_UNSND (attr_byte_size
);
4424 byte_size
= cu_header
->addr_size
;
4426 attr_address_class
= dwarf2_attr (die
, DW_AT_address_class
, cu
);
4427 if (attr_address_class
)
4428 addr_class
= DW_UNSND (attr_address_class
);
4430 addr_class
= DW_ADDR_none
;
4432 /* If the pointer size or address class is different than the
4433 default, create a type variant marked as such and set the
4434 length accordingly. */
4435 if (TYPE_LENGTH (type
) != byte_size
|| addr_class
!= DW_ADDR_none
)
4437 if (ADDRESS_CLASS_TYPE_FLAGS_P ())
4441 type_flags
= ADDRESS_CLASS_TYPE_FLAGS (byte_size
, addr_class
);
4442 gdb_assert ((type_flags
& ~TYPE_FLAG_ADDRESS_CLASS_ALL
) == 0);
4443 type
= make_type_with_address_space (type
, type_flags
);
4445 else if (TYPE_LENGTH (type
) != byte_size
)
4447 complaint (&symfile_complaints
, _("invalid pointer size %d"), byte_size
);
4450 /* Should we also complain about unhandled address classes? */
4454 TYPE_LENGTH (type
) = byte_size
;
4455 set_die_type (die
, type
, cu
);
4458 /* Extract all information from a DW_TAG_ptr_to_member_type DIE and add to
4459 the user defined type vector. */
4462 read_tag_ptr_to_member_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
4464 struct objfile
*objfile
= cu
->objfile
;
4466 struct type
*to_type
;
4467 struct type
*domain
;
4474 type
= alloc_type (objfile
);
4475 to_type
= die_type (die
, cu
);
4476 domain
= die_containing_type (die
, cu
);
4477 smash_to_member_type (type
, domain
, to_type
);
4479 set_die_type (die
, type
, cu
);
4482 /* Extract all information from a DW_TAG_reference_type DIE and add to
4483 the user defined type vector. */
4486 read_tag_reference_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
4488 struct comp_unit_head
*cu_header
= &cu
->header
;
4490 struct attribute
*attr
;
4497 type
= lookup_reference_type (die_type (die
, cu
));
4498 attr
= dwarf2_attr (die
, DW_AT_byte_size
, cu
);
4501 TYPE_LENGTH (type
) = DW_UNSND (attr
);
4505 TYPE_LENGTH (type
) = cu_header
->addr_size
;
4507 set_die_type (die
, type
, cu
);
4511 read_tag_const_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 (1, TYPE_VOLATILE (base_type
), base_type
, 0),
4526 read_tag_volatile_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
4528 struct type
*base_type
;
4535 base_type
= die_type (die
, cu
);
4536 set_die_type (die
, make_cv_type (TYPE_CONST (base_type
), 1, base_type
, 0),
4540 /* Extract all information from a DW_TAG_string_type DIE and add to
4541 the user defined type vector. It isn't really a user defined type,
4542 but it behaves like one, with other DIE's using an AT_user_def_type
4543 attribute to reference it. */
4546 read_tag_string_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
4548 struct objfile
*objfile
= cu
->objfile
;
4549 struct type
*type
, *range_type
, *index_type
, *char_type
;
4550 struct attribute
*attr
;
4551 unsigned int length
;
4558 attr
= dwarf2_attr (die
, DW_AT_string_length
, cu
);
4561 length
= DW_UNSND (attr
);
4565 /* check for the DW_AT_byte_size attribute */
4566 attr
= dwarf2_attr (die
, DW_AT_byte_size
, cu
);
4569 length
= DW_UNSND (attr
);
4576 index_type
= dwarf2_fundamental_type (objfile
, FT_INTEGER
, cu
);
4577 range_type
= create_range_type (NULL
, index_type
, 1, length
);
4578 if (cu
->language
== language_fortran
)
4580 /* Need to create a unique string type for bounds
4582 type
= create_string_type (0, range_type
);
4586 char_type
= dwarf2_fundamental_type (objfile
, FT_CHAR
, cu
);
4587 type
= create_string_type (char_type
, range_type
);
4589 set_die_type (die
, type
, cu
);
4592 /* Handle DIES due to C code like:
4596 int (*funcp)(int a, long l);
4600 ('funcp' generates a DW_TAG_subroutine_type DIE)
4604 read_subroutine_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
4606 struct type
*type
; /* Type that this function returns */
4607 struct type
*ftype
; /* Function that returns above type */
4608 struct attribute
*attr
;
4610 /* Decode the type that this subroutine returns */
4615 type
= die_type (die
, cu
);
4616 ftype
= make_function_type (type
, (struct type
**) 0);
4618 /* All functions in C++ and Java have prototypes. */
4619 attr
= dwarf2_attr (die
, DW_AT_prototyped
, cu
);
4620 if ((attr
&& (DW_UNSND (attr
) != 0))
4621 || cu
->language
== language_cplus
4622 || cu
->language
== language_java
)
4623 TYPE_FLAGS (ftype
) |= TYPE_FLAG_PROTOTYPED
;
4625 if (die
->child
!= NULL
)
4627 struct die_info
*child_die
;
4631 /* Count the number of parameters.
4632 FIXME: GDB currently ignores vararg functions, but knows about
4633 vararg member functions. */
4634 child_die
= die
->child
;
4635 while (child_die
&& child_die
->tag
)
4637 if (child_die
->tag
== DW_TAG_formal_parameter
)
4639 else if (child_die
->tag
== DW_TAG_unspecified_parameters
)
4640 TYPE_FLAGS (ftype
) |= TYPE_FLAG_VARARGS
;
4641 child_die
= sibling_die (child_die
);
4644 /* Allocate storage for parameters and fill them in. */
4645 TYPE_NFIELDS (ftype
) = nparams
;
4646 TYPE_FIELDS (ftype
) = (struct field
*)
4647 TYPE_ZALLOC (ftype
, nparams
* sizeof (struct field
));
4649 child_die
= die
->child
;
4650 while (child_die
&& child_die
->tag
)
4652 if (child_die
->tag
== DW_TAG_formal_parameter
)
4654 /* Dwarf2 has no clean way to discern C++ static and non-static
4655 member functions. G++ helps GDB by marking the first
4656 parameter for non-static member functions (which is the
4657 this pointer) as artificial. We pass this information
4658 to dwarf2_add_member_fn via TYPE_FIELD_ARTIFICIAL. */
4659 attr
= dwarf2_attr (child_die
, DW_AT_artificial
, cu
);
4661 TYPE_FIELD_ARTIFICIAL (ftype
, iparams
) = DW_UNSND (attr
);
4663 TYPE_FIELD_ARTIFICIAL (ftype
, iparams
) = 0;
4664 TYPE_FIELD_TYPE (ftype
, iparams
) = die_type (child_die
, cu
);
4667 child_die
= sibling_die (child_die
);
4671 set_die_type (die
, ftype
, cu
);
4675 read_typedef (struct die_info
*die
, struct dwarf2_cu
*cu
)
4677 struct objfile
*objfile
= cu
->objfile
;
4678 struct attribute
*attr
;
4683 attr
= dwarf2_attr (die
, DW_AT_name
, cu
);
4684 if (attr
&& DW_STRING (attr
))
4686 name
= DW_STRING (attr
);
4688 set_die_type (die
, init_type (TYPE_CODE_TYPEDEF
, 0,
4689 TYPE_FLAG_TARGET_STUB
, name
, objfile
),
4691 TYPE_TARGET_TYPE (die
->type
) = die_type (die
, cu
);
4695 /* Find a representation of a given base type and install
4696 it in the TYPE field of the die. */
4699 read_base_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
4701 struct objfile
*objfile
= cu
->objfile
;
4703 struct attribute
*attr
;
4704 int encoding
= 0, size
= 0;
4706 /* If we've already decoded this die, this is a no-op. */
4712 attr
= dwarf2_attr (die
, DW_AT_encoding
, cu
);
4715 encoding
= DW_UNSND (attr
);
4717 attr
= dwarf2_attr (die
, DW_AT_byte_size
, cu
);
4720 size
= DW_UNSND (attr
);
4722 attr
= dwarf2_attr (die
, DW_AT_name
, cu
);
4723 if (attr
&& DW_STRING (attr
))
4725 enum type_code code
= TYPE_CODE_INT
;
4730 case DW_ATE_address
:
4731 /* Turn DW_ATE_address into a void * pointer. */
4732 code
= TYPE_CODE_PTR
;
4733 type_flags
|= TYPE_FLAG_UNSIGNED
;
4735 case DW_ATE_boolean
:
4736 code
= TYPE_CODE_BOOL
;
4737 type_flags
|= TYPE_FLAG_UNSIGNED
;
4739 case DW_ATE_complex_float
:
4740 code
= TYPE_CODE_COMPLEX
;
4743 code
= TYPE_CODE_FLT
;
4747 case DW_ATE_unsigned
:
4748 type_flags
|= TYPE_FLAG_UNSIGNED
;
4750 case DW_ATE_signed_char
:
4751 if (cu
->language
== language_m2
)
4752 code
= TYPE_CODE_CHAR
;
4754 case DW_ATE_unsigned_char
:
4755 if (cu
->language
== language_m2
)
4756 code
= TYPE_CODE_CHAR
;
4757 type_flags
|= TYPE_FLAG_UNSIGNED
;
4760 complaint (&symfile_complaints
, _("unsupported DW_AT_encoding: '%s'"),
4761 dwarf_type_encoding_name (encoding
));
4764 type
= init_type (code
, size
, type_flags
, DW_STRING (attr
), objfile
);
4765 if (encoding
== DW_ATE_address
)
4766 TYPE_TARGET_TYPE (type
) = dwarf2_fundamental_type (objfile
, FT_VOID
,
4768 else if (encoding
== DW_ATE_complex_float
)
4771 TYPE_TARGET_TYPE (type
)
4772 = dwarf2_fundamental_type (objfile
, FT_EXT_PREC_FLOAT
, cu
);
4773 else if (size
== 16)
4774 TYPE_TARGET_TYPE (type
)
4775 = dwarf2_fundamental_type (objfile
, FT_DBL_PREC_FLOAT
, cu
);
4777 TYPE_TARGET_TYPE (type
)
4778 = dwarf2_fundamental_type (objfile
, FT_FLOAT
, cu
);
4783 type
= dwarf_base_type (encoding
, size
, cu
);
4785 set_die_type (die
, type
, cu
);
4788 /* Read the given DW_AT_subrange DIE. */
4791 read_subrange_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
4793 struct type
*base_type
;
4794 struct type
*range_type
;
4795 struct attribute
*attr
;
4799 /* If we have already decoded this die, then nothing more to do. */
4803 base_type
= die_type (die
, cu
);
4804 if (base_type
== NULL
)
4806 complaint (&symfile_complaints
,
4807 _("DW_AT_type missing from DW_TAG_subrange_type"));
4811 if (TYPE_CODE (base_type
) == TYPE_CODE_VOID
)
4812 base_type
= alloc_type (NULL
);
4814 if (cu
->language
== language_fortran
)
4816 /* FORTRAN implies a lower bound of 1, if not given. */
4820 /* FIXME: For variable sized arrays either of these could be
4821 a variable rather than a constant value. We'll allow it,
4822 but we don't know how to handle it. */
4823 attr
= dwarf2_attr (die
, DW_AT_lower_bound
, cu
);
4825 low
= dwarf2_get_attr_constant_value (attr
, 0);
4827 attr
= dwarf2_attr (die
, DW_AT_upper_bound
, cu
);
4830 if (attr
->form
== DW_FORM_block1
)
4832 /* GCC encodes arrays with unspecified or dynamic length
4833 with a DW_FORM_block1 attribute.
4834 FIXME: GDB does not yet know how to handle dynamic
4835 arrays properly, treat them as arrays with unspecified
4838 FIXME: jimb/2003-09-22: GDB does not really know
4839 how to handle arrays of unspecified length
4840 either; we just represent them as zero-length
4841 arrays. Choose an appropriate upper bound given
4842 the lower bound we've computed above. */
4846 high
= dwarf2_get_attr_constant_value (attr
, 1);
4849 range_type
= create_range_type (NULL
, base_type
, low
, high
);
4851 attr
= dwarf2_attr (die
, DW_AT_name
, cu
);
4852 if (attr
&& DW_STRING (attr
))
4853 TYPE_NAME (range_type
) = DW_STRING (attr
);
4855 attr
= dwarf2_attr (die
, DW_AT_byte_size
, cu
);
4857 TYPE_LENGTH (range_type
) = DW_UNSND (attr
);
4859 set_die_type (die
, range_type
, cu
);
4863 /* Read a whole compilation unit into a linked list of dies. */
4865 static struct die_info
*
4866 read_comp_unit (gdb_byte
*info_ptr
, bfd
*abfd
, struct dwarf2_cu
*cu
)
4868 return read_die_and_children (info_ptr
, abfd
, cu
, &info_ptr
, NULL
);
4871 /* Read a single die and all its descendents. Set the die's sibling
4872 field to NULL; set other fields in the die correctly, and set all
4873 of the descendents' fields correctly. Set *NEW_INFO_PTR to the
4874 location of the info_ptr after reading all of those dies. PARENT
4875 is the parent of the die in question. */
4877 static struct die_info
*
4878 read_die_and_children (gdb_byte
*info_ptr
, bfd
*abfd
,
4879 struct dwarf2_cu
*cu
,
4880 gdb_byte
**new_info_ptr
,
4881 struct die_info
*parent
)
4883 struct die_info
*die
;
4887 cur_ptr
= read_full_die (&die
, abfd
, info_ptr
, cu
, &has_children
);
4888 store_in_ref_table (die
->offset
, die
, cu
);
4892 die
->child
= read_die_and_siblings (cur_ptr
, abfd
, cu
,
4898 *new_info_ptr
= cur_ptr
;
4901 die
->sibling
= NULL
;
4902 die
->parent
= parent
;
4906 /* Read a die, all of its descendents, and all of its siblings; set
4907 all of the fields of all of the dies correctly. Arguments are as
4908 in read_die_and_children. */
4910 static struct die_info
*
4911 read_die_and_siblings (gdb_byte
*info_ptr
, bfd
*abfd
,
4912 struct dwarf2_cu
*cu
,
4913 gdb_byte
**new_info_ptr
,
4914 struct die_info
*parent
)
4916 struct die_info
*first_die
, *last_sibling
;
4920 first_die
= last_sibling
= NULL
;
4924 struct die_info
*die
4925 = read_die_and_children (cur_ptr
, abfd
, cu
, &cur_ptr
, parent
);
4933 last_sibling
->sibling
= die
;
4938 *new_info_ptr
= cur_ptr
;
4948 /* Free a linked list of dies. */
4951 free_die_list (struct die_info
*dies
)
4953 struct die_info
*die
, *next
;
4958 if (die
->child
!= NULL
)
4959 free_die_list (die
->child
);
4960 next
= die
->sibling
;
4967 /* Read the contents of the section at OFFSET and of size SIZE from the
4968 object file specified by OBJFILE into the objfile_obstack and return it. */
4971 dwarf2_read_section (struct objfile
*objfile
, asection
*sectp
)
4973 bfd
*abfd
= objfile
->obfd
;
4974 gdb_byte
*buf
, *retbuf
;
4975 bfd_size_type size
= bfd_get_section_size (sectp
);
4980 buf
= obstack_alloc (&objfile
->objfile_obstack
, size
);
4981 retbuf
= symfile_relocate_debug_section (abfd
, sectp
, buf
);
4985 if (bfd_seek (abfd
, sectp
->filepos
, SEEK_SET
) != 0
4986 || bfd_bread (buf
, size
, abfd
) != size
)
4987 error (_("Dwarf Error: Can't read DWARF data from '%s'"),
4988 bfd_get_filename (abfd
));
4993 /* In DWARF version 2, the description of the debugging information is
4994 stored in a separate .debug_abbrev section. Before we read any
4995 dies from a section we read in all abbreviations and install them
4996 in a hash table. This function also sets flags in CU describing
4997 the data found in the abbrev table. */
5000 dwarf2_read_abbrevs (bfd
*abfd
, struct dwarf2_cu
*cu
)
5002 struct comp_unit_head
*cu_header
= &cu
->header
;
5003 gdb_byte
*abbrev_ptr
;
5004 struct abbrev_info
*cur_abbrev
;
5005 unsigned int abbrev_number
, bytes_read
, abbrev_name
;
5006 unsigned int abbrev_form
, hash_number
;
5007 struct attr_abbrev
*cur_attrs
;
5008 unsigned int allocated_attrs
;
5010 /* Initialize dwarf2 abbrevs */
5011 obstack_init (&cu
->abbrev_obstack
);
5012 cu
->dwarf2_abbrevs
= obstack_alloc (&cu
->abbrev_obstack
,
5014 * sizeof (struct abbrev_info
*)));
5015 memset (cu
->dwarf2_abbrevs
, 0,
5016 ABBREV_HASH_SIZE
* sizeof (struct abbrev_info
*));
5018 abbrev_ptr
= dwarf2_per_objfile
->abbrev_buffer
+ cu_header
->abbrev_offset
;
5019 abbrev_number
= read_unsigned_leb128 (abfd
, abbrev_ptr
, &bytes_read
);
5020 abbrev_ptr
+= bytes_read
;
5022 allocated_attrs
= ATTR_ALLOC_CHUNK
;
5023 cur_attrs
= xmalloc (allocated_attrs
* sizeof (struct attr_abbrev
));
5025 /* loop until we reach an abbrev number of 0 */
5026 while (abbrev_number
)
5028 cur_abbrev
= dwarf_alloc_abbrev (cu
);
5030 /* read in abbrev header */
5031 cur_abbrev
->number
= abbrev_number
;
5032 cur_abbrev
->tag
= read_unsigned_leb128 (abfd
, abbrev_ptr
, &bytes_read
);
5033 abbrev_ptr
+= bytes_read
;
5034 cur_abbrev
->has_children
= read_1_byte (abfd
, abbrev_ptr
);
5037 if (cur_abbrev
->tag
== DW_TAG_namespace
)
5038 cu
->has_namespace_info
= 1;
5040 /* now read in declarations */
5041 abbrev_name
= read_unsigned_leb128 (abfd
, abbrev_ptr
, &bytes_read
);
5042 abbrev_ptr
+= bytes_read
;
5043 abbrev_form
= read_unsigned_leb128 (abfd
, abbrev_ptr
, &bytes_read
);
5044 abbrev_ptr
+= bytes_read
;
5047 if (cur_abbrev
->num_attrs
== allocated_attrs
)
5049 allocated_attrs
+= ATTR_ALLOC_CHUNK
;
5051 = xrealloc (cur_attrs
, (allocated_attrs
5052 * sizeof (struct attr_abbrev
)));
5055 /* Record whether this compilation unit might have
5056 inter-compilation-unit references. If we don't know what form
5057 this attribute will have, then it might potentially be a
5058 DW_FORM_ref_addr, so we conservatively expect inter-CU
5061 if (abbrev_form
== DW_FORM_ref_addr
5062 || abbrev_form
== DW_FORM_indirect
)
5063 cu
->has_form_ref_addr
= 1;
5065 cur_attrs
[cur_abbrev
->num_attrs
].name
= abbrev_name
;
5066 cur_attrs
[cur_abbrev
->num_attrs
++].form
= abbrev_form
;
5067 abbrev_name
= read_unsigned_leb128 (abfd
, abbrev_ptr
, &bytes_read
);
5068 abbrev_ptr
+= bytes_read
;
5069 abbrev_form
= read_unsigned_leb128 (abfd
, abbrev_ptr
, &bytes_read
);
5070 abbrev_ptr
+= bytes_read
;
5073 cur_abbrev
->attrs
= obstack_alloc (&cu
->abbrev_obstack
,
5074 (cur_abbrev
->num_attrs
5075 * sizeof (struct attr_abbrev
)));
5076 memcpy (cur_abbrev
->attrs
, cur_attrs
,
5077 cur_abbrev
->num_attrs
* sizeof (struct attr_abbrev
));
5079 hash_number
= abbrev_number
% ABBREV_HASH_SIZE
;
5080 cur_abbrev
->next
= cu
->dwarf2_abbrevs
[hash_number
];
5081 cu
->dwarf2_abbrevs
[hash_number
] = cur_abbrev
;
5083 /* Get next abbreviation.
5084 Under Irix6 the abbreviations for a compilation unit are not
5085 always properly terminated with an abbrev number of 0.
5086 Exit loop if we encounter an abbreviation which we have
5087 already read (which means we are about to read the abbreviations
5088 for the next compile unit) or if the end of the abbreviation
5089 table is reached. */
5090 if ((unsigned int) (abbrev_ptr
- dwarf2_per_objfile
->abbrev_buffer
)
5091 >= dwarf2_per_objfile
->abbrev_size
)
5093 abbrev_number
= read_unsigned_leb128 (abfd
, abbrev_ptr
, &bytes_read
);
5094 abbrev_ptr
+= bytes_read
;
5095 if (dwarf2_lookup_abbrev (abbrev_number
, cu
) != NULL
)
5102 /* Release the memory used by the abbrev table for a compilation unit. */
5105 dwarf2_free_abbrev_table (void *ptr_to_cu
)
5107 struct dwarf2_cu
*cu
= ptr_to_cu
;
5109 obstack_free (&cu
->abbrev_obstack
, NULL
);
5110 cu
->dwarf2_abbrevs
= NULL
;
5113 /* Lookup an abbrev_info structure in the abbrev hash table. */
5115 static struct abbrev_info
*
5116 dwarf2_lookup_abbrev (unsigned int number
, struct dwarf2_cu
*cu
)
5118 unsigned int hash_number
;
5119 struct abbrev_info
*abbrev
;
5121 hash_number
= number
% ABBREV_HASH_SIZE
;
5122 abbrev
= cu
->dwarf2_abbrevs
[hash_number
];
5126 if (abbrev
->number
== number
)
5129 abbrev
= abbrev
->next
;
5134 /* Returns nonzero if TAG represents a type that we might generate a partial
5138 is_type_tag_for_partial (int tag
)
5143 /* Some types that would be reasonable to generate partial symbols for,
5144 that we don't at present. */
5145 case DW_TAG_array_type
:
5146 case DW_TAG_file_type
:
5147 case DW_TAG_ptr_to_member_type
:
5148 case DW_TAG_set_type
:
5149 case DW_TAG_string_type
:
5150 case DW_TAG_subroutine_type
:
5152 case DW_TAG_base_type
:
5153 case DW_TAG_class_type
:
5154 case DW_TAG_enumeration_type
:
5155 case DW_TAG_structure_type
:
5156 case DW_TAG_subrange_type
:
5157 case DW_TAG_typedef
:
5158 case DW_TAG_union_type
:
5165 /* Load all DIEs that are interesting for partial symbols into memory. */
5167 static struct partial_die_info
*
5168 load_partial_dies (bfd
*abfd
, gdb_byte
*info_ptr
, int building_psymtab
,
5169 struct dwarf2_cu
*cu
)
5171 struct partial_die_info
*part_die
;
5172 struct partial_die_info
*parent_die
, *last_die
, *first_die
= NULL
;
5173 struct abbrev_info
*abbrev
;
5174 unsigned int bytes_read
;
5175 unsigned int load_all
= 0;
5177 int nesting_level
= 1;
5182 if (cu
->per_cu
&& cu
->per_cu
->load_all_dies
)
5186 = htab_create_alloc_ex (cu
->header
.length
/ 12,
5190 &cu
->comp_unit_obstack
,
5191 hashtab_obstack_allocate
,
5192 dummy_obstack_deallocate
);
5194 part_die
= obstack_alloc (&cu
->comp_unit_obstack
,
5195 sizeof (struct partial_die_info
));
5199 abbrev
= peek_die_abbrev (info_ptr
, &bytes_read
, cu
);
5201 /* A NULL abbrev means the end of a series of children. */
5204 if (--nesting_level
== 0)
5206 /* PART_DIE was probably the last thing allocated on the
5207 comp_unit_obstack, so we could call obstack_free
5208 here. We don't do that because the waste is small,
5209 and will be cleaned up when we're done with this
5210 compilation unit. This way, we're also more robust
5211 against other users of the comp_unit_obstack. */
5214 info_ptr
+= bytes_read
;
5215 last_die
= parent_die
;
5216 parent_die
= parent_die
->die_parent
;
5220 /* Check whether this DIE is interesting enough to save. Normally
5221 we would not be interested in members here, but there may be
5222 later variables referencing them via DW_AT_specification (for
5225 && !is_type_tag_for_partial (abbrev
->tag
)
5226 && abbrev
->tag
!= DW_TAG_enumerator
5227 && abbrev
->tag
!= DW_TAG_subprogram
5228 && abbrev
->tag
!= DW_TAG_variable
5229 && abbrev
->tag
!= DW_TAG_namespace
5230 && abbrev
->tag
!= DW_TAG_member
)
5232 /* Otherwise we skip to the next sibling, if any. */
5233 info_ptr
= skip_one_die (info_ptr
+ bytes_read
, abbrev
, cu
);
5237 info_ptr
= read_partial_die (part_die
, abbrev
, bytes_read
,
5238 abfd
, info_ptr
, cu
);
5240 /* This two-pass algorithm for processing partial symbols has a
5241 high cost in cache pressure. Thus, handle some simple cases
5242 here which cover the majority of C partial symbols. DIEs
5243 which neither have specification tags in them, nor could have
5244 specification tags elsewhere pointing at them, can simply be
5245 processed and discarded.
5247 This segment is also optional; scan_partial_symbols and
5248 add_partial_symbol will handle these DIEs if we chain
5249 them in normally. When compilers which do not emit large
5250 quantities of duplicate debug information are more common,
5251 this code can probably be removed. */
5253 /* Any complete simple types at the top level (pretty much all
5254 of them, for a language without namespaces), can be processed
5256 if (parent_die
== NULL
5257 && part_die
->has_specification
== 0
5258 && part_die
->is_declaration
== 0
5259 && (part_die
->tag
== DW_TAG_typedef
5260 || part_die
->tag
== DW_TAG_base_type
5261 || part_die
->tag
== DW_TAG_subrange_type
))
5263 if (building_psymtab
&& part_die
->name
!= NULL
)
5264 add_psymbol_to_list (part_die
->name
, strlen (part_die
->name
),
5265 VAR_DOMAIN
, LOC_TYPEDEF
,
5266 &cu
->objfile
->static_psymbols
,
5267 0, (CORE_ADDR
) 0, cu
->language
, cu
->objfile
);
5268 info_ptr
= locate_pdi_sibling (part_die
, info_ptr
, abfd
, cu
);
5272 /* If we're at the second level, and we're an enumerator, and
5273 our parent has no specification (meaning possibly lives in a
5274 namespace elsewhere), then we can add the partial symbol now
5275 instead of queueing it. */
5276 if (part_die
->tag
== DW_TAG_enumerator
5277 && parent_die
!= NULL
5278 && parent_die
->die_parent
== NULL
5279 && parent_die
->tag
== DW_TAG_enumeration_type
5280 && parent_die
->has_specification
== 0)
5282 if (part_die
->name
== NULL
)
5283 complaint (&symfile_complaints
, _("malformed enumerator DIE ignored"));
5284 else if (building_psymtab
)
5285 add_psymbol_to_list (part_die
->name
, strlen (part_die
->name
),
5286 VAR_DOMAIN
, LOC_CONST
,
5287 (cu
->language
== language_cplus
5288 || cu
->language
== language_java
)
5289 ? &cu
->objfile
->global_psymbols
5290 : &cu
->objfile
->static_psymbols
,
5291 0, (CORE_ADDR
) 0, cu
->language
, cu
->objfile
);
5293 info_ptr
= locate_pdi_sibling (part_die
, info_ptr
, abfd
, cu
);
5297 /* We'll save this DIE so link it in. */
5298 part_die
->die_parent
= parent_die
;
5299 part_die
->die_sibling
= NULL
;
5300 part_die
->die_child
= NULL
;
5302 if (last_die
&& last_die
== parent_die
)
5303 last_die
->die_child
= part_die
;
5305 last_die
->die_sibling
= part_die
;
5307 last_die
= part_die
;
5309 if (first_die
== NULL
)
5310 first_die
= part_die
;
5312 /* Maybe add the DIE to the hash table. Not all DIEs that we
5313 find interesting need to be in the hash table, because we
5314 also have the parent/sibling/child chains; only those that we
5315 might refer to by offset later during partial symbol reading.
5317 For now this means things that might have be the target of a
5318 DW_AT_specification, DW_AT_abstract_origin, or
5319 DW_AT_extension. DW_AT_extension will refer only to
5320 namespaces; DW_AT_abstract_origin refers to functions (and
5321 many things under the function DIE, but we do not recurse
5322 into function DIEs during partial symbol reading) and
5323 possibly variables as well; DW_AT_specification refers to
5324 declarations. Declarations ought to have the DW_AT_declaration
5325 flag. It happens that GCC forgets to put it in sometimes, but
5326 only for functions, not for types.
5328 Adding more things than necessary to the hash table is harmless
5329 except for the performance cost. Adding too few will result in
5330 wasted time in find_partial_die, when we reread the compilation
5331 unit with load_all_dies set. */
5334 || abbrev
->tag
== DW_TAG_subprogram
5335 || abbrev
->tag
== DW_TAG_variable
5336 || abbrev
->tag
== DW_TAG_namespace
5337 || part_die
->is_declaration
)
5341 slot
= htab_find_slot_with_hash (cu
->partial_dies
, part_die
,
5342 part_die
->offset
, INSERT
);
5346 part_die
= obstack_alloc (&cu
->comp_unit_obstack
,
5347 sizeof (struct partial_die_info
));
5349 /* For some DIEs we want to follow their children (if any). For C
5350 we have no reason to follow the children of structures; for other
5351 languages we have to, both so that we can get at method physnames
5352 to infer fully qualified class names, and for DW_AT_specification. */
5353 if (last_die
->has_children
5355 || last_die
->tag
== DW_TAG_namespace
5356 || last_die
->tag
== DW_TAG_enumeration_type
5357 || (cu
->language
!= language_c
5358 && (last_die
->tag
== DW_TAG_class_type
5359 || last_die
->tag
== DW_TAG_structure_type
5360 || last_die
->tag
== DW_TAG_union_type
))))
5363 parent_die
= last_die
;
5367 /* Otherwise we skip to the next sibling, if any. */
5368 info_ptr
= locate_pdi_sibling (last_die
, info_ptr
, abfd
, cu
);
5370 /* Back to the top, do it again. */
5374 /* Read a minimal amount of information into the minimal die structure. */
5377 read_partial_die (struct partial_die_info
*part_die
,
5378 struct abbrev_info
*abbrev
,
5379 unsigned int abbrev_len
, bfd
*abfd
,
5380 gdb_byte
*info_ptr
, struct dwarf2_cu
*cu
)
5382 unsigned int bytes_read
, i
;
5383 struct attribute attr
;
5384 int has_low_pc_attr
= 0;
5385 int has_high_pc_attr
= 0;
5387 memset (part_die
, 0, sizeof (struct partial_die_info
));
5389 part_die
->offset
= info_ptr
- dwarf2_per_objfile
->info_buffer
;
5391 info_ptr
+= abbrev_len
;
5396 part_die
->tag
= abbrev
->tag
;
5397 part_die
->has_children
= abbrev
->has_children
;
5399 for (i
= 0; i
< abbrev
->num_attrs
; ++i
)
5401 info_ptr
= read_attribute (&attr
, &abbrev
->attrs
[i
], abfd
, info_ptr
, cu
);
5403 /* Store the data if it is of an attribute we want to keep in a
5404 partial symbol table. */
5409 /* Prefer DW_AT_MIPS_linkage_name over DW_AT_name. */
5410 if (part_die
->name
== NULL
)
5411 part_die
->name
= DW_STRING (&attr
);
5413 case DW_AT_comp_dir
:
5414 if (part_die
->dirname
== NULL
)
5415 part_die
->dirname
= DW_STRING (&attr
);
5417 case DW_AT_MIPS_linkage_name
:
5418 part_die
->name
= DW_STRING (&attr
);
5421 has_low_pc_attr
= 1;
5422 part_die
->lowpc
= DW_ADDR (&attr
);
5425 has_high_pc_attr
= 1;
5426 part_die
->highpc
= DW_ADDR (&attr
);
5428 case DW_AT_location
:
5429 /* Support the .debug_loc offsets */
5430 if (attr_form_is_block (&attr
))
5432 part_die
->locdesc
= DW_BLOCK (&attr
);
5434 else if (attr
.form
== DW_FORM_data4
|| attr
.form
== DW_FORM_data8
)
5436 dwarf2_complex_location_expr_complaint ();
5440 dwarf2_invalid_attrib_class_complaint ("DW_AT_location",
5441 "partial symbol information");
5444 case DW_AT_language
:
5445 part_die
->language
= DW_UNSND (&attr
);
5447 case DW_AT_external
:
5448 part_die
->is_external
= DW_UNSND (&attr
);
5450 case DW_AT_declaration
:
5451 part_die
->is_declaration
= DW_UNSND (&attr
);
5454 part_die
->has_type
= 1;
5456 case DW_AT_abstract_origin
:
5457 case DW_AT_specification
:
5458 case DW_AT_extension
:
5459 part_die
->has_specification
= 1;
5460 part_die
->spec_offset
= dwarf2_get_ref_die_offset (&attr
, cu
);
5463 /* Ignore absolute siblings, they might point outside of
5464 the current compile unit. */
5465 if (attr
.form
== DW_FORM_ref_addr
)
5466 complaint (&symfile_complaints
, _("ignoring absolute DW_AT_sibling"));
5468 part_die
->sibling
= dwarf2_per_objfile
->info_buffer
5469 + dwarf2_get_ref_die_offset (&attr
, cu
);
5471 case DW_AT_stmt_list
:
5472 part_die
->has_stmt_list
= 1;
5473 part_die
->line_offset
= DW_UNSND (&attr
);
5480 /* When using the GNU linker, .gnu.linkonce. sections are used to
5481 eliminate duplicate copies of functions and vtables and such.
5482 The linker will arbitrarily choose one and discard the others.
5483 The AT_*_pc values for such functions refer to local labels in
5484 these sections. If the section from that file was discarded, the
5485 labels are not in the output, so the relocs get a value of 0.
5486 If this is a discarded function, mark the pc bounds as invalid,
5487 so that GDB will ignore it. */
5488 if (has_low_pc_attr
&& has_high_pc_attr
5489 && part_die
->lowpc
< part_die
->highpc
5490 && (part_die
->lowpc
!= 0
5491 || (bfd_get_file_flags (abfd
) & HAS_RELOC
)))
5492 part_die
->has_pc_info
= 1;
5496 /* Find a cached partial DIE at OFFSET in CU. */
5498 static struct partial_die_info
*
5499 find_partial_die_in_comp_unit (unsigned long offset
, struct dwarf2_cu
*cu
)
5501 struct partial_die_info
*lookup_die
= NULL
;
5502 struct partial_die_info part_die
;
5504 part_die
.offset
= offset
;
5505 lookup_die
= htab_find_with_hash (cu
->partial_dies
, &part_die
, offset
);
5510 /* Find a partial DIE at OFFSET, which may or may not be in CU. */
5512 static struct partial_die_info
*
5513 find_partial_die (unsigned long offset
, struct dwarf2_cu
*cu
)
5515 struct dwarf2_per_cu_data
*per_cu
= NULL
;
5516 struct partial_die_info
*pd
= NULL
;
5518 if (offset
>= cu
->header
.offset
5519 && offset
< cu
->header
.offset
+ cu
->header
.length
)
5521 pd
= find_partial_die_in_comp_unit (offset
, cu
);
5526 per_cu
= dwarf2_find_containing_comp_unit (offset
, cu
->objfile
);
5528 if (per_cu
->cu
== NULL
)
5530 load_comp_unit (per_cu
, cu
->objfile
);
5531 per_cu
->cu
->read_in_chain
= dwarf2_per_objfile
->read_in_chain
;
5532 dwarf2_per_objfile
->read_in_chain
= per_cu
;
5535 per_cu
->cu
->last_used
= 0;
5536 pd
= find_partial_die_in_comp_unit (offset
, per_cu
->cu
);
5538 if (pd
== NULL
&& per_cu
->load_all_dies
== 0)
5540 struct cleanup
*back_to
;
5541 struct partial_die_info comp_unit_die
;
5542 struct abbrev_info
*abbrev
;
5543 unsigned int bytes_read
;
5546 per_cu
->load_all_dies
= 1;
5548 /* Re-read the DIEs. */
5549 back_to
= make_cleanup (null_cleanup
, 0);
5550 if (per_cu
->cu
->dwarf2_abbrevs
== NULL
)
5552 dwarf2_read_abbrevs (per_cu
->cu
->objfile
->obfd
, per_cu
->cu
);
5553 back_to
= make_cleanup (dwarf2_free_abbrev_table
, per_cu
->cu
);
5555 info_ptr
= per_cu
->cu
->header
.first_die_ptr
;
5556 abbrev
= peek_die_abbrev (info_ptr
, &bytes_read
, per_cu
->cu
);
5557 info_ptr
= read_partial_die (&comp_unit_die
, abbrev
, bytes_read
,
5558 per_cu
->cu
->objfile
->obfd
, info_ptr
,
5560 if (comp_unit_die
.has_children
)
5561 load_partial_dies (per_cu
->cu
->objfile
->obfd
, info_ptr
, 0, per_cu
->cu
);
5562 do_cleanups (back_to
);
5564 pd
= find_partial_die_in_comp_unit (offset
, per_cu
->cu
);
5568 internal_error (__FILE__
, __LINE__
,
5569 _("could not find partial DIE 0x%lx in cache [from module %s]\n"),
5570 offset
, bfd_get_filename (cu
->objfile
->obfd
));
5574 /* Adjust PART_DIE before generating a symbol for it. This function
5575 may set the is_external flag or change the DIE's name. */
5578 fixup_partial_die (struct partial_die_info
*part_die
,
5579 struct dwarf2_cu
*cu
)
5581 /* If we found a reference attribute and the DIE has no name, try
5582 to find a name in the referred to DIE. */
5584 if (part_die
->name
== NULL
&& part_die
->has_specification
)
5586 struct partial_die_info
*spec_die
;
5588 spec_die
= find_partial_die (part_die
->spec_offset
, cu
);
5590 fixup_partial_die (spec_die
, cu
);
5594 part_die
->name
= spec_die
->name
;
5596 /* Copy DW_AT_external attribute if it is set. */
5597 if (spec_die
->is_external
)
5598 part_die
->is_external
= spec_die
->is_external
;
5602 /* Set default names for some unnamed DIEs. */
5603 if (part_die
->name
== NULL
&& (part_die
->tag
== DW_TAG_structure_type
5604 || part_die
->tag
== DW_TAG_class_type
))
5605 part_die
->name
= "(anonymous class)";
5607 if (part_die
->name
== NULL
&& part_die
->tag
== DW_TAG_namespace
)
5608 part_die
->name
= "(anonymous namespace)";
5610 if (part_die
->tag
== DW_TAG_structure_type
5611 || part_die
->tag
== DW_TAG_class_type
5612 || part_die
->tag
== DW_TAG_union_type
)
5613 guess_structure_name (part_die
, cu
);
5616 /* Read the die from the .debug_info section buffer. Set DIEP to
5617 point to a newly allocated die with its information, except for its
5618 child, sibling, and parent fields. Set HAS_CHILDREN to tell
5619 whether the die has children or not. */
5622 read_full_die (struct die_info
**diep
, bfd
*abfd
, gdb_byte
*info_ptr
,
5623 struct dwarf2_cu
*cu
, int *has_children
)
5625 unsigned int abbrev_number
, bytes_read
, i
, offset
;
5626 struct abbrev_info
*abbrev
;
5627 struct die_info
*die
;
5629 offset
= info_ptr
- dwarf2_per_objfile
->info_buffer
;
5630 abbrev_number
= read_unsigned_leb128 (abfd
, info_ptr
, &bytes_read
);
5631 info_ptr
+= bytes_read
;
5634 die
= dwarf_alloc_die ();
5636 die
->abbrev
= abbrev_number
;
5643 abbrev
= dwarf2_lookup_abbrev (abbrev_number
, cu
);
5646 error (_("Dwarf Error: could not find abbrev number %d [in module %s]"),
5648 bfd_get_filename (abfd
));
5650 die
= dwarf_alloc_die ();
5651 die
->offset
= offset
;
5652 die
->tag
= abbrev
->tag
;
5653 die
->abbrev
= abbrev_number
;
5656 die
->num_attrs
= abbrev
->num_attrs
;
5657 die
->attrs
= (struct attribute
*)
5658 xmalloc (die
->num_attrs
* sizeof (struct attribute
));
5660 for (i
= 0; i
< abbrev
->num_attrs
; ++i
)
5662 info_ptr
= read_attribute (&die
->attrs
[i
], &abbrev
->attrs
[i
],
5663 abfd
, info_ptr
, cu
);
5665 /* If this attribute is an absolute reference to a different
5666 compilation unit, make sure that compilation unit is loaded
5668 if (die
->attrs
[i
].form
== DW_FORM_ref_addr
5669 && (DW_ADDR (&die
->attrs
[i
]) < cu
->header
.offset
5670 || (DW_ADDR (&die
->attrs
[i
])
5671 >= cu
->header
.offset
+ cu
->header
.length
)))
5673 struct dwarf2_per_cu_data
*per_cu
;
5674 per_cu
= dwarf2_find_containing_comp_unit (DW_ADDR (&die
->attrs
[i
]),
5677 /* Mark the dependence relation so that we don't flush PER_CU
5679 dwarf2_add_dependence (cu
, per_cu
);
5681 /* If it's already on the queue, we have nothing to do. */
5685 /* If the compilation unit is already loaded, just mark it as
5687 if (per_cu
->cu
!= NULL
)
5689 per_cu
->cu
->last_used
= 0;
5693 /* Add it to the queue. */
5694 queue_comp_unit (per_cu
);
5699 *has_children
= abbrev
->has_children
;
5703 /* Read an attribute value described by an attribute form. */
5706 read_attribute_value (struct attribute
*attr
, unsigned form
,
5707 bfd
*abfd
, gdb_byte
*info_ptr
,
5708 struct dwarf2_cu
*cu
)
5710 struct comp_unit_head
*cu_header
= &cu
->header
;
5711 unsigned int bytes_read
;
5712 struct dwarf_block
*blk
;
5718 case DW_FORM_ref_addr
:
5719 DW_ADDR (attr
) = read_address (abfd
, info_ptr
, cu
, &bytes_read
);
5720 info_ptr
+= bytes_read
;
5722 case DW_FORM_block2
:
5723 blk
= dwarf_alloc_block (cu
);
5724 blk
->size
= read_2_bytes (abfd
, info_ptr
);
5726 blk
->data
= read_n_bytes (abfd
, info_ptr
, blk
->size
);
5727 info_ptr
+= blk
->size
;
5728 DW_BLOCK (attr
) = blk
;
5730 case DW_FORM_block4
:
5731 blk
= dwarf_alloc_block (cu
);
5732 blk
->size
= read_4_bytes (abfd
, info_ptr
);
5734 blk
->data
= read_n_bytes (abfd
, info_ptr
, blk
->size
);
5735 info_ptr
+= blk
->size
;
5736 DW_BLOCK (attr
) = blk
;
5739 DW_UNSND (attr
) = read_2_bytes (abfd
, info_ptr
);
5743 DW_UNSND (attr
) = read_4_bytes (abfd
, info_ptr
);
5747 DW_UNSND (attr
) = read_8_bytes (abfd
, info_ptr
);
5750 case DW_FORM_string
:
5751 DW_STRING (attr
) = read_string (abfd
, info_ptr
, &bytes_read
);
5752 info_ptr
+= bytes_read
;
5755 DW_STRING (attr
) = read_indirect_string (abfd
, info_ptr
, cu_header
,
5757 info_ptr
+= bytes_read
;
5760 blk
= dwarf_alloc_block (cu
);
5761 blk
->size
= read_unsigned_leb128 (abfd
, info_ptr
, &bytes_read
);
5762 info_ptr
+= bytes_read
;
5763 blk
->data
= read_n_bytes (abfd
, info_ptr
, blk
->size
);
5764 info_ptr
+= blk
->size
;
5765 DW_BLOCK (attr
) = blk
;
5767 case DW_FORM_block1
:
5768 blk
= dwarf_alloc_block (cu
);
5769 blk
->size
= read_1_byte (abfd
, info_ptr
);
5771 blk
->data
= read_n_bytes (abfd
, info_ptr
, blk
->size
);
5772 info_ptr
+= blk
->size
;
5773 DW_BLOCK (attr
) = blk
;
5776 DW_UNSND (attr
) = read_1_byte (abfd
, info_ptr
);
5780 DW_UNSND (attr
) = read_1_byte (abfd
, info_ptr
);
5784 DW_SND (attr
) = read_signed_leb128 (abfd
, info_ptr
, &bytes_read
);
5785 info_ptr
+= bytes_read
;
5788 DW_UNSND (attr
) = read_unsigned_leb128 (abfd
, info_ptr
, &bytes_read
);
5789 info_ptr
+= bytes_read
;
5792 DW_ADDR (attr
) = cu
->header
.offset
+ read_1_byte (abfd
, info_ptr
);
5796 DW_ADDR (attr
) = cu
->header
.offset
+ read_2_bytes (abfd
, info_ptr
);
5800 DW_ADDR (attr
) = cu
->header
.offset
+ read_4_bytes (abfd
, info_ptr
);
5804 DW_ADDR (attr
) = cu
->header
.offset
+ read_8_bytes (abfd
, info_ptr
);
5807 case DW_FORM_ref_udata
:
5808 DW_ADDR (attr
) = (cu
->header
.offset
5809 + read_unsigned_leb128 (abfd
, info_ptr
, &bytes_read
));
5810 info_ptr
+= bytes_read
;
5812 case DW_FORM_indirect
:
5813 form
= read_unsigned_leb128 (abfd
, info_ptr
, &bytes_read
);
5814 info_ptr
+= bytes_read
;
5815 info_ptr
= read_attribute_value (attr
, form
, abfd
, info_ptr
, cu
);
5818 error (_("Dwarf Error: Cannot handle %s in DWARF reader [in module %s]"),
5819 dwarf_form_name (form
),
5820 bfd_get_filename (abfd
));
5825 /* Read an attribute described by an abbreviated attribute. */
5828 read_attribute (struct attribute
*attr
, struct attr_abbrev
*abbrev
,
5829 bfd
*abfd
, gdb_byte
*info_ptr
, struct dwarf2_cu
*cu
)
5831 attr
->name
= abbrev
->name
;
5832 return read_attribute_value (attr
, abbrev
->form
, abfd
, info_ptr
, cu
);
5835 /* read dwarf information from a buffer */
5838 read_1_byte (bfd
*abfd
, gdb_byte
*buf
)
5840 return bfd_get_8 (abfd
, buf
);
5844 read_1_signed_byte (bfd
*abfd
, gdb_byte
*buf
)
5846 return bfd_get_signed_8 (abfd
, buf
);
5850 read_2_bytes (bfd
*abfd
, gdb_byte
*buf
)
5852 return bfd_get_16 (abfd
, buf
);
5856 read_2_signed_bytes (bfd
*abfd
, gdb_byte
*buf
)
5858 return bfd_get_signed_16 (abfd
, buf
);
5862 read_4_bytes (bfd
*abfd
, gdb_byte
*buf
)
5864 return bfd_get_32 (abfd
, buf
);
5868 read_4_signed_bytes (bfd
*abfd
, gdb_byte
*buf
)
5870 return bfd_get_signed_32 (abfd
, buf
);
5873 static unsigned long
5874 read_8_bytes (bfd
*abfd
, gdb_byte
*buf
)
5876 return bfd_get_64 (abfd
, buf
);
5880 read_address (bfd
*abfd
, gdb_byte
*buf
, struct dwarf2_cu
*cu
,
5881 unsigned int *bytes_read
)
5883 struct comp_unit_head
*cu_header
= &cu
->header
;
5884 CORE_ADDR retval
= 0;
5886 if (cu_header
->signed_addr_p
)
5888 switch (cu_header
->addr_size
)
5891 retval
= bfd_get_signed_16 (abfd
, buf
);
5894 retval
= bfd_get_signed_32 (abfd
, buf
);
5897 retval
= bfd_get_signed_64 (abfd
, buf
);
5900 internal_error (__FILE__
, __LINE__
,
5901 _("read_address: bad switch, signed [in module %s]"),
5902 bfd_get_filename (abfd
));
5907 switch (cu_header
->addr_size
)
5910 retval
= bfd_get_16 (abfd
, buf
);
5913 retval
= bfd_get_32 (abfd
, buf
);
5916 retval
= bfd_get_64 (abfd
, buf
);
5919 internal_error (__FILE__
, __LINE__
,
5920 _("read_address: bad switch, unsigned [in module %s]"),
5921 bfd_get_filename (abfd
));
5925 *bytes_read
= cu_header
->addr_size
;
5929 /* Read the initial length from a section. The (draft) DWARF 3
5930 specification allows the initial length to take up either 4 bytes
5931 or 12 bytes. If the first 4 bytes are 0xffffffff, then the next 8
5932 bytes describe the length and all offsets will be 8 bytes in length
5935 An older, non-standard 64-bit format is also handled by this
5936 function. The older format in question stores the initial length
5937 as an 8-byte quantity without an escape value. Lengths greater
5938 than 2^32 aren't very common which means that the initial 4 bytes
5939 is almost always zero. Since a length value of zero doesn't make
5940 sense for the 32-bit format, this initial zero can be considered to
5941 be an escape value which indicates the presence of the older 64-bit
5942 format. As written, the code can't detect (old format) lengths
5943 greater than 4GB. If it becomes necessary to handle lengths
5944 somewhat larger than 4GB, we could allow other small values (such
5945 as the non-sensical values of 1, 2, and 3) to also be used as
5946 escape values indicating the presence of the old format.
5948 The value returned via bytes_read should be used to increment the
5949 relevant pointer after calling read_initial_length().
5951 As a side effect, this function sets the fields initial_length_size
5952 and offset_size in cu_header to the values appropriate for the
5953 length field. (The format of the initial length field determines
5954 the width of file offsets to be fetched later with read_offset().)
5956 [ Note: read_initial_length() and read_offset() are based on the
5957 document entitled "DWARF Debugging Information Format", revision
5958 3, draft 8, dated November 19, 2001. This document was obtained
5961 http://reality.sgiweb.org/davea/dwarf3-draft8-011125.pdf
5963 This document is only a draft and is subject to change. (So beware.)
5965 Details regarding the older, non-standard 64-bit format were
5966 determined empirically by examining 64-bit ELF files produced by
5967 the SGI toolchain on an IRIX 6.5 machine.
5969 - Kevin, July 16, 2002
5973 read_initial_length (bfd
*abfd
, gdb_byte
*buf
, struct comp_unit_head
*cu_header
,
5974 unsigned int *bytes_read
)
5976 LONGEST length
= bfd_get_32 (abfd
, buf
);
5978 if (length
== 0xffffffff)
5980 length
= bfd_get_64 (abfd
, buf
+ 4);
5983 else if (length
== 0)
5985 /* Handle the (non-standard) 64-bit DWARF2 format used by IRIX. */
5986 length
= bfd_get_64 (abfd
, buf
);
5996 gdb_assert (cu_header
->initial_length_size
== 0
5997 || cu_header
->initial_length_size
== 4
5998 || cu_header
->initial_length_size
== 8
5999 || cu_header
->initial_length_size
== 12);
6001 if (cu_header
->initial_length_size
!= 0
6002 && cu_header
->initial_length_size
!= *bytes_read
)
6003 complaint (&symfile_complaints
,
6004 _("intermixed 32-bit and 64-bit DWARF sections"));
6006 cu_header
->initial_length_size
= *bytes_read
;
6007 cu_header
->offset_size
= (*bytes_read
== 4) ? 4 : 8;
6013 /* Read an offset from the data stream. The size of the offset is
6014 given by cu_header->offset_size. */
6017 read_offset (bfd
*abfd
, gdb_byte
*buf
, const struct comp_unit_head
*cu_header
,
6018 unsigned int *bytes_read
)
6022 switch (cu_header
->offset_size
)
6025 retval
= bfd_get_32 (abfd
, buf
);
6029 retval
= bfd_get_64 (abfd
, buf
);
6033 internal_error (__FILE__
, __LINE__
,
6034 _("read_offset: bad switch [in module %s]"),
6035 bfd_get_filename (abfd
));
6042 read_n_bytes (bfd
*abfd
, gdb_byte
*buf
, unsigned int size
)
6044 /* If the size of a host char is 8 bits, we can return a pointer
6045 to the buffer, otherwise we have to copy the data to a buffer
6046 allocated on the temporary obstack. */
6047 gdb_assert (HOST_CHAR_BIT
== 8);
6052 read_string (bfd
*abfd
, gdb_byte
*buf
, unsigned int *bytes_read_ptr
)
6054 /* If the size of a host char is 8 bits, we can return a pointer
6055 to the string, otherwise we have to copy the string to a buffer
6056 allocated on the temporary obstack. */
6057 gdb_assert (HOST_CHAR_BIT
== 8);
6060 *bytes_read_ptr
= 1;
6063 *bytes_read_ptr
= strlen ((char *) buf
) + 1;
6064 return (char *) buf
;
6068 read_indirect_string (bfd
*abfd
, gdb_byte
*buf
,
6069 const struct comp_unit_head
*cu_header
,
6070 unsigned int *bytes_read_ptr
)
6072 LONGEST str_offset
= read_offset (abfd
, buf
, cu_header
,
6075 if (dwarf2_per_objfile
->str_buffer
== NULL
)
6077 error (_("DW_FORM_strp used without .debug_str section [in module %s]"),
6078 bfd_get_filename (abfd
));
6081 if (str_offset
>= dwarf2_per_objfile
->str_size
)
6083 error (_("DW_FORM_strp pointing outside of .debug_str section [in module %s]"),
6084 bfd_get_filename (abfd
));
6087 gdb_assert (HOST_CHAR_BIT
== 8);
6088 if (dwarf2_per_objfile
->str_buffer
[str_offset
] == '\0')
6090 return (char *) (dwarf2_per_objfile
->str_buffer
+ str_offset
);
6093 static unsigned long
6094 read_unsigned_leb128 (bfd
*abfd
, gdb_byte
*buf
, unsigned int *bytes_read_ptr
)
6096 unsigned long result
;
6097 unsigned int num_read
;
6107 byte
= bfd_get_8 (abfd
, buf
);
6110 result
|= ((unsigned long)(byte
& 127) << shift
);
6111 if ((byte
& 128) == 0)
6117 *bytes_read_ptr
= num_read
;
6122 read_signed_leb128 (bfd
*abfd
, gdb_byte
*buf
, unsigned int *bytes_read_ptr
)
6125 int i
, shift
, num_read
;
6134 byte
= bfd_get_8 (abfd
, buf
);
6137 result
|= ((long)(byte
& 127) << shift
);
6139 if ((byte
& 128) == 0)
6144 if ((shift
< 8 * sizeof (result
)) && (byte
& 0x40))
6145 result
|= -(((long)1) << shift
);
6146 *bytes_read_ptr
= num_read
;
6150 /* Return a pointer to just past the end of an LEB128 number in BUF. */
6153 skip_leb128 (bfd
*abfd
, gdb_byte
*buf
)
6159 byte
= bfd_get_8 (abfd
, buf
);
6161 if ((byte
& 128) == 0)
6167 set_cu_language (unsigned int lang
, struct dwarf2_cu
*cu
)
6173 cu
->language
= language_c
;
6175 case DW_LANG_C_plus_plus
:
6176 cu
->language
= language_cplus
;
6178 case DW_LANG_Fortran77
:
6179 case DW_LANG_Fortran90
:
6180 case DW_LANG_Fortran95
:
6181 cu
->language
= language_fortran
;
6183 case DW_LANG_Mips_Assembler
:
6184 cu
->language
= language_asm
;
6187 cu
->language
= language_java
;
6191 cu
->language
= language_ada
;
6193 case DW_LANG_Modula2
:
6194 cu
->language
= language_m2
;
6196 case DW_LANG_Cobol74
:
6197 case DW_LANG_Cobol85
:
6198 case DW_LANG_Pascal83
:
6200 cu
->language
= language_minimal
;
6203 cu
->language_defn
= language_def (cu
->language
);
6206 /* Return the named attribute or NULL if not there. */
6208 static struct attribute
*
6209 dwarf2_attr (struct die_info
*die
, unsigned int name
, struct dwarf2_cu
*cu
)
6212 struct attribute
*spec
= NULL
;
6214 for (i
= 0; i
< die
->num_attrs
; ++i
)
6216 if (die
->attrs
[i
].name
== name
)
6217 return &die
->attrs
[i
];
6218 if (die
->attrs
[i
].name
== DW_AT_specification
6219 || die
->attrs
[i
].name
== DW_AT_abstract_origin
)
6220 spec
= &die
->attrs
[i
];
6224 return dwarf2_attr (follow_die_ref (die
, spec
, cu
), name
, cu
);
6229 /* Return non-zero iff the attribute NAME is defined for the given DIE,
6230 and holds a non-zero value. This function should only be used for
6231 DW_FORM_flag attributes. */
6234 dwarf2_flag_true_p (struct die_info
*die
, unsigned name
, struct dwarf2_cu
*cu
)
6236 struct attribute
*attr
= dwarf2_attr (die
, name
, cu
);
6238 return (attr
&& DW_UNSND (attr
));
6242 die_is_declaration (struct die_info
*die
, struct dwarf2_cu
*cu
)
6244 /* A DIE is a declaration if it has a DW_AT_declaration attribute
6245 which value is non-zero. However, we have to be careful with
6246 DIEs having a DW_AT_specification attribute, because dwarf2_attr()
6247 (via dwarf2_flag_true_p) follows this attribute. So we may
6248 end up accidently finding a declaration attribute that belongs
6249 to a different DIE referenced by the specification attribute,
6250 even though the given DIE does not have a declaration attribute. */
6251 return (dwarf2_flag_true_p (die
, DW_AT_declaration
, cu
)
6252 && dwarf2_attr (die
, DW_AT_specification
, cu
) == NULL
);
6255 /* Return the die giving the specification for DIE, if there is
6258 static struct die_info
*
6259 die_specification (struct die_info
*die
, struct dwarf2_cu
*cu
)
6261 struct attribute
*spec_attr
= dwarf2_attr (die
, DW_AT_specification
, cu
);
6263 if (spec_attr
== NULL
)
6266 return follow_die_ref (die
, spec_attr
, cu
);
6269 /* Free the line_header structure *LH, and any arrays and strings it
6272 free_line_header (struct line_header
*lh
)
6274 if (lh
->standard_opcode_lengths
)
6275 xfree (lh
->standard_opcode_lengths
);
6277 /* Remember that all the lh->file_names[i].name pointers are
6278 pointers into debug_line_buffer, and don't need to be freed. */
6280 xfree (lh
->file_names
);
6282 /* Similarly for the include directory names. */
6283 if (lh
->include_dirs
)
6284 xfree (lh
->include_dirs
);
6290 /* Add an entry to LH's include directory table. */
6292 add_include_dir (struct line_header
*lh
, char *include_dir
)
6294 /* Grow the array if necessary. */
6295 if (lh
->include_dirs_size
== 0)
6297 lh
->include_dirs_size
= 1; /* for testing */
6298 lh
->include_dirs
= xmalloc (lh
->include_dirs_size
6299 * sizeof (*lh
->include_dirs
));
6301 else if (lh
->num_include_dirs
>= lh
->include_dirs_size
)
6303 lh
->include_dirs_size
*= 2;
6304 lh
->include_dirs
= xrealloc (lh
->include_dirs
,
6305 (lh
->include_dirs_size
6306 * sizeof (*lh
->include_dirs
)));
6309 lh
->include_dirs
[lh
->num_include_dirs
++] = include_dir
;
6313 /* Add an entry to LH's file name table. */
6315 add_file_name (struct line_header
*lh
,
6317 unsigned int dir_index
,
6318 unsigned int mod_time
,
6319 unsigned int length
)
6321 struct file_entry
*fe
;
6323 /* Grow the array if necessary. */
6324 if (lh
->file_names_size
== 0)
6326 lh
->file_names_size
= 1; /* for testing */
6327 lh
->file_names
= xmalloc (lh
->file_names_size
6328 * sizeof (*lh
->file_names
));
6330 else if (lh
->num_file_names
>= lh
->file_names_size
)
6332 lh
->file_names_size
*= 2;
6333 lh
->file_names
= xrealloc (lh
->file_names
,
6334 (lh
->file_names_size
6335 * sizeof (*lh
->file_names
)));
6338 fe
= &lh
->file_names
[lh
->num_file_names
++];
6340 fe
->dir_index
= dir_index
;
6341 fe
->mod_time
= mod_time
;
6342 fe
->length
= length
;
6347 /* Read the statement program header starting at OFFSET in
6348 .debug_line, according to the endianness of ABFD. Return a pointer
6349 to a struct line_header, allocated using xmalloc.
6351 NOTE: the strings in the include directory and file name tables of
6352 the returned object point into debug_line_buffer, and must not be
6354 static struct line_header
*
6355 dwarf_decode_line_header (unsigned int offset
, bfd
*abfd
,
6356 struct dwarf2_cu
*cu
)
6358 struct cleanup
*back_to
;
6359 struct line_header
*lh
;
6361 unsigned int bytes_read
;
6363 char *cur_dir
, *cur_file
;
6365 if (dwarf2_per_objfile
->line_buffer
== NULL
)
6367 complaint (&symfile_complaints
, _("missing .debug_line section"));
6371 /* Make sure that at least there's room for the total_length field.
6372 That could be 12 bytes long, but we're just going to fudge that. */
6373 if (offset
+ 4 >= dwarf2_per_objfile
->line_size
)
6375 dwarf2_statement_list_fits_in_line_number_section_complaint ();
6379 lh
= xmalloc (sizeof (*lh
));
6380 memset (lh
, 0, sizeof (*lh
));
6381 back_to
= make_cleanup ((make_cleanup_ftype
*) free_line_header
,
6384 line_ptr
= dwarf2_per_objfile
->line_buffer
+ offset
;
6386 /* Read in the header. */
6388 read_initial_length (abfd
, line_ptr
, &cu
->header
, &bytes_read
);
6389 line_ptr
+= bytes_read
;
6390 if (line_ptr
+ lh
->total_length
> (dwarf2_per_objfile
->line_buffer
6391 + dwarf2_per_objfile
->line_size
))
6393 dwarf2_statement_list_fits_in_line_number_section_complaint ();
6396 lh
->statement_program_end
= line_ptr
+ lh
->total_length
;
6397 lh
->version
= read_2_bytes (abfd
, line_ptr
);
6399 lh
->header_length
= read_offset (abfd
, line_ptr
, &cu
->header
, &bytes_read
);
6400 line_ptr
+= bytes_read
;
6401 lh
->minimum_instruction_length
= read_1_byte (abfd
, line_ptr
);
6403 lh
->default_is_stmt
= read_1_byte (abfd
, line_ptr
);
6405 lh
->line_base
= read_1_signed_byte (abfd
, line_ptr
);
6407 lh
->line_range
= read_1_byte (abfd
, line_ptr
);
6409 lh
->opcode_base
= read_1_byte (abfd
, line_ptr
);
6411 lh
->standard_opcode_lengths
6412 = xmalloc (lh
->opcode_base
* sizeof (lh
->standard_opcode_lengths
[0]));
6414 lh
->standard_opcode_lengths
[0] = 1; /* This should never be used anyway. */
6415 for (i
= 1; i
< lh
->opcode_base
; ++i
)
6417 lh
->standard_opcode_lengths
[i
] = read_1_byte (abfd
, line_ptr
);
6421 /* Read directory table. */
6422 while ((cur_dir
= read_string (abfd
, line_ptr
, &bytes_read
)) != NULL
)
6424 line_ptr
+= bytes_read
;
6425 add_include_dir (lh
, cur_dir
);
6427 line_ptr
+= bytes_read
;
6429 /* Read file name table. */
6430 while ((cur_file
= read_string (abfd
, line_ptr
, &bytes_read
)) != NULL
)
6432 unsigned int dir_index
, mod_time
, length
;
6434 line_ptr
+= bytes_read
;
6435 dir_index
= read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
6436 line_ptr
+= bytes_read
;
6437 mod_time
= read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
6438 line_ptr
+= bytes_read
;
6439 length
= read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
6440 line_ptr
+= bytes_read
;
6442 add_file_name (lh
, cur_file
, dir_index
, mod_time
, length
);
6444 line_ptr
+= bytes_read
;
6445 lh
->statement_program_start
= line_ptr
;
6447 if (line_ptr
> (dwarf2_per_objfile
->line_buffer
6448 + dwarf2_per_objfile
->line_size
))
6449 complaint (&symfile_complaints
,
6450 _("line number info header doesn't fit in `.debug_line' section"));
6452 discard_cleanups (back_to
);
6456 /* This function exists to work around a bug in certain compilers
6457 (particularly GCC 2.95), in which the first line number marker of a
6458 function does not show up until after the prologue, right before
6459 the second line number marker. This function shifts ADDRESS down
6460 to the beginning of the function if necessary, and is called on
6461 addresses passed to record_line. */
6464 check_cu_functions (CORE_ADDR address
, struct dwarf2_cu
*cu
)
6466 struct function_range
*fn
;
6468 /* Find the function_range containing address. */
6473 cu
->cached_fn
= cu
->first_fn
;
6477 if (fn
->lowpc
<= address
&& fn
->highpc
> address
)
6483 while (fn
&& fn
!= cu
->cached_fn
)
6484 if (fn
->lowpc
<= address
&& fn
->highpc
> address
)
6494 if (address
!= fn
->lowpc
)
6495 complaint (&symfile_complaints
,
6496 _("misplaced first line number at 0x%lx for '%s'"),
6497 (unsigned long) address
, fn
->name
);
6502 /* Decode the Line Number Program (LNP) for the given line_header
6503 structure and CU. The actual information extracted and the type
6504 of structures created from the LNP depends on the value of PST.
6506 1. If PST is NULL, then this procedure uses the data from the program
6507 to create all necessary symbol tables, and their linetables.
6508 The compilation directory of the file is passed in COMP_DIR,
6509 and must not be NULL.
6511 2. If PST is not NULL, this procedure reads the program to determine
6512 the list of files included by the unit represented by PST, and
6513 builds all the associated partial symbol tables. In this case,
6514 the value of COMP_DIR is ignored, and can thus be NULL (the COMP_DIR
6515 is not used to compute the full name of the symtab, and therefore
6516 omitting it when building the partial symtab does not introduce
6517 the potential for inconsistency - a partial symtab and its associated
6518 symbtab having a different fullname -). */
6521 dwarf_decode_lines (struct line_header
*lh
, char *comp_dir
, bfd
*abfd
,
6522 struct dwarf2_cu
*cu
, struct partial_symtab
*pst
)
6526 unsigned int bytes_read
;
6527 unsigned char op_code
, extended_op
, adj_opcode
;
6529 struct objfile
*objfile
= cu
->objfile
;
6530 const int decode_for_pst_p
= (pst
!= NULL
);
6532 baseaddr
= ANOFFSET (objfile
->section_offsets
, SECT_OFF_TEXT (objfile
));
6534 line_ptr
= lh
->statement_program_start
;
6535 line_end
= lh
->statement_program_end
;
6537 /* Read the statement sequences until there's nothing left. */
6538 while (line_ptr
< line_end
)
6540 /* state machine registers */
6541 CORE_ADDR address
= 0;
6542 unsigned int file
= 1;
6543 unsigned int line
= 1;
6544 unsigned int column
= 0;
6545 int is_stmt
= lh
->default_is_stmt
;
6546 int basic_block
= 0;
6547 int end_sequence
= 0;
6549 if (!decode_for_pst_p
&& lh
->num_file_names
>= file
)
6551 /* Start a subfile for the current file of the state machine. */
6552 /* lh->include_dirs and lh->file_names are 0-based, but the
6553 directory and file name numbers in the statement program
6555 struct file_entry
*fe
= &lh
->file_names
[file
- 1];
6559 dir
= lh
->include_dirs
[fe
->dir_index
- 1];
6561 dwarf2_start_subfile (fe
->name
, dir
, comp_dir
);
6564 /* Decode the table. */
6565 while (!end_sequence
)
6567 op_code
= read_1_byte (abfd
, line_ptr
);
6570 if (op_code
>= lh
->opcode_base
)
6572 /* Special operand. */
6573 adj_opcode
= op_code
- lh
->opcode_base
;
6574 address
+= (adj_opcode
/ lh
->line_range
)
6575 * lh
->minimum_instruction_length
;
6576 line
+= lh
->line_base
+ (adj_opcode
% lh
->line_range
);
6577 lh
->file_names
[file
- 1].included_p
= 1;
6578 if (!decode_for_pst_p
)
6580 /* Append row to matrix using current values. */
6581 record_line (current_subfile
, line
,
6582 check_cu_functions (address
, cu
));
6586 else switch (op_code
)
6588 case DW_LNS_extended_op
:
6589 read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
6590 line_ptr
+= bytes_read
;
6591 extended_op
= read_1_byte (abfd
, line_ptr
);
6593 switch (extended_op
)
6595 case DW_LNE_end_sequence
:
6597 lh
->file_names
[file
- 1].included_p
= 1;
6598 if (!decode_for_pst_p
)
6599 record_line (current_subfile
, 0, address
);
6601 case DW_LNE_set_address
:
6602 address
= read_address (abfd
, line_ptr
, cu
, &bytes_read
);
6603 line_ptr
+= bytes_read
;
6604 address
+= baseaddr
;
6606 case DW_LNE_define_file
:
6609 unsigned int dir_index
, mod_time
, length
;
6611 cur_file
= read_string (abfd
, line_ptr
, &bytes_read
);
6612 line_ptr
+= bytes_read
;
6614 read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
6615 line_ptr
+= bytes_read
;
6617 read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
6618 line_ptr
+= bytes_read
;
6620 read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
6621 line_ptr
+= bytes_read
;
6622 add_file_name (lh
, cur_file
, dir_index
, mod_time
, length
);
6626 complaint (&symfile_complaints
,
6627 _("mangled .debug_line section"));
6632 lh
->file_names
[file
- 1].included_p
= 1;
6633 if (!decode_for_pst_p
)
6634 record_line (current_subfile
, line
,
6635 check_cu_functions (address
, cu
));
6638 case DW_LNS_advance_pc
:
6639 address
+= lh
->minimum_instruction_length
6640 * read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
6641 line_ptr
+= bytes_read
;
6643 case DW_LNS_advance_line
:
6644 line
+= read_signed_leb128 (abfd
, line_ptr
, &bytes_read
);
6645 line_ptr
+= bytes_read
;
6647 case DW_LNS_set_file
:
6649 /* The arrays lh->include_dirs and lh->file_names are
6650 0-based, but the directory and file name numbers in
6651 the statement program are 1-based. */
6652 struct file_entry
*fe
;
6655 file
= read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
6656 line_ptr
+= bytes_read
;
6657 fe
= &lh
->file_names
[file
- 1];
6659 dir
= lh
->include_dirs
[fe
->dir_index
- 1];
6661 if (!decode_for_pst_p
)
6662 dwarf2_start_subfile (fe
->name
, dir
, comp_dir
);
6665 case DW_LNS_set_column
:
6666 column
= read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
6667 line_ptr
+= bytes_read
;
6669 case DW_LNS_negate_stmt
:
6670 is_stmt
= (!is_stmt
);
6672 case DW_LNS_set_basic_block
:
6675 /* Add to the address register of the state machine the
6676 address increment value corresponding to special opcode
6677 255. I.e., this value is scaled by the minimum
6678 instruction length since special opcode 255 would have
6679 scaled the the increment. */
6680 case DW_LNS_const_add_pc
:
6681 address
+= (lh
->minimum_instruction_length
6682 * ((255 - lh
->opcode_base
) / lh
->line_range
));
6684 case DW_LNS_fixed_advance_pc
:
6685 address
+= read_2_bytes (abfd
, line_ptr
);
6690 /* Unknown standard opcode, ignore it. */
6693 for (i
= 0; i
< lh
->standard_opcode_lengths
[op_code
]; i
++)
6695 (void) read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
6696 line_ptr
+= bytes_read
;
6703 if (decode_for_pst_p
)
6707 /* Now that we're done scanning the Line Header Program, we can
6708 create the psymtab of each included file. */
6709 for (file_index
= 0; file_index
< lh
->num_file_names
; file_index
++)
6710 if (lh
->file_names
[file_index
].included_p
== 1)
6712 const struct file_entry fe
= lh
->file_names
[file_index
];
6713 char *include_name
= fe
.name
;
6714 char *dir_name
= NULL
;
6715 char *pst_filename
= pst
->filename
;
6718 dir_name
= lh
->include_dirs
[fe
.dir_index
- 1];
6720 if (!IS_ABSOLUTE_PATH (include_name
) && dir_name
!= NULL
)
6722 include_name
= concat (dir_name
, SLASH_STRING
,
6723 include_name
, (char *)NULL
);
6724 make_cleanup (xfree
, include_name
);
6727 if (!IS_ABSOLUTE_PATH (pst_filename
) && pst
->dirname
!= NULL
)
6729 pst_filename
= concat (pst
->dirname
, SLASH_STRING
,
6730 pst_filename
, (char *)NULL
);
6731 make_cleanup (xfree
, pst_filename
);
6734 if (strcmp (include_name
, pst_filename
) != 0)
6735 dwarf2_create_include_psymtab (include_name
, pst
, objfile
);
6740 /* Start a subfile for DWARF. FILENAME is the name of the file and
6741 DIRNAME the name of the source directory which contains FILENAME
6742 or NULL if not known. COMP_DIR is the compilation directory for the
6743 linetable's compilation unit or NULL if not known.
6744 This routine tries to keep line numbers from identical absolute and
6745 relative file names in a common subfile.
6747 Using the `list' example from the GDB testsuite, which resides in
6748 /srcdir and compiling it with Irix6.2 cc in /compdir using a filename
6749 of /srcdir/list0.c yields the following debugging information for list0.c:
6751 DW_AT_name: /srcdir/list0.c
6752 DW_AT_comp_dir: /compdir
6753 files.files[0].name: list0.h
6754 files.files[0].dir: /srcdir
6755 files.files[1].name: list0.c
6756 files.files[1].dir: /srcdir
6758 The line number information for list0.c has to end up in a single
6759 subfile, so that `break /srcdir/list0.c:1' works as expected.
6760 start_subfile will ensure that this happens provided that we pass the
6761 concatenation of files.files[1].dir and files.files[1].name as the
6765 dwarf2_start_subfile (char *filename
, char *dirname
, char *comp_dir
)
6769 /* While reading the DIEs, we call start_symtab(DW_AT_name, DW_AT_comp_dir).
6770 `start_symtab' will always pass the contents of DW_AT_comp_dir as
6771 second argument to start_subfile. To be consistent, we do the
6772 same here. In order not to lose the line information directory,
6773 we concatenate it to the filename when it makes sense.
6774 Note that the Dwarf3 standard says (speaking of filenames in line
6775 information): ``The directory index is ignored for file names
6776 that represent full path names''. Thus ignoring dirname in the
6777 `else' branch below isn't an issue. */
6779 if (!IS_ABSOLUTE_PATH (filename
) && dirname
!= NULL
)
6780 fullname
= concat (dirname
, SLASH_STRING
, filename
, (char *)NULL
);
6782 fullname
= filename
;
6784 start_subfile (fullname
, comp_dir
);
6786 if (fullname
!= filename
)
6791 var_decode_location (struct attribute
*attr
, struct symbol
*sym
,
6792 struct dwarf2_cu
*cu
)
6794 struct objfile
*objfile
= cu
->objfile
;
6795 struct comp_unit_head
*cu_header
= &cu
->header
;
6797 /* NOTE drow/2003-01-30: There used to be a comment and some special
6798 code here to turn a symbol with DW_AT_external and a
6799 SYMBOL_VALUE_ADDRESS of 0 into a LOC_UNRESOLVED symbol. This was
6800 necessary for platforms (maybe Alpha, certainly PowerPC GNU/Linux
6801 with some versions of binutils) where shared libraries could have
6802 relocations against symbols in their debug information - the
6803 minimal symbol would have the right address, but the debug info
6804 would not. It's no longer necessary, because we will explicitly
6805 apply relocations when we read in the debug information now. */
6807 /* A DW_AT_location attribute with no contents indicates that a
6808 variable has been optimized away. */
6809 if (attr_form_is_block (attr
) && DW_BLOCK (attr
)->size
== 0)
6811 SYMBOL_CLASS (sym
) = LOC_OPTIMIZED_OUT
;
6815 /* Handle one degenerate form of location expression specially, to
6816 preserve GDB's previous behavior when section offsets are
6817 specified. If this is just a DW_OP_addr then mark this symbol
6820 if (attr_form_is_block (attr
)
6821 && DW_BLOCK (attr
)->size
== 1 + cu_header
->addr_size
6822 && DW_BLOCK (attr
)->data
[0] == DW_OP_addr
)
6826 SYMBOL_VALUE_ADDRESS (sym
) =
6827 read_address (objfile
->obfd
, DW_BLOCK (attr
)->data
+ 1, cu
, &dummy
);
6828 fixup_symbol_section (sym
, objfile
);
6829 SYMBOL_VALUE_ADDRESS (sym
) += ANOFFSET (objfile
->section_offsets
,
6830 SYMBOL_SECTION (sym
));
6831 SYMBOL_CLASS (sym
) = LOC_STATIC
;
6835 /* NOTE drow/2002-01-30: It might be worthwhile to have a static
6836 expression evaluator, and use LOC_COMPUTED only when necessary
6837 (i.e. when the value of a register or memory location is
6838 referenced, or a thread-local block, etc.). Then again, it might
6839 not be worthwhile. I'm assuming that it isn't unless performance
6840 or memory numbers show me otherwise. */
6842 dwarf2_symbol_mark_computed (attr
, sym
, cu
);
6843 SYMBOL_CLASS (sym
) = LOC_COMPUTED
;
6846 /* Given a pointer to a DWARF information entry, figure out if we need
6847 to make a symbol table entry for it, and if so, create a new entry
6848 and return a pointer to it.
6849 If TYPE is NULL, determine symbol type from the die, otherwise
6850 used the passed type. */
6852 static struct symbol
*
6853 new_symbol (struct die_info
*die
, struct type
*type
, struct dwarf2_cu
*cu
)
6855 struct objfile
*objfile
= cu
->objfile
;
6856 struct symbol
*sym
= NULL
;
6858 struct attribute
*attr
= NULL
;
6859 struct attribute
*attr2
= NULL
;
6862 baseaddr
= ANOFFSET (objfile
->section_offsets
, SECT_OFF_TEXT (objfile
));
6864 if (die
->tag
!= DW_TAG_namespace
)
6865 name
= dwarf2_linkage_name (die
, cu
);
6867 name
= TYPE_NAME (type
);
6871 sym
= (struct symbol
*) obstack_alloc (&objfile
->objfile_obstack
,
6872 sizeof (struct symbol
));
6873 OBJSTAT (objfile
, n_syms
++);
6874 memset (sym
, 0, sizeof (struct symbol
));
6876 /* Cache this symbol's name and the name's demangled form (if any). */
6877 SYMBOL_LANGUAGE (sym
) = cu
->language
;
6878 SYMBOL_SET_NAMES (sym
, name
, strlen (name
), objfile
);
6880 /* Default assumptions.
6881 Use the passed type or decode it from the die. */
6882 SYMBOL_DOMAIN (sym
) = VAR_DOMAIN
;
6883 SYMBOL_CLASS (sym
) = LOC_OPTIMIZED_OUT
;
6885 SYMBOL_TYPE (sym
) = type
;
6887 SYMBOL_TYPE (sym
) = die_type (die
, cu
);
6888 attr
= dwarf2_attr (die
, DW_AT_decl_line
, cu
);
6891 SYMBOL_LINE (sym
) = DW_UNSND (attr
);
6896 attr
= dwarf2_attr (die
, DW_AT_low_pc
, cu
);
6899 SYMBOL_VALUE_ADDRESS (sym
) = DW_ADDR (attr
) + baseaddr
;
6901 SYMBOL_CLASS (sym
) = LOC_LABEL
;
6903 case DW_TAG_subprogram
:
6904 /* SYMBOL_BLOCK_VALUE (sym) will be filled in later by
6906 SYMBOL_CLASS (sym
) = LOC_BLOCK
;
6907 attr2
= dwarf2_attr (die
, DW_AT_external
, cu
);
6908 if (attr2
&& (DW_UNSND (attr2
) != 0))
6910 add_symbol_to_list (sym
, &global_symbols
);
6914 add_symbol_to_list (sym
, cu
->list_in_scope
);
6917 case DW_TAG_variable
:
6918 /* Compilation with minimal debug info may result in variables
6919 with missing type entries. Change the misleading `void' type
6920 to something sensible. */
6921 if (TYPE_CODE (SYMBOL_TYPE (sym
)) == TYPE_CODE_VOID
)
6922 SYMBOL_TYPE (sym
) = init_type (TYPE_CODE_INT
,
6923 TARGET_INT_BIT
/ HOST_CHAR_BIT
, 0,
6924 "<variable, no debug info>",
6926 attr
= dwarf2_attr (die
, DW_AT_const_value
, cu
);
6929 dwarf2_const_value (attr
, sym
, cu
);
6930 attr2
= dwarf2_attr (die
, DW_AT_external
, cu
);
6931 if (attr2
&& (DW_UNSND (attr2
) != 0))
6932 add_symbol_to_list (sym
, &global_symbols
);
6934 add_symbol_to_list (sym
, cu
->list_in_scope
);
6937 attr
= dwarf2_attr (die
, DW_AT_location
, cu
);
6940 var_decode_location (attr
, sym
, cu
);
6941 attr2
= dwarf2_attr (die
, DW_AT_external
, cu
);
6942 if (attr2
&& (DW_UNSND (attr2
) != 0))
6943 add_symbol_to_list (sym
, &global_symbols
);
6945 add_symbol_to_list (sym
, cu
->list_in_scope
);
6949 /* We do not know the address of this symbol.
6950 If it is an external symbol and we have type information
6951 for it, enter the symbol as a LOC_UNRESOLVED symbol.
6952 The address of the variable will then be determined from
6953 the minimal symbol table whenever the variable is
6955 attr2
= dwarf2_attr (die
, DW_AT_external
, cu
);
6956 if (attr2
&& (DW_UNSND (attr2
) != 0)
6957 && dwarf2_attr (die
, DW_AT_type
, cu
) != NULL
)
6959 SYMBOL_CLASS (sym
) = LOC_UNRESOLVED
;
6960 add_symbol_to_list (sym
, &global_symbols
);
6964 case DW_TAG_formal_parameter
:
6965 attr
= dwarf2_attr (die
, DW_AT_location
, cu
);
6968 var_decode_location (attr
, sym
, cu
);
6969 /* FIXME drow/2003-07-31: Is LOC_COMPUTED_ARG necessary? */
6970 if (SYMBOL_CLASS (sym
) == LOC_COMPUTED
)
6971 SYMBOL_CLASS (sym
) = LOC_COMPUTED_ARG
;
6973 attr
= dwarf2_attr (die
, DW_AT_const_value
, cu
);
6976 dwarf2_const_value (attr
, sym
, cu
);
6978 add_symbol_to_list (sym
, cu
->list_in_scope
);
6980 case DW_TAG_unspecified_parameters
:
6981 /* From varargs functions; gdb doesn't seem to have any
6982 interest in this information, so just ignore it for now.
6985 case DW_TAG_class_type
:
6986 case DW_TAG_structure_type
:
6987 case DW_TAG_union_type
:
6988 case DW_TAG_set_type
:
6989 case DW_TAG_enumeration_type
:
6990 SYMBOL_CLASS (sym
) = LOC_TYPEDEF
;
6991 SYMBOL_DOMAIN (sym
) = STRUCT_DOMAIN
;
6993 /* Make sure that the symbol includes appropriate enclosing
6994 classes/namespaces in its name. These are calculated in
6995 read_structure_type, and the correct name is saved in
6998 if (cu
->language
== language_cplus
6999 || cu
->language
== language_java
)
7001 struct type
*type
= SYMBOL_TYPE (sym
);
7003 if (TYPE_TAG_NAME (type
) != NULL
)
7005 /* FIXME: carlton/2003-11-10: Should this use
7006 SYMBOL_SET_NAMES instead? (The same problem also
7007 arises further down in this function.) */
7008 /* The type's name is already allocated along with
7009 this objfile, so we don't need to duplicate it
7011 SYMBOL_LINKAGE_NAME (sym
) = TYPE_TAG_NAME (type
);
7016 /* NOTE: carlton/2003-11-10: C++ and Java class symbols shouldn't
7017 really ever be static objects: otherwise, if you try
7018 to, say, break of a class's method and you're in a file
7019 which doesn't mention that class, it won't work unless
7020 the check for all static symbols in lookup_symbol_aux
7021 saves you. See the OtherFileClass tests in
7022 gdb.c++/namespace.exp. */
7024 struct pending
**list_to_add
;
7026 list_to_add
= (cu
->list_in_scope
== &file_symbols
7027 && (cu
->language
== language_cplus
7028 || cu
->language
== language_java
)
7029 ? &global_symbols
: cu
->list_in_scope
);
7031 add_symbol_to_list (sym
, list_to_add
);
7033 /* The semantics of C++ state that "struct foo { ... }" also
7034 defines a typedef for "foo". A Java class declaration also
7035 defines a typedef for the class. Synthesize a typedef symbol
7036 so that "ptype foo" works as expected. */
7037 if (cu
->language
== language_cplus
7038 || cu
->language
== language_java
)
7040 struct symbol
*typedef_sym
= (struct symbol
*)
7041 obstack_alloc (&objfile
->objfile_obstack
,
7042 sizeof (struct symbol
));
7043 *typedef_sym
= *sym
;
7044 SYMBOL_DOMAIN (typedef_sym
) = VAR_DOMAIN
;
7045 /* The symbol's name is already allocated along with
7046 this objfile, so we don't need to duplicate it for
7048 if (TYPE_NAME (SYMBOL_TYPE (sym
)) == 0)
7049 TYPE_NAME (SYMBOL_TYPE (sym
)) = SYMBOL_SEARCH_NAME (sym
);
7050 add_symbol_to_list (typedef_sym
, list_to_add
);
7054 case DW_TAG_typedef
:
7055 if (processing_has_namespace_info
7056 && processing_current_prefix
[0] != '\0')
7058 SYMBOL_LINKAGE_NAME (sym
) = typename_concat (&objfile
->objfile_obstack
,
7059 processing_current_prefix
,
7062 SYMBOL_CLASS (sym
) = LOC_TYPEDEF
;
7063 SYMBOL_DOMAIN (sym
) = VAR_DOMAIN
;
7064 add_symbol_to_list (sym
, cu
->list_in_scope
);
7066 case DW_TAG_base_type
:
7067 case DW_TAG_subrange_type
:
7068 SYMBOL_CLASS (sym
) = LOC_TYPEDEF
;
7069 SYMBOL_DOMAIN (sym
) = VAR_DOMAIN
;
7070 add_symbol_to_list (sym
, cu
->list_in_scope
);
7072 case DW_TAG_enumerator
:
7073 if (processing_has_namespace_info
7074 && processing_current_prefix
[0] != '\0')
7076 SYMBOL_LINKAGE_NAME (sym
) = typename_concat (&objfile
->objfile_obstack
,
7077 processing_current_prefix
,
7080 attr
= dwarf2_attr (die
, DW_AT_const_value
, cu
);
7083 dwarf2_const_value (attr
, sym
, cu
);
7086 /* NOTE: carlton/2003-11-10: See comment above in the
7087 DW_TAG_class_type, etc. block. */
7089 struct pending
**list_to_add
;
7091 list_to_add
= (cu
->list_in_scope
== &file_symbols
7092 && (cu
->language
== language_cplus
7093 || cu
->language
== language_java
)
7094 ? &global_symbols
: cu
->list_in_scope
);
7096 add_symbol_to_list (sym
, list_to_add
);
7099 case DW_TAG_namespace
:
7100 SYMBOL_CLASS (sym
) = LOC_TYPEDEF
;
7101 add_symbol_to_list (sym
, &global_symbols
);
7104 /* Not a tag we recognize. Hopefully we aren't processing
7105 trash data, but since we must specifically ignore things
7106 we don't recognize, there is nothing else we should do at
7108 complaint (&symfile_complaints
, _("unsupported tag: '%s'"),
7109 dwarf_tag_name (die
->tag
));
7116 /* Copy constant value from an attribute to a symbol. */
7119 dwarf2_const_value (struct attribute
*attr
, struct symbol
*sym
,
7120 struct dwarf2_cu
*cu
)
7122 struct objfile
*objfile
= cu
->objfile
;
7123 struct comp_unit_head
*cu_header
= &cu
->header
;
7124 struct dwarf_block
*blk
;
7129 if (TYPE_LENGTH (SYMBOL_TYPE (sym
)) != cu_header
->addr_size
)
7130 dwarf2_const_value_length_mismatch_complaint (DEPRECATED_SYMBOL_NAME (sym
),
7131 cu_header
->addr_size
,
7132 TYPE_LENGTH (SYMBOL_TYPE
7134 SYMBOL_VALUE_BYTES (sym
) =
7135 obstack_alloc (&objfile
->objfile_obstack
, cu_header
->addr_size
);
7136 /* NOTE: cagney/2003-05-09: In-lined store_address call with
7137 it's body - store_unsigned_integer. */
7138 store_unsigned_integer (SYMBOL_VALUE_BYTES (sym
), cu_header
->addr_size
,
7140 SYMBOL_CLASS (sym
) = LOC_CONST_BYTES
;
7142 case DW_FORM_block1
:
7143 case DW_FORM_block2
:
7144 case DW_FORM_block4
:
7146 blk
= DW_BLOCK (attr
);
7147 if (TYPE_LENGTH (SYMBOL_TYPE (sym
)) != blk
->size
)
7148 dwarf2_const_value_length_mismatch_complaint (DEPRECATED_SYMBOL_NAME (sym
),
7150 TYPE_LENGTH (SYMBOL_TYPE
7152 SYMBOL_VALUE_BYTES (sym
) =
7153 obstack_alloc (&objfile
->objfile_obstack
, blk
->size
);
7154 memcpy (SYMBOL_VALUE_BYTES (sym
), blk
->data
, blk
->size
);
7155 SYMBOL_CLASS (sym
) = LOC_CONST_BYTES
;
7158 /* The DW_AT_const_value attributes are supposed to carry the
7159 symbol's value "represented as it would be on the target
7160 architecture." By the time we get here, it's already been
7161 converted to host endianness, so we just need to sign- or
7162 zero-extend it as appropriate. */
7164 dwarf2_const_value_data (attr
, sym
, 8);
7167 dwarf2_const_value_data (attr
, sym
, 16);
7170 dwarf2_const_value_data (attr
, sym
, 32);
7173 dwarf2_const_value_data (attr
, sym
, 64);
7177 SYMBOL_VALUE (sym
) = DW_SND (attr
);
7178 SYMBOL_CLASS (sym
) = LOC_CONST
;
7182 SYMBOL_VALUE (sym
) = DW_UNSND (attr
);
7183 SYMBOL_CLASS (sym
) = LOC_CONST
;
7187 complaint (&symfile_complaints
,
7188 _("unsupported const value attribute form: '%s'"),
7189 dwarf_form_name (attr
->form
));
7190 SYMBOL_VALUE (sym
) = 0;
7191 SYMBOL_CLASS (sym
) = LOC_CONST
;
7197 /* Given an attr with a DW_FORM_dataN value in host byte order, sign-
7198 or zero-extend it as appropriate for the symbol's type. */
7200 dwarf2_const_value_data (struct attribute
*attr
,
7204 LONGEST l
= DW_UNSND (attr
);
7206 if (bits
< sizeof (l
) * 8)
7208 if (TYPE_UNSIGNED (SYMBOL_TYPE (sym
)))
7209 l
&= ((LONGEST
) 1 << bits
) - 1;
7211 l
= (l
<< (sizeof (l
) * 8 - bits
)) >> (sizeof (l
) * 8 - bits
);
7214 SYMBOL_VALUE (sym
) = l
;
7215 SYMBOL_CLASS (sym
) = LOC_CONST
;
7219 /* Return the type of the die in question using its DW_AT_type attribute. */
7221 static struct type
*
7222 die_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
7225 struct attribute
*type_attr
;
7226 struct die_info
*type_die
;
7228 type_attr
= dwarf2_attr (die
, DW_AT_type
, cu
);
7231 /* A missing DW_AT_type represents a void type. */
7232 return dwarf2_fundamental_type (cu
->objfile
, FT_VOID
, cu
);
7235 type_die
= follow_die_ref (die
, type_attr
, cu
);
7237 type
= tag_type_to_type (type_die
, cu
);
7240 dump_die (type_die
);
7241 error (_("Dwarf Error: Problem turning type die at offset into gdb type [in module %s]"),
7247 /* Return the containing type of the die in question using its
7248 DW_AT_containing_type attribute. */
7250 static struct type
*
7251 die_containing_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
7253 struct type
*type
= NULL
;
7254 struct attribute
*type_attr
;
7255 struct die_info
*type_die
= NULL
;
7257 type_attr
= dwarf2_attr (die
, DW_AT_containing_type
, cu
);
7260 type_die
= follow_die_ref (die
, type_attr
, cu
);
7261 type
= tag_type_to_type (type_die
, cu
);
7266 dump_die (type_die
);
7267 error (_("Dwarf Error: Problem turning containing type into gdb type [in module %s]"),
7273 static struct type
*
7274 tag_type_to_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
7282 read_type_die (die
, cu
);
7286 error (_("Dwarf Error: Cannot find type of die [in module %s]"),
7294 read_type_die (struct die_info
*die
, struct dwarf2_cu
*cu
)
7296 char *prefix
= determine_prefix (die
, cu
);
7297 const char *old_prefix
= processing_current_prefix
;
7298 struct cleanup
*back_to
= make_cleanup (xfree
, prefix
);
7299 processing_current_prefix
= prefix
;
7303 case DW_TAG_class_type
:
7304 case DW_TAG_structure_type
:
7305 case DW_TAG_union_type
:
7306 read_structure_type (die
, cu
);
7308 case DW_TAG_enumeration_type
:
7309 read_enumeration_type (die
, cu
);
7311 case DW_TAG_subprogram
:
7312 case DW_TAG_subroutine_type
:
7313 read_subroutine_type (die
, cu
);
7315 case DW_TAG_array_type
:
7316 read_array_type (die
, cu
);
7318 case DW_TAG_set_type
:
7319 read_set_type (die
, cu
);
7321 case DW_TAG_pointer_type
:
7322 read_tag_pointer_type (die
, cu
);
7324 case DW_TAG_ptr_to_member_type
:
7325 read_tag_ptr_to_member_type (die
, cu
);
7327 case DW_TAG_reference_type
:
7328 read_tag_reference_type (die
, cu
);
7330 case DW_TAG_const_type
:
7331 read_tag_const_type (die
, cu
);
7333 case DW_TAG_volatile_type
:
7334 read_tag_volatile_type (die
, cu
);
7336 case DW_TAG_string_type
:
7337 read_tag_string_type (die
, cu
);
7339 case DW_TAG_typedef
:
7340 read_typedef (die
, cu
);
7342 case DW_TAG_subrange_type
:
7343 read_subrange_type (die
, cu
);
7345 case DW_TAG_base_type
:
7346 read_base_type (die
, cu
);
7349 complaint (&symfile_complaints
, _("unexpected tag in read_type_die: '%s'"),
7350 dwarf_tag_name (die
->tag
));
7354 processing_current_prefix
= old_prefix
;
7355 do_cleanups (back_to
);
7358 /* Return the name of the namespace/class that DIE is defined within,
7359 or "" if we can't tell. The caller should xfree the result. */
7361 /* NOTE: carlton/2004-01-23: See read_func_scope (and the comment
7362 therein) for an example of how to use this function to deal with
7363 DW_AT_specification. */
7366 determine_prefix (struct die_info
*die
, struct dwarf2_cu
*cu
)
7368 struct die_info
*parent
;
7370 if (cu
->language
!= language_cplus
7371 && cu
->language
!= language_java
)
7374 parent
= die
->parent
;
7378 return xstrdup ("");
7382 switch (parent
->tag
) {
7383 case DW_TAG_namespace
:
7385 /* FIXME: carlton/2004-03-05: Should I follow extension dies
7386 before doing this check? */
7387 if (parent
->type
!= NULL
&& TYPE_TAG_NAME (parent
->type
) != NULL
)
7389 return xstrdup (TYPE_TAG_NAME (parent
->type
));
7394 char *parent_prefix
= determine_prefix (parent
, cu
);
7395 char *retval
= typename_concat (NULL
, parent_prefix
,
7396 namespace_name (parent
, &dummy
,
7399 xfree (parent_prefix
);
7404 case DW_TAG_class_type
:
7405 case DW_TAG_structure_type
:
7407 if (parent
->type
!= NULL
&& TYPE_TAG_NAME (parent
->type
) != NULL
)
7409 return xstrdup (TYPE_TAG_NAME (parent
->type
));
7413 const char *old_prefix
= processing_current_prefix
;
7414 char *new_prefix
= determine_prefix (parent
, cu
);
7417 processing_current_prefix
= new_prefix
;
7418 retval
= determine_class_name (parent
, cu
);
7419 processing_current_prefix
= old_prefix
;
7426 return determine_prefix (parent
, cu
);
7431 /* Return a newly-allocated string formed by concatenating PREFIX and
7432 SUFFIX with appropriate separator. If PREFIX or SUFFIX is NULL or empty, then
7433 simply copy the SUFFIX or PREFIX, respectively. If OBS is non-null,
7434 perform an obconcat, otherwise allocate storage for the result. The CU argument
7435 is used to determine the language and hence, the appropriate separator. */
7437 #define MAX_SEP_LEN 2 /* sizeof ("::") */
7440 typename_concat (struct obstack
*obs
, const char *prefix
, const char *suffix
,
7441 struct dwarf2_cu
*cu
)
7445 if (suffix
== NULL
|| suffix
[0] == '\0' || prefix
== NULL
|| prefix
[0] == '\0')
7447 else if (cu
->language
== language_java
)
7454 char *retval
= xmalloc (strlen (prefix
) + MAX_SEP_LEN
+ strlen (suffix
) + 1);
7459 strcpy (retval
, prefix
);
7460 strcat (retval
, sep
);
7463 strcat (retval
, suffix
);
7469 /* We have an obstack. */
7470 return obconcat (obs
, prefix
, sep
, suffix
);
7474 static struct type
*
7475 dwarf_base_type (int encoding
, int size
, struct dwarf2_cu
*cu
)
7477 struct objfile
*objfile
= cu
->objfile
;
7479 /* FIXME - this should not produce a new (struct type *)
7480 every time. It should cache base types. */
7484 case DW_ATE_address
:
7485 type
= dwarf2_fundamental_type (objfile
, FT_VOID
, cu
);
7487 case DW_ATE_boolean
:
7488 type
= dwarf2_fundamental_type (objfile
, FT_BOOLEAN
, cu
);
7490 case DW_ATE_complex_float
:
7493 type
= dwarf2_fundamental_type (objfile
, FT_DBL_PREC_COMPLEX
, cu
);
7497 type
= dwarf2_fundamental_type (objfile
, FT_COMPLEX
, cu
);
7503 type
= dwarf2_fundamental_type (objfile
, FT_DBL_PREC_FLOAT
, cu
);
7507 type
= dwarf2_fundamental_type (objfile
, FT_FLOAT
, cu
);
7514 type
= dwarf2_fundamental_type (objfile
, FT_SIGNED_CHAR
, cu
);
7517 type
= dwarf2_fundamental_type (objfile
, FT_SIGNED_SHORT
, cu
);
7521 type
= dwarf2_fundamental_type (objfile
, FT_SIGNED_INTEGER
, cu
);
7525 case DW_ATE_signed_char
:
7526 type
= dwarf2_fundamental_type (objfile
, FT_SIGNED_CHAR
, cu
);
7528 case DW_ATE_unsigned
:
7532 type
= dwarf2_fundamental_type (objfile
, FT_UNSIGNED_CHAR
, cu
);
7535 type
= dwarf2_fundamental_type (objfile
, FT_UNSIGNED_SHORT
, cu
);
7539 type
= dwarf2_fundamental_type (objfile
, FT_UNSIGNED_INTEGER
, cu
);
7543 case DW_ATE_unsigned_char
:
7544 type
= dwarf2_fundamental_type (objfile
, FT_UNSIGNED_CHAR
, cu
);
7547 type
= dwarf2_fundamental_type (objfile
, FT_SIGNED_INTEGER
, cu
);
7554 copy_die (struct die_info
*old_die
)
7556 struct die_info
*new_die
;
7559 new_die
= (struct die_info
*) xmalloc (sizeof (struct die_info
));
7560 memset (new_die
, 0, sizeof (struct die_info
));
7562 new_die
->tag
= old_die
->tag
;
7563 new_die
->has_children
= old_die
->has_children
;
7564 new_die
->abbrev
= old_die
->abbrev
;
7565 new_die
->offset
= old_die
->offset
;
7566 new_die
->type
= NULL
;
7568 num_attrs
= old_die
->num_attrs
;
7569 new_die
->num_attrs
= num_attrs
;
7570 new_die
->attrs
= (struct attribute
*)
7571 xmalloc (num_attrs
* sizeof (struct attribute
));
7573 for (i
= 0; i
< old_die
->num_attrs
; ++i
)
7575 new_die
->attrs
[i
].name
= old_die
->attrs
[i
].name
;
7576 new_die
->attrs
[i
].form
= old_die
->attrs
[i
].form
;
7577 new_die
->attrs
[i
].u
.addr
= old_die
->attrs
[i
].u
.addr
;
7580 new_die
->next
= NULL
;
7585 /* Return sibling of die, NULL if no sibling. */
7587 static struct die_info
*
7588 sibling_die (struct die_info
*die
)
7590 return die
->sibling
;
7593 /* Get linkage name of a die, return NULL if not found. */
7596 dwarf2_linkage_name (struct die_info
*die
, struct dwarf2_cu
*cu
)
7598 struct attribute
*attr
;
7600 attr
= dwarf2_attr (die
, DW_AT_MIPS_linkage_name
, cu
);
7601 if (attr
&& DW_STRING (attr
))
7602 return DW_STRING (attr
);
7603 attr
= dwarf2_attr (die
, DW_AT_name
, cu
);
7604 if (attr
&& DW_STRING (attr
))
7605 return DW_STRING (attr
);
7609 /* Get name of a die, return NULL if not found. */
7612 dwarf2_name (struct die_info
*die
, struct dwarf2_cu
*cu
)
7614 struct attribute
*attr
;
7616 attr
= dwarf2_attr (die
, DW_AT_name
, cu
);
7617 if (attr
&& DW_STRING (attr
))
7618 return DW_STRING (attr
);
7622 /* Return the die that this die in an extension of, or NULL if there
7625 static struct die_info
*
7626 dwarf2_extension (struct die_info
*die
, struct dwarf2_cu
*cu
)
7628 struct attribute
*attr
;
7630 attr
= dwarf2_attr (die
, DW_AT_extension
, cu
);
7634 return follow_die_ref (die
, attr
, cu
);
7637 /* Convert a DIE tag into its string name. */
7640 dwarf_tag_name (unsigned tag
)
7644 case DW_TAG_padding
:
7645 return "DW_TAG_padding";
7646 case DW_TAG_array_type
:
7647 return "DW_TAG_array_type";
7648 case DW_TAG_class_type
:
7649 return "DW_TAG_class_type";
7650 case DW_TAG_entry_point
:
7651 return "DW_TAG_entry_point";
7652 case DW_TAG_enumeration_type
:
7653 return "DW_TAG_enumeration_type";
7654 case DW_TAG_formal_parameter
:
7655 return "DW_TAG_formal_parameter";
7656 case DW_TAG_imported_declaration
:
7657 return "DW_TAG_imported_declaration";
7659 return "DW_TAG_label";
7660 case DW_TAG_lexical_block
:
7661 return "DW_TAG_lexical_block";
7663 return "DW_TAG_member";
7664 case DW_TAG_pointer_type
:
7665 return "DW_TAG_pointer_type";
7666 case DW_TAG_reference_type
:
7667 return "DW_TAG_reference_type";
7668 case DW_TAG_compile_unit
:
7669 return "DW_TAG_compile_unit";
7670 case DW_TAG_string_type
:
7671 return "DW_TAG_string_type";
7672 case DW_TAG_structure_type
:
7673 return "DW_TAG_structure_type";
7674 case DW_TAG_subroutine_type
:
7675 return "DW_TAG_subroutine_type";
7676 case DW_TAG_typedef
:
7677 return "DW_TAG_typedef";
7678 case DW_TAG_union_type
:
7679 return "DW_TAG_union_type";
7680 case DW_TAG_unspecified_parameters
:
7681 return "DW_TAG_unspecified_parameters";
7682 case DW_TAG_variant
:
7683 return "DW_TAG_variant";
7684 case DW_TAG_common_block
:
7685 return "DW_TAG_common_block";
7686 case DW_TAG_common_inclusion
:
7687 return "DW_TAG_common_inclusion";
7688 case DW_TAG_inheritance
:
7689 return "DW_TAG_inheritance";
7690 case DW_TAG_inlined_subroutine
:
7691 return "DW_TAG_inlined_subroutine";
7693 return "DW_TAG_module";
7694 case DW_TAG_ptr_to_member_type
:
7695 return "DW_TAG_ptr_to_member_type";
7696 case DW_TAG_set_type
:
7697 return "DW_TAG_set_type";
7698 case DW_TAG_subrange_type
:
7699 return "DW_TAG_subrange_type";
7700 case DW_TAG_with_stmt
:
7701 return "DW_TAG_with_stmt";
7702 case DW_TAG_access_declaration
:
7703 return "DW_TAG_access_declaration";
7704 case DW_TAG_base_type
:
7705 return "DW_TAG_base_type";
7706 case DW_TAG_catch_block
:
7707 return "DW_TAG_catch_block";
7708 case DW_TAG_const_type
:
7709 return "DW_TAG_const_type";
7710 case DW_TAG_constant
:
7711 return "DW_TAG_constant";
7712 case DW_TAG_enumerator
:
7713 return "DW_TAG_enumerator";
7714 case DW_TAG_file_type
:
7715 return "DW_TAG_file_type";
7717 return "DW_TAG_friend";
7718 case DW_TAG_namelist
:
7719 return "DW_TAG_namelist";
7720 case DW_TAG_namelist_item
:
7721 return "DW_TAG_namelist_item";
7722 case DW_TAG_packed_type
:
7723 return "DW_TAG_packed_type";
7724 case DW_TAG_subprogram
:
7725 return "DW_TAG_subprogram";
7726 case DW_TAG_template_type_param
:
7727 return "DW_TAG_template_type_param";
7728 case DW_TAG_template_value_param
:
7729 return "DW_TAG_template_value_param";
7730 case DW_TAG_thrown_type
:
7731 return "DW_TAG_thrown_type";
7732 case DW_TAG_try_block
:
7733 return "DW_TAG_try_block";
7734 case DW_TAG_variant_part
:
7735 return "DW_TAG_variant_part";
7736 case DW_TAG_variable
:
7737 return "DW_TAG_variable";
7738 case DW_TAG_volatile_type
:
7739 return "DW_TAG_volatile_type";
7740 case DW_TAG_dwarf_procedure
:
7741 return "DW_TAG_dwarf_procedure";
7742 case DW_TAG_restrict_type
:
7743 return "DW_TAG_restrict_type";
7744 case DW_TAG_interface_type
:
7745 return "DW_TAG_interface_type";
7746 case DW_TAG_namespace
:
7747 return "DW_TAG_namespace";
7748 case DW_TAG_imported_module
:
7749 return "DW_TAG_imported_module";
7750 case DW_TAG_unspecified_type
:
7751 return "DW_TAG_unspecified_type";
7752 case DW_TAG_partial_unit
:
7753 return "DW_TAG_partial_unit";
7754 case DW_TAG_imported_unit
:
7755 return "DW_TAG_imported_unit";
7756 case DW_TAG_MIPS_loop
:
7757 return "DW_TAG_MIPS_loop";
7758 case DW_TAG_format_label
:
7759 return "DW_TAG_format_label";
7760 case DW_TAG_function_template
:
7761 return "DW_TAG_function_template";
7762 case DW_TAG_class_template
:
7763 return "DW_TAG_class_template";
7765 return "DW_TAG_<unknown>";
7769 /* Convert a DWARF attribute code into its string name. */
7772 dwarf_attr_name (unsigned attr
)
7777 return "DW_AT_sibling";
7778 case DW_AT_location
:
7779 return "DW_AT_location";
7781 return "DW_AT_name";
7782 case DW_AT_ordering
:
7783 return "DW_AT_ordering";
7784 case DW_AT_subscr_data
:
7785 return "DW_AT_subscr_data";
7786 case DW_AT_byte_size
:
7787 return "DW_AT_byte_size";
7788 case DW_AT_bit_offset
:
7789 return "DW_AT_bit_offset";
7790 case DW_AT_bit_size
:
7791 return "DW_AT_bit_size";
7792 case DW_AT_element_list
:
7793 return "DW_AT_element_list";
7794 case DW_AT_stmt_list
:
7795 return "DW_AT_stmt_list";
7797 return "DW_AT_low_pc";
7799 return "DW_AT_high_pc";
7800 case DW_AT_language
:
7801 return "DW_AT_language";
7803 return "DW_AT_member";
7805 return "DW_AT_discr";
7806 case DW_AT_discr_value
:
7807 return "DW_AT_discr_value";
7808 case DW_AT_visibility
:
7809 return "DW_AT_visibility";
7811 return "DW_AT_import";
7812 case DW_AT_string_length
:
7813 return "DW_AT_string_length";
7814 case DW_AT_common_reference
:
7815 return "DW_AT_common_reference";
7816 case DW_AT_comp_dir
:
7817 return "DW_AT_comp_dir";
7818 case DW_AT_const_value
:
7819 return "DW_AT_const_value";
7820 case DW_AT_containing_type
:
7821 return "DW_AT_containing_type";
7822 case DW_AT_default_value
:
7823 return "DW_AT_default_value";
7825 return "DW_AT_inline";
7826 case DW_AT_is_optional
:
7827 return "DW_AT_is_optional";
7828 case DW_AT_lower_bound
:
7829 return "DW_AT_lower_bound";
7830 case DW_AT_producer
:
7831 return "DW_AT_producer";
7832 case DW_AT_prototyped
:
7833 return "DW_AT_prototyped";
7834 case DW_AT_return_addr
:
7835 return "DW_AT_return_addr";
7836 case DW_AT_start_scope
:
7837 return "DW_AT_start_scope";
7838 case DW_AT_stride_size
:
7839 return "DW_AT_stride_size";
7840 case DW_AT_upper_bound
:
7841 return "DW_AT_upper_bound";
7842 case DW_AT_abstract_origin
:
7843 return "DW_AT_abstract_origin";
7844 case DW_AT_accessibility
:
7845 return "DW_AT_accessibility";
7846 case DW_AT_address_class
:
7847 return "DW_AT_address_class";
7848 case DW_AT_artificial
:
7849 return "DW_AT_artificial";
7850 case DW_AT_base_types
:
7851 return "DW_AT_base_types";
7852 case DW_AT_calling_convention
:
7853 return "DW_AT_calling_convention";
7855 return "DW_AT_count";
7856 case DW_AT_data_member_location
:
7857 return "DW_AT_data_member_location";
7858 case DW_AT_decl_column
:
7859 return "DW_AT_decl_column";
7860 case DW_AT_decl_file
:
7861 return "DW_AT_decl_file";
7862 case DW_AT_decl_line
:
7863 return "DW_AT_decl_line";
7864 case DW_AT_declaration
:
7865 return "DW_AT_declaration";
7866 case DW_AT_discr_list
:
7867 return "DW_AT_discr_list";
7868 case DW_AT_encoding
:
7869 return "DW_AT_encoding";
7870 case DW_AT_external
:
7871 return "DW_AT_external";
7872 case DW_AT_frame_base
:
7873 return "DW_AT_frame_base";
7875 return "DW_AT_friend";
7876 case DW_AT_identifier_case
:
7877 return "DW_AT_identifier_case";
7878 case DW_AT_macro_info
:
7879 return "DW_AT_macro_info";
7880 case DW_AT_namelist_items
:
7881 return "DW_AT_namelist_items";
7882 case DW_AT_priority
:
7883 return "DW_AT_priority";
7885 return "DW_AT_segment";
7886 case DW_AT_specification
:
7887 return "DW_AT_specification";
7888 case DW_AT_static_link
:
7889 return "DW_AT_static_link";
7891 return "DW_AT_type";
7892 case DW_AT_use_location
:
7893 return "DW_AT_use_location";
7894 case DW_AT_variable_parameter
:
7895 return "DW_AT_variable_parameter";
7896 case DW_AT_virtuality
:
7897 return "DW_AT_virtuality";
7898 case DW_AT_vtable_elem_location
:
7899 return "DW_AT_vtable_elem_location";
7900 case DW_AT_allocated
:
7901 return "DW_AT_allocated";
7902 case DW_AT_associated
:
7903 return "DW_AT_associated";
7904 case DW_AT_data_location
:
7905 return "DW_AT_data_location";
7907 return "DW_AT_stride";
7908 case DW_AT_entry_pc
:
7909 return "DW_AT_entry_pc";
7910 case DW_AT_use_UTF8
:
7911 return "DW_AT_use_UTF8";
7912 case DW_AT_extension
:
7913 return "DW_AT_extension";
7915 return "DW_AT_ranges";
7916 case DW_AT_trampoline
:
7917 return "DW_AT_trampoline";
7918 case DW_AT_call_column
:
7919 return "DW_AT_call_column";
7920 case DW_AT_call_file
:
7921 return "DW_AT_call_file";
7922 case DW_AT_call_line
:
7923 return "DW_AT_call_line";
7925 case DW_AT_MIPS_fde
:
7926 return "DW_AT_MIPS_fde";
7927 case DW_AT_MIPS_loop_begin
:
7928 return "DW_AT_MIPS_loop_begin";
7929 case DW_AT_MIPS_tail_loop_begin
:
7930 return "DW_AT_MIPS_tail_loop_begin";
7931 case DW_AT_MIPS_epilog_begin
:
7932 return "DW_AT_MIPS_epilog_begin";
7933 case DW_AT_MIPS_loop_unroll_factor
:
7934 return "DW_AT_MIPS_loop_unroll_factor";
7935 case DW_AT_MIPS_software_pipeline_depth
:
7936 return "DW_AT_MIPS_software_pipeline_depth";
7938 case DW_AT_MIPS_linkage_name
:
7939 return "DW_AT_MIPS_linkage_name";
7941 case DW_AT_sf_names
:
7942 return "DW_AT_sf_names";
7943 case DW_AT_src_info
:
7944 return "DW_AT_src_info";
7945 case DW_AT_mac_info
:
7946 return "DW_AT_mac_info";
7947 case DW_AT_src_coords
:
7948 return "DW_AT_src_coords";
7949 case DW_AT_body_begin
:
7950 return "DW_AT_body_begin";
7951 case DW_AT_body_end
:
7952 return "DW_AT_body_end";
7953 case DW_AT_GNU_vector
:
7954 return "DW_AT_GNU_vector";
7956 return "DW_AT_<unknown>";
7960 /* Convert a DWARF value form code into its string name. */
7963 dwarf_form_name (unsigned form
)
7968 return "DW_FORM_addr";
7969 case DW_FORM_block2
:
7970 return "DW_FORM_block2";
7971 case DW_FORM_block4
:
7972 return "DW_FORM_block4";
7974 return "DW_FORM_data2";
7976 return "DW_FORM_data4";
7978 return "DW_FORM_data8";
7979 case DW_FORM_string
:
7980 return "DW_FORM_string";
7982 return "DW_FORM_block";
7983 case DW_FORM_block1
:
7984 return "DW_FORM_block1";
7986 return "DW_FORM_data1";
7988 return "DW_FORM_flag";
7990 return "DW_FORM_sdata";
7992 return "DW_FORM_strp";
7994 return "DW_FORM_udata";
7995 case DW_FORM_ref_addr
:
7996 return "DW_FORM_ref_addr";
7998 return "DW_FORM_ref1";
8000 return "DW_FORM_ref2";
8002 return "DW_FORM_ref4";
8004 return "DW_FORM_ref8";
8005 case DW_FORM_ref_udata
:
8006 return "DW_FORM_ref_udata";
8007 case DW_FORM_indirect
:
8008 return "DW_FORM_indirect";
8010 return "DW_FORM_<unknown>";
8014 /* Convert a DWARF stack opcode into its string name. */
8017 dwarf_stack_op_name (unsigned op
)
8022 return "DW_OP_addr";
8024 return "DW_OP_deref";
8026 return "DW_OP_const1u";
8028 return "DW_OP_const1s";
8030 return "DW_OP_const2u";
8032 return "DW_OP_const2s";
8034 return "DW_OP_const4u";
8036 return "DW_OP_const4s";
8038 return "DW_OP_const8u";
8040 return "DW_OP_const8s";
8042 return "DW_OP_constu";
8044 return "DW_OP_consts";
8048 return "DW_OP_drop";
8050 return "DW_OP_over";
8052 return "DW_OP_pick";
8054 return "DW_OP_swap";
8058 return "DW_OP_xderef";
8066 return "DW_OP_minus";
8078 return "DW_OP_plus";
8079 case DW_OP_plus_uconst
:
8080 return "DW_OP_plus_uconst";
8086 return "DW_OP_shra";
8104 return "DW_OP_skip";
8106 return "DW_OP_lit0";
8108 return "DW_OP_lit1";
8110 return "DW_OP_lit2";
8112 return "DW_OP_lit3";
8114 return "DW_OP_lit4";
8116 return "DW_OP_lit5";
8118 return "DW_OP_lit6";
8120 return "DW_OP_lit7";
8122 return "DW_OP_lit8";
8124 return "DW_OP_lit9";
8126 return "DW_OP_lit10";
8128 return "DW_OP_lit11";
8130 return "DW_OP_lit12";
8132 return "DW_OP_lit13";
8134 return "DW_OP_lit14";
8136 return "DW_OP_lit15";
8138 return "DW_OP_lit16";
8140 return "DW_OP_lit17";
8142 return "DW_OP_lit18";
8144 return "DW_OP_lit19";
8146 return "DW_OP_lit20";
8148 return "DW_OP_lit21";
8150 return "DW_OP_lit22";
8152 return "DW_OP_lit23";
8154 return "DW_OP_lit24";
8156 return "DW_OP_lit25";
8158 return "DW_OP_lit26";
8160 return "DW_OP_lit27";
8162 return "DW_OP_lit28";
8164 return "DW_OP_lit29";
8166 return "DW_OP_lit30";
8168 return "DW_OP_lit31";
8170 return "DW_OP_reg0";
8172 return "DW_OP_reg1";
8174 return "DW_OP_reg2";
8176 return "DW_OP_reg3";
8178 return "DW_OP_reg4";
8180 return "DW_OP_reg5";
8182 return "DW_OP_reg6";
8184 return "DW_OP_reg7";
8186 return "DW_OP_reg8";
8188 return "DW_OP_reg9";
8190 return "DW_OP_reg10";
8192 return "DW_OP_reg11";
8194 return "DW_OP_reg12";
8196 return "DW_OP_reg13";
8198 return "DW_OP_reg14";
8200 return "DW_OP_reg15";
8202 return "DW_OP_reg16";
8204 return "DW_OP_reg17";
8206 return "DW_OP_reg18";
8208 return "DW_OP_reg19";
8210 return "DW_OP_reg20";
8212 return "DW_OP_reg21";
8214 return "DW_OP_reg22";
8216 return "DW_OP_reg23";
8218 return "DW_OP_reg24";
8220 return "DW_OP_reg25";
8222 return "DW_OP_reg26";
8224 return "DW_OP_reg27";
8226 return "DW_OP_reg28";
8228 return "DW_OP_reg29";
8230 return "DW_OP_reg30";
8232 return "DW_OP_reg31";
8234 return "DW_OP_breg0";
8236 return "DW_OP_breg1";
8238 return "DW_OP_breg2";
8240 return "DW_OP_breg3";
8242 return "DW_OP_breg4";
8244 return "DW_OP_breg5";
8246 return "DW_OP_breg6";
8248 return "DW_OP_breg7";
8250 return "DW_OP_breg8";
8252 return "DW_OP_breg9";
8254 return "DW_OP_breg10";
8256 return "DW_OP_breg11";
8258 return "DW_OP_breg12";
8260 return "DW_OP_breg13";
8262 return "DW_OP_breg14";
8264 return "DW_OP_breg15";
8266 return "DW_OP_breg16";
8268 return "DW_OP_breg17";
8270 return "DW_OP_breg18";
8272 return "DW_OP_breg19";
8274 return "DW_OP_breg20";
8276 return "DW_OP_breg21";
8278 return "DW_OP_breg22";
8280 return "DW_OP_breg23";
8282 return "DW_OP_breg24";
8284 return "DW_OP_breg25";
8286 return "DW_OP_breg26";
8288 return "DW_OP_breg27";
8290 return "DW_OP_breg28";
8292 return "DW_OP_breg29";
8294 return "DW_OP_breg30";
8296 return "DW_OP_breg31";
8298 return "DW_OP_regx";
8300 return "DW_OP_fbreg";
8302 return "DW_OP_bregx";
8304 return "DW_OP_piece";
8305 case DW_OP_deref_size
:
8306 return "DW_OP_deref_size";
8307 case DW_OP_xderef_size
:
8308 return "DW_OP_xderef_size";
8311 /* DWARF 3 extensions. */
8312 case DW_OP_push_object_address
:
8313 return "DW_OP_push_object_address";
8315 return "DW_OP_call2";
8317 return "DW_OP_call4";
8318 case DW_OP_call_ref
:
8319 return "DW_OP_call_ref";
8320 /* GNU extensions. */
8321 case DW_OP_GNU_push_tls_address
:
8322 return "DW_OP_GNU_push_tls_address";
8324 return "OP_<unknown>";
8329 dwarf_bool_name (unsigned mybool
)
8337 /* Convert a DWARF type code into its string name. */
8340 dwarf_type_encoding_name (unsigned enc
)
8344 case DW_ATE_address
:
8345 return "DW_ATE_address";
8346 case DW_ATE_boolean
:
8347 return "DW_ATE_boolean";
8348 case DW_ATE_complex_float
:
8349 return "DW_ATE_complex_float";
8351 return "DW_ATE_float";
8353 return "DW_ATE_signed";
8354 case DW_ATE_signed_char
:
8355 return "DW_ATE_signed_char";
8356 case DW_ATE_unsigned
:
8357 return "DW_ATE_unsigned";
8358 case DW_ATE_unsigned_char
:
8359 return "DW_ATE_unsigned_char";
8360 case DW_ATE_imaginary_float
:
8361 return "DW_ATE_imaginary_float";
8363 return "DW_ATE_<unknown>";
8367 /* Convert a DWARF call frame info operation to its string name. */
8371 dwarf_cfi_name (unsigned cfi_opc
)
8375 case DW_CFA_advance_loc
:
8376 return "DW_CFA_advance_loc";
8378 return "DW_CFA_offset";
8379 case DW_CFA_restore
:
8380 return "DW_CFA_restore";
8382 return "DW_CFA_nop";
8383 case DW_CFA_set_loc
:
8384 return "DW_CFA_set_loc";
8385 case DW_CFA_advance_loc1
:
8386 return "DW_CFA_advance_loc1";
8387 case DW_CFA_advance_loc2
:
8388 return "DW_CFA_advance_loc2";
8389 case DW_CFA_advance_loc4
:
8390 return "DW_CFA_advance_loc4";
8391 case DW_CFA_offset_extended
:
8392 return "DW_CFA_offset_extended";
8393 case DW_CFA_restore_extended
:
8394 return "DW_CFA_restore_extended";
8395 case DW_CFA_undefined
:
8396 return "DW_CFA_undefined";
8397 case DW_CFA_same_value
:
8398 return "DW_CFA_same_value";
8399 case DW_CFA_register
:
8400 return "DW_CFA_register";
8401 case DW_CFA_remember_state
:
8402 return "DW_CFA_remember_state";
8403 case DW_CFA_restore_state
:
8404 return "DW_CFA_restore_state";
8405 case DW_CFA_def_cfa
:
8406 return "DW_CFA_def_cfa";
8407 case DW_CFA_def_cfa_register
:
8408 return "DW_CFA_def_cfa_register";
8409 case DW_CFA_def_cfa_offset
:
8410 return "DW_CFA_def_cfa_offset";
8413 case DW_CFA_def_cfa_expression
:
8414 return "DW_CFA_def_cfa_expression";
8415 case DW_CFA_expression
:
8416 return "DW_CFA_expression";
8417 case DW_CFA_offset_extended_sf
:
8418 return "DW_CFA_offset_extended_sf";
8419 case DW_CFA_def_cfa_sf
:
8420 return "DW_CFA_def_cfa_sf";
8421 case DW_CFA_def_cfa_offset_sf
:
8422 return "DW_CFA_def_cfa_offset_sf";
8424 /* SGI/MIPS specific */
8425 case DW_CFA_MIPS_advance_loc8
:
8426 return "DW_CFA_MIPS_advance_loc8";
8428 /* GNU extensions */
8429 case DW_CFA_GNU_window_save
:
8430 return "DW_CFA_GNU_window_save";
8431 case DW_CFA_GNU_args_size
:
8432 return "DW_CFA_GNU_args_size";
8433 case DW_CFA_GNU_negative_offset_extended
:
8434 return "DW_CFA_GNU_negative_offset_extended";
8437 return "DW_CFA_<unknown>";
8443 dump_die (struct die_info
*die
)
8447 fprintf_unfiltered (gdb_stderr
, "Die: %s (abbrev = %d, offset = %d)\n",
8448 dwarf_tag_name (die
->tag
), die
->abbrev
, die
->offset
);
8449 fprintf_unfiltered (gdb_stderr
, "\thas children: %s\n",
8450 dwarf_bool_name (die
->child
!= NULL
));
8452 fprintf_unfiltered (gdb_stderr
, "\tattributes:\n");
8453 for (i
= 0; i
< die
->num_attrs
; ++i
)
8455 fprintf_unfiltered (gdb_stderr
, "\t\t%s (%s) ",
8456 dwarf_attr_name (die
->attrs
[i
].name
),
8457 dwarf_form_name (die
->attrs
[i
].form
));
8458 switch (die
->attrs
[i
].form
)
8460 case DW_FORM_ref_addr
:
8462 fprintf_unfiltered (gdb_stderr
, "address: ");
8463 deprecated_print_address_numeric (DW_ADDR (&die
->attrs
[i
]), 1, gdb_stderr
);
8465 case DW_FORM_block2
:
8466 case DW_FORM_block4
:
8468 case DW_FORM_block1
:
8469 fprintf_unfiltered (gdb_stderr
, "block: size %d", DW_BLOCK (&die
->attrs
[i
])->size
);
8474 fprintf_unfiltered (gdb_stderr
, "constant ref: %ld (adjusted)",
8475 (long) (DW_ADDR (&die
->attrs
[i
])));
8483 fprintf_unfiltered (gdb_stderr
, "constant: %ld", DW_UNSND (&die
->attrs
[i
]));
8485 case DW_FORM_string
:
8487 fprintf_unfiltered (gdb_stderr
, "string: \"%s\"",
8488 DW_STRING (&die
->attrs
[i
])
8489 ? DW_STRING (&die
->attrs
[i
]) : "");
8492 if (DW_UNSND (&die
->attrs
[i
]))
8493 fprintf_unfiltered (gdb_stderr
, "flag: TRUE");
8495 fprintf_unfiltered (gdb_stderr
, "flag: FALSE");
8497 case DW_FORM_indirect
:
8498 /* the reader will have reduced the indirect form to
8499 the "base form" so this form should not occur */
8500 fprintf_unfiltered (gdb_stderr
, "unexpected attribute form: DW_FORM_indirect");
8503 fprintf_unfiltered (gdb_stderr
, "unsupported attribute form: %d.",
8504 die
->attrs
[i
].form
);
8506 fprintf_unfiltered (gdb_stderr
, "\n");
8511 dump_die_list (struct die_info
*die
)
8516 if (die
->child
!= NULL
)
8517 dump_die_list (die
->child
);
8518 if (die
->sibling
!= NULL
)
8519 dump_die_list (die
->sibling
);
8524 store_in_ref_table (unsigned int offset
, struct die_info
*die
,
8525 struct dwarf2_cu
*cu
)
8528 struct die_info
*old
;
8530 h
= (offset
% REF_HASH_SIZE
);
8531 old
= cu
->die_ref_table
[h
];
8532 die
->next_ref
= old
;
8533 cu
->die_ref_table
[h
] = die
;
8537 dwarf2_get_ref_die_offset (struct attribute
*attr
, struct dwarf2_cu
*cu
)
8539 unsigned int result
= 0;
8543 case DW_FORM_ref_addr
:
8548 case DW_FORM_ref_udata
:
8549 result
= DW_ADDR (attr
);
8552 complaint (&symfile_complaints
,
8553 _("unsupported die ref attribute form: '%s'"),
8554 dwarf_form_name (attr
->form
));
8559 /* Return the constant value held by the given attribute. Return -1
8560 if the value held by the attribute is not constant. */
8563 dwarf2_get_attr_constant_value (struct attribute
*attr
, int default_value
)
8565 if (attr
->form
== DW_FORM_sdata
)
8566 return DW_SND (attr
);
8567 else if (attr
->form
== DW_FORM_udata
8568 || attr
->form
== DW_FORM_data1
8569 || attr
->form
== DW_FORM_data2
8570 || attr
->form
== DW_FORM_data4
8571 || attr
->form
== DW_FORM_data8
)
8572 return DW_UNSND (attr
);
8575 complaint (&symfile_complaints
, _("Attribute value is not a constant (%s)"),
8576 dwarf_form_name (attr
->form
));
8577 return default_value
;
8581 static struct die_info
*
8582 follow_die_ref (struct die_info
*src_die
, struct attribute
*attr
,
8583 struct dwarf2_cu
*cu
)
8585 struct die_info
*die
;
8586 unsigned int offset
;
8588 struct die_info temp_die
;
8589 struct dwarf2_cu
*target_cu
;
8591 offset
= dwarf2_get_ref_die_offset (attr
, cu
);
8593 if (DW_ADDR (attr
) < cu
->header
.offset
8594 || DW_ADDR (attr
) >= cu
->header
.offset
+ cu
->header
.length
)
8596 struct dwarf2_per_cu_data
*per_cu
;
8597 per_cu
= dwarf2_find_containing_comp_unit (DW_ADDR (attr
),
8599 target_cu
= per_cu
->cu
;
8604 h
= (offset
% REF_HASH_SIZE
);
8605 die
= target_cu
->die_ref_table
[h
];
8608 if (die
->offset
== offset
)
8610 die
= die
->next_ref
;
8613 error (_("Dwarf Error: Cannot find DIE at 0x%lx referenced from DIE "
8614 "at 0x%lx [in module %s]"),
8615 (long) src_die
->offset
, (long) offset
, cu
->objfile
->name
);
8620 static struct type
*
8621 dwarf2_fundamental_type (struct objfile
*objfile
, int typeid,
8622 struct dwarf2_cu
*cu
)
8624 if (typeid < 0 || typeid >= FT_NUM_MEMBERS
)
8626 error (_("Dwarf Error: internal error - invalid fundamental type id %d [in module %s]"),
8627 typeid, objfile
->name
);
8630 /* Look for this particular type in the fundamental type vector. If
8631 one is not found, create and install one appropriate for the
8632 current language and the current target machine. */
8634 if (cu
->ftypes
[typeid] == NULL
)
8636 cu
->ftypes
[typeid] = cu
->language_defn
->la_fund_type (objfile
, typeid);
8639 return (cu
->ftypes
[typeid]);
8642 /* Decode simple location descriptions.
8643 Given a pointer to a dwarf block that defines a location, compute
8644 the location and return the value.
8646 NOTE drow/2003-11-18: This function is called in two situations
8647 now: for the address of static or global variables (partial symbols
8648 only) and for offsets into structures which are expected to be
8649 (more or less) constant. The partial symbol case should go away,
8650 and only the constant case should remain. That will let this
8651 function complain more accurately. A few special modes are allowed
8652 without complaint for global variables (for instance, global
8653 register values and thread-local values).
8655 A location description containing no operations indicates that the
8656 object is optimized out. The return value is 0 for that case.
8657 FIXME drow/2003-11-16: No callers check for this case any more; soon all
8658 callers will only want a very basic result and this can become a
8661 Note that stack[0] is unused except as a default error return.
8662 Note that stack overflow is not yet handled. */
8665 decode_locdesc (struct dwarf_block
*blk
, struct dwarf2_cu
*cu
)
8667 struct objfile
*objfile
= cu
->objfile
;
8668 struct comp_unit_head
*cu_header
= &cu
->header
;
8670 int size
= blk
->size
;
8671 gdb_byte
*data
= blk
->data
;
8672 CORE_ADDR stack
[64];
8674 unsigned int bytes_read
, unsnd
;
8718 stack
[++stacki
] = op
- DW_OP_lit0
;
8753 stack
[++stacki
] = op
- DW_OP_reg0
;
8755 dwarf2_complex_location_expr_complaint ();
8759 unsnd
= read_unsigned_leb128 (NULL
, (data
+ i
), &bytes_read
);
8761 stack
[++stacki
] = unsnd
;
8763 dwarf2_complex_location_expr_complaint ();
8767 stack
[++stacki
] = read_address (objfile
->obfd
, &data
[i
],
8773 stack
[++stacki
] = read_1_byte (objfile
->obfd
, &data
[i
]);
8778 stack
[++stacki
] = read_1_signed_byte (objfile
->obfd
, &data
[i
]);
8783 stack
[++stacki
] = read_2_bytes (objfile
->obfd
, &data
[i
]);
8788 stack
[++stacki
] = read_2_signed_bytes (objfile
->obfd
, &data
[i
]);
8793 stack
[++stacki
] = read_4_bytes (objfile
->obfd
, &data
[i
]);
8798 stack
[++stacki
] = read_4_signed_bytes (objfile
->obfd
, &data
[i
]);
8803 stack
[++stacki
] = read_unsigned_leb128 (NULL
, (data
+ i
),
8809 stack
[++stacki
] = read_signed_leb128 (NULL
, (data
+ i
), &bytes_read
);
8814 stack
[stacki
+ 1] = stack
[stacki
];
8819 stack
[stacki
- 1] += stack
[stacki
];
8823 case DW_OP_plus_uconst
:
8824 stack
[stacki
] += read_unsigned_leb128 (NULL
, (data
+ i
), &bytes_read
);
8829 stack
[stacki
- 1] -= stack
[stacki
];
8834 /* If we're not the last op, then we definitely can't encode
8835 this using GDB's address_class enum. This is valid for partial
8836 global symbols, although the variable's address will be bogus
8839 dwarf2_complex_location_expr_complaint ();
8842 case DW_OP_GNU_push_tls_address
:
8843 /* The top of the stack has the offset from the beginning
8844 of the thread control block at which the variable is located. */
8845 /* Nothing should follow this operator, so the top of stack would
8847 /* This is valid for partial global symbols, but the variable's
8848 address will be bogus in the psymtab. */
8850 dwarf2_complex_location_expr_complaint ();
8854 complaint (&symfile_complaints
, _("unsupported stack op: '%s'"),
8855 dwarf_stack_op_name (op
));
8856 return (stack
[stacki
]);
8859 return (stack
[stacki
]);
8862 /* memory allocation interface */
8864 static struct dwarf_block
*
8865 dwarf_alloc_block (struct dwarf2_cu
*cu
)
8867 struct dwarf_block
*blk
;
8869 blk
= (struct dwarf_block
*)
8870 obstack_alloc (&cu
->comp_unit_obstack
, sizeof (struct dwarf_block
));
8874 static struct abbrev_info
*
8875 dwarf_alloc_abbrev (struct dwarf2_cu
*cu
)
8877 struct abbrev_info
*abbrev
;
8879 abbrev
= (struct abbrev_info
*)
8880 obstack_alloc (&cu
->abbrev_obstack
, sizeof (struct abbrev_info
));
8881 memset (abbrev
, 0, sizeof (struct abbrev_info
));
8885 static struct die_info
*
8886 dwarf_alloc_die (void)
8888 struct die_info
*die
;
8890 die
= (struct die_info
*) xmalloc (sizeof (struct die_info
));
8891 memset (die
, 0, sizeof (struct die_info
));
8896 /* Macro support. */
8899 /* Return the full name of file number I in *LH's file name table.
8900 Use COMP_DIR as the name of the current directory of the
8901 compilation. The result is allocated using xmalloc; the caller is
8902 responsible for freeing it. */
8904 file_full_name (int file
, struct line_header
*lh
, const char *comp_dir
)
8906 /* Is the file number a valid index into the line header's file name
8907 table? Remember that file numbers start with one, not zero. */
8908 if (1 <= file
&& file
<= lh
->num_file_names
)
8910 struct file_entry
*fe
= &lh
->file_names
[file
- 1];
8912 if (IS_ABSOLUTE_PATH (fe
->name
))
8913 return xstrdup (fe
->name
);
8921 dir
= lh
->include_dirs
[fe
->dir_index
- 1];
8927 dir_len
= strlen (dir
);
8928 full_name
= xmalloc (dir_len
+ 1 + strlen (fe
->name
) + 1);
8929 strcpy (full_name
, dir
);
8930 full_name
[dir_len
] = '/';
8931 strcpy (full_name
+ dir_len
+ 1, fe
->name
);
8935 return xstrdup (fe
->name
);
8940 /* The compiler produced a bogus file number. We can at least
8941 record the macro definitions made in the file, even if we
8942 won't be able to find the file by name. */
8944 sprintf (fake_name
, "<bad macro file number %d>", file
);
8946 complaint (&symfile_complaints
,
8947 _("bad file number in macro information (%d)"),
8950 return xstrdup (fake_name
);
8955 static struct macro_source_file
*
8956 macro_start_file (int file
, int line
,
8957 struct macro_source_file
*current_file
,
8958 const char *comp_dir
,
8959 struct line_header
*lh
, struct objfile
*objfile
)
8961 /* The full name of this source file. */
8962 char *full_name
= file_full_name (file
, lh
, comp_dir
);
8964 /* We don't create a macro table for this compilation unit
8965 at all until we actually get a filename. */
8966 if (! pending_macros
)
8967 pending_macros
= new_macro_table (&objfile
->objfile_obstack
,
8968 objfile
->macro_cache
);
8971 /* If we have no current file, then this must be the start_file
8972 directive for the compilation unit's main source file. */
8973 current_file
= macro_set_main (pending_macros
, full_name
);
8975 current_file
= macro_include (current_file
, line
, full_name
);
8979 return current_file
;
8983 /* Copy the LEN characters at BUF to a xmalloc'ed block of memory,
8984 followed by a null byte. */
8986 copy_string (const char *buf
, int len
)
8988 char *s
= xmalloc (len
+ 1);
8989 memcpy (s
, buf
, len
);
8997 consume_improper_spaces (const char *p
, const char *body
)
9001 complaint (&symfile_complaints
,
9002 _("macro definition contains spaces in formal argument list:\n`%s'"),
9014 parse_macro_definition (struct macro_source_file
*file
, int line
,
9019 /* The body string takes one of two forms. For object-like macro
9020 definitions, it should be:
9022 <macro name> " " <definition>
9024 For function-like macro definitions, it should be:
9026 <macro name> "() " <definition>
9028 <macro name> "(" <arg name> ( "," <arg name> ) * ") " <definition>
9030 Spaces may appear only where explicitly indicated, and in the
9033 The Dwarf 2 spec says that an object-like macro's name is always
9034 followed by a space, but versions of GCC around March 2002 omit
9035 the space when the macro's definition is the empty string.
9037 The Dwarf 2 spec says that there should be no spaces between the
9038 formal arguments in a function-like macro's formal argument list,
9039 but versions of GCC around March 2002 include spaces after the
9043 /* Find the extent of the macro name. The macro name is terminated
9044 by either a space or null character (for an object-like macro) or
9045 an opening paren (for a function-like macro). */
9046 for (p
= body
; *p
; p
++)
9047 if (*p
== ' ' || *p
== '(')
9050 if (*p
== ' ' || *p
== '\0')
9052 /* It's an object-like macro. */
9053 int name_len
= p
- body
;
9054 char *name
= copy_string (body
, name_len
);
9055 const char *replacement
;
9058 replacement
= body
+ name_len
+ 1;
9061 dwarf2_macro_malformed_definition_complaint (body
);
9062 replacement
= body
+ name_len
;
9065 macro_define_object (file
, line
, name
, replacement
);
9071 /* It's a function-like macro. */
9072 char *name
= copy_string (body
, p
- body
);
9075 char **argv
= xmalloc (argv_size
* sizeof (*argv
));
9079 p
= consume_improper_spaces (p
, body
);
9081 /* Parse the formal argument list. */
9082 while (*p
&& *p
!= ')')
9084 /* Find the extent of the current argument name. */
9085 const char *arg_start
= p
;
9087 while (*p
&& *p
!= ',' && *p
!= ')' && *p
!= ' ')
9090 if (! *p
|| p
== arg_start
)
9091 dwarf2_macro_malformed_definition_complaint (body
);
9094 /* Make sure argv has room for the new argument. */
9095 if (argc
>= argv_size
)
9098 argv
= xrealloc (argv
, argv_size
* sizeof (*argv
));
9101 argv
[argc
++] = copy_string (arg_start
, p
- arg_start
);
9104 p
= consume_improper_spaces (p
, body
);
9106 /* Consume the comma, if present. */
9111 p
= consume_improper_spaces (p
, body
);
9120 /* Perfectly formed definition, no complaints. */
9121 macro_define_function (file
, line
, name
,
9122 argc
, (const char **) argv
,
9124 else if (*p
== '\0')
9126 /* Complain, but do define it. */
9127 dwarf2_macro_malformed_definition_complaint (body
);
9128 macro_define_function (file
, line
, name
,
9129 argc
, (const char **) argv
,
9133 /* Just complain. */
9134 dwarf2_macro_malformed_definition_complaint (body
);
9137 /* Just complain. */
9138 dwarf2_macro_malformed_definition_complaint (body
);
9144 for (i
= 0; i
< argc
; i
++)
9150 dwarf2_macro_malformed_definition_complaint (body
);
9155 dwarf_decode_macros (struct line_header
*lh
, unsigned int offset
,
9156 char *comp_dir
, bfd
*abfd
,
9157 struct dwarf2_cu
*cu
)
9159 gdb_byte
*mac_ptr
, *mac_end
;
9160 struct macro_source_file
*current_file
= 0;
9162 if (dwarf2_per_objfile
->macinfo_buffer
== NULL
)
9164 complaint (&symfile_complaints
, _("missing .debug_macinfo section"));
9168 mac_ptr
= dwarf2_per_objfile
->macinfo_buffer
+ offset
;
9169 mac_end
= dwarf2_per_objfile
->macinfo_buffer
9170 + dwarf2_per_objfile
->macinfo_size
;
9174 enum dwarf_macinfo_record_type macinfo_type
;
9176 /* Do we at least have room for a macinfo type byte? */
9177 if (mac_ptr
>= mac_end
)
9179 dwarf2_macros_too_long_complaint ();
9183 macinfo_type
= read_1_byte (abfd
, mac_ptr
);
9186 switch (macinfo_type
)
9188 /* A zero macinfo type indicates the end of the macro
9193 case DW_MACINFO_define
:
9194 case DW_MACINFO_undef
:
9196 unsigned int bytes_read
;
9200 line
= read_unsigned_leb128 (abfd
, mac_ptr
, &bytes_read
);
9201 mac_ptr
+= bytes_read
;
9202 body
= read_string (abfd
, mac_ptr
, &bytes_read
);
9203 mac_ptr
+= bytes_read
;
9206 complaint (&symfile_complaints
,
9207 _("debug info gives macro %s outside of any file: %s"),
9209 DW_MACINFO_define
? "definition" : macinfo_type
==
9210 DW_MACINFO_undef
? "undefinition" :
9211 "something-or-other", body
);
9214 if (macinfo_type
== DW_MACINFO_define
)
9215 parse_macro_definition (current_file
, line
, body
);
9216 else if (macinfo_type
== DW_MACINFO_undef
)
9217 macro_undef (current_file
, line
, body
);
9222 case DW_MACINFO_start_file
:
9224 unsigned int bytes_read
;
9227 line
= read_unsigned_leb128 (abfd
, mac_ptr
, &bytes_read
);
9228 mac_ptr
+= bytes_read
;
9229 file
= read_unsigned_leb128 (abfd
, mac_ptr
, &bytes_read
);
9230 mac_ptr
+= bytes_read
;
9232 current_file
= macro_start_file (file
, line
,
9233 current_file
, comp_dir
,
9238 case DW_MACINFO_end_file
:
9240 complaint (&symfile_complaints
,
9241 _("macro debug info has an unmatched `close_file' directive"));
9244 current_file
= current_file
->included_by
;
9247 enum dwarf_macinfo_record_type next_type
;
9249 /* GCC circa March 2002 doesn't produce the zero
9250 type byte marking the end of the compilation
9251 unit. Complain if it's not there, but exit no
9254 /* Do we at least have room for a macinfo type byte? */
9255 if (mac_ptr
>= mac_end
)
9257 dwarf2_macros_too_long_complaint ();
9261 /* We don't increment mac_ptr here, so this is just
9263 next_type
= read_1_byte (abfd
, mac_ptr
);
9265 complaint (&symfile_complaints
,
9266 _("no terminating 0-type entry for macros in `.debug_macinfo' section"));
9273 case DW_MACINFO_vendor_ext
:
9275 unsigned int bytes_read
;
9279 constant
= read_unsigned_leb128 (abfd
, mac_ptr
, &bytes_read
);
9280 mac_ptr
+= bytes_read
;
9281 string
= read_string (abfd
, mac_ptr
, &bytes_read
);
9282 mac_ptr
+= bytes_read
;
9284 /* We don't recognize any vendor extensions. */
9291 /* Check if the attribute's form is a DW_FORM_block*
9292 if so return true else false. */
9294 attr_form_is_block (struct attribute
*attr
)
9296 return (attr
== NULL
? 0 :
9297 attr
->form
== DW_FORM_block1
9298 || attr
->form
== DW_FORM_block2
9299 || attr
->form
== DW_FORM_block4
9300 || attr
->form
== DW_FORM_block
);
9304 dwarf2_symbol_mark_computed (struct attribute
*attr
, struct symbol
*sym
,
9305 struct dwarf2_cu
*cu
)
9307 if (attr
->form
== DW_FORM_data4
|| attr
->form
== DW_FORM_data8
)
9309 struct dwarf2_loclist_baton
*baton
;
9311 baton
= obstack_alloc (&cu
->objfile
->objfile_obstack
,
9312 sizeof (struct dwarf2_loclist_baton
));
9313 baton
->objfile
= cu
->objfile
;
9315 /* We don't know how long the location list is, but make sure we
9316 don't run off the edge of the section. */
9317 baton
->size
= dwarf2_per_objfile
->loc_size
- DW_UNSND (attr
);
9318 baton
->data
= dwarf2_per_objfile
->loc_buffer
+ DW_UNSND (attr
);
9319 baton
->base_address
= cu
->header
.base_address
;
9320 if (cu
->header
.base_known
== 0)
9321 complaint (&symfile_complaints
,
9322 _("Location list used without specifying the CU base address."));
9324 SYMBOL_OPS (sym
) = &dwarf2_loclist_funcs
;
9325 SYMBOL_LOCATION_BATON (sym
) = baton
;
9329 struct dwarf2_locexpr_baton
*baton
;
9331 baton
= obstack_alloc (&cu
->objfile
->objfile_obstack
,
9332 sizeof (struct dwarf2_locexpr_baton
));
9333 baton
->objfile
= cu
->objfile
;
9335 if (attr_form_is_block (attr
))
9337 /* Note that we're just copying the block's data pointer
9338 here, not the actual data. We're still pointing into the
9339 info_buffer for SYM's objfile; right now we never release
9340 that buffer, but when we do clean up properly this may
9342 baton
->size
= DW_BLOCK (attr
)->size
;
9343 baton
->data
= DW_BLOCK (attr
)->data
;
9347 dwarf2_invalid_attrib_class_complaint ("location description",
9348 SYMBOL_NATURAL_NAME (sym
));
9353 SYMBOL_OPS (sym
) = &dwarf2_locexpr_funcs
;
9354 SYMBOL_LOCATION_BATON (sym
) = baton
;
9358 /* Locate the compilation unit from CU's objfile which contains the
9359 DIE at OFFSET. Raises an error on failure. */
9361 static struct dwarf2_per_cu_data
*
9362 dwarf2_find_containing_comp_unit (unsigned long offset
,
9363 struct objfile
*objfile
)
9365 struct dwarf2_per_cu_data
*this_cu
;
9369 high
= dwarf2_per_objfile
->n_comp_units
- 1;
9372 int mid
= low
+ (high
- low
) / 2;
9373 if (dwarf2_per_objfile
->all_comp_units
[mid
]->offset
>= offset
)
9378 gdb_assert (low
== high
);
9379 if (dwarf2_per_objfile
->all_comp_units
[low
]->offset
> offset
)
9382 error (_("Dwarf Error: could not find partial DIE containing "
9383 "offset 0x%lx [in module %s]"),
9384 (long) offset
, bfd_get_filename (objfile
->obfd
));
9386 gdb_assert (dwarf2_per_objfile
->all_comp_units
[low
-1]->offset
<= offset
);
9387 return dwarf2_per_objfile
->all_comp_units
[low
-1];
9391 this_cu
= dwarf2_per_objfile
->all_comp_units
[low
];
9392 if (low
== dwarf2_per_objfile
->n_comp_units
- 1
9393 && offset
>= this_cu
->offset
+ this_cu
->length
)
9394 error (_("invalid dwarf2 offset %ld"), offset
);
9395 gdb_assert (offset
< this_cu
->offset
+ this_cu
->length
);
9400 /* Locate the compilation unit from OBJFILE which is located at exactly
9401 OFFSET. Raises an error on failure. */
9403 static struct dwarf2_per_cu_data
*
9404 dwarf2_find_comp_unit (unsigned long offset
, struct objfile
*objfile
)
9406 struct dwarf2_per_cu_data
*this_cu
;
9407 this_cu
= dwarf2_find_containing_comp_unit (offset
, objfile
);
9408 if (this_cu
->offset
!= offset
)
9409 error (_("no compilation unit with offset %ld."), offset
);
9413 /* Release one cached compilation unit, CU. We unlink it from the tree
9414 of compilation units, but we don't remove it from the read_in_chain;
9415 the caller is responsible for that. */
9418 free_one_comp_unit (void *data
)
9420 struct dwarf2_cu
*cu
= data
;
9422 if (cu
->per_cu
!= NULL
)
9423 cu
->per_cu
->cu
= NULL
;
9426 obstack_free (&cu
->comp_unit_obstack
, NULL
);
9428 free_die_list (cu
->dies
);
9433 /* This cleanup function is passed the address of a dwarf2_cu on the stack
9434 when we're finished with it. We can't free the pointer itself, but be
9435 sure to unlink it from the cache. Also release any associated storage
9436 and perform cache maintenance.
9438 Only used during partial symbol parsing. */
9441 free_stack_comp_unit (void *data
)
9443 struct dwarf2_cu
*cu
= data
;
9445 obstack_free (&cu
->comp_unit_obstack
, NULL
);
9446 cu
->partial_dies
= NULL
;
9448 if (cu
->per_cu
!= NULL
)
9450 /* This compilation unit is on the stack in our caller, so we
9451 should not xfree it. Just unlink it. */
9452 cu
->per_cu
->cu
= NULL
;
9455 /* If we had a per-cu pointer, then we may have other compilation
9456 units loaded, so age them now. */
9457 age_cached_comp_units ();
9461 /* Free all cached compilation units. */
9464 free_cached_comp_units (void *data
)
9466 struct dwarf2_per_cu_data
*per_cu
, **last_chain
;
9468 per_cu
= dwarf2_per_objfile
->read_in_chain
;
9469 last_chain
= &dwarf2_per_objfile
->read_in_chain
;
9470 while (per_cu
!= NULL
)
9472 struct dwarf2_per_cu_data
*next_cu
;
9474 next_cu
= per_cu
->cu
->read_in_chain
;
9476 free_one_comp_unit (per_cu
->cu
);
9477 *last_chain
= next_cu
;
9483 /* Increase the age counter on each cached compilation unit, and free
9484 any that are too old. */
9487 age_cached_comp_units (void)
9489 struct dwarf2_per_cu_data
*per_cu
, **last_chain
;
9491 dwarf2_clear_marks (dwarf2_per_objfile
->read_in_chain
);
9492 per_cu
= dwarf2_per_objfile
->read_in_chain
;
9493 while (per_cu
!= NULL
)
9495 per_cu
->cu
->last_used
++;
9496 if (per_cu
->cu
->last_used
<= dwarf2_max_cache_age
)
9497 dwarf2_mark (per_cu
->cu
);
9498 per_cu
= per_cu
->cu
->read_in_chain
;
9501 per_cu
= dwarf2_per_objfile
->read_in_chain
;
9502 last_chain
= &dwarf2_per_objfile
->read_in_chain
;
9503 while (per_cu
!= NULL
)
9505 struct dwarf2_per_cu_data
*next_cu
;
9507 next_cu
= per_cu
->cu
->read_in_chain
;
9509 if (!per_cu
->cu
->mark
)
9511 free_one_comp_unit (per_cu
->cu
);
9512 *last_chain
= next_cu
;
9515 last_chain
= &per_cu
->cu
->read_in_chain
;
9521 /* Remove a single compilation unit from the cache. */
9524 free_one_cached_comp_unit (void *target_cu
)
9526 struct dwarf2_per_cu_data
*per_cu
, **last_chain
;
9528 per_cu
= dwarf2_per_objfile
->read_in_chain
;
9529 last_chain
= &dwarf2_per_objfile
->read_in_chain
;
9530 while (per_cu
!= NULL
)
9532 struct dwarf2_per_cu_data
*next_cu
;
9534 next_cu
= per_cu
->cu
->read_in_chain
;
9536 if (per_cu
->cu
== target_cu
)
9538 free_one_comp_unit (per_cu
->cu
);
9539 *last_chain
= next_cu
;
9543 last_chain
= &per_cu
->cu
->read_in_chain
;
9549 /* A pair of DIE offset and GDB type pointer. We store these
9550 in a hash table separate from the DIEs, and preserve them
9551 when the DIEs are flushed out of cache. */
9553 struct dwarf2_offset_and_type
9555 unsigned int offset
;
9559 /* Hash function for a dwarf2_offset_and_type. */
9562 offset_and_type_hash (const void *item
)
9564 const struct dwarf2_offset_and_type
*ofs
= item
;
9568 /* Equality function for a dwarf2_offset_and_type. */
9571 offset_and_type_eq (const void *item_lhs
, const void *item_rhs
)
9573 const struct dwarf2_offset_and_type
*ofs_lhs
= item_lhs
;
9574 const struct dwarf2_offset_and_type
*ofs_rhs
= item_rhs
;
9575 return ofs_lhs
->offset
== ofs_rhs
->offset
;
9578 /* Set the type associated with DIE to TYPE. Save it in CU's hash
9579 table if necessary. */
9582 set_die_type (struct die_info
*die
, struct type
*type
, struct dwarf2_cu
*cu
)
9584 struct dwarf2_offset_and_type
**slot
, ofs
;
9588 if (cu
->per_cu
== NULL
)
9591 if (cu
->per_cu
->type_hash
== NULL
)
9592 cu
->per_cu
->type_hash
9593 = htab_create_alloc_ex (cu
->header
.length
/ 24,
9594 offset_and_type_hash
,
9597 &cu
->objfile
->objfile_obstack
,
9598 hashtab_obstack_allocate
,
9599 dummy_obstack_deallocate
);
9601 ofs
.offset
= die
->offset
;
9603 slot
= (struct dwarf2_offset_and_type
**)
9604 htab_find_slot_with_hash (cu
->per_cu
->type_hash
, &ofs
, ofs
.offset
, INSERT
);
9605 *slot
= obstack_alloc (&cu
->objfile
->objfile_obstack
, sizeof (**slot
));
9609 /* Find the type for DIE in TYPE_HASH, or return NULL if DIE does not
9610 have a saved type. */
9612 static struct type
*
9613 get_die_type (struct die_info
*die
, htab_t type_hash
)
9615 struct dwarf2_offset_and_type
*slot
, ofs
;
9617 ofs
.offset
= die
->offset
;
9618 slot
= htab_find_with_hash (type_hash
, &ofs
, ofs
.offset
);
9625 /* Restore the types of the DIE tree starting at START_DIE from the hash
9626 table saved in CU. */
9629 reset_die_and_siblings_types (struct die_info
*start_die
, struct dwarf2_cu
*cu
)
9631 struct die_info
*die
;
9633 if (cu
->per_cu
->type_hash
== NULL
)
9636 for (die
= start_die
; die
!= NULL
; die
= die
->sibling
)
9638 die
->type
= get_die_type (die
, cu
->per_cu
->type_hash
);
9639 if (die
->child
!= NULL
)
9640 reset_die_and_siblings_types (die
->child
, cu
);
9644 /* Set the mark field in CU and in every other compilation unit in the
9645 cache that we must keep because we are keeping CU. */
9647 /* Add a dependence relationship from CU to REF_PER_CU. */
9650 dwarf2_add_dependence (struct dwarf2_cu
*cu
,
9651 struct dwarf2_per_cu_data
*ref_per_cu
)
9655 if (cu
->dependencies
== NULL
)
9657 = htab_create_alloc_ex (5, htab_hash_pointer
, htab_eq_pointer
,
9658 NULL
, &cu
->comp_unit_obstack
,
9659 hashtab_obstack_allocate
,
9660 dummy_obstack_deallocate
);
9662 slot
= htab_find_slot (cu
->dependencies
, ref_per_cu
, INSERT
);
9667 /* Set the mark field in CU and in every other compilation unit in the
9668 cache that we must keep because we are keeping CU. */
9671 dwarf2_mark_helper (void **slot
, void *data
)
9673 struct dwarf2_per_cu_data
*per_cu
;
9675 per_cu
= (struct dwarf2_per_cu_data
*) *slot
;
9676 if (per_cu
->cu
->mark
)
9678 per_cu
->cu
->mark
= 1;
9680 if (per_cu
->cu
->dependencies
!= NULL
)
9681 htab_traverse (per_cu
->cu
->dependencies
, dwarf2_mark_helper
, NULL
);
9687 dwarf2_mark (struct dwarf2_cu
*cu
)
9692 if (cu
->dependencies
!= NULL
)
9693 htab_traverse (cu
->dependencies
, dwarf2_mark_helper
, NULL
);
9697 dwarf2_clear_marks (struct dwarf2_per_cu_data
*per_cu
)
9701 per_cu
->cu
->mark
= 0;
9702 per_cu
= per_cu
->cu
->read_in_chain
;
9706 /* Trivial hash function for partial_die_info: the hash value of a DIE
9707 is its offset in .debug_info for this objfile. */
9710 partial_die_hash (const void *item
)
9712 const struct partial_die_info
*part_die
= item
;
9713 return part_die
->offset
;
9716 /* Trivial comparison function for partial_die_info structures: two DIEs
9717 are equal if they have the same offset. */
9720 partial_die_eq (const void *item_lhs
, const void *item_rhs
)
9722 const struct partial_die_info
*part_die_lhs
= item_lhs
;
9723 const struct partial_die_info
*part_die_rhs
= item_rhs
;
9724 return part_die_lhs
->offset
== part_die_rhs
->offset
;
9727 static struct cmd_list_element
*set_dwarf2_cmdlist
;
9728 static struct cmd_list_element
*show_dwarf2_cmdlist
;
9731 set_dwarf2_cmd (char *args
, int from_tty
)
9733 help_list (set_dwarf2_cmdlist
, "maintenance set dwarf2 ", -1, gdb_stdout
);
9737 show_dwarf2_cmd (char *args
, int from_tty
)
9739 cmd_show_list (show_dwarf2_cmdlist
, from_tty
, "");
9742 void _initialize_dwarf2_read (void);
9745 _initialize_dwarf2_read (void)
9747 dwarf2_objfile_data_key
= register_objfile_data ();
9749 add_prefix_cmd ("dwarf2", class_maintenance
, set_dwarf2_cmd
, _("\
9750 Set DWARF 2 specific variables.\n\
9751 Configure DWARF 2 variables such as the cache size"),
9752 &set_dwarf2_cmdlist
, "maintenance set dwarf2 ",
9753 0/*allow-unknown*/, &maintenance_set_cmdlist
);
9755 add_prefix_cmd ("dwarf2", class_maintenance
, show_dwarf2_cmd
, _("\
9756 Show DWARF 2 specific variables\n\
9757 Show DWARF 2 variables such as the cache size"),
9758 &show_dwarf2_cmdlist
, "maintenance show dwarf2 ",
9759 0/*allow-unknown*/, &maintenance_show_cmdlist
);
9761 add_setshow_zinteger_cmd ("max-cache-age", class_obscure
,
9762 &dwarf2_max_cache_age
, _("\
9763 Set the upper bound on the age of cached dwarf2 compilation units."), _("\
9764 Show the upper bound on the age of cached dwarf2 compilation units."), _("\
9765 A higher limit means that cached compilation units will be stored\n\
9766 in memory longer, and more total memory will be used. Zero disables\n\
9767 caching, which can slow down startup."),
9769 show_dwarf2_max_cache_age
,
9770 &set_dwarf2_cmdlist
,
9771 &show_dwarf2_cmdlist
);