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