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 "gdb-demangle.h"
38 #include "expression.h"
39 #include "filenames.h" /* for DOSish file names */
42 #include "complaints.h"
44 #include "dwarf2expr.h"
45 #include "dwarf2loc.h"
46 #include "cp-support.h"
52 #include "typeprint.h"
55 #include "exceptions.h"
57 #include "completer.h"
64 #include "gdb_string.h"
65 #include "gdb_assert.h"
66 #include <sys/types.h>
73 #define MAP_FAILED ((void *) -1)
77 typedef struct symbol
*symbolp
;
81 /* .debug_info header for a compilation unit
82 Because of alignment constraints, this structure has padding and cannot
83 be mapped directly onto the beginning of the .debug_info section. */
84 typedef struct comp_unit_header
86 unsigned int length
; /* length of the .debug_info
88 unsigned short version
; /* version number -- 2 for DWARF
90 unsigned int abbrev_offset
; /* offset into .debug_abbrev section */
91 unsigned char addr_size
; /* byte size of an address -- 4 */
94 #define _ACTUAL_COMP_UNIT_HEADER_SIZE 11
97 /* .debug_line statement program prologue
98 Because of alignment constraints, this structure has padding and cannot
99 be mapped directly onto the beginning of the .debug_info section. */
100 typedef struct statement_prologue
102 unsigned int total_length
; /* byte length of the statement
104 unsigned short version
; /* version number -- 2 for DWARF
106 unsigned int prologue_length
; /* # bytes between prologue &
108 unsigned char minimum_instruction_length
; /* byte size of
110 unsigned char default_is_stmt
; /* initial value of is_stmt
113 unsigned char line_range
;
114 unsigned char opcode_base
; /* number assigned to first special
116 unsigned char *standard_opcode_lengths
;
120 /* When non-zero, dump DIEs after they are read in. */
121 static int dwarf2_die_debug
= 0;
123 /* When non-zero, cross-check physname against demangler. */
124 static int check_physname
= 0;
128 /* When set, the file that we're processing is known to have debugging
129 info for C++ namespaces. GCC 3.3.x did not produce this information,
130 but later versions do. */
132 static int processing_has_namespace_info
;
134 static const struct objfile_data
*dwarf2_objfile_data_key
;
136 struct dwarf2_section_info
141 /* Not NULL if the section was actually mmapped. */
143 /* Page aligned size of mmapped area. */
144 bfd_size_type map_len
;
145 /* True if we have tried to read this section. */
149 typedef struct dwarf2_section_info dwarf2_section_info_def
;
150 DEF_VEC_O (dwarf2_section_info_def
);
152 /* All offsets in the index are of this type. It must be
153 architecture-independent. */
154 typedef uint32_t offset_type
;
156 DEF_VEC_I (offset_type
);
158 /* A description of the mapped index. The file format is described in
159 a comment by the code that writes the index. */
162 /* Index data format version. */
165 /* The total length of the buffer. */
168 /* A pointer to the address table data. */
169 const gdb_byte
*address_table
;
171 /* Size of the address table data in bytes. */
172 offset_type address_table_size
;
174 /* The symbol table, implemented as a hash table. */
175 const offset_type
*symbol_table
;
177 /* Size in slots, each slot is 2 offset_types. */
178 offset_type symbol_table_slots
;
180 /* A pointer to the constant pool. */
181 const char *constant_pool
;
184 struct dwarf2_per_objfile
186 struct dwarf2_section_info info
;
187 struct dwarf2_section_info abbrev
;
188 struct dwarf2_section_info line
;
189 struct dwarf2_section_info loc
;
190 struct dwarf2_section_info macinfo
;
191 struct dwarf2_section_info macro
;
192 struct dwarf2_section_info str
;
193 struct dwarf2_section_info ranges
;
194 struct dwarf2_section_info frame
;
195 struct dwarf2_section_info eh_frame
;
196 struct dwarf2_section_info gdb_index
;
198 VEC (dwarf2_section_info_def
) *types
;
201 struct objfile
*objfile
;
203 /* A list of all the compilation units. This is used to locate
204 the target compilation unit of a particular reference. */
205 struct dwarf2_per_cu_data
**all_comp_units
;
207 /* The number of compilation units in ALL_COMP_UNITS. */
210 /* The number of .debug_types-related CUs. */
211 int n_type_comp_units
;
213 /* The .debug_types-related CUs. */
214 struct dwarf2_per_cu_data
**type_comp_units
;
216 /* A chain of compilation units that are currently read in, so that
217 they can be freed later. */
218 struct dwarf2_per_cu_data
*read_in_chain
;
220 /* A table mapping .debug_types signatures to its signatured_type entry.
221 This is NULL if the .debug_types section hasn't been read in yet. */
222 htab_t signatured_types
;
224 /* A flag indicating wether this objfile has a section loaded at a
226 int has_section_at_zero
;
228 /* True if we are using the mapped index,
229 or we are faking it for OBJF_READNOW's sake. */
230 unsigned char using_index
;
232 /* The mapped index, or NULL if .gdb_index is missing or not being used. */
233 struct mapped_index
*index_table
;
235 /* When using index_table, this keeps track of all quick_file_names entries.
236 TUs can share line table entries with CUs or other TUs, and there can be
237 a lot more TUs than unique line tables, so we maintain a separate table
238 of all line table entries to support the sharing. */
239 htab_t quick_file_names_table
;
241 /* Set during partial symbol reading, to prevent queueing of full
243 int reading_partial_symbols
;
245 /* Table mapping type .debug_info DIE offsets to types.
246 This is NULL if not allocated yet.
247 It (currently) makes sense to allocate debug_types_type_hash lazily.
248 To keep things simple we allocate both lazily. */
249 htab_t debug_info_type_hash
;
251 /* Table mapping type .debug_types DIE offsets to types.
252 This is NULL if not allocated yet. */
253 htab_t debug_types_type_hash
;
256 static struct dwarf2_per_objfile
*dwarf2_per_objfile
;
258 /* Default names of the debugging sections. */
260 /* Note that if the debugging section has been compressed, it might
261 have a name like .zdebug_info. */
263 static const struct dwarf2_debug_sections dwarf2_elf_names
= {
264 { ".debug_info", ".zdebug_info" },
265 { ".debug_abbrev", ".zdebug_abbrev" },
266 { ".debug_line", ".zdebug_line" },
267 { ".debug_loc", ".zdebug_loc" },
268 { ".debug_macinfo", ".zdebug_macinfo" },
269 { ".debug_macro", ".zdebug_macro" },
270 { ".debug_str", ".zdebug_str" },
271 { ".debug_ranges", ".zdebug_ranges" },
272 { ".debug_types", ".zdebug_types" },
273 { ".debug_frame", ".zdebug_frame" },
274 { ".eh_frame", NULL
},
275 { ".gdb_index", ".zgdb_index" },
279 /* local data types */
281 /* We hold several abbreviation tables in memory at the same time. */
282 #ifndef ABBREV_HASH_SIZE
283 #define ABBREV_HASH_SIZE 121
286 /* The data in a compilation unit header, after target2host
287 translation, looks like this. */
288 struct comp_unit_head
292 unsigned char addr_size
;
293 unsigned char signed_addr_p
;
294 unsigned int abbrev_offset
;
296 /* Size of file offsets; either 4 or 8. */
297 unsigned int offset_size
;
299 /* Size of the length field; either 4 or 12. */
300 unsigned int initial_length_size
;
302 /* Offset to the first byte of this compilation unit header in the
303 .debug_info section, for resolving relative reference dies. */
306 /* Offset to first die in this cu from the start of the cu.
307 This will be the first byte following the compilation unit header. */
308 unsigned int first_die_offset
;
311 /* Type used for delaying computation of method physnames.
312 See comments for compute_delayed_physnames. */
313 struct delayed_method_info
315 /* The type to which the method is attached, i.e., its parent class. */
318 /* The index of the method in the type's function fieldlists. */
321 /* The index of the method in the fieldlist. */
324 /* The name of the DIE. */
327 /* The DIE associated with this method. */
328 struct die_info
*die
;
331 typedef struct delayed_method_info delayed_method_info
;
332 DEF_VEC_O (delayed_method_info
);
334 /* Internal state when decoding a particular compilation unit. */
337 /* The objfile containing this compilation unit. */
338 struct objfile
*objfile
;
340 /* The header of the compilation unit. */
341 struct comp_unit_head header
;
343 /* Base address of this compilation unit. */
344 CORE_ADDR base_address
;
346 /* Non-zero if base_address has been set. */
349 struct function_range
*first_fn
, *last_fn
, *cached_fn
;
351 /* The language we are debugging. */
352 enum language language
;
353 const struct language_defn
*language_defn
;
355 const char *producer
;
357 /* The generic symbol table building routines have separate lists for
358 file scope symbols and all all other scopes (local scopes). So
359 we need to select the right one to pass to add_symbol_to_list().
360 We do it by keeping a pointer to the correct list in list_in_scope.
362 FIXME: The original dwarf code just treated the file scope as the
363 first local scope, and all other local scopes as nested local
364 scopes, and worked fine. Check to see if we really need to
365 distinguish these in buildsym.c. */
366 struct pending
**list_in_scope
;
368 /* DWARF abbreviation table associated with this compilation unit. */
369 struct abbrev_info
**dwarf2_abbrevs
;
371 /* Storage for the abbrev table. */
372 struct obstack abbrev_obstack
;
374 /* Hash table holding all the loaded partial DIEs. */
377 /* Storage for things with the same lifetime as this read-in compilation
378 unit, including partial DIEs. */
379 struct obstack comp_unit_obstack
;
381 /* When multiple dwarf2_cu structures are living in memory, this field
382 chains them all together, so that they can be released efficiently.
383 We will probably also want a generation counter so that most-recently-used
384 compilation units are cached... */
385 struct dwarf2_per_cu_data
*read_in_chain
;
387 /* Backchain to our per_cu entry if the tree has been built. */
388 struct dwarf2_per_cu_data
*per_cu
;
390 /* How many compilation units ago was this CU last referenced? */
393 /* A hash table of die offsets for following references. */
396 /* Full DIEs if read in. */
397 struct die_info
*dies
;
399 /* A set of pointers to dwarf2_per_cu_data objects for compilation
400 units referenced by this one. Only set during full symbol processing;
401 partial symbol tables do not have dependencies. */
404 /* Header data from the line table, during full symbol processing. */
405 struct line_header
*line_header
;
407 /* A list of methods which need to have physnames computed
408 after all type information has been read. */
409 VEC (delayed_method_info
) *method_list
;
411 /* To be copied to symtab->call_site_htab. */
412 htab_t call_site_htab
;
414 /* Mark used when releasing cached dies. */
415 unsigned int mark
: 1;
417 /* This flag will be set if this compilation unit might include
418 inter-compilation-unit references. */
419 unsigned int has_form_ref_addr
: 1;
421 /* This flag will be set if this compilation unit includes any
422 DW_TAG_namespace DIEs. If we know that there are explicit
423 DIEs for namespaces, we don't need to try to infer them
424 from mangled names. */
425 unsigned int has_namespace_info
: 1;
427 /* This CU references .debug_loc. See the symtab->locations_valid field.
428 This test is imperfect as there may exist optimized debug code not using
429 any location list and still facing inlining issues if handled as
430 unoptimized code. For a future better test see GCC PR other/32998. */
432 unsigned int has_loclist
: 1;
435 /* Persistent data held for a compilation unit, even when not
436 processing it. We put a pointer to this structure in the
437 read_symtab_private field of the psymtab. If we encounter
438 inter-compilation-unit references, we also maintain a sorted
439 list of all compilation units. */
441 struct dwarf2_per_cu_data
443 /* The start offset and length of this compilation unit. 2**29-1
444 bytes should suffice to store the length of any compilation unit
445 - if it doesn't, GDB will fall over anyway.
446 NOTE: Unlike comp_unit_head.length, this length includes
447 initial_length_size. */
449 unsigned int length
: 29;
451 /* Flag indicating this compilation unit will be read in before
452 any of the current compilation units are processed. */
453 unsigned int queued
: 1;
455 /* This flag will be set if we need to load absolutely all DIEs
456 for this compilation unit, instead of just the ones we think
457 are interesting. It gets set if we look for a DIE in the
458 hash table and don't find it. */
459 unsigned int load_all_dies
: 1;
461 /* Non-null if this CU is from .debug_types; in which case it points
462 to the section. Otherwise it's from .debug_info. */
463 struct dwarf2_section_info
*debug_type_section
;
465 /* Set to non-NULL iff this CU is currently loaded. When it gets freed out
466 of the CU cache it gets reset to NULL again. */
467 struct dwarf2_cu
*cu
;
469 /* The corresponding objfile. */
470 struct objfile
*objfile
;
472 /* When using partial symbol tables, the 'psymtab' field is active.
473 Otherwise the 'quick' field is active. */
476 /* The partial symbol table associated with this compilation unit,
477 or NULL for partial units (which do not have an associated
479 struct partial_symtab
*psymtab
;
481 /* Data needed by the "quick" functions. */
482 struct dwarf2_per_cu_quick_data
*quick
;
486 /* Entry in the signatured_types hash table. */
488 struct signatured_type
492 /* Offset in .debug_types of the type defined by this TU. */
493 unsigned int type_offset
;
495 /* The CU(/TU) of this type. */
496 struct dwarf2_per_cu_data per_cu
;
499 /* Struct used to pass misc. parameters to read_die_and_children, et
500 al. which are used for both .debug_info and .debug_types dies.
501 All parameters here are unchanging for the life of the call. This
502 struct exists to abstract away the constant parameters of die
505 struct die_reader_specs
507 /* The bfd of this objfile. */
510 /* The CU of the DIE we are parsing. */
511 struct dwarf2_cu
*cu
;
513 /* Pointer to start of section buffer.
514 This is either the start of .debug_info or .debug_types. */
515 const gdb_byte
*buffer
;
518 /* The line number information for a compilation unit (found in the
519 .debug_line section) begins with a "statement program header",
520 which contains the following information. */
523 unsigned int total_length
;
524 unsigned short version
;
525 unsigned int header_length
;
526 unsigned char minimum_instruction_length
;
527 unsigned char maximum_ops_per_instruction
;
528 unsigned char default_is_stmt
;
530 unsigned char line_range
;
531 unsigned char opcode_base
;
533 /* standard_opcode_lengths[i] is the number of operands for the
534 standard opcode whose value is i. This means that
535 standard_opcode_lengths[0] is unused, and the last meaningful
536 element is standard_opcode_lengths[opcode_base - 1]. */
537 unsigned char *standard_opcode_lengths
;
539 /* The include_directories table. NOTE! These strings are not
540 allocated with xmalloc; instead, they are pointers into
541 debug_line_buffer. If you try to free them, `free' will get
543 unsigned int num_include_dirs
, include_dirs_size
;
546 /* The file_names table. NOTE! These strings are not allocated
547 with xmalloc; instead, they are pointers into debug_line_buffer.
548 Don't try to free them directly. */
549 unsigned int num_file_names
, file_names_size
;
553 unsigned int dir_index
;
554 unsigned int mod_time
;
556 int included_p
; /* Non-zero if referenced by the Line Number Program. */
557 struct symtab
*symtab
; /* The associated symbol table, if any. */
560 /* The start and end of the statement program following this
561 header. These point into dwarf2_per_objfile->line_buffer. */
562 gdb_byte
*statement_program_start
, *statement_program_end
;
565 /* When we construct a partial symbol table entry we only
566 need this much information. */
567 struct partial_die_info
569 /* Offset of this DIE. */
572 /* DWARF-2 tag for this DIE. */
573 ENUM_BITFIELD(dwarf_tag
) tag
: 16;
575 /* Assorted flags describing the data found in this DIE. */
576 unsigned int has_children
: 1;
577 unsigned int is_external
: 1;
578 unsigned int is_declaration
: 1;
579 unsigned int has_type
: 1;
580 unsigned int has_specification
: 1;
581 unsigned int has_pc_info
: 1;
583 /* Flag set if the SCOPE field of this structure has been
585 unsigned int scope_set
: 1;
587 /* Flag set if the DIE has a byte_size attribute. */
588 unsigned int has_byte_size
: 1;
590 /* Flag set if any of the DIE's children are template arguments. */
591 unsigned int has_template_arguments
: 1;
593 /* Flag set if fixup_partial_die has been called on this die. */
594 unsigned int fixup_called
: 1;
596 /* The name of this DIE. Normally the value of DW_AT_name, but
597 sometimes a default name for unnamed DIEs. */
600 /* The linkage name, if present. */
601 const char *linkage_name
;
603 /* The scope to prepend to our children. This is generally
604 allocated on the comp_unit_obstack, so will disappear
605 when this compilation unit leaves the cache. */
608 /* The location description associated with this DIE, if any. */
609 struct dwarf_block
*locdesc
;
611 /* If HAS_PC_INFO, the PC range associated with this DIE. */
615 /* Pointer into the info_buffer (or types_buffer) pointing at the target of
616 DW_AT_sibling, if any. */
617 /* NOTE: This member isn't strictly necessary, read_partial_die could
618 return DW_AT_sibling values to its caller load_partial_dies. */
621 /* If HAS_SPECIFICATION, the offset of the DIE referred to by
622 DW_AT_specification (or DW_AT_abstract_origin or
624 unsigned int spec_offset
;
626 /* Pointers to this DIE's parent, first child, and next sibling,
628 struct partial_die_info
*die_parent
, *die_child
, *die_sibling
;
631 /* This data structure holds the information of an abbrev. */
634 unsigned int number
; /* number identifying abbrev */
635 enum dwarf_tag tag
; /* dwarf tag */
636 unsigned short has_children
; /* boolean */
637 unsigned short num_attrs
; /* number of attributes */
638 struct attr_abbrev
*attrs
; /* an array of attribute descriptions */
639 struct abbrev_info
*next
; /* next in chain */
644 ENUM_BITFIELD(dwarf_attribute
) name
: 16;
645 ENUM_BITFIELD(dwarf_form
) form
: 16;
648 /* Attributes have a name and a value. */
651 ENUM_BITFIELD(dwarf_attribute
) name
: 16;
652 ENUM_BITFIELD(dwarf_form
) form
: 15;
654 /* Has DW_STRING already been updated by dwarf2_canonicalize_name? This
655 field should be in u.str (existing only for DW_STRING) but it is kept
656 here for better struct attribute alignment. */
657 unsigned int string_is_canonical
: 1;
662 struct dwarf_block
*blk
;
666 struct signatured_type
*signatured_type
;
671 /* This data structure holds a complete die structure. */
674 /* DWARF-2 tag for this DIE. */
675 ENUM_BITFIELD(dwarf_tag
) tag
: 16;
677 /* Number of attributes */
678 unsigned char num_attrs
;
680 /* True if we're presently building the full type name for the
681 type derived from this DIE. */
682 unsigned char building_fullname
: 1;
687 /* Offset in .debug_info or .debug_types section. */
690 /* The dies in a compilation unit form an n-ary tree. PARENT
691 points to this die's parent; CHILD points to the first child of
692 this node; and all the children of a given node are chained
693 together via their SIBLING fields. */
694 struct die_info
*child
; /* Its first child, if any. */
695 struct die_info
*sibling
; /* Its next sibling, if any. */
696 struct die_info
*parent
; /* Its parent, if any. */
698 /* An array of attributes, with NUM_ATTRS elements. There may be
699 zero, but it's not common and zero-sized arrays are not
700 sufficiently portable C. */
701 struct attribute attrs
[1];
704 struct function_range
707 CORE_ADDR lowpc
, highpc
;
709 struct function_range
*next
;
712 /* Get at parts of an attribute structure. */
714 #define DW_STRING(attr) ((attr)->u.str)
715 #define DW_STRING_IS_CANONICAL(attr) ((attr)->string_is_canonical)
716 #define DW_UNSND(attr) ((attr)->u.unsnd)
717 #define DW_BLOCK(attr) ((attr)->u.blk)
718 #define DW_SND(attr) ((attr)->u.snd)
719 #define DW_ADDR(attr) ((attr)->u.addr)
720 #define DW_SIGNATURED_TYPE(attr) ((attr)->u.signatured_type)
722 /* Blocks are a bunch of untyped bytes. */
727 /* Valid only if SIZE is not zero. */
731 #ifndef ATTR_ALLOC_CHUNK
732 #define ATTR_ALLOC_CHUNK 4
735 /* Allocate fields for structs, unions and enums in this size. */
736 #ifndef DW_FIELD_ALLOC_CHUNK
737 #define DW_FIELD_ALLOC_CHUNK 4
740 /* FIXME: We might want to set this from BFD via bfd_arch_bits_per_byte,
741 but this would require a corresponding change in unpack_field_as_long
743 static int bits_per_byte
= 8;
745 /* The routines that read and process dies for a C struct or C++ class
746 pass lists of data member fields and lists of member function fields
747 in an instance of a field_info structure, as defined below. */
750 /* List of data member and baseclasses fields. */
753 struct nextfield
*next
;
758 *fields
, *baseclasses
;
760 /* Number of fields (including baseclasses). */
763 /* Number of baseclasses. */
766 /* Set if the accesibility of one of the fields is not public. */
767 int non_public_fields
;
769 /* Member function fields array, entries are allocated in the order they
770 are encountered in the object file. */
773 struct nextfnfield
*next
;
774 struct fn_field fnfield
;
778 /* Member function fieldlist array, contains name of possibly overloaded
779 member function, number of overloaded member functions and a pointer
780 to the head of the member function field chain. */
785 struct nextfnfield
*head
;
789 /* Number of entries in the fnfieldlists array. */
792 /* typedefs defined inside this class. TYPEDEF_FIELD_LIST contains head of
793 a NULL terminated list of TYPEDEF_FIELD_LIST_COUNT elements. */
794 struct typedef_field_list
796 struct typedef_field field
;
797 struct typedef_field_list
*next
;
800 unsigned typedef_field_list_count
;
803 /* One item on the queue of compilation units to read in full symbols
805 struct dwarf2_queue_item
807 struct dwarf2_per_cu_data
*per_cu
;
808 struct dwarf2_queue_item
*next
;
811 /* The current queue. */
812 static struct dwarf2_queue_item
*dwarf2_queue
, *dwarf2_queue_tail
;
814 /* Loaded secondary compilation units are kept in memory until they
815 have not been referenced for the processing of this many
816 compilation units. Set this to zero to disable caching. Cache
817 sizes of up to at least twenty will improve startup time for
818 typical inter-CU-reference binaries, at an obvious memory cost. */
819 static int dwarf2_max_cache_age
= 5;
821 show_dwarf2_max_cache_age (struct ui_file
*file
, int from_tty
,
822 struct cmd_list_element
*c
, const char *value
)
824 fprintf_filtered (file
, _("The upper bound on the age of cached "
825 "dwarf2 compilation units is %s.\n"),
830 /* Various complaints about symbol reading that don't abort the process. */
833 dwarf2_statement_list_fits_in_line_number_section_complaint (void)
835 complaint (&symfile_complaints
,
836 _("statement list doesn't fit in .debug_line section"));
840 dwarf2_debug_line_missing_file_complaint (void)
842 complaint (&symfile_complaints
,
843 _(".debug_line section has line data without a file"));
847 dwarf2_debug_line_missing_end_sequence_complaint (void)
849 complaint (&symfile_complaints
,
850 _(".debug_line section has line "
851 "program sequence without an end"));
855 dwarf2_complex_location_expr_complaint (void)
857 complaint (&symfile_complaints
, _("location expression too complex"));
861 dwarf2_const_value_length_mismatch_complaint (const char *arg1
, int arg2
,
864 complaint (&symfile_complaints
,
865 _("const value length mismatch for '%s', got %d, expected %d"),
870 dwarf2_macros_too_long_complaint (struct dwarf2_section_info
*section
)
872 complaint (&symfile_complaints
,
873 _("macro info runs off end of `%s' section"),
874 section
->asection
->name
);
878 dwarf2_macro_malformed_definition_complaint (const char *arg1
)
880 complaint (&symfile_complaints
,
881 _("macro debug info contains a "
882 "malformed macro definition:\n`%s'"),
887 dwarf2_invalid_attrib_class_complaint (const char *arg1
, const char *arg2
)
889 complaint (&symfile_complaints
,
890 _("invalid attribute class or form for '%s' in '%s'"),
894 /* local function prototypes */
896 static void dwarf2_locate_sections (bfd
*, asection
*, void *);
898 static void dwarf2_create_include_psymtab (char *, struct partial_symtab
*,
901 static void dwarf2_find_base_address (struct die_info
*die
,
902 struct dwarf2_cu
*cu
);
904 static void dwarf2_build_psymtabs_hard (struct objfile
*);
906 static void scan_partial_symbols (struct partial_die_info
*,
907 CORE_ADDR
*, CORE_ADDR
*,
908 int, struct dwarf2_cu
*);
910 static void add_partial_symbol (struct partial_die_info
*,
913 static void add_partial_namespace (struct partial_die_info
*pdi
,
914 CORE_ADDR
*lowpc
, CORE_ADDR
*highpc
,
915 int need_pc
, struct dwarf2_cu
*cu
);
917 static void add_partial_module (struct partial_die_info
*pdi
, CORE_ADDR
*lowpc
,
918 CORE_ADDR
*highpc
, int need_pc
,
919 struct dwarf2_cu
*cu
);
921 static void add_partial_enumeration (struct partial_die_info
*enum_pdi
,
922 struct dwarf2_cu
*cu
);
924 static void add_partial_subprogram (struct partial_die_info
*pdi
,
925 CORE_ADDR
*lowpc
, CORE_ADDR
*highpc
,
926 int need_pc
, struct dwarf2_cu
*cu
);
928 static gdb_byte
*locate_pdi_sibling (struct partial_die_info
*orig_pdi
,
929 gdb_byte
*buffer
, gdb_byte
*info_ptr
,
930 bfd
*abfd
, struct dwarf2_cu
*cu
);
932 static void dwarf2_psymtab_to_symtab (struct partial_symtab
*);
934 static void psymtab_to_symtab_1 (struct partial_symtab
*);
936 static void dwarf2_read_abbrevs (bfd
*abfd
, struct dwarf2_cu
*cu
);
938 static void dwarf2_free_abbrev_table (void *);
940 static unsigned int peek_abbrev_code (bfd
*, gdb_byte
*);
942 static struct abbrev_info
*peek_die_abbrev (gdb_byte
*, unsigned int *,
945 static struct abbrev_info
*dwarf2_lookup_abbrev (unsigned int,
948 static struct partial_die_info
*load_partial_dies (bfd
*,
949 gdb_byte
*, gdb_byte
*,
950 int, struct dwarf2_cu
*);
952 static gdb_byte
*read_partial_die (struct partial_die_info
*,
953 struct abbrev_info
*abbrev
,
955 gdb_byte
*, gdb_byte
*,
958 static struct partial_die_info
*find_partial_die (unsigned int,
961 static void fixup_partial_die (struct partial_die_info
*,
964 static gdb_byte
*read_attribute (struct attribute
*, struct attr_abbrev
*,
965 bfd
*, gdb_byte
*, struct dwarf2_cu
*);
967 static gdb_byte
*read_attribute_value (struct attribute
*, unsigned,
968 bfd
*, gdb_byte
*, struct dwarf2_cu
*);
970 static unsigned int read_1_byte (bfd
*, gdb_byte
*);
972 static int read_1_signed_byte (bfd
*, gdb_byte
*);
974 static unsigned int read_2_bytes (bfd
*, gdb_byte
*);
976 static unsigned int read_4_bytes (bfd
*, gdb_byte
*);
978 static ULONGEST
read_8_bytes (bfd
*, gdb_byte
*);
980 static CORE_ADDR
read_address (bfd
*, gdb_byte
*ptr
, struct dwarf2_cu
*,
983 static LONGEST
read_initial_length (bfd
*, gdb_byte
*, unsigned int *);
985 static LONGEST read_checked_initial_length_and_offset
986 (bfd
*, gdb_byte
*, const struct comp_unit_head
*,
987 unsigned int *, unsigned int *);
989 static LONGEST
read_offset (bfd
*, gdb_byte
*, const struct comp_unit_head
*,
992 static LONGEST
read_offset_1 (bfd
*, gdb_byte
*, unsigned int);
994 static gdb_byte
*read_n_bytes (bfd
*, gdb_byte
*, unsigned int);
996 static char *read_direct_string (bfd
*, gdb_byte
*, unsigned int *);
998 static char *read_indirect_string (bfd
*, gdb_byte
*,
999 const struct comp_unit_head
*,
1002 static unsigned long read_unsigned_leb128 (bfd
*, gdb_byte
*, unsigned int *);
1004 static long read_signed_leb128 (bfd
*, gdb_byte
*, unsigned int *);
1006 static gdb_byte
*skip_leb128 (bfd
*, gdb_byte
*);
1008 static void set_cu_language (unsigned int, struct dwarf2_cu
*);
1010 static struct attribute
*dwarf2_attr (struct die_info
*, unsigned int,
1011 struct dwarf2_cu
*);
1013 static struct attribute
*dwarf2_attr_no_follow (struct die_info
*,
1015 struct dwarf2_cu
*);
1017 static int dwarf2_flag_true_p (struct die_info
*die
, unsigned name
,
1018 struct dwarf2_cu
*cu
);
1020 static int die_is_declaration (struct die_info
*, struct dwarf2_cu
*cu
);
1022 static struct die_info
*die_specification (struct die_info
*die
,
1023 struct dwarf2_cu
**);
1025 static void free_line_header (struct line_header
*lh
);
1027 static void add_file_name (struct line_header
*, char *, unsigned int,
1028 unsigned int, unsigned int);
1030 static struct line_header
*(dwarf_decode_line_header
1031 (unsigned int offset
,
1032 bfd
*abfd
, struct dwarf2_cu
*cu
));
1034 static void dwarf_decode_lines (struct line_header
*, const char *, bfd
*,
1035 struct dwarf2_cu
*, struct partial_symtab
*);
1037 static void dwarf2_start_subfile (char *, const char *, const char *);
1039 static struct symbol
*new_symbol (struct die_info
*, struct type
*,
1040 struct dwarf2_cu
*);
1042 static struct symbol
*new_symbol_full (struct die_info
*, struct type
*,
1043 struct dwarf2_cu
*, struct symbol
*);
1045 static void dwarf2_const_value (struct attribute
*, struct symbol
*,
1046 struct dwarf2_cu
*);
1048 static void dwarf2_const_value_attr (struct attribute
*attr
,
1051 struct obstack
*obstack
,
1052 struct dwarf2_cu
*cu
, long *value
,
1054 struct dwarf2_locexpr_baton
**baton
);
1056 static struct type
*die_type (struct die_info
*, struct dwarf2_cu
*);
1058 static int need_gnat_info (struct dwarf2_cu
*);
1060 static struct type
*die_descriptive_type (struct die_info
*,
1061 struct dwarf2_cu
*);
1063 static void set_descriptive_type (struct type
*, struct die_info
*,
1064 struct dwarf2_cu
*);
1066 static struct type
*die_containing_type (struct die_info
*,
1067 struct dwarf2_cu
*);
1069 static struct type
*lookup_die_type (struct die_info
*, struct attribute
*,
1070 struct dwarf2_cu
*);
1072 static struct type
*read_type_die (struct die_info
*, struct dwarf2_cu
*);
1074 static struct type
*read_type_die_1 (struct die_info
*, struct dwarf2_cu
*);
1076 static char *determine_prefix (struct die_info
*die
, struct dwarf2_cu
*);
1078 static char *typename_concat (struct obstack
*obs
, const char *prefix
,
1079 const char *suffix
, int physname
,
1080 struct dwarf2_cu
*cu
);
1082 static void read_file_scope (struct die_info
*, struct dwarf2_cu
*);
1084 static void read_type_unit_scope (struct die_info
*, struct dwarf2_cu
*);
1086 static void read_func_scope (struct die_info
*, struct dwarf2_cu
*);
1088 static void read_lexical_block_scope (struct die_info
*, struct dwarf2_cu
*);
1090 static void read_call_site_scope (struct die_info
*die
, struct dwarf2_cu
*cu
);
1092 static int dwarf2_ranges_read (unsigned, CORE_ADDR
*, CORE_ADDR
*,
1093 struct dwarf2_cu
*, struct partial_symtab
*);
1095 static int dwarf2_get_pc_bounds (struct die_info
*,
1096 CORE_ADDR
*, CORE_ADDR
*, struct dwarf2_cu
*,
1097 struct partial_symtab
*);
1099 static void get_scope_pc_bounds (struct die_info
*,
1100 CORE_ADDR
*, CORE_ADDR
*,
1101 struct dwarf2_cu
*);
1103 static void dwarf2_record_block_ranges (struct die_info
*, struct block
*,
1104 CORE_ADDR
, struct dwarf2_cu
*);
1106 static void dwarf2_add_field (struct field_info
*, struct die_info
*,
1107 struct dwarf2_cu
*);
1109 static void dwarf2_attach_fields_to_type (struct field_info
*,
1110 struct type
*, struct dwarf2_cu
*);
1112 static void dwarf2_add_member_fn (struct field_info
*,
1113 struct die_info
*, struct type
*,
1114 struct dwarf2_cu
*);
1116 static void dwarf2_attach_fn_fields_to_type (struct field_info
*,
1118 struct dwarf2_cu
*);
1120 static void process_structure_scope (struct die_info
*, struct dwarf2_cu
*);
1122 static void read_common_block (struct die_info
*, struct dwarf2_cu
*);
1124 static void read_namespace (struct die_info
*die
, struct dwarf2_cu
*);
1126 static void read_module (struct die_info
*die
, struct dwarf2_cu
*cu
);
1128 static void read_import_statement (struct die_info
*die
, struct dwarf2_cu
*);
1130 static struct type
*read_module_type (struct die_info
*die
,
1131 struct dwarf2_cu
*cu
);
1133 static const char *namespace_name (struct die_info
*die
,
1134 int *is_anonymous
, struct dwarf2_cu
*);
1136 static void process_enumeration_scope (struct die_info
*, struct dwarf2_cu
*);
1138 static CORE_ADDR
decode_locdesc (struct dwarf_block
*, struct dwarf2_cu
*);
1140 static enum dwarf_array_dim_ordering
read_array_order (struct die_info
*,
1141 struct dwarf2_cu
*);
1143 static struct die_info
*read_comp_unit (gdb_byte
*, struct dwarf2_cu
*);
1145 static struct die_info
*read_die_and_children_1 (const struct die_reader_specs
*reader
,
1147 gdb_byte
**new_info_ptr
,
1148 struct die_info
*parent
);
1150 static struct die_info
*read_die_and_children (const struct die_reader_specs
*reader
,
1152 gdb_byte
**new_info_ptr
,
1153 struct die_info
*parent
);
1155 static struct die_info
*read_die_and_siblings (const struct die_reader_specs
*reader
,
1157 gdb_byte
**new_info_ptr
,
1158 struct die_info
*parent
);
1160 static gdb_byte
*read_full_die (const struct die_reader_specs
*reader
,
1161 struct die_info
**, gdb_byte
*,
1164 static void process_die (struct die_info
*, struct dwarf2_cu
*);
1166 static char *dwarf2_canonicalize_name (char *, struct dwarf2_cu
*,
1169 static char *dwarf2_name (struct die_info
*die
, struct dwarf2_cu
*);
1171 static const char *dwarf2_full_name (char *name
,
1172 struct die_info
*die
,
1173 struct dwarf2_cu
*cu
);
1175 static struct die_info
*dwarf2_extension (struct die_info
*die
,
1176 struct dwarf2_cu
**);
1178 static char *dwarf_tag_name (unsigned int);
1180 static char *dwarf_attr_name (unsigned int);
1182 static char *dwarf_form_name (unsigned int);
1184 static char *dwarf_bool_name (unsigned int);
1186 static char *dwarf_type_encoding_name (unsigned int);
1189 static char *dwarf_cfi_name (unsigned int);
1192 static struct die_info
*sibling_die (struct die_info
*);
1194 static void dump_die_shallow (struct ui_file
*, int indent
, struct die_info
*);
1196 static void dump_die_for_error (struct die_info
*);
1198 static void dump_die_1 (struct ui_file
*, int level
, int max_level
,
1201 /*static*/ void dump_die (struct die_info
*, int max_level
);
1203 static void store_in_ref_table (struct die_info
*,
1204 struct dwarf2_cu
*);
1206 static int is_ref_attr (struct attribute
*);
1208 static unsigned int dwarf2_get_ref_die_offset (struct attribute
*);
1210 static LONGEST
dwarf2_get_attr_constant_value (struct attribute
*, int);
1212 static struct die_info
*follow_die_ref_or_sig (struct die_info
*,
1214 struct dwarf2_cu
**);
1216 static struct die_info
*follow_die_ref (struct die_info
*,
1218 struct dwarf2_cu
**);
1220 static struct die_info
*follow_die_sig (struct die_info
*,
1222 struct dwarf2_cu
**);
1224 static struct signatured_type
*lookup_signatured_type_at_offset
1225 (struct objfile
*objfile
,
1226 struct dwarf2_section_info
*section
,
1227 unsigned int offset
);
1229 static void read_signatured_type_at_offset (struct objfile
*objfile
,
1230 struct dwarf2_section_info
*sect
,
1231 unsigned int offset
);
1233 static void read_signatured_type (struct objfile
*,
1234 struct signatured_type
*type_sig
);
1236 /* memory allocation interface */
1238 static struct dwarf_block
*dwarf_alloc_block (struct dwarf2_cu
*);
1240 static struct abbrev_info
*dwarf_alloc_abbrev (struct dwarf2_cu
*);
1242 static struct die_info
*dwarf_alloc_die (struct dwarf2_cu
*, int);
1244 static void initialize_cu_func_list (struct dwarf2_cu
*);
1246 static void add_to_cu_func_list (const char *, CORE_ADDR
, CORE_ADDR
,
1247 struct dwarf2_cu
*);
1249 static void dwarf_decode_macros (struct line_header
*, unsigned int,
1250 char *, bfd
*, struct dwarf2_cu
*,
1251 struct dwarf2_section_info
*,
1254 static int attr_form_is_block (struct attribute
*);
1256 static int attr_form_is_section_offset (struct attribute
*);
1258 static int attr_form_is_constant (struct attribute
*);
1260 static void fill_in_loclist_baton (struct dwarf2_cu
*cu
,
1261 struct dwarf2_loclist_baton
*baton
,
1262 struct attribute
*attr
);
1264 static void dwarf2_symbol_mark_computed (struct attribute
*attr
,
1266 struct dwarf2_cu
*cu
);
1268 static gdb_byte
*skip_one_die (gdb_byte
*buffer
, gdb_byte
*info_ptr
,
1269 struct abbrev_info
*abbrev
,
1270 struct dwarf2_cu
*cu
);
1272 static void free_stack_comp_unit (void *);
1274 static hashval_t
partial_die_hash (const void *item
);
1276 static int partial_die_eq (const void *item_lhs
, const void *item_rhs
);
1278 static struct dwarf2_per_cu_data
*dwarf2_find_containing_comp_unit
1279 (unsigned int offset
, struct objfile
*objfile
);
1281 static struct dwarf2_per_cu_data
*dwarf2_find_comp_unit
1282 (unsigned int offset
, struct objfile
*objfile
);
1284 static void init_one_comp_unit (struct dwarf2_cu
*cu
,
1285 struct objfile
*objfile
);
1287 static void prepare_one_comp_unit (struct dwarf2_cu
*cu
,
1288 struct die_info
*comp_unit_die
);
1290 static void free_one_comp_unit (void *);
1292 static void free_cached_comp_units (void *);
1294 static void age_cached_comp_units (void);
1296 static void free_one_cached_comp_unit (void *);
1298 static struct type
*set_die_type (struct die_info
*, struct type
*,
1299 struct dwarf2_cu
*);
1301 static void create_all_comp_units (struct objfile
*);
1303 static int create_debug_types_hash_table (struct objfile
*objfile
);
1305 static void load_full_comp_unit (struct dwarf2_per_cu_data
*,
1308 static void process_full_comp_unit (struct dwarf2_per_cu_data
*);
1310 static void dwarf2_add_dependence (struct dwarf2_cu
*,
1311 struct dwarf2_per_cu_data
*);
1313 static void dwarf2_mark (struct dwarf2_cu
*);
1315 static void dwarf2_clear_marks (struct dwarf2_per_cu_data
*);
1317 static struct type
*get_die_type_at_offset (unsigned int,
1318 struct dwarf2_per_cu_data
*per_cu
);
1320 static struct type
*get_die_type (struct die_info
*die
, struct dwarf2_cu
*cu
);
1322 static void dwarf2_release_queue (void *dummy
);
1324 static void queue_comp_unit (struct dwarf2_per_cu_data
*per_cu
,
1325 struct objfile
*objfile
);
1327 static void process_queue (struct objfile
*objfile
);
1329 static void find_file_and_directory (struct die_info
*die
,
1330 struct dwarf2_cu
*cu
,
1331 char **name
, char **comp_dir
);
1333 static char *file_full_name (int file
, struct line_header
*lh
,
1334 const char *comp_dir
);
1336 static gdb_byte
*partial_read_comp_unit_head (struct comp_unit_head
*header
,
1339 unsigned int buffer_size
,
1341 int is_debug_type_section
);
1343 static void init_cu_die_reader (struct die_reader_specs
*reader
,
1344 struct dwarf2_cu
*cu
);
1346 static htab_t
allocate_signatured_type_table (struct objfile
*objfile
);
1350 /* Convert VALUE between big- and little-endian. */
1352 byte_swap (offset_type value
)
1356 result
= (value
& 0xff) << 24;
1357 result
|= (value
& 0xff00) << 8;
1358 result
|= (value
& 0xff0000) >> 8;
1359 result
|= (value
& 0xff000000) >> 24;
1363 #define MAYBE_SWAP(V) byte_swap (V)
1366 #define MAYBE_SWAP(V) (V)
1367 #endif /* WORDS_BIGENDIAN */
1369 /* The suffix for an index file. */
1370 #define INDEX_SUFFIX ".gdb-index"
1372 static const char *dwarf2_physname (char *name
, struct die_info
*die
,
1373 struct dwarf2_cu
*cu
);
1375 /* Try to locate the sections we need for DWARF 2 debugging
1376 information and return true if we have enough to do something.
1377 NAMES points to the dwarf2 section names, or is NULL if the standard
1378 ELF names are used. */
1381 dwarf2_has_info (struct objfile
*objfile
,
1382 const struct dwarf2_debug_sections
*names
)
1384 dwarf2_per_objfile
= objfile_data (objfile
, dwarf2_objfile_data_key
);
1385 if (!dwarf2_per_objfile
)
1387 /* Initialize per-objfile state. */
1388 struct dwarf2_per_objfile
*data
1389 = obstack_alloc (&objfile
->objfile_obstack
, sizeof (*data
));
1391 memset (data
, 0, sizeof (*data
));
1392 set_objfile_data (objfile
, dwarf2_objfile_data_key
, data
);
1393 dwarf2_per_objfile
= data
;
1395 bfd_map_over_sections (objfile
->obfd
, dwarf2_locate_sections
,
1397 dwarf2_per_objfile
->objfile
= objfile
;
1399 return (dwarf2_per_objfile
->info
.asection
!= NULL
1400 && dwarf2_per_objfile
->abbrev
.asection
!= NULL
);
1403 /* When loading sections, we look either for uncompressed section or for
1404 compressed section names. */
1407 section_is_p (const char *section_name
,
1408 const struct dwarf2_section_names
*names
)
1410 if (names
->normal
!= NULL
1411 && strcmp (section_name
, names
->normal
) == 0)
1413 if (names
->compressed
!= NULL
1414 && strcmp (section_name
, names
->compressed
) == 0)
1419 /* This function is mapped across the sections and remembers the
1420 offset and size of each of the debugging sections we are interested
1424 dwarf2_locate_sections (bfd
*abfd
, asection
*sectp
, void *vnames
)
1426 const struct dwarf2_debug_sections
*names
;
1429 names
= &dwarf2_elf_names
;
1431 names
= (const struct dwarf2_debug_sections
*) vnames
;
1433 if (section_is_p (sectp
->name
, &names
->info
))
1435 dwarf2_per_objfile
->info
.asection
= sectp
;
1436 dwarf2_per_objfile
->info
.size
= bfd_get_section_size (sectp
);
1438 else if (section_is_p (sectp
->name
, &names
->abbrev
))
1440 dwarf2_per_objfile
->abbrev
.asection
= sectp
;
1441 dwarf2_per_objfile
->abbrev
.size
= bfd_get_section_size (sectp
);
1443 else if (section_is_p (sectp
->name
, &names
->line
))
1445 dwarf2_per_objfile
->line
.asection
= sectp
;
1446 dwarf2_per_objfile
->line
.size
= bfd_get_section_size (sectp
);
1448 else if (section_is_p (sectp
->name
, &names
->loc
))
1450 dwarf2_per_objfile
->loc
.asection
= sectp
;
1451 dwarf2_per_objfile
->loc
.size
= bfd_get_section_size (sectp
);
1453 else if (section_is_p (sectp
->name
, &names
->macinfo
))
1455 dwarf2_per_objfile
->macinfo
.asection
= sectp
;
1456 dwarf2_per_objfile
->macinfo
.size
= bfd_get_section_size (sectp
);
1458 else if (section_is_p (sectp
->name
, &names
->macro
))
1460 dwarf2_per_objfile
->macro
.asection
= sectp
;
1461 dwarf2_per_objfile
->macro
.size
= bfd_get_section_size (sectp
);
1463 else if (section_is_p (sectp
->name
, &names
->str
))
1465 dwarf2_per_objfile
->str
.asection
= sectp
;
1466 dwarf2_per_objfile
->str
.size
= bfd_get_section_size (sectp
);
1468 else if (section_is_p (sectp
->name
, &names
->frame
))
1470 dwarf2_per_objfile
->frame
.asection
= sectp
;
1471 dwarf2_per_objfile
->frame
.size
= bfd_get_section_size (sectp
);
1473 else if (section_is_p (sectp
->name
, &names
->eh_frame
))
1475 flagword aflag
= bfd_get_section_flags (ignore_abfd
, sectp
);
1477 if (aflag
& SEC_HAS_CONTENTS
)
1479 dwarf2_per_objfile
->eh_frame
.asection
= sectp
;
1480 dwarf2_per_objfile
->eh_frame
.size
= bfd_get_section_size (sectp
);
1483 else if (section_is_p (sectp
->name
, &names
->ranges
))
1485 dwarf2_per_objfile
->ranges
.asection
= sectp
;
1486 dwarf2_per_objfile
->ranges
.size
= bfd_get_section_size (sectp
);
1488 else if (section_is_p (sectp
->name
, &names
->types
))
1490 struct dwarf2_section_info type_section
;
1492 memset (&type_section
, 0, sizeof (type_section
));
1493 type_section
.asection
= sectp
;
1494 type_section
.size
= bfd_get_section_size (sectp
);
1496 VEC_safe_push (dwarf2_section_info_def
, dwarf2_per_objfile
->types
,
1499 else if (section_is_p (sectp
->name
, &names
->gdb_index
))
1501 dwarf2_per_objfile
->gdb_index
.asection
= sectp
;
1502 dwarf2_per_objfile
->gdb_index
.size
= bfd_get_section_size (sectp
);
1505 if ((bfd_get_section_flags (abfd
, sectp
) & SEC_LOAD
)
1506 && bfd_section_vma (abfd
, sectp
) == 0)
1507 dwarf2_per_objfile
->has_section_at_zero
= 1;
1510 /* Decompress a section that was compressed using zlib. Store the
1511 decompressed buffer, and its size, in OUTBUF and OUTSIZE. */
1514 zlib_decompress_section (struct objfile
*objfile
, asection
*sectp
,
1515 gdb_byte
**outbuf
, bfd_size_type
*outsize
)
1517 bfd
*abfd
= objfile
->obfd
;
1519 error (_("Support for zlib-compressed DWARF data (from '%s') "
1520 "is disabled in this copy of GDB"),
1521 bfd_get_filename (abfd
));
1523 bfd_size_type compressed_size
= bfd_get_section_size (sectp
);
1524 gdb_byte
*compressed_buffer
= xmalloc (compressed_size
);
1525 struct cleanup
*cleanup
= make_cleanup (xfree
, compressed_buffer
);
1526 bfd_size_type uncompressed_size
;
1527 gdb_byte
*uncompressed_buffer
;
1530 int header_size
= 12;
1532 if (bfd_seek (abfd
, sectp
->filepos
, SEEK_SET
) != 0
1533 || bfd_bread (compressed_buffer
,
1534 compressed_size
, abfd
) != compressed_size
)
1535 error (_("Dwarf Error: Can't read DWARF data from '%s'"),
1536 bfd_get_filename (abfd
));
1538 /* Read the zlib header. In this case, it should be "ZLIB" followed
1539 by the uncompressed section size, 8 bytes in big-endian order. */
1540 if (compressed_size
< header_size
1541 || strncmp (compressed_buffer
, "ZLIB", 4) != 0)
1542 error (_("Dwarf Error: Corrupt DWARF ZLIB header from '%s'"),
1543 bfd_get_filename (abfd
));
1544 uncompressed_size
= compressed_buffer
[4]; uncompressed_size
<<= 8;
1545 uncompressed_size
+= compressed_buffer
[5]; uncompressed_size
<<= 8;
1546 uncompressed_size
+= compressed_buffer
[6]; uncompressed_size
<<= 8;
1547 uncompressed_size
+= compressed_buffer
[7]; uncompressed_size
<<= 8;
1548 uncompressed_size
+= compressed_buffer
[8]; uncompressed_size
<<= 8;
1549 uncompressed_size
+= compressed_buffer
[9]; uncompressed_size
<<= 8;
1550 uncompressed_size
+= compressed_buffer
[10]; uncompressed_size
<<= 8;
1551 uncompressed_size
+= compressed_buffer
[11];
1553 /* It is possible the section consists of several compressed
1554 buffers concatenated together, so we uncompress in a loop. */
1558 strm
.avail_in
= compressed_size
- header_size
;
1559 strm
.next_in
= (Bytef
*) compressed_buffer
+ header_size
;
1560 strm
.avail_out
= uncompressed_size
;
1561 uncompressed_buffer
= obstack_alloc (&objfile
->objfile_obstack
,
1563 rc
= inflateInit (&strm
);
1564 while (strm
.avail_in
> 0)
1567 error (_("Dwarf Error: setting up DWARF uncompression in '%s': %d"),
1568 bfd_get_filename (abfd
), rc
);
1569 strm
.next_out
= ((Bytef
*) uncompressed_buffer
1570 + (uncompressed_size
- strm
.avail_out
));
1571 rc
= inflate (&strm
, Z_FINISH
);
1572 if (rc
!= Z_STREAM_END
)
1573 error (_("Dwarf Error: zlib error uncompressing from '%s': %d"),
1574 bfd_get_filename (abfd
), rc
);
1575 rc
= inflateReset (&strm
);
1577 rc
= inflateEnd (&strm
);
1579 || strm
.avail_out
!= 0)
1580 error (_("Dwarf Error: concluding DWARF uncompression in '%s': %d"),
1581 bfd_get_filename (abfd
), rc
);
1583 do_cleanups (cleanup
);
1584 *outbuf
= uncompressed_buffer
;
1585 *outsize
= uncompressed_size
;
1589 /* A helper function that decides whether a section is empty. */
1592 dwarf2_section_empty_p (struct dwarf2_section_info
*info
)
1594 return info
->asection
== NULL
|| info
->size
== 0;
1597 /* Read the contents of the section SECTP from object file specified by
1598 OBJFILE, store info about the section into INFO.
1599 If the section is compressed, uncompress it before returning. */
1602 dwarf2_read_section (struct objfile
*objfile
, struct dwarf2_section_info
*info
)
1604 bfd
*abfd
= objfile
->obfd
;
1605 asection
*sectp
= info
->asection
;
1606 gdb_byte
*buf
, *retbuf
;
1607 unsigned char header
[4];
1611 info
->buffer
= NULL
;
1612 info
->map_addr
= NULL
;
1615 if (dwarf2_section_empty_p (info
))
1618 /* Check if the file has a 4-byte header indicating compression. */
1619 if (info
->size
> sizeof (header
)
1620 && bfd_seek (abfd
, sectp
->filepos
, SEEK_SET
) == 0
1621 && bfd_bread (header
, sizeof (header
), abfd
) == sizeof (header
))
1623 /* Upon decompression, update the buffer and its size. */
1624 if (strncmp (header
, "ZLIB", sizeof (header
)) == 0)
1626 zlib_decompress_section (objfile
, sectp
, &info
->buffer
,
1634 pagesize
= getpagesize ();
1636 /* Only try to mmap sections which are large enough: we don't want to
1637 waste space due to fragmentation. Also, only try mmap for sections
1638 without relocations. */
1640 if (info
->size
> 4 * pagesize
&& (sectp
->flags
& SEC_RELOC
) == 0)
1642 info
->buffer
= bfd_mmap (abfd
, 0, info
->size
, PROT_READ
,
1643 MAP_PRIVATE
, sectp
->filepos
,
1644 &info
->map_addr
, &info
->map_len
);
1646 if ((caddr_t
)info
->buffer
!= MAP_FAILED
)
1648 #if HAVE_POSIX_MADVISE
1649 posix_madvise (info
->map_addr
, info
->map_len
, POSIX_MADV_WILLNEED
);
1656 /* If we get here, we are a normal, not-compressed section. */
1658 = obstack_alloc (&objfile
->objfile_obstack
, info
->size
);
1660 /* When debugging .o files, we may need to apply relocations; see
1661 http://sourceware.org/ml/gdb-patches/2002-04/msg00136.html .
1662 We never compress sections in .o files, so we only need to
1663 try this when the section is not compressed. */
1664 retbuf
= symfile_relocate_debug_section (objfile
, sectp
, buf
);
1667 info
->buffer
= retbuf
;
1671 if (bfd_seek (abfd
, sectp
->filepos
, SEEK_SET
) != 0
1672 || bfd_bread (buf
, info
->size
, abfd
) != info
->size
)
1673 error (_("Dwarf Error: Can't read DWARF data from '%s'"),
1674 bfd_get_filename (abfd
));
1677 /* A helper function that returns the size of a section in a safe way.
1678 If you are positive that the section has been read before using the
1679 size, then it is safe to refer to the dwarf2_section_info object's
1680 "size" field directly. In other cases, you must call this
1681 function, because for compressed sections the size field is not set
1682 correctly until the section has been read. */
1684 static bfd_size_type
1685 dwarf2_section_size (struct objfile
*objfile
,
1686 struct dwarf2_section_info
*info
)
1689 dwarf2_read_section (objfile
, info
);
1693 /* Fill in SECTP, BUFP and SIZEP with section info, given OBJFILE and
1697 dwarf2_get_section_info (struct objfile
*objfile
,
1698 enum dwarf2_section_enum sect
,
1699 asection
**sectp
, gdb_byte
**bufp
,
1700 bfd_size_type
*sizep
)
1702 struct dwarf2_per_objfile
*data
1703 = objfile_data (objfile
, dwarf2_objfile_data_key
);
1704 struct dwarf2_section_info
*info
;
1706 /* We may see an objfile without any DWARF, in which case we just
1717 case DWARF2_DEBUG_FRAME
:
1718 info
= &data
->frame
;
1720 case DWARF2_EH_FRAME
:
1721 info
= &data
->eh_frame
;
1724 gdb_assert_not_reached ("unexpected section");
1727 dwarf2_read_section (objfile
, info
);
1729 *sectp
= info
->asection
;
1730 *bufp
= info
->buffer
;
1731 *sizep
= info
->size
;
1735 /* DWARF quick_symbols_functions support. */
1737 /* TUs can share .debug_line entries, and there can be a lot more TUs than
1738 unique line tables, so we maintain a separate table of all .debug_line
1739 derived entries to support the sharing.
1740 All the quick functions need is the list of file names. We discard the
1741 line_header when we're done and don't need to record it here. */
1742 struct quick_file_names
1744 /* The offset in .debug_line of the line table. We hash on this. */
1745 unsigned int offset
;
1747 /* The number of entries in file_names, real_names. */
1748 unsigned int num_file_names
;
1750 /* The file names from the line table, after being run through
1752 const char **file_names
;
1754 /* The file names from the line table after being run through
1755 gdb_realpath. These are computed lazily. */
1756 const char **real_names
;
1759 /* When using the index (and thus not using psymtabs), each CU has an
1760 object of this type. This is used to hold information needed by
1761 the various "quick" methods. */
1762 struct dwarf2_per_cu_quick_data
1764 /* The file table. This can be NULL if there was no file table
1765 or it's currently not read in.
1766 NOTE: This points into dwarf2_per_objfile->quick_file_names_table. */
1767 struct quick_file_names
*file_names
;
1769 /* The corresponding symbol table. This is NULL if symbols for this
1770 CU have not yet been read. */
1771 struct symtab
*symtab
;
1773 /* A temporary mark bit used when iterating over all CUs in
1774 expand_symtabs_matching. */
1775 unsigned int mark
: 1;
1777 /* True if we've tried to read the file table and found there isn't one.
1778 There will be no point in trying to read it again next time. */
1779 unsigned int no_file_data
: 1;
1782 /* Hash function for a quick_file_names. */
1785 hash_file_name_entry (const void *e
)
1787 const struct quick_file_names
*file_data
= e
;
1789 return file_data
->offset
;
1792 /* Equality function for a quick_file_names. */
1795 eq_file_name_entry (const void *a
, const void *b
)
1797 const struct quick_file_names
*ea
= a
;
1798 const struct quick_file_names
*eb
= b
;
1800 return ea
->offset
== eb
->offset
;
1803 /* Delete function for a quick_file_names. */
1806 delete_file_name_entry (void *e
)
1808 struct quick_file_names
*file_data
= e
;
1811 for (i
= 0; i
< file_data
->num_file_names
; ++i
)
1813 xfree ((void*) file_data
->file_names
[i
]);
1814 if (file_data
->real_names
)
1815 xfree ((void*) file_data
->real_names
[i
]);
1818 /* The space for the struct itself lives on objfile_obstack,
1819 so we don't free it here. */
1822 /* Create a quick_file_names hash table. */
1825 create_quick_file_names_table (unsigned int nr_initial_entries
)
1827 return htab_create_alloc (nr_initial_entries
,
1828 hash_file_name_entry
, eq_file_name_entry
,
1829 delete_file_name_entry
, xcalloc
, xfree
);
1832 /* Read in PER_CU->CU. This function is unrelated to symtabs, symtab would
1833 have to be created afterwards. You should call age_cached_comp_units after
1834 processing PER_CU->CU. dw2_setup must have been already called. */
1837 load_cu (struct dwarf2_per_cu_data
*per_cu
)
1839 if (per_cu
->debug_type_section
)
1840 read_signatured_type_at_offset (per_cu
->objfile
,
1841 per_cu
->debug_type_section
,
1844 load_full_comp_unit (per_cu
, per_cu
->objfile
);
1846 dwarf2_find_base_address (per_cu
->cu
->dies
, per_cu
->cu
);
1848 gdb_assert (per_cu
->cu
!= NULL
);
1851 /* Read in the symbols for PER_CU. OBJFILE is the objfile from which
1855 dw2_do_instantiate_symtab (struct objfile
*objfile
,
1856 struct dwarf2_per_cu_data
*per_cu
)
1858 struct cleanup
*back_to
;
1860 back_to
= make_cleanup (dwarf2_release_queue
, NULL
);
1862 queue_comp_unit (per_cu
, objfile
);
1866 process_queue (objfile
);
1868 /* Age the cache, releasing compilation units that have not
1869 been used recently. */
1870 age_cached_comp_units ();
1872 do_cleanups (back_to
);
1875 /* Ensure that the symbols for PER_CU have been read in. OBJFILE is
1876 the objfile from which this CU came. Returns the resulting symbol
1879 static struct symtab
*
1880 dw2_instantiate_symtab (struct objfile
*objfile
,
1881 struct dwarf2_per_cu_data
*per_cu
)
1883 if (!per_cu
->v
.quick
->symtab
)
1885 struct cleanup
*back_to
= make_cleanup (free_cached_comp_units
, NULL
);
1886 increment_reading_symtab ();
1887 dw2_do_instantiate_symtab (objfile
, per_cu
);
1888 do_cleanups (back_to
);
1890 return per_cu
->v
.quick
->symtab
;
1893 /* Return the CU given its index. */
1895 static struct dwarf2_per_cu_data
*
1896 dw2_get_cu (int index
)
1898 if (index
>= dwarf2_per_objfile
->n_comp_units
)
1900 index
-= dwarf2_per_objfile
->n_comp_units
;
1901 return dwarf2_per_objfile
->type_comp_units
[index
];
1903 return dwarf2_per_objfile
->all_comp_units
[index
];
1906 /* A helper function that knows how to read a 64-bit value in a way
1907 that doesn't make gdb die. Returns 1 if the conversion went ok, 0
1911 extract_cu_value (const char *bytes
, ULONGEST
*result
)
1913 if (sizeof (ULONGEST
) < 8)
1917 /* Ignore the upper 4 bytes if they are all zero. */
1918 for (i
= 0; i
< 4; ++i
)
1919 if (bytes
[i
+ 4] != 0)
1922 *result
= extract_unsigned_integer (bytes
, 4, BFD_ENDIAN_LITTLE
);
1925 *result
= extract_unsigned_integer (bytes
, 8, BFD_ENDIAN_LITTLE
);
1929 /* Read the CU list from the mapped index, and use it to create all
1930 the CU objects for this objfile. Return 0 if something went wrong,
1931 1 if everything went ok. */
1934 create_cus_from_index (struct objfile
*objfile
, const gdb_byte
*cu_list
,
1935 offset_type cu_list_elements
)
1939 dwarf2_per_objfile
->n_comp_units
= cu_list_elements
/ 2;
1940 dwarf2_per_objfile
->all_comp_units
1941 = obstack_alloc (&objfile
->objfile_obstack
,
1942 dwarf2_per_objfile
->n_comp_units
1943 * sizeof (struct dwarf2_per_cu_data
*));
1945 for (i
= 0; i
< cu_list_elements
; i
+= 2)
1947 struct dwarf2_per_cu_data
*the_cu
;
1948 ULONGEST offset
, length
;
1950 if (!extract_cu_value (cu_list
, &offset
)
1951 || !extract_cu_value (cu_list
+ 8, &length
))
1955 the_cu
= OBSTACK_ZALLOC (&objfile
->objfile_obstack
,
1956 struct dwarf2_per_cu_data
);
1957 the_cu
->offset
= offset
;
1958 the_cu
->length
= length
;
1959 the_cu
->objfile
= objfile
;
1960 the_cu
->v
.quick
= OBSTACK_ZALLOC (&objfile
->objfile_obstack
,
1961 struct dwarf2_per_cu_quick_data
);
1962 dwarf2_per_objfile
->all_comp_units
[i
/ 2] = the_cu
;
1968 /* Create the signatured type hash table from the index. */
1971 create_signatured_type_table_from_index (struct objfile
*objfile
,
1972 struct dwarf2_section_info
*section
,
1973 const gdb_byte
*bytes
,
1974 offset_type elements
)
1977 htab_t sig_types_hash
;
1979 dwarf2_per_objfile
->n_type_comp_units
= elements
/ 3;
1980 dwarf2_per_objfile
->type_comp_units
1981 = obstack_alloc (&objfile
->objfile_obstack
,
1982 dwarf2_per_objfile
->n_type_comp_units
1983 * sizeof (struct dwarf2_per_cu_data
*));
1985 sig_types_hash
= allocate_signatured_type_table (objfile
);
1987 for (i
= 0; i
< elements
; i
+= 3)
1989 struct signatured_type
*type_sig
;
1990 ULONGEST offset
, type_offset
, signature
;
1993 if (!extract_cu_value (bytes
, &offset
)
1994 || !extract_cu_value (bytes
+ 8, &type_offset
))
1996 signature
= extract_unsigned_integer (bytes
+ 16, 8, BFD_ENDIAN_LITTLE
);
1999 type_sig
= OBSTACK_ZALLOC (&objfile
->objfile_obstack
,
2000 struct signatured_type
);
2001 type_sig
->signature
= signature
;
2002 type_sig
->type_offset
= type_offset
;
2003 type_sig
->per_cu
.debug_type_section
= section
;
2004 type_sig
->per_cu
.offset
= offset
;
2005 type_sig
->per_cu
.objfile
= objfile
;
2006 type_sig
->per_cu
.v
.quick
2007 = OBSTACK_ZALLOC (&objfile
->objfile_obstack
,
2008 struct dwarf2_per_cu_quick_data
);
2010 slot
= htab_find_slot (sig_types_hash
, type_sig
, INSERT
);
2013 dwarf2_per_objfile
->type_comp_units
[i
/ 3] = &type_sig
->per_cu
;
2016 dwarf2_per_objfile
->signatured_types
= sig_types_hash
;
2021 /* Read the address map data from the mapped index, and use it to
2022 populate the objfile's psymtabs_addrmap. */
2025 create_addrmap_from_index (struct objfile
*objfile
, struct mapped_index
*index
)
2027 const gdb_byte
*iter
, *end
;
2028 struct obstack temp_obstack
;
2029 struct addrmap
*mutable_map
;
2030 struct cleanup
*cleanup
;
2033 obstack_init (&temp_obstack
);
2034 cleanup
= make_cleanup_obstack_free (&temp_obstack
);
2035 mutable_map
= addrmap_create_mutable (&temp_obstack
);
2037 iter
= index
->address_table
;
2038 end
= iter
+ index
->address_table_size
;
2040 baseaddr
= ANOFFSET (objfile
->section_offsets
, SECT_OFF_TEXT (objfile
));
2044 ULONGEST hi
, lo
, cu_index
;
2045 lo
= extract_unsigned_integer (iter
, 8, BFD_ENDIAN_LITTLE
);
2047 hi
= extract_unsigned_integer (iter
, 8, BFD_ENDIAN_LITTLE
);
2049 cu_index
= extract_unsigned_integer (iter
, 4, BFD_ENDIAN_LITTLE
);
2052 addrmap_set_empty (mutable_map
, lo
+ baseaddr
, hi
+ baseaddr
- 1,
2053 dw2_get_cu (cu_index
));
2056 objfile
->psymtabs_addrmap
= addrmap_create_fixed (mutable_map
,
2057 &objfile
->objfile_obstack
);
2058 do_cleanups (cleanup
);
2061 /* The hash function for strings in the mapped index. This is the same as
2062 SYMBOL_HASH_NEXT, but we keep a separate copy to maintain control over the
2063 implementation. This is necessary because the hash function is tied to the
2064 format of the mapped index file. The hash values do not have to match with
2067 Use INT_MAX for INDEX_VERSION if you generate the current index format. */
2070 mapped_index_string_hash (int index_version
, const void *p
)
2072 const unsigned char *str
= (const unsigned char *) p
;
2076 while ((c
= *str
++) != 0)
2078 if (index_version
>= 5)
2080 r
= r
* 67 + c
- 113;
2086 /* Find a slot in the mapped index INDEX for the object named NAME.
2087 If NAME is found, set *VEC_OUT to point to the CU vector in the
2088 constant pool and return 1. If NAME cannot be found, return 0. */
2091 find_slot_in_mapped_hash (struct mapped_index
*index
, const char *name
,
2092 offset_type
**vec_out
)
2094 struct cleanup
*back_to
= make_cleanup (null_cleanup
, 0);
2096 offset_type slot
, step
;
2097 int (*cmp
) (const char *, const char *);
2099 if (current_language
->la_language
== language_cplus
2100 || current_language
->la_language
== language_java
2101 || current_language
->la_language
== language_fortran
)
2103 /* NAME is already canonical. Drop any qualifiers as .gdb_index does
2105 const char *paren
= strchr (name
, '(');
2111 dup
= xmalloc (paren
- name
+ 1);
2112 memcpy (dup
, name
, paren
- name
);
2113 dup
[paren
- name
] = 0;
2115 make_cleanup (xfree
, dup
);
2120 /* Index version 4 did not support case insensitive searches. But the
2121 indexes for case insensitive languages are built in lowercase, therefore
2122 simulate our NAME being searched is also lowercased. */
2123 hash
= mapped_index_string_hash ((index
->version
== 4
2124 && case_sensitivity
== case_sensitive_off
2125 ? 5 : index
->version
),
2128 slot
= hash
& (index
->symbol_table_slots
- 1);
2129 step
= ((hash
* 17) & (index
->symbol_table_slots
- 1)) | 1;
2130 cmp
= (case_sensitivity
== case_sensitive_on
? strcmp
: strcasecmp
);
2134 /* Convert a slot number to an offset into the table. */
2135 offset_type i
= 2 * slot
;
2137 if (index
->symbol_table
[i
] == 0 && index
->symbol_table
[i
+ 1] == 0)
2139 do_cleanups (back_to
);
2143 str
= index
->constant_pool
+ MAYBE_SWAP (index
->symbol_table
[i
]);
2144 if (!cmp (name
, str
))
2146 *vec_out
= (offset_type
*) (index
->constant_pool
2147 + MAYBE_SWAP (index
->symbol_table
[i
+ 1]));
2148 do_cleanups (back_to
);
2152 slot
= (slot
+ step
) & (index
->symbol_table_slots
- 1);
2156 /* Read the index file. If everything went ok, initialize the "quick"
2157 elements of all the CUs and return 1. Otherwise, return 0. */
2160 dwarf2_read_index (struct objfile
*objfile
)
2163 struct mapped_index
*map
;
2164 offset_type
*metadata
;
2165 const gdb_byte
*cu_list
;
2166 const gdb_byte
*types_list
= NULL
;
2167 offset_type version
, cu_list_elements
;
2168 offset_type types_list_elements
= 0;
2171 if (dwarf2_section_empty_p (&dwarf2_per_objfile
->gdb_index
))
2174 /* Older elfutils strip versions could keep the section in the main
2175 executable while splitting it for the separate debug info file. */
2176 if ((bfd_get_file_flags (dwarf2_per_objfile
->gdb_index
.asection
)
2177 & SEC_HAS_CONTENTS
) == 0)
2180 dwarf2_read_section (objfile
, &dwarf2_per_objfile
->gdb_index
);
2182 addr
= dwarf2_per_objfile
->gdb_index
.buffer
;
2183 /* Version check. */
2184 version
= MAYBE_SWAP (*(offset_type
*) addr
);
2185 /* Versions earlier than 3 emitted every copy of a psymbol. This
2186 causes the index to behave very poorly for certain requests. Version 3
2187 contained incomplete addrmap. So, it seems better to just ignore such
2188 indices. Index version 4 uses a different hash function than index
2189 version 5 and later. */
2192 /* Indexes with higher version than the one supported by GDB may be no
2193 longer backward compatible. */
2197 map
= OBSTACK_ZALLOC (&objfile
->objfile_obstack
, struct mapped_index
);
2198 map
->version
= version
;
2199 map
->total_size
= dwarf2_per_objfile
->gdb_index
.size
;
2201 metadata
= (offset_type
*) (addr
+ sizeof (offset_type
));
2204 cu_list
= addr
+ MAYBE_SWAP (metadata
[i
]);
2205 cu_list_elements
= ((MAYBE_SWAP (metadata
[i
+ 1]) - MAYBE_SWAP (metadata
[i
]))
2209 types_list
= addr
+ MAYBE_SWAP (metadata
[i
]);
2210 types_list_elements
= ((MAYBE_SWAP (metadata
[i
+ 1])
2211 - MAYBE_SWAP (metadata
[i
]))
2215 map
->address_table
= addr
+ MAYBE_SWAP (metadata
[i
]);
2216 map
->address_table_size
= (MAYBE_SWAP (metadata
[i
+ 1])
2217 - MAYBE_SWAP (metadata
[i
]));
2220 map
->symbol_table
= (offset_type
*) (addr
+ MAYBE_SWAP (metadata
[i
]));
2221 map
->symbol_table_slots
= ((MAYBE_SWAP (metadata
[i
+ 1])
2222 - MAYBE_SWAP (metadata
[i
]))
2223 / (2 * sizeof (offset_type
)));
2226 map
->constant_pool
= addr
+ MAYBE_SWAP (metadata
[i
]);
2228 if (!create_cus_from_index (objfile
, cu_list
, cu_list_elements
))
2231 if (types_list_elements
)
2233 struct dwarf2_section_info
*section
;
2235 /* We can only handle a single .debug_types when we have an
2237 if (VEC_length (dwarf2_section_info_def
, dwarf2_per_objfile
->types
) != 1)
2240 section
= VEC_index (dwarf2_section_info_def
,
2241 dwarf2_per_objfile
->types
, 0);
2243 if (!create_signatured_type_table_from_index (objfile
, section
,
2245 types_list_elements
))
2249 create_addrmap_from_index (objfile
, map
);
2251 dwarf2_per_objfile
->index_table
= map
;
2252 dwarf2_per_objfile
->using_index
= 1;
2253 dwarf2_per_objfile
->quick_file_names_table
=
2254 create_quick_file_names_table (dwarf2_per_objfile
->n_comp_units
);
2259 /* A helper for the "quick" functions which sets the global
2260 dwarf2_per_objfile according to OBJFILE. */
2263 dw2_setup (struct objfile
*objfile
)
2265 dwarf2_per_objfile
= objfile_data (objfile
, dwarf2_objfile_data_key
);
2266 gdb_assert (dwarf2_per_objfile
);
2269 /* A helper for the "quick" functions which attempts to read the line
2270 table for THIS_CU. */
2272 static struct quick_file_names
*
2273 dw2_get_file_names (struct objfile
*objfile
,
2274 struct dwarf2_per_cu_data
*this_cu
)
2276 bfd
*abfd
= objfile
->obfd
;
2277 struct line_header
*lh
;
2278 struct attribute
*attr
;
2279 struct cleanup
*cleanups
;
2280 struct die_info
*comp_unit_die
;
2281 struct dwarf2_section_info
* sec
;
2282 gdb_byte
*info_ptr
, *buffer
;
2283 int has_children
, i
;
2284 struct dwarf2_cu cu
;
2285 unsigned int bytes_read
, buffer_size
;
2286 struct die_reader_specs reader_specs
;
2287 char *name
, *comp_dir
;
2289 struct quick_file_names
*qfn
;
2290 unsigned int line_offset
;
2292 if (this_cu
->v
.quick
->file_names
!= NULL
)
2293 return this_cu
->v
.quick
->file_names
;
2294 /* If we know there is no line data, no point in looking again. */
2295 if (this_cu
->v
.quick
->no_file_data
)
2298 init_one_comp_unit (&cu
, objfile
);
2299 cleanups
= make_cleanup (free_stack_comp_unit
, &cu
);
2301 if (this_cu
->debug_type_section
)
2302 sec
= this_cu
->debug_type_section
;
2304 sec
= &dwarf2_per_objfile
->info
;
2305 dwarf2_read_section (objfile
, sec
);
2306 buffer_size
= sec
->size
;
2307 buffer
= sec
->buffer
;
2308 info_ptr
= buffer
+ this_cu
->offset
;
2310 info_ptr
= partial_read_comp_unit_head (&cu
.header
, info_ptr
,
2311 buffer
, buffer_size
,
2313 this_cu
->debug_type_section
!= NULL
);
2315 /* Skip dummy compilation units. */
2316 if (info_ptr
>= buffer
+ buffer_size
2317 || peek_abbrev_code (abfd
, info_ptr
) == 0)
2319 do_cleanups (cleanups
);
2324 cu
.per_cu
= this_cu
;
2326 dwarf2_read_abbrevs (abfd
, &cu
);
2327 make_cleanup (dwarf2_free_abbrev_table
, &cu
);
2329 init_cu_die_reader (&reader_specs
, &cu
);
2330 read_full_die (&reader_specs
, &comp_unit_die
, info_ptr
,
2336 attr
= dwarf2_attr (comp_unit_die
, DW_AT_stmt_list
, &cu
);
2339 struct quick_file_names find_entry
;
2341 line_offset
= DW_UNSND (attr
);
2343 /* We may have already read in this line header (TU line header sharing).
2344 If we have we're done. */
2345 find_entry
.offset
= line_offset
;
2346 slot
= htab_find_slot (dwarf2_per_objfile
->quick_file_names_table
,
2347 &find_entry
, INSERT
);
2350 do_cleanups (cleanups
);
2351 this_cu
->v
.quick
->file_names
= *slot
;
2355 lh
= dwarf_decode_line_header (line_offset
, abfd
, &cu
);
2359 do_cleanups (cleanups
);
2360 this_cu
->v
.quick
->no_file_data
= 1;
2364 qfn
= obstack_alloc (&objfile
->objfile_obstack
, sizeof (*qfn
));
2365 qfn
->offset
= line_offset
;
2366 gdb_assert (slot
!= NULL
);
2369 find_file_and_directory (comp_unit_die
, &cu
, &name
, &comp_dir
);
2371 qfn
->num_file_names
= lh
->num_file_names
;
2372 qfn
->file_names
= obstack_alloc (&objfile
->objfile_obstack
,
2373 lh
->num_file_names
* sizeof (char *));
2374 for (i
= 0; i
< lh
->num_file_names
; ++i
)
2375 qfn
->file_names
[i
] = file_full_name (i
+ 1, lh
, comp_dir
);
2376 qfn
->real_names
= NULL
;
2378 free_line_header (lh
);
2379 do_cleanups (cleanups
);
2381 this_cu
->v
.quick
->file_names
= qfn
;
2385 /* A helper for the "quick" functions which computes and caches the
2386 real path for a given file name from the line table. */
2389 dw2_get_real_path (struct objfile
*objfile
,
2390 struct quick_file_names
*qfn
, int index
)
2392 if (qfn
->real_names
== NULL
)
2393 qfn
->real_names
= OBSTACK_CALLOC (&objfile
->objfile_obstack
,
2394 qfn
->num_file_names
, sizeof (char *));
2396 if (qfn
->real_names
[index
] == NULL
)
2397 qfn
->real_names
[index
] = gdb_realpath (qfn
->file_names
[index
]);
2399 return qfn
->real_names
[index
];
2402 static struct symtab
*
2403 dw2_find_last_source_symtab (struct objfile
*objfile
)
2407 dw2_setup (objfile
);
2408 index
= dwarf2_per_objfile
->n_comp_units
- 1;
2409 return dw2_instantiate_symtab (objfile
, dw2_get_cu (index
));
2412 /* Traversal function for dw2_forget_cached_source_info. */
2415 dw2_free_cached_file_names (void **slot
, void *info
)
2417 struct quick_file_names
*file_data
= (struct quick_file_names
*) *slot
;
2419 if (file_data
->real_names
)
2423 for (i
= 0; i
< file_data
->num_file_names
; ++i
)
2425 xfree ((void*) file_data
->real_names
[i
]);
2426 file_data
->real_names
[i
] = NULL
;
2434 dw2_forget_cached_source_info (struct objfile
*objfile
)
2436 dw2_setup (objfile
);
2438 htab_traverse_noresize (dwarf2_per_objfile
->quick_file_names_table
,
2439 dw2_free_cached_file_names
, NULL
);
2442 /* Helper function for dw2_map_symtabs_matching_filename that expands
2443 the symtabs and calls the iterator. */
2446 dw2_map_expand_apply (struct objfile
*objfile
,
2447 struct dwarf2_per_cu_data
*per_cu
,
2449 const char *full_path
, const char *real_path
,
2450 int (*callback
) (struct symtab
*, void *),
2453 struct symtab
*last_made
= objfile
->symtabs
;
2455 /* Don't visit already-expanded CUs. */
2456 if (per_cu
->v
.quick
->symtab
)
2459 /* This may expand more than one symtab, and we want to iterate over
2461 dw2_instantiate_symtab (objfile
, per_cu
);
2463 return iterate_over_some_symtabs (name
, full_path
, real_path
, callback
, data
,
2464 objfile
->symtabs
, last_made
);
2467 /* Implementation of the map_symtabs_matching_filename method. */
2470 dw2_map_symtabs_matching_filename (struct objfile
*objfile
, const char *name
,
2471 const char *full_path
, const char *real_path
,
2472 int (*callback
) (struct symtab
*, void *),
2476 const char *name_basename
= lbasename (name
);
2477 int check_basename
= name_basename
== name
;
2478 struct dwarf2_per_cu_data
*base_cu
= NULL
;
2480 dw2_setup (objfile
);
2482 for (i
= 0; i
< (dwarf2_per_objfile
->n_comp_units
2483 + dwarf2_per_objfile
->n_type_comp_units
); ++i
)
2486 struct dwarf2_per_cu_data
*per_cu
= dw2_get_cu (i
);
2487 struct quick_file_names
*file_data
;
2489 /* We only need to look at symtabs not already expanded. */
2490 if (per_cu
->v
.quick
->symtab
)
2493 file_data
= dw2_get_file_names (objfile
, per_cu
);
2494 if (file_data
== NULL
)
2497 for (j
= 0; j
< file_data
->num_file_names
; ++j
)
2499 const char *this_name
= file_data
->file_names
[j
];
2501 if (FILENAME_CMP (name
, this_name
) == 0)
2503 if (dw2_map_expand_apply (objfile
, per_cu
,
2504 name
, full_path
, real_path
,
2509 if (check_basename
&& ! base_cu
2510 && FILENAME_CMP (lbasename (this_name
), name
) == 0)
2513 /* Before we invoke realpath, which can get expensive when many
2514 files are involved, do a quick comparison of the basenames. */
2515 if (! basenames_may_differ
2516 && FILENAME_CMP (lbasename (this_name
), name_basename
) != 0)
2519 if (full_path
!= NULL
)
2521 const char *this_real_name
= dw2_get_real_path (objfile
,
2524 if (this_real_name
!= NULL
2525 && FILENAME_CMP (full_path
, this_real_name
) == 0)
2527 if (dw2_map_expand_apply (objfile
, per_cu
,
2528 name
, full_path
, real_path
,
2534 if (real_path
!= NULL
)
2536 const char *this_real_name
= dw2_get_real_path (objfile
,
2539 if (this_real_name
!= NULL
2540 && FILENAME_CMP (real_path
, this_real_name
) == 0)
2542 if (dw2_map_expand_apply (objfile
, per_cu
,
2543 name
, full_path
, real_path
,
2553 if (dw2_map_expand_apply (objfile
, base_cu
,
2554 name
, full_path
, real_path
,
2562 static struct symtab
*
2563 dw2_lookup_symbol (struct objfile
*objfile
, int block_index
,
2564 const char *name
, domain_enum domain
)
2566 /* We do all the work in the pre_expand_symtabs_matching hook
2571 /* A helper function that expands all symtabs that hold an object
2575 dw2_do_expand_symtabs_matching (struct objfile
*objfile
, const char *name
)
2577 dw2_setup (objfile
);
2579 /* index_table is NULL if OBJF_READNOW. */
2580 if (dwarf2_per_objfile
->index_table
)
2584 if (find_slot_in_mapped_hash (dwarf2_per_objfile
->index_table
,
2587 offset_type i
, len
= MAYBE_SWAP (*vec
);
2588 for (i
= 0; i
< len
; ++i
)
2590 offset_type cu_index
= MAYBE_SWAP (vec
[i
+ 1]);
2591 struct dwarf2_per_cu_data
*per_cu
= dw2_get_cu (cu_index
);
2593 dw2_instantiate_symtab (objfile
, per_cu
);
2600 dw2_pre_expand_symtabs_matching (struct objfile
*objfile
,
2601 enum block_enum block_kind
, const char *name
,
2604 dw2_do_expand_symtabs_matching (objfile
, name
);
2608 dw2_print_stats (struct objfile
*objfile
)
2612 dw2_setup (objfile
);
2614 for (i
= 0; i
< (dwarf2_per_objfile
->n_comp_units
2615 + dwarf2_per_objfile
->n_type_comp_units
); ++i
)
2617 struct dwarf2_per_cu_data
*per_cu
= dw2_get_cu (i
);
2619 if (!per_cu
->v
.quick
->symtab
)
2622 printf_filtered (_(" Number of unread CUs: %d\n"), count
);
2626 dw2_dump (struct objfile
*objfile
)
2628 /* Nothing worth printing. */
2632 dw2_relocate (struct objfile
*objfile
, struct section_offsets
*new_offsets
,
2633 struct section_offsets
*delta
)
2635 /* There's nothing to relocate here. */
2639 dw2_expand_symtabs_for_function (struct objfile
*objfile
,
2640 const char *func_name
)
2642 dw2_do_expand_symtabs_matching (objfile
, func_name
);
2646 dw2_expand_all_symtabs (struct objfile
*objfile
)
2650 dw2_setup (objfile
);
2652 for (i
= 0; i
< (dwarf2_per_objfile
->n_comp_units
2653 + dwarf2_per_objfile
->n_type_comp_units
); ++i
)
2655 struct dwarf2_per_cu_data
*per_cu
= dw2_get_cu (i
);
2657 dw2_instantiate_symtab (objfile
, per_cu
);
2662 dw2_expand_symtabs_with_filename (struct objfile
*objfile
,
2663 const char *filename
)
2667 dw2_setup (objfile
);
2669 /* We don't need to consider type units here.
2670 This is only called for examining code, e.g. expand_line_sal.
2671 There can be an order of magnitude (or more) more type units
2672 than comp units, and we avoid them if we can. */
2674 for (i
= 0; i
< dwarf2_per_objfile
->n_comp_units
; ++i
)
2677 struct dwarf2_per_cu_data
*per_cu
= dw2_get_cu (i
);
2678 struct quick_file_names
*file_data
;
2680 /* We only need to look at symtabs not already expanded. */
2681 if (per_cu
->v
.quick
->symtab
)
2684 file_data
= dw2_get_file_names (objfile
, per_cu
);
2685 if (file_data
== NULL
)
2688 for (j
= 0; j
< file_data
->num_file_names
; ++j
)
2690 const char *this_name
= file_data
->file_names
[j
];
2691 if (FILENAME_CMP (this_name
, filename
) == 0)
2693 dw2_instantiate_symtab (objfile
, per_cu
);
2701 dw2_find_symbol_file (struct objfile
*objfile
, const char *name
)
2703 struct dwarf2_per_cu_data
*per_cu
;
2705 struct quick_file_names
*file_data
;
2707 dw2_setup (objfile
);
2709 /* index_table is NULL if OBJF_READNOW. */
2710 if (!dwarf2_per_objfile
->index_table
)
2714 ALL_OBJFILE_SYMTABS (objfile
, s
)
2717 struct blockvector
*bv
= BLOCKVECTOR (s
);
2718 const struct block
*block
= BLOCKVECTOR_BLOCK (bv
, GLOBAL_BLOCK
);
2719 struct symbol
*sym
= lookup_block_symbol (block
, name
, VAR_DOMAIN
);
2722 return sym
->symtab
->filename
;
2727 if (!find_slot_in_mapped_hash (dwarf2_per_objfile
->index_table
,
2731 /* Note that this just looks at the very first one named NAME -- but
2732 actually we are looking for a function. find_main_filename
2733 should be rewritten so that it doesn't require a custom hook. It
2734 could just use the ordinary symbol tables. */
2735 /* vec[0] is the length, which must always be >0. */
2736 per_cu
= dw2_get_cu (MAYBE_SWAP (vec
[1]));
2738 file_data
= dw2_get_file_names (objfile
, per_cu
);
2739 if (file_data
== NULL
)
2742 return file_data
->file_names
[file_data
->num_file_names
- 1];
2746 dw2_map_matching_symbols (const char * name
, domain_enum
namespace,
2747 struct objfile
*objfile
, int global
,
2748 int (*callback
) (struct block
*,
2749 struct symbol
*, void *),
2750 void *data
, symbol_compare_ftype
*match
,
2751 symbol_compare_ftype
*ordered_compare
)
2753 /* Currently unimplemented; used for Ada. The function can be called if the
2754 current language is Ada for a non-Ada objfile using GNU index. As Ada
2755 does not look for non-Ada symbols this function should just return. */
2759 dw2_expand_symtabs_matching
2760 (struct objfile
*objfile
,
2761 int (*file_matcher
) (const char *, void *),
2762 int (*name_matcher
) (const struct language_defn
*, const char *, void *),
2763 enum search_domain kind
,
2768 struct mapped_index
*index
;
2770 dw2_setup (objfile
);
2772 /* index_table is NULL if OBJF_READNOW. */
2773 if (!dwarf2_per_objfile
->index_table
)
2775 index
= dwarf2_per_objfile
->index_table
;
2777 if (file_matcher
!= NULL
)
2778 for (i
= 0; i
< (dwarf2_per_objfile
->n_comp_units
2779 + dwarf2_per_objfile
->n_type_comp_units
); ++i
)
2782 struct dwarf2_per_cu_data
*per_cu
= dw2_get_cu (i
);
2783 struct quick_file_names
*file_data
;
2785 per_cu
->v
.quick
->mark
= 0;
2787 /* We only need to look at symtabs not already expanded. */
2788 if (per_cu
->v
.quick
->symtab
)
2791 file_data
= dw2_get_file_names (objfile
, per_cu
);
2792 if (file_data
== NULL
)
2795 for (j
= 0; j
< file_data
->num_file_names
; ++j
)
2797 if (file_matcher (file_data
->file_names
[j
], data
))
2799 per_cu
->v
.quick
->mark
= 1;
2805 for (iter
= 0; iter
< index
->symbol_table_slots
; ++iter
)
2807 offset_type idx
= 2 * iter
;
2809 offset_type
*vec
, vec_len
, vec_idx
;
2811 if (index
->symbol_table
[idx
] == 0 && index
->symbol_table
[idx
+ 1] == 0)
2814 name
= index
->constant_pool
+ MAYBE_SWAP (index
->symbol_table
[idx
]);
2816 if (! (*name_matcher
) (current_language
, name
, data
))
2819 /* The name was matched, now expand corresponding CUs that were
2821 vec
= (offset_type
*) (index
->constant_pool
2822 + MAYBE_SWAP (index
->symbol_table
[idx
+ 1]));
2823 vec_len
= MAYBE_SWAP (vec
[0]);
2824 for (vec_idx
= 0; vec_idx
< vec_len
; ++vec_idx
)
2826 struct dwarf2_per_cu_data
*per_cu
;
2828 per_cu
= dw2_get_cu (MAYBE_SWAP (vec
[vec_idx
+ 1]));
2829 if (file_matcher
== NULL
|| per_cu
->v
.quick
->mark
)
2830 dw2_instantiate_symtab (objfile
, per_cu
);
2835 static struct symtab
*
2836 dw2_find_pc_sect_symtab (struct objfile
*objfile
,
2837 struct minimal_symbol
*msymbol
,
2839 struct obj_section
*section
,
2842 struct dwarf2_per_cu_data
*data
;
2844 dw2_setup (objfile
);
2846 if (!objfile
->psymtabs_addrmap
)
2849 data
= addrmap_find (objfile
->psymtabs_addrmap
, pc
);
2853 if (warn_if_readin
&& data
->v
.quick
->symtab
)
2854 warning (_("(Internal error: pc %s in read in CU, but not in symtab.)"),
2855 paddress (get_objfile_arch (objfile
), pc
));
2857 return dw2_instantiate_symtab (objfile
, data
);
2861 dw2_map_symbol_filenames (struct objfile
*objfile
, symbol_filename_ftype
*fun
,
2862 void *data
, int need_fullname
)
2866 dw2_setup (objfile
);
2868 for (i
= 0; i
< (dwarf2_per_objfile
->n_comp_units
2869 + dwarf2_per_objfile
->n_type_comp_units
); ++i
)
2872 struct dwarf2_per_cu_data
*per_cu
= dw2_get_cu (i
);
2873 struct quick_file_names
*file_data
;
2875 /* We only need to look at symtabs not already expanded. */
2876 if (per_cu
->v
.quick
->symtab
)
2879 file_data
= dw2_get_file_names (objfile
, per_cu
);
2880 if (file_data
== NULL
)
2883 for (j
= 0; j
< file_data
->num_file_names
; ++j
)
2885 const char *this_real_name
;
2888 this_real_name
= dw2_get_real_path (objfile
, file_data
, j
);
2890 this_real_name
= NULL
;
2891 (*fun
) (file_data
->file_names
[j
], this_real_name
, data
);
2897 dw2_has_symbols (struct objfile
*objfile
)
2902 const struct quick_symbol_functions dwarf2_gdb_index_functions
=
2905 dw2_find_last_source_symtab
,
2906 dw2_forget_cached_source_info
,
2907 dw2_map_symtabs_matching_filename
,
2909 dw2_pre_expand_symtabs_matching
,
2913 dw2_expand_symtabs_for_function
,
2914 dw2_expand_all_symtabs
,
2915 dw2_expand_symtabs_with_filename
,
2916 dw2_find_symbol_file
,
2917 dw2_map_matching_symbols
,
2918 dw2_expand_symtabs_matching
,
2919 dw2_find_pc_sect_symtab
,
2920 dw2_map_symbol_filenames
2923 /* Initialize for reading DWARF for this objfile. Return 0 if this
2924 file will use psymtabs, or 1 if using the GNU index. */
2927 dwarf2_initialize_objfile (struct objfile
*objfile
)
2929 /* If we're about to read full symbols, don't bother with the
2930 indices. In this case we also don't care if some other debug
2931 format is making psymtabs, because they are all about to be
2933 if ((objfile
->flags
& OBJF_READNOW
))
2937 dwarf2_per_objfile
->using_index
= 1;
2938 create_all_comp_units (objfile
);
2939 create_debug_types_hash_table (objfile
);
2940 dwarf2_per_objfile
->quick_file_names_table
=
2941 create_quick_file_names_table (dwarf2_per_objfile
->n_comp_units
);
2943 for (i
= 0; i
< (dwarf2_per_objfile
->n_comp_units
2944 + dwarf2_per_objfile
->n_type_comp_units
); ++i
)
2946 struct dwarf2_per_cu_data
*per_cu
= dw2_get_cu (i
);
2948 per_cu
->v
.quick
= OBSTACK_ZALLOC (&objfile
->objfile_obstack
,
2949 struct dwarf2_per_cu_quick_data
);
2952 /* Return 1 so that gdb sees the "quick" functions. However,
2953 these functions will be no-ops because we will have expanded
2958 if (dwarf2_read_index (objfile
))
2966 /* Build a partial symbol table. */
2969 dwarf2_build_psymtabs (struct objfile
*objfile
)
2971 if (objfile
->global_psymbols
.size
== 0 && objfile
->static_psymbols
.size
== 0)
2973 init_psymbol_list (objfile
, 1024);
2976 dwarf2_build_psymtabs_hard (objfile
);
2979 /* Return TRUE if OFFSET is within CU_HEADER. */
2982 offset_in_cu_p (const struct comp_unit_head
*cu_header
, unsigned int offset
)
2984 unsigned int bottom
= cu_header
->offset
;
2985 unsigned int top
= (cu_header
->offset
2987 + cu_header
->initial_length_size
);
2989 return (offset
>= bottom
&& offset
< top
);
2992 /* Read in the comp unit header information from the debug_info at info_ptr.
2993 NOTE: This leaves members offset, first_die_offset to be filled in
2997 read_comp_unit_head (struct comp_unit_head
*cu_header
,
2998 gdb_byte
*info_ptr
, bfd
*abfd
)
3001 unsigned int bytes_read
;
3003 cu_header
->length
= read_initial_length (abfd
, info_ptr
, &bytes_read
);
3004 cu_header
->initial_length_size
= bytes_read
;
3005 cu_header
->offset_size
= (bytes_read
== 4) ? 4 : 8;
3006 info_ptr
+= bytes_read
;
3007 cu_header
->version
= read_2_bytes (abfd
, info_ptr
);
3009 cu_header
->abbrev_offset
= read_offset (abfd
, info_ptr
, cu_header
,
3011 info_ptr
+= bytes_read
;
3012 cu_header
->addr_size
= read_1_byte (abfd
, info_ptr
);
3014 signed_addr
= bfd_get_sign_extend_vma (abfd
);
3015 if (signed_addr
< 0)
3016 internal_error (__FILE__
, __LINE__
,
3017 _("read_comp_unit_head: dwarf from non elf file"));
3018 cu_header
->signed_addr_p
= signed_addr
;
3023 /* Read in a CU header and perform some basic error checking. */
3026 partial_read_comp_unit_head (struct comp_unit_head
*header
, gdb_byte
*info_ptr
,
3027 gdb_byte
*buffer
, unsigned int buffer_size
,
3028 bfd
*abfd
, int is_debug_type_section
)
3030 gdb_byte
*beg_of_comp_unit
= info_ptr
;
3032 header
->offset
= beg_of_comp_unit
- buffer
;
3034 info_ptr
= read_comp_unit_head (header
, info_ptr
, abfd
);
3036 /* If we're reading a type unit, skip over the signature and
3037 type_offset fields. */
3038 if (is_debug_type_section
)
3039 info_ptr
+= 8 /*signature*/ + header
->offset_size
;
3041 header
->first_die_offset
= info_ptr
- beg_of_comp_unit
;
3043 if (header
->version
!= 2 && header
->version
!= 3 && header
->version
!= 4)
3044 error (_("Dwarf Error: wrong version in compilation unit header "
3045 "(is %d, should be 2, 3, or 4) [in module %s]"), header
->version
,
3046 bfd_get_filename (abfd
));
3048 if (header
->abbrev_offset
3049 >= dwarf2_section_size (dwarf2_per_objfile
->objfile
,
3050 &dwarf2_per_objfile
->abbrev
))
3051 error (_("Dwarf Error: bad offset (0x%lx) in compilation unit header "
3052 "(offset 0x%lx + 6) [in module %s]"),
3053 (long) header
->abbrev_offset
,
3054 (long) (beg_of_comp_unit
- buffer
),
3055 bfd_get_filename (abfd
));
3057 if (beg_of_comp_unit
+ header
->length
+ header
->initial_length_size
3058 > buffer
+ buffer_size
)
3059 error (_("Dwarf Error: bad length (0x%lx) in compilation unit header "
3060 "(offset 0x%lx + 0) [in module %s]"),
3061 (long) header
->length
,
3062 (long) (beg_of_comp_unit
- buffer
),
3063 bfd_get_filename (abfd
));
3068 /* Read in the types comp unit header information from .debug_types entry at
3069 types_ptr. The result is a pointer to one past the end of the header. */
3072 read_type_comp_unit_head (struct comp_unit_head
*cu_header
,
3073 struct dwarf2_section_info
*section
,
3074 ULONGEST
*signature
,
3075 gdb_byte
*types_ptr
, bfd
*abfd
)
3077 gdb_byte
*initial_types_ptr
= types_ptr
;
3079 dwarf2_read_section (dwarf2_per_objfile
->objfile
, section
);
3080 cu_header
->offset
= types_ptr
- section
->buffer
;
3082 types_ptr
= read_comp_unit_head (cu_header
, types_ptr
, abfd
);
3084 *signature
= read_8_bytes (abfd
, types_ptr
);
3086 types_ptr
+= cu_header
->offset_size
;
3087 cu_header
->first_die_offset
= types_ptr
- initial_types_ptr
;
3092 /* Allocate a new partial symtab for file named NAME and mark this new
3093 partial symtab as being an include of PST. */
3096 dwarf2_create_include_psymtab (char *name
, struct partial_symtab
*pst
,
3097 struct objfile
*objfile
)
3099 struct partial_symtab
*subpst
= allocate_psymtab (name
, objfile
);
3101 subpst
->section_offsets
= pst
->section_offsets
;
3102 subpst
->textlow
= 0;
3103 subpst
->texthigh
= 0;
3105 subpst
->dependencies
= (struct partial_symtab
**)
3106 obstack_alloc (&objfile
->objfile_obstack
,
3107 sizeof (struct partial_symtab
*));
3108 subpst
->dependencies
[0] = pst
;
3109 subpst
->number_of_dependencies
= 1;
3111 subpst
->globals_offset
= 0;
3112 subpst
->n_global_syms
= 0;
3113 subpst
->statics_offset
= 0;
3114 subpst
->n_static_syms
= 0;
3115 subpst
->symtab
= NULL
;
3116 subpst
->read_symtab
= pst
->read_symtab
;
3119 /* No private part is necessary for include psymtabs. This property
3120 can be used to differentiate between such include psymtabs and
3121 the regular ones. */
3122 subpst
->read_symtab_private
= NULL
;
3125 /* Read the Line Number Program data and extract the list of files
3126 included by the source file represented by PST. Build an include
3127 partial symtab for each of these included files. */
3130 dwarf2_build_include_psymtabs (struct dwarf2_cu
*cu
,
3131 struct die_info
*die
,
3132 struct partial_symtab
*pst
)
3134 struct objfile
*objfile
= cu
->objfile
;
3135 bfd
*abfd
= objfile
->obfd
;
3136 struct line_header
*lh
= NULL
;
3137 struct attribute
*attr
;
3139 attr
= dwarf2_attr (die
, DW_AT_stmt_list
, cu
);
3142 unsigned int line_offset
= DW_UNSND (attr
);
3144 lh
= dwarf_decode_line_header (line_offset
, abfd
, cu
);
3147 return; /* No linetable, so no includes. */
3149 /* NOTE: pst->dirname is DW_AT_comp_dir (if present). */
3150 dwarf_decode_lines (lh
, pst
->dirname
, abfd
, cu
, pst
);
3152 free_line_header (lh
);
3156 hash_type_signature (const void *item
)
3158 const struct signatured_type
*type_sig
= item
;
3160 /* This drops the top 32 bits of the signature, but is ok for a hash. */
3161 return type_sig
->signature
;
3165 eq_type_signature (const void *item_lhs
, const void *item_rhs
)
3167 const struct signatured_type
*lhs
= item_lhs
;
3168 const struct signatured_type
*rhs
= item_rhs
;
3170 return lhs
->signature
== rhs
->signature
;
3173 /* Allocate a hash table for signatured types. */
3176 allocate_signatured_type_table (struct objfile
*objfile
)
3178 return htab_create_alloc_ex (41,
3179 hash_type_signature
,
3182 &objfile
->objfile_obstack
,
3183 hashtab_obstack_allocate
,
3184 dummy_obstack_deallocate
);
3187 /* A helper function to add a signatured type CU to a list. */
3190 add_signatured_type_cu_to_list (void **slot
, void *datum
)
3192 struct signatured_type
*sigt
= *slot
;
3193 struct dwarf2_per_cu_data
***datap
= datum
;
3195 **datap
= &sigt
->per_cu
;
3201 /* Create the hash table of all entries in the .debug_types section.
3202 The result is zero if there is an error (e.g. missing .debug_types section),
3203 otherwise non-zero. */
3206 create_debug_types_hash_table (struct objfile
*objfile
)
3208 htab_t types_htab
= NULL
;
3209 struct dwarf2_per_cu_data
**iter
;
3211 struct dwarf2_section_info
*section
;
3213 if (VEC_empty (dwarf2_section_info_def
, dwarf2_per_objfile
->types
))
3215 dwarf2_per_objfile
->signatured_types
= NULL
;
3220 VEC_iterate (dwarf2_section_info_def
, dwarf2_per_objfile
->types
,
3224 gdb_byte
*info_ptr
, *end_ptr
;
3226 dwarf2_read_section (objfile
, section
);
3227 info_ptr
= section
->buffer
;
3229 if (info_ptr
== NULL
)
3232 if (types_htab
== NULL
)
3233 types_htab
= allocate_signatured_type_table (objfile
);
3235 if (dwarf2_die_debug
)
3236 fprintf_unfiltered (gdb_stdlog
, "Signatured types:\n");
3238 end_ptr
= info_ptr
+ section
->size
;
3239 while (info_ptr
< end_ptr
)
3241 unsigned int offset
;
3242 unsigned int offset_size
;
3243 unsigned int type_offset
;
3244 unsigned int length
, initial_length_size
;
3245 unsigned short version
;
3247 struct signatured_type
*type_sig
;
3249 gdb_byte
*ptr
= info_ptr
;
3251 offset
= ptr
- section
->buffer
;
3253 /* We need to read the type's signature in order to build the hash
3254 table, but we don't need to read anything else just yet. */
3256 /* Sanity check to ensure entire cu is present. */
3257 length
= read_initial_length (objfile
->obfd
, ptr
,
3258 &initial_length_size
);
3259 if (ptr
+ length
+ initial_length_size
> end_ptr
)
3261 complaint (&symfile_complaints
,
3262 _("debug type entry runs off end "
3263 "of `.debug_types' section, ignored"));
3267 offset_size
= initial_length_size
== 4 ? 4 : 8;
3268 ptr
+= initial_length_size
;
3269 version
= bfd_get_16 (objfile
->obfd
, ptr
);
3271 ptr
+= offset_size
; /* abbrev offset */
3272 ptr
+= 1; /* address size */
3273 signature
= bfd_get_64 (objfile
->obfd
, ptr
);
3275 type_offset
= read_offset_1 (objfile
->obfd
, ptr
, offset_size
);
3278 /* Skip dummy type units. */
3279 if (ptr
>= end_ptr
|| peek_abbrev_code (objfile
->obfd
, ptr
) == 0)
3281 info_ptr
= info_ptr
+ initial_length_size
+ length
;
3285 type_sig
= obstack_alloc (&objfile
->objfile_obstack
, sizeof (*type_sig
));
3286 memset (type_sig
, 0, sizeof (*type_sig
));
3287 type_sig
->signature
= signature
;
3288 type_sig
->type_offset
= type_offset
;
3289 type_sig
->per_cu
.objfile
= objfile
;
3290 type_sig
->per_cu
.debug_type_section
= section
;
3291 type_sig
->per_cu
.offset
= offset
;
3293 slot
= htab_find_slot (types_htab
, type_sig
, INSERT
);
3294 gdb_assert (slot
!= NULL
);
3297 const struct signatured_type
*dup_sig
= *slot
;
3299 complaint (&symfile_complaints
,
3300 _("debug type entry at offset 0x%x is duplicate to the "
3301 "entry at offset 0x%x, signature 0x%s"),
3302 offset
, dup_sig
->per_cu
.offset
,
3303 phex (signature
, sizeof (signature
)));
3304 gdb_assert (signature
== dup_sig
->signature
);
3308 if (dwarf2_die_debug
)
3309 fprintf_unfiltered (gdb_stdlog
, " offset 0x%x, signature 0x%s\n",
3310 offset
, phex (signature
, sizeof (signature
)));
3312 info_ptr
= info_ptr
+ initial_length_size
+ length
;
3316 dwarf2_per_objfile
->signatured_types
= types_htab
;
3318 dwarf2_per_objfile
->n_type_comp_units
= htab_elements (types_htab
);
3319 dwarf2_per_objfile
->type_comp_units
3320 = obstack_alloc (&objfile
->objfile_obstack
,
3321 dwarf2_per_objfile
->n_type_comp_units
3322 * sizeof (struct dwarf2_per_cu_data
*));
3323 iter
= &dwarf2_per_objfile
->type_comp_units
[0];
3324 htab_traverse_noresize (types_htab
, add_signatured_type_cu_to_list
, &iter
);
3325 gdb_assert (iter
- &dwarf2_per_objfile
->type_comp_units
[0]
3326 == dwarf2_per_objfile
->n_type_comp_units
);
3331 /* Lookup a signature based type.
3332 Returns NULL if SIG is not present in the table. */
3334 static struct signatured_type
*
3335 lookup_signatured_type (struct objfile
*objfile
, ULONGEST sig
)
3337 struct signatured_type find_entry
, *entry
;
3339 if (dwarf2_per_objfile
->signatured_types
== NULL
)
3341 complaint (&symfile_complaints
,
3342 _("missing `.debug_types' section for DW_FORM_ref_sig8 die"));
3346 find_entry
.signature
= sig
;
3347 entry
= htab_find (dwarf2_per_objfile
->signatured_types
, &find_entry
);
3351 /* Initialize a die_reader_specs struct from a dwarf2_cu struct. */
3354 init_cu_die_reader (struct die_reader_specs
*reader
,
3355 struct dwarf2_cu
*cu
)
3357 reader
->abfd
= cu
->objfile
->obfd
;
3359 if (cu
->per_cu
->debug_type_section
)
3361 gdb_assert (cu
->per_cu
->debug_type_section
->readin
);
3362 reader
->buffer
= cu
->per_cu
->debug_type_section
->buffer
;
3366 gdb_assert (dwarf2_per_objfile
->info
.readin
);
3367 reader
->buffer
= dwarf2_per_objfile
->info
.buffer
;
3371 /* Find the base address of the compilation unit for range lists and
3372 location lists. It will normally be specified by DW_AT_low_pc.
3373 In DWARF-3 draft 4, the base address could be overridden by
3374 DW_AT_entry_pc. It's been removed, but GCC still uses this for
3375 compilation units with discontinuous ranges. */
3378 dwarf2_find_base_address (struct die_info
*die
, struct dwarf2_cu
*cu
)
3380 struct attribute
*attr
;
3383 cu
->base_address
= 0;
3385 attr
= dwarf2_attr (die
, DW_AT_entry_pc
, cu
);
3388 cu
->base_address
= DW_ADDR (attr
);
3393 attr
= dwarf2_attr (die
, DW_AT_low_pc
, cu
);
3396 cu
->base_address
= DW_ADDR (attr
);
3402 /* Subroutine of process_type_comp_unit and dwarf2_build_psymtabs_hard
3403 to combine the common parts.
3404 Process a compilation unit for a psymtab.
3405 BUFFER is a pointer to the beginning of the dwarf section buffer,
3406 either .debug_info or debug_types.
3407 INFO_PTR is a pointer to the start of the CU.
3408 Returns a pointer to the next CU. */
3411 process_psymtab_comp_unit (struct objfile
*objfile
,
3412 struct dwarf2_per_cu_data
*this_cu
,
3413 gdb_byte
*buffer
, gdb_byte
*info_ptr
,
3414 unsigned int buffer_size
)
3416 bfd
*abfd
= objfile
->obfd
;
3417 gdb_byte
*beg_of_comp_unit
= info_ptr
;
3418 struct die_info
*comp_unit_die
;
3419 struct partial_symtab
*pst
;
3421 struct cleanup
*back_to_inner
;
3422 struct dwarf2_cu cu
;
3423 int has_children
, has_pc_info
;
3424 struct attribute
*attr
;
3425 CORE_ADDR best_lowpc
= 0, best_highpc
= 0;
3426 struct die_reader_specs reader_specs
;
3427 const char *filename
;
3429 init_one_comp_unit (&cu
, objfile
);
3430 back_to_inner
= make_cleanup (free_stack_comp_unit
, &cu
);
3432 info_ptr
= partial_read_comp_unit_head (&cu
.header
, info_ptr
,
3433 buffer
, buffer_size
,
3435 this_cu
->debug_type_section
!= NULL
);
3437 /* Skip dummy compilation units. */
3438 if (info_ptr
>= buffer
+ buffer_size
3439 || peek_abbrev_code (abfd
, info_ptr
) == 0)
3441 info_ptr
= (beg_of_comp_unit
+ cu
.header
.length
3442 + cu
.header
.initial_length_size
);
3443 do_cleanups (back_to_inner
);
3447 cu
.list_in_scope
= &file_symbols
;
3449 /* If this compilation unit was already read in, free the
3450 cached copy in order to read it in again. This is
3451 necessary because we skipped some symbols when we first
3452 read in the compilation unit (see load_partial_dies).
3453 This problem could be avoided, but the benefit is
3455 if (this_cu
->cu
!= NULL
)
3456 free_one_cached_comp_unit (this_cu
->cu
);
3458 /* Note that this is a pointer to our stack frame, being
3459 added to a global data structure. It will be cleaned up
3460 in free_stack_comp_unit when we finish with this
3461 compilation unit. */
3463 cu
.per_cu
= this_cu
;
3465 /* Read the abbrevs for this compilation unit into a table. */
3466 dwarf2_read_abbrevs (abfd
, &cu
);
3467 make_cleanup (dwarf2_free_abbrev_table
, &cu
);
3469 /* Read the compilation unit die. */
3470 init_cu_die_reader (&reader_specs
, &cu
);
3471 info_ptr
= read_full_die (&reader_specs
, &comp_unit_die
, info_ptr
,
3474 if (this_cu
->debug_type_section
)
3476 /* LENGTH has not been set yet for type units. */
3477 gdb_assert (this_cu
->offset
== cu
.header
.offset
);
3478 this_cu
->length
= cu
.header
.length
+ cu
.header
.initial_length_size
;
3480 else if (comp_unit_die
->tag
== DW_TAG_partial_unit
)
3482 info_ptr
= (beg_of_comp_unit
+ cu
.header
.length
3483 + cu
.header
.initial_length_size
);
3484 do_cleanups (back_to_inner
);
3488 prepare_one_comp_unit (&cu
, comp_unit_die
);
3490 /* Allocate a new partial symbol table structure. */
3491 attr
= dwarf2_attr (comp_unit_die
, DW_AT_name
, &cu
);
3492 if (attr
== NULL
|| !DW_STRING (attr
))
3495 filename
= DW_STRING (attr
);
3496 pst
= start_psymtab_common (objfile
, objfile
->section_offsets
,
3498 /* TEXTLOW and TEXTHIGH are set below. */
3500 objfile
->global_psymbols
.next
,
3501 objfile
->static_psymbols
.next
);
3502 pst
->psymtabs_addrmap_supported
= 1;
3504 attr
= dwarf2_attr (comp_unit_die
, DW_AT_comp_dir
, &cu
);
3506 pst
->dirname
= DW_STRING (attr
);
3508 pst
->read_symtab_private
= this_cu
;
3510 baseaddr
= ANOFFSET (objfile
->section_offsets
, SECT_OFF_TEXT (objfile
));
3512 /* Store the function that reads in the rest of the symbol table. */
3513 pst
->read_symtab
= dwarf2_psymtab_to_symtab
;
3515 this_cu
->v
.psymtab
= pst
;
3517 dwarf2_find_base_address (comp_unit_die
, &cu
);
3519 /* Possibly set the default values of LOWPC and HIGHPC from
3521 has_pc_info
= dwarf2_get_pc_bounds (comp_unit_die
, &best_lowpc
,
3522 &best_highpc
, &cu
, pst
);
3523 if (has_pc_info
== 1 && best_lowpc
< best_highpc
)
3524 /* Store the contiguous range if it is not empty; it can be empty for
3525 CUs with no code. */
3526 addrmap_set_empty (objfile
->psymtabs_addrmap
,
3527 best_lowpc
+ baseaddr
,
3528 best_highpc
+ baseaddr
- 1, pst
);
3530 /* Check if comp unit has_children.
3531 If so, read the rest of the partial symbols from this comp unit.
3532 If not, there's no more debug_info for this comp unit. */
3535 struct partial_die_info
*first_die
;
3536 CORE_ADDR lowpc
, highpc
;
3538 lowpc
= ((CORE_ADDR
) -1);
3539 highpc
= ((CORE_ADDR
) 0);
3541 first_die
= load_partial_dies (abfd
, buffer
, info_ptr
, 1, &cu
);
3543 scan_partial_symbols (first_die
, &lowpc
, &highpc
,
3544 ! has_pc_info
, &cu
);
3546 /* If we didn't find a lowpc, set it to highpc to avoid
3547 complaints from `maint check'. */
3548 if (lowpc
== ((CORE_ADDR
) -1))
3551 /* If the compilation unit didn't have an explicit address range,
3552 then use the information extracted from its child dies. */
3556 best_highpc
= highpc
;
3559 pst
->textlow
= best_lowpc
+ baseaddr
;
3560 pst
->texthigh
= best_highpc
+ baseaddr
;
3562 pst
->n_global_syms
= objfile
->global_psymbols
.next
-
3563 (objfile
->global_psymbols
.list
+ pst
->globals_offset
);
3564 pst
->n_static_syms
= objfile
->static_psymbols
.next
-
3565 (objfile
->static_psymbols
.list
+ pst
->statics_offset
);
3566 sort_pst_symbols (pst
);
3568 info_ptr
= (beg_of_comp_unit
+ cu
.header
.length
3569 + cu
.header
.initial_length_size
);
3571 if (this_cu
->debug_type_section
)
3573 /* It's not clear we want to do anything with stmt lists here.
3574 Waiting to see what gcc ultimately does. */
3578 /* Get the list of files included in the current compilation unit,
3579 and build a psymtab for each of them. */
3580 dwarf2_build_include_psymtabs (&cu
, comp_unit_die
, pst
);
3583 do_cleanups (back_to_inner
);
3588 /* Traversal function for htab_traverse_noresize.
3589 Process one .debug_types comp-unit. */
3592 process_type_comp_unit (void **slot
, void *info
)
3594 struct signatured_type
*entry
= (struct signatured_type
*) *slot
;
3595 struct objfile
*objfile
= (struct objfile
*) info
;
3596 struct dwarf2_per_cu_data
*this_cu
;
3598 this_cu
= &entry
->per_cu
;
3600 gdb_assert (this_cu
->debug_type_section
->readin
);
3601 process_psymtab_comp_unit (objfile
, this_cu
,
3602 this_cu
->debug_type_section
->buffer
,
3603 (this_cu
->debug_type_section
->buffer
3605 this_cu
->debug_type_section
->size
);
3610 /* Subroutine of dwarf2_build_psymtabs_hard to simplify it.
3611 Build partial symbol tables for the .debug_types comp-units. */
3614 build_type_psymtabs (struct objfile
*objfile
)
3616 if (! create_debug_types_hash_table (objfile
))
3619 htab_traverse_noresize (dwarf2_per_objfile
->signatured_types
,
3620 process_type_comp_unit
, objfile
);
3623 /* A cleanup function that clears objfile's psymtabs_addrmap field. */
3626 psymtabs_addrmap_cleanup (void *o
)
3628 struct objfile
*objfile
= o
;
3630 objfile
->psymtabs_addrmap
= NULL
;
3633 /* Build the partial symbol table by doing a quick pass through the
3634 .debug_info and .debug_abbrev sections. */
3637 dwarf2_build_psymtabs_hard (struct objfile
*objfile
)
3640 struct cleanup
*back_to
, *addrmap_cleanup
;
3641 struct obstack temp_obstack
;
3643 dwarf2_per_objfile
->reading_partial_symbols
= 1;
3645 dwarf2_read_section (objfile
, &dwarf2_per_objfile
->info
);
3646 info_ptr
= dwarf2_per_objfile
->info
.buffer
;
3648 /* Any cached compilation units will be linked by the per-objfile
3649 read_in_chain. Make sure to free them when we're done. */
3650 back_to
= make_cleanup (free_cached_comp_units
, NULL
);
3652 build_type_psymtabs (objfile
);
3654 create_all_comp_units (objfile
);
3656 /* Create a temporary address map on a temporary obstack. We later
3657 copy this to the final obstack. */
3658 obstack_init (&temp_obstack
);
3659 make_cleanup_obstack_free (&temp_obstack
);
3660 objfile
->psymtabs_addrmap
= addrmap_create_mutable (&temp_obstack
);
3661 addrmap_cleanup
= make_cleanup (psymtabs_addrmap_cleanup
, objfile
);
3663 /* Since the objects we're extracting from .debug_info vary in
3664 length, only the individual functions to extract them (like
3665 read_comp_unit_head and load_partial_die) can really know whether
3666 the buffer is large enough to hold another complete object.
3668 At the moment, they don't actually check that. If .debug_info
3669 holds just one extra byte after the last compilation unit's dies,
3670 then read_comp_unit_head will happily read off the end of the
3671 buffer. read_partial_die is similarly casual. Those functions
3674 For this loop condition, simply checking whether there's any data
3675 left at all should be sufficient. */
3677 while (info_ptr
< (dwarf2_per_objfile
->info
.buffer
3678 + dwarf2_per_objfile
->info
.size
))
3680 struct dwarf2_per_cu_data
*this_cu
;
3682 this_cu
= dwarf2_find_comp_unit (info_ptr
3683 - dwarf2_per_objfile
->info
.buffer
,
3686 info_ptr
= process_psymtab_comp_unit (objfile
, this_cu
,
3687 dwarf2_per_objfile
->info
.buffer
,
3689 dwarf2_per_objfile
->info
.size
);
3692 objfile
->psymtabs_addrmap
= addrmap_create_fixed (objfile
->psymtabs_addrmap
,
3693 &objfile
->objfile_obstack
);
3694 discard_cleanups (addrmap_cleanup
);
3696 do_cleanups (back_to
);
3699 /* Load the partial DIEs for a secondary CU into memory. */
3702 load_partial_comp_unit (struct dwarf2_per_cu_data
*this_cu
,
3703 struct objfile
*objfile
)
3705 bfd
*abfd
= objfile
->obfd
;
3707 struct die_info
*comp_unit_die
;
3708 struct dwarf2_cu
*cu
;
3709 struct cleanup
*free_abbrevs_cleanup
, *free_cu_cleanup
= NULL
;
3711 struct die_reader_specs reader_specs
;
3714 gdb_assert (! this_cu
->debug_type_section
);
3716 gdb_assert (dwarf2_per_objfile
->info
.readin
);
3717 info_ptr
= dwarf2_per_objfile
->info
.buffer
+ this_cu
->offset
;
3719 if (this_cu
->cu
== NULL
)
3721 cu
= xmalloc (sizeof (*cu
));
3722 init_one_comp_unit (cu
, objfile
);
3726 /* If an error occurs while loading, release our storage. */
3727 free_cu_cleanup
= make_cleanup (free_one_comp_unit
, cu
);
3729 info_ptr
= partial_read_comp_unit_head (&cu
->header
, info_ptr
,
3730 dwarf2_per_objfile
->info
.buffer
,
3731 dwarf2_per_objfile
->info
.size
,
3734 /* Skip dummy compilation units. */
3735 if (info_ptr
>= (dwarf2_per_objfile
->info
.buffer
3736 + dwarf2_per_objfile
->info
.size
)
3737 || peek_abbrev_code (abfd
, info_ptr
) == 0)
3739 do_cleanups (free_cu_cleanup
);
3743 /* Link this compilation unit into the compilation unit tree. */
3745 cu
->per_cu
= this_cu
;
3747 /* Link this CU into read_in_chain. */
3748 this_cu
->cu
->read_in_chain
= dwarf2_per_objfile
->read_in_chain
;
3749 dwarf2_per_objfile
->read_in_chain
= this_cu
;
3754 info_ptr
+= cu
->header
.first_die_offset
;
3757 /* Read the abbrevs for this compilation unit into a table. */
3758 gdb_assert (cu
->dwarf2_abbrevs
== NULL
);
3759 dwarf2_read_abbrevs (abfd
, cu
);
3760 free_abbrevs_cleanup
= make_cleanup (dwarf2_free_abbrev_table
, cu
);
3762 /* Read the compilation unit die. */
3763 init_cu_die_reader (&reader_specs
, cu
);
3764 info_ptr
= read_full_die (&reader_specs
, &comp_unit_die
, info_ptr
,
3767 prepare_one_comp_unit (cu
, comp_unit_die
);
3769 /* Check if comp unit has_children.
3770 If so, read the rest of the partial symbols from this comp unit.
3771 If not, there's no more debug_info for this comp unit. */
3773 load_partial_dies (abfd
, dwarf2_per_objfile
->info
.buffer
, info_ptr
, 0, cu
);
3775 do_cleanups (free_abbrevs_cleanup
);
3779 /* We've successfully allocated this compilation unit. Let our
3780 caller clean it up when finished with it. */
3781 discard_cleanups (free_cu_cleanup
);
3785 /* Create a list of all compilation units in OBJFILE. We do this only
3786 if an inter-comp-unit reference is found; presumably if there is one,
3787 there will be many, and one will occur early in the .debug_info section.
3788 So there's no point in building this list incrementally. */
3791 create_all_comp_units (struct objfile
*objfile
)
3795 struct dwarf2_per_cu_data
**all_comp_units
;
3798 dwarf2_read_section (objfile
, &dwarf2_per_objfile
->info
);
3799 info_ptr
= dwarf2_per_objfile
->info
.buffer
;
3803 all_comp_units
= xmalloc (n_allocated
3804 * sizeof (struct dwarf2_per_cu_data
*));
3806 while (info_ptr
< dwarf2_per_objfile
->info
.buffer
3807 + dwarf2_per_objfile
->info
.size
)
3809 unsigned int length
, initial_length_size
;
3810 struct dwarf2_per_cu_data
*this_cu
;
3811 unsigned int offset
;
3813 offset
= info_ptr
- dwarf2_per_objfile
->info
.buffer
;
3815 /* Read just enough information to find out where the next
3816 compilation unit is. */
3817 length
= read_initial_length (objfile
->obfd
, info_ptr
,
3818 &initial_length_size
);
3820 /* Save the compilation unit for later lookup. */
3821 this_cu
= obstack_alloc (&objfile
->objfile_obstack
,
3822 sizeof (struct dwarf2_per_cu_data
));
3823 memset (this_cu
, 0, sizeof (*this_cu
));
3824 this_cu
->offset
= offset
;
3825 this_cu
->length
= length
+ initial_length_size
;
3826 this_cu
->objfile
= objfile
;
3828 if (n_comp_units
== n_allocated
)
3831 all_comp_units
= xrealloc (all_comp_units
,
3833 * sizeof (struct dwarf2_per_cu_data
*));
3835 all_comp_units
[n_comp_units
++] = this_cu
;
3837 info_ptr
= info_ptr
+ this_cu
->length
;
3840 dwarf2_per_objfile
->all_comp_units
3841 = obstack_alloc (&objfile
->objfile_obstack
,
3842 n_comp_units
* sizeof (struct dwarf2_per_cu_data
*));
3843 memcpy (dwarf2_per_objfile
->all_comp_units
, all_comp_units
,
3844 n_comp_units
* sizeof (struct dwarf2_per_cu_data
*));
3845 xfree (all_comp_units
);
3846 dwarf2_per_objfile
->n_comp_units
= n_comp_units
;
3849 /* Process all loaded DIEs for compilation unit CU, starting at
3850 FIRST_DIE. The caller should pass NEED_PC == 1 if the compilation
3851 unit DIE did not have PC info (DW_AT_low_pc and DW_AT_high_pc, or
3852 DW_AT_ranges). If NEED_PC is set, then this function will set
3853 *LOWPC and *HIGHPC to the lowest and highest PC values found in CU
3854 and record the covered ranges in the addrmap. */
3857 scan_partial_symbols (struct partial_die_info
*first_die
, CORE_ADDR
*lowpc
,
3858 CORE_ADDR
*highpc
, int need_pc
, struct dwarf2_cu
*cu
)
3860 struct partial_die_info
*pdi
;
3862 /* Now, march along the PDI's, descending into ones which have
3863 interesting children but skipping the children of the other ones,
3864 until we reach the end of the compilation unit. */
3870 fixup_partial_die (pdi
, cu
);
3872 /* Anonymous namespaces or modules have no name but have interesting
3873 children, so we need to look at them. Ditto for anonymous
3876 if (pdi
->name
!= NULL
|| pdi
->tag
== DW_TAG_namespace
3877 || pdi
->tag
== DW_TAG_module
|| pdi
->tag
== DW_TAG_enumeration_type
)
3881 case DW_TAG_subprogram
:
3882 add_partial_subprogram (pdi
, lowpc
, highpc
, need_pc
, cu
);
3884 case DW_TAG_constant
:
3885 case DW_TAG_variable
:
3886 case DW_TAG_typedef
:
3887 case DW_TAG_union_type
:
3888 if (!pdi
->is_declaration
)
3890 add_partial_symbol (pdi
, cu
);
3893 case DW_TAG_class_type
:
3894 case DW_TAG_interface_type
:
3895 case DW_TAG_structure_type
:
3896 if (!pdi
->is_declaration
)
3898 add_partial_symbol (pdi
, cu
);
3901 case DW_TAG_enumeration_type
:
3902 if (!pdi
->is_declaration
)
3903 add_partial_enumeration (pdi
, cu
);
3905 case DW_TAG_base_type
:
3906 case DW_TAG_subrange_type
:
3907 /* File scope base type definitions are added to the partial
3909 add_partial_symbol (pdi
, cu
);
3911 case DW_TAG_namespace
:
3912 add_partial_namespace (pdi
, lowpc
, highpc
, need_pc
, cu
);
3915 add_partial_module (pdi
, lowpc
, highpc
, need_pc
, cu
);
3922 /* If the die has a sibling, skip to the sibling. */
3924 pdi
= pdi
->die_sibling
;
3928 /* Functions used to compute the fully scoped name of a partial DIE.
3930 Normally, this is simple. For C++, the parent DIE's fully scoped
3931 name is concatenated with "::" and the partial DIE's name. For
3932 Java, the same thing occurs except that "." is used instead of "::".
3933 Enumerators are an exception; they use the scope of their parent
3934 enumeration type, i.e. the name of the enumeration type is not
3935 prepended to the enumerator.
3937 There are two complexities. One is DW_AT_specification; in this
3938 case "parent" means the parent of the target of the specification,
3939 instead of the direct parent of the DIE. The other is compilers
3940 which do not emit DW_TAG_namespace; in this case we try to guess
3941 the fully qualified name of structure types from their members'
3942 linkage names. This must be done using the DIE's children rather
3943 than the children of any DW_AT_specification target. We only need
3944 to do this for structures at the top level, i.e. if the target of
3945 any DW_AT_specification (if any; otherwise the DIE itself) does not
3948 /* Compute the scope prefix associated with PDI's parent, in
3949 compilation unit CU. The result will be allocated on CU's
3950 comp_unit_obstack, or a copy of the already allocated PDI->NAME
3951 field. NULL is returned if no prefix is necessary. */
3953 partial_die_parent_scope (struct partial_die_info
*pdi
,
3954 struct dwarf2_cu
*cu
)
3956 char *grandparent_scope
;
3957 struct partial_die_info
*parent
, *real_pdi
;
3959 /* We need to look at our parent DIE; if we have a DW_AT_specification,
3960 then this means the parent of the specification DIE. */
3963 while (real_pdi
->has_specification
)
3964 real_pdi
= find_partial_die (real_pdi
->spec_offset
, cu
);
3966 parent
= real_pdi
->die_parent
;
3970 if (parent
->scope_set
)
3971 return parent
->scope
;
3973 fixup_partial_die (parent
, cu
);
3975 grandparent_scope
= partial_die_parent_scope (parent
, cu
);
3977 /* GCC 4.0 and 4.1 had a bug (PR c++/28460) where they generated bogus
3978 DW_TAG_namespace DIEs with a name of "::" for the global namespace.
3979 Work around this problem here. */
3980 if (cu
->language
== language_cplus
3981 && parent
->tag
== DW_TAG_namespace
3982 && strcmp (parent
->name
, "::") == 0
3983 && grandparent_scope
== NULL
)
3985 parent
->scope
= NULL
;
3986 parent
->scope_set
= 1;
3990 if (pdi
->tag
== DW_TAG_enumerator
)
3991 /* Enumerators should not get the name of the enumeration as a prefix. */
3992 parent
->scope
= grandparent_scope
;
3993 else if (parent
->tag
== DW_TAG_namespace
3994 || parent
->tag
== DW_TAG_module
3995 || parent
->tag
== DW_TAG_structure_type
3996 || parent
->tag
== DW_TAG_class_type
3997 || parent
->tag
== DW_TAG_interface_type
3998 || parent
->tag
== DW_TAG_union_type
3999 || parent
->tag
== DW_TAG_enumeration_type
)
4001 if (grandparent_scope
== NULL
)
4002 parent
->scope
= parent
->name
;
4004 parent
->scope
= typename_concat (&cu
->comp_unit_obstack
,
4006 parent
->name
, 0, cu
);
4010 /* FIXME drow/2004-04-01: What should we be doing with
4011 function-local names? For partial symbols, we should probably be
4013 complaint (&symfile_complaints
,
4014 _("unhandled containing DIE tag %d for DIE at %d"),
4015 parent
->tag
, pdi
->offset
);
4016 parent
->scope
= grandparent_scope
;
4019 parent
->scope_set
= 1;
4020 return parent
->scope
;
4023 /* Return the fully scoped name associated with PDI, from compilation unit
4024 CU. The result will be allocated with malloc. */
4026 partial_die_full_name (struct partial_die_info
*pdi
,
4027 struct dwarf2_cu
*cu
)
4031 /* If this is a template instantiation, we can not work out the
4032 template arguments from partial DIEs. So, unfortunately, we have
4033 to go through the full DIEs. At least any work we do building
4034 types here will be reused if full symbols are loaded later. */
4035 if (pdi
->has_template_arguments
)
4037 fixup_partial_die (pdi
, cu
);
4039 if (pdi
->name
!= NULL
&& strchr (pdi
->name
, '<') == NULL
)
4041 struct die_info
*die
;
4042 struct attribute attr
;
4043 struct dwarf2_cu
*ref_cu
= cu
;
4046 attr
.form
= DW_FORM_ref_addr
;
4047 attr
.u
.addr
= pdi
->offset
;
4048 die
= follow_die_ref (NULL
, &attr
, &ref_cu
);
4050 return xstrdup (dwarf2_full_name (NULL
, die
, ref_cu
));
4054 parent_scope
= partial_die_parent_scope (pdi
, cu
);
4055 if (parent_scope
== NULL
)
4058 return typename_concat (NULL
, parent_scope
, pdi
->name
, 0, cu
);
4062 add_partial_symbol (struct partial_die_info
*pdi
, struct dwarf2_cu
*cu
)
4064 struct objfile
*objfile
= cu
->objfile
;
4066 char *actual_name
= NULL
;
4067 const struct partial_symbol
*psym
= NULL
;
4069 int built_actual_name
= 0;
4071 baseaddr
= ANOFFSET (objfile
->section_offsets
, SECT_OFF_TEXT (objfile
));
4073 actual_name
= partial_die_full_name (pdi
, cu
);
4075 built_actual_name
= 1;
4077 if (actual_name
== NULL
)
4078 actual_name
= pdi
->name
;
4082 case DW_TAG_subprogram
:
4083 if (pdi
->is_external
|| cu
->language
== language_ada
)
4085 /* brobecker/2007-12-26: Normally, only "external" DIEs are part
4086 of the global scope. But in Ada, we want to be able to access
4087 nested procedures globally. So all Ada subprograms are stored
4088 in the global scope. */
4089 /* prim_record_minimal_symbol (actual_name, pdi->lowpc + baseaddr,
4090 mst_text, objfile); */
4091 add_psymbol_to_list (actual_name
, strlen (actual_name
),
4093 VAR_DOMAIN
, LOC_BLOCK
,
4094 &objfile
->global_psymbols
,
4095 0, pdi
->lowpc
+ baseaddr
,
4096 cu
->language
, objfile
);
4100 /* prim_record_minimal_symbol (actual_name, pdi->lowpc + baseaddr,
4101 mst_file_text, objfile); */
4102 add_psymbol_to_list (actual_name
, strlen (actual_name
),
4104 VAR_DOMAIN
, LOC_BLOCK
,
4105 &objfile
->static_psymbols
,
4106 0, pdi
->lowpc
+ baseaddr
,
4107 cu
->language
, objfile
);
4110 case DW_TAG_constant
:
4112 struct psymbol_allocation_list
*list
;
4114 if (pdi
->is_external
)
4115 list
= &objfile
->global_psymbols
;
4117 list
= &objfile
->static_psymbols
;
4118 add_psymbol_to_list (actual_name
, strlen (actual_name
),
4119 built_actual_name
, VAR_DOMAIN
, LOC_STATIC
,
4120 list
, 0, 0, cu
->language
, objfile
);
4123 case DW_TAG_variable
:
4125 addr
= decode_locdesc (pdi
->locdesc
, cu
);
4129 && !dwarf2_per_objfile
->has_section_at_zero
)
4131 /* A global or static variable may also have been stripped
4132 out by the linker if unused, in which case its address
4133 will be nullified; do not add such variables into partial
4134 symbol table then. */
4136 else if (pdi
->is_external
)
4139 Don't enter into the minimal symbol tables as there is
4140 a minimal symbol table entry from the ELF symbols already.
4141 Enter into partial symbol table if it has a location
4142 descriptor or a type.
4143 If the location descriptor is missing, new_symbol will create
4144 a LOC_UNRESOLVED symbol, the address of the variable will then
4145 be determined from the minimal symbol table whenever the variable
4147 The address for the partial symbol table entry is not
4148 used by GDB, but it comes in handy for debugging partial symbol
4151 if (pdi
->locdesc
|| pdi
->has_type
)
4152 add_psymbol_to_list (actual_name
, strlen (actual_name
),
4154 VAR_DOMAIN
, LOC_STATIC
,
4155 &objfile
->global_psymbols
,
4157 cu
->language
, objfile
);
4161 /* Static Variable. Skip symbols without location descriptors. */
4162 if (pdi
->locdesc
== NULL
)
4164 if (built_actual_name
)
4165 xfree (actual_name
);
4168 /* prim_record_minimal_symbol (actual_name, addr + baseaddr,
4169 mst_file_data, objfile); */
4170 add_psymbol_to_list (actual_name
, strlen (actual_name
),
4172 VAR_DOMAIN
, LOC_STATIC
,
4173 &objfile
->static_psymbols
,
4175 cu
->language
, objfile
);
4178 case DW_TAG_typedef
:
4179 case DW_TAG_base_type
:
4180 case DW_TAG_subrange_type
:
4181 add_psymbol_to_list (actual_name
, strlen (actual_name
),
4183 VAR_DOMAIN
, LOC_TYPEDEF
,
4184 &objfile
->static_psymbols
,
4185 0, (CORE_ADDR
) 0, cu
->language
, objfile
);
4187 case DW_TAG_namespace
:
4188 add_psymbol_to_list (actual_name
, strlen (actual_name
),
4190 VAR_DOMAIN
, LOC_TYPEDEF
,
4191 &objfile
->global_psymbols
,
4192 0, (CORE_ADDR
) 0, cu
->language
, objfile
);
4194 case DW_TAG_class_type
:
4195 case DW_TAG_interface_type
:
4196 case DW_TAG_structure_type
:
4197 case DW_TAG_union_type
:
4198 case DW_TAG_enumeration_type
:
4199 /* Skip external references. The DWARF standard says in the section
4200 about "Structure, Union, and Class Type Entries": "An incomplete
4201 structure, union or class type is represented by a structure,
4202 union or class entry that does not have a byte size attribute
4203 and that has a DW_AT_declaration attribute." */
4204 if (!pdi
->has_byte_size
&& pdi
->is_declaration
)
4206 if (built_actual_name
)
4207 xfree (actual_name
);
4211 /* NOTE: carlton/2003-10-07: See comment in new_symbol about
4212 static vs. global. */
4213 add_psymbol_to_list (actual_name
, strlen (actual_name
),
4215 STRUCT_DOMAIN
, LOC_TYPEDEF
,
4216 (cu
->language
== language_cplus
4217 || cu
->language
== language_java
)
4218 ? &objfile
->global_psymbols
4219 : &objfile
->static_psymbols
,
4220 0, (CORE_ADDR
) 0, cu
->language
, objfile
);
4223 case DW_TAG_enumerator
:
4224 add_psymbol_to_list (actual_name
, strlen (actual_name
),
4226 VAR_DOMAIN
, LOC_CONST
,
4227 (cu
->language
== language_cplus
4228 || cu
->language
== language_java
)
4229 ? &objfile
->global_psymbols
4230 : &objfile
->static_psymbols
,
4231 0, (CORE_ADDR
) 0, cu
->language
, objfile
);
4237 if (built_actual_name
)
4238 xfree (actual_name
);
4241 /* Read a partial die corresponding to a namespace; also, add a symbol
4242 corresponding to that namespace to the symbol table. NAMESPACE is
4243 the name of the enclosing namespace. */
4246 add_partial_namespace (struct partial_die_info
*pdi
,
4247 CORE_ADDR
*lowpc
, CORE_ADDR
*highpc
,
4248 int need_pc
, struct dwarf2_cu
*cu
)
4250 /* Add a symbol for the namespace. */
4252 add_partial_symbol (pdi
, cu
);
4254 /* Now scan partial symbols in that namespace. */
4256 if (pdi
->has_children
)
4257 scan_partial_symbols (pdi
->die_child
, lowpc
, highpc
, need_pc
, cu
);
4260 /* Read a partial die corresponding to a Fortran module. */
4263 add_partial_module (struct partial_die_info
*pdi
, CORE_ADDR
*lowpc
,
4264 CORE_ADDR
*highpc
, int need_pc
, struct dwarf2_cu
*cu
)
4266 /* Now scan partial symbols in that module. */
4268 if (pdi
->has_children
)
4269 scan_partial_symbols (pdi
->die_child
, lowpc
, highpc
, need_pc
, cu
);
4272 /* Read a partial die corresponding to a subprogram and create a partial
4273 symbol for that subprogram. When the CU language allows it, this
4274 routine also defines a partial symbol for each nested subprogram
4275 that this subprogram contains.
4277 DIE my also be a lexical block, in which case we simply search
4278 recursively for suprograms defined inside that lexical block.
4279 Again, this is only performed when the CU language allows this
4280 type of definitions. */
4283 add_partial_subprogram (struct partial_die_info
*pdi
,
4284 CORE_ADDR
*lowpc
, CORE_ADDR
*highpc
,
4285 int need_pc
, struct dwarf2_cu
*cu
)
4287 if (pdi
->tag
== DW_TAG_subprogram
)
4289 if (pdi
->has_pc_info
)
4291 if (pdi
->lowpc
< *lowpc
)
4292 *lowpc
= pdi
->lowpc
;
4293 if (pdi
->highpc
> *highpc
)
4294 *highpc
= pdi
->highpc
;
4298 struct objfile
*objfile
= cu
->objfile
;
4300 baseaddr
= ANOFFSET (objfile
->section_offsets
,
4301 SECT_OFF_TEXT (objfile
));
4302 addrmap_set_empty (objfile
->psymtabs_addrmap
,
4303 pdi
->lowpc
+ baseaddr
,
4304 pdi
->highpc
- 1 + baseaddr
,
4305 cu
->per_cu
->v
.psymtab
);
4307 if (!pdi
->is_declaration
)
4308 /* Ignore subprogram DIEs that do not have a name, they are
4309 illegal. Do not emit a complaint at this point, we will
4310 do so when we convert this psymtab into a symtab. */
4312 add_partial_symbol (pdi
, cu
);
4316 if (! pdi
->has_children
)
4319 if (cu
->language
== language_ada
)
4321 pdi
= pdi
->die_child
;
4324 fixup_partial_die (pdi
, cu
);
4325 if (pdi
->tag
== DW_TAG_subprogram
4326 || pdi
->tag
== DW_TAG_lexical_block
)
4327 add_partial_subprogram (pdi
, lowpc
, highpc
, need_pc
, cu
);
4328 pdi
= pdi
->die_sibling
;
4333 /* Read a partial die corresponding to an enumeration type. */
4336 add_partial_enumeration (struct partial_die_info
*enum_pdi
,
4337 struct dwarf2_cu
*cu
)
4339 struct partial_die_info
*pdi
;
4341 if (enum_pdi
->name
!= NULL
)
4342 add_partial_symbol (enum_pdi
, cu
);
4344 pdi
= enum_pdi
->die_child
;
4347 if (pdi
->tag
!= DW_TAG_enumerator
|| pdi
->name
== NULL
)
4348 complaint (&symfile_complaints
, _("malformed enumerator DIE ignored"));
4350 add_partial_symbol (pdi
, cu
);
4351 pdi
= pdi
->die_sibling
;
4355 /* Return the initial uleb128 in the die at INFO_PTR. */
4358 peek_abbrev_code (bfd
*abfd
, gdb_byte
*info_ptr
)
4360 unsigned int bytes_read
;
4362 return read_unsigned_leb128 (abfd
, info_ptr
, &bytes_read
);
4365 /* Read the initial uleb128 in the die at INFO_PTR in compilation unit CU.
4366 Return the corresponding abbrev, or NULL if the number is zero (indicating
4367 an empty DIE). In either case *BYTES_READ will be set to the length of
4368 the initial number. */
4370 static struct abbrev_info
*
4371 peek_die_abbrev (gdb_byte
*info_ptr
, unsigned int *bytes_read
,
4372 struct dwarf2_cu
*cu
)
4374 bfd
*abfd
= cu
->objfile
->obfd
;
4375 unsigned int abbrev_number
;
4376 struct abbrev_info
*abbrev
;
4378 abbrev_number
= read_unsigned_leb128 (abfd
, info_ptr
, bytes_read
);
4380 if (abbrev_number
== 0)
4383 abbrev
= dwarf2_lookup_abbrev (abbrev_number
, cu
);
4386 error (_("Dwarf Error: Could not find abbrev number %d [in module %s]"),
4387 abbrev_number
, bfd_get_filename (abfd
));
4393 /* Scan the debug information for CU starting at INFO_PTR in buffer BUFFER.
4394 Returns a pointer to the end of a series of DIEs, terminated by an empty
4395 DIE. Any children of the skipped DIEs will also be skipped. */
4398 skip_children (gdb_byte
*buffer
, gdb_byte
*info_ptr
, struct dwarf2_cu
*cu
)
4400 struct abbrev_info
*abbrev
;
4401 unsigned int bytes_read
;
4405 abbrev
= peek_die_abbrev (info_ptr
, &bytes_read
, cu
);
4407 return info_ptr
+ bytes_read
;
4409 info_ptr
= skip_one_die (buffer
, info_ptr
+ bytes_read
, abbrev
, cu
);
4413 /* Scan the debug information for CU starting at INFO_PTR in buffer BUFFER.
4414 INFO_PTR should point just after the initial uleb128 of a DIE, and the
4415 abbrev corresponding to that skipped uleb128 should be passed in
4416 ABBREV. Returns a pointer to this DIE's sibling, skipping any
4420 skip_one_die (gdb_byte
*buffer
, gdb_byte
*info_ptr
,
4421 struct abbrev_info
*abbrev
, struct dwarf2_cu
*cu
)
4423 unsigned int bytes_read
;
4424 struct attribute attr
;
4425 bfd
*abfd
= cu
->objfile
->obfd
;
4426 unsigned int form
, i
;
4428 for (i
= 0; i
< abbrev
->num_attrs
; i
++)
4430 /* The only abbrev we care about is DW_AT_sibling. */
4431 if (abbrev
->attrs
[i
].name
== DW_AT_sibling
)
4433 read_attribute (&attr
, &abbrev
->attrs
[i
],
4434 abfd
, info_ptr
, cu
);
4435 if (attr
.form
== DW_FORM_ref_addr
)
4436 complaint (&symfile_complaints
,
4437 _("ignoring absolute DW_AT_sibling"));
4439 return buffer
+ dwarf2_get_ref_die_offset (&attr
);
4442 /* If it isn't DW_AT_sibling, skip this attribute. */
4443 form
= abbrev
->attrs
[i
].form
;
4447 case DW_FORM_ref_addr
:
4448 /* In DWARF 2, DW_FORM_ref_addr is address sized; in DWARF 3
4449 and later it is offset sized. */
4450 if (cu
->header
.version
== 2)
4451 info_ptr
+= cu
->header
.addr_size
;
4453 info_ptr
+= cu
->header
.offset_size
;
4456 info_ptr
+= cu
->header
.addr_size
;
4463 case DW_FORM_flag_present
:
4475 case DW_FORM_ref_sig8
:
4478 case DW_FORM_string
:
4479 read_direct_string (abfd
, info_ptr
, &bytes_read
);
4480 info_ptr
+= bytes_read
;
4482 case DW_FORM_sec_offset
:
4484 info_ptr
+= cu
->header
.offset_size
;
4486 case DW_FORM_exprloc
:
4488 info_ptr
+= read_unsigned_leb128 (abfd
, info_ptr
, &bytes_read
);
4489 info_ptr
+= bytes_read
;
4491 case DW_FORM_block1
:
4492 info_ptr
+= 1 + read_1_byte (abfd
, info_ptr
);
4494 case DW_FORM_block2
:
4495 info_ptr
+= 2 + read_2_bytes (abfd
, info_ptr
);
4497 case DW_FORM_block4
:
4498 info_ptr
+= 4 + read_4_bytes (abfd
, info_ptr
);
4502 case DW_FORM_ref_udata
:
4503 info_ptr
= skip_leb128 (abfd
, info_ptr
);
4505 case DW_FORM_indirect
:
4506 form
= read_unsigned_leb128 (abfd
, info_ptr
, &bytes_read
);
4507 info_ptr
+= bytes_read
;
4508 /* We need to continue parsing from here, so just go back to
4510 goto skip_attribute
;
4513 error (_("Dwarf Error: Cannot handle %s "
4514 "in DWARF reader [in module %s]"),
4515 dwarf_form_name (form
),
4516 bfd_get_filename (abfd
));
4520 if (abbrev
->has_children
)
4521 return skip_children (buffer
, info_ptr
, cu
);
4526 /* Locate ORIG_PDI's sibling.
4527 INFO_PTR should point to the start of the next DIE after ORIG_PDI
4531 locate_pdi_sibling (struct partial_die_info
*orig_pdi
,
4532 gdb_byte
*buffer
, gdb_byte
*info_ptr
,
4533 bfd
*abfd
, struct dwarf2_cu
*cu
)
4535 /* Do we know the sibling already? */
4537 if (orig_pdi
->sibling
)
4538 return orig_pdi
->sibling
;
4540 /* Are there any children to deal with? */
4542 if (!orig_pdi
->has_children
)
4545 /* Skip the children the long way. */
4547 return skip_children (buffer
, info_ptr
, cu
);
4550 /* Expand this partial symbol table into a full symbol table. */
4553 dwarf2_psymtab_to_symtab (struct partial_symtab
*pst
)
4559 warning (_("bug: psymtab for %s is already read in."),
4566 printf_filtered (_("Reading in symbols for %s..."),
4568 gdb_flush (gdb_stdout
);
4571 /* Restore our global data. */
4572 dwarf2_per_objfile
= objfile_data (pst
->objfile
,
4573 dwarf2_objfile_data_key
);
4575 /* If this psymtab is constructed from a debug-only objfile, the
4576 has_section_at_zero flag will not necessarily be correct. We
4577 can get the correct value for this flag by looking at the data
4578 associated with the (presumably stripped) associated objfile. */
4579 if (pst
->objfile
->separate_debug_objfile_backlink
)
4581 struct dwarf2_per_objfile
*dpo_backlink
4582 = objfile_data (pst
->objfile
->separate_debug_objfile_backlink
,
4583 dwarf2_objfile_data_key
);
4585 dwarf2_per_objfile
->has_section_at_zero
4586 = dpo_backlink
->has_section_at_zero
;
4589 dwarf2_per_objfile
->reading_partial_symbols
= 0;
4591 psymtab_to_symtab_1 (pst
);
4593 /* Finish up the debug error message. */
4595 printf_filtered (_("done.\n"));
4600 /* Add PER_CU to the queue. */
4603 queue_comp_unit (struct dwarf2_per_cu_data
*per_cu
, struct objfile
*objfile
)
4605 struct dwarf2_queue_item
*item
;
4608 item
= xmalloc (sizeof (*item
));
4609 item
->per_cu
= per_cu
;
4612 if (dwarf2_queue
== NULL
)
4613 dwarf2_queue
= item
;
4615 dwarf2_queue_tail
->next
= item
;
4617 dwarf2_queue_tail
= item
;
4620 /* Process the queue. */
4623 process_queue (struct objfile
*objfile
)
4625 struct dwarf2_queue_item
*item
, *next_item
;
4627 /* The queue starts out with one item, but following a DIE reference
4628 may load a new CU, adding it to the end of the queue. */
4629 for (item
= dwarf2_queue
; item
!= NULL
; dwarf2_queue
= item
= next_item
)
4631 if (dwarf2_per_objfile
->using_index
4632 ? !item
->per_cu
->v
.quick
->symtab
4633 : (item
->per_cu
->v
.psymtab
&& !item
->per_cu
->v
.psymtab
->readin
))
4634 process_full_comp_unit (item
->per_cu
);
4636 item
->per_cu
->queued
= 0;
4637 next_item
= item
->next
;
4641 dwarf2_queue_tail
= NULL
;
4644 /* Free all allocated queue entries. This function only releases anything if
4645 an error was thrown; if the queue was processed then it would have been
4646 freed as we went along. */
4649 dwarf2_release_queue (void *dummy
)
4651 struct dwarf2_queue_item
*item
, *last
;
4653 item
= dwarf2_queue
;
4656 /* Anything still marked queued is likely to be in an
4657 inconsistent state, so discard it. */
4658 if (item
->per_cu
->queued
)
4660 if (item
->per_cu
->cu
!= NULL
)
4661 free_one_cached_comp_unit (item
->per_cu
->cu
);
4662 item
->per_cu
->queued
= 0;
4670 dwarf2_queue
= dwarf2_queue_tail
= NULL
;
4673 /* Read in full symbols for PST, and anything it depends on. */
4676 psymtab_to_symtab_1 (struct partial_symtab
*pst
)
4678 struct dwarf2_per_cu_data
*per_cu
;
4679 struct cleanup
*back_to
;
4682 for (i
= 0; i
< pst
->number_of_dependencies
; i
++)
4683 if (!pst
->dependencies
[i
]->readin
)
4685 /* Inform about additional files that need to be read in. */
4688 /* FIXME: i18n: Need to make this a single string. */
4689 fputs_filtered (" ", gdb_stdout
);
4691 fputs_filtered ("and ", gdb_stdout
);
4693 printf_filtered ("%s...", pst
->dependencies
[i
]->filename
);
4694 wrap_here (""); /* Flush output. */
4695 gdb_flush (gdb_stdout
);
4697 psymtab_to_symtab_1 (pst
->dependencies
[i
]);
4700 per_cu
= pst
->read_symtab_private
;
4704 /* It's an include file, no symbols to read for it.
4705 Everything is in the parent symtab. */
4710 dw2_do_instantiate_symtab (pst
->objfile
, per_cu
);
4713 /* Load the DIEs associated with PER_CU into memory. */
4716 load_full_comp_unit (struct dwarf2_per_cu_data
*per_cu
,
4717 struct objfile
*objfile
)
4719 bfd
*abfd
= objfile
->obfd
;
4720 struct dwarf2_cu
*cu
;
4721 unsigned int offset
;
4722 gdb_byte
*info_ptr
, *beg_of_comp_unit
;
4723 struct cleanup
*free_abbrevs_cleanup
= NULL
, *free_cu_cleanup
= NULL
;
4724 struct attribute
*attr
;
4727 gdb_assert (! per_cu
->debug_type_section
);
4729 /* Set local variables from the partial symbol table info. */
4730 offset
= per_cu
->offset
;
4732 dwarf2_read_section (objfile
, &dwarf2_per_objfile
->info
);
4733 info_ptr
= dwarf2_per_objfile
->info
.buffer
+ offset
;
4734 beg_of_comp_unit
= info_ptr
;
4736 if (per_cu
->cu
== NULL
)
4738 cu
= xmalloc (sizeof (*cu
));
4739 init_one_comp_unit (cu
, objfile
);
4743 /* If an error occurs while loading, release our storage. */
4744 free_cu_cleanup
= make_cleanup (free_one_comp_unit
, cu
);
4746 /* Read in the comp_unit header. */
4747 info_ptr
= read_comp_unit_head (&cu
->header
, info_ptr
, abfd
);
4749 /* Skip dummy compilation units. */
4750 if (info_ptr
>= (dwarf2_per_objfile
->info
.buffer
4751 + dwarf2_per_objfile
->info
.size
)
4752 || peek_abbrev_code (abfd
, info_ptr
) == 0)
4754 do_cleanups (free_cu_cleanup
);
4758 /* Complete the cu_header. */
4759 cu
->header
.offset
= offset
;
4760 cu
->header
.first_die_offset
= info_ptr
- beg_of_comp_unit
;
4762 /* Read the abbrevs for this compilation unit. */
4763 dwarf2_read_abbrevs (abfd
, cu
);
4764 free_abbrevs_cleanup
= make_cleanup (dwarf2_free_abbrev_table
, cu
);
4766 /* Link this compilation unit into the compilation unit tree. */
4768 cu
->per_cu
= per_cu
;
4770 /* Link this CU into read_in_chain. */
4771 per_cu
->cu
->read_in_chain
= dwarf2_per_objfile
->read_in_chain
;
4772 dwarf2_per_objfile
->read_in_chain
= per_cu
;
4777 info_ptr
+= cu
->header
.first_die_offset
;
4780 cu
->dies
= read_comp_unit (info_ptr
, cu
);
4782 /* We try not to read any attributes in this function, because not
4783 all objfiles needed for references have been loaded yet, and symbol
4784 table processing isn't initialized. But we have to set the CU language,
4785 or we won't be able to build types correctly. */
4786 prepare_one_comp_unit (cu
, cu
->dies
);
4788 /* Similarly, if we do not read the producer, we can not apply
4789 producer-specific interpretation. */
4790 attr
= dwarf2_attr (cu
->dies
, DW_AT_producer
, cu
);
4792 cu
->producer
= DW_STRING (attr
);
4796 do_cleanups (free_abbrevs_cleanup
);
4798 /* We've successfully allocated this compilation unit. Let our
4799 caller clean it up when finished with it. */
4800 discard_cleanups (free_cu_cleanup
);
4804 /* Add a DIE to the delayed physname list. */
4807 add_to_method_list (struct type
*type
, int fnfield_index
, int index
,
4808 const char *name
, struct die_info
*die
,
4809 struct dwarf2_cu
*cu
)
4811 struct delayed_method_info mi
;
4813 mi
.fnfield_index
= fnfield_index
;
4817 VEC_safe_push (delayed_method_info
, cu
->method_list
, &mi
);
4820 /* A cleanup for freeing the delayed method list. */
4823 free_delayed_list (void *ptr
)
4825 struct dwarf2_cu
*cu
= (struct dwarf2_cu
*) ptr
;
4826 if (cu
->method_list
!= NULL
)
4828 VEC_free (delayed_method_info
, cu
->method_list
);
4829 cu
->method_list
= NULL
;
4833 /* Compute the physnames of any methods on the CU's method list.
4835 The computation of method physnames is delayed in order to avoid the
4836 (bad) condition that one of the method's formal parameters is of an as yet
4840 compute_delayed_physnames (struct dwarf2_cu
*cu
)
4843 struct delayed_method_info
*mi
;
4844 for (i
= 0; VEC_iterate (delayed_method_info
, cu
->method_list
, i
, mi
) ; ++i
)
4846 const char *physname
;
4847 struct fn_fieldlist
*fn_flp
4848 = &TYPE_FN_FIELDLIST (mi
->type
, mi
->fnfield_index
);
4849 physname
= dwarf2_physname ((char *) mi
->name
, mi
->die
, cu
);
4850 fn_flp
->fn_fields
[mi
->index
].physname
= physname
? physname
: "";
4854 /* Generate full symbol information for PST and CU, whose DIEs have
4855 already been loaded into memory. */
4858 process_full_comp_unit (struct dwarf2_per_cu_data
*per_cu
)
4860 struct dwarf2_cu
*cu
= per_cu
->cu
;
4861 struct objfile
*objfile
= per_cu
->objfile
;
4862 CORE_ADDR lowpc
, highpc
;
4863 struct symtab
*symtab
;
4864 struct cleanup
*back_to
, *delayed_list_cleanup
;
4867 baseaddr
= ANOFFSET (objfile
->section_offsets
, SECT_OFF_TEXT (objfile
));
4870 back_to
= make_cleanup (really_free_pendings
, NULL
);
4871 delayed_list_cleanup
= make_cleanup (free_delayed_list
, cu
);
4873 cu
->list_in_scope
= &file_symbols
;
4875 /* Do line number decoding in read_file_scope () */
4876 process_die (cu
->dies
, cu
);
4878 /* Now that we have processed all the DIEs in the CU, all the types
4879 should be complete, and it should now be safe to compute all of the
4881 compute_delayed_physnames (cu
);
4882 do_cleanups (delayed_list_cleanup
);
4884 /* Some compilers don't define a DW_AT_high_pc attribute for the
4885 compilation unit. If the DW_AT_high_pc is missing, synthesize
4886 it, by scanning the DIE's below the compilation unit. */
4887 get_scope_pc_bounds (cu
->dies
, &lowpc
, &highpc
, cu
);
4889 symtab
= end_symtab (highpc
+ baseaddr
, objfile
, SECT_OFF_TEXT (objfile
));
4893 int gcc_4_minor
= producer_is_gcc_ge_4 (cu
->producer
);
4895 /* Set symtab language to language from DW_AT_language. If the
4896 compilation is from a C file generated by language preprocessors, do
4897 not set the language if it was already deduced by start_subfile. */
4898 if (!(cu
->language
== language_c
&& symtab
->language
!= language_c
))
4899 symtab
->language
= cu
->language
;
4901 /* GCC-4.0 has started to support -fvar-tracking. GCC-3.x still can
4902 produce DW_AT_location with location lists but it can be possibly
4903 invalid without -fvar-tracking.
4905 For -gdwarf-4 type units LOCATIONS_VALID indication is fortunately not
4906 needed, it would be wrong due to missing DW_AT_producer there.
4908 Still one can confuse GDB by using non-standard GCC compilation
4909 options - this waits on GCC PR other/32998 (-frecord-gcc-switches).
4911 if (cu
->has_loclist
&& gcc_4_minor
>= 0)
4912 symtab
->locations_valid
= 1;
4914 if (gcc_4_minor
>= 5)
4915 symtab
->epilogue_unwind_valid
= 1;
4917 symtab
->call_site_htab
= cu
->call_site_htab
;
4920 if (dwarf2_per_objfile
->using_index
)
4921 per_cu
->v
.quick
->symtab
= symtab
;
4924 struct partial_symtab
*pst
= per_cu
->v
.psymtab
;
4925 pst
->symtab
= symtab
;
4929 do_cleanups (back_to
);
4932 /* Process a die and its children. */
4935 process_die (struct die_info
*die
, struct dwarf2_cu
*cu
)
4939 case DW_TAG_padding
:
4941 case DW_TAG_compile_unit
:
4942 read_file_scope (die
, cu
);
4944 case DW_TAG_type_unit
:
4945 read_type_unit_scope (die
, cu
);
4947 case DW_TAG_subprogram
:
4948 case DW_TAG_inlined_subroutine
:
4949 read_func_scope (die
, cu
);
4951 case DW_TAG_lexical_block
:
4952 case DW_TAG_try_block
:
4953 case DW_TAG_catch_block
:
4954 read_lexical_block_scope (die
, cu
);
4956 case DW_TAG_GNU_call_site
:
4957 read_call_site_scope (die
, cu
);
4959 case DW_TAG_class_type
:
4960 case DW_TAG_interface_type
:
4961 case DW_TAG_structure_type
:
4962 case DW_TAG_union_type
:
4963 process_structure_scope (die
, cu
);
4965 case DW_TAG_enumeration_type
:
4966 process_enumeration_scope (die
, cu
);
4969 /* These dies have a type, but processing them does not create
4970 a symbol or recurse to process the children. Therefore we can
4971 read them on-demand through read_type_die. */
4972 case DW_TAG_subroutine_type
:
4973 case DW_TAG_set_type
:
4974 case DW_TAG_array_type
:
4975 case DW_TAG_pointer_type
:
4976 case DW_TAG_ptr_to_member_type
:
4977 case DW_TAG_reference_type
:
4978 case DW_TAG_string_type
:
4981 case DW_TAG_base_type
:
4982 case DW_TAG_subrange_type
:
4983 case DW_TAG_typedef
:
4984 /* Add a typedef symbol for the type definition, if it has a
4986 new_symbol (die
, read_type_die (die
, cu
), cu
);
4988 case DW_TAG_common_block
:
4989 read_common_block (die
, cu
);
4991 case DW_TAG_common_inclusion
:
4993 case DW_TAG_namespace
:
4994 processing_has_namespace_info
= 1;
4995 read_namespace (die
, cu
);
4998 processing_has_namespace_info
= 1;
4999 read_module (die
, cu
);
5001 case DW_TAG_imported_declaration
:
5002 case DW_TAG_imported_module
:
5003 processing_has_namespace_info
= 1;
5004 if (die
->child
!= NULL
&& (die
->tag
== DW_TAG_imported_declaration
5005 || cu
->language
!= language_fortran
))
5006 complaint (&symfile_complaints
, _("Tag '%s' has unexpected children"),
5007 dwarf_tag_name (die
->tag
));
5008 read_import_statement (die
, cu
);
5011 new_symbol (die
, NULL
, cu
);
5016 /* A helper function for dwarf2_compute_name which determines whether DIE
5017 needs to have the name of the scope prepended to the name listed in the
5021 die_needs_namespace (struct die_info
*die
, struct dwarf2_cu
*cu
)
5023 struct attribute
*attr
;
5027 case DW_TAG_namespace
:
5028 case DW_TAG_typedef
:
5029 case DW_TAG_class_type
:
5030 case DW_TAG_interface_type
:
5031 case DW_TAG_structure_type
:
5032 case DW_TAG_union_type
:
5033 case DW_TAG_enumeration_type
:
5034 case DW_TAG_enumerator
:
5035 case DW_TAG_subprogram
:
5039 case DW_TAG_variable
:
5040 case DW_TAG_constant
:
5041 /* We only need to prefix "globally" visible variables. These include
5042 any variable marked with DW_AT_external or any variable that
5043 lives in a namespace. [Variables in anonymous namespaces
5044 require prefixing, but they are not DW_AT_external.] */
5046 if (dwarf2_attr (die
, DW_AT_specification
, cu
))
5048 struct dwarf2_cu
*spec_cu
= cu
;
5050 return die_needs_namespace (die_specification (die
, &spec_cu
),
5054 attr
= dwarf2_attr (die
, DW_AT_external
, cu
);
5055 if (attr
== NULL
&& die
->parent
->tag
!= DW_TAG_namespace
5056 && die
->parent
->tag
!= DW_TAG_module
)
5058 /* A variable in a lexical block of some kind does not need a
5059 namespace, even though in C++ such variables may be external
5060 and have a mangled name. */
5061 if (die
->parent
->tag
== DW_TAG_lexical_block
5062 || die
->parent
->tag
== DW_TAG_try_block
5063 || die
->parent
->tag
== DW_TAG_catch_block
5064 || die
->parent
->tag
== DW_TAG_subprogram
)
5073 /* Retrieve the last character from a mem_file. */
5076 do_ui_file_peek_last (void *object
, const char *buffer
, long length
)
5078 char *last_char_p
= (char *) object
;
5081 *last_char_p
= buffer
[length
- 1];
5084 /* Compute the fully qualified name of DIE in CU. If PHYSNAME is nonzero,
5085 compute the physname for the object, which include a method's
5086 formal parameters (C++/Java) and return type (Java).
5088 For Ada, return the DIE's linkage name rather than the fully qualified
5089 name. PHYSNAME is ignored..
5091 The result is allocated on the objfile_obstack and canonicalized. */
5094 dwarf2_compute_name (char *name
, struct die_info
*die
, struct dwarf2_cu
*cu
,
5098 name
= dwarf2_name (die
, cu
);
5100 /* For Fortran GDB prefers DW_AT_*linkage_name if present but otherwise
5101 compute it by typename_concat inside GDB. */
5102 if (cu
->language
== language_ada
5103 || (cu
->language
== language_fortran
&& physname
))
5105 /* For Ada unit, we prefer the linkage name over the name, as
5106 the former contains the exported name, which the user expects
5107 to be able to reference. Ideally, we want the user to be able
5108 to reference this entity using either natural or linkage name,
5109 but we haven't started looking at this enhancement yet. */
5110 struct attribute
*attr
;
5112 attr
= dwarf2_attr (die
, DW_AT_linkage_name
, cu
);
5114 attr
= dwarf2_attr (die
, DW_AT_MIPS_linkage_name
, cu
);
5115 if (attr
&& DW_STRING (attr
))
5116 return DW_STRING (attr
);
5119 /* These are the only languages we know how to qualify names in. */
5121 && (cu
->language
== language_cplus
|| cu
->language
== language_java
5122 || cu
->language
== language_fortran
))
5124 if (die_needs_namespace (die
, cu
))
5128 struct ui_file
*buf
;
5130 prefix
= determine_prefix (die
, cu
);
5131 buf
= mem_fileopen ();
5132 if (*prefix
!= '\0')
5134 char *prefixed_name
= typename_concat (NULL
, prefix
, name
,
5137 fputs_unfiltered (prefixed_name
, buf
);
5138 xfree (prefixed_name
);
5141 fputs_unfiltered (name
, buf
);
5143 /* Template parameters may be specified in the DIE's DW_AT_name, or
5144 as children with DW_TAG_template_type_param or
5145 DW_TAG_value_type_param. If the latter, add them to the name
5146 here. If the name already has template parameters, then
5147 skip this step; some versions of GCC emit both, and
5148 it is more efficient to use the pre-computed name.
5150 Something to keep in mind about this process: it is very
5151 unlikely, or in some cases downright impossible, to produce
5152 something that will match the mangled name of a function.
5153 If the definition of the function has the same debug info,
5154 we should be able to match up with it anyway. But fallbacks
5155 using the minimal symbol, for instance to find a method
5156 implemented in a stripped copy of libstdc++, will not work.
5157 If we do not have debug info for the definition, we will have to
5158 match them up some other way.
5160 When we do name matching there is a related problem with function
5161 templates; two instantiated function templates are allowed to
5162 differ only by their return types, which we do not add here. */
5164 if (cu
->language
== language_cplus
&& strchr (name
, '<') == NULL
)
5166 struct attribute
*attr
;
5167 struct die_info
*child
;
5170 die
->building_fullname
= 1;
5172 for (child
= die
->child
; child
!= NULL
; child
= child
->sibling
)
5177 struct dwarf2_locexpr_baton
*baton
;
5180 if (child
->tag
!= DW_TAG_template_type_param
5181 && child
->tag
!= DW_TAG_template_value_param
)
5186 fputs_unfiltered ("<", buf
);
5190 fputs_unfiltered (", ", buf
);
5192 attr
= dwarf2_attr (child
, DW_AT_type
, cu
);
5195 complaint (&symfile_complaints
,
5196 _("template parameter missing DW_AT_type"));
5197 fputs_unfiltered ("UNKNOWN_TYPE", buf
);
5200 type
= die_type (child
, cu
);
5202 if (child
->tag
== DW_TAG_template_type_param
)
5204 c_print_type (type
, "", buf
, -1, 0);
5208 attr
= dwarf2_attr (child
, DW_AT_const_value
, cu
);
5211 complaint (&symfile_complaints
,
5212 _("template parameter missing "
5213 "DW_AT_const_value"));
5214 fputs_unfiltered ("UNKNOWN_VALUE", buf
);
5218 dwarf2_const_value_attr (attr
, type
, name
,
5219 &cu
->comp_unit_obstack
, cu
,
5220 &value
, &bytes
, &baton
);
5222 if (TYPE_NOSIGN (type
))
5223 /* GDB prints characters as NUMBER 'CHAR'. If that's
5224 changed, this can use value_print instead. */
5225 c_printchar (value
, type
, buf
);
5228 struct value_print_options opts
;
5231 v
= dwarf2_evaluate_loc_desc (type
, NULL
,
5235 else if (bytes
!= NULL
)
5237 v
= allocate_value (type
);
5238 memcpy (value_contents_writeable (v
), bytes
,
5239 TYPE_LENGTH (type
));
5242 v
= value_from_longest (type
, value
);
5244 /* Specify decimal so that we do not depend on
5246 get_formatted_print_options (&opts
, 'd');
5248 value_print (v
, buf
, &opts
);
5254 die
->building_fullname
= 0;
5258 /* Close the argument list, with a space if necessary
5259 (nested templates). */
5260 char last_char
= '\0';
5261 ui_file_put (buf
, do_ui_file_peek_last
, &last_char
);
5262 if (last_char
== '>')
5263 fputs_unfiltered (" >", buf
);
5265 fputs_unfiltered (">", buf
);
5269 /* For Java and C++ methods, append formal parameter type
5270 information, if PHYSNAME. */
5272 if (physname
&& die
->tag
== DW_TAG_subprogram
5273 && (cu
->language
== language_cplus
5274 || cu
->language
== language_java
))
5276 struct type
*type
= read_type_die (die
, cu
);
5278 c_type_print_args (type
, buf
, 1, cu
->language
);
5280 if (cu
->language
== language_java
)
5282 /* For java, we must append the return type to method
5284 if (die
->tag
== DW_TAG_subprogram
)
5285 java_print_type (TYPE_TARGET_TYPE (type
), "", buf
,
5288 else if (cu
->language
== language_cplus
)
5290 /* Assume that an artificial first parameter is
5291 "this", but do not crash if it is not. RealView
5292 marks unnamed (and thus unused) parameters as
5293 artificial; there is no way to differentiate
5295 if (TYPE_NFIELDS (type
) > 0
5296 && TYPE_FIELD_ARTIFICIAL (type
, 0)
5297 && TYPE_CODE (TYPE_FIELD_TYPE (type
, 0)) == TYPE_CODE_PTR
5298 && TYPE_CONST (TYPE_TARGET_TYPE (TYPE_FIELD_TYPE (type
,
5300 fputs_unfiltered (" const", buf
);
5304 name
= ui_file_obsavestring (buf
, &cu
->objfile
->objfile_obstack
,
5306 ui_file_delete (buf
);
5308 if (cu
->language
== language_cplus
)
5311 = dwarf2_canonicalize_name (name
, cu
,
5312 &cu
->objfile
->objfile_obstack
);
5323 /* Return the fully qualified name of DIE, based on its DW_AT_name.
5324 If scope qualifiers are appropriate they will be added. The result
5325 will be allocated on the objfile_obstack, or NULL if the DIE does
5326 not have a name. NAME may either be from a previous call to
5327 dwarf2_name or NULL.
5329 The output string will be canonicalized (if C++/Java). */
5332 dwarf2_full_name (char *name
, struct die_info
*die
, struct dwarf2_cu
*cu
)
5334 return dwarf2_compute_name (name
, die
, cu
, 0);
5337 /* Construct a physname for the given DIE in CU. NAME may either be
5338 from a previous call to dwarf2_name or NULL. The result will be
5339 allocated on the objfile_objstack or NULL if the DIE does not have a
5342 The output string will be canonicalized (if C++/Java). */
5345 dwarf2_physname (char *name
, struct die_info
*die
, struct dwarf2_cu
*cu
)
5347 struct attribute
*attr
;
5348 const char *retval
, *mangled
= NULL
, *canon
= NULL
;
5349 struct cleanup
*back_to
;
5352 /* In this case dwarf2_compute_name is just a shortcut not building anything
5354 if (!die_needs_namespace (die
, cu
))
5355 return dwarf2_compute_name (name
, die
, cu
, 1);
5357 back_to
= make_cleanup (null_cleanup
, NULL
);
5359 attr
= dwarf2_attr (die
, DW_AT_linkage_name
, cu
);
5361 attr
= dwarf2_attr (die
, DW_AT_MIPS_linkage_name
, cu
);
5363 /* DW_AT_linkage_name is missing in some cases - depend on what GDB
5365 if (attr
&& DW_STRING (attr
))
5369 mangled
= DW_STRING (attr
);
5371 /* Use DMGL_RET_DROP for C++ template functions to suppress their return
5372 type. It is easier for GDB users to search for such functions as
5373 `name(params)' than `long name(params)'. In such case the minimal
5374 symbol names do not match the full symbol names but for template
5375 functions there is never a need to look up their definition from their
5376 declaration so the only disadvantage remains the minimal symbol
5377 variant `long name(params)' does not have the proper inferior type.
5380 demangled
= cplus_demangle (mangled
, (DMGL_PARAMS
| DMGL_ANSI
5381 | (cu
->language
== language_java
5382 ? DMGL_JAVA
| DMGL_RET_POSTFIX
5386 make_cleanup (xfree
, demangled
);
5396 if (canon
== NULL
|| check_physname
)
5398 const char *physname
= dwarf2_compute_name (name
, die
, cu
, 1);
5400 if (canon
!= NULL
&& strcmp (physname
, canon
) != 0)
5402 /* It may not mean a bug in GDB. The compiler could also
5403 compute DW_AT_linkage_name incorrectly. But in such case
5404 GDB would need to be bug-to-bug compatible. */
5406 complaint (&symfile_complaints
,
5407 _("Computed physname <%s> does not match demangled <%s> "
5408 "(from linkage <%s>) - DIE at 0x%x [in module %s]"),
5409 physname
, canon
, mangled
, die
->offset
, cu
->objfile
->name
);
5411 /* Prefer DW_AT_linkage_name (in the CANON form) - when it
5412 is available here - over computed PHYSNAME. It is safer
5413 against both buggy GDB and buggy compilers. */
5427 retval
= obsavestring (retval
, strlen (retval
),
5428 &cu
->objfile
->objfile_obstack
);
5430 do_cleanups (back_to
);
5434 /* Read the import statement specified by the given die and record it. */
5437 read_import_statement (struct die_info
*die
, struct dwarf2_cu
*cu
)
5439 struct attribute
*import_attr
;
5440 struct die_info
*imported_die
, *child_die
;
5441 struct dwarf2_cu
*imported_cu
;
5442 const char *imported_name
;
5443 const char *imported_name_prefix
;
5444 const char *canonical_name
;
5445 const char *import_alias
;
5446 const char *imported_declaration
= NULL
;
5447 const char *import_prefix
;
5448 VEC (const_char_ptr
) *excludes
= NULL
;
5449 struct cleanup
*cleanups
;
5453 import_attr
= dwarf2_attr (die
, DW_AT_import
, cu
);
5454 if (import_attr
== NULL
)
5456 complaint (&symfile_complaints
, _("Tag '%s' has no DW_AT_import"),
5457 dwarf_tag_name (die
->tag
));
5462 imported_die
= follow_die_ref_or_sig (die
, import_attr
, &imported_cu
);
5463 imported_name
= dwarf2_name (imported_die
, imported_cu
);
5464 if (imported_name
== NULL
)
5466 /* GCC bug: https://bugzilla.redhat.com/show_bug.cgi?id=506524
5468 The import in the following code:
5482 <2><51>: Abbrev Number: 3 (DW_TAG_imported_declaration)
5483 <52> DW_AT_decl_file : 1
5484 <53> DW_AT_decl_line : 6
5485 <54> DW_AT_import : <0x75>
5486 <2><58>: Abbrev Number: 4 (DW_TAG_typedef)
5488 <5b> DW_AT_decl_file : 1
5489 <5c> DW_AT_decl_line : 2
5490 <5d> DW_AT_type : <0x6e>
5492 <1><75>: Abbrev Number: 7 (DW_TAG_base_type)
5493 <76> DW_AT_byte_size : 4
5494 <77> DW_AT_encoding : 5 (signed)
5496 imports the wrong die ( 0x75 instead of 0x58 ).
5497 This case will be ignored until the gcc bug is fixed. */
5501 /* Figure out the local name after import. */
5502 import_alias
= dwarf2_name (die
, cu
);
5504 /* Figure out where the statement is being imported to. */
5505 import_prefix
= determine_prefix (die
, cu
);
5507 /* Figure out what the scope of the imported die is and prepend it
5508 to the name of the imported die. */
5509 imported_name_prefix
= determine_prefix (imported_die
, imported_cu
);
5511 if (imported_die
->tag
!= DW_TAG_namespace
5512 && imported_die
->tag
!= DW_TAG_module
)
5514 imported_declaration
= imported_name
;
5515 canonical_name
= imported_name_prefix
;
5517 else if (strlen (imported_name_prefix
) > 0)
5519 temp
= alloca (strlen (imported_name_prefix
)
5520 + 2 + strlen (imported_name
) + 1);
5521 strcpy (temp
, imported_name_prefix
);
5522 strcat (temp
, "::");
5523 strcat (temp
, imported_name
);
5524 canonical_name
= temp
;
5527 canonical_name
= imported_name
;
5529 cleanups
= make_cleanup (VEC_cleanup (const_char_ptr
), &excludes
);
5531 if (die
->tag
== DW_TAG_imported_module
&& cu
->language
== language_fortran
)
5532 for (child_die
= die
->child
; child_die
&& child_die
->tag
;
5533 child_die
= sibling_die (child_die
))
5535 /* DWARF-4: A Fortran use statement with a “rename list” may be
5536 represented by an imported module entry with an import attribute
5537 referring to the module and owned entries corresponding to those
5538 entities that are renamed as part of being imported. */
5540 if (child_die
->tag
!= DW_TAG_imported_declaration
)
5542 complaint (&symfile_complaints
,
5543 _("child DW_TAG_imported_declaration expected "
5544 "- DIE at 0x%x [in module %s]"),
5545 child_die
->offset
, cu
->objfile
->name
);
5549 import_attr
= dwarf2_attr (child_die
, DW_AT_import
, cu
);
5550 if (import_attr
== NULL
)
5552 complaint (&symfile_complaints
, _("Tag '%s' has no DW_AT_import"),
5553 dwarf_tag_name (child_die
->tag
));
5558 imported_die
= follow_die_ref_or_sig (child_die
, import_attr
,
5560 imported_name
= dwarf2_name (imported_die
, imported_cu
);
5561 if (imported_name
== NULL
)
5563 complaint (&symfile_complaints
,
5564 _("child DW_TAG_imported_declaration has unknown "
5565 "imported name - DIE at 0x%x [in module %s]"),
5566 child_die
->offset
, cu
->objfile
->name
);
5570 VEC_safe_push (const_char_ptr
, excludes
, imported_name
);
5572 process_die (child_die
, cu
);
5575 cp_add_using_directive (import_prefix
,
5578 imported_declaration
,
5580 &cu
->objfile
->objfile_obstack
);
5582 do_cleanups (cleanups
);
5586 initialize_cu_func_list (struct dwarf2_cu
*cu
)
5588 cu
->first_fn
= cu
->last_fn
= cu
->cached_fn
= NULL
;
5591 /* Cleanup function for read_file_scope. */
5594 free_cu_line_header (void *arg
)
5596 struct dwarf2_cu
*cu
= arg
;
5598 free_line_header (cu
->line_header
);
5599 cu
->line_header
= NULL
;
5603 find_file_and_directory (struct die_info
*die
, struct dwarf2_cu
*cu
,
5604 char **name
, char **comp_dir
)
5606 struct attribute
*attr
;
5611 /* Find the filename. Do not use dwarf2_name here, since the filename
5612 is not a source language identifier. */
5613 attr
= dwarf2_attr (die
, DW_AT_name
, cu
);
5616 *name
= DW_STRING (attr
);
5619 attr
= dwarf2_attr (die
, DW_AT_comp_dir
, cu
);
5621 *comp_dir
= DW_STRING (attr
);
5622 else if (*name
!= NULL
&& IS_ABSOLUTE_PATH (*name
))
5624 *comp_dir
= ldirname (*name
);
5625 if (*comp_dir
!= NULL
)
5626 make_cleanup (xfree
, *comp_dir
);
5628 if (*comp_dir
!= NULL
)
5630 /* Irix 6.2 native cc prepends <machine>.: to the compilation
5631 directory, get rid of it. */
5632 char *cp
= strchr (*comp_dir
, ':');
5634 if (cp
&& cp
!= *comp_dir
&& cp
[-1] == '.' && cp
[1] == '/')
5639 *name
= "<unknown>";
5642 /* Handle DW_AT_stmt_list for a compilation unit. */
5645 handle_DW_AT_stmt_list (struct die_info
*die
, struct dwarf2_cu
*cu
,
5646 const char *comp_dir
)
5648 struct attribute
*attr
;
5649 struct objfile
*objfile
= cu
->objfile
;
5650 bfd
*abfd
= objfile
->obfd
;
5652 /* Decode line number information if present. We do this before
5653 processing child DIEs, so that the line header table is available
5654 for DW_AT_decl_file. */
5655 attr
= dwarf2_attr (die
, DW_AT_stmt_list
, cu
);
5658 unsigned int line_offset
= DW_UNSND (attr
);
5659 struct line_header
*line_header
5660 = dwarf_decode_line_header (line_offset
, abfd
, cu
);
5664 cu
->line_header
= line_header
;
5665 make_cleanup (free_cu_line_header
, cu
);
5666 dwarf_decode_lines (line_header
, comp_dir
, abfd
, cu
, NULL
);
5671 /* Process DW_TAG_compile_unit. */
5674 read_file_scope (struct die_info
*die
, struct dwarf2_cu
*cu
)
5676 struct objfile
*objfile
= cu
->objfile
;
5677 struct cleanup
*back_to
= make_cleanup (null_cleanup
, 0);
5678 CORE_ADDR lowpc
= ((CORE_ADDR
) -1);
5679 CORE_ADDR highpc
= ((CORE_ADDR
) 0);
5680 struct attribute
*attr
;
5682 char *comp_dir
= NULL
;
5683 struct die_info
*child_die
;
5684 bfd
*abfd
= objfile
->obfd
;
5687 baseaddr
= ANOFFSET (objfile
->section_offsets
, SECT_OFF_TEXT (objfile
));
5689 get_scope_pc_bounds (die
, &lowpc
, &highpc
, cu
);
5691 /* If we didn't find a lowpc, set it to highpc to avoid complaints
5692 from finish_block. */
5693 if (lowpc
== ((CORE_ADDR
) -1))
5698 find_file_and_directory (die
, cu
, &name
, &comp_dir
);
5700 attr
= dwarf2_attr (die
, DW_AT_language
, cu
);
5703 set_cu_language (DW_UNSND (attr
), cu
);
5706 attr
= dwarf2_attr (die
, DW_AT_producer
, cu
);
5708 cu
->producer
= DW_STRING (attr
);
5710 /* The XLCL doesn't generate DW_LANG_OpenCL because this attribute is not
5711 standardised yet. As a workaround for the language detection we fall
5712 back to the DW_AT_producer string. */
5713 if (cu
->producer
&& strstr (cu
->producer
, "IBM XL C for OpenCL") != NULL
)
5714 cu
->language
= language_opencl
;
5716 /* We assume that we're processing GCC output. */
5717 processing_gcc_compilation
= 2;
5719 processing_has_namespace_info
= 0;
5721 start_symtab (name
, comp_dir
, lowpc
);
5722 record_debugformat ("DWARF 2");
5723 record_producer (cu
->producer
);
5725 initialize_cu_func_list (cu
);
5727 handle_DW_AT_stmt_list (die
, cu
, comp_dir
);
5729 /* Process all dies in compilation unit. */
5730 if (die
->child
!= NULL
)
5732 child_die
= die
->child
;
5733 while (child_die
&& child_die
->tag
)
5735 process_die (child_die
, cu
);
5736 child_die
= sibling_die (child_die
);
5740 /* Decode macro information, if present. Dwarf 2 macro information
5741 refers to information in the line number info statement program
5742 header, so we can only read it if we've read the header
5744 attr
= dwarf2_attr (die
, DW_AT_GNU_macros
, cu
);
5745 if (attr
&& cu
->line_header
)
5747 if (dwarf2_attr (die
, DW_AT_macro_info
, cu
))
5748 complaint (&symfile_complaints
,
5749 _("CU refers to both DW_AT_GNU_macros and DW_AT_macro_info"));
5751 dwarf_decode_macros (cu
->line_header
, DW_UNSND (attr
),
5753 &dwarf2_per_objfile
->macro
, 1);
5757 attr
= dwarf2_attr (die
, DW_AT_macro_info
, cu
);
5758 if (attr
&& cu
->line_header
)
5760 unsigned int macro_offset
= DW_UNSND (attr
);
5762 dwarf_decode_macros (cu
->line_header
, macro_offset
,
5764 &dwarf2_per_objfile
->macinfo
, 0);
5767 do_cleanups (back_to
);
5770 /* Process DW_TAG_type_unit.
5771 For TUs we want to skip the first top level sibling if it's not the
5772 actual type being defined by this TU. In this case the first top
5773 level sibling is there to provide context only. */
5776 read_type_unit_scope (struct die_info
*die
, struct dwarf2_cu
*cu
)
5778 struct objfile
*objfile
= cu
->objfile
;
5779 struct cleanup
*back_to
= make_cleanup (null_cleanup
, 0);
5781 struct attribute
*attr
;
5783 char *comp_dir
= NULL
;
5784 struct die_info
*child_die
;
5785 bfd
*abfd
= objfile
->obfd
;
5787 /* start_symtab needs a low pc, but we don't really have one.
5788 Do what read_file_scope would do in the absence of such info. */
5789 lowpc
= ANOFFSET (objfile
->section_offsets
, SECT_OFF_TEXT (objfile
));
5791 /* Find the filename. Do not use dwarf2_name here, since the filename
5792 is not a source language identifier. */
5793 attr
= dwarf2_attr (die
, DW_AT_name
, cu
);
5795 name
= DW_STRING (attr
);
5797 attr
= dwarf2_attr (die
, DW_AT_comp_dir
, cu
);
5799 comp_dir
= DW_STRING (attr
);
5800 else if (name
!= NULL
&& IS_ABSOLUTE_PATH (name
))
5802 comp_dir
= ldirname (name
);
5803 if (comp_dir
!= NULL
)
5804 make_cleanup (xfree
, comp_dir
);
5810 attr
= dwarf2_attr (die
, DW_AT_language
, cu
);
5812 set_cu_language (DW_UNSND (attr
), cu
);
5814 /* This isn't technically needed today. It is done for symmetry
5815 with read_file_scope. */
5816 attr
= dwarf2_attr (die
, DW_AT_producer
, cu
);
5818 cu
->producer
= DW_STRING (attr
);
5820 /* We assume that we're processing GCC output. */
5821 processing_gcc_compilation
= 2;
5823 processing_has_namespace_info
= 0;
5825 start_symtab (name
, comp_dir
, lowpc
);
5826 record_debugformat ("DWARF 2");
5827 record_producer (cu
->producer
);
5829 handle_DW_AT_stmt_list (die
, cu
, comp_dir
);
5831 /* Process the dies in the type unit. */
5832 if (die
->child
== NULL
)
5834 dump_die_for_error (die
);
5835 error (_("Dwarf Error: Missing children for type unit [in module %s]"),
5836 bfd_get_filename (abfd
));
5839 child_die
= die
->child
;
5841 while (child_die
&& child_die
->tag
)
5843 process_die (child_die
, cu
);
5845 child_die
= sibling_die (child_die
);
5848 do_cleanups (back_to
);
5852 add_to_cu_func_list (const char *name
, CORE_ADDR lowpc
, CORE_ADDR highpc
,
5853 struct dwarf2_cu
*cu
)
5855 struct function_range
*thisfn
;
5857 thisfn
= (struct function_range
*)
5858 obstack_alloc (&cu
->comp_unit_obstack
, sizeof (struct function_range
));
5859 thisfn
->name
= name
;
5860 thisfn
->lowpc
= lowpc
;
5861 thisfn
->highpc
= highpc
;
5862 thisfn
->seen_line
= 0;
5863 thisfn
->next
= NULL
;
5865 if (cu
->last_fn
== NULL
)
5866 cu
->first_fn
= thisfn
;
5868 cu
->last_fn
->next
= thisfn
;
5870 cu
->last_fn
= thisfn
;
5873 /* qsort helper for inherit_abstract_dies. */
5876 unsigned_int_compar (const void *ap
, const void *bp
)
5878 unsigned int a
= *(unsigned int *) ap
;
5879 unsigned int b
= *(unsigned int *) bp
;
5881 return (a
> b
) - (b
> a
);
5884 /* DW_AT_abstract_origin inherits whole DIEs (not just their attributes).
5885 Inherit only the children of the DW_AT_abstract_origin DIE not being
5886 already referenced by DW_AT_abstract_origin from the children of the
5890 inherit_abstract_dies (struct die_info
*die
, struct dwarf2_cu
*cu
)
5892 struct die_info
*child_die
;
5893 unsigned die_children_count
;
5894 /* CU offsets which were referenced by children of the current DIE. */
5896 unsigned *offsets_end
, *offsetp
;
5897 /* Parent of DIE - referenced by DW_AT_abstract_origin. */
5898 struct die_info
*origin_die
;
5899 /* Iterator of the ORIGIN_DIE children. */
5900 struct die_info
*origin_child_die
;
5901 struct cleanup
*cleanups
;
5902 struct attribute
*attr
;
5903 struct dwarf2_cu
*origin_cu
;
5904 struct pending
**origin_previous_list_in_scope
;
5906 attr
= dwarf2_attr (die
, DW_AT_abstract_origin
, cu
);
5910 /* Note that following die references may follow to a die in a
5914 origin_die
= follow_die_ref (die
, attr
, &origin_cu
);
5916 /* We're inheriting ORIGIN's children into the scope we'd put DIE's
5918 origin_previous_list_in_scope
= origin_cu
->list_in_scope
;
5919 origin_cu
->list_in_scope
= cu
->list_in_scope
;
5921 if (die
->tag
!= origin_die
->tag
5922 && !(die
->tag
== DW_TAG_inlined_subroutine
5923 && origin_die
->tag
== DW_TAG_subprogram
))
5924 complaint (&symfile_complaints
,
5925 _("DIE 0x%x and its abstract origin 0x%x have different tags"),
5926 die
->offset
, origin_die
->offset
);
5928 child_die
= die
->child
;
5929 die_children_count
= 0;
5930 while (child_die
&& child_die
->tag
)
5932 child_die
= sibling_die (child_die
);
5933 die_children_count
++;
5935 offsets
= xmalloc (sizeof (*offsets
) * die_children_count
);
5936 cleanups
= make_cleanup (xfree
, offsets
);
5938 offsets_end
= offsets
;
5939 child_die
= die
->child
;
5940 while (child_die
&& child_die
->tag
)
5942 /* For each CHILD_DIE, find the corresponding child of
5943 ORIGIN_DIE. If there is more than one layer of
5944 DW_AT_abstract_origin, follow them all; there shouldn't be,
5945 but GCC versions at least through 4.4 generate this (GCC PR
5947 struct die_info
*child_origin_die
= child_die
;
5948 struct dwarf2_cu
*child_origin_cu
= cu
;
5952 attr
= dwarf2_attr (child_origin_die
, DW_AT_abstract_origin
,
5956 child_origin_die
= follow_die_ref (child_origin_die
, attr
,
5960 /* According to DWARF3 3.3.8.2 #3 new entries without their abstract
5961 counterpart may exist. */
5962 if (child_origin_die
!= child_die
)
5964 if (child_die
->tag
!= child_origin_die
->tag
5965 && !(child_die
->tag
== DW_TAG_inlined_subroutine
5966 && child_origin_die
->tag
== DW_TAG_subprogram
))
5967 complaint (&symfile_complaints
,
5968 _("Child DIE 0x%x and its abstract origin 0x%x have "
5969 "different tags"), child_die
->offset
,
5970 child_origin_die
->offset
);
5971 if (child_origin_die
->parent
!= origin_die
)
5972 complaint (&symfile_complaints
,
5973 _("Child DIE 0x%x and its abstract origin 0x%x have "
5974 "different parents"), child_die
->offset
,
5975 child_origin_die
->offset
);
5977 *offsets_end
++ = child_origin_die
->offset
;
5979 child_die
= sibling_die (child_die
);
5981 qsort (offsets
, offsets_end
- offsets
, sizeof (*offsets
),
5982 unsigned_int_compar
);
5983 for (offsetp
= offsets
+ 1; offsetp
< offsets_end
; offsetp
++)
5984 if (offsetp
[-1] == *offsetp
)
5985 complaint (&symfile_complaints
,
5986 _("Multiple children of DIE 0x%x refer "
5987 "to DIE 0x%x as their abstract origin"),
5988 die
->offset
, *offsetp
);
5991 origin_child_die
= origin_die
->child
;
5992 while (origin_child_die
&& origin_child_die
->tag
)
5994 /* Is ORIGIN_CHILD_DIE referenced by any of the DIE children? */
5995 while (offsetp
< offsets_end
&& *offsetp
< origin_child_die
->offset
)
5997 if (offsetp
>= offsets_end
|| *offsetp
> origin_child_die
->offset
)
5999 /* Found that ORIGIN_CHILD_DIE is really not referenced. */
6000 process_die (origin_child_die
, origin_cu
);
6002 origin_child_die
= sibling_die (origin_child_die
);
6004 origin_cu
->list_in_scope
= origin_previous_list_in_scope
;
6006 do_cleanups (cleanups
);
6010 read_func_scope (struct die_info
*die
, struct dwarf2_cu
*cu
)
6012 struct objfile
*objfile
= cu
->objfile
;
6013 struct context_stack
*new;
6016 struct die_info
*child_die
;
6017 struct attribute
*attr
, *call_line
, *call_file
;
6020 struct block
*block
;
6021 int inlined_func
= (die
->tag
== DW_TAG_inlined_subroutine
);
6022 VEC (symbolp
) *template_args
= NULL
;
6023 struct template_symbol
*templ_func
= NULL
;
6027 /* If we do not have call site information, we can't show the
6028 caller of this inlined function. That's too confusing, so
6029 only use the scope for local variables. */
6030 call_line
= dwarf2_attr (die
, DW_AT_call_line
, cu
);
6031 call_file
= dwarf2_attr (die
, DW_AT_call_file
, cu
);
6032 if (call_line
== NULL
|| call_file
== NULL
)
6034 read_lexical_block_scope (die
, cu
);
6039 baseaddr
= ANOFFSET (objfile
->section_offsets
, SECT_OFF_TEXT (objfile
));
6041 name
= dwarf2_name (die
, cu
);
6043 /* Ignore functions with missing or empty names. These are actually
6044 illegal according to the DWARF standard. */
6047 complaint (&symfile_complaints
,
6048 _("missing name for subprogram DIE at %d"), die
->offset
);
6052 /* Ignore functions with missing or invalid low and high pc attributes. */
6053 if (!dwarf2_get_pc_bounds (die
, &lowpc
, &highpc
, cu
, NULL
))
6055 attr
= dwarf2_attr (die
, DW_AT_external
, cu
);
6056 if (!attr
|| !DW_UNSND (attr
))
6057 complaint (&symfile_complaints
,
6058 _("cannot get low and high bounds "
6059 "for subprogram DIE at %d"),
6067 /* Record the function range for dwarf_decode_lines. */
6068 add_to_cu_func_list (name
, lowpc
, highpc
, cu
);
6070 /* If we have any template arguments, then we must allocate a
6071 different sort of symbol. */
6072 for (child_die
= die
->child
; child_die
; child_die
= sibling_die (child_die
))
6074 if (child_die
->tag
== DW_TAG_template_type_param
6075 || child_die
->tag
== DW_TAG_template_value_param
)
6077 templ_func
= OBSTACK_ZALLOC (&objfile
->objfile_obstack
,
6078 struct template_symbol
);
6079 templ_func
->base
.is_cplus_template_function
= 1;
6084 new = push_context (0, lowpc
);
6085 new->name
= new_symbol_full (die
, read_type_die (die
, cu
), cu
,
6086 (struct symbol
*) templ_func
);
6088 /* If there is a location expression for DW_AT_frame_base, record
6090 attr
= dwarf2_attr (die
, DW_AT_frame_base
, cu
);
6092 /* FIXME: cagney/2004-01-26: The DW_AT_frame_base's location
6093 expression is being recorded directly in the function's symbol
6094 and not in a separate frame-base object. I guess this hack is
6095 to avoid adding some sort of frame-base adjunct/annex to the
6096 function's symbol :-(. The problem with doing this is that it
6097 results in a function symbol with a location expression that
6098 has nothing to do with the location of the function, ouch! The
6099 relationship should be: a function's symbol has-a frame base; a
6100 frame-base has-a location expression. */
6101 dwarf2_symbol_mark_computed (attr
, new->name
, cu
);
6103 cu
->list_in_scope
= &local_symbols
;
6105 if (die
->child
!= NULL
)
6107 child_die
= die
->child
;
6108 while (child_die
&& child_die
->tag
)
6110 if (child_die
->tag
== DW_TAG_template_type_param
6111 || child_die
->tag
== DW_TAG_template_value_param
)
6113 struct symbol
*arg
= new_symbol (child_die
, NULL
, cu
);
6116 VEC_safe_push (symbolp
, template_args
, arg
);
6119 process_die (child_die
, cu
);
6120 child_die
= sibling_die (child_die
);
6124 inherit_abstract_dies (die
, cu
);
6126 /* If we have a DW_AT_specification, we might need to import using
6127 directives from the context of the specification DIE. See the
6128 comment in determine_prefix. */
6129 if (cu
->language
== language_cplus
6130 && dwarf2_attr (die
, DW_AT_specification
, cu
))
6132 struct dwarf2_cu
*spec_cu
= cu
;
6133 struct die_info
*spec_die
= die_specification (die
, &spec_cu
);
6137 child_die
= spec_die
->child
;
6138 while (child_die
&& child_die
->tag
)
6140 if (child_die
->tag
== DW_TAG_imported_module
)
6141 process_die (child_die
, spec_cu
);
6142 child_die
= sibling_die (child_die
);
6145 /* In some cases, GCC generates specification DIEs that
6146 themselves contain DW_AT_specification attributes. */
6147 spec_die
= die_specification (spec_die
, &spec_cu
);
6151 new = pop_context ();
6152 /* Make a block for the local symbols within. */
6153 block
= finish_block (new->name
, &local_symbols
, new->old_blocks
,
6154 lowpc
, highpc
, objfile
);
6156 /* For C++, set the block's scope. */
6157 if (cu
->language
== language_cplus
|| cu
->language
== language_fortran
)
6158 cp_set_block_scope (new->name
, block
, &objfile
->objfile_obstack
,
6159 determine_prefix (die
, cu
),
6160 processing_has_namespace_info
);
6162 /* If we have address ranges, record them. */
6163 dwarf2_record_block_ranges (die
, block
, baseaddr
, cu
);
6165 /* Attach template arguments to function. */
6166 if (! VEC_empty (symbolp
, template_args
))
6168 gdb_assert (templ_func
!= NULL
);
6170 templ_func
->n_template_arguments
= VEC_length (symbolp
, template_args
);
6171 templ_func
->template_arguments
6172 = obstack_alloc (&objfile
->objfile_obstack
,
6173 (templ_func
->n_template_arguments
6174 * sizeof (struct symbol
*)));
6175 memcpy (templ_func
->template_arguments
,
6176 VEC_address (symbolp
, template_args
),
6177 (templ_func
->n_template_arguments
* sizeof (struct symbol
*)));
6178 VEC_free (symbolp
, template_args
);
6181 /* In C++, we can have functions nested inside functions (e.g., when
6182 a function declares a class that has methods). This means that
6183 when we finish processing a function scope, we may need to go
6184 back to building a containing block's symbol lists. */
6185 local_symbols
= new->locals
;
6186 param_symbols
= new->params
;
6187 using_directives
= new->using_directives
;
6189 /* If we've finished processing a top-level function, subsequent
6190 symbols go in the file symbol list. */
6191 if (outermost_context_p ())
6192 cu
->list_in_scope
= &file_symbols
;
6195 /* Process all the DIES contained within a lexical block scope. Start
6196 a new scope, process the dies, and then close the scope. */
6199 read_lexical_block_scope (struct die_info
*die
, struct dwarf2_cu
*cu
)
6201 struct objfile
*objfile
= cu
->objfile
;
6202 struct context_stack
*new;
6203 CORE_ADDR lowpc
, highpc
;
6204 struct die_info
*child_die
;
6207 baseaddr
= ANOFFSET (objfile
->section_offsets
, SECT_OFF_TEXT (objfile
));
6209 /* Ignore blocks with missing or invalid low and high pc attributes. */
6210 /* ??? Perhaps consider discontiguous blocks defined by DW_AT_ranges
6211 as multiple lexical blocks? Handling children in a sane way would
6212 be nasty. Might be easier to properly extend generic blocks to
6214 if (!dwarf2_get_pc_bounds (die
, &lowpc
, &highpc
, cu
, NULL
))
6219 push_context (0, lowpc
);
6220 if (die
->child
!= NULL
)
6222 child_die
= die
->child
;
6223 while (child_die
&& child_die
->tag
)
6225 process_die (child_die
, cu
);
6226 child_die
= sibling_die (child_die
);
6229 new = pop_context ();
6231 if (local_symbols
!= NULL
|| using_directives
!= NULL
)
6234 = finish_block (0, &local_symbols
, new->old_blocks
, new->start_addr
,
6237 /* Note that recording ranges after traversing children, as we
6238 do here, means that recording a parent's ranges entails
6239 walking across all its children's ranges as they appear in
6240 the address map, which is quadratic behavior.
6242 It would be nicer to record the parent's ranges before
6243 traversing its children, simply overriding whatever you find
6244 there. But since we don't even decide whether to create a
6245 block until after we've traversed its children, that's hard
6247 dwarf2_record_block_ranges (die
, block
, baseaddr
, cu
);
6249 local_symbols
= new->locals
;
6250 using_directives
= new->using_directives
;
6253 /* Read in DW_TAG_GNU_call_site and insert it to CU->call_site_htab. */
6256 read_call_site_scope (struct die_info
*die
, struct dwarf2_cu
*cu
)
6258 struct objfile
*objfile
= cu
->objfile
;
6259 struct gdbarch
*gdbarch
= get_objfile_arch (objfile
);
6260 CORE_ADDR pc
, baseaddr
;
6261 struct attribute
*attr
;
6262 struct call_site
*call_site
, call_site_local
;
6265 struct die_info
*child_die
;
6267 baseaddr
= ANOFFSET (objfile
->section_offsets
, SECT_OFF_TEXT (objfile
));
6269 attr
= dwarf2_attr (die
, DW_AT_low_pc
, cu
);
6272 complaint (&symfile_complaints
,
6273 _("missing DW_AT_low_pc for DW_TAG_GNU_call_site "
6274 "DIE 0x%x [in module %s]"),
6275 die
->offset
, cu
->objfile
->name
);
6278 pc
= DW_ADDR (attr
) + baseaddr
;
6280 if (cu
->call_site_htab
== NULL
)
6281 cu
->call_site_htab
= htab_create_alloc_ex (16, core_addr_hash
, core_addr_eq
,
6282 NULL
, &objfile
->objfile_obstack
,
6283 hashtab_obstack_allocate
, NULL
);
6284 call_site_local
.pc
= pc
;
6285 slot
= htab_find_slot (cu
->call_site_htab
, &call_site_local
, INSERT
);
6288 complaint (&symfile_complaints
,
6289 _("Duplicate PC %s for DW_TAG_GNU_call_site "
6290 "DIE 0x%x [in module %s]"),
6291 paddress (gdbarch
, pc
), die
->offset
, cu
->objfile
->name
);
6295 /* Count parameters at the caller. */
6298 for (child_die
= die
->child
; child_die
&& child_die
->tag
;
6299 child_die
= sibling_die (child_die
))
6301 if (child_die
->tag
!= DW_TAG_GNU_call_site_parameter
)
6303 complaint (&symfile_complaints
,
6304 _("Tag %d is not DW_TAG_GNU_call_site_parameter in "
6305 "DW_TAG_GNU_call_site child DIE 0x%x [in module %s]"),
6306 child_die
->tag
, child_die
->offset
, cu
->objfile
->name
);
6313 call_site
= obstack_alloc (&objfile
->objfile_obstack
,
6314 (sizeof (*call_site
)
6315 + (sizeof (*call_site
->parameter
)
6318 memset (call_site
, 0, sizeof (*call_site
) - sizeof (*call_site
->parameter
));
6321 if (dwarf2_flag_true_p (die
, DW_AT_GNU_tail_call
, cu
))
6323 struct die_info
*func_die
;
6325 /* Skip also over DW_TAG_inlined_subroutine. */
6326 for (func_die
= die
->parent
;
6327 func_die
&& func_die
->tag
!= DW_TAG_subprogram
6328 && func_die
->tag
!= DW_TAG_subroutine_type
;
6329 func_die
= func_die
->parent
);
6331 /* DW_AT_GNU_all_call_sites is a superset
6332 of DW_AT_GNU_all_tail_call_sites. */
6334 && !dwarf2_flag_true_p (func_die
, DW_AT_GNU_all_call_sites
, cu
)
6335 && !dwarf2_flag_true_p (func_die
, DW_AT_GNU_all_tail_call_sites
, cu
))
6337 /* TYPE_TAIL_CALL_LIST is not interesting in functions where it is
6338 not complete. But keep CALL_SITE for look ups via call_site_htab,
6339 both the initial caller containing the real return address PC and
6340 the final callee containing the current PC of a chain of tail
6341 calls do not need to have the tail call list complete. But any
6342 function candidate for a virtual tail call frame searched via
6343 TYPE_TAIL_CALL_LIST must have the tail call list complete to be
6344 determined unambiguously. */
6348 struct type
*func_type
= NULL
;
6351 func_type
= get_die_type (func_die
, cu
);
6352 if (func_type
!= NULL
)
6354 gdb_assert (TYPE_CODE (func_type
) == TYPE_CODE_FUNC
);
6356 /* Enlist this call site to the function. */
6357 call_site
->tail_call_next
= TYPE_TAIL_CALL_LIST (func_type
);
6358 TYPE_TAIL_CALL_LIST (func_type
) = call_site
;
6361 complaint (&symfile_complaints
,
6362 _("Cannot find function owning DW_TAG_GNU_call_site "
6363 "DIE 0x%x [in module %s]"),
6364 die
->offset
, cu
->objfile
->name
);
6368 attr
= dwarf2_attr (die
, DW_AT_GNU_call_site_target
, cu
);
6370 attr
= dwarf2_attr (die
, DW_AT_abstract_origin
, cu
);
6371 SET_FIELD_DWARF_BLOCK (call_site
->target
, NULL
);
6372 if (!attr
|| (attr_form_is_block (attr
) && DW_BLOCK (attr
)->size
== 0))
6373 /* Keep NULL DWARF_BLOCK. */;
6374 else if (attr_form_is_block (attr
))
6376 struct dwarf2_locexpr_baton
*dlbaton
;
6378 dlbaton
= obstack_alloc (&objfile
->objfile_obstack
, sizeof (*dlbaton
));
6379 dlbaton
->data
= DW_BLOCK (attr
)->data
;
6380 dlbaton
->size
= DW_BLOCK (attr
)->size
;
6381 dlbaton
->per_cu
= cu
->per_cu
;
6383 SET_FIELD_DWARF_BLOCK (call_site
->target
, dlbaton
);
6385 else if (is_ref_attr (attr
))
6387 struct objfile
*objfile
= cu
->objfile
;
6388 struct dwarf2_cu
*target_cu
= cu
;
6389 struct die_info
*target_die
;
6391 target_die
= follow_die_ref_or_sig (die
, attr
, &target_cu
);
6392 gdb_assert (target_cu
->objfile
== objfile
);
6393 if (die_is_declaration (target_die
, target_cu
))
6395 const char *target_physname
;
6397 target_physname
= dwarf2_physname (NULL
, target_die
, target_cu
);
6398 if (target_physname
== NULL
)
6399 complaint (&symfile_complaints
,
6400 _("DW_AT_GNU_call_site_target target DIE has invalid "
6401 "physname, for referencing DIE 0x%x [in module %s]"),
6402 die
->offset
, cu
->objfile
->name
);
6404 SET_FIELD_PHYSNAME (call_site
->target
, (char *) target_physname
);
6410 /* DW_AT_entry_pc should be preferred. */
6411 if (!dwarf2_get_pc_bounds (target_die
, &lowpc
, NULL
, target_cu
, NULL
))
6412 complaint (&symfile_complaints
,
6413 _("DW_AT_GNU_call_site_target target DIE has invalid "
6414 "low pc, for referencing DIE 0x%x [in module %s]"),
6415 die
->offset
, cu
->objfile
->name
);
6417 SET_FIELD_PHYSADDR (call_site
->target
, lowpc
+ baseaddr
);
6421 complaint (&symfile_complaints
,
6422 _("DW_TAG_GNU_call_site DW_AT_GNU_call_site_target is neither "
6423 "block nor reference, for DIE 0x%x [in module %s]"),
6424 die
->offset
, cu
->objfile
->name
);
6426 call_site
->per_cu
= cu
->per_cu
;
6428 for (child_die
= die
->child
;
6429 child_die
&& child_die
->tag
;
6430 child_die
= sibling_die (child_die
))
6432 struct dwarf2_locexpr_baton
*dlbaton
;
6433 struct call_site_parameter
*parameter
;
6435 if (child_die
->tag
!= DW_TAG_GNU_call_site_parameter
)
6437 /* Already printed the complaint above. */
6441 gdb_assert (call_site
->parameter_count
< nparams
);
6442 parameter
= &call_site
->parameter
[call_site
->parameter_count
];
6444 /* DW_AT_location specifies the register number. Value of the data
6445 assumed for the register is contained in DW_AT_GNU_call_site_value. */
6447 attr
= dwarf2_attr (child_die
, DW_AT_location
, cu
);
6448 if (!attr
|| !attr_form_is_block (attr
))
6450 complaint (&symfile_complaints
,
6451 _("No DW_FORM_block* DW_AT_location for "
6452 "DW_TAG_GNU_call_site child DIE 0x%x [in module %s]"),
6453 child_die
->offset
, cu
->objfile
->name
);
6456 parameter
->dwarf_reg
= dwarf_block_to_dwarf_reg (DW_BLOCK (attr
)->data
,
6457 &DW_BLOCK (attr
)->data
[DW_BLOCK (attr
)->size
]);
6458 if (parameter
->dwarf_reg
== -1
6459 && !dwarf_block_to_sp_offset (gdbarch
, DW_BLOCK (attr
)->data
,
6460 &DW_BLOCK (attr
)->data
[DW_BLOCK (attr
)->size
],
6461 ¶meter
->fb_offset
))
6463 complaint (&symfile_complaints
,
6464 _("Only single DW_OP_reg or DW_OP_fbreg is supported "
6465 "for DW_FORM_block* DW_AT_location for "
6466 "DW_TAG_GNU_call_site child DIE 0x%x [in module %s]"),
6467 child_die
->offset
, cu
->objfile
->name
);
6471 attr
= dwarf2_attr (child_die
, DW_AT_GNU_call_site_value
, cu
);
6472 if (!attr_form_is_block (attr
))
6474 complaint (&symfile_complaints
,
6475 _("No DW_FORM_block* DW_AT_GNU_call_site_value for "
6476 "DW_TAG_GNU_call_site child DIE 0x%x [in module %s]"),
6477 child_die
->offset
, cu
->objfile
->name
);
6480 parameter
->value
= DW_BLOCK (attr
)->data
;
6481 parameter
->value_size
= DW_BLOCK (attr
)->size
;
6483 /* Parameters are not pre-cleared by memset above. */
6484 parameter
->data_value
= NULL
;
6485 parameter
->data_value_size
= 0;
6486 call_site
->parameter_count
++;
6488 attr
= dwarf2_attr (child_die
, DW_AT_GNU_call_site_data_value
, cu
);
6491 if (!attr_form_is_block (attr
))
6492 complaint (&symfile_complaints
,
6493 _("No DW_FORM_block* DW_AT_GNU_call_site_data_value for "
6494 "DW_TAG_GNU_call_site child DIE 0x%x [in module %s]"),
6495 child_die
->offset
, cu
->objfile
->name
);
6498 parameter
->data_value
= DW_BLOCK (attr
)->data
;
6499 parameter
->data_value_size
= DW_BLOCK (attr
)->size
;
6505 /* Get low and high pc attributes from DW_AT_ranges attribute value OFFSET.
6506 Return 1 if the attributes are present and valid, otherwise, return 0.
6507 If RANGES_PST is not NULL we should setup `objfile->psymtabs_addrmap'. */
6510 dwarf2_ranges_read (unsigned offset
, CORE_ADDR
*low_return
,
6511 CORE_ADDR
*high_return
, struct dwarf2_cu
*cu
,
6512 struct partial_symtab
*ranges_pst
)
6514 struct objfile
*objfile
= cu
->objfile
;
6515 struct comp_unit_head
*cu_header
= &cu
->header
;
6516 bfd
*obfd
= objfile
->obfd
;
6517 unsigned int addr_size
= cu_header
->addr_size
;
6518 CORE_ADDR mask
= ~(~(CORE_ADDR
)1 << (addr_size
* 8 - 1));
6519 /* Base address selection entry. */
6530 found_base
= cu
->base_known
;
6531 base
= cu
->base_address
;
6533 dwarf2_read_section (objfile
, &dwarf2_per_objfile
->ranges
);
6534 if (offset
>= dwarf2_per_objfile
->ranges
.size
)
6536 complaint (&symfile_complaints
,
6537 _("Offset %d out of bounds for DW_AT_ranges attribute"),
6541 buffer
= dwarf2_per_objfile
->ranges
.buffer
+ offset
;
6543 /* Read in the largest possible address. */
6544 marker
= read_address (obfd
, buffer
, cu
, &dummy
);
6545 if ((marker
& mask
) == mask
)
6547 /* If we found the largest possible address, then
6548 read the base address. */
6549 base
= read_address (obfd
, buffer
+ addr_size
, cu
, &dummy
);
6550 buffer
+= 2 * addr_size
;
6551 offset
+= 2 * addr_size
;
6557 baseaddr
= ANOFFSET (objfile
->section_offsets
, SECT_OFF_TEXT (objfile
));
6561 CORE_ADDR range_beginning
, range_end
;
6563 range_beginning
= read_address (obfd
, buffer
, cu
, &dummy
);
6564 buffer
+= addr_size
;
6565 range_end
= read_address (obfd
, buffer
, cu
, &dummy
);
6566 buffer
+= addr_size
;
6567 offset
+= 2 * addr_size
;
6569 /* An end of list marker is a pair of zero addresses. */
6570 if (range_beginning
== 0 && range_end
== 0)
6571 /* Found the end of list entry. */
6574 /* Each base address selection entry is a pair of 2 values.
6575 The first is the largest possible address, the second is
6576 the base address. Check for a base address here. */
6577 if ((range_beginning
& mask
) == mask
)
6579 /* If we found the largest possible address, then
6580 read the base address. */
6581 base
= read_address (obfd
, buffer
+ addr_size
, cu
, &dummy
);
6588 /* We have no valid base address for the ranges
6590 complaint (&symfile_complaints
,
6591 _("Invalid .debug_ranges data (no base address)"));
6595 if (range_beginning
> range_end
)
6597 /* Inverted range entries are invalid. */
6598 complaint (&symfile_complaints
,
6599 _("Invalid .debug_ranges data (inverted range)"));
6603 /* Empty range entries have no effect. */
6604 if (range_beginning
== range_end
)
6607 range_beginning
+= base
;
6610 if (ranges_pst
!= NULL
)
6611 addrmap_set_empty (objfile
->psymtabs_addrmap
,
6612 range_beginning
+ baseaddr
,
6613 range_end
- 1 + baseaddr
,
6616 /* FIXME: This is recording everything as a low-high
6617 segment of consecutive addresses. We should have a
6618 data structure for discontiguous block ranges
6622 low
= range_beginning
;
6628 if (range_beginning
< low
)
6629 low
= range_beginning
;
6630 if (range_end
> high
)
6636 /* If the first entry is an end-of-list marker, the range
6637 describes an empty scope, i.e. no instructions. */
6643 *high_return
= high
;
6647 /* Get low and high pc attributes from a die. Return 1 if the attributes
6648 are present and valid, otherwise, return 0. Return -1 if the range is
6649 discontinuous, i.e. derived from DW_AT_ranges information. */
6651 dwarf2_get_pc_bounds (struct die_info
*die
, CORE_ADDR
*lowpc
,
6652 CORE_ADDR
*highpc
, struct dwarf2_cu
*cu
,
6653 struct partial_symtab
*pst
)
6655 struct attribute
*attr
;
6660 attr
= dwarf2_attr (die
, DW_AT_high_pc
, cu
);
6663 high
= DW_ADDR (attr
);
6664 attr
= dwarf2_attr (die
, DW_AT_low_pc
, cu
);
6666 low
= DW_ADDR (attr
);
6668 /* Found high w/o low attribute. */
6671 /* Found consecutive range of addresses. */
6676 attr
= dwarf2_attr (die
, DW_AT_ranges
, cu
);
6679 /* Value of the DW_AT_ranges attribute is the offset in the
6680 .debug_ranges section. */
6681 if (!dwarf2_ranges_read (DW_UNSND (attr
), &low
, &high
, cu
, pst
))
6683 /* Found discontinuous range of addresses. */
6688 /* read_partial_die has also the strict LOW < HIGH requirement. */
6692 /* When using the GNU linker, .gnu.linkonce. sections are used to
6693 eliminate duplicate copies of functions and vtables and such.
6694 The linker will arbitrarily choose one and discard the others.
6695 The AT_*_pc values for such functions refer to local labels in
6696 these sections. If the section from that file was discarded, the
6697 labels are not in the output, so the relocs get a value of 0.
6698 If this is a discarded function, mark the pc bounds as invalid,
6699 so that GDB will ignore it. */
6700 if (low
== 0 && !dwarf2_per_objfile
->has_section_at_zero
)
6709 /* Assuming that DIE represents a subprogram DIE or a lexical block, get
6710 its low and high PC addresses. Do nothing if these addresses could not
6711 be determined. Otherwise, set LOWPC to the low address if it is smaller,
6712 and HIGHPC to the high address if greater than HIGHPC. */
6715 dwarf2_get_subprogram_pc_bounds (struct die_info
*die
,
6716 CORE_ADDR
*lowpc
, CORE_ADDR
*highpc
,
6717 struct dwarf2_cu
*cu
)
6719 CORE_ADDR low
, high
;
6720 struct die_info
*child
= die
->child
;
6722 if (dwarf2_get_pc_bounds (die
, &low
, &high
, cu
, NULL
))
6724 *lowpc
= min (*lowpc
, low
);
6725 *highpc
= max (*highpc
, high
);
6728 /* If the language does not allow nested subprograms (either inside
6729 subprograms or lexical blocks), we're done. */
6730 if (cu
->language
!= language_ada
)
6733 /* Check all the children of the given DIE. If it contains nested
6734 subprograms, then check their pc bounds. Likewise, we need to
6735 check lexical blocks as well, as they may also contain subprogram
6737 while (child
&& child
->tag
)
6739 if (child
->tag
== DW_TAG_subprogram
6740 || child
->tag
== DW_TAG_lexical_block
)
6741 dwarf2_get_subprogram_pc_bounds (child
, lowpc
, highpc
, cu
);
6742 child
= sibling_die (child
);
6746 /* Get the low and high pc's represented by the scope DIE, and store
6747 them in *LOWPC and *HIGHPC. If the correct values can't be
6748 determined, set *LOWPC to -1 and *HIGHPC to 0. */
6751 get_scope_pc_bounds (struct die_info
*die
,
6752 CORE_ADDR
*lowpc
, CORE_ADDR
*highpc
,
6753 struct dwarf2_cu
*cu
)
6755 CORE_ADDR best_low
= (CORE_ADDR
) -1;
6756 CORE_ADDR best_high
= (CORE_ADDR
) 0;
6757 CORE_ADDR current_low
, current_high
;
6759 if (dwarf2_get_pc_bounds (die
, ¤t_low
, ¤t_high
, cu
, NULL
))
6761 best_low
= current_low
;
6762 best_high
= current_high
;
6766 struct die_info
*child
= die
->child
;
6768 while (child
&& child
->tag
)
6770 switch (child
->tag
) {
6771 case DW_TAG_subprogram
:
6772 dwarf2_get_subprogram_pc_bounds (child
, &best_low
, &best_high
, cu
);
6774 case DW_TAG_namespace
:
6776 /* FIXME: carlton/2004-01-16: Should we do this for
6777 DW_TAG_class_type/DW_TAG_structure_type, too? I think
6778 that current GCC's always emit the DIEs corresponding
6779 to definitions of methods of classes as children of a
6780 DW_TAG_compile_unit or DW_TAG_namespace (as opposed to
6781 the DIEs giving the declarations, which could be
6782 anywhere). But I don't see any reason why the
6783 standards says that they have to be there. */
6784 get_scope_pc_bounds (child
, ¤t_low
, ¤t_high
, cu
);
6786 if (current_low
!= ((CORE_ADDR
) -1))
6788 best_low
= min (best_low
, current_low
);
6789 best_high
= max (best_high
, current_high
);
6797 child
= sibling_die (child
);
6802 *highpc
= best_high
;
6805 /* Record the address ranges for BLOCK, offset by BASEADDR, as given
6808 dwarf2_record_block_ranges (struct die_info
*die
, struct block
*block
,
6809 CORE_ADDR baseaddr
, struct dwarf2_cu
*cu
)
6811 struct attribute
*attr
;
6813 attr
= dwarf2_attr (die
, DW_AT_high_pc
, cu
);
6816 CORE_ADDR high
= DW_ADDR (attr
);
6818 attr
= dwarf2_attr (die
, DW_AT_low_pc
, cu
);
6821 CORE_ADDR low
= DW_ADDR (attr
);
6823 record_block_range (block
, baseaddr
+ low
, baseaddr
+ high
- 1);
6827 attr
= dwarf2_attr (die
, DW_AT_ranges
, cu
);
6830 bfd
*obfd
= cu
->objfile
->obfd
;
6832 /* The value of the DW_AT_ranges attribute is the offset of the
6833 address range list in the .debug_ranges section. */
6834 unsigned long offset
= DW_UNSND (attr
);
6835 gdb_byte
*buffer
= dwarf2_per_objfile
->ranges
.buffer
+ offset
;
6837 /* For some target architectures, but not others, the
6838 read_address function sign-extends the addresses it returns.
6839 To recognize base address selection entries, we need a
6841 unsigned int addr_size
= cu
->header
.addr_size
;
6842 CORE_ADDR base_select_mask
= ~(~(CORE_ADDR
)1 << (addr_size
* 8 - 1));
6844 /* The base address, to which the next pair is relative. Note
6845 that this 'base' is a DWARF concept: most entries in a range
6846 list are relative, to reduce the number of relocs against the
6847 debugging information. This is separate from this function's
6848 'baseaddr' argument, which GDB uses to relocate debugging
6849 information from a shared library based on the address at
6850 which the library was loaded. */
6851 CORE_ADDR base
= cu
->base_address
;
6852 int base_known
= cu
->base_known
;
6854 gdb_assert (dwarf2_per_objfile
->ranges
.readin
);
6855 if (offset
>= dwarf2_per_objfile
->ranges
.size
)
6857 complaint (&symfile_complaints
,
6858 _("Offset %lu out of bounds for DW_AT_ranges attribute"),
6865 unsigned int bytes_read
;
6866 CORE_ADDR start
, end
;
6868 start
= read_address (obfd
, buffer
, cu
, &bytes_read
);
6869 buffer
+= bytes_read
;
6870 end
= read_address (obfd
, buffer
, cu
, &bytes_read
);
6871 buffer
+= bytes_read
;
6873 /* Did we find the end of the range list? */
6874 if (start
== 0 && end
== 0)
6877 /* Did we find a base address selection entry? */
6878 else if ((start
& base_select_mask
) == base_select_mask
)
6884 /* We found an ordinary address range. */
6889 complaint (&symfile_complaints
,
6890 _("Invalid .debug_ranges data "
6891 "(no base address)"));
6897 /* Inverted range entries are invalid. */
6898 complaint (&symfile_complaints
,
6899 _("Invalid .debug_ranges data "
6900 "(inverted range)"));
6904 /* Empty range entries have no effect. */
6908 record_block_range (block
,
6909 baseaddr
+ base
+ start
,
6910 baseaddr
+ base
+ end
- 1);
6916 /* Check for GCC PR debug/45124 fix which is not present in any G++ version up
6917 to 4.5.any while it is present already in G++ 4.6.0 - the PR has been fixed
6918 during 4.6.0 experimental. */
6921 producer_is_gxx_lt_4_6 (struct dwarf2_cu
*cu
)
6924 int major
, minor
, release
;
6926 if (cu
->producer
== NULL
)
6928 /* For unknown compilers expect their behavior is DWARF version
6931 GCC started to support .debug_types sections by -gdwarf-4 since
6932 gcc-4.5.x. As the .debug_types sections are missing DW_AT_producer
6933 for their space efficiency GDB cannot workaround gcc-4.5.x -gdwarf-4
6934 combination. gcc-4.5.x -gdwarf-4 binaries have DW_AT_accessibility
6935 interpreted incorrectly by GDB now - GCC PR debug/48229. */
6940 /* Skip any identifier after "GNU " - such as "C++" or "Java". */
6942 if (strncmp (cu
->producer
, "GNU ", strlen ("GNU ")) != 0)
6944 /* For non-GCC compilers expect their behavior is DWARF version
6949 cs
= &cu
->producer
[strlen ("GNU ")];
6950 while (*cs
&& !isdigit (*cs
))
6952 if (sscanf (cs
, "%d.%d.%d", &major
, &minor
, &release
) != 3)
6954 /* Not recognized as GCC. */
6959 return major
< 4 || (major
== 4 && minor
< 6);
6962 /* Return the default accessibility type if it is not overriden by
6963 DW_AT_accessibility. */
6965 static enum dwarf_access_attribute
6966 dwarf2_default_access_attribute (struct die_info
*die
, struct dwarf2_cu
*cu
)
6968 if (cu
->header
.version
< 3 || producer_is_gxx_lt_4_6 (cu
))
6970 /* The default DWARF 2 accessibility for members is public, the default
6971 accessibility for inheritance is private. */
6973 if (die
->tag
!= DW_TAG_inheritance
)
6974 return DW_ACCESS_public
;
6976 return DW_ACCESS_private
;
6980 /* DWARF 3+ defines the default accessibility a different way. The same
6981 rules apply now for DW_TAG_inheritance as for the members and it only
6982 depends on the container kind. */
6984 if (die
->parent
->tag
== DW_TAG_class_type
)
6985 return DW_ACCESS_private
;
6987 return DW_ACCESS_public
;
6991 /* Look for DW_AT_data_member_location. Set *OFFSET to the byte
6992 offset. If the attribute was not found return 0, otherwise return
6993 1. If it was found but could not properly be handled, set *OFFSET
6997 handle_data_member_location (struct die_info
*die
, struct dwarf2_cu
*cu
,
7000 struct attribute
*attr
;
7002 attr
= dwarf2_attr (die
, DW_AT_data_member_location
, cu
);
7007 /* Note that we do not check for a section offset first here.
7008 This is because DW_AT_data_member_location is new in DWARF 4,
7009 so if we see it, we can assume that a constant form is really
7010 a constant and not a section offset. */
7011 if (attr_form_is_constant (attr
))
7012 *offset
= dwarf2_get_attr_constant_value (attr
, 0);
7013 else if (attr_form_is_section_offset (attr
))
7014 dwarf2_complex_location_expr_complaint ();
7015 else if (attr_form_is_block (attr
))
7016 *offset
= decode_locdesc (DW_BLOCK (attr
), cu
);
7018 dwarf2_complex_location_expr_complaint ();
7026 /* Add an aggregate field to the field list. */
7029 dwarf2_add_field (struct field_info
*fip
, struct die_info
*die
,
7030 struct dwarf2_cu
*cu
)
7032 struct objfile
*objfile
= cu
->objfile
;
7033 struct gdbarch
*gdbarch
= get_objfile_arch (objfile
);
7034 struct nextfield
*new_field
;
7035 struct attribute
*attr
;
7037 char *fieldname
= "";
7039 /* Allocate a new field list entry and link it in. */
7040 new_field
= (struct nextfield
*) xmalloc (sizeof (struct nextfield
));
7041 make_cleanup (xfree
, new_field
);
7042 memset (new_field
, 0, sizeof (struct nextfield
));
7044 if (die
->tag
== DW_TAG_inheritance
)
7046 new_field
->next
= fip
->baseclasses
;
7047 fip
->baseclasses
= new_field
;
7051 new_field
->next
= fip
->fields
;
7052 fip
->fields
= new_field
;
7056 attr
= dwarf2_attr (die
, DW_AT_accessibility
, cu
);
7058 new_field
->accessibility
= DW_UNSND (attr
);
7060 new_field
->accessibility
= dwarf2_default_access_attribute (die
, cu
);
7061 if (new_field
->accessibility
!= DW_ACCESS_public
)
7062 fip
->non_public_fields
= 1;
7064 attr
= dwarf2_attr (die
, DW_AT_virtuality
, cu
);
7066 new_field
->virtuality
= DW_UNSND (attr
);
7068 new_field
->virtuality
= DW_VIRTUALITY_none
;
7070 fp
= &new_field
->field
;
7072 if (die
->tag
== DW_TAG_member
&& ! die_is_declaration (die
, cu
))
7076 /* Data member other than a C++ static data member. */
7078 /* Get type of field. */
7079 fp
->type
= die_type (die
, cu
);
7081 SET_FIELD_BITPOS (*fp
, 0);
7083 /* Get bit size of field (zero if none). */
7084 attr
= dwarf2_attr (die
, DW_AT_bit_size
, cu
);
7087 FIELD_BITSIZE (*fp
) = DW_UNSND (attr
);
7091 FIELD_BITSIZE (*fp
) = 0;
7094 /* Get bit offset of field. */
7095 if (handle_data_member_location (die
, cu
, &offset
))
7096 SET_FIELD_BITPOS (*fp
, offset
* bits_per_byte
);
7097 attr
= dwarf2_attr (die
, DW_AT_bit_offset
, cu
);
7100 if (gdbarch_bits_big_endian (gdbarch
))
7102 /* For big endian bits, the DW_AT_bit_offset gives the
7103 additional bit offset from the MSB of the containing
7104 anonymous object to the MSB of the field. We don't
7105 have to do anything special since we don't need to
7106 know the size of the anonymous object. */
7107 FIELD_BITPOS (*fp
) += DW_UNSND (attr
);
7111 /* For little endian bits, compute the bit offset to the
7112 MSB of the anonymous object, subtract off the number of
7113 bits from the MSB of the field to the MSB of the
7114 object, and then subtract off the number of bits of
7115 the field itself. The result is the bit offset of
7116 the LSB of the field. */
7118 int bit_offset
= DW_UNSND (attr
);
7120 attr
= dwarf2_attr (die
, DW_AT_byte_size
, cu
);
7123 /* The size of the anonymous object containing
7124 the bit field is explicit, so use the
7125 indicated size (in bytes). */
7126 anonymous_size
= DW_UNSND (attr
);
7130 /* The size of the anonymous object containing
7131 the bit field must be inferred from the type
7132 attribute of the data member containing the
7134 anonymous_size
= TYPE_LENGTH (fp
->type
);
7136 FIELD_BITPOS (*fp
) += anonymous_size
* bits_per_byte
7137 - bit_offset
- FIELD_BITSIZE (*fp
);
7141 /* Get name of field. */
7142 fieldname
= dwarf2_name (die
, cu
);
7143 if (fieldname
== NULL
)
7146 /* The name is already allocated along with this objfile, so we don't
7147 need to duplicate it for the type. */
7148 fp
->name
= fieldname
;
7150 /* Change accessibility for artificial fields (e.g. virtual table
7151 pointer or virtual base class pointer) to private. */
7152 if (dwarf2_attr (die
, DW_AT_artificial
, cu
))
7154 FIELD_ARTIFICIAL (*fp
) = 1;
7155 new_field
->accessibility
= DW_ACCESS_private
;
7156 fip
->non_public_fields
= 1;
7159 else if (die
->tag
== DW_TAG_member
|| die
->tag
== DW_TAG_variable
)
7161 /* C++ static member. */
7163 /* NOTE: carlton/2002-11-05: It should be a DW_TAG_member that
7164 is a declaration, but all versions of G++ as of this writing
7165 (so through at least 3.2.1) incorrectly generate
7166 DW_TAG_variable tags. */
7168 const char *physname
;
7170 /* Get name of field. */
7171 fieldname
= dwarf2_name (die
, cu
);
7172 if (fieldname
== NULL
)
7175 attr
= dwarf2_attr (die
, DW_AT_const_value
, cu
);
7177 /* Only create a symbol if this is an external value.
7178 new_symbol checks this and puts the value in the global symbol
7179 table, which we want. If it is not external, new_symbol
7180 will try to put the value in cu->list_in_scope which is wrong. */
7181 && dwarf2_flag_true_p (die
, DW_AT_external
, cu
))
7183 /* A static const member, not much different than an enum as far as
7184 we're concerned, except that we can support more types. */
7185 new_symbol (die
, NULL
, cu
);
7188 /* Get physical name. */
7189 physname
= dwarf2_physname (fieldname
, die
, cu
);
7191 /* The name is already allocated along with this objfile, so we don't
7192 need to duplicate it for the type. */
7193 SET_FIELD_PHYSNAME (*fp
, physname
? physname
: "");
7194 FIELD_TYPE (*fp
) = die_type (die
, cu
);
7195 FIELD_NAME (*fp
) = fieldname
;
7197 else if (die
->tag
== DW_TAG_inheritance
)
7201 /* C++ base class field. */
7202 if (handle_data_member_location (die
, cu
, &offset
))
7203 SET_FIELD_BITPOS (*fp
, offset
* bits_per_byte
);
7204 FIELD_BITSIZE (*fp
) = 0;
7205 FIELD_TYPE (*fp
) = die_type (die
, cu
);
7206 FIELD_NAME (*fp
) = type_name_no_tag (fp
->type
);
7207 fip
->nbaseclasses
++;
7211 /* Add a typedef defined in the scope of the FIP's class. */
7214 dwarf2_add_typedef (struct field_info
*fip
, struct die_info
*die
,
7215 struct dwarf2_cu
*cu
)
7217 struct objfile
*objfile
= cu
->objfile
;
7218 struct typedef_field_list
*new_field
;
7219 struct attribute
*attr
;
7220 struct typedef_field
*fp
;
7221 char *fieldname
= "";
7223 /* Allocate a new field list entry and link it in. */
7224 new_field
= xzalloc (sizeof (*new_field
));
7225 make_cleanup (xfree
, new_field
);
7227 gdb_assert (die
->tag
== DW_TAG_typedef
);
7229 fp
= &new_field
->field
;
7231 /* Get name of field. */
7232 fp
->name
= dwarf2_name (die
, cu
);
7233 if (fp
->name
== NULL
)
7236 fp
->type
= read_type_die (die
, cu
);
7238 new_field
->next
= fip
->typedef_field_list
;
7239 fip
->typedef_field_list
= new_field
;
7240 fip
->typedef_field_list_count
++;
7243 /* Create the vector of fields, and attach it to the type. */
7246 dwarf2_attach_fields_to_type (struct field_info
*fip
, struct type
*type
,
7247 struct dwarf2_cu
*cu
)
7249 int nfields
= fip
->nfields
;
7251 /* Record the field count, allocate space for the array of fields,
7252 and create blank accessibility bitfields if necessary. */
7253 TYPE_NFIELDS (type
) = nfields
;
7254 TYPE_FIELDS (type
) = (struct field
*)
7255 TYPE_ALLOC (type
, sizeof (struct field
) * nfields
);
7256 memset (TYPE_FIELDS (type
), 0, sizeof (struct field
) * nfields
);
7258 if (fip
->non_public_fields
&& cu
->language
!= language_ada
)
7260 ALLOCATE_CPLUS_STRUCT_TYPE (type
);
7262 TYPE_FIELD_PRIVATE_BITS (type
) =
7263 (B_TYPE
*) TYPE_ALLOC (type
, B_BYTES (nfields
));
7264 B_CLRALL (TYPE_FIELD_PRIVATE_BITS (type
), nfields
);
7266 TYPE_FIELD_PROTECTED_BITS (type
) =
7267 (B_TYPE
*) TYPE_ALLOC (type
, B_BYTES (nfields
));
7268 B_CLRALL (TYPE_FIELD_PROTECTED_BITS (type
), nfields
);
7270 TYPE_FIELD_IGNORE_BITS (type
) =
7271 (B_TYPE
*) TYPE_ALLOC (type
, B_BYTES (nfields
));
7272 B_CLRALL (TYPE_FIELD_IGNORE_BITS (type
), nfields
);
7275 /* If the type has baseclasses, allocate and clear a bit vector for
7276 TYPE_FIELD_VIRTUAL_BITS. */
7277 if (fip
->nbaseclasses
&& cu
->language
!= language_ada
)
7279 int num_bytes
= B_BYTES (fip
->nbaseclasses
);
7280 unsigned char *pointer
;
7282 ALLOCATE_CPLUS_STRUCT_TYPE (type
);
7283 pointer
= TYPE_ALLOC (type
, num_bytes
);
7284 TYPE_FIELD_VIRTUAL_BITS (type
) = pointer
;
7285 B_CLRALL (TYPE_FIELD_VIRTUAL_BITS (type
), fip
->nbaseclasses
);
7286 TYPE_N_BASECLASSES (type
) = fip
->nbaseclasses
;
7289 /* Copy the saved-up fields into the field vector. Start from the head of
7290 the list, adding to the tail of the field array, so that they end up in
7291 the same order in the array in which they were added to the list. */
7292 while (nfields
-- > 0)
7294 struct nextfield
*fieldp
;
7298 fieldp
= fip
->fields
;
7299 fip
->fields
= fieldp
->next
;
7303 fieldp
= fip
->baseclasses
;
7304 fip
->baseclasses
= fieldp
->next
;
7307 TYPE_FIELD (type
, nfields
) = fieldp
->field
;
7308 switch (fieldp
->accessibility
)
7310 case DW_ACCESS_private
:
7311 if (cu
->language
!= language_ada
)
7312 SET_TYPE_FIELD_PRIVATE (type
, nfields
);
7315 case DW_ACCESS_protected
:
7316 if (cu
->language
!= language_ada
)
7317 SET_TYPE_FIELD_PROTECTED (type
, nfields
);
7320 case DW_ACCESS_public
:
7324 /* Unknown accessibility. Complain and treat it as public. */
7326 complaint (&symfile_complaints
, _("unsupported accessibility %d"),
7327 fieldp
->accessibility
);
7331 if (nfields
< fip
->nbaseclasses
)
7333 switch (fieldp
->virtuality
)
7335 case DW_VIRTUALITY_virtual
:
7336 case DW_VIRTUALITY_pure_virtual
:
7337 if (cu
->language
== language_ada
)
7338 error (_("unexpected virtuality in component of Ada type"));
7339 SET_TYPE_FIELD_VIRTUAL (type
, nfields
);
7346 /* Add a member function to the proper fieldlist. */
7349 dwarf2_add_member_fn (struct field_info
*fip
, struct die_info
*die
,
7350 struct type
*type
, struct dwarf2_cu
*cu
)
7352 struct objfile
*objfile
= cu
->objfile
;
7353 struct attribute
*attr
;
7354 struct fnfieldlist
*flp
;
7356 struct fn_field
*fnp
;
7358 struct nextfnfield
*new_fnfield
;
7359 struct type
*this_type
;
7360 enum dwarf_access_attribute accessibility
;
7362 if (cu
->language
== language_ada
)
7363 error (_("unexpected member function in Ada type"));
7365 /* Get name of member function. */
7366 fieldname
= dwarf2_name (die
, cu
);
7367 if (fieldname
== NULL
)
7370 /* Look up member function name in fieldlist. */
7371 for (i
= 0; i
< fip
->nfnfields
; i
++)
7373 if (strcmp (fip
->fnfieldlists
[i
].name
, fieldname
) == 0)
7377 /* Create new list element if necessary. */
7378 if (i
< fip
->nfnfields
)
7379 flp
= &fip
->fnfieldlists
[i
];
7382 if ((fip
->nfnfields
% DW_FIELD_ALLOC_CHUNK
) == 0)
7384 fip
->fnfieldlists
= (struct fnfieldlist
*)
7385 xrealloc (fip
->fnfieldlists
,
7386 (fip
->nfnfields
+ DW_FIELD_ALLOC_CHUNK
)
7387 * sizeof (struct fnfieldlist
));
7388 if (fip
->nfnfields
== 0)
7389 make_cleanup (free_current_contents
, &fip
->fnfieldlists
);
7391 flp
= &fip
->fnfieldlists
[fip
->nfnfields
];
7392 flp
->name
= fieldname
;
7395 i
= fip
->nfnfields
++;
7398 /* Create a new member function field and chain it to the field list
7400 new_fnfield
= (struct nextfnfield
*) xmalloc (sizeof (struct nextfnfield
));
7401 make_cleanup (xfree
, new_fnfield
);
7402 memset (new_fnfield
, 0, sizeof (struct nextfnfield
));
7403 new_fnfield
->next
= flp
->head
;
7404 flp
->head
= new_fnfield
;
7407 /* Fill in the member function field info. */
7408 fnp
= &new_fnfield
->fnfield
;
7410 /* Delay processing of the physname until later. */
7411 if (cu
->language
== language_cplus
|| cu
->language
== language_java
)
7413 add_to_method_list (type
, i
, flp
->length
- 1, fieldname
,
7418 const char *physname
= dwarf2_physname (fieldname
, die
, cu
);
7419 fnp
->physname
= physname
? physname
: "";
7422 fnp
->type
= alloc_type (objfile
);
7423 this_type
= read_type_die (die
, cu
);
7424 if (this_type
&& TYPE_CODE (this_type
) == TYPE_CODE_FUNC
)
7426 int nparams
= TYPE_NFIELDS (this_type
);
7428 /* TYPE is the domain of this method, and THIS_TYPE is the type
7429 of the method itself (TYPE_CODE_METHOD). */
7430 smash_to_method_type (fnp
->type
, type
,
7431 TYPE_TARGET_TYPE (this_type
),
7432 TYPE_FIELDS (this_type
),
7433 TYPE_NFIELDS (this_type
),
7434 TYPE_VARARGS (this_type
));
7436 /* Handle static member functions.
7437 Dwarf2 has no clean way to discern C++ static and non-static
7438 member functions. G++ helps GDB by marking the first
7439 parameter for non-static member functions (which is the this
7440 pointer) as artificial. We obtain this information from
7441 read_subroutine_type via TYPE_FIELD_ARTIFICIAL. */
7442 if (nparams
== 0 || TYPE_FIELD_ARTIFICIAL (this_type
, 0) == 0)
7443 fnp
->voffset
= VOFFSET_STATIC
;
7446 complaint (&symfile_complaints
, _("member function type missing for '%s'"),
7447 dwarf2_full_name (fieldname
, die
, cu
));
7449 /* Get fcontext from DW_AT_containing_type if present. */
7450 if (dwarf2_attr (die
, DW_AT_containing_type
, cu
) != NULL
)
7451 fnp
->fcontext
= die_containing_type (die
, cu
);
7453 /* dwarf2 doesn't have stubbed physical names, so the setting of is_const and
7454 is_volatile is irrelevant, as it is needed by gdb_mangle_name only. */
7456 /* Get accessibility. */
7457 attr
= dwarf2_attr (die
, DW_AT_accessibility
, cu
);
7459 accessibility
= DW_UNSND (attr
);
7461 accessibility
= dwarf2_default_access_attribute (die
, cu
);
7462 switch (accessibility
)
7464 case DW_ACCESS_private
:
7465 fnp
->is_private
= 1;
7467 case DW_ACCESS_protected
:
7468 fnp
->is_protected
= 1;
7472 /* Check for artificial methods. */
7473 attr
= dwarf2_attr (die
, DW_AT_artificial
, cu
);
7474 if (attr
&& DW_UNSND (attr
) != 0)
7475 fnp
->is_artificial
= 1;
7477 /* Get index in virtual function table if it is a virtual member
7478 function. For older versions of GCC, this is an offset in the
7479 appropriate virtual table, as specified by DW_AT_containing_type.
7480 For everyone else, it is an expression to be evaluated relative
7481 to the object address. */
7483 attr
= dwarf2_attr (die
, DW_AT_vtable_elem_location
, cu
);
7486 if (attr_form_is_block (attr
) && DW_BLOCK (attr
)->size
> 0)
7488 if (DW_BLOCK (attr
)->data
[0] == DW_OP_constu
)
7490 /* Old-style GCC. */
7491 fnp
->voffset
= decode_locdesc (DW_BLOCK (attr
), cu
) + 2;
7493 else if (DW_BLOCK (attr
)->data
[0] == DW_OP_deref
7494 || (DW_BLOCK (attr
)->size
> 1
7495 && DW_BLOCK (attr
)->data
[0] == DW_OP_deref_size
7496 && DW_BLOCK (attr
)->data
[1] == cu
->header
.addr_size
))
7498 struct dwarf_block blk
;
7501 offset
= (DW_BLOCK (attr
)->data
[0] == DW_OP_deref
7503 blk
.size
= DW_BLOCK (attr
)->size
- offset
;
7504 blk
.data
= DW_BLOCK (attr
)->data
+ offset
;
7505 fnp
->voffset
= decode_locdesc (DW_BLOCK (attr
), cu
);
7506 if ((fnp
->voffset
% cu
->header
.addr_size
) != 0)
7507 dwarf2_complex_location_expr_complaint ();
7509 fnp
->voffset
/= cu
->header
.addr_size
;
7513 dwarf2_complex_location_expr_complaint ();
7516 fnp
->fcontext
= TYPE_TARGET_TYPE (TYPE_FIELD_TYPE (this_type
, 0));
7518 else if (attr_form_is_section_offset (attr
))
7520 dwarf2_complex_location_expr_complaint ();
7524 dwarf2_invalid_attrib_class_complaint ("DW_AT_vtable_elem_location",
7530 attr
= dwarf2_attr (die
, DW_AT_virtuality
, cu
);
7531 if (attr
&& DW_UNSND (attr
))
7533 /* GCC does this, as of 2008-08-25; PR debug/37237. */
7534 complaint (&symfile_complaints
,
7535 _("Member function \"%s\" (offset %d) is virtual "
7536 "but the vtable offset is not specified"),
7537 fieldname
, die
->offset
);
7538 ALLOCATE_CPLUS_STRUCT_TYPE (type
);
7539 TYPE_CPLUS_DYNAMIC (type
) = 1;
7544 /* Create the vector of member function fields, and attach it to the type. */
7547 dwarf2_attach_fn_fields_to_type (struct field_info
*fip
, struct type
*type
,
7548 struct dwarf2_cu
*cu
)
7550 struct fnfieldlist
*flp
;
7551 int total_length
= 0;
7554 if (cu
->language
== language_ada
)
7555 error (_("unexpected member functions in Ada type"));
7557 ALLOCATE_CPLUS_STRUCT_TYPE (type
);
7558 TYPE_FN_FIELDLISTS (type
) = (struct fn_fieldlist
*)
7559 TYPE_ALLOC (type
, sizeof (struct fn_fieldlist
) * fip
->nfnfields
);
7561 for (i
= 0, flp
= fip
->fnfieldlists
; i
< fip
->nfnfields
; i
++, flp
++)
7563 struct nextfnfield
*nfp
= flp
->head
;
7564 struct fn_fieldlist
*fn_flp
= &TYPE_FN_FIELDLIST (type
, i
);
7567 TYPE_FN_FIELDLIST_NAME (type
, i
) = flp
->name
;
7568 TYPE_FN_FIELDLIST_LENGTH (type
, i
) = flp
->length
;
7569 fn_flp
->fn_fields
= (struct fn_field
*)
7570 TYPE_ALLOC (type
, sizeof (struct fn_field
) * flp
->length
);
7571 for (k
= flp
->length
; (k
--, nfp
); nfp
= nfp
->next
)
7572 fn_flp
->fn_fields
[k
] = nfp
->fnfield
;
7574 total_length
+= flp
->length
;
7577 TYPE_NFN_FIELDS (type
) = fip
->nfnfields
;
7578 TYPE_NFN_FIELDS_TOTAL (type
) = total_length
;
7581 /* Returns non-zero if NAME is the name of a vtable member in CU's
7582 language, zero otherwise. */
7584 is_vtable_name (const char *name
, struct dwarf2_cu
*cu
)
7586 static const char vptr
[] = "_vptr";
7587 static const char vtable
[] = "vtable";
7589 /* Look for the C++ and Java forms of the vtable. */
7590 if ((cu
->language
== language_java
7591 && strncmp (name
, vtable
, sizeof (vtable
) - 1) == 0)
7592 || (strncmp (name
, vptr
, sizeof (vptr
) - 1) == 0
7593 && is_cplus_marker (name
[sizeof (vptr
) - 1])))
7599 /* GCC outputs unnamed structures that are really pointers to member
7600 functions, with the ABI-specified layout. If TYPE describes
7601 such a structure, smash it into a member function type.
7603 GCC shouldn't do this; it should just output pointer to member DIEs.
7604 This is GCC PR debug/28767. */
7607 quirk_gcc_member_function_pointer (struct type
*type
, struct objfile
*objfile
)
7609 struct type
*pfn_type
, *domain_type
, *new_type
;
7611 /* Check for a structure with no name and two children. */
7612 if (TYPE_CODE (type
) != TYPE_CODE_STRUCT
|| TYPE_NFIELDS (type
) != 2)
7615 /* Check for __pfn and __delta members. */
7616 if (TYPE_FIELD_NAME (type
, 0) == NULL
7617 || strcmp (TYPE_FIELD_NAME (type
, 0), "__pfn") != 0
7618 || TYPE_FIELD_NAME (type
, 1) == NULL
7619 || strcmp (TYPE_FIELD_NAME (type
, 1), "__delta") != 0)
7622 /* Find the type of the method. */
7623 pfn_type
= TYPE_FIELD_TYPE (type
, 0);
7624 if (pfn_type
== NULL
7625 || TYPE_CODE (pfn_type
) != TYPE_CODE_PTR
7626 || TYPE_CODE (TYPE_TARGET_TYPE (pfn_type
)) != TYPE_CODE_FUNC
)
7629 /* Look for the "this" argument. */
7630 pfn_type
= TYPE_TARGET_TYPE (pfn_type
);
7631 if (TYPE_NFIELDS (pfn_type
) == 0
7632 /* || TYPE_FIELD_TYPE (pfn_type, 0) == NULL */
7633 || TYPE_CODE (TYPE_FIELD_TYPE (pfn_type
, 0)) != TYPE_CODE_PTR
)
7636 domain_type
= TYPE_TARGET_TYPE (TYPE_FIELD_TYPE (pfn_type
, 0));
7637 new_type
= alloc_type (objfile
);
7638 smash_to_method_type (new_type
, domain_type
, TYPE_TARGET_TYPE (pfn_type
),
7639 TYPE_FIELDS (pfn_type
), TYPE_NFIELDS (pfn_type
),
7640 TYPE_VARARGS (pfn_type
));
7641 smash_to_methodptr_type (type
, new_type
);
7644 /* Called when we find the DIE that starts a structure or union scope
7645 (definition) to create a type for the structure or union. Fill in
7646 the type's name and general properties; the members will not be
7647 processed until process_structure_type.
7649 NOTE: we need to call these functions regardless of whether or not the
7650 DIE has a DW_AT_name attribute, since it might be an anonymous
7651 structure or union. This gets the type entered into our set of
7654 However, if the structure is incomplete (an opaque struct/union)
7655 then suppress creating a symbol table entry for it since gdb only
7656 wants to find the one with the complete definition. Note that if
7657 it is complete, we just call new_symbol, which does it's own
7658 checking about whether the struct/union is anonymous or not (and
7659 suppresses creating a symbol table entry itself). */
7661 static struct type
*
7662 read_structure_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
7664 struct objfile
*objfile
= cu
->objfile
;
7666 struct attribute
*attr
;
7669 /* If the definition of this type lives in .debug_types, read that type.
7670 Don't follow DW_AT_specification though, that will take us back up
7671 the chain and we want to go down. */
7672 attr
= dwarf2_attr_no_follow (die
, DW_AT_signature
, cu
);
7675 struct dwarf2_cu
*type_cu
= cu
;
7676 struct die_info
*type_die
= follow_die_ref_or_sig (die
, attr
, &type_cu
);
7678 /* We could just recurse on read_structure_type, but we need to call
7679 get_die_type to ensure only one type for this DIE is created.
7680 This is important, for example, because for c++ classes we need
7681 TYPE_NAME set which is only done by new_symbol. Blech. */
7682 type
= read_type_die (type_die
, type_cu
);
7684 /* TYPE_CU may not be the same as CU.
7685 Ensure TYPE is recorded in CU's type_hash table. */
7686 return set_die_type (die
, type
, cu
);
7689 type
= alloc_type (objfile
);
7690 INIT_CPLUS_SPECIFIC (type
);
7692 name
= dwarf2_name (die
, cu
);
7695 if (cu
->language
== language_cplus
7696 || cu
->language
== language_java
)
7698 char *full_name
= (char *) dwarf2_full_name (name
, die
, cu
);
7700 /* dwarf2_full_name might have already finished building the DIE's
7701 type. If so, there is no need to continue. */
7702 if (get_die_type (die
, cu
) != NULL
)
7703 return get_die_type (die
, cu
);
7705 TYPE_TAG_NAME (type
) = full_name
;
7706 if (die
->tag
== DW_TAG_structure_type
7707 || die
->tag
== DW_TAG_class_type
)
7708 TYPE_NAME (type
) = TYPE_TAG_NAME (type
);
7712 /* The name is already allocated along with this objfile, so
7713 we don't need to duplicate it for the type. */
7714 TYPE_TAG_NAME (type
) = (char *) name
;
7715 if (die
->tag
== DW_TAG_class_type
)
7716 TYPE_NAME (type
) = TYPE_TAG_NAME (type
);
7720 if (die
->tag
== DW_TAG_structure_type
)
7722 TYPE_CODE (type
) = TYPE_CODE_STRUCT
;
7724 else if (die
->tag
== DW_TAG_union_type
)
7726 TYPE_CODE (type
) = TYPE_CODE_UNION
;
7730 TYPE_CODE (type
) = TYPE_CODE_CLASS
;
7733 if (cu
->language
== language_cplus
&& die
->tag
== DW_TAG_class_type
)
7734 TYPE_DECLARED_CLASS (type
) = 1;
7736 attr
= dwarf2_attr (die
, DW_AT_byte_size
, cu
);
7739 TYPE_LENGTH (type
) = DW_UNSND (attr
);
7743 TYPE_LENGTH (type
) = 0;
7746 TYPE_STUB_SUPPORTED (type
) = 1;
7747 if (die_is_declaration (die
, cu
))
7748 TYPE_STUB (type
) = 1;
7749 else if (attr
== NULL
&& die
->child
== NULL
7750 && producer_is_realview (cu
->producer
))
7751 /* RealView does not output the required DW_AT_declaration
7752 on incomplete types. */
7753 TYPE_STUB (type
) = 1;
7755 /* We need to add the type field to the die immediately so we don't
7756 infinitely recurse when dealing with pointers to the structure
7757 type within the structure itself. */
7758 set_die_type (die
, type
, cu
);
7760 /* set_die_type should be already done. */
7761 set_descriptive_type (type
, die
, cu
);
7766 /* Finish creating a structure or union type, including filling in
7767 its members and creating a symbol for it. */
7770 process_structure_scope (struct die_info
*die
, struct dwarf2_cu
*cu
)
7772 struct objfile
*objfile
= cu
->objfile
;
7773 struct die_info
*child_die
= die
->child
;
7776 type
= get_die_type (die
, cu
);
7778 type
= read_structure_type (die
, cu
);
7780 if (die
->child
!= NULL
&& ! die_is_declaration (die
, cu
))
7782 struct field_info fi
;
7783 struct die_info
*child_die
;
7784 VEC (symbolp
) *template_args
= NULL
;
7785 struct cleanup
*back_to
= make_cleanup (null_cleanup
, 0);
7787 memset (&fi
, 0, sizeof (struct field_info
));
7789 child_die
= die
->child
;
7791 while (child_die
&& child_die
->tag
)
7793 if (child_die
->tag
== DW_TAG_member
7794 || child_die
->tag
== DW_TAG_variable
)
7796 /* NOTE: carlton/2002-11-05: A C++ static data member
7797 should be a DW_TAG_member that is a declaration, but
7798 all versions of G++ as of this writing (so through at
7799 least 3.2.1) incorrectly generate DW_TAG_variable
7800 tags for them instead. */
7801 dwarf2_add_field (&fi
, child_die
, cu
);
7803 else if (child_die
->tag
== DW_TAG_subprogram
)
7805 /* C++ member function. */
7806 dwarf2_add_member_fn (&fi
, child_die
, type
, cu
);
7808 else if (child_die
->tag
== DW_TAG_inheritance
)
7810 /* C++ base class field. */
7811 dwarf2_add_field (&fi
, child_die
, cu
);
7813 else if (child_die
->tag
== DW_TAG_typedef
)
7814 dwarf2_add_typedef (&fi
, child_die
, cu
);
7815 else if (child_die
->tag
== DW_TAG_template_type_param
7816 || child_die
->tag
== DW_TAG_template_value_param
)
7818 struct symbol
*arg
= new_symbol (child_die
, NULL
, cu
);
7821 VEC_safe_push (symbolp
, template_args
, arg
);
7824 child_die
= sibling_die (child_die
);
7827 /* Attach template arguments to type. */
7828 if (! VEC_empty (symbolp
, template_args
))
7830 ALLOCATE_CPLUS_STRUCT_TYPE (type
);
7831 TYPE_N_TEMPLATE_ARGUMENTS (type
)
7832 = VEC_length (symbolp
, template_args
);
7833 TYPE_TEMPLATE_ARGUMENTS (type
)
7834 = obstack_alloc (&objfile
->objfile_obstack
,
7835 (TYPE_N_TEMPLATE_ARGUMENTS (type
)
7836 * sizeof (struct symbol
*)));
7837 memcpy (TYPE_TEMPLATE_ARGUMENTS (type
),
7838 VEC_address (symbolp
, template_args
),
7839 (TYPE_N_TEMPLATE_ARGUMENTS (type
)
7840 * sizeof (struct symbol
*)));
7841 VEC_free (symbolp
, template_args
);
7844 /* Attach fields and member functions to the type. */
7846 dwarf2_attach_fields_to_type (&fi
, type
, cu
);
7849 dwarf2_attach_fn_fields_to_type (&fi
, type
, cu
);
7851 /* Get the type which refers to the base class (possibly this
7852 class itself) which contains the vtable pointer for the current
7853 class from the DW_AT_containing_type attribute. This use of
7854 DW_AT_containing_type is a GNU extension. */
7856 if (dwarf2_attr (die
, DW_AT_containing_type
, cu
) != NULL
)
7858 struct type
*t
= die_containing_type (die
, cu
);
7860 TYPE_VPTR_BASETYPE (type
) = t
;
7865 /* Our own class provides vtbl ptr. */
7866 for (i
= TYPE_NFIELDS (t
) - 1;
7867 i
>= TYPE_N_BASECLASSES (t
);
7870 char *fieldname
= TYPE_FIELD_NAME (t
, i
);
7872 if (is_vtable_name (fieldname
, cu
))
7874 TYPE_VPTR_FIELDNO (type
) = i
;
7879 /* Complain if virtual function table field not found. */
7880 if (i
< TYPE_N_BASECLASSES (t
))
7881 complaint (&symfile_complaints
,
7882 _("virtual function table pointer "
7883 "not found when defining class '%s'"),
7884 TYPE_TAG_NAME (type
) ? TYPE_TAG_NAME (type
) :
7889 TYPE_VPTR_FIELDNO (type
) = TYPE_VPTR_FIELDNO (t
);
7892 else if (cu
->producer
7893 && strncmp (cu
->producer
,
7894 "IBM(R) XL C/C++ Advanced Edition", 32) == 0)
7896 /* The IBM XLC compiler does not provide direct indication
7897 of the containing type, but the vtable pointer is
7898 always named __vfp. */
7902 for (i
= TYPE_NFIELDS (type
) - 1;
7903 i
>= TYPE_N_BASECLASSES (type
);
7906 if (strcmp (TYPE_FIELD_NAME (type
, i
), "__vfp") == 0)
7908 TYPE_VPTR_FIELDNO (type
) = i
;
7909 TYPE_VPTR_BASETYPE (type
) = type
;
7916 /* Copy fi.typedef_field_list linked list elements content into the
7917 allocated array TYPE_TYPEDEF_FIELD_ARRAY (type). */
7918 if (fi
.typedef_field_list
)
7920 int i
= fi
.typedef_field_list_count
;
7922 ALLOCATE_CPLUS_STRUCT_TYPE (type
);
7923 TYPE_TYPEDEF_FIELD_ARRAY (type
)
7924 = TYPE_ALLOC (type
, sizeof (TYPE_TYPEDEF_FIELD (type
, 0)) * i
);
7925 TYPE_TYPEDEF_FIELD_COUNT (type
) = i
;
7927 /* Reverse the list order to keep the debug info elements order. */
7930 struct typedef_field
*dest
, *src
;
7932 dest
= &TYPE_TYPEDEF_FIELD (type
, i
);
7933 src
= &fi
.typedef_field_list
->field
;
7934 fi
.typedef_field_list
= fi
.typedef_field_list
->next
;
7939 do_cleanups (back_to
);
7941 if (HAVE_CPLUS_STRUCT (type
))
7942 TYPE_CPLUS_REALLY_JAVA (type
) = cu
->language
== language_java
;
7945 quirk_gcc_member_function_pointer (type
, cu
->objfile
);
7947 /* NOTE: carlton/2004-03-16: GCC 3.4 (or at least one of its
7948 snapshots) has been known to create a die giving a declaration
7949 for a class that has, as a child, a die giving a definition for a
7950 nested class. So we have to process our children even if the
7951 current die is a declaration. Normally, of course, a declaration
7952 won't have any children at all. */
7954 while (child_die
!= NULL
&& child_die
->tag
)
7956 if (child_die
->tag
== DW_TAG_member
7957 || child_die
->tag
== DW_TAG_variable
7958 || child_die
->tag
== DW_TAG_inheritance
7959 || child_die
->tag
== DW_TAG_template_value_param
7960 || child_die
->tag
== DW_TAG_template_type_param
)
7965 process_die (child_die
, cu
);
7967 child_die
= sibling_die (child_die
);
7970 /* Do not consider external references. According to the DWARF standard,
7971 these DIEs are identified by the fact that they have no byte_size
7972 attribute, and a declaration attribute. */
7973 if (dwarf2_attr (die
, DW_AT_byte_size
, cu
) != NULL
7974 || !die_is_declaration (die
, cu
))
7975 new_symbol (die
, type
, cu
);
7978 /* Given a DW_AT_enumeration_type die, set its type. We do not
7979 complete the type's fields yet, or create any symbols. */
7981 static struct type
*
7982 read_enumeration_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
7984 struct objfile
*objfile
= cu
->objfile
;
7986 struct attribute
*attr
;
7989 /* If the definition of this type lives in .debug_types, read that type.
7990 Don't follow DW_AT_specification though, that will take us back up
7991 the chain and we want to go down. */
7992 attr
= dwarf2_attr_no_follow (die
, DW_AT_signature
, cu
);
7995 struct dwarf2_cu
*type_cu
= cu
;
7996 struct die_info
*type_die
= follow_die_ref_or_sig (die
, attr
, &type_cu
);
7998 type
= read_type_die (type_die
, type_cu
);
8000 /* TYPE_CU may not be the same as CU.
8001 Ensure TYPE is recorded in CU's type_hash table. */
8002 return set_die_type (die
, type
, cu
);
8005 type
= alloc_type (objfile
);
8007 TYPE_CODE (type
) = TYPE_CODE_ENUM
;
8008 name
= dwarf2_full_name (NULL
, die
, cu
);
8010 TYPE_TAG_NAME (type
) = (char *) name
;
8012 attr
= dwarf2_attr (die
, DW_AT_byte_size
, cu
);
8015 TYPE_LENGTH (type
) = DW_UNSND (attr
);
8019 TYPE_LENGTH (type
) = 0;
8022 /* The enumeration DIE can be incomplete. In Ada, any type can be
8023 declared as private in the package spec, and then defined only
8024 inside the package body. Such types are known as Taft Amendment
8025 Types. When another package uses such a type, an incomplete DIE
8026 may be generated by the compiler. */
8027 if (die_is_declaration (die
, cu
))
8028 TYPE_STUB (type
) = 1;
8030 return set_die_type (die
, type
, cu
);
8033 /* Given a pointer to a die which begins an enumeration, process all
8034 the dies that define the members of the enumeration, and create the
8035 symbol for the enumeration type.
8037 NOTE: We reverse the order of the element list. */
8040 process_enumeration_scope (struct die_info
*die
, struct dwarf2_cu
*cu
)
8042 struct type
*this_type
;
8044 this_type
= get_die_type (die
, cu
);
8045 if (this_type
== NULL
)
8046 this_type
= read_enumeration_type (die
, cu
);
8048 if (die
->child
!= NULL
)
8050 struct die_info
*child_die
;
8052 struct field
*fields
= NULL
;
8054 int unsigned_enum
= 1;
8057 child_die
= die
->child
;
8058 while (child_die
&& child_die
->tag
)
8060 if (child_die
->tag
!= DW_TAG_enumerator
)
8062 process_die (child_die
, cu
);
8066 name
= dwarf2_name (child_die
, cu
);
8069 sym
= new_symbol (child_die
, this_type
, cu
);
8070 if (SYMBOL_VALUE (sym
) < 0)
8073 if ((num_fields
% DW_FIELD_ALLOC_CHUNK
) == 0)
8075 fields
= (struct field
*)
8077 (num_fields
+ DW_FIELD_ALLOC_CHUNK
)
8078 * sizeof (struct field
));
8081 FIELD_NAME (fields
[num_fields
]) = SYMBOL_LINKAGE_NAME (sym
);
8082 FIELD_TYPE (fields
[num_fields
]) = NULL
;
8083 SET_FIELD_BITPOS (fields
[num_fields
], SYMBOL_VALUE (sym
));
8084 FIELD_BITSIZE (fields
[num_fields
]) = 0;
8090 child_die
= sibling_die (child_die
);
8095 TYPE_NFIELDS (this_type
) = num_fields
;
8096 TYPE_FIELDS (this_type
) = (struct field
*)
8097 TYPE_ALLOC (this_type
, sizeof (struct field
) * num_fields
);
8098 memcpy (TYPE_FIELDS (this_type
), fields
,
8099 sizeof (struct field
) * num_fields
);
8103 TYPE_UNSIGNED (this_type
) = 1;
8106 /* If we are reading an enum from a .debug_types unit, and the enum
8107 is a declaration, and the enum is not the signatured type in the
8108 unit, then we do not want to add a symbol for it. Adding a
8109 symbol would in some cases obscure the true definition of the
8110 enum, giving users an incomplete type when the definition is
8111 actually available. Note that we do not want to do this for all
8112 enums which are just declarations, because C++0x allows forward
8113 enum declarations. */
8114 if (cu
->per_cu
->debug_type_section
8115 && die_is_declaration (die
, cu
))
8117 struct signatured_type
*type_sig
;
8120 = lookup_signatured_type_at_offset (dwarf2_per_objfile
->objfile
,
8121 cu
->per_cu
->debug_type_section
,
8122 cu
->per_cu
->offset
);
8123 if (type_sig
->type_offset
!= die
->offset
)
8127 new_symbol (die
, this_type
, cu
);
8130 /* Extract all information from a DW_TAG_array_type DIE and put it in
8131 the DIE's type field. For now, this only handles one dimensional
8134 static struct type
*
8135 read_array_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
8137 struct objfile
*objfile
= cu
->objfile
;
8138 struct die_info
*child_die
;
8140 struct type
*element_type
, *range_type
, *index_type
;
8141 struct type
**range_types
= NULL
;
8142 struct attribute
*attr
;
8144 struct cleanup
*back_to
;
8147 element_type
= die_type (die
, cu
);
8149 /* The die_type call above may have already set the type for this DIE. */
8150 type
= get_die_type (die
, cu
);
8154 /* Irix 6.2 native cc creates array types without children for
8155 arrays with unspecified length. */
8156 if (die
->child
== NULL
)
8158 index_type
= objfile_type (objfile
)->builtin_int
;
8159 range_type
= create_range_type (NULL
, index_type
, 0, -1);
8160 type
= create_array_type (NULL
, element_type
, range_type
);
8161 return set_die_type (die
, type
, cu
);
8164 back_to
= make_cleanup (null_cleanup
, NULL
);
8165 child_die
= die
->child
;
8166 while (child_die
&& child_die
->tag
)
8168 if (child_die
->tag
== DW_TAG_subrange_type
)
8170 struct type
*child_type
= read_type_die (child_die
, cu
);
8172 if (child_type
!= NULL
)
8174 /* The range type was succesfully read. Save it for the
8175 array type creation. */
8176 if ((ndim
% DW_FIELD_ALLOC_CHUNK
) == 0)
8178 range_types
= (struct type
**)
8179 xrealloc (range_types
, (ndim
+ DW_FIELD_ALLOC_CHUNK
)
8180 * sizeof (struct type
*));
8182 make_cleanup (free_current_contents
, &range_types
);
8184 range_types
[ndim
++] = child_type
;
8187 child_die
= sibling_die (child_die
);
8190 /* Dwarf2 dimensions are output from left to right, create the
8191 necessary array types in backwards order. */
8193 type
= element_type
;
8195 if (read_array_order (die
, cu
) == DW_ORD_col_major
)
8200 type
= create_array_type (NULL
, type
, range_types
[i
++]);
8205 type
= create_array_type (NULL
, type
, range_types
[ndim
]);
8208 /* Understand Dwarf2 support for vector types (like they occur on
8209 the PowerPC w/ AltiVec). Gcc just adds another attribute to the
8210 array type. This is not part of the Dwarf2/3 standard yet, but a
8211 custom vendor extension. The main difference between a regular
8212 array and the vector variant is that vectors are passed by value
8214 attr
= dwarf2_attr (die
, DW_AT_GNU_vector
, cu
);
8216 make_vector_type (type
);
8218 /* The DIE may have DW_AT_byte_size set. For example an OpenCL
8219 implementation may choose to implement triple vectors using this
8221 attr
= dwarf2_attr (die
, DW_AT_byte_size
, cu
);
8224 if (DW_UNSND (attr
) >= TYPE_LENGTH (type
))
8225 TYPE_LENGTH (type
) = DW_UNSND (attr
);
8227 complaint (&symfile_complaints
,
8228 _("DW_AT_byte_size for array type smaller "
8229 "than the total size of elements"));
8232 name
= dwarf2_name (die
, cu
);
8234 TYPE_NAME (type
) = name
;
8236 /* Install the type in the die. */
8237 set_die_type (die
, type
, cu
);
8239 /* set_die_type should be already done. */
8240 set_descriptive_type (type
, die
, cu
);
8242 do_cleanups (back_to
);
8247 static enum dwarf_array_dim_ordering
8248 read_array_order (struct die_info
*die
, struct dwarf2_cu
*cu
)
8250 struct attribute
*attr
;
8252 attr
= dwarf2_attr (die
, DW_AT_ordering
, cu
);
8254 if (attr
) return DW_SND (attr
);
8256 /* GNU F77 is a special case, as at 08/2004 array type info is the
8257 opposite order to the dwarf2 specification, but data is still
8258 laid out as per normal fortran.
8260 FIXME: dsl/2004-8-20: If G77 is ever fixed, this will also need
8261 version checking. */
8263 if (cu
->language
== language_fortran
8264 && cu
->producer
&& strstr (cu
->producer
, "GNU F77"))
8266 return DW_ORD_row_major
;
8269 switch (cu
->language_defn
->la_array_ordering
)
8271 case array_column_major
:
8272 return DW_ORD_col_major
;
8273 case array_row_major
:
8275 return DW_ORD_row_major
;
8279 /* Extract all information from a DW_TAG_set_type DIE and put it in
8280 the DIE's type field. */
8282 static struct type
*
8283 read_set_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
8285 struct type
*domain_type
, *set_type
;
8286 struct attribute
*attr
;
8288 domain_type
= die_type (die
, cu
);
8290 /* The die_type call above may have already set the type for this DIE. */
8291 set_type
= get_die_type (die
, cu
);
8295 set_type
= create_set_type (NULL
, domain_type
);
8297 attr
= dwarf2_attr (die
, DW_AT_byte_size
, cu
);
8299 TYPE_LENGTH (set_type
) = DW_UNSND (attr
);
8301 return set_die_type (die
, set_type
, cu
);
8304 /* First cut: install each common block member as a global variable. */
8307 read_common_block (struct die_info
*die
, struct dwarf2_cu
*cu
)
8309 struct die_info
*child_die
;
8310 struct attribute
*attr
;
8312 CORE_ADDR base
= (CORE_ADDR
) 0;
8314 attr
= dwarf2_attr (die
, DW_AT_location
, cu
);
8317 /* Support the .debug_loc offsets. */
8318 if (attr_form_is_block (attr
))
8320 base
= decode_locdesc (DW_BLOCK (attr
), cu
);
8322 else if (attr_form_is_section_offset (attr
))
8324 dwarf2_complex_location_expr_complaint ();
8328 dwarf2_invalid_attrib_class_complaint ("DW_AT_location",
8329 "common block member");
8332 if (die
->child
!= NULL
)
8334 child_die
= die
->child
;
8335 while (child_die
&& child_die
->tag
)
8339 sym
= new_symbol (child_die
, NULL
, cu
);
8341 && handle_data_member_location (child_die
, cu
, &offset
))
8343 SYMBOL_VALUE_ADDRESS (sym
) = base
+ offset
;
8344 add_symbol_to_list (sym
, &global_symbols
);
8346 child_die
= sibling_die (child_die
);
8351 /* Create a type for a C++ namespace. */
8353 static struct type
*
8354 read_namespace_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
8356 struct objfile
*objfile
= cu
->objfile
;
8357 const char *previous_prefix
, *name
;
8361 /* For extensions, reuse the type of the original namespace. */
8362 if (dwarf2_attr (die
, DW_AT_extension
, cu
) != NULL
)
8364 struct die_info
*ext_die
;
8365 struct dwarf2_cu
*ext_cu
= cu
;
8367 ext_die
= dwarf2_extension (die
, &ext_cu
);
8368 type
= read_type_die (ext_die
, ext_cu
);
8370 /* EXT_CU may not be the same as CU.
8371 Ensure TYPE is recorded in CU's type_hash table. */
8372 return set_die_type (die
, type
, cu
);
8375 name
= namespace_name (die
, &is_anonymous
, cu
);
8377 /* Now build the name of the current namespace. */
8379 previous_prefix
= determine_prefix (die
, cu
);
8380 if (previous_prefix
[0] != '\0')
8381 name
= typename_concat (&objfile
->objfile_obstack
,
8382 previous_prefix
, name
, 0, cu
);
8384 /* Create the type. */
8385 type
= init_type (TYPE_CODE_NAMESPACE
, 0, 0, NULL
,
8387 TYPE_NAME (type
) = (char *) name
;
8388 TYPE_TAG_NAME (type
) = TYPE_NAME (type
);
8390 return set_die_type (die
, type
, cu
);
8393 /* Read a C++ namespace. */
8396 read_namespace (struct die_info
*die
, struct dwarf2_cu
*cu
)
8398 struct objfile
*objfile
= cu
->objfile
;
8401 /* Add a symbol associated to this if we haven't seen the namespace
8402 before. Also, add a using directive if it's an anonymous
8405 if (dwarf2_attr (die
, DW_AT_extension
, cu
) == NULL
)
8409 type
= read_type_die (die
, cu
);
8410 new_symbol (die
, type
, cu
);
8412 namespace_name (die
, &is_anonymous
, cu
);
8415 const char *previous_prefix
= determine_prefix (die
, cu
);
8417 cp_add_using_directive (previous_prefix
, TYPE_NAME (type
), NULL
,
8418 NULL
, NULL
, &objfile
->objfile_obstack
);
8422 if (die
->child
!= NULL
)
8424 struct die_info
*child_die
= die
->child
;
8426 while (child_die
&& child_die
->tag
)
8428 process_die (child_die
, cu
);
8429 child_die
= sibling_die (child_die
);
8434 /* Read a Fortran module as type. This DIE can be only a declaration used for
8435 imported module. Still we need that type as local Fortran "use ... only"
8436 declaration imports depend on the created type in determine_prefix. */
8438 static struct type
*
8439 read_module_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
8441 struct objfile
*objfile
= cu
->objfile
;
8445 module_name
= dwarf2_name (die
, cu
);
8447 complaint (&symfile_complaints
,
8448 _("DW_TAG_module has no name, offset 0x%x"),
8450 type
= init_type (TYPE_CODE_MODULE
, 0, 0, module_name
, objfile
);
8452 /* determine_prefix uses TYPE_TAG_NAME. */
8453 TYPE_TAG_NAME (type
) = TYPE_NAME (type
);
8455 return set_die_type (die
, type
, cu
);
8458 /* Read a Fortran module. */
8461 read_module (struct die_info
*die
, struct dwarf2_cu
*cu
)
8463 struct die_info
*child_die
= die
->child
;
8465 while (child_die
&& child_die
->tag
)
8467 process_die (child_die
, cu
);
8468 child_die
= sibling_die (child_die
);
8472 /* Return the name of the namespace represented by DIE. Set
8473 *IS_ANONYMOUS to tell whether or not the namespace is an anonymous
8477 namespace_name (struct die_info
*die
, int *is_anonymous
, struct dwarf2_cu
*cu
)
8479 struct die_info
*current_die
;
8480 const char *name
= NULL
;
8482 /* Loop through the extensions until we find a name. */
8484 for (current_die
= die
;
8485 current_die
!= NULL
;
8486 current_die
= dwarf2_extension (die
, &cu
))
8488 name
= dwarf2_name (current_die
, cu
);
8493 /* Is it an anonymous namespace? */
8495 *is_anonymous
= (name
== NULL
);
8497 name
= CP_ANONYMOUS_NAMESPACE_STR
;
8502 /* Extract all information from a DW_TAG_pointer_type DIE and add to
8503 the user defined type vector. */
8505 static struct type
*
8506 read_tag_pointer_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
8508 struct gdbarch
*gdbarch
= get_objfile_arch (cu
->objfile
);
8509 struct comp_unit_head
*cu_header
= &cu
->header
;
8511 struct attribute
*attr_byte_size
;
8512 struct attribute
*attr_address_class
;
8513 int byte_size
, addr_class
;
8514 struct type
*target_type
;
8516 target_type
= die_type (die
, cu
);
8518 /* The die_type call above may have already set the type for this DIE. */
8519 type
= get_die_type (die
, cu
);
8523 type
= lookup_pointer_type (target_type
);
8525 attr_byte_size
= dwarf2_attr (die
, DW_AT_byte_size
, cu
);
8527 byte_size
= DW_UNSND (attr_byte_size
);
8529 byte_size
= cu_header
->addr_size
;
8531 attr_address_class
= dwarf2_attr (die
, DW_AT_address_class
, cu
);
8532 if (attr_address_class
)
8533 addr_class
= DW_UNSND (attr_address_class
);
8535 addr_class
= DW_ADDR_none
;
8537 /* If the pointer size or address class is different than the
8538 default, create a type variant marked as such and set the
8539 length accordingly. */
8540 if (TYPE_LENGTH (type
) != byte_size
|| addr_class
!= DW_ADDR_none
)
8542 if (gdbarch_address_class_type_flags_p (gdbarch
))
8546 type_flags
= gdbarch_address_class_type_flags
8547 (gdbarch
, byte_size
, addr_class
);
8548 gdb_assert ((type_flags
& ~TYPE_INSTANCE_FLAG_ADDRESS_CLASS_ALL
)
8550 type
= make_type_with_address_space (type
, type_flags
);
8552 else if (TYPE_LENGTH (type
) != byte_size
)
8554 complaint (&symfile_complaints
,
8555 _("invalid pointer size %d"), byte_size
);
8559 /* Should we also complain about unhandled address classes? */
8563 TYPE_LENGTH (type
) = byte_size
;
8564 return set_die_type (die
, type
, cu
);
8567 /* Extract all information from a DW_TAG_ptr_to_member_type DIE and add to
8568 the user defined type vector. */
8570 static struct type
*
8571 read_tag_ptr_to_member_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
8574 struct type
*to_type
;
8575 struct type
*domain
;
8577 to_type
= die_type (die
, cu
);
8578 domain
= die_containing_type (die
, cu
);
8580 /* The calls above may have already set the type for this DIE. */
8581 type
= get_die_type (die
, cu
);
8585 if (TYPE_CODE (check_typedef (to_type
)) == TYPE_CODE_METHOD
)
8586 type
= lookup_methodptr_type (to_type
);
8588 type
= lookup_memberptr_type (to_type
, domain
);
8590 return set_die_type (die
, type
, cu
);
8593 /* Extract all information from a DW_TAG_reference_type DIE and add to
8594 the user defined type vector. */
8596 static struct type
*
8597 read_tag_reference_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
8599 struct comp_unit_head
*cu_header
= &cu
->header
;
8600 struct type
*type
, *target_type
;
8601 struct attribute
*attr
;
8603 target_type
= die_type (die
, cu
);
8605 /* The die_type call above may have already set the type for this DIE. */
8606 type
= get_die_type (die
, cu
);
8610 type
= lookup_reference_type (target_type
);
8611 attr
= dwarf2_attr (die
, DW_AT_byte_size
, cu
);
8614 TYPE_LENGTH (type
) = DW_UNSND (attr
);
8618 TYPE_LENGTH (type
) = cu_header
->addr_size
;
8620 return set_die_type (die
, type
, cu
);
8623 static struct type
*
8624 read_tag_const_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
8626 struct type
*base_type
, *cv_type
;
8628 base_type
= die_type (die
, cu
);
8630 /* The die_type call above may have already set the type for this DIE. */
8631 cv_type
= get_die_type (die
, cu
);
8635 /* In case the const qualifier is applied to an array type, the element type
8636 is so qualified, not the array type (section 6.7.3 of C99). */
8637 if (TYPE_CODE (base_type
) == TYPE_CODE_ARRAY
)
8639 struct type
*el_type
, *inner_array
;
8641 base_type
= copy_type (base_type
);
8642 inner_array
= base_type
;
8644 while (TYPE_CODE (TYPE_TARGET_TYPE (inner_array
)) == TYPE_CODE_ARRAY
)
8646 TYPE_TARGET_TYPE (inner_array
) =
8647 copy_type (TYPE_TARGET_TYPE (inner_array
));
8648 inner_array
= TYPE_TARGET_TYPE (inner_array
);
8651 el_type
= TYPE_TARGET_TYPE (inner_array
);
8652 TYPE_TARGET_TYPE (inner_array
) =
8653 make_cv_type (1, TYPE_VOLATILE (el_type
), el_type
, NULL
);
8655 return set_die_type (die
, base_type
, cu
);
8658 cv_type
= make_cv_type (1, TYPE_VOLATILE (base_type
), base_type
, 0);
8659 return set_die_type (die
, cv_type
, cu
);
8662 static struct type
*
8663 read_tag_volatile_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
8665 struct type
*base_type
, *cv_type
;
8667 base_type
= die_type (die
, cu
);
8669 /* The die_type call above may have already set the type for this DIE. */
8670 cv_type
= get_die_type (die
, cu
);
8674 cv_type
= make_cv_type (TYPE_CONST (base_type
), 1, base_type
, 0);
8675 return set_die_type (die
, cv_type
, cu
);
8678 /* Extract all information from a DW_TAG_string_type DIE and add to
8679 the user defined type vector. It isn't really a user defined type,
8680 but it behaves like one, with other DIE's using an AT_user_def_type
8681 attribute to reference it. */
8683 static struct type
*
8684 read_tag_string_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
8686 struct objfile
*objfile
= cu
->objfile
;
8687 struct gdbarch
*gdbarch
= get_objfile_arch (objfile
);
8688 struct type
*type
, *range_type
, *index_type
, *char_type
;
8689 struct attribute
*attr
;
8690 unsigned int length
;
8692 attr
= dwarf2_attr (die
, DW_AT_string_length
, cu
);
8695 length
= DW_UNSND (attr
);
8699 /* Check for the DW_AT_byte_size attribute. */
8700 attr
= dwarf2_attr (die
, DW_AT_byte_size
, cu
);
8703 length
= DW_UNSND (attr
);
8711 index_type
= objfile_type (objfile
)->builtin_int
;
8712 range_type
= create_range_type (NULL
, index_type
, 1, length
);
8713 char_type
= language_string_char_type (cu
->language_defn
, gdbarch
);
8714 type
= create_string_type (NULL
, char_type
, range_type
);
8716 return set_die_type (die
, type
, cu
);
8719 /* Handle DIES due to C code like:
8723 int (*funcp)(int a, long l);
8727 ('funcp' generates a DW_TAG_subroutine_type DIE). */
8729 static struct type
*
8730 read_subroutine_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
8732 struct type
*type
; /* Type that this function returns. */
8733 struct type
*ftype
; /* Function that returns above type. */
8734 struct attribute
*attr
;
8736 type
= die_type (die
, cu
);
8738 /* The die_type call above may have already set the type for this DIE. */
8739 ftype
= get_die_type (die
, cu
);
8743 ftype
= lookup_function_type (type
);
8745 /* All functions in C++, Pascal and Java have prototypes. */
8746 attr
= dwarf2_attr (die
, DW_AT_prototyped
, cu
);
8747 if ((attr
&& (DW_UNSND (attr
) != 0))
8748 || cu
->language
== language_cplus
8749 || cu
->language
== language_java
8750 || cu
->language
== language_pascal
)
8751 TYPE_PROTOTYPED (ftype
) = 1;
8752 else if (producer_is_realview (cu
->producer
))
8753 /* RealView does not emit DW_AT_prototyped. We can not
8754 distinguish prototyped and unprototyped functions; default to
8755 prototyped, since that is more common in modern code (and
8756 RealView warns about unprototyped functions). */
8757 TYPE_PROTOTYPED (ftype
) = 1;
8759 /* Store the calling convention in the type if it's available in
8760 the subroutine die. Otherwise set the calling convention to
8761 the default value DW_CC_normal. */
8762 attr
= dwarf2_attr (die
, DW_AT_calling_convention
, cu
);
8764 TYPE_CALLING_CONVENTION (ftype
) = DW_UNSND (attr
);
8765 else if (cu
->producer
&& strstr (cu
->producer
, "IBM XL C for OpenCL"))
8766 TYPE_CALLING_CONVENTION (ftype
) = DW_CC_GDB_IBM_OpenCL
;
8768 TYPE_CALLING_CONVENTION (ftype
) = DW_CC_normal
;
8770 /* We need to add the subroutine type to the die immediately so
8771 we don't infinitely recurse when dealing with parameters
8772 declared as the same subroutine type. */
8773 set_die_type (die
, ftype
, cu
);
8775 if (die
->child
!= NULL
)
8777 struct type
*void_type
= objfile_type (cu
->objfile
)->builtin_void
;
8778 struct die_info
*child_die
;
8779 int nparams
, iparams
;
8781 /* Count the number of parameters.
8782 FIXME: GDB currently ignores vararg functions, but knows about
8783 vararg member functions. */
8785 child_die
= die
->child
;
8786 while (child_die
&& child_die
->tag
)
8788 if (child_die
->tag
== DW_TAG_formal_parameter
)
8790 else if (child_die
->tag
== DW_TAG_unspecified_parameters
)
8791 TYPE_VARARGS (ftype
) = 1;
8792 child_die
= sibling_die (child_die
);
8795 /* Allocate storage for parameters and fill them in. */
8796 TYPE_NFIELDS (ftype
) = nparams
;
8797 TYPE_FIELDS (ftype
) = (struct field
*)
8798 TYPE_ZALLOC (ftype
, nparams
* sizeof (struct field
));
8800 /* TYPE_FIELD_TYPE must never be NULL. Pre-fill the array to ensure it
8801 even if we error out during the parameters reading below. */
8802 for (iparams
= 0; iparams
< nparams
; iparams
++)
8803 TYPE_FIELD_TYPE (ftype
, iparams
) = void_type
;
8806 child_die
= die
->child
;
8807 while (child_die
&& child_die
->tag
)
8809 if (child_die
->tag
== DW_TAG_formal_parameter
)
8811 struct type
*arg_type
;
8813 /* DWARF version 2 has no clean way to discern C++
8814 static and non-static member functions. G++ helps
8815 GDB by marking the first parameter for non-static
8816 member functions (which is the this pointer) as
8817 artificial. We pass this information to
8818 dwarf2_add_member_fn via TYPE_FIELD_ARTIFICIAL.
8820 DWARF version 3 added DW_AT_object_pointer, which GCC
8821 4.5 does not yet generate. */
8822 attr
= dwarf2_attr (child_die
, DW_AT_artificial
, cu
);
8824 TYPE_FIELD_ARTIFICIAL (ftype
, iparams
) = DW_UNSND (attr
);
8827 TYPE_FIELD_ARTIFICIAL (ftype
, iparams
) = 0;
8829 /* GCC/43521: In java, the formal parameter
8830 "this" is sometimes not marked with DW_AT_artificial. */
8831 if (cu
->language
== language_java
)
8833 const char *name
= dwarf2_name (child_die
, cu
);
8835 if (name
&& !strcmp (name
, "this"))
8836 TYPE_FIELD_ARTIFICIAL (ftype
, iparams
) = 1;
8839 arg_type
= die_type (child_die
, cu
);
8841 /* RealView does not mark THIS as const, which the testsuite
8842 expects. GCC marks THIS as const in method definitions,
8843 but not in the class specifications (GCC PR 43053). */
8844 if (cu
->language
== language_cplus
&& !TYPE_CONST (arg_type
)
8845 && TYPE_FIELD_ARTIFICIAL (ftype
, iparams
))
8848 struct dwarf2_cu
*arg_cu
= cu
;
8849 const char *name
= dwarf2_name (child_die
, cu
);
8851 attr
= dwarf2_attr (die
, DW_AT_object_pointer
, cu
);
8854 /* If the compiler emits this, use it. */
8855 if (follow_die_ref (die
, attr
, &arg_cu
) == child_die
)
8858 else if (name
&& strcmp (name
, "this") == 0)
8859 /* Function definitions will have the argument names. */
8861 else if (name
== NULL
&& iparams
== 0)
8862 /* Declarations may not have the names, so like
8863 elsewhere in GDB, assume an artificial first
8864 argument is "this". */
8868 arg_type
= make_cv_type (1, TYPE_VOLATILE (arg_type
),
8872 TYPE_FIELD_TYPE (ftype
, iparams
) = arg_type
;
8875 child_die
= sibling_die (child_die
);
8882 static struct type
*
8883 read_typedef (struct die_info
*die
, struct dwarf2_cu
*cu
)
8885 struct objfile
*objfile
= cu
->objfile
;
8886 const char *name
= NULL
;
8887 struct type
*this_type
;
8889 name
= dwarf2_full_name (NULL
, die
, cu
);
8890 this_type
= init_type (TYPE_CODE_TYPEDEF
, 0,
8891 TYPE_FLAG_TARGET_STUB
, NULL
, objfile
);
8892 TYPE_NAME (this_type
) = (char *) name
;
8893 set_die_type (die
, this_type
, cu
);
8894 TYPE_TARGET_TYPE (this_type
) = die_type (die
, cu
);
8898 /* Find a representation of a given base type and install
8899 it in the TYPE field of the die. */
8901 static struct type
*
8902 read_base_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
8904 struct objfile
*objfile
= cu
->objfile
;
8906 struct attribute
*attr
;
8907 int encoding
= 0, size
= 0;
8909 enum type_code code
= TYPE_CODE_INT
;
8911 struct type
*target_type
= NULL
;
8913 attr
= dwarf2_attr (die
, DW_AT_encoding
, cu
);
8916 encoding
= DW_UNSND (attr
);
8918 attr
= dwarf2_attr (die
, DW_AT_byte_size
, cu
);
8921 size
= DW_UNSND (attr
);
8923 name
= dwarf2_name (die
, cu
);
8926 complaint (&symfile_complaints
,
8927 _("DW_AT_name missing from DW_TAG_base_type"));
8932 case DW_ATE_address
:
8933 /* Turn DW_ATE_address into a void * pointer. */
8934 code
= TYPE_CODE_PTR
;
8935 type_flags
|= TYPE_FLAG_UNSIGNED
;
8936 target_type
= init_type (TYPE_CODE_VOID
, 1, 0, NULL
, objfile
);
8938 case DW_ATE_boolean
:
8939 code
= TYPE_CODE_BOOL
;
8940 type_flags
|= TYPE_FLAG_UNSIGNED
;
8942 case DW_ATE_complex_float
:
8943 code
= TYPE_CODE_COMPLEX
;
8944 target_type
= init_type (TYPE_CODE_FLT
, size
/ 2, 0, NULL
, objfile
);
8946 case DW_ATE_decimal_float
:
8947 code
= TYPE_CODE_DECFLOAT
;
8950 code
= TYPE_CODE_FLT
;
8954 case DW_ATE_unsigned
:
8955 type_flags
|= TYPE_FLAG_UNSIGNED
;
8956 if (cu
->language
== language_fortran
8958 && strncmp (name
, "character(", sizeof ("character(") - 1) == 0)
8959 code
= TYPE_CODE_CHAR
;
8961 case DW_ATE_signed_char
:
8962 if (cu
->language
== language_ada
|| cu
->language
== language_m2
8963 || cu
->language
== language_pascal
8964 || cu
->language
== language_fortran
)
8965 code
= TYPE_CODE_CHAR
;
8967 case DW_ATE_unsigned_char
:
8968 if (cu
->language
== language_ada
|| cu
->language
== language_m2
8969 || cu
->language
== language_pascal
8970 || cu
->language
== language_fortran
)
8971 code
= TYPE_CODE_CHAR
;
8972 type_flags
|= TYPE_FLAG_UNSIGNED
;
8975 /* We just treat this as an integer and then recognize the
8976 type by name elsewhere. */
8980 complaint (&symfile_complaints
, _("unsupported DW_AT_encoding: '%s'"),
8981 dwarf_type_encoding_name (encoding
));
8985 type
= init_type (code
, size
, type_flags
, NULL
, objfile
);
8986 TYPE_NAME (type
) = name
;
8987 TYPE_TARGET_TYPE (type
) = target_type
;
8989 if (name
&& strcmp (name
, "char") == 0)
8990 TYPE_NOSIGN (type
) = 1;
8992 return set_die_type (die
, type
, cu
);
8995 /* Read the given DW_AT_subrange DIE. */
8997 static struct type
*
8998 read_subrange_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
9000 struct type
*base_type
;
9001 struct type
*range_type
;
9002 struct attribute
*attr
;
9006 LONGEST negative_mask
;
9008 base_type
= die_type (die
, cu
);
9009 /* Preserve BASE_TYPE's original type, just set its LENGTH. */
9010 check_typedef (base_type
);
9012 /* The die_type call above may have already set the type for this DIE. */
9013 range_type
= get_die_type (die
, cu
);
9017 if (cu
->language
== language_fortran
)
9019 /* FORTRAN implies a lower bound of 1, if not given. */
9023 /* FIXME: For variable sized arrays either of these could be
9024 a variable rather than a constant value. We'll allow it,
9025 but we don't know how to handle it. */
9026 attr
= dwarf2_attr (die
, DW_AT_lower_bound
, cu
);
9028 low
= dwarf2_get_attr_constant_value (attr
, 0);
9030 attr
= dwarf2_attr (die
, DW_AT_upper_bound
, cu
);
9033 if (attr_form_is_block (attr
) || is_ref_attr (attr
))
9035 /* GCC encodes arrays with unspecified or dynamic length
9036 with a DW_FORM_block1 attribute or a reference attribute.
9037 FIXME: GDB does not yet know how to handle dynamic
9038 arrays properly, treat them as arrays with unspecified
9041 FIXME: jimb/2003-09-22: GDB does not really know
9042 how to handle arrays of unspecified length
9043 either; we just represent them as zero-length
9044 arrays. Choose an appropriate upper bound given
9045 the lower bound we've computed above. */
9049 high
= dwarf2_get_attr_constant_value (attr
, 1);
9053 attr
= dwarf2_attr (die
, DW_AT_count
, cu
);
9056 int count
= dwarf2_get_attr_constant_value (attr
, 1);
9057 high
= low
+ count
- 1;
9061 /* Unspecified array length. */
9066 /* Dwarf-2 specifications explicitly allows to create subrange types
9067 without specifying a base type.
9068 In that case, the base type must be set to the type of
9069 the lower bound, upper bound or count, in that order, if any of these
9070 three attributes references an object that has a type.
9071 If no base type is found, the Dwarf-2 specifications say that
9072 a signed integer type of size equal to the size of an address should
9074 For the following C code: `extern char gdb_int [];'
9075 GCC produces an empty range DIE.
9076 FIXME: muller/2010-05-28: Possible references to object for low bound,
9077 high bound or count are not yet handled by this code. */
9078 if (TYPE_CODE (base_type
) == TYPE_CODE_VOID
)
9080 struct objfile
*objfile
= cu
->objfile
;
9081 struct gdbarch
*gdbarch
= get_objfile_arch (objfile
);
9082 int addr_size
= gdbarch_addr_bit (gdbarch
) /8;
9083 struct type
*int_type
= objfile_type (objfile
)->builtin_int
;
9085 /* Test "int", "long int", and "long long int" objfile types,
9086 and select the first one having a size above or equal to the
9087 architecture address size. */
9088 if (int_type
&& TYPE_LENGTH (int_type
) >= addr_size
)
9089 base_type
= int_type
;
9092 int_type
= objfile_type (objfile
)->builtin_long
;
9093 if (int_type
&& TYPE_LENGTH (int_type
) >= addr_size
)
9094 base_type
= int_type
;
9097 int_type
= objfile_type (objfile
)->builtin_long_long
;
9098 if (int_type
&& TYPE_LENGTH (int_type
) >= addr_size
)
9099 base_type
= int_type
;
9105 (LONGEST
) -1 << (TYPE_LENGTH (base_type
) * TARGET_CHAR_BIT
- 1);
9106 if (!TYPE_UNSIGNED (base_type
) && (low
& negative_mask
))
9107 low
|= negative_mask
;
9108 if (!TYPE_UNSIGNED (base_type
) && (high
& negative_mask
))
9109 high
|= negative_mask
;
9111 range_type
= create_range_type (NULL
, base_type
, low
, high
);
9113 /* Mark arrays with dynamic length at least as an array of unspecified
9114 length. GDB could check the boundary but before it gets implemented at
9115 least allow accessing the array elements. */
9116 if (attr
&& attr_form_is_block (attr
))
9117 TYPE_HIGH_BOUND_UNDEFINED (range_type
) = 1;
9119 /* Ada expects an empty array on no boundary attributes. */
9120 if (attr
== NULL
&& cu
->language
!= language_ada
)
9121 TYPE_HIGH_BOUND_UNDEFINED (range_type
) = 1;
9123 name
= dwarf2_name (die
, cu
);
9125 TYPE_NAME (range_type
) = name
;
9127 attr
= dwarf2_attr (die
, DW_AT_byte_size
, cu
);
9129 TYPE_LENGTH (range_type
) = DW_UNSND (attr
);
9131 set_die_type (die
, range_type
, cu
);
9133 /* set_die_type should be already done. */
9134 set_descriptive_type (range_type
, die
, cu
);
9139 static struct type
*
9140 read_unspecified_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
9144 /* For now, we only support the C meaning of an unspecified type: void. */
9146 type
= init_type (TYPE_CODE_VOID
, 0, 0, NULL
, cu
->objfile
);
9147 TYPE_NAME (type
) = dwarf2_name (die
, cu
);
9149 return set_die_type (die
, type
, cu
);
9152 /* Trivial hash function for die_info: the hash value of a DIE
9153 is its offset in .debug_info for this objfile. */
9156 die_hash (const void *item
)
9158 const struct die_info
*die
= item
;
9163 /* Trivial comparison function for die_info structures: two DIEs
9164 are equal if they have the same offset. */
9167 die_eq (const void *item_lhs
, const void *item_rhs
)
9169 const struct die_info
*die_lhs
= item_lhs
;
9170 const struct die_info
*die_rhs
= item_rhs
;
9172 return die_lhs
->offset
== die_rhs
->offset
;
9175 /* Read a whole compilation unit into a linked list of dies. */
9177 static struct die_info
*
9178 read_comp_unit (gdb_byte
*info_ptr
, struct dwarf2_cu
*cu
)
9180 struct die_reader_specs reader_specs
;
9181 int read_abbrevs
= 0;
9182 struct cleanup
*back_to
= NULL
;
9183 struct die_info
*die
;
9185 if (cu
->dwarf2_abbrevs
== NULL
)
9187 dwarf2_read_abbrevs (cu
->objfile
->obfd
, cu
);
9188 back_to
= make_cleanup (dwarf2_free_abbrev_table
, cu
);
9192 gdb_assert (cu
->die_hash
== NULL
);
9194 = htab_create_alloc_ex (cu
->header
.length
/ 12,
9198 &cu
->comp_unit_obstack
,
9199 hashtab_obstack_allocate
,
9200 dummy_obstack_deallocate
);
9202 init_cu_die_reader (&reader_specs
, cu
);
9204 die
= read_die_and_children (&reader_specs
, info_ptr
, &info_ptr
, NULL
);
9207 do_cleanups (back_to
);
9212 /* Main entry point for reading a DIE and all children.
9213 Read the DIE and dump it if requested. */
9215 static struct die_info
*
9216 read_die_and_children (const struct die_reader_specs
*reader
,
9218 gdb_byte
**new_info_ptr
,
9219 struct die_info
*parent
)
9221 struct die_info
*result
= read_die_and_children_1 (reader
, info_ptr
,
9222 new_info_ptr
, parent
);
9224 if (dwarf2_die_debug
)
9226 fprintf_unfiltered (gdb_stdlog
,
9227 "\nRead die from %s of %s:\n",
9228 (reader
->cu
->per_cu
->debug_type_section
9231 reader
->abfd
->filename
);
9232 dump_die (result
, dwarf2_die_debug
);
9238 /* Read a single die and all its descendents. Set the die's sibling
9239 field to NULL; set other fields in the die correctly, and set all
9240 of the descendents' fields correctly. Set *NEW_INFO_PTR to the
9241 location of the info_ptr after reading all of those dies. PARENT
9242 is the parent of the die in question. */
9244 static struct die_info
*
9245 read_die_and_children_1 (const struct die_reader_specs
*reader
,
9247 gdb_byte
**new_info_ptr
,
9248 struct die_info
*parent
)
9250 struct die_info
*die
;
9254 cur_ptr
= read_full_die (reader
, &die
, info_ptr
, &has_children
);
9257 *new_info_ptr
= cur_ptr
;
9260 store_in_ref_table (die
, reader
->cu
);
9263 die
->child
= read_die_and_siblings (reader
, cur_ptr
, new_info_ptr
, die
);
9267 *new_info_ptr
= cur_ptr
;
9270 die
->sibling
= NULL
;
9271 die
->parent
= parent
;
9275 /* Read a die, all of its descendents, and all of its siblings; set
9276 all of the fields of all of the dies correctly. Arguments are as
9277 in read_die_and_children. */
9279 static struct die_info
*
9280 read_die_and_siblings (const struct die_reader_specs
*reader
,
9282 gdb_byte
**new_info_ptr
,
9283 struct die_info
*parent
)
9285 struct die_info
*first_die
, *last_sibling
;
9289 first_die
= last_sibling
= NULL
;
9293 struct die_info
*die
9294 = read_die_and_children_1 (reader
, cur_ptr
, &cur_ptr
, parent
);
9298 *new_info_ptr
= cur_ptr
;
9305 last_sibling
->sibling
= die
;
9311 /* Read the die from the .debug_info section buffer. Set DIEP to
9312 point to a newly allocated die with its information, except for its
9313 child, sibling, and parent fields. Set HAS_CHILDREN to tell
9314 whether the die has children or not. */
9317 read_full_die (const struct die_reader_specs
*reader
,
9318 struct die_info
**diep
, gdb_byte
*info_ptr
,
9321 unsigned int abbrev_number
, bytes_read
, i
, offset
;
9322 struct abbrev_info
*abbrev
;
9323 struct die_info
*die
;
9324 struct dwarf2_cu
*cu
= reader
->cu
;
9325 bfd
*abfd
= reader
->abfd
;
9327 offset
= info_ptr
- reader
->buffer
;
9328 abbrev_number
= read_unsigned_leb128 (abfd
, info_ptr
, &bytes_read
);
9329 info_ptr
+= bytes_read
;
9337 abbrev
= dwarf2_lookup_abbrev (abbrev_number
, cu
);
9339 error (_("Dwarf Error: could not find abbrev number %d [in module %s]"),
9341 bfd_get_filename (abfd
));
9343 die
= dwarf_alloc_die (cu
, abbrev
->num_attrs
);
9344 die
->offset
= offset
;
9345 die
->tag
= abbrev
->tag
;
9346 die
->abbrev
= abbrev_number
;
9348 die
->num_attrs
= abbrev
->num_attrs
;
9350 for (i
= 0; i
< abbrev
->num_attrs
; ++i
)
9351 info_ptr
= read_attribute (&die
->attrs
[i
], &abbrev
->attrs
[i
],
9352 abfd
, info_ptr
, cu
);
9355 *has_children
= abbrev
->has_children
;
9359 /* In DWARF version 2, the description of the debugging information is
9360 stored in a separate .debug_abbrev section. Before we read any
9361 dies from a section we read in all abbreviations and install them
9362 in a hash table. This function also sets flags in CU describing
9363 the data found in the abbrev table. */
9366 dwarf2_read_abbrevs (bfd
*abfd
, struct dwarf2_cu
*cu
)
9368 struct comp_unit_head
*cu_header
= &cu
->header
;
9369 gdb_byte
*abbrev_ptr
;
9370 struct abbrev_info
*cur_abbrev
;
9371 unsigned int abbrev_number
, bytes_read
, abbrev_name
;
9372 unsigned int abbrev_form
, hash_number
;
9373 struct attr_abbrev
*cur_attrs
;
9374 unsigned int allocated_attrs
;
9376 /* Initialize dwarf2 abbrevs. */
9377 obstack_init (&cu
->abbrev_obstack
);
9378 cu
->dwarf2_abbrevs
= obstack_alloc (&cu
->abbrev_obstack
,
9380 * sizeof (struct abbrev_info
*)));
9381 memset (cu
->dwarf2_abbrevs
, 0,
9382 ABBREV_HASH_SIZE
* sizeof (struct abbrev_info
*));
9384 dwarf2_read_section (dwarf2_per_objfile
->objfile
,
9385 &dwarf2_per_objfile
->abbrev
);
9386 abbrev_ptr
= dwarf2_per_objfile
->abbrev
.buffer
+ cu_header
->abbrev_offset
;
9387 abbrev_number
= read_unsigned_leb128 (abfd
, abbrev_ptr
, &bytes_read
);
9388 abbrev_ptr
+= bytes_read
;
9390 allocated_attrs
= ATTR_ALLOC_CHUNK
;
9391 cur_attrs
= xmalloc (allocated_attrs
* sizeof (struct attr_abbrev
));
9393 /* Loop until we reach an abbrev number of 0. */
9394 while (abbrev_number
)
9396 cur_abbrev
= dwarf_alloc_abbrev (cu
);
9398 /* read in abbrev header */
9399 cur_abbrev
->number
= abbrev_number
;
9400 cur_abbrev
->tag
= read_unsigned_leb128 (abfd
, abbrev_ptr
, &bytes_read
);
9401 abbrev_ptr
+= bytes_read
;
9402 cur_abbrev
->has_children
= read_1_byte (abfd
, abbrev_ptr
);
9405 if (cur_abbrev
->tag
== DW_TAG_namespace
)
9406 cu
->has_namespace_info
= 1;
9408 /* now read in declarations */
9409 abbrev_name
= read_unsigned_leb128 (abfd
, abbrev_ptr
, &bytes_read
);
9410 abbrev_ptr
+= bytes_read
;
9411 abbrev_form
= read_unsigned_leb128 (abfd
, abbrev_ptr
, &bytes_read
);
9412 abbrev_ptr
+= bytes_read
;
9415 if (cur_abbrev
->num_attrs
== allocated_attrs
)
9417 allocated_attrs
+= ATTR_ALLOC_CHUNK
;
9419 = xrealloc (cur_attrs
, (allocated_attrs
9420 * sizeof (struct attr_abbrev
)));
9423 /* Record whether this compilation unit might have
9424 inter-compilation-unit references. If we don't know what form
9425 this attribute will have, then it might potentially be a
9426 DW_FORM_ref_addr, so we conservatively expect inter-CU
9429 if (abbrev_form
== DW_FORM_ref_addr
9430 || abbrev_form
== DW_FORM_indirect
)
9431 cu
->has_form_ref_addr
= 1;
9433 cur_attrs
[cur_abbrev
->num_attrs
].name
= abbrev_name
;
9434 cur_attrs
[cur_abbrev
->num_attrs
++].form
= abbrev_form
;
9435 abbrev_name
= read_unsigned_leb128 (abfd
, abbrev_ptr
, &bytes_read
);
9436 abbrev_ptr
+= bytes_read
;
9437 abbrev_form
= read_unsigned_leb128 (abfd
, abbrev_ptr
, &bytes_read
);
9438 abbrev_ptr
+= bytes_read
;
9441 cur_abbrev
->attrs
= obstack_alloc (&cu
->abbrev_obstack
,
9442 (cur_abbrev
->num_attrs
9443 * sizeof (struct attr_abbrev
)));
9444 memcpy (cur_abbrev
->attrs
, cur_attrs
,
9445 cur_abbrev
->num_attrs
* sizeof (struct attr_abbrev
));
9447 hash_number
= abbrev_number
% ABBREV_HASH_SIZE
;
9448 cur_abbrev
->next
= cu
->dwarf2_abbrevs
[hash_number
];
9449 cu
->dwarf2_abbrevs
[hash_number
] = cur_abbrev
;
9451 /* Get next abbreviation.
9452 Under Irix6 the abbreviations for a compilation unit are not
9453 always properly terminated with an abbrev number of 0.
9454 Exit loop if we encounter an abbreviation which we have
9455 already read (which means we are about to read the abbreviations
9456 for the next compile unit) or if the end of the abbreviation
9457 table is reached. */
9458 if ((unsigned int) (abbrev_ptr
- dwarf2_per_objfile
->abbrev
.buffer
)
9459 >= dwarf2_per_objfile
->abbrev
.size
)
9461 abbrev_number
= read_unsigned_leb128 (abfd
, abbrev_ptr
, &bytes_read
);
9462 abbrev_ptr
+= bytes_read
;
9463 if (dwarf2_lookup_abbrev (abbrev_number
, cu
) != NULL
)
9470 /* Release the memory used by the abbrev table for a compilation unit. */
9473 dwarf2_free_abbrev_table (void *ptr_to_cu
)
9475 struct dwarf2_cu
*cu
= ptr_to_cu
;
9477 obstack_free (&cu
->abbrev_obstack
, NULL
);
9478 cu
->dwarf2_abbrevs
= NULL
;
9481 /* Lookup an abbrev_info structure in the abbrev hash table. */
9483 static struct abbrev_info
*
9484 dwarf2_lookup_abbrev (unsigned int number
, struct dwarf2_cu
*cu
)
9486 unsigned int hash_number
;
9487 struct abbrev_info
*abbrev
;
9489 hash_number
= number
% ABBREV_HASH_SIZE
;
9490 abbrev
= cu
->dwarf2_abbrevs
[hash_number
];
9494 if (abbrev
->number
== number
)
9497 abbrev
= abbrev
->next
;
9502 /* Returns nonzero if TAG represents a type that we might generate a partial
9506 is_type_tag_for_partial (int tag
)
9511 /* Some types that would be reasonable to generate partial symbols for,
9512 that we don't at present. */
9513 case DW_TAG_array_type
:
9514 case DW_TAG_file_type
:
9515 case DW_TAG_ptr_to_member_type
:
9516 case DW_TAG_set_type
:
9517 case DW_TAG_string_type
:
9518 case DW_TAG_subroutine_type
:
9520 case DW_TAG_base_type
:
9521 case DW_TAG_class_type
:
9522 case DW_TAG_interface_type
:
9523 case DW_TAG_enumeration_type
:
9524 case DW_TAG_structure_type
:
9525 case DW_TAG_subrange_type
:
9526 case DW_TAG_typedef
:
9527 case DW_TAG_union_type
:
9534 /* Load all DIEs that are interesting for partial symbols into memory. */
9536 static struct partial_die_info
*
9537 load_partial_dies (bfd
*abfd
, gdb_byte
*buffer
, gdb_byte
*info_ptr
,
9538 int building_psymtab
, struct dwarf2_cu
*cu
)
9540 struct partial_die_info
*part_die
;
9541 struct partial_die_info
*parent_die
, *last_die
, *first_die
= NULL
;
9542 struct abbrev_info
*abbrev
;
9543 unsigned int bytes_read
;
9544 unsigned int load_all
= 0;
9546 int nesting_level
= 1;
9551 if (cu
->per_cu
&& cu
->per_cu
->load_all_dies
)
9555 = htab_create_alloc_ex (cu
->header
.length
/ 12,
9559 &cu
->comp_unit_obstack
,
9560 hashtab_obstack_allocate
,
9561 dummy_obstack_deallocate
);
9563 part_die
= obstack_alloc (&cu
->comp_unit_obstack
,
9564 sizeof (struct partial_die_info
));
9568 abbrev
= peek_die_abbrev (info_ptr
, &bytes_read
, cu
);
9570 /* A NULL abbrev means the end of a series of children. */
9573 if (--nesting_level
== 0)
9575 /* PART_DIE was probably the last thing allocated on the
9576 comp_unit_obstack, so we could call obstack_free
9577 here. We don't do that because the waste is small,
9578 and will be cleaned up when we're done with this
9579 compilation unit. This way, we're also more robust
9580 against other users of the comp_unit_obstack. */
9583 info_ptr
+= bytes_read
;
9584 last_die
= parent_die
;
9585 parent_die
= parent_die
->die_parent
;
9589 /* Check for template arguments. We never save these; if
9590 they're seen, we just mark the parent, and go on our way. */
9591 if (parent_die
!= NULL
9592 && cu
->language
== language_cplus
9593 && (abbrev
->tag
== DW_TAG_template_type_param
9594 || abbrev
->tag
== DW_TAG_template_value_param
))
9596 parent_die
->has_template_arguments
= 1;
9600 /* We don't need a partial DIE for the template argument. */
9601 info_ptr
= skip_one_die (buffer
, info_ptr
+ bytes_read
, abbrev
,
9607 /* We only recurse into subprograms looking for template arguments.
9608 Skip their other children. */
9610 && cu
->language
== language_cplus
9611 && parent_die
!= NULL
9612 && parent_die
->tag
== DW_TAG_subprogram
)
9614 info_ptr
= skip_one_die (buffer
, info_ptr
+ bytes_read
, abbrev
, cu
);
9618 /* Check whether this DIE is interesting enough to save. Normally
9619 we would not be interested in members here, but there may be
9620 later variables referencing them via DW_AT_specification (for
9623 && !is_type_tag_for_partial (abbrev
->tag
)
9624 && abbrev
->tag
!= DW_TAG_constant
9625 && abbrev
->tag
!= DW_TAG_enumerator
9626 && abbrev
->tag
!= DW_TAG_subprogram
9627 && abbrev
->tag
!= DW_TAG_lexical_block
9628 && abbrev
->tag
!= DW_TAG_variable
9629 && abbrev
->tag
!= DW_TAG_namespace
9630 && abbrev
->tag
!= DW_TAG_module
9631 && abbrev
->tag
!= DW_TAG_member
)
9633 /* Otherwise we skip to the next sibling, if any. */
9634 info_ptr
= skip_one_die (buffer
, info_ptr
+ bytes_read
, abbrev
, cu
);
9638 info_ptr
= read_partial_die (part_die
, abbrev
, bytes_read
, abfd
,
9639 buffer
, info_ptr
, cu
);
9641 /* This two-pass algorithm for processing partial symbols has a
9642 high cost in cache pressure. Thus, handle some simple cases
9643 here which cover the majority of C partial symbols. DIEs
9644 which neither have specification tags in them, nor could have
9645 specification tags elsewhere pointing at them, can simply be
9646 processed and discarded.
9648 This segment is also optional; scan_partial_symbols and
9649 add_partial_symbol will handle these DIEs if we chain
9650 them in normally. When compilers which do not emit large
9651 quantities of duplicate debug information are more common,
9652 this code can probably be removed. */
9654 /* Any complete simple types at the top level (pretty much all
9655 of them, for a language without namespaces), can be processed
9657 if (parent_die
== NULL
9658 && part_die
->has_specification
== 0
9659 && part_die
->is_declaration
== 0
9660 && ((part_die
->tag
== DW_TAG_typedef
&& !part_die
->has_children
)
9661 || part_die
->tag
== DW_TAG_base_type
9662 || part_die
->tag
== DW_TAG_subrange_type
))
9664 if (building_psymtab
&& part_die
->name
!= NULL
)
9665 add_psymbol_to_list (part_die
->name
, strlen (part_die
->name
), 0,
9666 VAR_DOMAIN
, LOC_TYPEDEF
,
9667 &cu
->objfile
->static_psymbols
,
9668 0, (CORE_ADDR
) 0, cu
->language
, cu
->objfile
);
9669 info_ptr
= locate_pdi_sibling (part_die
, buffer
, info_ptr
, abfd
, cu
);
9673 /* The exception for DW_TAG_typedef with has_children above is
9674 a workaround of GCC PR debug/47510. In the case of this complaint
9675 type_name_no_tag_or_error will error on such types later.
9677 GDB skipped children of DW_TAG_typedef by the shortcut above and then
9678 it could not find the child DIEs referenced later, this is checked
9679 above. In correct DWARF DW_TAG_typedef should have no children. */
9681 if (part_die
->tag
== DW_TAG_typedef
&& part_die
->has_children
)
9682 complaint (&symfile_complaints
,
9683 _("DW_TAG_typedef has childen - GCC PR debug/47510 bug "
9684 "- DIE at 0x%x [in module %s]"),
9685 part_die
->offset
, cu
->objfile
->name
);
9687 /* If we're at the second level, and we're an enumerator, and
9688 our parent has no specification (meaning possibly lives in a
9689 namespace elsewhere), then we can add the partial symbol now
9690 instead of queueing it. */
9691 if (part_die
->tag
== DW_TAG_enumerator
9692 && parent_die
!= NULL
9693 && parent_die
->die_parent
== NULL
9694 && parent_die
->tag
== DW_TAG_enumeration_type
9695 && parent_die
->has_specification
== 0)
9697 if (part_die
->name
== NULL
)
9698 complaint (&symfile_complaints
,
9699 _("malformed enumerator DIE ignored"));
9700 else if (building_psymtab
)
9701 add_psymbol_to_list (part_die
->name
, strlen (part_die
->name
), 0,
9702 VAR_DOMAIN
, LOC_CONST
,
9703 (cu
->language
== language_cplus
9704 || cu
->language
== language_java
)
9705 ? &cu
->objfile
->global_psymbols
9706 : &cu
->objfile
->static_psymbols
,
9707 0, (CORE_ADDR
) 0, cu
->language
, cu
->objfile
);
9709 info_ptr
= locate_pdi_sibling (part_die
, buffer
, info_ptr
, abfd
, cu
);
9713 /* We'll save this DIE so link it in. */
9714 part_die
->die_parent
= parent_die
;
9715 part_die
->die_sibling
= NULL
;
9716 part_die
->die_child
= NULL
;
9718 if (last_die
&& last_die
== parent_die
)
9719 last_die
->die_child
= part_die
;
9721 last_die
->die_sibling
= part_die
;
9723 last_die
= part_die
;
9725 if (first_die
== NULL
)
9726 first_die
= part_die
;
9728 /* Maybe add the DIE to the hash table. Not all DIEs that we
9729 find interesting need to be in the hash table, because we
9730 also have the parent/sibling/child chains; only those that we
9731 might refer to by offset later during partial symbol reading.
9733 For now this means things that might have be the target of a
9734 DW_AT_specification, DW_AT_abstract_origin, or
9735 DW_AT_extension. DW_AT_extension will refer only to
9736 namespaces; DW_AT_abstract_origin refers to functions (and
9737 many things under the function DIE, but we do not recurse
9738 into function DIEs during partial symbol reading) and
9739 possibly variables as well; DW_AT_specification refers to
9740 declarations. Declarations ought to have the DW_AT_declaration
9741 flag. It happens that GCC forgets to put it in sometimes, but
9742 only for functions, not for types.
9744 Adding more things than necessary to the hash table is harmless
9745 except for the performance cost. Adding too few will result in
9746 wasted time in find_partial_die, when we reread the compilation
9747 unit with load_all_dies set. */
9750 || abbrev
->tag
== DW_TAG_constant
9751 || abbrev
->tag
== DW_TAG_subprogram
9752 || abbrev
->tag
== DW_TAG_variable
9753 || abbrev
->tag
== DW_TAG_namespace
9754 || part_die
->is_declaration
)
9758 slot
= htab_find_slot_with_hash (cu
->partial_dies
, part_die
,
9759 part_die
->offset
, INSERT
);
9763 part_die
= obstack_alloc (&cu
->comp_unit_obstack
,
9764 sizeof (struct partial_die_info
));
9766 /* For some DIEs we want to follow their children (if any). For C
9767 we have no reason to follow the children of structures; for other
9768 languages we have to, so that we can get at method physnames
9769 to infer fully qualified class names, for DW_AT_specification,
9770 and for C++ template arguments. For C++, we also look one level
9771 inside functions to find template arguments (if the name of the
9772 function does not already contain the template arguments).
9774 For Ada, we need to scan the children of subprograms and lexical
9775 blocks as well because Ada allows the definition of nested
9776 entities that could be interesting for the debugger, such as
9777 nested subprograms for instance. */
9778 if (last_die
->has_children
9780 || last_die
->tag
== DW_TAG_namespace
9781 || last_die
->tag
== DW_TAG_module
9782 || last_die
->tag
== DW_TAG_enumeration_type
9783 || (cu
->language
== language_cplus
9784 && last_die
->tag
== DW_TAG_subprogram
9785 && (last_die
->name
== NULL
9786 || strchr (last_die
->name
, '<') == NULL
))
9787 || (cu
->language
!= language_c
9788 && (last_die
->tag
== DW_TAG_class_type
9789 || last_die
->tag
== DW_TAG_interface_type
9790 || last_die
->tag
== DW_TAG_structure_type
9791 || last_die
->tag
== DW_TAG_union_type
))
9792 || (cu
->language
== language_ada
9793 && (last_die
->tag
== DW_TAG_subprogram
9794 || last_die
->tag
== DW_TAG_lexical_block
))))
9797 parent_die
= last_die
;
9801 /* Otherwise we skip to the next sibling, if any. */
9802 info_ptr
= locate_pdi_sibling (last_die
, buffer
, info_ptr
, abfd
, cu
);
9804 /* Back to the top, do it again. */
9808 /* Read a minimal amount of information into the minimal die structure. */
9811 read_partial_die (struct partial_die_info
*part_die
,
9812 struct abbrev_info
*abbrev
,
9813 unsigned int abbrev_len
, bfd
*abfd
,
9814 gdb_byte
*buffer
, gdb_byte
*info_ptr
,
9815 struct dwarf2_cu
*cu
)
9818 struct attribute attr
;
9819 int has_low_pc_attr
= 0;
9820 int has_high_pc_attr
= 0;
9822 memset (part_die
, 0, sizeof (struct partial_die_info
));
9824 part_die
->offset
= info_ptr
- buffer
;
9826 info_ptr
+= abbrev_len
;
9831 part_die
->tag
= abbrev
->tag
;
9832 part_die
->has_children
= abbrev
->has_children
;
9834 for (i
= 0; i
< abbrev
->num_attrs
; ++i
)
9836 info_ptr
= read_attribute (&attr
, &abbrev
->attrs
[i
], abfd
, info_ptr
, cu
);
9838 /* Store the data if it is of an attribute we want to keep in a
9839 partial symbol table. */
9843 switch (part_die
->tag
)
9845 case DW_TAG_compile_unit
:
9846 case DW_TAG_type_unit
:
9847 /* Compilation units have a DW_AT_name that is a filename, not
9848 a source language identifier. */
9849 case DW_TAG_enumeration_type
:
9850 case DW_TAG_enumerator
:
9851 /* These tags always have simple identifiers already; no need
9852 to canonicalize them. */
9853 part_die
->name
= DW_STRING (&attr
);
9857 = dwarf2_canonicalize_name (DW_STRING (&attr
), cu
,
9858 &cu
->objfile
->objfile_obstack
);
9862 case DW_AT_linkage_name
:
9863 case DW_AT_MIPS_linkage_name
:
9864 /* Note that both forms of linkage name might appear. We
9865 assume they will be the same, and we only store the last
9867 if (cu
->language
== language_ada
)
9868 part_die
->name
= DW_STRING (&attr
);
9869 part_die
->linkage_name
= DW_STRING (&attr
);
9872 has_low_pc_attr
= 1;
9873 part_die
->lowpc
= DW_ADDR (&attr
);
9876 has_high_pc_attr
= 1;
9877 part_die
->highpc
= DW_ADDR (&attr
);
9879 case DW_AT_location
:
9880 /* Support the .debug_loc offsets. */
9881 if (attr_form_is_block (&attr
))
9883 part_die
->locdesc
= DW_BLOCK (&attr
);
9885 else if (attr_form_is_section_offset (&attr
))
9887 dwarf2_complex_location_expr_complaint ();
9891 dwarf2_invalid_attrib_class_complaint ("DW_AT_location",
9892 "partial symbol information");
9895 case DW_AT_external
:
9896 part_die
->is_external
= DW_UNSND (&attr
);
9898 case DW_AT_declaration
:
9899 part_die
->is_declaration
= DW_UNSND (&attr
);
9902 part_die
->has_type
= 1;
9904 case DW_AT_abstract_origin
:
9905 case DW_AT_specification
:
9906 case DW_AT_extension
:
9907 part_die
->has_specification
= 1;
9908 part_die
->spec_offset
= dwarf2_get_ref_die_offset (&attr
);
9911 /* Ignore absolute siblings, they might point outside of
9912 the current compile unit. */
9913 if (attr
.form
== DW_FORM_ref_addr
)
9914 complaint (&symfile_complaints
,
9915 _("ignoring absolute DW_AT_sibling"));
9917 part_die
->sibling
= buffer
+ dwarf2_get_ref_die_offset (&attr
);
9919 case DW_AT_byte_size
:
9920 part_die
->has_byte_size
= 1;
9922 case DW_AT_calling_convention
:
9923 /* DWARF doesn't provide a way to identify a program's source-level
9924 entry point. DW_AT_calling_convention attributes are only meant
9925 to describe functions' calling conventions.
9927 However, because it's a necessary piece of information in
9928 Fortran, and because DW_CC_program is the only piece of debugging
9929 information whose definition refers to a 'main program' at all,
9930 several compilers have begun marking Fortran main programs with
9931 DW_CC_program --- even when those functions use the standard
9932 calling conventions.
9934 So until DWARF specifies a way to provide this information and
9935 compilers pick up the new representation, we'll support this
9937 if (DW_UNSND (&attr
) == DW_CC_program
9938 && cu
->language
== language_fortran
)
9940 set_main_name (part_die
->name
);
9942 /* As this DIE has a static linkage the name would be difficult
9943 to look up later. */
9944 language_of_main
= language_fortran
;
9952 if (has_low_pc_attr
&& has_high_pc_attr
)
9954 /* When using the GNU linker, .gnu.linkonce. sections are used to
9955 eliminate duplicate copies of functions and vtables and such.
9956 The linker will arbitrarily choose one and discard the others.
9957 The AT_*_pc values for such functions refer to local labels in
9958 these sections. If the section from that file was discarded, the
9959 labels are not in the output, so the relocs get a value of 0.
9960 If this is a discarded function, mark the pc bounds as invalid,
9961 so that GDB will ignore it. */
9962 if (part_die
->lowpc
== 0 && !dwarf2_per_objfile
->has_section_at_zero
)
9964 struct gdbarch
*gdbarch
= get_objfile_arch (cu
->objfile
);
9966 complaint (&symfile_complaints
,
9967 _("DW_AT_low_pc %s is zero "
9968 "for DIE at 0x%x [in module %s]"),
9969 paddress (gdbarch
, part_die
->lowpc
),
9970 part_die
->offset
, cu
->objfile
->name
);
9972 /* dwarf2_get_pc_bounds has also the strict low < high requirement. */
9973 else if (part_die
->lowpc
>= part_die
->highpc
)
9975 struct gdbarch
*gdbarch
= get_objfile_arch (cu
->objfile
);
9977 complaint (&symfile_complaints
,
9978 _("DW_AT_low_pc %s is not < DW_AT_high_pc %s "
9979 "for DIE at 0x%x [in module %s]"),
9980 paddress (gdbarch
, part_die
->lowpc
),
9981 paddress (gdbarch
, part_die
->highpc
),
9982 part_die
->offset
, cu
->objfile
->name
);
9985 part_die
->has_pc_info
= 1;
9991 /* Find a cached partial DIE at OFFSET in CU. */
9993 static struct partial_die_info
*
9994 find_partial_die_in_comp_unit (unsigned int offset
, struct dwarf2_cu
*cu
)
9996 struct partial_die_info
*lookup_die
= NULL
;
9997 struct partial_die_info part_die
;
9999 part_die
.offset
= offset
;
10000 lookup_die
= htab_find_with_hash (cu
->partial_dies
, &part_die
, offset
);
10005 /* Find a partial DIE at OFFSET, which may or may not be in CU,
10006 except in the case of .debug_types DIEs which do not reference
10007 outside their CU (they do however referencing other types via
10008 DW_FORM_ref_sig8). */
10010 static struct partial_die_info
*
10011 find_partial_die (unsigned int offset
, struct dwarf2_cu
*cu
)
10013 struct dwarf2_per_cu_data
*per_cu
= NULL
;
10014 struct partial_die_info
*pd
= NULL
;
10016 if (cu
->per_cu
->debug_type_section
)
10018 pd
= find_partial_die_in_comp_unit (offset
, cu
);
10024 if (offset_in_cu_p (&cu
->header
, offset
))
10026 pd
= find_partial_die_in_comp_unit (offset
, cu
);
10031 per_cu
= dwarf2_find_containing_comp_unit (offset
, cu
->objfile
);
10033 if (per_cu
->cu
== NULL
|| per_cu
->cu
->partial_dies
== NULL
)
10034 load_partial_comp_unit (per_cu
, cu
->objfile
);
10036 per_cu
->cu
->last_used
= 0;
10037 pd
= find_partial_die_in_comp_unit (offset
, per_cu
->cu
);
10039 if (pd
== NULL
&& per_cu
->load_all_dies
== 0)
10041 struct cleanup
*back_to
;
10042 struct partial_die_info comp_unit_die
;
10043 struct abbrev_info
*abbrev
;
10044 unsigned int bytes_read
;
10047 per_cu
->load_all_dies
= 1;
10049 /* Re-read the DIEs. */
10050 back_to
= make_cleanup (null_cleanup
, 0);
10051 if (per_cu
->cu
->dwarf2_abbrevs
== NULL
)
10053 dwarf2_read_abbrevs (per_cu
->cu
->objfile
->obfd
, per_cu
->cu
);
10054 make_cleanup (dwarf2_free_abbrev_table
, per_cu
->cu
);
10056 info_ptr
= (dwarf2_per_objfile
->info
.buffer
10057 + per_cu
->cu
->header
.offset
10058 + per_cu
->cu
->header
.first_die_offset
);
10059 abbrev
= peek_die_abbrev (info_ptr
, &bytes_read
, per_cu
->cu
);
10060 info_ptr
= read_partial_die (&comp_unit_die
, abbrev
, bytes_read
,
10061 per_cu
->cu
->objfile
->obfd
,
10062 dwarf2_per_objfile
->info
.buffer
, info_ptr
,
10064 if (comp_unit_die
.has_children
)
10065 load_partial_dies (per_cu
->cu
->objfile
->obfd
,
10066 dwarf2_per_objfile
->info
.buffer
, info_ptr
,
10068 do_cleanups (back_to
);
10070 pd
= find_partial_die_in_comp_unit (offset
, per_cu
->cu
);
10076 internal_error (__FILE__
, __LINE__
,
10077 _("could not find partial DIE 0x%x "
10078 "in cache [from module %s]\n"),
10079 offset
, bfd_get_filename (cu
->objfile
->obfd
));
10083 /* See if we can figure out if the class lives in a namespace. We do
10084 this by looking for a member function; its demangled name will
10085 contain namespace info, if there is any. */
10088 guess_partial_die_structure_name (struct partial_die_info
*struct_pdi
,
10089 struct dwarf2_cu
*cu
)
10091 /* NOTE: carlton/2003-10-07: Getting the info this way changes
10092 what template types look like, because the demangler
10093 frequently doesn't give the same name as the debug info. We
10094 could fix this by only using the demangled name to get the
10095 prefix (but see comment in read_structure_type). */
10097 struct partial_die_info
*real_pdi
;
10098 struct partial_die_info
*child_pdi
;
10100 /* If this DIE (this DIE's specification, if any) has a parent, then
10101 we should not do this. We'll prepend the parent's fully qualified
10102 name when we create the partial symbol. */
10104 real_pdi
= struct_pdi
;
10105 while (real_pdi
->has_specification
)
10106 real_pdi
= find_partial_die (real_pdi
->spec_offset
, cu
);
10108 if (real_pdi
->die_parent
!= NULL
)
10111 for (child_pdi
= struct_pdi
->die_child
;
10113 child_pdi
= child_pdi
->die_sibling
)
10115 if (child_pdi
->tag
== DW_TAG_subprogram
10116 && child_pdi
->linkage_name
!= NULL
)
10118 char *actual_class_name
10119 = language_class_name_from_physname (cu
->language_defn
,
10120 child_pdi
->linkage_name
);
10121 if (actual_class_name
!= NULL
)
10124 = obsavestring (actual_class_name
,
10125 strlen (actual_class_name
),
10126 &cu
->objfile
->objfile_obstack
);
10127 xfree (actual_class_name
);
10134 /* Adjust PART_DIE before generating a symbol for it. This function
10135 may set the is_external flag or change the DIE's name. */
10138 fixup_partial_die (struct partial_die_info
*part_die
,
10139 struct dwarf2_cu
*cu
)
10141 /* Once we've fixed up a die, there's no point in doing so again.
10142 This also avoids a memory leak if we were to call
10143 guess_partial_die_structure_name multiple times. */
10144 if (part_die
->fixup_called
)
10147 /* If we found a reference attribute and the DIE has no name, try
10148 to find a name in the referred to DIE. */
10150 if (part_die
->name
== NULL
&& part_die
->has_specification
)
10152 struct partial_die_info
*spec_die
;
10154 spec_die
= find_partial_die (part_die
->spec_offset
, cu
);
10156 fixup_partial_die (spec_die
, cu
);
10158 if (spec_die
->name
)
10160 part_die
->name
= spec_die
->name
;
10162 /* Copy DW_AT_external attribute if it is set. */
10163 if (spec_die
->is_external
)
10164 part_die
->is_external
= spec_die
->is_external
;
10168 /* Set default names for some unnamed DIEs. */
10170 if (part_die
->name
== NULL
&& part_die
->tag
== DW_TAG_namespace
)
10171 part_die
->name
= CP_ANONYMOUS_NAMESPACE_STR
;
10173 /* If there is no parent die to provide a namespace, and there are
10174 children, see if we can determine the namespace from their linkage
10176 NOTE: We need to do this even if cu->has_namespace_info != 0.
10177 gcc-4.5 -gdwarf-4 can drop the enclosing namespace. */
10178 if (cu
->language
== language_cplus
10179 && !VEC_empty (dwarf2_section_info_def
, dwarf2_per_objfile
->types
)
10180 && part_die
->die_parent
== NULL
10181 && part_die
->has_children
10182 && (part_die
->tag
== DW_TAG_class_type
10183 || part_die
->tag
== DW_TAG_structure_type
10184 || part_die
->tag
== DW_TAG_union_type
))
10185 guess_partial_die_structure_name (part_die
, cu
);
10187 /* GCC might emit a nameless struct or union that has a linkage
10188 name. See http://gcc.gnu.org/bugzilla/show_bug.cgi?id=47510. */
10189 if (part_die
->name
== NULL
10190 && (part_die
->tag
== DW_TAG_class_type
10191 || part_die
->tag
== DW_TAG_interface_type
10192 || part_die
->tag
== DW_TAG_structure_type
10193 || part_die
->tag
== DW_TAG_union_type
)
10194 && part_die
->linkage_name
!= NULL
)
10198 demangled
= cplus_demangle (part_die
->linkage_name
, DMGL_TYPES
);
10203 /* Strip any leading namespaces/classes, keep only the base name.
10204 DW_AT_name for named DIEs does not contain the prefixes. */
10205 base
= strrchr (demangled
, ':');
10206 if (base
&& base
> demangled
&& base
[-1] == ':')
10211 part_die
->name
= obsavestring (base
, strlen (base
),
10212 &cu
->objfile
->objfile_obstack
);
10217 part_die
->fixup_called
= 1;
10220 /* Read an attribute value described by an attribute form. */
10223 read_attribute_value (struct attribute
*attr
, unsigned form
,
10224 bfd
*abfd
, gdb_byte
*info_ptr
,
10225 struct dwarf2_cu
*cu
)
10227 struct comp_unit_head
*cu_header
= &cu
->header
;
10228 unsigned int bytes_read
;
10229 struct dwarf_block
*blk
;
10234 case DW_FORM_ref_addr
:
10235 if (cu
->header
.version
== 2)
10236 DW_ADDR (attr
) = read_address (abfd
, info_ptr
, cu
, &bytes_read
);
10238 DW_ADDR (attr
) = read_offset (abfd
, info_ptr
,
10239 &cu
->header
, &bytes_read
);
10240 info_ptr
+= bytes_read
;
10243 DW_ADDR (attr
) = read_address (abfd
, info_ptr
, cu
, &bytes_read
);
10244 info_ptr
+= bytes_read
;
10246 case DW_FORM_block2
:
10247 blk
= dwarf_alloc_block (cu
);
10248 blk
->size
= read_2_bytes (abfd
, info_ptr
);
10250 blk
->data
= read_n_bytes (abfd
, info_ptr
, blk
->size
);
10251 info_ptr
+= blk
->size
;
10252 DW_BLOCK (attr
) = blk
;
10254 case DW_FORM_block4
:
10255 blk
= dwarf_alloc_block (cu
);
10256 blk
->size
= read_4_bytes (abfd
, info_ptr
);
10258 blk
->data
= read_n_bytes (abfd
, info_ptr
, blk
->size
);
10259 info_ptr
+= blk
->size
;
10260 DW_BLOCK (attr
) = blk
;
10262 case DW_FORM_data2
:
10263 DW_UNSND (attr
) = read_2_bytes (abfd
, info_ptr
);
10266 case DW_FORM_data4
:
10267 DW_UNSND (attr
) = read_4_bytes (abfd
, info_ptr
);
10270 case DW_FORM_data8
:
10271 DW_UNSND (attr
) = read_8_bytes (abfd
, info_ptr
);
10274 case DW_FORM_sec_offset
:
10275 DW_UNSND (attr
) = read_offset (abfd
, info_ptr
, &cu
->header
, &bytes_read
);
10276 info_ptr
+= bytes_read
;
10278 case DW_FORM_string
:
10279 DW_STRING (attr
) = read_direct_string (abfd
, info_ptr
, &bytes_read
);
10280 DW_STRING_IS_CANONICAL (attr
) = 0;
10281 info_ptr
+= bytes_read
;
10284 DW_STRING (attr
) = read_indirect_string (abfd
, info_ptr
, cu_header
,
10286 DW_STRING_IS_CANONICAL (attr
) = 0;
10287 info_ptr
+= bytes_read
;
10289 case DW_FORM_exprloc
:
10290 case DW_FORM_block
:
10291 blk
= dwarf_alloc_block (cu
);
10292 blk
->size
= read_unsigned_leb128 (abfd
, info_ptr
, &bytes_read
);
10293 info_ptr
+= bytes_read
;
10294 blk
->data
= read_n_bytes (abfd
, info_ptr
, blk
->size
);
10295 info_ptr
+= blk
->size
;
10296 DW_BLOCK (attr
) = blk
;
10298 case DW_FORM_block1
:
10299 blk
= dwarf_alloc_block (cu
);
10300 blk
->size
= read_1_byte (abfd
, info_ptr
);
10302 blk
->data
= read_n_bytes (abfd
, info_ptr
, blk
->size
);
10303 info_ptr
+= blk
->size
;
10304 DW_BLOCK (attr
) = blk
;
10306 case DW_FORM_data1
:
10307 DW_UNSND (attr
) = read_1_byte (abfd
, info_ptr
);
10311 DW_UNSND (attr
) = read_1_byte (abfd
, info_ptr
);
10314 case DW_FORM_flag_present
:
10315 DW_UNSND (attr
) = 1;
10317 case DW_FORM_sdata
:
10318 DW_SND (attr
) = read_signed_leb128 (abfd
, info_ptr
, &bytes_read
);
10319 info_ptr
+= bytes_read
;
10321 case DW_FORM_udata
:
10322 DW_UNSND (attr
) = read_unsigned_leb128 (abfd
, info_ptr
, &bytes_read
);
10323 info_ptr
+= bytes_read
;
10326 DW_ADDR (attr
) = cu
->header
.offset
+ read_1_byte (abfd
, info_ptr
);
10330 DW_ADDR (attr
) = cu
->header
.offset
+ read_2_bytes (abfd
, info_ptr
);
10334 DW_ADDR (attr
) = cu
->header
.offset
+ read_4_bytes (abfd
, info_ptr
);
10338 DW_ADDR (attr
) = cu
->header
.offset
+ read_8_bytes (abfd
, info_ptr
);
10341 case DW_FORM_ref_sig8
:
10342 /* Convert the signature to something we can record in DW_UNSND
10344 NOTE: This is NULL if the type wasn't found. */
10345 DW_SIGNATURED_TYPE (attr
) =
10346 lookup_signatured_type (cu
->objfile
, read_8_bytes (abfd
, info_ptr
));
10349 case DW_FORM_ref_udata
:
10350 DW_ADDR (attr
) = (cu
->header
.offset
10351 + read_unsigned_leb128 (abfd
, info_ptr
, &bytes_read
));
10352 info_ptr
+= bytes_read
;
10354 case DW_FORM_indirect
:
10355 form
= read_unsigned_leb128 (abfd
, info_ptr
, &bytes_read
);
10356 info_ptr
+= bytes_read
;
10357 info_ptr
= read_attribute_value (attr
, form
, abfd
, info_ptr
, cu
);
10360 error (_("Dwarf Error: Cannot handle %s in DWARF reader [in module %s]"),
10361 dwarf_form_name (form
),
10362 bfd_get_filename (abfd
));
10365 /* We have seen instances where the compiler tried to emit a byte
10366 size attribute of -1 which ended up being encoded as an unsigned
10367 0xffffffff. Although 0xffffffff is technically a valid size value,
10368 an object of this size seems pretty unlikely so we can relatively
10369 safely treat these cases as if the size attribute was invalid and
10370 treat them as zero by default. */
10371 if (attr
->name
== DW_AT_byte_size
10372 && form
== DW_FORM_data4
10373 && DW_UNSND (attr
) >= 0xffffffff)
10376 (&symfile_complaints
,
10377 _("Suspicious DW_AT_byte_size value treated as zero instead of %s"),
10378 hex_string (DW_UNSND (attr
)));
10379 DW_UNSND (attr
) = 0;
10385 /* Read an attribute described by an abbreviated attribute. */
10388 read_attribute (struct attribute
*attr
, struct attr_abbrev
*abbrev
,
10389 bfd
*abfd
, gdb_byte
*info_ptr
, struct dwarf2_cu
*cu
)
10391 attr
->name
= abbrev
->name
;
10392 return read_attribute_value (attr
, abbrev
->form
, abfd
, info_ptr
, cu
);
10395 /* Read dwarf information from a buffer. */
10397 static unsigned int
10398 read_1_byte (bfd
*abfd
, gdb_byte
*buf
)
10400 return bfd_get_8 (abfd
, buf
);
10404 read_1_signed_byte (bfd
*abfd
, gdb_byte
*buf
)
10406 return bfd_get_signed_8 (abfd
, buf
);
10409 static unsigned int
10410 read_2_bytes (bfd
*abfd
, gdb_byte
*buf
)
10412 return bfd_get_16 (abfd
, buf
);
10416 read_2_signed_bytes (bfd
*abfd
, gdb_byte
*buf
)
10418 return bfd_get_signed_16 (abfd
, buf
);
10421 static unsigned int
10422 read_4_bytes (bfd
*abfd
, gdb_byte
*buf
)
10424 return bfd_get_32 (abfd
, buf
);
10428 read_4_signed_bytes (bfd
*abfd
, gdb_byte
*buf
)
10430 return bfd_get_signed_32 (abfd
, buf
);
10434 read_8_bytes (bfd
*abfd
, gdb_byte
*buf
)
10436 return bfd_get_64 (abfd
, buf
);
10440 read_address (bfd
*abfd
, gdb_byte
*buf
, struct dwarf2_cu
*cu
,
10441 unsigned int *bytes_read
)
10443 struct comp_unit_head
*cu_header
= &cu
->header
;
10444 CORE_ADDR retval
= 0;
10446 if (cu_header
->signed_addr_p
)
10448 switch (cu_header
->addr_size
)
10451 retval
= bfd_get_signed_16 (abfd
, buf
);
10454 retval
= bfd_get_signed_32 (abfd
, buf
);
10457 retval
= bfd_get_signed_64 (abfd
, buf
);
10460 internal_error (__FILE__
, __LINE__
,
10461 _("read_address: bad switch, signed [in module %s]"),
10462 bfd_get_filename (abfd
));
10467 switch (cu_header
->addr_size
)
10470 retval
= bfd_get_16 (abfd
, buf
);
10473 retval
= bfd_get_32 (abfd
, buf
);
10476 retval
= bfd_get_64 (abfd
, buf
);
10479 internal_error (__FILE__
, __LINE__
,
10480 _("read_address: bad switch, "
10481 "unsigned [in module %s]"),
10482 bfd_get_filename (abfd
));
10486 *bytes_read
= cu_header
->addr_size
;
10490 /* Read the initial length from a section. The (draft) DWARF 3
10491 specification allows the initial length to take up either 4 bytes
10492 or 12 bytes. If the first 4 bytes are 0xffffffff, then the next 8
10493 bytes describe the length and all offsets will be 8 bytes in length
10496 An older, non-standard 64-bit format is also handled by this
10497 function. The older format in question stores the initial length
10498 as an 8-byte quantity without an escape value. Lengths greater
10499 than 2^32 aren't very common which means that the initial 4 bytes
10500 is almost always zero. Since a length value of zero doesn't make
10501 sense for the 32-bit format, this initial zero can be considered to
10502 be an escape value which indicates the presence of the older 64-bit
10503 format. As written, the code can't detect (old format) lengths
10504 greater than 4GB. If it becomes necessary to handle lengths
10505 somewhat larger than 4GB, we could allow other small values (such
10506 as the non-sensical values of 1, 2, and 3) to also be used as
10507 escape values indicating the presence of the old format.
10509 The value returned via bytes_read should be used to increment the
10510 relevant pointer after calling read_initial_length().
10512 [ Note: read_initial_length() and read_offset() are based on the
10513 document entitled "DWARF Debugging Information Format", revision
10514 3, draft 8, dated November 19, 2001. This document was obtained
10517 http://reality.sgiweb.org/davea/dwarf3-draft8-011125.pdf
10519 This document is only a draft and is subject to change. (So beware.)
10521 Details regarding the older, non-standard 64-bit format were
10522 determined empirically by examining 64-bit ELF files produced by
10523 the SGI toolchain on an IRIX 6.5 machine.
10525 - Kevin, July 16, 2002
10529 read_initial_length (bfd
*abfd
, gdb_byte
*buf
, unsigned int *bytes_read
)
10531 LONGEST length
= bfd_get_32 (abfd
, buf
);
10533 if (length
== 0xffffffff)
10535 length
= bfd_get_64 (abfd
, buf
+ 4);
10538 else if (length
== 0)
10540 /* Handle the (non-standard) 64-bit DWARF2 format used by IRIX. */
10541 length
= bfd_get_64 (abfd
, buf
);
10552 /* Cover function for read_initial_length.
10553 Returns the length of the object at BUF, and stores the size of the
10554 initial length in *BYTES_READ and stores the size that offsets will be in
10556 If the initial length size is not equivalent to that specified in
10557 CU_HEADER then issue a complaint.
10558 This is useful when reading non-comp-unit headers. */
10561 read_checked_initial_length_and_offset (bfd
*abfd
, gdb_byte
*buf
,
10562 const struct comp_unit_head
*cu_header
,
10563 unsigned int *bytes_read
,
10564 unsigned int *offset_size
)
10566 LONGEST length
= read_initial_length (abfd
, buf
, bytes_read
);
10568 gdb_assert (cu_header
->initial_length_size
== 4
10569 || cu_header
->initial_length_size
== 8
10570 || cu_header
->initial_length_size
== 12);
10572 if (cu_header
->initial_length_size
!= *bytes_read
)
10573 complaint (&symfile_complaints
,
10574 _("intermixed 32-bit and 64-bit DWARF sections"));
10576 *offset_size
= (*bytes_read
== 4) ? 4 : 8;
10580 /* Read an offset from the data stream. The size of the offset is
10581 given by cu_header->offset_size. */
10584 read_offset (bfd
*abfd
, gdb_byte
*buf
, const struct comp_unit_head
*cu_header
,
10585 unsigned int *bytes_read
)
10587 LONGEST offset
= read_offset_1 (abfd
, buf
, cu_header
->offset_size
);
10589 *bytes_read
= cu_header
->offset_size
;
10593 /* Read an offset from the data stream. */
10596 read_offset_1 (bfd
*abfd
, gdb_byte
*buf
, unsigned int offset_size
)
10598 LONGEST retval
= 0;
10600 switch (offset_size
)
10603 retval
= bfd_get_32 (abfd
, buf
);
10606 retval
= bfd_get_64 (abfd
, buf
);
10609 internal_error (__FILE__
, __LINE__
,
10610 _("read_offset_1: bad switch [in module %s]"),
10611 bfd_get_filename (abfd
));
10618 read_n_bytes (bfd
*abfd
, gdb_byte
*buf
, unsigned int size
)
10620 /* If the size of a host char is 8 bits, we can return a pointer
10621 to the buffer, otherwise we have to copy the data to a buffer
10622 allocated on the temporary obstack. */
10623 gdb_assert (HOST_CHAR_BIT
== 8);
10628 read_direct_string (bfd
*abfd
, gdb_byte
*buf
, unsigned int *bytes_read_ptr
)
10630 /* If the size of a host char is 8 bits, we can return a pointer
10631 to the string, otherwise we have to copy the string to a buffer
10632 allocated on the temporary obstack. */
10633 gdb_assert (HOST_CHAR_BIT
== 8);
10636 *bytes_read_ptr
= 1;
10639 *bytes_read_ptr
= strlen ((char *) buf
) + 1;
10640 return (char *) buf
;
10644 read_indirect_string_at_offset (bfd
*abfd
, LONGEST str_offset
)
10646 dwarf2_read_section (dwarf2_per_objfile
->objfile
, &dwarf2_per_objfile
->str
);
10647 if (dwarf2_per_objfile
->str
.buffer
== NULL
)
10648 error (_("DW_FORM_strp used without .debug_str section [in module %s]"),
10649 bfd_get_filename (abfd
));
10650 if (str_offset
>= dwarf2_per_objfile
->str
.size
)
10651 error (_("DW_FORM_strp pointing outside of "
10652 ".debug_str section [in module %s]"),
10653 bfd_get_filename (abfd
));
10654 gdb_assert (HOST_CHAR_BIT
== 8);
10655 if (dwarf2_per_objfile
->str
.buffer
[str_offset
] == '\0')
10657 return (char *) (dwarf2_per_objfile
->str
.buffer
+ str_offset
);
10661 read_indirect_string (bfd
*abfd
, gdb_byte
*buf
,
10662 const struct comp_unit_head
*cu_header
,
10663 unsigned int *bytes_read_ptr
)
10665 LONGEST str_offset
= read_offset (abfd
, buf
, cu_header
, bytes_read_ptr
);
10667 return read_indirect_string_at_offset (abfd
, str_offset
);
10670 static unsigned long
10671 read_unsigned_leb128 (bfd
*abfd
, gdb_byte
*buf
, unsigned int *bytes_read_ptr
)
10673 unsigned long result
;
10674 unsigned int num_read
;
10676 unsigned char byte
;
10684 byte
= bfd_get_8 (abfd
, buf
);
10687 result
|= ((unsigned long)(byte
& 127) << shift
);
10688 if ((byte
& 128) == 0)
10694 *bytes_read_ptr
= num_read
;
10699 read_signed_leb128 (bfd
*abfd
, gdb_byte
*buf
, unsigned int *bytes_read_ptr
)
10702 int i
, shift
, num_read
;
10703 unsigned char byte
;
10711 byte
= bfd_get_8 (abfd
, buf
);
10714 result
|= ((long)(byte
& 127) << shift
);
10716 if ((byte
& 128) == 0)
10721 if ((shift
< 8 * sizeof (result
)) && (byte
& 0x40))
10722 result
|= -(((long)1) << shift
);
10723 *bytes_read_ptr
= num_read
;
10727 /* Return a pointer to just past the end of an LEB128 number in BUF. */
10730 skip_leb128 (bfd
*abfd
, gdb_byte
*buf
)
10736 byte
= bfd_get_8 (abfd
, buf
);
10738 if ((byte
& 128) == 0)
10744 set_cu_language (unsigned int lang
, struct dwarf2_cu
*cu
)
10751 cu
->language
= language_c
;
10753 case DW_LANG_C_plus_plus
:
10754 cu
->language
= language_cplus
;
10757 cu
->language
= language_d
;
10759 case DW_LANG_Fortran77
:
10760 case DW_LANG_Fortran90
:
10761 case DW_LANG_Fortran95
:
10762 cu
->language
= language_fortran
;
10764 case DW_LANG_Mips_Assembler
:
10765 cu
->language
= language_asm
;
10768 cu
->language
= language_java
;
10770 case DW_LANG_Ada83
:
10771 case DW_LANG_Ada95
:
10772 cu
->language
= language_ada
;
10774 case DW_LANG_Modula2
:
10775 cu
->language
= language_m2
;
10777 case DW_LANG_Pascal83
:
10778 cu
->language
= language_pascal
;
10781 cu
->language
= language_objc
;
10783 case DW_LANG_Cobol74
:
10784 case DW_LANG_Cobol85
:
10786 cu
->language
= language_minimal
;
10789 cu
->language_defn
= language_def (cu
->language
);
10792 /* Return the named attribute or NULL if not there. */
10794 static struct attribute
*
10795 dwarf2_attr (struct die_info
*die
, unsigned int name
, struct dwarf2_cu
*cu
)
10798 struct attribute
*spec
= NULL
;
10800 for (i
= 0; i
< die
->num_attrs
; ++i
)
10802 if (die
->attrs
[i
].name
== name
)
10803 return &die
->attrs
[i
];
10804 if (die
->attrs
[i
].name
== DW_AT_specification
10805 || die
->attrs
[i
].name
== DW_AT_abstract_origin
)
10806 spec
= &die
->attrs
[i
];
10811 die
= follow_die_ref (die
, spec
, &cu
);
10812 return dwarf2_attr (die
, name
, cu
);
10818 /* Return the named attribute or NULL if not there,
10819 but do not follow DW_AT_specification, etc.
10820 This is for use in contexts where we're reading .debug_types dies.
10821 Following DW_AT_specification, DW_AT_abstract_origin will take us
10822 back up the chain, and we want to go down. */
10824 static struct attribute
*
10825 dwarf2_attr_no_follow (struct die_info
*die
, unsigned int name
,
10826 struct dwarf2_cu
*cu
)
10830 for (i
= 0; i
< die
->num_attrs
; ++i
)
10831 if (die
->attrs
[i
].name
== name
)
10832 return &die
->attrs
[i
];
10837 /* Return non-zero iff the attribute NAME is defined for the given DIE,
10838 and holds a non-zero value. This function should only be used for
10839 DW_FORM_flag or DW_FORM_flag_present attributes. */
10842 dwarf2_flag_true_p (struct die_info
*die
, unsigned name
, struct dwarf2_cu
*cu
)
10844 struct attribute
*attr
= dwarf2_attr (die
, name
, cu
);
10846 return (attr
&& DW_UNSND (attr
));
10850 die_is_declaration (struct die_info
*die
, struct dwarf2_cu
*cu
)
10852 /* A DIE is a declaration if it has a DW_AT_declaration attribute
10853 which value is non-zero. However, we have to be careful with
10854 DIEs having a DW_AT_specification attribute, because dwarf2_attr()
10855 (via dwarf2_flag_true_p) follows this attribute. So we may
10856 end up accidently finding a declaration attribute that belongs
10857 to a different DIE referenced by the specification attribute,
10858 even though the given DIE does not have a declaration attribute. */
10859 return (dwarf2_flag_true_p (die
, DW_AT_declaration
, cu
)
10860 && dwarf2_attr (die
, DW_AT_specification
, cu
) == NULL
);
10863 /* Return the die giving the specification for DIE, if there is
10864 one. *SPEC_CU is the CU containing DIE on input, and the CU
10865 containing the return value on output. If there is no
10866 specification, but there is an abstract origin, that is
10869 static struct die_info
*
10870 die_specification (struct die_info
*die
, struct dwarf2_cu
**spec_cu
)
10872 struct attribute
*spec_attr
= dwarf2_attr (die
, DW_AT_specification
,
10875 if (spec_attr
== NULL
)
10876 spec_attr
= dwarf2_attr (die
, DW_AT_abstract_origin
, *spec_cu
);
10878 if (spec_attr
== NULL
)
10881 return follow_die_ref (die
, spec_attr
, spec_cu
);
10884 /* Free the line_header structure *LH, and any arrays and strings it
10886 NOTE: This is also used as a "cleanup" function. */
10889 free_line_header (struct line_header
*lh
)
10891 if (lh
->standard_opcode_lengths
)
10892 xfree (lh
->standard_opcode_lengths
);
10894 /* Remember that all the lh->file_names[i].name pointers are
10895 pointers into debug_line_buffer, and don't need to be freed. */
10896 if (lh
->file_names
)
10897 xfree (lh
->file_names
);
10899 /* Similarly for the include directory names. */
10900 if (lh
->include_dirs
)
10901 xfree (lh
->include_dirs
);
10906 /* Add an entry to LH's include directory table. */
10909 add_include_dir (struct line_header
*lh
, char *include_dir
)
10911 /* Grow the array if necessary. */
10912 if (lh
->include_dirs_size
== 0)
10914 lh
->include_dirs_size
= 1; /* for testing */
10915 lh
->include_dirs
= xmalloc (lh
->include_dirs_size
10916 * sizeof (*lh
->include_dirs
));
10918 else if (lh
->num_include_dirs
>= lh
->include_dirs_size
)
10920 lh
->include_dirs_size
*= 2;
10921 lh
->include_dirs
= xrealloc (lh
->include_dirs
,
10922 (lh
->include_dirs_size
10923 * sizeof (*lh
->include_dirs
)));
10926 lh
->include_dirs
[lh
->num_include_dirs
++] = include_dir
;
10929 /* Add an entry to LH's file name table. */
10932 add_file_name (struct line_header
*lh
,
10934 unsigned int dir_index
,
10935 unsigned int mod_time
,
10936 unsigned int length
)
10938 struct file_entry
*fe
;
10940 /* Grow the array if necessary. */
10941 if (lh
->file_names_size
== 0)
10943 lh
->file_names_size
= 1; /* for testing */
10944 lh
->file_names
= xmalloc (lh
->file_names_size
10945 * sizeof (*lh
->file_names
));
10947 else if (lh
->num_file_names
>= lh
->file_names_size
)
10949 lh
->file_names_size
*= 2;
10950 lh
->file_names
= xrealloc (lh
->file_names
,
10951 (lh
->file_names_size
10952 * sizeof (*lh
->file_names
)));
10955 fe
= &lh
->file_names
[lh
->num_file_names
++];
10957 fe
->dir_index
= dir_index
;
10958 fe
->mod_time
= mod_time
;
10959 fe
->length
= length
;
10960 fe
->included_p
= 0;
10964 /* Read the statement program header starting at OFFSET in
10965 .debug_line, according to the endianness of ABFD. Return a pointer
10966 to a struct line_header, allocated using xmalloc.
10968 NOTE: the strings in the include directory and file name tables of
10969 the returned object point into debug_line_buffer, and must not be
10972 static struct line_header
*
10973 dwarf_decode_line_header (unsigned int offset
, bfd
*abfd
,
10974 struct dwarf2_cu
*cu
)
10976 struct cleanup
*back_to
;
10977 struct line_header
*lh
;
10978 gdb_byte
*line_ptr
;
10979 unsigned int bytes_read
, offset_size
;
10981 char *cur_dir
, *cur_file
;
10983 dwarf2_read_section (dwarf2_per_objfile
->objfile
, &dwarf2_per_objfile
->line
);
10984 if (dwarf2_per_objfile
->line
.buffer
== NULL
)
10986 complaint (&symfile_complaints
, _("missing .debug_line section"));
10990 /* Make sure that at least there's room for the total_length field.
10991 That could be 12 bytes long, but we're just going to fudge that. */
10992 if (offset
+ 4 >= dwarf2_per_objfile
->line
.size
)
10994 dwarf2_statement_list_fits_in_line_number_section_complaint ();
10998 lh
= xmalloc (sizeof (*lh
));
10999 memset (lh
, 0, sizeof (*lh
));
11000 back_to
= make_cleanup ((make_cleanup_ftype
*) free_line_header
,
11003 line_ptr
= dwarf2_per_objfile
->line
.buffer
+ offset
;
11005 /* Read in the header. */
11007 read_checked_initial_length_and_offset (abfd
, line_ptr
, &cu
->header
,
11008 &bytes_read
, &offset_size
);
11009 line_ptr
+= bytes_read
;
11010 if (line_ptr
+ lh
->total_length
> (dwarf2_per_objfile
->line
.buffer
11011 + dwarf2_per_objfile
->line
.size
))
11013 dwarf2_statement_list_fits_in_line_number_section_complaint ();
11016 lh
->statement_program_end
= line_ptr
+ lh
->total_length
;
11017 lh
->version
= read_2_bytes (abfd
, line_ptr
);
11019 lh
->header_length
= read_offset_1 (abfd
, line_ptr
, offset_size
);
11020 line_ptr
+= offset_size
;
11021 lh
->minimum_instruction_length
= read_1_byte (abfd
, line_ptr
);
11023 if (lh
->version
>= 4)
11025 lh
->maximum_ops_per_instruction
= read_1_byte (abfd
, line_ptr
);
11029 lh
->maximum_ops_per_instruction
= 1;
11031 if (lh
->maximum_ops_per_instruction
== 0)
11033 lh
->maximum_ops_per_instruction
= 1;
11034 complaint (&symfile_complaints
,
11035 _("invalid maximum_ops_per_instruction "
11036 "in `.debug_line' section"));
11039 lh
->default_is_stmt
= read_1_byte (abfd
, line_ptr
);
11041 lh
->line_base
= read_1_signed_byte (abfd
, line_ptr
);
11043 lh
->line_range
= read_1_byte (abfd
, line_ptr
);
11045 lh
->opcode_base
= read_1_byte (abfd
, line_ptr
);
11047 lh
->standard_opcode_lengths
11048 = xmalloc (lh
->opcode_base
* sizeof (lh
->standard_opcode_lengths
[0]));
11050 lh
->standard_opcode_lengths
[0] = 1; /* This should never be used anyway. */
11051 for (i
= 1; i
< lh
->opcode_base
; ++i
)
11053 lh
->standard_opcode_lengths
[i
] = read_1_byte (abfd
, line_ptr
);
11057 /* Read directory table. */
11058 while ((cur_dir
= read_direct_string (abfd
, line_ptr
, &bytes_read
)) != NULL
)
11060 line_ptr
+= bytes_read
;
11061 add_include_dir (lh
, cur_dir
);
11063 line_ptr
+= bytes_read
;
11065 /* Read file name table. */
11066 while ((cur_file
= read_direct_string (abfd
, line_ptr
, &bytes_read
)) != NULL
)
11068 unsigned int dir_index
, mod_time
, length
;
11070 line_ptr
+= bytes_read
;
11071 dir_index
= read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
11072 line_ptr
+= bytes_read
;
11073 mod_time
= read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
11074 line_ptr
+= bytes_read
;
11075 length
= read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
11076 line_ptr
+= bytes_read
;
11078 add_file_name (lh
, cur_file
, dir_index
, mod_time
, length
);
11080 line_ptr
+= bytes_read
;
11081 lh
->statement_program_start
= line_ptr
;
11083 if (line_ptr
> (dwarf2_per_objfile
->line
.buffer
11084 + dwarf2_per_objfile
->line
.size
))
11085 complaint (&symfile_complaints
,
11086 _("line number info header doesn't "
11087 "fit in `.debug_line' section"));
11089 discard_cleanups (back_to
);
11093 /* This function exists to work around a bug in certain compilers
11094 (particularly GCC 2.95), in which the first line number marker of a
11095 function does not show up until after the prologue, right before
11096 the second line number marker. This function shifts ADDRESS down
11097 to the beginning of the function if necessary, and is called on
11098 addresses passed to record_line. */
11101 check_cu_functions (CORE_ADDR address
, struct dwarf2_cu
*cu
)
11103 struct function_range
*fn
;
11105 /* Find the function_range containing address. */
11109 if (!cu
->cached_fn
)
11110 cu
->cached_fn
= cu
->first_fn
;
11112 fn
= cu
->cached_fn
;
11114 if (fn
->lowpc
<= address
&& fn
->highpc
> address
)
11120 while (fn
&& fn
!= cu
->cached_fn
)
11121 if (fn
->lowpc
<= address
&& fn
->highpc
> address
)
11131 if (address
!= fn
->lowpc
)
11132 complaint (&symfile_complaints
,
11133 _("misplaced first line number at 0x%lx for '%s'"),
11134 (unsigned long) address
, fn
->name
);
11139 /* Subroutine of dwarf_decode_lines to simplify it.
11140 Return the file name of the psymtab for included file FILE_INDEX
11141 in line header LH of PST.
11142 COMP_DIR is the compilation directory (DW_AT_comp_dir) or NULL if unknown.
11143 If space for the result is malloc'd, it will be freed by a cleanup.
11144 Returns NULL if FILE_INDEX should be ignored, i.e., it is pst->filename. */
11147 psymtab_include_file_name (const struct line_header
*lh
, int file_index
,
11148 const struct partial_symtab
*pst
,
11149 const char *comp_dir
)
11151 const struct file_entry fe
= lh
->file_names
[file_index
];
11152 char *include_name
= fe
.name
;
11153 char *include_name_to_compare
= include_name
;
11154 char *dir_name
= NULL
;
11155 const char *pst_filename
;
11156 char *copied_name
= NULL
;
11160 dir_name
= lh
->include_dirs
[fe
.dir_index
- 1];
11162 if (!IS_ABSOLUTE_PATH (include_name
)
11163 && (dir_name
!= NULL
|| comp_dir
!= NULL
))
11165 /* Avoid creating a duplicate psymtab for PST.
11166 We do this by comparing INCLUDE_NAME and PST_FILENAME.
11167 Before we do the comparison, however, we need to account
11168 for DIR_NAME and COMP_DIR.
11169 First prepend dir_name (if non-NULL). If we still don't
11170 have an absolute path prepend comp_dir (if non-NULL).
11171 However, the directory we record in the include-file's
11172 psymtab does not contain COMP_DIR (to match the
11173 corresponding symtab(s)).
11178 bash$ gcc -g ./hello.c
11179 include_name = "hello.c"
11181 DW_AT_comp_dir = comp_dir = "/tmp"
11182 DW_AT_name = "./hello.c" */
11184 if (dir_name
!= NULL
)
11186 include_name
= concat (dir_name
, SLASH_STRING
,
11187 include_name
, (char *)NULL
);
11188 include_name_to_compare
= include_name
;
11189 make_cleanup (xfree
, include_name
);
11191 if (!IS_ABSOLUTE_PATH (include_name
) && comp_dir
!= NULL
)
11193 include_name_to_compare
= concat (comp_dir
, SLASH_STRING
,
11194 include_name
, (char *)NULL
);
11198 pst_filename
= pst
->filename
;
11199 if (!IS_ABSOLUTE_PATH (pst_filename
) && pst
->dirname
!= NULL
)
11201 copied_name
= concat (pst
->dirname
, SLASH_STRING
,
11202 pst_filename
, (char *)NULL
);
11203 pst_filename
= copied_name
;
11206 file_is_pst
= FILENAME_CMP (include_name_to_compare
, pst_filename
) == 0;
11208 if (include_name_to_compare
!= include_name
)
11209 xfree (include_name_to_compare
);
11210 if (copied_name
!= NULL
)
11211 xfree (copied_name
);
11215 return include_name
;
11218 /* Ignore this record_line request. */
11221 noop_record_line (struct subfile
*subfile
, int line
, CORE_ADDR pc
)
11226 /* Decode the Line Number Program (LNP) for the given line_header
11227 structure and CU. The actual information extracted and the type
11228 of structures created from the LNP depends on the value of PST.
11230 1. If PST is NULL, then this procedure uses the data from the program
11231 to create all necessary symbol tables, and their linetables.
11233 2. If PST is not NULL, this procedure reads the program to determine
11234 the list of files included by the unit represented by PST, and
11235 builds all the associated partial symbol tables.
11237 COMP_DIR is the compilation directory (DW_AT_comp_dir) or NULL if unknown.
11238 It is used for relative paths in the line table.
11239 NOTE: When processing partial symtabs (pst != NULL),
11240 comp_dir == pst->dirname.
11242 NOTE: It is important that psymtabs have the same file name (via strcmp)
11243 as the corresponding symtab. Since COMP_DIR is not used in the name of the
11244 symtab we don't use it in the name of the psymtabs we create.
11245 E.g. expand_line_sal requires this when finding psymtabs to expand.
11246 A good testcase for this is mb-inline.exp. */
11249 dwarf_decode_lines (struct line_header
*lh
, const char *comp_dir
, bfd
*abfd
,
11250 struct dwarf2_cu
*cu
, struct partial_symtab
*pst
)
11252 gdb_byte
*line_ptr
, *extended_end
;
11253 gdb_byte
*line_end
;
11254 unsigned int bytes_read
, extended_len
;
11255 unsigned char op_code
, extended_op
, adj_opcode
;
11256 CORE_ADDR baseaddr
;
11257 struct objfile
*objfile
= cu
->objfile
;
11258 struct gdbarch
*gdbarch
= get_objfile_arch (objfile
);
11259 const int decode_for_pst_p
= (pst
!= NULL
);
11260 struct subfile
*last_subfile
= NULL
, *first_subfile
= current_subfile
;
11261 void (*p_record_line
) (struct subfile
*subfile
, int line
, CORE_ADDR pc
)
11264 baseaddr
= ANOFFSET (objfile
->section_offsets
, SECT_OFF_TEXT (objfile
));
11266 line_ptr
= lh
->statement_program_start
;
11267 line_end
= lh
->statement_program_end
;
11269 /* Read the statement sequences until there's nothing left. */
11270 while (line_ptr
< line_end
)
11272 /* state machine registers */
11273 CORE_ADDR address
= 0;
11274 unsigned int file
= 1;
11275 unsigned int line
= 1;
11276 unsigned int column
= 0;
11277 int is_stmt
= lh
->default_is_stmt
;
11278 int basic_block
= 0;
11279 int end_sequence
= 0;
11281 unsigned char op_index
= 0;
11283 if (!decode_for_pst_p
&& lh
->num_file_names
>= file
)
11285 /* Start a subfile for the current file of the state machine. */
11286 /* lh->include_dirs and lh->file_names are 0-based, but the
11287 directory and file name numbers in the statement program
11289 struct file_entry
*fe
= &lh
->file_names
[file
- 1];
11293 dir
= lh
->include_dirs
[fe
->dir_index
- 1];
11295 dwarf2_start_subfile (fe
->name
, dir
, comp_dir
);
11298 /* Decode the table. */
11299 while (!end_sequence
)
11301 op_code
= read_1_byte (abfd
, line_ptr
);
11303 if (line_ptr
> line_end
)
11305 dwarf2_debug_line_missing_end_sequence_complaint ();
11309 if (op_code
>= lh
->opcode_base
)
11311 /* Special operand. */
11312 adj_opcode
= op_code
- lh
->opcode_base
;
11313 address
+= (((op_index
+ (adj_opcode
/ lh
->line_range
))
11314 / lh
->maximum_ops_per_instruction
)
11315 * lh
->minimum_instruction_length
);
11316 op_index
= ((op_index
+ (adj_opcode
/ lh
->line_range
))
11317 % lh
->maximum_ops_per_instruction
);
11318 line
+= lh
->line_base
+ (adj_opcode
% lh
->line_range
);
11319 if (lh
->num_file_names
< file
|| file
== 0)
11320 dwarf2_debug_line_missing_file_complaint ();
11321 /* For now we ignore lines not starting on an
11322 instruction boundary. */
11323 else if (op_index
== 0)
11325 lh
->file_names
[file
- 1].included_p
= 1;
11326 if (!decode_for_pst_p
&& is_stmt
)
11328 if (last_subfile
!= current_subfile
)
11330 addr
= gdbarch_addr_bits_remove (gdbarch
, address
);
11332 (*p_record_line
) (last_subfile
, 0, addr
);
11333 last_subfile
= current_subfile
;
11335 /* Append row to matrix using current values. */
11336 addr
= check_cu_functions (address
, cu
);
11337 addr
= gdbarch_addr_bits_remove (gdbarch
, addr
);
11338 (*p_record_line
) (current_subfile
, line
, addr
);
11343 else switch (op_code
)
11345 case DW_LNS_extended_op
:
11346 extended_len
= read_unsigned_leb128 (abfd
, line_ptr
,
11348 line_ptr
+= bytes_read
;
11349 extended_end
= line_ptr
+ extended_len
;
11350 extended_op
= read_1_byte (abfd
, line_ptr
);
11352 switch (extended_op
)
11354 case DW_LNE_end_sequence
:
11355 p_record_line
= record_line
;
11358 case DW_LNE_set_address
:
11359 address
= read_address (abfd
, line_ptr
, cu
, &bytes_read
);
11361 if (address
== 0 && !dwarf2_per_objfile
->has_section_at_zero
)
11363 /* This line table is for a function which has been
11364 GCd by the linker. Ignore it. PR gdb/12528 */
11367 = line_ptr
- dwarf2_per_objfile
->line
.buffer
;
11369 complaint (&symfile_complaints
,
11370 _(".debug_line address at offset 0x%lx is 0 "
11372 line_offset
, cu
->objfile
->name
);
11373 p_record_line
= noop_record_line
;
11377 line_ptr
+= bytes_read
;
11378 address
+= baseaddr
;
11380 case DW_LNE_define_file
:
11383 unsigned int dir_index
, mod_time
, length
;
11385 cur_file
= read_direct_string (abfd
, line_ptr
,
11387 line_ptr
+= bytes_read
;
11389 read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
11390 line_ptr
+= bytes_read
;
11392 read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
11393 line_ptr
+= bytes_read
;
11395 read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
11396 line_ptr
+= bytes_read
;
11397 add_file_name (lh
, cur_file
, dir_index
, mod_time
, length
);
11400 case DW_LNE_set_discriminator
:
11401 /* The discriminator is not interesting to the debugger;
11403 line_ptr
= extended_end
;
11406 complaint (&symfile_complaints
,
11407 _("mangled .debug_line section"));
11410 /* Make sure that we parsed the extended op correctly. If e.g.
11411 we expected a different address size than the producer used,
11412 we may have read the wrong number of bytes. */
11413 if (line_ptr
!= extended_end
)
11415 complaint (&symfile_complaints
,
11416 _("mangled .debug_line section"));
11421 if (lh
->num_file_names
< file
|| file
== 0)
11422 dwarf2_debug_line_missing_file_complaint ();
11425 lh
->file_names
[file
- 1].included_p
= 1;
11426 if (!decode_for_pst_p
&& is_stmt
)
11428 if (last_subfile
!= current_subfile
)
11430 addr
= gdbarch_addr_bits_remove (gdbarch
, address
);
11432 (*p_record_line
) (last_subfile
, 0, addr
);
11433 last_subfile
= current_subfile
;
11435 addr
= check_cu_functions (address
, cu
);
11436 addr
= gdbarch_addr_bits_remove (gdbarch
, addr
);
11437 (*p_record_line
) (current_subfile
, line
, addr
);
11442 case DW_LNS_advance_pc
:
11445 = read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
11447 address
+= (((op_index
+ adjust
)
11448 / lh
->maximum_ops_per_instruction
)
11449 * lh
->minimum_instruction_length
);
11450 op_index
= ((op_index
+ adjust
)
11451 % lh
->maximum_ops_per_instruction
);
11452 line_ptr
+= bytes_read
;
11455 case DW_LNS_advance_line
:
11456 line
+= read_signed_leb128 (abfd
, line_ptr
, &bytes_read
);
11457 line_ptr
+= bytes_read
;
11459 case DW_LNS_set_file
:
11461 /* The arrays lh->include_dirs and lh->file_names are
11462 0-based, but the directory and file name numbers in
11463 the statement program are 1-based. */
11464 struct file_entry
*fe
;
11467 file
= read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
11468 line_ptr
+= bytes_read
;
11469 if (lh
->num_file_names
< file
|| file
== 0)
11470 dwarf2_debug_line_missing_file_complaint ();
11473 fe
= &lh
->file_names
[file
- 1];
11475 dir
= lh
->include_dirs
[fe
->dir_index
- 1];
11476 if (!decode_for_pst_p
)
11478 last_subfile
= current_subfile
;
11479 dwarf2_start_subfile (fe
->name
, dir
, comp_dir
);
11484 case DW_LNS_set_column
:
11485 column
= read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
11486 line_ptr
+= bytes_read
;
11488 case DW_LNS_negate_stmt
:
11489 is_stmt
= (!is_stmt
);
11491 case DW_LNS_set_basic_block
:
11494 /* Add to the address register of the state machine the
11495 address increment value corresponding to special opcode
11496 255. I.e., this value is scaled by the minimum
11497 instruction length since special opcode 255 would have
11498 scaled the increment. */
11499 case DW_LNS_const_add_pc
:
11501 CORE_ADDR adjust
= (255 - lh
->opcode_base
) / lh
->line_range
;
11503 address
+= (((op_index
+ adjust
)
11504 / lh
->maximum_ops_per_instruction
)
11505 * lh
->minimum_instruction_length
);
11506 op_index
= ((op_index
+ adjust
)
11507 % lh
->maximum_ops_per_instruction
);
11510 case DW_LNS_fixed_advance_pc
:
11511 address
+= read_2_bytes (abfd
, line_ptr
);
11517 /* Unknown standard opcode, ignore it. */
11520 for (i
= 0; i
< lh
->standard_opcode_lengths
[op_code
]; i
++)
11522 (void) read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
11523 line_ptr
+= bytes_read
;
11528 if (lh
->num_file_names
< file
|| file
== 0)
11529 dwarf2_debug_line_missing_file_complaint ();
11532 lh
->file_names
[file
- 1].included_p
= 1;
11533 if (!decode_for_pst_p
)
11535 addr
= gdbarch_addr_bits_remove (gdbarch
, address
);
11536 (*p_record_line
) (current_subfile
, 0, addr
);
11541 if (decode_for_pst_p
)
11545 /* Now that we're done scanning the Line Header Program, we can
11546 create the psymtab of each included file. */
11547 for (file_index
= 0; file_index
< lh
->num_file_names
; file_index
++)
11548 if (lh
->file_names
[file_index
].included_p
== 1)
11550 char *include_name
=
11551 psymtab_include_file_name (lh
, file_index
, pst
, comp_dir
);
11552 if (include_name
!= NULL
)
11553 dwarf2_create_include_psymtab (include_name
, pst
, objfile
);
11558 /* Make sure a symtab is created for every file, even files
11559 which contain only variables (i.e. no code with associated
11563 struct file_entry
*fe
;
11565 for (i
= 0; i
< lh
->num_file_names
; i
++)
11569 fe
= &lh
->file_names
[i
];
11571 dir
= lh
->include_dirs
[fe
->dir_index
- 1];
11572 dwarf2_start_subfile (fe
->name
, dir
, comp_dir
);
11574 /* Skip the main file; we don't need it, and it must be
11575 allocated last, so that it will show up before the
11576 non-primary symtabs in the objfile's symtab list. */
11577 if (current_subfile
== first_subfile
)
11580 if (current_subfile
->symtab
== NULL
)
11581 current_subfile
->symtab
= allocate_symtab (current_subfile
->name
,
11583 fe
->symtab
= current_subfile
->symtab
;
11588 /* Start a subfile for DWARF. FILENAME is the name of the file and
11589 DIRNAME the name of the source directory which contains FILENAME
11590 or NULL if not known. COMP_DIR is the compilation directory for the
11591 linetable's compilation unit or NULL if not known.
11592 This routine tries to keep line numbers from identical absolute and
11593 relative file names in a common subfile.
11595 Using the `list' example from the GDB testsuite, which resides in
11596 /srcdir and compiling it with Irix6.2 cc in /compdir using a filename
11597 of /srcdir/list0.c yields the following debugging information for list0.c:
11599 DW_AT_name: /srcdir/list0.c
11600 DW_AT_comp_dir: /compdir
11601 files.files[0].name: list0.h
11602 files.files[0].dir: /srcdir
11603 files.files[1].name: list0.c
11604 files.files[1].dir: /srcdir
11606 The line number information for list0.c has to end up in a single
11607 subfile, so that `break /srcdir/list0.c:1' works as expected.
11608 start_subfile will ensure that this happens provided that we pass the
11609 concatenation of files.files[1].dir and files.files[1].name as the
11613 dwarf2_start_subfile (char *filename
, const char *dirname
,
11614 const char *comp_dir
)
11618 /* While reading the DIEs, we call start_symtab(DW_AT_name, DW_AT_comp_dir).
11619 `start_symtab' will always pass the contents of DW_AT_comp_dir as
11620 second argument to start_subfile. To be consistent, we do the
11621 same here. In order not to lose the line information directory,
11622 we concatenate it to the filename when it makes sense.
11623 Note that the Dwarf3 standard says (speaking of filenames in line
11624 information): ``The directory index is ignored for file names
11625 that represent full path names''. Thus ignoring dirname in the
11626 `else' branch below isn't an issue. */
11628 if (!IS_ABSOLUTE_PATH (filename
) && dirname
!= NULL
)
11629 fullname
= concat (dirname
, SLASH_STRING
, filename
, (char *)NULL
);
11631 fullname
= filename
;
11633 start_subfile (fullname
, comp_dir
);
11635 if (fullname
!= filename
)
11640 var_decode_location (struct attribute
*attr
, struct symbol
*sym
,
11641 struct dwarf2_cu
*cu
)
11643 struct objfile
*objfile
= cu
->objfile
;
11644 struct comp_unit_head
*cu_header
= &cu
->header
;
11646 /* NOTE drow/2003-01-30: There used to be a comment and some special
11647 code here to turn a symbol with DW_AT_external and a
11648 SYMBOL_VALUE_ADDRESS of 0 into a LOC_UNRESOLVED symbol. This was
11649 necessary for platforms (maybe Alpha, certainly PowerPC GNU/Linux
11650 with some versions of binutils) where shared libraries could have
11651 relocations against symbols in their debug information - the
11652 minimal symbol would have the right address, but the debug info
11653 would not. It's no longer necessary, because we will explicitly
11654 apply relocations when we read in the debug information now. */
11656 /* A DW_AT_location attribute with no contents indicates that a
11657 variable has been optimized away. */
11658 if (attr_form_is_block (attr
) && DW_BLOCK (attr
)->size
== 0)
11660 SYMBOL_CLASS (sym
) = LOC_OPTIMIZED_OUT
;
11664 /* Handle one degenerate form of location expression specially, to
11665 preserve GDB's previous behavior when section offsets are
11666 specified. If this is just a DW_OP_addr then mark this symbol
11669 if (attr_form_is_block (attr
)
11670 && DW_BLOCK (attr
)->size
== 1 + cu_header
->addr_size
11671 && DW_BLOCK (attr
)->data
[0] == DW_OP_addr
)
11673 unsigned int dummy
;
11675 SYMBOL_VALUE_ADDRESS (sym
) =
11676 read_address (objfile
->obfd
, DW_BLOCK (attr
)->data
+ 1, cu
, &dummy
);
11677 SYMBOL_CLASS (sym
) = LOC_STATIC
;
11678 fixup_symbol_section (sym
, objfile
);
11679 SYMBOL_VALUE_ADDRESS (sym
) += ANOFFSET (objfile
->section_offsets
,
11680 SYMBOL_SECTION (sym
));
11684 /* NOTE drow/2002-01-30: It might be worthwhile to have a static
11685 expression evaluator, and use LOC_COMPUTED only when necessary
11686 (i.e. when the value of a register or memory location is
11687 referenced, or a thread-local block, etc.). Then again, it might
11688 not be worthwhile. I'm assuming that it isn't unless performance
11689 or memory numbers show me otherwise. */
11691 dwarf2_symbol_mark_computed (attr
, sym
, cu
);
11692 SYMBOL_CLASS (sym
) = LOC_COMPUTED
;
11694 if (SYMBOL_COMPUTED_OPS (sym
) == &dwarf2_loclist_funcs
)
11695 cu
->has_loclist
= 1;
11698 /* Given a pointer to a DWARF information entry, figure out if we need
11699 to make a symbol table entry for it, and if so, create a new entry
11700 and return a pointer to it.
11701 If TYPE is NULL, determine symbol type from the die, otherwise
11702 used the passed type.
11703 If SPACE is not NULL, use it to hold the new symbol. If it is
11704 NULL, allocate a new symbol on the objfile's obstack. */
11706 static struct symbol
*
11707 new_symbol_full (struct die_info
*die
, struct type
*type
, struct dwarf2_cu
*cu
,
11708 struct symbol
*space
)
11710 struct objfile
*objfile
= cu
->objfile
;
11711 struct symbol
*sym
= NULL
;
11713 struct attribute
*attr
= NULL
;
11714 struct attribute
*attr2
= NULL
;
11715 CORE_ADDR baseaddr
;
11716 struct pending
**list_to_add
= NULL
;
11718 int inlined_func
= (die
->tag
== DW_TAG_inlined_subroutine
);
11720 baseaddr
= ANOFFSET (objfile
->section_offsets
, SECT_OFF_TEXT (objfile
));
11722 name
= dwarf2_name (die
, cu
);
11725 const char *linkagename
;
11726 int suppress_add
= 0;
11731 sym
= OBSTACK_ZALLOC (&objfile
->objfile_obstack
, struct symbol
);
11732 OBJSTAT (objfile
, n_syms
++);
11734 /* Cache this symbol's name and the name's demangled form (if any). */
11735 SYMBOL_SET_LANGUAGE (sym
, cu
->language
);
11736 linkagename
= dwarf2_physname (name
, die
, cu
);
11737 SYMBOL_SET_NAMES (sym
, linkagename
, strlen (linkagename
), 0, objfile
);
11739 /* Fortran does not have mangling standard and the mangling does differ
11740 between gfortran, iFort etc. */
11741 if (cu
->language
== language_fortran
11742 && symbol_get_demangled_name (&(sym
->ginfo
)) == NULL
)
11743 symbol_set_demangled_name (&(sym
->ginfo
),
11744 (char *) dwarf2_full_name (name
, die
, cu
),
11747 /* Default assumptions.
11748 Use the passed type or decode it from the die. */
11749 SYMBOL_DOMAIN (sym
) = VAR_DOMAIN
;
11750 SYMBOL_CLASS (sym
) = LOC_OPTIMIZED_OUT
;
11752 SYMBOL_TYPE (sym
) = type
;
11754 SYMBOL_TYPE (sym
) = die_type (die
, cu
);
11755 attr
= dwarf2_attr (die
,
11756 inlined_func
? DW_AT_call_line
: DW_AT_decl_line
,
11760 SYMBOL_LINE (sym
) = DW_UNSND (attr
);
11763 attr
= dwarf2_attr (die
,
11764 inlined_func
? DW_AT_call_file
: DW_AT_decl_file
,
11768 int file_index
= DW_UNSND (attr
);
11770 if (cu
->line_header
== NULL
11771 || file_index
> cu
->line_header
->num_file_names
)
11772 complaint (&symfile_complaints
,
11773 _("file index out of range"));
11774 else if (file_index
> 0)
11776 struct file_entry
*fe
;
11778 fe
= &cu
->line_header
->file_names
[file_index
- 1];
11779 SYMBOL_SYMTAB (sym
) = fe
->symtab
;
11786 attr
= dwarf2_attr (die
, DW_AT_low_pc
, cu
);
11789 SYMBOL_VALUE_ADDRESS (sym
) = DW_ADDR (attr
) + baseaddr
;
11791 SYMBOL_TYPE (sym
) = objfile_type (objfile
)->builtin_core_addr
;
11792 SYMBOL_DOMAIN (sym
) = LABEL_DOMAIN
;
11793 SYMBOL_CLASS (sym
) = LOC_LABEL
;
11794 add_symbol_to_list (sym
, cu
->list_in_scope
);
11796 case DW_TAG_subprogram
:
11797 /* SYMBOL_BLOCK_VALUE (sym) will be filled in later by
11799 SYMBOL_CLASS (sym
) = LOC_BLOCK
;
11800 attr2
= dwarf2_attr (die
, DW_AT_external
, cu
);
11801 if ((attr2
&& (DW_UNSND (attr2
) != 0))
11802 || cu
->language
== language_ada
)
11804 /* Subprograms marked external are stored as a global symbol.
11805 Ada subprograms, whether marked external or not, are always
11806 stored as a global symbol, because we want to be able to
11807 access them globally. For instance, we want to be able
11808 to break on a nested subprogram without having to
11809 specify the context. */
11810 list_to_add
= &global_symbols
;
11814 list_to_add
= cu
->list_in_scope
;
11817 case DW_TAG_inlined_subroutine
:
11818 /* SYMBOL_BLOCK_VALUE (sym) will be filled in later by
11820 SYMBOL_CLASS (sym
) = LOC_BLOCK
;
11821 SYMBOL_INLINED (sym
) = 1;
11822 /* Do not add the symbol to any lists. It will be found via
11823 BLOCK_FUNCTION from the blockvector. */
11825 case DW_TAG_template_value_param
:
11827 /* Fall through. */
11828 case DW_TAG_constant
:
11829 case DW_TAG_variable
:
11830 case DW_TAG_member
:
11831 /* Compilation with minimal debug info may result in
11832 variables with missing type entries. Change the
11833 misleading `void' type to something sensible. */
11834 if (TYPE_CODE (SYMBOL_TYPE (sym
)) == TYPE_CODE_VOID
)
11836 = objfile_type (objfile
)->nodebug_data_symbol
;
11838 attr
= dwarf2_attr (die
, DW_AT_const_value
, cu
);
11839 /* In the case of DW_TAG_member, we should only be called for
11840 static const members. */
11841 if (die
->tag
== DW_TAG_member
)
11843 /* dwarf2_add_field uses die_is_declaration,
11844 so we do the same. */
11845 gdb_assert (die_is_declaration (die
, cu
));
11850 dwarf2_const_value (attr
, sym
, cu
);
11851 attr2
= dwarf2_attr (die
, DW_AT_external
, cu
);
11854 if (attr2
&& (DW_UNSND (attr2
) != 0))
11855 list_to_add
= &global_symbols
;
11857 list_to_add
= cu
->list_in_scope
;
11861 attr
= dwarf2_attr (die
, DW_AT_location
, cu
);
11864 var_decode_location (attr
, sym
, cu
);
11865 attr2
= dwarf2_attr (die
, DW_AT_external
, cu
);
11866 if (SYMBOL_CLASS (sym
) == LOC_STATIC
11867 && SYMBOL_VALUE_ADDRESS (sym
) == 0
11868 && !dwarf2_per_objfile
->has_section_at_zero
)
11870 /* When a static variable is eliminated by the linker,
11871 the corresponding debug information is not stripped
11872 out, but the variable address is set to null;
11873 do not add such variables into symbol table. */
11875 else if (attr2
&& (DW_UNSND (attr2
) != 0))
11877 /* Workaround gfortran PR debug/40040 - it uses
11878 DW_AT_location for variables in -fPIC libraries which may
11879 get overriden by other libraries/executable and get
11880 a different address. Resolve it by the minimal symbol
11881 which may come from inferior's executable using copy
11882 relocation. Make this workaround only for gfortran as for
11883 other compilers GDB cannot guess the minimal symbol
11884 Fortran mangling kind. */
11885 if (cu
->language
== language_fortran
&& die
->parent
11886 && die
->parent
->tag
== DW_TAG_module
11888 && strncmp (cu
->producer
, "GNU Fortran ", 12) == 0)
11889 SYMBOL_CLASS (sym
) = LOC_UNRESOLVED
;
11891 /* A variable with DW_AT_external is never static,
11892 but it may be block-scoped. */
11893 list_to_add
= (cu
->list_in_scope
== &file_symbols
11894 ? &global_symbols
: cu
->list_in_scope
);
11897 list_to_add
= cu
->list_in_scope
;
11901 /* We do not know the address of this symbol.
11902 If it is an external symbol and we have type information
11903 for it, enter the symbol as a LOC_UNRESOLVED symbol.
11904 The address of the variable will then be determined from
11905 the minimal symbol table whenever the variable is
11907 attr2
= dwarf2_attr (die
, DW_AT_external
, cu
);
11908 if (attr2
&& (DW_UNSND (attr2
) != 0)
11909 && dwarf2_attr (die
, DW_AT_type
, cu
) != NULL
)
11911 /* A variable with DW_AT_external is never static, but it
11912 may be block-scoped. */
11913 list_to_add
= (cu
->list_in_scope
== &file_symbols
11914 ? &global_symbols
: cu
->list_in_scope
);
11916 SYMBOL_CLASS (sym
) = LOC_UNRESOLVED
;
11918 else if (!die_is_declaration (die
, cu
))
11920 /* Use the default LOC_OPTIMIZED_OUT class. */
11921 gdb_assert (SYMBOL_CLASS (sym
) == LOC_OPTIMIZED_OUT
);
11923 list_to_add
= cu
->list_in_scope
;
11927 case DW_TAG_formal_parameter
:
11928 /* If we are inside a function, mark this as an argument. If
11929 not, we might be looking at an argument to an inlined function
11930 when we do not have enough information to show inlined frames;
11931 pretend it's a local variable in that case so that the user can
11933 if (context_stack_depth
> 0
11934 && context_stack
[context_stack_depth
- 1].name
!= NULL
)
11935 SYMBOL_IS_ARGUMENT (sym
) = 1;
11936 attr
= dwarf2_attr (die
, DW_AT_location
, cu
);
11939 var_decode_location (attr
, sym
, cu
);
11941 attr
= dwarf2_attr (die
, DW_AT_const_value
, cu
);
11944 dwarf2_const_value (attr
, sym
, cu
);
11947 list_to_add
= cu
->list_in_scope
;
11949 case DW_TAG_unspecified_parameters
:
11950 /* From varargs functions; gdb doesn't seem to have any
11951 interest in this information, so just ignore it for now.
11954 case DW_TAG_template_type_param
:
11956 /* Fall through. */
11957 case DW_TAG_class_type
:
11958 case DW_TAG_interface_type
:
11959 case DW_TAG_structure_type
:
11960 case DW_TAG_union_type
:
11961 case DW_TAG_set_type
:
11962 case DW_TAG_enumeration_type
:
11963 SYMBOL_CLASS (sym
) = LOC_TYPEDEF
;
11964 SYMBOL_DOMAIN (sym
) = STRUCT_DOMAIN
;
11967 /* NOTE: carlton/2003-11-10: C++ and Java class symbols shouldn't
11968 really ever be static objects: otherwise, if you try
11969 to, say, break of a class's method and you're in a file
11970 which doesn't mention that class, it won't work unless
11971 the check for all static symbols in lookup_symbol_aux
11972 saves you. See the OtherFileClass tests in
11973 gdb.c++/namespace.exp. */
11977 list_to_add
= (cu
->list_in_scope
== &file_symbols
11978 && (cu
->language
== language_cplus
11979 || cu
->language
== language_java
)
11980 ? &global_symbols
: cu
->list_in_scope
);
11982 /* The semantics of C++ state that "struct foo {
11983 ... }" also defines a typedef for "foo". A Java
11984 class declaration also defines a typedef for the
11986 if (cu
->language
== language_cplus
11987 || cu
->language
== language_java
11988 || cu
->language
== language_ada
)
11990 /* The symbol's name is already allocated along
11991 with this objfile, so we don't need to
11992 duplicate it for the type. */
11993 if (TYPE_NAME (SYMBOL_TYPE (sym
)) == 0)
11994 TYPE_NAME (SYMBOL_TYPE (sym
)) = SYMBOL_SEARCH_NAME (sym
);
11999 case DW_TAG_typedef
:
12000 SYMBOL_CLASS (sym
) = LOC_TYPEDEF
;
12001 SYMBOL_DOMAIN (sym
) = VAR_DOMAIN
;
12002 list_to_add
= cu
->list_in_scope
;
12004 case DW_TAG_base_type
:
12005 case DW_TAG_subrange_type
:
12006 SYMBOL_CLASS (sym
) = LOC_TYPEDEF
;
12007 SYMBOL_DOMAIN (sym
) = VAR_DOMAIN
;
12008 list_to_add
= cu
->list_in_scope
;
12010 case DW_TAG_enumerator
:
12011 attr
= dwarf2_attr (die
, DW_AT_const_value
, cu
);
12014 dwarf2_const_value (attr
, sym
, cu
);
12017 /* NOTE: carlton/2003-11-10: See comment above in the
12018 DW_TAG_class_type, etc. block. */
12020 list_to_add
= (cu
->list_in_scope
== &file_symbols
12021 && (cu
->language
== language_cplus
12022 || cu
->language
== language_java
)
12023 ? &global_symbols
: cu
->list_in_scope
);
12026 case DW_TAG_namespace
:
12027 SYMBOL_CLASS (sym
) = LOC_TYPEDEF
;
12028 list_to_add
= &global_symbols
;
12031 /* Not a tag we recognize. Hopefully we aren't processing
12032 trash data, but since we must specifically ignore things
12033 we don't recognize, there is nothing else we should do at
12035 complaint (&symfile_complaints
, _("unsupported tag: '%s'"),
12036 dwarf_tag_name (die
->tag
));
12042 sym
->hash_next
= objfile
->template_symbols
;
12043 objfile
->template_symbols
= sym
;
12044 list_to_add
= NULL
;
12047 if (list_to_add
!= NULL
)
12048 add_symbol_to_list (sym
, list_to_add
);
12050 /* For the benefit of old versions of GCC, check for anonymous
12051 namespaces based on the demangled name. */
12052 if (!processing_has_namespace_info
12053 && cu
->language
== language_cplus
)
12054 cp_scan_for_anonymous_namespaces (sym
, objfile
);
12059 /* A wrapper for new_symbol_full that always allocates a new symbol. */
12061 static struct symbol
*
12062 new_symbol (struct die_info
*die
, struct type
*type
, struct dwarf2_cu
*cu
)
12064 return new_symbol_full (die
, type
, cu
, NULL
);
12067 /* Given an attr with a DW_FORM_dataN value in host byte order,
12068 zero-extend it as appropriate for the symbol's type. The DWARF
12069 standard (v4) is not entirely clear about the meaning of using
12070 DW_FORM_dataN for a constant with a signed type, where the type is
12071 wider than the data. The conclusion of a discussion on the DWARF
12072 list was that this is unspecified. We choose to always zero-extend
12073 because that is the interpretation long in use by GCC. */
12076 dwarf2_const_value_data (struct attribute
*attr
, struct type
*type
,
12077 const char *name
, struct obstack
*obstack
,
12078 struct dwarf2_cu
*cu
, long *value
, int bits
)
12080 struct objfile
*objfile
= cu
->objfile
;
12081 enum bfd_endian byte_order
= bfd_big_endian (objfile
->obfd
) ?
12082 BFD_ENDIAN_BIG
: BFD_ENDIAN_LITTLE
;
12083 LONGEST l
= DW_UNSND (attr
);
12085 if (bits
< sizeof (*value
) * 8)
12087 l
&= ((LONGEST
) 1 << bits
) - 1;
12090 else if (bits
== sizeof (*value
) * 8)
12094 gdb_byte
*bytes
= obstack_alloc (obstack
, bits
/ 8);
12095 store_unsigned_integer (bytes
, bits
/ 8, byte_order
, l
);
12102 /* Read a constant value from an attribute. Either set *VALUE, or if
12103 the value does not fit in *VALUE, set *BYTES - either already
12104 allocated on the objfile obstack, or newly allocated on OBSTACK,
12105 or, set *BATON, if we translated the constant to a location
12109 dwarf2_const_value_attr (struct attribute
*attr
, struct type
*type
,
12110 const char *name
, struct obstack
*obstack
,
12111 struct dwarf2_cu
*cu
,
12112 long *value
, gdb_byte
**bytes
,
12113 struct dwarf2_locexpr_baton
**baton
)
12115 struct objfile
*objfile
= cu
->objfile
;
12116 struct comp_unit_head
*cu_header
= &cu
->header
;
12117 struct dwarf_block
*blk
;
12118 enum bfd_endian byte_order
= (bfd_big_endian (objfile
->obfd
) ?
12119 BFD_ENDIAN_BIG
: BFD_ENDIAN_LITTLE
);
12125 switch (attr
->form
)
12131 if (TYPE_LENGTH (type
) != cu_header
->addr_size
)
12132 dwarf2_const_value_length_mismatch_complaint (name
,
12133 cu_header
->addr_size
,
12134 TYPE_LENGTH (type
));
12135 /* Symbols of this form are reasonably rare, so we just
12136 piggyback on the existing location code rather than writing
12137 a new implementation of symbol_computed_ops. */
12138 *baton
= obstack_alloc (&objfile
->objfile_obstack
,
12139 sizeof (struct dwarf2_locexpr_baton
));
12140 (*baton
)->per_cu
= cu
->per_cu
;
12141 gdb_assert ((*baton
)->per_cu
);
12143 (*baton
)->size
= 2 + cu_header
->addr_size
;
12144 data
= obstack_alloc (&objfile
->objfile_obstack
, (*baton
)->size
);
12145 (*baton
)->data
= data
;
12147 data
[0] = DW_OP_addr
;
12148 store_unsigned_integer (&data
[1], cu_header
->addr_size
,
12149 byte_order
, DW_ADDR (attr
));
12150 data
[cu_header
->addr_size
+ 1] = DW_OP_stack_value
;
12153 case DW_FORM_string
:
12155 /* DW_STRING is already allocated on the objfile obstack, point
12157 *bytes
= (gdb_byte
*) DW_STRING (attr
);
12159 case DW_FORM_block1
:
12160 case DW_FORM_block2
:
12161 case DW_FORM_block4
:
12162 case DW_FORM_block
:
12163 case DW_FORM_exprloc
:
12164 blk
= DW_BLOCK (attr
);
12165 if (TYPE_LENGTH (type
) != blk
->size
)
12166 dwarf2_const_value_length_mismatch_complaint (name
, blk
->size
,
12167 TYPE_LENGTH (type
));
12168 *bytes
= blk
->data
;
12171 /* The DW_AT_const_value attributes are supposed to carry the
12172 symbol's value "represented as it would be on the target
12173 architecture." By the time we get here, it's already been
12174 converted to host endianness, so we just need to sign- or
12175 zero-extend it as appropriate. */
12176 case DW_FORM_data1
:
12177 *bytes
= dwarf2_const_value_data (attr
, type
, name
,
12178 obstack
, cu
, value
, 8);
12180 case DW_FORM_data2
:
12181 *bytes
= dwarf2_const_value_data (attr
, type
, name
,
12182 obstack
, cu
, value
, 16);
12184 case DW_FORM_data4
:
12185 *bytes
= dwarf2_const_value_data (attr
, type
, name
,
12186 obstack
, cu
, value
, 32);
12188 case DW_FORM_data8
:
12189 *bytes
= dwarf2_const_value_data (attr
, type
, name
,
12190 obstack
, cu
, value
, 64);
12193 case DW_FORM_sdata
:
12194 *value
= DW_SND (attr
);
12197 case DW_FORM_udata
:
12198 *value
= DW_UNSND (attr
);
12202 complaint (&symfile_complaints
,
12203 _("unsupported const value attribute form: '%s'"),
12204 dwarf_form_name (attr
->form
));
12211 /* Copy constant value from an attribute to a symbol. */
12214 dwarf2_const_value (struct attribute
*attr
, struct symbol
*sym
,
12215 struct dwarf2_cu
*cu
)
12217 struct objfile
*objfile
= cu
->objfile
;
12218 struct comp_unit_head
*cu_header
= &cu
->header
;
12221 struct dwarf2_locexpr_baton
*baton
;
12223 dwarf2_const_value_attr (attr
, SYMBOL_TYPE (sym
),
12224 SYMBOL_PRINT_NAME (sym
),
12225 &objfile
->objfile_obstack
, cu
,
12226 &value
, &bytes
, &baton
);
12230 SYMBOL_COMPUTED_OPS (sym
) = &dwarf2_locexpr_funcs
;
12231 SYMBOL_LOCATION_BATON (sym
) = baton
;
12232 SYMBOL_CLASS (sym
) = LOC_COMPUTED
;
12234 else if (bytes
!= NULL
)
12236 SYMBOL_VALUE_BYTES (sym
) = bytes
;
12237 SYMBOL_CLASS (sym
) = LOC_CONST_BYTES
;
12241 SYMBOL_VALUE (sym
) = value
;
12242 SYMBOL_CLASS (sym
) = LOC_CONST
;
12246 /* Return the type of the die in question using its DW_AT_type attribute. */
12248 static struct type
*
12249 die_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
12251 struct attribute
*type_attr
;
12253 type_attr
= dwarf2_attr (die
, DW_AT_type
, cu
);
12256 /* A missing DW_AT_type represents a void type. */
12257 return objfile_type (cu
->objfile
)->builtin_void
;
12260 return lookup_die_type (die
, type_attr
, cu
);
12263 /* True iff CU's producer generates GNAT Ada auxiliary information
12264 that allows to find parallel types through that information instead
12265 of having to do expensive parallel lookups by type name. */
12268 need_gnat_info (struct dwarf2_cu
*cu
)
12270 /* FIXME: brobecker/2010-10-12: As of now, only the AdaCore version
12271 of GNAT produces this auxiliary information, without any indication
12272 that it is produced. Part of enhancing the FSF version of GNAT
12273 to produce that information will be to put in place an indicator
12274 that we can use in order to determine whether the descriptive type
12275 info is available or not. One suggestion that has been made is
12276 to use a new attribute, attached to the CU die. For now, assume
12277 that the descriptive type info is not available. */
12281 /* Return the auxiliary type of the die in question using its
12282 DW_AT_GNAT_descriptive_type attribute. Returns NULL if the
12283 attribute is not present. */
12285 static struct type
*
12286 die_descriptive_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
12288 struct attribute
*type_attr
;
12290 type_attr
= dwarf2_attr (die
, DW_AT_GNAT_descriptive_type
, cu
);
12294 return lookup_die_type (die
, type_attr
, cu
);
12297 /* If DIE has a descriptive_type attribute, then set the TYPE's
12298 descriptive type accordingly. */
12301 set_descriptive_type (struct type
*type
, struct die_info
*die
,
12302 struct dwarf2_cu
*cu
)
12304 struct type
*descriptive_type
= die_descriptive_type (die
, cu
);
12306 if (descriptive_type
)
12308 ALLOCATE_GNAT_AUX_TYPE (type
);
12309 TYPE_DESCRIPTIVE_TYPE (type
) = descriptive_type
;
12313 /* Return the containing type of the die in question using its
12314 DW_AT_containing_type attribute. */
12316 static struct type
*
12317 die_containing_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
12319 struct attribute
*type_attr
;
12321 type_attr
= dwarf2_attr (die
, DW_AT_containing_type
, cu
);
12323 error (_("Dwarf Error: Problem turning containing type into gdb type "
12324 "[in module %s]"), cu
->objfile
->name
);
12326 return lookup_die_type (die
, type_attr
, cu
);
12329 /* Look up the type of DIE in CU using its type attribute ATTR.
12330 If there is no type substitute an error marker. */
12332 static struct type
*
12333 lookup_die_type (struct die_info
*die
, struct attribute
*attr
,
12334 struct dwarf2_cu
*cu
)
12336 struct type
*this_type
;
12338 /* First see if we have it cached. */
12340 if (is_ref_attr (attr
))
12342 unsigned int offset
= dwarf2_get_ref_die_offset (attr
);
12344 this_type
= get_die_type_at_offset (offset
, cu
->per_cu
);
12346 else if (attr
->form
== DW_FORM_ref_sig8
)
12348 struct signatured_type
*sig_type
= DW_SIGNATURED_TYPE (attr
);
12349 struct dwarf2_cu
*sig_cu
;
12350 unsigned int offset
;
12352 /* sig_type will be NULL if the signatured type is missing from
12354 if (sig_type
== NULL
)
12355 error (_("Dwarf Error: Cannot find signatured DIE referenced from DIE "
12356 "at 0x%x [in module %s]"),
12357 die
->offset
, cu
->objfile
->name
);
12359 gdb_assert (sig_type
->per_cu
.debug_type_section
);
12360 offset
= sig_type
->per_cu
.offset
+ sig_type
->type_offset
;
12361 this_type
= get_die_type_at_offset (offset
, &sig_type
->per_cu
);
12365 dump_die_for_error (die
);
12366 error (_("Dwarf Error: Bad type attribute %s [in module %s]"),
12367 dwarf_attr_name (attr
->name
), cu
->objfile
->name
);
12370 /* If not cached we need to read it in. */
12372 if (this_type
== NULL
)
12374 struct die_info
*type_die
;
12375 struct dwarf2_cu
*type_cu
= cu
;
12377 type_die
= follow_die_ref_or_sig (die
, attr
, &type_cu
);
12378 /* If the type is cached, we should have found it above. */
12379 gdb_assert (get_die_type (type_die
, type_cu
) == NULL
);
12380 this_type
= read_type_die_1 (type_die
, type_cu
);
12383 /* If we still don't have a type use an error marker. */
12385 if (this_type
== NULL
)
12387 char *message
, *saved
;
12389 /* read_type_die already issued a complaint. */
12390 message
= xstrprintf (_("<unknown type in %s, CU 0x%x, DIE 0x%x>"),
12394 saved
= obstack_copy0 (&cu
->objfile
->objfile_obstack
,
12395 message
, strlen (message
));
12398 this_type
= init_type (TYPE_CODE_ERROR
, 0, 0, saved
, cu
->objfile
);
12404 /* Return the type in DIE, CU.
12405 Returns NULL for invalid types.
12407 This first does a lookup in the appropriate type_hash table,
12408 and only reads the die in if necessary.
12410 NOTE: This can be called when reading in partial or full symbols. */
12412 static struct type
*
12413 read_type_die (struct die_info
*die
, struct dwarf2_cu
*cu
)
12415 struct type
*this_type
;
12417 this_type
= get_die_type (die
, cu
);
12421 return read_type_die_1 (die
, cu
);
12424 /* Read the type in DIE, CU.
12425 Returns NULL for invalid types. */
12427 static struct type
*
12428 read_type_die_1 (struct die_info
*die
, struct dwarf2_cu
*cu
)
12430 struct type
*this_type
= NULL
;
12434 case DW_TAG_class_type
:
12435 case DW_TAG_interface_type
:
12436 case DW_TAG_structure_type
:
12437 case DW_TAG_union_type
:
12438 this_type
= read_structure_type (die
, cu
);
12440 case DW_TAG_enumeration_type
:
12441 this_type
= read_enumeration_type (die
, cu
);
12443 case DW_TAG_subprogram
:
12444 case DW_TAG_subroutine_type
:
12445 case DW_TAG_inlined_subroutine
:
12446 this_type
= read_subroutine_type (die
, cu
);
12448 case DW_TAG_array_type
:
12449 this_type
= read_array_type (die
, cu
);
12451 case DW_TAG_set_type
:
12452 this_type
= read_set_type (die
, cu
);
12454 case DW_TAG_pointer_type
:
12455 this_type
= read_tag_pointer_type (die
, cu
);
12457 case DW_TAG_ptr_to_member_type
:
12458 this_type
= read_tag_ptr_to_member_type (die
, cu
);
12460 case DW_TAG_reference_type
:
12461 this_type
= read_tag_reference_type (die
, cu
);
12463 case DW_TAG_const_type
:
12464 this_type
= read_tag_const_type (die
, cu
);
12466 case DW_TAG_volatile_type
:
12467 this_type
= read_tag_volatile_type (die
, cu
);
12469 case DW_TAG_string_type
:
12470 this_type
= read_tag_string_type (die
, cu
);
12472 case DW_TAG_typedef
:
12473 this_type
= read_typedef (die
, cu
);
12475 case DW_TAG_subrange_type
:
12476 this_type
= read_subrange_type (die
, cu
);
12478 case DW_TAG_base_type
:
12479 this_type
= read_base_type (die
, cu
);
12481 case DW_TAG_unspecified_type
:
12482 this_type
= read_unspecified_type (die
, cu
);
12484 case DW_TAG_namespace
:
12485 this_type
= read_namespace_type (die
, cu
);
12487 case DW_TAG_module
:
12488 this_type
= read_module_type (die
, cu
);
12491 complaint (&symfile_complaints
,
12492 _("unexpected tag in read_type_die: '%s'"),
12493 dwarf_tag_name (die
->tag
));
12500 /* See if we can figure out if the class lives in a namespace. We do
12501 this by looking for a member function; its demangled name will
12502 contain namespace info, if there is any.
12503 Return the computed name or NULL.
12504 Space for the result is allocated on the objfile's obstack.
12505 This is the full-die version of guess_partial_die_structure_name.
12506 In this case we know DIE has no useful parent. */
12509 guess_full_die_structure_name (struct die_info
*die
, struct dwarf2_cu
*cu
)
12511 struct die_info
*spec_die
;
12512 struct dwarf2_cu
*spec_cu
;
12513 struct die_info
*child
;
12516 spec_die
= die_specification (die
, &spec_cu
);
12517 if (spec_die
!= NULL
)
12523 for (child
= die
->child
;
12525 child
= child
->sibling
)
12527 if (child
->tag
== DW_TAG_subprogram
)
12529 struct attribute
*attr
;
12531 attr
= dwarf2_attr (child
, DW_AT_linkage_name
, cu
);
12533 attr
= dwarf2_attr (child
, DW_AT_MIPS_linkage_name
, cu
);
12537 = language_class_name_from_physname (cu
->language_defn
,
12541 if (actual_name
!= NULL
)
12543 char *die_name
= dwarf2_name (die
, cu
);
12545 if (die_name
!= NULL
12546 && strcmp (die_name
, actual_name
) != 0)
12548 /* Strip off the class name from the full name.
12549 We want the prefix. */
12550 int die_name_len
= strlen (die_name
);
12551 int actual_name_len
= strlen (actual_name
);
12553 /* Test for '::' as a sanity check. */
12554 if (actual_name_len
> die_name_len
+ 2
12555 && actual_name
[actual_name_len
12556 - die_name_len
- 1] == ':')
12558 obsavestring (actual_name
,
12559 actual_name_len
- die_name_len
- 2,
12560 &cu
->objfile
->objfile_obstack
);
12563 xfree (actual_name
);
12572 /* GCC might emit a nameless typedef that has a linkage name. Determine the
12573 prefix part in such case. See
12574 http://gcc.gnu.org/bugzilla/show_bug.cgi?id=47510. */
12577 anonymous_struct_prefix (struct die_info
*die
, struct dwarf2_cu
*cu
)
12579 struct attribute
*attr
;
12582 if (die
->tag
!= DW_TAG_class_type
&& die
->tag
!= DW_TAG_interface_type
12583 && die
->tag
!= DW_TAG_structure_type
&& die
->tag
!= DW_TAG_union_type
)
12586 attr
= dwarf2_attr (die
, DW_AT_name
, cu
);
12587 if (attr
!= NULL
&& DW_STRING (attr
) != NULL
)
12590 attr
= dwarf2_attr (die
, DW_AT_linkage_name
, cu
);
12592 attr
= dwarf2_attr (die
, DW_AT_MIPS_linkage_name
, cu
);
12593 if (attr
== NULL
|| DW_STRING (attr
) == NULL
)
12596 /* dwarf2_name had to be already called. */
12597 gdb_assert (DW_STRING_IS_CANONICAL (attr
));
12599 /* Strip the base name, keep any leading namespaces/classes. */
12600 base
= strrchr (DW_STRING (attr
), ':');
12601 if (base
== NULL
|| base
== DW_STRING (attr
) || base
[-1] != ':')
12604 return obsavestring (DW_STRING (attr
), &base
[-1] - DW_STRING (attr
),
12605 &cu
->objfile
->objfile_obstack
);
12608 /* Return the name of the namespace/class that DIE is defined within,
12609 or "" if we can't tell. The caller should not xfree the result.
12611 For example, if we're within the method foo() in the following
12621 then determine_prefix on foo's die will return "N::C". */
12624 determine_prefix (struct die_info
*die
, struct dwarf2_cu
*cu
)
12626 struct die_info
*parent
, *spec_die
;
12627 struct dwarf2_cu
*spec_cu
;
12628 struct type
*parent_type
;
12631 if (cu
->language
!= language_cplus
&& cu
->language
!= language_java
12632 && cu
->language
!= language_fortran
)
12635 retval
= anonymous_struct_prefix (die
, cu
);
12639 /* We have to be careful in the presence of DW_AT_specification.
12640 For example, with GCC 3.4, given the code
12644 // Definition of N::foo.
12648 then we'll have a tree of DIEs like this:
12650 1: DW_TAG_compile_unit
12651 2: DW_TAG_namespace // N
12652 3: DW_TAG_subprogram // declaration of N::foo
12653 4: DW_TAG_subprogram // definition of N::foo
12654 DW_AT_specification // refers to die #3
12656 Thus, when processing die #4, we have to pretend that we're in
12657 the context of its DW_AT_specification, namely the contex of die
12660 spec_die
= die_specification (die
, &spec_cu
);
12661 if (spec_die
== NULL
)
12662 parent
= die
->parent
;
12665 parent
= spec_die
->parent
;
12669 if (parent
== NULL
)
12671 else if (parent
->building_fullname
)
12674 const char *parent_name
;
12676 /* It has been seen on RealView 2.2 built binaries,
12677 DW_TAG_template_type_param types actually _defined_ as
12678 children of the parent class:
12681 template class <class Enum> Class{};
12682 Class<enum E> class_e;
12684 1: DW_TAG_class_type (Class)
12685 2: DW_TAG_enumeration_type (E)
12686 3: DW_TAG_enumerator (enum1:0)
12687 3: DW_TAG_enumerator (enum2:1)
12689 2: DW_TAG_template_type_param
12690 DW_AT_type DW_FORM_ref_udata (E)
12692 Besides being broken debug info, it can put GDB into an
12693 infinite loop. Consider:
12695 When we're building the full name for Class<E>, we'll start
12696 at Class, and go look over its template type parameters,
12697 finding E. We'll then try to build the full name of E, and
12698 reach here. We're now trying to build the full name of E,
12699 and look over the parent DIE for containing scope. In the
12700 broken case, if we followed the parent DIE of E, we'd again
12701 find Class, and once again go look at its template type
12702 arguments, etc., etc. Simply don't consider such parent die
12703 as source-level parent of this die (it can't be, the language
12704 doesn't allow it), and break the loop here. */
12705 name
= dwarf2_name (die
, cu
);
12706 parent_name
= dwarf2_name (parent
, cu
);
12707 complaint (&symfile_complaints
,
12708 _("template param type '%s' defined within parent '%s'"),
12709 name
? name
: "<unknown>",
12710 parent_name
? parent_name
: "<unknown>");
12714 switch (parent
->tag
)
12716 case DW_TAG_namespace
:
12717 parent_type
= read_type_die (parent
, cu
);
12718 /* GCC 4.0 and 4.1 had a bug (PR c++/28460) where they generated bogus
12719 DW_TAG_namespace DIEs with a name of "::" for the global namespace.
12720 Work around this problem here. */
12721 if (cu
->language
== language_cplus
12722 && strcmp (TYPE_TAG_NAME (parent_type
), "::") == 0)
12724 /* We give a name to even anonymous namespaces. */
12725 return TYPE_TAG_NAME (parent_type
);
12726 case DW_TAG_class_type
:
12727 case DW_TAG_interface_type
:
12728 case DW_TAG_structure_type
:
12729 case DW_TAG_union_type
:
12730 case DW_TAG_module
:
12731 parent_type
= read_type_die (parent
, cu
);
12732 if (TYPE_TAG_NAME (parent_type
) != NULL
)
12733 return TYPE_TAG_NAME (parent_type
);
12735 /* An anonymous structure is only allowed non-static data
12736 members; no typedefs, no member functions, et cetera.
12737 So it does not need a prefix. */
12739 case DW_TAG_compile_unit
:
12740 /* gcc-4.5 -gdwarf-4 can drop the enclosing namespace. Cope. */
12741 if (cu
->language
== language_cplus
12742 && !VEC_empty (dwarf2_section_info_def
, dwarf2_per_objfile
->types
)
12743 && die
->child
!= NULL
12744 && (die
->tag
== DW_TAG_class_type
12745 || die
->tag
== DW_TAG_structure_type
12746 || die
->tag
== DW_TAG_union_type
))
12748 char *name
= guess_full_die_structure_name (die
, cu
);
12754 return determine_prefix (parent
, cu
);
12758 /* Return a newly-allocated string formed by concatenating PREFIX and SUFFIX
12759 with appropriate separator. If PREFIX or SUFFIX is NULL or empty, then
12760 simply copy the SUFFIX or PREFIX, respectively. If OBS is non-null, perform
12761 an obconcat, otherwise allocate storage for the result. The CU argument is
12762 used to determine the language and hence, the appropriate separator. */
12764 #define MAX_SEP_LEN 7 /* strlen ("__") + strlen ("_MOD_") */
12767 typename_concat (struct obstack
*obs
, const char *prefix
, const char *suffix
,
12768 int physname
, struct dwarf2_cu
*cu
)
12770 const char *lead
= "";
12773 if (suffix
== NULL
|| suffix
[0] == '\0'
12774 || prefix
== NULL
|| prefix
[0] == '\0')
12776 else if (cu
->language
== language_java
)
12778 else if (cu
->language
== language_fortran
&& physname
)
12780 /* This is gfortran specific mangling. Normally DW_AT_linkage_name or
12781 DW_AT_MIPS_linkage_name is preferred and used instead. */
12789 if (prefix
== NULL
)
12791 if (suffix
== NULL
)
12797 = xmalloc (strlen (prefix
) + MAX_SEP_LEN
+ strlen (suffix
) + 1);
12799 strcpy (retval
, lead
);
12800 strcat (retval
, prefix
);
12801 strcat (retval
, sep
);
12802 strcat (retval
, suffix
);
12807 /* We have an obstack. */
12808 return obconcat (obs
, lead
, prefix
, sep
, suffix
, (char *) NULL
);
12812 /* Return sibling of die, NULL if no sibling. */
12814 static struct die_info
*
12815 sibling_die (struct die_info
*die
)
12817 return die
->sibling
;
12820 /* Get name of a die, return NULL if not found. */
12823 dwarf2_canonicalize_name (char *name
, struct dwarf2_cu
*cu
,
12824 struct obstack
*obstack
)
12826 if (name
&& cu
->language
== language_cplus
)
12828 char *canon_name
= cp_canonicalize_string (name
);
12830 if (canon_name
!= NULL
)
12832 if (strcmp (canon_name
, name
) != 0)
12833 name
= obsavestring (canon_name
, strlen (canon_name
),
12835 xfree (canon_name
);
12842 /* Get name of a die, return NULL if not found. */
12845 dwarf2_name (struct die_info
*die
, struct dwarf2_cu
*cu
)
12847 struct attribute
*attr
;
12849 attr
= dwarf2_attr (die
, DW_AT_name
, cu
);
12850 if ((!attr
|| !DW_STRING (attr
))
12851 && die
->tag
!= DW_TAG_class_type
12852 && die
->tag
!= DW_TAG_interface_type
12853 && die
->tag
!= DW_TAG_structure_type
12854 && die
->tag
!= DW_TAG_union_type
)
12859 case DW_TAG_compile_unit
:
12860 /* Compilation units have a DW_AT_name that is a filename, not
12861 a source language identifier. */
12862 case DW_TAG_enumeration_type
:
12863 case DW_TAG_enumerator
:
12864 /* These tags always have simple identifiers already; no need
12865 to canonicalize them. */
12866 return DW_STRING (attr
);
12868 case DW_TAG_subprogram
:
12869 /* Java constructors will all be named "<init>", so return
12870 the class name when we see this special case. */
12871 if (cu
->language
== language_java
12872 && DW_STRING (attr
) != NULL
12873 && strcmp (DW_STRING (attr
), "<init>") == 0)
12875 struct dwarf2_cu
*spec_cu
= cu
;
12876 struct die_info
*spec_die
;
12878 /* GCJ will output '<init>' for Java constructor names.
12879 For this special case, return the name of the parent class. */
12881 /* GCJ may output suprogram DIEs with AT_specification set.
12882 If so, use the name of the specified DIE. */
12883 spec_die
= die_specification (die
, &spec_cu
);
12884 if (spec_die
!= NULL
)
12885 return dwarf2_name (spec_die
, spec_cu
);
12890 if (die
->tag
== DW_TAG_class_type
)
12891 return dwarf2_name (die
, cu
);
12893 while (die
->tag
!= DW_TAG_compile_unit
);
12897 case DW_TAG_class_type
:
12898 case DW_TAG_interface_type
:
12899 case DW_TAG_structure_type
:
12900 case DW_TAG_union_type
:
12901 /* Some GCC versions emit spurious DW_AT_name attributes for unnamed
12902 structures or unions. These were of the form "._%d" in GCC 4.1,
12903 or simply "<anonymous struct>" or "<anonymous union>" in GCC 4.3
12904 and GCC 4.4. We work around this problem by ignoring these. */
12905 if (attr
&& DW_STRING (attr
)
12906 && (strncmp (DW_STRING (attr
), "._", 2) == 0
12907 || strncmp (DW_STRING (attr
), "<anonymous", 10) == 0))
12910 /* GCC might emit a nameless typedef that has a linkage name. See
12911 http://gcc.gnu.org/bugzilla/show_bug.cgi?id=47510. */
12912 if (!attr
|| DW_STRING (attr
) == NULL
)
12914 char *demangled
= NULL
;
12916 attr
= dwarf2_attr (die
, DW_AT_linkage_name
, cu
);
12918 attr
= dwarf2_attr (die
, DW_AT_MIPS_linkage_name
, cu
);
12920 if (attr
== NULL
|| DW_STRING (attr
) == NULL
)
12923 /* Avoid demangling DW_STRING (attr) the second time on a second
12924 call for the same DIE. */
12925 if (!DW_STRING_IS_CANONICAL (attr
))
12926 demangled
= cplus_demangle (DW_STRING (attr
), DMGL_TYPES
);
12932 /* FIXME: we already did this for the partial symbol... */
12933 DW_STRING (attr
) = obsavestring (demangled
, strlen (demangled
),
12934 &cu
->objfile
->objfile_obstack
);
12935 DW_STRING_IS_CANONICAL (attr
) = 1;
12938 /* Strip any leading namespaces/classes, keep only the base name.
12939 DW_AT_name for named DIEs does not contain the prefixes. */
12940 base
= strrchr (DW_STRING (attr
), ':');
12941 if (base
&& base
> DW_STRING (attr
) && base
[-1] == ':')
12944 return DW_STRING (attr
);
12953 if (!DW_STRING_IS_CANONICAL (attr
))
12956 = dwarf2_canonicalize_name (DW_STRING (attr
), cu
,
12957 &cu
->objfile
->objfile_obstack
);
12958 DW_STRING_IS_CANONICAL (attr
) = 1;
12960 return DW_STRING (attr
);
12963 /* Return the die that this die in an extension of, or NULL if there
12964 is none. *EXT_CU is the CU containing DIE on input, and the CU
12965 containing the return value on output. */
12967 static struct die_info
*
12968 dwarf2_extension (struct die_info
*die
, struct dwarf2_cu
**ext_cu
)
12970 struct attribute
*attr
;
12972 attr
= dwarf2_attr (die
, DW_AT_extension
, *ext_cu
);
12976 return follow_die_ref (die
, attr
, ext_cu
);
12979 /* Convert a DIE tag into its string name. */
12982 dwarf_tag_name (unsigned tag
)
12986 case DW_TAG_padding
:
12987 return "DW_TAG_padding";
12988 case DW_TAG_array_type
:
12989 return "DW_TAG_array_type";
12990 case DW_TAG_class_type
:
12991 return "DW_TAG_class_type";
12992 case DW_TAG_entry_point
:
12993 return "DW_TAG_entry_point";
12994 case DW_TAG_enumeration_type
:
12995 return "DW_TAG_enumeration_type";
12996 case DW_TAG_formal_parameter
:
12997 return "DW_TAG_formal_parameter";
12998 case DW_TAG_imported_declaration
:
12999 return "DW_TAG_imported_declaration";
13001 return "DW_TAG_label";
13002 case DW_TAG_lexical_block
:
13003 return "DW_TAG_lexical_block";
13004 case DW_TAG_member
:
13005 return "DW_TAG_member";
13006 case DW_TAG_pointer_type
:
13007 return "DW_TAG_pointer_type";
13008 case DW_TAG_reference_type
:
13009 return "DW_TAG_reference_type";
13010 case DW_TAG_compile_unit
:
13011 return "DW_TAG_compile_unit";
13012 case DW_TAG_string_type
:
13013 return "DW_TAG_string_type";
13014 case DW_TAG_structure_type
:
13015 return "DW_TAG_structure_type";
13016 case DW_TAG_subroutine_type
:
13017 return "DW_TAG_subroutine_type";
13018 case DW_TAG_typedef
:
13019 return "DW_TAG_typedef";
13020 case DW_TAG_union_type
:
13021 return "DW_TAG_union_type";
13022 case DW_TAG_unspecified_parameters
:
13023 return "DW_TAG_unspecified_parameters";
13024 case DW_TAG_variant
:
13025 return "DW_TAG_variant";
13026 case DW_TAG_common_block
:
13027 return "DW_TAG_common_block";
13028 case DW_TAG_common_inclusion
:
13029 return "DW_TAG_common_inclusion";
13030 case DW_TAG_inheritance
:
13031 return "DW_TAG_inheritance";
13032 case DW_TAG_inlined_subroutine
:
13033 return "DW_TAG_inlined_subroutine";
13034 case DW_TAG_module
:
13035 return "DW_TAG_module";
13036 case DW_TAG_ptr_to_member_type
:
13037 return "DW_TAG_ptr_to_member_type";
13038 case DW_TAG_set_type
:
13039 return "DW_TAG_set_type";
13040 case DW_TAG_subrange_type
:
13041 return "DW_TAG_subrange_type";
13042 case DW_TAG_with_stmt
:
13043 return "DW_TAG_with_stmt";
13044 case DW_TAG_access_declaration
:
13045 return "DW_TAG_access_declaration";
13046 case DW_TAG_base_type
:
13047 return "DW_TAG_base_type";
13048 case DW_TAG_catch_block
:
13049 return "DW_TAG_catch_block";
13050 case DW_TAG_const_type
:
13051 return "DW_TAG_const_type";
13052 case DW_TAG_constant
:
13053 return "DW_TAG_constant";
13054 case DW_TAG_enumerator
:
13055 return "DW_TAG_enumerator";
13056 case DW_TAG_file_type
:
13057 return "DW_TAG_file_type";
13058 case DW_TAG_friend
:
13059 return "DW_TAG_friend";
13060 case DW_TAG_namelist
:
13061 return "DW_TAG_namelist";
13062 case DW_TAG_namelist_item
:
13063 return "DW_TAG_namelist_item";
13064 case DW_TAG_packed_type
:
13065 return "DW_TAG_packed_type";
13066 case DW_TAG_subprogram
:
13067 return "DW_TAG_subprogram";
13068 case DW_TAG_template_type_param
:
13069 return "DW_TAG_template_type_param";
13070 case DW_TAG_template_value_param
:
13071 return "DW_TAG_template_value_param";
13072 case DW_TAG_thrown_type
:
13073 return "DW_TAG_thrown_type";
13074 case DW_TAG_try_block
:
13075 return "DW_TAG_try_block";
13076 case DW_TAG_variant_part
:
13077 return "DW_TAG_variant_part";
13078 case DW_TAG_variable
:
13079 return "DW_TAG_variable";
13080 case DW_TAG_volatile_type
:
13081 return "DW_TAG_volatile_type";
13082 case DW_TAG_dwarf_procedure
:
13083 return "DW_TAG_dwarf_procedure";
13084 case DW_TAG_restrict_type
:
13085 return "DW_TAG_restrict_type";
13086 case DW_TAG_interface_type
:
13087 return "DW_TAG_interface_type";
13088 case DW_TAG_namespace
:
13089 return "DW_TAG_namespace";
13090 case DW_TAG_imported_module
:
13091 return "DW_TAG_imported_module";
13092 case DW_TAG_unspecified_type
:
13093 return "DW_TAG_unspecified_type";
13094 case DW_TAG_partial_unit
:
13095 return "DW_TAG_partial_unit";
13096 case DW_TAG_imported_unit
:
13097 return "DW_TAG_imported_unit";
13098 case DW_TAG_condition
:
13099 return "DW_TAG_condition";
13100 case DW_TAG_shared_type
:
13101 return "DW_TAG_shared_type";
13102 case DW_TAG_type_unit
:
13103 return "DW_TAG_type_unit";
13104 case DW_TAG_MIPS_loop
:
13105 return "DW_TAG_MIPS_loop";
13106 case DW_TAG_HP_array_descriptor
:
13107 return "DW_TAG_HP_array_descriptor";
13108 case DW_TAG_format_label
:
13109 return "DW_TAG_format_label";
13110 case DW_TAG_function_template
:
13111 return "DW_TAG_function_template";
13112 case DW_TAG_class_template
:
13113 return "DW_TAG_class_template";
13114 case DW_TAG_GNU_BINCL
:
13115 return "DW_TAG_GNU_BINCL";
13116 case DW_TAG_GNU_EINCL
:
13117 return "DW_TAG_GNU_EINCL";
13118 case DW_TAG_upc_shared_type
:
13119 return "DW_TAG_upc_shared_type";
13120 case DW_TAG_upc_strict_type
:
13121 return "DW_TAG_upc_strict_type";
13122 case DW_TAG_upc_relaxed_type
:
13123 return "DW_TAG_upc_relaxed_type";
13124 case DW_TAG_PGI_kanji_type
:
13125 return "DW_TAG_PGI_kanji_type";
13126 case DW_TAG_PGI_interface_block
:
13127 return "DW_TAG_PGI_interface_block";
13128 case DW_TAG_GNU_call_site
:
13129 return "DW_TAG_GNU_call_site";
13131 return "DW_TAG_<unknown>";
13135 /* Convert a DWARF attribute code into its string name. */
13138 dwarf_attr_name (unsigned attr
)
13142 case DW_AT_sibling
:
13143 return "DW_AT_sibling";
13144 case DW_AT_location
:
13145 return "DW_AT_location";
13147 return "DW_AT_name";
13148 case DW_AT_ordering
:
13149 return "DW_AT_ordering";
13150 case DW_AT_subscr_data
:
13151 return "DW_AT_subscr_data";
13152 case DW_AT_byte_size
:
13153 return "DW_AT_byte_size";
13154 case DW_AT_bit_offset
:
13155 return "DW_AT_bit_offset";
13156 case DW_AT_bit_size
:
13157 return "DW_AT_bit_size";
13158 case DW_AT_element_list
:
13159 return "DW_AT_element_list";
13160 case DW_AT_stmt_list
:
13161 return "DW_AT_stmt_list";
13163 return "DW_AT_low_pc";
13164 case DW_AT_high_pc
:
13165 return "DW_AT_high_pc";
13166 case DW_AT_language
:
13167 return "DW_AT_language";
13169 return "DW_AT_member";
13171 return "DW_AT_discr";
13172 case DW_AT_discr_value
:
13173 return "DW_AT_discr_value";
13174 case DW_AT_visibility
:
13175 return "DW_AT_visibility";
13177 return "DW_AT_import";
13178 case DW_AT_string_length
:
13179 return "DW_AT_string_length";
13180 case DW_AT_common_reference
:
13181 return "DW_AT_common_reference";
13182 case DW_AT_comp_dir
:
13183 return "DW_AT_comp_dir";
13184 case DW_AT_const_value
:
13185 return "DW_AT_const_value";
13186 case DW_AT_containing_type
:
13187 return "DW_AT_containing_type";
13188 case DW_AT_default_value
:
13189 return "DW_AT_default_value";
13191 return "DW_AT_inline";
13192 case DW_AT_is_optional
:
13193 return "DW_AT_is_optional";
13194 case DW_AT_lower_bound
:
13195 return "DW_AT_lower_bound";
13196 case DW_AT_producer
:
13197 return "DW_AT_producer";
13198 case DW_AT_prototyped
:
13199 return "DW_AT_prototyped";
13200 case DW_AT_return_addr
:
13201 return "DW_AT_return_addr";
13202 case DW_AT_start_scope
:
13203 return "DW_AT_start_scope";
13204 case DW_AT_bit_stride
:
13205 return "DW_AT_bit_stride";
13206 case DW_AT_upper_bound
:
13207 return "DW_AT_upper_bound";
13208 case DW_AT_abstract_origin
:
13209 return "DW_AT_abstract_origin";
13210 case DW_AT_accessibility
:
13211 return "DW_AT_accessibility";
13212 case DW_AT_address_class
:
13213 return "DW_AT_address_class";
13214 case DW_AT_artificial
:
13215 return "DW_AT_artificial";
13216 case DW_AT_base_types
:
13217 return "DW_AT_base_types";
13218 case DW_AT_calling_convention
:
13219 return "DW_AT_calling_convention";
13221 return "DW_AT_count";
13222 case DW_AT_data_member_location
:
13223 return "DW_AT_data_member_location";
13224 case DW_AT_decl_column
:
13225 return "DW_AT_decl_column";
13226 case DW_AT_decl_file
:
13227 return "DW_AT_decl_file";
13228 case DW_AT_decl_line
:
13229 return "DW_AT_decl_line";
13230 case DW_AT_declaration
:
13231 return "DW_AT_declaration";
13232 case DW_AT_discr_list
:
13233 return "DW_AT_discr_list";
13234 case DW_AT_encoding
:
13235 return "DW_AT_encoding";
13236 case DW_AT_external
:
13237 return "DW_AT_external";
13238 case DW_AT_frame_base
:
13239 return "DW_AT_frame_base";
13241 return "DW_AT_friend";
13242 case DW_AT_identifier_case
:
13243 return "DW_AT_identifier_case";
13244 case DW_AT_macro_info
:
13245 return "DW_AT_macro_info";
13246 case DW_AT_namelist_items
:
13247 return "DW_AT_namelist_items";
13248 case DW_AT_priority
:
13249 return "DW_AT_priority";
13250 case DW_AT_segment
:
13251 return "DW_AT_segment";
13252 case DW_AT_specification
:
13253 return "DW_AT_specification";
13254 case DW_AT_static_link
:
13255 return "DW_AT_static_link";
13257 return "DW_AT_type";
13258 case DW_AT_use_location
:
13259 return "DW_AT_use_location";
13260 case DW_AT_variable_parameter
:
13261 return "DW_AT_variable_parameter";
13262 case DW_AT_virtuality
:
13263 return "DW_AT_virtuality";
13264 case DW_AT_vtable_elem_location
:
13265 return "DW_AT_vtable_elem_location";
13266 /* DWARF 3 values. */
13267 case DW_AT_allocated
:
13268 return "DW_AT_allocated";
13269 case DW_AT_associated
:
13270 return "DW_AT_associated";
13271 case DW_AT_data_location
:
13272 return "DW_AT_data_location";
13273 case DW_AT_byte_stride
:
13274 return "DW_AT_byte_stride";
13275 case DW_AT_entry_pc
:
13276 return "DW_AT_entry_pc";
13277 case DW_AT_use_UTF8
:
13278 return "DW_AT_use_UTF8";
13279 case DW_AT_extension
:
13280 return "DW_AT_extension";
13282 return "DW_AT_ranges";
13283 case DW_AT_trampoline
:
13284 return "DW_AT_trampoline";
13285 case DW_AT_call_column
:
13286 return "DW_AT_call_column";
13287 case DW_AT_call_file
:
13288 return "DW_AT_call_file";
13289 case DW_AT_call_line
:
13290 return "DW_AT_call_line";
13291 case DW_AT_description
:
13292 return "DW_AT_description";
13293 case DW_AT_binary_scale
:
13294 return "DW_AT_binary_scale";
13295 case DW_AT_decimal_scale
:
13296 return "DW_AT_decimal_scale";
13298 return "DW_AT_small";
13299 case DW_AT_decimal_sign
:
13300 return "DW_AT_decimal_sign";
13301 case DW_AT_digit_count
:
13302 return "DW_AT_digit_count";
13303 case DW_AT_picture_string
:
13304 return "DW_AT_picture_string";
13305 case DW_AT_mutable
:
13306 return "DW_AT_mutable";
13307 case DW_AT_threads_scaled
:
13308 return "DW_AT_threads_scaled";
13309 case DW_AT_explicit
:
13310 return "DW_AT_explicit";
13311 case DW_AT_object_pointer
:
13312 return "DW_AT_object_pointer";
13313 case DW_AT_endianity
:
13314 return "DW_AT_endianity";
13315 case DW_AT_elemental
:
13316 return "DW_AT_elemental";
13318 return "DW_AT_pure";
13319 case DW_AT_recursive
:
13320 return "DW_AT_recursive";
13321 /* DWARF 4 values. */
13322 case DW_AT_signature
:
13323 return "DW_AT_signature";
13324 case DW_AT_linkage_name
:
13325 return "DW_AT_linkage_name";
13326 /* SGI/MIPS extensions. */
13327 #ifdef MIPS /* collides with DW_AT_HP_block_index */
13328 case DW_AT_MIPS_fde
:
13329 return "DW_AT_MIPS_fde";
13331 case DW_AT_MIPS_loop_begin
:
13332 return "DW_AT_MIPS_loop_begin";
13333 case DW_AT_MIPS_tail_loop_begin
:
13334 return "DW_AT_MIPS_tail_loop_begin";
13335 case DW_AT_MIPS_epilog_begin
:
13336 return "DW_AT_MIPS_epilog_begin";
13337 case DW_AT_MIPS_loop_unroll_factor
:
13338 return "DW_AT_MIPS_loop_unroll_factor";
13339 case DW_AT_MIPS_software_pipeline_depth
:
13340 return "DW_AT_MIPS_software_pipeline_depth";
13341 case DW_AT_MIPS_linkage_name
:
13342 return "DW_AT_MIPS_linkage_name";
13343 case DW_AT_MIPS_stride
:
13344 return "DW_AT_MIPS_stride";
13345 case DW_AT_MIPS_abstract_name
:
13346 return "DW_AT_MIPS_abstract_name";
13347 case DW_AT_MIPS_clone_origin
:
13348 return "DW_AT_MIPS_clone_origin";
13349 case DW_AT_MIPS_has_inlines
:
13350 return "DW_AT_MIPS_has_inlines";
13351 /* HP extensions. */
13352 #ifndef MIPS /* collides with DW_AT_MIPS_fde */
13353 case DW_AT_HP_block_index
:
13354 return "DW_AT_HP_block_index";
13356 case DW_AT_HP_unmodifiable
:
13357 return "DW_AT_HP_unmodifiable";
13358 case DW_AT_HP_actuals_stmt_list
:
13359 return "DW_AT_HP_actuals_stmt_list";
13360 case DW_AT_HP_proc_per_section
:
13361 return "DW_AT_HP_proc_per_section";
13362 case DW_AT_HP_raw_data_ptr
:
13363 return "DW_AT_HP_raw_data_ptr";
13364 case DW_AT_HP_pass_by_reference
:
13365 return "DW_AT_HP_pass_by_reference";
13366 case DW_AT_HP_opt_level
:
13367 return "DW_AT_HP_opt_level";
13368 case DW_AT_HP_prof_version_id
:
13369 return "DW_AT_HP_prof_version_id";
13370 case DW_AT_HP_opt_flags
:
13371 return "DW_AT_HP_opt_flags";
13372 case DW_AT_HP_cold_region_low_pc
:
13373 return "DW_AT_HP_cold_region_low_pc";
13374 case DW_AT_HP_cold_region_high_pc
:
13375 return "DW_AT_HP_cold_region_high_pc";
13376 case DW_AT_HP_all_variables_modifiable
:
13377 return "DW_AT_HP_all_variables_modifiable";
13378 case DW_AT_HP_linkage_name
:
13379 return "DW_AT_HP_linkage_name";
13380 case DW_AT_HP_prof_flags
:
13381 return "DW_AT_HP_prof_flags";
13382 /* GNU extensions. */
13383 case DW_AT_sf_names
:
13384 return "DW_AT_sf_names";
13385 case DW_AT_src_info
:
13386 return "DW_AT_src_info";
13387 case DW_AT_mac_info
:
13388 return "DW_AT_mac_info";
13389 case DW_AT_src_coords
:
13390 return "DW_AT_src_coords";
13391 case DW_AT_body_begin
:
13392 return "DW_AT_body_begin";
13393 case DW_AT_body_end
:
13394 return "DW_AT_body_end";
13395 case DW_AT_GNU_vector
:
13396 return "DW_AT_GNU_vector";
13397 case DW_AT_GNU_odr_signature
:
13398 return "DW_AT_GNU_odr_signature";
13399 /* VMS extensions. */
13400 case DW_AT_VMS_rtnbeg_pd_address
:
13401 return "DW_AT_VMS_rtnbeg_pd_address";
13402 /* UPC extension. */
13403 case DW_AT_upc_threads_scaled
:
13404 return "DW_AT_upc_threads_scaled";
13405 /* PGI (STMicroelectronics) extensions. */
13406 case DW_AT_PGI_lbase
:
13407 return "DW_AT_PGI_lbase";
13408 case DW_AT_PGI_soffset
:
13409 return "DW_AT_PGI_soffset";
13410 case DW_AT_PGI_lstride
:
13411 return "DW_AT_PGI_lstride";
13413 return "DW_AT_<unknown>";
13417 /* Convert a DWARF value form code into its string name. */
13420 dwarf_form_name (unsigned form
)
13425 return "DW_FORM_addr";
13426 case DW_FORM_block2
:
13427 return "DW_FORM_block2";
13428 case DW_FORM_block4
:
13429 return "DW_FORM_block4";
13430 case DW_FORM_data2
:
13431 return "DW_FORM_data2";
13432 case DW_FORM_data4
:
13433 return "DW_FORM_data4";
13434 case DW_FORM_data8
:
13435 return "DW_FORM_data8";
13436 case DW_FORM_string
:
13437 return "DW_FORM_string";
13438 case DW_FORM_block
:
13439 return "DW_FORM_block";
13440 case DW_FORM_block1
:
13441 return "DW_FORM_block1";
13442 case DW_FORM_data1
:
13443 return "DW_FORM_data1";
13445 return "DW_FORM_flag";
13446 case DW_FORM_sdata
:
13447 return "DW_FORM_sdata";
13449 return "DW_FORM_strp";
13450 case DW_FORM_udata
:
13451 return "DW_FORM_udata";
13452 case DW_FORM_ref_addr
:
13453 return "DW_FORM_ref_addr";
13455 return "DW_FORM_ref1";
13457 return "DW_FORM_ref2";
13459 return "DW_FORM_ref4";
13461 return "DW_FORM_ref8";
13462 case DW_FORM_ref_udata
:
13463 return "DW_FORM_ref_udata";
13464 case DW_FORM_indirect
:
13465 return "DW_FORM_indirect";
13466 case DW_FORM_sec_offset
:
13467 return "DW_FORM_sec_offset";
13468 case DW_FORM_exprloc
:
13469 return "DW_FORM_exprloc";
13470 case DW_FORM_flag_present
:
13471 return "DW_FORM_flag_present";
13472 case DW_FORM_ref_sig8
:
13473 return "DW_FORM_ref_sig8";
13475 return "DW_FORM_<unknown>";
13479 /* Convert a DWARF stack opcode into its string name. */
13482 dwarf_stack_op_name (unsigned op
)
13487 return "DW_OP_addr";
13489 return "DW_OP_deref";
13490 case DW_OP_const1u
:
13491 return "DW_OP_const1u";
13492 case DW_OP_const1s
:
13493 return "DW_OP_const1s";
13494 case DW_OP_const2u
:
13495 return "DW_OP_const2u";
13496 case DW_OP_const2s
:
13497 return "DW_OP_const2s";
13498 case DW_OP_const4u
:
13499 return "DW_OP_const4u";
13500 case DW_OP_const4s
:
13501 return "DW_OP_const4s";
13502 case DW_OP_const8u
:
13503 return "DW_OP_const8u";
13504 case DW_OP_const8s
:
13505 return "DW_OP_const8s";
13507 return "DW_OP_constu";
13509 return "DW_OP_consts";
13511 return "DW_OP_dup";
13513 return "DW_OP_drop";
13515 return "DW_OP_over";
13517 return "DW_OP_pick";
13519 return "DW_OP_swap";
13521 return "DW_OP_rot";
13523 return "DW_OP_xderef";
13525 return "DW_OP_abs";
13527 return "DW_OP_and";
13529 return "DW_OP_div";
13531 return "DW_OP_minus";
13533 return "DW_OP_mod";
13535 return "DW_OP_mul";
13537 return "DW_OP_neg";
13539 return "DW_OP_not";
13543 return "DW_OP_plus";
13544 case DW_OP_plus_uconst
:
13545 return "DW_OP_plus_uconst";
13547 return "DW_OP_shl";
13549 return "DW_OP_shr";
13551 return "DW_OP_shra";
13553 return "DW_OP_xor";
13555 return "DW_OP_bra";
13569 return "DW_OP_skip";
13571 return "DW_OP_lit0";
13573 return "DW_OP_lit1";
13575 return "DW_OP_lit2";
13577 return "DW_OP_lit3";
13579 return "DW_OP_lit4";
13581 return "DW_OP_lit5";
13583 return "DW_OP_lit6";
13585 return "DW_OP_lit7";
13587 return "DW_OP_lit8";
13589 return "DW_OP_lit9";
13591 return "DW_OP_lit10";
13593 return "DW_OP_lit11";
13595 return "DW_OP_lit12";
13597 return "DW_OP_lit13";
13599 return "DW_OP_lit14";
13601 return "DW_OP_lit15";
13603 return "DW_OP_lit16";
13605 return "DW_OP_lit17";
13607 return "DW_OP_lit18";
13609 return "DW_OP_lit19";
13611 return "DW_OP_lit20";
13613 return "DW_OP_lit21";
13615 return "DW_OP_lit22";
13617 return "DW_OP_lit23";
13619 return "DW_OP_lit24";
13621 return "DW_OP_lit25";
13623 return "DW_OP_lit26";
13625 return "DW_OP_lit27";
13627 return "DW_OP_lit28";
13629 return "DW_OP_lit29";
13631 return "DW_OP_lit30";
13633 return "DW_OP_lit31";
13635 return "DW_OP_reg0";
13637 return "DW_OP_reg1";
13639 return "DW_OP_reg2";
13641 return "DW_OP_reg3";
13643 return "DW_OP_reg4";
13645 return "DW_OP_reg5";
13647 return "DW_OP_reg6";
13649 return "DW_OP_reg7";
13651 return "DW_OP_reg8";
13653 return "DW_OP_reg9";
13655 return "DW_OP_reg10";
13657 return "DW_OP_reg11";
13659 return "DW_OP_reg12";
13661 return "DW_OP_reg13";
13663 return "DW_OP_reg14";
13665 return "DW_OP_reg15";
13667 return "DW_OP_reg16";
13669 return "DW_OP_reg17";
13671 return "DW_OP_reg18";
13673 return "DW_OP_reg19";
13675 return "DW_OP_reg20";
13677 return "DW_OP_reg21";
13679 return "DW_OP_reg22";
13681 return "DW_OP_reg23";
13683 return "DW_OP_reg24";
13685 return "DW_OP_reg25";
13687 return "DW_OP_reg26";
13689 return "DW_OP_reg27";
13691 return "DW_OP_reg28";
13693 return "DW_OP_reg29";
13695 return "DW_OP_reg30";
13697 return "DW_OP_reg31";
13699 return "DW_OP_breg0";
13701 return "DW_OP_breg1";
13703 return "DW_OP_breg2";
13705 return "DW_OP_breg3";
13707 return "DW_OP_breg4";
13709 return "DW_OP_breg5";
13711 return "DW_OP_breg6";
13713 return "DW_OP_breg7";
13715 return "DW_OP_breg8";
13717 return "DW_OP_breg9";
13719 return "DW_OP_breg10";
13721 return "DW_OP_breg11";
13723 return "DW_OP_breg12";
13725 return "DW_OP_breg13";
13727 return "DW_OP_breg14";
13729 return "DW_OP_breg15";
13731 return "DW_OP_breg16";
13733 return "DW_OP_breg17";
13735 return "DW_OP_breg18";
13737 return "DW_OP_breg19";
13739 return "DW_OP_breg20";
13741 return "DW_OP_breg21";
13743 return "DW_OP_breg22";
13745 return "DW_OP_breg23";
13747 return "DW_OP_breg24";
13749 return "DW_OP_breg25";
13751 return "DW_OP_breg26";
13753 return "DW_OP_breg27";
13755 return "DW_OP_breg28";
13757 return "DW_OP_breg29";
13759 return "DW_OP_breg30";
13761 return "DW_OP_breg31";
13763 return "DW_OP_regx";
13765 return "DW_OP_fbreg";
13767 return "DW_OP_bregx";
13769 return "DW_OP_piece";
13770 case DW_OP_deref_size
:
13771 return "DW_OP_deref_size";
13772 case DW_OP_xderef_size
:
13773 return "DW_OP_xderef_size";
13775 return "DW_OP_nop";
13776 /* DWARF 3 extensions. */
13777 case DW_OP_push_object_address
:
13778 return "DW_OP_push_object_address";
13780 return "DW_OP_call2";
13782 return "DW_OP_call4";
13783 case DW_OP_call_ref
:
13784 return "DW_OP_call_ref";
13785 case DW_OP_form_tls_address
:
13786 return "DW_OP_form_tls_address";
13787 case DW_OP_call_frame_cfa
:
13788 return "DW_OP_call_frame_cfa";
13789 case DW_OP_bit_piece
:
13790 return "DW_OP_bit_piece";
13791 /* DWARF 4 extensions. */
13792 case DW_OP_implicit_value
:
13793 return "DW_OP_implicit_value";
13794 case DW_OP_stack_value
:
13795 return "DW_OP_stack_value";
13796 /* GNU extensions. */
13797 case DW_OP_GNU_push_tls_address
:
13798 return "DW_OP_GNU_push_tls_address";
13799 case DW_OP_GNU_uninit
:
13800 return "DW_OP_GNU_uninit";
13801 case DW_OP_GNU_implicit_pointer
:
13802 return "DW_OP_GNU_implicit_pointer";
13803 case DW_OP_GNU_entry_value
:
13804 return "DW_OP_GNU_entry_value";
13805 case DW_OP_GNU_const_type
:
13806 return "DW_OP_GNU_const_type";
13807 case DW_OP_GNU_regval_type
:
13808 return "DW_OP_GNU_regval_type";
13809 case DW_OP_GNU_deref_type
:
13810 return "DW_OP_GNU_deref_type";
13811 case DW_OP_GNU_convert
:
13812 return "DW_OP_GNU_convert";
13813 case DW_OP_GNU_reinterpret
:
13814 return "DW_OP_GNU_reinterpret";
13821 dwarf_bool_name (unsigned mybool
)
13829 /* Convert a DWARF type code into its string name. */
13832 dwarf_type_encoding_name (unsigned enc
)
13837 return "DW_ATE_void";
13838 case DW_ATE_address
:
13839 return "DW_ATE_address";
13840 case DW_ATE_boolean
:
13841 return "DW_ATE_boolean";
13842 case DW_ATE_complex_float
:
13843 return "DW_ATE_complex_float";
13845 return "DW_ATE_float";
13846 case DW_ATE_signed
:
13847 return "DW_ATE_signed";
13848 case DW_ATE_signed_char
:
13849 return "DW_ATE_signed_char";
13850 case DW_ATE_unsigned
:
13851 return "DW_ATE_unsigned";
13852 case DW_ATE_unsigned_char
:
13853 return "DW_ATE_unsigned_char";
13855 case DW_ATE_imaginary_float
:
13856 return "DW_ATE_imaginary_float";
13857 case DW_ATE_packed_decimal
:
13858 return "DW_ATE_packed_decimal";
13859 case DW_ATE_numeric_string
:
13860 return "DW_ATE_numeric_string";
13861 case DW_ATE_edited
:
13862 return "DW_ATE_edited";
13863 case DW_ATE_signed_fixed
:
13864 return "DW_ATE_signed_fixed";
13865 case DW_ATE_unsigned_fixed
:
13866 return "DW_ATE_unsigned_fixed";
13867 case DW_ATE_decimal_float
:
13868 return "DW_ATE_decimal_float";
13871 return "DW_ATE_UTF";
13872 /* HP extensions. */
13873 case DW_ATE_HP_float80
:
13874 return "DW_ATE_HP_float80";
13875 case DW_ATE_HP_complex_float80
:
13876 return "DW_ATE_HP_complex_float80";
13877 case DW_ATE_HP_float128
:
13878 return "DW_ATE_HP_float128";
13879 case DW_ATE_HP_complex_float128
:
13880 return "DW_ATE_HP_complex_float128";
13881 case DW_ATE_HP_floathpintel
:
13882 return "DW_ATE_HP_floathpintel";
13883 case DW_ATE_HP_imaginary_float80
:
13884 return "DW_ATE_HP_imaginary_float80";
13885 case DW_ATE_HP_imaginary_float128
:
13886 return "DW_ATE_HP_imaginary_float128";
13888 return "DW_ATE_<unknown>";
13892 /* Convert a DWARF call frame info operation to its string name. */
13896 dwarf_cfi_name (unsigned cfi_opc
)
13900 case DW_CFA_advance_loc
:
13901 return "DW_CFA_advance_loc";
13902 case DW_CFA_offset
:
13903 return "DW_CFA_offset";
13904 case DW_CFA_restore
:
13905 return "DW_CFA_restore";
13907 return "DW_CFA_nop";
13908 case DW_CFA_set_loc
:
13909 return "DW_CFA_set_loc";
13910 case DW_CFA_advance_loc1
:
13911 return "DW_CFA_advance_loc1";
13912 case DW_CFA_advance_loc2
:
13913 return "DW_CFA_advance_loc2";
13914 case DW_CFA_advance_loc4
:
13915 return "DW_CFA_advance_loc4";
13916 case DW_CFA_offset_extended
:
13917 return "DW_CFA_offset_extended";
13918 case DW_CFA_restore_extended
:
13919 return "DW_CFA_restore_extended";
13920 case DW_CFA_undefined
:
13921 return "DW_CFA_undefined";
13922 case DW_CFA_same_value
:
13923 return "DW_CFA_same_value";
13924 case DW_CFA_register
:
13925 return "DW_CFA_register";
13926 case DW_CFA_remember_state
:
13927 return "DW_CFA_remember_state";
13928 case DW_CFA_restore_state
:
13929 return "DW_CFA_restore_state";
13930 case DW_CFA_def_cfa
:
13931 return "DW_CFA_def_cfa";
13932 case DW_CFA_def_cfa_register
:
13933 return "DW_CFA_def_cfa_register";
13934 case DW_CFA_def_cfa_offset
:
13935 return "DW_CFA_def_cfa_offset";
13937 case DW_CFA_def_cfa_expression
:
13938 return "DW_CFA_def_cfa_expression";
13939 case DW_CFA_expression
:
13940 return "DW_CFA_expression";
13941 case DW_CFA_offset_extended_sf
:
13942 return "DW_CFA_offset_extended_sf";
13943 case DW_CFA_def_cfa_sf
:
13944 return "DW_CFA_def_cfa_sf";
13945 case DW_CFA_def_cfa_offset_sf
:
13946 return "DW_CFA_def_cfa_offset_sf";
13947 case DW_CFA_val_offset
:
13948 return "DW_CFA_val_offset";
13949 case DW_CFA_val_offset_sf
:
13950 return "DW_CFA_val_offset_sf";
13951 case DW_CFA_val_expression
:
13952 return "DW_CFA_val_expression";
13953 /* SGI/MIPS specific. */
13954 case DW_CFA_MIPS_advance_loc8
:
13955 return "DW_CFA_MIPS_advance_loc8";
13956 /* GNU extensions. */
13957 case DW_CFA_GNU_window_save
:
13958 return "DW_CFA_GNU_window_save";
13959 case DW_CFA_GNU_args_size
:
13960 return "DW_CFA_GNU_args_size";
13961 case DW_CFA_GNU_negative_offset_extended
:
13962 return "DW_CFA_GNU_negative_offset_extended";
13964 return "DW_CFA_<unknown>";
13970 dump_die_shallow (struct ui_file
*f
, int indent
, struct die_info
*die
)
13974 print_spaces (indent
, f
);
13975 fprintf_unfiltered (f
, "Die: %s (abbrev %d, offset 0x%x)\n",
13976 dwarf_tag_name (die
->tag
), die
->abbrev
, die
->offset
);
13978 if (die
->parent
!= NULL
)
13980 print_spaces (indent
, f
);
13981 fprintf_unfiltered (f
, " parent at offset: 0x%x\n",
13982 die
->parent
->offset
);
13985 print_spaces (indent
, f
);
13986 fprintf_unfiltered (f
, " has children: %s\n",
13987 dwarf_bool_name (die
->child
!= NULL
));
13989 print_spaces (indent
, f
);
13990 fprintf_unfiltered (f
, " attributes:\n");
13992 for (i
= 0; i
< die
->num_attrs
; ++i
)
13994 print_spaces (indent
, f
);
13995 fprintf_unfiltered (f
, " %s (%s) ",
13996 dwarf_attr_name (die
->attrs
[i
].name
),
13997 dwarf_form_name (die
->attrs
[i
].form
));
13999 switch (die
->attrs
[i
].form
)
14001 case DW_FORM_ref_addr
:
14003 fprintf_unfiltered (f
, "address: ");
14004 fputs_filtered (hex_string (DW_ADDR (&die
->attrs
[i
])), f
);
14006 case DW_FORM_block2
:
14007 case DW_FORM_block4
:
14008 case DW_FORM_block
:
14009 case DW_FORM_block1
:
14010 fprintf_unfiltered (f
, "block: size %d",
14011 DW_BLOCK (&die
->attrs
[i
])->size
);
14013 case DW_FORM_exprloc
:
14014 fprintf_unfiltered (f
, "expression: size %u",
14015 DW_BLOCK (&die
->attrs
[i
])->size
);
14020 fprintf_unfiltered (f
, "constant ref: 0x%lx (adjusted)",
14021 (long) (DW_ADDR (&die
->attrs
[i
])));
14023 case DW_FORM_data1
:
14024 case DW_FORM_data2
:
14025 case DW_FORM_data4
:
14026 case DW_FORM_data8
:
14027 case DW_FORM_udata
:
14028 case DW_FORM_sdata
:
14029 fprintf_unfiltered (f
, "constant: %s",
14030 pulongest (DW_UNSND (&die
->attrs
[i
])));
14032 case DW_FORM_sec_offset
:
14033 fprintf_unfiltered (f
, "section offset: %s",
14034 pulongest (DW_UNSND (&die
->attrs
[i
])));
14036 case DW_FORM_ref_sig8
:
14037 if (DW_SIGNATURED_TYPE (&die
->attrs
[i
]) != NULL
)
14038 fprintf_unfiltered (f
, "signatured type, offset: 0x%x",
14039 DW_SIGNATURED_TYPE (&die
->attrs
[i
])->per_cu
.offset
);
14041 fprintf_unfiltered (f
, "signatured type, offset: unknown");
14043 case DW_FORM_string
:
14045 fprintf_unfiltered (f
, "string: \"%s\" (%s canonicalized)",
14046 DW_STRING (&die
->attrs
[i
])
14047 ? DW_STRING (&die
->attrs
[i
]) : "",
14048 DW_STRING_IS_CANONICAL (&die
->attrs
[i
]) ? "is" : "not");
14051 if (DW_UNSND (&die
->attrs
[i
]))
14052 fprintf_unfiltered (f
, "flag: TRUE");
14054 fprintf_unfiltered (f
, "flag: FALSE");
14056 case DW_FORM_flag_present
:
14057 fprintf_unfiltered (f
, "flag: TRUE");
14059 case DW_FORM_indirect
:
14060 /* The reader will have reduced the indirect form to
14061 the "base form" so this form should not occur. */
14062 fprintf_unfiltered (f
,
14063 "unexpected attribute form: DW_FORM_indirect");
14066 fprintf_unfiltered (f
, "unsupported attribute form: %d.",
14067 die
->attrs
[i
].form
);
14070 fprintf_unfiltered (f
, "\n");
14075 dump_die_for_error (struct die_info
*die
)
14077 dump_die_shallow (gdb_stderr
, 0, die
);
14081 dump_die_1 (struct ui_file
*f
, int level
, int max_level
, struct die_info
*die
)
14083 int indent
= level
* 4;
14085 gdb_assert (die
!= NULL
);
14087 if (level
>= max_level
)
14090 dump_die_shallow (f
, indent
, die
);
14092 if (die
->child
!= NULL
)
14094 print_spaces (indent
, f
);
14095 fprintf_unfiltered (f
, " Children:");
14096 if (level
+ 1 < max_level
)
14098 fprintf_unfiltered (f
, "\n");
14099 dump_die_1 (f
, level
+ 1, max_level
, die
->child
);
14103 fprintf_unfiltered (f
,
14104 " [not printed, max nesting level reached]\n");
14108 if (die
->sibling
!= NULL
&& level
> 0)
14110 dump_die_1 (f
, level
, max_level
, die
->sibling
);
14114 /* This is called from the pdie macro in gdbinit.in.
14115 It's not static so gcc will keep a copy callable from gdb. */
14118 dump_die (struct die_info
*die
, int max_level
)
14120 dump_die_1 (gdb_stdlog
, 0, max_level
, die
);
14124 store_in_ref_table (struct die_info
*die
, struct dwarf2_cu
*cu
)
14128 slot
= htab_find_slot_with_hash (cu
->die_hash
, die
, die
->offset
, INSERT
);
14134 is_ref_attr (struct attribute
*attr
)
14136 switch (attr
->form
)
14138 case DW_FORM_ref_addr
:
14143 case DW_FORM_ref_udata
:
14150 static unsigned int
14151 dwarf2_get_ref_die_offset (struct attribute
*attr
)
14153 if (is_ref_attr (attr
))
14154 return DW_ADDR (attr
);
14156 complaint (&symfile_complaints
,
14157 _("unsupported die ref attribute form: '%s'"),
14158 dwarf_form_name (attr
->form
));
14162 /* Return the constant value held by ATTR. Return DEFAULT_VALUE if
14163 * the value held by the attribute is not constant. */
14166 dwarf2_get_attr_constant_value (struct attribute
*attr
, int default_value
)
14168 if (attr
->form
== DW_FORM_sdata
)
14169 return DW_SND (attr
);
14170 else if (attr
->form
== DW_FORM_udata
14171 || attr
->form
== DW_FORM_data1
14172 || attr
->form
== DW_FORM_data2
14173 || attr
->form
== DW_FORM_data4
14174 || attr
->form
== DW_FORM_data8
)
14175 return DW_UNSND (attr
);
14178 complaint (&symfile_complaints
,
14179 _("Attribute value is not a constant (%s)"),
14180 dwarf_form_name (attr
->form
));
14181 return default_value
;
14185 /* THIS_CU has a reference to PER_CU. If necessary, load the new compilation
14186 unit and add it to our queue.
14187 The result is non-zero if PER_CU was queued, otherwise the result is zero
14188 meaning either PER_CU is already queued or it is already loaded. */
14191 maybe_queue_comp_unit (struct dwarf2_cu
*this_cu
,
14192 struct dwarf2_per_cu_data
*per_cu
)
14194 /* We may arrive here during partial symbol reading, if we need full
14195 DIEs to process an unusual case (e.g. template arguments). Do
14196 not queue PER_CU, just tell our caller to load its DIEs. */
14197 if (dwarf2_per_objfile
->reading_partial_symbols
)
14199 if (per_cu
->cu
== NULL
|| per_cu
->cu
->dies
== NULL
)
14204 /* Mark the dependence relation so that we don't flush PER_CU
14206 dwarf2_add_dependence (this_cu
, per_cu
);
14208 /* If it's already on the queue, we have nothing to do. */
14209 if (per_cu
->queued
)
14212 /* If the compilation unit is already loaded, just mark it as
14214 if (per_cu
->cu
!= NULL
)
14216 per_cu
->cu
->last_used
= 0;
14220 /* Add it to the queue. */
14221 queue_comp_unit (per_cu
, this_cu
->objfile
);
14226 /* Follow reference or signature attribute ATTR of SRC_DIE.
14227 On entry *REF_CU is the CU of SRC_DIE.
14228 On exit *REF_CU is the CU of the result. */
14230 static struct die_info
*
14231 follow_die_ref_or_sig (struct die_info
*src_die
, struct attribute
*attr
,
14232 struct dwarf2_cu
**ref_cu
)
14234 struct die_info
*die
;
14236 if (is_ref_attr (attr
))
14237 die
= follow_die_ref (src_die
, attr
, ref_cu
);
14238 else if (attr
->form
== DW_FORM_ref_sig8
)
14239 die
= follow_die_sig (src_die
, attr
, ref_cu
);
14242 dump_die_for_error (src_die
);
14243 error (_("Dwarf Error: Expected reference attribute [in module %s]"),
14244 (*ref_cu
)->objfile
->name
);
14250 /* Follow reference OFFSET.
14251 On entry *REF_CU is the CU of the source die referencing OFFSET.
14252 On exit *REF_CU is the CU of the result.
14253 Returns NULL if OFFSET is invalid. */
14255 static struct die_info
*
14256 follow_die_offset (unsigned int offset
, struct dwarf2_cu
**ref_cu
)
14258 struct die_info temp_die
;
14259 struct dwarf2_cu
*target_cu
, *cu
= *ref_cu
;
14261 gdb_assert (cu
->per_cu
!= NULL
);
14265 if (cu
->per_cu
->debug_type_section
)
14267 /* .debug_types CUs cannot reference anything outside their CU.
14268 If they need to, they have to reference a signatured type via
14269 DW_FORM_ref_sig8. */
14270 if (! offset_in_cu_p (&cu
->header
, offset
))
14273 else if (! offset_in_cu_p (&cu
->header
, offset
))
14275 struct dwarf2_per_cu_data
*per_cu
;
14277 per_cu
= dwarf2_find_containing_comp_unit (offset
, cu
->objfile
);
14279 /* If necessary, add it to the queue and load its DIEs. */
14280 if (maybe_queue_comp_unit (cu
, per_cu
))
14281 load_full_comp_unit (per_cu
, cu
->objfile
);
14283 target_cu
= per_cu
->cu
;
14285 else if (cu
->dies
== NULL
)
14287 /* We're loading full DIEs during partial symbol reading. */
14288 gdb_assert (dwarf2_per_objfile
->reading_partial_symbols
);
14289 load_full_comp_unit (cu
->per_cu
, cu
->objfile
);
14292 *ref_cu
= target_cu
;
14293 temp_die
.offset
= offset
;
14294 return htab_find_with_hash (target_cu
->die_hash
, &temp_die
, offset
);
14297 /* Follow reference attribute ATTR of SRC_DIE.
14298 On entry *REF_CU is the CU of SRC_DIE.
14299 On exit *REF_CU is the CU of the result. */
14301 static struct die_info
*
14302 follow_die_ref (struct die_info
*src_die
, struct attribute
*attr
,
14303 struct dwarf2_cu
**ref_cu
)
14305 unsigned int offset
= dwarf2_get_ref_die_offset (attr
);
14306 struct dwarf2_cu
*cu
= *ref_cu
;
14307 struct die_info
*die
;
14309 die
= follow_die_offset (offset
, ref_cu
);
14311 error (_("Dwarf Error: Cannot find DIE at 0x%x referenced from DIE "
14312 "at 0x%x [in module %s]"),
14313 offset
, src_die
->offset
, cu
->objfile
->name
);
14318 /* Return DWARF block referenced by DW_AT_location of DIE at OFFSET at PER_CU.
14319 Returned value is intended for DW_OP_call*. Returned
14320 dwarf2_locexpr_baton->data has lifetime of PER_CU->OBJFILE. */
14322 struct dwarf2_locexpr_baton
14323 dwarf2_fetch_die_location_block (unsigned int offset
,
14324 struct dwarf2_per_cu_data
*per_cu
,
14325 CORE_ADDR (*get_frame_pc
) (void *baton
),
14328 struct dwarf2_cu
*cu
;
14329 struct die_info
*die
;
14330 struct attribute
*attr
;
14331 struct dwarf2_locexpr_baton retval
;
14333 dw2_setup (per_cu
->objfile
);
14335 if (per_cu
->cu
== NULL
)
14339 die
= follow_die_offset (offset
, &cu
);
14341 error (_("Dwarf Error: Cannot find DIE at 0x%x referenced in module %s"),
14342 offset
, per_cu
->cu
->objfile
->name
);
14344 attr
= dwarf2_attr (die
, DW_AT_location
, cu
);
14347 /* DWARF: "If there is no such attribute, then there is no effect.".
14348 DATA is ignored if SIZE is 0. */
14350 retval
.data
= NULL
;
14353 else if (attr_form_is_section_offset (attr
))
14355 struct dwarf2_loclist_baton loclist_baton
;
14356 CORE_ADDR pc
= (*get_frame_pc
) (baton
);
14359 fill_in_loclist_baton (cu
, &loclist_baton
, attr
);
14361 retval
.data
= dwarf2_find_location_expression (&loclist_baton
,
14363 retval
.size
= size
;
14367 if (!attr_form_is_block (attr
))
14368 error (_("Dwarf Error: DIE at 0x%x referenced in module %s "
14369 "is neither DW_FORM_block* nor DW_FORM_exprloc"),
14370 offset
, per_cu
->cu
->objfile
->name
);
14372 retval
.data
= DW_BLOCK (attr
)->data
;
14373 retval
.size
= DW_BLOCK (attr
)->size
;
14375 retval
.per_cu
= cu
->per_cu
;
14377 age_cached_comp_units ();
14382 /* Return the type of the DIE at DIE_OFFSET in the CU named by
14386 dwarf2_get_die_type (unsigned int die_offset
,
14387 struct dwarf2_per_cu_data
*per_cu
)
14389 dw2_setup (per_cu
->objfile
);
14390 return get_die_type_at_offset (die_offset
, per_cu
);
14393 /* Follow the signature attribute ATTR in SRC_DIE.
14394 On entry *REF_CU is the CU of SRC_DIE.
14395 On exit *REF_CU is the CU of the result. */
14397 static struct die_info
*
14398 follow_die_sig (struct die_info
*src_die
, struct attribute
*attr
,
14399 struct dwarf2_cu
**ref_cu
)
14401 struct objfile
*objfile
= (*ref_cu
)->objfile
;
14402 struct die_info temp_die
;
14403 struct signatured_type
*sig_type
= DW_SIGNATURED_TYPE (attr
);
14404 struct dwarf2_cu
*sig_cu
;
14405 struct die_info
*die
;
14407 /* sig_type will be NULL if the signatured type is missing from
14409 if (sig_type
== NULL
)
14410 error (_("Dwarf Error: Cannot find signatured DIE referenced from DIE "
14411 "at 0x%x [in module %s]"),
14412 src_die
->offset
, objfile
->name
);
14414 /* If necessary, add it to the queue and load its DIEs. */
14416 if (maybe_queue_comp_unit (*ref_cu
, &sig_type
->per_cu
))
14417 read_signatured_type (objfile
, sig_type
);
14419 gdb_assert (sig_type
->per_cu
.cu
!= NULL
);
14421 sig_cu
= sig_type
->per_cu
.cu
;
14422 temp_die
.offset
= sig_cu
->header
.offset
+ sig_type
->type_offset
;
14423 die
= htab_find_with_hash (sig_cu
->die_hash
, &temp_die
, temp_die
.offset
);
14430 error (_("Dwarf Error: Cannot find signatured DIE at 0x%x referenced "
14431 "from DIE at 0x%x [in module %s]"),
14432 sig_type
->type_offset
, src_die
->offset
, objfile
->name
);
14435 /* Given an offset of a signatured type, return its signatured_type. */
14437 static struct signatured_type
*
14438 lookup_signatured_type_at_offset (struct objfile
*objfile
,
14439 struct dwarf2_section_info
*section
,
14440 unsigned int offset
)
14442 gdb_byte
*info_ptr
= section
->buffer
+ offset
;
14443 unsigned int length
, initial_length_size
;
14444 unsigned int sig_offset
;
14445 struct signatured_type find_entry
, *type_sig
;
14447 length
= read_initial_length (objfile
->obfd
, info_ptr
, &initial_length_size
);
14448 sig_offset
= (initial_length_size
14450 + (initial_length_size
== 4 ? 4 : 8) /*debug_abbrev_offset*/
14451 + 1 /*address_size*/);
14452 find_entry
.signature
= bfd_get_64 (objfile
->obfd
, info_ptr
+ sig_offset
);
14453 type_sig
= htab_find (dwarf2_per_objfile
->signatured_types
, &find_entry
);
14455 /* This is only used to lookup previously recorded types.
14456 If we didn't find it, it's our bug. */
14457 gdb_assert (type_sig
!= NULL
);
14458 gdb_assert (offset
== type_sig
->per_cu
.offset
);
14463 /* Read in signatured type at OFFSET and build its CU and die(s). */
14466 read_signatured_type_at_offset (struct objfile
*objfile
,
14467 struct dwarf2_section_info
*sect
,
14468 unsigned int offset
)
14470 struct signatured_type
*type_sig
;
14472 dwarf2_read_section (objfile
, sect
);
14474 /* We have the section offset, but we need the signature to do the
14475 hash table lookup. */
14476 type_sig
= lookup_signatured_type_at_offset (objfile
, sect
, offset
);
14478 gdb_assert (type_sig
->per_cu
.cu
== NULL
);
14480 read_signatured_type (objfile
, type_sig
);
14482 gdb_assert (type_sig
->per_cu
.cu
!= NULL
);
14485 /* Read in a signatured type and build its CU and DIEs. */
14488 read_signatured_type (struct objfile
*objfile
,
14489 struct signatured_type
*type_sig
)
14491 gdb_byte
*types_ptr
;
14492 struct die_reader_specs reader_specs
;
14493 struct dwarf2_cu
*cu
;
14494 ULONGEST signature
;
14495 struct cleanup
*back_to
, *free_cu_cleanup
;
14496 struct dwarf2_section_info
*section
= type_sig
->per_cu
.debug_type_section
;
14498 dwarf2_read_section (objfile
, section
);
14499 types_ptr
= section
->buffer
+ type_sig
->per_cu
.offset
;
14501 gdb_assert (type_sig
->per_cu
.cu
== NULL
);
14503 cu
= xmalloc (sizeof (*cu
));
14504 init_one_comp_unit (cu
, objfile
);
14506 type_sig
->per_cu
.cu
= cu
;
14507 cu
->per_cu
= &type_sig
->per_cu
;
14509 /* If an error occurs while loading, release our storage. */
14510 free_cu_cleanup
= make_cleanup (free_one_comp_unit
, cu
);
14512 types_ptr
= read_type_comp_unit_head (&cu
->header
, section
, &signature
,
14513 types_ptr
, objfile
->obfd
);
14514 gdb_assert (signature
== type_sig
->signature
);
14517 = htab_create_alloc_ex (cu
->header
.length
/ 12,
14521 &cu
->comp_unit_obstack
,
14522 hashtab_obstack_allocate
,
14523 dummy_obstack_deallocate
);
14525 dwarf2_read_abbrevs (cu
->objfile
->obfd
, cu
);
14526 back_to
= make_cleanup (dwarf2_free_abbrev_table
, cu
);
14528 init_cu_die_reader (&reader_specs
, cu
);
14530 cu
->dies
= read_die_and_children (&reader_specs
, types_ptr
, &types_ptr
,
14533 /* We try not to read any attributes in this function, because not
14534 all objfiles needed for references have been loaded yet, and symbol
14535 table processing isn't initialized. But we have to set the CU language,
14536 or we won't be able to build types correctly. */
14537 prepare_one_comp_unit (cu
, cu
->dies
);
14539 do_cleanups (back_to
);
14541 /* We've successfully allocated this compilation unit. Let our caller
14542 clean it up when finished with it. */
14543 discard_cleanups (free_cu_cleanup
);
14545 type_sig
->per_cu
.cu
->read_in_chain
= dwarf2_per_objfile
->read_in_chain
;
14546 dwarf2_per_objfile
->read_in_chain
= &type_sig
->per_cu
;
14549 /* Decode simple location descriptions.
14550 Given a pointer to a dwarf block that defines a location, compute
14551 the location and return the value.
14553 NOTE drow/2003-11-18: This function is called in two situations
14554 now: for the address of static or global variables (partial symbols
14555 only) and for offsets into structures which are expected to be
14556 (more or less) constant. The partial symbol case should go away,
14557 and only the constant case should remain. That will let this
14558 function complain more accurately. A few special modes are allowed
14559 without complaint for global variables (for instance, global
14560 register values and thread-local values).
14562 A location description containing no operations indicates that the
14563 object is optimized out. The return value is 0 for that case.
14564 FIXME drow/2003-11-16: No callers check for this case any more; soon all
14565 callers will only want a very basic result and this can become a
14568 Note that stack[0] is unused except as a default error return. */
14571 decode_locdesc (struct dwarf_block
*blk
, struct dwarf2_cu
*cu
)
14573 struct objfile
*objfile
= cu
->objfile
;
14575 int size
= blk
->size
;
14576 gdb_byte
*data
= blk
->data
;
14577 CORE_ADDR stack
[64];
14579 unsigned int bytes_read
, unsnd
;
14585 stack
[++stacki
] = 0;
14624 stack
[++stacki
] = op
- DW_OP_lit0
;
14659 stack
[++stacki
] = op
- DW_OP_reg0
;
14661 dwarf2_complex_location_expr_complaint ();
14665 unsnd
= read_unsigned_leb128 (NULL
, (data
+ i
), &bytes_read
);
14667 stack
[++stacki
] = unsnd
;
14669 dwarf2_complex_location_expr_complaint ();
14673 stack
[++stacki
] = read_address (objfile
->obfd
, &data
[i
],
14678 case DW_OP_const1u
:
14679 stack
[++stacki
] = read_1_byte (objfile
->obfd
, &data
[i
]);
14683 case DW_OP_const1s
:
14684 stack
[++stacki
] = read_1_signed_byte (objfile
->obfd
, &data
[i
]);
14688 case DW_OP_const2u
:
14689 stack
[++stacki
] = read_2_bytes (objfile
->obfd
, &data
[i
]);
14693 case DW_OP_const2s
:
14694 stack
[++stacki
] = read_2_signed_bytes (objfile
->obfd
, &data
[i
]);
14698 case DW_OP_const4u
:
14699 stack
[++stacki
] = read_4_bytes (objfile
->obfd
, &data
[i
]);
14703 case DW_OP_const4s
:
14704 stack
[++stacki
] = read_4_signed_bytes (objfile
->obfd
, &data
[i
]);
14708 case DW_OP_const8u
:
14709 stack
[++stacki
] = read_8_bytes (objfile
->obfd
, &data
[i
]);
14714 stack
[++stacki
] = read_unsigned_leb128 (NULL
, (data
+ i
),
14720 stack
[++stacki
] = read_signed_leb128 (NULL
, (data
+ i
), &bytes_read
);
14725 stack
[stacki
+ 1] = stack
[stacki
];
14730 stack
[stacki
- 1] += stack
[stacki
];
14734 case DW_OP_plus_uconst
:
14735 stack
[stacki
] += read_unsigned_leb128 (NULL
, (data
+ i
),
14741 stack
[stacki
- 1] -= stack
[stacki
];
14746 /* If we're not the last op, then we definitely can't encode
14747 this using GDB's address_class enum. This is valid for partial
14748 global symbols, although the variable's address will be bogus
14751 dwarf2_complex_location_expr_complaint ();
14754 case DW_OP_GNU_push_tls_address
:
14755 /* The top of the stack has the offset from the beginning
14756 of the thread control block at which the variable is located. */
14757 /* Nothing should follow this operator, so the top of stack would
14759 /* This is valid for partial global symbols, but the variable's
14760 address will be bogus in the psymtab. Make it always at least
14761 non-zero to not look as a variable garbage collected by linker
14762 which have DW_OP_addr 0. */
14764 dwarf2_complex_location_expr_complaint ();
14768 case DW_OP_GNU_uninit
:
14773 const char *name
= dwarf_stack_op_name (op
);
14776 complaint (&symfile_complaints
, _("unsupported stack op: '%s'"),
14779 complaint (&symfile_complaints
, _("unsupported stack op: '%02x'"),
14783 return (stack
[stacki
]);
14786 /* Enforce maximum stack depth of SIZE-1 to avoid writing
14787 outside of the allocated space. Also enforce minimum>0. */
14788 if (stacki
>= ARRAY_SIZE (stack
) - 1)
14790 complaint (&symfile_complaints
,
14791 _("location description stack overflow"));
14797 complaint (&symfile_complaints
,
14798 _("location description stack underflow"));
14802 return (stack
[stacki
]);
14805 /* memory allocation interface */
14807 static struct dwarf_block
*
14808 dwarf_alloc_block (struct dwarf2_cu
*cu
)
14810 struct dwarf_block
*blk
;
14812 blk
= (struct dwarf_block
*)
14813 obstack_alloc (&cu
->comp_unit_obstack
, sizeof (struct dwarf_block
));
14817 static struct abbrev_info
*
14818 dwarf_alloc_abbrev (struct dwarf2_cu
*cu
)
14820 struct abbrev_info
*abbrev
;
14822 abbrev
= (struct abbrev_info
*)
14823 obstack_alloc (&cu
->abbrev_obstack
, sizeof (struct abbrev_info
));
14824 memset (abbrev
, 0, sizeof (struct abbrev_info
));
14828 static struct die_info
*
14829 dwarf_alloc_die (struct dwarf2_cu
*cu
, int num_attrs
)
14831 struct die_info
*die
;
14832 size_t size
= sizeof (struct die_info
);
14835 size
+= (num_attrs
- 1) * sizeof (struct attribute
);
14837 die
= (struct die_info
*) obstack_alloc (&cu
->comp_unit_obstack
, size
);
14838 memset (die
, 0, sizeof (struct die_info
));
14843 /* Macro support. */
14845 /* Return the full name of file number I in *LH's file name table.
14846 Use COMP_DIR as the name of the current directory of the
14847 compilation. The result is allocated using xmalloc; the caller is
14848 responsible for freeing it. */
14850 file_full_name (int file
, struct line_header
*lh
, const char *comp_dir
)
14852 /* Is the file number a valid index into the line header's file name
14853 table? Remember that file numbers start with one, not zero. */
14854 if (1 <= file
&& file
<= lh
->num_file_names
)
14856 struct file_entry
*fe
= &lh
->file_names
[file
- 1];
14858 if (IS_ABSOLUTE_PATH (fe
->name
))
14859 return xstrdup (fe
->name
);
14867 dir
= lh
->include_dirs
[fe
->dir_index
- 1];
14873 dir_len
= strlen (dir
);
14874 full_name
= xmalloc (dir_len
+ 1 + strlen (fe
->name
) + 1);
14875 strcpy (full_name
, dir
);
14876 full_name
[dir_len
] = '/';
14877 strcpy (full_name
+ dir_len
+ 1, fe
->name
);
14881 return xstrdup (fe
->name
);
14886 /* The compiler produced a bogus file number. We can at least
14887 record the macro definitions made in the file, even if we
14888 won't be able to find the file by name. */
14889 char fake_name
[80];
14891 sprintf (fake_name
, "<bad macro file number %d>", file
);
14893 complaint (&symfile_complaints
,
14894 _("bad file number in macro information (%d)"),
14897 return xstrdup (fake_name
);
14902 static struct macro_source_file
*
14903 macro_start_file (int file
, int line
,
14904 struct macro_source_file
*current_file
,
14905 const char *comp_dir
,
14906 struct line_header
*lh
, struct objfile
*objfile
)
14908 /* The full name of this source file. */
14909 char *full_name
= file_full_name (file
, lh
, comp_dir
);
14911 /* We don't create a macro table for this compilation unit
14912 at all until we actually get a filename. */
14913 if (! pending_macros
)
14914 pending_macros
= new_macro_table (&objfile
->objfile_obstack
,
14915 objfile
->macro_cache
);
14917 if (! current_file
)
14918 /* If we have no current file, then this must be the start_file
14919 directive for the compilation unit's main source file. */
14920 current_file
= macro_set_main (pending_macros
, full_name
);
14922 current_file
= macro_include (current_file
, line
, full_name
);
14926 return current_file
;
14930 /* Copy the LEN characters at BUF to a xmalloc'ed block of memory,
14931 followed by a null byte. */
14933 copy_string (const char *buf
, int len
)
14935 char *s
= xmalloc (len
+ 1);
14937 memcpy (s
, buf
, len
);
14943 static const char *
14944 consume_improper_spaces (const char *p
, const char *body
)
14948 complaint (&symfile_complaints
,
14949 _("macro definition contains spaces "
14950 "in formal argument list:\n`%s'"),
14962 parse_macro_definition (struct macro_source_file
*file
, int line
,
14967 /* The body string takes one of two forms. For object-like macro
14968 definitions, it should be:
14970 <macro name> " " <definition>
14972 For function-like macro definitions, it should be:
14974 <macro name> "() " <definition>
14976 <macro name> "(" <arg name> ( "," <arg name> ) * ") " <definition>
14978 Spaces may appear only where explicitly indicated, and in the
14981 The Dwarf 2 spec says that an object-like macro's name is always
14982 followed by a space, but versions of GCC around March 2002 omit
14983 the space when the macro's definition is the empty string.
14985 The Dwarf 2 spec says that there should be no spaces between the
14986 formal arguments in a function-like macro's formal argument list,
14987 but versions of GCC around March 2002 include spaces after the
14991 /* Find the extent of the macro name. The macro name is terminated
14992 by either a space or null character (for an object-like macro) or
14993 an opening paren (for a function-like macro). */
14994 for (p
= body
; *p
; p
++)
14995 if (*p
== ' ' || *p
== '(')
14998 if (*p
== ' ' || *p
== '\0')
15000 /* It's an object-like macro. */
15001 int name_len
= p
- body
;
15002 char *name
= copy_string (body
, name_len
);
15003 const char *replacement
;
15006 replacement
= body
+ name_len
+ 1;
15009 dwarf2_macro_malformed_definition_complaint (body
);
15010 replacement
= body
+ name_len
;
15013 macro_define_object (file
, line
, name
, replacement
);
15017 else if (*p
== '(')
15019 /* It's a function-like macro. */
15020 char *name
= copy_string (body
, p
- body
);
15023 char **argv
= xmalloc (argv_size
* sizeof (*argv
));
15027 p
= consume_improper_spaces (p
, body
);
15029 /* Parse the formal argument list. */
15030 while (*p
&& *p
!= ')')
15032 /* Find the extent of the current argument name. */
15033 const char *arg_start
= p
;
15035 while (*p
&& *p
!= ',' && *p
!= ')' && *p
!= ' ')
15038 if (! *p
|| p
== arg_start
)
15039 dwarf2_macro_malformed_definition_complaint (body
);
15042 /* Make sure argv has room for the new argument. */
15043 if (argc
>= argv_size
)
15046 argv
= xrealloc (argv
, argv_size
* sizeof (*argv
));
15049 argv
[argc
++] = copy_string (arg_start
, p
- arg_start
);
15052 p
= consume_improper_spaces (p
, body
);
15054 /* Consume the comma, if present. */
15059 p
= consume_improper_spaces (p
, body
);
15068 /* Perfectly formed definition, no complaints. */
15069 macro_define_function (file
, line
, name
,
15070 argc
, (const char **) argv
,
15072 else if (*p
== '\0')
15074 /* Complain, but do define it. */
15075 dwarf2_macro_malformed_definition_complaint (body
);
15076 macro_define_function (file
, line
, name
,
15077 argc
, (const char **) argv
,
15081 /* Just complain. */
15082 dwarf2_macro_malformed_definition_complaint (body
);
15085 /* Just complain. */
15086 dwarf2_macro_malformed_definition_complaint (body
);
15092 for (i
= 0; i
< argc
; i
++)
15098 dwarf2_macro_malformed_definition_complaint (body
);
15101 /* Skip some bytes from BYTES according to the form given in FORM.
15102 Returns the new pointer. */
15105 skip_form_bytes (bfd
*abfd
, gdb_byte
*bytes
,
15106 enum dwarf_form form
,
15107 unsigned int offset_size
,
15108 struct dwarf2_section_info
*section
)
15110 unsigned int bytes_read
;
15114 case DW_FORM_data1
:
15119 case DW_FORM_data2
:
15123 case DW_FORM_data4
:
15127 case DW_FORM_data8
:
15131 case DW_FORM_string
:
15132 read_direct_string (abfd
, bytes
, &bytes_read
);
15133 bytes
+= bytes_read
;
15136 case DW_FORM_sec_offset
:
15138 bytes
+= offset_size
;
15141 case DW_FORM_block
:
15142 bytes
+= read_unsigned_leb128 (abfd
, bytes
, &bytes_read
);
15143 bytes
+= bytes_read
;
15146 case DW_FORM_block1
:
15147 bytes
+= 1 + read_1_byte (abfd
, bytes
);
15149 case DW_FORM_block2
:
15150 bytes
+= 2 + read_2_bytes (abfd
, bytes
);
15152 case DW_FORM_block4
:
15153 bytes
+= 4 + read_4_bytes (abfd
, bytes
);
15156 case DW_FORM_sdata
:
15157 case DW_FORM_udata
:
15158 bytes
= skip_leb128 (abfd
, bytes
);
15164 complaint (&symfile_complaints
,
15165 _("invalid form 0x%x in `%s'"),
15167 section
->asection
->name
);
15175 /* A helper for dwarf_decode_macros that handles skipping an unknown
15176 opcode. Returns an updated pointer to the macro data buffer; or,
15177 on error, issues a complaint and returns NULL. */
15180 skip_unknown_opcode (unsigned int opcode
,
15181 gdb_byte
**opcode_definitions
,
15184 unsigned int offset_size
,
15185 struct dwarf2_section_info
*section
)
15187 unsigned int bytes_read
, i
;
15191 if (opcode_definitions
[opcode
] == NULL
)
15193 complaint (&symfile_complaints
,
15194 _("unrecognized DW_MACFINO opcode 0x%x"),
15199 defn
= opcode_definitions
[opcode
];
15200 arg
= read_unsigned_leb128 (abfd
, defn
, &bytes_read
);
15201 defn
+= bytes_read
;
15203 for (i
= 0; i
< arg
; ++i
)
15205 mac_ptr
= skip_form_bytes (abfd
, mac_ptr
, defn
[i
], offset_size
, section
);
15206 if (mac_ptr
== NULL
)
15208 /* skip_form_bytes already issued the complaint. */
15216 /* A helper function which parses the header of a macro section.
15217 If the macro section is the extended (for now called "GNU") type,
15218 then this updates *OFFSET_SIZE. Returns a pointer to just after
15219 the header, or issues a complaint and returns NULL on error. */
15222 dwarf_parse_macro_header (gdb_byte
**opcode_definitions
,
15225 unsigned int *offset_size
,
15226 int section_is_gnu
)
15228 memset (opcode_definitions
, 0, 256 * sizeof (gdb_byte
*));
15230 if (section_is_gnu
)
15232 unsigned int version
, flags
;
15234 version
= read_2_bytes (abfd
, mac_ptr
);
15237 complaint (&symfile_complaints
,
15238 _("unrecognized version `%d' in .debug_macro section"),
15244 flags
= read_1_byte (abfd
, mac_ptr
);
15246 *offset_size
= (flags
& 1) ? 8 : 4;
15248 if ((flags
& 2) != 0)
15249 /* We don't need the line table offset. */
15250 mac_ptr
+= *offset_size
;
15252 /* Vendor opcode descriptions. */
15253 if ((flags
& 4) != 0)
15255 unsigned int i
, count
;
15257 count
= read_1_byte (abfd
, mac_ptr
);
15259 for (i
= 0; i
< count
; ++i
)
15261 unsigned int opcode
, bytes_read
;
15264 opcode
= read_1_byte (abfd
, mac_ptr
);
15266 opcode_definitions
[opcode
] = mac_ptr
;
15267 arg
= read_unsigned_leb128 (abfd
, mac_ptr
, &bytes_read
);
15268 mac_ptr
+= bytes_read
;
15277 /* A helper for dwarf_decode_macros that handles the GNU extensions,
15278 including DW_GNU_MACINFO_transparent_include. */
15281 dwarf_decode_macro_bytes (bfd
*abfd
, gdb_byte
*mac_ptr
, gdb_byte
*mac_end
,
15282 struct macro_source_file
*current_file
,
15283 struct line_header
*lh
, char *comp_dir
,
15284 struct dwarf2_section_info
*section
,
15285 int section_is_gnu
,
15286 unsigned int offset_size
,
15287 struct objfile
*objfile
)
15289 enum dwarf_macro_record_type macinfo_type
;
15290 int at_commandline
;
15291 gdb_byte
*opcode_definitions
[256];
15293 mac_ptr
= dwarf_parse_macro_header (opcode_definitions
, abfd
, mac_ptr
,
15294 &offset_size
, section_is_gnu
);
15295 if (mac_ptr
== NULL
)
15297 /* We already issued a complaint. */
15301 /* Determines if GDB is still before first DW_MACINFO_start_file. If true
15302 GDB is still reading the definitions from command line. First
15303 DW_MACINFO_start_file will need to be ignored as it was already executed
15304 to create CURRENT_FILE for the main source holding also the command line
15305 definitions. On first met DW_MACINFO_start_file this flag is reset to
15306 normally execute all the remaining DW_MACINFO_start_file macinfos. */
15308 at_commandline
= 1;
15312 /* Do we at least have room for a macinfo type byte? */
15313 if (mac_ptr
>= mac_end
)
15315 dwarf2_macros_too_long_complaint (section
);
15319 macinfo_type
= read_1_byte (abfd
, mac_ptr
);
15322 /* Note that we rely on the fact that the corresponding GNU and
15323 DWARF constants are the same. */
15324 switch (macinfo_type
)
15326 /* A zero macinfo type indicates the end of the macro
15331 case DW_MACRO_GNU_define
:
15332 case DW_MACRO_GNU_undef
:
15333 case DW_MACRO_GNU_define_indirect
:
15334 case DW_MACRO_GNU_undef_indirect
:
15336 unsigned int bytes_read
;
15341 line
= read_unsigned_leb128 (abfd
, mac_ptr
, &bytes_read
);
15342 mac_ptr
+= bytes_read
;
15344 if (macinfo_type
== DW_MACRO_GNU_define
15345 || macinfo_type
== DW_MACRO_GNU_undef
)
15347 body
= read_direct_string (abfd
, mac_ptr
, &bytes_read
);
15348 mac_ptr
+= bytes_read
;
15352 LONGEST str_offset
;
15354 str_offset
= read_offset_1 (abfd
, mac_ptr
, offset_size
);
15355 mac_ptr
+= offset_size
;
15357 body
= read_indirect_string_at_offset (abfd
, str_offset
);
15360 is_define
= (macinfo_type
== DW_MACRO_GNU_define
15361 || macinfo_type
== DW_MACRO_GNU_define_indirect
);
15362 if (! current_file
)
15364 /* DWARF violation as no main source is present. */
15365 complaint (&symfile_complaints
,
15366 _("debug info with no main source gives macro %s "
15368 is_define
? _("definition") : _("undefinition"),
15372 if ((line
== 0 && !at_commandline
)
15373 || (line
!= 0 && at_commandline
))
15374 complaint (&symfile_complaints
,
15375 _("debug info gives %s macro %s with %s line %d: %s"),
15376 at_commandline
? _("command-line") : _("in-file"),
15377 is_define
? _("definition") : _("undefinition"),
15378 line
== 0 ? _("zero") : _("non-zero"), line
, body
);
15381 parse_macro_definition (current_file
, line
, body
);
15384 gdb_assert (macinfo_type
== DW_MACRO_GNU_undef
15385 || macinfo_type
== DW_MACRO_GNU_undef_indirect
);
15386 macro_undef (current_file
, line
, body
);
15391 case DW_MACRO_GNU_start_file
:
15393 unsigned int bytes_read
;
15396 line
= read_unsigned_leb128 (abfd
, mac_ptr
, &bytes_read
);
15397 mac_ptr
+= bytes_read
;
15398 file
= read_unsigned_leb128 (abfd
, mac_ptr
, &bytes_read
);
15399 mac_ptr
+= bytes_read
;
15401 if ((line
== 0 && !at_commandline
)
15402 || (line
!= 0 && at_commandline
))
15403 complaint (&symfile_complaints
,
15404 _("debug info gives source %d included "
15405 "from %s at %s line %d"),
15406 file
, at_commandline
? _("command-line") : _("file"),
15407 line
== 0 ? _("zero") : _("non-zero"), line
);
15409 if (at_commandline
)
15411 /* This DW_MACRO_GNU_start_file was executed in the
15413 at_commandline
= 0;
15416 current_file
= macro_start_file (file
, line
,
15417 current_file
, comp_dir
,
15422 case DW_MACRO_GNU_end_file
:
15423 if (! current_file
)
15424 complaint (&symfile_complaints
,
15425 _("macro debug info has an unmatched "
15426 "`close_file' directive"));
15429 current_file
= current_file
->included_by
;
15430 if (! current_file
)
15432 enum dwarf_macro_record_type next_type
;
15434 /* GCC circa March 2002 doesn't produce the zero
15435 type byte marking the end of the compilation
15436 unit. Complain if it's not there, but exit no
15439 /* Do we at least have room for a macinfo type byte? */
15440 if (mac_ptr
>= mac_end
)
15442 dwarf2_macros_too_long_complaint (section
);
15446 /* We don't increment mac_ptr here, so this is just
15448 next_type
= read_1_byte (abfd
, mac_ptr
);
15449 if (next_type
!= 0)
15450 complaint (&symfile_complaints
,
15451 _("no terminating 0-type entry for "
15452 "macros in `.debug_macinfo' section"));
15459 case DW_MACRO_GNU_transparent_include
:
15463 offset
= read_offset_1 (abfd
, mac_ptr
, offset_size
);
15464 mac_ptr
+= offset_size
;
15466 dwarf_decode_macro_bytes (abfd
,
15467 section
->buffer
+ offset
,
15468 mac_end
, current_file
,
15470 section
, section_is_gnu
,
15471 offset_size
, objfile
);
15475 case DW_MACINFO_vendor_ext
:
15476 if (!section_is_gnu
)
15478 unsigned int bytes_read
;
15481 constant
= read_unsigned_leb128 (abfd
, mac_ptr
, &bytes_read
);
15482 mac_ptr
+= bytes_read
;
15483 read_direct_string (abfd
, mac_ptr
, &bytes_read
);
15484 mac_ptr
+= bytes_read
;
15486 /* We don't recognize any vendor extensions. */
15492 mac_ptr
= skip_unknown_opcode (macinfo_type
, opcode_definitions
,
15493 mac_ptr
, abfd
, offset_size
,
15495 if (mac_ptr
== NULL
)
15499 } while (macinfo_type
!= 0);
15503 dwarf_decode_macros (struct line_header
*lh
, unsigned int offset
,
15504 char *comp_dir
, bfd
*abfd
,
15505 struct dwarf2_cu
*cu
,
15506 struct dwarf2_section_info
*section
,
15507 int section_is_gnu
)
15509 gdb_byte
*mac_ptr
, *mac_end
;
15510 struct macro_source_file
*current_file
= 0;
15511 enum dwarf_macro_record_type macinfo_type
;
15512 unsigned int offset_size
= cu
->header
.offset_size
;
15513 gdb_byte
*opcode_definitions
[256];
15515 dwarf2_read_section (dwarf2_per_objfile
->objfile
, section
);
15516 if (section
->buffer
== NULL
)
15518 complaint (&symfile_complaints
, _("missing %s section"),
15519 section
->asection
->name
);
15523 /* First pass: Find the name of the base filename.
15524 This filename is needed in order to process all macros whose definition
15525 (or undefinition) comes from the command line. These macros are defined
15526 before the first DW_MACINFO_start_file entry, and yet still need to be
15527 associated to the base file.
15529 To determine the base file name, we scan the macro definitions until we
15530 reach the first DW_MACINFO_start_file entry. We then initialize
15531 CURRENT_FILE accordingly so that any macro definition found before the
15532 first DW_MACINFO_start_file can still be associated to the base file. */
15534 mac_ptr
= section
->buffer
+ offset
;
15535 mac_end
= section
->buffer
+ section
->size
;
15537 mac_ptr
= dwarf_parse_macro_header (opcode_definitions
, abfd
, mac_ptr
,
15538 &offset_size
, section_is_gnu
);
15539 if (mac_ptr
== NULL
)
15541 /* We already issued a complaint. */
15547 /* Do we at least have room for a macinfo type byte? */
15548 if (mac_ptr
>= mac_end
)
15550 /* Complaint is printed during the second pass as GDB will probably
15551 stop the first pass earlier upon finding
15552 DW_MACINFO_start_file. */
15556 macinfo_type
= read_1_byte (abfd
, mac_ptr
);
15559 /* Note that we rely on the fact that the corresponding GNU and
15560 DWARF constants are the same. */
15561 switch (macinfo_type
)
15563 /* A zero macinfo type indicates the end of the macro
15568 case DW_MACRO_GNU_define
:
15569 case DW_MACRO_GNU_undef
:
15570 /* Only skip the data by MAC_PTR. */
15572 unsigned int bytes_read
;
15574 read_unsigned_leb128 (abfd
, mac_ptr
, &bytes_read
);
15575 mac_ptr
+= bytes_read
;
15576 read_direct_string (abfd
, mac_ptr
, &bytes_read
);
15577 mac_ptr
+= bytes_read
;
15581 case DW_MACRO_GNU_start_file
:
15583 unsigned int bytes_read
;
15586 line
= read_unsigned_leb128 (abfd
, mac_ptr
, &bytes_read
);
15587 mac_ptr
+= bytes_read
;
15588 file
= read_unsigned_leb128 (abfd
, mac_ptr
, &bytes_read
);
15589 mac_ptr
+= bytes_read
;
15591 current_file
= macro_start_file (file
, line
, current_file
,
15592 comp_dir
, lh
, cu
->objfile
);
15596 case DW_MACRO_GNU_end_file
:
15597 /* No data to skip by MAC_PTR. */
15600 case DW_MACRO_GNU_define_indirect
:
15601 case DW_MACRO_GNU_undef_indirect
:
15603 unsigned int bytes_read
;
15605 read_unsigned_leb128 (abfd
, mac_ptr
, &bytes_read
);
15606 mac_ptr
+= bytes_read
;
15607 mac_ptr
+= offset_size
;
15611 case DW_MACRO_GNU_transparent_include
:
15612 /* Note that, according to the spec, a transparent include
15613 chain cannot call DW_MACRO_GNU_start_file. So, we can just
15614 skip this opcode. */
15615 mac_ptr
+= offset_size
;
15618 case DW_MACINFO_vendor_ext
:
15619 /* Only skip the data by MAC_PTR. */
15620 if (!section_is_gnu
)
15622 unsigned int bytes_read
;
15624 read_unsigned_leb128 (abfd
, mac_ptr
, &bytes_read
);
15625 mac_ptr
+= bytes_read
;
15626 read_direct_string (abfd
, mac_ptr
, &bytes_read
);
15627 mac_ptr
+= bytes_read
;
15632 mac_ptr
= skip_unknown_opcode (macinfo_type
, opcode_definitions
,
15633 mac_ptr
, abfd
, offset_size
,
15635 if (mac_ptr
== NULL
)
15639 } while (macinfo_type
!= 0 && current_file
== NULL
);
15641 /* Second pass: Process all entries.
15643 Use the AT_COMMAND_LINE flag to determine whether we are still processing
15644 command-line macro definitions/undefinitions. This flag is unset when we
15645 reach the first DW_MACINFO_start_file entry. */
15647 dwarf_decode_macro_bytes (abfd
, section
->buffer
+ offset
, mac_end
,
15648 current_file
, lh
, comp_dir
, section
, section_is_gnu
,
15649 offset_size
, cu
->objfile
);
15652 /* Check if the attribute's form is a DW_FORM_block*
15653 if so return true else false. */
15655 attr_form_is_block (struct attribute
*attr
)
15657 return (attr
== NULL
? 0 :
15658 attr
->form
== DW_FORM_block1
15659 || attr
->form
== DW_FORM_block2
15660 || attr
->form
== DW_FORM_block4
15661 || attr
->form
== DW_FORM_block
15662 || attr
->form
== DW_FORM_exprloc
);
15665 /* Return non-zero if ATTR's value is a section offset --- classes
15666 lineptr, loclistptr, macptr or rangelistptr --- or zero, otherwise.
15667 You may use DW_UNSND (attr) to retrieve such offsets.
15669 Section 7.5.4, "Attribute Encodings", explains that no attribute
15670 may have a value that belongs to more than one of these classes; it
15671 would be ambiguous if we did, because we use the same forms for all
15674 attr_form_is_section_offset (struct attribute
*attr
)
15676 return (attr
->form
== DW_FORM_data4
15677 || attr
->form
== DW_FORM_data8
15678 || attr
->form
== DW_FORM_sec_offset
);
15682 /* Return non-zero if ATTR's value falls in the 'constant' class, or
15683 zero otherwise. When this function returns true, you can apply
15684 dwarf2_get_attr_constant_value to it.
15686 However, note that for some attributes you must check
15687 attr_form_is_section_offset before using this test. DW_FORM_data4
15688 and DW_FORM_data8 are members of both the constant class, and of
15689 the classes that contain offsets into other debug sections
15690 (lineptr, loclistptr, macptr or rangelistptr). The DWARF spec says
15691 that, if an attribute's can be either a constant or one of the
15692 section offset classes, DW_FORM_data4 and DW_FORM_data8 should be
15693 taken as section offsets, not constants. */
15695 attr_form_is_constant (struct attribute
*attr
)
15697 switch (attr
->form
)
15699 case DW_FORM_sdata
:
15700 case DW_FORM_udata
:
15701 case DW_FORM_data1
:
15702 case DW_FORM_data2
:
15703 case DW_FORM_data4
:
15704 case DW_FORM_data8
:
15711 /* A helper function that fills in a dwarf2_loclist_baton. */
15714 fill_in_loclist_baton (struct dwarf2_cu
*cu
,
15715 struct dwarf2_loclist_baton
*baton
,
15716 struct attribute
*attr
)
15718 dwarf2_read_section (dwarf2_per_objfile
->objfile
,
15719 &dwarf2_per_objfile
->loc
);
15721 baton
->per_cu
= cu
->per_cu
;
15722 gdb_assert (baton
->per_cu
);
15723 /* We don't know how long the location list is, but make sure we
15724 don't run off the edge of the section. */
15725 baton
->size
= dwarf2_per_objfile
->loc
.size
- DW_UNSND (attr
);
15726 baton
->data
= dwarf2_per_objfile
->loc
.buffer
+ DW_UNSND (attr
);
15727 baton
->base_address
= cu
->base_address
;
15731 dwarf2_symbol_mark_computed (struct attribute
*attr
, struct symbol
*sym
,
15732 struct dwarf2_cu
*cu
)
15734 if (attr_form_is_section_offset (attr
)
15735 /* ".debug_loc" may not exist at all, or the offset may be outside
15736 the section. If so, fall through to the complaint in the
15738 && DW_UNSND (attr
) < dwarf2_section_size (dwarf2_per_objfile
->objfile
,
15739 &dwarf2_per_objfile
->loc
))
15741 struct dwarf2_loclist_baton
*baton
;
15743 baton
= obstack_alloc (&cu
->objfile
->objfile_obstack
,
15744 sizeof (struct dwarf2_loclist_baton
));
15746 fill_in_loclist_baton (cu
, baton
, attr
);
15748 if (cu
->base_known
== 0)
15749 complaint (&symfile_complaints
,
15750 _("Location list used without "
15751 "specifying the CU base address."));
15753 SYMBOL_COMPUTED_OPS (sym
) = &dwarf2_loclist_funcs
;
15754 SYMBOL_LOCATION_BATON (sym
) = baton
;
15758 struct dwarf2_locexpr_baton
*baton
;
15760 baton
= obstack_alloc (&cu
->objfile
->objfile_obstack
,
15761 sizeof (struct dwarf2_locexpr_baton
));
15762 baton
->per_cu
= cu
->per_cu
;
15763 gdb_assert (baton
->per_cu
);
15765 if (attr_form_is_block (attr
))
15767 /* Note that we're just copying the block's data pointer
15768 here, not the actual data. We're still pointing into the
15769 info_buffer for SYM's objfile; right now we never release
15770 that buffer, but when we do clean up properly this may
15772 baton
->size
= DW_BLOCK (attr
)->size
;
15773 baton
->data
= DW_BLOCK (attr
)->data
;
15777 dwarf2_invalid_attrib_class_complaint ("location description",
15778 SYMBOL_NATURAL_NAME (sym
));
15782 SYMBOL_COMPUTED_OPS (sym
) = &dwarf2_locexpr_funcs
;
15783 SYMBOL_LOCATION_BATON (sym
) = baton
;
15787 /* Return the OBJFILE associated with the compilation unit CU. If CU
15788 came from a separate debuginfo file, then the master objfile is
15792 dwarf2_per_cu_objfile (struct dwarf2_per_cu_data
*per_cu
)
15794 struct objfile
*objfile
= per_cu
->objfile
;
15796 /* Return the master objfile, so that we can report and look up the
15797 correct file containing this variable. */
15798 if (objfile
->separate_debug_objfile_backlink
)
15799 objfile
= objfile
->separate_debug_objfile_backlink
;
15804 /* Return comp_unit_head for PER_CU, either already available in PER_CU->CU
15805 (CU_HEADERP is unused in such case) or prepare a temporary copy at
15806 CU_HEADERP first. */
15808 static const struct comp_unit_head
*
15809 per_cu_header_read_in (struct comp_unit_head
*cu_headerp
,
15810 struct dwarf2_per_cu_data
*per_cu
)
15812 struct objfile
*objfile
;
15813 struct dwarf2_per_objfile
*per_objfile
;
15814 gdb_byte
*info_ptr
;
15817 return &per_cu
->cu
->header
;
15819 objfile
= per_cu
->objfile
;
15820 per_objfile
= objfile_data (objfile
, dwarf2_objfile_data_key
);
15821 info_ptr
= per_objfile
->info
.buffer
+ per_cu
->offset
;
15823 memset (cu_headerp
, 0, sizeof (*cu_headerp
));
15824 read_comp_unit_head (cu_headerp
, info_ptr
, objfile
->obfd
);
15829 /* Return the address size given in the compilation unit header for CU. */
15832 dwarf2_per_cu_addr_size (struct dwarf2_per_cu_data
*per_cu
)
15834 struct comp_unit_head cu_header_local
;
15835 const struct comp_unit_head
*cu_headerp
;
15837 cu_headerp
= per_cu_header_read_in (&cu_header_local
, per_cu
);
15839 return cu_headerp
->addr_size
;
15842 /* Return the offset size given in the compilation unit header for CU. */
15845 dwarf2_per_cu_offset_size (struct dwarf2_per_cu_data
*per_cu
)
15847 struct comp_unit_head cu_header_local
;
15848 const struct comp_unit_head
*cu_headerp
;
15850 cu_headerp
= per_cu_header_read_in (&cu_header_local
, per_cu
);
15852 return cu_headerp
->offset_size
;
15855 /* See its dwarf2loc.h declaration. */
15858 dwarf2_per_cu_ref_addr_size (struct dwarf2_per_cu_data
*per_cu
)
15860 struct comp_unit_head cu_header_local
;
15861 const struct comp_unit_head
*cu_headerp
;
15863 cu_headerp
= per_cu_header_read_in (&cu_header_local
, per_cu
);
15865 if (cu_headerp
->version
== 2)
15866 return cu_headerp
->addr_size
;
15868 return cu_headerp
->offset_size
;
15871 /* Return the text offset of the CU. The returned offset comes from
15872 this CU's objfile. If this objfile came from a separate debuginfo
15873 file, then the offset may be different from the corresponding
15874 offset in the parent objfile. */
15877 dwarf2_per_cu_text_offset (struct dwarf2_per_cu_data
*per_cu
)
15879 struct objfile
*objfile
= per_cu
->objfile
;
15881 return ANOFFSET (objfile
->section_offsets
, SECT_OFF_TEXT (objfile
));
15884 /* Locate the .debug_info compilation unit from CU's objfile which contains
15885 the DIE at OFFSET. Raises an error on failure. */
15887 static struct dwarf2_per_cu_data
*
15888 dwarf2_find_containing_comp_unit (unsigned int offset
,
15889 struct objfile
*objfile
)
15891 struct dwarf2_per_cu_data
*this_cu
;
15895 high
= dwarf2_per_objfile
->n_comp_units
- 1;
15898 int mid
= low
+ (high
- low
) / 2;
15900 if (dwarf2_per_objfile
->all_comp_units
[mid
]->offset
>= offset
)
15905 gdb_assert (low
== high
);
15906 if (dwarf2_per_objfile
->all_comp_units
[low
]->offset
> offset
)
15909 error (_("Dwarf Error: could not find partial DIE containing "
15910 "offset 0x%lx [in module %s]"),
15911 (long) offset
, bfd_get_filename (objfile
->obfd
));
15913 gdb_assert (dwarf2_per_objfile
->all_comp_units
[low
-1]->offset
<= offset
);
15914 return dwarf2_per_objfile
->all_comp_units
[low
-1];
15918 this_cu
= dwarf2_per_objfile
->all_comp_units
[low
];
15919 if (low
== dwarf2_per_objfile
->n_comp_units
- 1
15920 && offset
>= this_cu
->offset
+ this_cu
->length
)
15921 error (_("invalid dwarf2 offset %u"), offset
);
15922 gdb_assert (offset
< this_cu
->offset
+ this_cu
->length
);
15927 /* Locate the compilation unit from OBJFILE which is located at exactly
15928 OFFSET. Raises an error on failure. */
15930 static struct dwarf2_per_cu_data
*
15931 dwarf2_find_comp_unit (unsigned int offset
, struct objfile
*objfile
)
15933 struct dwarf2_per_cu_data
*this_cu
;
15935 this_cu
= dwarf2_find_containing_comp_unit (offset
, objfile
);
15936 if (this_cu
->offset
!= offset
)
15937 error (_("no compilation unit with offset %u."), offset
);
15941 /* Initialize dwarf2_cu CU for OBJFILE in a pre-allocated space. */
15944 init_one_comp_unit (struct dwarf2_cu
*cu
, struct objfile
*objfile
)
15946 memset (cu
, 0, sizeof (*cu
));
15947 cu
->objfile
= objfile
;
15948 obstack_init (&cu
->comp_unit_obstack
);
15951 /* Initialize basic fields of dwarf_cu CU according to DIE COMP_UNIT_DIE. */
15954 prepare_one_comp_unit (struct dwarf2_cu
*cu
, struct die_info
*comp_unit_die
)
15956 struct attribute
*attr
;
15958 /* Set the language we're debugging. */
15959 attr
= dwarf2_attr (comp_unit_die
, DW_AT_language
, cu
);
15961 set_cu_language (DW_UNSND (attr
), cu
);
15964 cu
->language
= language_minimal
;
15965 cu
->language_defn
= language_def (cu
->language
);
15969 /* Release one cached compilation unit, CU. We unlink it from the tree
15970 of compilation units, but we don't remove it from the read_in_chain;
15971 the caller is responsible for that.
15972 NOTE: DATA is a void * because this function is also used as a
15973 cleanup routine. */
15976 free_one_comp_unit (void *data
)
15978 struct dwarf2_cu
*cu
= data
;
15980 if (cu
->per_cu
!= NULL
)
15981 cu
->per_cu
->cu
= NULL
;
15984 obstack_free (&cu
->comp_unit_obstack
, NULL
);
15989 /* This cleanup function is passed the address of a dwarf2_cu on the stack
15990 when we're finished with it. We can't free the pointer itself, but be
15991 sure to unlink it from the cache. Also release any associated storage
15992 and perform cache maintenance.
15994 Only used during partial symbol parsing. */
15997 free_stack_comp_unit (void *data
)
15999 struct dwarf2_cu
*cu
= data
;
16001 obstack_free (&cu
->comp_unit_obstack
, NULL
);
16002 cu
->partial_dies
= NULL
;
16004 if (cu
->per_cu
!= NULL
)
16006 /* This compilation unit is on the stack in our caller, so we
16007 should not xfree it. Just unlink it. */
16008 cu
->per_cu
->cu
= NULL
;
16011 /* If we had a per-cu pointer, then we may have other compilation
16012 units loaded, so age them now. */
16013 age_cached_comp_units ();
16017 /* Free all cached compilation units. */
16020 free_cached_comp_units (void *data
)
16022 struct dwarf2_per_cu_data
*per_cu
, **last_chain
;
16024 per_cu
= dwarf2_per_objfile
->read_in_chain
;
16025 last_chain
= &dwarf2_per_objfile
->read_in_chain
;
16026 while (per_cu
!= NULL
)
16028 struct dwarf2_per_cu_data
*next_cu
;
16030 next_cu
= per_cu
->cu
->read_in_chain
;
16032 free_one_comp_unit (per_cu
->cu
);
16033 *last_chain
= next_cu
;
16039 /* Increase the age counter on each cached compilation unit, and free
16040 any that are too old. */
16043 age_cached_comp_units (void)
16045 struct dwarf2_per_cu_data
*per_cu
, **last_chain
;
16047 dwarf2_clear_marks (dwarf2_per_objfile
->read_in_chain
);
16048 per_cu
= dwarf2_per_objfile
->read_in_chain
;
16049 while (per_cu
!= NULL
)
16051 per_cu
->cu
->last_used
++;
16052 if (per_cu
->cu
->last_used
<= dwarf2_max_cache_age
)
16053 dwarf2_mark (per_cu
->cu
);
16054 per_cu
= per_cu
->cu
->read_in_chain
;
16057 per_cu
= dwarf2_per_objfile
->read_in_chain
;
16058 last_chain
= &dwarf2_per_objfile
->read_in_chain
;
16059 while (per_cu
!= NULL
)
16061 struct dwarf2_per_cu_data
*next_cu
;
16063 next_cu
= per_cu
->cu
->read_in_chain
;
16065 if (!per_cu
->cu
->mark
)
16067 free_one_comp_unit (per_cu
->cu
);
16068 *last_chain
= next_cu
;
16071 last_chain
= &per_cu
->cu
->read_in_chain
;
16077 /* Remove a single compilation unit from the cache. */
16080 free_one_cached_comp_unit (void *target_cu
)
16082 struct dwarf2_per_cu_data
*per_cu
, **last_chain
;
16084 per_cu
= dwarf2_per_objfile
->read_in_chain
;
16085 last_chain
= &dwarf2_per_objfile
->read_in_chain
;
16086 while (per_cu
!= NULL
)
16088 struct dwarf2_per_cu_data
*next_cu
;
16090 next_cu
= per_cu
->cu
->read_in_chain
;
16092 if (per_cu
->cu
== target_cu
)
16094 free_one_comp_unit (per_cu
->cu
);
16095 *last_chain
= next_cu
;
16099 last_chain
= &per_cu
->cu
->read_in_chain
;
16105 /* Release all extra memory associated with OBJFILE. */
16108 dwarf2_free_objfile (struct objfile
*objfile
)
16110 dwarf2_per_objfile
= objfile_data (objfile
, dwarf2_objfile_data_key
);
16112 if (dwarf2_per_objfile
== NULL
)
16115 /* Cached DIE trees use xmalloc and the comp_unit_obstack. */
16116 free_cached_comp_units (NULL
);
16118 if (dwarf2_per_objfile
->quick_file_names_table
)
16119 htab_delete (dwarf2_per_objfile
->quick_file_names_table
);
16121 /* Everything else should be on the objfile obstack. */
16124 /* A pair of DIE offset and GDB type pointer. We store these
16125 in a hash table separate from the DIEs, and preserve them
16126 when the DIEs are flushed out of cache. */
16128 struct dwarf2_offset_and_type
16130 unsigned int offset
;
16134 /* Hash function for a dwarf2_offset_and_type. */
16137 offset_and_type_hash (const void *item
)
16139 const struct dwarf2_offset_and_type
*ofs
= item
;
16141 return ofs
->offset
;
16144 /* Equality function for a dwarf2_offset_and_type. */
16147 offset_and_type_eq (const void *item_lhs
, const void *item_rhs
)
16149 const struct dwarf2_offset_and_type
*ofs_lhs
= item_lhs
;
16150 const struct dwarf2_offset_and_type
*ofs_rhs
= item_rhs
;
16152 return ofs_lhs
->offset
== ofs_rhs
->offset
;
16155 /* Set the type associated with DIE to TYPE. Save it in CU's hash
16156 table if necessary. For convenience, return TYPE.
16158 The DIEs reading must have careful ordering to:
16159 * Not cause infite loops trying to read in DIEs as a prerequisite for
16160 reading current DIE.
16161 * Not trying to dereference contents of still incompletely read in types
16162 while reading in other DIEs.
16163 * Enable referencing still incompletely read in types just by a pointer to
16164 the type without accessing its fields.
16166 Therefore caller should follow these rules:
16167 * Try to fetch any prerequisite types we may need to build this DIE type
16168 before building the type and calling set_die_type.
16169 * After building type call set_die_type for current DIE as soon as
16170 possible before fetching more types to complete the current type.
16171 * Make the type as complete as possible before fetching more types. */
16173 static struct type
*
16174 set_die_type (struct die_info
*die
, struct type
*type
, struct dwarf2_cu
*cu
)
16176 struct dwarf2_offset_and_type
**slot
, ofs
;
16177 struct objfile
*objfile
= cu
->objfile
;
16178 htab_t
*type_hash_ptr
;
16180 /* For Ada types, make sure that the gnat-specific data is always
16181 initialized (if not already set). There are a few types where
16182 we should not be doing so, because the type-specific area is
16183 already used to hold some other piece of info (eg: TYPE_CODE_FLT
16184 where the type-specific area is used to store the floatformat).
16185 But this is not a problem, because the gnat-specific information
16186 is actually not needed for these types. */
16187 if (need_gnat_info (cu
)
16188 && TYPE_CODE (type
) != TYPE_CODE_FUNC
16189 && TYPE_CODE (type
) != TYPE_CODE_FLT
16190 && !HAVE_GNAT_AUX_INFO (type
))
16191 INIT_GNAT_SPECIFIC (type
);
16193 if (cu
->per_cu
->debug_type_section
)
16194 type_hash_ptr
= &dwarf2_per_objfile
->debug_types_type_hash
;
16196 type_hash_ptr
= &dwarf2_per_objfile
->debug_info_type_hash
;
16198 if (*type_hash_ptr
== NULL
)
16201 = htab_create_alloc_ex (127,
16202 offset_and_type_hash
,
16203 offset_and_type_eq
,
16205 &objfile
->objfile_obstack
,
16206 hashtab_obstack_allocate
,
16207 dummy_obstack_deallocate
);
16210 ofs
.offset
= die
->offset
;
16212 slot
= (struct dwarf2_offset_and_type
**)
16213 htab_find_slot_with_hash (*type_hash_ptr
, &ofs
, ofs
.offset
, INSERT
);
16215 complaint (&symfile_complaints
,
16216 _("A problem internal to GDB: DIE 0x%x has type already set"),
16218 *slot
= obstack_alloc (&objfile
->objfile_obstack
, sizeof (**slot
));
16223 /* Look up the type for the die at DIE_OFFSET in the appropriate type_hash
16224 table, or return NULL if the die does not have a saved type. */
16226 static struct type
*
16227 get_die_type_at_offset (unsigned int offset
,
16228 struct dwarf2_per_cu_data
*per_cu
)
16230 struct dwarf2_offset_and_type
*slot
, ofs
;
16233 if (per_cu
->debug_type_section
)
16234 type_hash
= dwarf2_per_objfile
->debug_types_type_hash
;
16236 type_hash
= dwarf2_per_objfile
->debug_info_type_hash
;
16237 if (type_hash
== NULL
)
16240 ofs
.offset
= offset
;
16241 slot
= htab_find_with_hash (type_hash
, &ofs
, ofs
.offset
);
16248 /* Look up the type for DIE in the appropriate type_hash table,
16249 or return NULL if DIE does not have a saved type. */
16251 static struct type
*
16252 get_die_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
16254 return get_die_type_at_offset (die
->offset
, cu
->per_cu
);
16257 /* Add a dependence relationship from CU to REF_PER_CU. */
16260 dwarf2_add_dependence (struct dwarf2_cu
*cu
,
16261 struct dwarf2_per_cu_data
*ref_per_cu
)
16265 if (cu
->dependencies
== NULL
)
16267 = htab_create_alloc_ex (5, htab_hash_pointer
, htab_eq_pointer
,
16268 NULL
, &cu
->comp_unit_obstack
,
16269 hashtab_obstack_allocate
,
16270 dummy_obstack_deallocate
);
16272 slot
= htab_find_slot (cu
->dependencies
, ref_per_cu
, INSERT
);
16274 *slot
= ref_per_cu
;
16277 /* Subroutine of dwarf2_mark to pass to htab_traverse.
16278 Set the mark field in every compilation unit in the
16279 cache that we must keep because we are keeping CU. */
16282 dwarf2_mark_helper (void **slot
, void *data
)
16284 struct dwarf2_per_cu_data
*per_cu
;
16286 per_cu
= (struct dwarf2_per_cu_data
*) *slot
;
16288 /* cu->dependencies references may not yet have been ever read if QUIT aborts
16289 reading of the chain. As such dependencies remain valid it is not much
16290 useful to track and undo them during QUIT cleanups. */
16291 if (per_cu
->cu
== NULL
)
16294 if (per_cu
->cu
->mark
)
16296 per_cu
->cu
->mark
= 1;
16298 if (per_cu
->cu
->dependencies
!= NULL
)
16299 htab_traverse (per_cu
->cu
->dependencies
, dwarf2_mark_helper
, NULL
);
16304 /* Set the mark field in CU and in every other compilation unit in the
16305 cache that we must keep because we are keeping CU. */
16308 dwarf2_mark (struct dwarf2_cu
*cu
)
16313 if (cu
->dependencies
!= NULL
)
16314 htab_traverse (cu
->dependencies
, dwarf2_mark_helper
, NULL
);
16318 dwarf2_clear_marks (struct dwarf2_per_cu_data
*per_cu
)
16322 per_cu
->cu
->mark
= 0;
16323 per_cu
= per_cu
->cu
->read_in_chain
;
16327 /* Trivial hash function for partial_die_info: the hash value of a DIE
16328 is its offset in .debug_info for this objfile. */
16331 partial_die_hash (const void *item
)
16333 const struct partial_die_info
*part_die
= item
;
16335 return part_die
->offset
;
16338 /* Trivial comparison function for partial_die_info structures: two DIEs
16339 are equal if they have the same offset. */
16342 partial_die_eq (const void *item_lhs
, const void *item_rhs
)
16344 const struct partial_die_info
*part_die_lhs
= item_lhs
;
16345 const struct partial_die_info
*part_die_rhs
= item_rhs
;
16347 return part_die_lhs
->offset
== part_die_rhs
->offset
;
16350 static struct cmd_list_element
*set_dwarf2_cmdlist
;
16351 static struct cmd_list_element
*show_dwarf2_cmdlist
;
16354 set_dwarf2_cmd (char *args
, int from_tty
)
16356 help_list (set_dwarf2_cmdlist
, "maintenance set dwarf2 ", -1, gdb_stdout
);
16360 show_dwarf2_cmd (char *args
, int from_tty
)
16362 cmd_show_list (show_dwarf2_cmdlist
, from_tty
, "");
16365 /* If section described by INFO was mmapped, munmap it now. */
16368 munmap_section_buffer (struct dwarf2_section_info
*info
)
16370 if (info
->map_addr
!= NULL
)
16375 res
= munmap (info
->map_addr
, info
->map_len
);
16376 gdb_assert (res
== 0);
16378 /* Without HAVE_MMAP, we should never be here to begin with. */
16379 gdb_assert_not_reached ("no mmap support");
16384 /* munmap debug sections for OBJFILE, if necessary. */
16387 dwarf2_per_objfile_free (struct objfile
*objfile
, void *d
)
16389 struct dwarf2_per_objfile
*data
= d
;
16391 struct dwarf2_section_info
*section
;
16393 /* This is sorted according to the order they're defined in to make it easier
16394 to keep in sync. */
16395 munmap_section_buffer (&data
->info
);
16396 munmap_section_buffer (&data
->abbrev
);
16397 munmap_section_buffer (&data
->line
);
16398 munmap_section_buffer (&data
->loc
);
16399 munmap_section_buffer (&data
->macinfo
);
16400 munmap_section_buffer (&data
->macro
);
16401 munmap_section_buffer (&data
->str
);
16402 munmap_section_buffer (&data
->ranges
);
16403 munmap_section_buffer (&data
->frame
);
16404 munmap_section_buffer (&data
->eh_frame
);
16405 munmap_section_buffer (&data
->gdb_index
);
16408 VEC_iterate (dwarf2_section_info_def
, data
->types
, ix
, section
);
16410 munmap_section_buffer (section
);
16412 VEC_free (dwarf2_section_info_def
, data
->types
);
16416 /* The "save gdb-index" command. */
16418 /* The contents of the hash table we create when building the string
16420 struct strtab_entry
16422 offset_type offset
;
16426 /* Hash function for a strtab_entry.
16428 Function is used only during write_hash_table so no index format backward
16429 compatibility is needed. */
16432 hash_strtab_entry (const void *e
)
16434 const struct strtab_entry
*entry
= e
;
16435 return mapped_index_string_hash (INT_MAX
, entry
->str
);
16438 /* Equality function for a strtab_entry. */
16441 eq_strtab_entry (const void *a
, const void *b
)
16443 const struct strtab_entry
*ea
= a
;
16444 const struct strtab_entry
*eb
= b
;
16445 return !strcmp (ea
->str
, eb
->str
);
16448 /* Create a strtab_entry hash table. */
16451 create_strtab (void)
16453 return htab_create_alloc (100, hash_strtab_entry
, eq_strtab_entry
,
16454 xfree
, xcalloc
, xfree
);
16457 /* Add a string to the constant pool. Return the string's offset in
16461 add_string (htab_t table
, struct obstack
*cpool
, const char *str
)
16464 struct strtab_entry entry
;
16465 struct strtab_entry
*result
;
16468 slot
= htab_find_slot (table
, &entry
, INSERT
);
16473 result
= XNEW (struct strtab_entry
);
16474 result
->offset
= obstack_object_size (cpool
);
16476 obstack_grow_str0 (cpool
, str
);
16479 return result
->offset
;
16482 /* An entry in the symbol table. */
16483 struct symtab_index_entry
16485 /* The name of the symbol. */
16487 /* The offset of the name in the constant pool. */
16488 offset_type index_offset
;
16489 /* A sorted vector of the indices of all the CUs that hold an object
16491 VEC (offset_type
) *cu_indices
;
16494 /* The symbol table. This is a power-of-2-sized hash table. */
16495 struct mapped_symtab
16497 offset_type n_elements
;
16499 struct symtab_index_entry
**data
;
16502 /* Hash function for a symtab_index_entry. */
16505 hash_symtab_entry (const void *e
)
16507 const struct symtab_index_entry
*entry
= e
;
16508 return iterative_hash (VEC_address (offset_type
, entry
->cu_indices
),
16509 sizeof (offset_type
) * VEC_length (offset_type
,
16510 entry
->cu_indices
),
16514 /* Equality function for a symtab_index_entry. */
16517 eq_symtab_entry (const void *a
, const void *b
)
16519 const struct symtab_index_entry
*ea
= a
;
16520 const struct symtab_index_entry
*eb
= b
;
16521 int len
= VEC_length (offset_type
, ea
->cu_indices
);
16522 if (len
!= VEC_length (offset_type
, eb
->cu_indices
))
16524 return !memcmp (VEC_address (offset_type
, ea
->cu_indices
),
16525 VEC_address (offset_type
, eb
->cu_indices
),
16526 sizeof (offset_type
) * len
);
16529 /* Destroy a symtab_index_entry. */
16532 delete_symtab_entry (void *p
)
16534 struct symtab_index_entry
*entry
= p
;
16535 VEC_free (offset_type
, entry
->cu_indices
);
16539 /* Create a hash table holding symtab_index_entry objects. */
16542 create_symbol_hash_table (void)
16544 return htab_create_alloc (100, hash_symtab_entry
, eq_symtab_entry
,
16545 delete_symtab_entry
, xcalloc
, xfree
);
16548 /* Create a new mapped symtab object. */
16550 static struct mapped_symtab
*
16551 create_mapped_symtab (void)
16553 struct mapped_symtab
*symtab
= XNEW (struct mapped_symtab
);
16554 symtab
->n_elements
= 0;
16555 symtab
->size
= 1024;
16556 symtab
->data
= XCNEWVEC (struct symtab_index_entry
*, symtab
->size
);
16560 /* Destroy a mapped_symtab. */
16563 cleanup_mapped_symtab (void *p
)
16565 struct mapped_symtab
*symtab
= p
;
16566 /* The contents of the array are freed when the other hash table is
16568 xfree (symtab
->data
);
16572 /* Find a slot in SYMTAB for the symbol NAME. Returns a pointer to
16575 Function is used only during write_hash_table so no index format backward
16576 compatibility is needed. */
16578 static struct symtab_index_entry
**
16579 find_slot (struct mapped_symtab
*symtab
, const char *name
)
16581 offset_type index
, step
, hash
= mapped_index_string_hash (INT_MAX
, name
);
16583 index
= hash
& (symtab
->size
- 1);
16584 step
= ((hash
* 17) & (symtab
->size
- 1)) | 1;
16588 if (!symtab
->data
[index
] || !strcmp (name
, symtab
->data
[index
]->name
))
16589 return &symtab
->data
[index
];
16590 index
= (index
+ step
) & (symtab
->size
- 1);
16594 /* Expand SYMTAB's hash table. */
16597 hash_expand (struct mapped_symtab
*symtab
)
16599 offset_type old_size
= symtab
->size
;
16601 struct symtab_index_entry
**old_entries
= symtab
->data
;
16604 symtab
->data
= XCNEWVEC (struct symtab_index_entry
*, symtab
->size
);
16606 for (i
= 0; i
< old_size
; ++i
)
16608 if (old_entries
[i
])
16610 struct symtab_index_entry
**slot
= find_slot (symtab
,
16611 old_entries
[i
]->name
);
16612 *slot
= old_entries
[i
];
16616 xfree (old_entries
);
16619 /* Add an entry to SYMTAB. NAME is the name of the symbol. CU_INDEX
16620 is the index of the CU in which the symbol appears. */
16623 add_index_entry (struct mapped_symtab
*symtab
, const char *name
,
16624 offset_type cu_index
)
16626 struct symtab_index_entry
**slot
;
16628 ++symtab
->n_elements
;
16629 if (4 * symtab
->n_elements
/ 3 >= symtab
->size
)
16630 hash_expand (symtab
);
16632 slot
= find_slot (symtab
, name
);
16635 *slot
= XNEW (struct symtab_index_entry
);
16636 (*slot
)->name
= name
;
16637 (*slot
)->cu_indices
= NULL
;
16639 /* Don't push an index twice. Due to how we add entries we only
16640 have to check the last one. */
16641 if (VEC_empty (offset_type
, (*slot
)->cu_indices
)
16642 || VEC_last (offset_type
, (*slot
)->cu_indices
) != cu_index
)
16643 VEC_safe_push (offset_type
, (*slot
)->cu_indices
, cu_index
);
16646 /* Add a vector of indices to the constant pool. */
16649 add_indices_to_cpool (htab_t symbol_hash_table
, struct obstack
*cpool
,
16650 struct symtab_index_entry
*entry
)
16654 slot
= htab_find_slot (symbol_hash_table
, entry
, INSERT
);
16657 offset_type len
= VEC_length (offset_type
, entry
->cu_indices
);
16658 offset_type val
= MAYBE_SWAP (len
);
16663 entry
->index_offset
= obstack_object_size (cpool
);
16665 obstack_grow (cpool
, &val
, sizeof (val
));
16667 VEC_iterate (offset_type
, entry
->cu_indices
, i
, iter
);
16670 val
= MAYBE_SWAP (iter
);
16671 obstack_grow (cpool
, &val
, sizeof (val
));
16676 struct symtab_index_entry
*old_entry
= *slot
;
16677 entry
->index_offset
= old_entry
->index_offset
;
16680 return entry
->index_offset
;
16683 /* Write the mapped hash table SYMTAB to the obstack OUTPUT, with
16684 constant pool entries going into the obstack CPOOL. */
16687 write_hash_table (struct mapped_symtab
*symtab
,
16688 struct obstack
*output
, struct obstack
*cpool
)
16691 htab_t symbol_hash_table
;
16694 symbol_hash_table
= create_symbol_hash_table ();
16695 str_table
= create_strtab ();
16697 /* We add all the index vectors to the constant pool first, to
16698 ensure alignment is ok. */
16699 for (i
= 0; i
< symtab
->size
; ++i
)
16701 if (symtab
->data
[i
])
16702 add_indices_to_cpool (symbol_hash_table
, cpool
, symtab
->data
[i
]);
16705 /* Now write out the hash table. */
16706 for (i
= 0; i
< symtab
->size
; ++i
)
16708 offset_type str_off
, vec_off
;
16710 if (symtab
->data
[i
])
16712 str_off
= add_string (str_table
, cpool
, symtab
->data
[i
]->name
);
16713 vec_off
= symtab
->data
[i
]->index_offset
;
16717 /* While 0 is a valid constant pool index, it is not valid
16718 to have 0 for both offsets. */
16723 str_off
= MAYBE_SWAP (str_off
);
16724 vec_off
= MAYBE_SWAP (vec_off
);
16726 obstack_grow (output
, &str_off
, sizeof (str_off
));
16727 obstack_grow (output
, &vec_off
, sizeof (vec_off
));
16730 htab_delete (str_table
);
16731 htab_delete (symbol_hash_table
);
16734 /* Struct to map psymtab to CU index in the index file. */
16735 struct psymtab_cu_index_map
16737 struct partial_symtab
*psymtab
;
16738 unsigned int cu_index
;
16742 hash_psymtab_cu_index (const void *item
)
16744 const struct psymtab_cu_index_map
*map
= item
;
16746 return htab_hash_pointer (map
->psymtab
);
16750 eq_psymtab_cu_index (const void *item_lhs
, const void *item_rhs
)
16752 const struct psymtab_cu_index_map
*lhs
= item_lhs
;
16753 const struct psymtab_cu_index_map
*rhs
= item_rhs
;
16755 return lhs
->psymtab
== rhs
->psymtab
;
16758 /* Helper struct for building the address table. */
16759 struct addrmap_index_data
16761 struct objfile
*objfile
;
16762 struct obstack
*addr_obstack
;
16763 htab_t cu_index_htab
;
16765 /* Non-zero if the previous_* fields are valid.
16766 We can't write an entry until we see the next entry (since it is only then
16767 that we know the end of the entry). */
16768 int previous_valid
;
16769 /* Index of the CU in the table of all CUs in the index file. */
16770 unsigned int previous_cu_index
;
16771 /* Start address of the CU. */
16772 CORE_ADDR previous_cu_start
;
16775 /* Write an address entry to OBSTACK. */
16778 add_address_entry (struct objfile
*objfile
, struct obstack
*obstack
,
16779 CORE_ADDR start
, CORE_ADDR end
, unsigned int cu_index
)
16781 offset_type cu_index_to_write
;
16783 CORE_ADDR baseaddr
;
16785 baseaddr
= ANOFFSET (objfile
->section_offsets
, SECT_OFF_TEXT (objfile
));
16787 store_unsigned_integer (addr
, 8, BFD_ENDIAN_LITTLE
, start
- baseaddr
);
16788 obstack_grow (obstack
, addr
, 8);
16789 store_unsigned_integer (addr
, 8, BFD_ENDIAN_LITTLE
, end
- baseaddr
);
16790 obstack_grow (obstack
, addr
, 8);
16791 cu_index_to_write
= MAYBE_SWAP (cu_index
);
16792 obstack_grow (obstack
, &cu_index_to_write
, sizeof (offset_type
));
16795 /* Worker function for traversing an addrmap to build the address table. */
16798 add_address_entry_worker (void *datap
, CORE_ADDR start_addr
, void *obj
)
16800 struct addrmap_index_data
*data
= datap
;
16801 struct partial_symtab
*pst
= obj
;
16802 offset_type cu_index
;
16805 if (data
->previous_valid
)
16806 add_address_entry (data
->objfile
, data
->addr_obstack
,
16807 data
->previous_cu_start
, start_addr
,
16808 data
->previous_cu_index
);
16810 data
->previous_cu_start
= start_addr
;
16813 struct psymtab_cu_index_map find_map
, *map
;
16814 find_map
.psymtab
= pst
;
16815 map
= htab_find (data
->cu_index_htab
, &find_map
);
16816 gdb_assert (map
!= NULL
);
16817 data
->previous_cu_index
= map
->cu_index
;
16818 data
->previous_valid
= 1;
16821 data
->previous_valid
= 0;
16826 /* Write OBJFILE's address map to OBSTACK.
16827 CU_INDEX_HTAB is used to map addrmap entries to their CU indices
16828 in the index file. */
16831 write_address_map (struct objfile
*objfile
, struct obstack
*obstack
,
16832 htab_t cu_index_htab
)
16834 struct addrmap_index_data addrmap_index_data
;
16836 /* When writing the address table, we have to cope with the fact that
16837 the addrmap iterator only provides the start of a region; we have to
16838 wait until the next invocation to get the start of the next region. */
16840 addrmap_index_data
.objfile
= objfile
;
16841 addrmap_index_data
.addr_obstack
= obstack
;
16842 addrmap_index_data
.cu_index_htab
= cu_index_htab
;
16843 addrmap_index_data
.previous_valid
= 0;
16845 addrmap_foreach (objfile
->psymtabs_addrmap
, add_address_entry_worker
,
16846 &addrmap_index_data
);
16848 /* It's highly unlikely the last entry (end address = 0xff...ff)
16849 is valid, but we should still handle it.
16850 The end address is recorded as the start of the next region, but that
16851 doesn't work here. To cope we pass 0xff...ff, this is a rare situation
16853 if (addrmap_index_data
.previous_valid
)
16854 add_address_entry (objfile
, obstack
,
16855 addrmap_index_data
.previous_cu_start
, (CORE_ADDR
) -1,
16856 addrmap_index_data
.previous_cu_index
);
16859 /* Add a list of partial symbols to SYMTAB. */
16862 write_psymbols (struct mapped_symtab
*symtab
,
16864 struct partial_symbol
**psymp
,
16866 offset_type cu_index
,
16869 for (; count
-- > 0; ++psymp
)
16871 void **slot
, *lookup
;
16873 if (SYMBOL_LANGUAGE (*psymp
) == language_ada
)
16874 error (_("Ada is not currently supported by the index"));
16876 /* We only want to add a given psymbol once. However, we also
16877 want to account for whether it is global or static. So, we
16878 may add it twice, using slightly different values. */
16881 uintptr_t val
= 1 | (uintptr_t) *psymp
;
16883 lookup
= (void *) val
;
16888 /* Only add a given psymbol once. */
16889 slot
= htab_find_slot (psyms_seen
, lookup
, INSERT
);
16893 add_index_entry (symtab
, SYMBOL_NATURAL_NAME (*psymp
), cu_index
);
16898 /* Write the contents of an ("unfinished") obstack to FILE. Throw an
16899 exception if there is an error. */
16902 write_obstack (FILE *file
, struct obstack
*obstack
)
16904 if (fwrite (obstack_base (obstack
), 1, obstack_object_size (obstack
),
16906 != obstack_object_size (obstack
))
16907 error (_("couldn't data write to file"));
16910 /* Unlink a file if the argument is not NULL. */
16913 unlink_if_set (void *p
)
16915 char **filename
= p
;
16917 unlink (*filename
);
16920 /* A helper struct used when iterating over debug_types. */
16921 struct signatured_type_index_data
16923 struct objfile
*objfile
;
16924 struct mapped_symtab
*symtab
;
16925 struct obstack
*types_list
;
16930 /* A helper function that writes a single signatured_type to an
16934 write_one_signatured_type (void **slot
, void *d
)
16936 struct signatured_type_index_data
*info
= d
;
16937 struct signatured_type
*entry
= (struct signatured_type
*) *slot
;
16938 struct dwarf2_per_cu_data
*per_cu
= &entry
->per_cu
;
16939 struct partial_symtab
*psymtab
= per_cu
->v
.psymtab
;
16942 write_psymbols (info
->symtab
,
16944 info
->objfile
->global_psymbols
.list
16945 + psymtab
->globals_offset
,
16946 psymtab
->n_global_syms
, info
->cu_index
,
16948 write_psymbols (info
->symtab
,
16950 info
->objfile
->static_psymbols
.list
16951 + psymtab
->statics_offset
,
16952 psymtab
->n_static_syms
, info
->cu_index
,
16955 store_unsigned_integer (val
, 8, BFD_ENDIAN_LITTLE
, entry
->per_cu
.offset
);
16956 obstack_grow (info
->types_list
, val
, 8);
16957 store_unsigned_integer (val
, 8, BFD_ENDIAN_LITTLE
, entry
->type_offset
);
16958 obstack_grow (info
->types_list
, val
, 8);
16959 store_unsigned_integer (val
, 8, BFD_ENDIAN_LITTLE
, entry
->signature
);
16960 obstack_grow (info
->types_list
, val
, 8);
16967 /* Create an index file for OBJFILE in the directory DIR. */
16970 write_psymtabs_to_index (struct objfile
*objfile
, const char *dir
)
16972 struct cleanup
*cleanup
;
16973 char *filename
, *cleanup_filename
;
16974 struct obstack contents
, addr_obstack
, constant_pool
, symtab_obstack
;
16975 struct obstack cu_list
, types_cu_list
;
16978 struct mapped_symtab
*symtab
;
16979 offset_type val
, size_of_contents
, total_len
;
16983 htab_t cu_index_htab
;
16984 struct psymtab_cu_index_map
*psymtab_cu_index_map
;
16986 if (!objfile
->psymtabs
|| !objfile
->psymtabs_addrmap
)
16989 if (dwarf2_per_objfile
->using_index
)
16990 error (_("Cannot use an index to create the index"));
16992 if (VEC_length (dwarf2_section_info_def
, dwarf2_per_objfile
->types
) > 1)
16993 error (_("Cannot make an index when the file has multiple .debug_types sections"));
16995 if (stat (objfile
->name
, &st
) < 0)
16996 perror_with_name (objfile
->name
);
16998 filename
= concat (dir
, SLASH_STRING
, lbasename (objfile
->name
),
16999 INDEX_SUFFIX
, (char *) NULL
);
17000 cleanup
= make_cleanup (xfree
, filename
);
17002 out_file
= fopen (filename
, "wb");
17004 error (_("Can't open `%s' for writing"), filename
);
17006 cleanup_filename
= filename
;
17007 make_cleanup (unlink_if_set
, &cleanup_filename
);
17009 symtab
= create_mapped_symtab ();
17010 make_cleanup (cleanup_mapped_symtab
, symtab
);
17012 obstack_init (&addr_obstack
);
17013 make_cleanup_obstack_free (&addr_obstack
);
17015 obstack_init (&cu_list
);
17016 make_cleanup_obstack_free (&cu_list
);
17018 obstack_init (&types_cu_list
);
17019 make_cleanup_obstack_free (&types_cu_list
);
17021 psyms_seen
= htab_create_alloc (100, htab_hash_pointer
, htab_eq_pointer
,
17022 NULL
, xcalloc
, xfree
);
17023 make_cleanup_htab_delete (psyms_seen
);
17025 /* While we're scanning CU's create a table that maps a psymtab pointer
17026 (which is what addrmap records) to its index (which is what is recorded
17027 in the index file). This will later be needed to write the address
17029 cu_index_htab
= htab_create_alloc (100,
17030 hash_psymtab_cu_index
,
17031 eq_psymtab_cu_index
,
17032 NULL
, xcalloc
, xfree
);
17033 make_cleanup_htab_delete (cu_index_htab
);
17034 psymtab_cu_index_map
= (struct psymtab_cu_index_map
*)
17035 xmalloc (sizeof (struct psymtab_cu_index_map
)
17036 * dwarf2_per_objfile
->n_comp_units
);
17037 make_cleanup (xfree
, psymtab_cu_index_map
);
17039 /* The CU list is already sorted, so we don't need to do additional
17040 work here. Also, the debug_types entries do not appear in
17041 all_comp_units, but only in their own hash table. */
17042 for (i
= 0; i
< dwarf2_per_objfile
->n_comp_units
; ++i
)
17044 struct dwarf2_per_cu_data
*per_cu
17045 = dwarf2_per_objfile
->all_comp_units
[i
];
17046 struct partial_symtab
*psymtab
= per_cu
->v
.psymtab
;
17048 struct psymtab_cu_index_map
*map
;
17051 write_psymbols (symtab
,
17053 objfile
->global_psymbols
.list
+ psymtab
->globals_offset
,
17054 psymtab
->n_global_syms
, i
,
17056 write_psymbols (symtab
,
17058 objfile
->static_psymbols
.list
+ psymtab
->statics_offset
,
17059 psymtab
->n_static_syms
, i
,
17062 map
= &psymtab_cu_index_map
[i
];
17063 map
->psymtab
= psymtab
;
17065 slot
= htab_find_slot (cu_index_htab
, map
, INSERT
);
17066 gdb_assert (slot
!= NULL
);
17067 gdb_assert (*slot
== NULL
);
17070 store_unsigned_integer (val
, 8, BFD_ENDIAN_LITTLE
, per_cu
->offset
);
17071 obstack_grow (&cu_list
, val
, 8);
17072 store_unsigned_integer (val
, 8, BFD_ENDIAN_LITTLE
, per_cu
->length
);
17073 obstack_grow (&cu_list
, val
, 8);
17076 /* Dump the address map. */
17077 write_address_map (objfile
, &addr_obstack
, cu_index_htab
);
17079 /* Write out the .debug_type entries, if any. */
17080 if (dwarf2_per_objfile
->signatured_types
)
17082 struct signatured_type_index_data sig_data
;
17084 sig_data
.objfile
= objfile
;
17085 sig_data
.symtab
= symtab
;
17086 sig_data
.types_list
= &types_cu_list
;
17087 sig_data
.psyms_seen
= psyms_seen
;
17088 sig_data
.cu_index
= dwarf2_per_objfile
->n_comp_units
;
17089 htab_traverse_noresize (dwarf2_per_objfile
->signatured_types
,
17090 write_one_signatured_type
, &sig_data
);
17093 obstack_init (&constant_pool
);
17094 make_cleanup_obstack_free (&constant_pool
);
17095 obstack_init (&symtab_obstack
);
17096 make_cleanup_obstack_free (&symtab_obstack
);
17097 write_hash_table (symtab
, &symtab_obstack
, &constant_pool
);
17099 obstack_init (&contents
);
17100 make_cleanup_obstack_free (&contents
);
17101 size_of_contents
= 6 * sizeof (offset_type
);
17102 total_len
= size_of_contents
;
17104 /* The version number. */
17105 val
= MAYBE_SWAP (5);
17106 obstack_grow (&contents
, &val
, sizeof (val
));
17108 /* The offset of the CU list from the start of the file. */
17109 val
= MAYBE_SWAP (total_len
);
17110 obstack_grow (&contents
, &val
, sizeof (val
));
17111 total_len
+= obstack_object_size (&cu_list
);
17113 /* The offset of the types CU list from the start of the file. */
17114 val
= MAYBE_SWAP (total_len
);
17115 obstack_grow (&contents
, &val
, sizeof (val
));
17116 total_len
+= obstack_object_size (&types_cu_list
);
17118 /* The offset of the address table from the start of the file. */
17119 val
= MAYBE_SWAP (total_len
);
17120 obstack_grow (&contents
, &val
, sizeof (val
));
17121 total_len
+= obstack_object_size (&addr_obstack
);
17123 /* The offset of the symbol table from the start of the file. */
17124 val
= MAYBE_SWAP (total_len
);
17125 obstack_grow (&contents
, &val
, sizeof (val
));
17126 total_len
+= obstack_object_size (&symtab_obstack
);
17128 /* The offset of the constant pool from the start of the file. */
17129 val
= MAYBE_SWAP (total_len
);
17130 obstack_grow (&contents
, &val
, sizeof (val
));
17131 total_len
+= obstack_object_size (&constant_pool
);
17133 gdb_assert (obstack_object_size (&contents
) == size_of_contents
);
17135 write_obstack (out_file
, &contents
);
17136 write_obstack (out_file
, &cu_list
);
17137 write_obstack (out_file
, &types_cu_list
);
17138 write_obstack (out_file
, &addr_obstack
);
17139 write_obstack (out_file
, &symtab_obstack
);
17140 write_obstack (out_file
, &constant_pool
);
17144 /* We want to keep the file, so we set cleanup_filename to NULL
17145 here. See unlink_if_set. */
17146 cleanup_filename
= NULL
;
17148 do_cleanups (cleanup
);
17151 /* Implementation of the `save gdb-index' command.
17153 Note that the file format used by this command is documented in the
17154 GDB manual. Any changes here must be documented there. */
17157 save_gdb_index_command (char *arg
, int from_tty
)
17159 struct objfile
*objfile
;
17162 error (_("usage: save gdb-index DIRECTORY"));
17164 ALL_OBJFILES (objfile
)
17168 /* If the objfile does not correspond to an actual file, skip it. */
17169 if (stat (objfile
->name
, &st
) < 0)
17172 dwarf2_per_objfile
= objfile_data (objfile
, dwarf2_objfile_data_key
);
17173 if (dwarf2_per_objfile
)
17175 volatile struct gdb_exception except
;
17177 TRY_CATCH (except
, RETURN_MASK_ERROR
)
17179 write_psymtabs_to_index (objfile
, arg
);
17181 if (except
.reason
< 0)
17182 exception_fprintf (gdb_stderr
, except
,
17183 _("Error while writing index for `%s': "),
17191 int dwarf2_always_disassemble
;
17194 show_dwarf2_always_disassemble (struct ui_file
*file
, int from_tty
,
17195 struct cmd_list_element
*c
, const char *value
)
17197 fprintf_filtered (file
,
17198 _("Whether to always disassemble "
17199 "DWARF expressions is %s.\n"),
17204 show_check_physname (struct ui_file
*file
, int from_tty
,
17205 struct cmd_list_element
*c
, const char *value
)
17207 fprintf_filtered (file
,
17208 _("Whether to check \"physname\" is %s.\n"),
17212 void _initialize_dwarf2_read (void);
17215 _initialize_dwarf2_read (void)
17217 struct cmd_list_element
*c
;
17219 dwarf2_objfile_data_key
17220 = register_objfile_data_with_cleanup (NULL
, dwarf2_per_objfile_free
);
17222 add_prefix_cmd ("dwarf2", class_maintenance
, set_dwarf2_cmd
, _("\
17223 Set DWARF 2 specific variables.\n\
17224 Configure DWARF 2 variables such as the cache size"),
17225 &set_dwarf2_cmdlist
, "maintenance set dwarf2 ",
17226 0/*allow-unknown*/, &maintenance_set_cmdlist
);
17228 add_prefix_cmd ("dwarf2", class_maintenance
, show_dwarf2_cmd
, _("\
17229 Show DWARF 2 specific variables\n\
17230 Show DWARF 2 variables such as the cache size"),
17231 &show_dwarf2_cmdlist
, "maintenance show dwarf2 ",
17232 0/*allow-unknown*/, &maintenance_show_cmdlist
);
17234 add_setshow_zinteger_cmd ("max-cache-age", class_obscure
,
17235 &dwarf2_max_cache_age
, _("\
17236 Set the upper bound on the age of cached dwarf2 compilation units."), _("\
17237 Show the upper bound on the age of cached dwarf2 compilation units."), _("\
17238 A higher limit means that cached compilation units will be stored\n\
17239 in memory longer, and more total memory will be used. Zero disables\n\
17240 caching, which can slow down startup."),
17242 show_dwarf2_max_cache_age
,
17243 &set_dwarf2_cmdlist
,
17244 &show_dwarf2_cmdlist
);
17246 add_setshow_boolean_cmd ("always-disassemble", class_obscure
,
17247 &dwarf2_always_disassemble
, _("\
17248 Set whether `info address' always disassembles DWARF expressions."), _("\
17249 Show whether `info address' always disassembles DWARF expressions."), _("\
17250 When enabled, DWARF expressions are always printed in an assembly-like\n\
17251 syntax. When disabled, expressions will be printed in a more\n\
17252 conversational style, when possible."),
17254 show_dwarf2_always_disassemble
,
17255 &set_dwarf2_cmdlist
,
17256 &show_dwarf2_cmdlist
);
17258 add_setshow_zinteger_cmd ("dwarf2-die", no_class
, &dwarf2_die_debug
, _("\
17259 Set debugging of the dwarf2 DIE reader."), _("\
17260 Show debugging of the dwarf2 DIE reader."), _("\
17261 When enabled (non-zero), DIEs are dumped after they are read in.\n\
17262 The value is the maximum depth to print."),
17265 &setdebuglist
, &showdebuglist
);
17267 add_setshow_boolean_cmd ("check-physname", no_class
, &check_physname
, _("\
17268 Set cross-checking of \"physname\" code against demangler."), _("\
17269 Show cross-checking of \"physname\" code against demangler."), _("\
17270 When enabled, GDB's internal \"physname\" code is checked against\n\
17272 NULL
, show_check_physname
,
17273 &setdebuglist
, &showdebuglist
);
17275 c
= add_cmd ("gdb-index", class_files
, save_gdb_index_command
,
17277 Save a gdb-index file.\n\
17278 Usage: save gdb-index DIRECTORY"),
17280 set_cmd_completer (c
, filename_completer
);