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_unspecified_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
4866 struct attribute
*attr
;
4871 /* For now, we only support the C meaning of an unspecified type: void. */
4873 attr
= dwarf2_attr (die
, DW_AT_name
, cu
);
4874 type
= init_type (TYPE_CODE_VOID
, 0, 0, attr
? DW_STRING (attr
) : "",
4877 set_die_type (die
, type
, cu
);
4880 /* Read a whole compilation unit into a linked list of dies. */
4882 static struct die_info
*
4883 read_comp_unit (gdb_byte
*info_ptr
, bfd
*abfd
, struct dwarf2_cu
*cu
)
4885 return read_die_and_children (info_ptr
, abfd
, cu
, &info_ptr
, NULL
);
4888 /* Read a single die and all its descendents. Set the die's sibling
4889 field to NULL; set other fields in the die correctly, and set all
4890 of the descendents' fields correctly. Set *NEW_INFO_PTR to the
4891 location of the info_ptr after reading all of those dies. PARENT
4892 is the parent of the die in question. */
4894 static struct die_info
*
4895 read_die_and_children (gdb_byte
*info_ptr
, bfd
*abfd
,
4896 struct dwarf2_cu
*cu
,
4897 gdb_byte
**new_info_ptr
,
4898 struct die_info
*parent
)
4900 struct die_info
*die
;
4904 cur_ptr
= read_full_die (&die
, abfd
, info_ptr
, cu
, &has_children
);
4905 store_in_ref_table (die
->offset
, die
, cu
);
4909 die
->child
= read_die_and_siblings (cur_ptr
, abfd
, cu
,
4915 *new_info_ptr
= cur_ptr
;
4918 die
->sibling
= NULL
;
4919 die
->parent
= parent
;
4923 /* Read a die, all of its descendents, and all of its siblings; set
4924 all of the fields of all of the dies correctly. Arguments are as
4925 in read_die_and_children. */
4927 static struct die_info
*
4928 read_die_and_siblings (gdb_byte
*info_ptr
, bfd
*abfd
,
4929 struct dwarf2_cu
*cu
,
4930 gdb_byte
**new_info_ptr
,
4931 struct die_info
*parent
)
4933 struct die_info
*first_die
, *last_sibling
;
4937 first_die
= last_sibling
= NULL
;
4941 struct die_info
*die
4942 = read_die_and_children (cur_ptr
, abfd
, cu
, &cur_ptr
, parent
);
4950 last_sibling
->sibling
= die
;
4955 *new_info_ptr
= cur_ptr
;
4965 /* Free a linked list of dies. */
4968 free_die_list (struct die_info
*dies
)
4970 struct die_info
*die
, *next
;
4975 if (die
->child
!= NULL
)
4976 free_die_list (die
->child
);
4977 next
= die
->sibling
;
4984 /* Read the contents of the section at OFFSET and of size SIZE from the
4985 object file specified by OBJFILE into the objfile_obstack and return it. */
4988 dwarf2_read_section (struct objfile
*objfile
, asection
*sectp
)
4990 bfd
*abfd
= objfile
->obfd
;
4991 gdb_byte
*buf
, *retbuf
;
4992 bfd_size_type size
= bfd_get_section_size (sectp
);
4997 buf
= obstack_alloc (&objfile
->objfile_obstack
, size
);
4998 retbuf
= symfile_relocate_debug_section (abfd
, sectp
, buf
);
5002 if (bfd_seek (abfd
, sectp
->filepos
, SEEK_SET
) != 0
5003 || bfd_bread (buf
, size
, abfd
) != size
)
5004 error (_("Dwarf Error: Can't read DWARF data from '%s'"),
5005 bfd_get_filename (abfd
));
5010 /* In DWARF version 2, the description of the debugging information is
5011 stored in a separate .debug_abbrev section. Before we read any
5012 dies from a section we read in all abbreviations and install them
5013 in a hash table. This function also sets flags in CU describing
5014 the data found in the abbrev table. */
5017 dwarf2_read_abbrevs (bfd
*abfd
, struct dwarf2_cu
*cu
)
5019 struct comp_unit_head
*cu_header
= &cu
->header
;
5020 gdb_byte
*abbrev_ptr
;
5021 struct abbrev_info
*cur_abbrev
;
5022 unsigned int abbrev_number
, bytes_read
, abbrev_name
;
5023 unsigned int abbrev_form
, hash_number
;
5024 struct attr_abbrev
*cur_attrs
;
5025 unsigned int allocated_attrs
;
5027 /* Initialize dwarf2 abbrevs */
5028 obstack_init (&cu
->abbrev_obstack
);
5029 cu
->dwarf2_abbrevs
= obstack_alloc (&cu
->abbrev_obstack
,
5031 * sizeof (struct abbrev_info
*)));
5032 memset (cu
->dwarf2_abbrevs
, 0,
5033 ABBREV_HASH_SIZE
* sizeof (struct abbrev_info
*));
5035 abbrev_ptr
= dwarf2_per_objfile
->abbrev_buffer
+ cu_header
->abbrev_offset
;
5036 abbrev_number
= read_unsigned_leb128 (abfd
, abbrev_ptr
, &bytes_read
);
5037 abbrev_ptr
+= bytes_read
;
5039 allocated_attrs
= ATTR_ALLOC_CHUNK
;
5040 cur_attrs
= xmalloc (allocated_attrs
* sizeof (struct attr_abbrev
));
5042 /* loop until we reach an abbrev number of 0 */
5043 while (abbrev_number
)
5045 cur_abbrev
= dwarf_alloc_abbrev (cu
);
5047 /* read in abbrev header */
5048 cur_abbrev
->number
= abbrev_number
;
5049 cur_abbrev
->tag
= read_unsigned_leb128 (abfd
, abbrev_ptr
, &bytes_read
);
5050 abbrev_ptr
+= bytes_read
;
5051 cur_abbrev
->has_children
= read_1_byte (abfd
, abbrev_ptr
);
5054 if (cur_abbrev
->tag
== DW_TAG_namespace
)
5055 cu
->has_namespace_info
= 1;
5057 /* now read in declarations */
5058 abbrev_name
= read_unsigned_leb128 (abfd
, abbrev_ptr
, &bytes_read
);
5059 abbrev_ptr
+= bytes_read
;
5060 abbrev_form
= read_unsigned_leb128 (abfd
, abbrev_ptr
, &bytes_read
);
5061 abbrev_ptr
+= bytes_read
;
5064 if (cur_abbrev
->num_attrs
== allocated_attrs
)
5066 allocated_attrs
+= ATTR_ALLOC_CHUNK
;
5068 = xrealloc (cur_attrs
, (allocated_attrs
5069 * sizeof (struct attr_abbrev
)));
5072 /* Record whether this compilation unit might have
5073 inter-compilation-unit references. If we don't know what form
5074 this attribute will have, then it might potentially be a
5075 DW_FORM_ref_addr, so we conservatively expect inter-CU
5078 if (abbrev_form
== DW_FORM_ref_addr
5079 || abbrev_form
== DW_FORM_indirect
)
5080 cu
->has_form_ref_addr
= 1;
5082 cur_attrs
[cur_abbrev
->num_attrs
].name
= abbrev_name
;
5083 cur_attrs
[cur_abbrev
->num_attrs
++].form
= abbrev_form
;
5084 abbrev_name
= read_unsigned_leb128 (abfd
, abbrev_ptr
, &bytes_read
);
5085 abbrev_ptr
+= bytes_read
;
5086 abbrev_form
= read_unsigned_leb128 (abfd
, abbrev_ptr
, &bytes_read
);
5087 abbrev_ptr
+= bytes_read
;
5090 cur_abbrev
->attrs
= obstack_alloc (&cu
->abbrev_obstack
,
5091 (cur_abbrev
->num_attrs
5092 * sizeof (struct attr_abbrev
)));
5093 memcpy (cur_abbrev
->attrs
, cur_attrs
,
5094 cur_abbrev
->num_attrs
* sizeof (struct attr_abbrev
));
5096 hash_number
= abbrev_number
% ABBREV_HASH_SIZE
;
5097 cur_abbrev
->next
= cu
->dwarf2_abbrevs
[hash_number
];
5098 cu
->dwarf2_abbrevs
[hash_number
] = cur_abbrev
;
5100 /* Get next abbreviation.
5101 Under Irix6 the abbreviations for a compilation unit are not
5102 always properly terminated with an abbrev number of 0.
5103 Exit loop if we encounter an abbreviation which we have
5104 already read (which means we are about to read the abbreviations
5105 for the next compile unit) or if the end of the abbreviation
5106 table is reached. */
5107 if ((unsigned int) (abbrev_ptr
- dwarf2_per_objfile
->abbrev_buffer
)
5108 >= dwarf2_per_objfile
->abbrev_size
)
5110 abbrev_number
= read_unsigned_leb128 (abfd
, abbrev_ptr
, &bytes_read
);
5111 abbrev_ptr
+= bytes_read
;
5112 if (dwarf2_lookup_abbrev (abbrev_number
, cu
) != NULL
)
5119 /* Release the memory used by the abbrev table for a compilation unit. */
5122 dwarf2_free_abbrev_table (void *ptr_to_cu
)
5124 struct dwarf2_cu
*cu
= ptr_to_cu
;
5126 obstack_free (&cu
->abbrev_obstack
, NULL
);
5127 cu
->dwarf2_abbrevs
= NULL
;
5130 /* Lookup an abbrev_info structure in the abbrev hash table. */
5132 static struct abbrev_info
*
5133 dwarf2_lookup_abbrev (unsigned int number
, struct dwarf2_cu
*cu
)
5135 unsigned int hash_number
;
5136 struct abbrev_info
*abbrev
;
5138 hash_number
= number
% ABBREV_HASH_SIZE
;
5139 abbrev
= cu
->dwarf2_abbrevs
[hash_number
];
5143 if (abbrev
->number
== number
)
5146 abbrev
= abbrev
->next
;
5151 /* Returns nonzero if TAG represents a type that we might generate a partial
5155 is_type_tag_for_partial (int tag
)
5160 /* Some types that would be reasonable to generate partial symbols for,
5161 that we don't at present. */
5162 case DW_TAG_array_type
:
5163 case DW_TAG_file_type
:
5164 case DW_TAG_ptr_to_member_type
:
5165 case DW_TAG_set_type
:
5166 case DW_TAG_string_type
:
5167 case DW_TAG_subroutine_type
:
5169 case DW_TAG_base_type
:
5170 case DW_TAG_class_type
:
5171 case DW_TAG_enumeration_type
:
5172 case DW_TAG_structure_type
:
5173 case DW_TAG_subrange_type
:
5174 case DW_TAG_typedef
:
5175 case DW_TAG_union_type
:
5182 /* Load all DIEs that are interesting for partial symbols into memory. */
5184 static struct partial_die_info
*
5185 load_partial_dies (bfd
*abfd
, gdb_byte
*info_ptr
, int building_psymtab
,
5186 struct dwarf2_cu
*cu
)
5188 struct partial_die_info
*part_die
;
5189 struct partial_die_info
*parent_die
, *last_die
, *first_die
= NULL
;
5190 struct abbrev_info
*abbrev
;
5191 unsigned int bytes_read
;
5192 unsigned int load_all
= 0;
5194 int nesting_level
= 1;
5199 if (cu
->per_cu
&& cu
->per_cu
->load_all_dies
)
5203 = htab_create_alloc_ex (cu
->header
.length
/ 12,
5207 &cu
->comp_unit_obstack
,
5208 hashtab_obstack_allocate
,
5209 dummy_obstack_deallocate
);
5211 part_die
= obstack_alloc (&cu
->comp_unit_obstack
,
5212 sizeof (struct partial_die_info
));
5216 abbrev
= peek_die_abbrev (info_ptr
, &bytes_read
, cu
);
5218 /* A NULL abbrev means the end of a series of children. */
5221 if (--nesting_level
== 0)
5223 /* PART_DIE was probably the last thing allocated on the
5224 comp_unit_obstack, so we could call obstack_free
5225 here. We don't do that because the waste is small,
5226 and will be cleaned up when we're done with this
5227 compilation unit. This way, we're also more robust
5228 against other users of the comp_unit_obstack. */
5231 info_ptr
+= bytes_read
;
5232 last_die
= parent_die
;
5233 parent_die
= parent_die
->die_parent
;
5237 /* Check whether this DIE is interesting enough to save. Normally
5238 we would not be interested in members here, but there may be
5239 later variables referencing them via DW_AT_specification (for
5242 && !is_type_tag_for_partial (abbrev
->tag
)
5243 && abbrev
->tag
!= DW_TAG_enumerator
5244 && abbrev
->tag
!= DW_TAG_subprogram
5245 && abbrev
->tag
!= DW_TAG_variable
5246 && abbrev
->tag
!= DW_TAG_namespace
5247 && abbrev
->tag
!= DW_TAG_member
)
5249 /* Otherwise we skip to the next sibling, if any. */
5250 info_ptr
= skip_one_die (info_ptr
+ bytes_read
, abbrev
, cu
);
5254 info_ptr
= read_partial_die (part_die
, abbrev
, bytes_read
,
5255 abfd
, info_ptr
, cu
);
5257 /* This two-pass algorithm for processing partial symbols has a
5258 high cost in cache pressure. Thus, handle some simple cases
5259 here which cover the majority of C partial symbols. DIEs
5260 which neither have specification tags in them, nor could have
5261 specification tags elsewhere pointing at them, can simply be
5262 processed and discarded.
5264 This segment is also optional; scan_partial_symbols and
5265 add_partial_symbol will handle these DIEs if we chain
5266 them in normally. When compilers which do not emit large
5267 quantities of duplicate debug information are more common,
5268 this code can probably be removed. */
5270 /* Any complete simple types at the top level (pretty much all
5271 of them, for a language without namespaces), can be processed
5273 if (parent_die
== NULL
5274 && part_die
->has_specification
== 0
5275 && part_die
->is_declaration
== 0
5276 && (part_die
->tag
== DW_TAG_typedef
5277 || part_die
->tag
== DW_TAG_base_type
5278 || part_die
->tag
== DW_TAG_subrange_type
))
5280 if (building_psymtab
&& part_die
->name
!= NULL
)
5281 add_psymbol_to_list (part_die
->name
, strlen (part_die
->name
),
5282 VAR_DOMAIN
, LOC_TYPEDEF
,
5283 &cu
->objfile
->static_psymbols
,
5284 0, (CORE_ADDR
) 0, cu
->language
, cu
->objfile
);
5285 info_ptr
= locate_pdi_sibling (part_die
, info_ptr
, abfd
, cu
);
5289 /* If we're at the second level, and we're an enumerator, and
5290 our parent has no specification (meaning possibly lives in a
5291 namespace elsewhere), then we can add the partial symbol now
5292 instead of queueing it. */
5293 if (part_die
->tag
== DW_TAG_enumerator
5294 && parent_die
!= NULL
5295 && parent_die
->die_parent
== NULL
5296 && parent_die
->tag
== DW_TAG_enumeration_type
5297 && parent_die
->has_specification
== 0)
5299 if (part_die
->name
== NULL
)
5300 complaint (&symfile_complaints
, _("malformed enumerator DIE ignored"));
5301 else if (building_psymtab
)
5302 add_psymbol_to_list (part_die
->name
, strlen (part_die
->name
),
5303 VAR_DOMAIN
, LOC_CONST
,
5304 (cu
->language
== language_cplus
5305 || cu
->language
== language_java
)
5306 ? &cu
->objfile
->global_psymbols
5307 : &cu
->objfile
->static_psymbols
,
5308 0, (CORE_ADDR
) 0, cu
->language
, cu
->objfile
);
5310 info_ptr
= locate_pdi_sibling (part_die
, info_ptr
, abfd
, cu
);
5314 /* We'll save this DIE so link it in. */
5315 part_die
->die_parent
= parent_die
;
5316 part_die
->die_sibling
= NULL
;
5317 part_die
->die_child
= NULL
;
5319 if (last_die
&& last_die
== parent_die
)
5320 last_die
->die_child
= part_die
;
5322 last_die
->die_sibling
= part_die
;
5324 last_die
= part_die
;
5326 if (first_die
== NULL
)
5327 first_die
= part_die
;
5329 /* Maybe add the DIE to the hash table. Not all DIEs that we
5330 find interesting need to be in the hash table, because we
5331 also have the parent/sibling/child chains; only those that we
5332 might refer to by offset later during partial symbol reading.
5334 For now this means things that might have be the target of a
5335 DW_AT_specification, DW_AT_abstract_origin, or
5336 DW_AT_extension. DW_AT_extension will refer only to
5337 namespaces; DW_AT_abstract_origin refers to functions (and
5338 many things under the function DIE, but we do not recurse
5339 into function DIEs during partial symbol reading) and
5340 possibly variables as well; DW_AT_specification refers to
5341 declarations. Declarations ought to have the DW_AT_declaration
5342 flag. It happens that GCC forgets to put it in sometimes, but
5343 only for functions, not for types.
5345 Adding more things than necessary to the hash table is harmless
5346 except for the performance cost. Adding too few will result in
5347 wasted time in find_partial_die, when we reread the compilation
5348 unit with load_all_dies set. */
5351 || abbrev
->tag
== DW_TAG_subprogram
5352 || abbrev
->tag
== DW_TAG_variable
5353 || abbrev
->tag
== DW_TAG_namespace
5354 || part_die
->is_declaration
)
5358 slot
= htab_find_slot_with_hash (cu
->partial_dies
, part_die
,
5359 part_die
->offset
, INSERT
);
5363 part_die
= obstack_alloc (&cu
->comp_unit_obstack
,
5364 sizeof (struct partial_die_info
));
5366 /* For some DIEs we want to follow their children (if any). For C
5367 we have no reason to follow the children of structures; for other
5368 languages we have to, both so that we can get at method physnames
5369 to infer fully qualified class names, and for DW_AT_specification. */
5370 if (last_die
->has_children
5372 || last_die
->tag
== DW_TAG_namespace
5373 || last_die
->tag
== DW_TAG_enumeration_type
5374 || (cu
->language
!= language_c
5375 && (last_die
->tag
== DW_TAG_class_type
5376 || last_die
->tag
== DW_TAG_structure_type
5377 || last_die
->tag
== DW_TAG_union_type
))))
5380 parent_die
= last_die
;
5384 /* Otherwise we skip to the next sibling, if any. */
5385 info_ptr
= locate_pdi_sibling (last_die
, info_ptr
, abfd
, cu
);
5387 /* Back to the top, do it again. */
5391 /* Read a minimal amount of information into the minimal die structure. */
5394 read_partial_die (struct partial_die_info
*part_die
,
5395 struct abbrev_info
*abbrev
,
5396 unsigned int abbrev_len
, bfd
*abfd
,
5397 gdb_byte
*info_ptr
, struct dwarf2_cu
*cu
)
5399 unsigned int bytes_read
, i
;
5400 struct attribute attr
;
5401 int has_low_pc_attr
= 0;
5402 int has_high_pc_attr
= 0;
5404 memset (part_die
, 0, sizeof (struct partial_die_info
));
5406 part_die
->offset
= info_ptr
- dwarf2_per_objfile
->info_buffer
;
5408 info_ptr
+= abbrev_len
;
5413 part_die
->tag
= abbrev
->tag
;
5414 part_die
->has_children
= abbrev
->has_children
;
5416 for (i
= 0; i
< abbrev
->num_attrs
; ++i
)
5418 info_ptr
= read_attribute (&attr
, &abbrev
->attrs
[i
], abfd
, info_ptr
, cu
);
5420 /* Store the data if it is of an attribute we want to keep in a
5421 partial symbol table. */
5426 /* Prefer DW_AT_MIPS_linkage_name over DW_AT_name. */
5427 if (part_die
->name
== NULL
)
5428 part_die
->name
= DW_STRING (&attr
);
5430 case DW_AT_comp_dir
:
5431 if (part_die
->dirname
== NULL
)
5432 part_die
->dirname
= DW_STRING (&attr
);
5434 case DW_AT_MIPS_linkage_name
:
5435 part_die
->name
= DW_STRING (&attr
);
5438 has_low_pc_attr
= 1;
5439 part_die
->lowpc
= DW_ADDR (&attr
);
5442 has_high_pc_attr
= 1;
5443 part_die
->highpc
= DW_ADDR (&attr
);
5445 case DW_AT_location
:
5446 /* Support the .debug_loc offsets */
5447 if (attr_form_is_block (&attr
))
5449 part_die
->locdesc
= DW_BLOCK (&attr
);
5451 else if (attr
.form
== DW_FORM_data4
|| attr
.form
== DW_FORM_data8
)
5453 dwarf2_complex_location_expr_complaint ();
5457 dwarf2_invalid_attrib_class_complaint ("DW_AT_location",
5458 "partial symbol information");
5461 case DW_AT_language
:
5462 part_die
->language
= DW_UNSND (&attr
);
5464 case DW_AT_external
:
5465 part_die
->is_external
= DW_UNSND (&attr
);
5467 case DW_AT_declaration
:
5468 part_die
->is_declaration
= DW_UNSND (&attr
);
5471 part_die
->has_type
= 1;
5473 case DW_AT_abstract_origin
:
5474 case DW_AT_specification
:
5475 case DW_AT_extension
:
5476 part_die
->has_specification
= 1;
5477 part_die
->spec_offset
= dwarf2_get_ref_die_offset (&attr
, cu
);
5480 /* Ignore absolute siblings, they might point outside of
5481 the current compile unit. */
5482 if (attr
.form
== DW_FORM_ref_addr
)
5483 complaint (&symfile_complaints
, _("ignoring absolute DW_AT_sibling"));
5485 part_die
->sibling
= dwarf2_per_objfile
->info_buffer
5486 + dwarf2_get_ref_die_offset (&attr
, cu
);
5488 case DW_AT_stmt_list
:
5489 part_die
->has_stmt_list
= 1;
5490 part_die
->line_offset
= DW_UNSND (&attr
);
5497 /* When using the GNU linker, .gnu.linkonce. sections are used to
5498 eliminate duplicate copies of functions and vtables and such.
5499 The linker will arbitrarily choose one and discard the others.
5500 The AT_*_pc values for such functions refer to local labels in
5501 these sections. If the section from that file was discarded, the
5502 labels are not in the output, so the relocs get a value of 0.
5503 If this is a discarded function, mark the pc bounds as invalid,
5504 so that GDB will ignore it. */
5505 if (has_low_pc_attr
&& has_high_pc_attr
5506 && part_die
->lowpc
< part_die
->highpc
5507 && (part_die
->lowpc
!= 0
5508 || (bfd_get_file_flags (abfd
) & HAS_RELOC
)))
5509 part_die
->has_pc_info
= 1;
5513 /* Find a cached partial DIE at OFFSET in CU. */
5515 static struct partial_die_info
*
5516 find_partial_die_in_comp_unit (unsigned long offset
, struct dwarf2_cu
*cu
)
5518 struct partial_die_info
*lookup_die
= NULL
;
5519 struct partial_die_info part_die
;
5521 part_die
.offset
= offset
;
5522 lookup_die
= htab_find_with_hash (cu
->partial_dies
, &part_die
, offset
);
5527 /* Find a partial DIE at OFFSET, which may or may not be in CU. */
5529 static struct partial_die_info
*
5530 find_partial_die (unsigned long offset
, struct dwarf2_cu
*cu
)
5532 struct dwarf2_per_cu_data
*per_cu
= NULL
;
5533 struct partial_die_info
*pd
= NULL
;
5535 if (offset
>= cu
->header
.offset
5536 && offset
< cu
->header
.offset
+ cu
->header
.length
)
5538 pd
= find_partial_die_in_comp_unit (offset
, cu
);
5543 per_cu
= dwarf2_find_containing_comp_unit (offset
, cu
->objfile
);
5545 if (per_cu
->cu
== NULL
)
5547 load_comp_unit (per_cu
, cu
->objfile
);
5548 per_cu
->cu
->read_in_chain
= dwarf2_per_objfile
->read_in_chain
;
5549 dwarf2_per_objfile
->read_in_chain
= per_cu
;
5552 per_cu
->cu
->last_used
= 0;
5553 pd
= find_partial_die_in_comp_unit (offset
, per_cu
->cu
);
5555 if (pd
== NULL
&& per_cu
->load_all_dies
== 0)
5557 struct cleanup
*back_to
;
5558 struct partial_die_info comp_unit_die
;
5559 struct abbrev_info
*abbrev
;
5560 unsigned int bytes_read
;
5563 per_cu
->load_all_dies
= 1;
5565 /* Re-read the DIEs. */
5566 back_to
= make_cleanup (null_cleanup
, 0);
5567 if (per_cu
->cu
->dwarf2_abbrevs
== NULL
)
5569 dwarf2_read_abbrevs (per_cu
->cu
->objfile
->obfd
, per_cu
->cu
);
5570 back_to
= make_cleanup (dwarf2_free_abbrev_table
, per_cu
->cu
);
5572 info_ptr
= per_cu
->cu
->header
.first_die_ptr
;
5573 abbrev
= peek_die_abbrev (info_ptr
, &bytes_read
, per_cu
->cu
);
5574 info_ptr
= read_partial_die (&comp_unit_die
, abbrev
, bytes_read
,
5575 per_cu
->cu
->objfile
->obfd
, info_ptr
,
5577 if (comp_unit_die
.has_children
)
5578 load_partial_dies (per_cu
->cu
->objfile
->obfd
, info_ptr
, 0, per_cu
->cu
);
5579 do_cleanups (back_to
);
5581 pd
= find_partial_die_in_comp_unit (offset
, per_cu
->cu
);
5585 internal_error (__FILE__
, __LINE__
,
5586 _("could not find partial DIE 0x%lx in cache [from module %s]\n"),
5587 offset
, bfd_get_filename (cu
->objfile
->obfd
));
5591 /* Adjust PART_DIE before generating a symbol for it. This function
5592 may set the is_external flag or change the DIE's name. */
5595 fixup_partial_die (struct partial_die_info
*part_die
,
5596 struct dwarf2_cu
*cu
)
5598 /* If we found a reference attribute and the DIE has no name, try
5599 to find a name in the referred to DIE. */
5601 if (part_die
->name
== NULL
&& part_die
->has_specification
)
5603 struct partial_die_info
*spec_die
;
5605 spec_die
= find_partial_die (part_die
->spec_offset
, cu
);
5607 fixup_partial_die (spec_die
, cu
);
5611 part_die
->name
= spec_die
->name
;
5613 /* Copy DW_AT_external attribute if it is set. */
5614 if (spec_die
->is_external
)
5615 part_die
->is_external
= spec_die
->is_external
;
5619 /* Set default names for some unnamed DIEs. */
5620 if (part_die
->name
== NULL
&& (part_die
->tag
== DW_TAG_structure_type
5621 || part_die
->tag
== DW_TAG_class_type
))
5622 part_die
->name
= "(anonymous class)";
5624 if (part_die
->name
== NULL
&& part_die
->tag
== DW_TAG_namespace
)
5625 part_die
->name
= "(anonymous namespace)";
5627 if (part_die
->tag
== DW_TAG_structure_type
5628 || part_die
->tag
== DW_TAG_class_type
5629 || part_die
->tag
== DW_TAG_union_type
)
5630 guess_structure_name (part_die
, cu
);
5633 /* Read the die from the .debug_info section buffer. Set DIEP to
5634 point to a newly allocated die with its information, except for its
5635 child, sibling, and parent fields. Set HAS_CHILDREN to tell
5636 whether the die has children or not. */
5639 read_full_die (struct die_info
**diep
, bfd
*abfd
, gdb_byte
*info_ptr
,
5640 struct dwarf2_cu
*cu
, int *has_children
)
5642 unsigned int abbrev_number
, bytes_read
, i
, offset
;
5643 struct abbrev_info
*abbrev
;
5644 struct die_info
*die
;
5646 offset
= info_ptr
- dwarf2_per_objfile
->info_buffer
;
5647 abbrev_number
= read_unsigned_leb128 (abfd
, info_ptr
, &bytes_read
);
5648 info_ptr
+= bytes_read
;
5651 die
= dwarf_alloc_die ();
5653 die
->abbrev
= abbrev_number
;
5660 abbrev
= dwarf2_lookup_abbrev (abbrev_number
, cu
);
5663 error (_("Dwarf Error: could not find abbrev number %d [in module %s]"),
5665 bfd_get_filename (abfd
));
5667 die
= dwarf_alloc_die ();
5668 die
->offset
= offset
;
5669 die
->tag
= abbrev
->tag
;
5670 die
->abbrev
= abbrev_number
;
5673 die
->num_attrs
= abbrev
->num_attrs
;
5674 die
->attrs
= (struct attribute
*)
5675 xmalloc (die
->num_attrs
* sizeof (struct attribute
));
5677 for (i
= 0; i
< abbrev
->num_attrs
; ++i
)
5679 info_ptr
= read_attribute (&die
->attrs
[i
], &abbrev
->attrs
[i
],
5680 abfd
, info_ptr
, cu
);
5682 /* If this attribute is an absolute reference to a different
5683 compilation unit, make sure that compilation unit is loaded
5685 if (die
->attrs
[i
].form
== DW_FORM_ref_addr
5686 && (DW_ADDR (&die
->attrs
[i
]) < cu
->header
.offset
5687 || (DW_ADDR (&die
->attrs
[i
])
5688 >= cu
->header
.offset
+ cu
->header
.length
)))
5690 struct dwarf2_per_cu_data
*per_cu
;
5691 per_cu
= dwarf2_find_containing_comp_unit (DW_ADDR (&die
->attrs
[i
]),
5694 /* Mark the dependence relation so that we don't flush PER_CU
5696 dwarf2_add_dependence (cu
, per_cu
);
5698 /* If it's already on the queue, we have nothing to do. */
5702 /* If the compilation unit is already loaded, just mark it as
5704 if (per_cu
->cu
!= NULL
)
5706 per_cu
->cu
->last_used
= 0;
5710 /* Add it to the queue. */
5711 queue_comp_unit (per_cu
);
5716 *has_children
= abbrev
->has_children
;
5720 /* Read an attribute value described by an attribute form. */
5723 read_attribute_value (struct attribute
*attr
, unsigned form
,
5724 bfd
*abfd
, gdb_byte
*info_ptr
,
5725 struct dwarf2_cu
*cu
)
5727 struct comp_unit_head
*cu_header
= &cu
->header
;
5728 unsigned int bytes_read
;
5729 struct dwarf_block
*blk
;
5735 case DW_FORM_ref_addr
:
5736 DW_ADDR (attr
) = read_address (abfd
, info_ptr
, cu
, &bytes_read
);
5737 info_ptr
+= bytes_read
;
5739 case DW_FORM_block2
:
5740 blk
= dwarf_alloc_block (cu
);
5741 blk
->size
= read_2_bytes (abfd
, info_ptr
);
5743 blk
->data
= read_n_bytes (abfd
, info_ptr
, blk
->size
);
5744 info_ptr
+= blk
->size
;
5745 DW_BLOCK (attr
) = blk
;
5747 case DW_FORM_block4
:
5748 blk
= dwarf_alloc_block (cu
);
5749 blk
->size
= read_4_bytes (abfd
, info_ptr
);
5751 blk
->data
= read_n_bytes (abfd
, info_ptr
, blk
->size
);
5752 info_ptr
+= blk
->size
;
5753 DW_BLOCK (attr
) = blk
;
5756 DW_UNSND (attr
) = read_2_bytes (abfd
, info_ptr
);
5760 DW_UNSND (attr
) = read_4_bytes (abfd
, info_ptr
);
5764 DW_UNSND (attr
) = read_8_bytes (abfd
, info_ptr
);
5767 case DW_FORM_string
:
5768 DW_STRING (attr
) = read_string (abfd
, info_ptr
, &bytes_read
);
5769 info_ptr
+= bytes_read
;
5772 DW_STRING (attr
) = read_indirect_string (abfd
, info_ptr
, cu_header
,
5774 info_ptr
+= bytes_read
;
5777 blk
= dwarf_alloc_block (cu
);
5778 blk
->size
= read_unsigned_leb128 (abfd
, info_ptr
, &bytes_read
);
5779 info_ptr
+= bytes_read
;
5780 blk
->data
= read_n_bytes (abfd
, info_ptr
, blk
->size
);
5781 info_ptr
+= blk
->size
;
5782 DW_BLOCK (attr
) = blk
;
5784 case DW_FORM_block1
:
5785 blk
= dwarf_alloc_block (cu
);
5786 blk
->size
= read_1_byte (abfd
, info_ptr
);
5788 blk
->data
= read_n_bytes (abfd
, info_ptr
, blk
->size
);
5789 info_ptr
+= blk
->size
;
5790 DW_BLOCK (attr
) = blk
;
5793 DW_UNSND (attr
) = read_1_byte (abfd
, info_ptr
);
5797 DW_UNSND (attr
) = read_1_byte (abfd
, info_ptr
);
5801 DW_SND (attr
) = read_signed_leb128 (abfd
, info_ptr
, &bytes_read
);
5802 info_ptr
+= bytes_read
;
5805 DW_UNSND (attr
) = read_unsigned_leb128 (abfd
, info_ptr
, &bytes_read
);
5806 info_ptr
+= bytes_read
;
5809 DW_ADDR (attr
) = cu
->header
.offset
+ read_1_byte (abfd
, info_ptr
);
5813 DW_ADDR (attr
) = cu
->header
.offset
+ read_2_bytes (abfd
, info_ptr
);
5817 DW_ADDR (attr
) = cu
->header
.offset
+ read_4_bytes (abfd
, info_ptr
);
5821 DW_ADDR (attr
) = cu
->header
.offset
+ read_8_bytes (abfd
, info_ptr
);
5824 case DW_FORM_ref_udata
:
5825 DW_ADDR (attr
) = (cu
->header
.offset
5826 + read_unsigned_leb128 (abfd
, info_ptr
, &bytes_read
));
5827 info_ptr
+= bytes_read
;
5829 case DW_FORM_indirect
:
5830 form
= read_unsigned_leb128 (abfd
, info_ptr
, &bytes_read
);
5831 info_ptr
+= bytes_read
;
5832 info_ptr
= read_attribute_value (attr
, form
, abfd
, info_ptr
, cu
);
5835 error (_("Dwarf Error: Cannot handle %s in DWARF reader [in module %s]"),
5836 dwarf_form_name (form
),
5837 bfd_get_filename (abfd
));
5842 /* Read an attribute described by an abbreviated attribute. */
5845 read_attribute (struct attribute
*attr
, struct attr_abbrev
*abbrev
,
5846 bfd
*abfd
, gdb_byte
*info_ptr
, struct dwarf2_cu
*cu
)
5848 attr
->name
= abbrev
->name
;
5849 return read_attribute_value (attr
, abbrev
->form
, abfd
, info_ptr
, cu
);
5852 /* read dwarf information from a buffer */
5855 read_1_byte (bfd
*abfd
, gdb_byte
*buf
)
5857 return bfd_get_8 (abfd
, buf
);
5861 read_1_signed_byte (bfd
*abfd
, gdb_byte
*buf
)
5863 return bfd_get_signed_8 (abfd
, buf
);
5867 read_2_bytes (bfd
*abfd
, gdb_byte
*buf
)
5869 return bfd_get_16 (abfd
, buf
);
5873 read_2_signed_bytes (bfd
*abfd
, gdb_byte
*buf
)
5875 return bfd_get_signed_16 (abfd
, buf
);
5879 read_4_bytes (bfd
*abfd
, gdb_byte
*buf
)
5881 return bfd_get_32 (abfd
, buf
);
5885 read_4_signed_bytes (bfd
*abfd
, gdb_byte
*buf
)
5887 return bfd_get_signed_32 (abfd
, buf
);
5890 static unsigned long
5891 read_8_bytes (bfd
*abfd
, gdb_byte
*buf
)
5893 return bfd_get_64 (abfd
, buf
);
5897 read_address (bfd
*abfd
, gdb_byte
*buf
, struct dwarf2_cu
*cu
,
5898 unsigned int *bytes_read
)
5900 struct comp_unit_head
*cu_header
= &cu
->header
;
5901 CORE_ADDR retval
= 0;
5903 if (cu_header
->signed_addr_p
)
5905 switch (cu_header
->addr_size
)
5908 retval
= bfd_get_signed_16 (abfd
, buf
);
5911 retval
= bfd_get_signed_32 (abfd
, buf
);
5914 retval
= bfd_get_signed_64 (abfd
, buf
);
5917 internal_error (__FILE__
, __LINE__
,
5918 _("read_address: bad switch, signed [in module %s]"),
5919 bfd_get_filename (abfd
));
5924 switch (cu_header
->addr_size
)
5927 retval
= bfd_get_16 (abfd
, buf
);
5930 retval
= bfd_get_32 (abfd
, buf
);
5933 retval
= bfd_get_64 (abfd
, buf
);
5936 internal_error (__FILE__
, __LINE__
,
5937 _("read_address: bad switch, unsigned [in module %s]"),
5938 bfd_get_filename (abfd
));
5942 *bytes_read
= cu_header
->addr_size
;
5946 /* Read the initial length from a section. The (draft) DWARF 3
5947 specification allows the initial length to take up either 4 bytes
5948 or 12 bytes. If the first 4 bytes are 0xffffffff, then the next 8
5949 bytes describe the length and all offsets will be 8 bytes in length
5952 An older, non-standard 64-bit format is also handled by this
5953 function. The older format in question stores the initial length
5954 as an 8-byte quantity without an escape value. Lengths greater
5955 than 2^32 aren't very common which means that the initial 4 bytes
5956 is almost always zero. Since a length value of zero doesn't make
5957 sense for the 32-bit format, this initial zero can be considered to
5958 be an escape value which indicates the presence of the older 64-bit
5959 format. As written, the code can't detect (old format) lengths
5960 greater than 4GB. If it becomes necessary to handle lengths
5961 somewhat larger than 4GB, we could allow other small values (such
5962 as the non-sensical values of 1, 2, and 3) to also be used as
5963 escape values indicating the presence of the old format.
5965 The value returned via bytes_read should be used to increment the
5966 relevant pointer after calling read_initial_length().
5968 As a side effect, this function sets the fields initial_length_size
5969 and offset_size in cu_header to the values appropriate for the
5970 length field. (The format of the initial length field determines
5971 the width of file offsets to be fetched later with read_offset().)
5973 [ Note: read_initial_length() and read_offset() are based on the
5974 document entitled "DWARF Debugging Information Format", revision
5975 3, draft 8, dated November 19, 2001. This document was obtained
5978 http://reality.sgiweb.org/davea/dwarf3-draft8-011125.pdf
5980 This document is only a draft and is subject to change. (So beware.)
5982 Details regarding the older, non-standard 64-bit format were
5983 determined empirically by examining 64-bit ELF files produced by
5984 the SGI toolchain on an IRIX 6.5 machine.
5986 - Kevin, July 16, 2002
5990 read_initial_length (bfd
*abfd
, gdb_byte
*buf
, struct comp_unit_head
*cu_header
,
5991 unsigned int *bytes_read
)
5993 LONGEST length
= bfd_get_32 (abfd
, buf
);
5995 if (length
== 0xffffffff)
5997 length
= bfd_get_64 (abfd
, buf
+ 4);
6000 else if (length
== 0)
6002 /* Handle the (non-standard) 64-bit DWARF2 format used by IRIX. */
6003 length
= bfd_get_64 (abfd
, buf
);
6013 gdb_assert (cu_header
->initial_length_size
== 0
6014 || cu_header
->initial_length_size
== 4
6015 || cu_header
->initial_length_size
== 8
6016 || cu_header
->initial_length_size
== 12);
6018 if (cu_header
->initial_length_size
!= 0
6019 && cu_header
->initial_length_size
!= *bytes_read
)
6020 complaint (&symfile_complaints
,
6021 _("intermixed 32-bit and 64-bit DWARF sections"));
6023 cu_header
->initial_length_size
= *bytes_read
;
6024 cu_header
->offset_size
= (*bytes_read
== 4) ? 4 : 8;
6030 /* Read an offset from the data stream. The size of the offset is
6031 given by cu_header->offset_size. */
6034 read_offset (bfd
*abfd
, gdb_byte
*buf
, const struct comp_unit_head
*cu_header
,
6035 unsigned int *bytes_read
)
6039 switch (cu_header
->offset_size
)
6042 retval
= bfd_get_32 (abfd
, buf
);
6046 retval
= bfd_get_64 (abfd
, buf
);
6050 internal_error (__FILE__
, __LINE__
,
6051 _("read_offset: bad switch [in module %s]"),
6052 bfd_get_filename (abfd
));
6059 read_n_bytes (bfd
*abfd
, gdb_byte
*buf
, unsigned int size
)
6061 /* If the size of a host char is 8 bits, we can return a pointer
6062 to the buffer, otherwise we have to copy the data to a buffer
6063 allocated on the temporary obstack. */
6064 gdb_assert (HOST_CHAR_BIT
== 8);
6069 read_string (bfd
*abfd
, gdb_byte
*buf
, unsigned int *bytes_read_ptr
)
6071 /* If the size of a host char is 8 bits, we can return a pointer
6072 to the string, otherwise we have to copy the string to a buffer
6073 allocated on the temporary obstack. */
6074 gdb_assert (HOST_CHAR_BIT
== 8);
6077 *bytes_read_ptr
= 1;
6080 *bytes_read_ptr
= strlen ((char *) buf
) + 1;
6081 return (char *) buf
;
6085 read_indirect_string (bfd
*abfd
, gdb_byte
*buf
,
6086 const struct comp_unit_head
*cu_header
,
6087 unsigned int *bytes_read_ptr
)
6089 LONGEST str_offset
= read_offset (abfd
, buf
, cu_header
,
6092 if (dwarf2_per_objfile
->str_buffer
== NULL
)
6094 error (_("DW_FORM_strp used without .debug_str section [in module %s]"),
6095 bfd_get_filename (abfd
));
6098 if (str_offset
>= dwarf2_per_objfile
->str_size
)
6100 error (_("DW_FORM_strp pointing outside of .debug_str section [in module %s]"),
6101 bfd_get_filename (abfd
));
6104 gdb_assert (HOST_CHAR_BIT
== 8);
6105 if (dwarf2_per_objfile
->str_buffer
[str_offset
] == '\0')
6107 return (char *) (dwarf2_per_objfile
->str_buffer
+ str_offset
);
6110 static unsigned long
6111 read_unsigned_leb128 (bfd
*abfd
, gdb_byte
*buf
, unsigned int *bytes_read_ptr
)
6113 unsigned long result
;
6114 unsigned int num_read
;
6124 byte
= bfd_get_8 (abfd
, buf
);
6127 result
|= ((unsigned long)(byte
& 127) << shift
);
6128 if ((byte
& 128) == 0)
6134 *bytes_read_ptr
= num_read
;
6139 read_signed_leb128 (bfd
*abfd
, gdb_byte
*buf
, unsigned int *bytes_read_ptr
)
6142 int i
, shift
, num_read
;
6151 byte
= bfd_get_8 (abfd
, buf
);
6154 result
|= ((long)(byte
& 127) << shift
);
6156 if ((byte
& 128) == 0)
6161 if ((shift
< 8 * sizeof (result
)) && (byte
& 0x40))
6162 result
|= -(((long)1) << shift
);
6163 *bytes_read_ptr
= num_read
;
6167 /* Return a pointer to just past the end of an LEB128 number in BUF. */
6170 skip_leb128 (bfd
*abfd
, gdb_byte
*buf
)
6176 byte
= bfd_get_8 (abfd
, buf
);
6178 if ((byte
& 128) == 0)
6184 set_cu_language (unsigned int lang
, struct dwarf2_cu
*cu
)
6190 cu
->language
= language_c
;
6192 case DW_LANG_C_plus_plus
:
6193 cu
->language
= language_cplus
;
6195 case DW_LANG_Fortran77
:
6196 case DW_LANG_Fortran90
:
6197 case DW_LANG_Fortran95
:
6198 cu
->language
= language_fortran
;
6200 case DW_LANG_Mips_Assembler
:
6201 cu
->language
= language_asm
;
6204 cu
->language
= language_java
;
6208 cu
->language
= language_ada
;
6210 case DW_LANG_Modula2
:
6211 cu
->language
= language_m2
;
6213 case DW_LANG_Cobol74
:
6214 case DW_LANG_Cobol85
:
6215 case DW_LANG_Pascal83
:
6217 cu
->language
= language_minimal
;
6220 cu
->language_defn
= language_def (cu
->language
);
6223 /* Return the named attribute or NULL if not there. */
6225 static struct attribute
*
6226 dwarf2_attr (struct die_info
*die
, unsigned int name
, struct dwarf2_cu
*cu
)
6229 struct attribute
*spec
= NULL
;
6231 for (i
= 0; i
< die
->num_attrs
; ++i
)
6233 if (die
->attrs
[i
].name
== name
)
6234 return &die
->attrs
[i
];
6235 if (die
->attrs
[i
].name
== DW_AT_specification
6236 || die
->attrs
[i
].name
== DW_AT_abstract_origin
)
6237 spec
= &die
->attrs
[i
];
6241 return dwarf2_attr (follow_die_ref (die
, spec
, cu
), name
, cu
);
6246 /* Return non-zero iff the attribute NAME is defined for the given DIE,
6247 and holds a non-zero value. This function should only be used for
6248 DW_FORM_flag attributes. */
6251 dwarf2_flag_true_p (struct die_info
*die
, unsigned name
, struct dwarf2_cu
*cu
)
6253 struct attribute
*attr
= dwarf2_attr (die
, name
, cu
);
6255 return (attr
&& DW_UNSND (attr
));
6259 die_is_declaration (struct die_info
*die
, struct dwarf2_cu
*cu
)
6261 /* A DIE is a declaration if it has a DW_AT_declaration attribute
6262 which value is non-zero. However, we have to be careful with
6263 DIEs having a DW_AT_specification attribute, because dwarf2_attr()
6264 (via dwarf2_flag_true_p) follows this attribute. So we may
6265 end up accidently finding a declaration attribute that belongs
6266 to a different DIE referenced by the specification attribute,
6267 even though the given DIE does not have a declaration attribute. */
6268 return (dwarf2_flag_true_p (die
, DW_AT_declaration
, cu
)
6269 && dwarf2_attr (die
, DW_AT_specification
, cu
) == NULL
);
6272 /* Return the die giving the specification for DIE, if there is
6275 static struct die_info
*
6276 die_specification (struct die_info
*die
, struct dwarf2_cu
*cu
)
6278 struct attribute
*spec_attr
= dwarf2_attr (die
, DW_AT_specification
, cu
);
6280 if (spec_attr
== NULL
)
6283 return follow_die_ref (die
, spec_attr
, cu
);
6286 /* Free the line_header structure *LH, and any arrays and strings it
6289 free_line_header (struct line_header
*lh
)
6291 if (lh
->standard_opcode_lengths
)
6292 xfree (lh
->standard_opcode_lengths
);
6294 /* Remember that all the lh->file_names[i].name pointers are
6295 pointers into debug_line_buffer, and don't need to be freed. */
6297 xfree (lh
->file_names
);
6299 /* Similarly for the include directory names. */
6300 if (lh
->include_dirs
)
6301 xfree (lh
->include_dirs
);
6307 /* Add an entry to LH's include directory table. */
6309 add_include_dir (struct line_header
*lh
, char *include_dir
)
6311 /* Grow the array if necessary. */
6312 if (lh
->include_dirs_size
== 0)
6314 lh
->include_dirs_size
= 1; /* for testing */
6315 lh
->include_dirs
= xmalloc (lh
->include_dirs_size
6316 * sizeof (*lh
->include_dirs
));
6318 else if (lh
->num_include_dirs
>= lh
->include_dirs_size
)
6320 lh
->include_dirs_size
*= 2;
6321 lh
->include_dirs
= xrealloc (lh
->include_dirs
,
6322 (lh
->include_dirs_size
6323 * sizeof (*lh
->include_dirs
)));
6326 lh
->include_dirs
[lh
->num_include_dirs
++] = include_dir
;
6330 /* Add an entry to LH's file name table. */
6332 add_file_name (struct line_header
*lh
,
6334 unsigned int dir_index
,
6335 unsigned int mod_time
,
6336 unsigned int length
)
6338 struct file_entry
*fe
;
6340 /* Grow the array if necessary. */
6341 if (lh
->file_names_size
== 0)
6343 lh
->file_names_size
= 1; /* for testing */
6344 lh
->file_names
= xmalloc (lh
->file_names_size
6345 * sizeof (*lh
->file_names
));
6347 else if (lh
->num_file_names
>= lh
->file_names_size
)
6349 lh
->file_names_size
*= 2;
6350 lh
->file_names
= xrealloc (lh
->file_names
,
6351 (lh
->file_names_size
6352 * sizeof (*lh
->file_names
)));
6355 fe
= &lh
->file_names
[lh
->num_file_names
++];
6357 fe
->dir_index
= dir_index
;
6358 fe
->mod_time
= mod_time
;
6359 fe
->length
= length
;
6364 /* Read the statement program header starting at OFFSET in
6365 .debug_line, according to the endianness of ABFD. Return a pointer
6366 to a struct line_header, allocated using xmalloc.
6368 NOTE: the strings in the include directory and file name tables of
6369 the returned object point into debug_line_buffer, and must not be
6371 static struct line_header
*
6372 dwarf_decode_line_header (unsigned int offset
, bfd
*abfd
,
6373 struct dwarf2_cu
*cu
)
6375 struct cleanup
*back_to
;
6376 struct line_header
*lh
;
6378 unsigned int bytes_read
;
6380 char *cur_dir
, *cur_file
;
6382 if (dwarf2_per_objfile
->line_buffer
== NULL
)
6384 complaint (&symfile_complaints
, _("missing .debug_line section"));
6388 /* Make sure that at least there's room for the total_length field.
6389 That could be 12 bytes long, but we're just going to fudge that. */
6390 if (offset
+ 4 >= dwarf2_per_objfile
->line_size
)
6392 dwarf2_statement_list_fits_in_line_number_section_complaint ();
6396 lh
= xmalloc (sizeof (*lh
));
6397 memset (lh
, 0, sizeof (*lh
));
6398 back_to
= make_cleanup ((make_cleanup_ftype
*) free_line_header
,
6401 line_ptr
= dwarf2_per_objfile
->line_buffer
+ offset
;
6403 /* Read in the header. */
6405 read_initial_length (abfd
, line_ptr
, &cu
->header
, &bytes_read
);
6406 line_ptr
+= bytes_read
;
6407 if (line_ptr
+ lh
->total_length
> (dwarf2_per_objfile
->line_buffer
6408 + dwarf2_per_objfile
->line_size
))
6410 dwarf2_statement_list_fits_in_line_number_section_complaint ();
6413 lh
->statement_program_end
= line_ptr
+ lh
->total_length
;
6414 lh
->version
= read_2_bytes (abfd
, line_ptr
);
6416 lh
->header_length
= read_offset (abfd
, line_ptr
, &cu
->header
, &bytes_read
);
6417 line_ptr
+= bytes_read
;
6418 lh
->minimum_instruction_length
= read_1_byte (abfd
, line_ptr
);
6420 lh
->default_is_stmt
= read_1_byte (abfd
, line_ptr
);
6422 lh
->line_base
= read_1_signed_byte (abfd
, line_ptr
);
6424 lh
->line_range
= read_1_byte (abfd
, line_ptr
);
6426 lh
->opcode_base
= read_1_byte (abfd
, line_ptr
);
6428 lh
->standard_opcode_lengths
6429 = xmalloc (lh
->opcode_base
* sizeof (lh
->standard_opcode_lengths
[0]));
6431 lh
->standard_opcode_lengths
[0] = 1; /* This should never be used anyway. */
6432 for (i
= 1; i
< lh
->opcode_base
; ++i
)
6434 lh
->standard_opcode_lengths
[i
] = read_1_byte (abfd
, line_ptr
);
6438 /* Read directory table. */
6439 while ((cur_dir
= read_string (abfd
, line_ptr
, &bytes_read
)) != NULL
)
6441 line_ptr
+= bytes_read
;
6442 add_include_dir (lh
, cur_dir
);
6444 line_ptr
+= bytes_read
;
6446 /* Read file name table. */
6447 while ((cur_file
= read_string (abfd
, line_ptr
, &bytes_read
)) != NULL
)
6449 unsigned int dir_index
, mod_time
, length
;
6451 line_ptr
+= bytes_read
;
6452 dir_index
= read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
6453 line_ptr
+= bytes_read
;
6454 mod_time
= read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
6455 line_ptr
+= bytes_read
;
6456 length
= read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
6457 line_ptr
+= bytes_read
;
6459 add_file_name (lh
, cur_file
, dir_index
, mod_time
, length
);
6461 line_ptr
+= bytes_read
;
6462 lh
->statement_program_start
= line_ptr
;
6464 if (line_ptr
> (dwarf2_per_objfile
->line_buffer
6465 + dwarf2_per_objfile
->line_size
))
6466 complaint (&symfile_complaints
,
6467 _("line number info header doesn't fit in `.debug_line' section"));
6469 discard_cleanups (back_to
);
6473 /* This function exists to work around a bug in certain compilers
6474 (particularly GCC 2.95), in which the first line number marker of a
6475 function does not show up until after the prologue, right before
6476 the second line number marker. This function shifts ADDRESS down
6477 to the beginning of the function if necessary, and is called on
6478 addresses passed to record_line. */
6481 check_cu_functions (CORE_ADDR address
, struct dwarf2_cu
*cu
)
6483 struct function_range
*fn
;
6485 /* Find the function_range containing address. */
6490 cu
->cached_fn
= cu
->first_fn
;
6494 if (fn
->lowpc
<= address
&& fn
->highpc
> address
)
6500 while (fn
&& fn
!= cu
->cached_fn
)
6501 if (fn
->lowpc
<= address
&& fn
->highpc
> address
)
6511 if (address
!= fn
->lowpc
)
6512 complaint (&symfile_complaints
,
6513 _("misplaced first line number at 0x%lx for '%s'"),
6514 (unsigned long) address
, fn
->name
);
6519 /* Decode the Line Number Program (LNP) for the given line_header
6520 structure and CU. The actual information extracted and the type
6521 of structures created from the LNP depends on the value of PST.
6523 1. If PST is NULL, then this procedure uses the data from the program
6524 to create all necessary symbol tables, and their linetables.
6525 The compilation directory of the file is passed in COMP_DIR,
6526 and must not be NULL.
6528 2. If PST is not NULL, this procedure reads the program to determine
6529 the list of files included by the unit represented by PST, and
6530 builds all the associated partial symbol tables. In this case,
6531 the value of COMP_DIR is ignored, and can thus be NULL (the COMP_DIR
6532 is not used to compute the full name of the symtab, and therefore
6533 omitting it when building the partial symtab does not introduce
6534 the potential for inconsistency - a partial symtab and its associated
6535 symbtab having a different fullname -). */
6538 dwarf_decode_lines (struct line_header
*lh
, char *comp_dir
, bfd
*abfd
,
6539 struct dwarf2_cu
*cu
, struct partial_symtab
*pst
)
6543 unsigned int bytes_read
;
6544 unsigned char op_code
, extended_op
, adj_opcode
;
6546 struct objfile
*objfile
= cu
->objfile
;
6547 const int decode_for_pst_p
= (pst
!= NULL
);
6549 baseaddr
= ANOFFSET (objfile
->section_offsets
, SECT_OFF_TEXT (objfile
));
6551 line_ptr
= lh
->statement_program_start
;
6552 line_end
= lh
->statement_program_end
;
6554 /* Read the statement sequences until there's nothing left. */
6555 while (line_ptr
< line_end
)
6557 /* state machine registers */
6558 CORE_ADDR address
= 0;
6559 unsigned int file
= 1;
6560 unsigned int line
= 1;
6561 unsigned int column
= 0;
6562 int is_stmt
= lh
->default_is_stmt
;
6563 int basic_block
= 0;
6564 int end_sequence
= 0;
6566 if (!decode_for_pst_p
&& lh
->num_file_names
>= file
)
6568 /* Start a subfile for the current file of the state machine. */
6569 /* lh->include_dirs and lh->file_names are 0-based, but the
6570 directory and file name numbers in the statement program
6572 struct file_entry
*fe
= &lh
->file_names
[file
- 1];
6576 dir
= lh
->include_dirs
[fe
->dir_index
- 1];
6578 dwarf2_start_subfile (fe
->name
, dir
, comp_dir
);
6581 /* Decode the table. */
6582 while (!end_sequence
)
6584 op_code
= read_1_byte (abfd
, line_ptr
);
6587 if (op_code
>= lh
->opcode_base
)
6589 /* Special operand. */
6590 adj_opcode
= op_code
- lh
->opcode_base
;
6591 address
+= (adj_opcode
/ lh
->line_range
)
6592 * lh
->minimum_instruction_length
;
6593 line
+= lh
->line_base
+ (adj_opcode
% lh
->line_range
);
6594 lh
->file_names
[file
- 1].included_p
= 1;
6595 if (!decode_for_pst_p
)
6597 /* Append row to matrix using current values. */
6598 record_line (current_subfile
, line
,
6599 check_cu_functions (address
, cu
));
6603 else switch (op_code
)
6605 case DW_LNS_extended_op
:
6606 read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
6607 line_ptr
+= bytes_read
;
6608 extended_op
= read_1_byte (abfd
, line_ptr
);
6610 switch (extended_op
)
6612 case DW_LNE_end_sequence
:
6614 lh
->file_names
[file
- 1].included_p
= 1;
6615 if (!decode_for_pst_p
)
6616 record_line (current_subfile
, 0, address
);
6618 case DW_LNE_set_address
:
6619 address
= read_address (abfd
, line_ptr
, cu
, &bytes_read
);
6620 line_ptr
+= bytes_read
;
6621 address
+= baseaddr
;
6623 case DW_LNE_define_file
:
6626 unsigned int dir_index
, mod_time
, length
;
6628 cur_file
= read_string (abfd
, line_ptr
, &bytes_read
);
6629 line_ptr
+= bytes_read
;
6631 read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
6632 line_ptr
+= bytes_read
;
6634 read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
6635 line_ptr
+= bytes_read
;
6637 read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
6638 line_ptr
+= bytes_read
;
6639 add_file_name (lh
, cur_file
, dir_index
, mod_time
, length
);
6643 complaint (&symfile_complaints
,
6644 _("mangled .debug_line section"));
6649 lh
->file_names
[file
- 1].included_p
= 1;
6650 if (!decode_for_pst_p
)
6651 record_line (current_subfile
, line
,
6652 check_cu_functions (address
, cu
));
6655 case DW_LNS_advance_pc
:
6656 address
+= lh
->minimum_instruction_length
6657 * read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
6658 line_ptr
+= bytes_read
;
6660 case DW_LNS_advance_line
:
6661 line
+= read_signed_leb128 (abfd
, line_ptr
, &bytes_read
);
6662 line_ptr
+= bytes_read
;
6664 case DW_LNS_set_file
:
6666 /* The arrays lh->include_dirs and lh->file_names are
6667 0-based, but the directory and file name numbers in
6668 the statement program are 1-based. */
6669 struct file_entry
*fe
;
6672 file
= read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
6673 line_ptr
+= bytes_read
;
6674 fe
= &lh
->file_names
[file
- 1];
6676 dir
= lh
->include_dirs
[fe
->dir_index
- 1];
6678 if (!decode_for_pst_p
)
6679 dwarf2_start_subfile (fe
->name
, dir
, comp_dir
);
6682 case DW_LNS_set_column
:
6683 column
= read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
6684 line_ptr
+= bytes_read
;
6686 case DW_LNS_negate_stmt
:
6687 is_stmt
= (!is_stmt
);
6689 case DW_LNS_set_basic_block
:
6692 /* Add to the address register of the state machine the
6693 address increment value corresponding to special opcode
6694 255. I.e., this value is scaled by the minimum
6695 instruction length since special opcode 255 would have
6696 scaled the the increment. */
6697 case DW_LNS_const_add_pc
:
6698 address
+= (lh
->minimum_instruction_length
6699 * ((255 - lh
->opcode_base
) / lh
->line_range
));
6701 case DW_LNS_fixed_advance_pc
:
6702 address
+= read_2_bytes (abfd
, line_ptr
);
6707 /* Unknown standard opcode, ignore it. */
6710 for (i
= 0; i
< lh
->standard_opcode_lengths
[op_code
]; i
++)
6712 (void) read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
6713 line_ptr
+= bytes_read
;
6720 if (decode_for_pst_p
)
6724 /* Now that we're done scanning the Line Header Program, we can
6725 create the psymtab of each included file. */
6726 for (file_index
= 0; file_index
< lh
->num_file_names
; file_index
++)
6727 if (lh
->file_names
[file_index
].included_p
== 1)
6729 const struct file_entry fe
= lh
->file_names
[file_index
];
6730 char *include_name
= fe
.name
;
6731 char *dir_name
= NULL
;
6732 char *pst_filename
= pst
->filename
;
6735 dir_name
= lh
->include_dirs
[fe
.dir_index
- 1];
6737 if (!IS_ABSOLUTE_PATH (include_name
) && dir_name
!= NULL
)
6739 include_name
= concat (dir_name
, SLASH_STRING
,
6740 include_name
, (char *)NULL
);
6741 make_cleanup (xfree
, include_name
);
6744 if (!IS_ABSOLUTE_PATH (pst_filename
) && pst
->dirname
!= NULL
)
6746 pst_filename
= concat (pst
->dirname
, SLASH_STRING
,
6747 pst_filename
, (char *)NULL
);
6748 make_cleanup (xfree
, pst_filename
);
6751 if (strcmp (include_name
, pst_filename
) != 0)
6752 dwarf2_create_include_psymtab (include_name
, pst
, objfile
);
6757 /* Start a subfile for DWARF. FILENAME is the name of the file and
6758 DIRNAME the name of the source directory which contains FILENAME
6759 or NULL if not known. COMP_DIR is the compilation directory for the
6760 linetable's compilation unit or NULL if not known.
6761 This routine tries to keep line numbers from identical absolute and
6762 relative file names in a common subfile.
6764 Using the `list' example from the GDB testsuite, which resides in
6765 /srcdir and compiling it with Irix6.2 cc in /compdir using a filename
6766 of /srcdir/list0.c yields the following debugging information for list0.c:
6768 DW_AT_name: /srcdir/list0.c
6769 DW_AT_comp_dir: /compdir
6770 files.files[0].name: list0.h
6771 files.files[0].dir: /srcdir
6772 files.files[1].name: list0.c
6773 files.files[1].dir: /srcdir
6775 The line number information for list0.c has to end up in a single
6776 subfile, so that `break /srcdir/list0.c:1' works as expected.
6777 start_subfile will ensure that this happens provided that we pass the
6778 concatenation of files.files[1].dir and files.files[1].name as the
6782 dwarf2_start_subfile (char *filename
, char *dirname
, char *comp_dir
)
6786 /* While reading the DIEs, we call start_symtab(DW_AT_name, DW_AT_comp_dir).
6787 `start_symtab' will always pass the contents of DW_AT_comp_dir as
6788 second argument to start_subfile. To be consistent, we do the
6789 same here. In order not to lose the line information directory,
6790 we concatenate it to the filename when it makes sense.
6791 Note that the Dwarf3 standard says (speaking of filenames in line
6792 information): ``The directory index is ignored for file names
6793 that represent full path names''. Thus ignoring dirname in the
6794 `else' branch below isn't an issue. */
6796 if (!IS_ABSOLUTE_PATH (filename
) && dirname
!= NULL
)
6797 fullname
= concat (dirname
, SLASH_STRING
, filename
, (char *)NULL
);
6799 fullname
= filename
;
6801 start_subfile (fullname
, comp_dir
);
6803 if (fullname
!= filename
)
6808 var_decode_location (struct attribute
*attr
, struct symbol
*sym
,
6809 struct dwarf2_cu
*cu
)
6811 struct objfile
*objfile
= cu
->objfile
;
6812 struct comp_unit_head
*cu_header
= &cu
->header
;
6814 /* NOTE drow/2003-01-30: There used to be a comment and some special
6815 code here to turn a symbol with DW_AT_external and a
6816 SYMBOL_VALUE_ADDRESS of 0 into a LOC_UNRESOLVED symbol. This was
6817 necessary for platforms (maybe Alpha, certainly PowerPC GNU/Linux
6818 with some versions of binutils) where shared libraries could have
6819 relocations against symbols in their debug information - the
6820 minimal symbol would have the right address, but the debug info
6821 would not. It's no longer necessary, because we will explicitly
6822 apply relocations when we read in the debug information now. */
6824 /* A DW_AT_location attribute with no contents indicates that a
6825 variable has been optimized away. */
6826 if (attr_form_is_block (attr
) && DW_BLOCK (attr
)->size
== 0)
6828 SYMBOL_CLASS (sym
) = LOC_OPTIMIZED_OUT
;
6832 /* Handle one degenerate form of location expression specially, to
6833 preserve GDB's previous behavior when section offsets are
6834 specified. If this is just a DW_OP_addr then mark this symbol
6837 if (attr_form_is_block (attr
)
6838 && DW_BLOCK (attr
)->size
== 1 + cu_header
->addr_size
6839 && DW_BLOCK (attr
)->data
[0] == DW_OP_addr
)
6843 SYMBOL_VALUE_ADDRESS (sym
) =
6844 read_address (objfile
->obfd
, DW_BLOCK (attr
)->data
+ 1, cu
, &dummy
);
6845 fixup_symbol_section (sym
, objfile
);
6846 SYMBOL_VALUE_ADDRESS (sym
) += ANOFFSET (objfile
->section_offsets
,
6847 SYMBOL_SECTION (sym
));
6848 SYMBOL_CLASS (sym
) = LOC_STATIC
;
6852 /* NOTE drow/2002-01-30: It might be worthwhile to have a static
6853 expression evaluator, and use LOC_COMPUTED only when necessary
6854 (i.e. when the value of a register or memory location is
6855 referenced, or a thread-local block, etc.). Then again, it might
6856 not be worthwhile. I'm assuming that it isn't unless performance
6857 or memory numbers show me otherwise. */
6859 dwarf2_symbol_mark_computed (attr
, sym
, cu
);
6860 SYMBOL_CLASS (sym
) = LOC_COMPUTED
;
6863 /* Given a pointer to a DWARF information entry, figure out if we need
6864 to make a symbol table entry for it, and if so, create a new entry
6865 and return a pointer to it.
6866 If TYPE is NULL, determine symbol type from the die, otherwise
6867 used the passed type. */
6869 static struct symbol
*
6870 new_symbol (struct die_info
*die
, struct type
*type
, struct dwarf2_cu
*cu
)
6872 struct objfile
*objfile
= cu
->objfile
;
6873 struct symbol
*sym
= NULL
;
6875 struct attribute
*attr
= NULL
;
6876 struct attribute
*attr2
= NULL
;
6879 baseaddr
= ANOFFSET (objfile
->section_offsets
, SECT_OFF_TEXT (objfile
));
6881 if (die
->tag
!= DW_TAG_namespace
)
6882 name
= dwarf2_linkage_name (die
, cu
);
6884 name
= TYPE_NAME (type
);
6888 sym
= (struct symbol
*) obstack_alloc (&objfile
->objfile_obstack
,
6889 sizeof (struct symbol
));
6890 OBJSTAT (objfile
, n_syms
++);
6891 memset (sym
, 0, sizeof (struct symbol
));
6893 /* Cache this symbol's name and the name's demangled form (if any). */
6894 SYMBOL_LANGUAGE (sym
) = cu
->language
;
6895 SYMBOL_SET_NAMES (sym
, name
, strlen (name
), objfile
);
6897 /* Default assumptions.
6898 Use the passed type or decode it from the die. */
6899 SYMBOL_DOMAIN (sym
) = VAR_DOMAIN
;
6900 SYMBOL_CLASS (sym
) = LOC_OPTIMIZED_OUT
;
6902 SYMBOL_TYPE (sym
) = type
;
6904 SYMBOL_TYPE (sym
) = die_type (die
, cu
);
6905 attr
= dwarf2_attr (die
, DW_AT_decl_line
, cu
);
6908 SYMBOL_LINE (sym
) = DW_UNSND (attr
);
6913 attr
= dwarf2_attr (die
, DW_AT_low_pc
, cu
);
6916 SYMBOL_VALUE_ADDRESS (sym
) = DW_ADDR (attr
) + baseaddr
;
6918 SYMBOL_CLASS (sym
) = LOC_LABEL
;
6920 case DW_TAG_subprogram
:
6921 /* SYMBOL_BLOCK_VALUE (sym) will be filled in later by
6923 SYMBOL_CLASS (sym
) = LOC_BLOCK
;
6924 attr2
= dwarf2_attr (die
, DW_AT_external
, cu
);
6925 if (attr2
&& (DW_UNSND (attr2
) != 0))
6927 add_symbol_to_list (sym
, &global_symbols
);
6931 add_symbol_to_list (sym
, cu
->list_in_scope
);
6934 case DW_TAG_variable
:
6935 /* Compilation with minimal debug info may result in variables
6936 with missing type entries. Change the misleading `void' type
6937 to something sensible. */
6938 if (TYPE_CODE (SYMBOL_TYPE (sym
)) == TYPE_CODE_VOID
)
6939 SYMBOL_TYPE (sym
) = init_type (TYPE_CODE_INT
,
6940 TARGET_INT_BIT
/ HOST_CHAR_BIT
, 0,
6941 "<variable, no debug info>",
6943 attr
= dwarf2_attr (die
, DW_AT_const_value
, cu
);
6946 dwarf2_const_value (attr
, sym
, cu
);
6947 attr2
= dwarf2_attr (die
, DW_AT_external
, cu
);
6948 if (attr2
&& (DW_UNSND (attr2
) != 0))
6949 add_symbol_to_list (sym
, &global_symbols
);
6951 add_symbol_to_list (sym
, cu
->list_in_scope
);
6954 attr
= dwarf2_attr (die
, DW_AT_location
, cu
);
6957 var_decode_location (attr
, sym
, cu
);
6958 attr2
= dwarf2_attr (die
, DW_AT_external
, cu
);
6959 if (attr2
&& (DW_UNSND (attr2
) != 0))
6960 add_symbol_to_list (sym
, &global_symbols
);
6962 add_symbol_to_list (sym
, cu
->list_in_scope
);
6966 /* We do not know the address of this symbol.
6967 If it is an external symbol and we have type information
6968 for it, enter the symbol as a LOC_UNRESOLVED symbol.
6969 The address of the variable will then be determined from
6970 the minimal symbol table whenever the variable is
6972 attr2
= dwarf2_attr (die
, DW_AT_external
, cu
);
6973 if (attr2
&& (DW_UNSND (attr2
) != 0)
6974 && dwarf2_attr (die
, DW_AT_type
, cu
) != NULL
)
6976 SYMBOL_CLASS (sym
) = LOC_UNRESOLVED
;
6977 add_symbol_to_list (sym
, &global_symbols
);
6981 case DW_TAG_formal_parameter
:
6982 attr
= dwarf2_attr (die
, DW_AT_location
, cu
);
6985 var_decode_location (attr
, sym
, cu
);
6986 /* FIXME drow/2003-07-31: Is LOC_COMPUTED_ARG necessary? */
6987 if (SYMBOL_CLASS (sym
) == LOC_COMPUTED
)
6988 SYMBOL_CLASS (sym
) = LOC_COMPUTED_ARG
;
6990 attr
= dwarf2_attr (die
, DW_AT_const_value
, cu
);
6993 dwarf2_const_value (attr
, sym
, cu
);
6995 add_symbol_to_list (sym
, cu
->list_in_scope
);
6997 case DW_TAG_unspecified_parameters
:
6998 /* From varargs functions; gdb doesn't seem to have any
6999 interest in this information, so just ignore it for now.
7002 case DW_TAG_class_type
:
7003 case DW_TAG_structure_type
:
7004 case DW_TAG_union_type
:
7005 case DW_TAG_set_type
:
7006 case DW_TAG_enumeration_type
:
7007 SYMBOL_CLASS (sym
) = LOC_TYPEDEF
;
7008 SYMBOL_DOMAIN (sym
) = STRUCT_DOMAIN
;
7010 /* Make sure that the symbol includes appropriate enclosing
7011 classes/namespaces in its name. These are calculated in
7012 read_structure_type, and the correct name is saved in
7015 if (cu
->language
== language_cplus
7016 || cu
->language
== language_java
)
7018 struct type
*type
= SYMBOL_TYPE (sym
);
7020 if (TYPE_TAG_NAME (type
) != NULL
)
7022 /* FIXME: carlton/2003-11-10: Should this use
7023 SYMBOL_SET_NAMES instead? (The same problem also
7024 arises further down in this function.) */
7025 /* The type's name is already allocated along with
7026 this objfile, so we don't need to duplicate it
7028 SYMBOL_LINKAGE_NAME (sym
) = TYPE_TAG_NAME (type
);
7033 /* NOTE: carlton/2003-11-10: C++ and Java class symbols shouldn't
7034 really ever be static objects: otherwise, if you try
7035 to, say, break of a class's method and you're in a file
7036 which doesn't mention that class, it won't work unless
7037 the check for all static symbols in lookup_symbol_aux
7038 saves you. See the OtherFileClass tests in
7039 gdb.c++/namespace.exp. */
7041 struct pending
**list_to_add
;
7043 list_to_add
= (cu
->list_in_scope
== &file_symbols
7044 && (cu
->language
== language_cplus
7045 || cu
->language
== language_java
)
7046 ? &global_symbols
: cu
->list_in_scope
);
7048 add_symbol_to_list (sym
, list_to_add
);
7050 /* The semantics of C++ state that "struct foo { ... }" also
7051 defines a typedef for "foo". A Java class declaration also
7052 defines a typedef for the class. Synthesize a typedef symbol
7053 so that "ptype foo" works as expected. */
7054 if (cu
->language
== language_cplus
7055 || cu
->language
== language_java
)
7057 struct symbol
*typedef_sym
= (struct symbol
*)
7058 obstack_alloc (&objfile
->objfile_obstack
,
7059 sizeof (struct symbol
));
7060 *typedef_sym
= *sym
;
7061 SYMBOL_DOMAIN (typedef_sym
) = VAR_DOMAIN
;
7062 /* The symbol's name is already allocated along with
7063 this objfile, so we don't need to duplicate it for
7065 if (TYPE_NAME (SYMBOL_TYPE (sym
)) == 0)
7066 TYPE_NAME (SYMBOL_TYPE (sym
)) = SYMBOL_SEARCH_NAME (sym
);
7067 add_symbol_to_list (typedef_sym
, list_to_add
);
7071 case DW_TAG_typedef
:
7072 if (processing_has_namespace_info
7073 && processing_current_prefix
[0] != '\0')
7075 SYMBOL_LINKAGE_NAME (sym
) = typename_concat (&objfile
->objfile_obstack
,
7076 processing_current_prefix
,
7079 SYMBOL_CLASS (sym
) = LOC_TYPEDEF
;
7080 SYMBOL_DOMAIN (sym
) = VAR_DOMAIN
;
7081 add_symbol_to_list (sym
, cu
->list_in_scope
);
7083 case DW_TAG_base_type
:
7084 case DW_TAG_subrange_type
:
7085 SYMBOL_CLASS (sym
) = LOC_TYPEDEF
;
7086 SYMBOL_DOMAIN (sym
) = VAR_DOMAIN
;
7087 add_symbol_to_list (sym
, cu
->list_in_scope
);
7089 case DW_TAG_enumerator
:
7090 if (processing_has_namespace_info
7091 && processing_current_prefix
[0] != '\0')
7093 SYMBOL_LINKAGE_NAME (sym
) = typename_concat (&objfile
->objfile_obstack
,
7094 processing_current_prefix
,
7097 attr
= dwarf2_attr (die
, DW_AT_const_value
, cu
);
7100 dwarf2_const_value (attr
, sym
, cu
);
7103 /* NOTE: carlton/2003-11-10: See comment above in the
7104 DW_TAG_class_type, etc. block. */
7106 struct pending
**list_to_add
;
7108 list_to_add
= (cu
->list_in_scope
== &file_symbols
7109 && (cu
->language
== language_cplus
7110 || cu
->language
== language_java
)
7111 ? &global_symbols
: cu
->list_in_scope
);
7113 add_symbol_to_list (sym
, list_to_add
);
7116 case DW_TAG_namespace
:
7117 SYMBOL_CLASS (sym
) = LOC_TYPEDEF
;
7118 add_symbol_to_list (sym
, &global_symbols
);
7121 /* Not a tag we recognize. Hopefully we aren't processing
7122 trash data, but since we must specifically ignore things
7123 we don't recognize, there is nothing else we should do at
7125 complaint (&symfile_complaints
, _("unsupported tag: '%s'"),
7126 dwarf_tag_name (die
->tag
));
7133 /* Copy constant value from an attribute to a symbol. */
7136 dwarf2_const_value (struct attribute
*attr
, struct symbol
*sym
,
7137 struct dwarf2_cu
*cu
)
7139 struct objfile
*objfile
= cu
->objfile
;
7140 struct comp_unit_head
*cu_header
= &cu
->header
;
7141 struct dwarf_block
*blk
;
7146 if (TYPE_LENGTH (SYMBOL_TYPE (sym
)) != cu_header
->addr_size
)
7147 dwarf2_const_value_length_mismatch_complaint (DEPRECATED_SYMBOL_NAME (sym
),
7148 cu_header
->addr_size
,
7149 TYPE_LENGTH (SYMBOL_TYPE
7151 SYMBOL_VALUE_BYTES (sym
) =
7152 obstack_alloc (&objfile
->objfile_obstack
, cu_header
->addr_size
);
7153 /* NOTE: cagney/2003-05-09: In-lined store_address call with
7154 it's body - store_unsigned_integer. */
7155 store_unsigned_integer (SYMBOL_VALUE_BYTES (sym
), cu_header
->addr_size
,
7157 SYMBOL_CLASS (sym
) = LOC_CONST_BYTES
;
7159 case DW_FORM_block1
:
7160 case DW_FORM_block2
:
7161 case DW_FORM_block4
:
7163 blk
= DW_BLOCK (attr
);
7164 if (TYPE_LENGTH (SYMBOL_TYPE (sym
)) != blk
->size
)
7165 dwarf2_const_value_length_mismatch_complaint (DEPRECATED_SYMBOL_NAME (sym
),
7167 TYPE_LENGTH (SYMBOL_TYPE
7169 SYMBOL_VALUE_BYTES (sym
) =
7170 obstack_alloc (&objfile
->objfile_obstack
, blk
->size
);
7171 memcpy (SYMBOL_VALUE_BYTES (sym
), blk
->data
, blk
->size
);
7172 SYMBOL_CLASS (sym
) = LOC_CONST_BYTES
;
7175 /* The DW_AT_const_value attributes are supposed to carry the
7176 symbol's value "represented as it would be on the target
7177 architecture." By the time we get here, it's already been
7178 converted to host endianness, so we just need to sign- or
7179 zero-extend it as appropriate. */
7181 dwarf2_const_value_data (attr
, sym
, 8);
7184 dwarf2_const_value_data (attr
, sym
, 16);
7187 dwarf2_const_value_data (attr
, sym
, 32);
7190 dwarf2_const_value_data (attr
, sym
, 64);
7194 SYMBOL_VALUE (sym
) = DW_SND (attr
);
7195 SYMBOL_CLASS (sym
) = LOC_CONST
;
7199 SYMBOL_VALUE (sym
) = DW_UNSND (attr
);
7200 SYMBOL_CLASS (sym
) = LOC_CONST
;
7204 complaint (&symfile_complaints
,
7205 _("unsupported const value attribute form: '%s'"),
7206 dwarf_form_name (attr
->form
));
7207 SYMBOL_VALUE (sym
) = 0;
7208 SYMBOL_CLASS (sym
) = LOC_CONST
;
7214 /* Given an attr with a DW_FORM_dataN value in host byte order, sign-
7215 or zero-extend it as appropriate for the symbol's type. */
7217 dwarf2_const_value_data (struct attribute
*attr
,
7221 LONGEST l
= DW_UNSND (attr
);
7223 if (bits
< sizeof (l
) * 8)
7225 if (TYPE_UNSIGNED (SYMBOL_TYPE (sym
)))
7226 l
&= ((LONGEST
) 1 << bits
) - 1;
7228 l
= (l
<< (sizeof (l
) * 8 - bits
)) >> (sizeof (l
) * 8 - bits
);
7231 SYMBOL_VALUE (sym
) = l
;
7232 SYMBOL_CLASS (sym
) = LOC_CONST
;
7236 /* Return the type of the die in question using its DW_AT_type attribute. */
7238 static struct type
*
7239 die_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
7242 struct attribute
*type_attr
;
7243 struct die_info
*type_die
;
7245 type_attr
= dwarf2_attr (die
, DW_AT_type
, cu
);
7248 /* A missing DW_AT_type represents a void type. */
7249 return dwarf2_fundamental_type (cu
->objfile
, FT_VOID
, cu
);
7252 type_die
= follow_die_ref (die
, type_attr
, cu
);
7254 type
= tag_type_to_type (type_die
, cu
);
7257 dump_die (type_die
);
7258 error (_("Dwarf Error: Problem turning type die at offset into gdb type [in module %s]"),
7264 /* Return the containing type of the die in question using its
7265 DW_AT_containing_type attribute. */
7267 static struct type
*
7268 die_containing_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
7270 struct type
*type
= NULL
;
7271 struct attribute
*type_attr
;
7272 struct die_info
*type_die
= NULL
;
7274 type_attr
= dwarf2_attr (die
, DW_AT_containing_type
, cu
);
7277 type_die
= follow_die_ref (die
, type_attr
, cu
);
7278 type
= tag_type_to_type (type_die
, cu
);
7283 dump_die (type_die
);
7284 error (_("Dwarf Error: Problem turning containing type into gdb type [in module %s]"),
7290 static struct type
*
7291 tag_type_to_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
7299 read_type_die (die
, cu
);
7303 error (_("Dwarf Error: Cannot find type of die [in module %s]"),
7311 read_type_die (struct die_info
*die
, struct dwarf2_cu
*cu
)
7313 char *prefix
= determine_prefix (die
, cu
);
7314 const char *old_prefix
= processing_current_prefix
;
7315 struct cleanup
*back_to
= make_cleanup (xfree
, prefix
);
7316 processing_current_prefix
= prefix
;
7320 case DW_TAG_class_type
:
7321 case DW_TAG_structure_type
:
7322 case DW_TAG_union_type
:
7323 read_structure_type (die
, cu
);
7325 case DW_TAG_enumeration_type
:
7326 read_enumeration_type (die
, cu
);
7328 case DW_TAG_subprogram
:
7329 case DW_TAG_subroutine_type
:
7330 read_subroutine_type (die
, cu
);
7332 case DW_TAG_array_type
:
7333 read_array_type (die
, cu
);
7335 case DW_TAG_set_type
:
7336 read_set_type (die
, cu
);
7338 case DW_TAG_pointer_type
:
7339 read_tag_pointer_type (die
, cu
);
7341 case DW_TAG_ptr_to_member_type
:
7342 read_tag_ptr_to_member_type (die
, cu
);
7344 case DW_TAG_reference_type
:
7345 read_tag_reference_type (die
, cu
);
7347 case DW_TAG_const_type
:
7348 read_tag_const_type (die
, cu
);
7350 case DW_TAG_volatile_type
:
7351 read_tag_volatile_type (die
, cu
);
7353 case DW_TAG_string_type
:
7354 read_tag_string_type (die
, cu
);
7356 case DW_TAG_typedef
:
7357 read_typedef (die
, cu
);
7359 case DW_TAG_subrange_type
:
7360 read_subrange_type (die
, cu
);
7362 case DW_TAG_base_type
:
7363 read_base_type (die
, cu
);
7365 case DW_TAG_unspecified_type
:
7366 read_unspecified_type (die
, cu
);
7369 complaint (&symfile_complaints
, _("unexpected tag in read_type_die: '%s'"),
7370 dwarf_tag_name (die
->tag
));
7374 processing_current_prefix
= old_prefix
;
7375 do_cleanups (back_to
);
7378 /* Return the name of the namespace/class that DIE is defined within,
7379 or "" if we can't tell. The caller should xfree the result. */
7381 /* NOTE: carlton/2004-01-23: See read_func_scope (and the comment
7382 therein) for an example of how to use this function to deal with
7383 DW_AT_specification. */
7386 determine_prefix (struct die_info
*die
, struct dwarf2_cu
*cu
)
7388 struct die_info
*parent
;
7390 if (cu
->language
!= language_cplus
7391 && cu
->language
!= language_java
)
7394 parent
= die
->parent
;
7398 return xstrdup ("");
7402 switch (parent
->tag
) {
7403 case DW_TAG_namespace
:
7405 /* FIXME: carlton/2004-03-05: Should I follow extension dies
7406 before doing this check? */
7407 if (parent
->type
!= NULL
&& TYPE_TAG_NAME (parent
->type
) != NULL
)
7409 return xstrdup (TYPE_TAG_NAME (parent
->type
));
7414 char *parent_prefix
= determine_prefix (parent
, cu
);
7415 char *retval
= typename_concat (NULL
, parent_prefix
,
7416 namespace_name (parent
, &dummy
,
7419 xfree (parent_prefix
);
7424 case DW_TAG_class_type
:
7425 case DW_TAG_structure_type
:
7427 if (parent
->type
!= NULL
&& TYPE_TAG_NAME (parent
->type
) != NULL
)
7429 return xstrdup (TYPE_TAG_NAME (parent
->type
));
7433 const char *old_prefix
= processing_current_prefix
;
7434 char *new_prefix
= determine_prefix (parent
, cu
);
7437 processing_current_prefix
= new_prefix
;
7438 retval
= determine_class_name (parent
, cu
);
7439 processing_current_prefix
= old_prefix
;
7446 return determine_prefix (parent
, cu
);
7451 /* Return a newly-allocated string formed by concatenating PREFIX and
7452 SUFFIX with appropriate separator. If PREFIX or SUFFIX is NULL or empty, then
7453 simply copy the SUFFIX or PREFIX, respectively. If OBS is non-null,
7454 perform an obconcat, otherwise allocate storage for the result. The CU argument
7455 is used to determine the language and hence, the appropriate separator. */
7457 #define MAX_SEP_LEN 2 /* sizeof ("::") */
7460 typename_concat (struct obstack
*obs
, const char *prefix
, const char *suffix
,
7461 struct dwarf2_cu
*cu
)
7465 if (suffix
== NULL
|| suffix
[0] == '\0' || prefix
== NULL
|| prefix
[0] == '\0')
7467 else if (cu
->language
== language_java
)
7474 char *retval
= xmalloc (strlen (prefix
) + MAX_SEP_LEN
+ strlen (suffix
) + 1);
7479 strcpy (retval
, prefix
);
7480 strcat (retval
, sep
);
7483 strcat (retval
, suffix
);
7489 /* We have an obstack. */
7490 return obconcat (obs
, prefix
, sep
, suffix
);
7494 static struct type
*
7495 dwarf_base_type (int encoding
, int size
, struct dwarf2_cu
*cu
)
7497 struct objfile
*objfile
= cu
->objfile
;
7499 /* FIXME - this should not produce a new (struct type *)
7500 every time. It should cache base types. */
7504 case DW_ATE_address
:
7505 type
= dwarf2_fundamental_type (objfile
, FT_VOID
, cu
);
7507 case DW_ATE_boolean
:
7508 type
= dwarf2_fundamental_type (objfile
, FT_BOOLEAN
, cu
);
7510 case DW_ATE_complex_float
:
7513 type
= dwarf2_fundamental_type (objfile
, FT_DBL_PREC_COMPLEX
, cu
);
7517 type
= dwarf2_fundamental_type (objfile
, FT_COMPLEX
, cu
);
7523 type
= dwarf2_fundamental_type (objfile
, FT_DBL_PREC_FLOAT
, cu
);
7527 type
= dwarf2_fundamental_type (objfile
, FT_FLOAT
, cu
);
7534 type
= dwarf2_fundamental_type (objfile
, FT_SIGNED_CHAR
, cu
);
7537 type
= dwarf2_fundamental_type (objfile
, FT_SIGNED_SHORT
, cu
);
7541 type
= dwarf2_fundamental_type (objfile
, FT_SIGNED_INTEGER
, cu
);
7545 case DW_ATE_signed_char
:
7546 type
= dwarf2_fundamental_type (objfile
, FT_SIGNED_CHAR
, cu
);
7548 case DW_ATE_unsigned
:
7552 type
= dwarf2_fundamental_type (objfile
, FT_UNSIGNED_CHAR
, cu
);
7555 type
= dwarf2_fundamental_type (objfile
, FT_UNSIGNED_SHORT
, cu
);
7559 type
= dwarf2_fundamental_type (objfile
, FT_UNSIGNED_INTEGER
, cu
);
7563 case DW_ATE_unsigned_char
:
7564 type
= dwarf2_fundamental_type (objfile
, FT_UNSIGNED_CHAR
, cu
);
7567 type
= dwarf2_fundamental_type (objfile
, FT_SIGNED_INTEGER
, cu
);
7574 copy_die (struct die_info
*old_die
)
7576 struct die_info
*new_die
;
7579 new_die
= (struct die_info
*) xmalloc (sizeof (struct die_info
));
7580 memset (new_die
, 0, sizeof (struct die_info
));
7582 new_die
->tag
= old_die
->tag
;
7583 new_die
->has_children
= old_die
->has_children
;
7584 new_die
->abbrev
= old_die
->abbrev
;
7585 new_die
->offset
= old_die
->offset
;
7586 new_die
->type
= NULL
;
7588 num_attrs
= old_die
->num_attrs
;
7589 new_die
->num_attrs
= num_attrs
;
7590 new_die
->attrs
= (struct attribute
*)
7591 xmalloc (num_attrs
* sizeof (struct attribute
));
7593 for (i
= 0; i
< old_die
->num_attrs
; ++i
)
7595 new_die
->attrs
[i
].name
= old_die
->attrs
[i
].name
;
7596 new_die
->attrs
[i
].form
= old_die
->attrs
[i
].form
;
7597 new_die
->attrs
[i
].u
.addr
= old_die
->attrs
[i
].u
.addr
;
7600 new_die
->next
= NULL
;
7605 /* Return sibling of die, NULL if no sibling. */
7607 static struct die_info
*
7608 sibling_die (struct die_info
*die
)
7610 return die
->sibling
;
7613 /* Get linkage name of a die, return NULL if not found. */
7616 dwarf2_linkage_name (struct die_info
*die
, struct dwarf2_cu
*cu
)
7618 struct attribute
*attr
;
7620 attr
= dwarf2_attr (die
, DW_AT_MIPS_linkage_name
, cu
);
7621 if (attr
&& DW_STRING (attr
))
7622 return DW_STRING (attr
);
7623 attr
= dwarf2_attr (die
, DW_AT_name
, cu
);
7624 if (attr
&& DW_STRING (attr
))
7625 return DW_STRING (attr
);
7629 /* Get name of a die, return NULL if not found. */
7632 dwarf2_name (struct die_info
*die
, struct dwarf2_cu
*cu
)
7634 struct attribute
*attr
;
7636 attr
= dwarf2_attr (die
, DW_AT_name
, cu
);
7637 if (attr
&& DW_STRING (attr
))
7638 return DW_STRING (attr
);
7642 /* Return the die that this die in an extension of, or NULL if there
7645 static struct die_info
*
7646 dwarf2_extension (struct die_info
*die
, struct dwarf2_cu
*cu
)
7648 struct attribute
*attr
;
7650 attr
= dwarf2_attr (die
, DW_AT_extension
, cu
);
7654 return follow_die_ref (die
, attr
, cu
);
7657 /* Convert a DIE tag into its string name. */
7660 dwarf_tag_name (unsigned tag
)
7664 case DW_TAG_padding
:
7665 return "DW_TAG_padding";
7666 case DW_TAG_array_type
:
7667 return "DW_TAG_array_type";
7668 case DW_TAG_class_type
:
7669 return "DW_TAG_class_type";
7670 case DW_TAG_entry_point
:
7671 return "DW_TAG_entry_point";
7672 case DW_TAG_enumeration_type
:
7673 return "DW_TAG_enumeration_type";
7674 case DW_TAG_formal_parameter
:
7675 return "DW_TAG_formal_parameter";
7676 case DW_TAG_imported_declaration
:
7677 return "DW_TAG_imported_declaration";
7679 return "DW_TAG_label";
7680 case DW_TAG_lexical_block
:
7681 return "DW_TAG_lexical_block";
7683 return "DW_TAG_member";
7684 case DW_TAG_pointer_type
:
7685 return "DW_TAG_pointer_type";
7686 case DW_TAG_reference_type
:
7687 return "DW_TAG_reference_type";
7688 case DW_TAG_compile_unit
:
7689 return "DW_TAG_compile_unit";
7690 case DW_TAG_string_type
:
7691 return "DW_TAG_string_type";
7692 case DW_TAG_structure_type
:
7693 return "DW_TAG_structure_type";
7694 case DW_TAG_subroutine_type
:
7695 return "DW_TAG_subroutine_type";
7696 case DW_TAG_typedef
:
7697 return "DW_TAG_typedef";
7698 case DW_TAG_union_type
:
7699 return "DW_TAG_union_type";
7700 case DW_TAG_unspecified_parameters
:
7701 return "DW_TAG_unspecified_parameters";
7702 case DW_TAG_variant
:
7703 return "DW_TAG_variant";
7704 case DW_TAG_common_block
:
7705 return "DW_TAG_common_block";
7706 case DW_TAG_common_inclusion
:
7707 return "DW_TAG_common_inclusion";
7708 case DW_TAG_inheritance
:
7709 return "DW_TAG_inheritance";
7710 case DW_TAG_inlined_subroutine
:
7711 return "DW_TAG_inlined_subroutine";
7713 return "DW_TAG_module";
7714 case DW_TAG_ptr_to_member_type
:
7715 return "DW_TAG_ptr_to_member_type";
7716 case DW_TAG_set_type
:
7717 return "DW_TAG_set_type";
7718 case DW_TAG_subrange_type
:
7719 return "DW_TAG_subrange_type";
7720 case DW_TAG_with_stmt
:
7721 return "DW_TAG_with_stmt";
7722 case DW_TAG_access_declaration
:
7723 return "DW_TAG_access_declaration";
7724 case DW_TAG_base_type
:
7725 return "DW_TAG_base_type";
7726 case DW_TAG_catch_block
:
7727 return "DW_TAG_catch_block";
7728 case DW_TAG_const_type
:
7729 return "DW_TAG_const_type";
7730 case DW_TAG_constant
:
7731 return "DW_TAG_constant";
7732 case DW_TAG_enumerator
:
7733 return "DW_TAG_enumerator";
7734 case DW_TAG_file_type
:
7735 return "DW_TAG_file_type";
7737 return "DW_TAG_friend";
7738 case DW_TAG_namelist
:
7739 return "DW_TAG_namelist";
7740 case DW_TAG_namelist_item
:
7741 return "DW_TAG_namelist_item";
7742 case DW_TAG_packed_type
:
7743 return "DW_TAG_packed_type";
7744 case DW_TAG_subprogram
:
7745 return "DW_TAG_subprogram";
7746 case DW_TAG_template_type_param
:
7747 return "DW_TAG_template_type_param";
7748 case DW_TAG_template_value_param
:
7749 return "DW_TAG_template_value_param";
7750 case DW_TAG_thrown_type
:
7751 return "DW_TAG_thrown_type";
7752 case DW_TAG_try_block
:
7753 return "DW_TAG_try_block";
7754 case DW_TAG_variant_part
:
7755 return "DW_TAG_variant_part";
7756 case DW_TAG_variable
:
7757 return "DW_TAG_variable";
7758 case DW_TAG_volatile_type
:
7759 return "DW_TAG_volatile_type";
7760 case DW_TAG_dwarf_procedure
:
7761 return "DW_TAG_dwarf_procedure";
7762 case DW_TAG_restrict_type
:
7763 return "DW_TAG_restrict_type";
7764 case DW_TAG_interface_type
:
7765 return "DW_TAG_interface_type";
7766 case DW_TAG_namespace
:
7767 return "DW_TAG_namespace";
7768 case DW_TAG_imported_module
:
7769 return "DW_TAG_imported_module";
7770 case DW_TAG_unspecified_type
:
7771 return "DW_TAG_unspecified_type";
7772 case DW_TAG_partial_unit
:
7773 return "DW_TAG_partial_unit";
7774 case DW_TAG_imported_unit
:
7775 return "DW_TAG_imported_unit";
7776 case DW_TAG_MIPS_loop
:
7777 return "DW_TAG_MIPS_loop";
7778 case DW_TAG_format_label
:
7779 return "DW_TAG_format_label";
7780 case DW_TAG_function_template
:
7781 return "DW_TAG_function_template";
7782 case DW_TAG_class_template
:
7783 return "DW_TAG_class_template";
7785 return "DW_TAG_<unknown>";
7789 /* Convert a DWARF attribute code into its string name. */
7792 dwarf_attr_name (unsigned attr
)
7797 return "DW_AT_sibling";
7798 case DW_AT_location
:
7799 return "DW_AT_location";
7801 return "DW_AT_name";
7802 case DW_AT_ordering
:
7803 return "DW_AT_ordering";
7804 case DW_AT_subscr_data
:
7805 return "DW_AT_subscr_data";
7806 case DW_AT_byte_size
:
7807 return "DW_AT_byte_size";
7808 case DW_AT_bit_offset
:
7809 return "DW_AT_bit_offset";
7810 case DW_AT_bit_size
:
7811 return "DW_AT_bit_size";
7812 case DW_AT_element_list
:
7813 return "DW_AT_element_list";
7814 case DW_AT_stmt_list
:
7815 return "DW_AT_stmt_list";
7817 return "DW_AT_low_pc";
7819 return "DW_AT_high_pc";
7820 case DW_AT_language
:
7821 return "DW_AT_language";
7823 return "DW_AT_member";
7825 return "DW_AT_discr";
7826 case DW_AT_discr_value
:
7827 return "DW_AT_discr_value";
7828 case DW_AT_visibility
:
7829 return "DW_AT_visibility";
7831 return "DW_AT_import";
7832 case DW_AT_string_length
:
7833 return "DW_AT_string_length";
7834 case DW_AT_common_reference
:
7835 return "DW_AT_common_reference";
7836 case DW_AT_comp_dir
:
7837 return "DW_AT_comp_dir";
7838 case DW_AT_const_value
:
7839 return "DW_AT_const_value";
7840 case DW_AT_containing_type
:
7841 return "DW_AT_containing_type";
7842 case DW_AT_default_value
:
7843 return "DW_AT_default_value";
7845 return "DW_AT_inline";
7846 case DW_AT_is_optional
:
7847 return "DW_AT_is_optional";
7848 case DW_AT_lower_bound
:
7849 return "DW_AT_lower_bound";
7850 case DW_AT_producer
:
7851 return "DW_AT_producer";
7852 case DW_AT_prototyped
:
7853 return "DW_AT_prototyped";
7854 case DW_AT_return_addr
:
7855 return "DW_AT_return_addr";
7856 case DW_AT_start_scope
:
7857 return "DW_AT_start_scope";
7858 case DW_AT_stride_size
:
7859 return "DW_AT_stride_size";
7860 case DW_AT_upper_bound
:
7861 return "DW_AT_upper_bound";
7862 case DW_AT_abstract_origin
:
7863 return "DW_AT_abstract_origin";
7864 case DW_AT_accessibility
:
7865 return "DW_AT_accessibility";
7866 case DW_AT_address_class
:
7867 return "DW_AT_address_class";
7868 case DW_AT_artificial
:
7869 return "DW_AT_artificial";
7870 case DW_AT_base_types
:
7871 return "DW_AT_base_types";
7872 case DW_AT_calling_convention
:
7873 return "DW_AT_calling_convention";
7875 return "DW_AT_count";
7876 case DW_AT_data_member_location
:
7877 return "DW_AT_data_member_location";
7878 case DW_AT_decl_column
:
7879 return "DW_AT_decl_column";
7880 case DW_AT_decl_file
:
7881 return "DW_AT_decl_file";
7882 case DW_AT_decl_line
:
7883 return "DW_AT_decl_line";
7884 case DW_AT_declaration
:
7885 return "DW_AT_declaration";
7886 case DW_AT_discr_list
:
7887 return "DW_AT_discr_list";
7888 case DW_AT_encoding
:
7889 return "DW_AT_encoding";
7890 case DW_AT_external
:
7891 return "DW_AT_external";
7892 case DW_AT_frame_base
:
7893 return "DW_AT_frame_base";
7895 return "DW_AT_friend";
7896 case DW_AT_identifier_case
:
7897 return "DW_AT_identifier_case";
7898 case DW_AT_macro_info
:
7899 return "DW_AT_macro_info";
7900 case DW_AT_namelist_items
:
7901 return "DW_AT_namelist_items";
7902 case DW_AT_priority
:
7903 return "DW_AT_priority";
7905 return "DW_AT_segment";
7906 case DW_AT_specification
:
7907 return "DW_AT_specification";
7908 case DW_AT_static_link
:
7909 return "DW_AT_static_link";
7911 return "DW_AT_type";
7912 case DW_AT_use_location
:
7913 return "DW_AT_use_location";
7914 case DW_AT_variable_parameter
:
7915 return "DW_AT_variable_parameter";
7916 case DW_AT_virtuality
:
7917 return "DW_AT_virtuality";
7918 case DW_AT_vtable_elem_location
:
7919 return "DW_AT_vtable_elem_location";
7920 case DW_AT_allocated
:
7921 return "DW_AT_allocated";
7922 case DW_AT_associated
:
7923 return "DW_AT_associated";
7924 case DW_AT_data_location
:
7925 return "DW_AT_data_location";
7927 return "DW_AT_stride";
7928 case DW_AT_entry_pc
:
7929 return "DW_AT_entry_pc";
7930 case DW_AT_use_UTF8
:
7931 return "DW_AT_use_UTF8";
7932 case DW_AT_extension
:
7933 return "DW_AT_extension";
7935 return "DW_AT_ranges";
7936 case DW_AT_trampoline
:
7937 return "DW_AT_trampoline";
7938 case DW_AT_call_column
:
7939 return "DW_AT_call_column";
7940 case DW_AT_call_file
:
7941 return "DW_AT_call_file";
7942 case DW_AT_call_line
:
7943 return "DW_AT_call_line";
7945 case DW_AT_MIPS_fde
:
7946 return "DW_AT_MIPS_fde";
7947 case DW_AT_MIPS_loop_begin
:
7948 return "DW_AT_MIPS_loop_begin";
7949 case DW_AT_MIPS_tail_loop_begin
:
7950 return "DW_AT_MIPS_tail_loop_begin";
7951 case DW_AT_MIPS_epilog_begin
:
7952 return "DW_AT_MIPS_epilog_begin";
7953 case DW_AT_MIPS_loop_unroll_factor
:
7954 return "DW_AT_MIPS_loop_unroll_factor";
7955 case DW_AT_MIPS_software_pipeline_depth
:
7956 return "DW_AT_MIPS_software_pipeline_depth";
7958 case DW_AT_MIPS_linkage_name
:
7959 return "DW_AT_MIPS_linkage_name";
7961 case DW_AT_sf_names
:
7962 return "DW_AT_sf_names";
7963 case DW_AT_src_info
:
7964 return "DW_AT_src_info";
7965 case DW_AT_mac_info
:
7966 return "DW_AT_mac_info";
7967 case DW_AT_src_coords
:
7968 return "DW_AT_src_coords";
7969 case DW_AT_body_begin
:
7970 return "DW_AT_body_begin";
7971 case DW_AT_body_end
:
7972 return "DW_AT_body_end";
7973 case DW_AT_GNU_vector
:
7974 return "DW_AT_GNU_vector";
7976 return "DW_AT_<unknown>";
7980 /* Convert a DWARF value form code into its string name. */
7983 dwarf_form_name (unsigned form
)
7988 return "DW_FORM_addr";
7989 case DW_FORM_block2
:
7990 return "DW_FORM_block2";
7991 case DW_FORM_block4
:
7992 return "DW_FORM_block4";
7994 return "DW_FORM_data2";
7996 return "DW_FORM_data4";
7998 return "DW_FORM_data8";
7999 case DW_FORM_string
:
8000 return "DW_FORM_string";
8002 return "DW_FORM_block";
8003 case DW_FORM_block1
:
8004 return "DW_FORM_block1";
8006 return "DW_FORM_data1";
8008 return "DW_FORM_flag";
8010 return "DW_FORM_sdata";
8012 return "DW_FORM_strp";
8014 return "DW_FORM_udata";
8015 case DW_FORM_ref_addr
:
8016 return "DW_FORM_ref_addr";
8018 return "DW_FORM_ref1";
8020 return "DW_FORM_ref2";
8022 return "DW_FORM_ref4";
8024 return "DW_FORM_ref8";
8025 case DW_FORM_ref_udata
:
8026 return "DW_FORM_ref_udata";
8027 case DW_FORM_indirect
:
8028 return "DW_FORM_indirect";
8030 return "DW_FORM_<unknown>";
8034 /* Convert a DWARF stack opcode into its string name. */
8037 dwarf_stack_op_name (unsigned op
)
8042 return "DW_OP_addr";
8044 return "DW_OP_deref";
8046 return "DW_OP_const1u";
8048 return "DW_OP_const1s";
8050 return "DW_OP_const2u";
8052 return "DW_OP_const2s";
8054 return "DW_OP_const4u";
8056 return "DW_OP_const4s";
8058 return "DW_OP_const8u";
8060 return "DW_OP_const8s";
8062 return "DW_OP_constu";
8064 return "DW_OP_consts";
8068 return "DW_OP_drop";
8070 return "DW_OP_over";
8072 return "DW_OP_pick";
8074 return "DW_OP_swap";
8078 return "DW_OP_xderef";
8086 return "DW_OP_minus";
8098 return "DW_OP_plus";
8099 case DW_OP_plus_uconst
:
8100 return "DW_OP_plus_uconst";
8106 return "DW_OP_shra";
8124 return "DW_OP_skip";
8126 return "DW_OP_lit0";
8128 return "DW_OP_lit1";
8130 return "DW_OP_lit2";
8132 return "DW_OP_lit3";
8134 return "DW_OP_lit4";
8136 return "DW_OP_lit5";
8138 return "DW_OP_lit6";
8140 return "DW_OP_lit7";
8142 return "DW_OP_lit8";
8144 return "DW_OP_lit9";
8146 return "DW_OP_lit10";
8148 return "DW_OP_lit11";
8150 return "DW_OP_lit12";
8152 return "DW_OP_lit13";
8154 return "DW_OP_lit14";
8156 return "DW_OP_lit15";
8158 return "DW_OP_lit16";
8160 return "DW_OP_lit17";
8162 return "DW_OP_lit18";
8164 return "DW_OP_lit19";
8166 return "DW_OP_lit20";
8168 return "DW_OP_lit21";
8170 return "DW_OP_lit22";
8172 return "DW_OP_lit23";
8174 return "DW_OP_lit24";
8176 return "DW_OP_lit25";
8178 return "DW_OP_lit26";
8180 return "DW_OP_lit27";
8182 return "DW_OP_lit28";
8184 return "DW_OP_lit29";
8186 return "DW_OP_lit30";
8188 return "DW_OP_lit31";
8190 return "DW_OP_reg0";
8192 return "DW_OP_reg1";
8194 return "DW_OP_reg2";
8196 return "DW_OP_reg3";
8198 return "DW_OP_reg4";
8200 return "DW_OP_reg5";
8202 return "DW_OP_reg6";
8204 return "DW_OP_reg7";
8206 return "DW_OP_reg8";
8208 return "DW_OP_reg9";
8210 return "DW_OP_reg10";
8212 return "DW_OP_reg11";
8214 return "DW_OP_reg12";
8216 return "DW_OP_reg13";
8218 return "DW_OP_reg14";
8220 return "DW_OP_reg15";
8222 return "DW_OP_reg16";
8224 return "DW_OP_reg17";
8226 return "DW_OP_reg18";
8228 return "DW_OP_reg19";
8230 return "DW_OP_reg20";
8232 return "DW_OP_reg21";
8234 return "DW_OP_reg22";
8236 return "DW_OP_reg23";
8238 return "DW_OP_reg24";
8240 return "DW_OP_reg25";
8242 return "DW_OP_reg26";
8244 return "DW_OP_reg27";
8246 return "DW_OP_reg28";
8248 return "DW_OP_reg29";
8250 return "DW_OP_reg30";
8252 return "DW_OP_reg31";
8254 return "DW_OP_breg0";
8256 return "DW_OP_breg1";
8258 return "DW_OP_breg2";
8260 return "DW_OP_breg3";
8262 return "DW_OP_breg4";
8264 return "DW_OP_breg5";
8266 return "DW_OP_breg6";
8268 return "DW_OP_breg7";
8270 return "DW_OP_breg8";
8272 return "DW_OP_breg9";
8274 return "DW_OP_breg10";
8276 return "DW_OP_breg11";
8278 return "DW_OP_breg12";
8280 return "DW_OP_breg13";
8282 return "DW_OP_breg14";
8284 return "DW_OP_breg15";
8286 return "DW_OP_breg16";
8288 return "DW_OP_breg17";
8290 return "DW_OP_breg18";
8292 return "DW_OP_breg19";
8294 return "DW_OP_breg20";
8296 return "DW_OP_breg21";
8298 return "DW_OP_breg22";
8300 return "DW_OP_breg23";
8302 return "DW_OP_breg24";
8304 return "DW_OP_breg25";
8306 return "DW_OP_breg26";
8308 return "DW_OP_breg27";
8310 return "DW_OP_breg28";
8312 return "DW_OP_breg29";
8314 return "DW_OP_breg30";
8316 return "DW_OP_breg31";
8318 return "DW_OP_regx";
8320 return "DW_OP_fbreg";
8322 return "DW_OP_bregx";
8324 return "DW_OP_piece";
8325 case DW_OP_deref_size
:
8326 return "DW_OP_deref_size";
8327 case DW_OP_xderef_size
:
8328 return "DW_OP_xderef_size";
8331 /* DWARF 3 extensions. */
8332 case DW_OP_push_object_address
:
8333 return "DW_OP_push_object_address";
8335 return "DW_OP_call2";
8337 return "DW_OP_call4";
8338 case DW_OP_call_ref
:
8339 return "DW_OP_call_ref";
8340 /* GNU extensions. */
8341 case DW_OP_GNU_push_tls_address
:
8342 return "DW_OP_GNU_push_tls_address";
8344 return "OP_<unknown>";
8349 dwarf_bool_name (unsigned mybool
)
8357 /* Convert a DWARF type code into its string name. */
8360 dwarf_type_encoding_name (unsigned enc
)
8364 case DW_ATE_address
:
8365 return "DW_ATE_address";
8366 case DW_ATE_boolean
:
8367 return "DW_ATE_boolean";
8368 case DW_ATE_complex_float
:
8369 return "DW_ATE_complex_float";
8371 return "DW_ATE_float";
8373 return "DW_ATE_signed";
8374 case DW_ATE_signed_char
:
8375 return "DW_ATE_signed_char";
8376 case DW_ATE_unsigned
:
8377 return "DW_ATE_unsigned";
8378 case DW_ATE_unsigned_char
:
8379 return "DW_ATE_unsigned_char";
8380 case DW_ATE_imaginary_float
:
8381 return "DW_ATE_imaginary_float";
8383 return "DW_ATE_<unknown>";
8387 /* Convert a DWARF call frame info operation to its string name. */
8391 dwarf_cfi_name (unsigned cfi_opc
)
8395 case DW_CFA_advance_loc
:
8396 return "DW_CFA_advance_loc";
8398 return "DW_CFA_offset";
8399 case DW_CFA_restore
:
8400 return "DW_CFA_restore";
8402 return "DW_CFA_nop";
8403 case DW_CFA_set_loc
:
8404 return "DW_CFA_set_loc";
8405 case DW_CFA_advance_loc1
:
8406 return "DW_CFA_advance_loc1";
8407 case DW_CFA_advance_loc2
:
8408 return "DW_CFA_advance_loc2";
8409 case DW_CFA_advance_loc4
:
8410 return "DW_CFA_advance_loc4";
8411 case DW_CFA_offset_extended
:
8412 return "DW_CFA_offset_extended";
8413 case DW_CFA_restore_extended
:
8414 return "DW_CFA_restore_extended";
8415 case DW_CFA_undefined
:
8416 return "DW_CFA_undefined";
8417 case DW_CFA_same_value
:
8418 return "DW_CFA_same_value";
8419 case DW_CFA_register
:
8420 return "DW_CFA_register";
8421 case DW_CFA_remember_state
:
8422 return "DW_CFA_remember_state";
8423 case DW_CFA_restore_state
:
8424 return "DW_CFA_restore_state";
8425 case DW_CFA_def_cfa
:
8426 return "DW_CFA_def_cfa";
8427 case DW_CFA_def_cfa_register
:
8428 return "DW_CFA_def_cfa_register";
8429 case DW_CFA_def_cfa_offset
:
8430 return "DW_CFA_def_cfa_offset";
8433 case DW_CFA_def_cfa_expression
:
8434 return "DW_CFA_def_cfa_expression";
8435 case DW_CFA_expression
:
8436 return "DW_CFA_expression";
8437 case DW_CFA_offset_extended_sf
:
8438 return "DW_CFA_offset_extended_sf";
8439 case DW_CFA_def_cfa_sf
:
8440 return "DW_CFA_def_cfa_sf";
8441 case DW_CFA_def_cfa_offset_sf
:
8442 return "DW_CFA_def_cfa_offset_sf";
8444 /* SGI/MIPS specific */
8445 case DW_CFA_MIPS_advance_loc8
:
8446 return "DW_CFA_MIPS_advance_loc8";
8448 /* GNU extensions */
8449 case DW_CFA_GNU_window_save
:
8450 return "DW_CFA_GNU_window_save";
8451 case DW_CFA_GNU_args_size
:
8452 return "DW_CFA_GNU_args_size";
8453 case DW_CFA_GNU_negative_offset_extended
:
8454 return "DW_CFA_GNU_negative_offset_extended";
8457 return "DW_CFA_<unknown>";
8463 dump_die (struct die_info
*die
)
8467 fprintf_unfiltered (gdb_stderr
, "Die: %s (abbrev = %d, offset = %d)\n",
8468 dwarf_tag_name (die
->tag
), die
->abbrev
, die
->offset
);
8469 fprintf_unfiltered (gdb_stderr
, "\thas children: %s\n",
8470 dwarf_bool_name (die
->child
!= NULL
));
8472 fprintf_unfiltered (gdb_stderr
, "\tattributes:\n");
8473 for (i
= 0; i
< die
->num_attrs
; ++i
)
8475 fprintf_unfiltered (gdb_stderr
, "\t\t%s (%s) ",
8476 dwarf_attr_name (die
->attrs
[i
].name
),
8477 dwarf_form_name (die
->attrs
[i
].form
));
8478 switch (die
->attrs
[i
].form
)
8480 case DW_FORM_ref_addr
:
8482 fprintf_unfiltered (gdb_stderr
, "address: ");
8483 deprecated_print_address_numeric (DW_ADDR (&die
->attrs
[i
]), 1, gdb_stderr
);
8485 case DW_FORM_block2
:
8486 case DW_FORM_block4
:
8488 case DW_FORM_block1
:
8489 fprintf_unfiltered (gdb_stderr
, "block: size %d", DW_BLOCK (&die
->attrs
[i
])->size
);
8494 fprintf_unfiltered (gdb_stderr
, "constant ref: %ld (adjusted)",
8495 (long) (DW_ADDR (&die
->attrs
[i
])));
8503 fprintf_unfiltered (gdb_stderr
, "constant: %ld", DW_UNSND (&die
->attrs
[i
]));
8505 case DW_FORM_string
:
8507 fprintf_unfiltered (gdb_stderr
, "string: \"%s\"",
8508 DW_STRING (&die
->attrs
[i
])
8509 ? DW_STRING (&die
->attrs
[i
]) : "");
8512 if (DW_UNSND (&die
->attrs
[i
]))
8513 fprintf_unfiltered (gdb_stderr
, "flag: TRUE");
8515 fprintf_unfiltered (gdb_stderr
, "flag: FALSE");
8517 case DW_FORM_indirect
:
8518 /* the reader will have reduced the indirect form to
8519 the "base form" so this form should not occur */
8520 fprintf_unfiltered (gdb_stderr
, "unexpected attribute form: DW_FORM_indirect");
8523 fprintf_unfiltered (gdb_stderr
, "unsupported attribute form: %d.",
8524 die
->attrs
[i
].form
);
8526 fprintf_unfiltered (gdb_stderr
, "\n");
8531 dump_die_list (struct die_info
*die
)
8536 if (die
->child
!= NULL
)
8537 dump_die_list (die
->child
);
8538 if (die
->sibling
!= NULL
)
8539 dump_die_list (die
->sibling
);
8544 store_in_ref_table (unsigned int offset
, struct die_info
*die
,
8545 struct dwarf2_cu
*cu
)
8548 struct die_info
*old
;
8550 h
= (offset
% REF_HASH_SIZE
);
8551 old
= cu
->die_ref_table
[h
];
8552 die
->next_ref
= old
;
8553 cu
->die_ref_table
[h
] = die
;
8557 dwarf2_get_ref_die_offset (struct attribute
*attr
, struct dwarf2_cu
*cu
)
8559 unsigned int result
= 0;
8563 case DW_FORM_ref_addr
:
8568 case DW_FORM_ref_udata
:
8569 result
= DW_ADDR (attr
);
8572 complaint (&symfile_complaints
,
8573 _("unsupported die ref attribute form: '%s'"),
8574 dwarf_form_name (attr
->form
));
8579 /* Return the constant value held by the given attribute. Return -1
8580 if the value held by the attribute is not constant. */
8583 dwarf2_get_attr_constant_value (struct attribute
*attr
, int default_value
)
8585 if (attr
->form
== DW_FORM_sdata
)
8586 return DW_SND (attr
);
8587 else if (attr
->form
== DW_FORM_udata
8588 || attr
->form
== DW_FORM_data1
8589 || attr
->form
== DW_FORM_data2
8590 || attr
->form
== DW_FORM_data4
8591 || attr
->form
== DW_FORM_data8
)
8592 return DW_UNSND (attr
);
8595 complaint (&symfile_complaints
, _("Attribute value is not a constant (%s)"),
8596 dwarf_form_name (attr
->form
));
8597 return default_value
;
8601 static struct die_info
*
8602 follow_die_ref (struct die_info
*src_die
, struct attribute
*attr
,
8603 struct dwarf2_cu
*cu
)
8605 struct die_info
*die
;
8606 unsigned int offset
;
8608 struct die_info temp_die
;
8609 struct dwarf2_cu
*target_cu
;
8611 offset
= dwarf2_get_ref_die_offset (attr
, cu
);
8613 if (DW_ADDR (attr
) < cu
->header
.offset
8614 || DW_ADDR (attr
) >= cu
->header
.offset
+ cu
->header
.length
)
8616 struct dwarf2_per_cu_data
*per_cu
;
8617 per_cu
= dwarf2_find_containing_comp_unit (DW_ADDR (attr
),
8619 target_cu
= per_cu
->cu
;
8624 h
= (offset
% REF_HASH_SIZE
);
8625 die
= target_cu
->die_ref_table
[h
];
8628 if (die
->offset
== offset
)
8630 die
= die
->next_ref
;
8633 error (_("Dwarf Error: Cannot find DIE at 0x%lx referenced from DIE "
8634 "at 0x%lx [in module %s]"),
8635 (long) src_die
->offset
, (long) offset
, cu
->objfile
->name
);
8640 static struct type
*
8641 dwarf2_fundamental_type (struct objfile
*objfile
, int typeid,
8642 struct dwarf2_cu
*cu
)
8644 if (typeid < 0 || typeid >= FT_NUM_MEMBERS
)
8646 error (_("Dwarf Error: internal error - invalid fundamental type id %d [in module %s]"),
8647 typeid, objfile
->name
);
8650 /* Look for this particular type in the fundamental type vector. If
8651 one is not found, create and install one appropriate for the
8652 current language and the current target machine. */
8654 if (cu
->ftypes
[typeid] == NULL
)
8656 cu
->ftypes
[typeid] = cu
->language_defn
->la_fund_type (objfile
, typeid);
8659 return (cu
->ftypes
[typeid]);
8662 /* Decode simple location descriptions.
8663 Given a pointer to a dwarf block that defines a location, compute
8664 the location and return the value.
8666 NOTE drow/2003-11-18: This function is called in two situations
8667 now: for the address of static or global variables (partial symbols
8668 only) and for offsets into structures which are expected to be
8669 (more or less) constant. The partial symbol case should go away,
8670 and only the constant case should remain. That will let this
8671 function complain more accurately. A few special modes are allowed
8672 without complaint for global variables (for instance, global
8673 register values and thread-local values).
8675 A location description containing no operations indicates that the
8676 object is optimized out. The return value is 0 for that case.
8677 FIXME drow/2003-11-16: No callers check for this case any more; soon all
8678 callers will only want a very basic result and this can become a
8681 Note that stack[0] is unused except as a default error return.
8682 Note that stack overflow is not yet handled. */
8685 decode_locdesc (struct dwarf_block
*blk
, struct dwarf2_cu
*cu
)
8687 struct objfile
*objfile
= cu
->objfile
;
8688 struct comp_unit_head
*cu_header
= &cu
->header
;
8690 int size
= blk
->size
;
8691 gdb_byte
*data
= blk
->data
;
8692 CORE_ADDR stack
[64];
8694 unsigned int bytes_read
, unsnd
;
8738 stack
[++stacki
] = op
- DW_OP_lit0
;
8773 stack
[++stacki
] = op
- DW_OP_reg0
;
8775 dwarf2_complex_location_expr_complaint ();
8779 unsnd
= read_unsigned_leb128 (NULL
, (data
+ i
), &bytes_read
);
8781 stack
[++stacki
] = unsnd
;
8783 dwarf2_complex_location_expr_complaint ();
8787 stack
[++stacki
] = read_address (objfile
->obfd
, &data
[i
],
8793 stack
[++stacki
] = read_1_byte (objfile
->obfd
, &data
[i
]);
8798 stack
[++stacki
] = read_1_signed_byte (objfile
->obfd
, &data
[i
]);
8803 stack
[++stacki
] = read_2_bytes (objfile
->obfd
, &data
[i
]);
8808 stack
[++stacki
] = read_2_signed_bytes (objfile
->obfd
, &data
[i
]);
8813 stack
[++stacki
] = read_4_bytes (objfile
->obfd
, &data
[i
]);
8818 stack
[++stacki
] = read_4_signed_bytes (objfile
->obfd
, &data
[i
]);
8823 stack
[++stacki
] = read_unsigned_leb128 (NULL
, (data
+ i
),
8829 stack
[++stacki
] = read_signed_leb128 (NULL
, (data
+ i
), &bytes_read
);
8834 stack
[stacki
+ 1] = stack
[stacki
];
8839 stack
[stacki
- 1] += stack
[stacki
];
8843 case DW_OP_plus_uconst
:
8844 stack
[stacki
] += read_unsigned_leb128 (NULL
, (data
+ i
), &bytes_read
);
8849 stack
[stacki
- 1] -= stack
[stacki
];
8854 /* If we're not the last op, then we definitely can't encode
8855 this using GDB's address_class enum. This is valid for partial
8856 global symbols, although the variable's address will be bogus
8859 dwarf2_complex_location_expr_complaint ();
8862 case DW_OP_GNU_push_tls_address
:
8863 /* The top of the stack has the offset from the beginning
8864 of the thread control block at which the variable is located. */
8865 /* Nothing should follow this operator, so the top of stack would
8867 /* This is valid for partial global symbols, but the variable's
8868 address will be bogus in the psymtab. */
8870 dwarf2_complex_location_expr_complaint ();
8874 complaint (&symfile_complaints
, _("unsupported stack op: '%s'"),
8875 dwarf_stack_op_name (op
));
8876 return (stack
[stacki
]);
8879 return (stack
[stacki
]);
8882 /* memory allocation interface */
8884 static struct dwarf_block
*
8885 dwarf_alloc_block (struct dwarf2_cu
*cu
)
8887 struct dwarf_block
*blk
;
8889 blk
= (struct dwarf_block
*)
8890 obstack_alloc (&cu
->comp_unit_obstack
, sizeof (struct dwarf_block
));
8894 static struct abbrev_info
*
8895 dwarf_alloc_abbrev (struct dwarf2_cu
*cu
)
8897 struct abbrev_info
*abbrev
;
8899 abbrev
= (struct abbrev_info
*)
8900 obstack_alloc (&cu
->abbrev_obstack
, sizeof (struct abbrev_info
));
8901 memset (abbrev
, 0, sizeof (struct abbrev_info
));
8905 static struct die_info
*
8906 dwarf_alloc_die (void)
8908 struct die_info
*die
;
8910 die
= (struct die_info
*) xmalloc (sizeof (struct die_info
));
8911 memset (die
, 0, sizeof (struct die_info
));
8916 /* Macro support. */
8919 /* Return the full name of file number I in *LH's file name table.
8920 Use COMP_DIR as the name of the current directory of the
8921 compilation. The result is allocated using xmalloc; the caller is
8922 responsible for freeing it. */
8924 file_full_name (int file
, struct line_header
*lh
, const char *comp_dir
)
8926 /* Is the file number a valid index into the line header's file name
8927 table? Remember that file numbers start with one, not zero. */
8928 if (1 <= file
&& file
<= lh
->num_file_names
)
8930 struct file_entry
*fe
= &lh
->file_names
[file
- 1];
8932 if (IS_ABSOLUTE_PATH (fe
->name
))
8933 return xstrdup (fe
->name
);
8941 dir
= lh
->include_dirs
[fe
->dir_index
- 1];
8947 dir_len
= strlen (dir
);
8948 full_name
= xmalloc (dir_len
+ 1 + strlen (fe
->name
) + 1);
8949 strcpy (full_name
, dir
);
8950 full_name
[dir_len
] = '/';
8951 strcpy (full_name
+ dir_len
+ 1, fe
->name
);
8955 return xstrdup (fe
->name
);
8960 /* The compiler produced a bogus file number. We can at least
8961 record the macro definitions made in the file, even if we
8962 won't be able to find the file by name. */
8964 sprintf (fake_name
, "<bad macro file number %d>", file
);
8966 complaint (&symfile_complaints
,
8967 _("bad file number in macro information (%d)"),
8970 return xstrdup (fake_name
);
8975 static struct macro_source_file
*
8976 macro_start_file (int file
, int line
,
8977 struct macro_source_file
*current_file
,
8978 const char *comp_dir
,
8979 struct line_header
*lh
, struct objfile
*objfile
)
8981 /* The full name of this source file. */
8982 char *full_name
= file_full_name (file
, lh
, comp_dir
);
8984 /* We don't create a macro table for this compilation unit
8985 at all until we actually get a filename. */
8986 if (! pending_macros
)
8987 pending_macros
= new_macro_table (&objfile
->objfile_obstack
,
8988 objfile
->macro_cache
);
8991 /* If we have no current file, then this must be the start_file
8992 directive for the compilation unit's main source file. */
8993 current_file
= macro_set_main (pending_macros
, full_name
);
8995 current_file
= macro_include (current_file
, line
, full_name
);
8999 return current_file
;
9003 /* Copy the LEN characters at BUF to a xmalloc'ed block of memory,
9004 followed by a null byte. */
9006 copy_string (const char *buf
, int len
)
9008 char *s
= xmalloc (len
+ 1);
9009 memcpy (s
, buf
, len
);
9017 consume_improper_spaces (const char *p
, const char *body
)
9021 complaint (&symfile_complaints
,
9022 _("macro definition contains spaces in formal argument list:\n`%s'"),
9034 parse_macro_definition (struct macro_source_file
*file
, int line
,
9039 /* The body string takes one of two forms. For object-like macro
9040 definitions, it should be:
9042 <macro name> " " <definition>
9044 For function-like macro definitions, it should be:
9046 <macro name> "() " <definition>
9048 <macro name> "(" <arg name> ( "," <arg name> ) * ") " <definition>
9050 Spaces may appear only where explicitly indicated, and in the
9053 The Dwarf 2 spec says that an object-like macro's name is always
9054 followed by a space, but versions of GCC around March 2002 omit
9055 the space when the macro's definition is the empty string.
9057 The Dwarf 2 spec says that there should be no spaces between the
9058 formal arguments in a function-like macro's formal argument list,
9059 but versions of GCC around March 2002 include spaces after the
9063 /* Find the extent of the macro name. The macro name is terminated
9064 by either a space or null character (for an object-like macro) or
9065 an opening paren (for a function-like macro). */
9066 for (p
= body
; *p
; p
++)
9067 if (*p
== ' ' || *p
== '(')
9070 if (*p
== ' ' || *p
== '\0')
9072 /* It's an object-like macro. */
9073 int name_len
= p
- body
;
9074 char *name
= copy_string (body
, name_len
);
9075 const char *replacement
;
9078 replacement
= body
+ name_len
+ 1;
9081 dwarf2_macro_malformed_definition_complaint (body
);
9082 replacement
= body
+ name_len
;
9085 macro_define_object (file
, line
, name
, replacement
);
9091 /* It's a function-like macro. */
9092 char *name
= copy_string (body
, p
- body
);
9095 char **argv
= xmalloc (argv_size
* sizeof (*argv
));
9099 p
= consume_improper_spaces (p
, body
);
9101 /* Parse the formal argument list. */
9102 while (*p
&& *p
!= ')')
9104 /* Find the extent of the current argument name. */
9105 const char *arg_start
= p
;
9107 while (*p
&& *p
!= ',' && *p
!= ')' && *p
!= ' ')
9110 if (! *p
|| p
== arg_start
)
9111 dwarf2_macro_malformed_definition_complaint (body
);
9114 /* Make sure argv has room for the new argument. */
9115 if (argc
>= argv_size
)
9118 argv
= xrealloc (argv
, argv_size
* sizeof (*argv
));
9121 argv
[argc
++] = copy_string (arg_start
, p
- arg_start
);
9124 p
= consume_improper_spaces (p
, body
);
9126 /* Consume the comma, if present. */
9131 p
= consume_improper_spaces (p
, body
);
9140 /* Perfectly formed definition, no complaints. */
9141 macro_define_function (file
, line
, name
,
9142 argc
, (const char **) argv
,
9144 else if (*p
== '\0')
9146 /* Complain, but do define it. */
9147 dwarf2_macro_malformed_definition_complaint (body
);
9148 macro_define_function (file
, line
, name
,
9149 argc
, (const char **) argv
,
9153 /* Just complain. */
9154 dwarf2_macro_malformed_definition_complaint (body
);
9157 /* Just complain. */
9158 dwarf2_macro_malformed_definition_complaint (body
);
9164 for (i
= 0; i
< argc
; i
++)
9170 dwarf2_macro_malformed_definition_complaint (body
);
9175 dwarf_decode_macros (struct line_header
*lh
, unsigned int offset
,
9176 char *comp_dir
, bfd
*abfd
,
9177 struct dwarf2_cu
*cu
)
9179 gdb_byte
*mac_ptr
, *mac_end
;
9180 struct macro_source_file
*current_file
= 0;
9182 if (dwarf2_per_objfile
->macinfo_buffer
== NULL
)
9184 complaint (&symfile_complaints
, _("missing .debug_macinfo section"));
9188 mac_ptr
= dwarf2_per_objfile
->macinfo_buffer
+ offset
;
9189 mac_end
= dwarf2_per_objfile
->macinfo_buffer
9190 + dwarf2_per_objfile
->macinfo_size
;
9194 enum dwarf_macinfo_record_type macinfo_type
;
9196 /* Do we at least have room for a macinfo type byte? */
9197 if (mac_ptr
>= mac_end
)
9199 dwarf2_macros_too_long_complaint ();
9203 macinfo_type
= read_1_byte (abfd
, mac_ptr
);
9206 switch (macinfo_type
)
9208 /* A zero macinfo type indicates the end of the macro
9213 case DW_MACINFO_define
:
9214 case DW_MACINFO_undef
:
9216 unsigned int bytes_read
;
9220 line
= read_unsigned_leb128 (abfd
, mac_ptr
, &bytes_read
);
9221 mac_ptr
+= bytes_read
;
9222 body
= read_string (abfd
, mac_ptr
, &bytes_read
);
9223 mac_ptr
+= bytes_read
;
9226 complaint (&symfile_complaints
,
9227 _("debug info gives macro %s outside of any file: %s"),
9229 DW_MACINFO_define
? "definition" : macinfo_type
==
9230 DW_MACINFO_undef
? "undefinition" :
9231 "something-or-other", body
);
9234 if (macinfo_type
== DW_MACINFO_define
)
9235 parse_macro_definition (current_file
, line
, body
);
9236 else if (macinfo_type
== DW_MACINFO_undef
)
9237 macro_undef (current_file
, line
, body
);
9242 case DW_MACINFO_start_file
:
9244 unsigned int bytes_read
;
9247 line
= read_unsigned_leb128 (abfd
, mac_ptr
, &bytes_read
);
9248 mac_ptr
+= bytes_read
;
9249 file
= read_unsigned_leb128 (abfd
, mac_ptr
, &bytes_read
);
9250 mac_ptr
+= bytes_read
;
9252 current_file
= macro_start_file (file
, line
,
9253 current_file
, comp_dir
,
9258 case DW_MACINFO_end_file
:
9260 complaint (&symfile_complaints
,
9261 _("macro debug info has an unmatched `close_file' directive"));
9264 current_file
= current_file
->included_by
;
9267 enum dwarf_macinfo_record_type next_type
;
9269 /* GCC circa March 2002 doesn't produce the zero
9270 type byte marking the end of the compilation
9271 unit. Complain if it's not there, but exit no
9274 /* Do we at least have room for a macinfo type byte? */
9275 if (mac_ptr
>= mac_end
)
9277 dwarf2_macros_too_long_complaint ();
9281 /* We don't increment mac_ptr here, so this is just
9283 next_type
= read_1_byte (abfd
, mac_ptr
);
9285 complaint (&symfile_complaints
,
9286 _("no terminating 0-type entry for macros in `.debug_macinfo' section"));
9293 case DW_MACINFO_vendor_ext
:
9295 unsigned int bytes_read
;
9299 constant
= read_unsigned_leb128 (abfd
, mac_ptr
, &bytes_read
);
9300 mac_ptr
+= bytes_read
;
9301 string
= read_string (abfd
, mac_ptr
, &bytes_read
);
9302 mac_ptr
+= bytes_read
;
9304 /* We don't recognize any vendor extensions. */
9311 /* Check if the attribute's form is a DW_FORM_block*
9312 if so return true else false. */
9314 attr_form_is_block (struct attribute
*attr
)
9316 return (attr
== NULL
? 0 :
9317 attr
->form
== DW_FORM_block1
9318 || attr
->form
== DW_FORM_block2
9319 || attr
->form
== DW_FORM_block4
9320 || attr
->form
== DW_FORM_block
);
9324 dwarf2_symbol_mark_computed (struct attribute
*attr
, struct symbol
*sym
,
9325 struct dwarf2_cu
*cu
)
9327 if (attr
->form
== DW_FORM_data4
|| attr
->form
== DW_FORM_data8
)
9329 struct dwarf2_loclist_baton
*baton
;
9331 baton
= obstack_alloc (&cu
->objfile
->objfile_obstack
,
9332 sizeof (struct dwarf2_loclist_baton
));
9333 baton
->objfile
= cu
->objfile
;
9335 /* We don't know how long the location list is, but make sure we
9336 don't run off the edge of the section. */
9337 baton
->size
= dwarf2_per_objfile
->loc_size
- DW_UNSND (attr
);
9338 baton
->data
= dwarf2_per_objfile
->loc_buffer
+ DW_UNSND (attr
);
9339 baton
->base_address
= cu
->header
.base_address
;
9340 if (cu
->header
.base_known
== 0)
9341 complaint (&symfile_complaints
,
9342 _("Location list used without specifying the CU base address."));
9344 SYMBOL_OPS (sym
) = &dwarf2_loclist_funcs
;
9345 SYMBOL_LOCATION_BATON (sym
) = baton
;
9349 struct dwarf2_locexpr_baton
*baton
;
9351 baton
= obstack_alloc (&cu
->objfile
->objfile_obstack
,
9352 sizeof (struct dwarf2_locexpr_baton
));
9353 baton
->objfile
= cu
->objfile
;
9355 if (attr_form_is_block (attr
))
9357 /* Note that we're just copying the block's data pointer
9358 here, not the actual data. We're still pointing into the
9359 info_buffer for SYM's objfile; right now we never release
9360 that buffer, but when we do clean up properly this may
9362 baton
->size
= DW_BLOCK (attr
)->size
;
9363 baton
->data
= DW_BLOCK (attr
)->data
;
9367 dwarf2_invalid_attrib_class_complaint ("location description",
9368 SYMBOL_NATURAL_NAME (sym
));
9373 SYMBOL_OPS (sym
) = &dwarf2_locexpr_funcs
;
9374 SYMBOL_LOCATION_BATON (sym
) = baton
;
9378 /* Locate the compilation unit from CU's objfile which contains the
9379 DIE at OFFSET. Raises an error on failure. */
9381 static struct dwarf2_per_cu_data
*
9382 dwarf2_find_containing_comp_unit (unsigned long offset
,
9383 struct objfile
*objfile
)
9385 struct dwarf2_per_cu_data
*this_cu
;
9389 high
= dwarf2_per_objfile
->n_comp_units
- 1;
9392 int mid
= low
+ (high
- low
) / 2;
9393 if (dwarf2_per_objfile
->all_comp_units
[mid
]->offset
>= offset
)
9398 gdb_assert (low
== high
);
9399 if (dwarf2_per_objfile
->all_comp_units
[low
]->offset
> offset
)
9402 error (_("Dwarf Error: could not find partial DIE containing "
9403 "offset 0x%lx [in module %s]"),
9404 (long) offset
, bfd_get_filename (objfile
->obfd
));
9406 gdb_assert (dwarf2_per_objfile
->all_comp_units
[low
-1]->offset
<= offset
);
9407 return dwarf2_per_objfile
->all_comp_units
[low
-1];
9411 this_cu
= dwarf2_per_objfile
->all_comp_units
[low
];
9412 if (low
== dwarf2_per_objfile
->n_comp_units
- 1
9413 && offset
>= this_cu
->offset
+ this_cu
->length
)
9414 error (_("invalid dwarf2 offset %ld"), offset
);
9415 gdb_assert (offset
< this_cu
->offset
+ this_cu
->length
);
9420 /* Locate the compilation unit from OBJFILE which is located at exactly
9421 OFFSET. Raises an error on failure. */
9423 static struct dwarf2_per_cu_data
*
9424 dwarf2_find_comp_unit (unsigned long offset
, struct objfile
*objfile
)
9426 struct dwarf2_per_cu_data
*this_cu
;
9427 this_cu
= dwarf2_find_containing_comp_unit (offset
, objfile
);
9428 if (this_cu
->offset
!= offset
)
9429 error (_("no compilation unit with offset %ld."), offset
);
9433 /* Release one cached compilation unit, CU. We unlink it from the tree
9434 of compilation units, but we don't remove it from the read_in_chain;
9435 the caller is responsible for that. */
9438 free_one_comp_unit (void *data
)
9440 struct dwarf2_cu
*cu
= data
;
9442 if (cu
->per_cu
!= NULL
)
9443 cu
->per_cu
->cu
= NULL
;
9446 obstack_free (&cu
->comp_unit_obstack
, NULL
);
9448 free_die_list (cu
->dies
);
9453 /* This cleanup function is passed the address of a dwarf2_cu on the stack
9454 when we're finished with it. We can't free the pointer itself, but be
9455 sure to unlink it from the cache. Also release any associated storage
9456 and perform cache maintenance.
9458 Only used during partial symbol parsing. */
9461 free_stack_comp_unit (void *data
)
9463 struct dwarf2_cu
*cu
= data
;
9465 obstack_free (&cu
->comp_unit_obstack
, NULL
);
9466 cu
->partial_dies
= NULL
;
9468 if (cu
->per_cu
!= NULL
)
9470 /* This compilation unit is on the stack in our caller, so we
9471 should not xfree it. Just unlink it. */
9472 cu
->per_cu
->cu
= NULL
;
9475 /* If we had a per-cu pointer, then we may have other compilation
9476 units loaded, so age them now. */
9477 age_cached_comp_units ();
9481 /* Free all cached compilation units. */
9484 free_cached_comp_units (void *data
)
9486 struct dwarf2_per_cu_data
*per_cu
, **last_chain
;
9488 per_cu
= dwarf2_per_objfile
->read_in_chain
;
9489 last_chain
= &dwarf2_per_objfile
->read_in_chain
;
9490 while (per_cu
!= NULL
)
9492 struct dwarf2_per_cu_data
*next_cu
;
9494 next_cu
= per_cu
->cu
->read_in_chain
;
9496 free_one_comp_unit (per_cu
->cu
);
9497 *last_chain
= next_cu
;
9503 /* Increase the age counter on each cached compilation unit, and free
9504 any that are too old. */
9507 age_cached_comp_units (void)
9509 struct dwarf2_per_cu_data
*per_cu
, **last_chain
;
9511 dwarf2_clear_marks (dwarf2_per_objfile
->read_in_chain
);
9512 per_cu
= dwarf2_per_objfile
->read_in_chain
;
9513 while (per_cu
!= NULL
)
9515 per_cu
->cu
->last_used
++;
9516 if (per_cu
->cu
->last_used
<= dwarf2_max_cache_age
)
9517 dwarf2_mark (per_cu
->cu
);
9518 per_cu
= per_cu
->cu
->read_in_chain
;
9521 per_cu
= dwarf2_per_objfile
->read_in_chain
;
9522 last_chain
= &dwarf2_per_objfile
->read_in_chain
;
9523 while (per_cu
!= NULL
)
9525 struct dwarf2_per_cu_data
*next_cu
;
9527 next_cu
= per_cu
->cu
->read_in_chain
;
9529 if (!per_cu
->cu
->mark
)
9531 free_one_comp_unit (per_cu
->cu
);
9532 *last_chain
= next_cu
;
9535 last_chain
= &per_cu
->cu
->read_in_chain
;
9541 /* Remove a single compilation unit from the cache. */
9544 free_one_cached_comp_unit (void *target_cu
)
9546 struct dwarf2_per_cu_data
*per_cu
, **last_chain
;
9548 per_cu
= dwarf2_per_objfile
->read_in_chain
;
9549 last_chain
= &dwarf2_per_objfile
->read_in_chain
;
9550 while (per_cu
!= NULL
)
9552 struct dwarf2_per_cu_data
*next_cu
;
9554 next_cu
= per_cu
->cu
->read_in_chain
;
9556 if (per_cu
->cu
== target_cu
)
9558 free_one_comp_unit (per_cu
->cu
);
9559 *last_chain
= next_cu
;
9563 last_chain
= &per_cu
->cu
->read_in_chain
;
9569 /* A pair of DIE offset and GDB type pointer. We store these
9570 in a hash table separate from the DIEs, and preserve them
9571 when the DIEs are flushed out of cache. */
9573 struct dwarf2_offset_and_type
9575 unsigned int offset
;
9579 /* Hash function for a dwarf2_offset_and_type. */
9582 offset_and_type_hash (const void *item
)
9584 const struct dwarf2_offset_and_type
*ofs
= item
;
9588 /* Equality function for a dwarf2_offset_and_type. */
9591 offset_and_type_eq (const void *item_lhs
, const void *item_rhs
)
9593 const struct dwarf2_offset_and_type
*ofs_lhs
= item_lhs
;
9594 const struct dwarf2_offset_and_type
*ofs_rhs
= item_rhs
;
9595 return ofs_lhs
->offset
== ofs_rhs
->offset
;
9598 /* Set the type associated with DIE to TYPE. Save it in CU's hash
9599 table if necessary. */
9602 set_die_type (struct die_info
*die
, struct type
*type
, struct dwarf2_cu
*cu
)
9604 struct dwarf2_offset_and_type
**slot
, ofs
;
9608 if (cu
->per_cu
== NULL
)
9611 if (cu
->per_cu
->type_hash
== NULL
)
9612 cu
->per_cu
->type_hash
9613 = htab_create_alloc_ex (cu
->header
.length
/ 24,
9614 offset_and_type_hash
,
9617 &cu
->objfile
->objfile_obstack
,
9618 hashtab_obstack_allocate
,
9619 dummy_obstack_deallocate
);
9621 ofs
.offset
= die
->offset
;
9623 slot
= (struct dwarf2_offset_and_type
**)
9624 htab_find_slot_with_hash (cu
->per_cu
->type_hash
, &ofs
, ofs
.offset
, INSERT
);
9625 *slot
= obstack_alloc (&cu
->objfile
->objfile_obstack
, sizeof (**slot
));
9629 /* Find the type for DIE in TYPE_HASH, or return NULL if DIE does not
9630 have a saved type. */
9632 static struct type
*
9633 get_die_type (struct die_info
*die
, htab_t type_hash
)
9635 struct dwarf2_offset_and_type
*slot
, ofs
;
9637 ofs
.offset
= die
->offset
;
9638 slot
= htab_find_with_hash (type_hash
, &ofs
, ofs
.offset
);
9645 /* Restore the types of the DIE tree starting at START_DIE from the hash
9646 table saved in CU. */
9649 reset_die_and_siblings_types (struct die_info
*start_die
, struct dwarf2_cu
*cu
)
9651 struct die_info
*die
;
9653 if (cu
->per_cu
->type_hash
== NULL
)
9656 for (die
= start_die
; die
!= NULL
; die
= die
->sibling
)
9658 die
->type
= get_die_type (die
, cu
->per_cu
->type_hash
);
9659 if (die
->child
!= NULL
)
9660 reset_die_and_siblings_types (die
->child
, cu
);
9664 /* Set the mark field in CU and in every other compilation unit in the
9665 cache that we must keep because we are keeping CU. */
9667 /* Add a dependence relationship from CU to REF_PER_CU. */
9670 dwarf2_add_dependence (struct dwarf2_cu
*cu
,
9671 struct dwarf2_per_cu_data
*ref_per_cu
)
9675 if (cu
->dependencies
== NULL
)
9677 = htab_create_alloc_ex (5, htab_hash_pointer
, htab_eq_pointer
,
9678 NULL
, &cu
->comp_unit_obstack
,
9679 hashtab_obstack_allocate
,
9680 dummy_obstack_deallocate
);
9682 slot
= htab_find_slot (cu
->dependencies
, ref_per_cu
, INSERT
);
9687 /* Set the mark field in CU and in every other compilation unit in the
9688 cache that we must keep because we are keeping CU. */
9691 dwarf2_mark_helper (void **slot
, void *data
)
9693 struct dwarf2_per_cu_data
*per_cu
;
9695 per_cu
= (struct dwarf2_per_cu_data
*) *slot
;
9696 if (per_cu
->cu
->mark
)
9698 per_cu
->cu
->mark
= 1;
9700 if (per_cu
->cu
->dependencies
!= NULL
)
9701 htab_traverse (per_cu
->cu
->dependencies
, dwarf2_mark_helper
, NULL
);
9707 dwarf2_mark (struct dwarf2_cu
*cu
)
9712 if (cu
->dependencies
!= NULL
)
9713 htab_traverse (cu
->dependencies
, dwarf2_mark_helper
, NULL
);
9717 dwarf2_clear_marks (struct dwarf2_per_cu_data
*per_cu
)
9721 per_cu
->cu
->mark
= 0;
9722 per_cu
= per_cu
->cu
->read_in_chain
;
9726 /* Trivial hash function for partial_die_info: the hash value of a DIE
9727 is its offset in .debug_info for this objfile. */
9730 partial_die_hash (const void *item
)
9732 const struct partial_die_info
*part_die
= item
;
9733 return part_die
->offset
;
9736 /* Trivial comparison function for partial_die_info structures: two DIEs
9737 are equal if they have the same offset. */
9740 partial_die_eq (const void *item_lhs
, const void *item_rhs
)
9742 const struct partial_die_info
*part_die_lhs
= item_lhs
;
9743 const struct partial_die_info
*part_die_rhs
= item_rhs
;
9744 return part_die_lhs
->offset
== part_die_rhs
->offset
;
9747 static struct cmd_list_element
*set_dwarf2_cmdlist
;
9748 static struct cmd_list_element
*show_dwarf2_cmdlist
;
9751 set_dwarf2_cmd (char *args
, int from_tty
)
9753 help_list (set_dwarf2_cmdlist
, "maintenance set dwarf2 ", -1, gdb_stdout
);
9757 show_dwarf2_cmd (char *args
, int from_tty
)
9759 cmd_show_list (show_dwarf2_cmdlist
, from_tty
, "");
9762 void _initialize_dwarf2_read (void);
9765 _initialize_dwarf2_read (void)
9767 dwarf2_objfile_data_key
= register_objfile_data ();
9769 add_prefix_cmd ("dwarf2", class_maintenance
, set_dwarf2_cmd
, _("\
9770 Set DWARF 2 specific variables.\n\
9771 Configure DWARF 2 variables such as the cache size"),
9772 &set_dwarf2_cmdlist
, "maintenance set dwarf2 ",
9773 0/*allow-unknown*/, &maintenance_set_cmdlist
);
9775 add_prefix_cmd ("dwarf2", class_maintenance
, show_dwarf2_cmd
, _("\
9776 Show DWARF 2 specific variables\n\
9777 Show DWARF 2 variables such as the cache size"),
9778 &show_dwarf2_cmdlist
, "maintenance show dwarf2 ",
9779 0/*allow-unknown*/, &maintenance_show_cmdlist
);
9781 add_setshow_zinteger_cmd ("max-cache-age", class_obscure
,
9782 &dwarf2_max_cache_age
, _("\
9783 Set the upper bound on the age of cached dwarf2 compilation units."), _("\
9784 Show the upper bound on the age of cached dwarf2 compilation units."), _("\
9785 A higher limit means that cached compilation units will be stored\n\
9786 in memory longer, and more total memory will be used. Zero disables\n\
9787 caching, which can slow down startup."),
9789 show_dwarf2_max_cache_age
,
9790 &set_dwarf2_cmdlist
,
9791 &show_dwarf2_cmdlist
);