1 /* DWARF 2 debugging format support for GDB.
3 Copyright (C) 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003,
4 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2011
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
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 3 of the License, or
19 (at your option) any later version.
21 This program is distributed in the hope that it will be useful,
22 but WITHOUT ANY WARRANTY; without even the implied warranty of
23 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
24 GNU 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, see <http://www.gnu.org/licenses/>. */
37 #include "expression.h"
38 #include "filenames.h" /* for DOSish file names */
41 #include "complaints.h"
43 #include "dwarf2expr.h"
44 #include "dwarf2loc.h"
45 #include "cp-support.h"
51 #include "typeprint.h"
54 #include "exceptions.h"
56 #include "completer.h"
63 #include "gdb_string.h"
64 #include "gdb_assert.h"
65 #include <sys/types.h>
72 #define MAP_FAILED ((void *) -1)
76 typedef struct symbol
*symbolp
;
80 /* .debug_info header for a compilation unit
81 Because of alignment constraints, this structure has padding and cannot
82 be mapped directly onto the beginning of the .debug_info section. */
83 typedef struct comp_unit_header
85 unsigned int length
; /* length of the .debug_info
87 unsigned short version
; /* version number -- 2 for DWARF
89 unsigned int abbrev_offset
; /* offset into .debug_abbrev section */
90 unsigned char addr_size
; /* byte size of an address -- 4 */
93 #define _ACTUAL_COMP_UNIT_HEADER_SIZE 11
96 /* .debug_line statement program prologue
97 Because of alignment constraints, this structure has padding and cannot
98 be mapped directly onto the beginning of the .debug_info section. */
99 typedef struct statement_prologue
101 unsigned int total_length
; /* byte length of the statement
103 unsigned short version
; /* version number -- 2 for DWARF
105 unsigned int prologue_length
; /* # bytes between prologue &
107 unsigned char minimum_instruction_length
; /* byte size of
109 unsigned char default_is_stmt
; /* initial value of is_stmt
112 unsigned char line_range
;
113 unsigned char opcode_base
; /* number assigned to first special
115 unsigned char *standard_opcode_lengths
;
119 /* When non-zero, dump DIEs after they are read in. */
120 static int dwarf2_die_debug
= 0;
122 /* When non-zero, cross-check physname against demangler. */
123 static int check_physname
= 0;
127 /* When set, the file that we're processing is known to have debugging
128 info for C++ namespaces. GCC 3.3.x did not produce this information,
129 but later versions do. */
131 static int processing_has_namespace_info
;
133 static const struct objfile_data
*dwarf2_objfile_data_key
;
135 struct dwarf2_section_info
140 /* Not NULL if the section was actually mmapped. */
142 /* Page aligned size of mmapped area. */
143 bfd_size_type map_len
;
144 /* True if we have tried to read this section. */
148 typedef struct dwarf2_section_info dwarf2_section_info_def
;
149 DEF_VEC_O (dwarf2_section_info_def
);
151 /* All offsets in the index are of this type. It must be
152 architecture-independent. */
153 typedef uint32_t offset_type
;
155 DEF_VEC_I (offset_type
);
157 /* A description of the mapped index. The file format is described in
158 a comment by the code that writes the index. */
161 /* Index data format version. */
164 /* The total length of the buffer. */
167 /* A pointer to the address table data. */
168 const gdb_byte
*address_table
;
170 /* Size of the address table data in bytes. */
171 offset_type address_table_size
;
173 /* The symbol table, implemented as a hash table. */
174 const offset_type
*symbol_table
;
176 /* Size in slots, each slot is 2 offset_types. */
177 offset_type symbol_table_slots
;
179 /* A pointer to the constant pool. */
180 const char *constant_pool
;
183 struct dwarf2_per_objfile
185 struct dwarf2_section_info info
;
186 struct dwarf2_section_info abbrev
;
187 struct dwarf2_section_info line
;
188 struct dwarf2_section_info loc
;
189 struct dwarf2_section_info macinfo
;
190 struct dwarf2_section_info macro
;
191 struct dwarf2_section_info str
;
192 struct dwarf2_section_info ranges
;
193 struct dwarf2_section_info frame
;
194 struct dwarf2_section_info eh_frame
;
195 struct dwarf2_section_info gdb_index
;
197 VEC (dwarf2_section_info_def
) *types
;
200 struct objfile
*objfile
;
202 /* A list of all the compilation units. This is used to locate
203 the target compilation unit of a particular reference. */
204 struct dwarf2_per_cu_data
**all_comp_units
;
206 /* The number of compilation units in ALL_COMP_UNITS. */
209 /* The number of .debug_types-related CUs. */
210 int n_type_comp_units
;
212 /* The .debug_types-related CUs. */
213 struct dwarf2_per_cu_data
**type_comp_units
;
215 /* A chain of compilation units that are currently read in, so that
216 they can be freed later. */
217 struct dwarf2_per_cu_data
*read_in_chain
;
219 /* A table mapping .debug_types signatures to its signatured_type entry.
220 This is NULL if the .debug_types section hasn't been read in yet. */
221 htab_t signatured_types
;
223 /* A flag indicating wether this objfile has a section loaded at a
225 int has_section_at_zero
;
227 /* True if we are using the mapped index,
228 or we are faking it for OBJF_READNOW's sake. */
229 unsigned char using_index
;
231 /* The mapped index, or NULL if .gdb_index is missing or not being used. */
232 struct mapped_index
*index_table
;
234 /* When using index_table, this keeps track of all quick_file_names entries.
235 TUs can share line table entries with CUs or other TUs, and there can be
236 a lot more TUs than unique line tables, so we maintain a separate table
237 of all line table entries to support the sharing. */
238 htab_t quick_file_names_table
;
240 /* Set during partial symbol reading, to prevent queueing of full
242 int reading_partial_symbols
;
244 /* Table mapping type .debug_info DIE offsets to types.
245 This is NULL if not allocated yet.
246 It (currently) makes sense to allocate debug_types_type_hash lazily.
247 To keep things simple we allocate both lazily. */
248 htab_t debug_info_type_hash
;
250 /* Table mapping type .debug_types DIE offsets to types.
251 This is NULL if not allocated yet. */
252 htab_t debug_types_type_hash
;
255 static struct dwarf2_per_objfile
*dwarf2_per_objfile
;
257 /* Default names of the debugging sections. */
259 /* Note that if the debugging section has been compressed, it might
260 have a name like .zdebug_info. */
262 static const struct dwarf2_debug_sections dwarf2_elf_names
= {
263 { ".debug_info", ".zdebug_info" },
264 { ".debug_abbrev", ".zdebug_abbrev" },
265 { ".debug_line", ".zdebug_line" },
266 { ".debug_loc", ".zdebug_loc" },
267 { ".debug_macinfo", ".zdebug_macinfo" },
268 { ".debug_macro", ".zdebug_macro" },
269 { ".debug_str", ".zdebug_str" },
270 { ".debug_ranges", ".zdebug_ranges" },
271 { ".debug_types", ".zdebug_types" },
272 { ".debug_frame", ".zdebug_frame" },
273 { ".eh_frame", NULL
},
274 { ".gdb_index", ".zgdb_index" },
278 /* local data types */
280 /* We hold several abbreviation tables in memory at the same time. */
281 #ifndef ABBREV_HASH_SIZE
282 #define ABBREV_HASH_SIZE 121
285 /* The data in a compilation unit header, after target2host
286 translation, looks like this. */
287 struct comp_unit_head
291 unsigned char addr_size
;
292 unsigned char signed_addr_p
;
293 unsigned int abbrev_offset
;
295 /* Size of file offsets; either 4 or 8. */
296 unsigned int offset_size
;
298 /* Size of the length field; either 4 or 12. */
299 unsigned int initial_length_size
;
301 /* Offset to the first byte of this compilation unit header in the
302 .debug_info section, for resolving relative reference dies. */
305 /* Offset to first die in this cu from the start of the cu.
306 This will be the first byte following the compilation unit header. */
307 unsigned int first_die_offset
;
310 /* Type used for delaying computation of method physnames.
311 See comments for compute_delayed_physnames. */
312 struct delayed_method_info
314 /* The type to which the method is attached, i.e., its parent class. */
317 /* The index of the method in the type's function fieldlists. */
320 /* The index of the method in the fieldlist. */
323 /* The name of the DIE. */
326 /* The DIE associated with this method. */
327 struct die_info
*die
;
330 typedef struct delayed_method_info delayed_method_info
;
331 DEF_VEC_O (delayed_method_info
);
333 /* Internal state when decoding a particular compilation unit. */
336 /* The objfile containing this compilation unit. */
337 struct objfile
*objfile
;
339 /* The header of the compilation unit. */
340 struct comp_unit_head header
;
342 /* Base address of this compilation unit. */
343 CORE_ADDR base_address
;
345 /* Non-zero if base_address has been set. */
348 struct function_range
*first_fn
, *last_fn
, *cached_fn
;
350 /* The language we are debugging. */
351 enum language language
;
352 const struct language_defn
*language_defn
;
354 const char *producer
;
356 /* The generic symbol table building routines have separate lists for
357 file scope symbols and all all other scopes (local scopes). So
358 we need to select the right one to pass to add_symbol_to_list().
359 We do it by keeping a pointer to the correct list in list_in_scope.
361 FIXME: The original dwarf code just treated the file scope as the
362 first local scope, and all other local scopes as nested local
363 scopes, and worked fine. Check to see if we really need to
364 distinguish these in buildsym.c. */
365 struct pending
**list_in_scope
;
367 /* DWARF abbreviation table associated with this compilation unit. */
368 struct abbrev_info
**dwarf2_abbrevs
;
370 /* Storage for the abbrev table. */
371 struct obstack abbrev_obstack
;
373 /* Hash table holding all the loaded partial DIEs. */
376 /* Storage for things with the same lifetime as this read-in compilation
377 unit, including partial DIEs. */
378 struct obstack comp_unit_obstack
;
380 /* When multiple dwarf2_cu structures are living in memory, this field
381 chains them all together, so that they can be released efficiently.
382 We will probably also want a generation counter so that most-recently-used
383 compilation units are cached... */
384 struct dwarf2_per_cu_data
*read_in_chain
;
386 /* Backchain to our per_cu entry if the tree has been built. */
387 struct dwarf2_per_cu_data
*per_cu
;
389 /* How many compilation units ago was this CU last referenced? */
392 /* A hash table of die offsets for following references. */
395 /* Full DIEs if read in. */
396 struct die_info
*dies
;
398 /* A set of pointers to dwarf2_per_cu_data objects for compilation
399 units referenced by this one. Only set during full symbol processing;
400 partial symbol tables do not have dependencies. */
403 /* Header data from the line table, during full symbol processing. */
404 struct line_header
*line_header
;
406 /* A list of methods which need to have physnames computed
407 after all type information has been read. */
408 VEC (delayed_method_info
) *method_list
;
410 /* Mark used when releasing cached dies. */
411 unsigned int mark
: 1;
413 /* This flag will be set if this compilation unit might include
414 inter-compilation-unit references. */
415 unsigned int has_form_ref_addr
: 1;
417 /* This flag will be set if this compilation unit includes any
418 DW_TAG_namespace DIEs. If we know that there are explicit
419 DIEs for namespaces, we don't need to try to infer them
420 from mangled names. */
421 unsigned int has_namespace_info
: 1;
423 /* This CU references .debug_loc. See the symtab->locations_valid field.
424 This test is imperfect as there may exist optimized debug code not using
425 any location list and still facing inlining issues if handled as
426 unoptimized code. For a future better test see GCC PR other/32998. */
428 unsigned int has_loclist
: 1;
431 /* Persistent data held for a compilation unit, even when not
432 processing it. We put a pointer to this structure in the
433 read_symtab_private field of the psymtab. If we encounter
434 inter-compilation-unit references, we also maintain a sorted
435 list of all compilation units. */
437 struct dwarf2_per_cu_data
439 /* The start offset and length of this compilation unit. 2**29-1
440 bytes should suffice to store the length of any compilation unit
441 - if it doesn't, GDB will fall over anyway.
442 NOTE: Unlike comp_unit_head.length, this length includes
443 initial_length_size. */
445 unsigned int length
: 29;
447 /* Flag indicating this compilation unit will be read in before
448 any of the current compilation units are processed. */
449 unsigned int queued
: 1;
451 /* This flag will be set if we need to load absolutely all DIEs
452 for this compilation unit, instead of just the ones we think
453 are interesting. It gets set if we look for a DIE in the
454 hash table and don't find it. */
455 unsigned int load_all_dies
: 1;
457 /* Non-null if this CU is from .debug_types; in which case it points
458 to the section. Otherwise it's from .debug_info. */
459 struct dwarf2_section_info
*debug_type_section
;
461 /* Set to non-NULL iff this CU is currently loaded. When it gets freed out
462 of the CU cache it gets reset to NULL again. */
463 struct dwarf2_cu
*cu
;
465 /* The corresponding objfile. */
466 struct objfile
*objfile
;
468 /* When using partial symbol tables, the 'psymtab' field is active.
469 Otherwise the 'quick' field is active. */
472 /* The partial symbol table associated with this compilation unit,
473 or NULL for partial units (which do not have an associated
475 struct partial_symtab
*psymtab
;
477 /* Data needed by the "quick" functions. */
478 struct dwarf2_per_cu_quick_data
*quick
;
482 /* Entry in the signatured_types hash table. */
484 struct signatured_type
488 /* Offset in .debug_types of the type defined by this TU. */
489 unsigned int type_offset
;
491 /* The CU(/TU) of this type. */
492 struct dwarf2_per_cu_data per_cu
;
495 /* Struct used to pass misc. parameters to read_die_and_children, et
496 al. which are used for both .debug_info and .debug_types dies.
497 All parameters here are unchanging for the life of the call. This
498 struct exists to abstract away the constant parameters of die
501 struct die_reader_specs
503 /* The bfd of this objfile. */
506 /* The CU of the DIE we are parsing. */
507 struct dwarf2_cu
*cu
;
509 /* Pointer to start of section buffer.
510 This is either the start of .debug_info or .debug_types. */
511 const gdb_byte
*buffer
;
514 /* The line number information for a compilation unit (found in the
515 .debug_line section) begins with a "statement program header",
516 which contains the following information. */
519 unsigned int total_length
;
520 unsigned short version
;
521 unsigned int header_length
;
522 unsigned char minimum_instruction_length
;
523 unsigned char maximum_ops_per_instruction
;
524 unsigned char default_is_stmt
;
526 unsigned char line_range
;
527 unsigned char opcode_base
;
529 /* standard_opcode_lengths[i] is the number of operands for the
530 standard opcode whose value is i. This means that
531 standard_opcode_lengths[0] is unused, and the last meaningful
532 element is standard_opcode_lengths[opcode_base - 1]. */
533 unsigned char *standard_opcode_lengths
;
535 /* The include_directories table. NOTE! These strings are not
536 allocated with xmalloc; instead, they are pointers into
537 debug_line_buffer. If you try to free them, `free' will get
539 unsigned int num_include_dirs
, include_dirs_size
;
542 /* The file_names table. NOTE! These strings are not allocated
543 with xmalloc; instead, they are pointers into debug_line_buffer.
544 Don't try to free them directly. */
545 unsigned int num_file_names
, file_names_size
;
549 unsigned int dir_index
;
550 unsigned int mod_time
;
552 int included_p
; /* Non-zero if referenced by the Line Number Program. */
553 struct symtab
*symtab
; /* The associated symbol table, if any. */
556 /* The start and end of the statement program following this
557 header. These point into dwarf2_per_objfile->line_buffer. */
558 gdb_byte
*statement_program_start
, *statement_program_end
;
561 /* When we construct a partial symbol table entry we only
562 need this much information. */
563 struct partial_die_info
565 /* Offset of this DIE. */
568 /* DWARF-2 tag for this DIE. */
569 ENUM_BITFIELD(dwarf_tag
) tag
: 16;
571 /* Assorted flags describing the data found in this DIE. */
572 unsigned int has_children
: 1;
573 unsigned int is_external
: 1;
574 unsigned int is_declaration
: 1;
575 unsigned int has_type
: 1;
576 unsigned int has_specification
: 1;
577 unsigned int has_pc_info
: 1;
579 /* Flag set if the SCOPE field of this structure has been
581 unsigned int scope_set
: 1;
583 /* Flag set if the DIE has a byte_size attribute. */
584 unsigned int has_byte_size
: 1;
586 /* Flag set if any of the DIE's children are template arguments. */
587 unsigned int has_template_arguments
: 1;
589 /* Flag set if fixup_partial_die has been called on this die. */
590 unsigned int fixup_called
: 1;
592 /* The name of this DIE. Normally the value of DW_AT_name, but
593 sometimes a default name for unnamed DIEs. */
596 /* The linkage name, if present. */
597 const char *linkage_name
;
599 /* The scope to prepend to our children. This is generally
600 allocated on the comp_unit_obstack, so will disappear
601 when this compilation unit leaves the cache. */
604 /* The location description associated with this DIE, if any. */
605 struct dwarf_block
*locdesc
;
607 /* If HAS_PC_INFO, the PC range associated with this DIE. */
611 /* Pointer into the info_buffer (or types_buffer) pointing at the target of
612 DW_AT_sibling, if any. */
613 /* NOTE: This member isn't strictly necessary, read_partial_die could
614 return DW_AT_sibling values to its caller load_partial_dies. */
617 /* If HAS_SPECIFICATION, the offset of the DIE referred to by
618 DW_AT_specification (or DW_AT_abstract_origin or
620 unsigned int spec_offset
;
622 /* Pointers to this DIE's parent, first child, and next sibling,
624 struct partial_die_info
*die_parent
, *die_child
, *die_sibling
;
627 /* This data structure holds the information of an abbrev. */
630 unsigned int number
; /* number identifying abbrev */
631 enum dwarf_tag tag
; /* dwarf tag */
632 unsigned short has_children
; /* boolean */
633 unsigned short num_attrs
; /* number of attributes */
634 struct attr_abbrev
*attrs
; /* an array of attribute descriptions */
635 struct abbrev_info
*next
; /* next in chain */
640 ENUM_BITFIELD(dwarf_attribute
) name
: 16;
641 ENUM_BITFIELD(dwarf_form
) form
: 16;
644 /* Attributes have a name and a value. */
647 ENUM_BITFIELD(dwarf_attribute
) name
: 16;
648 ENUM_BITFIELD(dwarf_form
) form
: 15;
650 /* Has DW_STRING already been updated by dwarf2_canonicalize_name? This
651 field should be in u.str (existing only for DW_STRING) but it is kept
652 here for better struct attribute alignment. */
653 unsigned int string_is_canonical
: 1;
658 struct dwarf_block
*blk
;
662 struct signatured_type
*signatured_type
;
667 /* This data structure holds a complete die structure. */
670 /* DWARF-2 tag for this DIE. */
671 ENUM_BITFIELD(dwarf_tag
) tag
: 16;
673 /* Number of attributes */
674 unsigned char num_attrs
;
676 /* True if we're presently building the full type name for the
677 type derived from this DIE. */
678 unsigned char building_fullname
: 1;
683 /* Offset in .debug_info or .debug_types section. */
686 /* The dies in a compilation unit form an n-ary tree. PARENT
687 points to this die's parent; CHILD points to the first child of
688 this node; and all the children of a given node are chained
689 together via their SIBLING fields. */
690 struct die_info
*child
; /* Its first child, if any. */
691 struct die_info
*sibling
; /* Its next sibling, if any. */
692 struct die_info
*parent
; /* Its parent, if any. */
694 /* An array of attributes, with NUM_ATTRS elements. There may be
695 zero, but it's not common and zero-sized arrays are not
696 sufficiently portable C. */
697 struct attribute attrs
[1];
700 struct function_range
703 CORE_ADDR lowpc
, highpc
;
705 struct function_range
*next
;
708 /* Get at parts of an attribute structure. */
710 #define DW_STRING(attr) ((attr)->u.str)
711 #define DW_STRING_IS_CANONICAL(attr) ((attr)->string_is_canonical)
712 #define DW_UNSND(attr) ((attr)->u.unsnd)
713 #define DW_BLOCK(attr) ((attr)->u.blk)
714 #define DW_SND(attr) ((attr)->u.snd)
715 #define DW_ADDR(attr) ((attr)->u.addr)
716 #define DW_SIGNATURED_TYPE(attr) ((attr)->u.signatured_type)
718 /* Blocks are a bunch of untyped bytes. */
725 #ifndef ATTR_ALLOC_CHUNK
726 #define ATTR_ALLOC_CHUNK 4
729 /* Allocate fields for structs, unions and enums in this size. */
730 #ifndef DW_FIELD_ALLOC_CHUNK
731 #define DW_FIELD_ALLOC_CHUNK 4
734 /* FIXME: We might want to set this from BFD via bfd_arch_bits_per_byte,
735 but this would require a corresponding change in unpack_field_as_long
737 static int bits_per_byte
= 8;
739 /* The routines that read and process dies for a C struct or C++ class
740 pass lists of data member fields and lists of member function fields
741 in an instance of a field_info structure, as defined below. */
744 /* List of data member and baseclasses fields. */
747 struct nextfield
*next
;
752 *fields
, *baseclasses
;
754 /* Number of fields (including baseclasses). */
757 /* Number of baseclasses. */
760 /* Set if the accesibility of one of the fields is not public. */
761 int non_public_fields
;
763 /* Member function fields array, entries are allocated in the order they
764 are encountered in the object file. */
767 struct nextfnfield
*next
;
768 struct fn_field fnfield
;
772 /* Member function fieldlist array, contains name of possibly overloaded
773 member function, number of overloaded member functions and a pointer
774 to the head of the member function field chain. */
779 struct nextfnfield
*head
;
783 /* Number of entries in the fnfieldlists array. */
786 /* typedefs defined inside this class. TYPEDEF_FIELD_LIST contains head of
787 a NULL terminated list of TYPEDEF_FIELD_LIST_COUNT elements. */
788 struct typedef_field_list
790 struct typedef_field field
;
791 struct typedef_field_list
*next
;
794 unsigned typedef_field_list_count
;
797 /* One item on the queue of compilation units to read in full symbols
799 struct dwarf2_queue_item
801 struct dwarf2_per_cu_data
*per_cu
;
802 struct dwarf2_queue_item
*next
;
805 /* The current queue. */
806 static struct dwarf2_queue_item
*dwarf2_queue
, *dwarf2_queue_tail
;
808 /* Loaded secondary compilation units are kept in memory until they
809 have not been referenced for the processing of this many
810 compilation units. Set this to zero to disable caching. Cache
811 sizes of up to at least twenty will improve startup time for
812 typical inter-CU-reference binaries, at an obvious memory cost. */
813 static int dwarf2_max_cache_age
= 5;
815 show_dwarf2_max_cache_age (struct ui_file
*file
, int from_tty
,
816 struct cmd_list_element
*c
, const char *value
)
818 fprintf_filtered (file
, _("The upper bound on the age of cached "
819 "dwarf2 compilation units is %s.\n"),
824 /* Various complaints about symbol reading that don't abort the process. */
827 dwarf2_statement_list_fits_in_line_number_section_complaint (void)
829 complaint (&symfile_complaints
,
830 _("statement list doesn't fit in .debug_line section"));
834 dwarf2_debug_line_missing_file_complaint (void)
836 complaint (&symfile_complaints
,
837 _(".debug_line section has line data without a file"));
841 dwarf2_debug_line_missing_end_sequence_complaint (void)
843 complaint (&symfile_complaints
,
844 _(".debug_line section has line "
845 "program sequence without an end"));
849 dwarf2_complex_location_expr_complaint (void)
851 complaint (&symfile_complaints
, _("location expression too complex"));
855 dwarf2_const_value_length_mismatch_complaint (const char *arg1
, int arg2
,
858 complaint (&symfile_complaints
,
859 _("const value length mismatch for '%s', got %d, expected %d"),
864 dwarf2_macros_too_long_complaint (struct dwarf2_section_info
*section
)
866 complaint (&symfile_complaints
,
867 _("macro info runs off end of `%s' section"),
868 section
->asection
->name
);
872 dwarf2_macro_malformed_definition_complaint (const char *arg1
)
874 complaint (&symfile_complaints
,
875 _("macro debug info contains a "
876 "malformed macro definition:\n`%s'"),
881 dwarf2_invalid_attrib_class_complaint (const char *arg1
, const char *arg2
)
883 complaint (&symfile_complaints
,
884 _("invalid attribute class or form for '%s' in '%s'"),
888 /* local function prototypes */
890 static void dwarf2_locate_sections (bfd
*, asection
*, void *);
892 static void dwarf2_create_include_psymtab (char *, struct partial_symtab
*,
895 static void dwarf2_find_base_address (struct die_info
*die
,
896 struct dwarf2_cu
*cu
);
898 static void dwarf2_build_psymtabs_hard (struct objfile
*);
900 static void scan_partial_symbols (struct partial_die_info
*,
901 CORE_ADDR
*, CORE_ADDR
*,
902 int, struct dwarf2_cu
*);
904 static void add_partial_symbol (struct partial_die_info
*,
907 static void add_partial_namespace (struct partial_die_info
*pdi
,
908 CORE_ADDR
*lowpc
, CORE_ADDR
*highpc
,
909 int need_pc
, struct dwarf2_cu
*cu
);
911 static void add_partial_module (struct partial_die_info
*pdi
, CORE_ADDR
*lowpc
,
912 CORE_ADDR
*highpc
, int need_pc
,
913 struct dwarf2_cu
*cu
);
915 static void add_partial_enumeration (struct partial_die_info
*enum_pdi
,
916 struct dwarf2_cu
*cu
);
918 static void add_partial_subprogram (struct partial_die_info
*pdi
,
919 CORE_ADDR
*lowpc
, CORE_ADDR
*highpc
,
920 int need_pc
, struct dwarf2_cu
*cu
);
922 static gdb_byte
*locate_pdi_sibling (struct partial_die_info
*orig_pdi
,
923 gdb_byte
*buffer
, gdb_byte
*info_ptr
,
924 bfd
*abfd
, struct dwarf2_cu
*cu
);
926 static void dwarf2_psymtab_to_symtab (struct partial_symtab
*);
928 static void psymtab_to_symtab_1 (struct partial_symtab
*);
930 static void dwarf2_read_abbrevs (bfd
*abfd
, struct dwarf2_cu
*cu
);
932 static void dwarf2_free_abbrev_table (void *);
934 static struct abbrev_info
*peek_die_abbrev (gdb_byte
*, unsigned int *,
937 static struct abbrev_info
*dwarf2_lookup_abbrev (unsigned int,
940 static struct partial_die_info
*load_partial_dies (bfd
*,
941 gdb_byte
*, gdb_byte
*,
942 int, struct dwarf2_cu
*);
944 static gdb_byte
*read_partial_die (struct partial_die_info
*,
945 struct abbrev_info
*abbrev
,
947 gdb_byte
*, gdb_byte
*,
950 static struct partial_die_info
*find_partial_die (unsigned int,
953 static void fixup_partial_die (struct partial_die_info
*,
956 static gdb_byte
*read_attribute (struct attribute
*, struct attr_abbrev
*,
957 bfd
*, gdb_byte
*, struct dwarf2_cu
*);
959 static gdb_byte
*read_attribute_value (struct attribute
*, unsigned,
960 bfd
*, gdb_byte
*, struct dwarf2_cu
*);
962 static unsigned int read_1_byte (bfd
*, gdb_byte
*);
964 static int read_1_signed_byte (bfd
*, gdb_byte
*);
966 static unsigned int read_2_bytes (bfd
*, gdb_byte
*);
968 static unsigned int read_4_bytes (bfd
*, gdb_byte
*);
970 static ULONGEST
read_8_bytes (bfd
*, gdb_byte
*);
972 static CORE_ADDR
read_address (bfd
*, gdb_byte
*ptr
, struct dwarf2_cu
*,
975 static LONGEST
read_initial_length (bfd
*, gdb_byte
*, unsigned int *);
977 static LONGEST read_checked_initial_length_and_offset
978 (bfd
*, gdb_byte
*, const struct comp_unit_head
*,
979 unsigned int *, unsigned int *);
981 static LONGEST
read_offset (bfd
*, gdb_byte
*, const struct comp_unit_head
*,
984 static LONGEST
read_offset_1 (bfd
*, gdb_byte
*, unsigned int);
986 static gdb_byte
*read_n_bytes (bfd
*, gdb_byte
*, unsigned int);
988 static char *read_direct_string (bfd
*, gdb_byte
*, unsigned int *);
990 static char *read_indirect_string (bfd
*, gdb_byte
*,
991 const struct comp_unit_head
*,
994 static unsigned long read_unsigned_leb128 (bfd
*, gdb_byte
*, unsigned int *);
996 static long read_signed_leb128 (bfd
*, gdb_byte
*, unsigned int *);
998 static gdb_byte
*skip_leb128 (bfd
*, gdb_byte
*);
1000 static void set_cu_language (unsigned int, struct dwarf2_cu
*);
1002 static struct attribute
*dwarf2_attr (struct die_info
*, unsigned int,
1003 struct dwarf2_cu
*);
1005 static struct attribute
*dwarf2_attr_no_follow (struct die_info
*,
1007 struct dwarf2_cu
*);
1009 static int dwarf2_flag_true_p (struct die_info
*die
, unsigned name
,
1010 struct dwarf2_cu
*cu
);
1012 static int die_is_declaration (struct die_info
*, struct dwarf2_cu
*cu
);
1014 static struct die_info
*die_specification (struct die_info
*die
,
1015 struct dwarf2_cu
**);
1017 static void free_line_header (struct line_header
*lh
);
1019 static void add_file_name (struct line_header
*, char *, unsigned int,
1020 unsigned int, unsigned int);
1022 static struct line_header
*(dwarf_decode_line_header
1023 (unsigned int offset
,
1024 bfd
*abfd
, struct dwarf2_cu
*cu
));
1026 static void dwarf_decode_lines (struct line_header
*, const char *, bfd
*,
1027 struct dwarf2_cu
*, struct partial_symtab
*);
1029 static void dwarf2_start_subfile (char *, const char *, const char *);
1031 static struct symbol
*new_symbol (struct die_info
*, struct type
*,
1032 struct dwarf2_cu
*);
1034 static struct symbol
*new_symbol_full (struct die_info
*, struct type
*,
1035 struct dwarf2_cu
*, struct symbol
*);
1037 static void dwarf2_const_value (struct attribute
*, struct symbol
*,
1038 struct dwarf2_cu
*);
1040 static void dwarf2_const_value_attr (struct attribute
*attr
,
1043 struct obstack
*obstack
,
1044 struct dwarf2_cu
*cu
, long *value
,
1046 struct dwarf2_locexpr_baton
**baton
);
1048 static struct type
*die_type (struct die_info
*, struct dwarf2_cu
*);
1050 static int need_gnat_info (struct dwarf2_cu
*);
1052 static struct type
*die_descriptive_type (struct die_info
*,
1053 struct dwarf2_cu
*);
1055 static void set_descriptive_type (struct type
*, struct die_info
*,
1056 struct dwarf2_cu
*);
1058 static struct type
*die_containing_type (struct die_info
*,
1059 struct dwarf2_cu
*);
1061 static struct type
*lookup_die_type (struct die_info
*, struct attribute
*,
1062 struct dwarf2_cu
*);
1064 static struct type
*read_type_die (struct die_info
*, struct dwarf2_cu
*);
1066 static struct type
*read_type_die_1 (struct die_info
*, struct dwarf2_cu
*);
1068 static char *determine_prefix (struct die_info
*die
, struct dwarf2_cu
*);
1070 static char *typename_concat (struct obstack
*obs
, const char *prefix
,
1071 const char *suffix
, int physname
,
1072 struct dwarf2_cu
*cu
);
1074 static void read_file_scope (struct die_info
*, struct dwarf2_cu
*);
1076 static void read_type_unit_scope (struct die_info
*, struct dwarf2_cu
*);
1078 static void read_func_scope (struct die_info
*, struct dwarf2_cu
*);
1080 static void read_lexical_block_scope (struct die_info
*, struct dwarf2_cu
*);
1082 static int dwarf2_ranges_read (unsigned, CORE_ADDR
*, CORE_ADDR
*,
1083 struct dwarf2_cu
*, struct partial_symtab
*);
1085 static int dwarf2_get_pc_bounds (struct die_info
*,
1086 CORE_ADDR
*, CORE_ADDR
*, struct dwarf2_cu
*,
1087 struct partial_symtab
*);
1089 static void get_scope_pc_bounds (struct die_info
*,
1090 CORE_ADDR
*, CORE_ADDR
*,
1091 struct dwarf2_cu
*);
1093 static void dwarf2_record_block_ranges (struct die_info
*, struct block
*,
1094 CORE_ADDR
, struct dwarf2_cu
*);
1096 static void dwarf2_add_field (struct field_info
*, struct die_info
*,
1097 struct dwarf2_cu
*);
1099 static void dwarf2_attach_fields_to_type (struct field_info
*,
1100 struct type
*, struct dwarf2_cu
*);
1102 static void dwarf2_add_member_fn (struct field_info
*,
1103 struct die_info
*, struct type
*,
1104 struct dwarf2_cu
*);
1106 static void dwarf2_attach_fn_fields_to_type (struct field_info
*,
1108 struct dwarf2_cu
*);
1110 static void process_structure_scope (struct die_info
*, struct dwarf2_cu
*);
1112 static void read_common_block (struct die_info
*, struct dwarf2_cu
*);
1114 static void read_namespace (struct die_info
*die
, struct dwarf2_cu
*);
1116 static void read_module (struct die_info
*die
, struct dwarf2_cu
*cu
);
1118 static void read_import_statement (struct die_info
*die
, struct dwarf2_cu
*);
1120 static struct type
*read_module_type (struct die_info
*die
,
1121 struct dwarf2_cu
*cu
);
1123 static const char *namespace_name (struct die_info
*die
,
1124 int *is_anonymous
, struct dwarf2_cu
*);
1126 static void process_enumeration_scope (struct die_info
*, struct dwarf2_cu
*);
1128 static CORE_ADDR
decode_locdesc (struct dwarf_block
*, struct dwarf2_cu
*);
1130 static enum dwarf_array_dim_ordering
read_array_order (struct die_info
*,
1131 struct dwarf2_cu
*);
1133 static struct die_info
*read_comp_unit (gdb_byte
*, struct dwarf2_cu
*);
1135 static struct die_info
*read_die_and_children_1 (const struct die_reader_specs
*reader
,
1137 gdb_byte
**new_info_ptr
,
1138 struct die_info
*parent
);
1140 static struct die_info
*read_die_and_children (const struct die_reader_specs
*reader
,
1142 gdb_byte
**new_info_ptr
,
1143 struct die_info
*parent
);
1145 static struct die_info
*read_die_and_siblings (const struct die_reader_specs
*reader
,
1147 gdb_byte
**new_info_ptr
,
1148 struct die_info
*parent
);
1150 static gdb_byte
*read_full_die (const struct die_reader_specs
*reader
,
1151 struct die_info
**, gdb_byte
*,
1154 static void process_die (struct die_info
*, struct dwarf2_cu
*);
1156 static char *dwarf2_canonicalize_name (char *, struct dwarf2_cu
*,
1159 static char *dwarf2_name (struct die_info
*die
, struct dwarf2_cu
*);
1161 static const char *dwarf2_full_name (char *name
,
1162 struct die_info
*die
,
1163 struct dwarf2_cu
*cu
);
1165 static struct die_info
*dwarf2_extension (struct die_info
*die
,
1166 struct dwarf2_cu
**);
1168 static char *dwarf_tag_name (unsigned int);
1170 static char *dwarf_attr_name (unsigned int);
1172 static char *dwarf_form_name (unsigned int);
1174 static char *dwarf_bool_name (unsigned int);
1176 static char *dwarf_type_encoding_name (unsigned int);
1179 static char *dwarf_cfi_name (unsigned int);
1182 static struct die_info
*sibling_die (struct die_info
*);
1184 static void dump_die_shallow (struct ui_file
*, int indent
, struct die_info
*);
1186 static void dump_die_for_error (struct die_info
*);
1188 static void dump_die_1 (struct ui_file
*, int level
, int max_level
,
1191 /*static*/ void dump_die (struct die_info
*, int max_level
);
1193 static void store_in_ref_table (struct die_info
*,
1194 struct dwarf2_cu
*);
1196 static int is_ref_attr (struct attribute
*);
1198 static unsigned int dwarf2_get_ref_die_offset (struct attribute
*);
1200 static LONGEST
dwarf2_get_attr_constant_value (struct attribute
*, int);
1202 static struct die_info
*follow_die_ref_or_sig (struct die_info
*,
1204 struct dwarf2_cu
**);
1206 static struct die_info
*follow_die_ref (struct die_info
*,
1208 struct dwarf2_cu
**);
1210 static struct die_info
*follow_die_sig (struct die_info
*,
1212 struct dwarf2_cu
**);
1214 static struct signatured_type
*lookup_signatured_type_at_offset
1215 (struct objfile
*objfile
,
1216 struct dwarf2_section_info
*section
,
1217 unsigned int offset
);
1219 static void read_signatured_type_at_offset (struct objfile
*objfile
,
1220 struct dwarf2_section_info
*sect
,
1221 unsigned int offset
);
1223 static void read_signatured_type (struct objfile
*,
1224 struct signatured_type
*type_sig
);
1226 /* memory allocation interface */
1228 static struct dwarf_block
*dwarf_alloc_block (struct dwarf2_cu
*);
1230 static struct abbrev_info
*dwarf_alloc_abbrev (struct dwarf2_cu
*);
1232 static struct die_info
*dwarf_alloc_die (struct dwarf2_cu
*, int);
1234 static void initialize_cu_func_list (struct dwarf2_cu
*);
1236 static void add_to_cu_func_list (const char *, CORE_ADDR
, CORE_ADDR
,
1237 struct dwarf2_cu
*);
1239 static void dwarf_decode_macros (struct line_header
*, unsigned int,
1240 char *, bfd
*, struct dwarf2_cu
*,
1241 struct dwarf2_section_info
*,
1244 static int attr_form_is_block (struct attribute
*);
1246 static int attr_form_is_section_offset (struct attribute
*);
1248 static int attr_form_is_constant (struct attribute
*);
1250 static void fill_in_loclist_baton (struct dwarf2_cu
*cu
,
1251 struct dwarf2_loclist_baton
*baton
,
1252 struct attribute
*attr
);
1254 static void dwarf2_symbol_mark_computed (struct attribute
*attr
,
1256 struct dwarf2_cu
*cu
);
1258 static gdb_byte
*skip_one_die (gdb_byte
*buffer
, gdb_byte
*info_ptr
,
1259 struct abbrev_info
*abbrev
,
1260 struct dwarf2_cu
*cu
);
1262 static void free_stack_comp_unit (void *);
1264 static hashval_t
partial_die_hash (const void *item
);
1266 static int partial_die_eq (const void *item_lhs
, const void *item_rhs
);
1268 static struct dwarf2_per_cu_data
*dwarf2_find_containing_comp_unit
1269 (unsigned int offset
, struct objfile
*objfile
);
1271 static struct dwarf2_per_cu_data
*dwarf2_find_comp_unit
1272 (unsigned int offset
, struct objfile
*objfile
);
1274 static void init_one_comp_unit (struct dwarf2_cu
*cu
,
1275 struct objfile
*objfile
);
1277 static void prepare_one_comp_unit (struct dwarf2_cu
*cu
,
1278 struct die_info
*comp_unit_die
);
1280 static void free_one_comp_unit (void *);
1282 static void free_cached_comp_units (void *);
1284 static void age_cached_comp_units (void);
1286 static void free_one_cached_comp_unit (void *);
1288 static struct type
*set_die_type (struct die_info
*, struct type
*,
1289 struct dwarf2_cu
*);
1291 static void create_all_comp_units (struct objfile
*);
1293 static int create_debug_types_hash_table (struct objfile
*objfile
);
1295 static void load_full_comp_unit (struct dwarf2_per_cu_data
*,
1298 static void process_full_comp_unit (struct dwarf2_per_cu_data
*);
1300 static void dwarf2_add_dependence (struct dwarf2_cu
*,
1301 struct dwarf2_per_cu_data
*);
1303 static void dwarf2_mark (struct dwarf2_cu
*);
1305 static void dwarf2_clear_marks (struct dwarf2_per_cu_data
*);
1307 static struct type
*get_die_type_at_offset (unsigned int,
1308 struct dwarf2_per_cu_data
*per_cu
);
1310 static struct type
*get_die_type (struct die_info
*die
, struct dwarf2_cu
*cu
);
1312 static void dwarf2_release_queue (void *dummy
);
1314 static void queue_comp_unit (struct dwarf2_per_cu_data
*per_cu
,
1315 struct objfile
*objfile
);
1317 static void process_queue (struct objfile
*objfile
);
1319 static void find_file_and_directory (struct die_info
*die
,
1320 struct dwarf2_cu
*cu
,
1321 char **name
, char **comp_dir
);
1323 static char *file_full_name (int file
, struct line_header
*lh
,
1324 const char *comp_dir
);
1326 static gdb_byte
*partial_read_comp_unit_head (struct comp_unit_head
*header
,
1329 unsigned int buffer_size
,
1332 static void init_cu_die_reader (struct die_reader_specs
*reader
,
1333 struct dwarf2_cu
*cu
);
1335 static htab_t
allocate_signatured_type_table (struct objfile
*objfile
);
1339 /* Convert VALUE between big- and little-endian. */
1341 byte_swap (offset_type value
)
1345 result
= (value
& 0xff) << 24;
1346 result
|= (value
& 0xff00) << 8;
1347 result
|= (value
& 0xff0000) >> 8;
1348 result
|= (value
& 0xff000000) >> 24;
1352 #define MAYBE_SWAP(V) byte_swap (V)
1355 #define MAYBE_SWAP(V) (V)
1356 #endif /* WORDS_BIGENDIAN */
1358 /* The suffix for an index file. */
1359 #define INDEX_SUFFIX ".gdb-index"
1361 static const char *dwarf2_physname (char *name
, struct die_info
*die
,
1362 struct dwarf2_cu
*cu
);
1364 /* Try to locate the sections we need for DWARF 2 debugging
1365 information and return true if we have enough to do something.
1366 NAMES points to the dwarf2 section names, or is NULL if the standard
1367 ELF names are used. */
1370 dwarf2_has_info (struct objfile
*objfile
,
1371 const struct dwarf2_debug_sections
*names
)
1373 dwarf2_per_objfile
= objfile_data (objfile
, dwarf2_objfile_data_key
);
1374 if (!dwarf2_per_objfile
)
1376 /* Initialize per-objfile state. */
1377 struct dwarf2_per_objfile
*data
1378 = obstack_alloc (&objfile
->objfile_obstack
, sizeof (*data
));
1380 memset (data
, 0, sizeof (*data
));
1381 set_objfile_data (objfile
, dwarf2_objfile_data_key
, data
);
1382 dwarf2_per_objfile
= data
;
1384 bfd_map_over_sections (objfile
->obfd
, dwarf2_locate_sections
,
1386 dwarf2_per_objfile
->objfile
= objfile
;
1388 return (dwarf2_per_objfile
->info
.asection
!= NULL
1389 && dwarf2_per_objfile
->abbrev
.asection
!= NULL
);
1392 /* When loading sections, we look either for uncompressed section or for
1393 compressed section names. */
1396 section_is_p (const char *section_name
,
1397 const struct dwarf2_section_names
*names
)
1399 if (names
->normal
!= NULL
1400 && strcmp (section_name
, names
->normal
) == 0)
1402 if (names
->compressed
!= NULL
1403 && strcmp (section_name
, names
->compressed
) == 0)
1408 /* This function is mapped across the sections and remembers the
1409 offset and size of each of the debugging sections we are interested
1413 dwarf2_locate_sections (bfd
*abfd
, asection
*sectp
, void *vnames
)
1415 const struct dwarf2_debug_sections
*names
;
1418 names
= &dwarf2_elf_names
;
1420 names
= (const struct dwarf2_debug_sections
*) vnames
;
1422 if (section_is_p (sectp
->name
, &names
->info
))
1424 dwarf2_per_objfile
->info
.asection
= sectp
;
1425 dwarf2_per_objfile
->info
.size
= bfd_get_section_size (sectp
);
1427 else if (section_is_p (sectp
->name
, &names
->abbrev
))
1429 dwarf2_per_objfile
->abbrev
.asection
= sectp
;
1430 dwarf2_per_objfile
->abbrev
.size
= bfd_get_section_size (sectp
);
1432 else if (section_is_p (sectp
->name
, &names
->line
))
1434 dwarf2_per_objfile
->line
.asection
= sectp
;
1435 dwarf2_per_objfile
->line
.size
= bfd_get_section_size (sectp
);
1437 else if (section_is_p (sectp
->name
, &names
->loc
))
1439 dwarf2_per_objfile
->loc
.asection
= sectp
;
1440 dwarf2_per_objfile
->loc
.size
= bfd_get_section_size (sectp
);
1442 else if (section_is_p (sectp
->name
, &names
->macinfo
))
1444 dwarf2_per_objfile
->macinfo
.asection
= sectp
;
1445 dwarf2_per_objfile
->macinfo
.size
= bfd_get_section_size (sectp
);
1447 else if (section_is_p (sectp
->name
, &names
->macro
))
1449 dwarf2_per_objfile
->macro
.asection
= sectp
;
1450 dwarf2_per_objfile
->macro
.size
= bfd_get_section_size (sectp
);
1452 else if (section_is_p (sectp
->name
, &names
->str
))
1454 dwarf2_per_objfile
->str
.asection
= sectp
;
1455 dwarf2_per_objfile
->str
.size
= bfd_get_section_size (sectp
);
1457 else if (section_is_p (sectp
->name
, &names
->frame
))
1459 dwarf2_per_objfile
->frame
.asection
= sectp
;
1460 dwarf2_per_objfile
->frame
.size
= bfd_get_section_size (sectp
);
1462 else if (section_is_p (sectp
->name
, &names
->eh_frame
))
1464 flagword aflag
= bfd_get_section_flags (ignore_abfd
, sectp
);
1466 if (aflag
& SEC_HAS_CONTENTS
)
1468 dwarf2_per_objfile
->eh_frame
.asection
= sectp
;
1469 dwarf2_per_objfile
->eh_frame
.size
= bfd_get_section_size (sectp
);
1472 else if (section_is_p (sectp
->name
, &names
->ranges
))
1474 dwarf2_per_objfile
->ranges
.asection
= sectp
;
1475 dwarf2_per_objfile
->ranges
.size
= bfd_get_section_size (sectp
);
1477 else if (section_is_p (sectp
->name
, &names
->types
))
1479 struct dwarf2_section_info type_section
;
1481 memset (&type_section
, 0, sizeof (type_section
));
1482 type_section
.asection
= sectp
;
1483 type_section
.size
= bfd_get_section_size (sectp
);
1485 VEC_safe_push (dwarf2_section_info_def
, dwarf2_per_objfile
->types
,
1488 else if (section_is_p (sectp
->name
, &names
->gdb_index
))
1490 dwarf2_per_objfile
->gdb_index
.asection
= sectp
;
1491 dwarf2_per_objfile
->gdb_index
.size
= bfd_get_section_size (sectp
);
1494 if ((bfd_get_section_flags (abfd
, sectp
) & SEC_LOAD
)
1495 && bfd_section_vma (abfd
, sectp
) == 0)
1496 dwarf2_per_objfile
->has_section_at_zero
= 1;
1499 /* Decompress a section that was compressed using zlib. Store the
1500 decompressed buffer, and its size, in OUTBUF and OUTSIZE. */
1503 zlib_decompress_section (struct objfile
*objfile
, asection
*sectp
,
1504 gdb_byte
**outbuf
, bfd_size_type
*outsize
)
1506 bfd
*abfd
= objfile
->obfd
;
1508 error (_("Support for zlib-compressed DWARF data (from '%s') "
1509 "is disabled in this copy of GDB"),
1510 bfd_get_filename (abfd
));
1512 bfd_size_type compressed_size
= bfd_get_section_size (sectp
);
1513 gdb_byte
*compressed_buffer
= xmalloc (compressed_size
);
1514 struct cleanup
*cleanup
= make_cleanup (xfree
, compressed_buffer
);
1515 bfd_size_type uncompressed_size
;
1516 gdb_byte
*uncompressed_buffer
;
1519 int header_size
= 12;
1521 if (bfd_seek (abfd
, sectp
->filepos
, SEEK_SET
) != 0
1522 || bfd_bread (compressed_buffer
,
1523 compressed_size
, abfd
) != compressed_size
)
1524 error (_("Dwarf Error: Can't read DWARF data from '%s'"),
1525 bfd_get_filename (abfd
));
1527 /* Read the zlib header. In this case, it should be "ZLIB" followed
1528 by the uncompressed section size, 8 bytes in big-endian order. */
1529 if (compressed_size
< header_size
1530 || strncmp (compressed_buffer
, "ZLIB", 4) != 0)
1531 error (_("Dwarf Error: Corrupt DWARF ZLIB header from '%s'"),
1532 bfd_get_filename (abfd
));
1533 uncompressed_size
= compressed_buffer
[4]; uncompressed_size
<<= 8;
1534 uncompressed_size
+= compressed_buffer
[5]; uncompressed_size
<<= 8;
1535 uncompressed_size
+= compressed_buffer
[6]; uncompressed_size
<<= 8;
1536 uncompressed_size
+= compressed_buffer
[7]; uncompressed_size
<<= 8;
1537 uncompressed_size
+= compressed_buffer
[8]; uncompressed_size
<<= 8;
1538 uncompressed_size
+= compressed_buffer
[9]; uncompressed_size
<<= 8;
1539 uncompressed_size
+= compressed_buffer
[10]; uncompressed_size
<<= 8;
1540 uncompressed_size
+= compressed_buffer
[11];
1542 /* It is possible the section consists of several compressed
1543 buffers concatenated together, so we uncompress in a loop. */
1547 strm
.avail_in
= compressed_size
- header_size
;
1548 strm
.next_in
= (Bytef
*) compressed_buffer
+ header_size
;
1549 strm
.avail_out
= uncompressed_size
;
1550 uncompressed_buffer
= obstack_alloc (&objfile
->objfile_obstack
,
1552 rc
= inflateInit (&strm
);
1553 while (strm
.avail_in
> 0)
1556 error (_("Dwarf Error: setting up DWARF uncompression in '%s': %d"),
1557 bfd_get_filename (abfd
), rc
);
1558 strm
.next_out
= ((Bytef
*) uncompressed_buffer
1559 + (uncompressed_size
- strm
.avail_out
));
1560 rc
= inflate (&strm
, Z_FINISH
);
1561 if (rc
!= Z_STREAM_END
)
1562 error (_("Dwarf Error: zlib error uncompressing from '%s': %d"),
1563 bfd_get_filename (abfd
), rc
);
1564 rc
= inflateReset (&strm
);
1566 rc
= inflateEnd (&strm
);
1568 || strm
.avail_out
!= 0)
1569 error (_("Dwarf Error: concluding DWARF uncompression in '%s': %d"),
1570 bfd_get_filename (abfd
), rc
);
1572 do_cleanups (cleanup
);
1573 *outbuf
= uncompressed_buffer
;
1574 *outsize
= uncompressed_size
;
1578 /* A helper function that decides whether a section is empty. */
1581 dwarf2_section_empty_p (struct dwarf2_section_info
*info
)
1583 return info
->asection
== NULL
|| info
->size
== 0;
1586 /* Read the contents of the section SECTP from object file specified by
1587 OBJFILE, store info about the section into INFO.
1588 If the section is compressed, uncompress it before returning. */
1591 dwarf2_read_section (struct objfile
*objfile
, struct dwarf2_section_info
*info
)
1593 bfd
*abfd
= objfile
->obfd
;
1594 asection
*sectp
= info
->asection
;
1595 gdb_byte
*buf
, *retbuf
;
1596 unsigned char header
[4];
1600 info
->buffer
= NULL
;
1601 info
->map_addr
= NULL
;
1604 if (dwarf2_section_empty_p (info
))
1607 /* Check if the file has a 4-byte header indicating compression. */
1608 if (info
->size
> sizeof (header
)
1609 && bfd_seek (abfd
, sectp
->filepos
, SEEK_SET
) == 0
1610 && bfd_bread (header
, sizeof (header
), abfd
) == sizeof (header
))
1612 /* Upon decompression, update the buffer and its size. */
1613 if (strncmp (header
, "ZLIB", sizeof (header
)) == 0)
1615 zlib_decompress_section (objfile
, sectp
, &info
->buffer
,
1623 pagesize
= getpagesize ();
1625 /* Only try to mmap sections which are large enough: we don't want to
1626 waste space due to fragmentation. Also, only try mmap for sections
1627 without relocations. */
1629 if (info
->size
> 4 * pagesize
&& (sectp
->flags
& SEC_RELOC
) == 0)
1631 info
->buffer
= bfd_mmap (abfd
, 0, info
->size
, PROT_READ
,
1632 MAP_PRIVATE
, sectp
->filepos
,
1633 &info
->map_addr
, &info
->map_len
);
1635 if ((caddr_t
)info
->buffer
!= MAP_FAILED
)
1637 #if HAVE_POSIX_MADVISE
1638 posix_madvise (info
->map_addr
, info
->map_len
, POSIX_MADV_WILLNEED
);
1645 /* If we get here, we are a normal, not-compressed section. */
1647 = obstack_alloc (&objfile
->objfile_obstack
, info
->size
);
1649 /* When debugging .o files, we may need to apply relocations; see
1650 http://sourceware.org/ml/gdb-patches/2002-04/msg00136.html .
1651 We never compress sections in .o files, so we only need to
1652 try this when the section is not compressed. */
1653 retbuf
= symfile_relocate_debug_section (objfile
, sectp
, buf
);
1656 info
->buffer
= retbuf
;
1660 if (bfd_seek (abfd
, sectp
->filepos
, SEEK_SET
) != 0
1661 || bfd_bread (buf
, info
->size
, abfd
) != info
->size
)
1662 error (_("Dwarf Error: Can't read DWARF data from '%s'"),
1663 bfd_get_filename (abfd
));
1666 /* A helper function that returns the size of a section in a safe way.
1667 If you are positive that the section has been read before using the
1668 size, then it is safe to refer to the dwarf2_section_info object's
1669 "size" field directly. In other cases, you must call this
1670 function, because for compressed sections the size field is not set
1671 correctly until the section has been read. */
1673 static bfd_size_type
1674 dwarf2_section_size (struct objfile
*objfile
,
1675 struct dwarf2_section_info
*info
)
1678 dwarf2_read_section (objfile
, info
);
1682 /* Fill in SECTP, BUFP and SIZEP with section info, given OBJFILE and
1686 dwarf2_get_section_info (struct objfile
*objfile
,
1687 enum dwarf2_section_enum sect
,
1688 asection
**sectp
, gdb_byte
**bufp
,
1689 bfd_size_type
*sizep
)
1691 struct dwarf2_per_objfile
*data
1692 = objfile_data (objfile
, dwarf2_objfile_data_key
);
1693 struct dwarf2_section_info
*info
;
1695 /* We may see an objfile without any DWARF, in which case we just
1706 case DWARF2_DEBUG_FRAME
:
1707 info
= &data
->frame
;
1709 case DWARF2_EH_FRAME
:
1710 info
= &data
->eh_frame
;
1713 gdb_assert_not_reached ("unexpected section");
1716 dwarf2_read_section (objfile
, info
);
1718 *sectp
= info
->asection
;
1719 *bufp
= info
->buffer
;
1720 *sizep
= info
->size
;
1724 /* DWARF quick_symbols_functions support. */
1726 /* TUs can share .debug_line entries, and there can be a lot more TUs than
1727 unique line tables, so we maintain a separate table of all .debug_line
1728 derived entries to support the sharing.
1729 All the quick functions need is the list of file names. We discard the
1730 line_header when we're done and don't need to record it here. */
1731 struct quick_file_names
1733 /* The offset in .debug_line of the line table. We hash on this. */
1734 unsigned int offset
;
1736 /* The number of entries in file_names, real_names. */
1737 unsigned int num_file_names
;
1739 /* The file names from the line table, after being run through
1741 const char **file_names
;
1743 /* The file names from the line table after being run through
1744 gdb_realpath. These are computed lazily. */
1745 const char **real_names
;
1748 /* When using the index (and thus not using psymtabs), each CU has an
1749 object of this type. This is used to hold information needed by
1750 the various "quick" methods. */
1751 struct dwarf2_per_cu_quick_data
1753 /* The file table. This can be NULL if there was no file table
1754 or it's currently not read in.
1755 NOTE: This points into dwarf2_per_objfile->quick_file_names_table. */
1756 struct quick_file_names
*file_names
;
1758 /* The corresponding symbol table. This is NULL if symbols for this
1759 CU have not yet been read. */
1760 struct symtab
*symtab
;
1762 /* A temporary mark bit used when iterating over all CUs in
1763 expand_symtabs_matching. */
1764 unsigned int mark
: 1;
1766 /* True if we've tried to read the file table and found there isn't one.
1767 There will be no point in trying to read it again next time. */
1768 unsigned int no_file_data
: 1;
1771 /* Hash function for a quick_file_names. */
1774 hash_file_name_entry (const void *e
)
1776 const struct quick_file_names
*file_data
= e
;
1778 return file_data
->offset
;
1781 /* Equality function for a quick_file_names. */
1784 eq_file_name_entry (const void *a
, const void *b
)
1786 const struct quick_file_names
*ea
= a
;
1787 const struct quick_file_names
*eb
= b
;
1789 return ea
->offset
== eb
->offset
;
1792 /* Delete function for a quick_file_names. */
1795 delete_file_name_entry (void *e
)
1797 struct quick_file_names
*file_data
= e
;
1800 for (i
= 0; i
< file_data
->num_file_names
; ++i
)
1802 xfree ((void*) file_data
->file_names
[i
]);
1803 if (file_data
->real_names
)
1804 xfree ((void*) file_data
->real_names
[i
]);
1807 /* The space for the struct itself lives on objfile_obstack,
1808 so we don't free it here. */
1811 /* Create a quick_file_names hash table. */
1814 create_quick_file_names_table (unsigned int nr_initial_entries
)
1816 return htab_create_alloc (nr_initial_entries
,
1817 hash_file_name_entry
, eq_file_name_entry
,
1818 delete_file_name_entry
, xcalloc
, xfree
);
1821 /* Read in PER_CU->CU. This function is unrelated to symtabs, symtab would
1822 have to be created afterwards. You should call age_cached_comp_units after
1823 processing PER_CU->CU. dw2_setup must have been already called. */
1826 load_cu (struct dwarf2_per_cu_data
*per_cu
)
1828 if (per_cu
->debug_type_section
)
1829 read_signatured_type_at_offset (per_cu
->objfile
,
1830 per_cu
->debug_type_section
,
1833 load_full_comp_unit (per_cu
, per_cu
->objfile
);
1835 dwarf2_find_base_address (per_cu
->cu
->dies
, per_cu
->cu
);
1837 gdb_assert (per_cu
->cu
!= NULL
);
1840 /* Read in the symbols for PER_CU. OBJFILE is the objfile from which
1844 dw2_do_instantiate_symtab (struct objfile
*objfile
,
1845 struct dwarf2_per_cu_data
*per_cu
)
1847 struct cleanup
*back_to
;
1849 back_to
= make_cleanup (dwarf2_release_queue
, NULL
);
1851 queue_comp_unit (per_cu
, objfile
);
1855 process_queue (objfile
);
1857 /* Age the cache, releasing compilation units that have not
1858 been used recently. */
1859 age_cached_comp_units ();
1861 do_cleanups (back_to
);
1864 /* Ensure that the symbols for PER_CU have been read in. OBJFILE is
1865 the objfile from which this CU came. Returns the resulting symbol
1868 static struct symtab
*
1869 dw2_instantiate_symtab (struct objfile
*objfile
,
1870 struct dwarf2_per_cu_data
*per_cu
)
1872 if (!per_cu
->v
.quick
->symtab
)
1874 struct cleanup
*back_to
= make_cleanup (free_cached_comp_units
, NULL
);
1875 increment_reading_symtab ();
1876 dw2_do_instantiate_symtab (objfile
, per_cu
);
1877 do_cleanups (back_to
);
1879 return per_cu
->v
.quick
->symtab
;
1882 /* Return the CU given its index. */
1884 static struct dwarf2_per_cu_data
*
1885 dw2_get_cu (int index
)
1887 if (index
>= dwarf2_per_objfile
->n_comp_units
)
1889 index
-= dwarf2_per_objfile
->n_comp_units
;
1890 return dwarf2_per_objfile
->type_comp_units
[index
];
1892 return dwarf2_per_objfile
->all_comp_units
[index
];
1895 /* A helper function that knows how to read a 64-bit value in a way
1896 that doesn't make gdb die. Returns 1 if the conversion went ok, 0
1900 extract_cu_value (const char *bytes
, ULONGEST
*result
)
1902 if (sizeof (ULONGEST
) < 8)
1906 /* Ignore the upper 4 bytes if they are all zero. */
1907 for (i
= 0; i
< 4; ++i
)
1908 if (bytes
[i
+ 4] != 0)
1911 *result
= extract_unsigned_integer (bytes
, 4, BFD_ENDIAN_LITTLE
);
1914 *result
= extract_unsigned_integer (bytes
, 8, BFD_ENDIAN_LITTLE
);
1918 /* Read the CU list from the mapped index, and use it to create all
1919 the CU objects for this objfile. Return 0 if something went wrong,
1920 1 if everything went ok. */
1923 create_cus_from_index (struct objfile
*objfile
, const gdb_byte
*cu_list
,
1924 offset_type cu_list_elements
)
1928 dwarf2_per_objfile
->n_comp_units
= cu_list_elements
/ 2;
1929 dwarf2_per_objfile
->all_comp_units
1930 = obstack_alloc (&objfile
->objfile_obstack
,
1931 dwarf2_per_objfile
->n_comp_units
1932 * sizeof (struct dwarf2_per_cu_data
*));
1934 for (i
= 0; i
< cu_list_elements
; i
+= 2)
1936 struct dwarf2_per_cu_data
*the_cu
;
1937 ULONGEST offset
, length
;
1939 if (!extract_cu_value (cu_list
, &offset
)
1940 || !extract_cu_value (cu_list
+ 8, &length
))
1944 the_cu
= OBSTACK_ZALLOC (&objfile
->objfile_obstack
,
1945 struct dwarf2_per_cu_data
);
1946 the_cu
->offset
= offset
;
1947 the_cu
->length
= length
;
1948 the_cu
->objfile
= objfile
;
1949 the_cu
->v
.quick
= OBSTACK_ZALLOC (&objfile
->objfile_obstack
,
1950 struct dwarf2_per_cu_quick_data
);
1951 dwarf2_per_objfile
->all_comp_units
[i
/ 2] = the_cu
;
1957 /* Create the signatured type hash table from the index. */
1960 create_signatured_type_table_from_index (struct objfile
*objfile
,
1961 struct dwarf2_section_info
*section
,
1962 const gdb_byte
*bytes
,
1963 offset_type elements
)
1966 htab_t sig_types_hash
;
1968 dwarf2_per_objfile
->n_type_comp_units
= elements
/ 3;
1969 dwarf2_per_objfile
->type_comp_units
1970 = obstack_alloc (&objfile
->objfile_obstack
,
1971 dwarf2_per_objfile
->n_type_comp_units
1972 * sizeof (struct dwarf2_per_cu_data
*));
1974 sig_types_hash
= allocate_signatured_type_table (objfile
);
1976 for (i
= 0; i
< elements
; i
+= 3)
1978 struct signatured_type
*type_sig
;
1979 ULONGEST offset
, type_offset
, signature
;
1982 if (!extract_cu_value (bytes
, &offset
)
1983 || !extract_cu_value (bytes
+ 8, &type_offset
))
1985 signature
= extract_unsigned_integer (bytes
+ 16, 8, BFD_ENDIAN_LITTLE
);
1988 type_sig
= OBSTACK_ZALLOC (&objfile
->objfile_obstack
,
1989 struct signatured_type
);
1990 type_sig
->signature
= signature
;
1991 type_sig
->type_offset
= type_offset
;
1992 type_sig
->per_cu
.debug_type_section
= section
;
1993 type_sig
->per_cu
.offset
= offset
;
1994 type_sig
->per_cu
.objfile
= objfile
;
1995 type_sig
->per_cu
.v
.quick
1996 = OBSTACK_ZALLOC (&objfile
->objfile_obstack
,
1997 struct dwarf2_per_cu_quick_data
);
1999 slot
= htab_find_slot (sig_types_hash
, type_sig
, INSERT
);
2002 dwarf2_per_objfile
->type_comp_units
[i
/ 3] = &type_sig
->per_cu
;
2005 dwarf2_per_objfile
->signatured_types
= sig_types_hash
;
2010 /* Read the address map data from the mapped index, and use it to
2011 populate the objfile's psymtabs_addrmap. */
2014 create_addrmap_from_index (struct objfile
*objfile
, struct mapped_index
*index
)
2016 const gdb_byte
*iter
, *end
;
2017 struct obstack temp_obstack
;
2018 struct addrmap
*mutable_map
;
2019 struct cleanup
*cleanup
;
2022 obstack_init (&temp_obstack
);
2023 cleanup
= make_cleanup_obstack_free (&temp_obstack
);
2024 mutable_map
= addrmap_create_mutable (&temp_obstack
);
2026 iter
= index
->address_table
;
2027 end
= iter
+ index
->address_table_size
;
2029 baseaddr
= ANOFFSET (objfile
->section_offsets
, SECT_OFF_TEXT (objfile
));
2033 ULONGEST hi
, lo
, cu_index
;
2034 lo
= extract_unsigned_integer (iter
, 8, BFD_ENDIAN_LITTLE
);
2036 hi
= extract_unsigned_integer (iter
, 8, BFD_ENDIAN_LITTLE
);
2038 cu_index
= extract_unsigned_integer (iter
, 4, BFD_ENDIAN_LITTLE
);
2041 addrmap_set_empty (mutable_map
, lo
+ baseaddr
, hi
+ baseaddr
- 1,
2042 dw2_get_cu (cu_index
));
2045 objfile
->psymtabs_addrmap
= addrmap_create_fixed (mutable_map
,
2046 &objfile
->objfile_obstack
);
2047 do_cleanups (cleanup
);
2050 /* The hash function for strings in the mapped index. This is the same as
2051 SYMBOL_HASH_NEXT, but we keep a separate copy to maintain control over the
2052 implementation. This is necessary because the hash function is tied to the
2053 format of the mapped index file. The hash values do not have to match with
2056 Use INT_MAX for INDEX_VERSION if you generate the current index format. */
2059 mapped_index_string_hash (int index_version
, const void *p
)
2061 const unsigned char *str
= (const unsigned char *) p
;
2065 while ((c
= *str
++) != 0)
2067 if (index_version
>= 5)
2069 r
= r
* 67 + c
- 113;
2075 /* Find a slot in the mapped index INDEX for the object named NAME.
2076 If NAME is found, set *VEC_OUT to point to the CU vector in the
2077 constant pool and return 1. If NAME cannot be found, return 0. */
2080 find_slot_in_mapped_hash (struct mapped_index
*index
, const char *name
,
2081 offset_type
**vec_out
)
2083 struct cleanup
*back_to
= make_cleanup (null_cleanup
, 0);
2085 offset_type slot
, step
;
2086 int (*cmp
) (const char *, const char *);
2088 if (current_language
->la_language
== language_cplus
2089 || current_language
->la_language
== language_java
2090 || current_language
->la_language
== language_fortran
)
2092 /* NAME is already canonical. Drop any qualifiers as .gdb_index does
2094 const char *paren
= strchr (name
, '(');
2100 dup
= xmalloc (paren
- name
+ 1);
2101 memcpy (dup
, name
, paren
- name
);
2102 dup
[paren
- name
] = 0;
2104 make_cleanup (xfree
, dup
);
2109 /* Index version 4 did not support case insensitive searches. But the
2110 indexes for case insensitive languages are built in lowercase, therefore
2111 simulate our NAME being searched is also lowercased. */
2112 hash
= mapped_index_string_hash ((index
->version
== 4
2113 && case_sensitivity
== case_sensitive_off
2114 ? 5 : index
->version
),
2117 slot
= hash
& (index
->symbol_table_slots
- 1);
2118 step
= ((hash
* 17) & (index
->symbol_table_slots
- 1)) | 1;
2119 cmp
= (case_sensitivity
== case_sensitive_on
? strcmp
: strcasecmp
);
2123 /* Convert a slot number to an offset into the table. */
2124 offset_type i
= 2 * slot
;
2126 if (index
->symbol_table
[i
] == 0 && index
->symbol_table
[i
+ 1] == 0)
2128 do_cleanups (back_to
);
2132 str
= index
->constant_pool
+ MAYBE_SWAP (index
->symbol_table
[i
]);
2133 if (!cmp (name
, str
))
2135 *vec_out
= (offset_type
*) (index
->constant_pool
2136 + MAYBE_SWAP (index
->symbol_table
[i
+ 1]));
2137 do_cleanups (back_to
);
2141 slot
= (slot
+ step
) & (index
->symbol_table_slots
- 1);
2145 /* Read the index file. If everything went ok, initialize the "quick"
2146 elements of all the CUs and return 1. Otherwise, return 0. */
2149 dwarf2_read_index (struct objfile
*objfile
)
2152 struct mapped_index
*map
;
2153 offset_type
*metadata
;
2154 const gdb_byte
*cu_list
;
2155 const gdb_byte
*types_list
= NULL
;
2156 offset_type version
, cu_list_elements
;
2157 offset_type types_list_elements
= 0;
2160 if (dwarf2_section_empty_p (&dwarf2_per_objfile
->gdb_index
))
2163 /* Older elfutils strip versions could keep the section in the main
2164 executable while splitting it for the separate debug info file. */
2165 if ((bfd_get_file_flags (dwarf2_per_objfile
->gdb_index
.asection
)
2166 & SEC_HAS_CONTENTS
) == 0)
2169 dwarf2_read_section (objfile
, &dwarf2_per_objfile
->gdb_index
);
2171 addr
= dwarf2_per_objfile
->gdb_index
.buffer
;
2172 /* Version check. */
2173 version
= MAYBE_SWAP (*(offset_type
*) addr
);
2174 /* Versions earlier than 3 emitted every copy of a psymbol. This
2175 causes the index to behave very poorly for certain requests. Version 3
2176 contained incomplete addrmap. So, it seems better to just ignore such
2177 indices. Index version 4 uses a different hash function than index
2178 version 5 and later. */
2181 /* Indexes with higher version than the one supported by GDB may be no
2182 longer backward compatible. */
2186 map
= OBSTACK_ZALLOC (&objfile
->objfile_obstack
, struct mapped_index
);
2187 map
->version
= version
;
2188 map
->total_size
= dwarf2_per_objfile
->gdb_index
.size
;
2190 metadata
= (offset_type
*) (addr
+ sizeof (offset_type
));
2193 cu_list
= addr
+ MAYBE_SWAP (metadata
[i
]);
2194 cu_list_elements
= ((MAYBE_SWAP (metadata
[i
+ 1]) - MAYBE_SWAP (metadata
[i
]))
2198 types_list
= addr
+ MAYBE_SWAP (metadata
[i
]);
2199 types_list_elements
= ((MAYBE_SWAP (metadata
[i
+ 1])
2200 - MAYBE_SWAP (metadata
[i
]))
2204 map
->address_table
= addr
+ MAYBE_SWAP (metadata
[i
]);
2205 map
->address_table_size
= (MAYBE_SWAP (metadata
[i
+ 1])
2206 - MAYBE_SWAP (metadata
[i
]));
2209 map
->symbol_table
= (offset_type
*) (addr
+ MAYBE_SWAP (metadata
[i
]));
2210 map
->symbol_table_slots
= ((MAYBE_SWAP (metadata
[i
+ 1])
2211 - MAYBE_SWAP (metadata
[i
]))
2212 / (2 * sizeof (offset_type
)));
2215 map
->constant_pool
= addr
+ MAYBE_SWAP (metadata
[i
]);
2217 if (!create_cus_from_index (objfile
, cu_list
, cu_list_elements
))
2220 if (types_list_elements
)
2222 struct dwarf2_section_info
*section
;
2224 /* We can only handle a single .debug_types when we have an
2226 if (VEC_length (dwarf2_section_info_def
, dwarf2_per_objfile
->types
) != 1)
2229 section
= VEC_index (dwarf2_section_info_def
,
2230 dwarf2_per_objfile
->types
, 0);
2232 if (!create_signatured_type_table_from_index (objfile
, section
,
2234 types_list_elements
))
2238 create_addrmap_from_index (objfile
, map
);
2240 dwarf2_per_objfile
->index_table
= map
;
2241 dwarf2_per_objfile
->using_index
= 1;
2242 dwarf2_per_objfile
->quick_file_names_table
=
2243 create_quick_file_names_table (dwarf2_per_objfile
->n_comp_units
);
2248 /* A helper for the "quick" functions which sets the global
2249 dwarf2_per_objfile according to OBJFILE. */
2252 dw2_setup (struct objfile
*objfile
)
2254 dwarf2_per_objfile
= objfile_data (objfile
, dwarf2_objfile_data_key
);
2255 gdb_assert (dwarf2_per_objfile
);
2258 /* A helper for the "quick" functions which attempts to read the line
2259 table for THIS_CU. */
2261 static struct quick_file_names
*
2262 dw2_get_file_names (struct objfile
*objfile
,
2263 struct dwarf2_per_cu_data
*this_cu
)
2265 bfd
*abfd
= objfile
->obfd
;
2266 struct line_header
*lh
;
2267 struct attribute
*attr
;
2268 struct cleanup
*cleanups
;
2269 struct die_info
*comp_unit_die
;
2270 struct dwarf2_section_info
* sec
;
2271 gdb_byte
*beg_of_comp_unit
, *info_ptr
, *buffer
;
2272 int has_children
, i
;
2273 struct dwarf2_cu cu
;
2274 unsigned int bytes_read
, buffer_size
;
2275 struct die_reader_specs reader_specs
;
2276 char *name
, *comp_dir
;
2278 struct quick_file_names
*qfn
;
2279 unsigned int line_offset
;
2281 if (this_cu
->v
.quick
->file_names
!= NULL
)
2282 return this_cu
->v
.quick
->file_names
;
2283 /* If we know there is no line data, no point in looking again. */
2284 if (this_cu
->v
.quick
->no_file_data
)
2287 init_one_comp_unit (&cu
, objfile
);
2288 cleanups
= make_cleanup (free_stack_comp_unit
, &cu
);
2290 if (this_cu
->debug_type_section
)
2291 sec
= this_cu
->debug_type_section
;
2293 sec
= &dwarf2_per_objfile
->info
;
2294 dwarf2_read_section (objfile
, sec
);
2295 buffer_size
= sec
->size
;
2296 buffer
= sec
->buffer
;
2297 info_ptr
= buffer
+ this_cu
->offset
;
2298 beg_of_comp_unit
= info_ptr
;
2300 info_ptr
= partial_read_comp_unit_head (&cu
.header
, info_ptr
,
2301 buffer
, buffer_size
,
2304 /* Complete the cu_header. */
2305 cu
.header
.offset
= beg_of_comp_unit
- buffer
;
2306 cu
.header
.first_die_offset
= info_ptr
- beg_of_comp_unit
;
2309 cu
.per_cu
= this_cu
;
2311 dwarf2_read_abbrevs (abfd
, &cu
);
2312 make_cleanup (dwarf2_free_abbrev_table
, &cu
);
2314 if (this_cu
->debug_type_section
)
2315 info_ptr
+= 8 /*signature*/ + cu
.header
.offset_size
;
2316 init_cu_die_reader (&reader_specs
, &cu
);
2317 read_full_die (&reader_specs
, &comp_unit_die
, info_ptr
,
2323 attr
= dwarf2_attr (comp_unit_die
, DW_AT_stmt_list
, &cu
);
2326 struct quick_file_names find_entry
;
2328 line_offset
= DW_UNSND (attr
);
2330 /* We may have already read in this line header (TU line header sharing).
2331 If we have we're done. */
2332 find_entry
.offset
= line_offset
;
2333 slot
= htab_find_slot (dwarf2_per_objfile
->quick_file_names_table
,
2334 &find_entry
, INSERT
);
2337 do_cleanups (cleanups
);
2338 this_cu
->v
.quick
->file_names
= *slot
;
2342 lh
= dwarf_decode_line_header (line_offset
, abfd
, &cu
);
2346 do_cleanups (cleanups
);
2347 this_cu
->v
.quick
->no_file_data
= 1;
2351 qfn
= obstack_alloc (&objfile
->objfile_obstack
, sizeof (*qfn
));
2352 qfn
->offset
= line_offset
;
2353 gdb_assert (slot
!= NULL
);
2356 find_file_and_directory (comp_unit_die
, &cu
, &name
, &comp_dir
);
2358 qfn
->num_file_names
= lh
->num_file_names
;
2359 qfn
->file_names
= obstack_alloc (&objfile
->objfile_obstack
,
2360 lh
->num_file_names
* sizeof (char *));
2361 for (i
= 0; i
< lh
->num_file_names
; ++i
)
2362 qfn
->file_names
[i
] = file_full_name (i
+ 1, lh
, comp_dir
);
2363 qfn
->real_names
= NULL
;
2365 free_line_header (lh
);
2366 do_cleanups (cleanups
);
2368 this_cu
->v
.quick
->file_names
= qfn
;
2372 /* A helper for the "quick" functions which computes and caches the
2373 real path for a given file name from the line table. */
2376 dw2_get_real_path (struct objfile
*objfile
,
2377 struct quick_file_names
*qfn
, int index
)
2379 if (qfn
->real_names
== NULL
)
2380 qfn
->real_names
= OBSTACK_CALLOC (&objfile
->objfile_obstack
,
2381 qfn
->num_file_names
, sizeof (char *));
2383 if (qfn
->real_names
[index
] == NULL
)
2384 qfn
->real_names
[index
] = gdb_realpath (qfn
->file_names
[index
]);
2386 return qfn
->real_names
[index
];
2389 static struct symtab
*
2390 dw2_find_last_source_symtab (struct objfile
*objfile
)
2394 dw2_setup (objfile
);
2395 index
= dwarf2_per_objfile
->n_comp_units
- 1;
2396 return dw2_instantiate_symtab (objfile
, dw2_get_cu (index
));
2399 /* Traversal function for dw2_forget_cached_source_info. */
2402 dw2_free_cached_file_names (void **slot
, void *info
)
2404 struct quick_file_names
*file_data
= (struct quick_file_names
*) *slot
;
2406 if (file_data
->real_names
)
2410 for (i
= 0; i
< file_data
->num_file_names
; ++i
)
2412 xfree ((void*) file_data
->real_names
[i
]);
2413 file_data
->real_names
[i
] = NULL
;
2421 dw2_forget_cached_source_info (struct objfile
*objfile
)
2423 dw2_setup (objfile
);
2425 htab_traverse_noresize (dwarf2_per_objfile
->quick_file_names_table
,
2426 dw2_free_cached_file_names
, NULL
);
2430 dw2_lookup_symtab (struct objfile
*objfile
, const char *name
,
2431 const char *full_path
, const char *real_path
,
2432 struct symtab
**result
)
2435 int check_basename
= lbasename (name
) == name
;
2436 struct dwarf2_per_cu_data
*base_cu
= NULL
;
2438 dw2_setup (objfile
);
2440 for (i
= 0; i
< (dwarf2_per_objfile
->n_comp_units
2441 + dwarf2_per_objfile
->n_type_comp_units
); ++i
)
2444 struct dwarf2_per_cu_data
*per_cu
= dw2_get_cu (i
);
2445 struct quick_file_names
*file_data
;
2447 if (per_cu
->v
.quick
->symtab
)
2450 file_data
= dw2_get_file_names (objfile
, per_cu
);
2451 if (file_data
== NULL
)
2454 for (j
= 0; j
< file_data
->num_file_names
; ++j
)
2456 const char *this_name
= file_data
->file_names
[j
];
2458 if (FILENAME_CMP (name
, this_name
) == 0)
2460 *result
= dw2_instantiate_symtab (objfile
, per_cu
);
2464 if (check_basename
&& ! base_cu
2465 && FILENAME_CMP (lbasename (this_name
), name
) == 0)
2468 if (full_path
!= NULL
)
2470 const char *this_real_name
= dw2_get_real_path (objfile
,
2473 if (this_real_name
!= NULL
2474 && FILENAME_CMP (full_path
, this_real_name
) == 0)
2476 *result
= dw2_instantiate_symtab (objfile
, per_cu
);
2481 if (real_path
!= NULL
)
2483 const char *this_real_name
= dw2_get_real_path (objfile
,
2486 if (this_real_name
!= NULL
2487 && FILENAME_CMP (real_path
, this_real_name
) == 0)
2489 *result
= dw2_instantiate_symtab (objfile
, per_cu
);
2498 *result
= dw2_instantiate_symtab (objfile
, base_cu
);
2505 static struct symtab
*
2506 dw2_lookup_symbol (struct objfile
*objfile
, int block_index
,
2507 const char *name
, domain_enum domain
)
2509 /* We do all the work in the pre_expand_symtabs_matching hook
2514 /* A helper function that expands all symtabs that hold an object
2518 dw2_do_expand_symtabs_matching (struct objfile
*objfile
, const char *name
)
2520 dw2_setup (objfile
);
2522 /* index_table is NULL if OBJF_READNOW. */
2523 if (dwarf2_per_objfile
->index_table
)
2527 if (find_slot_in_mapped_hash (dwarf2_per_objfile
->index_table
,
2530 offset_type i
, len
= MAYBE_SWAP (*vec
);
2531 for (i
= 0; i
< len
; ++i
)
2533 offset_type cu_index
= MAYBE_SWAP (vec
[i
+ 1]);
2534 struct dwarf2_per_cu_data
*per_cu
= dw2_get_cu (cu_index
);
2536 dw2_instantiate_symtab (objfile
, per_cu
);
2543 dw2_pre_expand_symtabs_matching (struct objfile
*objfile
,
2544 enum block_enum block_kind
, const char *name
,
2547 dw2_do_expand_symtabs_matching (objfile
, name
);
2551 dw2_print_stats (struct objfile
*objfile
)
2555 dw2_setup (objfile
);
2557 for (i
= 0; i
< (dwarf2_per_objfile
->n_comp_units
2558 + dwarf2_per_objfile
->n_type_comp_units
); ++i
)
2560 struct dwarf2_per_cu_data
*per_cu
= dw2_get_cu (i
);
2562 if (!per_cu
->v
.quick
->symtab
)
2565 printf_filtered (_(" Number of unread CUs: %d\n"), count
);
2569 dw2_dump (struct objfile
*objfile
)
2571 /* Nothing worth printing. */
2575 dw2_relocate (struct objfile
*objfile
, struct section_offsets
*new_offsets
,
2576 struct section_offsets
*delta
)
2578 /* There's nothing to relocate here. */
2582 dw2_expand_symtabs_for_function (struct objfile
*objfile
,
2583 const char *func_name
)
2585 dw2_do_expand_symtabs_matching (objfile
, func_name
);
2589 dw2_expand_all_symtabs (struct objfile
*objfile
)
2593 dw2_setup (objfile
);
2595 for (i
= 0; i
< (dwarf2_per_objfile
->n_comp_units
2596 + dwarf2_per_objfile
->n_type_comp_units
); ++i
)
2598 struct dwarf2_per_cu_data
*per_cu
= dw2_get_cu (i
);
2600 dw2_instantiate_symtab (objfile
, per_cu
);
2605 dw2_expand_symtabs_with_filename (struct objfile
*objfile
,
2606 const char *filename
)
2610 dw2_setup (objfile
);
2612 /* We don't need to consider type units here.
2613 This is only called for examining code, e.g. expand_line_sal.
2614 There can be an order of magnitude (or more) more type units
2615 than comp units, and we avoid them if we can. */
2617 for (i
= 0; i
< dwarf2_per_objfile
->n_comp_units
; ++i
)
2620 struct dwarf2_per_cu_data
*per_cu
= dw2_get_cu (i
);
2621 struct quick_file_names
*file_data
;
2623 if (per_cu
->v
.quick
->symtab
)
2626 file_data
= dw2_get_file_names (objfile
, per_cu
);
2627 if (file_data
== NULL
)
2630 for (j
= 0; j
< file_data
->num_file_names
; ++j
)
2632 const char *this_name
= file_data
->file_names
[j
];
2633 if (FILENAME_CMP (this_name
, filename
) == 0)
2635 dw2_instantiate_symtab (objfile
, per_cu
);
2643 dw2_find_symbol_file (struct objfile
*objfile
, const char *name
)
2645 struct dwarf2_per_cu_data
*per_cu
;
2647 struct quick_file_names
*file_data
;
2649 dw2_setup (objfile
);
2651 /* index_table is NULL if OBJF_READNOW. */
2652 if (!dwarf2_per_objfile
->index_table
)
2655 if (!find_slot_in_mapped_hash (dwarf2_per_objfile
->index_table
,
2659 /* Note that this just looks at the very first one named NAME -- but
2660 actually we are looking for a function. find_main_filename
2661 should be rewritten so that it doesn't require a custom hook. It
2662 could just use the ordinary symbol tables. */
2663 /* vec[0] is the length, which must always be >0. */
2664 per_cu
= dw2_get_cu (MAYBE_SWAP (vec
[1]));
2666 file_data
= dw2_get_file_names (objfile
, per_cu
);
2667 if (file_data
== NULL
)
2670 return file_data
->file_names
[file_data
->num_file_names
- 1];
2674 dw2_map_matching_symbols (const char * name
, domain_enum
namespace,
2675 struct objfile
*objfile
, int global
,
2676 int (*callback
) (struct block
*,
2677 struct symbol
*, void *),
2678 void *data
, symbol_compare_ftype
*match
,
2679 symbol_compare_ftype
*ordered_compare
)
2681 /* Currently unimplemented; used for Ada. The function can be called if the
2682 current language is Ada for a non-Ada objfile using GNU index. As Ada
2683 does not look for non-Ada symbols this function should just return. */
2687 dw2_expand_symtabs_matching (struct objfile
*objfile
,
2688 int (*file_matcher
) (const char *, void *),
2689 int (*name_matcher
) (const char *, void *),
2690 enum search_domain kind
,
2695 struct mapped_index
*index
;
2697 dw2_setup (objfile
);
2699 /* index_table is NULL if OBJF_READNOW. */
2700 if (!dwarf2_per_objfile
->index_table
)
2702 index
= dwarf2_per_objfile
->index_table
;
2704 if (file_matcher
!= NULL
)
2705 for (i
= 0; i
< (dwarf2_per_objfile
->n_comp_units
2706 + dwarf2_per_objfile
->n_type_comp_units
); ++i
)
2709 struct dwarf2_per_cu_data
*per_cu
= dw2_get_cu (i
);
2710 struct quick_file_names
*file_data
;
2712 per_cu
->v
.quick
->mark
= 0;
2713 if (per_cu
->v
.quick
->symtab
)
2716 file_data
= dw2_get_file_names (objfile
, per_cu
);
2717 if (file_data
== NULL
)
2720 for (j
= 0; j
< file_data
->num_file_names
; ++j
)
2722 if (file_matcher (file_data
->file_names
[j
], data
))
2724 per_cu
->v
.quick
->mark
= 1;
2730 for (iter
= 0; iter
< index
->symbol_table_slots
; ++iter
)
2732 offset_type idx
= 2 * iter
;
2734 offset_type
*vec
, vec_len
, vec_idx
;
2736 if (index
->symbol_table
[idx
] == 0 && index
->symbol_table
[idx
+ 1] == 0)
2739 name
= index
->constant_pool
+ MAYBE_SWAP (index
->symbol_table
[idx
]);
2741 if (! (*name_matcher
) (name
, data
))
2744 /* The name was matched, now expand corresponding CUs that were
2746 vec
= (offset_type
*) (index
->constant_pool
2747 + MAYBE_SWAP (index
->symbol_table
[idx
+ 1]));
2748 vec_len
= MAYBE_SWAP (vec
[0]);
2749 for (vec_idx
= 0; vec_idx
< vec_len
; ++vec_idx
)
2751 struct dwarf2_per_cu_data
*per_cu
;
2753 per_cu
= dw2_get_cu (MAYBE_SWAP (vec
[vec_idx
+ 1]));
2754 if (file_matcher
== NULL
|| per_cu
->v
.quick
->mark
)
2755 dw2_instantiate_symtab (objfile
, per_cu
);
2760 static struct symtab
*
2761 dw2_find_pc_sect_symtab (struct objfile
*objfile
,
2762 struct minimal_symbol
*msymbol
,
2764 struct obj_section
*section
,
2767 struct dwarf2_per_cu_data
*data
;
2769 dw2_setup (objfile
);
2771 if (!objfile
->psymtabs_addrmap
)
2774 data
= addrmap_find (objfile
->psymtabs_addrmap
, pc
);
2778 if (warn_if_readin
&& data
->v
.quick
->symtab
)
2779 warning (_("(Internal error: pc %s in read in CU, but not in symtab.)"),
2780 paddress (get_objfile_arch (objfile
), pc
));
2782 return dw2_instantiate_symtab (objfile
, data
);
2786 dw2_map_symbol_filenames (struct objfile
*objfile
, symbol_filename_ftype
*fun
,
2791 dw2_setup (objfile
);
2793 for (i
= 0; i
< (dwarf2_per_objfile
->n_comp_units
2794 + dwarf2_per_objfile
->n_type_comp_units
); ++i
)
2797 struct dwarf2_per_cu_data
*per_cu
= dw2_get_cu (i
);
2798 struct quick_file_names
*file_data
;
2800 if (per_cu
->v
.quick
->symtab
)
2803 file_data
= dw2_get_file_names (objfile
, per_cu
);
2804 if (file_data
== NULL
)
2807 for (j
= 0; j
< file_data
->num_file_names
; ++j
)
2809 const char *this_real_name
= dw2_get_real_path (objfile
, file_data
,
2811 (*fun
) (file_data
->file_names
[j
], this_real_name
, data
);
2817 dw2_has_symbols (struct objfile
*objfile
)
2822 const struct quick_symbol_functions dwarf2_gdb_index_functions
=
2825 dw2_find_last_source_symtab
,
2826 dw2_forget_cached_source_info
,
2829 dw2_pre_expand_symtabs_matching
,
2833 dw2_expand_symtabs_for_function
,
2834 dw2_expand_all_symtabs
,
2835 dw2_expand_symtabs_with_filename
,
2836 dw2_find_symbol_file
,
2837 dw2_map_matching_symbols
,
2838 dw2_expand_symtabs_matching
,
2839 dw2_find_pc_sect_symtab
,
2840 dw2_map_symbol_filenames
2843 /* Initialize for reading DWARF for this objfile. Return 0 if this
2844 file will use psymtabs, or 1 if using the GNU index. */
2847 dwarf2_initialize_objfile (struct objfile
*objfile
)
2849 /* If we're about to read full symbols, don't bother with the
2850 indices. In this case we also don't care if some other debug
2851 format is making psymtabs, because they are all about to be
2853 if ((objfile
->flags
& OBJF_READNOW
))
2857 dwarf2_per_objfile
->using_index
= 1;
2858 create_all_comp_units (objfile
);
2859 create_debug_types_hash_table (objfile
);
2860 dwarf2_per_objfile
->quick_file_names_table
=
2861 create_quick_file_names_table (dwarf2_per_objfile
->n_comp_units
);
2863 for (i
= 0; i
< (dwarf2_per_objfile
->n_comp_units
2864 + dwarf2_per_objfile
->n_type_comp_units
); ++i
)
2866 struct dwarf2_per_cu_data
*per_cu
= dw2_get_cu (i
);
2868 per_cu
->v
.quick
= OBSTACK_ZALLOC (&objfile
->objfile_obstack
,
2869 struct dwarf2_per_cu_quick_data
);
2872 /* Return 1 so that gdb sees the "quick" functions. However,
2873 these functions will be no-ops because we will have expanded
2878 if (dwarf2_read_index (objfile
))
2886 /* Build a partial symbol table. */
2889 dwarf2_build_psymtabs (struct objfile
*objfile
)
2891 if (objfile
->global_psymbols
.size
== 0 && objfile
->static_psymbols
.size
== 0)
2893 init_psymbol_list (objfile
, 1024);
2896 dwarf2_build_psymtabs_hard (objfile
);
2899 /* Return TRUE if OFFSET is within CU_HEADER. */
2902 offset_in_cu_p (const struct comp_unit_head
*cu_header
, unsigned int offset
)
2904 unsigned int bottom
= cu_header
->offset
;
2905 unsigned int top
= (cu_header
->offset
2907 + cu_header
->initial_length_size
);
2909 return (offset
>= bottom
&& offset
< top
);
2912 /* Read in the comp unit header information from the debug_info at info_ptr.
2913 NOTE: This leaves members offset, first_die_offset to be filled in
2917 read_comp_unit_head (struct comp_unit_head
*cu_header
,
2918 gdb_byte
*info_ptr
, bfd
*abfd
)
2921 unsigned int bytes_read
;
2923 cu_header
->length
= read_initial_length (abfd
, info_ptr
, &bytes_read
);
2924 cu_header
->initial_length_size
= bytes_read
;
2925 cu_header
->offset_size
= (bytes_read
== 4) ? 4 : 8;
2926 info_ptr
+= bytes_read
;
2927 cu_header
->version
= read_2_bytes (abfd
, info_ptr
);
2929 cu_header
->abbrev_offset
= read_offset (abfd
, info_ptr
, cu_header
,
2931 info_ptr
+= bytes_read
;
2932 cu_header
->addr_size
= read_1_byte (abfd
, info_ptr
);
2934 signed_addr
= bfd_get_sign_extend_vma (abfd
);
2935 if (signed_addr
< 0)
2936 internal_error (__FILE__
, __LINE__
,
2937 _("read_comp_unit_head: dwarf from non elf file"));
2938 cu_header
->signed_addr_p
= signed_addr
;
2944 partial_read_comp_unit_head (struct comp_unit_head
*header
, gdb_byte
*info_ptr
,
2945 gdb_byte
*buffer
, unsigned int buffer_size
,
2948 gdb_byte
*beg_of_comp_unit
= info_ptr
;
2950 info_ptr
= read_comp_unit_head (header
, info_ptr
, abfd
);
2952 if (header
->version
!= 2 && header
->version
!= 3 && header
->version
!= 4)
2953 error (_("Dwarf Error: wrong version in compilation unit header "
2954 "(is %d, should be 2, 3, or 4) [in module %s]"), header
->version
,
2955 bfd_get_filename (abfd
));
2957 if (header
->abbrev_offset
2958 >= dwarf2_section_size (dwarf2_per_objfile
->objfile
,
2959 &dwarf2_per_objfile
->abbrev
))
2960 error (_("Dwarf Error: bad offset (0x%lx) in compilation unit header "
2961 "(offset 0x%lx + 6) [in module %s]"),
2962 (long) header
->abbrev_offset
,
2963 (long) (beg_of_comp_unit
- buffer
),
2964 bfd_get_filename (abfd
));
2966 if (beg_of_comp_unit
+ header
->length
+ header
->initial_length_size
2967 > buffer
+ buffer_size
)
2968 error (_("Dwarf Error: bad length (0x%lx) in compilation unit header "
2969 "(offset 0x%lx + 0) [in module %s]"),
2970 (long) header
->length
,
2971 (long) (beg_of_comp_unit
- buffer
),
2972 bfd_get_filename (abfd
));
2977 /* Read in the types comp unit header information from .debug_types entry at
2978 types_ptr. The result is a pointer to one past the end of the header. */
2981 read_type_comp_unit_head (struct comp_unit_head
*cu_header
,
2982 struct dwarf2_section_info
*section
,
2983 ULONGEST
*signature
,
2984 gdb_byte
*types_ptr
, bfd
*abfd
)
2986 gdb_byte
*initial_types_ptr
= types_ptr
;
2988 dwarf2_read_section (dwarf2_per_objfile
->objfile
, section
);
2989 cu_header
->offset
= types_ptr
- section
->buffer
;
2991 types_ptr
= read_comp_unit_head (cu_header
, types_ptr
, abfd
);
2993 *signature
= read_8_bytes (abfd
, types_ptr
);
2995 types_ptr
+= cu_header
->offset_size
;
2996 cu_header
->first_die_offset
= types_ptr
- initial_types_ptr
;
3001 /* Allocate a new partial symtab for file named NAME and mark this new
3002 partial symtab as being an include of PST. */
3005 dwarf2_create_include_psymtab (char *name
, struct partial_symtab
*pst
,
3006 struct objfile
*objfile
)
3008 struct partial_symtab
*subpst
= allocate_psymtab (name
, objfile
);
3010 subpst
->section_offsets
= pst
->section_offsets
;
3011 subpst
->textlow
= 0;
3012 subpst
->texthigh
= 0;
3014 subpst
->dependencies
= (struct partial_symtab
**)
3015 obstack_alloc (&objfile
->objfile_obstack
,
3016 sizeof (struct partial_symtab
*));
3017 subpst
->dependencies
[0] = pst
;
3018 subpst
->number_of_dependencies
= 1;
3020 subpst
->globals_offset
= 0;
3021 subpst
->n_global_syms
= 0;
3022 subpst
->statics_offset
= 0;
3023 subpst
->n_static_syms
= 0;
3024 subpst
->symtab
= NULL
;
3025 subpst
->read_symtab
= pst
->read_symtab
;
3028 /* No private part is necessary for include psymtabs. This property
3029 can be used to differentiate between such include psymtabs and
3030 the regular ones. */
3031 subpst
->read_symtab_private
= NULL
;
3034 /* Read the Line Number Program data and extract the list of files
3035 included by the source file represented by PST. Build an include
3036 partial symtab for each of these included files. */
3039 dwarf2_build_include_psymtabs (struct dwarf2_cu
*cu
,
3040 struct die_info
*die
,
3041 struct partial_symtab
*pst
)
3043 struct objfile
*objfile
= cu
->objfile
;
3044 bfd
*abfd
= objfile
->obfd
;
3045 struct line_header
*lh
= NULL
;
3046 struct attribute
*attr
;
3048 attr
= dwarf2_attr (die
, DW_AT_stmt_list
, cu
);
3051 unsigned int line_offset
= DW_UNSND (attr
);
3053 lh
= dwarf_decode_line_header (line_offset
, abfd
, cu
);
3056 return; /* No linetable, so no includes. */
3058 /* NOTE: pst->dirname is DW_AT_comp_dir (if present). */
3059 dwarf_decode_lines (lh
, pst
->dirname
, abfd
, cu
, pst
);
3061 free_line_header (lh
);
3065 hash_type_signature (const void *item
)
3067 const struct signatured_type
*type_sig
= item
;
3069 /* This drops the top 32 bits of the signature, but is ok for a hash. */
3070 return type_sig
->signature
;
3074 eq_type_signature (const void *item_lhs
, const void *item_rhs
)
3076 const struct signatured_type
*lhs
= item_lhs
;
3077 const struct signatured_type
*rhs
= item_rhs
;
3079 return lhs
->signature
== rhs
->signature
;
3082 /* Allocate a hash table for signatured types. */
3085 allocate_signatured_type_table (struct objfile
*objfile
)
3087 return htab_create_alloc_ex (41,
3088 hash_type_signature
,
3091 &objfile
->objfile_obstack
,
3092 hashtab_obstack_allocate
,
3093 dummy_obstack_deallocate
);
3096 /* A helper function to add a signatured type CU to a list. */
3099 add_signatured_type_cu_to_list (void **slot
, void *datum
)
3101 struct signatured_type
*sigt
= *slot
;
3102 struct dwarf2_per_cu_data
***datap
= datum
;
3104 **datap
= &sigt
->per_cu
;
3110 /* Create the hash table of all entries in the .debug_types section.
3111 The result is zero if there is an error (e.g. missing .debug_types section),
3112 otherwise non-zero. */
3115 create_debug_types_hash_table (struct objfile
*objfile
)
3117 htab_t types_htab
= NULL
;
3118 struct dwarf2_per_cu_data
**iter
;
3120 struct dwarf2_section_info
*section
;
3122 if (VEC_empty (dwarf2_section_info_def
, dwarf2_per_objfile
->types
))
3124 dwarf2_per_objfile
->signatured_types
= NULL
;
3129 VEC_iterate (dwarf2_section_info_def
, dwarf2_per_objfile
->types
,
3133 gdb_byte
*info_ptr
, *end_ptr
;
3135 dwarf2_read_section (objfile
, section
);
3136 info_ptr
= section
->buffer
;
3138 if (info_ptr
== NULL
)
3141 if (types_htab
== NULL
)
3142 types_htab
= allocate_signatured_type_table (objfile
);
3144 if (dwarf2_die_debug
)
3145 fprintf_unfiltered (gdb_stdlog
, "Signatured types:\n");
3147 end_ptr
= info_ptr
+ section
->size
;
3148 while (info_ptr
< end_ptr
)
3150 unsigned int offset
;
3151 unsigned int offset_size
;
3152 unsigned int type_offset
;
3153 unsigned int length
, initial_length_size
;
3154 unsigned short version
;
3156 struct signatured_type
*type_sig
;
3158 gdb_byte
*ptr
= info_ptr
;
3160 offset
= ptr
- section
->buffer
;
3162 /* We need to read the type's signature in order to build the hash
3163 table, but we don't need to read anything else just yet. */
3165 /* Sanity check to ensure entire cu is present. */
3166 length
= read_initial_length (objfile
->obfd
, ptr
,
3167 &initial_length_size
);
3168 if (ptr
+ length
+ initial_length_size
> end_ptr
)
3170 complaint (&symfile_complaints
,
3171 _("debug type entry runs off end "
3172 "of `.debug_types' section, ignored"));
3176 offset_size
= initial_length_size
== 4 ? 4 : 8;
3177 ptr
+= initial_length_size
;
3178 version
= bfd_get_16 (objfile
->obfd
, ptr
);
3180 ptr
+= offset_size
; /* abbrev offset */
3181 ptr
+= 1; /* address size */
3182 signature
= bfd_get_64 (objfile
->obfd
, ptr
);
3184 type_offset
= read_offset_1 (objfile
->obfd
, ptr
, offset_size
);
3186 type_sig
= obstack_alloc (&objfile
->objfile_obstack
, sizeof (*type_sig
));
3187 memset (type_sig
, 0, sizeof (*type_sig
));
3188 type_sig
->signature
= signature
;
3189 type_sig
->type_offset
= type_offset
;
3190 type_sig
->per_cu
.objfile
= objfile
;
3191 type_sig
->per_cu
.debug_type_section
= section
;
3192 type_sig
->per_cu
.offset
= offset
;
3194 slot
= htab_find_slot (types_htab
, type_sig
, INSERT
);
3195 gdb_assert (slot
!= NULL
);
3198 const struct signatured_type
*dup_sig
= *slot
;
3200 complaint (&symfile_complaints
,
3201 _("debug type entry at offset 0x%x is duplicate to the "
3202 "entry at offset 0x%x, signature 0x%s"),
3203 offset
, dup_sig
->per_cu
.offset
,
3204 phex (signature
, sizeof (signature
)));
3205 gdb_assert (signature
== dup_sig
->signature
);
3209 if (dwarf2_die_debug
)
3210 fprintf_unfiltered (gdb_stdlog
, " offset 0x%x, signature 0x%s\n",
3211 offset
, phex (signature
, sizeof (signature
)));
3213 info_ptr
= info_ptr
+ initial_length_size
+ length
;
3217 dwarf2_per_objfile
->signatured_types
= types_htab
;
3219 dwarf2_per_objfile
->n_type_comp_units
= htab_elements (types_htab
);
3220 dwarf2_per_objfile
->type_comp_units
3221 = obstack_alloc (&objfile
->objfile_obstack
,
3222 dwarf2_per_objfile
->n_type_comp_units
3223 * sizeof (struct dwarf2_per_cu_data
*));
3224 iter
= &dwarf2_per_objfile
->type_comp_units
[0];
3225 htab_traverse_noresize (types_htab
, add_signatured_type_cu_to_list
, &iter
);
3226 gdb_assert (iter
- &dwarf2_per_objfile
->type_comp_units
[0]
3227 == dwarf2_per_objfile
->n_type_comp_units
);
3232 /* Lookup a signature based type.
3233 Returns NULL if SIG is not present in the table. */
3235 static struct signatured_type
*
3236 lookup_signatured_type (struct objfile
*objfile
, ULONGEST sig
)
3238 struct signatured_type find_entry
, *entry
;
3240 if (dwarf2_per_objfile
->signatured_types
== NULL
)
3242 complaint (&symfile_complaints
,
3243 _("missing `.debug_types' section for DW_FORM_ref_sig8 die"));
3247 find_entry
.signature
= sig
;
3248 entry
= htab_find (dwarf2_per_objfile
->signatured_types
, &find_entry
);
3252 /* Initialize a die_reader_specs struct from a dwarf2_cu struct. */
3255 init_cu_die_reader (struct die_reader_specs
*reader
,
3256 struct dwarf2_cu
*cu
)
3258 reader
->abfd
= cu
->objfile
->obfd
;
3260 if (cu
->per_cu
->debug_type_section
)
3262 gdb_assert (cu
->per_cu
->debug_type_section
->readin
);
3263 reader
->buffer
= cu
->per_cu
->debug_type_section
->buffer
;
3267 gdb_assert (dwarf2_per_objfile
->info
.readin
);
3268 reader
->buffer
= dwarf2_per_objfile
->info
.buffer
;
3272 /* Find the base address of the compilation unit for range lists and
3273 location lists. It will normally be specified by DW_AT_low_pc.
3274 In DWARF-3 draft 4, the base address could be overridden by
3275 DW_AT_entry_pc. It's been removed, but GCC still uses this for
3276 compilation units with discontinuous ranges. */
3279 dwarf2_find_base_address (struct die_info
*die
, struct dwarf2_cu
*cu
)
3281 struct attribute
*attr
;
3284 cu
->base_address
= 0;
3286 attr
= dwarf2_attr (die
, DW_AT_entry_pc
, cu
);
3289 cu
->base_address
= DW_ADDR (attr
);
3294 attr
= dwarf2_attr (die
, DW_AT_low_pc
, cu
);
3297 cu
->base_address
= DW_ADDR (attr
);
3303 /* Subroutine of process_type_comp_unit and dwarf2_build_psymtabs_hard
3304 to combine the common parts.
3305 Process a compilation unit for a psymtab.
3306 BUFFER is a pointer to the beginning of the dwarf section buffer,
3307 either .debug_info or debug_types.
3308 INFO_PTR is a pointer to the start of the CU.
3309 Returns a pointer to the next CU. */
3312 process_psymtab_comp_unit (struct objfile
*objfile
,
3313 struct dwarf2_per_cu_data
*this_cu
,
3314 gdb_byte
*buffer
, gdb_byte
*info_ptr
,
3315 unsigned int buffer_size
)
3317 bfd
*abfd
= objfile
->obfd
;
3318 gdb_byte
*beg_of_comp_unit
= info_ptr
;
3319 struct die_info
*comp_unit_die
;
3320 struct partial_symtab
*pst
;
3322 struct cleanup
*back_to_inner
;
3323 struct dwarf2_cu cu
;
3324 int has_children
, has_pc_info
;
3325 struct attribute
*attr
;
3326 CORE_ADDR best_lowpc
= 0, best_highpc
= 0;
3327 struct die_reader_specs reader_specs
;
3328 const char *filename
;
3330 init_one_comp_unit (&cu
, objfile
);
3331 back_to_inner
= make_cleanup (free_stack_comp_unit
, &cu
);
3333 info_ptr
= partial_read_comp_unit_head (&cu
.header
, info_ptr
,
3334 buffer
, buffer_size
,
3337 /* Complete the cu_header. */
3338 cu
.header
.offset
= beg_of_comp_unit
- buffer
;
3339 cu
.header
.first_die_offset
= info_ptr
- beg_of_comp_unit
;
3341 cu
.list_in_scope
= &file_symbols
;
3343 /* If this compilation unit was already read in, free the
3344 cached copy in order to read it in again. This is
3345 necessary because we skipped some symbols when we first
3346 read in the compilation unit (see load_partial_dies).
3347 This problem could be avoided, but the benefit is
3349 if (this_cu
->cu
!= NULL
)
3350 free_one_cached_comp_unit (this_cu
->cu
);
3352 /* Note that this is a pointer to our stack frame, being
3353 added to a global data structure. It will be cleaned up
3354 in free_stack_comp_unit when we finish with this
3355 compilation unit. */
3357 cu
.per_cu
= this_cu
;
3359 /* Read the abbrevs for this compilation unit into a table. */
3360 dwarf2_read_abbrevs (abfd
, &cu
);
3361 make_cleanup (dwarf2_free_abbrev_table
, &cu
);
3363 /* Read the compilation unit die. */
3364 if (this_cu
->debug_type_section
)
3365 info_ptr
+= 8 /*signature*/ + cu
.header
.offset_size
;
3366 init_cu_die_reader (&reader_specs
, &cu
);
3367 info_ptr
= read_full_die (&reader_specs
, &comp_unit_die
, info_ptr
,
3370 if (this_cu
->debug_type_section
)
3372 /* LENGTH has not been set yet for type units. */
3373 gdb_assert (this_cu
->offset
== cu
.header
.offset
);
3374 this_cu
->length
= cu
.header
.length
+ cu
.header
.initial_length_size
;
3376 else if (comp_unit_die
->tag
== DW_TAG_partial_unit
)
3378 info_ptr
= (beg_of_comp_unit
+ cu
.header
.length
3379 + cu
.header
.initial_length_size
);
3380 do_cleanups (back_to_inner
);
3384 prepare_one_comp_unit (&cu
, comp_unit_die
);
3386 /* Allocate a new partial symbol table structure. */
3387 attr
= dwarf2_attr (comp_unit_die
, DW_AT_name
, &cu
);
3388 if (attr
== NULL
|| !DW_STRING (attr
))
3391 filename
= DW_STRING (attr
);
3392 pst
= start_psymtab_common (objfile
, objfile
->section_offsets
,
3394 /* TEXTLOW and TEXTHIGH are set below. */
3396 objfile
->global_psymbols
.next
,
3397 objfile
->static_psymbols
.next
);
3399 attr
= dwarf2_attr (comp_unit_die
, DW_AT_comp_dir
, &cu
);
3401 pst
->dirname
= DW_STRING (attr
);
3403 pst
->read_symtab_private
= this_cu
;
3405 baseaddr
= ANOFFSET (objfile
->section_offsets
, SECT_OFF_TEXT (objfile
));
3407 /* Store the function that reads in the rest of the symbol table. */
3408 pst
->read_symtab
= dwarf2_psymtab_to_symtab
;
3410 this_cu
->v
.psymtab
= pst
;
3412 dwarf2_find_base_address (comp_unit_die
, &cu
);
3414 /* Possibly set the default values of LOWPC and HIGHPC from
3416 has_pc_info
= dwarf2_get_pc_bounds (comp_unit_die
, &best_lowpc
,
3417 &best_highpc
, &cu
, pst
);
3418 if (has_pc_info
== 1 && best_lowpc
< best_highpc
)
3419 /* Store the contiguous range if it is not empty; it can be empty for
3420 CUs with no code. */
3421 addrmap_set_empty (objfile
->psymtabs_addrmap
,
3422 best_lowpc
+ baseaddr
,
3423 best_highpc
+ baseaddr
- 1, pst
);
3425 /* Check if comp unit has_children.
3426 If so, read the rest of the partial symbols from this comp unit.
3427 If not, there's no more debug_info for this comp unit. */
3430 struct partial_die_info
*first_die
;
3431 CORE_ADDR lowpc
, highpc
;
3433 lowpc
= ((CORE_ADDR
) -1);
3434 highpc
= ((CORE_ADDR
) 0);
3436 first_die
= load_partial_dies (abfd
, buffer
, info_ptr
, 1, &cu
);
3438 scan_partial_symbols (first_die
, &lowpc
, &highpc
,
3439 ! has_pc_info
, &cu
);
3441 /* If we didn't find a lowpc, set it to highpc to avoid
3442 complaints from `maint check'. */
3443 if (lowpc
== ((CORE_ADDR
) -1))
3446 /* If the compilation unit didn't have an explicit address range,
3447 then use the information extracted from its child dies. */
3451 best_highpc
= highpc
;
3454 pst
->textlow
= best_lowpc
+ baseaddr
;
3455 pst
->texthigh
= best_highpc
+ baseaddr
;
3457 pst
->n_global_syms
= objfile
->global_psymbols
.next
-
3458 (objfile
->global_psymbols
.list
+ pst
->globals_offset
);
3459 pst
->n_static_syms
= objfile
->static_psymbols
.next
-
3460 (objfile
->static_psymbols
.list
+ pst
->statics_offset
);
3461 sort_pst_symbols (pst
);
3463 info_ptr
= (beg_of_comp_unit
+ cu
.header
.length
3464 + cu
.header
.initial_length_size
);
3466 if (this_cu
->debug_type_section
)
3468 /* It's not clear we want to do anything with stmt lists here.
3469 Waiting to see what gcc ultimately does. */
3473 /* Get the list of files included in the current compilation unit,
3474 and build a psymtab for each of them. */
3475 dwarf2_build_include_psymtabs (&cu
, comp_unit_die
, pst
);
3478 do_cleanups (back_to_inner
);
3483 /* Traversal function for htab_traverse_noresize.
3484 Process one .debug_types comp-unit. */
3487 process_type_comp_unit (void **slot
, void *info
)
3489 struct signatured_type
*entry
= (struct signatured_type
*) *slot
;
3490 struct objfile
*objfile
= (struct objfile
*) info
;
3491 struct dwarf2_per_cu_data
*this_cu
;
3493 this_cu
= &entry
->per_cu
;
3495 gdb_assert (this_cu
->debug_type_section
->readin
);
3496 process_psymtab_comp_unit (objfile
, this_cu
,
3497 this_cu
->debug_type_section
->buffer
,
3498 (this_cu
->debug_type_section
->buffer
3500 this_cu
->debug_type_section
->size
);
3505 /* Subroutine of dwarf2_build_psymtabs_hard to simplify it.
3506 Build partial symbol tables for the .debug_types comp-units. */
3509 build_type_psymtabs (struct objfile
*objfile
)
3511 if (! create_debug_types_hash_table (objfile
))
3514 htab_traverse_noresize (dwarf2_per_objfile
->signatured_types
,
3515 process_type_comp_unit
, objfile
);
3518 /* A cleanup function that clears objfile's psymtabs_addrmap field. */
3521 psymtabs_addrmap_cleanup (void *o
)
3523 struct objfile
*objfile
= o
;
3525 objfile
->psymtabs_addrmap
= NULL
;
3528 /* Build the partial symbol table by doing a quick pass through the
3529 .debug_info and .debug_abbrev sections. */
3532 dwarf2_build_psymtabs_hard (struct objfile
*objfile
)
3535 struct cleanup
*back_to
, *addrmap_cleanup
;
3536 struct obstack temp_obstack
;
3538 dwarf2_per_objfile
->reading_partial_symbols
= 1;
3540 dwarf2_read_section (objfile
, &dwarf2_per_objfile
->info
);
3541 info_ptr
= dwarf2_per_objfile
->info
.buffer
;
3543 /* Any cached compilation units will be linked by the per-objfile
3544 read_in_chain. Make sure to free them when we're done. */
3545 back_to
= make_cleanup (free_cached_comp_units
, NULL
);
3547 build_type_psymtabs (objfile
);
3549 create_all_comp_units (objfile
);
3551 /* Create a temporary address map on a temporary obstack. We later
3552 copy this to the final obstack. */
3553 obstack_init (&temp_obstack
);
3554 make_cleanup_obstack_free (&temp_obstack
);
3555 objfile
->psymtabs_addrmap
= addrmap_create_mutable (&temp_obstack
);
3556 addrmap_cleanup
= make_cleanup (psymtabs_addrmap_cleanup
, objfile
);
3558 /* Since the objects we're extracting from .debug_info vary in
3559 length, only the individual functions to extract them (like
3560 read_comp_unit_head and load_partial_die) can really know whether
3561 the buffer is large enough to hold another complete object.
3563 At the moment, they don't actually check that. If .debug_info
3564 holds just one extra byte after the last compilation unit's dies,
3565 then read_comp_unit_head will happily read off the end of the
3566 buffer. read_partial_die is similarly casual. Those functions
3569 For this loop condition, simply checking whether there's any data
3570 left at all should be sufficient. */
3572 while (info_ptr
< (dwarf2_per_objfile
->info
.buffer
3573 + dwarf2_per_objfile
->info
.size
))
3575 struct dwarf2_per_cu_data
*this_cu
;
3577 this_cu
= dwarf2_find_comp_unit (info_ptr
3578 - dwarf2_per_objfile
->info
.buffer
,
3581 info_ptr
= process_psymtab_comp_unit (objfile
, this_cu
,
3582 dwarf2_per_objfile
->info
.buffer
,
3584 dwarf2_per_objfile
->info
.size
);
3587 objfile
->psymtabs_addrmap
= addrmap_create_fixed (objfile
->psymtabs_addrmap
,
3588 &objfile
->objfile_obstack
);
3589 discard_cleanups (addrmap_cleanup
);
3591 do_cleanups (back_to
);
3594 /* Load the partial DIEs for a secondary CU into memory. */
3597 load_partial_comp_unit (struct dwarf2_per_cu_data
*this_cu
,
3598 struct objfile
*objfile
)
3600 bfd
*abfd
= objfile
->obfd
;
3601 gdb_byte
*info_ptr
, *beg_of_comp_unit
;
3602 struct die_info
*comp_unit_die
;
3603 struct dwarf2_cu
*cu
;
3604 struct cleanup
*free_abbrevs_cleanup
, *free_cu_cleanup
= NULL
;
3606 struct die_reader_specs reader_specs
;
3609 gdb_assert (! this_cu
->debug_type_section
);
3611 gdb_assert (dwarf2_per_objfile
->info
.readin
);
3612 info_ptr
= dwarf2_per_objfile
->info
.buffer
+ this_cu
->offset
;
3613 beg_of_comp_unit
= info_ptr
;
3615 if (this_cu
->cu
== NULL
)
3617 cu
= xmalloc (sizeof (*cu
));
3618 init_one_comp_unit (cu
, objfile
);
3622 /* If an error occurs while loading, release our storage. */
3623 free_cu_cleanup
= make_cleanup (free_one_comp_unit
, cu
);
3625 info_ptr
= partial_read_comp_unit_head (&cu
->header
, info_ptr
,
3626 dwarf2_per_objfile
->info
.buffer
,
3627 dwarf2_per_objfile
->info
.size
,
3630 /* Complete the cu_header. */
3631 cu
->header
.offset
= this_cu
->offset
;
3632 cu
->header
.first_die_offset
= info_ptr
- beg_of_comp_unit
;
3634 /* Link this compilation unit into the compilation unit tree. */
3636 cu
->per_cu
= this_cu
;
3638 /* Link this CU into read_in_chain. */
3639 this_cu
->cu
->read_in_chain
= dwarf2_per_objfile
->read_in_chain
;
3640 dwarf2_per_objfile
->read_in_chain
= this_cu
;
3645 info_ptr
+= cu
->header
.first_die_offset
;
3648 /* Read the abbrevs for this compilation unit into a table. */
3649 gdb_assert (cu
->dwarf2_abbrevs
== NULL
);
3650 dwarf2_read_abbrevs (abfd
, cu
);
3651 free_abbrevs_cleanup
= make_cleanup (dwarf2_free_abbrev_table
, cu
);
3653 /* Read the compilation unit die. */
3654 init_cu_die_reader (&reader_specs
, cu
);
3655 info_ptr
= read_full_die (&reader_specs
, &comp_unit_die
, info_ptr
,
3658 prepare_one_comp_unit (cu
, comp_unit_die
);
3660 /* Check if comp unit has_children.
3661 If so, read the rest of the partial symbols from this comp unit.
3662 If not, there's no more debug_info for this comp unit. */
3664 load_partial_dies (abfd
, dwarf2_per_objfile
->info
.buffer
, info_ptr
, 0, cu
);
3666 do_cleanups (free_abbrevs_cleanup
);
3670 /* We've successfully allocated this compilation unit. Let our
3671 caller clean it up when finished with it. */
3672 discard_cleanups (free_cu_cleanup
);
3676 /* Create a list of all compilation units in OBJFILE. We do this only
3677 if an inter-comp-unit reference is found; presumably if there is one,
3678 there will be many, and one will occur early in the .debug_info section.
3679 So there's no point in building this list incrementally. */
3682 create_all_comp_units (struct objfile
*objfile
)
3686 struct dwarf2_per_cu_data
**all_comp_units
;
3689 dwarf2_read_section (objfile
, &dwarf2_per_objfile
->info
);
3690 info_ptr
= dwarf2_per_objfile
->info
.buffer
;
3694 all_comp_units
= xmalloc (n_allocated
3695 * sizeof (struct dwarf2_per_cu_data
*));
3697 while (info_ptr
< dwarf2_per_objfile
->info
.buffer
3698 + dwarf2_per_objfile
->info
.size
)
3700 unsigned int length
, initial_length_size
;
3701 struct dwarf2_per_cu_data
*this_cu
;
3702 unsigned int offset
;
3704 offset
= info_ptr
- dwarf2_per_objfile
->info
.buffer
;
3706 /* Read just enough information to find out where the next
3707 compilation unit is. */
3708 length
= read_initial_length (objfile
->obfd
, info_ptr
,
3709 &initial_length_size
);
3711 /* Save the compilation unit for later lookup. */
3712 this_cu
= obstack_alloc (&objfile
->objfile_obstack
,
3713 sizeof (struct dwarf2_per_cu_data
));
3714 memset (this_cu
, 0, sizeof (*this_cu
));
3715 this_cu
->offset
= offset
;
3716 this_cu
->length
= length
+ initial_length_size
;
3717 this_cu
->objfile
= objfile
;
3719 if (n_comp_units
== n_allocated
)
3722 all_comp_units
= xrealloc (all_comp_units
,
3724 * sizeof (struct dwarf2_per_cu_data
*));
3726 all_comp_units
[n_comp_units
++] = this_cu
;
3728 info_ptr
= info_ptr
+ this_cu
->length
;
3731 dwarf2_per_objfile
->all_comp_units
3732 = obstack_alloc (&objfile
->objfile_obstack
,
3733 n_comp_units
* sizeof (struct dwarf2_per_cu_data
*));
3734 memcpy (dwarf2_per_objfile
->all_comp_units
, all_comp_units
,
3735 n_comp_units
* sizeof (struct dwarf2_per_cu_data
*));
3736 xfree (all_comp_units
);
3737 dwarf2_per_objfile
->n_comp_units
= n_comp_units
;
3740 /* Process all loaded DIEs for compilation unit CU, starting at
3741 FIRST_DIE. The caller should pass NEED_PC == 1 if the compilation
3742 unit DIE did not have PC info (DW_AT_low_pc and DW_AT_high_pc, or
3743 DW_AT_ranges). If NEED_PC is set, then this function will set
3744 *LOWPC and *HIGHPC to the lowest and highest PC values found in CU
3745 and record the covered ranges in the addrmap. */
3748 scan_partial_symbols (struct partial_die_info
*first_die
, CORE_ADDR
*lowpc
,
3749 CORE_ADDR
*highpc
, int need_pc
, struct dwarf2_cu
*cu
)
3751 struct partial_die_info
*pdi
;
3753 /* Now, march along the PDI's, descending into ones which have
3754 interesting children but skipping the children of the other ones,
3755 until we reach the end of the compilation unit. */
3761 fixup_partial_die (pdi
, cu
);
3763 /* Anonymous namespaces or modules have no name but have interesting
3764 children, so we need to look at them. Ditto for anonymous
3767 if (pdi
->name
!= NULL
|| pdi
->tag
== DW_TAG_namespace
3768 || pdi
->tag
== DW_TAG_module
|| pdi
->tag
== DW_TAG_enumeration_type
)
3772 case DW_TAG_subprogram
:
3773 add_partial_subprogram (pdi
, lowpc
, highpc
, need_pc
, cu
);
3775 case DW_TAG_constant
:
3776 case DW_TAG_variable
:
3777 case DW_TAG_typedef
:
3778 case DW_TAG_union_type
:
3779 if (!pdi
->is_declaration
)
3781 add_partial_symbol (pdi
, cu
);
3784 case DW_TAG_class_type
:
3785 case DW_TAG_interface_type
:
3786 case DW_TAG_structure_type
:
3787 if (!pdi
->is_declaration
)
3789 add_partial_symbol (pdi
, cu
);
3792 case DW_TAG_enumeration_type
:
3793 if (!pdi
->is_declaration
)
3794 add_partial_enumeration (pdi
, cu
);
3796 case DW_TAG_base_type
:
3797 case DW_TAG_subrange_type
:
3798 /* File scope base type definitions are added to the partial
3800 add_partial_symbol (pdi
, cu
);
3802 case DW_TAG_namespace
:
3803 add_partial_namespace (pdi
, lowpc
, highpc
, need_pc
, cu
);
3806 add_partial_module (pdi
, lowpc
, highpc
, need_pc
, cu
);
3813 /* If the die has a sibling, skip to the sibling. */
3815 pdi
= pdi
->die_sibling
;
3819 /* Functions used to compute the fully scoped name of a partial DIE.
3821 Normally, this is simple. For C++, the parent DIE's fully scoped
3822 name is concatenated with "::" and the partial DIE's name. For
3823 Java, the same thing occurs except that "." is used instead of "::".
3824 Enumerators are an exception; they use the scope of their parent
3825 enumeration type, i.e. the name of the enumeration type is not
3826 prepended to the enumerator.
3828 There are two complexities. One is DW_AT_specification; in this
3829 case "parent" means the parent of the target of the specification,
3830 instead of the direct parent of the DIE. The other is compilers
3831 which do not emit DW_TAG_namespace; in this case we try to guess
3832 the fully qualified name of structure types from their members'
3833 linkage names. This must be done using the DIE's children rather
3834 than the children of any DW_AT_specification target. We only need
3835 to do this for structures at the top level, i.e. if the target of
3836 any DW_AT_specification (if any; otherwise the DIE itself) does not
3839 /* Compute the scope prefix associated with PDI's parent, in
3840 compilation unit CU. The result will be allocated on CU's
3841 comp_unit_obstack, or a copy of the already allocated PDI->NAME
3842 field. NULL is returned if no prefix is necessary. */
3844 partial_die_parent_scope (struct partial_die_info
*pdi
,
3845 struct dwarf2_cu
*cu
)
3847 char *grandparent_scope
;
3848 struct partial_die_info
*parent
, *real_pdi
;
3850 /* We need to look at our parent DIE; if we have a DW_AT_specification,
3851 then this means the parent of the specification DIE. */
3854 while (real_pdi
->has_specification
)
3855 real_pdi
= find_partial_die (real_pdi
->spec_offset
, cu
);
3857 parent
= real_pdi
->die_parent
;
3861 if (parent
->scope_set
)
3862 return parent
->scope
;
3864 fixup_partial_die (parent
, cu
);
3866 grandparent_scope
= partial_die_parent_scope (parent
, cu
);
3868 /* GCC 4.0 and 4.1 had a bug (PR c++/28460) where they generated bogus
3869 DW_TAG_namespace DIEs with a name of "::" for the global namespace.
3870 Work around this problem here. */
3871 if (cu
->language
== language_cplus
3872 && parent
->tag
== DW_TAG_namespace
3873 && strcmp (parent
->name
, "::") == 0
3874 && grandparent_scope
== NULL
)
3876 parent
->scope
= NULL
;
3877 parent
->scope_set
= 1;
3881 if (parent
->tag
== DW_TAG_namespace
3882 || parent
->tag
== DW_TAG_module
3883 || parent
->tag
== DW_TAG_structure_type
3884 || parent
->tag
== DW_TAG_class_type
3885 || parent
->tag
== DW_TAG_interface_type
3886 || parent
->tag
== DW_TAG_union_type
3887 || parent
->tag
== DW_TAG_enumeration_type
)
3889 if (grandparent_scope
== NULL
)
3890 parent
->scope
= parent
->name
;
3892 parent
->scope
= typename_concat (&cu
->comp_unit_obstack
,
3894 parent
->name
, 0, cu
);
3896 else if (parent
->tag
== DW_TAG_enumerator
)
3897 /* Enumerators should not get the name of the enumeration as a prefix. */
3898 parent
->scope
= grandparent_scope
;
3901 /* FIXME drow/2004-04-01: What should we be doing with
3902 function-local names? For partial symbols, we should probably be
3904 complaint (&symfile_complaints
,
3905 _("unhandled containing DIE tag %d for DIE at %d"),
3906 parent
->tag
, pdi
->offset
);
3907 parent
->scope
= grandparent_scope
;
3910 parent
->scope_set
= 1;
3911 return parent
->scope
;
3914 /* Return the fully scoped name associated with PDI, from compilation unit
3915 CU. The result will be allocated with malloc. */
3917 partial_die_full_name (struct partial_die_info
*pdi
,
3918 struct dwarf2_cu
*cu
)
3922 /* If this is a template instantiation, we can not work out the
3923 template arguments from partial DIEs. So, unfortunately, we have
3924 to go through the full DIEs. At least any work we do building
3925 types here will be reused if full symbols are loaded later. */
3926 if (pdi
->has_template_arguments
)
3928 fixup_partial_die (pdi
, cu
);
3930 if (pdi
->name
!= NULL
&& strchr (pdi
->name
, '<') == NULL
)
3932 struct die_info
*die
;
3933 struct attribute attr
;
3934 struct dwarf2_cu
*ref_cu
= cu
;
3937 attr
.form
= DW_FORM_ref_addr
;
3938 attr
.u
.addr
= pdi
->offset
;
3939 die
= follow_die_ref (NULL
, &attr
, &ref_cu
);
3941 return xstrdup (dwarf2_full_name (NULL
, die
, ref_cu
));
3945 parent_scope
= partial_die_parent_scope (pdi
, cu
);
3946 if (parent_scope
== NULL
)
3949 return typename_concat (NULL
, parent_scope
, pdi
->name
, 0, cu
);
3953 add_partial_symbol (struct partial_die_info
*pdi
, struct dwarf2_cu
*cu
)
3955 struct objfile
*objfile
= cu
->objfile
;
3957 char *actual_name
= NULL
;
3958 const struct partial_symbol
*psym
= NULL
;
3960 int built_actual_name
= 0;
3962 baseaddr
= ANOFFSET (objfile
->section_offsets
, SECT_OFF_TEXT (objfile
));
3964 actual_name
= partial_die_full_name (pdi
, cu
);
3966 built_actual_name
= 1;
3968 if (actual_name
== NULL
)
3969 actual_name
= pdi
->name
;
3973 case DW_TAG_subprogram
:
3974 if (pdi
->is_external
|| cu
->language
== language_ada
)
3976 /* brobecker/2007-12-26: Normally, only "external" DIEs are part
3977 of the global scope. But in Ada, we want to be able to access
3978 nested procedures globally. So all Ada subprograms are stored
3979 in the global scope. */
3980 /* prim_record_minimal_symbol (actual_name, pdi->lowpc + baseaddr,
3981 mst_text, objfile); */
3982 add_psymbol_to_list (actual_name
, strlen (actual_name
),
3984 VAR_DOMAIN
, LOC_BLOCK
,
3985 &objfile
->global_psymbols
,
3986 0, pdi
->lowpc
+ baseaddr
,
3987 cu
->language
, objfile
);
3991 /* prim_record_minimal_symbol (actual_name, pdi->lowpc + baseaddr,
3992 mst_file_text, objfile); */
3993 add_psymbol_to_list (actual_name
, strlen (actual_name
),
3995 VAR_DOMAIN
, LOC_BLOCK
,
3996 &objfile
->static_psymbols
,
3997 0, pdi
->lowpc
+ baseaddr
,
3998 cu
->language
, objfile
);
4001 case DW_TAG_constant
:
4003 struct psymbol_allocation_list
*list
;
4005 if (pdi
->is_external
)
4006 list
= &objfile
->global_psymbols
;
4008 list
= &objfile
->static_psymbols
;
4009 add_psymbol_to_list (actual_name
, strlen (actual_name
),
4010 built_actual_name
, VAR_DOMAIN
, LOC_STATIC
,
4011 list
, 0, 0, cu
->language
, objfile
);
4014 case DW_TAG_variable
:
4016 addr
= decode_locdesc (pdi
->locdesc
, cu
);
4020 && !dwarf2_per_objfile
->has_section_at_zero
)
4022 /* A global or static variable may also have been stripped
4023 out by the linker if unused, in which case its address
4024 will be nullified; do not add such variables into partial
4025 symbol table then. */
4027 else if (pdi
->is_external
)
4030 Don't enter into the minimal symbol tables as there is
4031 a minimal symbol table entry from the ELF symbols already.
4032 Enter into partial symbol table if it has a location
4033 descriptor or a type.
4034 If the location descriptor is missing, new_symbol will create
4035 a LOC_UNRESOLVED symbol, the address of the variable will then
4036 be determined from the minimal symbol table whenever the variable
4038 The address for the partial symbol table entry is not
4039 used by GDB, but it comes in handy for debugging partial symbol
4042 if (pdi
->locdesc
|| pdi
->has_type
)
4043 add_psymbol_to_list (actual_name
, strlen (actual_name
),
4045 VAR_DOMAIN
, LOC_STATIC
,
4046 &objfile
->global_psymbols
,
4048 cu
->language
, objfile
);
4052 /* Static Variable. Skip symbols without location descriptors. */
4053 if (pdi
->locdesc
== NULL
)
4055 if (built_actual_name
)
4056 xfree (actual_name
);
4059 /* prim_record_minimal_symbol (actual_name, addr + baseaddr,
4060 mst_file_data, objfile); */
4061 add_psymbol_to_list (actual_name
, strlen (actual_name
),
4063 VAR_DOMAIN
, LOC_STATIC
,
4064 &objfile
->static_psymbols
,
4066 cu
->language
, objfile
);
4069 case DW_TAG_typedef
:
4070 case DW_TAG_base_type
:
4071 case DW_TAG_subrange_type
:
4072 add_psymbol_to_list (actual_name
, strlen (actual_name
),
4074 VAR_DOMAIN
, LOC_TYPEDEF
,
4075 &objfile
->static_psymbols
,
4076 0, (CORE_ADDR
) 0, cu
->language
, objfile
);
4078 case DW_TAG_namespace
:
4079 add_psymbol_to_list (actual_name
, strlen (actual_name
),
4081 VAR_DOMAIN
, LOC_TYPEDEF
,
4082 &objfile
->global_psymbols
,
4083 0, (CORE_ADDR
) 0, cu
->language
, objfile
);
4085 case DW_TAG_class_type
:
4086 case DW_TAG_interface_type
:
4087 case DW_TAG_structure_type
:
4088 case DW_TAG_union_type
:
4089 case DW_TAG_enumeration_type
:
4090 /* Skip external references. The DWARF standard says in the section
4091 about "Structure, Union, and Class Type Entries": "An incomplete
4092 structure, union or class type is represented by a structure,
4093 union or class entry that does not have a byte size attribute
4094 and that has a DW_AT_declaration attribute." */
4095 if (!pdi
->has_byte_size
&& pdi
->is_declaration
)
4097 if (built_actual_name
)
4098 xfree (actual_name
);
4102 /* NOTE: carlton/2003-10-07: See comment in new_symbol about
4103 static vs. global. */
4104 add_psymbol_to_list (actual_name
, strlen (actual_name
),
4106 STRUCT_DOMAIN
, LOC_TYPEDEF
,
4107 (cu
->language
== language_cplus
4108 || cu
->language
== language_java
)
4109 ? &objfile
->global_psymbols
4110 : &objfile
->static_psymbols
,
4111 0, (CORE_ADDR
) 0, cu
->language
, objfile
);
4114 case DW_TAG_enumerator
:
4115 add_psymbol_to_list (actual_name
, strlen (actual_name
),
4117 VAR_DOMAIN
, LOC_CONST
,
4118 (cu
->language
== language_cplus
4119 || cu
->language
== language_java
)
4120 ? &objfile
->global_psymbols
4121 : &objfile
->static_psymbols
,
4122 0, (CORE_ADDR
) 0, cu
->language
, objfile
);
4128 if (built_actual_name
)
4129 xfree (actual_name
);
4132 /* Read a partial die corresponding to a namespace; also, add a symbol
4133 corresponding to that namespace to the symbol table. NAMESPACE is
4134 the name of the enclosing namespace. */
4137 add_partial_namespace (struct partial_die_info
*pdi
,
4138 CORE_ADDR
*lowpc
, CORE_ADDR
*highpc
,
4139 int need_pc
, struct dwarf2_cu
*cu
)
4141 /* Add a symbol for the namespace. */
4143 add_partial_symbol (pdi
, cu
);
4145 /* Now scan partial symbols in that namespace. */
4147 if (pdi
->has_children
)
4148 scan_partial_symbols (pdi
->die_child
, lowpc
, highpc
, need_pc
, cu
);
4151 /* Read a partial die corresponding to a Fortran module. */
4154 add_partial_module (struct partial_die_info
*pdi
, CORE_ADDR
*lowpc
,
4155 CORE_ADDR
*highpc
, int need_pc
, struct dwarf2_cu
*cu
)
4157 /* Now scan partial symbols in that module. */
4159 if (pdi
->has_children
)
4160 scan_partial_symbols (pdi
->die_child
, lowpc
, highpc
, need_pc
, cu
);
4163 /* Read a partial die corresponding to a subprogram and create a partial
4164 symbol for that subprogram. When the CU language allows it, this
4165 routine also defines a partial symbol for each nested subprogram
4166 that this subprogram contains.
4168 DIE my also be a lexical block, in which case we simply search
4169 recursively for suprograms defined inside that lexical block.
4170 Again, this is only performed when the CU language allows this
4171 type of definitions. */
4174 add_partial_subprogram (struct partial_die_info
*pdi
,
4175 CORE_ADDR
*lowpc
, CORE_ADDR
*highpc
,
4176 int need_pc
, struct dwarf2_cu
*cu
)
4178 if (pdi
->tag
== DW_TAG_subprogram
)
4180 if (pdi
->has_pc_info
)
4182 if (pdi
->lowpc
< *lowpc
)
4183 *lowpc
= pdi
->lowpc
;
4184 if (pdi
->highpc
> *highpc
)
4185 *highpc
= pdi
->highpc
;
4189 struct objfile
*objfile
= cu
->objfile
;
4191 baseaddr
= ANOFFSET (objfile
->section_offsets
,
4192 SECT_OFF_TEXT (objfile
));
4193 addrmap_set_empty (objfile
->psymtabs_addrmap
,
4194 pdi
->lowpc
+ baseaddr
,
4195 pdi
->highpc
- 1 + baseaddr
,
4196 cu
->per_cu
->v
.psymtab
);
4198 if (!pdi
->is_declaration
)
4199 /* Ignore subprogram DIEs that do not have a name, they are
4200 illegal. Do not emit a complaint at this point, we will
4201 do so when we convert this psymtab into a symtab. */
4203 add_partial_symbol (pdi
, cu
);
4207 if (! pdi
->has_children
)
4210 if (cu
->language
== language_ada
)
4212 pdi
= pdi
->die_child
;
4215 fixup_partial_die (pdi
, cu
);
4216 if (pdi
->tag
== DW_TAG_subprogram
4217 || pdi
->tag
== DW_TAG_lexical_block
)
4218 add_partial_subprogram (pdi
, lowpc
, highpc
, need_pc
, cu
);
4219 pdi
= pdi
->die_sibling
;
4224 /* Read a partial die corresponding to an enumeration type. */
4227 add_partial_enumeration (struct partial_die_info
*enum_pdi
,
4228 struct dwarf2_cu
*cu
)
4230 struct partial_die_info
*pdi
;
4232 if (enum_pdi
->name
!= NULL
)
4233 add_partial_symbol (enum_pdi
, cu
);
4235 pdi
= enum_pdi
->die_child
;
4238 if (pdi
->tag
!= DW_TAG_enumerator
|| pdi
->name
== NULL
)
4239 complaint (&symfile_complaints
, _("malformed enumerator DIE ignored"));
4241 add_partial_symbol (pdi
, cu
);
4242 pdi
= pdi
->die_sibling
;
4246 /* Read the initial uleb128 in the die at INFO_PTR in compilation unit CU.
4247 Return the corresponding abbrev, or NULL if the number is zero (indicating
4248 an empty DIE). In either case *BYTES_READ will be set to the length of
4249 the initial number. */
4251 static struct abbrev_info
*
4252 peek_die_abbrev (gdb_byte
*info_ptr
, unsigned int *bytes_read
,
4253 struct dwarf2_cu
*cu
)
4255 bfd
*abfd
= cu
->objfile
->obfd
;
4256 unsigned int abbrev_number
;
4257 struct abbrev_info
*abbrev
;
4259 abbrev_number
= read_unsigned_leb128 (abfd
, info_ptr
, bytes_read
);
4261 if (abbrev_number
== 0)
4264 abbrev
= dwarf2_lookup_abbrev (abbrev_number
, cu
);
4267 error (_("Dwarf Error: Could not find abbrev number %d [in module %s]"),
4268 abbrev_number
, bfd_get_filename (abfd
));
4274 /* Scan the debug information for CU starting at INFO_PTR in buffer BUFFER.
4275 Returns a pointer to the end of a series of DIEs, terminated by an empty
4276 DIE. Any children of the skipped DIEs will also be skipped. */
4279 skip_children (gdb_byte
*buffer
, gdb_byte
*info_ptr
, struct dwarf2_cu
*cu
)
4281 struct abbrev_info
*abbrev
;
4282 unsigned int bytes_read
;
4286 abbrev
= peek_die_abbrev (info_ptr
, &bytes_read
, cu
);
4288 return info_ptr
+ bytes_read
;
4290 info_ptr
= skip_one_die (buffer
, info_ptr
+ bytes_read
, abbrev
, cu
);
4294 /* Scan the debug information for CU starting at INFO_PTR in buffer BUFFER.
4295 INFO_PTR should point just after the initial uleb128 of a DIE, and the
4296 abbrev corresponding to that skipped uleb128 should be passed in
4297 ABBREV. Returns a pointer to this DIE's sibling, skipping any
4301 skip_one_die (gdb_byte
*buffer
, gdb_byte
*info_ptr
,
4302 struct abbrev_info
*abbrev
, struct dwarf2_cu
*cu
)
4304 unsigned int bytes_read
;
4305 struct attribute attr
;
4306 bfd
*abfd
= cu
->objfile
->obfd
;
4307 unsigned int form
, i
;
4309 for (i
= 0; i
< abbrev
->num_attrs
; i
++)
4311 /* The only abbrev we care about is DW_AT_sibling. */
4312 if (abbrev
->attrs
[i
].name
== DW_AT_sibling
)
4314 read_attribute (&attr
, &abbrev
->attrs
[i
],
4315 abfd
, info_ptr
, cu
);
4316 if (attr
.form
== DW_FORM_ref_addr
)
4317 complaint (&symfile_complaints
,
4318 _("ignoring absolute DW_AT_sibling"));
4320 return buffer
+ dwarf2_get_ref_die_offset (&attr
);
4323 /* If it isn't DW_AT_sibling, skip this attribute. */
4324 form
= abbrev
->attrs
[i
].form
;
4328 case DW_FORM_ref_addr
:
4329 /* In DWARF 2, DW_FORM_ref_addr is address sized; in DWARF 3
4330 and later it is offset sized. */
4331 if (cu
->header
.version
== 2)
4332 info_ptr
+= cu
->header
.addr_size
;
4334 info_ptr
+= cu
->header
.offset_size
;
4337 info_ptr
+= cu
->header
.addr_size
;
4344 case DW_FORM_flag_present
:
4356 case DW_FORM_ref_sig8
:
4359 case DW_FORM_string
:
4360 read_direct_string (abfd
, info_ptr
, &bytes_read
);
4361 info_ptr
+= bytes_read
;
4363 case DW_FORM_sec_offset
:
4365 info_ptr
+= cu
->header
.offset_size
;
4367 case DW_FORM_exprloc
:
4369 info_ptr
+= read_unsigned_leb128 (abfd
, info_ptr
, &bytes_read
);
4370 info_ptr
+= bytes_read
;
4372 case DW_FORM_block1
:
4373 info_ptr
+= 1 + read_1_byte (abfd
, info_ptr
);
4375 case DW_FORM_block2
:
4376 info_ptr
+= 2 + read_2_bytes (abfd
, info_ptr
);
4378 case DW_FORM_block4
:
4379 info_ptr
+= 4 + read_4_bytes (abfd
, info_ptr
);
4383 case DW_FORM_ref_udata
:
4384 info_ptr
= skip_leb128 (abfd
, info_ptr
);
4386 case DW_FORM_indirect
:
4387 form
= read_unsigned_leb128 (abfd
, info_ptr
, &bytes_read
);
4388 info_ptr
+= bytes_read
;
4389 /* We need to continue parsing from here, so just go back to
4391 goto skip_attribute
;
4394 error (_("Dwarf Error: Cannot handle %s "
4395 "in DWARF reader [in module %s]"),
4396 dwarf_form_name (form
),
4397 bfd_get_filename (abfd
));
4401 if (abbrev
->has_children
)
4402 return skip_children (buffer
, info_ptr
, cu
);
4407 /* Locate ORIG_PDI's sibling.
4408 INFO_PTR should point to the start of the next DIE after ORIG_PDI
4412 locate_pdi_sibling (struct partial_die_info
*orig_pdi
,
4413 gdb_byte
*buffer
, gdb_byte
*info_ptr
,
4414 bfd
*abfd
, struct dwarf2_cu
*cu
)
4416 /* Do we know the sibling already? */
4418 if (orig_pdi
->sibling
)
4419 return orig_pdi
->sibling
;
4421 /* Are there any children to deal with? */
4423 if (!orig_pdi
->has_children
)
4426 /* Skip the children the long way. */
4428 return skip_children (buffer
, info_ptr
, cu
);
4431 /* Expand this partial symbol table into a full symbol table. */
4434 dwarf2_psymtab_to_symtab (struct partial_symtab
*pst
)
4440 warning (_("bug: psymtab for %s is already read in."),
4447 printf_filtered (_("Reading in symbols for %s..."),
4449 gdb_flush (gdb_stdout
);
4452 /* Restore our global data. */
4453 dwarf2_per_objfile
= objfile_data (pst
->objfile
,
4454 dwarf2_objfile_data_key
);
4456 /* If this psymtab is constructed from a debug-only objfile, the
4457 has_section_at_zero flag will not necessarily be correct. We
4458 can get the correct value for this flag by looking at the data
4459 associated with the (presumably stripped) associated objfile. */
4460 if (pst
->objfile
->separate_debug_objfile_backlink
)
4462 struct dwarf2_per_objfile
*dpo_backlink
4463 = objfile_data (pst
->objfile
->separate_debug_objfile_backlink
,
4464 dwarf2_objfile_data_key
);
4466 dwarf2_per_objfile
->has_section_at_zero
4467 = dpo_backlink
->has_section_at_zero
;
4470 dwarf2_per_objfile
->reading_partial_symbols
= 0;
4472 psymtab_to_symtab_1 (pst
);
4474 /* Finish up the debug error message. */
4476 printf_filtered (_("done.\n"));
4481 /* Add PER_CU to the queue. */
4484 queue_comp_unit (struct dwarf2_per_cu_data
*per_cu
, struct objfile
*objfile
)
4486 struct dwarf2_queue_item
*item
;
4489 item
= xmalloc (sizeof (*item
));
4490 item
->per_cu
= per_cu
;
4493 if (dwarf2_queue
== NULL
)
4494 dwarf2_queue
= item
;
4496 dwarf2_queue_tail
->next
= item
;
4498 dwarf2_queue_tail
= item
;
4501 /* Process the queue. */
4504 process_queue (struct objfile
*objfile
)
4506 struct dwarf2_queue_item
*item
, *next_item
;
4508 /* The queue starts out with one item, but following a DIE reference
4509 may load a new CU, adding it to the end of the queue. */
4510 for (item
= dwarf2_queue
; item
!= NULL
; dwarf2_queue
= item
= next_item
)
4512 if (dwarf2_per_objfile
->using_index
4513 ? !item
->per_cu
->v
.quick
->symtab
4514 : (item
->per_cu
->v
.psymtab
&& !item
->per_cu
->v
.psymtab
->readin
))
4515 process_full_comp_unit (item
->per_cu
);
4517 item
->per_cu
->queued
= 0;
4518 next_item
= item
->next
;
4522 dwarf2_queue_tail
= NULL
;
4525 /* Free all allocated queue entries. This function only releases anything if
4526 an error was thrown; if the queue was processed then it would have been
4527 freed as we went along. */
4530 dwarf2_release_queue (void *dummy
)
4532 struct dwarf2_queue_item
*item
, *last
;
4534 item
= dwarf2_queue
;
4537 /* Anything still marked queued is likely to be in an
4538 inconsistent state, so discard it. */
4539 if (item
->per_cu
->queued
)
4541 if (item
->per_cu
->cu
!= NULL
)
4542 free_one_cached_comp_unit (item
->per_cu
->cu
);
4543 item
->per_cu
->queued
= 0;
4551 dwarf2_queue
= dwarf2_queue_tail
= NULL
;
4554 /* Read in full symbols for PST, and anything it depends on. */
4557 psymtab_to_symtab_1 (struct partial_symtab
*pst
)
4559 struct dwarf2_per_cu_data
*per_cu
;
4560 struct cleanup
*back_to
;
4563 for (i
= 0; i
< pst
->number_of_dependencies
; i
++)
4564 if (!pst
->dependencies
[i
]->readin
)
4566 /* Inform about additional files that need to be read in. */
4569 /* FIXME: i18n: Need to make this a single string. */
4570 fputs_filtered (" ", gdb_stdout
);
4572 fputs_filtered ("and ", gdb_stdout
);
4574 printf_filtered ("%s...", pst
->dependencies
[i
]->filename
);
4575 wrap_here (""); /* Flush output. */
4576 gdb_flush (gdb_stdout
);
4578 psymtab_to_symtab_1 (pst
->dependencies
[i
]);
4581 per_cu
= pst
->read_symtab_private
;
4585 /* It's an include file, no symbols to read for it.
4586 Everything is in the parent symtab. */
4591 dw2_do_instantiate_symtab (pst
->objfile
, per_cu
);
4594 /* Load the DIEs associated with PER_CU into memory. */
4597 load_full_comp_unit (struct dwarf2_per_cu_data
*per_cu
,
4598 struct objfile
*objfile
)
4600 bfd
*abfd
= objfile
->obfd
;
4601 struct dwarf2_cu
*cu
;
4602 unsigned int offset
;
4603 gdb_byte
*info_ptr
, *beg_of_comp_unit
;
4604 struct cleanup
*free_abbrevs_cleanup
= NULL
, *free_cu_cleanup
= NULL
;
4605 struct attribute
*attr
;
4608 gdb_assert (! per_cu
->debug_type_section
);
4610 /* Set local variables from the partial symbol table info. */
4611 offset
= per_cu
->offset
;
4613 dwarf2_read_section (objfile
, &dwarf2_per_objfile
->info
);
4614 info_ptr
= dwarf2_per_objfile
->info
.buffer
+ offset
;
4615 beg_of_comp_unit
= info_ptr
;
4617 if (per_cu
->cu
== NULL
)
4619 cu
= xmalloc (sizeof (*cu
));
4620 init_one_comp_unit (cu
, objfile
);
4624 /* If an error occurs while loading, release our storage. */
4625 free_cu_cleanup
= make_cleanup (free_one_comp_unit
, cu
);
4627 /* Read in the comp_unit header. */
4628 info_ptr
= read_comp_unit_head (&cu
->header
, info_ptr
, abfd
);
4630 /* Complete the cu_header. */
4631 cu
->header
.offset
= offset
;
4632 cu
->header
.first_die_offset
= info_ptr
- beg_of_comp_unit
;
4634 /* Read the abbrevs for this compilation unit. */
4635 dwarf2_read_abbrevs (abfd
, cu
);
4636 free_abbrevs_cleanup
= make_cleanup (dwarf2_free_abbrev_table
, cu
);
4638 /* Link this compilation unit into the compilation unit tree. */
4640 cu
->per_cu
= per_cu
;
4642 /* Link this CU into read_in_chain. */
4643 per_cu
->cu
->read_in_chain
= dwarf2_per_objfile
->read_in_chain
;
4644 dwarf2_per_objfile
->read_in_chain
= per_cu
;
4649 info_ptr
+= cu
->header
.first_die_offset
;
4652 cu
->dies
= read_comp_unit (info_ptr
, cu
);
4654 /* We try not to read any attributes in this function, because not
4655 all objfiles needed for references have been loaded yet, and symbol
4656 table processing isn't initialized. But we have to set the CU language,
4657 or we won't be able to build types correctly. */
4658 prepare_one_comp_unit (cu
, cu
->dies
);
4660 /* Similarly, if we do not read the producer, we can not apply
4661 producer-specific interpretation. */
4662 attr
= dwarf2_attr (cu
->dies
, DW_AT_producer
, cu
);
4664 cu
->producer
= DW_STRING (attr
);
4668 do_cleanups (free_abbrevs_cleanup
);
4670 /* We've successfully allocated this compilation unit. Let our
4671 caller clean it up when finished with it. */
4672 discard_cleanups (free_cu_cleanup
);
4676 /* Add a DIE to the delayed physname list. */
4679 add_to_method_list (struct type
*type
, int fnfield_index
, int index
,
4680 const char *name
, struct die_info
*die
,
4681 struct dwarf2_cu
*cu
)
4683 struct delayed_method_info mi
;
4685 mi
.fnfield_index
= fnfield_index
;
4689 VEC_safe_push (delayed_method_info
, cu
->method_list
, &mi
);
4692 /* A cleanup for freeing the delayed method list. */
4695 free_delayed_list (void *ptr
)
4697 struct dwarf2_cu
*cu
= (struct dwarf2_cu
*) ptr
;
4698 if (cu
->method_list
!= NULL
)
4700 VEC_free (delayed_method_info
, cu
->method_list
);
4701 cu
->method_list
= NULL
;
4705 /* Compute the physnames of any methods on the CU's method list.
4707 The computation of method physnames is delayed in order to avoid the
4708 (bad) condition that one of the method's formal parameters is of an as yet
4712 compute_delayed_physnames (struct dwarf2_cu
*cu
)
4715 struct delayed_method_info
*mi
;
4716 for (i
= 0; VEC_iterate (delayed_method_info
, cu
->method_list
, i
, mi
) ; ++i
)
4718 const char *physname
;
4719 struct fn_fieldlist
*fn_flp
4720 = &TYPE_FN_FIELDLIST (mi
->type
, mi
->fnfield_index
);
4721 physname
= dwarf2_physname ((char *) mi
->name
, mi
->die
, cu
);
4722 fn_flp
->fn_fields
[mi
->index
].physname
= physname
? physname
: "";
4726 /* Check for GCC >= 4.x. Return minor version (x) of 4.x in such case. If it
4727 is not GCC or it is GCC older than 4.x return -1. If it is GCC 5.x or
4728 higher return INT_MAX. */
4731 producer_is_gcc_ge_4 (struct dwarf2_cu
*cu
)
4736 if (cu
->producer
== NULL
)
4738 /* For unknown compilers expect their behavior is not compliant. For GCC
4739 this case can also happen for -gdwarf-4 type units supported since
4745 /* Skip any identifier after "GNU " - such as "C++" or "Java". */
4747 if (strncmp (cu
->producer
, "GNU ", strlen ("GNU ")) != 0)
4749 /* For non-GCC compilers expect their behavior is not compliant. */
4753 cs
= &cu
->producer
[strlen ("GNU ")];
4754 while (*cs
&& !isdigit (*cs
))
4756 if (sscanf (cs
, "%d.%d", &major
, &minor
) != 2)
4758 /* Not recognized as GCC. */
4770 /* Generate full symbol information for PST and CU, whose DIEs have
4771 already been loaded into memory. */
4774 process_full_comp_unit (struct dwarf2_per_cu_data
*per_cu
)
4776 struct dwarf2_cu
*cu
= per_cu
->cu
;
4777 struct objfile
*objfile
= per_cu
->objfile
;
4778 CORE_ADDR lowpc
, highpc
;
4779 struct symtab
*symtab
;
4780 struct cleanup
*back_to
, *delayed_list_cleanup
;
4783 baseaddr
= ANOFFSET (objfile
->section_offsets
, SECT_OFF_TEXT (objfile
));
4786 back_to
= make_cleanup (really_free_pendings
, NULL
);
4787 delayed_list_cleanup
= make_cleanup (free_delayed_list
, cu
);
4789 cu
->list_in_scope
= &file_symbols
;
4791 /* Do line number decoding in read_file_scope () */
4792 process_die (cu
->dies
, cu
);
4794 /* Now that we have processed all the DIEs in the CU, all the types
4795 should be complete, and it should now be safe to compute all of the
4797 compute_delayed_physnames (cu
);
4798 do_cleanups (delayed_list_cleanup
);
4800 /* Some compilers don't define a DW_AT_high_pc attribute for the
4801 compilation unit. If the DW_AT_high_pc is missing, synthesize
4802 it, by scanning the DIE's below the compilation unit. */
4803 get_scope_pc_bounds (cu
->dies
, &lowpc
, &highpc
, cu
);
4805 symtab
= end_symtab (highpc
+ baseaddr
, objfile
, SECT_OFF_TEXT (objfile
));
4809 int gcc_4_minor
= producer_is_gcc_ge_4 (cu
);
4811 /* Set symtab language to language from DW_AT_language. If the
4812 compilation is from a C file generated by language preprocessors, do
4813 not set the language if it was already deduced by start_subfile. */
4814 if (!(cu
->language
== language_c
&& symtab
->language
!= language_c
))
4815 symtab
->language
= cu
->language
;
4817 /* GCC-4.0 has started to support -fvar-tracking. GCC-3.x still can
4818 produce DW_AT_location with location lists but it can be possibly
4819 invalid without -fvar-tracking.
4821 For -gdwarf-4 type units LOCATIONS_VALID indication is fortunately not
4822 needed, it would be wrong due to missing DW_AT_producer there.
4824 Still one can confuse GDB by using non-standard GCC compilation
4825 options - this waits on GCC PR other/32998 (-frecord-gcc-switches).
4827 if (cu
->has_loclist
&& gcc_4_minor
>= 0)
4828 symtab
->locations_valid
= 1;
4830 if (gcc_4_minor
>= 5)
4831 symtab
->epilogue_unwind_valid
= 1;
4833 if (gcc_4_minor
>= 6)
4834 symtab
->amd64_prologue_line_bug
= 1;
4837 if (dwarf2_per_objfile
->using_index
)
4838 per_cu
->v
.quick
->symtab
= symtab
;
4841 struct partial_symtab
*pst
= per_cu
->v
.psymtab
;
4842 pst
->symtab
= symtab
;
4846 do_cleanups (back_to
);
4849 /* Process a die and its children. */
4852 process_die (struct die_info
*die
, struct dwarf2_cu
*cu
)
4856 case DW_TAG_padding
:
4858 case DW_TAG_compile_unit
:
4859 read_file_scope (die
, cu
);
4861 case DW_TAG_type_unit
:
4862 read_type_unit_scope (die
, cu
);
4864 case DW_TAG_subprogram
:
4865 case DW_TAG_inlined_subroutine
:
4866 read_func_scope (die
, cu
);
4868 case DW_TAG_lexical_block
:
4869 case DW_TAG_try_block
:
4870 case DW_TAG_catch_block
:
4871 read_lexical_block_scope (die
, cu
);
4873 case DW_TAG_class_type
:
4874 case DW_TAG_interface_type
:
4875 case DW_TAG_structure_type
:
4876 case DW_TAG_union_type
:
4877 process_structure_scope (die
, cu
);
4879 case DW_TAG_enumeration_type
:
4880 process_enumeration_scope (die
, cu
);
4883 /* These dies have a type, but processing them does not create
4884 a symbol or recurse to process the children. Therefore we can
4885 read them on-demand through read_type_die. */
4886 case DW_TAG_subroutine_type
:
4887 case DW_TAG_set_type
:
4888 case DW_TAG_array_type
:
4889 case DW_TAG_pointer_type
:
4890 case DW_TAG_ptr_to_member_type
:
4891 case DW_TAG_reference_type
:
4892 case DW_TAG_string_type
:
4895 case DW_TAG_base_type
:
4896 case DW_TAG_subrange_type
:
4897 case DW_TAG_typedef
:
4898 /* Add a typedef symbol for the type definition, if it has a
4900 new_symbol (die
, read_type_die (die
, cu
), cu
);
4902 case DW_TAG_common_block
:
4903 read_common_block (die
, cu
);
4905 case DW_TAG_common_inclusion
:
4907 case DW_TAG_namespace
:
4908 processing_has_namespace_info
= 1;
4909 read_namespace (die
, cu
);
4912 processing_has_namespace_info
= 1;
4913 read_module (die
, cu
);
4915 case DW_TAG_imported_declaration
:
4916 case DW_TAG_imported_module
:
4917 processing_has_namespace_info
= 1;
4918 if (die
->child
!= NULL
&& (die
->tag
== DW_TAG_imported_declaration
4919 || cu
->language
!= language_fortran
))
4920 complaint (&symfile_complaints
, _("Tag '%s' has unexpected children"),
4921 dwarf_tag_name (die
->tag
));
4922 read_import_statement (die
, cu
);
4925 new_symbol (die
, NULL
, cu
);
4930 /* A helper function for dwarf2_compute_name which determines whether DIE
4931 needs to have the name of the scope prepended to the name listed in the
4935 die_needs_namespace (struct die_info
*die
, struct dwarf2_cu
*cu
)
4937 struct attribute
*attr
;
4941 case DW_TAG_namespace
:
4942 case DW_TAG_typedef
:
4943 case DW_TAG_class_type
:
4944 case DW_TAG_interface_type
:
4945 case DW_TAG_structure_type
:
4946 case DW_TAG_union_type
:
4947 case DW_TAG_enumeration_type
:
4948 case DW_TAG_enumerator
:
4949 case DW_TAG_subprogram
:
4953 case DW_TAG_variable
:
4954 case DW_TAG_constant
:
4955 /* We only need to prefix "globally" visible variables. These include
4956 any variable marked with DW_AT_external or any variable that
4957 lives in a namespace. [Variables in anonymous namespaces
4958 require prefixing, but they are not DW_AT_external.] */
4960 if (dwarf2_attr (die
, DW_AT_specification
, cu
))
4962 struct dwarf2_cu
*spec_cu
= cu
;
4964 return die_needs_namespace (die_specification (die
, &spec_cu
),
4968 attr
= dwarf2_attr (die
, DW_AT_external
, cu
);
4969 if (attr
== NULL
&& die
->parent
->tag
!= DW_TAG_namespace
4970 && die
->parent
->tag
!= DW_TAG_module
)
4972 /* A variable in a lexical block of some kind does not need a
4973 namespace, even though in C++ such variables may be external
4974 and have a mangled name. */
4975 if (die
->parent
->tag
== DW_TAG_lexical_block
4976 || die
->parent
->tag
== DW_TAG_try_block
4977 || die
->parent
->tag
== DW_TAG_catch_block
4978 || die
->parent
->tag
== DW_TAG_subprogram
)
4987 /* Retrieve the last character from a mem_file. */
4990 do_ui_file_peek_last (void *object
, const char *buffer
, long length
)
4992 char *last_char_p
= (char *) object
;
4995 *last_char_p
= buffer
[length
- 1];
4998 /* Compute the fully qualified name of DIE in CU. If PHYSNAME is nonzero,
4999 compute the physname for the object, which include a method's
5000 formal parameters (C++/Java) and return type (Java).
5002 For Ada, return the DIE's linkage name rather than the fully qualified
5003 name. PHYSNAME is ignored..
5005 The result is allocated on the objfile_obstack and canonicalized. */
5008 dwarf2_compute_name (char *name
, struct die_info
*die
, struct dwarf2_cu
*cu
,
5012 name
= dwarf2_name (die
, cu
);
5014 /* For Fortran GDB prefers DW_AT_*linkage_name if present but otherwise
5015 compute it by typename_concat inside GDB. */
5016 if (cu
->language
== language_ada
5017 || (cu
->language
== language_fortran
&& physname
))
5019 /* For Ada unit, we prefer the linkage name over the name, as
5020 the former contains the exported name, which the user expects
5021 to be able to reference. Ideally, we want the user to be able
5022 to reference this entity using either natural or linkage name,
5023 but we haven't started looking at this enhancement yet. */
5024 struct attribute
*attr
;
5026 attr
= dwarf2_attr (die
, DW_AT_linkage_name
, cu
);
5028 attr
= dwarf2_attr (die
, DW_AT_MIPS_linkage_name
, cu
);
5029 if (attr
&& DW_STRING (attr
))
5030 return DW_STRING (attr
);
5033 /* These are the only languages we know how to qualify names in. */
5035 && (cu
->language
== language_cplus
|| cu
->language
== language_java
5036 || cu
->language
== language_fortran
))
5038 if (die_needs_namespace (die
, cu
))
5042 struct ui_file
*buf
;
5044 prefix
= determine_prefix (die
, cu
);
5045 buf
= mem_fileopen ();
5046 if (*prefix
!= '\0')
5048 char *prefixed_name
= typename_concat (NULL
, prefix
, name
,
5051 fputs_unfiltered (prefixed_name
, buf
);
5052 xfree (prefixed_name
);
5055 fputs_unfiltered (name
, buf
);
5057 /* Template parameters may be specified in the DIE's DW_AT_name, or
5058 as children with DW_TAG_template_type_param or
5059 DW_TAG_value_type_param. If the latter, add them to the name
5060 here. If the name already has template parameters, then
5061 skip this step; some versions of GCC emit both, and
5062 it is more efficient to use the pre-computed name.
5064 Something to keep in mind about this process: it is very
5065 unlikely, or in some cases downright impossible, to produce
5066 something that will match the mangled name of a function.
5067 If the definition of the function has the same debug info,
5068 we should be able to match up with it anyway. But fallbacks
5069 using the minimal symbol, for instance to find a method
5070 implemented in a stripped copy of libstdc++, will not work.
5071 If we do not have debug info for the definition, we will have to
5072 match them up some other way.
5074 When we do name matching there is a related problem with function
5075 templates; two instantiated function templates are allowed to
5076 differ only by their return types, which we do not add here. */
5078 if (cu
->language
== language_cplus
&& strchr (name
, '<') == NULL
)
5080 struct attribute
*attr
;
5081 struct die_info
*child
;
5084 die
->building_fullname
= 1;
5086 for (child
= die
->child
; child
!= NULL
; child
= child
->sibling
)
5091 struct dwarf2_locexpr_baton
*baton
;
5094 if (child
->tag
!= DW_TAG_template_type_param
5095 && child
->tag
!= DW_TAG_template_value_param
)
5100 fputs_unfiltered ("<", buf
);
5104 fputs_unfiltered (", ", buf
);
5106 attr
= dwarf2_attr (child
, DW_AT_type
, cu
);
5109 complaint (&symfile_complaints
,
5110 _("template parameter missing DW_AT_type"));
5111 fputs_unfiltered ("UNKNOWN_TYPE", buf
);
5114 type
= die_type (child
, cu
);
5116 if (child
->tag
== DW_TAG_template_type_param
)
5118 c_print_type (type
, "", buf
, -1, 0);
5122 attr
= dwarf2_attr (child
, DW_AT_const_value
, cu
);
5125 complaint (&symfile_complaints
,
5126 _("template parameter missing "
5127 "DW_AT_const_value"));
5128 fputs_unfiltered ("UNKNOWN_VALUE", buf
);
5132 dwarf2_const_value_attr (attr
, type
, name
,
5133 &cu
->comp_unit_obstack
, cu
,
5134 &value
, &bytes
, &baton
);
5136 if (TYPE_NOSIGN (type
))
5137 /* GDB prints characters as NUMBER 'CHAR'. If that's
5138 changed, this can use value_print instead. */
5139 c_printchar (value
, type
, buf
);
5142 struct value_print_options opts
;
5145 v
= dwarf2_evaluate_loc_desc (type
, NULL
,
5149 else if (bytes
!= NULL
)
5151 v
= allocate_value (type
);
5152 memcpy (value_contents_writeable (v
), bytes
,
5153 TYPE_LENGTH (type
));
5156 v
= value_from_longest (type
, value
);
5158 /* Specify decimal so that we do not depend on
5160 get_formatted_print_options (&opts
, 'd');
5162 value_print (v
, buf
, &opts
);
5168 die
->building_fullname
= 0;
5172 /* Close the argument list, with a space if necessary
5173 (nested templates). */
5174 char last_char
= '\0';
5175 ui_file_put (buf
, do_ui_file_peek_last
, &last_char
);
5176 if (last_char
== '>')
5177 fputs_unfiltered (" >", buf
);
5179 fputs_unfiltered (">", buf
);
5183 /* For Java and C++ methods, append formal parameter type
5184 information, if PHYSNAME. */
5186 if (physname
&& die
->tag
== DW_TAG_subprogram
5187 && (cu
->language
== language_cplus
5188 || cu
->language
== language_java
))
5190 struct type
*type
= read_type_die (die
, cu
);
5192 c_type_print_args (type
, buf
, 1, cu
->language
);
5194 if (cu
->language
== language_java
)
5196 /* For java, we must append the return type to method
5198 if (die
->tag
== DW_TAG_subprogram
)
5199 java_print_type (TYPE_TARGET_TYPE (type
), "", buf
,
5202 else if (cu
->language
== language_cplus
)
5204 /* Assume that an artificial first parameter is
5205 "this", but do not crash if it is not. RealView
5206 marks unnamed (and thus unused) parameters as
5207 artificial; there is no way to differentiate
5209 if (TYPE_NFIELDS (type
) > 0
5210 && TYPE_FIELD_ARTIFICIAL (type
, 0)
5211 && TYPE_CODE (TYPE_FIELD_TYPE (type
, 0)) == TYPE_CODE_PTR
5212 && TYPE_CONST (TYPE_TARGET_TYPE (TYPE_FIELD_TYPE (type
,
5214 fputs_unfiltered (" const", buf
);
5218 name
= ui_file_obsavestring (buf
, &cu
->objfile
->objfile_obstack
,
5220 ui_file_delete (buf
);
5222 if (cu
->language
== language_cplus
)
5225 = dwarf2_canonicalize_name (name
, cu
,
5226 &cu
->objfile
->objfile_obstack
);
5237 /* Return the fully qualified name of DIE, based on its DW_AT_name.
5238 If scope qualifiers are appropriate they will be added. The result
5239 will be allocated on the objfile_obstack, or NULL if the DIE does
5240 not have a name. NAME may either be from a previous call to
5241 dwarf2_name or NULL.
5243 The output string will be canonicalized (if C++/Java). */
5246 dwarf2_full_name (char *name
, struct die_info
*die
, struct dwarf2_cu
*cu
)
5248 return dwarf2_compute_name (name
, die
, cu
, 0);
5251 /* Construct a physname for the given DIE in CU. NAME may either be
5252 from a previous call to dwarf2_name or NULL. The result will be
5253 allocated on the objfile_objstack or NULL if the DIE does not have a
5256 The output string will be canonicalized (if C++/Java). */
5259 dwarf2_physname (char *name
, struct die_info
*die
, struct dwarf2_cu
*cu
)
5261 struct attribute
*attr
;
5262 const char *retval
, *mangled
= NULL
, *canon
= NULL
;
5263 struct cleanup
*back_to
;
5266 /* In this case dwarf2_compute_name is just a shortcut not building anything
5268 if (!die_needs_namespace (die
, cu
))
5269 return dwarf2_compute_name (name
, die
, cu
, 1);
5271 back_to
= make_cleanup (null_cleanup
, NULL
);
5273 attr
= dwarf2_attr (die
, DW_AT_linkage_name
, cu
);
5275 attr
= dwarf2_attr (die
, DW_AT_MIPS_linkage_name
, cu
);
5277 /* DW_AT_linkage_name is missing in some cases - depend on what GDB
5279 if (attr
&& DW_STRING (attr
))
5283 mangled
= DW_STRING (attr
);
5285 /* Use DMGL_RET_DROP for C++ template functions to suppress their return
5286 type. It is easier for GDB users to search for such functions as
5287 `name(params)' than `long name(params)'. In such case the minimal
5288 symbol names do not match the full symbol names but for template
5289 functions there is never a need to look up their definition from their
5290 declaration so the only disadvantage remains the minimal symbol
5291 variant `long name(params)' does not have the proper inferior type.
5294 demangled
= cplus_demangle (mangled
, (DMGL_PARAMS
| DMGL_ANSI
5295 | (cu
->language
== language_java
5296 ? DMGL_JAVA
| DMGL_RET_POSTFIX
5300 make_cleanup (xfree
, demangled
);
5310 if (canon
== NULL
|| check_physname
)
5312 const char *physname
= dwarf2_compute_name (name
, die
, cu
, 1);
5314 if (canon
!= NULL
&& strcmp (physname
, canon
) != 0)
5316 /* It may not mean a bug in GDB. The compiler could also
5317 compute DW_AT_linkage_name incorrectly. But in such case
5318 GDB would need to be bug-to-bug compatible. */
5320 complaint (&symfile_complaints
,
5321 _("Computed physname <%s> does not match demangled <%s> "
5322 "(from linkage <%s>) - DIE at 0x%x [in module %s]"),
5323 physname
, canon
, mangled
, die
->offset
, cu
->objfile
->name
);
5325 /* Prefer DW_AT_linkage_name (in the CANON form) - when it
5326 is available here - over computed PHYSNAME. It is safer
5327 against both buggy GDB and buggy compilers. */
5341 retval
= obsavestring (retval
, strlen (retval
),
5342 &cu
->objfile
->objfile_obstack
);
5344 do_cleanups (back_to
);
5348 /* Read the import statement specified by the given die and record it. */
5351 read_import_statement (struct die_info
*die
, struct dwarf2_cu
*cu
)
5353 struct attribute
*import_attr
;
5354 struct die_info
*imported_die
, *child_die
;
5355 struct dwarf2_cu
*imported_cu
;
5356 const char *imported_name
;
5357 const char *imported_name_prefix
;
5358 const char *canonical_name
;
5359 const char *import_alias
;
5360 const char *imported_declaration
= NULL
;
5361 const char *import_prefix
;
5362 VEC (const_char_ptr
) *excludes
= NULL
;
5363 struct cleanup
*cleanups
;
5367 import_attr
= dwarf2_attr (die
, DW_AT_import
, cu
);
5368 if (import_attr
== NULL
)
5370 complaint (&symfile_complaints
, _("Tag '%s' has no DW_AT_import"),
5371 dwarf_tag_name (die
->tag
));
5376 imported_die
= follow_die_ref_or_sig (die
, import_attr
, &imported_cu
);
5377 imported_name
= dwarf2_name (imported_die
, imported_cu
);
5378 if (imported_name
== NULL
)
5380 /* GCC bug: https://bugzilla.redhat.com/show_bug.cgi?id=506524
5382 The import in the following code:
5396 <2><51>: Abbrev Number: 3 (DW_TAG_imported_declaration)
5397 <52> DW_AT_decl_file : 1
5398 <53> DW_AT_decl_line : 6
5399 <54> DW_AT_import : <0x75>
5400 <2><58>: Abbrev Number: 4 (DW_TAG_typedef)
5402 <5b> DW_AT_decl_file : 1
5403 <5c> DW_AT_decl_line : 2
5404 <5d> DW_AT_type : <0x6e>
5406 <1><75>: Abbrev Number: 7 (DW_TAG_base_type)
5407 <76> DW_AT_byte_size : 4
5408 <77> DW_AT_encoding : 5 (signed)
5410 imports the wrong die ( 0x75 instead of 0x58 ).
5411 This case will be ignored until the gcc bug is fixed. */
5415 /* Figure out the local name after import. */
5416 import_alias
= dwarf2_name (die
, cu
);
5418 /* Figure out where the statement is being imported to. */
5419 import_prefix
= determine_prefix (die
, cu
);
5421 /* Figure out what the scope of the imported die is and prepend it
5422 to the name of the imported die. */
5423 imported_name_prefix
= determine_prefix (imported_die
, imported_cu
);
5425 if (imported_die
->tag
!= DW_TAG_namespace
5426 && imported_die
->tag
!= DW_TAG_module
)
5428 imported_declaration
= imported_name
;
5429 canonical_name
= imported_name_prefix
;
5431 else if (strlen (imported_name_prefix
) > 0)
5433 temp
= alloca (strlen (imported_name_prefix
)
5434 + 2 + strlen (imported_name
) + 1);
5435 strcpy (temp
, imported_name_prefix
);
5436 strcat (temp
, "::");
5437 strcat (temp
, imported_name
);
5438 canonical_name
= temp
;
5441 canonical_name
= imported_name
;
5443 cleanups
= make_cleanup (VEC_cleanup (const_char_ptr
), &excludes
);
5445 if (die
->tag
== DW_TAG_imported_module
&& cu
->language
== language_fortran
)
5446 for (child_die
= die
->child
; child_die
&& child_die
->tag
;
5447 child_die
= sibling_die (child_die
))
5449 /* DWARF-4: A Fortran use statement with a “rename list” may be
5450 represented by an imported module entry with an import attribute
5451 referring to the module and owned entries corresponding to those
5452 entities that are renamed as part of being imported. */
5454 if (child_die
->tag
!= DW_TAG_imported_declaration
)
5456 complaint (&symfile_complaints
,
5457 _("child DW_TAG_imported_declaration expected "
5458 "- DIE at 0x%x [in module %s]"),
5459 child_die
->offset
, cu
->objfile
->name
);
5463 import_attr
= dwarf2_attr (child_die
, DW_AT_import
, cu
);
5464 if (import_attr
== NULL
)
5466 complaint (&symfile_complaints
, _("Tag '%s' has no DW_AT_import"),
5467 dwarf_tag_name (child_die
->tag
));
5472 imported_die
= follow_die_ref_or_sig (child_die
, import_attr
,
5474 imported_name
= dwarf2_name (imported_die
, imported_cu
);
5475 if (imported_name
== NULL
)
5477 complaint (&symfile_complaints
,
5478 _("child DW_TAG_imported_declaration has unknown "
5479 "imported name - DIE at 0x%x [in module %s]"),
5480 child_die
->offset
, cu
->objfile
->name
);
5484 VEC_safe_push (const_char_ptr
, excludes
, imported_name
);
5486 process_die (child_die
, cu
);
5489 cp_add_using_directive (import_prefix
,
5492 imported_declaration
,
5494 &cu
->objfile
->objfile_obstack
);
5496 do_cleanups (cleanups
);
5500 initialize_cu_func_list (struct dwarf2_cu
*cu
)
5502 cu
->first_fn
= cu
->last_fn
= cu
->cached_fn
= NULL
;
5505 /* Cleanup function for read_file_scope. */
5508 free_cu_line_header (void *arg
)
5510 struct dwarf2_cu
*cu
= arg
;
5512 free_line_header (cu
->line_header
);
5513 cu
->line_header
= NULL
;
5517 find_file_and_directory (struct die_info
*die
, struct dwarf2_cu
*cu
,
5518 char **name
, char **comp_dir
)
5520 struct attribute
*attr
;
5525 /* Find the filename. Do not use dwarf2_name here, since the filename
5526 is not a source language identifier. */
5527 attr
= dwarf2_attr (die
, DW_AT_name
, cu
);
5530 *name
= DW_STRING (attr
);
5533 attr
= dwarf2_attr (die
, DW_AT_comp_dir
, cu
);
5535 *comp_dir
= DW_STRING (attr
);
5536 else if (*name
!= NULL
&& IS_ABSOLUTE_PATH (*name
))
5538 *comp_dir
= ldirname (*name
);
5539 if (*comp_dir
!= NULL
)
5540 make_cleanup (xfree
, *comp_dir
);
5542 if (*comp_dir
!= NULL
)
5544 /* Irix 6.2 native cc prepends <machine>.: to the compilation
5545 directory, get rid of it. */
5546 char *cp
= strchr (*comp_dir
, ':');
5548 if (cp
&& cp
!= *comp_dir
&& cp
[-1] == '.' && cp
[1] == '/')
5553 *name
= "<unknown>";
5556 /* Handle DW_AT_stmt_list for a compilation unit. */
5559 handle_DW_AT_stmt_list (struct die_info
*die
, struct dwarf2_cu
*cu
,
5560 const char *comp_dir
)
5562 struct attribute
*attr
;
5563 struct objfile
*objfile
= cu
->objfile
;
5564 bfd
*abfd
= objfile
->obfd
;
5566 /* Decode line number information if present. We do this before
5567 processing child DIEs, so that the line header table is available
5568 for DW_AT_decl_file. */
5569 attr
= dwarf2_attr (die
, DW_AT_stmt_list
, cu
);
5572 unsigned int line_offset
= DW_UNSND (attr
);
5573 struct line_header
*line_header
5574 = dwarf_decode_line_header (line_offset
, abfd
, cu
);
5578 cu
->line_header
= line_header
;
5579 make_cleanup (free_cu_line_header
, cu
);
5580 dwarf_decode_lines (line_header
, comp_dir
, abfd
, cu
, NULL
);
5585 /* Process DW_TAG_compile_unit. */
5588 read_file_scope (struct die_info
*die
, struct dwarf2_cu
*cu
)
5590 struct objfile
*objfile
= cu
->objfile
;
5591 struct cleanup
*back_to
= make_cleanup (null_cleanup
, 0);
5592 CORE_ADDR lowpc
= ((CORE_ADDR
) -1);
5593 CORE_ADDR highpc
= ((CORE_ADDR
) 0);
5594 struct attribute
*attr
;
5596 char *comp_dir
= NULL
;
5597 struct die_info
*child_die
;
5598 bfd
*abfd
= objfile
->obfd
;
5601 baseaddr
= ANOFFSET (objfile
->section_offsets
, SECT_OFF_TEXT (objfile
));
5603 get_scope_pc_bounds (die
, &lowpc
, &highpc
, cu
);
5605 /* If we didn't find a lowpc, set it to highpc to avoid complaints
5606 from finish_block. */
5607 if (lowpc
== ((CORE_ADDR
) -1))
5612 find_file_and_directory (die
, cu
, &name
, &comp_dir
);
5614 attr
= dwarf2_attr (die
, DW_AT_language
, cu
);
5617 set_cu_language (DW_UNSND (attr
), cu
);
5620 attr
= dwarf2_attr (die
, DW_AT_producer
, cu
);
5622 cu
->producer
= DW_STRING (attr
);
5624 /* The XLCL doesn't generate DW_LANG_OpenCL because this attribute is not
5625 standardised yet. As a workaround for the language detection we fall
5626 back to the DW_AT_producer string. */
5627 if (cu
->producer
&& strstr (cu
->producer
, "IBM XL C for OpenCL") != NULL
)
5628 cu
->language
= language_opencl
;
5630 /* We assume that we're processing GCC output. */
5631 processing_gcc_compilation
= 2;
5633 processing_has_namespace_info
= 0;
5635 start_symtab (name
, comp_dir
, lowpc
);
5636 record_debugformat ("DWARF 2");
5637 record_producer (cu
->producer
);
5639 initialize_cu_func_list (cu
);
5641 handle_DW_AT_stmt_list (die
, cu
, comp_dir
);
5643 /* Process all dies in compilation unit. */
5644 if (die
->child
!= NULL
)
5646 child_die
= die
->child
;
5647 while (child_die
&& child_die
->tag
)
5649 process_die (child_die
, cu
);
5650 child_die
= sibling_die (child_die
);
5654 /* Decode macro information, if present. Dwarf 2 macro information
5655 refers to information in the line number info statement program
5656 header, so we can only read it if we've read the header
5658 attr
= dwarf2_attr (die
, DW_AT_GNU_macros
, cu
);
5659 if (attr
&& cu
->line_header
)
5661 if (dwarf2_attr (die
, DW_AT_macro_info
, cu
))
5662 complaint (&symfile_complaints
,
5663 _("CU refers to both DW_AT_GNU_macros and DW_AT_macro_info"));
5665 dwarf_decode_macros (cu
->line_header
, DW_UNSND (attr
),
5667 &dwarf2_per_objfile
->macro
, 1);
5671 attr
= dwarf2_attr (die
, DW_AT_macro_info
, cu
);
5672 if (attr
&& cu
->line_header
)
5674 unsigned int macro_offset
= DW_UNSND (attr
);
5676 dwarf_decode_macros (cu
->line_header
, macro_offset
,
5678 &dwarf2_per_objfile
->macinfo
, 0);
5681 do_cleanups (back_to
);
5684 /* Process DW_TAG_type_unit.
5685 For TUs we want to skip the first top level sibling if it's not the
5686 actual type being defined by this TU. In this case the first top
5687 level sibling is there to provide context only. */
5690 read_type_unit_scope (struct die_info
*die
, struct dwarf2_cu
*cu
)
5692 struct objfile
*objfile
= cu
->objfile
;
5693 struct cleanup
*back_to
= make_cleanup (null_cleanup
, 0);
5695 struct attribute
*attr
;
5697 char *comp_dir
= NULL
;
5698 struct die_info
*child_die
;
5699 bfd
*abfd
= objfile
->obfd
;
5701 /* start_symtab needs a low pc, but we don't really have one.
5702 Do what read_file_scope would do in the absence of such info. */
5703 lowpc
= ANOFFSET (objfile
->section_offsets
, SECT_OFF_TEXT (objfile
));
5705 /* Find the filename. Do not use dwarf2_name here, since the filename
5706 is not a source language identifier. */
5707 attr
= dwarf2_attr (die
, DW_AT_name
, cu
);
5709 name
= DW_STRING (attr
);
5711 attr
= dwarf2_attr (die
, DW_AT_comp_dir
, cu
);
5713 comp_dir
= DW_STRING (attr
);
5714 else if (name
!= NULL
&& IS_ABSOLUTE_PATH (name
))
5716 comp_dir
= ldirname (name
);
5717 if (comp_dir
!= NULL
)
5718 make_cleanup (xfree
, comp_dir
);
5724 attr
= dwarf2_attr (die
, DW_AT_language
, cu
);
5726 set_cu_language (DW_UNSND (attr
), cu
);
5728 /* This isn't technically needed today. It is done for symmetry
5729 with read_file_scope. */
5730 attr
= dwarf2_attr (die
, DW_AT_producer
, cu
);
5732 cu
->producer
= DW_STRING (attr
);
5734 /* We assume that we're processing GCC output. */
5735 processing_gcc_compilation
= 2;
5737 processing_has_namespace_info
= 0;
5739 start_symtab (name
, comp_dir
, lowpc
);
5740 record_debugformat ("DWARF 2");
5741 record_producer (cu
->producer
);
5743 handle_DW_AT_stmt_list (die
, cu
, comp_dir
);
5745 /* Process the dies in the type unit. */
5746 if (die
->child
== NULL
)
5748 dump_die_for_error (die
);
5749 error (_("Dwarf Error: Missing children for type unit [in module %s]"),
5750 bfd_get_filename (abfd
));
5753 child_die
= die
->child
;
5755 while (child_die
&& child_die
->tag
)
5757 process_die (child_die
, cu
);
5759 child_die
= sibling_die (child_die
);
5762 do_cleanups (back_to
);
5766 add_to_cu_func_list (const char *name
, CORE_ADDR lowpc
, CORE_ADDR highpc
,
5767 struct dwarf2_cu
*cu
)
5769 struct function_range
*thisfn
;
5771 thisfn
= (struct function_range
*)
5772 obstack_alloc (&cu
->comp_unit_obstack
, sizeof (struct function_range
));
5773 thisfn
->name
= name
;
5774 thisfn
->lowpc
= lowpc
;
5775 thisfn
->highpc
= highpc
;
5776 thisfn
->seen_line
= 0;
5777 thisfn
->next
= NULL
;
5779 if (cu
->last_fn
== NULL
)
5780 cu
->first_fn
= thisfn
;
5782 cu
->last_fn
->next
= thisfn
;
5784 cu
->last_fn
= thisfn
;
5787 /* qsort helper for inherit_abstract_dies. */
5790 unsigned_int_compar (const void *ap
, const void *bp
)
5792 unsigned int a
= *(unsigned int *) ap
;
5793 unsigned int b
= *(unsigned int *) bp
;
5795 return (a
> b
) - (b
> a
);
5798 /* DW_AT_abstract_origin inherits whole DIEs (not just their attributes).
5799 Inherit only the children of the DW_AT_abstract_origin DIE not being
5800 already referenced by DW_AT_abstract_origin from the children of the
5804 inherit_abstract_dies (struct die_info
*die
, struct dwarf2_cu
*cu
)
5806 struct die_info
*child_die
;
5807 unsigned die_children_count
;
5808 /* CU offsets which were referenced by children of the current DIE. */
5810 unsigned *offsets_end
, *offsetp
;
5811 /* Parent of DIE - referenced by DW_AT_abstract_origin. */
5812 struct die_info
*origin_die
;
5813 /* Iterator of the ORIGIN_DIE children. */
5814 struct die_info
*origin_child_die
;
5815 struct cleanup
*cleanups
;
5816 struct attribute
*attr
;
5817 struct dwarf2_cu
*origin_cu
;
5818 struct pending
**origin_previous_list_in_scope
;
5820 attr
= dwarf2_attr (die
, DW_AT_abstract_origin
, cu
);
5824 /* Note that following die references may follow to a die in a
5828 origin_die
= follow_die_ref (die
, attr
, &origin_cu
);
5830 /* We're inheriting ORIGIN's children into the scope we'd put DIE's
5832 origin_previous_list_in_scope
= origin_cu
->list_in_scope
;
5833 origin_cu
->list_in_scope
= cu
->list_in_scope
;
5835 if (die
->tag
!= origin_die
->tag
5836 && !(die
->tag
== DW_TAG_inlined_subroutine
5837 && origin_die
->tag
== DW_TAG_subprogram
))
5838 complaint (&symfile_complaints
,
5839 _("DIE 0x%x and its abstract origin 0x%x have different tags"),
5840 die
->offset
, origin_die
->offset
);
5842 child_die
= die
->child
;
5843 die_children_count
= 0;
5844 while (child_die
&& child_die
->tag
)
5846 child_die
= sibling_die (child_die
);
5847 die_children_count
++;
5849 offsets
= xmalloc (sizeof (*offsets
) * die_children_count
);
5850 cleanups
= make_cleanup (xfree
, offsets
);
5852 offsets_end
= offsets
;
5853 child_die
= die
->child
;
5854 while (child_die
&& child_die
->tag
)
5856 /* For each CHILD_DIE, find the corresponding child of
5857 ORIGIN_DIE. If there is more than one layer of
5858 DW_AT_abstract_origin, follow them all; there shouldn't be,
5859 but GCC versions at least through 4.4 generate this (GCC PR
5861 struct die_info
*child_origin_die
= child_die
;
5862 struct dwarf2_cu
*child_origin_cu
= cu
;
5866 attr
= dwarf2_attr (child_origin_die
, DW_AT_abstract_origin
,
5870 child_origin_die
= follow_die_ref (child_origin_die
, attr
,
5874 /* According to DWARF3 3.3.8.2 #3 new entries without their abstract
5875 counterpart may exist. */
5876 if (child_origin_die
!= child_die
)
5878 if (child_die
->tag
!= child_origin_die
->tag
5879 && !(child_die
->tag
== DW_TAG_inlined_subroutine
5880 && child_origin_die
->tag
== DW_TAG_subprogram
))
5881 complaint (&symfile_complaints
,
5882 _("Child DIE 0x%x and its abstract origin 0x%x have "
5883 "different tags"), child_die
->offset
,
5884 child_origin_die
->offset
);
5885 if (child_origin_die
->parent
!= origin_die
)
5886 complaint (&symfile_complaints
,
5887 _("Child DIE 0x%x and its abstract origin 0x%x have "
5888 "different parents"), child_die
->offset
,
5889 child_origin_die
->offset
);
5891 *offsets_end
++ = child_origin_die
->offset
;
5893 child_die
= sibling_die (child_die
);
5895 qsort (offsets
, offsets_end
- offsets
, sizeof (*offsets
),
5896 unsigned_int_compar
);
5897 for (offsetp
= offsets
+ 1; offsetp
< offsets_end
; offsetp
++)
5898 if (offsetp
[-1] == *offsetp
)
5899 complaint (&symfile_complaints
,
5900 _("Multiple children of DIE 0x%x refer "
5901 "to DIE 0x%x as their abstract origin"),
5902 die
->offset
, *offsetp
);
5905 origin_child_die
= origin_die
->child
;
5906 while (origin_child_die
&& origin_child_die
->tag
)
5908 /* Is ORIGIN_CHILD_DIE referenced by any of the DIE children? */
5909 while (offsetp
< offsets_end
&& *offsetp
< origin_child_die
->offset
)
5911 if (offsetp
>= offsets_end
|| *offsetp
> origin_child_die
->offset
)
5913 /* Found that ORIGIN_CHILD_DIE is really not referenced. */
5914 process_die (origin_child_die
, origin_cu
);
5916 origin_child_die
= sibling_die (origin_child_die
);
5918 origin_cu
->list_in_scope
= origin_previous_list_in_scope
;
5920 do_cleanups (cleanups
);
5924 read_func_scope (struct die_info
*die
, struct dwarf2_cu
*cu
)
5926 struct objfile
*objfile
= cu
->objfile
;
5927 struct context_stack
*new;
5930 struct die_info
*child_die
;
5931 struct attribute
*attr
, *call_line
, *call_file
;
5934 struct block
*block
;
5935 int inlined_func
= (die
->tag
== DW_TAG_inlined_subroutine
);
5936 VEC (symbolp
) *template_args
= NULL
;
5937 struct template_symbol
*templ_func
= NULL
;
5941 /* If we do not have call site information, we can't show the
5942 caller of this inlined function. That's too confusing, so
5943 only use the scope for local variables. */
5944 call_line
= dwarf2_attr (die
, DW_AT_call_line
, cu
);
5945 call_file
= dwarf2_attr (die
, DW_AT_call_file
, cu
);
5946 if (call_line
== NULL
|| call_file
== NULL
)
5948 read_lexical_block_scope (die
, cu
);
5953 baseaddr
= ANOFFSET (objfile
->section_offsets
, SECT_OFF_TEXT (objfile
));
5955 name
= dwarf2_name (die
, cu
);
5957 /* Ignore functions with missing or empty names. These are actually
5958 illegal according to the DWARF standard. */
5961 complaint (&symfile_complaints
,
5962 _("missing name for subprogram DIE at %d"), die
->offset
);
5966 /* Ignore functions with missing or invalid low and high pc attributes. */
5967 if (!dwarf2_get_pc_bounds (die
, &lowpc
, &highpc
, cu
, NULL
))
5969 attr
= dwarf2_attr (die
, DW_AT_external
, cu
);
5970 if (!attr
|| !DW_UNSND (attr
))
5971 complaint (&symfile_complaints
,
5972 _("cannot get low and high bounds "
5973 "for subprogram DIE at %d"),
5981 /* Record the function range for dwarf_decode_lines. */
5982 add_to_cu_func_list (name
, lowpc
, highpc
, cu
);
5984 /* If we have any template arguments, then we must allocate a
5985 different sort of symbol. */
5986 for (child_die
= die
->child
; child_die
; child_die
= sibling_die (child_die
))
5988 if (child_die
->tag
== DW_TAG_template_type_param
5989 || child_die
->tag
== DW_TAG_template_value_param
)
5991 templ_func
= OBSTACK_ZALLOC (&objfile
->objfile_obstack
,
5992 struct template_symbol
);
5993 templ_func
->base
.is_cplus_template_function
= 1;
5998 new = push_context (0, lowpc
);
5999 new->name
= new_symbol_full (die
, read_type_die (die
, cu
), cu
,
6000 (struct symbol
*) templ_func
);
6002 /* If there is a location expression for DW_AT_frame_base, record
6004 attr
= dwarf2_attr (die
, DW_AT_frame_base
, cu
);
6006 /* FIXME: cagney/2004-01-26: The DW_AT_frame_base's location
6007 expression is being recorded directly in the function's symbol
6008 and not in a separate frame-base object. I guess this hack is
6009 to avoid adding some sort of frame-base adjunct/annex to the
6010 function's symbol :-(. The problem with doing this is that it
6011 results in a function symbol with a location expression that
6012 has nothing to do with the location of the function, ouch! The
6013 relationship should be: a function's symbol has-a frame base; a
6014 frame-base has-a location expression. */
6015 dwarf2_symbol_mark_computed (attr
, new->name
, cu
);
6017 cu
->list_in_scope
= &local_symbols
;
6019 if (die
->child
!= NULL
)
6021 child_die
= die
->child
;
6022 while (child_die
&& child_die
->tag
)
6024 if (child_die
->tag
== DW_TAG_template_type_param
6025 || child_die
->tag
== DW_TAG_template_value_param
)
6027 struct symbol
*arg
= new_symbol (child_die
, NULL
, cu
);
6030 VEC_safe_push (symbolp
, template_args
, arg
);
6033 process_die (child_die
, cu
);
6034 child_die
= sibling_die (child_die
);
6038 inherit_abstract_dies (die
, cu
);
6040 /* If we have a DW_AT_specification, we might need to import using
6041 directives from the context of the specification DIE. See the
6042 comment in determine_prefix. */
6043 if (cu
->language
== language_cplus
6044 && dwarf2_attr (die
, DW_AT_specification
, cu
))
6046 struct dwarf2_cu
*spec_cu
= cu
;
6047 struct die_info
*spec_die
= die_specification (die
, &spec_cu
);
6051 child_die
= spec_die
->child
;
6052 while (child_die
&& child_die
->tag
)
6054 if (child_die
->tag
== DW_TAG_imported_module
)
6055 process_die (child_die
, spec_cu
);
6056 child_die
= sibling_die (child_die
);
6059 /* In some cases, GCC generates specification DIEs that
6060 themselves contain DW_AT_specification attributes. */
6061 spec_die
= die_specification (spec_die
, &spec_cu
);
6065 new = pop_context ();
6066 /* Make a block for the local symbols within. */
6067 block
= finish_block (new->name
, &local_symbols
, new->old_blocks
,
6068 lowpc
, highpc
, objfile
);
6070 /* For C++, set the block's scope. */
6071 if (cu
->language
== language_cplus
|| cu
->language
== language_fortran
)
6072 cp_set_block_scope (new->name
, block
, &objfile
->objfile_obstack
,
6073 determine_prefix (die
, cu
),
6074 processing_has_namespace_info
);
6076 /* If we have address ranges, record them. */
6077 dwarf2_record_block_ranges (die
, block
, baseaddr
, cu
);
6079 /* Attach template arguments to function. */
6080 if (! VEC_empty (symbolp
, template_args
))
6082 gdb_assert (templ_func
!= NULL
);
6084 templ_func
->n_template_arguments
= VEC_length (symbolp
, template_args
);
6085 templ_func
->template_arguments
6086 = obstack_alloc (&objfile
->objfile_obstack
,
6087 (templ_func
->n_template_arguments
6088 * sizeof (struct symbol
*)));
6089 memcpy (templ_func
->template_arguments
,
6090 VEC_address (symbolp
, template_args
),
6091 (templ_func
->n_template_arguments
* sizeof (struct symbol
*)));
6092 VEC_free (symbolp
, template_args
);
6095 /* In C++, we can have functions nested inside functions (e.g., when
6096 a function declares a class that has methods). This means that
6097 when we finish processing a function scope, we may need to go
6098 back to building a containing block's symbol lists. */
6099 local_symbols
= new->locals
;
6100 param_symbols
= new->params
;
6101 using_directives
= new->using_directives
;
6103 /* If we've finished processing a top-level function, subsequent
6104 symbols go in the file symbol list. */
6105 if (outermost_context_p ())
6106 cu
->list_in_scope
= &file_symbols
;
6109 /* Process all the DIES contained within a lexical block scope. Start
6110 a new scope, process the dies, and then close the scope. */
6113 read_lexical_block_scope (struct die_info
*die
, struct dwarf2_cu
*cu
)
6115 struct objfile
*objfile
= cu
->objfile
;
6116 struct context_stack
*new;
6117 CORE_ADDR lowpc
, highpc
;
6118 struct die_info
*child_die
;
6121 baseaddr
= ANOFFSET (objfile
->section_offsets
, SECT_OFF_TEXT (objfile
));
6123 /* Ignore blocks with missing or invalid low and high pc attributes. */
6124 /* ??? Perhaps consider discontiguous blocks defined by DW_AT_ranges
6125 as multiple lexical blocks? Handling children in a sane way would
6126 be nasty. Might be easier to properly extend generic blocks to
6128 if (!dwarf2_get_pc_bounds (die
, &lowpc
, &highpc
, cu
, NULL
))
6133 push_context (0, lowpc
);
6134 if (die
->child
!= NULL
)
6136 child_die
= die
->child
;
6137 while (child_die
&& child_die
->tag
)
6139 process_die (child_die
, cu
);
6140 child_die
= sibling_die (child_die
);
6143 new = pop_context ();
6145 if (local_symbols
!= NULL
|| using_directives
!= NULL
)
6148 = finish_block (0, &local_symbols
, new->old_blocks
, new->start_addr
,
6151 /* Note that recording ranges after traversing children, as we
6152 do here, means that recording a parent's ranges entails
6153 walking across all its children's ranges as they appear in
6154 the address map, which is quadratic behavior.
6156 It would be nicer to record the parent's ranges before
6157 traversing its children, simply overriding whatever you find
6158 there. But since we don't even decide whether to create a
6159 block until after we've traversed its children, that's hard
6161 dwarf2_record_block_ranges (die
, block
, baseaddr
, cu
);
6163 local_symbols
= new->locals
;
6164 using_directives
= new->using_directives
;
6167 /* Get low and high pc attributes from DW_AT_ranges attribute value OFFSET.
6168 Return 1 if the attributes are present and valid, otherwise, return 0.
6169 If RANGES_PST is not NULL we should setup `objfile->psymtabs_addrmap'. */
6172 dwarf2_ranges_read (unsigned offset
, CORE_ADDR
*low_return
,
6173 CORE_ADDR
*high_return
, struct dwarf2_cu
*cu
,
6174 struct partial_symtab
*ranges_pst
)
6176 struct objfile
*objfile
= cu
->objfile
;
6177 struct comp_unit_head
*cu_header
= &cu
->header
;
6178 bfd
*obfd
= objfile
->obfd
;
6179 unsigned int addr_size
= cu_header
->addr_size
;
6180 CORE_ADDR mask
= ~(~(CORE_ADDR
)1 << (addr_size
* 8 - 1));
6181 /* Base address selection entry. */
6192 found_base
= cu
->base_known
;
6193 base
= cu
->base_address
;
6195 dwarf2_read_section (objfile
, &dwarf2_per_objfile
->ranges
);
6196 if (offset
>= dwarf2_per_objfile
->ranges
.size
)
6198 complaint (&symfile_complaints
,
6199 _("Offset %d out of bounds for DW_AT_ranges attribute"),
6203 buffer
= dwarf2_per_objfile
->ranges
.buffer
+ offset
;
6205 /* Read in the largest possible address. */
6206 marker
= read_address (obfd
, buffer
, cu
, &dummy
);
6207 if ((marker
& mask
) == mask
)
6209 /* If we found the largest possible address, then
6210 read the base address. */
6211 base
= read_address (obfd
, buffer
+ addr_size
, cu
, &dummy
);
6212 buffer
+= 2 * addr_size
;
6213 offset
+= 2 * addr_size
;
6219 baseaddr
= ANOFFSET (objfile
->section_offsets
, SECT_OFF_TEXT (objfile
));
6223 CORE_ADDR range_beginning
, range_end
;
6225 range_beginning
= read_address (obfd
, buffer
, cu
, &dummy
);
6226 buffer
+= addr_size
;
6227 range_end
= read_address (obfd
, buffer
, cu
, &dummy
);
6228 buffer
+= addr_size
;
6229 offset
+= 2 * addr_size
;
6231 /* An end of list marker is a pair of zero addresses. */
6232 if (range_beginning
== 0 && range_end
== 0)
6233 /* Found the end of list entry. */
6236 /* Each base address selection entry is a pair of 2 values.
6237 The first is the largest possible address, the second is
6238 the base address. Check for a base address here. */
6239 if ((range_beginning
& mask
) == mask
)
6241 /* If we found the largest possible address, then
6242 read the base address. */
6243 base
= read_address (obfd
, buffer
+ addr_size
, cu
, &dummy
);
6250 /* We have no valid base address for the ranges
6252 complaint (&symfile_complaints
,
6253 _("Invalid .debug_ranges data (no base address)"));
6257 if (range_beginning
> range_end
)
6259 /* Inverted range entries are invalid. */
6260 complaint (&symfile_complaints
,
6261 _("Invalid .debug_ranges data (inverted range)"));
6265 /* Empty range entries have no effect. */
6266 if (range_beginning
== range_end
)
6269 range_beginning
+= base
;
6272 if (ranges_pst
!= NULL
)
6273 addrmap_set_empty (objfile
->psymtabs_addrmap
,
6274 range_beginning
+ baseaddr
,
6275 range_end
- 1 + baseaddr
,
6278 /* FIXME: This is recording everything as a low-high
6279 segment of consecutive addresses. We should have a
6280 data structure for discontiguous block ranges
6284 low
= range_beginning
;
6290 if (range_beginning
< low
)
6291 low
= range_beginning
;
6292 if (range_end
> high
)
6298 /* If the first entry is an end-of-list marker, the range
6299 describes an empty scope, i.e. no instructions. */
6305 *high_return
= high
;
6309 /* Get low and high pc attributes from a die. Return 1 if the attributes
6310 are present and valid, otherwise, return 0. Return -1 if the range is
6311 discontinuous, i.e. derived from DW_AT_ranges information. */
6313 dwarf2_get_pc_bounds (struct die_info
*die
, CORE_ADDR
*lowpc
,
6314 CORE_ADDR
*highpc
, struct dwarf2_cu
*cu
,
6315 struct partial_symtab
*pst
)
6317 struct attribute
*attr
;
6322 attr
= dwarf2_attr (die
, DW_AT_high_pc
, cu
);
6325 high
= DW_ADDR (attr
);
6326 attr
= dwarf2_attr (die
, DW_AT_low_pc
, cu
);
6328 low
= DW_ADDR (attr
);
6330 /* Found high w/o low attribute. */
6333 /* Found consecutive range of addresses. */
6338 attr
= dwarf2_attr (die
, DW_AT_ranges
, cu
);
6341 /* Value of the DW_AT_ranges attribute is the offset in the
6342 .debug_ranges section. */
6343 if (!dwarf2_ranges_read (DW_UNSND (attr
), &low
, &high
, cu
, pst
))
6345 /* Found discontinuous range of addresses. */
6350 /* read_partial_die has also the strict LOW < HIGH requirement. */
6354 /* When using the GNU linker, .gnu.linkonce. sections are used to
6355 eliminate duplicate copies of functions and vtables and such.
6356 The linker will arbitrarily choose one and discard the others.
6357 The AT_*_pc values for such functions refer to local labels in
6358 these sections. If the section from that file was discarded, the
6359 labels are not in the output, so the relocs get a value of 0.
6360 If this is a discarded function, mark the pc bounds as invalid,
6361 so that GDB will ignore it. */
6362 if (low
== 0 && !dwarf2_per_objfile
->has_section_at_zero
)
6370 /* Assuming that DIE represents a subprogram DIE or a lexical block, get
6371 its low and high PC addresses. Do nothing if these addresses could not
6372 be determined. Otherwise, set LOWPC to the low address if it is smaller,
6373 and HIGHPC to the high address if greater than HIGHPC. */
6376 dwarf2_get_subprogram_pc_bounds (struct die_info
*die
,
6377 CORE_ADDR
*lowpc
, CORE_ADDR
*highpc
,
6378 struct dwarf2_cu
*cu
)
6380 CORE_ADDR low
, high
;
6381 struct die_info
*child
= die
->child
;
6383 if (dwarf2_get_pc_bounds (die
, &low
, &high
, cu
, NULL
))
6385 *lowpc
= min (*lowpc
, low
);
6386 *highpc
= max (*highpc
, high
);
6389 /* If the language does not allow nested subprograms (either inside
6390 subprograms or lexical blocks), we're done. */
6391 if (cu
->language
!= language_ada
)
6394 /* Check all the children of the given DIE. If it contains nested
6395 subprograms, then check their pc bounds. Likewise, we need to
6396 check lexical blocks as well, as they may also contain subprogram
6398 while (child
&& child
->tag
)
6400 if (child
->tag
== DW_TAG_subprogram
6401 || child
->tag
== DW_TAG_lexical_block
)
6402 dwarf2_get_subprogram_pc_bounds (child
, lowpc
, highpc
, cu
);
6403 child
= sibling_die (child
);
6407 /* Get the low and high pc's represented by the scope DIE, and store
6408 them in *LOWPC and *HIGHPC. If the correct values can't be
6409 determined, set *LOWPC to -1 and *HIGHPC to 0. */
6412 get_scope_pc_bounds (struct die_info
*die
,
6413 CORE_ADDR
*lowpc
, CORE_ADDR
*highpc
,
6414 struct dwarf2_cu
*cu
)
6416 CORE_ADDR best_low
= (CORE_ADDR
) -1;
6417 CORE_ADDR best_high
= (CORE_ADDR
) 0;
6418 CORE_ADDR current_low
, current_high
;
6420 if (dwarf2_get_pc_bounds (die
, ¤t_low
, ¤t_high
, cu
, NULL
))
6422 best_low
= current_low
;
6423 best_high
= current_high
;
6427 struct die_info
*child
= die
->child
;
6429 while (child
&& child
->tag
)
6431 switch (child
->tag
) {
6432 case DW_TAG_subprogram
:
6433 dwarf2_get_subprogram_pc_bounds (child
, &best_low
, &best_high
, cu
);
6435 case DW_TAG_namespace
:
6437 /* FIXME: carlton/2004-01-16: Should we do this for
6438 DW_TAG_class_type/DW_TAG_structure_type, too? I think
6439 that current GCC's always emit the DIEs corresponding
6440 to definitions of methods of classes as children of a
6441 DW_TAG_compile_unit or DW_TAG_namespace (as opposed to
6442 the DIEs giving the declarations, which could be
6443 anywhere). But I don't see any reason why the
6444 standards says that they have to be there. */
6445 get_scope_pc_bounds (child
, ¤t_low
, ¤t_high
, cu
);
6447 if (current_low
!= ((CORE_ADDR
) -1))
6449 best_low
= min (best_low
, current_low
);
6450 best_high
= max (best_high
, current_high
);
6458 child
= sibling_die (child
);
6463 *highpc
= best_high
;
6466 /* Record the address ranges for BLOCK, offset by BASEADDR, as given
6469 dwarf2_record_block_ranges (struct die_info
*die
, struct block
*block
,
6470 CORE_ADDR baseaddr
, struct dwarf2_cu
*cu
)
6472 struct attribute
*attr
;
6474 attr
= dwarf2_attr (die
, DW_AT_high_pc
, cu
);
6477 CORE_ADDR high
= DW_ADDR (attr
);
6479 attr
= dwarf2_attr (die
, DW_AT_low_pc
, cu
);
6482 CORE_ADDR low
= DW_ADDR (attr
);
6484 record_block_range (block
, baseaddr
+ low
, baseaddr
+ high
- 1);
6488 attr
= dwarf2_attr (die
, DW_AT_ranges
, cu
);
6491 bfd
*obfd
= cu
->objfile
->obfd
;
6493 /* The value of the DW_AT_ranges attribute is the offset of the
6494 address range list in the .debug_ranges section. */
6495 unsigned long offset
= DW_UNSND (attr
);
6496 gdb_byte
*buffer
= dwarf2_per_objfile
->ranges
.buffer
+ offset
;
6498 /* For some target architectures, but not others, the
6499 read_address function sign-extends the addresses it returns.
6500 To recognize base address selection entries, we need a
6502 unsigned int addr_size
= cu
->header
.addr_size
;
6503 CORE_ADDR base_select_mask
= ~(~(CORE_ADDR
)1 << (addr_size
* 8 - 1));
6505 /* The base address, to which the next pair is relative. Note
6506 that this 'base' is a DWARF concept: most entries in a range
6507 list are relative, to reduce the number of relocs against the
6508 debugging information. This is separate from this function's
6509 'baseaddr' argument, which GDB uses to relocate debugging
6510 information from a shared library based on the address at
6511 which the library was loaded. */
6512 CORE_ADDR base
= cu
->base_address
;
6513 int base_known
= cu
->base_known
;
6515 gdb_assert (dwarf2_per_objfile
->ranges
.readin
);
6516 if (offset
>= dwarf2_per_objfile
->ranges
.size
)
6518 complaint (&symfile_complaints
,
6519 _("Offset %lu out of bounds for DW_AT_ranges attribute"),
6526 unsigned int bytes_read
;
6527 CORE_ADDR start
, end
;
6529 start
= read_address (obfd
, buffer
, cu
, &bytes_read
);
6530 buffer
+= bytes_read
;
6531 end
= read_address (obfd
, buffer
, cu
, &bytes_read
);
6532 buffer
+= bytes_read
;
6534 /* Did we find the end of the range list? */
6535 if (start
== 0 && end
== 0)
6538 /* Did we find a base address selection entry? */
6539 else if ((start
& base_select_mask
) == base_select_mask
)
6545 /* We found an ordinary address range. */
6550 complaint (&symfile_complaints
,
6551 _("Invalid .debug_ranges data "
6552 "(no base address)"));
6558 /* Inverted range entries are invalid. */
6559 complaint (&symfile_complaints
,
6560 _("Invalid .debug_ranges data "
6561 "(inverted range)"));
6565 /* Empty range entries have no effect. */
6569 record_block_range (block
,
6570 baseaddr
+ base
+ start
,
6571 baseaddr
+ base
+ end
- 1);
6577 /* Check for GCC PR debug/45124 fix which is not present in any G++ version up
6578 to 4.5.any while it is present already in G++ 4.6.0 - the PR has been fixed
6579 during 4.6.0 experimental. */
6582 producer_is_gxx_lt_4_6 (struct dwarf2_cu
*cu
)
6585 int major
, minor
, release
;
6587 if (cu
->producer
== NULL
)
6589 /* For unknown compilers expect their behavior is DWARF version
6592 GCC started to support .debug_types sections by -gdwarf-4 since
6593 gcc-4.5.x. As the .debug_types sections are missing DW_AT_producer
6594 for their space efficiency GDB cannot workaround gcc-4.5.x -gdwarf-4
6595 combination. gcc-4.5.x -gdwarf-4 binaries have DW_AT_accessibility
6596 interpreted incorrectly by GDB now - GCC PR debug/48229. */
6601 /* Skip any identifier after "GNU " - such as "C++" or "Java". */
6603 if (strncmp (cu
->producer
, "GNU ", strlen ("GNU ")) != 0)
6605 /* For non-GCC compilers expect their behavior is DWARF version
6610 cs
= &cu
->producer
[strlen ("GNU ")];
6611 while (*cs
&& !isdigit (*cs
))
6613 if (sscanf (cs
, "%d.%d.%d", &major
, &minor
, &release
) != 3)
6615 /* Not recognized as GCC. */
6620 return major
< 4 || (major
== 4 && minor
< 6);
6623 /* Return the default accessibility type if it is not overriden by
6624 DW_AT_accessibility. */
6626 static enum dwarf_access_attribute
6627 dwarf2_default_access_attribute (struct die_info
*die
, struct dwarf2_cu
*cu
)
6629 if (cu
->header
.version
< 3 || producer_is_gxx_lt_4_6 (cu
))
6631 /* The default DWARF 2 accessibility for members is public, the default
6632 accessibility for inheritance is private. */
6634 if (die
->tag
!= DW_TAG_inheritance
)
6635 return DW_ACCESS_public
;
6637 return DW_ACCESS_private
;
6641 /* DWARF 3+ defines the default accessibility a different way. The same
6642 rules apply now for DW_TAG_inheritance as for the members and it only
6643 depends on the container kind. */
6645 if (die
->parent
->tag
== DW_TAG_class_type
)
6646 return DW_ACCESS_private
;
6648 return DW_ACCESS_public
;
6652 /* Look for DW_AT_data_member_location. Set *OFFSET to the byte
6653 offset. If the attribute was not found return 0, otherwise return
6654 1. If it was found but could not properly be handled, set *OFFSET
6658 handle_data_member_location (struct die_info
*die
, struct dwarf2_cu
*cu
,
6661 struct attribute
*attr
;
6663 attr
= dwarf2_attr (die
, DW_AT_data_member_location
, cu
);
6668 /* Note that we do not check for a section offset first here.
6669 This is because DW_AT_data_member_location is new in DWARF 4,
6670 so if we see it, we can assume that a constant form is really
6671 a constant and not a section offset. */
6672 if (attr_form_is_constant (attr
))
6673 *offset
= dwarf2_get_attr_constant_value (attr
, 0);
6674 else if (attr_form_is_section_offset (attr
))
6675 dwarf2_complex_location_expr_complaint ();
6676 else if (attr_form_is_block (attr
))
6677 *offset
= decode_locdesc (DW_BLOCK (attr
), cu
);
6679 dwarf2_complex_location_expr_complaint ();
6687 /* Add an aggregate field to the field list. */
6690 dwarf2_add_field (struct field_info
*fip
, struct die_info
*die
,
6691 struct dwarf2_cu
*cu
)
6693 struct objfile
*objfile
= cu
->objfile
;
6694 struct gdbarch
*gdbarch
= get_objfile_arch (objfile
);
6695 struct nextfield
*new_field
;
6696 struct attribute
*attr
;
6698 char *fieldname
= "";
6700 /* Allocate a new field list entry and link it in. */
6701 new_field
= (struct nextfield
*) xmalloc (sizeof (struct nextfield
));
6702 make_cleanup (xfree
, new_field
);
6703 memset (new_field
, 0, sizeof (struct nextfield
));
6705 if (die
->tag
== DW_TAG_inheritance
)
6707 new_field
->next
= fip
->baseclasses
;
6708 fip
->baseclasses
= new_field
;
6712 new_field
->next
= fip
->fields
;
6713 fip
->fields
= new_field
;
6717 attr
= dwarf2_attr (die
, DW_AT_accessibility
, cu
);
6719 new_field
->accessibility
= DW_UNSND (attr
);
6721 new_field
->accessibility
= dwarf2_default_access_attribute (die
, cu
);
6722 if (new_field
->accessibility
!= DW_ACCESS_public
)
6723 fip
->non_public_fields
= 1;
6725 attr
= dwarf2_attr (die
, DW_AT_virtuality
, cu
);
6727 new_field
->virtuality
= DW_UNSND (attr
);
6729 new_field
->virtuality
= DW_VIRTUALITY_none
;
6731 fp
= &new_field
->field
;
6733 if (die
->tag
== DW_TAG_member
&& ! die_is_declaration (die
, cu
))
6737 /* Data member other than a C++ static data member. */
6739 /* Get type of field. */
6740 fp
->type
= die_type (die
, cu
);
6742 SET_FIELD_BITPOS (*fp
, 0);
6744 /* Get bit size of field (zero if none). */
6745 attr
= dwarf2_attr (die
, DW_AT_bit_size
, cu
);
6748 FIELD_BITSIZE (*fp
) = DW_UNSND (attr
);
6752 FIELD_BITSIZE (*fp
) = 0;
6755 /* Get bit offset of field. */
6756 if (handle_data_member_location (die
, cu
, &offset
))
6757 SET_FIELD_BITPOS (*fp
, offset
* bits_per_byte
);
6758 attr
= dwarf2_attr (die
, DW_AT_bit_offset
, cu
);
6761 if (gdbarch_bits_big_endian (gdbarch
))
6763 /* For big endian bits, the DW_AT_bit_offset gives the
6764 additional bit offset from the MSB of the containing
6765 anonymous object to the MSB of the field. We don't
6766 have to do anything special since we don't need to
6767 know the size of the anonymous object. */
6768 FIELD_BITPOS (*fp
) += DW_UNSND (attr
);
6772 /* For little endian bits, compute the bit offset to the
6773 MSB of the anonymous object, subtract off the number of
6774 bits from the MSB of the field to the MSB of the
6775 object, and then subtract off the number of bits of
6776 the field itself. The result is the bit offset of
6777 the LSB of the field. */
6779 int bit_offset
= DW_UNSND (attr
);
6781 attr
= dwarf2_attr (die
, DW_AT_byte_size
, cu
);
6784 /* The size of the anonymous object containing
6785 the bit field is explicit, so use the
6786 indicated size (in bytes). */
6787 anonymous_size
= DW_UNSND (attr
);
6791 /* The size of the anonymous object containing
6792 the bit field must be inferred from the type
6793 attribute of the data member containing the
6795 anonymous_size
= TYPE_LENGTH (fp
->type
);
6797 FIELD_BITPOS (*fp
) += anonymous_size
* bits_per_byte
6798 - bit_offset
- FIELD_BITSIZE (*fp
);
6802 /* Get name of field. */
6803 fieldname
= dwarf2_name (die
, cu
);
6804 if (fieldname
== NULL
)
6807 /* The name is already allocated along with this objfile, so we don't
6808 need to duplicate it for the type. */
6809 fp
->name
= fieldname
;
6811 /* Change accessibility for artificial fields (e.g. virtual table
6812 pointer or virtual base class pointer) to private. */
6813 if (dwarf2_attr (die
, DW_AT_artificial
, cu
))
6815 FIELD_ARTIFICIAL (*fp
) = 1;
6816 new_field
->accessibility
= DW_ACCESS_private
;
6817 fip
->non_public_fields
= 1;
6820 else if (die
->tag
== DW_TAG_member
|| die
->tag
== DW_TAG_variable
)
6822 /* C++ static member. */
6824 /* NOTE: carlton/2002-11-05: It should be a DW_TAG_member that
6825 is a declaration, but all versions of G++ as of this writing
6826 (so through at least 3.2.1) incorrectly generate
6827 DW_TAG_variable tags. */
6829 const char *physname
;
6831 /* Get name of field. */
6832 fieldname
= dwarf2_name (die
, cu
);
6833 if (fieldname
== NULL
)
6836 attr
= dwarf2_attr (die
, DW_AT_const_value
, cu
);
6838 /* Only create a symbol if this is an external value.
6839 new_symbol checks this and puts the value in the global symbol
6840 table, which we want. If it is not external, new_symbol
6841 will try to put the value in cu->list_in_scope which is wrong. */
6842 && dwarf2_flag_true_p (die
, DW_AT_external
, cu
))
6844 /* A static const member, not much different than an enum as far as
6845 we're concerned, except that we can support more types. */
6846 new_symbol (die
, NULL
, cu
);
6849 /* Get physical name. */
6850 physname
= dwarf2_physname (fieldname
, die
, cu
);
6852 /* The name is already allocated along with this objfile, so we don't
6853 need to duplicate it for the type. */
6854 SET_FIELD_PHYSNAME (*fp
, physname
? physname
: "");
6855 FIELD_TYPE (*fp
) = die_type (die
, cu
);
6856 FIELD_NAME (*fp
) = fieldname
;
6858 else if (die
->tag
== DW_TAG_inheritance
)
6862 /* C++ base class field. */
6863 if (handle_data_member_location (die
, cu
, &offset
))
6864 SET_FIELD_BITPOS (*fp
, offset
* bits_per_byte
);
6865 FIELD_BITSIZE (*fp
) = 0;
6866 FIELD_TYPE (*fp
) = die_type (die
, cu
);
6867 FIELD_NAME (*fp
) = type_name_no_tag (fp
->type
);
6868 fip
->nbaseclasses
++;
6872 /* Add a typedef defined in the scope of the FIP's class. */
6875 dwarf2_add_typedef (struct field_info
*fip
, struct die_info
*die
,
6876 struct dwarf2_cu
*cu
)
6878 struct objfile
*objfile
= cu
->objfile
;
6879 struct typedef_field_list
*new_field
;
6880 struct attribute
*attr
;
6881 struct typedef_field
*fp
;
6882 char *fieldname
= "";
6884 /* Allocate a new field list entry and link it in. */
6885 new_field
= xzalloc (sizeof (*new_field
));
6886 make_cleanup (xfree
, new_field
);
6888 gdb_assert (die
->tag
== DW_TAG_typedef
);
6890 fp
= &new_field
->field
;
6892 /* Get name of field. */
6893 fp
->name
= dwarf2_name (die
, cu
);
6894 if (fp
->name
== NULL
)
6897 fp
->type
= read_type_die (die
, cu
);
6899 new_field
->next
= fip
->typedef_field_list
;
6900 fip
->typedef_field_list
= new_field
;
6901 fip
->typedef_field_list_count
++;
6904 /* Create the vector of fields, and attach it to the type. */
6907 dwarf2_attach_fields_to_type (struct field_info
*fip
, struct type
*type
,
6908 struct dwarf2_cu
*cu
)
6910 int nfields
= fip
->nfields
;
6912 /* Record the field count, allocate space for the array of fields,
6913 and create blank accessibility bitfields if necessary. */
6914 TYPE_NFIELDS (type
) = nfields
;
6915 TYPE_FIELDS (type
) = (struct field
*)
6916 TYPE_ALLOC (type
, sizeof (struct field
) * nfields
);
6917 memset (TYPE_FIELDS (type
), 0, sizeof (struct field
) * nfields
);
6919 if (fip
->non_public_fields
&& cu
->language
!= language_ada
)
6921 ALLOCATE_CPLUS_STRUCT_TYPE (type
);
6923 TYPE_FIELD_PRIVATE_BITS (type
) =
6924 (B_TYPE
*) TYPE_ALLOC (type
, B_BYTES (nfields
));
6925 B_CLRALL (TYPE_FIELD_PRIVATE_BITS (type
), nfields
);
6927 TYPE_FIELD_PROTECTED_BITS (type
) =
6928 (B_TYPE
*) TYPE_ALLOC (type
, B_BYTES (nfields
));
6929 B_CLRALL (TYPE_FIELD_PROTECTED_BITS (type
), nfields
);
6931 TYPE_FIELD_IGNORE_BITS (type
) =
6932 (B_TYPE
*) TYPE_ALLOC (type
, B_BYTES (nfields
));
6933 B_CLRALL (TYPE_FIELD_IGNORE_BITS (type
), nfields
);
6936 /* If the type has baseclasses, allocate and clear a bit vector for
6937 TYPE_FIELD_VIRTUAL_BITS. */
6938 if (fip
->nbaseclasses
&& cu
->language
!= language_ada
)
6940 int num_bytes
= B_BYTES (fip
->nbaseclasses
);
6941 unsigned char *pointer
;
6943 ALLOCATE_CPLUS_STRUCT_TYPE (type
);
6944 pointer
= TYPE_ALLOC (type
, num_bytes
);
6945 TYPE_FIELD_VIRTUAL_BITS (type
) = pointer
;
6946 B_CLRALL (TYPE_FIELD_VIRTUAL_BITS (type
), fip
->nbaseclasses
);
6947 TYPE_N_BASECLASSES (type
) = fip
->nbaseclasses
;
6950 /* Copy the saved-up fields into the field vector. Start from the head of
6951 the list, adding to the tail of the field array, so that they end up in
6952 the same order in the array in which they were added to the list. */
6953 while (nfields
-- > 0)
6955 struct nextfield
*fieldp
;
6959 fieldp
= fip
->fields
;
6960 fip
->fields
= fieldp
->next
;
6964 fieldp
= fip
->baseclasses
;
6965 fip
->baseclasses
= fieldp
->next
;
6968 TYPE_FIELD (type
, nfields
) = fieldp
->field
;
6969 switch (fieldp
->accessibility
)
6971 case DW_ACCESS_private
:
6972 if (cu
->language
!= language_ada
)
6973 SET_TYPE_FIELD_PRIVATE (type
, nfields
);
6976 case DW_ACCESS_protected
:
6977 if (cu
->language
!= language_ada
)
6978 SET_TYPE_FIELD_PROTECTED (type
, nfields
);
6981 case DW_ACCESS_public
:
6985 /* Unknown accessibility. Complain and treat it as public. */
6987 complaint (&symfile_complaints
, _("unsupported accessibility %d"),
6988 fieldp
->accessibility
);
6992 if (nfields
< fip
->nbaseclasses
)
6994 switch (fieldp
->virtuality
)
6996 case DW_VIRTUALITY_virtual
:
6997 case DW_VIRTUALITY_pure_virtual
:
6998 if (cu
->language
== language_ada
)
6999 error (_("unexpected virtuality in component of Ada type"));
7000 SET_TYPE_FIELD_VIRTUAL (type
, nfields
);
7007 /* Add a member function to the proper fieldlist. */
7010 dwarf2_add_member_fn (struct field_info
*fip
, struct die_info
*die
,
7011 struct type
*type
, struct dwarf2_cu
*cu
)
7013 struct objfile
*objfile
= cu
->objfile
;
7014 struct attribute
*attr
;
7015 struct fnfieldlist
*flp
;
7017 struct fn_field
*fnp
;
7019 struct nextfnfield
*new_fnfield
;
7020 struct type
*this_type
;
7021 enum dwarf_access_attribute accessibility
;
7023 if (cu
->language
== language_ada
)
7024 error (_("unexpected member function in Ada type"));
7026 /* Get name of member function. */
7027 fieldname
= dwarf2_name (die
, cu
);
7028 if (fieldname
== NULL
)
7031 /* Look up member function name in fieldlist. */
7032 for (i
= 0; i
< fip
->nfnfields
; i
++)
7034 if (strcmp (fip
->fnfieldlists
[i
].name
, fieldname
) == 0)
7038 /* Create new list element if necessary. */
7039 if (i
< fip
->nfnfields
)
7040 flp
= &fip
->fnfieldlists
[i
];
7043 if ((fip
->nfnfields
% DW_FIELD_ALLOC_CHUNK
) == 0)
7045 fip
->fnfieldlists
= (struct fnfieldlist
*)
7046 xrealloc (fip
->fnfieldlists
,
7047 (fip
->nfnfields
+ DW_FIELD_ALLOC_CHUNK
)
7048 * sizeof (struct fnfieldlist
));
7049 if (fip
->nfnfields
== 0)
7050 make_cleanup (free_current_contents
, &fip
->fnfieldlists
);
7052 flp
= &fip
->fnfieldlists
[fip
->nfnfields
];
7053 flp
->name
= fieldname
;
7056 i
= fip
->nfnfields
++;
7059 /* Create a new member function field and chain it to the field list
7061 new_fnfield
= (struct nextfnfield
*) xmalloc (sizeof (struct nextfnfield
));
7062 make_cleanup (xfree
, new_fnfield
);
7063 memset (new_fnfield
, 0, sizeof (struct nextfnfield
));
7064 new_fnfield
->next
= flp
->head
;
7065 flp
->head
= new_fnfield
;
7068 /* Fill in the member function field info. */
7069 fnp
= &new_fnfield
->fnfield
;
7071 /* Delay processing of the physname until later. */
7072 if (cu
->language
== language_cplus
|| cu
->language
== language_java
)
7074 add_to_method_list (type
, i
, flp
->length
- 1, fieldname
,
7079 const char *physname
= dwarf2_physname (fieldname
, die
, cu
);
7080 fnp
->physname
= physname
? physname
: "";
7083 fnp
->type
= alloc_type (objfile
);
7084 this_type
= read_type_die (die
, cu
);
7085 if (this_type
&& TYPE_CODE (this_type
) == TYPE_CODE_FUNC
)
7087 int nparams
= TYPE_NFIELDS (this_type
);
7089 /* TYPE is the domain of this method, and THIS_TYPE is the type
7090 of the method itself (TYPE_CODE_METHOD). */
7091 smash_to_method_type (fnp
->type
, type
,
7092 TYPE_TARGET_TYPE (this_type
),
7093 TYPE_FIELDS (this_type
),
7094 TYPE_NFIELDS (this_type
),
7095 TYPE_VARARGS (this_type
));
7097 /* Handle static member functions.
7098 Dwarf2 has no clean way to discern C++ static and non-static
7099 member functions. G++ helps GDB by marking the first
7100 parameter for non-static member functions (which is the this
7101 pointer) as artificial. We obtain this information from
7102 read_subroutine_type via TYPE_FIELD_ARTIFICIAL. */
7103 if (nparams
== 0 || TYPE_FIELD_ARTIFICIAL (this_type
, 0) == 0)
7104 fnp
->voffset
= VOFFSET_STATIC
;
7107 complaint (&symfile_complaints
, _("member function type missing for '%s'"),
7108 dwarf2_full_name (fieldname
, die
, cu
));
7110 /* Get fcontext from DW_AT_containing_type if present. */
7111 if (dwarf2_attr (die
, DW_AT_containing_type
, cu
) != NULL
)
7112 fnp
->fcontext
= die_containing_type (die
, cu
);
7114 /* dwarf2 doesn't have stubbed physical names, so the setting of is_const and
7115 is_volatile is irrelevant, as it is needed by gdb_mangle_name only. */
7117 /* Get accessibility. */
7118 attr
= dwarf2_attr (die
, DW_AT_accessibility
, cu
);
7120 accessibility
= DW_UNSND (attr
);
7122 accessibility
= dwarf2_default_access_attribute (die
, cu
);
7123 switch (accessibility
)
7125 case DW_ACCESS_private
:
7126 fnp
->is_private
= 1;
7128 case DW_ACCESS_protected
:
7129 fnp
->is_protected
= 1;
7133 /* Check for artificial methods. */
7134 attr
= dwarf2_attr (die
, DW_AT_artificial
, cu
);
7135 if (attr
&& DW_UNSND (attr
) != 0)
7136 fnp
->is_artificial
= 1;
7138 /* Get index in virtual function table if it is a virtual member
7139 function. For older versions of GCC, this is an offset in the
7140 appropriate virtual table, as specified by DW_AT_containing_type.
7141 For everyone else, it is an expression to be evaluated relative
7142 to the object address. */
7144 attr
= dwarf2_attr (die
, DW_AT_vtable_elem_location
, cu
);
7147 if (attr_form_is_block (attr
) && DW_BLOCK (attr
)->size
> 0)
7149 if (DW_BLOCK (attr
)->data
[0] == DW_OP_constu
)
7151 /* Old-style GCC. */
7152 fnp
->voffset
= decode_locdesc (DW_BLOCK (attr
), cu
) + 2;
7154 else if (DW_BLOCK (attr
)->data
[0] == DW_OP_deref
7155 || (DW_BLOCK (attr
)->size
> 1
7156 && DW_BLOCK (attr
)->data
[0] == DW_OP_deref_size
7157 && DW_BLOCK (attr
)->data
[1] == cu
->header
.addr_size
))
7159 struct dwarf_block blk
;
7162 offset
= (DW_BLOCK (attr
)->data
[0] == DW_OP_deref
7164 blk
.size
= DW_BLOCK (attr
)->size
- offset
;
7165 blk
.data
= DW_BLOCK (attr
)->data
+ offset
;
7166 fnp
->voffset
= decode_locdesc (DW_BLOCK (attr
), cu
);
7167 if ((fnp
->voffset
% cu
->header
.addr_size
) != 0)
7168 dwarf2_complex_location_expr_complaint ();
7170 fnp
->voffset
/= cu
->header
.addr_size
;
7174 dwarf2_complex_location_expr_complaint ();
7177 fnp
->fcontext
= TYPE_TARGET_TYPE (TYPE_FIELD_TYPE (this_type
, 0));
7179 else if (attr_form_is_section_offset (attr
))
7181 dwarf2_complex_location_expr_complaint ();
7185 dwarf2_invalid_attrib_class_complaint ("DW_AT_vtable_elem_location",
7191 attr
= dwarf2_attr (die
, DW_AT_virtuality
, cu
);
7192 if (attr
&& DW_UNSND (attr
))
7194 /* GCC does this, as of 2008-08-25; PR debug/37237. */
7195 complaint (&symfile_complaints
,
7196 _("Member function \"%s\" (offset %d) is virtual "
7197 "but the vtable offset is not specified"),
7198 fieldname
, die
->offset
);
7199 ALLOCATE_CPLUS_STRUCT_TYPE (type
);
7200 TYPE_CPLUS_DYNAMIC (type
) = 1;
7205 /* Create the vector of member function fields, and attach it to the type. */
7208 dwarf2_attach_fn_fields_to_type (struct field_info
*fip
, struct type
*type
,
7209 struct dwarf2_cu
*cu
)
7211 struct fnfieldlist
*flp
;
7212 int total_length
= 0;
7215 if (cu
->language
== language_ada
)
7216 error (_("unexpected member functions in Ada type"));
7218 ALLOCATE_CPLUS_STRUCT_TYPE (type
);
7219 TYPE_FN_FIELDLISTS (type
) = (struct fn_fieldlist
*)
7220 TYPE_ALLOC (type
, sizeof (struct fn_fieldlist
) * fip
->nfnfields
);
7222 for (i
= 0, flp
= fip
->fnfieldlists
; i
< fip
->nfnfields
; i
++, flp
++)
7224 struct nextfnfield
*nfp
= flp
->head
;
7225 struct fn_fieldlist
*fn_flp
= &TYPE_FN_FIELDLIST (type
, i
);
7228 TYPE_FN_FIELDLIST_NAME (type
, i
) = flp
->name
;
7229 TYPE_FN_FIELDLIST_LENGTH (type
, i
) = flp
->length
;
7230 fn_flp
->fn_fields
= (struct fn_field
*)
7231 TYPE_ALLOC (type
, sizeof (struct fn_field
) * flp
->length
);
7232 for (k
= flp
->length
; (k
--, nfp
); nfp
= nfp
->next
)
7233 fn_flp
->fn_fields
[k
] = nfp
->fnfield
;
7235 total_length
+= flp
->length
;
7238 TYPE_NFN_FIELDS (type
) = fip
->nfnfields
;
7239 TYPE_NFN_FIELDS_TOTAL (type
) = total_length
;
7242 /* Returns non-zero if NAME is the name of a vtable member in CU's
7243 language, zero otherwise. */
7245 is_vtable_name (const char *name
, struct dwarf2_cu
*cu
)
7247 static const char vptr
[] = "_vptr";
7248 static const char vtable
[] = "vtable";
7250 /* Look for the C++ and Java forms of the vtable. */
7251 if ((cu
->language
== language_java
7252 && strncmp (name
, vtable
, sizeof (vtable
) - 1) == 0)
7253 || (strncmp (name
, vptr
, sizeof (vptr
) - 1) == 0
7254 && is_cplus_marker (name
[sizeof (vptr
) - 1])))
7260 /* GCC outputs unnamed structures that are really pointers to member
7261 functions, with the ABI-specified layout. If TYPE describes
7262 such a structure, smash it into a member function type.
7264 GCC shouldn't do this; it should just output pointer to member DIEs.
7265 This is GCC PR debug/28767. */
7268 quirk_gcc_member_function_pointer (struct type
*type
, struct objfile
*objfile
)
7270 struct type
*pfn_type
, *domain_type
, *new_type
;
7272 /* Check for a structure with no name and two children. */
7273 if (TYPE_CODE (type
) != TYPE_CODE_STRUCT
|| TYPE_NFIELDS (type
) != 2)
7276 /* Check for __pfn and __delta members. */
7277 if (TYPE_FIELD_NAME (type
, 0) == NULL
7278 || strcmp (TYPE_FIELD_NAME (type
, 0), "__pfn") != 0
7279 || TYPE_FIELD_NAME (type
, 1) == NULL
7280 || strcmp (TYPE_FIELD_NAME (type
, 1), "__delta") != 0)
7283 /* Find the type of the method. */
7284 pfn_type
= TYPE_FIELD_TYPE (type
, 0);
7285 if (pfn_type
== NULL
7286 || TYPE_CODE (pfn_type
) != TYPE_CODE_PTR
7287 || TYPE_CODE (TYPE_TARGET_TYPE (pfn_type
)) != TYPE_CODE_FUNC
)
7290 /* Look for the "this" argument. */
7291 pfn_type
= TYPE_TARGET_TYPE (pfn_type
);
7292 if (TYPE_NFIELDS (pfn_type
) == 0
7293 /* || TYPE_FIELD_TYPE (pfn_type, 0) == NULL */
7294 || TYPE_CODE (TYPE_FIELD_TYPE (pfn_type
, 0)) != TYPE_CODE_PTR
)
7297 domain_type
= TYPE_TARGET_TYPE (TYPE_FIELD_TYPE (pfn_type
, 0));
7298 new_type
= alloc_type (objfile
);
7299 smash_to_method_type (new_type
, domain_type
, TYPE_TARGET_TYPE (pfn_type
),
7300 TYPE_FIELDS (pfn_type
), TYPE_NFIELDS (pfn_type
),
7301 TYPE_VARARGS (pfn_type
));
7302 smash_to_methodptr_type (type
, new_type
);
7305 /* Called when we find the DIE that starts a structure or union scope
7306 (definition) to create a type for the structure or union. Fill in
7307 the type's name and general properties; the members will not be
7308 processed until process_structure_type.
7310 NOTE: we need to call these functions regardless of whether or not the
7311 DIE has a DW_AT_name attribute, since it might be an anonymous
7312 structure or union. This gets the type entered into our set of
7315 However, if the structure is incomplete (an opaque struct/union)
7316 then suppress creating a symbol table entry for it since gdb only
7317 wants to find the one with the complete definition. Note that if
7318 it is complete, we just call new_symbol, which does it's own
7319 checking about whether the struct/union is anonymous or not (and
7320 suppresses creating a symbol table entry itself). */
7322 static struct type
*
7323 read_structure_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
7325 struct objfile
*objfile
= cu
->objfile
;
7327 struct attribute
*attr
;
7330 /* If the definition of this type lives in .debug_types, read that type.
7331 Don't follow DW_AT_specification though, that will take us back up
7332 the chain and we want to go down. */
7333 attr
= dwarf2_attr_no_follow (die
, DW_AT_signature
, cu
);
7336 struct dwarf2_cu
*type_cu
= cu
;
7337 struct die_info
*type_die
= follow_die_ref_or_sig (die
, attr
, &type_cu
);
7339 /* We could just recurse on read_structure_type, but we need to call
7340 get_die_type to ensure only one type for this DIE is created.
7341 This is important, for example, because for c++ classes we need
7342 TYPE_NAME set which is only done by new_symbol. Blech. */
7343 type
= read_type_die (type_die
, type_cu
);
7345 /* TYPE_CU may not be the same as CU.
7346 Ensure TYPE is recorded in CU's type_hash table. */
7347 return set_die_type (die
, type
, cu
);
7350 type
= alloc_type (objfile
);
7351 INIT_CPLUS_SPECIFIC (type
);
7353 name
= dwarf2_name (die
, cu
);
7356 if (cu
->language
== language_cplus
7357 || cu
->language
== language_java
)
7359 char *full_name
= (char *) dwarf2_full_name (name
, die
, cu
);
7361 /* dwarf2_full_name might have already finished building the DIE's
7362 type. If so, there is no need to continue. */
7363 if (get_die_type (die
, cu
) != NULL
)
7364 return get_die_type (die
, cu
);
7366 TYPE_TAG_NAME (type
) = full_name
;
7367 if (die
->tag
== DW_TAG_structure_type
7368 || die
->tag
== DW_TAG_class_type
)
7369 TYPE_NAME (type
) = TYPE_TAG_NAME (type
);
7373 /* The name is already allocated along with this objfile, so
7374 we don't need to duplicate it for the type. */
7375 TYPE_TAG_NAME (type
) = (char *) name
;
7376 if (die
->tag
== DW_TAG_class_type
)
7377 TYPE_NAME (type
) = TYPE_TAG_NAME (type
);
7381 if (die
->tag
== DW_TAG_structure_type
)
7383 TYPE_CODE (type
) = TYPE_CODE_STRUCT
;
7385 else if (die
->tag
== DW_TAG_union_type
)
7387 TYPE_CODE (type
) = TYPE_CODE_UNION
;
7391 TYPE_CODE (type
) = TYPE_CODE_CLASS
;
7394 if (cu
->language
== language_cplus
&& die
->tag
== DW_TAG_class_type
)
7395 TYPE_DECLARED_CLASS (type
) = 1;
7397 attr
= dwarf2_attr (die
, DW_AT_byte_size
, cu
);
7400 TYPE_LENGTH (type
) = DW_UNSND (attr
);
7404 TYPE_LENGTH (type
) = 0;
7407 TYPE_STUB_SUPPORTED (type
) = 1;
7408 if (die_is_declaration (die
, cu
))
7409 TYPE_STUB (type
) = 1;
7410 else if (attr
== NULL
&& die
->child
== NULL
7411 && producer_is_realview (cu
->producer
))
7412 /* RealView does not output the required DW_AT_declaration
7413 on incomplete types. */
7414 TYPE_STUB (type
) = 1;
7416 /* We need to add the type field to the die immediately so we don't
7417 infinitely recurse when dealing with pointers to the structure
7418 type within the structure itself. */
7419 set_die_type (die
, type
, cu
);
7421 /* set_die_type should be already done. */
7422 set_descriptive_type (type
, die
, cu
);
7427 /* Finish creating a structure or union type, including filling in
7428 its members and creating a symbol for it. */
7431 process_structure_scope (struct die_info
*die
, struct dwarf2_cu
*cu
)
7433 struct objfile
*objfile
= cu
->objfile
;
7434 struct die_info
*child_die
= die
->child
;
7437 type
= get_die_type (die
, cu
);
7439 type
= read_structure_type (die
, cu
);
7441 if (die
->child
!= NULL
&& ! die_is_declaration (die
, cu
))
7443 struct field_info fi
;
7444 struct die_info
*child_die
;
7445 VEC (symbolp
) *template_args
= NULL
;
7446 struct cleanup
*back_to
= make_cleanup (null_cleanup
, 0);
7448 memset (&fi
, 0, sizeof (struct field_info
));
7450 child_die
= die
->child
;
7452 while (child_die
&& child_die
->tag
)
7454 if (child_die
->tag
== DW_TAG_member
7455 || child_die
->tag
== DW_TAG_variable
)
7457 /* NOTE: carlton/2002-11-05: A C++ static data member
7458 should be a DW_TAG_member that is a declaration, but
7459 all versions of G++ as of this writing (so through at
7460 least 3.2.1) incorrectly generate DW_TAG_variable
7461 tags for them instead. */
7462 dwarf2_add_field (&fi
, child_die
, cu
);
7464 else if (child_die
->tag
== DW_TAG_subprogram
)
7466 /* C++ member function. */
7467 dwarf2_add_member_fn (&fi
, child_die
, type
, cu
);
7469 else if (child_die
->tag
== DW_TAG_inheritance
)
7471 /* C++ base class field. */
7472 dwarf2_add_field (&fi
, child_die
, cu
);
7474 else if (child_die
->tag
== DW_TAG_typedef
)
7475 dwarf2_add_typedef (&fi
, child_die
, cu
);
7476 else if (child_die
->tag
== DW_TAG_template_type_param
7477 || child_die
->tag
== DW_TAG_template_value_param
)
7479 struct symbol
*arg
= new_symbol (child_die
, NULL
, cu
);
7482 VEC_safe_push (symbolp
, template_args
, arg
);
7485 child_die
= sibling_die (child_die
);
7488 /* Attach template arguments to type. */
7489 if (! VEC_empty (symbolp
, template_args
))
7491 ALLOCATE_CPLUS_STRUCT_TYPE (type
);
7492 TYPE_N_TEMPLATE_ARGUMENTS (type
)
7493 = VEC_length (symbolp
, template_args
);
7494 TYPE_TEMPLATE_ARGUMENTS (type
)
7495 = obstack_alloc (&objfile
->objfile_obstack
,
7496 (TYPE_N_TEMPLATE_ARGUMENTS (type
)
7497 * sizeof (struct symbol
*)));
7498 memcpy (TYPE_TEMPLATE_ARGUMENTS (type
),
7499 VEC_address (symbolp
, template_args
),
7500 (TYPE_N_TEMPLATE_ARGUMENTS (type
)
7501 * sizeof (struct symbol
*)));
7502 VEC_free (symbolp
, template_args
);
7505 /* Attach fields and member functions to the type. */
7507 dwarf2_attach_fields_to_type (&fi
, type
, cu
);
7510 dwarf2_attach_fn_fields_to_type (&fi
, type
, cu
);
7512 /* Get the type which refers to the base class (possibly this
7513 class itself) which contains the vtable pointer for the current
7514 class from the DW_AT_containing_type attribute. This use of
7515 DW_AT_containing_type is a GNU extension. */
7517 if (dwarf2_attr (die
, DW_AT_containing_type
, cu
) != NULL
)
7519 struct type
*t
= die_containing_type (die
, cu
);
7521 TYPE_VPTR_BASETYPE (type
) = t
;
7526 /* Our own class provides vtbl ptr. */
7527 for (i
= TYPE_NFIELDS (t
) - 1;
7528 i
>= TYPE_N_BASECLASSES (t
);
7531 char *fieldname
= TYPE_FIELD_NAME (t
, i
);
7533 if (is_vtable_name (fieldname
, cu
))
7535 TYPE_VPTR_FIELDNO (type
) = i
;
7540 /* Complain if virtual function table field not found. */
7541 if (i
< TYPE_N_BASECLASSES (t
))
7542 complaint (&symfile_complaints
,
7543 _("virtual function table pointer "
7544 "not found when defining class '%s'"),
7545 TYPE_TAG_NAME (type
) ? TYPE_TAG_NAME (type
) :
7550 TYPE_VPTR_FIELDNO (type
) = TYPE_VPTR_FIELDNO (t
);
7553 else if (cu
->producer
7554 && strncmp (cu
->producer
,
7555 "IBM(R) XL C/C++ Advanced Edition", 32) == 0)
7557 /* The IBM XLC compiler does not provide direct indication
7558 of the containing type, but the vtable pointer is
7559 always named __vfp. */
7563 for (i
= TYPE_NFIELDS (type
) - 1;
7564 i
>= TYPE_N_BASECLASSES (type
);
7567 if (strcmp (TYPE_FIELD_NAME (type
, i
), "__vfp") == 0)
7569 TYPE_VPTR_FIELDNO (type
) = i
;
7570 TYPE_VPTR_BASETYPE (type
) = type
;
7577 /* Copy fi.typedef_field_list linked list elements content into the
7578 allocated array TYPE_TYPEDEF_FIELD_ARRAY (type). */
7579 if (fi
.typedef_field_list
)
7581 int i
= fi
.typedef_field_list_count
;
7583 ALLOCATE_CPLUS_STRUCT_TYPE (type
);
7584 TYPE_TYPEDEF_FIELD_ARRAY (type
)
7585 = TYPE_ALLOC (type
, sizeof (TYPE_TYPEDEF_FIELD (type
, 0)) * i
);
7586 TYPE_TYPEDEF_FIELD_COUNT (type
) = i
;
7588 /* Reverse the list order to keep the debug info elements order. */
7591 struct typedef_field
*dest
, *src
;
7593 dest
= &TYPE_TYPEDEF_FIELD (type
, i
);
7594 src
= &fi
.typedef_field_list
->field
;
7595 fi
.typedef_field_list
= fi
.typedef_field_list
->next
;
7600 do_cleanups (back_to
);
7602 if (HAVE_CPLUS_STRUCT (type
))
7603 TYPE_CPLUS_REALLY_JAVA (type
) = cu
->language
== language_java
;
7606 quirk_gcc_member_function_pointer (type
, cu
->objfile
);
7608 /* NOTE: carlton/2004-03-16: GCC 3.4 (or at least one of its
7609 snapshots) has been known to create a die giving a declaration
7610 for a class that has, as a child, a die giving a definition for a
7611 nested class. So we have to process our children even if the
7612 current die is a declaration. Normally, of course, a declaration
7613 won't have any children at all. */
7615 while (child_die
!= NULL
&& child_die
->tag
)
7617 if (child_die
->tag
== DW_TAG_member
7618 || child_die
->tag
== DW_TAG_variable
7619 || child_die
->tag
== DW_TAG_inheritance
7620 || child_die
->tag
== DW_TAG_template_value_param
7621 || child_die
->tag
== DW_TAG_template_type_param
)
7626 process_die (child_die
, cu
);
7628 child_die
= sibling_die (child_die
);
7631 /* Do not consider external references. According to the DWARF standard,
7632 these DIEs are identified by the fact that they have no byte_size
7633 attribute, and a declaration attribute. */
7634 if (dwarf2_attr (die
, DW_AT_byte_size
, cu
) != NULL
7635 || !die_is_declaration (die
, cu
))
7636 new_symbol (die
, type
, cu
);
7639 /* Given a DW_AT_enumeration_type die, set its type. We do not
7640 complete the type's fields yet, or create any symbols. */
7642 static struct type
*
7643 read_enumeration_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
7645 struct objfile
*objfile
= cu
->objfile
;
7647 struct attribute
*attr
;
7650 /* If the definition of this type lives in .debug_types, read that type.
7651 Don't follow DW_AT_specification though, that will take us back up
7652 the chain and we want to go down. */
7653 attr
= dwarf2_attr_no_follow (die
, DW_AT_signature
, cu
);
7656 struct dwarf2_cu
*type_cu
= cu
;
7657 struct die_info
*type_die
= follow_die_ref_or_sig (die
, attr
, &type_cu
);
7659 type
= read_type_die (type_die
, type_cu
);
7661 /* TYPE_CU may not be the same as CU.
7662 Ensure TYPE is recorded in CU's type_hash table. */
7663 return set_die_type (die
, type
, cu
);
7666 type
= alloc_type (objfile
);
7668 TYPE_CODE (type
) = TYPE_CODE_ENUM
;
7669 name
= dwarf2_full_name (NULL
, die
, cu
);
7671 TYPE_TAG_NAME (type
) = (char *) name
;
7673 attr
= dwarf2_attr (die
, DW_AT_byte_size
, cu
);
7676 TYPE_LENGTH (type
) = DW_UNSND (attr
);
7680 TYPE_LENGTH (type
) = 0;
7683 /* The enumeration DIE can be incomplete. In Ada, any type can be
7684 declared as private in the package spec, and then defined only
7685 inside the package body. Such types are known as Taft Amendment
7686 Types. When another package uses such a type, an incomplete DIE
7687 may be generated by the compiler. */
7688 if (die_is_declaration (die
, cu
))
7689 TYPE_STUB (type
) = 1;
7691 return set_die_type (die
, type
, cu
);
7694 /* Given a pointer to a die which begins an enumeration, process all
7695 the dies that define the members of the enumeration, and create the
7696 symbol for the enumeration type.
7698 NOTE: We reverse the order of the element list. */
7701 process_enumeration_scope (struct die_info
*die
, struct dwarf2_cu
*cu
)
7703 struct type
*this_type
;
7705 this_type
= get_die_type (die
, cu
);
7706 if (this_type
== NULL
)
7707 this_type
= read_enumeration_type (die
, cu
);
7709 if (die
->child
!= NULL
)
7711 struct die_info
*child_die
;
7713 struct field
*fields
= NULL
;
7715 int unsigned_enum
= 1;
7718 child_die
= die
->child
;
7719 while (child_die
&& child_die
->tag
)
7721 if (child_die
->tag
!= DW_TAG_enumerator
)
7723 process_die (child_die
, cu
);
7727 name
= dwarf2_name (child_die
, cu
);
7730 sym
= new_symbol (child_die
, this_type
, cu
);
7731 if (SYMBOL_VALUE (sym
) < 0)
7734 if ((num_fields
% DW_FIELD_ALLOC_CHUNK
) == 0)
7736 fields
= (struct field
*)
7738 (num_fields
+ DW_FIELD_ALLOC_CHUNK
)
7739 * sizeof (struct field
));
7742 FIELD_NAME (fields
[num_fields
]) = SYMBOL_LINKAGE_NAME (sym
);
7743 FIELD_TYPE (fields
[num_fields
]) = NULL
;
7744 SET_FIELD_BITPOS (fields
[num_fields
], SYMBOL_VALUE (sym
));
7745 FIELD_BITSIZE (fields
[num_fields
]) = 0;
7751 child_die
= sibling_die (child_die
);
7756 TYPE_NFIELDS (this_type
) = num_fields
;
7757 TYPE_FIELDS (this_type
) = (struct field
*)
7758 TYPE_ALLOC (this_type
, sizeof (struct field
) * num_fields
);
7759 memcpy (TYPE_FIELDS (this_type
), fields
,
7760 sizeof (struct field
) * num_fields
);
7764 TYPE_UNSIGNED (this_type
) = 1;
7767 /* If we are reading an enum from a .debug_types unit, and the enum
7768 is a declaration, and the enum is not the signatured type in the
7769 unit, then we do not want to add a symbol for it. Adding a
7770 symbol would in some cases obscure the true definition of the
7771 enum, giving users an incomplete type when the definition is
7772 actually available. Note that we do not want to do this for all
7773 enums which are just declarations, because C++0x allows forward
7774 enum declarations. */
7775 if (cu
->per_cu
->debug_type_section
7776 && die_is_declaration (die
, cu
))
7778 struct signatured_type
*type_sig
;
7781 = lookup_signatured_type_at_offset (dwarf2_per_objfile
->objfile
,
7782 cu
->per_cu
->debug_type_section
,
7783 cu
->per_cu
->offset
);
7784 if (type_sig
->type_offset
!= die
->offset
)
7788 new_symbol (die
, this_type
, cu
);
7791 /* Extract all information from a DW_TAG_array_type DIE and put it in
7792 the DIE's type field. For now, this only handles one dimensional
7795 static struct type
*
7796 read_array_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
7798 struct objfile
*objfile
= cu
->objfile
;
7799 struct die_info
*child_die
;
7801 struct type
*element_type
, *range_type
, *index_type
;
7802 struct type
**range_types
= NULL
;
7803 struct attribute
*attr
;
7805 struct cleanup
*back_to
;
7808 element_type
= die_type (die
, cu
);
7810 /* The die_type call above may have already set the type for this DIE. */
7811 type
= get_die_type (die
, cu
);
7815 /* Irix 6.2 native cc creates array types without children for
7816 arrays with unspecified length. */
7817 if (die
->child
== NULL
)
7819 index_type
= objfile_type (objfile
)->builtin_int
;
7820 range_type
= create_range_type (NULL
, index_type
, 0, -1);
7821 type
= create_array_type (NULL
, element_type
, range_type
);
7822 return set_die_type (die
, type
, cu
);
7825 back_to
= make_cleanup (null_cleanup
, NULL
);
7826 child_die
= die
->child
;
7827 while (child_die
&& child_die
->tag
)
7829 if (child_die
->tag
== DW_TAG_subrange_type
)
7831 struct type
*child_type
= read_type_die (child_die
, cu
);
7833 if (child_type
!= NULL
)
7835 /* The range type was succesfully read. Save it for the
7836 array type creation. */
7837 if ((ndim
% DW_FIELD_ALLOC_CHUNK
) == 0)
7839 range_types
= (struct type
**)
7840 xrealloc (range_types
, (ndim
+ DW_FIELD_ALLOC_CHUNK
)
7841 * sizeof (struct type
*));
7843 make_cleanup (free_current_contents
, &range_types
);
7845 range_types
[ndim
++] = child_type
;
7848 child_die
= sibling_die (child_die
);
7851 /* Dwarf2 dimensions are output from left to right, create the
7852 necessary array types in backwards order. */
7854 type
= element_type
;
7856 if (read_array_order (die
, cu
) == DW_ORD_col_major
)
7861 type
= create_array_type (NULL
, type
, range_types
[i
++]);
7866 type
= create_array_type (NULL
, type
, range_types
[ndim
]);
7869 /* Understand Dwarf2 support for vector types (like they occur on
7870 the PowerPC w/ AltiVec). Gcc just adds another attribute to the
7871 array type. This is not part of the Dwarf2/3 standard yet, but a
7872 custom vendor extension. The main difference between a regular
7873 array and the vector variant is that vectors are passed by value
7875 attr
= dwarf2_attr (die
, DW_AT_GNU_vector
, cu
);
7877 make_vector_type (type
);
7879 /* The DIE may have DW_AT_byte_size set. For example an OpenCL
7880 implementation may choose to implement triple vectors using this
7882 attr
= dwarf2_attr (die
, DW_AT_byte_size
, cu
);
7885 if (DW_UNSND (attr
) >= TYPE_LENGTH (type
))
7886 TYPE_LENGTH (type
) = DW_UNSND (attr
);
7888 complaint (&symfile_complaints
,
7889 _("DW_AT_byte_size for array type smaller "
7890 "than the total size of elements"));
7893 name
= dwarf2_name (die
, cu
);
7895 TYPE_NAME (type
) = name
;
7897 /* Install the type in the die. */
7898 set_die_type (die
, type
, cu
);
7900 /* set_die_type should be already done. */
7901 set_descriptive_type (type
, die
, cu
);
7903 do_cleanups (back_to
);
7908 static enum dwarf_array_dim_ordering
7909 read_array_order (struct die_info
*die
, struct dwarf2_cu
*cu
)
7911 struct attribute
*attr
;
7913 attr
= dwarf2_attr (die
, DW_AT_ordering
, cu
);
7915 if (attr
) return DW_SND (attr
);
7917 /* GNU F77 is a special case, as at 08/2004 array type info is the
7918 opposite order to the dwarf2 specification, but data is still
7919 laid out as per normal fortran.
7921 FIXME: dsl/2004-8-20: If G77 is ever fixed, this will also need
7922 version checking. */
7924 if (cu
->language
== language_fortran
7925 && cu
->producer
&& strstr (cu
->producer
, "GNU F77"))
7927 return DW_ORD_row_major
;
7930 switch (cu
->language_defn
->la_array_ordering
)
7932 case array_column_major
:
7933 return DW_ORD_col_major
;
7934 case array_row_major
:
7936 return DW_ORD_row_major
;
7940 /* Extract all information from a DW_TAG_set_type DIE and put it in
7941 the DIE's type field. */
7943 static struct type
*
7944 read_set_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
7946 struct type
*domain_type
, *set_type
;
7947 struct attribute
*attr
;
7949 domain_type
= die_type (die
, cu
);
7951 /* The die_type call above may have already set the type for this DIE. */
7952 set_type
= get_die_type (die
, cu
);
7956 set_type
= create_set_type (NULL
, domain_type
);
7958 attr
= dwarf2_attr (die
, DW_AT_byte_size
, cu
);
7960 TYPE_LENGTH (set_type
) = DW_UNSND (attr
);
7962 return set_die_type (die
, set_type
, cu
);
7965 /* First cut: install each common block member as a global variable. */
7968 read_common_block (struct die_info
*die
, struct dwarf2_cu
*cu
)
7970 struct die_info
*child_die
;
7971 struct attribute
*attr
;
7973 CORE_ADDR base
= (CORE_ADDR
) 0;
7975 attr
= dwarf2_attr (die
, DW_AT_location
, cu
);
7978 /* Support the .debug_loc offsets. */
7979 if (attr_form_is_block (attr
))
7981 base
= decode_locdesc (DW_BLOCK (attr
), cu
);
7983 else if (attr_form_is_section_offset (attr
))
7985 dwarf2_complex_location_expr_complaint ();
7989 dwarf2_invalid_attrib_class_complaint ("DW_AT_location",
7990 "common block member");
7993 if (die
->child
!= NULL
)
7995 child_die
= die
->child
;
7996 while (child_die
&& child_die
->tag
)
8000 sym
= new_symbol (child_die
, NULL
, cu
);
8002 && handle_data_member_location (child_die
, cu
, &offset
))
8004 SYMBOL_VALUE_ADDRESS (sym
) = base
+ offset
;
8005 add_symbol_to_list (sym
, &global_symbols
);
8007 child_die
= sibling_die (child_die
);
8012 /* Create a type for a C++ namespace. */
8014 static struct type
*
8015 read_namespace_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
8017 struct objfile
*objfile
= cu
->objfile
;
8018 const char *previous_prefix
, *name
;
8022 /* For extensions, reuse the type of the original namespace. */
8023 if (dwarf2_attr (die
, DW_AT_extension
, cu
) != NULL
)
8025 struct die_info
*ext_die
;
8026 struct dwarf2_cu
*ext_cu
= cu
;
8028 ext_die
= dwarf2_extension (die
, &ext_cu
);
8029 type
= read_type_die (ext_die
, ext_cu
);
8031 /* EXT_CU may not be the same as CU.
8032 Ensure TYPE is recorded in CU's type_hash table. */
8033 return set_die_type (die
, type
, cu
);
8036 name
= namespace_name (die
, &is_anonymous
, cu
);
8038 /* Now build the name of the current namespace. */
8040 previous_prefix
= determine_prefix (die
, cu
);
8041 if (previous_prefix
[0] != '\0')
8042 name
= typename_concat (&objfile
->objfile_obstack
,
8043 previous_prefix
, name
, 0, cu
);
8045 /* Create the type. */
8046 type
= init_type (TYPE_CODE_NAMESPACE
, 0, 0, NULL
,
8048 TYPE_NAME (type
) = (char *) name
;
8049 TYPE_TAG_NAME (type
) = TYPE_NAME (type
);
8051 return set_die_type (die
, type
, cu
);
8054 /* Read a C++ namespace. */
8057 read_namespace (struct die_info
*die
, struct dwarf2_cu
*cu
)
8059 struct objfile
*objfile
= cu
->objfile
;
8062 /* Add a symbol associated to this if we haven't seen the namespace
8063 before. Also, add a using directive if it's an anonymous
8066 if (dwarf2_attr (die
, DW_AT_extension
, cu
) == NULL
)
8070 type
= read_type_die (die
, cu
);
8071 new_symbol (die
, type
, cu
);
8073 namespace_name (die
, &is_anonymous
, cu
);
8076 const char *previous_prefix
= determine_prefix (die
, cu
);
8078 cp_add_using_directive (previous_prefix
, TYPE_NAME (type
), NULL
,
8079 NULL
, NULL
, &objfile
->objfile_obstack
);
8083 if (die
->child
!= NULL
)
8085 struct die_info
*child_die
= die
->child
;
8087 while (child_die
&& child_die
->tag
)
8089 process_die (child_die
, cu
);
8090 child_die
= sibling_die (child_die
);
8095 /* Read a Fortran module as type. This DIE can be only a declaration used for
8096 imported module. Still we need that type as local Fortran "use ... only"
8097 declaration imports depend on the created type in determine_prefix. */
8099 static struct type
*
8100 read_module_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
8102 struct objfile
*objfile
= cu
->objfile
;
8106 module_name
= dwarf2_name (die
, cu
);
8108 complaint (&symfile_complaints
,
8109 _("DW_TAG_module has no name, offset 0x%x"),
8111 type
= init_type (TYPE_CODE_MODULE
, 0, 0, module_name
, objfile
);
8113 /* determine_prefix uses TYPE_TAG_NAME. */
8114 TYPE_TAG_NAME (type
) = TYPE_NAME (type
);
8116 return set_die_type (die
, type
, cu
);
8119 /* Read a Fortran module. */
8122 read_module (struct die_info
*die
, struct dwarf2_cu
*cu
)
8124 struct die_info
*child_die
= die
->child
;
8126 while (child_die
&& child_die
->tag
)
8128 process_die (child_die
, cu
);
8129 child_die
= sibling_die (child_die
);
8133 /* Return the name of the namespace represented by DIE. Set
8134 *IS_ANONYMOUS to tell whether or not the namespace is an anonymous
8138 namespace_name (struct die_info
*die
, int *is_anonymous
, struct dwarf2_cu
*cu
)
8140 struct die_info
*current_die
;
8141 const char *name
= NULL
;
8143 /* Loop through the extensions until we find a name. */
8145 for (current_die
= die
;
8146 current_die
!= NULL
;
8147 current_die
= dwarf2_extension (die
, &cu
))
8149 name
= dwarf2_name (current_die
, cu
);
8154 /* Is it an anonymous namespace? */
8156 *is_anonymous
= (name
== NULL
);
8158 name
= CP_ANONYMOUS_NAMESPACE_STR
;
8163 /* Extract all information from a DW_TAG_pointer_type DIE and add to
8164 the user defined type vector. */
8166 static struct type
*
8167 read_tag_pointer_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
8169 struct gdbarch
*gdbarch
= get_objfile_arch (cu
->objfile
);
8170 struct comp_unit_head
*cu_header
= &cu
->header
;
8172 struct attribute
*attr_byte_size
;
8173 struct attribute
*attr_address_class
;
8174 int byte_size
, addr_class
;
8175 struct type
*target_type
;
8177 target_type
= die_type (die
, cu
);
8179 /* The die_type call above may have already set the type for this DIE. */
8180 type
= get_die_type (die
, cu
);
8184 type
= lookup_pointer_type (target_type
);
8186 attr_byte_size
= dwarf2_attr (die
, DW_AT_byte_size
, cu
);
8188 byte_size
= DW_UNSND (attr_byte_size
);
8190 byte_size
= cu_header
->addr_size
;
8192 attr_address_class
= dwarf2_attr (die
, DW_AT_address_class
, cu
);
8193 if (attr_address_class
)
8194 addr_class
= DW_UNSND (attr_address_class
);
8196 addr_class
= DW_ADDR_none
;
8198 /* If the pointer size or address class is different than the
8199 default, create a type variant marked as such and set the
8200 length accordingly. */
8201 if (TYPE_LENGTH (type
) != byte_size
|| addr_class
!= DW_ADDR_none
)
8203 if (gdbarch_address_class_type_flags_p (gdbarch
))
8207 type_flags
= gdbarch_address_class_type_flags
8208 (gdbarch
, byte_size
, addr_class
);
8209 gdb_assert ((type_flags
& ~TYPE_INSTANCE_FLAG_ADDRESS_CLASS_ALL
)
8211 type
= make_type_with_address_space (type
, type_flags
);
8213 else if (TYPE_LENGTH (type
) != byte_size
)
8215 complaint (&symfile_complaints
,
8216 _("invalid pointer size %d"), byte_size
);
8220 /* Should we also complain about unhandled address classes? */
8224 TYPE_LENGTH (type
) = byte_size
;
8225 return set_die_type (die
, type
, cu
);
8228 /* Extract all information from a DW_TAG_ptr_to_member_type DIE and add to
8229 the user defined type vector. */
8231 static struct type
*
8232 read_tag_ptr_to_member_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
8235 struct type
*to_type
;
8236 struct type
*domain
;
8238 to_type
= die_type (die
, cu
);
8239 domain
= die_containing_type (die
, cu
);
8241 /* The calls above may have already set the type for this DIE. */
8242 type
= get_die_type (die
, cu
);
8246 if (TYPE_CODE (check_typedef (to_type
)) == TYPE_CODE_METHOD
)
8247 type
= lookup_methodptr_type (to_type
);
8249 type
= lookup_memberptr_type (to_type
, domain
);
8251 return set_die_type (die
, type
, cu
);
8254 /* Extract all information from a DW_TAG_reference_type DIE and add to
8255 the user defined type vector. */
8257 static struct type
*
8258 read_tag_reference_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
8260 struct comp_unit_head
*cu_header
= &cu
->header
;
8261 struct type
*type
, *target_type
;
8262 struct attribute
*attr
;
8264 target_type
= die_type (die
, cu
);
8266 /* The die_type call above may have already set the type for this DIE. */
8267 type
= get_die_type (die
, cu
);
8271 type
= lookup_reference_type (target_type
);
8272 attr
= dwarf2_attr (die
, DW_AT_byte_size
, cu
);
8275 TYPE_LENGTH (type
) = DW_UNSND (attr
);
8279 TYPE_LENGTH (type
) = cu_header
->addr_size
;
8281 return set_die_type (die
, type
, cu
);
8284 static struct type
*
8285 read_tag_const_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
8287 struct type
*base_type
, *cv_type
;
8289 base_type
= die_type (die
, cu
);
8291 /* The die_type call above may have already set the type for this DIE. */
8292 cv_type
= get_die_type (die
, cu
);
8296 /* In case the const qualifier is applied to an array type, the element type
8297 is so qualified, not the array type (section 6.7.3 of C99). */
8298 if (TYPE_CODE (base_type
) == TYPE_CODE_ARRAY
)
8300 struct type
*el_type
, *inner_array
;
8302 base_type
= copy_type (base_type
);
8303 inner_array
= base_type
;
8305 while (TYPE_CODE (TYPE_TARGET_TYPE (inner_array
)) == TYPE_CODE_ARRAY
)
8307 TYPE_TARGET_TYPE (inner_array
) =
8308 copy_type (TYPE_TARGET_TYPE (inner_array
));
8309 inner_array
= TYPE_TARGET_TYPE (inner_array
);
8312 el_type
= TYPE_TARGET_TYPE (inner_array
);
8313 TYPE_TARGET_TYPE (inner_array
) =
8314 make_cv_type (1, TYPE_VOLATILE (el_type
), el_type
, NULL
);
8316 return set_die_type (die
, base_type
, cu
);
8319 cv_type
= make_cv_type (1, TYPE_VOLATILE (base_type
), base_type
, 0);
8320 return set_die_type (die
, cv_type
, cu
);
8323 static struct type
*
8324 read_tag_volatile_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
8326 struct type
*base_type
, *cv_type
;
8328 base_type
= die_type (die
, cu
);
8330 /* The die_type call above may have already set the type for this DIE. */
8331 cv_type
= get_die_type (die
, cu
);
8335 cv_type
= make_cv_type (TYPE_CONST (base_type
), 1, base_type
, 0);
8336 return set_die_type (die
, cv_type
, cu
);
8339 /* Extract all information from a DW_TAG_string_type DIE and add to
8340 the user defined type vector. It isn't really a user defined type,
8341 but it behaves like one, with other DIE's using an AT_user_def_type
8342 attribute to reference it. */
8344 static struct type
*
8345 read_tag_string_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
8347 struct objfile
*objfile
= cu
->objfile
;
8348 struct gdbarch
*gdbarch
= get_objfile_arch (objfile
);
8349 struct type
*type
, *range_type
, *index_type
, *char_type
;
8350 struct attribute
*attr
;
8351 unsigned int length
;
8353 attr
= dwarf2_attr (die
, DW_AT_string_length
, cu
);
8356 length
= DW_UNSND (attr
);
8360 /* Check for the DW_AT_byte_size attribute. */
8361 attr
= dwarf2_attr (die
, DW_AT_byte_size
, cu
);
8364 length
= DW_UNSND (attr
);
8372 index_type
= objfile_type (objfile
)->builtin_int
;
8373 range_type
= create_range_type (NULL
, index_type
, 1, length
);
8374 char_type
= language_string_char_type (cu
->language_defn
, gdbarch
);
8375 type
= create_string_type (NULL
, char_type
, range_type
);
8377 return set_die_type (die
, type
, cu
);
8380 /* Handle DIES due to C code like:
8384 int (*funcp)(int a, long l);
8388 ('funcp' generates a DW_TAG_subroutine_type DIE). */
8390 static struct type
*
8391 read_subroutine_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
8393 struct type
*type
; /* Type that this function returns. */
8394 struct type
*ftype
; /* Function that returns above type. */
8395 struct attribute
*attr
;
8397 type
= die_type (die
, cu
);
8399 /* The die_type call above may have already set the type for this DIE. */
8400 ftype
= get_die_type (die
, cu
);
8404 ftype
= lookup_function_type (type
);
8406 /* All functions in C++, Pascal and Java have prototypes. */
8407 attr
= dwarf2_attr (die
, DW_AT_prototyped
, cu
);
8408 if ((attr
&& (DW_UNSND (attr
) != 0))
8409 || cu
->language
== language_cplus
8410 || cu
->language
== language_java
8411 || cu
->language
== language_pascal
)
8412 TYPE_PROTOTYPED (ftype
) = 1;
8413 else if (producer_is_realview (cu
->producer
))
8414 /* RealView does not emit DW_AT_prototyped. We can not
8415 distinguish prototyped and unprototyped functions; default to
8416 prototyped, since that is more common in modern code (and
8417 RealView warns about unprototyped functions). */
8418 TYPE_PROTOTYPED (ftype
) = 1;
8420 /* Store the calling convention in the type if it's available in
8421 the subroutine die. Otherwise set the calling convention to
8422 the default value DW_CC_normal. */
8423 attr
= dwarf2_attr (die
, DW_AT_calling_convention
, cu
);
8425 TYPE_CALLING_CONVENTION (ftype
) = DW_UNSND (attr
);
8426 else if (cu
->producer
&& strstr (cu
->producer
, "IBM XL C for OpenCL"))
8427 TYPE_CALLING_CONVENTION (ftype
) = DW_CC_GDB_IBM_OpenCL
;
8429 TYPE_CALLING_CONVENTION (ftype
) = DW_CC_normal
;
8431 /* We need to add the subroutine type to the die immediately so
8432 we don't infinitely recurse when dealing with parameters
8433 declared as the same subroutine type. */
8434 set_die_type (die
, ftype
, cu
);
8436 if (die
->child
!= NULL
)
8438 struct type
*void_type
= objfile_type (cu
->objfile
)->builtin_void
;
8439 struct die_info
*child_die
;
8440 int nparams
, iparams
;
8442 /* Count the number of parameters.
8443 FIXME: GDB currently ignores vararg functions, but knows about
8444 vararg member functions. */
8446 child_die
= die
->child
;
8447 while (child_die
&& child_die
->tag
)
8449 if (child_die
->tag
== DW_TAG_formal_parameter
)
8451 else if (child_die
->tag
== DW_TAG_unspecified_parameters
)
8452 TYPE_VARARGS (ftype
) = 1;
8453 child_die
= sibling_die (child_die
);
8456 /* Allocate storage for parameters and fill them in. */
8457 TYPE_NFIELDS (ftype
) = nparams
;
8458 TYPE_FIELDS (ftype
) = (struct field
*)
8459 TYPE_ZALLOC (ftype
, nparams
* sizeof (struct field
));
8461 /* TYPE_FIELD_TYPE must never be NULL. Pre-fill the array to ensure it
8462 even if we error out during the parameters reading below. */
8463 for (iparams
= 0; iparams
< nparams
; iparams
++)
8464 TYPE_FIELD_TYPE (ftype
, iparams
) = void_type
;
8467 child_die
= die
->child
;
8468 while (child_die
&& child_die
->tag
)
8470 if (child_die
->tag
== DW_TAG_formal_parameter
)
8472 struct type
*arg_type
;
8474 /* DWARF version 2 has no clean way to discern C++
8475 static and non-static member functions. G++ helps
8476 GDB by marking the first parameter for non-static
8477 member functions (which is the this pointer) as
8478 artificial. We pass this information to
8479 dwarf2_add_member_fn via TYPE_FIELD_ARTIFICIAL.
8481 DWARF version 3 added DW_AT_object_pointer, which GCC
8482 4.5 does not yet generate. */
8483 attr
= dwarf2_attr (child_die
, DW_AT_artificial
, cu
);
8485 TYPE_FIELD_ARTIFICIAL (ftype
, iparams
) = DW_UNSND (attr
);
8488 TYPE_FIELD_ARTIFICIAL (ftype
, iparams
) = 0;
8490 /* GCC/43521: In java, the formal parameter
8491 "this" is sometimes not marked with DW_AT_artificial. */
8492 if (cu
->language
== language_java
)
8494 const char *name
= dwarf2_name (child_die
, cu
);
8496 if (name
&& !strcmp (name
, "this"))
8497 TYPE_FIELD_ARTIFICIAL (ftype
, iparams
) = 1;
8500 arg_type
= die_type (child_die
, cu
);
8502 /* RealView does not mark THIS as const, which the testsuite
8503 expects. GCC marks THIS as const in method definitions,
8504 but not in the class specifications (GCC PR 43053). */
8505 if (cu
->language
== language_cplus
&& !TYPE_CONST (arg_type
)
8506 && TYPE_FIELD_ARTIFICIAL (ftype
, iparams
))
8509 struct dwarf2_cu
*arg_cu
= cu
;
8510 const char *name
= dwarf2_name (child_die
, cu
);
8512 attr
= dwarf2_attr (die
, DW_AT_object_pointer
, cu
);
8515 /* If the compiler emits this, use it. */
8516 if (follow_die_ref (die
, attr
, &arg_cu
) == child_die
)
8519 else if (name
&& strcmp (name
, "this") == 0)
8520 /* Function definitions will have the argument names. */
8522 else if (name
== NULL
&& iparams
== 0)
8523 /* Declarations may not have the names, so like
8524 elsewhere in GDB, assume an artificial first
8525 argument is "this". */
8529 arg_type
= make_cv_type (1, TYPE_VOLATILE (arg_type
),
8533 TYPE_FIELD_TYPE (ftype
, iparams
) = arg_type
;
8536 child_die
= sibling_die (child_die
);
8543 static struct type
*
8544 read_typedef (struct die_info
*die
, struct dwarf2_cu
*cu
)
8546 struct objfile
*objfile
= cu
->objfile
;
8547 const char *name
= NULL
;
8548 struct type
*this_type
;
8550 name
= dwarf2_full_name (NULL
, die
, cu
);
8551 this_type
= init_type (TYPE_CODE_TYPEDEF
, 0,
8552 TYPE_FLAG_TARGET_STUB
, NULL
, objfile
);
8553 TYPE_NAME (this_type
) = (char *) name
;
8554 set_die_type (die
, this_type
, cu
);
8555 TYPE_TARGET_TYPE (this_type
) = die_type (die
, cu
);
8559 /* Find a representation of a given base type and install
8560 it in the TYPE field of the die. */
8562 static struct type
*
8563 read_base_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
8565 struct objfile
*objfile
= cu
->objfile
;
8567 struct attribute
*attr
;
8568 int encoding
= 0, size
= 0;
8570 enum type_code code
= TYPE_CODE_INT
;
8572 struct type
*target_type
= NULL
;
8574 attr
= dwarf2_attr (die
, DW_AT_encoding
, cu
);
8577 encoding
= DW_UNSND (attr
);
8579 attr
= dwarf2_attr (die
, DW_AT_byte_size
, cu
);
8582 size
= DW_UNSND (attr
);
8584 name
= dwarf2_name (die
, cu
);
8587 complaint (&symfile_complaints
,
8588 _("DW_AT_name missing from DW_TAG_base_type"));
8593 case DW_ATE_address
:
8594 /* Turn DW_ATE_address into a void * pointer. */
8595 code
= TYPE_CODE_PTR
;
8596 type_flags
|= TYPE_FLAG_UNSIGNED
;
8597 target_type
= init_type (TYPE_CODE_VOID
, 1, 0, NULL
, objfile
);
8599 case DW_ATE_boolean
:
8600 code
= TYPE_CODE_BOOL
;
8601 type_flags
|= TYPE_FLAG_UNSIGNED
;
8603 case DW_ATE_complex_float
:
8604 code
= TYPE_CODE_COMPLEX
;
8605 target_type
= init_type (TYPE_CODE_FLT
, size
/ 2, 0, NULL
, objfile
);
8607 case DW_ATE_decimal_float
:
8608 code
= TYPE_CODE_DECFLOAT
;
8611 code
= TYPE_CODE_FLT
;
8615 case DW_ATE_unsigned
:
8616 type_flags
|= TYPE_FLAG_UNSIGNED
;
8617 if (cu
->language
== language_fortran
8619 && strncmp (name
, "character(", sizeof ("character(") - 1) == 0)
8620 code
= TYPE_CODE_CHAR
;
8622 case DW_ATE_signed_char
:
8623 if (cu
->language
== language_ada
|| cu
->language
== language_m2
8624 || cu
->language
== language_pascal
8625 || cu
->language
== language_fortran
)
8626 code
= TYPE_CODE_CHAR
;
8628 case DW_ATE_unsigned_char
:
8629 if (cu
->language
== language_ada
|| cu
->language
== language_m2
8630 || cu
->language
== language_pascal
8631 || cu
->language
== language_fortran
)
8632 code
= TYPE_CODE_CHAR
;
8633 type_flags
|= TYPE_FLAG_UNSIGNED
;
8636 /* We just treat this as an integer and then recognize the
8637 type by name elsewhere. */
8641 complaint (&symfile_complaints
, _("unsupported DW_AT_encoding: '%s'"),
8642 dwarf_type_encoding_name (encoding
));
8646 type
= init_type (code
, size
, type_flags
, NULL
, objfile
);
8647 TYPE_NAME (type
) = name
;
8648 TYPE_TARGET_TYPE (type
) = target_type
;
8650 if (name
&& strcmp (name
, "char") == 0)
8651 TYPE_NOSIGN (type
) = 1;
8653 return set_die_type (die
, type
, cu
);
8656 /* Read the given DW_AT_subrange DIE. */
8658 static struct type
*
8659 read_subrange_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
8661 struct type
*base_type
;
8662 struct type
*range_type
;
8663 struct attribute
*attr
;
8667 LONGEST negative_mask
;
8669 base_type
= die_type (die
, cu
);
8670 /* Preserve BASE_TYPE's original type, just set its LENGTH. */
8671 check_typedef (base_type
);
8673 /* The die_type call above may have already set the type for this DIE. */
8674 range_type
= get_die_type (die
, cu
);
8678 if (cu
->language
== language_fortran
)
8680 /* FORTRAN implies a lower bound of 1, if not given. */
8684 /* FIXME: For variable sized arrays either of these could be
8685 a variable rather than a constant value. We'll allow it,
8686 but we don't know how to handle it. */
8687 attr
= dwarf2_attr (die
, DW_AT_lower_bound
, cu
);
8689 low
= dwarf2_get_attr_constant_value (attr
, 0);
8691 attr
= dwarf2_attr (die
, DW_AT_upper_bound
, cu
);
8694 if (attr_form_is_block (attr
) || is_ref_attr (attr
))
8696 /* GCC encodes arrays with unspecified or dynamic length
8697 with a DW_FORM_block1 attribute or a reference attribute.
8698 FIXME: GDB does not yet know how to handle dynamic
8699 arrays properly, treat them as arrays with unspecified
8702 FIXME: jimb/2003-09-22: GDB does not really know
8703 how to handle arrays of unspecified length
8704 either; we just represent them as zero-length
8705 arrays. Choose an appropriate upper bound given
8706 the lower bound we've computed above. */
8710 high
= dwarf2_get_attr_constant_value (attr
, 1);
8714 attr
= dwarf2_attr (die
, DW_AT_count
, cu
);
8717 int count
= dwarf2_get_attr_constant_value (attr
, 1);
8718 high
= low
+ count
- 1;
8722 /* Unspecified array length. */
8727 /* Dwarf-2 specifications explicitly allows to create subrange types
8728 without specifying a base type.
8729 In that case, the base type must be set to the type of
8730 the lower bound, upper bound or count, in that order, if any of these
8731 three attributes references an object that has a type.
8732 If no base type is found, the Dwarf-2 specifications say that
8733 a signed integer type of size equal to the size of an address should
8735 For the following C code: `extern char gdb_int [];'
8736 GCC produces an empty range DIE.
8737 FIXME: muller/2010-05-28: Possible references to object for low bound,
8738 high bound or count are not yet handled by this code. */
8739 if (TYPE_CODE (base_type
) == TYPE_CODE_VOID
)
8741 struct objfile
*objfile
= cu
->objfile
;
8742 struct gdbarch
*gdbarch
= get_objfile_arch (objfile
);
8743 int addr_size
= gdbarch_addr_bit (gdbarch
) /8;
8744 struct type
*int_type
= objfile_type (objfile
)->builtin_int
;
8746 /* Test "int", "long int", and "long long int" objfile types,
8747 and select the first one having a size above or equal to the
8748 architecture address size. */
8749 if (int_type
&& TYPE_LENGTH (int_type
) >= addr_size
)
8750 base_type
= int_type
;
8753 int_type
= objfile_type (objfile
)->builtin_long
;
8754 if (int_type
&& TYPE_LENGTH (int_type
) >= addr_size
)
8755 base_type
= int_type
;
8758 int_type
= objfile_type (objfile
)->builtin_long_long
;
8759 if (int_type
&& TYPE_LENGTH (int_type
) >= addr_size
)
8760 base_type
= int_type
;
8766 (LONGEST
) -1 << (TYPE_LENGTH (base_type
) * TARGET_CHAR_BIT
- 1);
8767 if (!TYPE_UNSIGNED (base_type
) && (low
& negative_mask
))
8768 low
|= negative_mask
;
8769 if (!TYPE_UNSIGNED (base_type
) && (high
& negative_mask
))
8770 high
|= negative_mask
;
8772 range_type
= create_range_type (NULL
, base_type
, low
, high
);
8774 /* Mark arrays with dynamic length at least as an array of unspecified
8775 length. GDB could check the boundary but before it gets implemented at
8776 least allow accessing the array elements. */
8777 if (attr
&& attr_form_is_block (attr
))
8778 TYPE_HIGH_BOUND_UNDEFINED (range_type
) = 1;
8780 /* Ada expects an empty array on no boundary attributes. */
8781 if (attr
== NULL
&& cu
->language
!= language_ada
)
8782 TYPE_HIGH_BOUND_UNDEFINED (range_type
) = 1;
8784 name
= dwarf2_name (die
, cu
);
8786 TYPE_NAME (range_type
) = name
;
8788 attr
= dwarf2_attr (die
, DW_AT_byte_size
, cu
);
8790 TYPE_LENGTH (range_type
) = DW_UNSND (attr
);
8792 set_die_type (die
, range_type
, cu
);
8794 /* set_die_type should be already done. */
8795 set_descriptive_type (range_type
, die
, cu
);
8800 static struct type
*
8801 read_unspecified_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
8805 /* For now, we only support the C meaning of an unspecified type: void. */
8807 type
= init_type (TYPE_CODE_VOID
, 0, 0, NULL
, cu
->objfile
);
8808 TYPE_NAME (type
) = dwarf2_name (die
, cu
);
8810 return set_die_type (die
, type
, cu
);
8813 /* Trivial hash function for die_info: the hash value of a DIE
8814 is its offset in .debug_info for this objfile. */
8817 die_hash (const void *item
)
8819 const struct die_info
*die
= item
;
8824 /* Trivial comparison function for die_info structures: two DIEs
8825 are equal if they have the same offset. */
8828 die_eq (const void *item_lhs
, const void *item_rhs
)
8830 const struct die_info
*die_lhs
= item_lhs
;
8831 const struct die_info
*die_rhs
= item_rhs
;
8833 return die_lhs
->offset
== die_rhs
->offset
;
8836 /* Read a whole compilation unit into a linked list of dies. */
8838 static struct die_info
*
8839 read_comp_unit (gdb_byte
*info_ptr
, struct dwarf2_cu
*cu
)
8841 struct die_reader_specs reader_specs
;
8842 int read_abbrevs
= 0;
8843 struct cleanup
*back_to
= NULL
;
8844 struct die_info
*die
;
8846 if (cu
->dwarf2_abbrevs
== NULL
)
8848 dwarf2_read_abbrevs (cu
->objfile
->obfd
, cu
);
8849 back_to
= make_cleanup (dwarf2_free_abbrev_table
, cu
);
8853 gdb_assert (cu
->die_hash
== NULL
);
8855 = htab_create_alloc_ex (cu
->header
.length
/ 12,
8859 &cu
->comp_unit_obstack
,
8860 hashtab_obstack_allocate
,
8861 dummy_obstack_deallocate
);
8863 init_cu_die_reader (&reader_specs
, cu
);
8865 die
= read_die_and_children (&reader_specs
, info_ptr
, &info_ptr
, NULL
);
8868 do_cleanups (back_to
);
8873 /* Main entry point for reading a DIE and all children.
8874 Read the DIE and dump it if requested. */
8876 static struct die_info
*
8877 read_die_and_children (const struct die_reader_specs
*reader
,
8879 gdb_byte
**new_info_ptr
,
8880 struct die_info
*parent
)
8882 struct die_info
*result
= read_die_and_children_1 (reader
, info_ptr
,
8883 new_info_ptr
, parent
);
8885 if (dwarf2_die_debug
)
8887 fprintf_unfiltered (gdb_stdlog
,
8888 "\nRead die from %s of %s:\n",
8889 (reader
->cu
->per_cu
->debug_type_section
8892 reader
->abfd
->filename
);
8893 dump_die (result
, dwarf2_die_debug
);
8899 /* Read a single die and all its descendents. Set the die's sibling
8900 field to NULL; set other fields in the die correctly, and set all
8901 of the descendents' fields correctly. Set *NEW_INFO_PTR to the
8902 location of the info_ptr after reading all of those dies. PARENT
8903 is the parent of the die in question. */
8905 static struct die_info
*
8906 read_die_and_children_1 (const struct die_reader_specs
*reader
,
8908 gdb_byte
**new_info_ptr
,
8909 struct die_info
*parent
)
8911 struct die_info
*die
;
8915 cur_ptr
= read_full_die (reader
, &die
, info_ptr
, &has_children
);
8918 *new_info_ptr
= cur_ptr
;
8921 store_in_ref_table (die
, reader
->cu
);
8924 die
->child
= read_die_and_siblings (reader
, cur_ptr
, new_info_ptr
, die
);
8928 *new_info_ptr
= cur_ptr
;
8931 die
->sibling
= NULL
;
8932 die
->parent
= parent
;
8936 /* Read a die, all of its descendents, and all of its siblings; set
8937 all of the fields of all of the dies correctly. Arguments are as
8938 in read_die_and_children. */
8940 static struct die_info
*
8941 read_die_and_siblings (const struct die_reader_specs
*reader
,
8943 gdb_byte
**new_info_ptr
,
8944 struct die_info
*parent
)
8946 struct die_info
*first_die
, *last_sibling
;
8950 first_die
= last_sibling
= NULL
;
8954 struct die_info
*die
8955 = read_die_and_children_1 (reader
, cur_ptr
, &cur_ptr
, parent
);
8959 *new_info_ptr
= cur_ptr
;
8966 last_sibling
->sibling
= die
;
8972 /* Read the die from the .debug_info section buffer. Set DIEP to
8973 point to a newly allocated die with its information, except for its
8974 child, sibling, and parent fields. Set HAS_CHILDREN to tell
8975 whether the die has children or not. */
8978 read_full_die (const struct die_reader_specs
*reader
,
8979 struct die_info
**diep
, gdb_byte
*info_ptr
,
8982 unsigned int abbrev_number
, bytes_read
, i
, offset
;
8983 struct abbrev_info
*abbrev
;
8984 struct die_info
*die
;
8985 struct dwarf2_cu
*cu
= reader
->cu
;
8986 bfd
*abfd
= reader
->abfd
;
8988 offset
= info_ptr
- reader
->buffer
;
8989 abbrev_number
= read_unsigned_leb128 (abfd
, info_ptr
, &bytes_read
);
8990 info_ptr
+= bytes_read
;
8998 abbrev
= dwarf2_lookup_abbrev (abbrev_number
, cu
);
9000 error (_("Dwarf Error: could not find abbrev number %d [in module %s]"),
9002 bfd_get_filename (abfd
));
9004 die
= dwarf_alloc_die (cu
, abbrev
->num_attrs
);
9005 die
->offset
= offset
;
9006 die
->tag
= abbrev
->tag
;
9007 die
->abbrev
= abbrev_number
;
9009 die
->num_attrs
= abbrev
->num_attrs
;
9011 for (i
= 0; i
< abbrev
->num_attrs
; ++i
)
9012 info_ptr
= read_attribute (&die
->attrs
[i
], &abbrev
->attrs
[i
],
9013 abfd
, info_ptr
, cu
);
9016 *has_children
= abbrev
->has_children
;
9020 /* In DWARF version 2, the description of the debugging information is
9021 stored in a separate .debug_abbrev section. Before we read any
9022 dies from a section we read in all abbreviations and install them
9023 in a hash table. This function also sets flags in CU describing
9024 the data found in the abbrev table. */
9027 dwarf2_read_abbrevs (bfd
*abfd
, struct dwarf2_cu
*cu
)
9029 struct comp_unit_head
*cu_header
= &cu
->header
;
9030 gdb_byte
*abbrev_ptr
;
9031 struct abbrev_info
*cur_abbrev
;
9032 unsigned int abbrev_number
, bytes_read
, abbrev_name
;
9033 unsigned int abbrev_form
, hash_number
;
9034 struct attr_abbrev
*cur_attrs
;
9035 unsigned int allocated_attrs
;
9037 /* Initialize dwarf2 abbrevs. */
9038 obstack_init (&cu
->abbrev_obstack
);
9039 cu
->dwarf2_abbrevs
= obstack_alloc (&cu
->abbrev_obstack
,
9041 * sizeof (struct abbrev_info
*)));
9042 memset (cu
->dwarf2_abbrevs
, 0,
9043 ABBREV_HASH_SIZE
* sizeof (struct abbrev_info
*));
9045 dwarf2_read_section (dwarf2_per_objfile
->objfile
,
9046 &dwarf2_per_objfile
->abbrev
);
9047 abbrev_ptr
= dwarf2_per_objfile
->abbrev
.buffer
+ cu_header
->abbrev_offset
;
9048 abbrev_number
= read_unsigned_leb128 (abfd
, abbrev_ptr
, &bytes_read
);
9049 abbrev_ptr
+= bytes_read
;
9051 allocated_attrs
= ATTR_ALLOC_CHUNK
;
9052 cur_attrs
= xmalloc (allocated_attrs
* sizeof (struct attr_abbrev
));
9054 /* Loop until we reach an abbrev number of 0. */
9055 while (abbrev_number
)
9057 cur_abbrev
= dwarf_alloc_abbrev (cu
);
9059 /* read in abbrev header */
9060 cur_abbrev
->number
= abbrev_number
;
9061 cur_abbrev
->tag
= read_unsigned_leb128 (abfd
, abbrev_ptr
, &bytes_read
);
9062 abbrev_ptr
+= bytes_read
;
9063 cur_abbrev
->has_children
= read_1_byte (abfd
, abbrev_ptr
);
9066 if (cur_abbrev
->tag
== DW_TAG_namespace
)
9067 cu
->has_namespace_info
= 1;
9069 /* now read in declarations */
9070 abbrev_name
= read_unsigned_leb128 (abfd
, abbrev_ptr
, &bytes_read
);
9071 abbrev_ptr
+= bytes_read
;
9072 abbrev_form
= read_unsigned_leb128 (abfd
, abbrev_ptr
, &bytes_read
);
9073 abbrev_ptr
+= bytes_read
;
9076 if (cur_abbrev
->num_attrs
== allocated_attrs
)
9078 allocated_attrs
+= ATTR_ALLOC_CHUNK
;
9080 = xrealloc (cur_attrs
, (allocated_attrs
9081 * sizeof (struct attr_abbrev
)));
9084 /* Record whether this compilation unit might have
9085 inter-compilation-unit references. If we don't know what form
9086 this attribute will have, then it might potentially be a
9087 DW_FORM_ref_addr, so we conservatively expect inter-CU
9090 if (abbrev_form
== DW_FORM_ref_addr
9091 || abbrev_form
== DW_FORM_indirect
)
9092 cu
->has_form_ref_addr
= 1;
9094 cur_attrs
[cur_abbrev
->num_attrs
].name
= abbrev_name
;
9095 cur_attrs
[cur_abbrev
->num_attrs
++].form
= abbrev_form
;
9096 abbrev_name
= read_unsigned_leb128 (abfd
, abbrev_ptr
, &bytes_read
);
9097 abbrev_ptr
+= bytes_read
;
9098 abbrev_form
= read_unsigned_leb128 (abfd
, abbrev_ptr
, &bytes_read
);
9099 abbrev_ptr
+= bytes_read
;
9102 cur_abbrev
->attrs
= obstack_alloc (&cu
->abbrev_obstack
,
9103 (cur_abbrev
->num_attrs
9104 * sizeof (struct attr_abbrev
)));
9105 memcpy (cur_abbrev
->attrs
, cur_attrs
,
9106 cur_abbrev
->num_attrs
* sizeof (struct attr_abbrev
));
9108 hash_number
= abbrev_number
% ABBREV_HASH_SIZE
;
9109 cur_abbrev
->next
= cu
->dwarf2_abbrevs
[hash_number
];
9110 cu
->dwarf2_abbrevs
[hash_number
] = cur_abbrev
;
9112 /* Get next abbreviation.
9113 Under Irix6 the abbreviations for a compilation unit are not
9114 always properly terminated with an abbrev number of 0.
9115 Exit loop if we encounter an abbreviation which we have
9116 already read (which means we are about to read the abbreviations
9117 for the next compile unit) or if the end of the abbreviation
9118 table is reached. */
9119 if ((unsigned int) (abbrev_ptr
- dwarf2_per_objfile
->abbrev
.buffer
)
9120 >= dwarf2_per_objfile
->abbrev
.size
)
9122 abbrev_number
= read_unsigned_leb128 (abfd
, abbrev_ptr
, &bytes_read
);
9123 abbrev_ptr
+= bytes_read
;
9124 if (dwarf2_lookup_abbrev (abbrev_number
, cu
) != NULL
)
9131 /* Release the memory used by the abbrev table for a compilation unit. */
9134 dwarf2_free_abbrev_table (void *ptr_to_cu
)
9136 struct dwarf2_cu
*cu
= ptr_to_cu
;
9138 obstack_free (&cu
->abbrev_obstack
, NULL
);
9139 cu
->dwarf2_abbrevs
= NULL
;
9142 /* Lookup an abbrev_info structure in the abbrev hash table. */
9144 static struct abbrev_info
*
9145 dwarf2_lookup_abbrev (unsigned int number
, struct dwarf2_cu
*cu
)
9147 unsigned int hash_number
;
9148 struct abbrev_info
*abbrev
;
9150 hash_number
= number
% ABBREV_HASH_SIZE
;
9151 abbrev
= cu
->dwarf2_abbrevs
[hash_number
];
9155 if (abbrev
->number
== number
)
9158 abbrev
= abbrev
->next
;
9163 /* Returns nonzero if TAG represents a type that we might generate a partial
9167 is_type_tag_for_partial (int tag
)
9172 /* Some types that would be reasonable to generate partial symbols for,
9173 that we don't at present. */
9174 case DW_TAG_array_type
:
9175 case DW_TAG_file_type
:
9176 case DW_TAG_ptr_to_member_type
:
9177 case DW_TAG_set_type
:
9178 case DW_TAG_string_type
:
9179 case DW_TAG_subroutine_type
:
9181 case DW_TAG_base_type
:
9182 case DW_TAG_class_type
:
9183 case DW_TAG_interface_type
:
9184 case DW_TAG_enumeration_type
:
9185 case DW_TAG_structure_type
:
9186 case DW_TAG_subrange_type
:
9187 case DW_TAG_typedef
:
9188 case DW_TAG_union_type
:
9195 /* Load all DIEs that are interesting for partial symbols into memory. */
9197 static struct partial_die_info
*
9198 load_partial_dies (bfd
*abfd
, gdb_byte
*buffer
, gdb_byte
*info_ptr
,
9199 int building_psymtab
, struct dwarf2_cu
*cu
)
9201 struct partial_die_info
*part_die
;
9202 struct partial_die_info
*parent_die
, *last_die
, *first_die
= NULL
;
9203 struct abbrev_info
*abbrev
;
9204 unsigned int bytes_read
;
9205 unsigned int load_all
= 0;
9207 int nesting_level
= 1;
9212 if (cu
->per_cu
&& cu
->per_cu
->load_all_dies
)
9216 = htab_create_alloc_ex (cu
->header
.length
/ 12,
9220 &cu
->comp_unit_obstack
,
9221 hashtab_obstack_allocate
,
9222 dummy_obstack_deallocate
);
9224 part_die
= obstack_alloc (&cu
->comp_unit_obstack
,
9225 sizeof (struct partial_die_info
));
9229 abbrev
= peek_die_abbrev (info_ptr
, &bytes_read
, cu
);
9231 /* A NULL abbrev means the end of a series of children. */
9234 if (--nesting_level
== 0)
9236 /* PART_DIE was probably the last thing allocated on the
9237 comp_unit_obstack, so we could call obstack_free
9238 here. We don't do that because the waste is small,
9239 and will be cleaned up when we're done with this
9240 compilation unit. This way, we're also more robust
9241 against other users of the comp_unit_obstack. */
9244 info_ptr
+= bytes_read
;
9245 last_die
= parent_die
;
9246 parent_die
= parent_die
->die_parent
;
9250 /* Check for template arguments. We never save these; if
9251 they're seen, we just mark the parent, and go on our way. */
9252 if (parent_die
!= NULL
9253 && cu
->language
== language_cplus
9254 && (abbrev
->tag
== DW_TAG_template_type_param
9255 || abbrev
->tag
== DW_TAG_template_value_param
))
9257 parent_die
->has_template_arguments
= 1;
9261 /* We don't need a partial DIE for the template argument. */
9262 info_ptr
= skip_one_die (buffer
, info_ptr
+ bytes_read
, abbrev
,
9268 /* We only recurse into subprograms looking for template arguments.
9269 Skip their other children. */
9271 && cu
->language
== language_cplus
9272 && parent_die
!= NULL
9273 && parent_die
->tag
== DW_TAG_subprogram
)
9275 info_ptr
= skip_one_die (buffer
, info_ptr
+ bytes_read
, abbrev
, cu
);
9279 /* Check whether this DIE is interesting enough to save. Normally
9280 we would not be interested in members here, but there may be
9281 later variables referencing them via DW_AT_specification (for
9284 && !is_type_tag_for_partial (abbrev
->tag
)
9285 && abbrev
->tag
!= DW_TAG_constant
9286 && abbrev
->tag
!= DW_TAG_enumerator
9287 && abbrev
->tag
!= DW_TAG_subprogram
9288 && abbrev
->tag
!= DW_TAG_lexical_block
9289 && abbrev
->tag
!= DW_TAG_variable
9290 && abbrev
->tag
!= DW_TAG_namespace
9291 && abbrev
->tag
!= DW_TAG_module
9292 && abbrev
->tag
!= DW_TAG_member
)
9294 /* Otherwise we skip to the next sibling, if any. */
9295 info_ptr
= skip_one_die (buffer
, info_ptr
+ bytes_read
, abbrev
, cu
);
9299 info_ptr
= read_partial_die (part_die
, abbrev
, bytes_read
, abfd
,
9300 buffer
, info_ptr
, cu
);
9302 /* This two-pass algorithm for processing partial symbols has a
9303 high cost in cache pressure. Thus, handle some simple cases
9304 here which cover the majority of C partial symbols. DIEs
9305 which neither have specification tags in them, nor could have
9306 specification tags elsewhere pointing at them, can simply be
9307 processed and discarded.
9309 This segment is also optional; scan_partial_symbols and
9310 add_partial_symbol will handle these DIEs if we chain
9311 them in normally. When compilers which do not emit large
9312 quantities of duplicate debug information are more common,
9313 this code can probably be removed. */
9315 /* Any complete simple types at the top level (pretty much all
9316 of them, for a language without namespaces), can be processed
9318 if (parent_die
== NULL
9319 && part_die
->has_specification
== 0
9320 && part_die
->is_declaration
== 0
9321 && ((part_die
->tag
== DW_TAG_typedef
&& !part_die
->has_children
)
9322 || part_die
->tag
== DW_TAG_base_type
9323 || part_die
->tag
== DW_TAG_subrange_type
))
9325 if (building_psymtab
&& part_die
->name
!= NULL
)
9326 add_psymbol_to_list (part_die
->name
, strlen (part_die
->name
), 0,
9327 VAR_DOMAIN
, LOC_TYPEDEF
,
9328 &cu
->objfile
->static_psymbols
,
9329 0, (CORE_ADDR
) 0, cu
->language
, cu
->objfile
);
9330 info_ptr
= locate_pdi_sibling (part_die
, buffer
, info_ptr
, abfd
, cu
);
9334 /* The exception for DW_TAG_typedef with has_children above is
9335 a workaround of GCC PR debug/47510. In the case of this complaint
9336 type_name_no_tag_or_error will error on such types later.
9338 GDB skipped children of DW_TAG_typedef by the shortcut above and then
9339 it could not find the child DIEs referenced later, this is checked
9340 above. In correct DWARF DW_TAG_typedef should have no children. */
9342 if (part_die
->tag
== DW_TAG_typedef
&& part_die
->has_children
)
9343 complaint (&symfile_complaints
,
9344 _("DW_TAG_typedef has childen - GCC PR debug/47510 bug "
9345 "- DIE at 0x%x [in module %s]"),
9346 part_die
->offset
, cu
->objfile
->name
);
9348 /* If we're at the second level, and we're an enumerator, and
9349 our parent has no specification (meaning possibly lives in a
9350 namespace elsewhere), then we can add the partial symbol now
9351 instead of queueing it. */
9352 if (part_die
->tag
== DW_TAG_enumerator
9353 && parent_die
!= NULL
9354 && parent_die
->die_parent
== NULL
9355 && parent_die
->tag
== DW_TAG_enumeration_type
9356 && parent_die
->has_specification
== 0)
9358 if (part_die
->name
== NULL
)
9359 complaint (&symfile_complaints
,
9360 _("malformed enumerator DIE ignored"));
9361 else if (building_psymtab
)
9362 add_psymbol_to_list (part_die
->name
, strlen (part_die
->name
), 0,
9363 VAR_DOMAIN
, LOC_CONST
,
9364 (cu
->language
== language_cplus
9365 || cu
->language
== language_java
)
9366 ? &cu
->objfile
->global_psymbols
9367 : &cu
->objfile
->static_psymbols
,
9368 0, (CORE_ADDR
) 0, cu
->language
, cu
->objfile
);
9370 info_ptr
= locate_pdi_sibling (part_die
, buffer
, info_ptr
, abfd
, cu
);
9374 /* We'll save this DIE so link it in. */
9375 part_die
->die_parent
= parent_die
;
9376 part_die
->die_sibling
= NULL
;
9377 part_die
->die_child
= NULL
;
9379 if (last_die
&& last_die
== parent_die
)
9380 last_die
->die_child
= part_die
;
9382 last_die
->die_sibling
= part_die
;
9384 last_die
= part_die
;
9386 if (first_die
== NULL
)
9387 first_die
= part_die
;
9389 /* Maybe add the DIE to the hash table. Not all DIEs that we
9390 find interesting need to be in the hash table, because we
9391 also have the parent/sibling/child chains; only those that we
9392 might refer to by offset later during partial symbol reading.
9394 For now this means things that might have be the target of a
9395 DW_AT_specification, DW_AT_abstract_origin, or
9396 DW_AT_extension. DW_AT_extension will refer only to
9397 namespaces; DW_AT_abstract_origin refers to functions (and
9398 many things under the function DIE, but we do not recurse
9399 into function DIEs during partial symbol reading) and
9400 possibly variables as well; DW_AT_specification refers to
9401 declarations. Declarations ought to have the DW_AT_declaration
9402 flag. It happens that GCC forgets to put it in sometimes, but
9403 only for functions, not for types.
9405 Adding more things than necessary to the hash table is harmless
9406 except for the performance cost. Adding too few will result in
9407 wasted time in find_partial_die, when we reread the compilation
9408 unit with load_all_dies set. */
9411 || abbrev
->tag
== DW_TAG_constant
9412 || abbrev
->tag
== DW_TAG_subprogram
9413 || abbrev
->tag
== DW_TAG_variable
9414 || abbrev
->tag
== DW_TAG_namespace
9415 || part_die
->is_declaration
)
9419 slot
= htab_find_slot_with_hash (cu
->partial_dies
, part_die
,
9420 part_die
->offset
, INSERT
);
9424 part_die
= obstack_alloc (&cu
->comp_unit_obstack
,
9425 sizeof (struct partial_die_info
));
9427 /* For some DIEs we want to follow their children (if any). For C
9428 we have no reason to follow the children of structures; for other
9429 languages we have to, so that we can get at method physnames
9430 to infer fully qualified class names, for DW_AT_specification,
9431 and for C++ template arguments. For C++, we also look one level
9432 inside functions to find template arguments (if the name of the
9433 function does not already contain the template arguments).
9435 For Ada, we need to scan the children of subprograms and lexical
9436 blocks as well because Ada allows the definition of nested
9437 entities that could be interesting for the debugger, such as
9438 nested subprograms for instance. */
9439 if (last_die
->has_children
9441 || last_die
->tag
== DW_TAG_namespace
9442 || last_die
->tag
== DW_TAG_module
9443 || last_die
->tag
== DW_TAG_enumeration_type
9444 || (cu
->language
== language_cplus
9445 && last_die
->tag
== DW_TAG_subprogram
9446 && (last_die
->name
== NULL
9447 || strchr (last_die
->name
, '<') == NULL
))
9448 || (cu
->language
!= language_c
9449 && (last_die
->tag
== DW_TAG_class_type
9450 || last_die
->tag
== DW_TAG_interface_type
9451 || last_die
->tag
== DW_TAG_structure_type
9452 || last_die
->tag
== DW_TAG_union_type
))
9453 || (cu
->language
== language_ada
9454 && (last_die
->tag
== DW_TAG_subprogram
9455 || last_die
->tag
== DW_TAG_lexical_block
))))
9458 parent_die
= last_die
;
9462 /* Otherwise we skip to the next sibling, if any. */
9463 info_ptr
= locate_pdi_sibling (last_die
, buffer
, info_ptr
, abfd
, cu
);
9465 /* Back to the top, do it again. */
9469 /* Read a minimal amount of information into the minimal die structure. */
9472 read_partial_die (struct partial_die_info
*part_die
,
9473 struct abbrev_info
*abbrev
,
9474 unsigned int abbrev_len
, bfd
*abfd
,
9475 gdb_byte
*buffer
, gdb_byte
*info_ptr
,
9476 struct dwarf2_cu
*cu
)
9479 struct attribute attr
;
9480 int has_low_pc_attr
= 0;
9481 int has_high_pc_attr
= 0;
9483 memset (part_die
, 0, sizeof (struct partial_die_info
));
9485 part_die
->offset
= info_ptr
- buffer
;
9487 info_ptr
+= abbrev_len
;
9492 part_die
->tag
= abbrev
->tag
;
9493 part_die
->has_children
= abbrev
->has_children
;
9495 for (i
= 0; i
< abbrev
->num_attrs
; ++i
)
9497 info_ptr
= read_attribute (&attr
, &abbrev
->attrs
[i
], abfd
, info_ptr
, cu
);
9499 /* Store the data if it is of an attribute we want to keep in a
9500 partial symbol table. */
9504 switch (part_die
->tag
)
9506 case DW_TAG_compile_unit
:
9507 case DW_TAG_type_unit
:
9508 /* Compilation units have a DW_AT_name that is a filename, not
9509 a source language identifier. */
9510 case DW_TAG_enumeration_type
:
9511 case DW_TAG_enumerator
:
9512 /* These tags always have simple identifiers already; no need
9513 to canonicalize them. */
9514 part_die
->name
= DW_STRING (&attr
);
9518 = dwarf2_canonicalize_name (DW_STRING (&attr
), cu
,
9519 &cu
->objfile
->objfile_obstack
);
9523 case DW_AT_linkage_name
:
9524 case DW_AT_MIPS_linkage_name
:
9525 /* Note that both forms of linkage name might appear. We
9526 assume they will be the same, and we only store the last
9528 if (cu
->language
== language_ada
)
9529 part_die
->name
= DW_STRING (&attr
);
9530 part_die
->linkage_name
= DW_STRING (&attr
);
9533 has_low_pc_attr
= 1;
9534 part_die
->lowpc
= DW_ADDR (&attr
);
9537 has_high_pc_attr
= 1;
9538 part_die
->highpc
= DW_ADDR (&attr
);
9540 case DW_AT_location
:
9541 /* Support the .debug_loc offsets. */
9542 if (attr_form_is_block (&attr
))
9544 part_die
->locdesc
= DW_BLOCK (&attr
);
9546 else if (attr_form_is_section_offset (&attr
))
9548 dwarf2_complex_location_expr_complaint ();
9552 dwarf2_invalid_attrib_class_complaint ("DW_AT_location",
9553 "partial symbol information");
9556 case DW_AT_external
:
9557 part_die
->is_external
= DW_UNSND (&attr
);
9559 case DW_AT_declaration
:
9560 part_die
->is_declaration
= DW_UNSND (&attr
);
9563 part_die
->has_type
= 1;
9565 case DW_AT_abstract_origin
:
9566 case DW_AT_specification
:
9567 case DW_AT_extension
:
9568 part_die
->has_specification
= 1;
9569 part_die
->spec_offset
= dwarf2_get_ref_die_offset (&attr
);
9572 /* Ignore absolute siblings, they might point outside of
9573 the current compile unit. */
9574 if (attr
.form
== DW_FORM_ref_addr
)
9575 complaint (&symfile_complaints
,
9576 _("ignoring absolute DW_AT_sibling"));
9578 part_die
->sibling
= buffer
+ dwarf2_get_ref_die_offset (&attr
);
9580 case DW_AT_byte_size
:
9581 part_die
->has_byte_size
= 1;
9583 case DW_AT_calling_convention
:
9584 /* DWARF doesn't provide a way to identify a program's source-level
9585 entry point. DW_AT_calling_convention attributes are only meant
9586 to describe functions' calling conventions.
9588 However, because it's a necessary piece of information in
9589 Fortran, and because DW_CC_program is the only piece of debugging
9590 information whose definition refers to a 'main program' at all,
9591 several compilers have begun marking Fortran main programs with
9592 DW_CC_program --- even when those functions use the standard
9593 calling conventions.
9595 So until DWARF specifies a way to provide this information and
9596 compilers pick up the new representation, we'll support this
9598 if (DW_UNSND (&attr
) == DW_CC_program
9599 && cu
->language
== language_fortran
)
9601 set_main_name (part_die
->name
);
9603 /* As this DIE has a static linkage the name would be difficult
9604 to look up later. */
9605 language_of_main
= language_fortran
;
9613 if (has_low_pc_attr
&& has_high_pc_attr
)
9615 /* When using the GNU linker, .gnu.linkonce. sections are used to
9616 eliminate duplicate copies of functions and vtables and such.
9617 The linker will arbitrarily choose one and discard the others.
9618 The AT_*_pc values for such functions refer to local labels in
9619 these sections. If the section from that file was discarded, the
9620 labels are not in the output, so the relocs get a value of 0.
9621 If this is a discarded function, mark the pc bounds as invalid,
9622 so that GDB will ignore it. */
9623 if (part_die
->lowpc
== 0 && !dwarf2_per_objfile
->has_section_at_zero
)
9625 struct gdbarch
*gdbarch
= get_objfile_arch (cu
->objfile
);
9627 complaint (&symfile_complaints
,
9628 _("DW_AT_low_pc %s is zero "
9629 "for DIE at 0x%x [in module %s]"),
9630 paddress (gdbarch
, part_die
->lowpc
),
9631 part_die
->offset
, cu
->objfile
->name
);
9633 /* dwarf2_get_pc_bounds has also the strict low < high requirement. */
9634 else if (part_die
->lowpc
>= part_die
->highpc
)
9636 struct gdbarch
*gdbarch
= get_objfile_arch (cu
->objfile
);
9638 complaint (&symfile_complaints
,
9639 _("DW_AT_low_pc %s is not < DW_AT_high_pc %s "
9640 "for DIE at 0x%x [in module %s]"),
9641 paddress (gdbarch
, part_die
->lowpc
),
9642 paddress (gdbarch
, part_die
->highpc
),
9643 part_die
->offset
, cu
->objfile
->name
);
9646 part_die
->has_pc_info
= 1;
9652 /* Find a cached partial DIE at OFFSET in CU. */
9654 static struct partial_die_info
*
9655 find_partial_die_in_comp_unit (unsigned int offset
, struct dwarf2_cu
*cu
)
9657 struct partial_die_info
*lookup_die
= NULL
;
9658 struct partial_die_info part_die
;
9660 part_die
.offset
= offset
;
9661 lookup_die
= htab_find_with_hash (cu
->partial_dies
, &part_die
, offset
);
9666 /* Find a partial DIE at OFFSET, which may or may not be in CU,
9667 except in the case of .debug_types DIEs which do not reference
9668 outside their CU (they do however referencing other types via
9669 DW_FORM_ref_sig8). */
9671 static struct partial_die_info
*
9672 find_partial_die (unsigned int offset
, struct dwarf2_cu
*cu
)
9674 struct dwarf2_per_cu_data
*per_cu
= NULL
;
9675 struct partial_die_info
*pd
= NULL
;
9677 if (cu
->per_cu
->debug_type_section
)
9679 pd
= find_partial_die_in_comp_unit (offset
, cu
);
9685 if (offset_in_cu_p (&cu
->header
, offset
))
9687 pd
= find_partial_die_in_comp_unit (offset
, cu
);
9692 per_cu
= dwarf2_find_containing_comp_unit (offset
, cu
->objfile
);
9694 if (per_cu
->cu
== NULL
|| per_cu
->cu
->partial_dies
== NULL
)
9695 load_partial_comp_unit (per_cu
, cu
->objfile
);
9697 per_cu
->cu
->last_used
= 0;
9698 pd
= find_partial_die_in_comp_unit (offset
, per_cu
->cu
);
9700 if (pd
== NULL
&& per_cu
->load_all_dies
== 0)
9702 struct cleanup
*back_to
;
9703 struct partial_die_info comp_unit_die
;
9704 struct abbrev_info
*abbrev
;
9705 unsigned int bytes_read
;
9708 per_cu
->load_all_dies
= 1;
9710 /* Re-read the DIEs. */
9711 back_to
= make_cleanup (null_cleanup
, 0);
9712 if (per_cu
->cu
->dwarf2_abbrevs
== NULL
)
9714 dwarf2_read_abbrevs (per_cu
->cu
->objfile
->obfd
, per_cu
->cu
);
9715 make_cleanup (dwarf2_free_abbrev_table
, per_cu
->cu
);
9717 info_ptr
= (dwarf2_per_objfile
->info
.buffer
9718 + per_cu
->cu
->header
.offset
9719 + per_cu
->cu
->header
.first_die_offset
);
9720 abbrev
= peek_die_abbrev (info_ptr
, &bytes_read
, per_cu
->cu
);
9721 info_ptr
= read_partial_die (&comp_unit_die
, abbrev
, bytes_read
,
9722 per_cu
->cu
->objfile
->obfd
,
9723 dwarf2_per_objfile
->info
.buffer
, info_ptr
,
9725 if (comp_unit_die
.has_children
)
9726 load_partial_dies (per_cu
->cu
->objfile
->obfd
,
9727 dwarf2_per_objfile
->info
.buffer
, info_ptr
,
9729 do_cleanups (back_to
);
9731 pd
= find_partial_die_in_comp_unit (offset
, per_cu
->cu
);
9737 internal_error (__FILE__
, __LINE__
,
9738 _("could not find partial DIE 0x%x "
9739 "in cache [from module %s]\n"),
9740 offset
, bfd_get_filename (cu
->objfile
->obfd
));
9744 /* See if we can figure out if the class lives in a namespace. We do
9745 this by looking for a member function; its demangled name will
9746 contain namespace info, if there is any. */
9749 guess_partial_die_structure_name (struct partial_die_info
*struct_pdi
,
9750 struct dwarf2_cu
*cu
)
9752 /* NOTE: carlton/2003-10-07: Getting the info this way changes
9753 what template types look like, because the demangler
9754 frequently doesn't give the same name as the debug info. We
9755 could fix this by only using the demangled name to get the
9756 prefix (but see comment in read_structure_type). */
9758 struct partial_die_info
*real_pdi
;
9759 struct partial_die_info
*child_pdi
;
9761 /* If this DIE (this DIE's specification, if any) has a parent, then
9762 we should not do this. We'll prepend the parent's fully qualified
9763 name when we create the partial symbol. */
9765 real_pdi
= struct_pdi
;
9766 while (real_pdi
->has_specification
)
9767 real_pdi
= find_partial_die (real_pdi
->spec_offset
, cu
);
9769 if (real_pdi
->die_parent
!= NULL
)
9772 for (child_pdi
= struct_pdi
->die_child
;
9774 child_pdi
= child_pdi
->die_sibling
)
9776 if (child_pdi
->tag
== DW_TAG_subprogram
9777 && child_pdi
->linkage_name
!= NULL
)
9779 char *actual_class_name
9780 = language_class_name_from_physname (cu
->language_defn
,
9781 child_pdi
->linkage_name
);
9782 if (actual_class_name
!= NULL
)
9785 = obsavestring (actual_class_name
,
9786 strlen (actual_class_name
),
9787 &cu
->objfile
->objfile_obstack
);
9788 xfree (actual_class_name
);
9795 /* Adjust PART_DIE before generating a symbol for it. This function
9796 may set the is_external flag or change the DIE's name. */
9799 fixup_partial_die (struct partial_die_info
*part_die
,
9800 struct dwarf2_cu
*cu
)
9802 /* Once we've fixed up a die, there's no point in doing so again.
9803 This also avoids a memory leak if we were to call
9804 guess_partial_die_structure_name multiple times. */
9805 if (part_die
->fixup_called
)
9808 /* If we found a reference attribute and the DIE has no name, try
9809 to find a name in the referred to DIE. */
9811 if (part_die
->name
== NULL
&& part_die
->has_specification
)
9813 struct partial_die_info
*spec_die
;
9815 spec_die
= find_partial_die (part_die
->spec_offset
, cu
);
9817 fixup_partial_die (spec_die
, cu
);
9821 part_die
->name
= spec_die
->name
;
9823 /* Copy DW_AT_external attribute if it is set. */
9824 if (spec_die
->is_external
)
9825 part_die
->is_external
= spec_die
->is_external
;
9829 /* Set default names for some unnamed DIEs. */
9831 if (part_die
->name
== NULL
&& part_die
->tag
== DW_TAG_namespace
)
9832 part_die
->name
= CP_ANONYMOUS_NAMESPACE_STR
;
9834 /* If there is no parent die to provide a namespace, and there are
9835 children, see if we can determine the namespace from their linkage
9837 NOTE: We need to do this even if cu->has_namespace_info != 0.
9838 gcc-4.5 -gdwarf-4 can drop the enclosing namespace. */
9839 if (cu
->language
== language_cplus
9840 && !VEC_empty (dwarf2_section_info_def
, dwarf2_per_objfile
->types
)
9841 && part_die
->die_parent
== NULL
9842 && part_die
->has_children
9843 && (part_die
->tag
== DW_TAG_class_type
9844 || part_die
->tag
== DW_TAG_structure_type
9845 || part_die
->tag
== DW_TAG_union_type
))
9846 guess_partial_die_structure_name (part_die
, cu
);
9848 /* GCC might emit a nameless struct or union that has a linkage
9849 name. See http://gcc.gnu.org/bugzilla/show_bug.cgi?id=47510. */
9850 if (part_die
->name
== NULL
9851 && (part_die
->tag
== DW_TAG_structure_type
9852 || part_die
->tag
== DW_TAG_union_type
9853 || part_die
->tag
== DW_TAG_class_type
)
9854 && part_die
->linkage_name
!= NULL
)
9858 demangled
= cplus_demangle (part_die
->linkage_name
, DMGL_TYPES
);
9861 part_die
->name
= obsavestring (demangled
, strlen (demangled
),
9862 &cu
->objfile
->objfile_obstack
);
9867 part_die
->fixup_called
= 1;
9870 /* Read an attribute value described by an attribute form. */
9873 read_attribute_value (struct attribute
*attr
, unsigned form
,
9874 bfd
*abfd
, gdb_byte
*info_ptr
,
9875 struct dwarf2_cu
*cu
)
9877 struct comp_unit_head
*cu_header
= &cu
->header
;
9878 unsigned int bytes_read
;
9879 struct dwarf_block
*blk
;
9884 case DW_FORM_ref_addr
:
9885 if (cu
->header
.version
== 2)
9886 DW_ADDR (attr
) = read_address (abfd
, info_ptr
, cu
, &bytes_read
);
9888 DW_ADDR (attr
) = read_offset (abfd
, info_ptr
,
9889 &cu
->header
, &bytes_read
);
9890 info_ptr
+= bytes_read
;
9893 DW_ADDR (attr
) = read_address (abfd
, info_ptr
, cu
, &bytes_read
);
9894 info_ptr
+= bytes_read
;
9896 case DW_FORM_block2
:
9897 blk
= dwarf_alloc_block (cu
);
9898 blk
->size
= read_2_bytes (abfd
, info_ptr
);
9900 blk
->data
= read_n_bytes (abfd
, info_ptr
, blk
->size
);
9901 info_ptr
+= blk
->size
;
9902 DW_BLOCK (attr
) = blk
;
9904 case DW_FORM_block4
:
9905 blk
= dwarf_alloc_block (cu
);
9906 blk
->size
= read_4_bytes (abfd
, info_ptr
);
9908 blk
->data
= read_n_bytes (abfd
, info_ptr
, blk
->size
);
9909 info_ptr
+= blk
->size
;
9910 DW_BLOCK (attr
) = blk
;
9913 DW_UNSND (attr
) = read_2_bytes (abfd
, info_ptr
);
9917 DW_UNSND (attr
) = read_4_bytes (abfd
, info_ptr
);
9921 DW_UNSND (attr
) = read_8_bytes (abfd
, info_ptr
);
9924 case DW_FORM_sec_offset
:
9925 DW_UNSND (attr
) = read_offset (abfd
, info_ptr
, &cu
->header
, &bytes_read
);
9926 info_ptr
+= bytes_read
;
9928 case DW_FORM_string
:
9929 DW_STRING (attr
) = read_direct_string (abfd
, info_ptr
, &bytes_read
);
9930 DW_STRING_IS_CANONICAL (attr
) = 0;
9931 info_ptr
+= bytes_read
;
9934 DW_STRING (attr
) = read_indirect_string (abfd
, info_ptr
, cu_header
,
9936 DW_STRING_IS_CANONICAL (attr
) = 0;
9937 info_ptr
+= bytes_read
;
9939 case DW_FORM_exprloc
:
9941 blk
= dwarf_alloc_block (cu
);
9942 blk
->size
= read_unsigned_leb128 (abfd
, info_ptr
, &bytes_read
);
9943 info_ptr
+= bytes_read
;
9944 blk
->data
= read_n_bytes (abfd
, info_ptr
, blk
->size
);
9945 info_ptr
+= blk
->size
;
9946 DW_BLOCK (attr
) = blk
;
9948 case DW_FORM_block1
:
9949 blk
= dwarf_alloc_block (cu
);
9950 blk
->size
= read_1_byte (abfd
, info_ptr
);
9952 blk
->data
= read_n_bytes (abfd
, info_ptr
, blk
->size
);
9953 info_ptr
+= blk
->size
;
9954 DW_BLOCK (attr
) = blk
;
9957 DW_UNSND (attr
) = read_1_byte (abfd
, info_ptr
);
9961 DW_UNSND (attr
) = read_1_byte (abfd
, info_ptr
);
9964 case DW_FORM_flag_present
:
9965 DW_UNSND (attr
) = 1;
9968 DW_SND (attr
) = read_signed_leb128 (abfd
, info_ptr
, &bytes_read
);
9969 info_ptr
+= bytes_read
;
9972 DW_UNSND (attr
) = read_unsigned_leb128 (abfd
, info_ptr
, &bytes_read
);
9973 info_ptr
+= bytes_read
;
9976 DW_ADDR (attr
) = cu
->header
.offset
+ read_1_byte (abfd
, info_ptr
);
9980 DW_ADDR (attr
) = cu
->header
.offset
+ read_2_bytes (abfd
, info_ptr
);
9984 DW_ADDR (attr
) = cu
->header
.offset
+ read_4_bytes (abfd
, info_ptr
);
9988 DW_ADDR (attr
) = cu
->header
.offset
+ read_8_bytes (abfd
, info_ptr
);
9991 case DW_FORM_ref_sig8
:
9992 /* Convert the signature to something we can record in DW_UNSND
9994 NOTE: This is NULL if the type wasn't found. */
9995 DW_SIGNATURED_TYPE (attr
) =
9996 lookup_signatured_type (cu
->objfile
, read_8_bytes (abfd
, info_ptr
));
9999 case DW_FORM_ref_udata
:
10000 DW_ADDR (attr
) = (cu
->header
.offset
10001 + read_unsigned_leb128 (abfd
, info_ptr
, &bytes_read
));
10002 info_ptr
+= bytes_read
;
10004 case DW_FORM_indirect
:
10005 form
= read_unsigned_leb128 (abfd
, info_ptr
, &bytes_read
);
10006 info_ptr
+= bytes_read
;
10007 info_ptr
= read_attribute_value (attr
, form
, abfd
, info_ptr
, cu
);
10010 error (_("Dwarf Error: Cannot handle %s in DWARF reader [in module %s]"),
10011 dwarf_form_name (form
),
10012 bfd_get_filename (abfd
));
10015 /* We have seen instances where the compiler tried to emit a byte
10016 size attribute of -1 which ended up being encoded as an unsigned
10017 0xffffffff. Although 0xffffffff is technically a valid size value,
10018 an object of this size seems pretty unlikely so we can relatively
10019 safely treat these cases as if the size attribute was invalid and
10020 treat them as zero by default. */
10021 if (attr
->name
== DW_AT_byte_size
10022 && form
== DW_FORM_data4
10023 && DW_UNSND (attr
) >= 0xffffffff)
10026 (&symfile_complaints
,
10027 _("Suspicious DW_AT_byte_size value treated as zero instead of %s"),
10028 hex_string (DW_UNSND (attr
)));
10029 DW_UNSND (attr
) = 0;
10035 /* Read an attribute described by an abbreviated attribute. */
10038 read_attribute (struct attribute
*attr
, struct attr_abbrev
*abbrev
,
10039 bfd
*abfd
, gdb_byte
*info_ptr
, struct dwarf2_cu
*cu
)
10041 attr
->name
= abbrev
->name
;
10042 return read_attribute_value (attr
, abbrev
->form
, abfd
, info_ptr
, cu
);
10045 /* Read dwarf information from a buffer. */
10047 static unsigned int
10048 read_1_byte (bfd
*abfd
, gdb_byte
*buf
)
10050 return bfd_get_8 (abfd
, buf
);
10054 read_1_signed_byte (bfd
*abfd
, gdb_byte
*buf
)
10056 return bfd_get_signed_8 (abfd
, buf
);
10059 static unsigned int
10060 read_2_bytes (bfd
*abfd
, gdb_byte
*buf
)
10062 return bfd_get_16 (abfd
, buf
);
10065 static unsigned int
10066 read_4_bytes (bfd
*abfd
, gdb_byte
*buf
)
10068 return bfd_get_32 (abfd
, buf
);
10072 read_8_bytes (bfd
*abfd
, gdb_byte
*buf
)
10074 return bfd_get_64 (abfd
, buf
);
10078 read_address (bfd
*abfd
, gdb_byte
*buf
, struct dwarf2_cu
*cu
,
10079 unsigned int *bytes_read
)
10081 struct comp_unit_head
*cu_header
= &cu
->header
;
10082 CORE_ADDR retval
= 0;
10084 if (cu_header
->signed_addr_p
)
10086 switch (cu_header
->addr_size
)
10089 retval
= bfd_get_signed_16 (abfd
, buf
);
10092 retval
= bfd_get_signed_32 (abfd
, buf
);
10095 retval
= bfd_get_signed_64 (abfd
, buf
);
10098 internal_error (__FILE__
, __LINE__
,
10099 _("read_address: bad switch, signed [in module %s]"),
10100 bfd_get_filename (abfd
));
10105 switch (cu_header
->addr_size
)
10108 retval
= bfd_get_16 (abfd
, buf
);
10111 retval
= bfd_get_32 (abfd
, buf
);
10114 retval
= bfd_get_64 (abfd
, buf
);
10117 internal_error (__FILE__
, __LINE__
,
10118 _("read_address: bad switch, "
10119 "unsigned [in module %s]"),
10120 bfd_get_filename (abfd
));
10124 *bytes_read
= cu_header
->addr_size
;
10128 /* Read the initial length from a section. The (draft) DWARF 3
10129 specification allows the initial length to take up either 4 bytes
10130 or 12 bytes. If the first 4 bytes are 0xffffffff, then the next 8
10131 bytes describe the length and all offsets will be 8 bytes in length
10134 An older, non-standard 64-bit format is also handled by this
10135 function. The older format in question stores the initial length
10136 as an 8-byte quantity without an escape value. Lengths greater
10137 than 2^32 aren't very common which means that the initial 4 bytes
10138 is almost always zero. Since a length value of zero doesn't make
10139 sense for the 32-bit format, this initial zero can be considered to
10140 be an escape value which indicates the presence of the older 64-bit
10141 format. As written, the code can't detect (old format) lengths
10142 greater than 4GB. If it becomes necessary to handle lengths
10143 somewhat larger than 4GB, we could allow other small values (such
10144 as the non-sensical values of 1, 2, and 3) to also be used as
10145 escape values indicating the presence of the old format.
10147 The value returned via bytes_read should be used to increment the
10148 relevant pointer after calling read_initial_length().
10150 [ Note: read_initial_length() and read_offset() are based on the
10151 document entitled "DWARF Debugging Information Format", revision
10152 3, draft 8, dated November 19, 2001. This document was obtained
10155 http://reality.sgiweb.org/davea/dwarf3-draft8-011125.pdf
10157 This document is only a draft and is subject to change. (So beware.)
10159 Details regarding the older, non-standard 64-bit format were
10160 determined empirically by examining 64-bit ELF files produced by
10161 the SGI toolchain on an IRIX 6.5 machine.
10163 - Kevin, July 16, 2002
10167 read_initial_length (bfd
*abfd
, gdb_byte
*buf
, unsigned int *bytes_read
)
10169 LONGEST length
= bfd_get_32 (abfd
, buf
);
10171 if (length
== 0xffffffff)
10173 length
= bfd_get_64 (abfd
, buf
+ 4);
10176 else if (length
== 0)
10178 /* Handle the (non-standard) 64-bit DWARF2 format used by IRIX. */
10179 length
= bfd_get_64 (abfd
, buf
);
10190 /* Cover function for read_initial_length.
10191 Returns the length of the object at BUF, and stores the size of the
10192 initial length in *BYTES_READ and stores the size that offsets will be in
10194 If the initial length size is not equivalent to that specified in
10195 CU_HEADER then issue a complaint.
10196 This is useful when reading non-comp-unit headers. */
10199 read_checked_initial_length_and_offset (bfd
*abfd
, gdb_byte
*buf
,
10200 const struct comp_unit_head
*cu_header
,
10201 unsigned int *bytes_read
,
10202 unsigned int *offset_size
)
10204 LONGEST length
= read_initial_length (abfd
, buf
, bytes_read
);
10206 gdb_assert (cu_header
->initial_length_size
== 4
10207 || cu_header
->initial_length_size
== 8
10208 || cu_header
->initial_length_size
== 12);
10210 if (cu_header
->initial_length_size
!= *bytes_read
)
10211 complaint (&symfile_complaints
,
10212 _("intermixed 32-bit and 64-bit DWARF sections"));
10214 *offset_size
= (*bytes_read
== 4) ? 4 : 8;
10218 /* Read an offset from the data stream. The size of the offset is
10219 given by cu_header->offset_size. */
10222 read_offset (bfd
*abfd
, gdb_byte
*buf
, const struct comp_unit_head
*cu_header
,
10223 unsigned int *bytes_read
)
10225 LONGEST offset
= read_offset_1 (abfd
, buf
, cu_header
->offset_size
);
10227 *bytes_read
= cu_header
->offset_size
;
10231 /* Read an offset from the data stream. */
10234 read_offset_1 (bfd
*abfd
, gdb_byte
*buf
, unsigned int offset_size
)
10236 LONGEST retval
= 0;
10238 switch (offset_size
)
10241 retval
= bfd_get_32 (abfd
, buf
);
10244 retval
= bfd_get_64 (abfd
, buf
);
10247 internal_error (__FILE__
, __LINE__
,
10248 _("read_offset_1: bad switch [in module %s]"),
10249 bfd_get_filename (abfd
));
10256 read_n_bytes (bfd
*abfd
, gdb_byte
*buf
, unsigned int size
)
10258 /* If the size of a host char is 8 bits, we can return a pointer
10259 to the buffer, otherwise we have to copy the data to a buffer
10260 allocated on the temporary obstack. */
10261 gdb_assert (HOST_CHAR_BIT
== 8);
10266 read_direct_string (bfd
*abfd
, gdb_byte
*buf
, unsigned int *bytes_read_ptr
)
10268 /* If the size of a host char is 8 bits, we can return a pointer
10269 to the string, otherwise we have to copy the string to a buffer
10270 allocated on the temporary obstack. */
10271 gdb_assert (HOST_CHAR_BIT
== 8);
10274 *bytes_read_ptr
= 1;
10277 *bytes_read_ptr
= strlen ((char *) buf
) + 1;
10278 return (char *) buf
;
10282 read_indirect_string_at_offset (bfd
*abfd
, LONGEST str_offset
)
10284 dwarf2_read_section (dwarf2_per_objfile
->objfile
, &dwarf2_per_objfile
->str
);
10285 if (dwarf2_per_objfile
->str
.buffer
== NULL
)
10286 error (_("DW_FORM_strp used without .debug_str section [in module %s]"),
10287 bfd_get_filename (abfd
));
10288 if (str_offset
>= dwarf2_per_objfile
->str
.size
)
10289 error (_("DW_FORM_strp pointing outside of "
10290 ".debug_str section [in module %s]"),
10291 bfd_get_filename (abfd
));
10292 gdb_assert (HOST_CHAR_BIT
== 8);
10293 if (dwarf2_per_objfile
->str
.buffer
[str_offset
] == '\0')
10295 return (char *) (dwarf2_per_objfile
->str
.buffer
+ str_offset
);
10299 read_indirect_string (bfd
*abfd
, gdb_byte
*buf
,
10300 const struct comp_unit_head
*cu_header
,
10301 unsigned int *bytes_read_ptr
)
10303 LONGEST str_offset
= read_offset (abfd
, buf
, cu_header
, bytes_read_ptr
);
10305 return read_indirect_string_at_offset (abfd
, str_offset
);
10308 static unsigned long
10309 read_unsigned_leb128 (bfd
*abfd
, gdb_byte
*buf
, unsigned int *bytes_read_ptr
)
10311 unsigned long result
;
10312 unsigned int num_read
;
10314 unsigned char byte
;
10322 byte
= bfd_get_8 (abfd
, buf
);
10325 result
|= ((unsigned long)(byte
& 127) << shift
);
10326 if ((byte
& 128) == 0)
10332 *bytes_read_ptr
= num_read
;
10337 read_signed_leb128 (bfd
*abfd
, gdb_byte
*buf
, unsigned int *bytes_read_ptr
)
10340 int i
, shift
, num_read
;
10341 unsigned char byte
;
10349 byte
= bfd_get_8 (abfd
, buf
);
10352 result
|= ((long)(byte
& 127) << shift
);
10354 if ((byte
& 128) == 0)
10359 if ((shift
< 8 * sizeof (result
)) && (byte
& 0x40))
10360 result
|= -(((long)1) << shift
);
10361 *bytes_read_ptr
= num_read
;
10365 /* Return a pointer to just past the end of an LEB128 number in BUF. */
10368 skip_leb128 (bfd
*abfd
, gdb_byte
*buf
)
10374 byte
= bfd_get_8 (abfd
, buf
);
10376 if ((byte
& 128) == 0)
10382 set_cu_language (unsigned int lang
, struct dwarf2_cu
*cu
)
10389 cu
->language
= language_c
;
10391 case DW_LANG_C_plus_plus
:
10392 cu
->language
= language_cplus
;
10395 cu
->language
= language_d
;
10397 case DW_LANG_Fortran77
:
10398 case DW_LANG_Fortran90
:
10399 case DW_LANG_Fortran95
:
10400 cu
->language
= language_fortran
;
10402 case DW_LANG_Mips_Assembler
:
10403 cu
->language
= language_asm
;
10406 cu
->language
= language_java
;
10408 case DW_LANG_Ada83
:
10409 case DW_LANG_Ada95
:
10410 cu
->language
= language_ada
;
10412 case DW_LANG_Modula2
:
10413 cu
->language
= language_m2
;
10415 case DW_LANG_Pascal83
:
10416 cu
->language
= language_pascal
;
10419 cu
->language
= language_objc
;
10421 case DW_LANG_Cobol74
:
10422 case DW_LANG_Cobol85
:
10424 cu
->language
= language_minimal
;
10427 cu
->language_defn
= language_def (cu
->language
);
10430 /* Return the named attribute or NULL if not there. */
10432 static struct attribute
*
10433 dwarf2_attr (struct die_info
*die
, unsigned int name
, struct dwarf2_cu
*cu
)
10436 struct attribute
*spec
= NULL
;
10438 for (i
= 0; i
< die
->num_attrs
; ++i
)
10440 if (die
->attrs
[i
].name
== name
)
10441 return &die
->attrs
[i
];
10442 if (die
->attrs
[i
].name
== DW_AT_specification
10443 || die
->attrs
[i
].name
== DW_AT_abstract_origin
)
10444 spec
= &die
->attrs
[i
];
10449 die
= follow_die_ref (die
, spec
, &cu
);
10450 return dwarf2_attr (die
, name
, cu
);
10456 /* Return the named attribute or NULL if not there,
10457 but do not follow DW_AT_specification, etc.
10458 This is for use in contexts where we're reading .debug_types dies.
10459 Following DW_AT_specification, DW_AT_abstract_origin will take us
10460 back up the chain, and we want to go down. */
10462 static struct attribute
*
10463 dwarf2_attr_no_follow (struct die_info
*die
, unsigned int name
,
10464 struct dwarf2_cu
*cu
)
10468 for (i
= 0; i
< die
->num_attrs
; ++i
)
10469 if (die
->attrs
[i
].name
== name
)
10470 return &die
->attrs
[i
];
10475 /* Return non-zero iff the attribute NAME is defined for the given DIE,
10476 and holds a non-zero value. This function should only be used for
10477 DW_FORM_flag or DW_FORM_flag_present attributes. */
10480 dwarf2_flag_true_p (struct die_info
*die
, unsigned name
, struct dwarf2_cu
*cu
)
10482 struct attribute
*attr
= dwarf2_attr (die
, name
, cu
);
10484 return (attr
&& DW_UNSND (attr
));
10488 die_is_declaration (struct die_info
*die
, struct dwarf2_cu
*cu
)
10490 /* A DIE is a declaration if it has a DW_AT_declaration attribute
10491 which value is non-zero. However, we have to be careful with
10492 DIEs having a DW_AT_specification attribute, because dwarf2_attr()
10493 (via dwarf2_flag_true_p) follows this attribute. So we may
10494 end up accidently finding a declaration attribute that belongs
10495 to a different DIE referenced by the specification attribute,
10496 even though the given DIE does not have a declaration attribute. */
10497 return (dwarf2_flag_true_p (die
, DW_AT_declaration
, cu
)
10498 && dwarf2_attr (die
, DW_AT_specification
, cu
) == NULL
);
10501 /* Return the die giving the specification for DIE, if there is
10502 one. *SPEC_CU is the CU containing DIE on input, and the CU
10503 containing the return value on output. If there is no
10504 specification, but there is an abstract origin, that is
10507 static struct die_info
*
10508 die_specification (struct die_info
*die
, struct dwarf2_cu
**spec_cu
)
10510 struct attribute
*spec_attr
= dwarf2_attr (die
, DW_AT_specification
,
10513 if (spec_attr
== NULL
)
10514 spec_attr
= dwarf2_attr (die
, DW_AT_abstract_origin
, *spec_cu
);
10516 if (spec_attr
== NULL
)
10519 return follow_die_ref (die
, spec_attr
, spec_cu
);
10522 /* Free the line_header structure *LH, and any arrays and strings it
10524 NOTE: This is also used as a "cleanup" function. */
10527 free_line_header (struct line_header
*lh
)
10529 if (lh
->standard_opcode_lengths
)
10530 xfree (lh
->standard_opcode_lengths
);
10532 /* Remember that all the lh->file_names[i].name pointers are
10533 pointers into debug_line_buffer, and don't need to be freed. */
10534 if (lh
->file_names
)
10535 xfree (lh
->file_names
);
10537 /* Similarly for the include directory names. */
10538 if (lh
->include_dirs
)
10539 xfree (lh
->include_dirs
);
10544 /* Add an entry to LH's include directory table. */
10547 add_include_dir (struct line_header
*lh
, char *include_dir
)
10549 /* Grow the array if necessary. */
10550 if (lh
->include_dirs_size
== 0)
10552 lh
->include_dirs_size
= 1; /* for testing */
10553 lh
->include_dirs
= xmalloc (lh
->include_dirs_size
10554 * sizeof (*lh
->include_dirs
));
10556 else if (lh
->num_include_dirs
>= lh
->include_dirs_size
)
10558 lh
->include_dirs_size
*= 2;
10559 lh
->include_dirs
= xrealloc (lh
->include_dirs
,
10560 (lh
->include_dirs_size
10561 * sizeof (*lh
->include_dirs
)));
10564 lh
->include_dirs
[lh
->num_include_dirs
++] = include_dir
;
10567 /* Add an entry to LH's file name table. */
10570 add_file_name (struct line_header
*lh
,
10572 unsigned int dir_index
,
10573 unsigned int mod_time
,
10574 unsigned int length
)
10576 struct file_entry
*fe
;
10578 /* Grow the array if necessary. */
10579 if (lh
->file_names_size
== 0)
10581 lh
->file_names_size
= 1; /* for testing */
10582 lh
->file_names
= xmalloc (lh
->file_names_size
10583 * sizeof (*lh
->file_names
));
10585 else if (lh
->num_file_names
>= lh
->file_names_size
)
10587 lh
->file_names_size
*= 2;
10588 lh
->file_names
= xrealloc (lh
->file_names
,
10589 (lh
->file_names_size
10590 * sizeof (*lh
->file_names
)));
10593 fe
= &lh
->file_names
[lh
->num_file_names
++];
10595 fe
->dir_index
= dir_index
;
10596 fe
->mod_time
= mod_time
;
10597 fe
->length
= length
;
10598 fe
->included_p
= 0;
10602 /* Read the statement program header starting at OFFSET in
10603 .debug_line, according to the endianness of ABFD. Return a pointer
10604 to a struct line_header, allocated using xmalloc.
10606 NOTE: the strings in the include directory and file name tables of
10607 the returned object point into debug_line_buffer, and must not be
10610 static struct line_header
*
10611 dwarf_decode_line_header (unsigned int offset
, bfd
*abfd
,
10612 struct dwarf2_cu
*cu
)
10614 struct cleanup
*back_to
;
10615 struct line_header
*lh
;
10616 gdb_byte
*line_ptr
;
10617 unsigned int bytes_read
, offset_size
;
10619 char *cur_dir
, *cur_file
;
10621 dwarf2_read_section (dwarf2_per_objfile
->objfile
, &dwarf2_per_objfile
->line
);
10622 if (dwarf2_per_objfile
->line
.buffer
== NULL
)
10624 complaint (&symfile_complaints
, _("missing .debug_line section"));
10628 /* Make sure that at least there's room for the total_length field.
10629 That could be 12 bytes long, but we're just going to fudge that. */
10630 if (offset
+ 4 >= dwarf2_per_objfile
->line
.size
)
10632 dwarf2_statement_list_fits_in_line_number_section_complaint ();
10636 lh
= xmalloc (sizeof (*lh
));
10637 memset (lh
, 0, sizeof (*lh
));
10638 back_to
= make_cleanup ((make_cleanup_ftype
*) free_line_header
,
10641 line_ptr
= dwarf2_per_objfile
->line
.buffer
+ offset
;
10643 /* Read in the header. */
10645 read_checked_initial_length_and_offset (abfd
, line_ptr
, &cu
->header
,
10646 &bytes_read
, &offset_size
);
10647 line_ptr
+= bytes_read
;
10648 if (line_ptr
+ lh
->total_length
> (dwarf2_per_objfile
->line
.buffer
10649 + dwarf2_per_objfile
->line
.size
))
10651 dwarf2_statement_list_fits_in_line_number_section_complaint ();
10654 lh
->statement_program_end
= line_ptr
+ lh
->total_length
;
10655 lh
->version
= read_2_bytes (abfd
, line_ptr
);
10657 lh
->header_length
= read_offset_1 (abfd
, line_ptr
, offset_size
);
10658 line_ptr
+= offset_size
;
10659 lh
->minimum_instruction_length
= read_1_byte (abfd
, line_ptr
);
10661 if (lh
->version
>= 4)
10663 lh
->maximum_ops_per_instruction
= read_1_byte (abfd
, line_ptr
);
10667 lh
->maximum_ops_per_instruction
= 1;
10669 if (lh
->maximum_ops_per_instruction
== 0)
10671 lh
->maximum_ops_per_instruction
= 1;
10672 complaint (&symfile_complaints
,
10673 _("invalid maximum_ops_per_instruction "
10674 "in `.debug_line' section"));
10677 lh
->default_is_stmt
= read_1_byte (abfd
, line_ptr
);
10679 lh
->line_base
= read_1_signed_byte (abfd
, line_ptr
);
10681 lh
->line_range
= read_1_byte (abfd
, line_ptr
);
10683 lh
->opcode_base
= read_1_byte (abfd
, line_ptr
);
10685 lh
->standard_opcode_lengths
10686 = xmalloc (lh
->opcode_base
* sizeof (lh
->standard_opcode_lengths
[0]));
10688 lh
->standard_opcode_lengths
[0] = 1; /* This should never be used anyway. */
10689 for (i
= 1; i
< lh
->opcode_base
; ++i
)
10691 lh
->standard_opcode_lengths
[i
] = read_1_byte (abfd
, line_ptr
);
10695 /* Read directory table. */
10696 while ((cur_dir
= read_direct_string (abfd
, line_ptr
, &bytes_read
)) != NULL
)
10698 line_ptr
+= bytes_read
;
10699 add_include_dir (lh
, cur_dir
);
10701 line_ptr
+= bytes_read
;
10703 /* Read file name table. */
10704 while ((cur_file
= read_direct_string (abfd
, line_ptr
, &bytes_read
)) != NULL
)
10706 unsigned int dir_index
, mod_time
, length
;
10708 line_ptr
+= bytes_read
;
10709 dir_index
= read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
10710 line_ptr
+= bytes_read
;
10711 mod_time
= read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
10712 line_ptr
+= bytes_read
;
10713 length
= read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
10714 line_ptr
+= bytes_read
;
10716 add_file_name (lh
, cur_file
, dir_index
, mod_time
, length
);
10718 line_ptr
+= bytes_read
;
10719 lh
->statement_program_start
= line_ptr
;
10721 if (line_ptr
> (dwarf2_per_objfile
->line
.buffer
10722 + dwarf2_per_objfile
->line
.size
))
10723 complaint (&symfile_complaints
,
10724 _("line number info header doesn't "
10725 "fit in `.debug_line' section"));
10727 discard_cleanups (back_to
);
10731 /* This function exists to work around a bug in certain compilers
10732 (particularly GCC 2.95), in which the first line number marker of a
10733 function does not show up until after the prologue, right before
10734 the second line number marker. This function shifts ADDRESS down
10735 to the beginning of the function if necessary, and is called on
10736 addresses passed to record_line. */
10739 check_cu_functions (CORE_ADDR address
, struct dwarf2_cu
*cu
)
10741 struct function_range
*fn
;
10743 /* Find the function_range containing address. */
10747 if (!cu
->cached_fn
)
10748 cu
->cached_fn
= cu
->first_fn
;
10750 fn
= cu
->cached_fn
;
10752 if (fn
->lowpc
<= address
&& fn
->highpc
> address
)
10758 while (fn
&& fn
!= cu
->cached_fn
)
10759 if (fn
->lowpc
<= address
&& fn
->highpc
> address
)
10769 if (address
!= fn
->lowpc
)
10770 complaint (&symfile_complaints
,
10771 _("misplaced first line number at 0x%lx for '%s'"),
10772 (unsigned long) address
, fn
->name
);
10777 /* Subroutine of dwarf_decode_lines to simplify it.
10778 Return the file name of the psymtab for included file FILE_INDEX
10779 in line header LH of PST.
10780 COMP_DIR is the compilation directory (DW_AT_comp_dir) or NULL if unknown.
10781 If space for the result is malloc'd, it will be freed by a cleanup.
10782 Returns NULL if FILE_INDEX should be ignored, i.e., it is pst->filename. */
10785 psymtab_include_file_name (const struct line_header
*lh
, int file_index
,
10786 const struct partial_symtab
*pst
,
10787 const char *comp_dir
)
10789 const struct file_entry fe
= lh
->file_names
[file_index
];
10790 char *include_name
= fe
.name
;
10791 char *include_name_to_compare
= include_name
;
10792 char *dir_name
= NULL
;
10793 const char *pst_filename
;
10794 char *copied_name
= NULL
;
10798 dir_name
= lh
->include_dirs
[fe
.dir_index
- 1];
10800 if (!IS_ABSOLUTE_PATH (include_name
)
10801 && (dir_name
!= NULL
|| comp_dir
!= NULL
))
10803 /* Avoid creating a duplicate psymtab for PST.
10804 We do this by comparing INCLUDE_NAME and PST_FILENAME.
10805 Before we do the comparison, however, we need to account
10806 for DIR_NAME and COMP_DIR.
10807 First prepend dir_name (if non-NULL). If we still don't
10808 have an absolute path prepend comp_dir (if non-NULL).
10809 However, the directory we record in the include-file's
10810 psymtab does not contain COMP_DIR (to match the
10811 corresponding symtab(s)).
10816 bash$ gcc -g ./hello.c
10817 include_name = "hello.c"
10819 DW_AT_comp_dir = comp_dir = "/tmp"
10820 DW_AT_name = "./hello.c" */
10822 if (dir_name
!= NULL
)
10824 include_name
= concat (dir_name
, SLASH_STRING
,
10825 include_name
, (char *)NULL
);
10826 include_name_to_compare
= include_name
;
10827 make_cleanup (xfree
, include_name
);
10829 if (!IS_ABSOLUTE_PATH (include_name
) && comp_dir
!= NULL
)
10831 include_name_to_compare
= concat (comp_dir
, SLASH_STRING
,
10832 include_name
, (char *)NULL
);
10836 pst_filename
= pst
->filename
;
10837 if (!IS_ABSOLUTE_PATH (pst_filename
) && pst
->dirname
!= NULL
)
10839 copied_name
= concat (pst
->dirname
, SLASH_STRING
,
10840 pst_filename
, (char *)NULL
);
10841 pst_filename
= copied_name
;
10844 file_is_pst
= FILENAME_CMP (include_name_to_compare
, pst_filename
) == 0;
10846 if (include_name_to_compare
!= include_name
)
10847 xfree (include_name_to_compare
);
10848 if (copied_name
!= NULL
)
10849 xfree (copied_name
);
10853 return include_name
;
10856 /* Ignore this record_line request. */
10859 noop_record_line (struct subfile
*subfile
, int line
, CORE_ADDR pc
)
10864 /* Decode the Line Number Program (LNP) for the given line_header
10865 structure and CU. The actual information extracted and the type
10866 of structures created from the LNP depends on the value of PST.
10868 1. If PST is NULL, then this procedure uses the data from the program
10869 to create all necessary symbol tables, and their linetables.
10871 2. If PST is not NULL, this procedure reads the program to determine
10872 the list of files included by the unit represented by PST, and
10873 builds all the associated partial symbol tables.
10875 COMP_DIR is the compilation directory (DW_AT_comp_dir) or NULL if unknown.
10876 It is used for relative paths in the line table.
10877 NOTE: When processing partial symtabs (pst != NULL),
10878 comp_dir == pst->dirname.
10880 NOTE: It is important that psymtabs have the same file name (via strcmp)
10881 as the corresponding symtab. Since COMP_DIR is not used in the name of the
10882 symtab we don't use it in the name of the psymtabs we create.
10883 E.g. expand_line_sal requires this when finding psymtabs to expand.
10884 A good testcase for this is mb-inline.exp. */
10887 dwarf_decode_lines (struct line_header
*lh
, const char *comp_dir
, bfd
*abfd
,
10888 struct dwarf2_cu
*cu
, struct partial_symtab
*pst
)
10890 gdb_byte
*line_ptr
, *extended_end
;
10891 gdb_byte
*line_end
;
10892 unsigned int bytes_read
, extended_len
;
10893 unsigned char op_code
, extended_op
, adj_opcode
;
10894 CORE_ADDR baseaddr
;
10895 struct objfile
*objfile
= cu
->objfile
;
10896 struct gdbarch
*gdbarch
= get_objfile_arch (objfile
);
10897 const int decode_for_pst_p
= (pst
!= NULL
);
10898 struct subfile
*last_subfile
= NULL
, *first_subfile
= current_subfile
;
10899 void (*p_record_line
) (struct subfile
*subfile
, int line
, CORE_ADDR pc
)
10902 baseaddr
= ANOFFSET (objfile
->section_offsets
, SECT_OFF_TEXT (objfile
));
10904 line_ptr
= lh
->statement_program_start
;
10905 line_end
= lh
->statement_program_end
;
10907 /* Read the statement sequences until there's nothing left. */
10908 while (line_ptr
< line_end
)
10910 /* state machine registers */
10911 CORE_ADDR address
= 0;
10912 unsigned int file
= 1;
10913 unsigned int line
= 1;
10914 unsigned int column
= 0;
10915 int is_stmt
= lh
->default_is_stmt
;
10916 int basic_block
= 0;
10917 int end_sequence
= 0;
10919 unsigned char op_index
= 0;
10921 if (!decode_for_pst_p
&& lh
->num_file_names
>= file
)
10923 /* Start a subfile for the current file of the state machine. */
10924 /* lh->include_dirs and lh->file_names are 0-based, but the
10925 directory and file name numbers in the statement program
10927 struct file_entry
*fe
= &lh
->file_names
[file
- 1];
10931 dir
= lh
->include_dirs
[fe
->dir_index
- 1];
10933 dwarf2_start_subfile (fe
->name
, dir
, comp_dir
);
10936 /* Decode the table. */
10937 while (!end_sequence
)
10939 op_code
= read_1_byte (abfd
, line_ptr
);
10941 if (line_ptr
> line_end
)
10943 dwarf2_debug_line_missing_end_sequence_complaint ();
10947 if (op_code
>= lh
->opcode_base
)
10949 /* Special operand. */
10950 adj_opcode
= op_code
- lh
->opcode_base
;
10951 address
+= (((op_index
+ (adj_opcode
/ lh
->line_range
))
10952 / lh
->maximum_ops_per_instruction
)
10953 * lh
->minimum_instruction_length
);
10954 op_index
= ((op_index
+ (adj_opcode
/ lh
->line_range
))
10955 % lh
->maximum_ops_per_instruction
);
10956 line
+= lh
->line_base
+ (adj_opcode
% lh
->line_range
);
10957 if (lh
->num_file_names
< file
|| file
== 0)
10958 dwarf2_debug_line_missing_file_complaint ();
10959 /* For now we ignore lines not starting on an
10960 instruction boundary. */
10961 else if (op_index
== 0)
10963 lh
->file_names
[file
- 1].included_p
= 1;
10964 if (!decode_for_pst_p
&& is_stmt
)
10966 if (last_subfile
!= current_subfile
)
10968 addr
= gdbarch_addr_bits_remove (gdbarch
, address
);
10970 (*p_record_line
) (last_subfile
, 0, addr
);
10971 last_subfile
= current_subfile
;
10973 /* Append row to matrix using current values. */
10974 addr
= check_cu_functions (address
, cu
);
10975 addr
= gdbarch_addr_bits_remove (gdbarch
, addr
);
10976 (*p_record_line
) (current_subfile
, line
, addr
);
10981 else switch (op_code
)
10983 case DW_LNS_extended_op
:
10984 extended_len
= read_unsigned_leb128 (abfd
, line_ptr
,
10986 line_ptr
+= bytes_read
;
10987 extended_end
= line_ptr
+ extended_len
;
10988 extended_op
= read_1_byte (abfd
, line_ptr
);
10990 switch (extended_op
)
10992 case DW_LNE_end_sequence
:
10993 p_record_line
= record_line
;
10996 case DW_LNE_set_address
:
10997 address
= read_address (abfd
, line_ptr
, cu
, &bytes_read
);
10999 if (address
== 0 && !dwarf2_per_objfile
->has_section_at_zero
)
11001 /* This line table is for a function which has been
11002 GCd by the linker. Ignore it. PR gdb/12528 */
11005 = line_ptr
- dwarf2_per_objfile
->line
.buffer
;
11007 complaint (&symfile_complaints
,
11008 _(".debug_line address at offset 0x%lx is 0 "
11010 line_offset
, cu
->objfile
->name
);
11011 p_record_line
= noop_record_line
;
11015 line_ptr
+= bytes_read
;
11016 address
+= baseaddr
;
11018 case DW_LNE_define_file
:
11021 unsigned int dir_index
, mod_time
, length
;
11023 cur_file
= read_direct_string (abfd
, line_ptr
,
11025 line_ptr
+= bytes_read
;
11027 read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
11028 line_ptr
+= bytes_read
;
11030 read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
11031 line_ptr
+= bytes_read
;
11033 read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
11034 line_ptr
+= bytes_read
;
11035 add_file_name (lh
, cur_file
, dir_index
, mod_time
, length
);
11038 case DW_LNE_set_discriminator
:
11039 /* The discriminator is not interesting to the debugger;
11041 line_ptr
= extended_end
;
11044 complaint (&symfile_complaints
,
11045 _("mangled .debug_line section"));
11048 /* Make sure that we parsed the extended op correctly. If e.g.
11049 we expected a different address size than the producer used,
11050 we may have read the wrong number of bytes. */
11051 if (line_ptr
!= extended_end
)
11053 complaint (&symfile_complaints
,
11054 _("mangled .debug_line section"));
11059 if (lh
->num_file_names
< file
|| file
== 0)
11060 dwarf2_debug_line_missing_file_complaint ();
11063 lh
->file_names
[file
- 1].included_p
= 1;
11064 if (!decode_for_pst_p
&& is_stmt
)
11066 if (last_subfile
!= current_subfile
)
11068 addr
= gdbarch_addr_bits_remove (gdbarch
, address
);
11070 (*p_record_line
) (last_subfile
, 0, addr
);
11071 last_subfile
= current_subfile
;
11073 addr
= check_cu_functions (address
, cu
);
11074 addr
= gdbarch_addr_bits_remove (gdbarch
, addr
);
11075 (*p_record_line
) (current_subfile
, line
, addr
);
11080 case DW_LNS_advance_pc
:
11083 = read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
11085 address
+= (((op_index
+ adjust
)
11086 / lh
->maximum_ops_per_instruction
)
11087 * lh
->minimum_instruction_length
);
11088 op_index
= ((op_index
+ adjust
)
11089 % lh
->maximum_ops_per_instruction
);
11090 line_ptr
+= bytes_read
;
11093 case DW_LNS_advance_line
:
11094 line
+= read_signed_leb128 (abfd
, line_ptr
, &bytes_read
);
11095 line_ptr
+= bytes_read
;
11097 case DW_LNS_set_file
:
11099 /* The arrays lh->include_dirs and lh->file_names are
11100 0-based, but the directory and file name numbers in
11101 the statement program are 1-based. */
11102 struct file_entry
*fe
;
11105 file
= read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
11106 line_ptr
+= bytes_read
;
11107 if (lh
->num_file_names
< file
|| file
== 0)
11108 dwarf2_debug_line_missing_file_complaint ();
11111 fe
= &lh
->file_names
[file
- 1];
11113 dir
= lh
->include_dirs
[fe
->dir_index
- 1];
11114 if (!decode_for_pst_p
)
11116 last_subfile
= current_subfile
;
11117 dwarf2_start_subfile (fe
->name
, dir
, comp_dir
);
11122 case DW_LNS_set_column
:
11123 column
= read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
11124 line_ptr
+= bytes_read
;
11126 case DW_LNS_negate_stmt
:
11127 is_stmt
= (!is_stmt
);
11129 case DW_LNS_set_basic_block
:
11132 /* Add to the address register of the state machine the
11133 address increment value corresponding to special opcode
11134 255. I.e., this value is scaled by the minimum
11135 instruction length since special opcode 255 would have
11136 scaled the increment. */
11137 case DW_LNS_const_add_pc
:
11139 CORE_ADDR adjust
= (255 - lh
->opcode_base
) / lh
->line_range
;
11141 address
+= (((op_index
+ adjust
)
11142 / lh
->maximum_ops_per_instruction
)
11143 * lh
->minimum_instruction_length
);
11144 op_index
= ((op_index
+ adjust
)
11145 % lh
->maximum_ops_per_instruction
);
11148 case DW_LNS_fixed_advance_pc
:
11149 address
+= read_2_bytes (abfd
, line_ptr
);
11155 /* Unknown standard opcode, ignore it. */
11158 for (i
= 0; i
< lh
->standard_opcode_lengths
[op_code
]; i
++)
11160 (void) read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
11161 line_ptr
+= bytes_read
;
11166 if (lh
->num_file_names
< file
|| file
== 0)
11167 dwarf2_debug_line_missing_file_complaint ();
11170 lh
->file_names
[file
- 1].included_p
= 1;
11171 if (!decode_for_pst_p
)
11173 addr
= gdbarch_addr_bits_remove (gdbarch
, address
);
11174 (*p_record_line
) (current_subfile
, 0, addr
);
11179 if (decode_for_pst_p
)
11183 /* Now that we're done scanning the Line Header Program, we can
11184 create the psymtab of each included file. */
11185 for (file_index
= 0; file_index
< lh
->num_file_names
; file_index
++)
11186 if (lh
->file_names
[file_index
].included_p
== 1)
11188 char *include_name
=
11189 psymtab_include_file_name (lh
, file_index
, pst
, comp_dir
);
11190 if (include_name
!= NULL
)
11191 dwarf2_create_include_psymtab (include_name
, pst
, objfile
);
11196 /* Make sure a symtab is created for every file, even files
11197 which contain only variables (i.e. no code with associated
11201 struct file_entry
*fe
;
11203 for (i
= 0; i
< lh
->num_file_names
; i
++)
11207 fe
= &lh
->file_names
[i
];
11209 dir
= lh
->include_dirs
[fe
->dir_index
- 1];
11210 dwarf2_start_subfile (fe
->name
, dir
, comp_dir
);
11212 /* Skip the main file; we don't need it, and it must be
11213 allocated last, so that it will show up before the
11214 non-primary symtabs in the objfile's symtab list. */
11215 if (current_subfile
== first_subfile
)
11218 if (current_subfile
->symtab
== NULL
)
11219 current_subfile
->symtab
= allocate_symtab (current_subfile
->name
,
11221 fe
->symtab
= current_subfile
->symtab
;
11226 /* Start a subfile for DWARF. FILENAME is the name of the file and
11227 DIRNAME the name of the source directory which contains FILENAME
11228 or NULL if not known. COMP_DIR is the compilation directory for the
11229 linetable's compilation unit or NULL if not known.
11230 This routine tries to keep line numbers from identical absolute and
11231 relative file names in a common subfile.
11233 Using the `list' example from the GDB testsuite, which resides in
11234 /srcdir and compiling it with Irix6.2 cc in /compdir using a filename
11235 of /srcdir/list0.c yields the following debugging information for list0.c:
11237 DW_AT_name: /srcdir/list0.c
11238 DW_AT_comp_dir: /compdir
11239 files.files[0].name: list0.h
11240 files.files[0].dir: /srcdir
11241 files.files[1].name: list0.c
11242 files.files[1].dir: /srcdir
11244 The line number information for list0.c has to end up in a single
11245 subfile, so that `break /srcdir/list0.c:1' works as expected.
11246 start_subfile will ensure that this happens provided that we pass the
11247 concatenation of files.files[1].dir and files.files[1].name as the
11251 dwarf2_start_subfile (char *filename
, const char *dirname
,
11252 const char *comp_dir
)
11256 /* While reading the DIEs, we call start_symtab(DW_AT_name, DW_AT_comp_dir).
11257 `start_symtab' will always pass the contents of DW_AT_comp_dir as
11258 second argument to start_subfile. To be consistent, we do the
11259 same here. In order not to lose the line information directory,
11260 we concatenate it to the filename when it makes sense.
11261 Note that the Dwarf3 standard says (speaking of filenames in line
11262 information): ``The directory index is ignored for file names
11263 that represent full path names''. Thus ignoring dirname in the
11264 `else' branch below isn't an issue. */
11266 if (!IS_ABSOLUTE_PATH (filename
) && dirname
!= NULL
)
11267 fullname
= concat (dirname
, SLASH_STRING
, filename
, (char *)NULL
);
11269 fullname
= filename
;
11271 start_subfile (fullname
, comp_dir
);
11273 if (fullname
!= filename
)
11278 var_decode_location (struct attribute
*attr
, struct symbol
*sym
,
11279 struct dwarf2_cu
*cu
)
11281 struct objfile
*objfile
= cu
->objfile
;
11282 struct comp_unit_head
*cu_header
= &cu
->header
;
11284 /* NOTE drow/2003-01-30: There used to be a comment and some special
11285 code here to turn a symbol with DW_AT_external and a
11286 SYMBOL_VALUE_ADDRESS of 0 into a LOC_UNRESOLVED symbol. This was
11287 necessary for platforms (maybe Alpha, certainly PowerPC GNU/Linux
11288 with some versions of binutils) where shared libraries could have
11289 relocations against symbols in their debug information - the
11290 minimal symbol would have the right address, but the debug info
11291 would not. It's no longer necessary, because we will explicitly
11292 apply relocations when we read in the debug information now. */
11294 /* A DW_AT_location attribute with no contents indicates that a
11295 variable has been optimized away. */
11296 if (attr_form_is_block (attr
) && DW_BLOCK (attr
)->size
== 0)
11298 SYMBOL_CLASS (sym
) = LOC_OPTIMIZED_OUT
;
11302 /* Handle one degenerate form of location expression specially, to
11303 preserve GDB's previous behavior when section offsets are
11304 specified. If this is just a DW_OP_addr then mark this symbol
11307 if (attr_form_is_block (attr
)
11308 && DW_BLOCK (attr
)->size
== 1 + cu_header
->addr_size
11309 && DW_BLOCK (attr
)->data
[0] == DW_OP_addr
)
11311 unsigned int dummy
;
11313 SYMBOL_VALUE_ADDRESS (sym
) =
11314 read_address (objfile
->obfd
, DW_BLOCK (attr
)->data
+ 1, cu
, &dummy
);
11315 SYMBOL_CLASS (sym
) = LOC_STATIC
;
11316 fixup_symbol_section (sym
, objfile
);
11317 SYMBOL_VALUE_ADDRESS (sym
) += ANOFFSET (objfile
->section_offsets
,
11318 SYMBOL_SECTION (sym
));
11322 /* NOTE drow/2002-01-30: It might be worthwhile to have a static
11323 expression evaluator, and use LOC_COMPUTED only when necessary
11324 (i.e. when the value of a register or memory location is
11325 referenced, or a thread-local block, etc.). Then again, it might
11326 not be worthwhile. I'm assuming that it isn't unless performance
11327 or memory numbers show me otherwise. */
11329 dwarf2_symbol_mark_computed (attr
, sym
, cu
);
11330 SYMBOL_CLASS (sym
) = LOC_COMPUTED
;
11332 if (SYMBOL_COMPUTED_OPS (sym
) == &dwarf2_loclist_funcs
)
11333 cu
->has_loclist
= 1;
11336 /* Given a pointer to a DWARF information entry, figure out if we need
11337 to make a symbol table entry for it, and if so, create a new entry
11338 and return a pointer to it.
11339 If TYPE is NULL, determine symbol type from the die, otherwise
11340 used the passed type.
11341 If SPACE is not NULL, use it to hold the new symbol. If it is
11342 NULL, allocate a new symbol on the objfile's obstack. */
11344 static struct symbol
*
11345 new_symbol_full (struct die_info
*die
, struct type
*type
, struct dwarf2_cu
*cu
,
11346 struct symbol
*space
)
11348 struct objfile
*objfile
= cu
->objfile
;
11349 struct symbol
*sym
= NULL
;
11351 struct attribute
*attr
= NULL
;
11352 struct attribute
*attr2
= NULL
;
11353 CORE_ADDR baseaddr
;
11354 struct pending
**list_to_add
= NULL
;
11356 int inlined_func
= (die
->tag
== DW_TAG_inlined_subroutine
);
11358 baseaddr
= ANOFFSET (objfile
->section_offsets
, SECT_OFF_TEXT (objfile
));
11360 name
= dwarf2_name (die
, cu
);
11363 const char *linkagename
;
11364 int suppress_add
= 0;
11369 sym
= OBSTACK_ZALLOC (&objfile
->objfile_obstack
, struct symbol
);
11370 OBJSTAT (objfile
, n_syms
++);
11372 /* Cache this symbol's name and the name's demangled form (if any). */
11373 SYMBOL_SET_LANGUAGE (sym
, cu
->language
);
11374 linkagename
= dwarf2_physname (name
, die
, cu
);
11375 SYMBOL_SET_NAMES (sym
, linkagename
, strlen (linkagename
), 0, objfile
);
11377 /* Fortran does not have mangling standard and the mangling does differ
11378 between gfortran, iFort etc. */
11379 if (cu
->language
== language_fortran
11380 && symbol_get_demangled_name (&(sym
->ginfo
)) == NULL
)
11381 symbol_set_demangled_name (&(sym
->ginfo
),
11382 (char *) dwarf2_full_name (name
, die
, cu
),
11385 /* Default assumptions.
11386 Use the passed type or decode it from the die. */
11387 SYMBOL_DOMAIN (sym
) = VAR_DOMAIN
;
11388 SYMBOL_CLASS (sym
) = LOC_OPTIMIZED_OUT
;
11390 SYMBOL_TYPE (sym
) = type
;
11392 SYMBOL_TYPE (sym
) = die_type (die
, cu
);
11393 attr
= dwarf2_attr (die
,
11394 inlined_func
? DW_AT_call_line
: DW_AT_decl_line
,
11398 SYMBOL_LINE (sym
) = DW_UNSND (attr
);
11401 attr
= dwarf2_attr (die
,
11402 inlined_func
? DW_AT_call_file
: DW_AT_decl_file
,
11406 int file_index
= DW_UNSND (attr
);
11408 if (cu
->line_header
== NULL
11409 || file_index
> cu
->line_header
->num_file_names
)
11410 complaint (&symfile_complaints
,
11411 _("file index out of range"));
11412 else if (file_index
> 0)
11414 struct file_entry
*fe
;
11416 fe
= &cu
->line_header
->file_names
[file_index
- 1];
11417 SYMBOL_SYMTAB (sym
) = fe
->symtab
;
11424 attr
= dwarf2_attr (die
, DW_AT_low_pc
, cu
);
11427 SYMBOL_VALUE_ADDRESS (sym
) = DW_ADDR (attr
) + baseaddr
;
11429 SYMBOL_TYPE (sym
) = objfile_type (objfile
)->builtin_core_addr
;
11430 SYMBOL_DOMAIN (sym
) = LABEL_DOMAIN
;
11431 SYMBOL_CLASS (sym
) = LOC_LABEL
;
11432 add_symbol_to_list (sym
, cu
->list_in_scope
);
11434 case DW_TAG_subprogram
:
11435 /* SYMBOL_BLOCK_VALUE (sym) will be filled in later by
11437 SYMBOL_CLASS (sym
) = LOC_BLOCK
;
11438 attr2
= dwarf2_attr (die
, DW_AT_external
, cu
);
11439 if ((attr2
&& (DW_UNSND (attr2
) != 0))
11440 || cu
->language
== language_ada
)
11442 /* Subprograms marked external are stored as a global symbol.
11443 Ada subprograms, whether marked external or not, are always
11444 stored as a global symbol, because we want to be able to
11445 access them globally. For instance, we want to be able
11446 to break on a nested subprogram without having to
11447 specify the context. */
11448 list_to_add
= &global_symbols
;
11452 list_to_add
= cu
->list_in_scope
;
11455 case DW_TAG_inlined_subroutine
:
11456 /* SYMBOL_BLOCK_VALUE (sym) will be filled in later by
11458 SYMBOL_CLASS (sym
) = LOC_BLOCK
;
11459 SYMBOL_INLINED (sym
) = 1;
11460 /* Do not add the symbol to any lists. It will be found via
11461 BLOCK_FUNCTION from the blockvector. */
11463 case DW_TAG_template_value_param
:
11465 /* Fall through. */
11466 case DW_TAG_constant
:
11467 case DW_TAG_variable
:
11468 case DW_TAG_member
:
11469 /* Compilation with minimal debug info may result in
11470 variables with missing type entries. Change the
11471 misleading `void' type to something sensible. */
11472 if (TYPE_CODE (SYMBOL_TYPE (sym
)) == TYPE_CODE_VOID
)
11474 = objfile_type (objfile
)->nodebug_data_symbol
;
11476 attr
= dwarf2_attr (die
, DW_AT_const_value
, cu
);
11477 /* In the case of DW_TAG_member, we should only be called for
11478 static const members. */
11479 if (die
->tag
== DW_TAG_member
)
11481 /* dwarf2_add_field uses die_is_declaration,
11482 so we do the same. */
11483 gdb_assert (die_is_declaration (die
, cu
));
11488 dwarf2_const_value (attr
, sym
, cu
);
11489 attr2
= dwarf2_attr (die
, DW_AT_external
, cu
);
11492 if (attr2
&& (DW_UNSND (attr2
) != 0))
11493 list_to_add
= &global_symbols
;
11495 list_to_add
= cu
->list_in_scope
;
11499 attr
= dwarf2_attr (die
, DW_AT_location
, cu
);
11502 var_decode_location (attr
, sym
, cu
);
11503 attr2
= dwarf2_attr (die
, DW_AT_external
, cu
);
11504 if (SYMBOL_CLASS (sym
) == LOC_STATIC
11505 && SYMBOL_VALUE_ADDRESS (sym
) == 0
11506 && !dwarf2_per_objfile
->has_section_at_zero
)
11508 /* When a static variable is eliminated by the linker,
11509 the corresponding debug information is not stripped
11510 out, but the variable address is set to null;
11511 do not add such variables into symbol table. */
11513 else if (attr2
&& (DW_UNSND (attr2
) != 0))
11515 /* Workaround gfortran PR debug/40040 - it uses
11516 DW_AT_location for variables in -fPIC libraries which may
11517 get overriden by other libraries/executable and get
11518 a different address. Resolve it by the minimal symbol
11519 which may come from inferior's executable using copy
11520 relocation. Make this workaround only for gfortran as for
11521 other compilers GDB cannot guess the minimal symbol
11522 Fortran mangling kind. */
11523 if (cu
->language
== language_fortran
&& die
->parent
11524 && die
->parent
->tag
== DW_TAG_module
11526 && strncmp (cu
->producer
, "GNU Fortran ", 12) == 0)
11527 SYMBOL_CLASS (sym
) = LOC_UNRESOLVED
;
11529 /* A variable with DW_AT_external is never static,
11530 but it may be block-scoped. */
11531 list_to_add
= (cu
->list_in_scope
== &file_symbols
11532 ? &global_symbols
: cu
->list_in_scope
);
11535 list_to_add
= cu
->list_in_scope
;
11539 /* We do not know the address of this symbol.
11540 If it is an external symbol and we have type information
11541 for it, enter the symbol as a LOC_UNRESOLVED symbol.
11542 The address of the variable will then be determined from
11543 the minimal symbol table whenever the variable is
11545 attr2
= dwarf2_attr (die
, DW_AT_external
, cu
);
11546 if (attr2
&& (DW_UNSND (attr2
) != 0)
11547 && dwarf2_attr (die
, DW_AT_type
, cu
) != NULL
)
11549 /* A variable with DW_AT_external is never static, but it
11550 may be block-scoped. */
11551 list_to_add
= (cu
->list_in_scope
== &file_symbols
11552 ? &global_symbols
: cu
->list_in_scope
);
11554 SYMBOL_CLASS (sym
) = LOC_UNRESOLVED
;
11556 else if (!die_is_declaration (die
, cu
))
11558 /* Use the default LOC_OPTIMIZED_OUT class. */
11559 gdb_assert (SYMBOL_CLASS (sym
) == LOC_OPTIMIZED_OUT
);
11561 list_to_add
= cu
->list_in_scope
;
11565 case DW_TAG_formal_parameter
:
11566 /* If we are inside a function, mark this as an argument. If
11567 not, we might be looking at an argument to an inlined function
11568 when we do not have enough information to show inlined frames;
11569 pretend it's a local variable in that case so that the user can
11571 if (context_stack_depth
> 0
11572 && context_stack
[context_stack_depth
- 1].name
!= NULL
)
11573 SYMBOL_IS_ARGUMENT (sym
) = 1;
11574 attr
= dwarf2_attr (die
, DW_AT_location
, cu
);
11577 var_decode_location (attr
, sym
, cu
);
11579 attr
= dwarf2_attr (die
, DW_AT_const_value
, cu
);
11582 dwarf2_const_value (attr
, sym
, cu
);
11585 list_to_add
= cu
->list_in_scope
;
11587 case DW_TAG_unspecified_parameters
:
11588 /* From varargs functions; gdb doesn't seem to have any
11589 interest in this information, so just ignore it for now.
11592 case DW_TAG_template_type_param
:
11594 /* Fall through. */
11595 case DW_TAG_class_type
:
11596 case DW_TAG_interface_type
:
11597 case DW_TAG_structure_type
:
11598 case DW_TAG_union_type
:
11599 case DW_TAG_set_type
:
11600 case DW_TAG_enumeration_type
:
11601 SYMBOL_CLASS (sym
) = LOC_TYPEDEF
;
11602 SYMBOL_DOMAIN (sym
) = STRUCT_DOMAIN
;
11605 /* NOTE: carlton/2003-11-10: C++ and Java class symbols shouldn't
11606 really ever be static objects: otherwise, if you try
11607 to, say, break of a class's method and you're in a file
11608 which doesn't mention that class, it won't work unless
11609 the check for all static symbols in lookup_symbol_aux
11610 saves you. See the OtherFileClass tests in
11611 gdb.c++/namespace.exp. */
11615 list_to_add
= (cu
->list_in_scope
== &file_symbols
11616 && (cu
->language
== language_cplus
11617 || cu
->language
== language_java
)
11618 ? &global_symbols
: cu
->list_in_scope
);
11620 /* The semantics of C++ state that "struct foo {
11621 ... }" also defines a typedef for "foo". A Java
11622 class declaration also defines a typedef for the
11624 if (cu
->language
== language_cplus
11625 || cu
->language
== language_java
11626 || cu
->language
== language_ada
)
11628 /* The symbol's name is already allocated along
11629 with this objfile, so we don't need to
11630 duplicate it for the type. */
11631 if (TYPE_NAME (SYMBOL_TYPE (sym
)) == 0)
11632 TYPE_NAME (SYMBOL_TYPE (sym
)) = SYMBOL_SEARCH_NAME (sym
);
11637 case DW_TAG_typedef
:
11638 SYMBOL_CLASS (sym
) = LOC_TYPEDEF
;
11639 SYMBOL_DOMAIN (sym
) = VAR_DOMAIN
;
11640 list_to_add
= cu
->list_in_scope
;
11642 case DW_TAG_base_type
:
11643 case DW_TAG_subrange_type
:
11644 SYMBOL_CLASS (sym
) = LOC_TYPEDEF
;
11645 SYMBOL_DOMAIN (sym
) = VAR_DOMAIN
;
11646 list_to_add
= cu
->list_in_scope
;
11648 case DW_TAG_enumerator
:
11649 attr
= dwarf2_attr (die
, DW_AT_const_value
, cu
);
11652 dwarf2_const_value (attr
, sym
, cu
);
11655 /* NOTE: carlton/2003-11-10: See comment above in the
11656 DW_TAG_class_type, etc. block. */
11658 list_to_add
= (cu
->list_in_scope
== &file_symbols
11659 && (cu
->language
== language_cplus
11660 || cu
->language
== language_java
)
11661 ? &global_symbols
: cu
->list_in_scope
);
11664 case DW_TAG_namespace
:
11665 SYMBOL_CLASS (sym
) = LOC_TYPEDEF
;
11666 list_to_add
= &global_symbols
;
11669 /* Not a tag we recognize. Hopefully we aren't processing
11670 trash data, but since we must specifically ignore things
11671 we don't recognize, there is nothing else we should do at
11673 complaint (&symfile_complaints
, _("unsupported tag: '%s'"),
11674 dwarf_tag_name (die
->tag
));
11680 sym
->hash_next
= objfile
->template_symbols
;
11681 objfile
->template_symbols
= sym
;
11682 list_to_add
= NULL
;
11685 if (list_to_add
!= NULL
)
11686 add_symbol_to_list (sym
, list_to_add
);
11688 /* For the benefit of old versions of GCC, check for anonymous
11689 namespaces based on the demangled name. */
11690 if (!processing_has_namespace_info
11691 && cu
->language
== language_cplus
)
11692 cp_scan_for_anonymous_namespaces (sym
);
11697 /* A wrapper for new_symbol_full that always allocates a new symbol. */
11699 static struct symbol
*
11700 new_symbol (struct die_info
*die
, struct type
*type
, struct dwarf2_cu
*cu
)
11702 return new_symbol_full (die
, type
, cu
, NULL
);
11705 /* Given an attr with a DW_FORM_dataN value in host byte order,
11706 zero-extend it as appropriate for the symbol's type. The DWARF
11707 standard (v4) is not entirely clear about the meaning of using
11708 DW_FORM_dataN for a constant with a signed type, where the type is
11709 wider than the data. The conclusion of a discussion on the DWARF
11710 list was that this is unspecified. We choose to always zero-extend
11711 because that is the interpretation long in use by GCC. */
11714 dwarf2_const_value_data (struct attribute
*attr
, struct type
*type
,
11715 const char *name
, struct obstack
*obstack
,
11716 struct dwarf2_cu
*cu
, long *value
, int bits
)
11718 struct objfile
*objfile
= cu
->objfile
;
11719 enum bfd_endian byte_order
= bfd_big_endian (objfile
->obfd
) ?
11720 BFD_ENDIAN_BIG
: BFD_ENDIAN_LITTLE
;
11721 LONGEST l
= DW_UNSND (attr
);
11723 if (bits
< sizeof (*value
) * 8)
11725 l
&= ((LONGEST
) 1 << bits
) - 1;
11728 else if (bits
== sizeof (*value
) * 8)
11732 gdb_byte
*bytes
= obstack_alloc (obstack
, bits
/ 8);
11733 store_unsigned_integer (bytes
, bits
/ 8, byte_order
, l
);
11740 /* Read a constant value from an attribute. Either set *VALUE, or if
11741 the value does not fit in *VALUE, set *BYTES - either already
11742 allocated on the objfile obstack, or newly allocated on OBSTACK,
11743 or, set *BATON, if we translated the constant to a location
11747 dwarf2_const_value_attr (struct attribute
*attr
, struct type
*type
,
11748 const char *name
, struct obstack
*obstack
,
11749 struct dwarf2_cu
*cu
,
11750 long *value
, gdb_byte
**bytes
,
11751 struct dwarf2_locexpr_baton
**baton
)
11753 struct objfile
*objfile
= cu
->objfile
;
11754 struct comp_unit_head
*cu_header
= &cu
->header
;
11755 struct dwarf_block
*blk
;
11756 enum bfd_endian byte_order
= (bfd_big_endian (objfile
->obfd
) ?
11757 BFD_ENDIAN_BIG
: BFD_ENDIAN_LITTLE
);
11763 switch (attr
->form
)
11769 if (TYPE_LENGTH (type
) != cu_header
->addr_size
)
11770 dwarf2_const_value_length_mismatch_complaint (name
,
11771 cu_header
->addr_size
,
11772 TYPE_LENGTH (type
));
11773 /* Symbols of this form are reasonably rare, so we just
11774 piggyback on the existing location code rather than writing
11775 a new implementation of symbol_computed_ops. */
11776 *baton
= obstack_alloc (&objfile
->objfile_obstack
,
11777 sizeof (struct dwarf2_locexpr_baton
));
11778 (*baton
)->per_cu
= cu
->per_cu
;
11779 gdb_assert ((*baton
)->per_cu
);
11781 (*baton
)->size
= 2 + cu_header
->addr_size
;
11782 data
= obstack_alloc (&objfile
->objfile_obstack
, (*baton
)->size
);
11783 (*baton
)->data
= data
;
11785 data
[0] = DW_OP_addr
;
11786 store_unsigned_integer (&data
[1], cu_header
->addr_size
,
11787 byte_order
, DW_ADDR (attr
));
11788 data
[cu_header
->addr_size
+ 1] = DW_OP_stack_value
;
11791 case DW_FORM_string
:
11793 /* DW_STRING is already allocated on the objfile obstack, point
11795 *bytes
= (gdb_byte
*) DW_STRING (attr
);
11797 case DW_FORM_block1
:
11798 case DW_FORM_block2
:
11799 case DW_FORM_block4
:
11800 case DW_FORM_block
:
11801 case DW_FORM_exprloc
:
11802 blk
= DW_BLOCK (attr
);
11803 if (TYPE_LENGTH (type
) != blk
->size
)
11804 dwarf2_const_value_length_mismatch_complaint (name
, blk
->size
,
11805 TYPE_LENGTH (type
));
11806 *bytes
= blk
->data
;
11809 /* The DW_AT_const_value attributes are supposed to carry the
11810 symbol's value "represented as it would be on the target
11811 architecture." By the time we get here, it's already been
11812 converted to host endianness, so we just need to sign- or
11813 zero-extend it as appropriate. */
11814 case DW_FORM_data1
:
11815 *bytes
= dwarf2_const_value_data (attr
, type
, name
,
11816 obstack
, cu
, value
, 8);
11818 case DW_FORM_data2
:
11819 *bytes
= dwarf2_const_value_data (attr
, type
, name
,
11820 obstack
, cu
, value
, 16);
11822 case DW_FORM_data4
:
11823 *bytes
= dwarf2_const_value_data (attr
, type
, name
,
11824 obstack
, cu
, value
, 32);
11826 case DW_FORM_data8
:
11827 *bytes
= dwarf2_const_value_data (attr
, type
, name
,
11828 obstack
, cu
, value
, 64);
11831 case DW_FORM_sdata
:
11832 *value
= DW_SND (attr
);
11835 case DW_FORM_udata
:
11836 *value
= DW_UNSND (attr
);
11840 complaint (&symfile_complaints
,
11841 _("unsupported const value attribute form: '%s'"),
11842 dwarf_form_name (attr
->form
));
11849 /* Copy constant value from an attribute to a symbol. */
11852 dwarf2_const_value (struct attribute
*attr
, struct symbol
*sym
,
11853 struct dwarf2_cu
*cu
)
11855 struct objfile
*objfile
= cu
->objfile
;
11856 struct comp_unit_head
*cu_header
= &cu
->header
;
11859 struct dwarf2_locexpr_baton
*baton
;
11861 dwarf2_const_value_attr (attr
, SYMBOL_TYPE (sym
),
11862 SYMBOL_PRINT_NAME (sym
),
11863 &objfile
->objfile_obstack
, cu
,
11864 &value
, &bytes
, &baton
);
11868 SYMBOL_COMPUTED_OPS (sym
) = &dwarf2_locexpr_funcs
;
11869 SYMBOL_LOCATION_BATON (sym
) = baton
;
11870 SYMBOL_CLASS (sym
) = LOC_COMPUTED
;
11872 else if (bytes
!= NULL
)
11874 SYMBOL_VALUE_BYTES (sym
) = bytes
;
11875 SYMBOL_CLASS (sym
) = LOC_CONST_BYTES
;
11879 SYMBOL_VALUE (sym
) = value
;
11880 SYMBOL_CLASS (sym
) = LOC_CONST
;
11884 /* Return the type of the die in question using its DW_AT_type attribute. */
11886 static struct type
*
11887 die_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
11889 struct attribute
*type_attr
;
11891 type_attr
= dwarf2_attr (die
, DW_AT_type
, cu
);
11894 /* A missing DW_AT_type represents a void type. */
11895 return objfile_type (cu
->objfile
)->builtin_void
;
11898 return lookup_die_type (die
, type_attr
, cu
);
11901 /* True iff CU's producer generates GNAT Ada auxiliary information
11902 that allows to find parallel types through that information instead
11903 of having to do expensive parallel lookups by type name. */
11906 need_gnat_info (struct dwarf2_cu
*cu
)
11908 /* FIXME: brobecker/2010-10-12: As of now, only the AdaCore version
11909 of GNAT produces this auxiliary information, without any indication
11910 that it is produced. Part of enhancing the FSF version of GNAT
11911 to produce that information will be to put in place an indicator
11912 that we can use in order to determine whether the descriptive type
11913 info is available or not. One suggestion that has been made is
11914 to use a new attribute, attached to the CU die. For now, assume
11915 that the descriptive type info is not available. */
11919 /* Return the auxiliary type of the die in question using its
11920 DW_AT_GNAT_descriptive_type attribute. Returns NULL if the
11921 attribute is not present. */
11923 static struct type
*
11924 die_descriptive_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
11926 struct attribute
*type_attr
;
11928 type_attr
= dwarf2_attr (die
, DW_AT_GNAT_descriptive_type
, cu
);
11932 return lookup_die_type (die
, type_attr
, cu
);
11935 /* If DIE has a descriptive_type attribute, then set the TYPE's
11936 descriptive type accordingly. */
11939 set_descriptive_type (struct type
*type
, struct die_info
*die
,
11940 struct dwarf2_cu
*cu
)
11942 struct type
*descriptive_type
= die_descriptive_type (die
, cu
);
11944 if (descriptive_type
)
11946 ALLOCATE_GNAT_AUX_TYPE (type
);
11947 TYPE_DESCRIPTIVE_TYPE (type
) = descriptive_type
;
11951 /* Return the containing type of the die in question using its
11952 DW_AT_containing_type attribute. */
11954 static struct type
*
11955 die_containing_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
11957 struct attribute
*type_attr
;
11959 type_attr
= dwarf2_attr (die
, DW_AT_containing_type
, cu
);
11961 error (_("Dwarf Error: Problem turning containing type into gdb type "
11962 "[in module %s]"), cu
->objfile
->name
);
11964 return lookup_die_type (die
, type_attr
, cu
);
11967 /* Look up the type of DIE in CU using its type attribute ATTR.
11968 If there is no type substitute an error marker. */
11970 static struct type
*
11971 lookup_die_type (struct die_info
*die
, struct attribute
*attr
,
11972 struct dwarf2_cu
*cu
)
11974 struct type
*this_type
;
11976 /* First see if we have it cached. */
11978 if (is_ref_attr (attr
))
11980 unsigned int offset
= dwarf2_get_ref_die_offset (attr
);
11982 this_type
= get_die_type_at_offset (offset
, cu
->per_cu
);
11984 else if (attr
->form
== DW_FORM_ref_sig8
)
11986 struct signatured_type
*sig_type
= DW_SIGNATURED_TYPE (attr
);
11987 struct dwarf2_cu
*sig_cu
;
11988 unsigned int offset
;
11990 /* sig_type will be NULL if the signatured type is missing from
11992 if (sig_type
== NULL
)
11993 error (_("Dwarf Error: Cannot find signatured DIE referenced from DIE "
11994 "at 0x%x [in module %s]"),
11995 die
->offset
, cu
->objfile
->name
);
11997 gdb_assert (sig_type
->per_cu
.debug_type_section
);
11998 offset
= sig_type
->per_cu
.offset
+ sig_type
->type_offset
;
11999 this_type
= get_die_type_at_offset (offset
, &sig_type
->per_cu
);
12003 dump_die_for_error (die
);
12004 error (_("Dwarf Error: Bad type attribute %s [in module %s]"),
12005 dwarf_attr_name (attr
->name
), cu
->objfile
->name
);
12008 /* If not cached we need to read it in. */
12010 if (this_type
== NULL
)
12012 struct die_info
*type_die
;
12013 struct dwarf2_cu
*type_cu
= cu
;
12015 type_die
= follow_die_ref_or_sig (die
, attr
, &type_cu
);
12016 /* If the type is cached, we should have found it above. */
12017 gdb_assert (get_die_type (type_die
, type_cu
) == NULL
);
12018 this_type
= read_type_die_1 (type_die
, type_cu
);
12021 /* If we still don't have a type use an error marker. */
12023 if (this_type
== NULL
)
12025 char *message
, *saved
;
12027 /* read_type_die already issued a complaint. */
12028 message
= xstrprintf (_("<unknown type in %s, CU 0x%x, DIE 0x%x>"),
12032 saved
= obstack_copy0 (&cu
->objfile
->objfile_obstack
,
12033 message
, strlen (message
));
12036 this_type
= init_type (TYPE_CODE_ERROR
, 0, 0, saved
, cu
->objfile
);
12042 /* Return the type in DIE, CU.
12043 Returns NULL for invalid types.
12045 This first does a lookup in the appropriate type_hash table,
12046 and only reads the die in if necessary.
12048 NOTE: This can be called when reading in partial or full symbols. */
12050 static struct type
*
12051 read_type_die (struct die_info
*die
, struct dwarf2_cu
*cu
)
12053 struct type
*this_type
;
12055 this_type
= get_die_type (die
, cu
);
12059 return read_type_die_1 (die
, cu
);
12062 /* Read the type in DIE, CU.
12063 Returns NULL for invalid types. */
12065 static struct type
*
12066 read_type_die_1 (struct die_info
*die
, struct dwarf2_cu
*cu
)
12068 struct type
*this_type
= NULL
;
12072 case DW_TAG_class_type
:
12073 case DW_TAG_interface_type
:
12074 case DW_TAG_structure_type
:
12075 case DW_TAG_union_type
:
12076 this_type
= read_structure_type (die
, cu
);
12078 case DW_TAG_enumeration_type
:
12079 this_type
= read_enumeration_type (die
, cu
);
12081 case DW_TAG_subprogram
:
12082 case DW_TAG_subroutine_type
:
12083 case DW_TAG_inlined_subroutine
:
12084 this_type
= read_subroutine_type (die
, cu
);
12086 case DW_TAG_array_type
:
12087 this_type
= read_array_type (die
, cu
);
12089 case DW_TAG_set_type
:
12090 this_type
= read_set_type (die
, cu
);
12092 case DW_TAG_pointer_type
:
12093 this_type
= read_tag_pointer_type (die
, cu
);
12095 case DW_TAG_ptr_to_member_type
:
12096 this_type
= read_tag_ptr_to_member_type (die
, cu
);
12098 case DW_TAG_reference_type
:
12099 this_type
= read_tag_reference_type (die
, cu
);
12101 case DW_TAG_const_type
:
12102 this_type
= read_tag_const_type (die
, cu
);
12104 case DW_TAG_volatile_type
:
12105 this_type
= read_tag_volatile_type (die
, cu
);
12107 case DW_TAG_string_type
:
12108 this_type
= read_tag_string_type (die
, cu
);
12110 case DW_TAG_typedef
:
12111 this_type
= read_typedef (die
, cu
);
12113 case DW_TAG_subrange_type
:
12114 this_type
= read_subrange_type (die
, cu
);
12116 case DW_TAG_base_type
:
12117 this_type
= read_base_type (die
, cu
);
12119 case DW_TAG_unspecified_type
:
12120 this_type
= read_unspecified_type (die
, cu
);
12122 case DW_TAG_namespace
:
12123 this_type
= read_namespace_type (die
, cu
);
12125 case DW_TAG_module
:
12126 this_type
= read_module_type (die
, cu
);
12129 complaint (&symfile_complaints
,
12130 _("unexpected tag in read_type_die: '%s'"),
12131 dwarf_tag_name (die
->tag
));
12138 /* See if we can figure out if the class lives in a namespace. We do
12139 this by looking for a member function; its demangled name will
12140 contain namespace info, if there is any.
12141 Return the computed name or NULL.
12142 Space for the result is allocated on the objfile's obstack.
12143 This is the full-die version of guess_partial_die_structure_name.
12144 In this case we know DIE has no useful parent. */
12147 guess_full_die_structure_name (struct die_info
*die
, struct dwarf2_cu
*cu
)
12149 struct die_info
*spec_die
;
12150 struct dwarf2_cu
*spec_cu
;
12151 struct die_info
*child
;
12154 spec_die
= die_specification (die
, &spec_cu
);
12155 if (spec_die
!= NULL
)
12161 for (child
= die
->child
;
12163 child
= child
->sibling
)
12165 if (child
->tag
== DW_TAG_subprogram
)
12167 struct attribute
*attr
;
12169 attr
= dwarf2_attr (child
, DW_AT_linkage_name
, cu
);
12171 attr
= dwarf2_attr (child
, DW_AT_MIPS_linkage_name
, cu
);
12175 = language_class_name_from_physname (cu
->language_defn
,
12179 if (actual_name
!= NULL
)
12181 char *die_name
= dwarf2_name (die
, cu
);
12183 if (die_name
!= NULL
12184 && strcmp (die_name
, actual_name
) != 0)
12186 /* Strip off the class name from the full name.
12187 We want the prefix. */
12188 int die_name_len
= strlen (die_name
);
12189 int actual_name_len
= strlen (actual_name
);
12191 /* Test for '::' as a sanity check. */
12192 if (actual_name_len
> die_name_len
+ 2
12193 && actual_name
[actual_name_len
12194 - die_name_len
- 1] == ':')
12196 obsavestring (actual_name
,
12197 actual_name_len
- die_name_len
- 2,
12198 &cu
->objfile
->objfile_obstack
);
12201 xfree (actual_name
);
12210 /* Return the name of the namespace/class that DIE is defined within,
12211 or "" if we can't tell. The caller should not xfree the result.
12213 For example, if we're within the method foo() in the following
12223 then determine_prefix on foo's die will return "N::C". */
12226 determine_prefix (struct die_info
*die
, struct dwarf2_cu
*cu
)
12228 struct die_info
*parent
, *spec_die
;
12229 struct dwarf2_cu
*spec_cu
;
12230 struct type
*parent_type
;
12232 if (cu
->language
!= language_cplus
&& cu
->language
!= language_java
12233 && cu
->language
!= language_fortran
)
12236 /* We have to be careful in the presence of DW_AT_specification.
12237 For example, with GCC 3.4, given the code
12241 // Definition of N::foo.
12245 then we'll have a tree of DIEs like this:
12247 1: DW_TAG_compile_unit
12248 2: DW_TAG_namespace // N
12249 3: DW_TAG_subprogram // declaration of N::foo
12250 4: DW_TAG_subprogram // definition of N::foo
12251 DW_AT_specification // refers to die #3
12253 Thus, when processing die #4, we have to pretend that we're in
12254 the context of its DW_AT_specification, namely the contex of die
12257 spec_die
= die_specification (die
, &spec_cu
);
12258 if (spec_die
== NULL
)
12259 parent
= die
->parent
;
12262 parent
= spec_die
->parent
;
12266 if (parent
== NULL
)
12268 else if (parent
->building_fullname
)
12271 const char *parent_name
;
12273 /* It has been seen on RealView 2.2 built binaries,
12274 DW_TAG_template_type_param types actually _defined_ as
12275 children of the parent class:
12278 template class <class Enum> Class{};
12279 Class<enum E> class_e;
12281 1: DW_TAG_class_type (Class)
12282 2: DW_TAG_enumeration_type (E)
12283 3: DW_TAG_enumerator (enum1:0)
12284 3: DW_TAG_enumerator (enum2:1)
12286 2: DW_TAG_template_type_param
12287 DW_AT_type DW_FORM_ref_udata (E)
12289 Besides being broken debug info, it can put GDB into an
12290 infinite loop. Consider:
12292 When we're building the full name for Class<E>, we'll start
12293 at Class, and go look over its template type parameters,
12294 finding E. We'll then try to build the full name of E, and
12295 reach here. We're now trying to build the full name of E,
12296 and look over the parent DIE for containing scope. In the
12297 broken case, if we followed the parent DIE of E, we'd again
12298 find Class, and once again go look at its template type
12299 arguments, etc., etc. Simply don't consider such parent die
12300 as source-level parent of this die (it can't be, the language
12301 doesn't allow it), and break the loop here. */
12302 name
= dwarf2_name (die
, cu
);
12303 parent_name
= dwarf2_name (parent
, cu
);
12304 complaint (&symfile_complaints
,
12305 _("template param type '%s' defined within parent '%s'"),
12306 name
? name
: "<unknown>",
12307 parent_name
? parent_name
: "<unknown>");
12311 switch (parent
->tag
)
12313 case DW_TAG_namespace
:
12314 parent_type
= read_type_die (parent
, cu
);
12315 /* GCC 4.0 and 4.1 had a bug (PR c++/28460) where they generated bogus
12316 DW_TAG_namespace DIEs with a name of "::" for the global namespace.
12317 Work around this problem here. */
12318 if (cu
->language
== language_cplus
12319 && strcmp (TYPE_TAG_NAME (parent_type
), "::") == 0)
12321 /* We give a name to even anonymous namespaces. */
12322 return TYPE_TAG_NAME (parent_type
);
12323 case DW_TAG_class_type
:
12324 case DW_TAG_interface_type
:
12325 case DW_TAG_structure_type
:
12326 case DW_TAG_union_type
:
12327 case DW_TAG_module
:
12328 parent_type
= read_type_die (parent
, cu
);
12329 if (TYPE_TAG_NAME (parent_type
) != NULL
)
12330 return TYPE_TAG_NAME (parent_type
);
12332 /* An anonymous structure is only allowed non-static data
12333 members; no typedefs, no member functions, et cetera.
12334 So it does not need a prefix. */
12336 case DW_TAG_compile_unit
:
12337 /* gcc-4.5 -gdwarf-4 can drop the enclosing namespace. Cope. */
12338 if (cu
->language
== language_cplus
12339 && !VEC_empty (dwarf2_section_info_def
, dwarf2_per_objfile
->types
)
12340 && die
->child
!= NULL
12341 && (die
->tag
== DW_TAG_class_type
12342 || die
->tag
== DW_TAG_structure_type
12343 || die
->tag
== DW_TAG_union_type
))
12345 char *name
= guess_full_die_structure_name (die
, cu
);
12351 return determine_prefix (parent
, cu
);
12355 /* Return a newly-allocated string formed by concatenating PREFIX and SUFFIX
12356 with appropriate separator. If PREFIX or SUFFIX is NULL or empty, then
12357 simply copy the SUFFIX or PREFIX, respectively. If OBS is non-null, perform
12358 an obconcat, otherwise allocate storage for the result. The CU argument is
12359 used to determine the language and hence, the appropriate separator. */
12361 #define MAX_SEP_LEN 7 /* strlen ("__") + strlen ("_MOD_") */
12364 typename_concat (struct obstack
*obs
, const char *prefix
, const char *suffix
,
12365 int physname
, struct dwarf2_cu
*cu
)
12367 const char *lead
= "";
12370 if (suffix
== NULL
|| suffix
[0] == '\0'
12371 || prefix
== NULL
|| prefix
[0] == '\0')
12373 else if (cu
->language
== language_java
)
12375 else if (cu
->language
== language_fortran
&& physname
)
12377 /* This is gfortran specific mangling. Normally DW_AT_linkage_name or
12378 DW_AT_MIPS_linkage_name is preferred and used instead. */
12386 if (prefix
== NULL
)
12388 if (suffix
== NULL
)
12394 = xmalloc (strlen (prefix
) + MAX_SEP_LEN
+ strlen (suffix
) + 1);
12396 strcpy (retval
, lead
);
12397 strcat (retval
, prefix
);
12398 strcat (retval
, sep
);
12399 strcat (retval
, suffix
);
12404 /* We have an obstack. */
12405 return obconcat (obs
, lead
, prefix
, sep
, suffix
, (char *) NULL
);
12409 /* Return sibling of die, NULL if no sibling. */
12411 static struct die_info
*
12412 sibling_die (struct die_info
*die
)
12414 return die
->sibling
;
12417 /* Get name of a die, return NULL if not found. */
12420 dwarf2_canonicalize_name (char *name
, struct dwarf2_cu
*cu
,
12421 struct obstack
*obstack
)
12423 if (name
&& cu
->language
== language_cplus
)
12425 char *canon_name
= cp_canonicalize_string (name
);
12427 if (canon_name
!= NULL
)
12429 if (strcmp (canon_name
, name
) != 0)
12430 name
= obsavestring (canon_name
, strlen (canon_name
),
12432 xfree (canon_name
);
12439 /* Get name of a die, return NULL if not found. */
12442 dwarf2_name (struct die_info
*die
, struct dwarf2_cu
*cu
)
12444 struct attribute
*attr
;
12446 attr
= dwarf2_attr (die
, DW_AT_name
, cu
);
12447 if ((!attr
|| !DW_STRING (attr
))
12448 && die
->tag
!= DW_TAG_class_type
12449 && die
->tag
!= DW_TAG_interface_type
12450 && die
->tag
!= DW_TAG_structure_type
12451 && die
->tag
!= DW_TAG_union_type
)
12456 case DW_TAG_compile_unit
:
12457 /* Compilation units have a DW_AT_name that is a filename, not
12458 a source language identifier. */
12459 case DW_TAG_enumeration_type
:
12460 case DW_TAG_enumerator
:
12461 /* These tags always have simple identifiers already; no need
12462 to canonicalize them. */
12463 return DW_STRING (attr
);
12465 case DW_TAG_subprogram
:
12466 /* Java constructors will all be named "<init>", so return
12467 the class name when we see this special case. */
12468 if (cu
->language
== language_java
12469 && DW_STRING (attr
) != NULL
12470 && strcmp (DW_STRING (attr
), "<init>") == 0)
12472 struct dwarf2_cu
*spec_cu
= cu
;
12473 struct die_info
*spec_die
;
12475 /* GCJ will output '<init>' for Java constructor names.
12476 For this special case, return the name of the parent class. */
12478 /* GCJ may output suprogram DIEs with AT_specification set.
12479 If so, use the name of the specified DIE. */
12480 spec_die
= die_specification (die
, &spec_cu
);
12481 if (spec_die
!= NULL
)
12482 return dwarf2_name (spec_die
, spec_cu
);
12487 if (die
->tag
== DW_TAG_class_type
)
12488 return dwarf2_name (die
, cu
);
12490 while (die
->tag
!= DW_TAG_compile_unit
);
12494 case DW_TAG_class_type
:
12495 case DW_TAG_interface_type
:
12496 case DW_TAG_structure_type
:
12497 case DW_TAG_union_type
:
12498 /* Some GCC versions emit spurious DW_AT_name attributes for unnamed
12499 structures or unions. These were of the form "._%d" in GCC 4.1,
12500 or simply "<anonymous struct>" or "<anonymous union>" in GCC 4.3
12501 and GCC 4.4. We work around this problem by ignoring these. */
12502 if (attr
&& DW_STRING (attr
)
12503 && (strncmp (DW_STRING (attr
), "._", 2) == 0
12504 || strncmp (DW_STRING (attr
), "<anonymous", 10) == 0))
12507 /* GCC might emit a nameless typedef that has a linkage name. See
12508 http://gcc.gnu.org/bugzilla/show_bug.cgi?id=47510. */
12509 if (!attr
|| DW_STRING (attr
) == NULL
)
12511 char *demangled
= NULL
;
12513 attr
= dwarf2_attr (die
, DW_AT_linkage_name
, cu
);
12515 attr
= dwarf2_attr (die
, DW_AT_MIPS_linkage_name
, cu
);
12517 if (attr
== NULL
|| DW_STRING (attr
) == NULL
)
12520 /* Avoid demangling DW_STRING (attr) the second time on a second
12521 call for the same DIE. */
12522 if (!DW_STRING_IS_CANONICAL (attr
))
12523 demangled
= cplus_demangle (DW_STRING (attr
), DMGL_TYPES
);
12527 /* FIXME: we already did this for the partial symbol... */
12529 = obsavestring (demangled
, strlen (demangled
),
12530 &cu
->objfile
->objfile_obstack
);
12531 DW_STRING_IS_CANONICAL (attr
) = 1;
12541 if (!DW_STRING_IS_CANONICAL (attr
))
12544 = dwarf2_canonicalize_name (DW_STRING (attr
), cu
,
12545 &cu
->objfile
->objfile_obstack
);
12546 DW_STRING_IS_CANONICAL (attr
) = 1;
12548 return DW_STRING (attr
);
12551 /* Return the die that this die in an extension of, or NULL if there
12552 is none. *EXT_CU is the CU containing DIE on input, and the CU
12553 containing the return value on output. */
12555 static struct die_info
*
12556 dwarf2_extension (struct die_info
*die
, struct dwarf2_cu
**ext_cu
)
12558 struct attribute
*attr
;
12560 attr
= dwarf2_attr (die
, DW_AT_extension
, *ext_cu
);
12564 return follow_die_ref (die
, attr
, ext_cu
);
12567 /* Convert a DIE tag into its string name. */
12570 dwarf_tag_name (unsigned tag
)
12574 case DW_TAG_padding
:
12575 return "DW_TAG_padding";
12576 case DW_TAG_array_type
:
12577 return "DW_TAG_array_type";
12578 case DW_TAG_class_type
:
12579 return "DW_TAG_class_type";
12580 case DW_TAG_entry_point
:
12581 return "DW_TAG_entry_point";
12582 case DW_TAG_enumeration_type
:
12583 return "DW_TAG_enumeration_type";
12584 case DW_TAG_formal_parameter
:
12585 return "DW_TAG_formal_parameter";
12586 case DW_TAG_imported_declaration
:
12587 return "DW_TAG_imported_declaration";
12589 return "DW_TAG_label";
12590 case DW_TAG_lexical_block
:
12591 return "DW_TAG_lexical_block";
12592 case DW_TAG_member
:
12593 return "DW_TAG_member";
12594 case DW_TAG_pointer_type
:
12595 return "DW_TAG_pointer_type";
12596 case DW_TAG_reference_type
:
12597 return "DW_TAG_reference_type";
12598 case DW_TAG_compile_unit
:
12599 return "DW_TAG_compile_unit";
12600 case DW_TAG_string_type
:
12601 return "DW_TAG_string_type";
12602 case DW_TAG_structure_type
:
12603 return "DW_TAG_structure_type";
12604 case DW_TAG_subroutine_type
:
12605 return "DW_TAG_subroutine_type";
12606 case DW_TAG_typedef
:
12607 return "DW_TAG_typedef";
12608 case DW_TAG_union_type
:
12609 return "DW_TAG_union_type";
12610 case DW_TAG_unspecified_parameters
:
12611 return "DW_TAG_unspecified_parameters";
12612 case DW_TAG_variant
:
12613 return "DW_TAG_variant";
12614 case DW_TAG_common_block
:
12615 return "DW_TAG_common_block";
12616 case DW_TAG_common_inclusion
:
12617 return "DW_TAG_common_inclusion";
12618 case DW_TAG_inheritance
:
12619 return "DW_TAG_inheritance";
12620 case DW_TAG_inlined_subroutine
:
12621 return "DW_TAG_inlined_subroutine";
12622 case DW_TAG_module
:
12623 return "DW_TAG_module";
12624 case DW_TAG_ptr_to_member_type
:
12625 return "DW_TAG_ptr_to_member_type";
12626 case DW_TAG_set_type
:
12627 return "DW_TAG_set_type";
12628 case DW_TAG_subrange_type
:
12629 return "DW_TAG_subrange_type";
12630 case DW_TAG_with_stmt
:
12631 return "DW_TAG_with_stmt";
12632 case DW_TAG_access_declaration
:
12633 return "DW_TAG_access_declaration";
12634 case DW_TAG_base_type
:
12635 return "DW_TAG_base_type";
12636 case DW_TAG_catch_block
:
12637 return "DW_TAG_catch_block";
12638 case DW_TAG_const_type
:
12639 return "DW_TAG_const_type";
12640 case DW_TAG_constant
:
12641 return "DW_TAG_constant";
12642 case DW_TAG_enumerator
:
12643 return "DW_TAG_enumerator";
12644 case DW_TAG_file_type
:
12645 return "DW_TAG_file_type";
12646 case DW_TAG_friend
:
12647 return "DW_TAG_friend";
12648 case DW_TAG_namelist
:
12649 return "DW_TAG_namelist";
12650 case DW_TAG_namelist_item
:
12651 return "DW_TAG_namelist_item";
12652 case DW_TAG_packed_type
:
12653 return "DW_TAG_packed_type";
12654 case DW_TAG_subprogram
:
12655 return "DW_TAG_subprogram";
12656 case DW_TAG_template_type_param
:
12657 return "DW_TAG_template_type_param";
12658 case DW_TAG_template_value_param
:
12659 return "DW_TAG_template_value_param";
12660 case DW_TAG_thrown_type
:
12661 return "DW_TAG_thrown_type";
12662 case DW_TAG_try_block
:
12663 return "DW_TAG_try_block";
12664 case DW_TAG_variant_part
:
12665 return "DW_TAG_variant_part";
12666 case DW_TAG_variable
:
12667 return "DW_TAG_variable";
12668 case DW_TAG_volatile_type
:
12669 return "DW_TAG_volatile_type";
12670 case DW_TAG_dwarf_procedure
:
12671 return "DW_TAG_dwarf_procedure";
12672 case DW_TAG_restrict_type
:
12673 return "DW_TAG_restrict_type";
12674 case DW_TAG_interface_type
:
12675 return "DW_TAG_interface_type";
12676 case DW_TAG_namespace
:
12677 return "DW_TAG_namespace";
12678 case DW_TAG_imported_module
:
12679 return "DW_TAG_imported_module";
12680 case DW_TAG_unspecified_type
:
12681 return "DW_TAG_unspecified_type";
12682 case DW_TAG_partial_unit
:
12683 return "DW_TAG_partial_unit";
12684 case DW_TAG_imported_unit
:
12685 return "DW_TAG_imported_unit";
12686 case DW_TAG_condition
:
12687 return "DW_TAG_condition";
12688 case DW_TAG_shared_type
:
12689 return "DW_TAG_shared_type";
12690 case DW_TAG_type_unit
:
12691 return "DW_TAG_type_unit";
12692 case DW_TAG_MIPS_loop
:
12693 return "DW_TAG_MIPS_loop";
12694 case DW_TAG_HP_array_descriptor
:
12695 return "DW_TAG_HP_array_descriptor";
12696 case DW_TAG_format_label
:
12697 return "DW_TAG_format_label";
12698 case DW_TAG_function_template
:
12699 return "DW_TAG_function_template";
12700 case DW_TAG_class_template
:
12701 return "DW_TAG_class_template";
12702 case DW_TAG_GNU_BINCL
:
12703 return "DW_TAG_GNU_BINCL";
12704 case DW_TAG_GNU_EINCL
:
12705 return "DW_TAG_GNU_EINCL";
12706 case DW_TAG_upc_shared_type
:
12707 return "DW_TAG_upc_shared_type";
12708 case DW_TAG_upc_strict_type
:
12709 return "DW_TAG_upc_strict_type";
12710 case DW_TAG_upc_relaxed_type
:
12711 return "DW_TAG_upc_relaxed_type";
12712 case DW_TAG_PGI_kanji_type
:
12713 return "DW_TAG_PGI_kanji_type";
12714 case DW_TAG_PGI_interface_block
:
12715 return "DW_TAG_PGI_interface_block";
12717 return "DW_TAG_<unknown>";
12721 /* Convert a DWARF attribute code into its string name. */
12724 dwarf_attr_name (unsigned attr
)
12728 case DW_AT_sibling
:
12729 return "DW_AT_sibling";
12730 case DW_AT_location
:
12731 return "DW_AT_location";
12733 return "DW_AT_name";
12734 case DW_AT_ordering
:
12735 return "DW_AT_ordering";
12736 case DW_AT_subscr_data
:
12737 return "DW_AT_subscr_data";
12738 case DW_AT_byte_size
:
12739 return "DW_AT_byte_size";
12740 case DW_AT_bit_offset
:
12741 return "DW_AT_bit_offset";
12742 case DW_AT_bit_size
:
12743 return "DW_AT_bit_size";
12744 case DW_AT_element_list
:
12745 return "DW_AT_element_list";
12746 case DW_AT_stmt_list
:
12747 return "DW_AT_stmt_list";
12749 return "DW_AT_low_pc";
12750 case DW_AT_high_pc
:
12751 return "DW_AT_high_pc";
12752 case DW_AT_language
:
12753 return "DW_AT_language";
12755 return "DW_AT_member";
12757 return "DW_AT_discr";
12758 case DW_AT_discr_value
:
12759 return "DW_AT_discr_value";
12760 case DW_AT_visibility
:
12761 return "DW_AT_visibility";
12763 return "DW_AT_import";
12764 case DW_AT_string_length
:
12765 return "DW_AT_string_length";
12766 case DW_AT_common_reference
:
12767 return "DW_AT_common_reference";
12768 case DW_AT_comp_dir
:
12769 return "DW_AT_comp_dir";
12770 case DW_AT_const_value
:
12771 return "DW_AT_const_value";
12772 case DW_AT_containing_type
:
12773 return "DW_AT_containing_type";
12774 case DW_AT_default_value
:
12775 return "DW_AT_default_value";
12777 return "DW_AT_inline";
12778 case DW_AT_is_optional
:
12779 return "DW_AT_is_optional";
12780 case DW_AT_lower_bound
:
12781 return "DW_AT_lower_bound";
12782 case DW_AT_producer
:
12783 return "DW_AT_producer";
12784 case DW_AT_prototyped
:
12785 return "DW_AT_prototyped";
12786 case DW_AT_return_addr
:
12787 return "DW_AT_return_addr";
12788 case DW_AT_start_scope
:
12789 return "DW_AT_start_scope";
12790 case DW_AT_bit_stride
:
12791 return "DW_AT_bit_stride";
12792 case DW_AT_upper_bound
:
12793 return "DW_AT_upper_bound";
12794 case DW_AT_abstract_origin
:
12795 return "DW_AT_abstract_origin";
12796 case DW_AT_accessibility
:
12797 return "DW_AT_accessibility";
12798 case DW_AT_address_class
:
12799 return "DW_AT_address_class";
12800 case DW_AT_artificial
:
12801 return "DW_AT_artificial";
12802 case DW_AT_base_types
:
12803 return "DW_AT_base_types";
12804 case DW_AT_calling_convention
:
12805 return "DW_AT_calling_convention";
12807 return "DW_AT_count";
12808 case DW_AT_data_member_location
:
12809 return "DW_AT_data_member_location";
12810 case DW_AT_decl_column
:
12811 return "DW_AT_decl_column";
12812 case DW_AT_decl_file
:
12813 return "DW_AT_decl_file";
12814 case DW_AT_decl_line
:
12815 return "DW_AT_decl_line";
12816 case DW_AT_declaration
:
12817 return "DW_AT_declaration";
12818 case DW_AT_discr_list
:
12819 return "DW_AT_discr_list";
12820 case DW_AT_encoding
:
12821 return "DW_AT_encoding";
12822 case DW_AT_external
:
12823 return "DW_AT_external";
12824 case DW_AT_frame_base
:
12825 return "DW_AT_frame_base";
12827 return "DW_AT_friend";
12828 case DW_AT_identifier_case
:
12829 return "DW_AT_identifier_case";
12830 case DW_AT_macro_info
:
12831 return "DW_AT_macro_info";
12832 case DW_AT_namelist_items
:
12833 return "DW_AT_namelist_items";
12834 case DW_AT_priority
:
12835 return "DW_AT_priority";
12836 case DW_AT_segment
:
12837 return "DW_AT_segment";
12838 case DW_AT_specification
:
12839 return "DW_AT_specification";
12840 case DW_AT_static_link
:
12841 return "DW_AT_static_link";
12843 return "DW_AT_type";
12844 case DW_AT_use_location
:
12845 return "DW_AT_use_location";
12846 case DW_AT_variable_parameter
:
12847 return "DW_AT_variable_parameter";
12848 case DW_AT_virtuality
:
12849 return "DW_AT_virtuality";
12850 case DW_AT_vtable_elem_location
:
12851 return "DW_AT_vtable_elem_location";
12852 /* DWARF 3 values. */
12853 case DW_AT_allocated
:
12854 return "DW_AT_allocated";
12855 case DW_AT_associated
:
12856 return "DW_AT_associated";
12857 case DW_AT_data_location
:
12858 return "DW_AT_data_location";
12859 case DW_AT_byte_stride
:
12860 return "DW_AT_byte_stride";
12861 case DW_AT_entry_pc
:
12862 return "DW_AT_entry_pc";
12863 case DW_AT_use_UTF8
:
12864 return "DW_AT_use_UTF8";
12865 case DW_AT_extension
:
12866 return "DW_AT_extension";
12868 return "DW_AT_ranges";
12869 case DW_AT_trampoline
:
12870 return "DW_AT_trampoline";
12871 case DW_AT_call_column
:
12872 return "DW_AT_call_column";
12873 case DW_AT_call_file
:
12874 return "DW_AT_call_file";
12875 case DW_AT_call_line
:
12876 return "DW_AT_call_line";
12877 case DW_AT_description
:
12878 return "DW_AT_description";
12879 case DW_AT_binary_scale
:
12880 return "DW_AT_binary_scale";
12881 case DW_AT_decimal_scale
:
12882 return "DW_AT_decimal_scale";
12884 return "DW_AT_small";
12885 case DW_AT_decimal_sign
:
12886 return "DW_AT_decimal_sign";
12887 case DW_AT_digit_count
:
12888 return "DW_AT_digit_count";
12889 case DW_AT_picture_string
:
12890 return "DW_AT_picture_string";
12891 case DW_AT_mutable
:
12892 return "DW_AT_mutable";
12893 case DW_AT_threads_scaled
:
12894 return "DW_AT_threads_scaled";
12895 case DW_AT_explicit
:
12896 return "DW_AT_explicit";
12897 case DW_AT_object_pointer
:
12898 return "DW_AT_object_pointer";
12899 case DW_AT_endianity
:
12900 return "DW_AT_endianity";
12901 case DW_AT_elemental
:
12902 return "DW_AT_elemental";
12904 return "DW_AT_pure";
12905 case DW_AT_recursive
:
12906 return "DW_AT_recursive";
12907 /* DWARF 4 values. */
12908 case DW_AT_signature
:
12909 return "DW_AT_signature";
12910 case DW_AT_linkage_name
:
12911 return "DW_AT_linkage_name";
12912 /* SGI/MIPS extensions. */
12913 #ifdef MIPS /* collides with DW_AT_HP_block_index */
12914 case DW_AT_MIPS_fde
:
12915 return "DW_AT_MIPS_fde";
12917 case DW_AT_MIPS_loop_begin
:
12918 return "DW_AT_MIPS_loop_begin";
12919 case DW_AT_MIPS_tail_loop_begin
:
12920 return "DW_AT_MIPS_tail_loop_begin";
12921 case DW_AT_MIPS_epilog_begin
:
12922 return "DW_AT_MIPS_epilog_begin";
12923 case DW_AT_MIPS_loop_unroll_factor
:
12924 return "DW_AT_MIPS_loop_unroll_factor";
12925 case DW_AT_MIPS_software_pipeline_depth
:
12926 return "DW_AT_MIPS_software_pipeline_depth";
12927 case DW_AT_MIPS_linkage_name
:
12928 return "DW_AT_MIPS_linkage_name";
12929 case DW_AT_MIPS_stride
:
12930 return "DW_AT_MIPS_stride";
12931 case DW_AT_MIPS_abstract_name
:
12932 return "DW_AT_MIPS_abstract_name";
12933 case DW_AT_MIPS_clone_origin
:
12934 return "DW_AT_MIPS_clone_origin";
12935 case DW_AT_MIPS_has_inlines
:
12936 return "DW_AT_MIPS_has_inlines";
12937 /* HP extensions. */
12938 #ifndef MIPS /* collides with DW_AT_MIPS_fde */
12939 case DW_AT_HP_block_index
:
12940 return "DW_AT_HP_block_index";
12942 case DW_AT_HP_unmodifiable
:
12943 return "DW_AT_HP_unmodifiable";
12944 case DW_AT_HP_actuals_stmt_list
:
12945 return "DW_AT_HP_actuals_stmt_list";
12946 case DW_AT_HP_proc_per_section
:
12947 return "DW_AT_HP_proc_per_section";
12948 case DW_AT_HP_raw_data_ptr
:
12949 return "DW_AT_HP_raw_data_ptr";
12950 case DW_AT_HP_pass_by_reference
:
12951 return "DW_AT_HP_pass_by_reference";
12952 case DW_AT_HP_opt_level
:
12953 return "DW_AT_HP_opt_level";
12954 case DW_AT_HP_prof_version_id
:
12955 return "DW_AT_HP_prof_version_id";
12956 case DW_AT_HP_opt_flags
:
12957 return "DW_AT_HP_opt_flags";
12958 case DW_AT_HP_cold_region_low_pc
:
12959 return "DW_AT_HP_cold_region_low_pc";
12960 case DW_AT_HP_cold_region_high_pc
:
12961 return "DW_AT_HP_cold_region_high_pc";
12962 case DW_AT_HP_all_variables_modifiable
:
12963 return "DW_AT_HP_all_variables_modifiable";
12964 case DW_AT_HP_linkage_name
:
12965 return "DW_AT_HP_linkage_name";
12966 case DW_AT_HP_prof_flags
:
12967 return "DW_AT_HP_prof_flags";
12968 /* GNU extensions. */
12969 case DW_AT_sf_names
:
12970 return "DW_AT_sf_names";
12971 case DW_AT_src_info
:
12972 return "DW_AT_src_info";
12973 case DW_AT_mac_info
:
12974 return "DW_AT_mac_info";
12975 case DW_AT_src_coords
:
12976 return "DW_AT_src_coords";
12977 case DW_AT_body_begin
:
12978 return "DW_AT_body_begin";
12979 case DW_AT_body_end
:
12980 return "DW_AT_body_end";
12981 case DW_AT_GNU_vector
:
12982 return "DW_AT_GNU_vector";
12983 case DW_AT_GNU_odr_signature
:
12984 return "DW_AT_GNU_odr_signature";
12985 /* VMS extensions. */
12986 case DW_AT_VMS_rtnbeg_pd_address
:
12987 return "DW_AT_VMS_rtnbeg_pd_address";
12988 /* UPC extension. */
12989 case DW_AT_upc_threads_scaled
:
12990 return "DW_AT_upc_threads_scaled";
12991 /* PGI (STMicroelectronics) extensions. */
12992 case DW_AT_PGI_lbase
:
12993 return "DW_AT_PGI_lbase";
12994 case DW_AT_PGI_soffset
:
12995 return "DW_AT_PGI_soffset";
12996 case DW_AT_PGI_lstride
:
12997 return "DW_AT_PGI_lstride";
12999 return "DW_AT_<unknown>";
13003 /* Convert a DWARF value form code into its string name. */
13006 dwarf_form_name (unsigned form
)
13011 return "DW_FORM_addr";
13012 case DW_FORM_block2
:
13013 return "DW_FORM_block2";
13014 case DW_FORM_block4
:
13015 return "DW_FORM_block4";
13016 case DW_FORM_data2
:
13017 return "DW_FORM_data2";
13018 case DW_FORM_data4
:
13019 return "DW_FORM_data4";
13020 case DW_FORM_data8
:
13021 return "DW_FORM_data8";
13022 case DW_FORM_string
:
13023 return "DW_FORM_string";
13024 case DW_FORM_block
:
13025 return "DW_FORM_block";
13026 case DW_FORM_block1
:
13027 return "DW_FORM_block1";
13028 case DW_FORM_data1
:
13029 return "DW_FORM_data1";
13031 return "DW_FORM_flag";
13032 case DW_FORM_sdata
:
13033 return "DW_FORM_sdata";
13035 return "DW_FORM_strp";
13036 case DW_FORM_udata
:
13037 return "DW_FORM_udata";
13038 case DW_FORM_ref_addr
:
13039 return "DW_FORM_ref_addr";
13041 return "DW_FORM_ref1";
13043 return "DW_FORM_ref2";
13045 return "DW_FORM_ref4";
13047 return "DW_FORM_ref8";
13048 case DW_FORM_ref_udata
:
13049 return "DW_FORM_ref_udata";
13050 case DW_FORM_indirect
:
13051 return "DW_FORM_indirect";
13052 case DW_FORM_sec_offset
:
13053 return "DW_FORM_sec_offset";
13054 case DW_FORM_exprloc
:
13055 return "DW_FORM_exprloc";
13056 case DW_FORM_flag_present
:
13057 return "DW_FORM_flag_present";
13058 case DW_FORM_ref_sig8
:
13059 return "DW_FORM_ref_sig8";
13061 return "DW_FORM_<unknown>";
13065 /* Convert a DWARF stack opcode into its string name. */
13068 dwarf_stack_op_name (unsigned op
)
13073 return "DW_OP_addr";
13075 return "DW_OP_deref";
13076 case DW_OP_const1u
:
13077 return "DW_OP_const1u";
13078 case DW_OP_const1s
:
13079 return "DW_OP_const1s";
13080 case DW_OP_const2u
:
13081 return "DW_OP_const2u";
13082 case DW_OP_const2s
:
13083 return "DW_OP_const2s";
13084 case DW_OP_const4u
:
13085 return "DW_OP_const4u";
13086 case DW_OP_const4s
:
13087 return "DW_OP_const4s";
13088 case DW_OP_const8u
:
13089 return "DW_OP_const8u";
13090 case DW_OP_const8s
:
13091 return "DW_OP_const8s";
13093 return "DW_OP_constu";
13095 return "DW_OP_consts";
13097 return "DW_OP_dup";
13099 return "DW_OP_drop";
13101 return "DW_OP_over";
13103 return "DW_OP_pick";
13105 return "DW_OP_swap";
13107 return "DW_OP_rot";
13109 return "DW_OP_xderef";
13111 return "DW_OP_abs";
13113 return "DW_OP_and";
13115 return "DW_OP_div";
13117 return "DW_OP_minus";
13119 return "DW_OP_mod";
13121 return "DW_OP_mul";
13123 return "DW_OP_neg";
13125 return "DW_OP_not";
13129 return "DW_OP_plus";
13130 case DW_OP_plus_uconst
:
13131 return "DW_OP_plus_uconst";
13133 return "DW_OP_shl";
13135 return "DW_OP_shr";
13137 return "DW_OP_shra";
13139 return "DW_OP_xor";
13141 return "DW_OP_bra";
13155 return "DW_OP_skip";
13157 return "DW_OP_lit0";
13159 return "DW_OP_lit1";
13161 return "DW_OP_lit2";
13163 return "DW_OP_lit3";
13165 return "DW_OP_lit4";
13167 return "DW_OP_lit5";
13169 return "DW_OP_lit6";
13171 return "DW_OP_lit7";
13173 return "DW_OP_lit8";
13175 return "DW_OP_lit9";
13177 return "DW_OP_lit10";
13179 return "DW_OP_lit11";
13181 return "DW_OP_lit12";
13183 return "DW_OP_lit13";
13185 return "DW_OP_lit14";
13187 return "DW_OP_lit15";
13189 return "DW_OP_lit16";
13191 return "DW_OP_lit17";
13193 return "DW_OP_lit18";
13195 return "DW_OP_lit19";
13197 return "DW_OP_lit20";
13199 return "DW_OP_lit21";
13201 return "DW_OP_lit22";
13203 return "DW_OP_lit23";
13205 return "DW_OP_lit24";
13207 return "DW_OP_lit25";
13209 return "DW_OP_lit26";
13211 return "DW_OP_lit27";
13213 return "DW_OP_lit28";
13215 return "DW_OP_lit29";
13217 return "DW_OP_lit30";
13219 return "DW_OP_lit31";
13221 return "DW_OP_reg0";
13223 return "DW_OP_reg1";
13225 return "DW_OP_reg2";
13227 return "DW_OP_reg3";
13229 return "DW_OP_reg4";
13231 return "DW_OP_reg5";
13233 return "DW_OP_reg6";
13235 return "DW_OP_reg7";
13237 return "DW_OP_reg8";
13239 return "DW_OP_reg9";
13241 return "DW_OP_reg10";
13243 return "DW_OP_reg11";
13245 return "DW_OP_reg12";
13247 return "DW_OP_reg13";
13249 return "DW_OP_reg14";
13251 return "DW_OP_reg15";
13253 return "DW_OP_reg16";
13255 return "DW_OP_reg17";
13257 return "DW_OP_reg18";
13259 return "DW_OP_reg19";
13261 return "DW_OP_reg20";
13263 return "DW_OP_reg21";
13265 return "DW_OP_reg22";
13267 return "DW_OP_reg23";
13269 return "DW_OP_reg24";
13271 return "DW_OP_reg25";
13273 return "DW_OP_reg26";
13275 return "DW_OP_reg27";
13277 return "DW_OP_reg28";
13279 return "DW_OP_reg29";
13281 return "DW_OP_reg30";
13283 return "DW_OP_reg31";
13285 return "DW_OP_breg0";
13287 return "DW_OP_breg1";
13289 return "DW_OP_breg2";
13291 return "DW_OP_breg3";
13293 return "DW_OP_breg4";
13295 return "DW_OP_breg5";
13297 return "DW_OP_breg6";
13299 return "DW_OP_breg7";
13301 return "DW_OP_breg8";
13303 return "DW_OP_breg9";
13305 return "DW_OP_breg10";
13307 return "DW_OP_breg11";
13309 return "DW_OP_breg12";
13311 return "DW_OP_breg13";
13313 return "DW_OP_breg14";
13315 return "DW_OP_breg15";
13317 return "DW_OP_breg16";
13319 return "DW_OP_breg17";
13321 return "DW_OP_breg18";
13323 return "DW_OP_breg19";
13325 return "DW_OP_breg20";
13327 return "DW_OP_breg21";
13329 return "DW_OP_breg22";
13331 return "DW_OP_breg23";
13333 return "DW_OP_breg24";
13335 return "DW_OP_breg25";
13337 return "DW_OP_breg26";
13339 return "DW_OP_breg27";
13341 return "DW_OP_breg28";
13343 return "DW_OP_breg29";
13345 return "DW_OP_breg30";
13347 return "DW_OP_breg31";
13349 return "DW_OP_regx";
13351 return "DW_OP_fbreg";
13353 return "DW_OP_bregx";
13355 return "DW_OP_piece";
13356 case DW_OP_deref_size
:
13357 return "DW_OP_deref_size";
13358 case DW_OP_xderef_size
:
13359 return "DW_OP_xderef_size";
13361 return "DW_OP_nop";
13362 /* DWARF 3 extensions. */
13363 case DW_OP_push_object_address
:
13364 return "DW_OP_push_object_address";
13366 return "DW_OP_call2";
13368 return "DW_OP_call4";
13369 case DW_OP_call_ref
:
13370 return "DW_OP_call_ref";
13371 case DW_OP_form_tls_address
:
13372 return "DW_OP_form_tls_address";
13373 case DW_OP_call_frame_cfa
:
13374 return "DW_OP_call_frame_cfa";
13375 case DW_OP_bit_piece
:
13376 return "DW_OP_bit_piece";
13377 /* DWARF 4 extensions. */
13378 case DW_OP_implicit_value
:
13379 return "DW_OP_implicit_value";
13380 case DW_OP_stack_value
:
13381 return "DW_OP_stack_value";
13382 /* GNU extensions. */
13383 case DW_OP_GNU_push_tls_address
:
13384 return "DW_OP_GNU_push_tls_address";
13385 case DW_OP_GNU_uninit
:
13386 return "DW_OP_GNU_uninit";
13387 case DW_OP_GNU_implicit_pointer
:
13388 return "DW_OP_GNU_implicit_pointer";
13389 case DW_OP_GNU_entry_value
:
13390 return "DW_OP_GNU_entry_value";
13391 case DW_OP_GNU_const_type
:
13392 return "DW_OP_GNU_const_type";
13393 case DW_OP_GNU_regval_type
:
13394 return "DW_OP_GNU_regval_type";
13395 case DW_OP_GNU_deref_type
:
13396 return "DW_OP_GNU_deref_type";
13397 case DW_OP_GNU_convert
:
13398 return "DW_OP_GNU_convert";
13399 case DW_OP_GNU_reinterpret
:
13400 return "DW_OP_GNU_reinterpret";
13407 dwarf_bool_name (unsigned mybool
)
13415 /* Convert a DWARF type code into its string name. */
13418 dwarf_type_encoding_name (unsigned enc
)
13423 return "DW_ATE_void";
13424 case DW_ATE_address
:
13425 return "DW_ATE_address";
13426 case DW_ATE_boolean
:
13427 return "DW_ATE_boolean";
13428 case DW_ATE_complex_float
:
13429 return "DW_ATE_complex_float";
13431 return "DW_ATE_float";
13432 case DW_ATE_signed
:
13433 return "DW_ATE_signed";
13434 case DW_ATE_signed_char
:
13435 return "DW_ATE_signed_char";
13436 case DW_ATE_unsigned
:
13437 return "DW_ATE_unsigned";
13438 case DW_ATE_unsigned_char
:
13439 return "DW_ATE_unsigned_char";
13441 case DW_ATE_imaginary_float
:
13442 return "DW_ATE_imaginary_float";
13443 case DW_ATE_packed_decimal
:
13444 return "DW_ATE_packed_decimal";
13445 case DW_ATE_numeric_string
:
13446 return "DW_ATE_numeric_string";
13447 case DW_ATE_edited
:
13448 return "DW_ATE_edited";
13449 case DW_ATE_signed_fixed
:
13450 return "DW_ATE_signed_fixed";
13451 case DW_ATE_unsigned_fixed
:
13452 return "DW_ATE_unsigned_fixed";
13453 case DW_ATE_decimal_float
:
13454 return "DW_ATE_decimal_float";
13457 return "DW_ATE_UTF";
13458 /* HP extensions. */
13459 case DW_ATE_HP_float80
:
13460 return "DW_ATE_HP_float80";
13461 case DW_ATE_HP_complex_float80
:
13462 return "DW_ATE_HP_complex_float80";
13463 case DW_ATE_HP_float128
:
13464 return "DW_ATE_HP_float128";
13465 case DW_ATE_HP_complex_float128
:
13466 return "DW_ATE_HP_complex_float128";
13467 case DW_ATE_HP_floathpintel
:
13468 return "DW_ATE_HP_floathpintel";
13469 case DW_ATE_HP_imaginary_float80
:
13470 return "DW_ATE_HP_imaginary_float80";
13471 case DW_ATE_HP_imaginary_float128
:
13472 return "DW_ATE_HP_imaginary_float128";
13474 return "DW_ATE_<unknown>";
13478 /* Convert a DWARF call frame info operation to its string name. */
13482 dwarf_cfi_name (unsigned cfi_opc
)
13486 case DW_CFA_advance_loc
:
13487 return "DW_CFA_advance_loc";
13488 case DW_CFA_offset
:
13489 return "DW_CFA_offset";
13490 case DW_CFA_restore
:
13491 return "DW_CFA_restore";
13493 return "DW_CFA_nop";
13494 case DW_CFA_set_loc
:
13495 return "DW_CFA_set_loc";
13496 case DW_CFA_advance_loc1
:
13497 return "DW_CFA_advance_loc1";
13498 case DW_CFA_advance_loc2
:
13499 return "DW_CFA_advance_loc2";
13500 case DW_CFA_advance_loc4
:
13501 return "DW_CFA_advance_loc4";
13502 case DW_CFA_offset_extended
:
13503 return "DW_CFA_offset_extended";
13504 case DW_CFA_restore_extended
:
13505 return "DW_CFA_restore_extended";
13506 case DW_CFA_undefined
:
13507 return "DW_CFA_undefined";
13508 case DW_CFA_same_value
:
13509 return "DW_CFA_same_value";
13510 case DW_CFA_register
:
13511 return "DW_CFA_register";
13512 case DW_CFA_remember_state
:
13513 return "DW_CFA_remember_state";
13514 case DW_CFA_restore_state
:
13515 return "DW_CFA_restore_state";
13516 case DW_CFA_def_cfa
:
13517 return "DW_CFA_def_cfa";
13518 case DW_CFA_def_cfa_register
:
13519 return "DW_CFA_def_cfa_register";
13520 case DW_CFA_def_cfa_offset
:
13521 return "DW_CFA_def_cfa_offset";
13523 case DW_CFA_def_cfa_expression
:
13524 return "DW_CFA_def_cfa_expression";
13525 case DW_CFA_expression
:
13526 return "DW_CFA_expression";
13527 case DW_CFA_offset_extended_sf
:
13528 return "DW_CFA_offset_extended_sf";
13529 case DW_CFA_def_cfa_sf
:
13530 return "DW_CFA_def_cfa_sf";
13531 case DW_CFA_def_cfa_offset_sf
:
13532 return "DW_CFA_def_cfa_offset_sf";
13533 case DW_CFA_val_offset
:
13534 return "DW_CFA_val_offset";
13535 case DW_CFA_val_offset_sf
:
13536 return "DW_CFA_val_offset_sf";
13537 case DW_CFA_val_expression
:
13538 return "DW_CFA_val_expression";
13539 /* SGI/MIPS specific. */
13540 case DW_CFA_MIPS_advance_loc8
:
13541 return "DW_CFA_MIPS_advance_loc8";
13542 /* GNU extensions. */
13543 case DW_CFA_GNU_window_save
:
13544 return "DW_CFA_GNU_window_save";
13545 case DW_CFA_GNU_args_size
:
13546 return "DW_CFA_GNU_args_size";
13547 case DW_CFA_GNU_negative_offset_extended
:
13548 return "DW_CFA_GNU_negative_offset_extended";
13550 return "DW_CFA_<unknown>";
13556 dump_die_shallow (struct ui_file
*f
, int indent
, struct die_info
*die
)
13560 print_spaces (indent
, f
);
13561 fprintf_unfiltered (f
, "Die: %s (abbrev %d, offset 0x%x)\n",
13562 dwarf_tag_name (die
->tag
), die
->abbrev
, die
->offset
);
13564 if (die
->parent
!= NULL
)
13566 print_spaces (indent
, f
);
13567 fprintf_unfiltered (f
, " parent at offset: 0x%x\n",
13568 die
->parent
->offset
);
13571 print_spaces (indent
, f
);
13572 fprintf_unfiltered (f
, " has children: %s\n",
13573 dwarf_bool_name (die
->child
!= NULL
));
13575 print_spaces (indent
, f
);
13576 fprintf_unfiltered (f
, " attributes:\n");
13578 for (i
= 0; i
< die
->num_attrs
; ++i
)
13580 print_spaces (indent
, f
);
13581 fprintf_unfiltered (f
, " %s (%s) ",
13582 dwarf_attr_name (die
->attrs
[i
].name
),
13583 dwarf_form_name (die
->attrs
[i
].form
));
13585 switch (die
->attrs
[i
].form
)
13587 case DW_FORM_ref_addr
:
13589 fprintf_unfiltered (f
, "address: ");
13590 fputs_filtered (hex_string (DW_ADDR (&die
->attrs
[i
])), f
);
13592 case DW_FORM_block2
:
13593 case DW_FORM_block4
:
13594 case DW_FORM_block
:
13595 case DW_FORM_block1
:
13596 fprintf_unfiltered (f
, "block: size %d",
13597 DW_BLOCK (&die
->attrs
[i
])->size
);
13599 case DW_FORM_exprloc
:
13600 fprintf_unfiltered (f
, "expression: size %u",
13601 DW_BLOCK (&die
->attrs
[i
])->size
);
13606 fprintf_unfiltered (f
, "constant ref: 0x%lx (adjusted)",
13607 (long) (DW_ADDR (&die
->attrs
[i
])));
13609 case DW_FORM_data1
:
13610 case DW_FORM_data2
:
13611 case DW_FORM_data4
:
13612 case DW_FORM_data8
:
13613 case DW_FORM_udata
:
13614 case DW_FORM_sdata
:
13615 fprintf_unfiltered (f
, "constant: %s",
13616 pulongest (DW_UNSND (&die
->attrs
[i
])));
13618 case DW_FORM_sec_offset
:
13619 fprintf_unfiltered (f
, "section offset: %s",
13620 pulongest (DW_UNSND (&die
->attrs
[i
])));
13622 case DW_FORM_ref_sig8
:
13623 if (DW_SIGNATURED_TYPE (&die
->attrs
[i
]) != NULL
)
13624 fprintf_unfiltered (f
, "signatured type, offset: 0x%x",
13625 DW_SIGNATURED_TYPE (&die
->attrs
[i
])->per_cu
.offset
);
13627 fprintf_unfiltered (f
, "signatured type, offset: unknown");
13629 case DW_FORM_string
:
13631 fprintf_unfiltered (f
, "string: \"%s\" (%s canonicalized)",
13632 DW_STRING (&die
->attrs
[i
])
13633 ? DW_STRING (&die
->attrs
[i
]) : "",
13634 DW_STRING_IS_CANONICAL (&die
->attrs
[i
]) ? "is" : "not");
13637 if (DW_UNSND (&die
->attrs
[i
]))
13638 fprintf_unfiltered (f
, "flag: TRUE");
13640 fprintf_unfiltered (f
, "flag: FALSE");
13642 case DW_FORM_flag_present
:
13643 fprintf_unfiltered (f
, "flag: TRUE");
13645 case DW_FORM_indirect
:
13646 /* The reader will have reduced the indirect form to
13647 the "base form" so this form should not occur. */
13648 fprintf_unfiltered (f
,
13649 "unexpected attribute form: DW_FORM_indirect");
13652 fprintf_unfiltered (f
, "unsupported attribute form: %d.",
13653 die
->attrs
[i
].form
);
13656 fprintf_unfiltered (f
, "\n");
13661 dump_die_for_error (struct die_info
*die
)
13663 dump_die_shallow (gdb_stderr
, 0, die
);
13667 dump_die_1 (struct ui_file
*f
, int level
, int max_level
, struct die_info
*die
)
13669 int indent
= level
* 4;
13671 gdb_assert (die
!= NULL
);
13673 if (level
>= max_level
)
13676 dump_die_shallow (f
, indent
, die
);
13678 if (die
->child
!= NULL
)
13680 print_spaces (indent
, f
);
13681 fprintf_unfiltered (f
, " Children:");
13682 if (level
+ 1 < max_level
)
13684 fprintf_unfiltered (f
, "\n");
13685 dump_die_1 (f
, level
+ 1, max_level
, die
->child
);
13689 fprintf_unfiltered (f
,
13690 " [not printed, max nesting level reached]\n");
13694 if (die
->sibling
!= NULL
&& level
> 0)
13696 dump_die_1 (f
, level
, max_level
, die
->sibling
);
13700 /* This is called from the pdie macro in gdbinit.in.
13701 It's not static so gcc will keep a copy callable from gdb. */
13704 dump_die (struct die_info
*die
, int max_level
)
13706 dump_die_1 (gdb_stdlog
, 0, max_level
, die
);
13710 store_in_ref_table (struct die_info
*die
, struct dwarf2_cu
*cu
)
13714 slot
= htab_find_slot_with_hash (cu
->die_hash
, die
, die
->offset
, INSERT
);
13720 is_ref_attr (struct attribute
*attr
)
13722 switch (attr
->form
)
13724 case DW_FORM_ref_addr
:
13729 case DW_FORM_ref_udata
:
13736 static unsigned int
13737 dwarf2_get_ref_die_offset (struct attribute
*attr
)
13739 if (is_ref_attr (attr
))
13740 return DW_ADDR (attr
);
13742 complaint (&symfile_complaints
,
13743 _("unsupported die ref attribute form: '%s'"),
13744 dwarf_form_name (attr
->form
));
13748 /* Return the constant value held by ATTR. Return DEFAULT_VALUE if
13749 * the value held by the attribute is not constant. */
13752 dwarf2_get_attr_constant_value (struct attribute
*attr
, int default_value
)
13754 if (attr
->form
== DW_FORM_sdata
)
13755 return DW_SND (attr
);
13756 else if (attr
->form
== DW_FORM_udata
13757 || attr
->form
== DW_FORM_data1
13758 || attr
->form
== DW_FORM_data2
13759 || attr
->form
== DW_FORM_data4
13760 || attr
->form
== DW_FORM_data8
)
13761 return DW_UNSND (attr
);
13764 complaint (&symfile_complaints
,
13765 _("Attribute value is not a constant (%s)"),
13766 dwarf_form_name (attr
->form
));
13767 return default_value
;
13771 /* THIS_CU has a reference to PER_CU. If necessary, load the new compilation
13772 unit and add it to our queue.
13773 The result is non-zero if PER_CU was queued, otherwise the result is zero
13774 meaning either PER_CU is already queued or it is already loaded. */
13777 maybe_queue_comp_unit (struct dwarf2_cu
*this_cu
,
13778 struct dwarf2_per_cu_data
*per_cu
)
13780 /* We may arrive here during partial symbol reading, if we need full
13781 DIEs to process an unusual case (e.g. template arguments). Do
13782 not queue PER_CU, just tell our caller to load its DIEs. */
13783 if (dwarf2_per_objfile
->reading_partial_symbols
)
13785 if (per_cu
->cu
== NULL
|| per_cu
->cu
->dies
== NULL
)
13790 /* Mark the dependence relation so that we don't flush PER_CU
13792 dwarf2_add_dependence (this_cu
, per_cu
);
13794 /* If it's already on the queue, we have nothing to do. */
13795 if (per_cu
->queued
)
13798 /* If the compilation unit is already loaded, just mark it as
13800 if (per_cu
->cu
!= NULL
)
13802 per_cu
->cu
->last_used
= 0;
13806 /* Add it to the queue. */
13807 queue_comp_unit (per_cu
, this_cu
->objfile
);
13812 /* Follow reference or signature attribute ATTR of SRC_DIE.
13813 On entry *REF_CU is the CU of SRC_DIE.
13814 On exit *REF_CU is the CU of the result. */
13816 static struct die_info
*
13817 follow_die_ref_or_sig (struct die_info
*src_die
, struct attribute
*attr
,
13818 struct dwarf2_cu
**ref_cu
)
13820 struct die_info
*die
;
13822 if (is_ref_attr (attr
))
13823 die
= follow_die_ref (src_die
, attr
, ref_cu
);
13824 else if (attr
->form
== DW_FORM_ref_sig8
)
13825 die
= follow_die_sig (src_die
, attr
, ref_cu
);
13828 dump_die_for_error (src_die
);
13829 error (_("Dwarf Error: Expected reference attribute [in module %s]"),
13830 (*ref_cu
)->objfile
->name
);
13836 /* Follow reference OFFSET.
13837 On entry *REF_CU is the CU of the source die referencing OFFSET.
13838 On exit *REF_CU is the CU of the result.
13839 Returns NULL if OFFSET is invalid. */
13841 static struct die_info
*
13842 follow_die_offset (unsigned int offset
, struct dwarf2_cu
**ref_cu
)
13844 struct die_info temp_die
;
13845 struct dwarf2_cu
*target_cu
, *cu
= *ref_cu
;
13847 gdb_assert (cu
->per_cu
!= NULL
);
13851 if (cu
->per_cu
->debug_type_section
)
13853 /* .debug_types CUs cannot reference anything outside their CU.
13854 If they need to, they have to reference a signatured type via
13855 DW_FORM_ref_sig8. */
13856 if (! offset_in_cu_p (&cu
->header
, offset
))
13859 else if (! offset_in_cu_p (&cu
->header
, offset
))
13861 struct dwarf2_per_cu_data
*per_cu
;
13863 per_cu
= dwarf2_find_containing_comp_unit (offset
, cu
->objfile
);
13865 /* If necessary, add it to the queue and load its DIEs. */
13866 if (maybe_queue_comp_unit (cu
, per_cu
))
13867 load_full_comp_unit (per_cu
, cu
->objfile
);
13869 target_cu
= per_cu
->cu
;
13871 else if (cu
->dies
== NULL
)
13873 /* We're loading full DIEs during partial symbol reading. */
13874 gdb_assert (dwarf2_per_objfile
->reading_partial_symbols
);
13875 load_full_comp_unit (cu
->per_cu
, cu
->objfile
);
13878 *ref_cu
= target_cu
;
13879 temp_die
.offset
= offset
;
13880 return htab_find_with_hash (target_cu
->die_hash
, &temp_die
, offset
);
13883 /* Follow reference attribute ATTR of SRC_DIE.
13884 On entry *REF_CU is the CU of SRC_DIE.
13885 On exit *REF_CU is the CU of the result. */
13887 static struct die_info
*
13888 follow_die_ref (struct die_info
*src_die
, struct attribute
*attr
,
13889 struct dwarf2_cu
**ref_cu
)
13891 unsigned int offset
= dwarf2_get_ref_die_offset (attr
);
13892 struct dwarf2_cu
*cu
= *ref_cu
;
13893 struct die_info
*die
;
13895 die
= follow_die_offset (offset
, ref_cu
);
13897 error (_("Dwarf Error: Cannot find DIE at 0x%x referenced from DIE "
13898 "at 0x%x [in module %s]"),
13899 offset
, src_die
->offset
, cu
->objfile
->name
);
13904 /* Return DWARF block and its CU referenced by OFFSET at PER_CU. Returned
13905 value is intended for DW_OP_call*. You must call xfree on returned
13906 dwarf2_locexpr_baton->data. */
13908 struct dwarf2_locexpr_baton
13909 dwarf2_fetch_die_location_block (unsigned int offset
,
13910 struct dwarf2_per_cu_data
*per_cu
,
13911 CORE_ADDR (*get_frame_pc
) (void *baton
),
13914 struct dwarf2_cu
*cu
;
13915 struct die_info
*die
;
13916 struct attribute
*attr
;
13917 struct dwarf2_locexpr_baton retval
;
13919 dw2_setup (per_cu
->objfile
);
13921 if (per_cu
->cu
== NULL
)
13925 die
= follow_die_offset (offset
, &cu
);
13927 error (_("Dwarf Error: Cannot find DIE at 0x%x referenced in module %s"),
13928 offset
, per_cu
->cu
->objfile
->name
);
13930 attr
= dwarf2_attr (die
, DW_AT_location
, cu
);
13933 /* DWARF: "If there is no such attribute, then there is no effect.". */
13935 retval
.data
= NULL
;
13938 else if (attr_form_is_section_offset (attr
))
13940 struct dwarf2_loclist_baton loclist_baton
;
13941 CORE_ADDR pc
= (*get_frame_pc
) (baton
);
13944 fill_in_loclist_baton (cu
, &loclist_baton
, attr
);
13946 retval
.data
= dwarf2_find_location_expression (&loclist_baton
,
13948 retval
.size
= size
;
13952 if (!attr_form_is_block (attr
))
13953 error (_("Dwarf Error: DIE at 0x%x referenced in module %s "
13954 "is neither DW_FORM_block* nor DW_FORM_exprloc"),
13955 offset
, per_cu
->cu
->objfile
->name
);
13957 retval
.data
= DW_BLOCK (attr
)->data
;
13958 retval
.size
= DW_BLOCK (attr
)->size
;
13960 retval
.per_cu
= cu
->per_cu
;
13963 retval
.data
= xmemdup (retval
.data
, retval
.size
, retval
.size
);
13965 age_cached_comp_units ();
13970 /* Return the type of the DIE at DIE_OFFSET in the CU named by
13974 dwarf2_get_die_type (unsigned int die_offset
,
13975 struct dwarf2_per_cu_data
*per_cu
)
13977 dw2_setup (per_cu
->objfile
);
13978 return get_die_type_at_offset (die_offset
, per_cu
);
13981 /* Follow the signature attribute ATTR in SRC_DIE.
13982 On entry *REF_CU is the CU of SRC_DIE.
13983 On exit *REF_CU is the CU of the result. */
13985 static struct die_info
*
13986 follow_die_sig (struct die_info
*src_die
, struct attribute
*attr
,
13987 struct dwarf2_cu
**ref_cu
)
13989 struct objfile
*objfile
= (*ref_cu
)->objfile
;
13990 struct die_info temp_die
;
13991 struct signatured_type
*sig_type
= DW_SIGNATURED_TYPE (attr
);
13992 struct dwarf2_cu
*sig_cu
;
13993 struct die_info
*die
;
13995 /* sig_type will be NULL if the signatured type is missing from
13997 if (sig_type
== NULL
)
13998 error (_("Dwarf Error: Cannot find signatured DIE referenced from DIE "
13999 "at 0x%x [in module %s]"),
14000 src_die
->offset
, objfile
->name
);
14002 /* If necessary, add it to the queue and load its DIEs. */
14004 if (maybe_queue_comp_unit (*ref_cu
, &sig_type
->per_cu
))
14005 read_signatured_type (objfile
, sig_type
);
14007 gdb_assert (sig_type
->per_cu
.cu
!= NULL
);
14009 sig_cu
= sig_type
->per_cu
.cu
;
14010 temp_die
.offset
= sig_cu
->header
.offset
+ sig_type
->type_offset
;
14011 die
= htab_find_with_hash (sig_cu
->die_hash
, &temp_die
, temp_die
.offset
);
14018 error (_("Dwarf Error: Cannot find signatured DIE at 0x%x referenced "
14019 "from DIE at 0x%x [in module %s]"),
14020 sig_type
->type_offset
, src_die
->offset
, objfile
->name
);
14023 /* Given an offset of a signatured type, return its signatured_type. */
14025 static struct signatured_type
*
14026 lookup_signatured_type_at_offset (struct objfile
*objfile
,
14027 struct dwarf2_section_info
*section
,
14028 unsigned int offset
)
14030 gdb_byte
*info_ptr
= section
->buffer
+ offset
;
14031 unsigned int length
, initial_length_size
;
14032 unsigned int sig_offset
;
14033 struct signatured_type find_entry
, *type_sig
;
14035 length
= read_initial_length (objfile
->obfd
, info_ptr
, &initial_length_size
);
14036 sig_offset
= (initial_length_size
14038 + (initial_length_size
== 4 ? 4 : 8) /*debug_abbrev_offset*/
14039 + 1 /*address_size*/);
14040 find_entry
.signature
= bfd_get_64 (objfile
->obfd
, info_ptr
+ sig_offset
);
14041 type_sig
= htab_find (dwarf2_per_objfile
->signatured_types
, &find_entry
);
14043 /* This is only used to lookup previously recorded types.
14044 If we didn't find it, it's our bug. */
14045 gdb_assert (type_sig
!= NULL
);
14046 gdb_assert (offset
== type_sig
->per_cu
.offset
);
14051 /* Read in signatured type at OFFSET and build its CU and die(s). */
14054 read_signatured_type_at_offset (struct objfile
*objfile
,
14055 struct dwarf2_section_info
*sect
,
14056 unsigned int offset
)
14058 struct signatured_type
*type_sig
;
14060 dwarf2_read_section (objfile
, sect
);
14062 /* We have the section offset, but we need the signature to do the
14063 hash table lookup. */
14064 type_sig
= lookup_signatured_type_at_offset (objfile
, sect
, offset
);
14066 gdb_assert (type_sig
->per_cu
.cu
== NULL
);
14068 read_signatured_type (objfile
, type_sig
);
14070 gdb_assert (type_sig
->per_cu
.cu
!= NULL
);
14073 /* Read in a signatured type and build its CU and DIEs. */
14076 read_signatured_type (struct objfile
*objfile
,
14077 struct signatured_type
*type_sig
)
14079 gdb_byte
*types_ptr
;
14080 struct die_reader_specs reader_specs
;
14081 struct dwarf2_cu
*cu
;
14082 ULONGEST signature
;
14083 struct cleanup
*back_to
, *free_cu_cleanup
;
14084 struct dwarf2_section_info
*section
= type_sig
->per_cu
.debug_type_section
;
14086 dwarf2_read_section (objfile
, section
);
14087 types_ptr
= section
->buffer
+ type_sig
->per_cu
.offset
;
14089 gdb_assert (type_sig
->per_cu
.cu
== NULL
);
14091 cu
= xmalloc (sizeof (*cu
));
14092 init_one_comp_unit (cu
, objfile
);
14094 type_sig
->per_cu
.cu
= cu
;
14095 cu
->per_cu
= &type_sig
->per_cu
;
14097 /* If an error occurs while loading, release our storage. */
14098 free_cu_cleanup
= make_cleanup (free_one_comp_unit
, cu
);
14100 types_ptr
= read_type_comp_unit_head (&cu
->header
, section
, &signature
,
14101 types_ptr
, objfile
->obfd
);
14102 gdb_assert (signature
== type_sig
->signature
);
14105 = htab_create_alloc_ex (cu
->header
.length
/ 12,
14109 &cu
->comp_unit_obstack
,
14110 hashtab_obstack_allocate
,
14111 dummy_obstack_deallocate
);
14113 dwarf2_read_abbrevs (cu
->objfile
->obfd
, cu
);
14114 back_to
= make_cleanup (dwarf2_free_abbrev_table
, cu
);
14116 init_cu_die_reader (&reader_specs
, cu
);
14118 cu
->dies
= read_die_and_children (&reader_specs
, types_ptr
, &types_ptr
,
14121 /* We try not to read any attributes in this function, because not
14122 all objfiles needed for references have been loaded yet, and symbol
14123 table processing isn't initialized. But we have to set the CU language,
14124 or we won't be able to build types correctly. */
14125 prepare_one_comp_unit (cu
, cu
->dies
);
14127 do_cleanups (back_to
);
14129 /* We've successfully allocated this compilation unit. Let our caller
14130 clean it up when finished with it. */
14131 discard_cleanups (free_cu_cleanup
);
14133 type_sig
->per_cu
.cu
->read_in_chain
= dwarf2_per_objfile
->read_in_chain
;
14134 dwarf2_per_objfile
->read_in_chain
= &type_sig
->per_cu
;
14137 /* Workaround as dwarf_expr_context_funcs.read_mem implementation before
14138 a proper runtime DWARF expressions evaluator gets implemented.
14139 Otherwise gnuv3_baseclass_offset would error by:
14140 Expected a negative vbase offset (old compiler?) */
14143 decode_locdesc_read_mem (void *baton
, gdb_byte
*buf
, CORE_ADDR addr
,
14146 struct dwarf_expr_context
*ctx
= baton
;
14147 struct gdbarch
*gdbarch
= ctx
->gdbarch
;
14148 struct type
*ptr_type
= builtin_type (gdbarch
)->builtin_data_ptr
;
14150 memset (buf
, 0, length
);
14152 if (TYPE_LENGTH (ptr_type
) == length
)
14153 store_typed_address (buf
, ptr_type
, addr
);
14156 static const struct dwarf_expr_context_funcs decode_locdesc_ctx_funcs
=
14159 decode_locdesc_read_mem
,
14160 ctx_no_get_frame_base
,
14161 ctx_no_get_frame_cfa
,
14162 ctx_no_get_frame_pc
,
14163 ctx_no_get_tls_address
,
14165 ctx_no_get_base_type
14168 /* Decode simple location descriptions.
14169 Given a pointer to a dwarf block that defines a location, compute
14170 the location and return the value.
14172 NOTE drow/2003-11-18: This function is called in two situations
14173 now: for the address of static or global variables (partial symbols
14174 only) and for offsets into structures which are expected to be
14175 (more or less) constant. The partial symbol case should go away,
14176 and only the constant case should remain. That will let this
14177 function complain more accurately. A few special modes are allowed
14178 without complaint for global variables (for instance, global
14179 register values and thread-local values).
14181 A location description containing no operations indicates that the
14182 object is optimized out. The return value is 0 for that case.
14183 FIXME drow/2003-11-16: No callers check for this case any more; soon all
14184 callers will only want a very basic result and this can become a
14188 decode_locdesc (struct dwarf_block
*blk
, struct dwarf2_cu
*cu
)
14190 struct objfile
*objfile
= cu
->objfile
;
14191 struct dwarf_expr_context
*ctx
;
14192 struct cleanup
*old_chain
;
14193 volatile struct gdb_exception ex
;
14195 ctx
= new_dwarf_expr_context ();
14196 old_chain
= make_cleanup_free_dwarf_expr_context (ctx
);
14197 make_cleanup_value_free_to_mark (value_mark ());
14199 ctx
->gdbarch
= get_objfile_arch (objfile
);
14200 ctx
->addr_size
= cu
->header
.addr_size
;
14201 ctx
->offset
= ANOFFSET (objfile
->section_offsets
, SECT_OFF_TEXT (objfile
));
14203 ctx
->funcs
= &decode_locdesc_ctx_funcs
;
14205 /* DW_AT_data_member_location expects the structure address to be pushed on
14206 the stack. Simulate the offset by address 0. */
14207 dwarf_expr_push_address (ctx
, 0, 0);
14209 TRY_CATCH (ex
, RETURN_MASK_ERROR
)
14211 dwarf_expr_eval (ctx
, blk
->data
, blk
->size
);
14216 complaint (&symfile_complaints
, "%s", ex
.message
);
14218 else if (ctx
->num_pieces
== 0)
14219 switch (ctx
->location
)
14221 /* The returned number will be bogus, just do not complain for locations
14222 in global registers - it is here only a partial symbol address. */
14223 case DWARF_VALUE_REGISTER
:
14225 case DWARF_VALUE_MEMORY
:
14226 case DWARF_VALUE_STACK
:
14228 CORE_ADDR address
= dwarf_expr_fetch_address (ctx
, 0);
14230 do_cleanups (old_chain
);
14235 do_cleanups (old_chain
);
14236 dwarf2_complex_location_expr_complaint ();
14240 /* memory allocation interface */
14242 static struct dwarf_block
*
14243 dwarf_alloc_block (struct dwarf2_cu
*cu
)
14245 struct dwarf_block
*blk
;
14247 blk
= (struct dwarf_block
*)
14248 obstack_alloc (&cu
->comp_unit_obstack
, sizeof (struct dwarf_block
));
14252 static struct abbrev_info
*
14253 dwarf_alloc_abbrev (struct dwarf2_cu
*cu
)
14255 struct abbrev_info
*abbrev
;
14257 abbrev
= (struct abbrev_info
*)
14258 obstack_alloc (&cu
->abbrev_obstack
, sizeof (struct abbrev_info
));
14259 memset (abbrev
, 0, sizeof (struct abbrev_info
));
14263 static struct die_info
*
14264 dwarf_alloc_die (struct dwarf2_cu
*cu
, int num_attrs
)
14266 struct die_info
*die
;
14267 size_t size
= sizeof (struct die_info
);
14270 size
+= (num_attrs
- 1) * sizeof (struct attribute
);
14272 die
= (struct die_info
*) obstack_alloc (&cu
->comp_unit_obstack
, size
);
14273 memset (die
, 0, sizeof (struct die_info
));
14278 /* Macro support. */
14280 /* Return the full name of file number I in *LH's file name table.
14281 Use COMP_DIR as the name of the current directory of the
14282 compilation. The result is allocated using xmalloc; the caller is
14283 responsible for freeing it. */
14285 file_full_name (int file
, struct line_header
*lh
, const char *comp_dir
)
14287 /* Is the file number a valid index into the line header's file name
14288 table? Remember that file numbers start with one, not zero. */
14289 if (1 <= file
&& file
<= lh
->num_file_names
)
14291 struct file_entry
*fe
= &lh
->file_names
[file
- 1];
14293 if (IS_ABSOLUTE_PATH (fe
->name
))
14294 return xstrdup (fe
->name
);
14302 dir
= lh
->include_dirs
[fe
->dir_index
- 1];
14308 dir_len
= strlen (dir
);
14309 full_name
= xmalloc (dir_len
+ 1 + strlen (fe
->name
) + 1);
14310 strcpy (full_name
, dir
);
14311 full_name
[dir_len
] = '/';
14312 strcpy (full_name
+ dir_len
+ 1, fe
->name
);
14316 return xstrdup (fe
->name
);
14321 /* The compiler produced a bogus file number. We can at least
14322 record the macro definitions made in the file, even if we
14323 won't be able to find the file by name. */
14324 char fake_name
[80];
14326 sprintf (fake_name
, "<bad macro file number %d>", file
);
14328 complaint (&symfile_complaints
,
14329 _("bad file number in macro information (%d)"),
14332 return xstrdup (fake_name
);
14337 static struct macro_source_file
*
14338 macro_start_file (int file
, int line
,
14339 struct macro_source_file
*current_file
,
14340 const char *comp_dir
,
14341 struct line_header
*lh
, struct objfile
*objfile
)
14343 /* The full name of this source file. */
14344 char *full_name
= file_full_name (file
, lh
, comp_dir
);
14346 /* We don't create a macro table for this compilation unit
14347 at all until we actually get a filename. */
14348 if (! pending_macros
)
14349 pending_macros
= new_macro_table (&objfile
->objfile_obstack
,
14350 objfile
->macro_cache
);
14352 if (! current_file
)
14353 /* If we have no current file, then this must be the start_file
14354 directive for the compilation unit's main source file. */
14355 current_file
= macro_set_main (pending_macros
, full_name
);
14357 current_file
= macro_include (current_file
, line
, full_name
);
14361 return current_file
;
14365 /* Copy the LEN characters at BUF to a xmalloc'ed block of memory,
14366 followed by a null byte. */
14368 copy_string (const char *buf
, int len
)
14370 char *s
= xmalloc (len
+ 1);
14372 memcpy (s
, buf
, len
);
14378 static const char *
14379 consume_improper_spaces (const char *p
, const char *body
)
14383 complaint (&symfile_complaints
,
14384 _("macro definition contains spaces "
14385 "in formal argument list:\n`%s'"),
14397 parse_macro_definition (struct macro_source_file
*file
, int line
,
14402 /* The body string takes one of two forms. For object-like macro
14403 definitions, it should be:
14405 <macro name> " " <definition>
14407 For function-like macro definitions, it should be:
14409 <macro name> "() " <definition>
14411 <macro name> "(" <arg name> ( "," <arg name> ) * ") " <definition>
14413 Spaces may appear only where explicitly indicated, and in the
14416 The Dwarf 2 spec says that an object-like macro's name is always
14417 followed by a space, but versions of GCC around March 2002 omit
14418 the space when the macro's definition is the empty string.
14420 The Dwarf 2 spec says that there should be no spaces between the
14421 formal arguments in a function-like macro's formal argument list,
14422 but versions of GCC around March 2002 include spaces after the
14426 /* Find the extent of the macro name. The macro name is terminated
14427 by either a space or null character (for an object-like macro) or
14428 an opening paren (for a function-like macro). */
14429 for (p
= body
; *p
; p
++)
14430 if (*p
== ' ' || *p
== '(')
14433 if (*p
== ' ' || *p
== '\0')
14435 /* It's an object-like macro. */
14436 int name_len
= p
- body
;
14437 char *name
= copy_string (body
, name_len
);
14438 const char *replacement
;
14441 replacement
= body
+ name_len
+ 1;
14444 dwarf2_macro_malformed_definition_complaint (body
);
14445 replacement
= body
+ name_len
;
14448 macro_define_object (file
, line
, name
, replacement
);
14452 else if (*p
== '(')
14454 /* It's a function-like macro. */
14455 char *name
= copy_string (body
, p
- body
);
14458 char **argv
= xmalloc (argv_size
* sizeof (*argv
));
14462 p
= consume_improper_spaces (p
, body
);
14464 /* Parse the formal argument list. */
14465 while (*p
&& *p
!= ')')
14467 /* Find the extent of the current argument name. */
14468 const char *arg_start
= p
;
14470 while (*p
&& *p
!= ',' && *p
!= ')' && *p
!= ' ')
14473 if (! *p
|| p
== arg_start
)
14474 dwarf2_macro_malformed_definition_complaint (body
);
14477 /* Make sure argv has room for the new argument. */
14478 if (argc
>= argv_size
)
14481 argv
= xrealloc (argv
, argv_size
* sizeof (*argv
));
14484 argv
[argc
++] = copy_string (arg_start
, p
- arg_start
);
14487 p
= consume_improper_spaces (p
, body
);
14489 /* Consume the comma, if present. */
14494 p
= consume_improper_spaces (p
, body
);
14503 /* Perfectly formed definition, no complaints. */
14504 macro_define_function (file
, line
, name
,
14505 argc
, (const char **) argv
,
14507 else if (*p
== '\0')
14509 /* Complain, but do define it. */
14510 dwarf2_macro_malformed_definition_complaint (body
);
14511 macro_define_function (file
, line
, name
,
14512 argc
, (const char **) argv
,
14516 /* Just complain. */
14517 dwarf2_macro_malformed_definition_complaint (body
);
14520 /* Just complain. */
14521 dwarf2_macro_malformed_definition_complaint (body
);
14527 for (i
= 0; i
< argc
; i
++)
14533 dwarf2_macro_malformed_definition_complaint (body
);
14536 /* Skip some bytes from BYTES according to the form given in FORM.
14537 Returns the new pointer. */
14540 skip_form_bytes (bfd
*abfd
, gdb_byte
*bytes
,
14541 enum dwarf_form form
,
14542 unsigned int offset_size
,
14543 struct dwarf2_section_info
*section
)
14545 unsigned int bytes_read
;
14549 case DW_FORM_data1
:
14554 case DW_FORM_data2
:
14558 case DW_FORM_data4
:
14562 case DW_FORM_data8
:
14566 case DW_FORM_string
:
14567 read_direct_string (abfd
, bytes
, &bytes_read
);
14568 bytes
+= bytes_read
;
14571 case DW_FORM_sec_offset
:
14573 bytes
+= offset_size
;
14576 case DW_FORM_block
:
14577 bytes
+= read_unsigned_leb128 (abfd
, bytes
, &bytes_read
);
14578 bytes
+= bytes_read
;
14581 case DW_FORM_block1
:
14582 bytes
+= 1 + read_1_byte (abfd
, bytes
);
14584 case DW_FORM_block2
:
14585 bytes
+= 2 + read_2_bytes (abfd
, bytes
);
14587 case DW_FORM_block4
:
14588 bytes
+= 4 + read_4_bytes (abfd
, bytes
);
14591 case DW_FORM_sdata
:
14592 case DW_FORM_udata
:
14593 bytes
= skip_leb128 (abfd
, bytes
);
14599 complaint (&symfile_complaints
,
14600 _("invalid form 0x%x in `%s'"),
14602 section
->asection
->name
);
14610 /* A helper for dwarf_decode_macros that handles skipping an unknown
14611 opcode. Returns an updated pointer to the macro data buffer; or,
14612 on error, issues a complaint and returns NULL. */
14615 skip_unknown_opcode (unsigned int opcode
,
14616 gdb_byte
**opcode_definitions
,
14619 unsigned int offset_size
,
14620 struct dwarf2_section_info
*section
)
14622 unsigned int bytes_read
, i
;
14626 if (opcode_definitions
[opcode
] == NULL
)
14628 complaint (&symfile_complaints
,
14629 _("unrecognized DW_MACFINO opcode 0x%x"),
14634 defn
= opcode_definitions
[opcode
];
14635 arg
= read_unsigned_leb128 (abfd
, defn
, &bytes_read
);
14636 defn
+= bytes_read
;
14638 for (i
= 0; i
< arg
; ++i
)
14640 mac_ptr
= skip_form_bytes (abfd
, mac_ptr
, defn
[i
], offset_size
, section
);
14641 if (mac_ptr
== NULL
)
14643 /* skip_form_bytes already issued the complaint. */
14651 /* A helper function which parses the header of a macro section.
14652 If the macro section is the extended (for now called "GNU") type,
14653 then this updates *OFFSET_SIZE. Returns a pointer to just after
14654 the header, or issues a complaint and returns NULL on error. */
14657 dwarf_parse_macro_header (gdb_byte
**opcode_definitions
,
14660 unsigned int *offset_size
,
14661 int section_is_gnu
)
14663 memset (opcode_definitions
, 0, 256 * sizeof (gdb_byte
*));
14665 if (section_is_gnu
)
14667 unsigned int version
, flags
;
14669 version
= read_2_bytes (abfd
, mac_ptr
);
14672 complaint (&symfile_complaints
,
14673 _("unrecognized version `%d' in .debug_macro section"),
14679 flags
= read_1_byte (abfd
, mac_ptr
);
14681 *offset_size
= (flags
& 1) ? 8 : 4;
14683 if ((flags
& 2) != 0)
14684 /* We don't need the line table offset. */
14685 mac_ptr
+= *offset_size
;
14687 /* Vendor opcode descriptions. */
14688 if ((flags
& 4) != 0)
14690 unsigned int i
, count
;
14692 count
= read_1_byte (abfd
, mac_ptr
);
14694 for (i
= 0; i
< count
; ++i
)
14696 unsigned int opcode
, bytes_read
;
14699 opcode
= read_1_byte (abfd
, mac_ptr
);
14701 opcode_definitions
[opcode
] = mac_ptr
;
14702 arg
= read_unsigned_leb128 (abfd
, mac_ptr
, &bytes_read
);
14703 mac_ptr
+= bytes_read
;
14712 /* A helper for dwarf_decode_macros that handles the GNU extensions,
14713 including DW_GNU_MACINFO_transparent_include. */
14716 dwarf_decode_macro_bytes (bfd
*abfd
, gdb_byte
*mac_ptr
, gdb_byte
*mac_end
,
14717 struct macro_source_file
*current_file
,
14718 struct line_header
*lh
, char *comp_dir
,
14719 struct dwarf2_section_info
*section
,
14720 int section_is_gnu
,
14721 unsigned int offset_size
,
14722 struct objfile
*objfile
)
14724 enum dwarf_macro_record_type macinfo_type
;
14725 int at_commandline
;
14726 gdb_byte
*opcode_definitions
[256];
14728 mac_ptr
= dwarf_parse_macro_header (opcode_definitions
, abfd
, mac_ptr
,
14729 &offset_size
, section_is_gnu
);
14730 if (mac_ptr
== NULL
)
14732 /* We already issued a complaint. */
14736 /* Determines if GDB is still before first DW_MACINFO_start_file. If true
14737 GDB is still reading the definitions from command line. First
14738 DW_MACINFO_start_file will need to be ignored as it was already executed
14739 to create CURRENT_FILE for the main source holding also the command line
14740 definitions. On first met DW_MACINFO_start_file this flag is reset to
14741 normally execute all the remaining DW_MACINFO_start_file macinfos. */
14743 at_commandline
= 1;
14747 /* Do we at least have room for a macinfo type byte? */
14748 if (mac_ptr
>= mac_end
)
14750 dwarf2_macros_too_long_complaint (section
);
14754 macinfo_type
= read_1_byte (abfd
, mac_ptr
);
14757 /* Note that we rely on the fact that the corresponding GNU and
14758 DWARF constants are the same. */
14759 switch (macinfo_type
)
14761 /* A zero macinfo type indicates the end of the macro
14766 case DW_MACRO_GNU_define
:
14767 case DW_MACRO_GNU_undef
:
14768 case DW_MACRO_GNU_define_indirect
:
14769 case DW_MACRO_GNU_undef_indirect
:
14771 unsigned int bytes_read
;
14776 line
= read_unsigned_leb128 (abfd
, mac_ptr
, &bytes_read
);
14777 mac_ptr
+= bytes_read
;
14779 if (macinfo_type
== DW_MACRO_GNU_define
14780 || macinfo_type
== DW_MACRO_GNU_undef
)
14782 body
= read_direct_string (abfd
, mac_ptr
, &bytes_read
);
14783 mac_ptr
+= bytes_read
;
14787 LONGEST str_offset
;
14789 str_offset
= read_offset_1 (abfd
, mac_ptr
, offset_size
);
14790 mac_ptr
+= offset_size
;
14792 body
= read_indirect_string_at_offset (abfd
, str_offset
);
14795 is_define
= (macinfo_type
== DW_MACRO_GNU_define
14796 || macinfo_type
== DW_MACRO_GNU_define_indirect
);
14797 if (! current_file
)
14799 /* DWARF violation as no main source is present. */
14800 complaint (&symfile_complaints
,
14801 _("debug info with no main source gives macro %s "
14803 is_define
? _("definition") : _("undefinition"),
14807 if ((line
== 0 && !at_commandline
)
14808 || (line
!= 0 && at_commandline
))
14809 complaint (&symfile_complaints
,
14810 _("debug info gives %s macro %s with %s line %d: %s"),
14811 at_commandline
? _("command-line") : _("in-file"),
14812 is_define
? _("definition") : _("undefinition"),
14813 line
== 0 ? _("zero") : _("non-zero"), line
, body
);
14816 parse_macro_definition (current_file
, line
, body
);
14819 gdb_assert (macinfo_type
== DW_MACRO_GNU_undef
14820 || macinfo_type
== DW_MACRO_GNU_undef_indirect
);
14821 macro_undef (current_file
, line
, body
);
14826 case DW_MACRO_GNU_start_file
:
14828 unsigned int bytes_read
;
14831 line
= read_unsigned_leb128 (abfd
, mac_ptr
, &bytes_read
);
14832 mac_ptr
+= bytes_read
;
14833 file
= read_unsigned_leb128 (abfd
, mac_ptr
, &bytes_read
);
14834 mac_ptr
+= bytes_read
;
14836 if ((line
== 0 && !at_commandline
)
14837 || (line
!= 0 && at_commandline
))
14838 complaint (&symfile_complaints
,
14839 _("debug info gives source %d included "
14840 "from %s at %s line %d"),
14841 file
, at_commandline
? _("command-line") : _("file"),
14842 line
== 0 ? _("zero") : _("non-zero"), line
);
14844 if (at_commandline
)
14846 /* This DW_MACRO_GNU_start_file was executed in the
14848 at_commandline
= 0;
14851 current_file
= macro_start_file (file
, line
,
14852 current_file
, comp_dir
,
14857 case DW_MACRO_GNU_end_file
:
14858 if (! current_file
)
14859 complaint (&symfile_complaints
,
14860 _("macro debug info has an unmatched "
14861 "`close_file' directive"));
14864 current_file
= current_file
->included_by
;
14865 if (! current_file
)
14867 enum dwarf_macro_record_type next_type
;
14869 /* GCC circa March 2002 doesn't produce the zero
14870 type byte marking the end of the compilation
14871 unit. Complain if it's not there, but exit no
14874 /* Do we at least have room for a macinfo type byte? */
14875 if (mac_ptr
>= mac_end
)
14877 dwarf2_macros_too_long_complaint (section
);
14881 /* We don't increment mac_ptr here, so this is just
14883 next_type
= read_1_byte (abfd
, mac_ptr
);
14884 if (next_type
!= 0)
14885 complaint (&symfile_complaints
,
14886 _("no terminating 0-type entry for "
14887 "macros in `.debug_macinfo' section"));
14894 case DW_MACRO_GNU_transparent_include
:
14898 offset
= read_offset_1 (abfd
, mac_ptr
, offset_size
);
14899 mac_ptr
+= offset_size
;
14901 dwarf_decode_macro_bytes (abfd
,
14902 section
->buffer
+ offset
,
14903 mac_end
, current_file
,
14905 section
, section_is_gnu
,
14906 offset_size
, objfile
);
14910 case DW_MACINFO_vendor_ext
:
14911 if (!section_is_gnu
)
14913 unsigned int bytes_read
;
14916 constant
= read_unsigned_leb128 (abfd
, mac_ptr
, &bytes_read
);
14917 mac_ptr
+= bytes_read
;
14918 read_direct_string (abfd
, mac_ptr
, &bytes_read
);
14919 mac_ptr
+= bytes_read
;
14921 /* We don't recognize any vendor extensions. */
14927 mac_ptr
= skip_unknown_opcode (macinfo_type
, opcode_definitions
,
14928 mac_ptr
, abfd
, offset_size
,
14930 if (mac_ptr
== NULL
)
14934 } while (macinfo_type
!= 0);
14938 dwarf_decode_macros (struct line_header
*lh
, unsigned int offset
,
14939 char *comp_dir
, bfd
*abfd
,
14940 struct dwarf2_cu
*cu
,
14941 struct dwarf2_section_info
*section
,
14942 int section_is_gnu
)
14944 gdb_byte
*mac_ptr
, *mac_end
;
14945 struct macro_source_file
*current_file
= 0;
14946 enum dwarf_macro_record_type macinfo_type
;
14947 unsigned int offset_size
= cu
->header
.offset_size
;
14948 gdb_byte
*opcode_definitions
[256];
14950 dwarf2_read_section (dwarf2_per_objfile
->objfile
, section
);
14951 if (section
->buffer
== NULL
)
14953 complaint (&symfile_complaints
, _("missing %s section"),
14954 section
->asection
->name
);
14958 /* First pass: Find the name of the base filename.
14959 This filename is needed in order to process all macros whose definition
14960 (or undefinition) comes from the command line. These macros are defined
14961 before the first DW_MACINFO_start_file entry, and yet still need to be
14962 associated to the base file.
14964 To determine the base file name, we scan the macro definitions until we
14965 reach the first DW_MACINFO_start_file entry. We then initialize
14966 CURRENT_FILE accordingly so that any macro definition found before the
14967 first DW_MACINFO_start_file can still be associated to the base file. */
14969 mac_ptr
= section
->buffer
+ offset
;
14970 mac_end
= section
->buffer
+ section
->size
;
14972 mac_ptr
= dwarf_parse_macro_header (opcode_definitions
, abfd
, mac_ptr
,
14973 &offset_size
, section_is_gnu
);
14974 if (mac_ptr
== NULL
)
14976 /* We already issued a complaint. */
14982 /* Do we at least have room for a macinfo type byte? */
14983 if (mac_ptr
>= mac_end
)
14985 /* Complaint is printed during the second pass as GDB will probably
14986 stop the first pass earlier upon finding
14987 DW_MACINFO_start_file. */
14991 macinfo_type
= read_1_byte (abfd
, mac_ptr
);
14994 /* Note that we rely on the fact that the corresponding GNU and
14995 DWARF constants are the same. */
14996 switch (macinfo_type
)
14998 /* A zero macinfo type indicates the end of the macro
15003 case DW_MACRO_GNU_define
:
15004 case DW_MACRO_GNU_undef
:
15005 /* Only skip the data by MAC_PTR. */
15007 unsigned int bytes_read
;
15009 read_unsigned_leb128 (abfd
, mac_ptr
, &bytes_read
);
15010 mac_ptr
+= bytes_read
;
15011 read_direct_string (abfd
, mac_ptr
, &bytes_read
);
15012 mac_ptr
+= bytes_read
;
15016 case DW_MACRO_GNU_start_file
:
15018 unsigned int bytes_read
;
15021 line
= read_unsigned_leb128 (abfd
, mac_ptr
, &bytes_read
);
15022 mac_ptr
+= bytes_read
;
15023 file
= read_unsigned_leb128 (abfd
, mac_ptr
, &bytes_read
);
15024 mac_ptr
+= bytes_read
;
15026 current_file
= macro_start_file (file
, line
, current_file
,
15027 comp_dir
, lh
, cu
->objfile
);
15031 case DW_MACRO_GNU_end_file
:
15032 /* No data to skip by MAC_PTR. */
15035 case DW_MACRO_GNU_define_indirect
:
15036 case DW_MACRO_GNU_undef_indirect
:
15038 unsigned int bytes_read
;
15040 read_unsigned_leb128 (abfd
, mac_ptr
, &bytes_read
);
15041 mac_ptr
+= bytes_read
;
15042 mac_ptr
+= offset_size
;
15046 case DW_MACRO_GNU_transparent_include
:
15047 /* Note that, according to the spec, a transparent include
15048 chain cannot call DW_MACRO_GNU_start_file. So, we can just
15049 skip this opcode. */
15050 mac_ptr
+= offset_size
;
15053 case DW_MACINFO_vendor_ext
:
15054 /* Only skip the data by MAC_PTR. */
15055 if (!section_is_gnu
)
15057 unsigned int bytes_read
;
15059 read_unsigned_leb128 (abfd
, mac_ptr
, &bytes_read
);
15060 mac_ptr
+= bytes_read
;
15061 read_direct_string (abfd
, mac_ptr
, &bytes_read
);
15062 mac_ptr
+= bytes_read
;
15067 mac_ptr
= skip_unknown_opcode (macinfo_type
, opcode_definitions
,
15068 mac_ptr
, abfd
, offset_size
,
15070 if (mac_ptr
== NULL
)
15074 } while (macinfo_type
!= 0 && current_file
== NULL
);
15076 /* Second pass: Process all entries.
15078 Use the AT_COMMAND_LINE flag to determine whether we are still processing
15079 command-line macro definitions/undefinitions. This flag is unset when we
15080 reach the first DW_MACINFO_start_file entry. */
15082 dwarf_decode_macro_bytes (abfd
, section
->buffer
+ offset
, mac_end
,
15083 current_file
, lh
, comp_dir
, section
, section_is_gnu
,
15084 offset_size
, cu
->objfile
);
15087 /* Check if the attribute's form is a DW_FORM_block*
15088 if so return true else false. */
15090 attr_form_is_block (struct attribute
*attr
)
15092 return (attr
== NULL
? 0 :
15093 attr
->form
== DW_FORM_block1
15094 || attr
->form
== DW_FORM_block2
15095 || attr
->form
== DW_FORM_block4
15096 || attr
->form
== DW_FORM_block
15097 || attr
->form
== DW_FORM_exprloc
);
15100 /* Return non-zero if ATTR's value is a section offset --- classes
15101 lineptr, loclistptr, macptr or rangelistptr --- or zero, otherwise.
15102 You may use DW_UNSND (attr) to retrieve such offsets.
15104 Section 7.5.4, "Attribute Encodings", explains that no attribute
15105 may have a value that belongs to more than one of these classes; it
15106 would be ambiguous if we did, because we use the same forms for all
15109 attr_form_is_section_offset (struct attribute
*attr
)
15111 return (attr
->form
== DW_FORM_data4
15112 || attr
->form
== DW_FORM_data8
15113 || attr
->form
== DW_FORM_sec_offset
);
15117 /* Return non-zero if ATTR's value falls in the 'constant' class, or
15118 zero otherwise. When this function returns true, you can apply
15119 dwarf2_get_attr_constant_value to it.
15121 However, note that for some attributes you must check
15122 attr_form_is_section_offset before using this test. DW_FORM_data4
15123 and DW_FORM_data8 are members of both the constant class, and of
15124 the classes that contain offsets into other debug sections
15125 (lineptr, loclistptr, macptr or rangelistptr). The DWARF spec says
15126 that, if an attribute's can be either a constant or one of the
15127 section offset classes, DW_FORM_data4 and DW_FORM_data8 should be
15128 taken as section offsets, not constants. */
15130 attr_form_is_constant (struct attribute
*attr
)
15132 switch (attr
->form
)
15134 case DW_FORM_sdata
:
15135 case DW_FORM_udata
:
15136 case DW_FORM_data1
:
15137 case DW_FORM_data2
:
15138 case DW_FORM_data4
:
15139 case DW_FORM_data8
:
15146 /* A helper function that fills in a dwarf2_loclist_baton. */
15149 fill_in_loclist_baton (struct dwarf2_cu
*cu
,
15150 struct dwarf2_loclist_baton
*baton
,
15151 struct attribute
*attr
)
15153 dwarf2_read_section (dwarf2_per_objfile
->objfile
,
15154 &dwarf2_per_objfile
->loc
);
15156 baton
->per_cu
= cu
->per_cu
;
15157 gdb_assert (baton
->per_cu
);
15158 /* We don't know how long the location list is, but make sure we
15159 don't run off the edge of the section. */
15160 baton
->size
= dwarf2_per_objfile
->loc
.size
- DW_UNSND (attr
);
15161 baton
->data
= dwarf2_per_objfile
->loc
.buffer
+ DW_UNSND (attr
);
15162 baton
->base_address
= cu
->base_address
;
15166 dwarf2_symbol_mark_computed (struct attribute
*attr
, struct symbol
*sym
,
15167 struct dwarf2_cu
*cu
)
15169 if (attr_form_is_section_offset (attr
)
15170 /* ".debug_loc" may not exist at all, or the offset may be outside
15171 the section. If so, fall through to the complaint in the
15173 && DW_UNSND (attr
) < dwarf2_section_size (dwarf2_per_objfile
->objfile
,
15174 &dwarf2_per_objfile
->loc
))
15176 struct dwarf2_loclist_baton
*baton
;
15178 baton
= obstack_alloc (&cu
->objfile
->objfile_obstack
,
15179 sizeof (struct dwarf2_loclist_baton
));
15181 fill_in_loclist_baton (cu
, baton
, attr
);
15183 if (cu
->base_known
== 0)
15184 complaint (&symfile_complaints
,
15185 _("Location list used without "
15186 "specifying the CU base address."));
15188 SYMBOL_COMPUTED_OPS (sym
) = &dwarf2_loclist_funcs
;
15189 SYMBOL_LOCATION_BATON (sym
) = baton
;
15193 struct dwarf2_locexpr_baton
*baton
;
15195 baton
= obstack_alloc (&cu
->objfile
->objfile_obstack
,
15196 sizeof (struct dwarf2_locexpr_baton
));
15197 baton
->per_cu
= cu
->per_cu
;
15198 gdb_assert (baton
->per_cu
);
15200 if (attr_form_is_block (attr
))
15202 /* Note that we're just copying the block's data pointer
15203 here, not the actual data. We're still pointing into the
15204 info_buffer for SYM's objfile; right now we never release
15205 that buffer, but when we do clean up properly this may
15207 baton
->size
= DW_BLOCK (attr
)->size
;
15208 baton
->data
= DW_BLOCK (attr
)->data
;
15212 dwarf2_invalid_attrib_class_complaint ("location description",
15213 SYMBOL_NATURAL_NAME (sym
));
15215 baton
->data
= NULL
;
15218 SYMBOL_COMPUTED_OPS (sym
) = &dwarf2_locexpr_funcs
;
15219 SYMBOL_LOCATION_BATON (sym
) = baton
;
15223 /* Return the OBJFILE associated with the compilation unit CU. If CU
15224 came from a separate debuginfo file, then the master objfile is
15228 dwarf2_per_cu_objfile (struct dwarf2_per_cu_data
*per_cu
)
15230 struct objfile
*objfile
= per_cu
->objfile
;
15232 /* Return the master objfile, so that we can report and look up the
15233 correct file containing this variable. */
15234 if (objfile
->separate_debug_objfile_backlink
)
15235 objfile
= objfile
->separate_debug_objfile_backlink
;
15240 /* Return the address size given in the compilation unit header for CU. */
15243 dwarf2_per_cu_addr_size (struct dwarf2_per_cu_data
*per_cu
)
15246 return per_cu
->cu
->header
.addr_size
;
15249 /* If the CU is not currently read in, we re-read its header. */
15250 struct objfile
*objfile
= per_cu
->objfile
;
15251 struct dwarf2_per_objfile
*per_objfile
15252 = objfile_data (objfile
, dwarf2_objfile_data_key
);
15253 gdb_byte
*info_ptr
= per_objfile
->info
.buffer
+ per_cu
->offset
;
15254 struct comp_unit_head cu_header
;
15256 memset (&cu_header
, 0, sizeof cu_header
);
15257 read_comp_unit_head (&cu_header
, info_ptr
, objfile
->obfd
);
15258 return cu_header
.addr_size
;
15262 /* Return the offset size given in the compilation unit header for CU. */
15265 dwarf2_per_cu_offset_size (struct dwarf2_per_cu_data
*per_cu
)
15268 return per_cu
->cu
->header
.offset_size
;
15271 /* If the CU is not currently read in, we re-read its header. */
15272 struct objfile
*objfile
= per_cu
->objfile
;
15273 struct dwarf2_per_objfile
*per_objfile
15274 = objfile_data (objfile
, dwarf2_objfile_data_key
);
15275 gdb_byte
*info_ptr
= per_objfile
->info
.buffer
+ per_cu
->offset
;
15276 struct comp_unit_head cu_header
;
15278 memset (&cu_header
, 0, sizeof cu_header
);
15279 read_comp_unit_head (&cu_header
, info_ptr
, objfile
->obfd
);
15280 return cu_header
.offset_size
;
15284 /* Return the text offset of the CU. The returned offset comes from
15285 this CU's objfile. If this objfile came from a separate debuginfo
15286 file, then the offset may be different from the corresponding
15287 offset in the parent objfile. */
15290 dwarf2_per_cu_text_offset (struct dwarf2_per_cu_data
*per_cu
)
15292 struct objfile
*objfile
= per_cu
->objfile
;
15294 return ANOFFSET (objfile
->section_offsets
, SECT_OFF_TEXT (objfile
));
15297 /* Locate the .debug_info compilation unit from CU's objfile which contains
15298 the DIE at OFFSET. Raises an error on failure. */
15300 static struct dwarf2_per_cu_data
*
15301 dwarf2_find_containing_comp_unit (unsigned int offset
,
15302 struct objfile
*objfile
)
15304 struct dwarf2_per_cu_data
*this_cu
;
15308 high
= dwarf2_per_objfile
->n_comp_units
- 1;
15311 int mid
= low
+ (high
- low
) / 2;
15313 if (dwarf2_per_objfile
->all_comp_units
[mid
]->offset
>= offset
)
15318 gdb_assert (low
== high
);
15319 if (dwarf2_per_objfile
->all_comp_units
[low
]->offset
> offset
)
15322 error (_("Dwarf Error: could not find partial DIE containing "
15323 "offset 0x%lx [in module %s]"),
15324 (long) offset
, bfd_get_filename (objfile
->obfd
));
15326 gdb_assert (dwarf2_per_objfile
->all_comp_units
[low
-1]->offset
<= offset
);
15327 return dwarf2_per_objfile
->all_comp_units
[low
-1];
15331 this_cu
= dwarf2_per_objfile
->all_comp_units
[low
];
15332 if (low
== dwarf2_per_objfile
->n_comp_units
- 1
15333 && offset
>= this_cu
->offset
+ this_cu
->length
)
15334 error (_("invalid dwarf2 offset %u"), offset
);
15335 gdb_assert (offset
< this_cu
->offset
+ this_cu
->length
);
15340 /* Locate the compilation unit from OBJFILE which is located at exactly
15341 OFFSET. Raises an error on failure. */
15343 static struct dwarf2_per_cu_data
*
15344 dwarf2_find_comp_unit (unsigned int offset
, struct objfile
*objfile
)
15346 struct dwarf2_per_cu_data
*this_cu
;
15348 this_cu
= dwarf2_find_containing_comp_unit (offset
, objfile
);
15349 if (this_cu
->offset
!= offset
)
15350 error (_("no compilation unit with offset %u."), offset
);
15354 /* Initialize dwarf2_cu CU for OBJFILE in a pre-allocated space. */
15357 init_one_comp_unit (struct dwarf2_cu
*cu
, struct objfile
*objfile
)
15359 memset (cu
, 0, sizeof (*cu
));
15360 cu
->objfile
= objfile
;
15361 obstack_init (&cu
->comp_unit_obstack
);
15364 /* Initialize basic fields of dwarf_cu CU according to DIE COMP_UNIT_DIE. */
15367 prepare_one_comp_unit (struct dwarf2_cu
*cu
, struct die_info
*comp_unit_die
)
15369 struct attribute
*attr
;
15371 /* Set the language we're debugging. */
15372 attr
= dwarf2_attr (comp_unit_die
, DW_AT_language
, cu
);
15374 set_cu_language (DW_UNSND (attr
), cu
);
15377 cu
->language
= language_minimal
;
15378 cu
->language_defn
= language_def (cu
->language
);
15382 /* Release one cached compilation unit, CU. We unlink it from the tree
15383 of compilation units, but we don't remove it from the read_in_chain;
15384 the caller is responsible for that.
15385 NOTE: DATA is a void * because this function is also used as a
15386 cleanup routine. */
15389 free_one_comp_unit (void *data
)
15391 struct dwarf2_cu
*cu
= data
;
15393 if (cu
->per_cu
!= NULL
)
15394 cu
->per_cu
->cu
= NULL
;
15397 obstack_free (&cu
->comp_unit_obstack
, NULL
);
15402 /* This cleanup function is passed the address of a dwarf2_cu on the stack
15403 when we're finished with it. We can't free the pointer itself, but be
15404 sure to unlink it from the cache. Also release any associated storage
15405 and perform cache maintenance.
15407 Only used during partial symbol parsing. */
15410 free_stack_comp_unit (void *data
)
15412 struct dwarf2_cu
*cu
= data
;
15414 obstack_free (&cu
->comp_unit_obstack
, NULL
);
15415 cu
->partial_dies
= NULL
;
15417 if (cu
->per_cu
!= NULL
)
15419 /* This compilation unit is on the stack in our caller, so we
15420 should not xfree it. Just unlink it. */
15421 cu
->per_cu
->cu
= NULL
;
15424 /* If we had a per-cu pointer, then we may have other compilation
15425 units loaded, so age them now. */
15426 age_cached_comp_units ();
15430 /* Free all cached compilation units. */
15433 free_cached_comp_units (void *data
)
15435 struct dwarf2_per_cu_data
*per_cu
, **last_chain
;
15437 per_cu
= dwarf2_per_objfile
->read_in_chain
;
15438 last_chain
= &dwarf2_per_objfile
->read_in_chain
;
15439 while (per_cu
!= NULL
)
15441 struct dwarf2_per_cu_data
*next_cu
;
15443 next_cu
= per_cu
->cu
->read_in_chain
;
15445 free_one_comp_unit (per_cu
->cu
);
15446 *last_chain
= next_cu
;
15452 /* Increase the age counter on each cached compilation unit, and free
15453 any that are too old. */
15456 age_cached_comp_units (void)
15458 struct dwarf2_per_cu_data
*per_cu
, **last_chain
;
15460 dwarf2_clear_marks (dwarf2_per_objfile
->read_in_chain
);
15461 per_cu
= dwarf2_per_objfile
->read_in_chain
;
15462 while (per_cu
!= NULL
)
15464 per_cu
->cu
->last_used
++;
15465 if (per_cu
->cu
->last_used
<= dwarf2_max_cache_age
)
15466 dwarf2_mark (per_cu
->cu
);
15467 per_cu
= per_cu
->cu
->read_in_chain
;
15470 per_cu
= dwarf2_per_objfile
->read_in_chain
;
15471 last_chain
= &dwarf2_per_objfile
->read_in_chain
;
15472 while (per_cu
!= NULL
)
15474 struct dwarf2_per_cu_data
*next_cu
;
15476 next_cu
= per_cu
->cu
->read_in_chain
;
15478 if (!per_cu
->cu
->mark
)
15480 free_one_comp_unit (per_cu
->cu
);
15481 *last_chain
= next_cu
;
15484 last_chain
= &per_cu
->cu
->read_in_chain
;
15490 /* Remove a single compilation unit from the cache. */
15493 free_one_cached_comp_unit (void *target_cu
)
15495 struct dwarf2_per_cu_data
*per_cu
, **last_chain
;
15497 per_cu
= dwarf2_per_objfile
->read_in_chain
;
15498 last_chain
= &dwarf2_per_objfile
->read_in_chain
;
15499 while (per_cu
!= NULL
)
15501 struct dwarf2_per_cu_data
*next_cu
;
15503 next_cu
= per_cu
->cu
->read_in_chain
;
15505 if (per_cu
->cu
== target_cu
)
15507 free_one_comp_unit (per_cu
->cu
);
15508 *last_chain
= next_cu
;
15512 last_chain
= &per_cu
->cu
->read_in_chain
;
15518 /* Release all extra memory associated with OBJFILE. */
15521 dwarf2_free_objfile (struct objfile
*objfile
)
15523 dwarf2_per_objfile
= objfile_data (objfile
, dwarf2_objfile_data_key
);
15525 if (dwarf2_per_objfile
== NULL
)
15528 /* Cached DIE trees use xmalloc and the comp_unit_obstack. */
15529 free_cached_comp_units (NULL
);
15531 if (dwarf2_per_objfile
->quick_file_names_table
)
15532 htab_delete (dwarf2_per_objfile
->quick_file_names_table
);
15534 /* Everything else should be on the objfile obstack. */
15537 /* A pair of DIE offset and GDB type pointer. We store these
15538 in a hash table separate from the DIEs, and preserve them
15539 when the DIEs are flushed out of cache. */
15541 struct dwarf2_offset_and_type
15543 unsigned int offset
;
15547 /* Hash function for a dwarf2_offset_and_type. */
15550 offset_and_type_hash (const void *item
)
15552 const struct dwarf2_offset_and_type
*ofs
= item
;
15554 return ofs
->offset
;
15557 /* Equality function for a dwarf2_offset_and_type. */
15560 offset_and_type_eq (const void *item_lhs
, const void *item_rhs
)
15562 const struct dwarf2_offset_and_type
*ofs_lhs
= item_lhs
;
15563 const struct dwarf2_offset_and_type
*ofs_rhs
= item_rhs
;
15565 return ofs_lhs
->offset
== ofs_rhs
->offset
;
15568 /* Set the type associated with DIE to TYPE. Save it in CU's hash
15569 table if necessary. For convenience, return TYPE.
15571 The DIEs reading must have careful ordering to:
15572 * Not cause infite loops trying to read in DIEs as a prerequisite for
15573 reading current DIE.
15574 * Not trying to dereference contents of still incompletely read in types
15575 while reading in other DIEs.
15576 * Enable referencing still incompletely read in types just by a pointer to
15577 the type without accessing its fields.
15579 Therefore caller should follow these rules:
15580 * Try to fetch any prerequisite types we may need to build this DIE type
15581 before building the type and calling set_die_type.
15582 * After building type call set_die_type for current DIE as soon as
15583 possible before fetching more types to complete the current type.
15584 * Make the type as complete as possible before fetching more types. */
15586 static struct type
*
15587 set_die_type (struct die_info
*die
, struct type
*type
, struct dwarf2_cu
*cu
)
15589 struct dwarf2_offset_and_type
**slot
, ofs
;
15590 struct objfile
*objfile
= cu
->objfile
;
15591 htab_t
*type_hash_ptr
;
15593 /* For Ada types, make sure that the gnat-specific data is always
15594 initialized (if not already set). There are a few types where
15595 we should not be doing so, because the type-specific area is
15596 already used to hold some other piece of info (eg: TYPE_CODE_FLT
15597 where the type-specific area is used to store the floatformat).
15598 But this is not a problem, because the gnat-specific information
15599 is actually not needed for these types. */
15600 if (need_gnat_info (cu
)
15601 && TYPE_CODE (type
) != TYPE_CODE_FUNC
15602 && TYPE_CODE (type
) != TYPE_CODE_FLT
15603 && !HAVE_GNAT_AUX_INFO (type
))
15604 INIT_GNAT_SPECIFIC (type
);
15606 if (cu
->per_cu
->debug_type_section
)
15607 type_hash_ptr
= &dwarf2_per_objfile
->debug_types_type_hash
;
15609 type_hash_ptr
= &dwarf2_per_objfile
->debug_info_type_hash
;
15611 if (*type_hash_ptr
== NULL
)
15614 = htab_create_alloc_ex (127,
15615 offset_and_type_hash
,
15616 offset_and_type_eq
,
15618 &objfile
->objfile_obstack
,
15619 hashtab_obstack_allocate
,
15620 dummy_obstack_deallocate
);
15623 ofs
.offset
= die
->offset
;
15625 slot
= (struct dwarf2_offset_and_type
**)
15626 htab_find_slot_with_hash (*type_hash_ptr
, &ofs
, ofs
.offset
, INSERT
);
15628 complaint (&symfile_complaints
,
15629 _("A problem internal to GDB: DIE 0x%x has type already set"),
15631 *slot
= obstack_alloc (&objfile
->objfile_obstack
, sizeof (**slot
));
15636 /* Look up the type for the die at DIE_OFFSET in the appropriate type_hash
15637 table, or return NULL if the die does not have a saved type. */
15639 static struct type
*
15640 get_die_type_at_offset (unsigned int offset
,
15641 struct dwarf2_per_cu_data
*per_cu
)
15643 struct dwarf2_offset_and_type
*slot
, ofs
;
15646 if (per_cu
->debug_type_section
)
15647 type_hash
= dwarf2_per_objfile
->debug_types_type_hash
;
15649 type_hash
= dwarf2_per_objfile
->debug_info_type_hash
;
15650 if (type_hash
== NULL
)
15653 ofs
.offset
= offset
;
15654 slot
= htab_find_with_hash (type_hash
, &ofs
, ofs
.offset
);
15661 /* Look up the type for DIE in the appropriate type_hash table,
15662 or return NULL if DIE does not have a saved type. */
15664 static struct type
*
15665 get_die_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
15667 return get_die_type_at_offset (die
->offset
, cu
->per_cu
);
15670 /* Add a dependence relationship from CU to REF_PER_CU. */
15673 dwarf2_add_dependence (struct dwarf2_cu
*cu
,
15674 struct dwarf2_per_cu_data
*ref_per_cu
)
15678 if (cu
->dependencies
== NULL
)
15680 = htab_create_alloc_ex (5, htab_hash_pointer
, htab_eq_pointer
,
15681 NULL
, &cu
->comp_unit_obstack
,
15682 hashtab_obstack_allocate
,
15683 dummy_obstack_deallocate
);
15685 slot
= htab_find_slot (cu
->dependencies
, ref_per_cu
, INSERT
);
15687 *slot
= ref_per_cu
;
15690 /* Subroutine of dwarf2_mark to pass to htab_traverse.
15691 Set the mark field in every compilation unit in the
15692 cache that we must keep because we are keeping CU. */
15695 dwarf2_mark_helper (void **slot
, void *data
)
15697 struct dwarf2_per_cu_data
*per_cu
;
15699 per_cu
= (struct dwarf2_per_cu_data
*) *slot
;
15701 /* cu->dependencies references may not yet have been ever read if QUIT aborts
15702 reading of the chain. As such dependencies remain valid it is not much
15703 useful to track and undo them during QUIT cleanups. */
15704 if (per_cu
->cu
== NULL
)
15707 if (per_cu
->cu
->mark
)
15709 per_cu
->cu
->mark
= 1;
15711 if (per_cu
->cu
->dependencies
!= NULL
)
15712 htab_traverse (per_cu
->cu
->dependencies
, dwarf2_mark_helper
, NULL
);
15717 /* Set the mark field in CU and in every other compilation unit in the
15718 cache that we must keep because we are keeping CU. */
15721 dwarf2_mark (struct dwarf2_cu
*cu
)
15726 if (cu
->dependencies
!= NULL
)
15727 htab_traverse (cu
->dependencies
, dwarf2_mark_helper
, NULL
);
15731 dwarf2_clear_marks (struct dwarf2_per_cu_data
*per_cu
)
15735 per_cu
->cu
->mark
= 0;
15736 per_cu
= per_cu
->cu
->read_in_chain
;
15740 /* Trivial hash function for partial_die_info: the hash value of a DIE
15741 is its offset in .debug_info for this objfile. */
15744 partial_die_hash (const void *item
)
15746 const struct partial_die_info
*part_die
= item
;
15748 return part_die
->offset
;
15751 /* Trivial comparison function for partial_die_info structures: two DIEs
15752 are equal if they have the same offset. */
15755 partial_die_eq (const void *item_lhs
, const void *item_rhs
)
15757 const struct partial_die_info
*part_die_lhs
= item_lhs
;
15758 const struct partial_die_info
*part_die_rhs
= item_rhs
;
15760 return part_die_lhs
->offset
== part_die_rhs
->offset
;
15763 static struct cmd_list_element
*set_dwarf2_cmdlist
;
15764 static struct cmd_list_element
*show_dwarf2_cmdlist
;
15767 set_dwarf2_cmd (char *args
, int from_tty
)
15769 help_list (set_dwarf2_cmdlist
, "maintenance set dwarf2 ", -1, gdb_stdout
);
15773 show_dwarf2_cmd (char *args
, int from_tty
)
15775 cmd_show_list (show_dwarf2_cmdlist
, from_tty
, "");
15778 /* If section described by INFO was mmapped, munmap it now. */
15781 munmap_section_buffer (struct dwarf2_section_info
*info
)
15783 if (info
->map_addr
!= NULL
)
15788 res
= munmap (info
->map_addr
, info
->map_len
);
15789 gdb_assert (res
== 0);
15791 /* Without HAVE_MMAP, we should never be here to begin with. */
15792 gdb_assert_not_reached ("no mmap support");
15797 /* munmap debug sections for OBJFILE, if necessary. */
15800 dwarf2_per_objfile_free (struct objfile
*objfile
, void *d
)
15802 struct dwarf2_per_objfile
*data
= d
;
15804 struct dwarf2_section_info
*section
;
15806 /* This is sorted according to the order they're defined in to make it easier
15807 to keep in sync. */
15808 munmap_section_buffer (&data
->info
);
15809 munmap_section_buffer (&data
->abbrev
);
15810 munmap_section_buffer (&data
->line
);
15811 munmap_section_buffer (&data
->loc
);
15812 munmap_section_buffer (&data
->macinfo
);
15813 munmap_section_buffer (&data
->macro
);
15814 munmap_section_buffer (&data
->str
);
15815 munmap_section_buffer (&data
->ranges
);
15816 munmap_section_buffer (&data
->frame
);
15817 munmap_section_buffer (&data
->eh_frame
);
15818 munmap_section_buffer (&data
->gdb_index
);
15821 VEC_iterate (dwarf2_section_info_def
, data
->types
, ix
, section
);
15823 munmap_section_buffer (section
);
15825 VEC_free (dwarf2_section_info_def
, data
->types
);
15829 /* The "save gdb-index" command. */
15831 /* The contents of the hash table we create when building the string
15833 struct strtab_entry
15835 offset_type offset
;
15839 /* Hash function for a strtab_entry.
15841 Function is used only during write_hash_table so no index format backward
15842 compatibility is needed. */
15845 hash_strtab_entry (const void *e
)
15847 const struct strtab_entry
*entry
= e
;
15848 return mapped_index_string_hash (INT_MAX
, entry
->str
);
15851 /* Equality function for a strtab_entry. */
15854 eq_strtab_entry (const void *a
, const void *b
)
15856 const struct strtab_entry
*ea
= a
;
15857 const struct strtab_entry
*eb
= b
;
15858 return !strcmp (ea
->str
, eb
->str
);
15861 /* Create a strtab_entry hash table. */
15864 create_strtab (void)
15866 return htab_create_alloc (100, hash_strtab_entry
, eq_strtab_entry
,
15867 xfree
, xcalloc
, xfree
);
15870 /* Add a string to the constant pool. Return the string's offset in
15874 add_string (htab_t table
, struct obstack
*cpool
, const char *str
)
15877 struct strtab_entry entry
;
15878 struct strtab_entry
*result
;
15881 slot
= htab_find_slot (table
, &entry
, INSERT
);
15886 result
= XNEW (struct strtab_entry
);
15887 result
->offset
= obstack_object_size (cpool
);
15889 obstack_grow_str0 (cpool
, str
);
15892 return result
->offset
;
15895 /* An entry in the symbol table. */
15896 struct symtab_index_entry
15898 /* The name of the symbol. */
15900 /* The offset of the name in the constant pool. */
15901 offset_type index_offset
;
15902 /* A sorted vector of the indices of all the CUs that hold an object
15904 VEC (offset_type
) *cu_indices
;
15907 /* The symbol table. This is a power-of-2-sized hash table. */
15908 struct mapped_symtab
15910 offset_type n_elements
;
15912 struct symtab_index_entry
**data
;
15915 /* Hash function for a symtab_index_entry. */
15918 hash_symtab_entry (const void *e
)
15920 const struct symtab_index_entry
*entry
= e
;
15921 return iterative_hash (VEC_address (offset_type
, entry
->cu_indices
),
15922 sizeof (offset_type
) * VEC_length (offset_type
,
15923 entry
->cu_indices
),
15927 /* Equality function for a symtab_index_entry. */
15930 eq_symtab_entry (const void *a
, const void *b
)
15932 const struct symtab_index_entry
*ea
= a
;
15933 const struct symtab_index_entry
*eb
= b
;
15934 int len
= VEC_length (offset_type
, ea
->cu_indices
);
15935 if (len
!= VEC_length (offset_type
, eb
->cu_indices
))
15937 return !memcmp (VEC_address (offset_type
, ea
->cu_indices
),
15938 VEC_address (offset_type
, eb
->cu_indices
),
15939 sizeof (offset_type
) * len
);
15942 /* Destroy a symtab_index_entry. */
15945 delete_symtab_entry (void *p
)
15947 struct symtab_index_entry
*entry
= p
;
15948 VEC_free (offset_type
, entry
->cu_indices
);
15952 /* Create a hash table holding symtab_index_entry objects. */
15955 create_symbol_hash_table (void)
15957 return htab_create_alloc (100, hash_symtab_entry
, eq_symtab_entry
,
15958 delete_symtab_entry
, xcalloc
, xfree
);
15961 /* Create a new mapped symtab object. */
15963 static struct mapped_symtab
*
15964 create_mapped_symtab (void)
15966 struct mapped_symtab
*symtab
= XNEW (struct mapped_symtab
);
15967 symtab
->n_elements
= 0;
15968 symtab
->size
= 1024;
15969 symtab
->data
= XCNEWVEC (struct symtab_index_entry
*, symtab
->size
);
15973 /* Destroy a mapped_symtab. */
15976 cleanup_mapped_symtab (void *p
)
15978 struct mapped_symtab
*symtab
= p
;
15979 /* The contents of the array are freed when the other hash table is
15981 xfree (symtab
->data
);
15985 /* Find a slot in SYMTAB for the symbol NAME. Returns a pointer to
15988 Function is used only during write_hash_table so no index format backward
15989 compatibility is needed. */
15991 static struct symtab_index_entry
**
15992 find_slot (struct mapped_symtab
*symtab
, const char *name
)
15994 offset_type index
, step
, hash
= mapped_index_string_hash (INT_MAX
, name
);
15996 index
= hash
& (symtab
->size
- 1);
15997 step
= ((hash
* 17) & (symtab
->size
- 1)) | 1;
16001 if (!symtab
->data
[index
] || !strcmp (name
, symtab
->data
[index
]->name
))
16002 return &symtab
->data
[index
];
16003 index
= (index
+ step
) & (symtab
->size
- 1);
16007 /* Expand SYMTAB's hash table. */
16010 hash_expand (struct mapped_symtab
*symtab
)
16012 offset_type old_size
= symtab
->size
;
16014 struct symtab_index_entry
**old_entries
= symtab
->data
;
16017 symtab
->data
= XCNEWVEC (struct symtab_index_entry
*, symtab
->size
);
16019 for (i
= 0; i
< old_size
; ++i
)
16021 if (old_entries
[i
])
16023 struct symtab_index_entry
**slot
= find_slot (symtab
,
16024 old_entries
[i
]->name
);
16025 *slot
= old_entries
[i
];
16029 xfree (old_entries
);
16032 /* Add an entry to SYMTAB. NAME is the name of the symbol. CU_INDEX
16033 is the index of the CU in which the symbol appears. */
16036 add_index_entry (struct mapped_symtab
*symtab
, const char *name
,
16037 offset_type cu_index
)
16039 struct symtab_index_entry
**slot
;
16041 ++symtab
->n_elements
;
16042 if (4 * symtab
->n_elements
/ 3 >= symtab
->size
)
16043 hash_expand (symtab
);
16045 slot
= find_slot (symtab
, name
);
16048 *slot
= XNEW (struct symtab_index_entry
);
16049 (*slot
)->name
= name
;
16050 (*slot
)->cu_indices
= NULL
;
16052 /* Don't push an index twice. Due to how we add entries we only
16053 have to check the last one. */
16054 if (VEC_empty (offset_type
, (*slot
)->cu_indices
)
16055 || VEC_last (offset_type
, (*slot
)->cu_indices
) != cu_index
)
16056 VEC_safe_push (offset_type
, (*slot
)->cu_indices
, cu_index
);
16059 /* Add a vector of indices to the constant pool. */
16062 add_indices_to_cpool (htab_t symbol_hash_table
, struct obstack
*cpool
,
16063 struct symtab_index_entry
*entry
)
16067 slot
= htab_find_slot (symbol_hash_table
, entry
, INSERT
);
16070 offset_type len
= VEC_length (offset_type
, entry
->cu_indices
);
16071 offset_type val
= MAYBE_SWAP (len
);
16076 entry
->index_offset
= obstack_object_size (cpool
);
16078 obstack_grow (cpool
, &val
, sizeof (val
));
16080 VEC_iterate (offset_type
, entry
->cu_indices
, i
, iter
);
16083 val
= MAYBE_SWAP (iter
);
16084 obstack_grow (cpool
, &val
, sizeof (val
));
16089 struct symtab_index_entry
*old_entry
= *slot
;
16090 entry
->index_offset
= old_entry
->index_offset
;
16093 return entry
->index_offset
;
16096 /* Write the mapped hash table SYMTAB to the obstack OUTPUT, with
16097 constant pool entries going into the obstack CPOOL. */
16100 write_hash_table (struct mapped_symtab
*symtab
,
16101 struct obstack
*output
, struct obstack
*cpool
)
16104 htab_t symbol_hash_table
;
16107 symbol_hash_table
= create_symbol_hash_table ();
16108 str_table
= create_strtab ();
16110 /* We add all the index vectors to the constant pool first, to
16111 ensure alignment is ok. */
16112 for (i
= 0; i
< symtab
->size
; ++i
)
16114 if (symtab
->data
[i
])
16115 add_indices_to_cpool (symbol_hash_table
, cpool
, symtab
->data
[i
]);
16118 /* Now write out the hash table. */
16119 for (i
= 0; i
< symtab
->size
; ++i
)
16121 offset_type str_off
, vec_off
;
16123 if (symtab
->data
[i
])
16125 str_off
= add_string (str_table
, cpool
, symtab
->data
[i
]->name
);
16126 vec_off
= symtab
->data
[i
]->index_offset
;
16130 /* While 0 is a valid constant pool index, it is not valid
16131 to have 0 for both offsets. */
16136 str_off
= MAYBE_SWAP (str_off
);
16137 vec_off
= MAYBE_SWAP (vec_off
);
16139 obstack_grow (output
, &str_off
, sizeof (str_off
));
16140 obstack_grow (output
, &vec_off
, sizeof (vec_off
));
16143 htab_delete (str_table
);
16144 htab_delete (symbol_hash_table
);
16147 /* Struct to map psymtab to CU index in the index file. */
16148 struct psymtab_cu_index_map
16150 struct partial_symtab
*psymtab
;
16151 unsigned int cu_index
;
16155 hash_psymtab_cu_index (const void *item
)
16157 const struct psymtab_cu_index_map
*map
= item
;
16159 return htab_hash_pointer (map
->psymtab
);
16163 eq_psymtab_cu_index (const void *item_lhs
, const void *item_rhs
)
16165 const struct psymtab_cu_index_map
*lhs
= item_lhs
;
16166 const struct psymtab_cu_index_map
*rhs
= item_rhs
;
16168 return lhs
->psymtab
== rhs
->psymtab
;
16171 /* Helper struct for building the address table. */
16172 struct addrmap_index_data
16174 struct objfile
*objfile
;
16175 struct obstack
*addr_obstack
;
16176 htab_t cu_index_htab
;
16178 /* Non-zero if the previous_* fields are valid.
16179 We can't write an entry until we see the next entry (since it is only then
16180 that we know the end of the entry). */
16181 int previous_valid
;
16182 /* Index of the CU in the table of all CUs in the index file. */
16183 unsigned int previous_cu_index
;
16184 /* Start address of the CU. */
16185 CORE_ADDR previous_cu_start
;
16188 /* Write an address entry to OBSTACK. */
16191 add_address_entry (struct objfile
*objfile
, struct obstack
*obstack
,
16192 CORE_ADDR start
, CORE_ADDR end
, unsigned int cu_index
)
16194 offset_type cu_index_to_write
;
16196 CORE_ADDR baseaddr
;
16198 baseaddr
= ANOFFSET (objfile
->section_offsets
, SECT_OFF_TEXT (objfile
));
16200 store_unsigned_integer (addr
, 8, BFD_ENDIAN_LITTLE
, start
- baseaddr
);
16201 obstack_grow (obstack
, addr
, 8);
16202 store_unsigned_integer (addr
, 8, BFD_ENDIAN_LITTLE
, end
- baseaddr
);
16203 obstack_grow (obstack
, addr
, 8);
16204 cu_index_to_write
= MAYBE_SWAP (cu_index
);
16205 obstack_grow (obstack
, &cu_index_to_write
, sizeof (offset_type
));
16208 /* Worker function for traversing an addrmap to build the address table. */
16211 add_address_entry_worker (void *datap
, CORE_ADDR start_addr
, void *obj
)
16213 struct addrmap_index_data
*data
= datap
;
16214 struct partial_symtab
*pst
= obj
;
16215 offset_type cu_index
;
16218 if (data
->previous_valid
)
16219 add_address_entry (data
->objfile
, data
->addr_obstack
,
16220 data
->previous_cu_start
, start_addr
,
16221 data
->previous_cu_index
);
16223 data
->previous_cu_start
= start_addr
;
16226 struct psymtab_cu_index_map find_map
, *map
;
16227 find_map
.psymtab
= pst
;
16228 map
= htab_find (data
->cu_index_htab
, &find_map
);
16229 gdb_assert (map
!= NULL
);
16230 data
->previous_cu_index
= map
->cu_index
;
16231 data
->previous_valid
= 1;
16234 data
->previous_valid
= 0;
16239 /* Write OBJFILE's address map to OBSTACK.
16240 CU_INDEX_HTAB is used to map addrmap entries to their CU indices
16241 in the index file. */
16244 write_address_map (struct objfile
*objfile
, struct obstack
*obstack
,
16245 htab_t cu_index_htab
)
16247 struct addrmap_index_data addrmap_index_data
;
16249 /* When writing the address table, we have to cope with the fact that
16250 the addrmap iterator only provides the start of a region; we have to
16251 wait until the next invocation to get the start of the next region. */
16253 addrmap_index_data
.objfile
= objfile
;
16254 addrmap_index_data
.addr_obstack
= obstack
;
16255 addrmap_index_data
.cu_index_htab
= cu_index_htab
;
16256 addrmap_index_data
.previous_valid
= 0;
16258 addrmap_foreach (objfile
->psymtabs_addrmap
, add_address_entry_worker
,
16259 &addrmap_index_data
);
16261 /* It's highly unlikely the last entry (end address = 0xff...ff)
16262 is valid, but we should still handle it.
16263 The end address is recorded as the start of the next region, but that
16264 doesn't work here. To cope we pass 0xff...ff, this is a rare situation
16266 if (addrmap_index_data
.previous_valid
)
16267 add_address_entry (objfile
, obstack
,
16268 addrmap_index_data
.previous_cu_start
, (CORE_ADDR
) -1,
16269 addrmap_index_data
.previous_cu_index
);
16272 /* Add a list of partial symbols to SYMTAB. */
16275 write_psymbols (struct mapped_symtab
*symtab
,
16277 struct partial_symbol
**psymp
,
16279 offset_type cu_index
,
16282 for (; count
-- > 0; ++psymp
)
16284 void **slot
, *lookup
;
16286 if (SYMBOL_LANGUAGE (*psymp
) == language_ada
)
16287 error (_("Ada is not currently supported by the index"));
16289 /* We only want to add a given psymbol once. However, we also
16290 want to account for whether it is global or static. So, we
16291 may add it twice, using slightly different values. */
16294 uintptr_t val
= 1 | (uintptr_t) *psymp
;
16296 lookup
= (void *) val
;
16301 /* Only add a given psymbol once. */
16302 slot
= htab_find_slot (psyms_seen
, lookup
, INSERT
);
16306 add_index_entry (symtab
, SYMBOL_NATURAL_NAME (*psymp
), cu_index
);
16311 /* Write the contents of an ("unfinished") obstack to FILE. Throw an
16312 exception if there is an error. */
16315 write_obstack (FILE *file
, struct obstack
*obstack
)
16317 if (fwrite (obstack_base (obstack
), 1, obstack_object_size (obstack
),
16319 != obstack_object_size (obstack
))
16320 error (_("couldn't data write to file"));
16323 /* Unlink a file if the argument is not NULL. */
16326 unlink_if_set (void *p
)
16328 char **filename
= p
;
16330 unlink (*filename
);
16333 /* A helper struct used when iterating over debug_types. */
16334 struct signatured_type_index_data
16336 struct objfile
*objfile
;
16337 struct mapped_symtab
*symtab
;
16338 struct obstack
*types_list
;
16343 /* A helper function that writes a single signatured_type to an
16347 write_one_signatured_type (void **slot
, void *d
)
16349 struct signatured_type_index_data
*info
= d
;
16350 struct signatured_type
*entry
= (struct signatured_type
*) *slot
;
16351 struct dwarf2_per_cu_data
*per_cu
= &entry
->per_cu
;
16352 struct partial_symtab
*psymtab
= per_cu
->v
.psymtab
;
16355 write_psymbols (info
->symtab
,
16357 info
->objfile
->global_psymbols
.list
16358 + psymtab
->globals_offset
,
16359 psymtab
->n_global_syms
, info
->cu_index
,
16361 write_psymbols (info
->symtab
,
16363 info
->objfile
->static_psymbols
.list
16364 + psymtab
->statics_offset
,
16365 psymtab
->n_static_syms
, info
->cu_index
,
16368 store_unsigned_integer (val
, 8, BFD_ENDIAN_LITTLE
, entry
->per_cu
.offset
);
16369 obstack_grow (info
->types_list
, val
, 8);
16370 store_unsigned_integer (val
, 8, BFD_ENDIAN_LITTLE
, entry
->type_offset
);
16371 obstack_grow (info
->types_list
, val
, 8);
16372 store_unsigned_integer (val
, 8, BFD_ENDIAN_LITTLE
, entry
->signature
);
16373 obstack_grow (info
->types_list
, val
, 8);
16380 /* A cleanup function for an htab_t. */
16383 cleanup_htab (void *arg
)
16388 /* Create an index file for OBJFILE in the directory DIR. */
16391 write_psymtabs_to_index (struct objfile
*objfile
, const char *dir
)
16393 struct cleanup
*cleanup
;
16394 char *filename
, *cleanup_filename
;
16395 struct obstack contents
, addr_obstack
, constant_pool
, symtab_obstack
;
16396 struct obstack cu_list
, types_cu_list
;
16399 struct mapped_symtab
*symtab
;
16400 offset_type val
, size_of_contents
, total_len
;
16404 htab_t cu_index_htab
;
16405 struct psymtab_cu_index_map
*psymtab_cu_index_map
;
16407 if (!objfile
->psymtabs
|| !objfile
->psymtabs_addrmap
)
16410 if (dwarf2_per_objfile
->using_index
)
16411 error (_("Cannot use an index to create the index"));
16413 if (VEC_length (dwarf2_section_info_def
, dwarf2_per_objfile
->types
) > 1)
16414 error (_("Cannot make an index when the file has multiple .debug_types sections"));
16416 if (stat (objfile
->name
, &st
) < 0)
16417 perror_with_name (objfile
->name
);
16419 filename
= concat (dir
, SLASH_STRING
, lbasename (objfile
->name
),
16420 INDEX_SUFFIX
, (char *) NULL
);
16421 cleanup
= make_cleanup (xfree
, filename
);
16423 out_file
= fopen (filename
, "wb");
16425 error (_("Can't open `%s' for writing"), filename
);
16427 cleanup_filename
= filename
;
16428 make_cleanup (unlink_if_set
, &cleanup_filename
);
16430 symtab
= create_mapped_symtab ();
16431 make_cleanup (cleanup_mapped_symtab
, symtab
);
16433 obstack_init (&addr_obstack
);
16434 make_cleanup_obstack_free (&addr_obstack
);
16436 obstack_init (&cu_list
);
16437 make_cleanup_obstack_free (&cu_list
);
16439 obstack_init (&types_cu_list
);
16440 make_cleanup_obstack_free (&types_cu_list
);
16442 psyms_seen
= htab_create_alloc (100, htab_hash_pointer
, htab_eq_pointer
,
16443 NULL
, xcalloc
, xfree
);
16444 make_cleanup (cleanup_htab
, psyms_seen
);
16446 /* While we're scanning CU's create a table that maps a psymtab pointer
16447 (which is what addrmap records) to its index (which is what is recorded
16448 in the index file). This will later be needed to write the address
16450 cu_index_htab
= htab_create_alloc (100,
16451 hash_psymtab_cu_index
,
16452 eq_psymtab_cu_index
,
16453 NULL
, xcalloc
, xfree
);
16454 make_cleanup (cleanup_htab
, cu_index_htab
);
16455 psymtab_cu_index_map
= (struct psymtab_cu_index_map
*)
16456 xmalloc (sizeof (struct psymtab_cu_index_map
)
16457 * dwarf2_per_objfile
->n_comp_units
);
16458 make_cleanup (xfree
, psymtab_cu_index_map
);
16460 /* The CU list is already sorted, so we don't need to do additional
16461 work here. Also, the debug_types entries do not appear in
16462 all_comp_units, but only in their own hash table. */
16463 for (i
= 0; i
< dwarf2_per_objfile
->n_comp_units
; ++i
)
16465 struct dwarf2_per_cu_data
*per_cu
16466 = dwarf2_per_objfile
->all_comp_units
[i
];
16467 struct partial_symtab
*psymtab
= per_cu
->v
.psymtab
;
16469 struct psymtab_cu_index_map
*map
;
16472 write_psymbols (symtab
,
16474 objfile
->global_psymbols
.list
+ psymtab
->globals_offset
,
16475 psymtab
->n_global_syms
, i
,
16477 write_psymbols (symtab
,
16479 objfile
->static_psymbols
.list
+ psymtab
->statics_offset
,
16480 psymtab
->n_static_syms
, i
,
16483 map
= &psymtab_cu_index_map
[i
];
16484 map
->psymtab
= psymtab
;
16486 slot
= htab_find_slot (cu_index_htab
, map
, INSERT
);
16487 gdb_assert (slot
!= NULL
);
16488 gdb_assert (*slot
== NULL
);
16491 store_unsigned_integer (val
, 8, BFD_ENDIAN_LITTLE
, per_cu
->offset
);
16492 obstack_grow (&cu_list
, val
, 8);
16493 store_unsigned_integer (val
, 8, BFD_ENDIAN_LITTLE
, per_cu
->length
);
16494 obstack_grow (&cu_list
, val
, 8);
16497 /* Dump the address map. */
16498 write_address_map (objfile
, &addr_obstack
, cu_index_htab
);
16500 /* Write out the .debug_type entries, if any. */
16501 if (dwarf2_per_objfile
->signatured_types
)
16503 struct signatured_type_index_data sig_data
;
16505 sig_data
.objfile
= objfile
;
16506 sig_data
.symtab
= symtab
;
16507 sig_data
.types_list
= &types_cu_list
;
16508 sig_data
.psyms_seen
= psyms_seen
;
16509 sig_data
.cu_index
= dwarf2_per_objfile
->n_comp_units
;
16510 htab_traverse_noresize (dwarf2_per_objfile
->signatured_types
,
16511 write_one_signatured_type
, &sig_data
);
16514 obstack_init (&constant_pool
);
16515 make_cleanup_obstack_free (&constant_pool
);
16516 obstack_init (&symtab_obstack
);
16517 make_cleanup_obstack_free (&symtab_obstack
);
16518 write_hash_table (symtab
, &symtab_obstack
, &constant_pool
);
16520 obstack_init (&contents
);
16521 make_cleanup_obstack_free (&contents
);
16522 size_of_contents
= 6 * sizeof (offset_type
);
16523 total_len
= size_of_contents
;
16525 /* The version number. */
16526 val
= MAYBE_SWAP (5);
16527 obstack_grow (&contents
, &val
, sizeof (val
));
16529 /* The offset of the CU list from the start of the file. */
16530 val
= MAYBE_SWAP (total_len
);
16531 obstack_grow (&contents
, &val
, sizeof (val
));
16532 total_len
+= obstack_object_size (&cu_list
);
16534 /* The offset of the types CU list from the start of the file. */
16535 val
= MAYBE_SWAP (total_len
);
16536 obstack_grow (&contents
, &val
, sizeof (val
));
16537 total_len
+= obstack_object_size (&types_cu_list
);
16539 /* The offset of the address table from the start of the file. */
16540 val
= MAYBE_SWAP (total_len
);
16541 obstack_grow (&contents
, &val
, sizeof (val
));
16542 total_len
+= obstack_object_size (&addr_obstack
);
16544 /* The offset of the symbol table from the start of the file. */
16545 val
= MAYBE_SWAP (total_len
);
16546 obstack_grow (&contents
, &val
, sizeof (val
));
16547 total_len
+= obstack_object_size (&symtab_obstack
);
16549 /* The offset of the constant pool from the start of the file. */
16550 val
= MAYBE_SWAP (total_len
);
16551 obstack_grow (&contents
, &val
, sizeof (val
));
16552 total_len
+= obstack_object_size (&constant_pool
);
16554 gdb_assert (obstack_object_size (&contents
) == size_of_contents
);
16556 write_obstack (out_file
, &contents
);
16557 write_obstack (out_file
, &cu_list
);
16558 write_obstack (out_file
, &types_cu_list
);
16559 write_obstack (out_file
, &addr_obstack
);
16560 write_obstack (out_file
, &symtab_obstack
);
16561 write_obstack (out_file
, &constant_pool
);
16565 /* We want to keep the file, so we set cleanup_filename to NULL
16566 here. See unlink_if_set. */
16567 cleanup_filename
= NULL
;
16569 do_cleanups (cleanup
);
16572 /* Implementation of the `save gdb-index' command.
16574 Note that the file format used by this command is documented in the
16575 GDB manual. Any changes here must be documented there. */
16578 save_gdb_index_command (char *arg
, int from_tty
)
16580 struct objfile
*objfile
;
16583 error (_("usage: save gdb-index DIRECTORY"));
16585 ALL_OBJFILES (objfile
)
16589 /* If the objfile does not correspond to an actual file, skip it. */
16590 if (stat (objfile
->name
, &st
) < 0)
16593 dwarf2_per_objfile
= objfile_data (objfile
, dwarf2_objfile_data_key
);
16594 if (dwarf2_per_objfile
)
16596 volatile struct gdb_exception except
;
16598 TRY_CATCH (except
, RETURN_MASK_ERROR
)
16600 write_psymtabs_to_index (objfile
, arg
);
16602 if (except
.reason
< 0)
16603 exception_fprintf (gdb_stderr
, except
,
16604 _("Error while writing index for `%s': "),
16612 int dwarf2_always_disassemble
;
16615 show_dwarf2_always_disassemble (struct ui_file
*file
, int from_tty
,
16616 struct cmd_list_element
*c
, const char *value
)
16618 fprintf_filtered (file
,
16619 _("Whether to always disassemble "
16620 "DWARF expressions is %s.\n"),
16625 show_check_physname (struct ui_file
*file
, int from_tty
,
16626 struct cmd_list_element
*c
, const char *value
)
16628 fprintf_filtered (file
,
16629 _("Whether to check \"physname\" is %s.\n"),
16633 void _initialize_dwarf2_read (void);
16636 _initialize_dwarf2_read (void)
16638 struct cmd_list_element
*c
;
16640 dwarf2_objfile_data_key
16641 = register_objfile_data_with_cleanup (NULL
, dwarf2_per_objfile_free
);
16643 add_prefix_cmd ("dwarf2", class_maintenance
, set_dwarf2_cmd
, _("\
16644 Set DWARF 2 specific variables.\n\
16645 Configure DWARF 2 variables such as the cache size"),
16646 &set_dwarf2_cmdlist
, "maintenance set dwarf2 ",
16647 0/*allow-unknown*/, &maintenance_set_cmdlist
);
16649 add_prefix_cmd ("dwarf2", class_maintenance
, show_dwarf2_cmd
, _("\
16650 Show DWARF 2 specific variables\n\
16651 Show DWARF 2 variables such as the cache size"),
16652 &show_dwarf2_cmdlist
, "maintenance show dwarf2 ",
16653 0/*allow-unknown*/, &maintenance_show_cmdlist
);
16655 add_setshow_zinteger_cmd ("max-cache-age", class_obscure
,
16656 &dwarf2_max_cache_age
, _("\
16657 Set the upper bound on the age of cached dwarf2 compilation units."), _("\
16658 Show the upper bound on the age of cached dwarf2 compilation units."), _("\
16659 A higher limit means that cached compilation units will be stored\n\
16660 in memory longer, and more total memory will be used. Zero disables\n\
16661 caching, which can slow down startup."),
16663 show_dwarf2_max_cache_age
,
16664 &set_dwarf2_cmdlist
,
16665 &show_dwarf2_cmdlist
);
16667 add_setshow_boolean_cmd ("always-disassemble", class_obscure
,
16668 &dwarf2_always_disassemble
, _("\
16669 Set whether `info address' always disassembles DWARF expressions."), _("\
16670 Show whether `info address' always disassembles DWARF expressions."), _("\
16671 When enabled, DWARF expressions are always printed in an assembly-like\n\
16672 syntax. When disabled, expressions will be printed in a more\n\
16673 conversational style, when possible."),
16675 show_dwarf2_always_disassemble
,
16676 &set_dwarf2_cmdlist
,
16677 &show_dwarf2_cmdlist
);
16679 add_setshow_zinteger_cmd ("dwarf2-die", no_class
, &dwarf2_die_debug
, _("\
16680 Set debugging of the dwarf2 DIE reader."), _("\
16681 Show debugging of the dwarf2 DIE reader."), _("\
16682 When enabled (non-zero), DIEs are dumped after they are read in.\n\
16683 The value is the maximum depth to print."),
16686 &setdebuglist
, &showdebuglist
);
16688 add_setshow_boolean_cmd ("check-physname", no_class
, &check_physname
, _("\
16689 Set cross-checking of \"physname\" code against demangler."), _("\
16690 Show cross-checking of \"physname\" code against demangler."), _("\
16691 When enabled, GDB's internal \"physname\" code is checked against\n\
16693 NULL
, show_check_physname
,
16694 &setdebuglist
, &showdebuglist
);
16696 c
= add_cmd ("gdb-index", class_files
, save_gdb_index_command
,
16698 Save a gdb-index file.\n\
16699 Usage: save gdb-index DIRECTORY"),
16701 set_cmd_completer (c
, filename_completer
);