1 /* DWARF 2 debugging format support for GDB.
3 Copyright (C) 1994-2012 Free Software Foundation, Inc.
5 Adapted by Gary Funck (gary@intrepid.com), Intrepid Technology,
6 Inc. with support from Florida State University (under contract
7 with the Ada Joint Program Office), and Silicon Graphics, Inc.
8 Initial contribution by Brent Benson, Harris Computer Systems, Inc.,
9 based on Fred Fish's (Cygnus Support) implementation of DWARF 1
12 This file is part of GDB.
14 This program is free software; you can redistribute it and/or modify
15 it under the terms of the GNU General Public License as published by
16 the Free Software Foundation; either version 3 of the License, or
17 (at your option) any later version.
19 This program is distributed in the hope that it will be useful,
20 but WITHOUT ANY WARRANTY; without even the implied warranty of
21 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
22 GNU General Public License for more details.
24 You should have received a copy of the GNU General Public License
25 along with this program. If not, see <http://www.gnu.org/licenses/>. */
35 #include "gdb-demangle.h"
36 #include "expression.h"
37 #include "filenames.h" /* for DOSish file names */
40 #include "complaints.h"
42 #include "dwarf2expr.h"
43 #include "dwarf2loc.h"
44 #include "cp-support.h"
50 #include "typeprint.h"
53 #include "exceptions.h"
55 #include "completer.h"
62 #include "gdb_string.h"
63 #include "gdb_assert.h"
64 #include <sys/types.h>
71 #define MAP_FAILED ((void *) -1)
75 typedef struct symbol
*symbolp
;
79 /* .debug_info header for a compilation unit
80 Because of alignment constraints, this structure has padding and cannot
81 be mapped directly onto the beginning of the .debug_info section. */
82 typedef struct comp_unit_header
84 unsigned int length
; /* length of the .debug_info
86 unsigned short version
; /* version number -- 2 for DWARF
88 unsigned int abbrev_offset
; /* offset into .debug_abbrev section */
89 unsigned char addr_size
; /* byte size of an address -- 4 */
92 #define _ACTUAL_COMP_UNIT_HEADER_SIZE 11
95 /* .debug_line statement program prologue
96 Because of alignment constraints, this structure has padding and cannot
97 be mapped directly onto the beginning of the .debug_info section. */
98 typedef struct statement_prologue
100 unsigned int total_length
; /* byte length of the statement
102 unsigned short version
; /* version number -- 2 for DWARF
104 unsigned int prologue_length
; /* # bytes between prologue &
106 unsigned char minimum_instruction_length
; /* byte size of
108 unsigned char default_is_stmt
; /* initial value of is_stmt
111 unsigned char line_range
;
112 unsigned char opcode_base
; /* number assigned to first special
114 unsigned char *standard_opcode_lengths
;
118 /* When non-zero, dump DIEs after they are read in. */
119 static int dwarf2_die_debug
= 0;
121 /* When non-zero, cross-check physname against demangler. */
122 static int check_physname
= 0;
126 /* When set, the file that we're processing is known to have debugging
127 info for C++ namespaces. GCC 3.3.x did not produce this information,
128 but later versions do. */
130 static int processing_has_namespace_info
;
132 static const struct objfile_data
*dwarf2_objfile_data_key
;
134 struct dwarf2_section_info
139 /* Not NULL if the section was actually mmapped. */
141 /* Page aligned size of mmapped area. */
142 bfd_size_type map_len
;
143 /* True if we have tried to read this section. */
147 typedef struct dwarf2_section_info dwarf2_section_info_def
;
148 DEF_VEC_O (dwarf2_section_info_def
);
150 /* All offsets in the index are of this type. It must be
151 architecture-independent. */
152 typedef uint32_t offset_type
;
154 DEF_VEC_I (offset_type
);
156 /* A description of the mapped index. The file format is described in
157 a comment by the code that writes the index. */
160 /* Index data format version. */
163 /* The total length of the buffer. */
166 /* A pointer to the address table data. */
167 const gdb_byte
*address_table
;
169 /* Size of the address table data in bytes. */
170 offset_type address_table_size
;
172 /* The symbol table, implemented as a hash table. */
173 const offset_type
*symbol_table
;
175 /* Size in slots, each slot is 2 offset_types. */
176 offset_type symbol_table_slots
;
178 /* A pointer to the constant pool. */
179 const char *constant_pool
;
182 /* Collection of data recorded per objfile.
183 This hangs off of dwarf2_objfile_data_key. */
185 struct dwarf2_per_objfile
187 struct dwarf2_section_info info
;
188 struct dwarf2_section_info abbrev
;
189 struct dwarf2_section_info line
;
190 struct dwarf2_section_info loc
;
191 struct dwarf2_section_info macinfo
;
192 struct dwarf2_section_info macro
;
193 struct dwarf2_section_info str
;
194 struct dwarf2_section_info ranges
;
195 struct dwarf2_section_info frame
;
196 struct dwarf2_section_info eh_frame
;
197 struct dwarf2_section_info gdb_index
;
199 VEC (dwarf2_section_info_def
) *types
;
202 struct objfile
*objfile
;
204 /* A list of all the compilation units. This is used to locate
205 the target compilation unit of a particular reference. */
206 struct dwarf2_per_cu_data
**all_comp_units
;
208 /* The number of compilation units in ALL_COMP_UNITS. */
211 /* The number of .debug_types-related CUs. */
212 int n_type_comp_units
;
214 /* The .debug_types-related CUs. */
215 struct dwarf2_per_cu_data
**type_comp_units
;
217 /* A chain of compilation units that are currently read in, so that
218 they can be freed later. */
219 struct dwarf2_per_cu_data
*read_in_chain
;
221 /* A table mapping .debug_types signatures to its signatured_type entry.
222 This is NULL if the .debug_types section hasn't been read in yet. */
223 htab_t signatured_types
;
225 /* A flag indicating wether this objfile has a section loaded at a
227 int has_section_at_zero
;
229 /* True if we are using the mapped index,
230 or we are faking it for OBJF_READNOW's sake. */
231 unsigned char using_index
;
233 /* The mapped index, or NULL if .gdb_index is missing or not being used. */
234 struct mapped_index
*index_table
;
236 /* When using index_table, this keeps track of all quick_file_names entries.
237 TUs can share line table entries with CUs or other TUs, and there can be
238 a lot more TUs than unique line tables, so we maintain a separate table
239 of all line table entries to support the sharing. */
240 htab_t quick_file_names_table
;
242 /* Set during partial symbol reading, to prevent queueing of full
244 int reading_partial_symbols
;
246 /* Table mapping type .debug_info DIE offsets to types.
247 This is NULL if not allocated yet.
248 It (currently) makes sense to allocate debug_types_type_hash lazily.
249 To keep things simple we allocate both lazily. */
250 htab_t debug_info_type_hash
;
252 /* Table mapping type .debug_types DIE offsets to types.
253 This is NULL if not allocated yet. */
254 htab_t debug_types_type_hash
;
257 static struct dwarf2_per_objfile
*dwarf2_per_objfile
;
259 /* Default names of the debugging sections. */
261 /* Note that if the debugging section has been compressed, it might
262 have a name like .zdebug_info. */
264 static const struct dwarf2_debug_sections dwarf2_elf_names
=
266 { ".debug_info", ".zdebug_info" },
267 { ".debug_abbrev", ".zdebug_abbrev" },
268 { ".debug_line", ".zdebug_line" },
269 { ".debug_loc", ".zdebug_loc" },
270 { ".debug_macinfo", ".zdebug_macinfo" },
271 { ".debug_macro", ".zdebug_macro" },
272 { ".debug_str", ".zdebug_str" },
273 { ".debug_ranges", ".zdebug_ranges" },
274 { ".debug_types", ".zdebug_types" },
275 { ".debug_frame", ".zdebug_frame" },
276 { ".eh_frame", NULL
},
277 { ".gdb_index", ".zgdb_index" },
281 /* local data types */
283 /* We hold several abbreviation tables in memory at the same time. */
284 #ifndef ABBREV_HASH_SIZE
285 #define ABBREV_HASH_SIZE 121
288 /* The data in a compilation unit header, after target2host
289 translation, looks like this. */
290 struct comp_unit_head
294 unsigned char addr_size
;
295 unsigned char signed_addr_p
;
296 unsigned int abbrev_offset
;
298 /* Size of file offsets; either 4 or 8. */
299 unsigned int offset_size
;
301 /* Size of the length field; either 4 or 12. */
302 unsigned int initial_length_size
;
304 /* Offset to the first byte of this compilation unit header in the
305 .debug_info section, for resolving relative reference dies. */
308 /* Offset to first die in this cu from the start of the cu.
309 This will be the first byte following the compilation unit header. */
310 unsigned int first_die_offset
;
313 /* Type used for delaying computation of method physnames.
314 See comments for compute_delayed_physnames. */
315 struct delayed_method_info
317 /* The type to which the method is attached, i.e., its parent class. */
320 /* The index of the method in the type's function fieldlists. */
323 /* The index of the method in the fieldlist. */
326 /* The name of the DIE. */
329 /* The DIE associated with this method. */
330 struct die_info
*die
;
333 typedef struct delayed_method_info delayed_method_info
;
334 DEF_VEC_O (delayed_method_info
);
336 /* Internal state when decoding a particular compilation unit. */
339 /* The objfile containing this compilation unit. */
340 struct objfile
*objfile
;
342 /* The header of the compilation unit. */
343 struct comp_unit_head header
;
345 /* Base address of this compilation unit. */
346 CORE_ADDR base_address
;
348 /* Non-zero if base_address has been set. */
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. */
431 unsigned int has_loclist
: 1;
434 /* Persistent data held for a compilation unit, even when not
435 processing it. We put a pointer to this structure in the
436 read_symtab_private field of the psymtab. */
438 struct dwarf2_per_cu_data
440 /* The start offset and length of this compilation unit. 2**29-1
441 bytes should suffice to store the length of any compilation unit
442 - if it doesn't, GDB will fall over anyway.
443 NOTE: Unlike comp_unit_head.length, this length includes
444 initial_length_size. */
446 unsigned int length
: 29;
448 /* Flag indicating this compilation unit will be read in before
449 any of the current compilation units are processed. */
450 unsigned int queued
: 1;
452 /* This flag will be set if we need to load absolutely all DIEs
453 for this compilation unit, instead of just the ones we think
454 are interesting. It gets set if we look for a DIE in the
455 hash table and don't find it. */
456 unsigned int load_all_dies
: 1;
458 /* Non-null if this CU is from .debug_types; in which case it points
459 to the section. Otherwise it's from .debug_info. */
460 struct dwarf2_section_info
*debug_types_section
;
462 /* Set to non-NULL iff this CU is currently loaded. When it gets freed out
463 of the CU cache it gets reset to NULL again. */
464 struct dwarf2_cu
*cu
;
466 /* The corresponding objfile.
467 Normally we can get the objfile from dwarf2_per_objfile.
468 However we can enter this file with just a "per_cu" handle. */
469 struct objfile
*objfile
;
471 /* When using partial symbol tables, the 'psymtab' field is active.
472 Otherwise the 'quick' field is active. */
475 /* The partial symbol table associated with this compilation unit,
476 or NULL for partial units (which do not have an associated
478 struct partial_symtab
*psymtab
;
480 /* Data needed by the "quick" functions. */
481 struct dwarf2_per_cu_quick_data
*quick
;
485 /* Entry in the signatured_types hash table. */
487 struct signatured_type
491 /* Offset in .debug_types of the type defined by this TU. */
492 unsigned int type_offset
;
494 /* The CU(/TU) of this type. */
495 struct dwarf2_per_cu_data per_cu
;
498 /* Struct used to pass misc. parameters to read_die_and_children, et
499 al. which are used for both .debug_info and .debug_types dies.
500 All parameters here are unchanging for the life of the call. This
501 struct exists to abstract away the constant parameters of die
504 struct die_reader_specs
506 /* The bfd of this objfile. */
509 /* The CU of the DIE we are parsing. */
510 struct dwarf2_cu
*cu
;
512 /* Pointer to start of section buffer.
513 This is either the start of .debug_info or .debug_types. */
514 const gdb_byte
*buffer
;
517 /* The line number information for a compilation unit (found in the
518 .debug_line section) begins with a "statement program header",
519 which contains the following information. */
522 unsigned int total_length
;
523 unsigned short version
;
524 unsigned int header_length
;
525 unsigned char minimum_instruction_length
;
526 unsigned char maximum_ops_per_instruction
;
527 unsigned char default_is_stmt
;
529 unsigned char line_range
;
530 unsigned char opcode_base
;
532 /* standard_opcode_lengths[i] is the number of operands for the
533 standard opcode whose value is i. This means that
534 standard_opcode_lengths[0] is unused, and the last meaningful
535 element is standard_opcode_lengths[opcode_base - 1]. */
536 unsigned char *standard_opcode_lengths
;
538 /* The include_directories table. NOTE! These strings are not
539 allocated with xmalloc; instead, they are pointers into
540 debug_line_buffer. If you try to free them, `free' will get
542 unsigned int num_include_dirs
, include_dirs_size
;
545 /* The file_names table. NOTE! These strings are not allocated
546 with xmalloc; instead, they are pointers into debug_line_buffer.
547 Don't try to free them directly. */
548 unsigned int num_file_names
, file_names_size
;
552 unsigned int dir_index
;
553 unsigned int mod_time
;
555 int included_p
; /* Non-zero if referenced by the Line Number Program. */
556 struct symtab
*symtab
; /* The associated symbol table, if any. */
559 /* The start and end of the statement program following this
560 header. These point into dwarf2_per_objfile->line_buffer. */
561 gdb_byte
*statement_program_start
, *statement_program_end
;
564 /* When we construct a partial symbol table entry we only
565 need this much information. */
566 struct partial_die_info
568 /* Offset of this DIE. */
571 /* DWARF-2 tag for this DIE. */
572 ENUM_BITFIELD(dwarf_tag
) tag
: 16;
574 /* Assorted flags describing the data found in this DIE. */
575 unsigned int has_children
: 1;
576 unsigned int is_external
: 1;
577 unsigned int is_declaration
: 1;
578 unsigned int has_type
: 1;
579 unsigned int has_specification
: 1;
580 unsigned int has_pc_info
: 1;
582 /* Flag set if the SCOPE field of this structure has been
584 unsigned int scope_set
: 1;
586 /* Flag set if the DIE has a byte_size attribute. */
587 unsigned int has_byte_size
: 1;
589 /* Flag set if any of the DIE's children are template arguments. */
590 unsigned int has_template_arguments
: 1;
592 /* Flag set if fixup_partial_die has been called on this die. */
593 unsigned int fixup_called
: 1;
595 /* The name of this DIE. Normally the value of DW_AT_name, but
596 sometimes a default name for unnamed DIEs. */
599 /* The linkage name, if present. */
600 const char *linkage_name
;
602 /* The scope to prepend to our children. This is generally
603 allocated on the comp_unit_obstack, so will disappear
604 when this compilation unit leaves the cache. */
607 /* The location description associated with this DIE, if any. */
608 struct dwarf_block
*locdesc
;
610 /* If HAS_PC_INFO, the PC range associated with this DIE. */
614 /* Pointer into the info_buffer (or types_buffer) pointing at the target of
615 DW_AT_sibling, if any. */
616 /* NOTE: This member isn't strictly necessary, read_partial_die could
617 return DW_AT_sibling values to its caller load_partial_dies. */
620 /* If HAS_SPECIFICATION, the offset of the DIE referred to by
621 DW_AT_specification (or DW_AT_abstract_origin or
623 unsigned int spec_offset
;
625 /* Pointers to this DIE's parent, first child, and next sibling,
627 struct partial_die_info
*die_parent
, *die_child
, *die_sibling
;
630 /* This data structure holds the information of an abbrev. */
633 unsigned int number
; /* number identifying abbrev */
634 enum dwarf_tag tag
; /* dwarf tag */
635 unsigned short has_children
; /* boolean */
636 unsigned short num_attrs
; /* number of attributes */
637 struct attr_abbrev
*attrs
; /* an array of attribute descriptions */
638 struct abbrev_info
*next
; /* next in chain */
643 ENUM_BITFIELD(dwarf_attribute
) name
: 16;
644 ENUM_BITFIELD(dwarf_form
) form
: 16;
647 /* Attributes have a name and a value. */
650 ENUM_BITFIELD(dwarf_attribute
) name
: 16;
651 ENUM_BITFIELD(dwarf_form
) form
: 15;
653 /* Has DW_STRING already been updated by dwarf2_canonicalize_name? This
654 field should be in u.str (existing only for DW_STRING) but it is kept
655 here for better struct attribute alignment. */
656 unsigned int string_is_canonical
: 1;
661 struct dwarf_block
*blk
;
665 struct signatured_type
*signatured_type
;
670 /* This data structure holds a complete die structure. */
673 /* DWARF-2 tag for this DIE. */
674 ENUM_BITFIELD(dwarf_tag
) tag
: 16;
676 /* Number of attributes */
677 unsigned char num_attrs
;
679 /* True if we're presently building the full type name for the
680 type derived from this DIE. */
681 unsigned char building_fullname
: 1;
686 /* Offset in .debug_info or .debug_types section. */
689 /* The dies in a compilation unit form an n-ary tree. PARENT
690 points to this die's parent; CHILD points to the first child of
691 this node; and all the children of a given node are chained
692 together via their SIBLING fields. */
693 struct die_info
*child
; /* Its first child, if any. */
694 struct die_info
*sibling
; /* Its next sibling, if any. */
695 struct die_info
*parent
; /* Its parent, if any. */
697 /* An array of attributes, with NUM_ATTRS elements. There may be
698 zero, but it's not common and zero-sized arrays are not
699 sufficiently portable C. */
700 struct attribute attrs
[1];
703 /* Get at parts of an attribute structure. */
705 #define DW_STRING(attr) ((attr)->u.str)
706 #define DW_STRING_IS_CANONICAL(attr) ((attr)->string_is_canonical)
707 #define DW_UNSND(attr) ((attr)->u.unsnd)
708 #define DW_BLOCK(attr) ((attr)->u.blk)
709 #define DW_SND(attr) ((attr)->u.snd)
710 #define DW_ADDR(attr) ((attr)->u.addr)
711 #define DW_SIGNATURED_TYPE(attr) ((attr)->u.signatured_type)
713 /* Blocks are a bunch of untyped bytes. */
718 /* Valid only if SIZE is not zero. */
722 #ifndef ATTR_ALLOC_CHUNK
723 #define ATTR_ALLOC_CHUNK 4
726 /* Allocate fields for structs, unions and enums in this size. */
727 #ifndef DW_FIELD_ALLOC_CHUNK
728 #define DW_FIELD_ALLOC_CHUNK 4
731 /* FIXME: We might want to set this from BFD via bfd_arch_bits_per_byte,
732 but this would require a corresponding change in unpack_field_as_long
734 static int bits_per_byte
= 8;
736 /* The routines that read and process dies for a C struct or C++ class
737 pass lists of data member fields and lists of member function fields
738 in an instance of a field_info structure, as defined below. */
741 /* List of data member and baseclasses fields. */
744 struct nextfield
*next
;
749 *fields
, *baseclasses
;
751 /* Number of fields (including baseclasses). */
754 /* Number of baseclasses. */
757 /* Set if the accesibility of one of the fields is not public. */
758 int non_public_fields
;
760 /* Member function fields array, entries are allocated in the order they
761 are encountered in the object file. */
764 struct nextfnfield
*next
;
765 struct fn_field fnfield
;
769 /* Member function fieldlist array, contains name of possibly overloaded
770 member function, number of overloaded member functions and a pointer
771 to the head of the member function field chain. */
776 struct nextfnfield
*head
;
780 /* Number of entries in the fnfieldlists array. */
783 /* typedefs defined inside this class. TYPEDEF_FIELD_LIST contains head of
784 a NULL terminated list of TYPEDEF_FIELD_LIST_COUNT elements. */
785 struct typedef_field_list
787 struct typedef_field field
;
788 struct typedef_field_list
*next
;
791 unsigned typedef_field_list_count
;
794 /* One item on the queue of compilation units to read in full symbols
796 struct dwarf2_queue_item
798 struct dwarf2_per_cu_data
*per_cu
;
799 struct dwarf2_queue_item
*next
;
802 /* The current queue. */
803 static struct dwarf2_queue_item
*dwarf2_queue
, *dwarf2_queue_tail
;
805 /* Loaded secondary compilation units are kept in memory until they
806 have not been referenced for the processing of this many
807 compilation units. Set this to zero to disable caching. Cache
808 sizes of up to at least twenty will improve startup time for
809 typical inter-CU-reference binaries, at an obvious memory cost. */
810 static int dwarf2_max_cache_age
= 5;
812 show_dwarf2_max_cache_age (struct ui_file
*file
, int from_tty
,
813 struct cmd_list_element
*c
, const char *value
)
815 fprintf_filtered (file
, _("The upper bound on the age of cached "
816 "dwarf2 compilation units is %s.\n"),
821 /* Various complaints about symbol reading that don't abort the process. */
824 dwarf2_statement_list_fits_in_line_number_section_complaint (void)
826 complaint (&symfile_complaints
,
827 _("statement list doesn't fit in .debug_line section"));
831 dwarf2_debug_line_missing_file_complaint (void)
833 complaint (&symfile_complaints
,
834 _(".debug_line section has line data without a file"));
838 dwarf2_debug_line_missing_end_sequence_complaint (void)
840 complaint (&symfile_complaints
,
841 _(".debug_line section has line "
842 "program sequence without an end"));
846 dwarf2_complex_location_expr_complaint (void)
848 complaint (&symfile_complaints
, _("location expression too complex"));
852 dwarf2_const_value_length_mismatch_complaint (const char *arg1
, int arg2
,
855 complaint (&symfile_complaints
,
856 _("const value length mismatch for '%s', got %d, expected %d"),
861 dwarf2_macros_too_long_complaint (struct dwarf2_section_info
*section
)
863 complaint (&symfile_complaints
,
864 _("macro info runs off end of `%s' section"),
865 section
->asection
->name
);
869 dwarf2_macro_malformed_definition_complaint (const char *arg1
)
871 complaint (&symfile_complaints
,
872 _("macro debug info contains a "
873 "malformed macro definition:\n`%s'"),
878 dwarf2_invalid_attrib_class_complaint (const char *arg1
, const char *arg2
)
880 complaint (&symfile_complaints
,
881 _("invalid attribute class or form for '%s' in '%s'"),
885 /* local function prototypes */
887 static void dwarf2_locate_sections (bfd
*, asection
*, void *);
889 static void dwarf2_create_include_psymtab (char *, struct partial_symtab
*,
892 static void dwarf2_find_base_address (struct die_info
*die
,
893 struct dwarf2_cu
*cu
);
895 static void dwarf2_build_psymtabs_hard (struct objfile
*);
897 static void scan_partial_symbols (struct partial_die_info
*,
898 CORE_ADDR
*, CORE_ADDR
*,
899 int, struct dwarf2_cu
*);
901 static void add_partial_symbol (struct partial_die_info
*,
904 static void add_partial_namespace (struct partial_die_info
*pdi
,
905 CORE_ADDR
*lowpc
, CORE_ADDR
*highpc
,
906 int need_pc
, struct dwarf2_cu
*cu
);
908 static void add_partial_module (struct partial_die_info
*pdi
, CORE_ADDR
*lowpc
,
909 CORE_ADDR
*highpc
, int need_pc
,
910 struct dwarf2_cu
*cu
);
912 static void add_partial_enumeration (struct partial_die_info
*enum_pdi
,
913 struct dwarf2_cu
*cu
);
915 static void add_partial_subprogram (struct partial_die_info
*pdi
,
916 CORE_ADDR
*lowpc
, CORE_ADDR
*highpc
,
917 int need_pc
, struct dwarf2_cu
*cu
);
919 static gdb_byte
*locate_pdi_sibling (struct partial_die_info
*orig_pdi
,
920 gdb_byte
*buffer
, gdb_byte
*info_ptr
,
921 bfd
*abfd
, struct dwarf2_cu
*cu
);
923 static void dwarf2_psymtab_to_symtab (struct partial_symtab
*);
925 static void psymtab_to_symtab_1 (struct partial_symtab
*);
927 static void dwarf2_read_abbrevs (struct dwarf2_cu
*cu
);
929 static void dwarf2_free_abbrev_table (void *);
931 static unsigned int peek_abbrev_code (bfd
*, gdb_byte
*);
933 static struct abbrev_info
*peek_die_abbrev (gdb_byte
*, unsigned int *,
936 static struct abbrev_info
*dwarf2_lookup_abbrev (unsigned int,
939 static struct partial_die_info
*load_partial_dies (bfd
*,
940 gdb_byte
*, gdb_byte
*,
941 int, struct dwarf2_cu
*);
943 static gdb_byte
*read_partial_die (struct partial_die_info
*,
944 struct abbrev_info
*abbrev
,
946 gdb_byte
*, gdb_byte
*,
949 static struct partial_die_info
*find_partial_die (unsigned int,
952 static void fixup_partial_die (struct partial_die_info
*,
955 static gdb_byte
*read_attribute (struct attribute
*, struct attr_abbrev
*,
956 bfd
*, gdb_byte
*, struct dwarf2_cu
*);
958 static gdb_byte
*read_attribute_value (struct attribute
*, unsigned,
959 bfd
*, gdb_byte
*, struct dwarf2_cu
*);
961 static unsigned int read_1_byte (bfd
*, gdb_byte
*);
963 static int read_1_signed_byte (bfd
*, gdb_byte
*);
965 static unsigned int read_2_bytes (bfd
*, gdb_byte
*);
967 static unsigned int read_4_bytes (bfd
*, gdb_byte
*);
969 static ULONGEST
read_8_bytes (bfd
*, gdb_byte
*);
971 static CORE_ADDR
read_address (bfd
*, gdb_byte
*ptr
, struct dwarf2_cu
*,
974 static LONGEST
read_initial_length (bfd
*, gdb_byte
*, unsigned int *);
976 static LONGEST read_checked_initial_length_and_offset
977 (bfd
*, gdb_byte
*, const struct comp_unit_head
*,
978 unsigned int *, unsigned int *);
980 static LONGEST
read_offset (bfd
*, gdb_byte
*, const struct comp_unit_head
*,
983 static LONGEST
read_offset_1 (bfd
*, gdb_byte
*, unsigned int);
985 static gdb_byte
*read_n_bytes (bfd
*, gdb_byte
*, unsigned int);
987 static char *read_direct_string (bfd
*, gdb_byte
*, unsigned int *);
989 static char *read_indirect_string (bfd
*, gdb_byte
*,
990 const struct comp_unit_head
*,
993 static unsigned long read_unsigned_leb128 (bfd
*, gdb_byte
*, unsigned int *);
995 static long read_signed_leb128 (bfd
*, gdb_byte
*, unsigned int *);
997 static gdb_byte
*skip_leb128 (bfd
*, gdb_byte
*);
999 static void set_cu_language (unsigned int, struct dwarf2_cu
*);
1001 static struct attribute
*dwarf2_attr (struct die_info
*, unsigned int,
1002 struct dwarf2_cu
*);
1004 static struct attribute
*dwarf2_attr_no_follow (struct die_info
*,
1006 struct dwarf2_cu
*);
1008 static int dwarf2_flag_true_p (struct die_info
*die
, unsigned name
,
1009 struct dwarf2_cu
*cu
);
1011 static int die_is_declaration (struct die_info
*, struct dwarf2_cu
*cu
);
1013 static struct die_info
*die_specification (struct die_info
*die
,
1014 struct dwarf2_cu
**);
1016 static void free_line_header (struct line_header
*lh
);
1018 static void add_file_name (struct line_header
*, char *, unsigned int,
1019 unsigned int, unsigned int);
1021 static struct line_header
*(dwarf_decode_line_header
1022 (unsigned int offset
,
1023 bfd
*abfd
, struct dwarf2_cu
*cu
));
1025 static void dwarf_decode_lines (struct line_header
*, const char *, bfd
*,
1026 struct dwarf2_cu
*, struct partial_symtab
*);
1028 static void dwarf2_start_subfile (char *, const char *, const char *);
1030 static struct symbol
*new_symbol (struct die_info
*, struct type
*,
1031 struct dwarf2_cu
*);
1033 static struct symbol
*new_symbol_full (struct die_info
*, struct type
*,
1034 struct dwarf2_cu
*, struct symbol
*);
1036 static void dwarf2_const_value (struct attribute
*, struct symbol
*,
1037 struct dwarf2_cu
*);
1039 static void dwarf2_const_value_attr (struct attribute
*attr
,
1042 struct obstack
*obstack
,
1043 struct dwarf2_cu
*cu
, long *value
,
1045 struct dwarf2_locexpr_baton
**baton
);
1047 static struct type
*die_type (struct die_info
*, struct dwarf2_cu
*);
1049 static int need_gnat_info (struct dwarf2_cu
*);
1051 static struct type
*die_descriptive_type (struct die_info
*,
1052 struct dwarf2_cu
*);
1054 static void set_descriptive_type (struct type
*, struct die_info
*,
1055 struct dwarf2_cu
*);
1057 static struct type
*die_containing_type (struct die_info
*,
1058 struct dwarf2_cu
*);
1060 static struct type
*lookup_die_type (struct die_info
*, struct attribute
*,
1061 struct dwarf2_cu
*);
1063 static struct type
*read_type_die (struct die_info
*, struct dwarf2_cu
*);
1065 static struct type
*read_type_die_1 (struct die_info
*, struct dwarf2_cu
*);
1067 static char *determine_prefix (struct die_info
*die
, struct dwarf2_cu
*);
1069 static char *typename_concat (struct obstack
*obs
, const char *prefix
,
1070 const char *suffix
, int physname
,
1071 struct dwarf2_cu
*cu
);
1073 static void read_file_scope (struct die_info
*, struct dwarf2_cu
*);
1075 static void read_type_unit_scope (struct die_info
*, struct dwarf2_cu
*);
1077 static void read_func_scope (struct die_info
*, struct dwarf2_cu
*);
1079 static void read_lexical_block_scope (struct die_info
*, struct dwarf2_cu
*);
1081 static void read_call_site_scope (struct die_info
*die
, struct dwarf2_cu
*cu
);
1083 static int dwarf2_ranges_read (unsigned, CORE_ADDR
*, CORE_ADDR
*,
1084 struct dwarf2_cu
*, struct partial_symtab
*);
1086 static int dwarf2_get_pc_bounds (struct die_info
*,
1087 CORE_ADDR
*, CORE_ADDR
*, struct dwarf2_cu
*,
1088 struct partial_symtab
*);
1090 static void get_scope_pc_bounds (struct die_info
*,
1091 CORE_ADDR
*, CORE_ADDR
*,
1092 struct dwarf2_cu
*);
1094 static void dwarf2_record_block_ranges (struct die_info
*, struct block
*,
1095 CORE_ADDR
, struct dwarf2_cu
*);
1097 static void dwarf2_add_field (struct field_info
*, struct die_info
*,
1098 struct dwarf2_cu
*);
1100 static void dwarf2_attach_fields_to_type (struct field_info
*,
1101 struct type
*, struct dwarf2_cu
*);
1103 static void dwarf2_add_member_fn (struct field_info
*,
1104 struct die_info
*, struct type
*,
1105 struct dwarf2_cu
*);
1107 static void dwarf2_attach_fn_fields_to_type (struct field_info
*,
1109 struct dwarf2_cu
*);
1111 static void process_structure_scope (struct die_info
*, struct dwarf2_cu
*);
1113 static void read_common_block (struct die_info
*, struct dwarf2_cu
*);
1115 static void read_namespace (struct die_info
*die
, struct dwarf2_cu
*);
1117 static void read_module (struct die_info
*die
, struct dwarf2_cu
*cu
);
1119 static void read_import_statement (struct die_info
*die
, struct dwarf2_cu
*);
1121 static struct type
*read_module_type (struct die_info
*die
,
1122 struct dwarf2_cu
*cu
);
1124 static const char *namespace_name (struct die_info
*die
,
1125 int *is_anonymous
, struct dwarf2_cu
*);
1127 static void process_enumeration_scope (struct die_info
*, struct dwarf2_cu
*);
1129 static CORE_ADDR
decode_locdesc (struct dwarf_block
*, struct dwarf2_cu
*);
1131 static enum dwarf_array_dim_ordering
read_array_order (struct die_info
*,
1132 struct dwarf2_cu
*);
1134 static struct die_info
*read_comp_unit (gdb_byte
*, struct dwarf2_cu
*);
1136 static struct die_info
*read_die_and_children_1 (const struct die_reader_specs
*reader
,
1138 gdb_byte
**new_info_ptr
,
1139 struct die_info
*parent
);
1141 static struct die_info
*read_die_and_children (const struct die_reader_specs
*reader
,
1143 gdb_byte
**new_info_ptr
,
1144 struct die_info
*parent
);
1146 static struct die_info
*read_die_and_siblings (const struct die_reader_specs
*reader
,
1148 gdb_byte
**new_info_ptr
,
1149 struct die_info
*parent
);
1151 static gdb_byte
*read_full_die (const struct die_reader_specs
*reader
,
1152 struct die_info
**, gdb_byte
*,
1155 static void process_die (struct die_info
*, struct dwarf2_cu
*);
1157 static char *dwarf2_canonicalize_name (char *, struct dwarf2_cu
*,
1160 static char *dwarf2_name (struct die_info
*die
, struct dwarf2_cu
*);
1162 static const char *dwarf2_full_name (char *name
,
1163 struct die_info
*die
,
1164 struct dwarf2_cu
*cu
);
1166 static struct die_info
*dwarf2_extension (struct die_info
*die
,
1167 struct dwarf2_cu
**);
1169 static char *dwarf_tag_name (unsigned int);
1171 static char *dwarf_attr_name (unsigned int);
1173 static char *dwarf_form_name (unsigned int);
1175 static char *dwarf_bool_name (unsigned int);
1177 static char *dwarf_type_encoding_name (unsigned int);
1180 static char *dwarf_cfi_name (unsigned int);
1183 static struct die_info
*sibling_die (struct die_info
*);
1185 static void dump_die_shallow (struct ui_file
*, int indent
, struct die_info
*);
1187 static void dump_die_for_error (struct die_info
*);
1189 static void dump_die_1 (struct ui_file
*, int level
, int max_level
,
1192 /*static*/ void dump_die (struct die_info
*, int max_level
);
1194 static void store_in_ref_table (struct die_info
*,
1195 struct dwarf2_cu
*);
1197 static int is_ref_attr (struct attribute
*);
1199 static unsigned int dwarf2_get_ref_die_offset (struct attribute
*);
1201 static LONGEST
dwarf2_get_attr_constant_value (struct attribute
*, int);
1203 static struct die_info
*follow_die_ref_or_sig (struct die_info
*,
1205 struct dwarf2_cu
**);
1207 static struct die_info
*follow_die_ref (struct die_info
*,
1209 struct dwarf2_cu
**);
1211 static struct die_info
*follow_die_sig (struct die_info
*,
1213 struct dwarf2_cu
**);
1215 static struct signatured_type
*lookup_signatured_type_at_offset
1216 (struct objfile
*objfile
,
1217 struct dwarf2_section_info
*section
,
1218 unsigned int offset
);
1220 static void load_full_type_unit (struct dwarf2_per_cu_data
*per_cu
);
1222 static void read_signatured_type (struct signatured_type
*type_sig
);
1224 /* memory allocation interface */
1226 static struct dwarf_block
*dwarf_alloc_block (struct dwarf2_cu
*);
1228 static struct abbrev_info
*dwarf_alloc_abbrev (struct dwarf2_cu
*);
1230 static struct die_info
*dwarf_alloc_die (struct dwarf2_cu
*, int);
1232 static void dwarf_decode_macros (struct line_header
*, unsigned int,
1233 char *, bfd
*, struct dwarf2_cu
*,
1234 struct dwarf2_section_info
*,
1237 static int attr_form_is_block (struct attribute
*);
1239 static int attr_form_is_section_offset (struct attribute
*);
1241 static int attr_form_is_constant (struct attribute
*);
1243 static void fill_in_loclist_baton (struct dwarf2_cu
*cu
,
1244 struct dwarf2_loclist_baton
*baton
,
1245 struct attribute
*attr
);
1247 static void dwarf2_symbol_mark_computed (struct attribute
*attr
,
1249 struct dwarf2_cu
*cu
);
1251 static gdb_byte
*skip_one_die (gdb_byte
*buffer
, gdb_byte
*info_ptr
,
1252 struct abbrev_info
*abbrev
,
1253 struct dwarf2_cu
*cu
);
1255 static void free_stack_comp_unit (void *);
1257 static hashval_t
partial_die_hash (const void *item
);
1259 static int partial_die_eq (const void *item_lhs
, const void *item_rhs
);
1261 static struct dwarf2_per_cu_data
*dwarf2_find_containing_comp_unit
1262 (unsigned int offset
, struct objfile
*objfile
);
1264 static struct dwarf2_per_cu_data
*dwarf2_find_comp_unit
1265 (unsigned int offset
, struct objfile
*objfile
);
1267 static void init_one_comp_unit (struct dwarf2_cu
*cu
,
1268 struct dwarf2_per_cu_data
*per_cu
);
1270 static void prepare_one_comp_unit (struct dwarf2_cu
*cu
,
1271 struct die_info
*comp_unit_die
);
1273 static void free_heap_comp_unit (void *);
1275 static void free_cached_comp_units (void *);
1277 static void age_cached_comp_units (void);
1279 static void free_one_cached_comp_unit (void *);
1281 static struct type
*set_die_type (struct die_info
*, struct type
*,
1282 struct dwarf2_cu
*);
1284 static void create_all_comp_units (struct objfile
*);
1286 static int create_debug_types_hash_table (struct objfile
*objfile
);
1288 static void load_full_comp_unit (struct dwarf2_per_cu_data
*);
1290 static void process_full_comp_unit (struct dwarf2_per_cu_data
*);
1292 static void dwarf2_add_dependence (struct dwarf2_cu
*,
1293 struct dwarf2_per_cu_data
*);
1295 static void dwarf2_mark (struct dwarf2_cu
*);
1297 static void dwarf2_clear_marks (struct dwarf2_per_cu_data
*);
1299 static struct type
*get_die_type_at_offset (unsigned int,
1300 struct dwarf2_per_cu_data
*per_cu
);
1302 static struct type
*get_die_type (struct die_info
*die
, struct dwarf2_cu
*cu
);
1304 static void dwarf2_release_queue (void *dummy
);
1306 static void queue_comp_unit (struct dwarf2_per_cu_data
*per_cu
);
1308 static void process_queue (void);
1310 static void find_file_and_directory (struct die_info
*die
,
1311 struct dwarf2_cu
*cu
,
1312 char **name
, char **comp_dir
);
1314 static char *file_full_name (int file
, struct line_header
*lh
,
1315 const char *comp_dir
);
1317 static gdb_byte
*partial_read_comp_unit_head (struct comp_unit_head
*header
,
1320 unsigned int buffer_size
,
1322 int is_debug_types_section
);
1324 static void init_cu_die_reader (struct die_reader_specs
*reader
,
1325 struct dwarf2_cu
*cu
);
1327 static htab_t
allocate_signatured_type_table (struct objfile
*objfile
);
1331 /* Convert VALUE between big- and little-endian. */
1333 byte_swap (offset_type value
)
1337 result
= (value
& 0xff) << 24;
1338 result
|= (value
& 0xff00) << 8;
1339 result
|= (value
& 0xff0000) >> 8;
1340 result
|= (value
& 0xff000000) >> 24;
1344 #define MAYBE_SWAP(V) byte_swap (V)
1347 #define MAYBE_SWAP(V) (V)
1348 #endif /* WORDS_BIGENDIAN */
1350 /* The suffix for an index file. */
1351 #define INDEX_SUFFIX ".gdb-index"
1353 static const char *dwarf2_physname (char *name
, struct die_info
*die
,
1354 struct dwarf2_cu
*cu
);
1356 /* Try to locate the sections we need for DWARF 2 debugging
1357 information and return true if we have enough to do something.
1358 NAMES points to the dwarf2 section names, or is NULL if the standard
1359 ELF names are used. */
1362 dwarf2_has_info (struct objfile
*objfile
,
1363 const struct dwarf2_debug_sections
*names
)
1365 dwarf2_per_objfile
= objfile_data (objfile
, dwarf2_objfile_data_key
);
1366 if (!dwarf2_per_objfile
)
1368 /* Initialize per-objfile state. */
1369 struct dwarf2_per_objfile
*data
1370 = obstack_alloc (&objfile
->objfile_obstack
, sizeof (*data
));
1372 memset (data
, 0, sizeof (*data
));
1373 set_objfile_data (objfile
, dwarf2_objfile_data_key
, data
);
1374 dwarf2_per_objfile
= data
;
1376 bfd_map_over_sections (objfile
->obfd
, dwarf2_locate_sections
,
1378 dwarf2_per_objfile
->objfile
= objfile
;
1380 return (dwarf2_per_objfile
->info
.asection
!= NULL
1381 && dwarf2_per_objfile
->abbrev
.asection
!= NULL
);
1384 /* When loading sections, we look either for uncompressed section or for
1385 compressed section names. */
1388 section_is_p (const char *section_name
,
1389 const struct dwarf2_section_names
*names
)
1391 if (names
->normal
!= NULL
1392 && strcmp (section_name
, names
->normal
) == 0)
1394 if (names
->compressed
!= NULL
1395 && strcmp (section_name
, names
->compressed
) == 0)
1400 /* This function is mapped across the sections and remembers the
1401 offset and size of each of the debugging sections we are interested
1405 dwarf2_locate_sections (bfd
*abfd
, asection
*sectp
, void *vnames
)
1407 const struct dwarf2_debug_sections
*names
;
1410 names
= &dwarf2_elf_names
;
1412 names
= (const struct dwarf2_debug_sections
*) vnames
;
1414 if (section_is_p (sectp
->name
, &names
->info
))
1416 dwarf2_per_objfile
->info
.asection
= sectp
;
1417 dwarf2_per_objfile
->info
.size
= bfd_get_section_size (sectp
);
1419 else if (section_is_p (sectp
->name
, &names
->abbrev
))
1421 dwarf2_per_objfile
->abbrev
.asection
= sectp
;
1422 dwarf2_per_objfile
->abbrev
.size
= bfd_get_section_size (sectp
);
1424 else if (section_is_p (sectp
->name
, &names
->line
))
1426 dwarf2_per_objfile
->line
.asection
= sectp
;
1427 dwarf2_per_objfile
->line
.size
= bfd_get_section_size (sectp
);
1429 else if (section_is_p (sectp
->name
, &names
->loc
))
1431 dwarf2_per_objfile
->loc
.asection
= sectp
;
1432 dwarf2_per_objfile
->loc
.size
= bfd_get_section_size (sectp
);
1434 else if (section_is_p (sectp
->name
, &names
->macinfo
))
1436 dwarf2_per_objfile
->macinfo
.asection
= sectp
;
1437 dwarf2_per_objfile
->macinfo
.size
= bfd_get_section_size (sectp
);
1439 else if (section_is_p (sectp
->name
, &names
->macro
))
1441 dwarf2_per_objfile
->macro
.asection
= sectp
;
1442 dwarf2_per_objfile
->macro
.size
= bfd_get_section_size (sectp
);
1444 else if (section_is_p (sectp
->name
, &names
->str
))
1446 dwarf2_per_objfile
->str
.asection
= sectp
;
1447 dwarf2_per_objfile
->str
.size
= bfd_get_section_size (sectp
);
1449 else if (section_is_p (sectp
->name
, &names
->frame
))
1451 dwarf2_per_objfile
->frame
.asection
= sectp
;
1452 dwarf2_per_objfile
->frame
.size
= bfd_get_section_size (sectp
);
1454 else if (section_is_p (sectp
->name
, &names
->eh_frame
))
1456 flagword aflag
= bfd_get_section_flags (ignore_abfd
, sectp
);
1458 if (aflag
& SEC_HAS_CONTENTS
)
1460 dwarf2_per_objfile
->eh_frame
.asection
= sectp
;
1461 dwarf2_per_objfile
->eh_frame
.size
= bfd_get_section_size (sectp
);
1464 else if (section_is_p (sectp
->name
, &names
->ranges
))
1466 dwarf2_per_objfile
->ranges
.asection
= sectp
;
1467 dwarf2_per_objfile
->ranges
.size
= bfd_get_section_size (sectp
);
1469 else if (section_is_p (sectp
->name
, &names
->types
))
1471 struct dwarf2_section_info type_section
;
1473 memset (&type_section
, 0, sizeof (type_section
));
1474 type_section
.asection
= sectp
;
1475 type_section
.size
= bfd_get_section_size (sectp
);
1477 VEC_safe_push (dwarf2_section_info_def
, dwarf2_per_objfile
->types
,
1480 else if (section_is_p (sectp
->name
, &names
->gdb_index
))
1482 dwarf2_per_objfile
->gdb_index
.asection
= sectp
;
1483 dwarf2_per_objfile
->gdb_index
.size
= bfd_get_section_size (sectp
);
1486 if ((bfd_get_section_flags (abfd
, sectp
) & SEC_LOAD
)
1487 && bfd_section_vma (abfd
, sectp
) == 0)
1488 dwarf2_per_objfile
->has_section_at_zero
= 1;
1491 /* Decompress a section that was compressed using zlib. Store the
1492 decompressed buffer, and its size, in OUTBUF and OUTSIZE. */
1495 zlib_decompress_section (struct objfile
*objfile
, asection
*sectp
,
1496 gdb_byte
**outbuf
, bfd_size_type
*outsize
)
1498 bfd
*abfd
= objfile
->obfd
;
1500 error (_("Support for zlib-compressed DWARF data (from '%s') "
1501 "is disabled in this copy of GDB"),
1502 bfd_get_filename (abfd
));
1504 bfd_size_type compressed_size
= bfd_get_section_size (sectp
);
1505 gdb_byte
*compressed_buffer
= xmalloc (compressed_size
);
1506 struct cleanup
*cleanup
= make_cleanup (xfree
, compressed_buffer
);
1507 bfd_size_type uncompressed_size
;
1508 gdb_byte
*uncompressed_buffer
;
1511 int header_size
= 12;
1513 if (bfd_seek (abfd
, sectp
->filepos
, SEEK_SET
) != 0
1514 || bfd_bread (compressed_buffer
,
1515 compressed_size
, abfd
) != compressed_size
)
1516 error (_("Dwarf Error: Can't read DWARF data from '%s'"),
1517 bfd_get_filename (abfd
));
1519 /* Read the zlib header. In this case, it should be "ZLIB" followed
1520 by the uncompressed section size, 8 bytes in big-endian order. */
1521 if (compressed_size
< header_size
1522 || strncmp (compressed_buffer
, "ZLIB", 4) != 0)
1523 error (_("Dwarf Error: Corrupt DWARF ZLIB header from '%s'"),
1524 bfd_get_filename (abfd
));
1525 uncompressed_size
= compressed_buffer
[4]; uncompressed_size
<<= 8;
1526 uncompressed_size
+= compressed_buffer
[5]; uncompressed_size
<<= 8;
1527 uncompressed_size
+= compressed_buffer
[6]; uncompressed_size
<<= 8;
1528 uncompressed_size
+= compressed_buffer
[7]; uncompressed_size
<<= 8;
1529 uncompressed_size
+= compressed_buffer
[8]; uncompressed_size
<<= 8;
1530 uncompressed_size
+= compressed_buffer
[9]; uncompressed_size
<<= 8;
1531 uncompressed_size
+= compressed_buffer
[10]; uncompressed_size
<<= 8;
1532 uncompressed_size
+= compressed_buffer
[11];
1534 /* It is possible the section consists of several compressed
1535 buffers concatenated together, so we uncompress in a loop. */
1539 strm
.avail_in
= compressed_size
- header_size
;
1540 strm
.next_in
= (Bytef
*) compressed_buffer
+ header_size
;
1541 strm
.avail_out
= uncompressed_size
;
1542 uncompressed_buffer
= obstack_alloc (&objfile
->objfile_obstack
,
1544 rc
= inflateInit (&strm
);
1545 while (strm
.avail_in
> 0)
1548 error (_("Dwarf Error: setting up DWARF uncompression in '%s': %d"),
1549 bfd_get_filename (abfd
), rc
);
1550 strm
.next_out
= ((Bytef
*) uncompressed_buffer
1551 + (uncompressed_size
- strm
.avail_out
));
1552 rc
= inflate (&strm
, Z_FINISH
);
1553 if (rc
!= Z_STREAM_END
)
1554 error (_("Dwarf Error: zlib error uncompressing from '%s': %d"),
1555 bfd_get_filename (abfd
), rc
);
1556 rc
= inflateReset (&strm
);
1558 rc
= inflateEnd (&strm
);
1560 || strm
.avail_out
!= 0)
1561 error (_("Dwarf Error: concluding DWARF uncompression in '%s': %d"),
1562 bfd_get_filename (abfd
), rc
);
1564 do_cleanups (cleanup
);
1565 *outbuf
= uncompressed_buffer
;
1566 *outsize
= uncompressed_size
;
1570 /* A helper function that decides whether a section is empty. */
1573 dwarf2_section_empty_p (struct dwarf2_section_info
*info
)
1575 return info
->asection
== NULL
|| info
->size
== 0;
1578 /* Read the contents of the section INFO from object file specified by
1579 OBJFILE, store info about the section into INFO.
1580 If the section is compressed, uncompress it before returning. */
1583 dwarf2_read_section (struct objfile
*objfile
, struct dwarf2_section_info
*info
)
1585 bfd
*abfd
= objfile
->obfd
;
1586 asection
*sectp
= info
->asection
;
1587 gdb_byte
*buf
, *retbuf
;
1588 unsigned char header
[4];
1592 info
->buffer
= NULL
;
1593 info
->map_addr
= NULL
;
1596 if (dwarf2_section_empty_p (info
))
1599 /* Check if the file has a 4-byte header indicating compression. */
1600 if (info
->size
> sizeof (header
)
1601 && bfd_seek (abfd
, sectp
->filepos
, SEEK_SET
) == 0
1602 && bfd_bread (header
, sizeof (header
), abfd
) == sizeof (header
))
1604 /* Upon decompression, update the buffer and its size. */
1605 if (strncmp (header
, "ZLIB", sizeof (header
)) == 0)
1607 zlib_decompress_section (objfile
, sectp
, &info
->buffer
,
1615 pagesize
= getpagesize ();
1617 /* Only try to mmap sections which are large enough: we don't want to
1618 waste space due to fragmentation. Also, only try mmap for sections
1619 without relocations. */
1621 if (info
->size
> 4 * pagesize
&& (sectp
->flags
& SEC_RELOC
) == 0)
1623 info
->buffer
= bfd_mmap (abfd
, 0, info
->size
, PROT_READ
,
1624 MAP_PRIVATE
, sectp
->filepos
,
1625 &info
->map_addr
, &info
->map_len
);
1627 if ((caddr_t
)info
->buffer
!= MAP_FAILED
)
1629 #if HAVE_POSIX_MADVISE
1630 posix_madvise (info
->map_addr
, info
->map_len
, POSIX_MADV_WILLNEED
);
1637 /* If we get here, we are a normal, not-compressed section. */
1639 = obstack_alloc (&objfile
->objfile_obstack
, info
->size
);
1641 /* When debugging .o files, we may need to apply relocations; see
1642 http://sourceware.org/ml/gdb-patches/2002-04/msg00136.html .
1643 We never compress sections in .o files, so we only need to
1644 try this when the section is not compressed. */
1645 retbuf
= symfile_relocate_debug_section (objfile
, sectp
, buf
);
1648 info
->buffer
= retbuf
;
1652 if (bfd_seek (abfd
, sectp
->filepos
, SEEK_SET
) != 0
1653 || bfd_bread (buf
, info
->size
, abfd
) != info
->size
)
1654 error (_("Dwarf Error: Can't read DWARF data from '%s'"),
1655 bfd_get_filename (abfd
));
1658 /* A helper function that returns the size of a section in a safe way.
1659 If you are positive that the section has been read before using the
1660 size, then it is safe to refer to the dwarf2_section_info object's
1661 "size" field directly. In other cases, you must call this
1662 function, because for compressed sections the size field is not set
1663 correctly until the section has been read. */
1665 static bfd_size_type
1666 dwarf2_section_size (struct objfile
*objfile
,
1667 struct dwarf2_section_info
*info
)
1670 dwarf2_read_section (objfile
, info
);
1674 /* Fill in SECTP, BUFP and SIZEP with section info, given OBJFILE and
1678 dwarf2_get_section_info (struct objfile
*objfile
,
1679 enum dwarf2_section_enum sect
,
1680 asection
**sectp
, gdb_byte
**bufp
,
1681 bfd_size_type
*sizep
)
1683 struct dwarf2_per_objfile
*data
1684 = objfile_data (objfile
, dwarf2_objfile_data_key
);
1685 struct dwarf2_section_info
*info
;
1687 /* We may see an objfile without any DWARF, in which case we just
1698 case DWARF2_DEBUG_FRAME
:
1699 info
= &data
->frame
;
1701 case DWARF2_EH_FRAME
:
1702 info
= &data
->eh_frame
;
1705 gdb_assert_not_reached ("unexpected section");
1708 dwarf2_read_section (objfile
, info
);
1710 *sectp
= info
->asection
;
1711 *bufp
= info
->buffer
;
1712 *sizep
= info
->size
;
1716 /* DWARF quick_symbols_functions support. */
1718 /* TUs can share .debug_line entries, and there can be a lot more TUs than
1719 unique line tables, so we maintain a separate table of all .debug_line
1720 derived entries to support the sharing.
1721 All the quick functions need is the list of file names. We discard the
1722 line_header when we're done and don't need to record it here. */
1723 struct quick_file_names
1725 /* The offset in .debug_line of the line table. We hash on this. */
1726 unsigned int offset
;
1728 /* The number of entries in file_names, real_names. */
1729 unsigned int num_file_names
;
1731 /* The file names from the line table, after being run through
1733 const char **file_names
;
1735 /* The file names from the line table after being run through
1736 gdb_realpath. These are computed lazily. */
1737 const char **real_names
;
1740 /* When using the index (and thus not using psymtabs), each CU has an
1741 object of this type. This is used to hold information needed by
1742 the various "quick" methods. */
1743 struct dwarf2_per_cu_quick_data
1745 /* The file table. This can be NULL if there was no file table
1746 or it's currently not read in.
1747 NOTE: This points into dwarf2_per_objfile->quick_file_names_table. */
1748 struct quick_file_names
*file_names
;
1750 /* The corresponding symbol table. This is NULL if symbols for this
1751 CU have not yet been read. */
1752 struct symtab
*symtab
;
1754 /* A temporary mark bit used when iterating over all CUs in
1755 expand_symtabs_matching. */
1756 unsigned int mark
: 1;
1758 /* True if we've tried to read the file table and found there isn't one.
1759 There will be no point in trying to read it again next time. */
1760 unsigned int no_file_data
: 1;
1763 /* Hash function for a quick_file_names. */
1766 hash_file_name_entry (const void *e
)
1768 const struct quick_file_names
*file_data
= e
;
1770 return file_data
->offset
;
1773 /* Equality function for a quick_file_names. */
1776 eq_file_name_entry (const void *a
, const void *b
)
1778 const struct quick_file_names
*ea
= a
;
1779 const struct quick_file_names
*eb
= b
;
1781 return ea
->offset
== eb
->offset
;
1784 /* Delete function for a quick_file_names. */
1787 delete_file_name_entry (void *e
)
1789 struct quick_file_names
*file_data
= e
;
1792 for (i
= 0; i
< file_data
->num_file_names
; ++i
)
1794 xfree ((void*) file_data
->file_names
[i
]);
1795 if (file_data
->real_names
)
1796 xfree ((void*) file_data
->real_names
[i
]);
1799 /* The space for the struct itself lives on objfile_obstack,
1800 so we don't free it here. */
1803 /* Create a quick_file_names hash table. */
1806 create_quick_file_names_table (unsigned int nr_initial_entries
)
1808 return htab_create_alloc (nr_initial_entries
,
1809 hash_file_name_entry
, eq_file_name_entry
,
1810 delete_file_name_entry
, xcalloc
, xfree
);
1813 /* Read in PER_CU->CU. This function is unrelated to symtabs, symtab would
1814 have to be created afterwards. You should call age_cached_comp_units after
1815 processing PER_CU->CU. dw2_setup must have been already called. */
1818 load_cu (struct dwarf2_per_cu_data
*per_cu
)
1820 if (per_cu
->debug_types_section
)
1821 load_full_type_unit (per_cu
);
1823 load_full_comp_unit (per_cu
);
1825 gdb_assert (per_cu
->cu
!= NULL
);
1827 dwarf2_find_base_address (per_cu
->cu
->dies
, per_cu
->cu
);
1830 /* Read in the symbols for PER_CU. */
1833 dw2_do_instantiate_symtab (struct dwarf2_per_cu_data
*per_cu
)
1835 struct cleanup
*back_to
;
1837 back_to
= make_cleanup (dwarf2_release_queue
, NULL
);
1839 queue_comp_unit (per_cu
);
1845 /* Age the cache, releasing compilation units that have not
1846 been used recently. */
1847 age_cached_comp_units ();
1849 do_cleanups (back_to
);
1852 /* Ensure that the symbols for PER_CU have been read in. OBJFILE is
1853 the objfile from which this CU came. Returns the resulting symbol
1856 static struct symtab
*
1857 dw2_instantiate_symtab (struct dwarf2_per_cu_data
*per_cu
)
1859 if (!per_cu
->v
.quick
->symtab
)
1861 struct cleanup
*back_to
= make_cleanup (free_cached_comp_units
, NULL
);
1862 increment_reading_symtab ();
1863 dw2_do_instantiate_symtab (per_cu
);
1864 do_cleanups (back_to
);
1866 return per_cu
->v
.quick
->symtab
;
1869 /* Return the CU given its index. */
1871 static struct dwarf2_per_cu_data
*
1872 dw2_get_cu (int index
)
1874 if (index
>= dwarf2_per_objfile
->n_comp_units
)
1876 index
-= dwarf2_per_objfile
->n_comp_units
;
1877 return dwarf2_per_objfile
->type_comp_units
[index
];
1879 return dwarf2_per_objfile
->all_comp_units
[index
];
1882 /* A helper function that knows how to read a 64-bit value in a way
1883 that doesn't make gdb die. Returns 1 if the conversion went ok, 0
1887 extract_cu_value (const char *bytes
, ULONGEST
*result
)
1889 if (sizeof (ULONGEST
) < 8)
1893 /* Ignore the upper 4 bytes if they are all zero. */
1894 for (i
= 0; i
< 4; ++i
)
1895 if (bytes
[i
+ 4] != 0)
1898 *result
= extract_unsigned_integer (bytes
, 4, BFD_ENDIAN_LITTLE
);
1901 *result
= extract_unsigned_integer (bytes
, 8, BFD_ENDIAN_LITTLE
);
1905 /* Read the CU list from the mapped index, and use it to create all
1906 the CU objects for this objfile. Return 0 if something went wrong,
1907 1 if everything went ok. */
1910 create_cus_from_index (struct objfile
*objfile
, const gdb_byte
*cu_list
,
1911 offset_type cu_list_elements
)
1915 dwarf2_per_objfile
->n_comp_units
= cu_list_elements
/ 2;
1916 dwarf2_per_objfile
->all_comp_units
1917 = obstack_alloc (&objfile
->objfile_obstack
,
1918 dwarf2_per_objfile
->n_comp_units
1919 * sizeof (struct dwarf2_per_cu_data
*));
1921 for (i
= 0; i
< cu_list_elements
; i
+= 2)
1923 struct dwarf2_per_cu_data
*the_cu
;
1924 ULONGEST offset
, length
;
1926 if (!extract_cu_value (cu_list
, &offset
)
1927 || !extract_cu_value (cu_list
+ 8, &length
))
1931 the_cu
= OBSTACK_ZALLOC (&objfile
->objfile_obstack
,
1932 struct dwarf2_per_cu_data
);
1933 the_cu
->offset
= offset
;
1934 the_cu
->length
= length
;
1935 the_cu
->objfile
= objfile
;
1936 the_cu
->v
.quick
= OBSTACK_ZALLOC (&objfile
->objfile_obstack
,
1937 struct dwarf2_per_cu_quick_data
);
1938 dwarf2_per_objfile
->all_comp_units
[i
/ 2] = the_cu
;
1944 /* Create the signatured type hash table from the index. */
1947 create_signatured_type_table_from_index (struct objfile
*objfile
,
1948 struct dwarf2_section_info
*section
,
1949 const gdb_byte
*bytes
,
1950 offset_type elements
)
1953 htab_t sig_types_hash
;
1955 dwarf2_per_objfile
->n_type_comp_units
= elements
/ 3;
1956 dwarf2_per_objfile
->type_comp_units
1957 = obstack_alloc (&objfile
->objfile_obstack
,
1958 dwarf2_per_objfile
->n_type_comp_units
1959 * sizeof (struct dwarf2_per_cu_data
*));
1961 sig_types_hash
= allocate_signatured_type_table (objfile
);
1963 for (i
= 0; i
< elements
; i
+= 3)
1965 struct signatured_type
*type_sig
;
1966 ULONGEST offset
, type_offset
, signature
;
1969 if (!extract_cu_value (bytes
, &offset
)
1970 || !extract_cu_value (bytes
+ 8, &type_offset
))
1972 signature
= extract_unsigned_integer (bytes
+ 16, 8, BFD_ENDIAN_LITTLE
);
1975 type_sig
= OBSTACK_ZALLOC (&objfile
->objfile_obstack
,
1976 struct signatured_type
);
1977 type_sig
->signature
= signature
;
1978 type_sig
->type_offset
= type_offset
;
1979 type_sig
->per_cu
.debug_types_section
= section
;
1980 type_sig
->per_cu
.offset
= offset
;
1981 type_sig
->per_cu
.objfile
= objfile
;
1982 type_sig
->per_cu
.v
.quick
1983 = OBSTACK_ZALLOC (&objfile
->objfile_obstack
,
1984 struct dwarf2_per_cu_quick_data
);
1986 slot
= htab_find_slot (sig_types_hash
, type_sig
, INSERT
);
1989 dwarf2_per_objfile
->type_comp_units
[i
/ 3] = &type_sig
->per_cu
;
1992 dwarf2_per_objfile
->signatured_types
= sig_types_hash
;
1997 /* Read the address map data from the mapped index, and use it to
1998 populate the objfile's psymtabs_addrmap. */
2001 create_addrmap_from_index (struct objfile
*objfile
, struct mapped_index
*index
)
2003 const gdb_byte
*iter
, *end
;
2004 struct obstack temp_obstack
;
2005 struct addrmap
*mutable_map
;
2006 struct cleanup
*cleanup
;
2009 obstack_init (&temp_obstack
);
2010 cleanup
= make_cleanup_obstack_free (&temp_obstack
);
2011 mutable_map
= addrmap_create_mutable (&temp_obstack
);
2013 iter
= index
->address_table
;
2014 end
= iter
+ index
->address_table_size
;
2016 baseaddr
= ANOFFSET (objfile
->section_offsets
, SECT_OFF_TEXT (objfile
));
2020 ULONGEST hi
, lo
, cu_index
;
2021 lo
= extract_unsigned_integer (iter
, 8, BFD_ENDIAN_LITTLE
);
2023 hi
= extract_unsigned_integer (iter
, 8, BFD_ENDIAN_LITTLE
);
2025 cu_index
= extract_unsigned_integer (iter
, 4, BFD_ENDIAN_LITTLE
);
2028 addrmap_set_empty (mutable_map
, lo
+ baseaddr
, hi
+ baseaddr
- 1,
2029 dw2_get_cu (cu_index
));
2032 objfile
->psymtabs_addrmap
= addrmap_create_fixed (mutable_map
,
2033 &objfile
->objfile_obstack
);
2034 do_cleanups (cleanup
);
2037 /* The hash function for strings in the mapped index. This is the same as
2038 SYMBOL_HASH_NEXT, but we keep a separate copy to maintain control over the
2039 implementation. This is necessary because the hash function is tied to the
2040 format of the mapped index file. The hash values do not have to match with
2043 Use INT_MAX for INDEX_VERSION if you generate the current index format. */
2046 mapped_index_string_hash (int index_version
, const void *p
)
2048 const unsigned char *str
= (const unsigned char *) p
;
2052 while ((c
= *str
++) != 0)
2054 if (index_version
>= 5)
2056 r
= r
* 67 + c
- 113;
2062 /* Find a slot in the mapped index INDEX for the object named NAME.
2063 If NAME is found, set *VEC_OUT to point to the CU vector in the
2064 constant pool and return 1. If NAME cannot be found, return 0. */
2067 find_slot_in_mapped_hash (struct mapped_index
*index
, const char *name
,
2068 offset_type
**vec_out
)
2070 struct cleanup
*back_to
= make_cleanup (null_cleanup
, 0);
2072 offset_type slot
, step
;
2073 int (*cmp
) (const char *, const char *);
2075 if (current_language
->la_language
== language_cplus
2076 || current_language
->la_language
== language_java
2077 || current_language
->la_language
== language_fortran
)
2079 /* NAME is already canonical. Drop any qualifiers as .gdb_index does
2081 const char *paren
= strchr (name
, '(');
2087 dup
= xmalloc (paren
- name
+ 1);
2088 memcpy (dup
, name
, paren
- name
);
2089 dup
[paren
- name
] = 0;
2091 make_cleanup (xfree
, dup
);
2096 /* Index version 4 did not support case insensitive searches. But the
2097 indexes for case insensitive languages are built in lowercase, therefore
2098 simulate our NAME being searched is also lowercased. */
2099 hash
= mapped_index_string_hash ((index
->version
== 4
2100 && case_sensitivity
== case_sensitive_off
2101 ? 5 : index
->version
),
2104 slot
= hash
& (index
->symbol_table_slots
- 1);
2105 step
= ((hash
* 17) & (index
->symbol_table_slots
- 1)) | 1;
2106 cmp
= (case_sensitivity
== case_sensitive_on
? strcmp
: strcasecmp
);
2110 /* Convert a slot number to an offset into the table. */
2111 offset_type i
= 2 * slot
;
2113 if (index
->symbol_table
[i
] == 0 && index
->symbol_table
[i
+ 1] == 0)
2115 do_cleanups (back_to
);
2119 str
= index
->constant_pool
+ MAYBE_SWAP (index
->symbol_table
[i
]);
2120 if (!cmp (name
, str
))
2122 *vec_out
= (offset_type
*) (index
->constant_pool
2123 + MAYBE_SWAP (index
->symbol_table
[i
+ 1]));
2124 do_cleanups (back_to
);
2128 slot
= (slot
+ step
) & (index
->symbol_table_slots
- 1);
2132 /* Read the index file. If everything went ok, initialize the "quick"
2133 elements of all the CUs and return 1. Otherwise, return 0. */
2136 dwarf2_read_index (struct objfile
*objfile
)
2139 struct mapped_index
*map
;
2140 offset_type
*metadata
;
2141 const gdb_byte
*cu_list
;
2142 const gdb_byte
*types_list
= NULL
;
2143 offset_type version
, cu_list_elements
;
2144 offset_type types_list_elements
= 0;
2147 if (dwarf2_section_empty_p (&dwarf2_per_objfile
->gdb_index
))
2150 /* Older elfutils strip versions could keep the section in the main
2151 executable while splitting it for the separate debug info file. */
2152 if ((bfd_get_file_flags (dwarf2_per_objfile
->gdb_index
.asection
)
2153 & SEC_HAS_CONTENTS
) == 0)
2156 dwarf2_read_section (objfile
, &dwarf2_per_objfile
->gdb_index
);
2158 addr
= dwarf2_per_objfile
->gdb_index
.buffer
;
2159 /* Version check. */
2160 version
= MAYBE_SWAP (*(offset_type
*) addr
);
2161 /* Versions earlier than 3 emitted every copy of a psymbol. This
2162 causes the index to behave very poorly for certain requests. Version 3
2163 contained incomplete addrmap. So, it seems better to just ignore such
2164 indices. Index version 4 uses a different hash function than index
2165 version 5 and later. */
2168 /* Indexes with higher version than the one supported by GDB may be no
2169 longer backward compatible. */
2173 map
= OBSTACK_ZALLOC (&objfile
->objfile_obstack
, struct mapped_index
);
2174 map
->version
= version
;
2175 map
->total_size
= dwarf2_per_objfile
->gdb_index
.size
;
2177 metadata
= (offset_type
*) (addr
+ sizeof (offset_type
));
2180 cu_list
= addr
+ MAYBE_SWAP (metadata
[i
]);
2181 cu_list_elements
= ((MAYBE_SWAP (metadata
[i
+ 1]) - MAYBE_SWAP (metadata
[i
]))
2185 types_list
= addr
+ MAYBE_SWAP (metadata
[i
]);
2186 types_list_elements
= ((MAYBE_SWAP (metadata
[i
+ 1])
2187 - MAYBE_SWAP (metadata
[i
]))
2191 map
->address_table
= addr
+ MAYBE_SWAP (metadata
[i
]);
2192 map
->address_table_size
= (MAYBE_SWAP (metadata
[i
+ 1])
2193 - MAYBE_SWAP (metadata
[i
]));
2196 map
->symbol_table
= (offset_type
*) (addr
+ MAYBE_SWAP (metadata
[i
]));
2197 map
->symbol_table_slots
= ((MAYBE_SWAP (metadata
[i
+ 1])
2198 - MAYBE_SWAP (metadata
[i
]))
2199 / (2 * sizeof (offset_type
)));
2202 map
->constant_pool
= addr
+ MAYBE_SWAP (metadata
[i
]);
2204 if (!create_cus_from_index (objfile
, cu_list
, cu_list_elements
))
2207 if (types_list_elements
)
2209 struct dwarf2_section_info
*section
;
2211 /* We can only handle a single .debug_types when we have an
2213 if (VEC_length (dwarf2_section_info_def
, dwarf2_per_objfile
->types
) != 1)
2216 section
= VEC_index (dwarf2_section_info_def
,
2217 dwarf2_per_objfile
->types
, 0);
2219 if (!create_signatured_type_table_from_index (objfile
, section
,
2221 types_list_elements
))
2225 create_addrmap_from_index (objfile
, map
);
2227 dwarf2_per_objfile
->index_table
= map
;
2228 dwarf2_per_objfile
->using_index
= 1;
2229 dwarf2_per_objfile
->quick_file_names_table
=
2230 create_quick_file_names_table (dwarf2_per_objfile
->n_comp_units
);
2235 /* A helper for the "quick" functions which sets the global
2236 dwarf2_per_objfile according to OBJFILE. */
2239 dw2_setup (struct objfile
*objfile
)
2241 dwarf2_per_objfile
= objfile_data (objfile
, dwarf2_objfile_data_key
);
2242 gdb_assert (dwarf2_per_objfile
);
2245 /* A helper for the "quick" functions which attempts to read the line
2246 table for THIS_CU. */
2248 static struct quick_file_names
*
2249 dw2_get_file_names (struct objfile
*objfile
,
2250 struct dwarf2_per_cu_data
*this_cu
)
2252 bfd
*abfd
= objfile
->obfd
;
2253 struct line_header
*lh
;
2254 struct attribute
*attr
;
2255 struct cleanup
*cleanups
;
2256 struct die_info
*comp_unit_die
;
2257 struct dwarf2_section_info
* sec
;
2258 gdb_byte
*info_ptr
, *buffer
;
2259 int has_children
, i
;
2260 struct dwarf2_cu cu
;
2261 unsigned int bytes_read
, buffer_size
;
2262 struct die_reader_specs reader_specs
;
2263 char *name
, *comp_dir
;
2265 struct quick_file_names
*qfn
;
2266 unsigned int line_offset
;
2268 if (this_cu
->v
.quick
->file_names
!= NULL
)
2269 return this_cu
->v
.quick
->file_names
;
2270 /* If we know there is no line data, no point in looking again. */
2271 if (this_cu
->v
.quick
->no_file_data
)
2274 init_one_comp_unit (&cu
, this_cu
);
2275 cleanups
= make_cleanup (free_stack_comp_unit
, &cu
);
2277 if (this_cu
->debug_types_section
)
2278 sec
= this_cu
->debug_types_section
;
2280 sec
= &dwarf2_per_objfile
->info
;
2281 dwarf2_read_section (objfile
, sec
);
2282 buffer_size
= sec
->size
;
2283 buffer
= sec
->buffer
;
2284 info_ptr
= buffer
+ this_cu
->offset
;
2286 info_ptr
= partial_read_comp_unit_head (&cu
.header
, info_ptr
,
2287 buffer
, buffer_size
,
2289 this_cu
->debug_types_section
!= NULL
);
2291 /* Skip dummy compilation units. */
2292 if (info_ptr
>= buffer
+ buffer_size
2293 || peek_abbrev_code (abfd
, info_ptr
) == 0)
2295 do_cleanups (cleanups
);
2299 dwarf2_read_abbrevs (&cu
);
2300 make_cleanup (dwarf2_free_abbrev_table
, &cu
);
2302 init_cu_die_reader (&reader_specs
, &cu
);
2303 read_full_die (&reader_specs
, &comp_unit_die
, info_ptr
,
2309 attr
= dwarf2_attr (comp_unit_die
, DW_AT_stmt_list
, &cu
);
2312 struct quick_file_names find_entry
;
2314 line_offset
= DW_UNSND (attr
);
2316 /* We may have already read in this line header (TU line header sharing).
2317 If we have we're done. */
2318 find_entry
.offset
= line_offset
;
2319 slot
= htab_find_slot (dwarf2_per_objfile
->quick_file_names_table
,
2320 &find_entry
, INSERT
);
2323 do_cleanups (cleanups
);
2324 this_cu
->v
.quick
->file_names
= *slot
;
2328 lh
= dwarf_decode_line_header (line_offset
, abfd
, &cu
);
2332 do_cleanups (cleanups
);
2333 this_cu
->v
.quick
->no_file_data
= 1;
2337 qfn
= obstack_alloc (&objfile
->objfile_obstack
, sizeof (*qfn
));
2338 qfn
->offset
= line_offset
;
2339 gdb_assert (slot
!= NULL
);
2342 find_file_and_directory (comp_unit_die
, &cu
, &name
, &comp_dir
);
2344 qfn
->num_file_names
= lh
->num_file_names
;
2345 qfn
->file_names
= obstack_alloc (&objfile
->objfile_obstack
,
2346 lh
->num_file_names
* sizeof (char *));
2347 for (i
= 0; i
< lh
->num_file_names
; ++i
)
2348 qfn
->file_names
[i
] = file_full_name (i
+ 1, lh
, comp_dir
);
2349 qfn
->real_names
= NULL
;
2351 free_line_header (lh
);
2352 do_cleanups (cleanups
);
2354 this_cu
->v
.quick
->file_names
= qfn
;
2358 /* A helper for the "quick" functions which computes and caches the
2359 real path for a given file name from the line table. */
2362 dw2_get_real_path (struct objfile
*objfile
,
2363 struct quick_file_names
*qfn
, int index
)
2365 if (qfn
->real_names
== NULL
)
2366 qfn
->real_names
= OBSTACK_CALLOC (&objfile
->objfile_obstack
,
2367 qfn
->num_file_names
, sizeof (char *));
2369 if (qfn
->real_names
[index
] == NULL
)
2370 qfn
->real_names
[index
] = gdb_realpath (qfn
->file_names
[index
]);
2372 return qfn
->real_names
[index
];
2375 static struct symtab
*
2376 dw2_find_last_source_symtab (struct objfile
*objfile
)
2380 dw2_setup (objfile
);
2381 index
= dwarf2_per_objfile
->n_comp_units
- 1;
2382 return dw2_instantiate_symtab (dw2_get_cu (index
));
2385 /* Traversal function for dw2_forget_cached_source_info. */
2388 dw2_free_cached_file_names (void **slot
, void *info
)
2390 struct quick_file_names
*file_data
= (struct quick_file_names
*) *slot
;
2392 if (file_data
->real_names
)
2396 for (i
= 0; i
< file_data
->num_file_names
; ++i
)
2398 xfree ((void*) file_data
->real_names
[i
]);
2399 file_data
->real_names
[i
] = NULL
;
2407 dw2_forget_cached_source_info (struct objfile
*objfile
)
2409 dw2_setup (objfile
);
2411 htab_traverse_noresize (dwarf2_per_objfile
->quick_file_names_table
,
2412 dw2_free_cached_file_names
, NULL
);
2415 /* Helper function for dw2_map_symtabs_matching_filename that expands
2416 the symtabs and calls the iterator. */
2419 dw2_map_expand_apply (struct objfile
*objfile
,
2420 struct dwarf2_per_cu_data
*per_cu
,
2422 const char *full_path
, const char *real_path
,
2423 int (*callback
) (struct symtab
*, void *),
2426 struct symtab
*last_made
= objfile
->symtabs
;
2428 /* Don't visit already-expanded CUs. */
2429 if (per_cu
->v
.quick
->symtab
)
2432 /* This may expand more than one symtab, and we want to iterate over
2434 dw2_instantiate_symtab (per_cu
);
2436 return iterate_over_some_symtabs (name
, full_path
, real_path
, callback
, data
,
2437 objfile
->symtabs
, last_made
);
2440 /* Implementation of the map_symtabs_matching_filename method. */
2443 dw2_map_symtabs_matching_filename (struct objfile
*objfile
, const char *name
,
2444 const char *full_path
, const char *real_path
,
2445 int (*callback
) (struct symtab
*, void *),
2449 const char *name_basename
= lbasename (name
);
2450 int check_basename
= name_basename
== name
;
2451 struct dwarf2_per_cu_data
*base_cu
= NULL
;
2453 dw2_setup (objfile
);
2455 for (i
= 0; i
< (dwarf2_per_objfile
->n_comp_units
2456 + dwarf2_per_objfile
->n_type_comp_units
); ++i
)
2459 struct dwarf2_per_cu_data
*per_cu
= dw2_get_cu (i
);
2460 struct quick_file_names
*file_data
;
2462 /* We only need to look at symtabs not already expanded. */
2463 if (per_cu
->v
.quick
->symtab
)
2466 file_data
= dw2_get_file_names (objfile
, per_cu
);
2467 if (file_data
== NULL
)
2470 for (j
= 0; j
< file_data
->num_file_names
; ++j
)
2472 const char *this_name
= file_data
->file_names
[j
];
2474 if (FILENAME_CMP (name
, this_name
) == 0)
2476 if (dw2_map_expand_apply (objfile
, per_cu
,
2477 name
, full_path
, real_path
,
2482 if (check_basename
&& ! base_cu
2483 && FILENAME_CMP (lbasename (this_name
), name
) == 0)
2486 /* Before we invoke realpath, which can get expensive when many
2487 files are involved, do a quick comparison of the basenames. */
2488 if (! basenames_may_differ
2489 && FILENAME_CMP (lbasename (this_name
), name_basename
) != 0)
2492 if (full_path
!= NULL
)
2494 const char *this_real_name
= dw2_get_real_path (objfile
,
2497 if (this_real_name
!= NULL
2498 && FILENAME_CMP (full_path
, this_real_name
) == 0)
2500 if (dw2_map_expand_apply (objfile
, per_cu
,
2501 name
, full_path
, real_path
,
2507 if (real_path
!= NULL
)
2509 const char *this_real_name
= dw2_get_real_path (objfile
,
2512 if (this_real_name
!= NULL
2513 && FILENAME_CMP (real_path
, this_real_name
) == 0)
2515 if (dw2_map_expand_apply (objfile
, per_cu
,
2516 name
, full_path
, real_path
,
2526 if (dw2_map_expand_apply (objfile
, base_cu
,
2527 name
, full_path
, real_path
,
2535 static struct symtab
*
2536 dw2_lookup_symbol (struct objfile
*objfile
, int block_index
,
2537 const char *name
, domain_enum domain
)
2539 /* We do all the work in the pre_expand_symtabs_matching hook
2544 /* A helper function that expands all symtabs that hold an object
2548 dw2_do_expand_symtabs_matching (struct objfile
*objfile
, const char *name
)
2550 dw2_setup (objfile
);
2552 /* index_table is NULL if OBJF_READNOW. */
2553 if (dwarf2_per_objfile
->index_table
)
2557 if (find_slot_in_mapped_hash (dwarf2_per_objfile
->index_table
,
2560 offset_type i
, len
= MAYBE_SWAP (*vec
);
2561 for (i
= 0; i
< len
; ++i
)
2563 offset_type cu_index
= MAYBE_SWAP (vec
[i
+ 1]);
2564 struct dwarf2_per_cu_data
*per_cu
= dw2_get_cu (cu_index
);
2566 dw2_instantiate_symtab (per_cu
);
2573 dw2_pre_expand_symtabs_matching (struct objfile
*objfile
,
2574 enum block_enum block_kind
, const char *name
,
2577 dw2_do_expand_symtabs_matching (objfile
, name
);
2581 dw2_print_stats (struct objfile
*objfile
)
2585 dw2_setup (objfile
);
2587 for (i
= 0; i
< (dwarf2_per_objfile
->n_comp_units
2588 + dwarf2_per_objfile
->n_type_comp_units
); ++i
)
2590 struct dwarf2_per_cu_data
*per_cu
= dw2_get_cu (i
);
2592 if (!per_cu
->v
.quick
->symtab
)
2595 printf_filtered (_(" Number of unread CUs: %d\n"), count
);
2599 dw2_dump (struct objfile
*objfile
)
2601 /* Nothing worth printing. */
2605 dw2_relocate (struct objfile
*objfile
, struct section_offsets
*new_offsets
,
2606 struct section_offsets
*delta
)
2608 /* There's nothing to relocate here. */
2612 dw2_expand_symtabs_for_function (struct objfile
*objfile
,
2613 const char *func_name
)
2615 dw2_do_expand_symtabs_matching (objfile
, func_name
);
2619 dw2_expand_all_symtabs (struct objfile
*objfile
)
2623 dw2_setup (objfile
);
2625 for (i
= 0; i
< (dwarf2_per_objfile
->n_comp_units
2626 + dwarf2_per_objfile
->n_type_comp_units
); ++i
)
2628 struct dwarf2_per_cu_data
*per_cu
= dw2_get_cu (i
);
2630 dw2_instantiate_symtab (per_cu
);
2635 dw2_expand_symtabs_with_filename (struct objfile
*objfile
,
2636 const char *filename
)
2640 dw2_setup (objfile
);
2642 /* We don't need to consider type units here.
2643 This is only called for examining code, e.g. expand_line_sal.
2644 There can be an order of magnitude (or more) more type units
2645 than comp units, and we avoid them if we can. */
2647 for (i
= 0; i
< dwarf2_per_objfile
->n_comp_units
; ++i
)
2650 struct dwarf2_per_cu_data
*per_cu
= dw2_get_cu (i
);
2651 struct quick_file_names
*file_data
;
2653 /* We only need to look at symtabs not already expanded. */
2654 if (per_cu
->v
.quick
->symtab
)
2657 file_data
= dw2_get_file_names (objfile
, per_cu
);
2658 if (file_data
== NULL
)
2661 for (j
= 0; j
< file_data
->num_file_names
; ++j
)
2663 const char *this_name
= file_data
->file_names
[j
];
2664 if (FILENAME_CMP (this_name
, filename
) == 0)
2666 dw2_instantiate_symtab (per_cu
);
2674 dw2_find_symbol_file (struct objfile
*objfile
, const char *name
)
2676 struct dwarf2_per_cu_data
*per_cu
;
2678 struct quick_file_names
*file_data
;
2680 dw2_setup (objfile
);
2682 /* index_table is NULL if OBJF_READNOW. */
2683 if (!dwarf2_per_objfile
->index_table
)
2687 ALL_OBJFILE_SYMTABS (objfile
, s
)
2690 struct blockvector
*bv
= BLOCKVECTOR (s
);
2691 const struct block
*block
= BLOCKVECTOR_BLOCK (bv
, GLOBAL_BLOCK
);
2692 struct symbol
*sym
= lookup_block_symbol (block
, name
, VAR_DOMAIN
);
2695 return sym
->symtab
->filename
;
2700 if (!find_slot_in_mapped_hash (dwarf2_per_objfile
->index_table
,
2704 /* Note that this just looks at the very first one named NAME -- but
2705 actually we are looking for a function. find_main_filename
2706 should be rewritten so that it doesn't require a custom hook. It
2707 could just use the ordinary symbol tables. */
2708 /* vec[0] is the length, which must always be >0. */
2709 per_cu
= dw2_get_cu (MAYBE_SWAP (vec
[1]));
2711 file_data
= dw2_get_file_names (objfile
, per_cu
);
2712 if (file_data
== NULL
)
2715 return file_data
->file_names
[file_data
->num_file_names
- 1];
2719 dw2_map_matching_symbols (const char * name
, domain_enum
namespace,
2720 struct objfile
*objfile
, int global
,
2721 int (*callback
) (struct block
*,
2722 struct symbol
*, void *),
2723 void *data
, symbol_compare_ftype
*match
,
2724 symbol_compare_ftype
*ordered_compare
)
2726 /* Currently unimplemented; used for Ada. The function can be called if the
2727 current language is Ada for a non-Ada objfile using GNU index. As Ada
2728 does not look for non-Ada symbols this function should just return. */
2732 dw2_expand_symtabs_matching
2733 (struct objfile
*objfile
,
2734 int (*file_matcher
) (const char *, void *),
2735 int (*name_matcher
) (const struct language_defn
*, const char *, void *),
2736 enum search_domain kind
,
2741 struct mapped_index
*index
;
2743 dw2_setup (objfile
);
2745 /* index_table is NULL if OBJF_READNOW. */
2746 if (!dwarf2_per_objfile
->index_table
)
2748 index
= dwarf2_per_objfile
->index_table
;
2750 if (file_matcher
!= NULL
)
2751 for (i
= 0; i
< (dwarf2_per_objfile
->n_comp_units
2752 + dwarf2_per_objfile
->n_type_comp_units
); ++i
)
2755 struct dwarf2_per_cu_data
*per_cu
= dw2_get_cu (i
);
2756 struct quick_file_names
*file_data
;
2758 per_cu
->v
.quick
->mark
= 0;
2760 /* We only need to look at symtabs not already expanded. */
2761 if (per_cu
->v
.quick
->symtab
)
2764 file_data
= dw2_get_file_names (objfile
, per_cu
);
2765 if (file_data
== NULL
)
2768 for (j
= 0; j
< file_data
->num_file_names
; ++j
)
2770 if (file_matcher (file_data
->file_names
[j
], data
))
2772 per_cu
->v
.quick
->mark
= 1;
2778 for (iter
= 0; iter
< index
->symbol_table_slots
; ++iter
)
2780 offset_type idx
= 2 * iter
;
2782 offset_type
*vec
, vec_len
, vec_idx
;
2784 if (index
->symbol_table
[idx
] == 0 && index
->symbol_table
[idx
+ 1] == 0)
2787 name
= index
->constant_pool
+ MAYBE_SWAP (index
->symbol_table
[idx
]);
2789 if (! (*name_matcher
) (current_language
, name
, data
))
2792 /* The name was matched, now expand corresponding CUs that were
2794 vec
= (offset_type
*) (index
->constant_pool
2795 + MAYBE_SWAP (index
->symbol_table
[idx
+ 1]));
2796 vec_len
= MAYBE_SWAP (vec
[0]);
2797 for (vec_idx
= 0; vec_idx
< vec_len
; ++vec_idx
)
2799 struct dwarf2_per_cu_data
*per_cu
;
2801 per_cu
= dw2_get_cu (MAYBE_SWAP (vec
[vec_idx
+ 1]));
2802 if (file_matcher
== NULL
|| per_cu
->v
.quick
->mark
)
2803 dw2_instantiate_symtab (per_cu
);
2808 static struct symtab
*
2809 dw2_find_pc_sect_symtab (struct objfile
*objfile
,
2810 struct minimal_symbol
*msymbol
,
2812 struct obj_section
*section
,
2815 struct dwarf2_per_cu_data
*data
;
2817 dw2_setup (objfile
);
2819 if (!objfile
->psymtabs_addrmap
)
2822 data
= addrmap_find (objfile
->psymtabs_addrmap
, pc
);
2826 if (warn_if_readin
&& data
->v
.quick
->symtab
)
2827 warning (_("(Internal error: pc %s in read in CU, but not in symtab.)"),
2828 paddress (get_objfile_arch (objfile
), pc
));
2830 return dw2_instantiate_symtab (data
);
2834 dw2_map_symbol_filenames (struct objfile
*objfile
, symbol_filename_ftype
*fun
,
2835 void *data
, int need_fullname
)
2839 dw2_setup (objfile
);
2841 for (i
= 0; i
< (dwarf2_per_objfile
->n_comp_units
2842 + dwarf2_per_objfile
->n_type_comp_units
); ++i
)
2845 struct dwarf2_per_cu_data
*per_cu
= dw2_get_cu (i
);
2846 struct quick_file_names
*file_data
;
2848 /* We only need to look at symtabs not already expanded. */
2849 if (per_cu
->v
.quick
->symtab
)
2852 file_data
= dw2_get_file_names (objfile
, per_cu
);
2853 if (file_data
== NULL
)
2856 for (j
= 0; j
< file_data
->num_file_names
; ++j
)
2858 const char *this_real_name
;
2861 this_real_name
= dw2_get_real_path (objfile
, file_data
, j
);
2863 this_real_name
= NULL
;
2864 (*fun
) (file_data
->file_names
[j
], this_real_name
, data
);
2870 dw2_has_symbols (struct objfile
*objfile
)
2875 const struct quick_symbol_functions dwarf2_gdb_index_functions
=
2878 dw2_find_last_source_symtab
,
2879 dw2_forget_cached_source_info
,
2880 dw2_map_symtabs_matching_filename
,
2882 dw2_pre_expand_symtabs_matching
,
2886 dw2_expand_symtabs_for_function
,
2887 dw2_expand_all_symtabs
,
2888 dw2_expand_symtabs_with_filename
,
2889 dw2_find_symbol_file
,
2890 dw2_map_matching_symbols
,
2891 dw2_expand_symtabs_matching
,
2892 dw2_find_pc_sect_symtab
,
2893 dw2_map_symbol_filenames
2896 /* Initialize for reading DWARF for this objfile. Return 0 if this
2897 file will use psymtabs, or 1 if using the GNU index. */
2900 dwarf2_initialize_objfile (struct objfile
*objfile
)
2902 /* If we're about to read full symbols, don't bother with the
2903 indices. In this case we also don't care if some other debug
2904 format is making psymtabs, because they are all about to be
2906 if ((objfile
->flags
& OBJF_READNOW
))
2910 dwarf2_per_objfile
->using_index
= 1;
2911 create_all_comp_units (objfile
);
2912 create_debug_types_hash_table (objfile
);
2913 dwarf2_per_objfile
->quick_file_names_table
=
2914 create_quick_file_names_table (dwarf2_per_objfile
->n_comp_units
);
2916 for (i
= 0; i
< (dwarf2_per_objfile
->n_comp_units
2917 + dwarf2_per_objfile
->n_type_comp_units
); ++i
)
2919 struct dwarf2_per_cu_data
*per_cu
= dw2_get_cu (i
);
2921 per_cu
->v
.quick
= OBSTACK_ZALLOC (&objfile
->objfile_obstack
,
2922 struct dwarf2_per_cu_quick_data
);
2925 /* Return 1 so that gdb sees the "quick" functions. However,
2926 these functions will be no-ops because we will have expanded
2931 if (dwarf2_read_index (objfile
))
2939 /* Build a partial symbol table. */
2942 dwarf2_build_psymtabs (struct objfile
*objfile
)
2944 if (objfile
->global_psymbols
.size
== 0 && objfile
->static_psymbols
.size
== 0)
2946 init_psymbol_list (objfile
, 1024);
2949 dwarf2_build_psymtabs_hard (objfile
);
2952 /* Return TRUE if OFFSET is within CU_HEADER. */
2955 offset_in_cu_p (const struct comp_unit_head
*cu_header
, unsigned int offset
)
2957 unsigned int bottom
= cu_header
->offset
;
2958 unsigned int top
= (cu_header
->offset
2960 + cu_header
->initial_length_size
);
2962 return (offset
>= bottom
&& offset
< top
);
2965 /* Read in the comp unit header information from the debug_info at info_ptr.
2966 NOTE: This leaves members offset, first_die_offset to be filled in
2970 read_comp_unit_head (struct comp_unit_head
*cu_header
,
2971 gdb_byte
*info_ptr
, bfd
*abfd
)
2974 unsigned int bytes_read
;
2976 cu_header
->length
= read_initial_length (abfd
, info_ptr
, &bytes_read
);
2977 cu_header
->initial_length_size
= bytes_read
;
2978 cu_header
->offset_size
= (bytes_read
== 4) ? 4 : 8;
2979 info_ptr
+= bytes_read
;
2980 cu_header
->version
= read_2_bytes (abfd
, info_ptr
);
2982 cu_header
->abbrev_offset
= read_offset (abfd
, info_ptr
, cu_header
,
2984 info_ptr
+= bytes_read
;
2985 cu_header
->addr_size
= read_1_byte (abfd
, info_ptr
);
2987 signed_addr
= bfd_get_sign_extend_vma (abfd
);
2988 if (signed_addr
< 0)
2989 internal_error (__FILE__
, __LINE__
,
2990 _("read_comp_unit_head: dwarf from non elf file"));
2991 cu_header
->signed_addr_p
= signed_addr
;
2996 /* Read in a CU header and perform some basic error checking. */
2999 partial_read_comp_unit_head (struct comp_unit_head
*header
, gdb_byte
*info_ptr
,
3000 gdb_byte
*buffer
, unsigned int buffer_size
,
3001 bfd
*abfd
, int is_debug_types_section
)
3003 gdb_byte
*beg_of_comp_unit
= info_ptr
;
3005 header
->offset
= beg_of_comp_unit
- buffer
;
3007 info_ptr
= read_comp_unit_head (header
, info_ptr
, abfd
);
3009 /* If we're reading a type unit, skip over the signature and
3010 type_offset fields. */
3011 if (is_debug_types_section
)
3012 info_ptr
+= 8 /*signature*/ + header
->offset_size
;
3014 header
->first_die_offset
= info_ptr
- beg_of_comp_unit
;
3016 if (header
->version
!= 2 && header
->version
!= 3 && header
->version
!= 4)
3017 error (_("Dwarf Error: wrong version in compilation unit header "
3018 "(is %d, should be 2, 3, or 4) [in module %s]"), header
->version
,
3019 bfd_get_filename (abfd
));
3021 if (header
->abbrev_offset
3022 >= dwarf2_section_size (dwarf2_per_objfile
->objfile
,
3023 &dwarf2_per_objfile
->abbrev
))
3024 error (_("Dwarf Error: bad offset (0x%lx) in compilation unit header "
3025 "(offset 0x%lx + 6) [in module %s]"),
3026 (long) header
->abbrev_offset
,
3027 (long) (beg_of_comp_unit
- buffer
),
3028 bfd_get_filename (abfd
));
3030 if (beg_of_comp_unit
+ header
->length
+ header
->initial_length_size
3031 > buffer
+ buffer_size
)
3032 error (_("Dwarf Error: bad length (0x%lx) in compilation unit header "
3033 "(offset 0x%lx + 0) [in module %s]"),
3034 (long) header
->length
,
3035 (long) (beg_of_comp_unit
- buffer
),
3036 bfd_get_filename (abfd
));
3041 /* Read in the types comp unit header information from .debug_types entry at
3042 types_ptr. The result is a pointer to one past the end of the header. */
3045 read_type_comp_unit_head (struct comp_unit_head
*cu_header
,
3046 struct dwarf2_section_info
*section
,
3047 ULONGEST
*signature
,
3048 gdb_byte
*types_ptr
, bfd
*abfd
)
3050 gdb_byte
*initial_types_ptr
= types_ptr
;
3052 dwarf2_read_section (dwarf2_per_objfile
->objfile
, section
);
3053 cu_header
->offset
= types_ptr
- section
->buffer
;
3055 types_ptr
= read_comp_unit_head (cu_header
, types_ptr
, abfd
);
3057 *signature
= read_8_bytes (abfd
, types_ptr
);
3059 types_ptr
+= cu_header
->offset_size
;
3060 cu_header
->first_die_offset
= types_ptr
- initial_types_ptr
;
3065 /* Allocate a new partial symtab for file named NAME and mark this new
3066 partial symtab as being an include of PST. */
3069 dwarf2_create_include_psymtab (char *name
, struct partial_symtab
*pst
,
3070 struct objfile
*objfile
)
3072 struct partial_symtab
*subpst
= allocate_psymtab (name
, objfile
);
3074 subpst
->section_offsets
= pst
->section_offsets
;
3075 subpst
->textlow
= 0;
3076 subpst
->texthigh
= 0;
3078 subpst
->dependencies
= (struct partial_symtab
**)
3079 obstack_alloc (&objfile
->objfile_obstack
,
3080 sizeof (struct partial_symtab
*));
3081 subpst
->dependencies
[0] = pst
;
3082 subpst
->number_of_dependencies
= 1;
3084 subpst
->globals_offset
= 0;
3085 subpst
->n_global_syms
= 0;
3086 subpst
->statics_offset
= 0;
3087 subpst
->n_static_syms
= 0;
3088 subpst
->symtab
= NULL
;
3089 subpst
->read_symtab
= pst
->read_symtab
;
3092 /* No private part is necessary for include psymtabs. This property
3093 can be used to differentiate between such include psymtabs and
3094 the regular ones. */
3095 subpst
->read_symtab_private
= NULL
;
3098 /* Read the Line Number Program data and extract the list of files
3099 included by the source file represented by PST. Build an include
3100 partial symtab for each of these included files. */
3103 dwarf2_build_include_psymtabs (struct dwarf2_cu
*cu
,
3104 struct die_info
*die
,
3105 struct partial_symtab
*pst
)
3107 struct objfile
*objfile
= cu
->objfile
;
3108 bfd
*abfd
= objfile
->obfd
;
3109 struct line_header
*lh
= NULL
;
3110 struct attribute
*attr
;
3112 attr
= dwarf2_attr (die
, DW_AT_stmt_list
, cu
);
3115 unsigned int line_offset
= DW_UNSND (attr
);
3117 lh
= dwarf_decode_line_header (line_offset
, abfd
, cu
);
3120 return; /* No linetable, so no includes. */
3122 /* NOTE: pst->dirname is DW_AT_comp_dir (if present). */
3123 dwarf_decode_lines (lh
, pst
->dirname
, abfd
, cu
, pst
);
3125 free_line_header (lh
);
3129 hash_type_signature (const void *item
)
3131 const struct signatured_type
*type_sig
= item
;
3133 /* This drops the top 32 bits of the signature, but is ok for a hash. */
3134 return type_sig
->signature
;
3138 eq_type_signature (const void *item_lhs
, const void *item_rhs
)
3140 const struct signatured_type
*lhs
= item_lhs
;
3141 const struct signatured_type
*rhs
= item_rhs
;
3143 return lhs
->signature
== rhs
->signature
;
3146 /* Allocate a hash table for signatured types. */
3149 allocate_signatured_type_table (struct objfile
*objfile
)
3151 return htab_create_alloc_ex (41,
3152 hash_type_signature
,
3155 &objfile
->objfile_obstack
,
3156 hashtab_obstack_allocate
,
3157 dummy_obstack_deallocate
);
3160 /* A helper function to add a signatured type CU to a list. */
3163 add_signatured_type_cu_to_list (void **slot
, void *datum
)
3165 struct signatured_type
*sigt
= *slot
;
3166 struct dwarf2_per_cu_data
***datap
= datum
;
3168 **datap
= &sigt
->per_cu
;
3174 /* Create the hash table of all entries in the .debug_types section.
3175 The result is zero if there is an error (e.g. missing .debug_types section),
3176 otherwise non-zero. */
3179 create_debug_types_hash_table (struct objfile
*objfile
)
3181 htab_t types_htab
= NULL
;
3182 struct dwarf2_per_cu_data
**iter
;
3184 struct dwarf2_section_info
*section
;
3186 if (VEC_empty (dwarf2_section_info_def
, dwarf2_per_objfile
->types
))
3188 dwarf2_per_objfile
->signatured_types
= NULL
;
3193 VEC_iterate (dwarf2_section_info_def
, dwarf2_per_objfile
->types
,
3197 gdb_byte
*info_ptr
, *end_ptr
;
3199 dwarf2_read_section (objfile
, section
);
3200 info_ptr
= section
->buffer
;
3202 if (info_ptr
== NULL
)
3205 if (types_htab
== NULL
)
3206 types_htab
= allocate_signatured_type_table (objfile
);
3208 if (dwarf2_die_debug
)
3209 fprintf_unfiltered (gdb_stdlog
, "Signatured types:\n");
3211 end_ptr
= info_ptr
+ section
->size
;
3212 while (info_ptr
< end_ptr
)
3214 unsigned int offset
;
3215 unsigned int offset_size
;
3216 unsigned int type_offset
;
3217 unsigned int length
, initial_length_size
;
3218 unsigned short version
;
3220 struct signatured_type
*type_sig
;
3222 gdb_byte
*ptr
= info_ptr
;
3224 offset
= ptr
- section
->buffer
;
3226 /* We need to read the type's signature in order to build the hash
3227 table, but we don't need to read anything else just yet. */
3229 /* Sanity check to ensure entire cu is present. */
3230 length
= read_initial_length (objfile
->obfd
, ptr
,
3231 &initial_length_size
);
3232 if (ptr
+ length
+ initial_length_size
> end_ptr
)
3234 complaint (&symfile_complaints
,
3235 _("debug type entry runs off end "
3236 "of `.debug_types' section, ignored"));
3240 offset_size
= initial_length_size
== 4 ? 4 : 8;
3241 ptr
+= initial_length_size
;
3242 version
= bfd_get_16 (objfile
->obfd
, ptr
);
3244 ptr
+= offset_size
; /* abbrev offset */
3245 ptr
+= 1; /* address size */
3246 signature
= bfd_get_64 (objfile
->obfd
, ptr
);
3248 type_offset
= read_offset_1 (objfile
->obfd
, ptr
, offset_size
);
3251 /* Skip dummy type units. */
3252 if (ptr
>= end_ptr
|| peek_abbrev_code (objfile
->obfd
, ptr
) == 0)
3254 info_ptr
= info_ptr
+ initial_length_size
+ length
;
3258 type_sig
= obstack_alloc (&objfile
->objfile_obstack
, sizeof (*type_sig
));
3259 memset (type_sig
, 0, sizeof (*type_sig
));
3260 type_sig
->signature
= signature
;
3261 type_sig
->type_offset
= type_offset
;
3262 type_sig
->per_cu
.objfile
= objfile
;
3263 type_sig
->per_cu
.debug_types_section
= section
;
3264 type_sig
->per_cu
.offset
= offset
;
3266 slot
= htab_find_slot (types_htab
, type_sig
, INSERT
);
3267 gdb_assert (slot
!= NULL
);
3270 const struct signatured_type
*dup_sig
= *slot
;
3272 complaint (&symfile_complaints
,
3273 _("debug type entry at offset 0x%x is duplicate to the "
3274 "entry at offset 0x%x, signature 0x%s"),
3275 offset
, dup_sig
->per_cu
.offset
,
3276 phex (signature
, sizeof (signature
)));
3277 gdb_assert (signature
== dup_sig
->signature
);
3281 if (dwarf2_die_debug
)
3282 fprintf_unfiltered (gdb_stdlog
, " offset 0x%x, signature 0x%s\n",
3283 offset
, phex (signature
, sizeof (signature
)));
3285 info_ptr
= info_ptr
+ initial_length_size
+ length
;
3289 dwarf2_per_objfile
->signatured_types
= types_htab
;
3291 dwarf2_per_objfile
->n_type_comp_units
= htab_elements (types_htab
);
3292 dwarf2_per_objfile
->type_comp_units
3293 = obstack_alloc (&objfile
->objfile_obstack
,
3294 dwarf2_per_objfile
->n_type_comp_units
3295 * sizeof (struct dwarf2_per_cu_data
*));
3296 iter
= &dwarf2_per_objfile
->type_comp_units
[0];
3297 htab_traverse_noresize (types_htab
, add_signatured_type_cu_to_list
, &iter
);
3298 gdb_assert (iter
- &dwarf2_per_objfile
->type_comp_units
[0]
3299 == dwarf2_per_objfile
->n_type_comp_units
);
3304 /* Lookup a signature based type.
3305 Returns NULL if SIG is not present in the table. */
3307 static struct signatured_type
*
3308 lookup_signatured_type (struct objfile
*objfile
, ULONGEST sig
)
3310 struct signatured_type find_entry
, *entry
;
3312 if (dwarf2_per_objfile
->signatured_types
== NULL
)
3314 complaint (&symfile_complaints
,
3315 _("missing `.debug_types' section for DW_FORM_ref_sig8 die"));
3319 find_entry
.signature
= sig
;
3320 entry
= htab_find (dwarf2_per_objfile
->signatured_types
, &find_entry
);
3324 /* Initialize a die_reader_specs struct from a dwarf2_cu struct. */
3327 init_cu_die_reader (struct die_reader_specs
*reader
,
3328 struct dwarf2_cu
*cu
)
3330 reader
->abfd
= cu
->objfile
->obfd
;
3332 if (cu
->per_cu
->debug_types_section
)
3334 gdb_assert (cu
->per_cu
->debug_types_section
->readin
);
3335 reader
->buffer
= cu
->per_cu
->debug_types_section
->buffer
;
3339 gdb_assert (dwarf2_per_objfile
->info
.readin
);
3340 reader
->buffer
= dwarf2_per_objfile
->info
.buffer
;
3344 /* Find the base address of the compilation unit for range lists and
3345 location lists. It will normally be specified by DW_AT_low_pc.
3346 In DWARF-3 draft 4, the base address could be overridden by
3347 DW_AT_entry_pc. It's been removed, but GCC still uses this for
3348 compilation units with discontinuous ranges. */
3351 dwarf2_find_base_address (struct die_info
*die
, struct dwarf2_cu
*cu
)
3353 struct attribute
*attr
;
3356 cu
->base_address
= 0;
3358 attr
= dwarf2_attr (die
, DW_AT_entry_pc
, cu
);
3361 cu
->base_address
= DW_ADDR (attr
);
3366 attr
= dwarf2_attr (die
, DW_AT_low_pc
, cu
);
3369 cu
->base_address
= DW_ADDR (attr
);
3375 /* Subroutine of process_type_comp_unit and dwarf2_build_psymtabs_hard
3376 to combine the common parts.
3377 Process a compilation unit for a psymtab.
3378 BUFFER is a pointer to the beginning of the dwarf section buffer,
3379 either .debug_info or debug_types.
3380 INFO_PTR is a pointer to the start of the CU.
3381 Returns a pointer to the next CU. */
3384 process_psymtab_comp_unit (struct dwarf2_per_cu_data
*this_cu
,
3385 gdb_byte
*buffer
, gdb_byte
*info_ptr
,
3386 unsigned int buffer_size
)
3388 struct objfile
*objfile
= this_cu
->objfile
;
3389 bfd
*abfd
= objfile
->obfd
;
3390 gdb_byte
*beg_of_comp_unit
= info_ptr
;
3391 struct die_info
*comp_unit_die
;
3392 struct partial_symtab
*pst
;
3394 struct cleanup
*back_to_inner
;
3395 struct dwarf2_cu cu
;
3396 int has_children
, has_pc_info
;
3397 struct attribute
*attr
;
3398 CORE_ADDR best_lowpc
= 0, best_highpc
= 0;
3399 struct die_reader_specs reader_specs
;
3400 const char *filename
;
3402 /* If this compilation unit was already read in, free the
3403 cached copy in order to read it in again. This is
3404 necessary because we skipped some symbols when we first
3405 read in the compilation unit (see load_partial_dies).
3406 This problem could be avoided, but the benefit is
3408 if (this_cu
->cu
!= NULL
)
3409 free_one_cached_comp_unit (this_cu
->cu
);
3411 /* Note that this is a pointer to our stack frame, being
3412 added to a global data structure. It will be cleaned up
3413 in free_stack_comp_unit when we finish with this
3414 compilation unit. */
3415 init_one_comp_unit (&cu
, this_cu
);
3416 back_to_inner
= make_cleanup (free_stack_comp_unit
, &cu
);
3418 info_ptr
= partial_read_comp_unit_head (&cu
.header
, info_ptr
,
3419 buffer
, buffer_size
,
3421 this_cu
->debug_types_section
!= NULL
);
3423 /* Skip dummy compilation units. */
3424 if (info_ptr
>= buffer
+ buffer_size
3425 || peek_abbrev_code (abfd
, info_ptr
) == 0)
3427 info_ptr
= (beg_of_comp_unit
+ cu
.header
.length
3428 + cu
.header
.initial_length_size
);
3429 do_cleanups (back_to_inner
);
3433 cu
.list_in_scope
= &file_symbols
;
3435 /* Read the abbrevs for this compilation unit into a table. */
3436 dwarf2_read_abbrevs (&cu
);
3437 make_cleanup (dwarf2_free_abbrev_table
, &cu
);
3439 /* Read the compilation unit die. */
3440 init_cu_die_reader (&reader_specs
, &cu
);
3441 info_ptr
= read_full_die (&reader_specs
, &comp_unit_die
, info_ptr
,
3444 if (this_cu
->debug_types_section
)
3446 /* LENGTH has not been set yet for type units. */
3447 gdb_assert (this_cu
->offset
== cu
.header
.offset
);
3448 this_cu
->length
= cu
.header
.length
+ cu
.header
.initial_length_size
;
3450 else if (comp_unit_die
->tag
== DW_TAG_partial_unit
)
3452 info_ptr
= (beg_of_comp_unit
+ cu
.header
.length
3453 + cu
.header
.initial_length_size
);
3454 do_cleanups (back_to_inner
);
3458 prepare_one_comp_unit (&cu
, comp_unit_die
);
3460 /* Allocate a new partial symbol table structure. */
3461 attr
= dwarf2_attr (comp_unit_die
, DW_AT_name
, &cu
);
3462 if (attr
== NULL
|| !DW_STRING (attr
))
3465 filename
= DW_STRING (attr
);
3466 pst
= start_psymtab_common (objfile
, objfile
->section_offsets
,
3468 /* TEXTLOW and TEXTHIGH are set below. */
3470 objfile
->global_psymbols
.next
,
3471 objfile
->static_psymbols
.next
);
3472 pst
->psymtabs_addrmap_supported
= 1;
3474 attr
= dwarf2_attr (comp_unit_die
, DW_AT_comp_dir
, &cu
);
3476 pst
->dirname
= DW_STRING (attr
);
3478 pst
->read_symtab_private
= this_cu
;
3480 baseaddr
= ANOFFSET (objfile
->section_offsets
, SECT_OFF_TEXT (objfile
));
3482 /* Store the function that reads in the rest of the symbol table. */
3483 pst
->read_symtab
= dwarf2_psymtab_to_symtab
;
3485 this_cu
->v
.psymtab
= pst
;
3487 dwarf2_find_base_address (comp_unit_die
, &cu
);
3489 /* Possibly set the default values of LOWPC and HIGHPC from
3491 has_pc_info
= dwarf2_get_pc_bounds (comp_unit_die
, &best_lowpc
,
3492 &best_highpc
, &cu
, pst
);
3493 if (has_pc_info
== 1 && best_lowpc
< best_highpc
)
3494 /* Store the contiguous range if it is not empty; it can be empty for
3495 CUs with no code. */
3496 addrmap_set_empty (objfile
->psymtabs_addrmap
,
3497 best_lowpc
+ baseaddr
,
3498 best_highpc
+ baseaddr
- 1, pst
);
3500 /* Check if comp unit has_children.
3501 If so, read the rest of the partial symbols from this comp unit.
3502 If not, there's no more debug_info for this comp unit. */
3505 struct partial_die_info
*first_die
;
3506 CORE_ADDR lowpc
, highpc
;
3508 lowpc
= ((CORE_ADDR
) -1);
3509 highpc
= ((CORE_ADDR
) 0);
3511 first_die
= load_partial_dies (abfd
, buffer
, info_ptr
, 1, &cu
);
3513 scan_partial_symbols (first_die
, &lowpc
, &highpc
,
3514 ! has_pc_info
, &cu
);
3516 /* If we didn't find a lowpc, set it to highpc to avoid
3517 complaints from `maint check'. */
3518 if (lowpc
== ((CORE_ADDR
) -1))
3521 /* If the compilation unit didn't have an explicit address range,
3522 then use the information extracted from its child dies. */
3526 best_highpc
= highpc
;
3529 pst
->textlow
= best_lowpc
+ baseaddr
;
3530 pst
->texthigh
= best_highpc
+ baseaddr
;
3532 pst
->n_global_syms
= objfile
->global_psymbols
.next
-
3533 (objfile
->global_psymbols
.list
+ pst
->globals_offset
);
3534 pst
->n_static_syms
= objfile
->static_psymbols
.next
-
3535 (objfile
->static_psymbols
.list
+ pst
->statics_offset
);
3536 sort_pst_symbols (pst
);
3538 info_ptr
= (beg_of_comp_unit
+ cu
.header
.length
3539 + cu
.header
.initial_length_size
);
3541 if (this_cu
->debug_types_section
)
3543 /* It's not clear we want to do anything with stmt lists here.
3544 Waiting to see what gcc ultimately does. */
3548 /* Get the list of files included in the current compilation unit,
3549 and build a psymtab for each of them. */
3550 dwarf2_build_include_psymtabs (&cu
, comp_unit_die
, pst
);
3553 do_cleanups (back_to_inner
);
3558 /* Traversal function for htab_traverse_noresize.
3559 Process one .debug_types comp-unit. */
3562 process_type_comp_unit (void **slot
, void *info
)
3564 struct signatured_type
*entry
= (struct signatured_type
*) *slot
;
3565 struct dwarf2_per_cu_data
*this_cu
;
3567 gdb_assert (info
== NULL
);
3568 this_cu
= &entry
->per_cu
;
3570 gdb_assert (this_cu
->debug_types_section
->readin
);
3571 process_psymtab_comp_unit (this_cu
,
3572 this_cu
->debug_types_section
->buffer
,
3573 (this_cu
->debug_types_section
->buffer
3575 this_cu
->debug_types_section
->size
);
3580 /* Subroutine of dwarf2_build_psymtabs_hard to simplify it.
3581 Build partial symbol tables for the .debug_types comp-units. */
3584 build_type_psymtabs (struct objfile
*objfile
)
3586 if (! create_debug_types_hash_table (objfile
))
3589 htab_traverse_noresize (dwarf2_per_objfile
->signatured_types
,
3590 process_type_comp_unit
, NULL
);
3593 /* A cleanup function that clears objfile's psymtabs_addrmap field. */
3596 psymtabs_addrmap_cleanup (void *o
)
3598 struct objfile
*objfile
= o
;
3600 objfile
->psymtabs_addrmap
= NULL
;
3603 /* Build the partial symbol table by doing a quick pass through the
3604 .debug_info and .debug_abbrev sections. */
3607 dwarf2_build_psymtabs_hard (struct objfile
*objfile
)
3610 struct cleanup
*back_to
, *addrmap_cleanup
;
3611 struct obstack temp_obstack
;
3613 dwarf2_per_objfile
->reading_partial_symbols
= 1;
3615 dwarf2_read_section (objfile
, &dwarf2_per_objfile
->info
);
3616 info_ptr
= dwarf2_per_objfile
->info
.buffer
;
3618 /* Any cached compilation units will be linked by the per-objfile
3619 read_in_chain. Make sure to free them when we're done. */
3620 back_to
= make_cleanup (free_cached_comp_units
, NULL
);
3622 build_type_psymtabs (objfile
);
3624 create_all_comp_units (objfile
);
3626 /* Create a temporary address map on a temporary obstack. We later
3627 copy this to the final obstack. */
3628 obstack_init (&temp_obstack
);
3629 make_cleanup_obstack_free (&temp_obstack
);
3630 objfile
->psymtabs_addrmap
= addrmap_create_mutable (&temp_obstack
);
3631 addrmap_cleanup
= make_cleanup (psymtabs_addrmap_cleanup
, objfile
);
3633 /* Since the objects we're extracting from .debug_info vary in
3634 length, only the individual functions to extract them (like
3635 read_comp_unit_head and load_partial_die) can really know whether
3636 the buffer is large enough to hold another complete object.
3638 At the moment, they don't actually check that. If .debug_info
3639 holds just one extra byte after the last compilation unit's dies,
3640 then read_comp_unit_head will happily read off the end of the
3641 buffer. read_partial_die is similarly casual. Those functions
3644 For this loop condition, simply checking whether there's any data
3645 left at all should be sufficient. */
3647 while (info_ptr
< (dwarf2_per_objfile
->info
.buffer
3648 + dwarf2_per_objfile
->info
.size
))
3650 struct dwarf2_per_cu_data
*this_cu
;
3652 this_cu
= dwarf2_find_comp_unit (info_ptr
3653 - dwarf2_per_objfile
->info
.buffer
,
3656 info_ptr
= process_psymtab_comp_unit (this_cu
,
3657 dwarf2_per_objfile
->info
.buffer
,
3659 dwarf2_per_objfile
->info
.size
);
3662 objfile
->psymtabs_addrmap
= addrmap_create_fixed (objfile
->psymtabs_addrmap
,
3663 &objfile
->objfile_obstack
);
3664 discard_cleanups (addrmap_cleanup
);
3666 do_cleanups (back_to
);
3669 /* Load the partial DIEs for a secondary CU into memory. */
3672 load_partial_comp_unit (struct dwarf2_per_cu_data
*this_cu
)
3674 struct objfile
*objfile
= this_cu
->objfile
;
3675 bfd
*abfd
= objfile
->obfd
;
3677 struct die_info
*comp_unit_die
;
3678 struct dwarf2_cu
*cu
;
3679 struct cleanup
*free_abbrevs_cleanup
, *free_cu_cleanup
= NULL
;
3681 struct die_reader_specs reader_specs
;
3684 gdb_assert (! this_cu
->debug_types_section
);
3686 gdb_assert (dwarf2_per_objfile
->info
.readin
);
3687 info_ptr
= dwarf2_per_objfile
->info
.buffer
+ this_cu
->offset
;
3689 if (this_cu
->cu
== NULL
)
3691 cu
= xmalloc (sizeof (*cu
));
3692 init_one_comp_unit (cu
, this_cu
);
3696 /* If an error occurs while loading, release our storage. */
3697 free_cu_cleanup
= make_cleanup (free_heap_comp_unit
, cu
);
3699 info_ptr
= partial_read_comp_unit_head (&cu
->header
, info_ptr
,
3700 dwarf2_per_objfile
->info
.buffer
,
3701 dwarf2_per_objfile
->info
.size
,
3704 /* Skip dummy compilation units. */
3705 if (info_ptr
>= (dwarf2_per_objfile
->info
.buffer
3706 + dwarf2_per_objfile
->info
.size
)
3707 || peek_abbrev_code (abfd
, info_ptr
) == 0)
3709 do_cleanups (free_cu_cleanup
);
3713 /* Link this CU into read_in_chain. */
3714 this_cu
->cu
->read_in_chain
= dwarf2_per_objfile
->read_in_chain
;
3715 dwarf2_per_objfile
->read_in_chain
= this_cu
;
3720 info_ptr
+= cu
->header
.first_die_offset
;
3723 /* Read the abbrevs for this compilation unit into a table. */
3724 gdb_assert (cu
->dwarf2_abbrevs
== NULL
);
3725 dwarf2_read_abbrevs (cu
);
3726 free_abbrevs_cleanup
= make_cleanup (dwarf2_free_abbrev_table
, cu
);
3728 /* Read the compilation unit die. */
3729 init_cu_die_reader (&reader_specs
, cu
);
3730 info_ptr
= read_full_die (&reader_specs
, &comp_unit_die
, info_ptr
,
3733 prepare_one_comp_unit (cu
, comp_unit_die
);
3735 /* Check if comp unit has_children.
3736 If so, read the rest of the partial symbols from this comp unit.
3737 If not, there's no more debug_info for this comp unit. */
3739 load_partial_dies (abfd
, dwarf2_per_objfile
->info
.buffer
, info_ptr
, 0, cu
);
3741 do_cleanups (free_abbrevs_cleanup
);
3745 /* We've successfully allocated this compilation unit. Let our
3746 caller clean it up when finished with it. */
3747 discard_cleanups (free_cu_cleanup
);
3751 /* Create a list of all compilation units in OBJFILE.
3752 This is only done for -readnow and building partial symtabs. */
3755 create_all_comp_units (struct objfile
*objfile
)
3759 struct dwarf2_per_cu_data
**all_comp_units
;
3762 dwarf2_read_section (objfile
, &dwarf2_per_objfile
->info
);
3763 info_ptr
= dwarf2_per_objfile
->info
.buffer
;
3767 all_comp_units
= xmalloc (n_allocated
3768 * sizeof (struct dwarf2_per_cu_data
*));
3770 while (info_ptr
< dwarf2_per_objfile
->info
.buffer
3771 + dwarf2_per_objfile
->info
.size
)
3773 unsigned int length
, initial_length_size
;
3774 struct dwarf2_per_cu_data
*this_cu
;
3775 unsigned int offset
;
3777 offset
= info_ptr
- dwarf2_per_objfile
->info
.buffer
;
3779 /* Read just enough information to find out where the next
3780 compilation unit is. */
3781 length
= read_initial_length (objfile
->obfd
, info_ptr
,
3782 &initial_length_size
);
3784 /* Save the compilation unit for later lookup. */
3785 this_cu
= obstack_alloc (&objfile
->objfile_obstack
,
3786 sizeof (struct dwarf2_per_cu_data
));
3787 memset (this_cu
, 0, sizeof (*this_cu
));
3788 this_cu
->offset
= offset
;
3789 this_cu
->length
= length
+ initial_length_size
;
3790 this_cu
->objfile
= objfile
;
3792 if (n_comp_units
== n_allocated
)
3795 all_comp_units
= xrealloc (all_comp_units
,
3797 * sizeof (struct dwarf2_per_cu_data
*));
3799 all_comp_units
[n_comp_units
++] = this_cu
;
3801 info_ptr
= info_ptr
+ this_cu
->length
;
3804 dwarf2_per_objfile
->all_comp_units
3805 = obstack_alloc (&objfile
->objfile_obstack
,
3806 n_comp_units
* sizeof (struct dwarf2_per_cu_data
*));
3807 memcpy (dwarf2_per_objfile
->all_comp_units
, all_comp_units
,
3808 n_comp_units
* sizeof (struct dwarf2_per_cu_data
*));
3809 xfree (all_comp_units
);
3810 dwarf2_per_objfile
->n_comp_units
= n_comp_units
;
3813 /* Process all loaded DIEs for compilation unit CU, starting at
3814 FIRST_DIE. The caller should pass NEED_PC == 1 if the compilation
3815 unit DIE did not have PC info (DW_AT_low_pc and DW_AT_high_pc, or
3816 DW_AT_ranges). If NEED_PC is set, then this function will set
3817 *LOWPC and *HIGHPC to the lowest and highest PC values found in CU
3818 and record the covered ranges in the addrmap. */
3821 scan_partial_symbols (struct partial_die_info
*first_die
, CORE_ADDR
*lowpc
,
3822 CORE_ADDR
*highpc
, int need_pc
, struct dwarf2_cu
*cu
)
3824 struct partial_die_info
*pdi
;
3826 /* Now, march along the PDI's, descending into ones which have
3827 interesting children but skipping the children of the other ones,
3828 until we reach the end of the compilation unit. */
3834 fixup_partial_die (pdi
, cu
);
3836 /* Anonymous namespaces or modules have no name but have interesting
3837 children, so we need to look at them. Ditto for anonymous
3840 if (pdi
->name
!= NULL
|| pdi
->tag
== DW_TAG_namespace
3841 || pdi
->tag
== DW_TAG_module
|| pdi
->tag
== DW_TAG_enumeration_type
)
3845 case DW_TAG_subprogram
:
3846 add_partial_subprogram (pdi
, lowpc
, highpc
, need_pc
, cu
);
3848 case DW_TAG_constant
:
3849 case DW_TAG_variable
:
3850 case DW_TAG_typedef
:
3851 case DW_TAG_union_type
:
3852 if (!pdi
->is_declaration
)
3854 add_partial_symbol (pdi
, cu
);
3857 case DW_TAG_class_type
:
3858 case DW_TAG_interface_type
:
3859 case DW_TAG_structure_type
:
3860 if (!pdi
->is_declaration
)
3862 add_partial_symbol (pdi
, cu
);
3865 case DW_TAG_enumeration_type
:
3866 if (!pdi
->is_declaration
)
3867 add_partial_enumeration (pdi
, cu
);
3869 case DW_TAG_base_type
:
3870 case DW_TAG_subrange_type
:
3871 /* File scope base type definitions are added to the partial
3873 add_partial_symbol (pdi
, cu
);
3875 case DW_TAG_namespace
:
3876 add_partial_namespace (pdi
, lowpc
, highpc
, need_pc
, cu
);
3879 add_partial_module (pdi
, lowpc
, highpc
, need_pc
, cu
);
3886 /* If the die has a sibling, skip to the sibling. */
3888 pdi
= pdi
->die_sibling
;
3892 /* Functions used to compute the fully scoped name of a partial DIE.
3894 Normally, this is simple. For C++, the parent DIE's fully scoped
3895 name is concatenated with "::" and the partial DIE's name. For
3896 Java, the same thing occurs except that "." is used instead of "::".
3897 Enumerators are an exception; they use the scope of their parent
3898 enumeration type, i.e. the name of the enumeration type is not
3899 prepended to the enumerator.
3901 There are two complexities. One is DW_AT_specification; in this
3902 case "parent" means the parent of the target of the specification,
3903 instead of the direct parent of the DIE. The other is compilers
3904 which do not emit DW_TAG_namespace; in this case we try to guess
3905 the fully qualified name of structure types from their members'
3906 linkage names. This must be done using the DIE's children rather
3907 than the children of any DW_AT_specification target. We only need
3908 to do this for structures at the top level, i.e. if the target of
3909 any DW_AT_specification (if any; otherwise the DIE itself) does not
3912 /* Compute the scope prefix associated with PDI's parent, in
3913 compilation unit CU. The result will be allocated on CU's
3914 comp_unit_obstack, or a copy of the already allocated PDI->NAME
3915 field. NULL is returned if no prefix is necessary. */
3917 partial_die_parent_scope (struct partial_die_info
*pdi
,
3918 struct dwarf2_cu
*cu
)
3920 char *grandparent_scope
;
3921 struct partial_die_info
*parent
, *real_pdi
;
3923 /* We need to look at our parent DIE; if we have a DW_AT_specification,
3924 then this means the parent of the specification DIE. */
3927 while (real_pdi
->has_specification
)
3928 real_pdi
= find_partial_die (real_pdi
->spec_offset
, cu
);
3930 parent
= real_pdi
->die_parent
;
3934 if (parent
->scope_set
)
3935 return parent
->scope
;
3937 fixup_partial_die (parent
, cu
);
3939 grandparent_scope
= partial_die_parent_scope (parent
, cu
);
3941 /* GCC 4.0 and 4.1 had a bug (PR c++/28460) where they generated bogus
3942 DW_TAG_namespace DIEs with a name of "::" for the global namespace.
3943 Work around this problem here. */
3944 if (cu
->language
== language_cplus
3945 && parent
->tag
== DW_TAG_namespace
3946 && strcmp (parent
->name
, "::") == 0
3947 && grandparent_scope
== NULL
)
3949 parent
->scope
= NULL
;
3950 parent
->scope_set
= 1;
3954 if (pdi
->tag
== DW_TAG_enumerator
)
3955 /* Enumerators should not get the name of the enumeration as a prefix. */
3956 parent
->scope
= grandparent_scope
;
3957 else if (parent
->tag
== DW_TAG_namespace
3958 || parent
->tag
== DW_TAG_module
3959 || parent
->tag
== DW_TAG_structure_type
3960 || parent
->tag
== DW_TAG_class_type
3961 || parent
->tag
== DW_TAG_interface_type
3962 || parent
->tag
== DW_TAG_union_type
3963 || parent
->tag
== DW_TAG_enumeration_type
)
3965 if (grandparent_scope
== NULL
)
3966 parent
->scope
= parent
->name
;
3968 parent
->scope
= typename_concat (&cu
->comp_unit_obstack
,
3970 parent
->name
, 0, cu
);
3974 /* FIXME drow/2004-04-01: What should we be doing with
3975 function-local names? For partial symbols, we should probably be
3977 complaint (&symfile_complaints
,
3978 _("unhandled containing DIE tag %d for DIE at %d"),
3979 parent
->tag
, pdi
->offset
);
3980 parent
->scope
= grandparent_scope
;
3983 parent
->scope_set
= 1;
3984 return parent
->scope
;
3987 /* Return the fully scoped name associated with PDI, from compilation unit
3988 CU. The result will be allocated with malloc. */
3990 partial_die_full_name (struct partial_die_info
*pdi
,
3991 struct dwarf2_cu
*cu
)
3995 /* If this is a template instantiation, we can not work out the
3996 template arguments from partial DIEs. So, unfortunately, we have
3997 to go through the full DIEs. At least any work we do building
3998 types here will be reused if full symbols are loaded later. */
3999 if (pdi
->has_template_arguments
)
4001 fixup_partial_die (pdi
, cu
);
4003 if (pdi
->name
!= NULL
&& strchr (pdi
->name
, '<') == NULL
)
4005 struct die_info
*die
;
4006 struct attribute attr
;
4007 struct dwarf2_cu
*ref_cu
= cu
;
4010 attr
.form
= DW_FORM_ref_addr
;
4011 attr
.u
.addr
= pdi
->offset
;
4012 die
= follow_die_ref (NULL
, &attr
, &ref_cu
);
4014 return xstrdup (dwarf2_full_name (NULL
, die
, ref_cu
));
4018 parent_scope
= partial_die_parent_scope (pdi
, cu
);
4019 if (parent_scope
== NULL
)
4022 return typename_concat (NULL
, parent_scope
, pdi
->name
, 0, cu
);
4026 add_partial_symbol (struct partial_die_info
*pdi
, struct dwarf2_cu
*cu
)
4028 struct objfile
*objfile
= cu
->objfile
;
4030 char *actual_name
= NULL
;
4031 const struct partial_symbol
*psym
= NULL
;
4033 int built_actual_name
= 0;
4035 baseaddr
= ANOFFSET (objfile
->section_offsets
, SECT_OFF_TEXT (objfile
));
4037 actual_name
= partial_die_full_name (pdi
, cu
);
4039 built_actual_name
= 1;
4041 if (actual_name
== NULL
)
4042 actual_name
= pdi
->name
;
4046 case DW_TAG_subprogram
:
4047 if (pdi
->is_external
|| cu
->language
== language_ada
)
4049 /* brobecker/2007-12-26: Normally, only "external" DIEs are part
4050 of the global scope. But in Ada, we want to be able to access
4051 nested procedures globally. So all Ada subprograms are stored
4052 in the global scope. */
4053 /* prim_record_minimal_symbol (actual_name, pdi->lowpc + baseaddr,
4054 mst_text, objfile); */
4055 add_psymbol_to_list (actual_name
, strlen (actual_name
),
4057 VAR_DOMAIN
, LOC_BLOCK
,
4058 &objfile
->global_psymbols
,
4059 0, pdi
->lowpc
+ baseaddr
,
4060 cu
->language
, objfile
);
4064 /* prim_record_minimal_symbol (actual_name, pdi->lowpc + baseaddr,
4065 mst_file_text, objfile); */
4066 add_psymbol_to_list (actual_name
, strlen (actual_name
),
4068 VAR_DOMAIN
, LOC_BLOCK
,
4069 &objfile
->static_psymbols
,
4070 0, pdi
->lowpc
+ baseaddr
,
4071 cu
->language
, objfile
);
4074 case DW_TAG_constant
:
4076 struct psymbol_allocation_list
*list
;
4078 if (pdi
->is_external
)
4079 list
= &objfile
->global_psymbols
;
4081 list
= &objfile
->static_psymbols
;
4082 add_psymbol_to_list (actual_name
, strlen (actual_name
),
4083 built_actual_name
, VAR_DOMAIN
, LOC_STATIC
,
4084 list
, 0, 0, cu
->language
, objfile
);
4087 case DW_TAG_variable
:
4089 addr
= decode_locdesc (pdi
->locdesc
, cu
);
4093 && !dwarf2_per_objfile
->has_section_at_zero
)
4095 /* A global or static variable may also have been stripped
4096 out by the linker if unused, in which case its address
4097 will be nullified; do not add such variables into partial
4098 symbol table then. */
4100 else if (pdi
->is_external
)
4103 Don't enter into the minimal symbol tables as there is
4104 a minimal symbol table entry from the ELF symbols already.
4105 Enter into partial symbol table if it has a location
4106 descriptor or a type.
4107 If the location descriptor is missing, new_symbol will create
4108 a LOC_UNRESOLVED symbol, the address of the variable will then
4109 be determined from the minimal symbol table whenever the variable
4111 The address for the partial symbol table entry is not
4112 used by GDB, but it comes in handy for debugging partial symbol
4115 if (pdi
->locdesc
|| pdi
->has_type
)
4116 add_psymbol_to_list (actual_name
, strlen (actual_name
),
4118 VAR_DOMAIN
, LOC_STATIC
,
4119 &objfile
->global_psymbols
,
4121 cu
->language
, objfile
);
4125 /* Static Variable. Skip symbols without location descriptors. */
4126 if (pdi
->locdesc
== NULL
)
4128 if (built_actual_name
)
4129 xfree (actual_name
);
4132 /* prim_record_minimal_symbol (actual_name, addr + baseaddr,
4133 mst_file_data, objfile); */
4134 add_psymbol_to_list (actual_name
, strlen (actual_name
),
4136 VAR_DOMAIN
, LOC_STATIC
,
4137 &objfile
->static_psymbols
,
4139 cu
->language
, objfile
);
4142 case DW_TAG_typedef
:
4143 case DW_TAG_base_type
:
4144 case DW_TAG_subrange_type
:
4145 add_psymbol_to_list (actual_name
, strlen (actual_name
),
4147 VAR_DOMAIN
, LOC_TYPEDEF
,
4148 &objfile
->static_psymbols
,
4149 0, (CORE_ADDR
) 0, cu
->language
, objfile
);
4151 case DW_TAG_namespace
:
4152 add_psymbol_to_list (actual_name
, strlen (actual_name
),
4154 VAR_DOMAIN
, LOC_TYPEDEF
,
4155 &objfile
->global_psymbols
,
4156 0, (CORE_ADDR
) 0, cu
->language
, objfile
);
4158 case DW_TAG_class_type
:
4159 case DW_TAG_interface_type
:
4160 case DW_TAG_structure_type
:
4161 case DW_TAG_union_type
:
4162 case DW_TAG_enumeration_type
:
4163 /* Skip external references. The DWARF standard says in the section
4164 about "Structure, Union, and Class Type Entries": "An incomplete
4165 structure, union or class type is represented by a structure,
4166 union or class entry that does not have a byte size attribute
4167 and that has a DW_AT_declaration attribute." */
4168 if (!pdi
->has_byte_size
&& pdi
->is_declaration
)
4170 if (built_actual_name
)
4171 xfree (actual_name
);
4175 /* NOTE: carlton/2003-10-07: See comment in new_symbol about
4176 static vs. global. */
4177 add_psymbol_to_list (actual_name
, strlen (actual_name
),
4179 STRUCT_DOMAIN
, LOC_TYPEDEF
,
4180 (cu
->language
== language_cplus
4181 || cu
->language
== language_java
)
4182 ? &objfile
->global_psymbols
4183 : &objfile
->static_psymbols
,
4184 0, (CORE_ADDR
) 0, cu
->language
, objfile
);
4187 case DW_TAG_enumerator
:
4188 add_psymbol_to_list (actual_name
, strlen (actual_name
),
4190 VAR_DOMAIN
, LOC_CONST
,
4191 (cu
->language
== language_cplus
4192 || cu
->language
== language_java
)
4193 ? &objfile
->global_psymbols
4194 : &objfile
->static_psymbols
,
4195 0, (CORE_ADDR
) 0, cu
->language
, objfile
);
4201 if (built_actual_name
)
4202 xfree (actual_name
);
4205 /* Read a partial die corresponding to a namespace; also, add a symbol
4206 corresponding to that namespace to the symbol table. NAMESPACE is
4207 the name of the enclosing namespace. */
4210 add_partial_namespace (struct partial_die_info
*pdi
,
4211 CORE_ADDR
*lowpc
, CORE_ADDR
*highpc
,
4212 int need_pc
, struct dwarf2_cu
*cu
)
4214 /* Add a symbol for the namespace. */
4216 add_partial_symbol (pdi
, cu
);
4218 /* Now scan partial symbols in that namespace. */
4220 if (pdi
->has_children
)
4221 scan_partial_symbols (pdi
->die_child
, lowpc
, highpc
, need_pc
, cu
);
4224 /* Read a partial die corresponding to a Fortran module. */
4227 add_partial_module (struct partial_die_info
*pdi
, CORE_ADDR
*lowpc
,
4228 CORE_ADDR
*highpc
, int need_pc
, struct dwarf2_cu
*cu
)
4230 /* Now scan partial symbols in that module. */
4232 if (pdi
->has_children
)
4233 scan_partial_symbols (pdi
->die_child
, lowpc
, highpc
, need_pc
, cu
);
4236 /* Read a partial die corresponding to a subprogram and create a partial
4237 symbol for that subprogram. When the CU language allows it, this
4238 routine also defines a partial symbol for each nested subprogram
4239 that this subprogram contains.
4241 DIE my also be a lexical block, in which case we simply search
4242 recursively for suprograms defined inside that lexical block.
4243 Again, this is only performed when the CU language allows this
4244 type of definitions. */
4247 add_partial_subprogram (struct partial_die_info
*pdi
,
4248 CORE_ADDR
*lowpc
, CORE_ADDR
*highpc
,
4249 int need_pc
, struct dwarf2_cu
*cu
)
4251 if (pdi
->tag
== DW_TAG_subprogram
)
4253 if (pdi
->has_pc_info
)
4255 if (pdi
->lowpc
< *lowpc
)
4256 *lowpc
= pdi
->lowpc
;
4257 if (pdi
->highpc
> *highpc
)
4258 *highpc
= pdi
->highpc
;
4262 struct objfile
*objfile
= cu
->objfile
;
4264 baseaddr
= ANOFFSET (objfile
->section_offsets
,
4265 SECT_OFF_TEXT (objfile
));
4266 addrmap_set_empty (objfile
->psymtabs_addrmap
,
4267 pdi
->lowpc
+ baseaddr
,
4268 pdi
->highpc
- 1 + baseaddr
,
4269 cu
->per_cu
->v
.psymtab
);
4271 if (!pdi
->is_declaration
)
4272 /* Ignore subprogram DIEs that do not have a name, they are
4273 illegal. Do not emit a complaint at this point, we will
4274 do so when we convert this psymtab into a symtab. */
4276 add_partial_symbol (pdi
, cu
);
4280 if (! pdi
->has_children
)
4283 if (cu
->language
== language_ada
)
4285 pdi
= pdi
->die_child
;
4288 fixup_partial_die (pdi
, cu
);
4289 if (pdi
->tag
== DW_TAG_subprogram
4290 || pdi
->tag
== DW_TAG_lexical_block
)
4291 add_partial_subprogram (pdi
, lowpc
, highpc
, need_pc
, cu
);
4292 pdi
= pdi
->die_sibling
;
4297 /* Read a partial die corresponding to an enumeration type. */
4300 add_partial_enumeration (struct partial_die_info
*enum_pdi
,
4301 struct dwarf2_cu
*cu
)
4303 struct partial_die_info
*pdi
;
4305 if (enum_pdi
->name
!= NULL
)
4306 add_partial_symbol (enum_pdi
, cu
);
4308 pdi
= enum_pdi
->die_child
;
4311 if (pdi
->tag
!= DW_TAG_enumerator
|| pdi
->name
== NULL
)
4312 complaint (&symfile_complaints
, _("malformed enumerator DIE ignored"));
4314 add_partial_symbol (pdi
, cu
);
4315 pdi
= pdi
->die_sibling
;
4319 /* Return the initial uleb128 in the die at INFO_PTR. */
4322 peek_abbrev_code (bfd
*abfd
, gdb_byte
*info_ptr
)
4324 unsigned int bytes_read
;
4326 return read_unsigned_leb128 (abfd
, info_ptr
, &bytes_read
);
4329 /* Read the initial uleb128 in the die at INFO_PTR in compilation unit CU.
4330 Return the corresponding abbrev, or NULL if the number is zero (indicating
4331 an empty DIE). In either case *BYTES_READ will be set to the length of
4332 the initial number. */
4334 static struct abbrev_info
*
4335 peek_die_abbrev (gdb_byte
*info_ptr
, unsigned int *bytes_read
,
4336 struct dwarf2_cu
*cu
)
4338 bfd
*abfd
= cu
->objfile
->obfd
;
4339 unsigned int abbrev_number
;
4340 struct abbrev_info
*abbrev
;
4342 abbrev_number
= read_unsigned_leb128 (abfd
, info_ptr
, bytes_read
);
4344 if (abbrev_number
== 0)
4347 abbrev
= dwarf2_lookup_abbrev (abbrev_number
, cu
);
4350 error (_("Dwarf Error: Could not find abbrev number %d [in module %s]"),
4351 abbrev_number
, bfd_get_filename (abfd
));
4357 /* Scan the debug information for CU starting at INFO_PTR in buffer BUFFER.
4358 Returns a pointer to the end of a series of DIEs, terminated by an empty
4359 DIE. Any children of the skipped DIEs will also be skipped. */
4362 skip_children (gdb_byte
*buffer
, gdb_byte
*info_ptr
, struct dwarf2_cu
*cu
)
4364 struct abbrev_info
*abbrev
;
4365 unsigned int bytes_read
;
4369 abbrev
= peek_die_abbrev (info_ptr
, &bytes_read
, cu
);
4371 return info_ptr
+ bytes_read
;
4373 info_ptr
= skip_one_die (buffer
, info_ptr
+ bytes_read
, abbrev
, cu
);
4377 /* Scan the debug information for CU starting at INFO_PTR in buffer BUFFER.
4378 INFO_PTR should point just after the initial uleb128 of a DIE, and the
4379 abbrev corresponding to that skipped uleb128 should be passed in
4380 ABBREV. Returns a pointer to this DIE's sibling, skipping any
4384 skip_one_die (gdb_byte
*buffer
, gdb_byte
*info_ptr
,
4385 struct abbrev_info
*abbrev
, struct dwarf2_cu
*cu
)
4387 unsigned int bytes_read
;
4388 struct attribute attr
;
4389 bfd
*abfd
= cu
->objfile
->obfd
;
4390 unsigned int form
, i
;
4392 for (i
= 0; i
< abbrev
->num_attrs
; i
++)
4394 /* The only abbrev we care about is DW_AT_sibling. */
4395 if (abbrev
->attrs
[i
].name
== DW_AT_sibling
)
4397 read_attribute (&attr
, &abbrev
->attrs
[i
],
4398 abfd
, info_ptr
, cu
);
4399 if (attr
.form
== DW_FORM_ref_addr
)
4400 complaint (&symfile_complaints
,
4401 _("ignoring absolute DW_AT_sibling"));
4403 return buffer
+ dwarf2_get_ref_die_offset (&attr
);
4406 /* If it isn't DW_AT_sibling, skip this attribute. */
4407 form
= abbrev
->attrs
[i
].form
;
4411 case DW_FORM_ref_addr
:
4412 /* In DWARF 2, DW_FORM_ref_addr is address sized; in DWARF 3
4413 and later it is offset sized. */
4414 if (cu
->header
.version
== 2)
4415 info_ptr
+= cu
->header
.addr_size
;
4417 info_ptr
+= cu
->header
.offset_size
;
4420 info_ptr
+= cu
->header
.addr_size
;
4427 case DW_FORM_flag_present
:
4439 case DW_FORM_ref_sig8
:
4442 case DW_FORM_string
:
4443 read_direct_string (abfd
, info_ptr
, &bytes_read
);
4444 info_ptr
+= bytes_read
;
4446 case DW_FORM_sec_offset
:
4448 info_ptr
+= cu
->header
.offset_size
;
4450 case DW_FORM_exprloc
:
4452 info_ptr
+= read_unsigned_leb128 (abfd
, info_ptr
, &bytes_read
);
4453 info_ptr
+= bytes_read
;
4455 case DW_FORM_block1
:
4456 info_ptr
+= 1 + read_1_byte (abfd
, info_ptr
);
4458 case DW_FORM_block2
:
4459 info_ptr
+= 2 + read_2_bytes (abfd
, info_ptr
);
4461 case DW_FORM_block4
:
4462 info_ptr
+= 4 + read_4_bytes (abfd
, info_ptr
);
4466 case DW_FORM_ref_udata
:
4467 info_ptr
= skip_leb128 (abfd
, info_ptr
);
4469 case DW_FORM_indirect
:
4470 form
= read_unsigned_leb128 (abfd
, info_ptr
, &bytes_read
);
4471 info_ptr
+= bytes_read
;
4472 /* We need to continue parsing from here, so just go back to
4474 goto skip_attribute
;
4477 error (_("Dwarf Error: Cannot handle %s "
4478 "in DWARF reader [in module %s]"),
4479 dwarf_form_name (form
),
4480 bfd_get_filename (abfd
));
4484 if (abbrev
->has_children
)
4485 return skip_children (buffer
, info_ptr
, cu
);
4490 /* Locate ORIG_PDI's sibling.
4491 INFO_PTR should point to the start of the next DIE after ORIG_PDI
4495 locate_pdi_sibling (struct partial_die_info
*orig_pdi
,
4496 gdb_byte
*buffer
, gdb_byte
*info_ptr
,
4497 bfd
*abfd
, struct dwarf2_cu
*cu
)
4499 /* Do we know the sibling already? */
4501 if (orig_pdi
->sibling
)
4502 return orig_pdi
->sibling
;
4504 /* Are there any children to deal with? */
4506 if (!orig_pdi
->has_children
)
4509 /* Skip the children the long way. */
4511 return skip_children (buffer
, info_ptr
, cu
);
4514 /* Expand this partial symbol table into a full symbol table. */
4517 dwarf2_psymtab_to_symtab (struct partial_symtab
*pst
)
4523 warning (_("bug: psymtab for %s is already read in."),
4530 printf_filtered (_("Reading in symbols for %s..."),
4532 gdb_flush (gdb_stdout
);
4535 /* Restore our global data. */
4536 dwarf2_per_objfile
= objfile_data (pst
->objfile
,
4537 dwarf2_objfile_data_key
);
4539 /* If this psymtab is constructed from a debug-only objfile, the
4540 has_section_at_zero flag will not necessarily be correct. We
4541 can get the correct value for this flag by looking at the data
4542 associated with the (presumably stripped) associated objfile. */
4543 if (pst
->objfile
->separate_debug_objfile_backlink
)
4545 struct dwarf2_per_objfile
*dpo_backlink
4546 = objfile_data (pst
->objfile
->separate_debug_objfile_backlink
,
4547 dwarf2_objfile_data_key
);
4549 dwarf2_per_objfile
->has_section_at_zero
4550 = dpo_backlink
->has_section_at_zero
;
4553 dwarf2_per_objfile
->reading_partial_symbols
= 0;
4555 psymtab_to_symtab_1 (pst
);
4557 /* Finish up the debug error message. */
4559 printf_filtered (_("done.\n"));
4564 /* Reading in full CUs. */
4566 /* Add PER_CU to the queue. */
4569 queue_comp_unit (struct dwarf2_per_cu_data
*per_cu
)
4571 struct dwarf2_queue_item
*item
;
4574 item
= xmalloc (sizeof (*item
));
4575 item
->per_cu
= per_cu
;
4578 if (dwarf2_queue
== NULL
)
4579 dwarf2_queue
= item
;
4581 dwarf2_queue_tail
->next
= item
;
4583 dwarf2_queue_tail
= item
;
4586 /* Process the queue. */
4589 process_queue (void)
4591 struct dwarf2_queue_item
*item
, *next_item
;
4593 /* The queue starts out with one item, but following a DIE reference
4594 may load a new CU, adding it to the end of the queue. */
4595 for (item
= dwarf2_queue
; item
!= NULL
; dwarf2_queue
= item
= next_item
)
4597 if (dwarf2_per_objfile
->using_index
4598 ? !item
->per_cu
->v
.quick
->symtab
4599 : (item
->per_cu
->v
.psymtab
&& !item
->per_cu
->v
.psymtab
->readin
))
4600 process_full_comp_unit (item
->per_cu
);
4602 item
->per_cu
->queued
= 0;
4603 next_item
= item
->next
;
4607 dwarf2_queue_tail
= NULL
;
4610 /* Free all allocated queue entries. This function only releases anything if
4611 an error was thrown; if the queue was processed then it would have been
4612 freed as we went along. */
4615 dwarf2_release_queue (void *dummy
)
4617 struct dwarf2_queue_item
*item
, *last
;
4619 item
= dwarf2_queue
;
4622 /* Anything still marked queued is likely to be in an
4623 inconsistent state, so discard it. */
4624 if (item
->per_cu
->queued
)
4626 if (item
->per_cu
->cu
!= NULL
)
4627 free_one_cached_comp_unit (item
->per_cu
->cu
);
4628 item
->per_cu
->queued
= 0;
4636 dwarf2_queue
= dwarf2_queue_tail
= NULL
;
4639 /* Read in full symbols for PST, and anything it depends on. */
4642 psymtab_to_symtab_1 (struct partial_symtab
*pst
)
4644 struct dwarf2_per_cu_data
*per_cu
;
4645 struct cleanup
*back_to
;
4648 for (i
= 0; i
< pst
->number_of_dependencies
; i
++)
4649 if (!pst
->dependencies
[i
]->readin
)
4651 /* Inform about additional files that need to be read in. */
4654 /* FIXME: i18n: Need to make this a single string. */
4655 fputs_filtered (" ", gdb_stdout
);
4657 fputs_filtered ("and ", gdb_stdout
);
4659 printf_filtered ("%s...", pst
->dependencies
[i
]->filename
);
4660 wrap_here (""); /* Flush output. */
4661 gdb_flush (gdb_stdout
);
4663 psymtab_to_symtab_1 (pst
->dependencies
[i
]);
4666 per_cu
= pst
->read_symtab_private
;
4670 /* It's an include file, no symbols to read for it.
4671 Everything is in the parent symtab. */
4676 dw2_do_instantiate_symtab (per_cu
);
4679 /* Load the DIEs associated with PER_CU into memory. */
4682 load_full_comp_unit (struct dwarf2_per_cu_data
*per_cu
)
4684 struct objfile
*objfile
= per_cu
->objfile
;
4685 bfd
*abfd
= objfile
->obfd
;
4686 struct dwarf2_cu
*cu
;
4687 unsigned int offset
;
4688 gdb_byte
*info_ptr
, *beg_of_comp_unit
;
4689 struct cleanup
*free_abbrevs_cleanup
= NULL
, *free_cu_cleanup
= NULL
;
4690 struct attribute
*attr
;
4693 gdb_assert (! per_cu
->debug_types_section
);
4695 /* Set local variables from the partial symbol table info. */
4696 offset
= per_cu
->offset
;
4698 dwarf2_read_section (objfile
, &dwarf2_per_objfile
->info
);
4699 info_ptr
= dwarf2_per_objfile
->info
.buffer
+ offset
;
4700 beg_of_comp_unit
= info_ptr
;
4702 if (per_cu
->cu
== NULL
)
4704 cu
= xmalloc (sizeof (*cu
));
4705 init_one_comp_unit (cu
, per_cu
);
4709 /* If an error occurs while loading, release our storage. */
4710 free_cu_cleanup
= make_cleanup (free_heap_comp_unit
, cu
);
4712 /* Read in the comp_unit header. */
4713 info_ptr
= read_comp_unit_head (&cu
->header
, info_ptr
, abfd
);
4715 /* Skip dummy compilation units. */
4716 if (info_ptr
>= (dwarf2_per_objfile
->info
.buffer
4717 + dwarf2_per_objfile
->info
.size
)
4718 || peek_abbrev_code (abfd
, info_ptr
) == 0)
4720 do_cleanups (free_cu_cleanup
);
4724 /* Complete the cu_header. */
4725 cu
->header
.offset
= offset
;
4726 cu
->header
.first_die_offset
= info_ptr
- beg_of_comp_unit
;
4728 /* Read the abbrevs for this compilation unit. */
4729 dwarf2_read_abbrevs (cu
);
4730 free_abbrevs_cleanup
= make_cleanup (dwarf2_free_abbrev_table
, cu
);
4732 /* Link this CU into read_in_chain. */
4733 per_cu
->cu
->read_in_chain
= dwarf2_per_objfile
->read_in_chain
;
4734 dwarf2_per_objfile
->read_in_chain
= per_cu
;
4739 info_ptr
+= cu
->header
.first_die_offset
;
4742 cu
->dies
= read_comp_unit (info_ptr
, cu
);
4744 /* We try not to read any attributes in this function, because not
4745 all CUs needed for references have been loaded yet, and symbol
4746 table processing isn't initialized. But we have to set the CU language,
4747 or we won't be able to build types correctly. */
4748 prepare_one_comp_unit (cu
, cu
->dies
);
4750 /* Similarly, if we do not read the producer, we can not apply
4751 producer-specific interpretation. */
4752 attr
= dwarf2_attr (cu
->dies
, DW_AT_producer
, cu
);
4754 cu
->producer
= DW_STRING (attr
);
4758 do_cleanups (free_abbrevs_cleanup
);
4760 /* We've successfully allocated this compilation unit. Let our
4761 caller clean it up when finished with it. */
4762 discard_cleanups (free_cu_cleanup
);
4766 /* Add a DIE to the delayed physname list. */
4769 add_to_method_list (struct type
*type
, int fnfield_index
, int index
,
4770 const char *name
, struct die_info
*die
,
4771 struct dwarf2_cu
*cu
)
4773 struct delayed_method_info mi
;
4775 mi
.fnfield_index
= fnfield_index
;
4779 VEC_safe_push (delayed_method_info
, cu
->method_list
, &mi
);
4782 /* A cleanup for freeing the delayed method list. */
4785 free_delayed_list (void *ptr
)
4787 struct dwarf2_cu
*cu
= (struct dwarf2_cu
*) ptr
;
4788 if (cu
->method_list
!= NULL
)
4790 VEC_free (delayed_method_info
, cu
->method_list
);
4791 cu
->method_list
= NULL
;
4795 /* Compute the physnames of any methods on the CU's method list.
4797 The computation of method physnames is delayed in order to avoid the
4798 (bad) condition that one of the method's formal parameters is of an as yet
4802 compute_delayed_physnames (struct dwarf2_cu
*cu
)
4805 struct delayed_method_info
*mi
;
4806 for (i
= 0; VEC_iterate (delayed_method_info
, cu
->method_list
, i
, mi
) ; ++i
)
4808 const char *physname
;
4809 struct fn_fieldlist
*fn_flp
4810 = &TYPE_FN_FIELDLIST (mi
->type
, mi
->fnfield_index
);
4811 physname
= dwarf2_physname ((char *) mi
->name
, mi
->die
, cu
);
4812 fn_flp
->fn_fields
[mi
->index
].physname
= physname
? physname
: "";
4816 /* Generate full symbol information for PER_CU, whose DIEs have
4817 already been loaded into memory. */
4820 process_full_comp_unit (struct dwarf2_per_cu_data
*per_cu
)
4822 struct dwarf2_cu
*cu
= per_cu
->cu
;
4823 struct objfile
*objfile
= per_cu
->objfile
;
4824 CORE_ADDR lowpc
, highpc
;
4825 struct symtab
*symtab
;
4826 struct cleanup
*back_to
, *delayed_list_cleanup
;
4829 baseaddr
= ANOFFSET (objfile
->section_offsets
, SECT_OFF_TEXT (objfile
));
4832 back_to
= make_cleanup (really_free_pendings
, NULL
);
4833 delayed_list_cleanup
= make_cleanup (free_delayed_list
, cu
);
4835 cu
->list_in_scope
= &file_symbols
;
4837 /* Do line number decoding in read_file_scope () */
4838 process_die (cu
->dies
, cu
);
4840 /* Now that we have processed all the DIEs in the CU, all the types
4841 should be complete, and it should now be safe to compute all of the
4843 compute_delayed_physnames (cu
);
4844 do_cleanups (delayed_list_cleanup
);
4846 /* Some compilers don't define a DW_AT_high_pc attribute for the
4847 compilation unit. If the DW_AT_high_pc is missing, synthesize
4848 it, by scanning the DIE's below the compilation unit. */
4849 get_scope_pc_bounds (cu
->dies
, &lowpc
, &highpc
, cu
);
4851 symtab
= end_symtab (highpc
+ baseaddr
, objfile
, SECT_OFF_TEXT (objfile
));
4855 int gcc_4_minor
= producer_is_gcc_ge_4 (cu
->producer
);
4857 /* Set symtab language to language from DW_AT_language. If the
4858 compilation is from a C file generated by language preprocessors, do
4859 not set the language if it was already deduced by start_subfile. */
4860 if (!(cu
->language
== language_c
&& symtab
->language
!= language_c
))
4861 symtab
->language
= cu
->language
;
4863 /* GCC-4.0 has started to support -fvar-tracking. GCC-3.x still can
4864 produce DW_AT_location with location lists but it can be possibly
4865 invalid without -fvar-tracking.
4867 For -gdwarf-4 type units LOCATIONS_VALID indication is fortunately not
4868 needed, it would be wrong due to missing DW_AT_producer there.
4870 Still one can confuse GDB by using non-standard GCC compilation
4871 options - this waits on GCC PR other/32998 (-frecord-gcc-switches).
4873 if (cu
->has_loclist
&& gcc_4_minor
>= 0)
4874 symtab
->locations_valid
= 1;
4876 if (gcc_4_minor
>= 5)
4877 symtab
->epilogue_unwind_valid
= 1;
4879 symtab
->call_site_htab
= cu
->call_site_htab
;
4882 if (dwarf2_per_objfile
->using_index
)
4883 per_cu
->v
.quick
->symtab
= symtab
;
4886 struct partial_symtab
*pst
= per_cu
->v
.psymtab
;
4887 pst
->symtab
= symtab
;
4891 do_cleanups (back_to
);
4894 /* Process a die and its children. */
4897 process_die (struct die_info
*die
, struct dwarf2_cu
*cu
)
4901 case DW_TAG_padding
:
4903 case DW_TAG_compile_unit
:
4904 read_file_scope (die
, cu
);
4906 case DW_TAG_type_unit
:
4907 read_type_unit_scope (die
, cu
);
4909 case DW_TAG_subprogram
:
4910 case DW_TAG_inlined_subroutine
:
4911 read_func_scope (die
, cu
);
4913 case DW_TAG_lexical_block
:
4914 case DW_TAG_try_block
:
4915 case DW_TAG_catch_block
:
4916 read_lexical_block_scope (die
, cu
);
4918 case DW_TAG_GNU_call_site
:
4919 read_call_site_scope (die
, cu
);
4921 case DW_TAG_class_type
:
4922 case DW_TAG_interface_type
:
4923 case DW_TAG_structure_type
:
4924 case DW_TAG_union_type
:
4925 process_structure_scope (die
, cu
);
4927 case DW_TAG_enumeration_type
:
4928 process_enumeration_scope (die
, cu
);
4931 /* These dies have a type, but processing them does not create
4932 a symbol or recurse to process the children. Therefore we can
4933 read them on-demand through read_type_die. */
4934 case DW_TAG_subroutine_type
:
4935 case DW_TAG_set_type
:
4936 case DW_TAG_array_type
:
4937 case DW_TAG_pointer_type
:
4938 case DW_TAG_ptr_to_member_type
:
4939 case DW_TAG_reference_type
:
4940 case DW_TAG_string_type
:
4943 case DW_TAG_base_type
:
4944 case DW_TAG_subrange_type
:
4945 case DW_TAG_typedef
:
4946 /* Add a typedef symbol for the type definition, if it has a
4948 new_symbol (die
, read_type_die (die
, cu
), cu
);
4950 case DW_TAG_common_block
:
4951 read_common_block (die
, cu
);
4953 case DW_TAG_common_inclusion
:
4955 case DW_TAG_namespace
:
4956 processing_has_namespace_info
= 1;
4957 read_namespace (die
, cu
);
4960 processing_has_namespace_info
= 1;
4961 read_module (die
, cu
);
4963 case DW_TAG_imported_declaration
:
4964 case DW_TAG_imported_module
:
4965 processing_has_namespace_info
= 1;
4966 if (die
->child
!= NULL
&& (die
->tag
== DW_TAG_imported_declaration
4967 || cu
->language
!= language_fortran
))
4968 complaint (&symfile_complaints
, _("Tag '%s' has unexpected children"),
4969 dwarf_tag_name (die
->tag
));
4970 read_import_statement (die
, cu
);
4973 new_symbol (die
, NULL
, cu
);
4978 /* A helper function for dwarf2_compute_name which determines whether DIE
4979 needs to have the name of the scope prepended to the name listed in the
4983 die_needs_namespace (struct die_info
*die
, struct dwarf2_cu
*cu
)
4985 struct attribute
*attr
;
4989 case DW_TAG_namespace
:
4990 case DW_TAG_typedef
:
4991 case DW_TAG_class_type
:
4992 case DW_TAG_interface_type
:
4993 case DW_TAG_structure_type
:
4994 case DW_TAG_union_type
:
4995 case DW_TAG_enumeration_type
:
4996 case DW_TAG_enumerator
:
4997 case DW_TAG_subprogram
:
5001 case DW_TAG_variable
:
5002 case DW_TAG_constant
:
5003 /* We only need to prefix "globally" visible variables. These include
5004 any variable marked with DW_AT_external or any variable that
5005 lives in a namespace. [Variables in anonymous namespaces
5006 require prefixing, but they are not DW_AT_external.] */
5008 if (dwarf2_attr (die
, DW_AT_specification
, cu
))
5010 struct dwarf2_cu
*spec_cu
= cu
;
5012 return die_needs_namespace (die_specification (die
, &spec_cu
),
5016 attr
= dwarf2_attr (die
, DW_AT_external
, cu
);
5017 if (attr
== NULL
&& die
->parent
->tag
!= DW_TAG_namespace
5018 && die
->parent
->tag
!= DW_TAG_module
)
5020 /* A variable in a lexical block of some kind does not need a
5021 namespace, even though in C++ such variables may be external
5022 and have a mangled name. */
5023 if (die
->parent
->tag
== DW_TAG_lexical_block
5024 || die
->parent
->tag
== DW_TAG_try_block
5025 || die
->parent
->tag
== DW_TAG_catch_block
5026 || die
->parent
->tag
== DW_TAG_subprogram
)
5035 /* Retrieve the last character from a mem_file. */
5038 do_ui_file_peek_last (void *object
, const char *buffer
, long length
)
5040 char *last_char_p
= (char *) object
;
5043 *last_char_p
= buffer
[length
- 1];
5046 /* Compute the fully qualified name of DIE in CU. If PHYSNAME is nonzero,
5047 compute the physname for the object, which include a method's
5048 formal parameters (C++/Java) and return type (Java).
5050 For Ada, return the DIE's linkage name rather than the fully qualified
5051 name. PHYSNAME is ignored..
5053 The result is allocated on the objfile_obstack and canonicalized. */
5056 dwarf2_compute_name (char *name
, struct die_info
*die
, struct dwarf2_cu
*cu
,
5059 struct objfile
*objfile
= cu
->objfile
;
5062 name
= dwarf2_name (die
, cu
);
5064 /* For Fortran GDB prefers DW_AT_*linkage_name if present but otherwise
5065 compute it by typename_concat inside GDB. */
5066 if (cu
->language
== language_ada
5067 || (cu
->language
== language_fortran
&& physname
))
5069 /* For Ada unit, we prefer the linkage name over the name, as
5070 the former contains the exported name, which the user expects
5071 to be able to reference. Ideally, we want the user to be able
5072 to reference this entity using either natural or linkage name,
5073 but we haven't started looking at this enhancement yet. */
5074 struct attribute
*attr
;
5076 attr
= dwarf2_attr (die
, DW_AT_linkage_name
, cu
);
5078 attr
= dwarf2_attr (die
, DW_AT_MIPS_linkage_name
, cu
);
5079 if (attr
&& DW_STRING (attr
))
5080 return DW_STRING (attr
);
5083 /* These are the only languages we know how to qualify names in. */
5085 && (cu
->language
== language_cplus
|| cu
->language
== language_java
5086 || cu
->language
== language_fortran
))
5088 if (die_needs_namespace (die
, cu
))
5092 struct ui_file
*buf
;
5094 prefix
= determine_prefix (die
, cu
);
5095 buf
= mem_fileopen ();
5096 if (*prefix
!= '\0')
5098 char *prefixed_name
= typename_concat (NULL
, prefix
, name
,
5101 fputs_unfiltered (prefixed_name
, buf
);
5102 xfree (prefixed_name
);
5105 fputs_unfiltered (name
, buf
);
5107 /* Template parameters may be specified in the DIE's DW_AT_name, or
5108 as children with DW_TAG_template_type_param or
5109 DW_TAG_value_type_param. If the latter, add them to the name
5110 here. If the name already has template parameters, then
5111 skip this step; some versions of GCC emit both, and
5112 it is more efficient to use the pre-computed name.
5114 Something to keep in mind about this process: it is very
5115 unlikely, or in some cases downright impossible, to produce
5116 something that will match the mangled name of a function.
5117 If the definition of the function has the same debug info,
5118 we should be able to match up with it anyway. But fallbacks
5119 using the minimal symbol, for instance to find a method
5120 implemented in a stripped copy of libstdc++, will not work.
5121 If we do not have debug info for the definition, we will have to
5122 match them up some other way.
5124 When we do name matching there is a related problem with function
5125 templates; two instantiated function templates are allowed to
5126 differ only by their return types, which we do not add here. */
5128 if (cu
->language
== language_cplus
&& strchr (name
, '<') == NULL
)
5130 struct attribute
*attr
;
5131 struct die_info
*child
;
5134 die
->building_fullname
= 1;
5136 for (child
= die
->child
; child
!= NULL
; child
= child
->sibling
)
5141 struct dwarf2_locexpr_baton
*baton
;
5144 if (child
->tag
!= DW_TAG_template_type_param
5145 && child
->tag
!= DW_TAG_template_value_param
)
5150 fputs_unfiltered ("<", buf
);
5154 fputs_unfiltered (", ", buf
);
5156 attr
= dwarf2_attr (child
, DW_AT_type
, cu
);
5159 complaint (&symfile_complaints
,
5160 _("template parameter missing DW_AT_type"));
5161 fputs_unfiltered ("UNKNOWN_TYPE", buf
);
5164 type
= die_type (child
, cu
);
5166 if (child
->tag
== DW_TAG_template_type_param
)
5168 c_print_type (type
, "", buf
, -1, 0);
5172 attr
= dwarf2_attr (child
, DW_AT_const_value
, cu
);
5175 complaint (&symfile_complaints
,
5176 _("template parameter missing "
5177 "DW_AT_const_value"));
5178 fputs_unfiltered ("UNKNOWN_VALUE", buf
);
5182 dwarf2_const_value_attr (attr
, type
, name
,
5183 &cu
->comp_unit_obstack
, cu
,
5184 &value
, &bytes
, &baton
);
5186 if (TYPE_NOSIGN (type
))
5187 /* GDB prints characters as NUMBER 'CHAR'. If that's
5188 changed, this can use value_print instead. */
5189 c_printchar (value
, type
, buf
);
5192 struct value_print_options opts
;
5195 v
= dwarf2_evaluate_loc_desc (type
, NULL
,
5199 else if (bytes
!= NULL
)
5201 v
= allocate_value (type
);
5202 memcpy (value_contents_writeable (v
), bytes
,
5203 TYPE_LENGTH (type
));
5206 v
= value_from_longest (type
, value
);
5208 /* Specify decimal so that we do not depend on
5210 get_formatted_print_options (&opts
, 'd');
5212 value_print (v
, buf
, &opts
);
5218 die
->building_fullname
= 0;
5222 /* Close the argument list, with a space if necessary
5223 (nested templates). */
5224 char last_char
= '\0';
5225 ui_file_put (buf
, do_ui_file_peek_last
, &last_char
);
5226 if (last_char
== '>')
5227 fputs_unfiltered (" >", buf
);
5229 fputs_unfiltered (">", buf
);
5233 /* For Java and C++ methods, append formal parameter type
5234 information, if PHYSNAME. */
5236 if (physname
&& die
->tag
== DW_TAG_subprogram
5237 && (cu
->language
== language_cplus
5238 || cu
->language
== language_java
))
5240 struct type
*type
= read_type_die (die
, cu
);
5242 c_type_print_args (type
, buf
, 1, cu
->language
);
5244 if (cu
->language
== language_java
)
5246 /* For java, we must append the return type to method
5248 if (die
->tag
== DW_TAG_subprogram
)
5249 java_print_type (TYPE_TARGET_TYPE (type
), "", buf
,
5252 else if (cu
->language
== language_cplus
)
5254 /* Assume that an artificial first parameter is
5255 "this", but do not crash if it is not. RealView
5256 marks unnamed (and thus unused) parameters as
5257 artificial; there is no way to differentiate
5259 if (TYPE_NFIELDS (type
) > 0
5260 && TYPE_FIELD_ARTIFICIAL (type
, 0)
5261 && TYPE_CODE (TYPE_FIELD_TYPE (type
, 0)) == TYPE_CODE_PTR
5262 && TYPE_CONST (TYPE_TARGET_TYPE (TYPE_FIELD_TYPE (type
,
5264 fputs_unfiltered (" const", buf
);
5268 name
= ui_file_obsavestring (buf
, &objfile
->objfile_obstack
,
5270 ui_file_delete (buf
);
5272 if (cu
->language
== language_cplus
)
5275 = dwarf2_canonicalize_name (name
, cu
,
5276 &objfile
->objfile_obstack
);
5287 /* Return the fully qualified name of DIE, based on its DW_AT_name.
5288 If scope qualifiers are appropriate they will be added. The result
5289 will be allocated on the objfile_obstack, or NULL if the DIE does
5290 not have a name. NAME may either be from a previous call to
5291 dwarf2_name or NULL.
5293 The output string will be canonicalized (if C++/Java). */
5296 dwarf2_full_name (char *name
, struct die_info
*die
, struct dwarf2_cu
*cu
)
5298 return dwarf2_compute_name (name
, die
, cu
, 0);
5301 /* Construct a physname for the given DIE in CU. NAME may either be
5302 from a previous call to dwarf2_name or NULL. The result will be
5303 allocated on the objfile_objstack or NULL if the DIE does not have a
5306 The output string will be canonicalized (if C++/Java). */
5309 dwarf2_physname (char *name
, struct die_info
*die
, struct dwarf2_cu
*cu
)
5311 struct objfile
*objfile
= cu
->objfile
;
5312 struct attribute
*attr
;
5313 const char *retval
, *mangled
= NULL
, *canon
= NULL
;
5314 struct cleanup
*back_to
;
5317 /* In this case dwarf2_compute_name is just a shortcut not building anything
5319 if (!die_needs_namespace (die
, cu
))
5320 return dwarf2_compute_name (name
, die
, cu
, 1);
5322 back_to
= make_cleanup (null_cleanup
, NULL
);
5324 attr
= dwarf2_attr (die
, DW_AT_linkage_name
, cu
);
5326 attr
= dwarf2_attr (die
, DW_AT_MIPS_linkage_name
, cu
);
5328 /* DW_AT_linkage_name is missing in some cases - depend on what GDB
5330 if (attr
&& DW_STRING (attr
))
5334 mangled
= DW_STRING (attr
);
5336 /* Use DMGL_RET_DROP for C++ template functions to suppress their return
5337 type. It is easier for GDB users to search for such functions as
5338 `name(params)' than `long name(params)'. In such case the minimal
5339 symbol names do not match the full symbol names but for template
5340 functions there is never a need to look up their definition from their
5341 declaration so the only disadvantage remains the minimal symbol
5342 variant `long name(params)' does not have the proper inferior type.
5345 demangled
= cplus_demangle (mangled
, (DMGL_PARAMS
| DMGL_ANSI
5346 | (cu
->language
== language_java
5347 ? DMGL_JAVA
| DMGL_RET_POSTFIX
5351 make_cleanup (xfree
, demangled
);
5361 if (canon
== NULL
|| check_physname
)
5363 const char *physname
= dwarf2_compute_name (name
, die
, cu
, 1);
5365 if (canon
!= NULL
&& strcmp (physname
, canon
) != 0)
5367 /* It may not mean a bug in GDB. The compiler could also
5368 compute DW_AT_linkage_name incorrectly. But in such case
5369 GDB would need to be bug-to-bug compatible. */
5371 complaint (&symfile_complaints
,
5372 _("Computed physname <%s> does not match demangled <%s> "
5373 "(from linkage <%s>) - DIE at 0x%x [in module %s]"),
5374 physname
, canon
, mangled
, die
->offset
, objfile
->name
);
5376 /* Prefer DW_AT_linkage_name (in the CANON form) - when it
5377 is available here - over computed PHYSNAME. It is safer
5378 against both buggy GDB and buggy compilers. */
5392 retval
= obsavestring (retval
, strlen (retval
),
5393 &objfile
->objfile_obstack
);
5395 do_cleanups (back_to
);
5399 /* Read the import statement specified by the given die and record it. */
5402 read_import_statement (struct die_info
*die
, struct dwarf2_cu
*cu
)
5404 struct objfile
*objfile
= cu
->objfile
;
5405 struct attribute
*import_attr
;
5406 struct die_info
*imported_die
, *child_die
;
5407 struct dwarf2_cu
*imported_cu
;
5408 const char *imported_name
;
5409 const char *imported_name_prefix
;
5410 const char *canonical_name
;
5411 const char *import_alias
;
5412 const char *imported_declaration
= NULL
;
5413 const char *import_prefix
;
5414 VEC (const_char_ptr
) *excludes
= NULL
;
5415 struct cleanup
*cleanups
;
5419 import_attr
= dwarf2_attr (die
, DW_AT_import
, cu
);
5420 if (import_attr
== NULL
)
5422 complaint (&symfile_complaints
, _("Tag '%s' has no DW_AT_import"),
5423 dwarf_tag_name (die
->tag
));
5428 imported_die
= follow_die_ref_or_sig (die
, import_attr
, &imported_cu
);
5429 imported_name
= dwarf2_name (imported_die
, imported_cu
);
5430 if (imported_name
== NULL
)
5432 /* GCC bug: https://bugzilla.redhat.com/show_bug.cgi?id=506524
5434 The import in the following code:
5448 <2><51>: Abbrev Number: 3 (DW_TAG_imported_declaration)
5449 <52> DW_AT_decl_file : 1
5450 <53> DW_AT_decl_line : 6
5451 <54> DW_AT_import : <0x75>
5452 <2><58>: Abbrev Number: 4 (DW_TAG_typedef)
5454 <5b> DW_AT_decl_file : 1
5455 <5c> DW_AT_decl_line : 2
5456 <5d> DW_AT_type : <0x6e>
5458 <1><75>: Abbrev Number: 7 (DW_TAG_base_type)
5459 <76> DW_AT_byte_size : 4
5460 <77> DW_AT_encoding : 5 (signed)
5462 imports the wrong die ( 0x75 instead of 0x58 ).
5463 This case will be ignored until the gcc bug is fixed. */
5467 /* Figure out the local name after import. */
5468 import_alias
= dwarf2_name (die
, cu
);
5470 /* Figure out where the statement is being imported to. */
5471 import_prefix
= determine_prefix (die
, cu
);
5473 /* Figure out what the scope of the imported die is and prepend it
5474 to the name of the imported die. */
5475 imported_name_prefix
= determine_prefix (imported_die
, imported_cu
);
5477 if (imported_die
->tag
!= DW_TAG_namespace
5478 && imported_die
->tag
!= DW_TAG_module
)
5480 imported_declaration
= imported_name
;
5481 canonical_name
= imported_name_prefix
;
5483 else if (strlen (imported_name_prefix
) > 0)
5485 temp
= alloca (strlen (imported_name_prefix
)
5486 + 2 + strlen (imported_name
) + 1);
5487 strcpy (temp
, imported_name_prefix
);
5488 strcat (temp
, "::");
5489 strcat (temp
, imported_name
);
5490 canonical_name
= temp
;
5493 canonical_name
= imported_name
;
5495 cleanups
= make_cleanup (VEC_cleanup (const_char_ptr
), &excludes
);
5497 if (die
->tag
== DW_TAG_imported_module
&& cu
->language
== language_fortran
)
5498 for (child_die
= die
->child
; child_die
&& child_die
->tag
;
5499 child_die
= sibling_die (child_die
))
5501 /* DWARF-4: A Fortran use statement with a “rename list” may be
5502 represented by an imported module entry with an import attribute
5503 referring to the module and owned entries corresponding to those
5504 entities that are renamed as part of being imported. */
5506 if (child_die
->tag
!= DW_TAG_imported_declaration
)
5508 complaint (&symfile_complaints
,
5509 _("child DW_TAG_imported_declaration expected "
5510 "- DIE at 0x%x [in module %s]"),
5511 child_die
->offset
, objfile
->name
);
5515 import_attr
= dwarf2_attr (child_die
, DW_AT_import
, cu
);
5516 if (import_attr
== NULL
)
5518 complaint (&symfile_complaints
, _("Tag '%s' has no DW_AT_import"),
5519 dwarf_tag_name (child_die
->tag
));
5524 imported_die
= follow_die_ref_or_sig (child_die
, import_attr
,
5526 imported_name
= dwarf2_name (imported_die
, imported_cu
);
5527 if (imported_name
== NULL
)
5529 complaint (&symfile_complaints
,
5530 _("child DW_TAG_imported_declaration has unknown "
5531 "imported name - DIE at 0x%x [in module %s]"),
5532 child_die
->offset
, objfile
->name
);
5536 VEC_safe_push (const_char_ptr
, excludes
, imported_name
);
5538 process_die (child_die
, cu
);
5541 cp_add_using_directive (import_prefix
,
5544 imported_declaration
,
5546 &objfile
->objfile_obstack
);
5548 do_cleanups (cleanups
);
5551 /* Cleanup function for read_file_scope. */
5554 free_cu_line_header (void *arg
)
5556 struct dwarf2_cu
*cu
= arg
;
5558 free_line_header (cu
->line_header
);
5559 cu
->line_header
= NULL
;
5563 find_file_and_directory (struct die_info
*die
, struct dwarf2_cu
*cu
,
5564 char **name
, char **comp_dir
)
5566 struct attribute
*attr
;
5571 /* Find the filename. Do not use dwarf2_name here, since the filename
5572 is not a source language identifier. */
5573 attr
= dwarf2_attr (die
, DW_AT_name
, cu
);
5576 *name
= DW_STRING (attr
);
5579 attr
= dwarf2_attr (die
, DW_AT_comp_dir
, cu
);
5581 *comp_dir
= DW_STRING (attr
);
5582 else if (*name
!= NULL
&& IS_ABSOLUTE_PATH (*name
))
5584 *comp_dir
= ldirname (*name
);
5585 if (*comp_dir
!= NULL
)
5586 make_cleanup (xfree
, *comp_dir
);
5588 if (*comp_dir
!= NULL
)
5590 /* Irix 6.2 native cc prepends <machine>.: to the compilation
5591 directory, get rid of it. */
5592 char *cp
= strchr (*comp_dir
, ':');
5594 if (cp
&& cp
!= *comp_dir
&& cp
[-1] == '.' && cp
[1] == '/')
5599 *name
= "<unknown>";
5602 /* Handle DW_AT_stmt_list for a compilation unit. */
5605 handle_DW_AT_stmt_list (struct die_info
*die
, struct dwarf2_cu
*cu
,
5606 const char *comp_dir
)
5608 struct attribute
*attr
;
5609 struct objfile
*objfile
= cu
->objfile
;
5610 bfd
*abfd
= objfile
->obfd
;
5612 /* Decode line number information if present. We do this before
5613 processing child DIEs, so that the line header table is available
5614 for DW_AT_decl_file. */
5615 attr
= dwarf2_attr (die
, DW_AT_stmt_list
, cu
);
5618 unsigned int line_offset
= DW_UNSND (attr
);
5619 struct line_header
*line_header
5620 = dwarf_decode_line_header (line_offset
, abfd
, cu
);
5624 cu
->line_header
= line_header
;
5625 make_cleanup (free_cu_line_header
, cu
);
5626 dwarf_decode_lines (line_header
, comp_dir
, abfd
, cu
, NULL
);
5631 /* Process DW_TAG_compile_unit. */
5634 read_file_scope (struct die_info
*die
, struct dwarf2_cu
*cu
)
5636 struct objfile
*objfile
= cu
->objfile
;
5637 struct cleanup
*back_to
= make_cleanup (null_cleanup
, 0);
5638 CORE_ADDR lowpc
= ((CORE_ADDR
) -1);
5639 CORE_ADDR highpc
= ((CORE_ADDR
) 0);
5640 struct attribute
*attr
;
5642 char *comp_dir
= NULL
;
5643 struct die_info
*child_die
;
5644 bfd
*abfd
= objfile
->obfd
;
5647 baseaddr
= ANOFFSET (objfile
->section_offsets
, SECT_OFF_TEXT (objfile
));
5649 get_scope_pc_bounds (die
, &lowpc
, &highpc
, cu
);
5651 /* If we didn't find a lowpc, set it to highpc to avoid complaints
5652 from finish_block. */
5653 if (lowpc
== ((CORE_ADDR
) -1))
5658 find_file_and_directory (die
, cu
, &name
, &comp_dir
);
5660 attr
= dwarf2_attr (die
, DW_AT_language
, cu
);
5663 set_cu_language (DW_UNSND (attr
), cu
);
5666 attr
= dwarf2_attr (die
, DW_AT_producer
, cu
);
5668 cu
->producer
= DW_STRING (attr
);
5670 /* The XLCL doesn't generate DW_LANG_OpenCL because this attribute is not
5671 standardised yet. As a workaround for the language detection we fall
5672 back to the DW_AT_producer string. */
5673 if (cu
->producer
&& strstr (cu
->producer
, "IBM XL C for OpenCL") != NULL
)
5674 cu
->language
= language_opencl
;
5676 /* We assume that we're processing GCC output. */
5677 processing_gcc_compilation
= 2;
5679 processing_has_namespace_info
= 0;
5681 start_symtab (name
, comp_dir
, lowpc
);
5682 record_debugformat ("DWARF 2");
5683 record_producer (cu
->producer
);
5685 handle_DW_AT_stmt_list (die
, cu
, comp_dir
);
5687 /* Process all dies in compilation unit. */
5688 if (die
->child
!= NULL
)
5690 child_die
= die
->child
;
5691 while (child_die
&& child_die
->tag
)
5693 process_die (child_die
, cu
);
5694 child_die
= sibling_die (child_die
);
5698 /* Decode macro information, if present. Dwarf 2 macro information
5699 refers to information in the line number info statement program
5700 header, so we can only read it if we've read the header
5702 attr
= dwarf2_attr (die
, DW_AT_GNU_macros
, cu
);
5703 if (attr
&& cu
->line_header
)
5705 if (dwarf2_attr (die
, DW_AT_macro_info
, cu
))
5706 complaint (&symfile_complaints
,
5707 _("CU refers to both DW_AT_GNU_macros and DW_AT_macro_info"));
5709 dwarf_decode_macros (cu
->line_header
, DW_UNSND (attr
),
5711 &dwarf2_per_objfile
->macro
, 1);
5715 attr
= dwarf2_attr (die
, DW_AT_macro_info
, cu
);
5716 if (attr
&& cu
->line_header
)
5718 unsigned int macro_offset
= DW_UNSND (attr
);
5720 dwarf_decode_macros (cu
->line_header
, macro_offset
,
5722 &dwarf2_per_objfile
->macinfo
, 0);
5726 do_cleanups (back_to
);
5729 /* Process DW_TAG_type_unit.
5730 For TUs we want to skip the first top level sibling if it's not the
5731 actual type being defined by this TU. In this case the first top
5732 level sibling is there to provide context only. */
5735 read_type_unit_scope (struct die_info
*die
, struct dwarf2_cu
*cu
)
5737 struct objfile
*objfile
= cu
->objfile
;
5738 struct cleanup
*back_to
= make_cleanup (null_cleanup
, 0);
5740 struct attribute
*attr
;
5742 char *comp_dir
= NULL
;
5743 struct die_info
*child_die
;
5744 bfd
*abfd
= objfile
->obfd
;
5746 /* start_symtab needs a low pc, but we don't really have one.
5747 Do what read_file_scope would do in the absence of such info. */
5748 lowpc
= ANOFFSET (objfile
->section_offsets
, SECT_OFF_TEXT (objfile
));
5750 /* Find the filename. Do not use dwarf2_name here, since the filename
5751 is not a source language identifier. */
5752 attr
= dwarf2_attr (die
, DW_AT_name
, cu
);
5754 name
= DW_STRING (attr
);
5756 attr
= dwarf2_attr (die
, DW_AT_comp_dir
, cu
);
5758 comp_dir
= DW_STRING (attr
);
5759 else if (name
!= NULL
&& IS_ABSOLUTE_PATH (name
))
5761 comp_dir
= ldirname (name
);
5762 if (comp_dir
!= NULL
)
5763 make_cleanup (xfree
, comp_dir
);
5769 attr
= dwarf2_attr (die
, DW_AT_language
, cu
);
5771 set_cu_language (DW_UNSND (attr
), cu
);
5773 /* This isn't technically needed today. It is done for symmetry
5774 with read_file_scope. */
5775 attr
= dwarf2_attr (die
, DW_AT_producer
, cu
);
5777 cu
->producer
= DW_STRING (attr
);
5779 /* We assume that we're processing GCC output. */
5780 processing_gcc_compilation
= 2;
5782 processing_has_namespace_info
= 0;
5784 start_symtab (name
, comp_dir
, lowpc
);
5785 record_debugformat ("DWARF 2");
5786 record_producer (cu
->producer
);
5788 handle_DW_AT_stmt_list (die
, cu
, comp_dir
);
5790 /* Process the dies in the type unit. */
5791 if (die
->child
== NULL
)
5793 dump_die_for_error (die
);
5794 error (_("Dwarf Error: Missing children for type unit [in module %s]"),
5795 bfd_get_filename (abfd
));
5798 child_die
= die
->child
;
5800 while (child_die
&& child_die
->tag
)
5802 process_die (child_die
, cu
);
5804 child_die
= sibling_die (child_die
);
5807 do_cleanups (back_to
);
5810 /* qsort helper for inherit_abstract_dies. */
5813 unsigned_int_compar (const void *ap
, const void *bp
)
5815 unsigned int a
= *(unsigned int *) ap
;
5816 unsigned int b
= *(unsigned int *) bp
;
5818 return (a
> b
) - (b
> a
);
5821 /* DW_AT_abstract_origin inherits whole DIEs (not just their attributes).
5822 Inherit only the children of the DW_AT_abstract_origin DIE not being
5823 already referenced by DW_AT_abstract_origin from the children of the
5827 inherit_abstract_dies (struct die_info
*die
, struct dwarf2_cu
*cu
)
5829 struct die_info
*child_die
;
5830 unsigned die_children_count
;
5831 /* CU offsets which were referenced by children of the current DIE. */
5833 unsigned *offsets_end
, *offsetp
;
5834 /* Parent of DIE - referenced by DW_AT_abstract_origin. */
5835 struct die_info
*origin_die
;
5836 /* Iterator of the ORIGIN_DIE children. */
5837 struct die_info
*origin_child_die
;
5838 struct cleanup
*cleanups
;
5839 struct attribute
*attr
;
5840 struct dwarf2_cu
*origin_cu
;
5841 struct pending
**origin_previous_list_in_scope
;
5843 attr
= dwarf2_attr (die
, DW_AT_abstract_origin
, cu
);
5847 /* Note that following die references may follow to a die in a
5851 origin_die
= follow_die_ref (die
, attr
, &origin_cu
);
5853 /* We're inheriting ORIGIN's children into the scope we'd put DIE's
5855 origin_previous_list_in_scope
= origin_cu
->list_in_scope
;
5856 origin_cu
->list_in_scope
= cu
->list_in_scope
;
5858 if (die
->tag
!= origin_die
->tag
5859 && !(die
->tag
== DW_TAG_inlined_subroutine
5860 && origin_die
->tag
== DW_TAG_subprogram
))
5861 complaint (&symfile_complaints
,
5862 _("DIE 0x%x and its abstract origin 0x%x have different tags"),
5863 die
->offset
, origin_die
->offset
);
5865 child_die
= die
->child
;
5866 die_children_count
= 0;
5867 while (child_die
&& child_die
->tag
)
5869 child_die
= sibling_die (child_die
);
5870 die_children_count
++;
5872 offsets
= xmalloc (sizeof (*offsets
) * die_children_count
);
5873 cleanups
= make_cleanup (xfree
, offsets
);
5875 offsets_end
= offsets
;
5876 child_die
= die
->child
;
5877 while (child_die
&& child_die
->tag
)
5879 /* For each CHILD_DIE, find the corresponding child of
5880 ORIGIN_DIE. If there is more than one layer of
5881 DW_AT_abstract_origin, follow them all; there shouldn't be,
5882 but GCC versions at least through 4.4 generate this (GCC PR
5884 struct die_info
*child_origin_die
= child_die
;
5885 struct dwarf2_cu
*child_origin_cu
= cu
;
5889 attr
= dwarf2_attr (child_origin_die
, DW_AT_abstract_origin
,
5893 child_origin_die
= follow_die_ref (child_origin_die
, attr
,
5897 /* According to DWARF3 3.3.8.2 #3 new entries without their abstract
5898 counterpart may exist. */
5899 if (child_origin_die
!= child_die
)
5901 if (child_die
->tag
!= child_origin_die
->tag
5902 && !(child_die
->tag
== DW_TAG_inlined_subroutine
5903 && child_origin_die
->tag
== DW_TAG_subprogram
))
5904 complaint (&symfile_complaints
,
5905 _("Child DIE 0x%x and its abstract origin 0x%x have "
5906 "different tags"), child_die
->offset
,
5907 child_origin_die
->offset
);
5908 if (child_origin_die
->parent
!= origin_die
)
5909 complaint (&symfile_complaints
,
5910 _("Child DIE 0x%x and its abstract origin 0x%x have "
5911 "different parents"), child_die
->offset
,
5912 child_origin_die
->offset
);
5914 *offsets_end
++ = child_origin_die
->offset
;
5916 child_die
= sibling_die (child_die
);
5918 qsort (offsets
, offsets_end
- offsets
, sizeof (*offsets
),
5919 unsigned_int_compar
);
5920 for (offsetp
= offsets
+ 1; offsetp
< offsets_end
; offsetp
++)
5921 if (offsetp
[-1] == *offsetp
)
5922 complaint (&symfile_complaints
,
5923 _("Multiple children of DIE 0x%x refer "
5924 "to DIE 0x%x as their abstract origin"),
5925 die
->offset
, *offsetp
);
5928 origin_child_die
= origin_die
->child
;
5929 while (origin_child_die
&& origin_child_die
->tag
)
5931 /* Is ORIGIN_CHILD_DIE referenced by any of the DIE children? */
5932 while (offsetp
< offsets_end
&& *offsetp
< origin_child_die
->offset
)
5934 if (offsetp
>= offsets_end
|| *offsetp
> origin_child_die
->offset
)
5936 /* Found that ORIGIN_CHILD_DIE is really not referenced. */
5937 process_die (origin_child_die
, origin_cu
);
5939 origin_child_die
= sibling_die (origin_child_die
);
5941 origin_cu
->list_in_scope
= origin_previous_list_in_scope
;
5943 do_cleanups (cleanups
);
5947 read_func_scope (struct die_info
*die
, struct dwarf2_cu
*cu
)
5949 struct objfile
*objfile
= cu
->objfile
;
5950 struct context_stack
*new;
5953 struct die_info
*child_die
;
5954 struct attribute
*attr
, *call_line
, *call_file
;
5957 struct block
*block
;
5958 int inlined_func
= (die
->tag
== DW_TAG_inlined_subroutine
);
5959 VEC (symbolp
) *template_args
= NULL
;
5960 struct template_symbol
*templ_func
= NULL
;
5964 /* If we do not have call site information, we can't show the
5965 caller of this inlined function. That's too confusing, so
5966 only use the scope for local variables. */
5967 call_line
= dwarf2_attr (die
, DW_AT_call_line
, cu
);
5968 call_file
= dwarf2_attr (die
, DW_AT_call_file
, cu
);
5969 if (call_line
== NULL
|| call_file
== NULL
)
5971 read_lexical_block_scope (die
, cu
);
5976 baseaddr
= ANOFFSET (objfile
->section_offsets
, SECT_OFF_TEXT (objfile
));
5978 name
= dwarf2_name (die
, cu
);
5980 /* Ignore functions with missing or empty names. These are actually
5981 illegal according to the DWARF standard. */
5984 complaint (&symfile_complaints
,
5985 _("missing name for subprogram DIE at %d"), die
->offset
);
5989 /* Ignore functions with missing or invalid low and high pc attributes. */
5990 if (!dwarf2_get_pc_bounds (die
, &lowpc
, &highpc
, cu
, NULL
))
5992 attr
= dwarf2_attr (die
, DW_AT_external
, cu
);
5993 if (!attr
|| !DW_UNSND (attr
))
5994 complaint (&symfile_complaints
,
5995 _("cannot get low and high bounds "
5996 "for subprogram DIE at %d"),
6004 /* If we have any template arguments, then we must allocate a
6005 different sort of symbol. */
6006 for (child_die
= die
->child
; child_die
; child_die
= sibling_die (child_die
))
6008 if (child_die
->tag
== DW_TAG_template_type_param
6009 || child_die
->tag
== DW_TAG_template_value_param
)
6011 templ_func
= OBSTACK_ZALLOC (&objfile
->objfile_obstack
,
6012 struct template_symbol
);
6013 templ_func
->base
.is_cplus_template_function
= 1;
6018 new = push_context (0, lowpc
);
6019 new->name
= new_symbol_full (die
, read_type_die (die
, cu
), cu
,
6020 (struct symbol
*) templ_func
);
6022 /* If there is a location expression for DW_AT_frame_base, record
6024 attr
= dwarf2_attr (die
, DW_AT_frame_base
, cu
);
6026 /* FIXME: cagney/2004-01-26: The DW_AT_frame_base's location
6027 expression is being recorded directly in the function's symbol
6028 and not in a separate frame-base object. I guess this hack is
6029 to avoid adding some sort of frame-base adjunct/annex to the
6030 function's symbol :-(. The problem with doing this is that it
6031 results in a function symbol with a location expression that
6032 has nothing to do with the location of the function, ouch! The
6033 relationship should be: a function's symbol has-a frame base; a
6034 frame-base has-a location expression. */
6035 dwarf2_symbol_mark_computed (attr
, new->name
, cu
);
6037 cu
->list_in_scope
= &local_symbols
;
6039 if (die
->child
!= NULL
)
6041 child_die
= die
->child
;
6042 while (child_die
&& child_die
->tag
)
6044 if (child_die
->tag
== DW_TAG_template_type_param
6045 || child_die
->tag
== DW_TAG_template_value_param
)
6047 struct symbol
*arg
= new_symbol (child_die
, NULL
, cu
);
6050 VEC_safe_push (symbolp
, template_args
, arg
);
6053 process_die (child_die
, cu
);
6054 child_die
= sibling_die (child_die
);
6058 inherit_abstract_dies (die
, cu
);
6060 /* If we have a DW_AT_specification, we might need to import using
6061 directives from the context of the specification DIE. See the
6062 comment in determine_prefix. */
6063 if (cu
->language
== language_cplus
6064 && dwarf2_attr (die
, DW_AT_specification
, cu
))
6066 struct dwarf2_cu
*spec_cu
= cu
;
6067 struct die_info
*spec_die
= die_specification (die
, &spec_cu
);
6071 child_die
= spec_die
->child
;
6072 while (child_die
&& child_die
->tag
)
6074 if (child_die
->tag
== DW_TAG_imported_module
)
6075 process_die (child_die
, spec_cu
);
6076 child_die
= sibling_die (child_die
);
6079 /* In some cases, GCC generates specification DIEs that
6080 themselves contain DW_AT_specification attributes. */
6081 spec_die
= die_specification (spec_die
, &spec_cu
);
6085 new = pop_context ();
6086 /* Make a block for the local symbols within. */
6087 block
= finish_block (new->name
, &local_symbols
, new->old_blocks
,
6088 lowpc
, highpc
, objfile
);
6090 /* For C++, set the block's scope. */
6091 if (cu
->language
== language_cplus
|| cu
->language
== language_fortran
)
6092 cp_set_block_scope (new->name
, block
, &objfile
->objfile_obstack
,
6093 determine_prefix (die
, cu
),
6094 processing_has_namespace_info
);
6096 /* If we have address ranges, record them. */
6097 dwarf2_record_block_ranges (die
, block
, baseaddr
, cu
);
6099 /* Attach template arguments to function. */
6100 if (! VEC_empty (symbolp
, template_args
))
6102 gdb_assert (templ_func
!= NULL
);
6104 templ_func
->n_template_arguments
= VEC_length (symbolp
, template_args
);
6105 templ_func
->template_arguments
6106 = obstack_alloc (&objfile
->objfile_obstack
,
6107 (templ_func
->n_template_arguments
6108 * sizeof (struct symbol
*)));
6109 memcpy (templ_func
->template_arguments
,
6110 VEC_address (symbolp
, template_args
),
6111 (templ_func
->n_template_arguments
* sizeof (struct symbol
*)));
6112 VEC_free (symbolp
, template_args
);
6115 /* In C++, we can have functions nested inside functions (e.g., when
6116 a function declares a class that has methods). This means that
6117 when we finish processing a function scope, we may need to go
6118 back to building a containing block's symbol lists. */
6119 local_symbols
= new->locals
;
6120 param_symbols
= new->params
;
6121 using_directives
= new->using_directives
;
6123 /* If we've finished processing a top-level function, subsequent
6124 symbols go in the file symbol list. */
6125 if (outermost_context_p ())
6126 cu
->list_in_scope
= &file_symbols
;
6129 /* Process all the DIES contained within a lexical block scope. Start
6130 a new scope, process the dies, and then close the scope. */
6133 read_lexical_block_scope (struct die_info
*die
, struct dwarf2_cu
*cu
)
6135 struct objfile
*objfile
= cu
->objfile
;
6136 struct context_stack
*new;
6137 CORE_ADDR lowpc
, highpc
;
6138 struct die_info
*child_die
;
6141 baseaddr
= ANOFFSET (objfile
->section_offsets
, SECT_OFF_TEXT (objfile
));
6143 /* Ignore blocks with missing or invalid low and high pc attributes. */
6144 /* ??? Perhaps consider discontiguous blocks defined by DW_AT_ranges
6145 as multiple lexical blocks? Handling children in a sane way would
6146 be nasty. Might be easier to properly extend generic blocks to
6148 if (!dwarf2_get_pc_bounds (die
, &lowpc
, &highpc
, cu
, NULL
))
6153 push_context (0, lowpc
);
6154 if (die
->child
!= NULL
)
6156 child_die
= die
->child
;
6157 while (child_die
&& child_die
->tag
)
6159 process_die (child_die
, cu
);
6160 child_die
= sibling_die (child_die
);
6163 new = pop_context ();
6165 if (local_symbols
!= NULL
|| using_directives
!= NULL
)
6168 = finish_block (0, &local_symbols
, new->old_blocks
, new->start_addr
,
6171 /* Note that recording ranges after traversing children, as we
6172 do here, means that recording a parent's ranges entails
6173 walking across all its children's ranges as they appear in
6174 the address map, which is quadratic behavior.
6176 It would be nicer to record the parent's ranges before
6177 traversing its children, simply overriding whatever you find
6178 there. But since we don't even decide whether to create a
6179 block until after we've traversed its children, that's hard
6181 dwarf2_record_block_ranges (die
, block
, baseaddr
, cu
);
6183 local_symbols
= new->locals
;
6184 using_directives
= new->using_directives
;
6187 /* Read in DW_TAG_GNU_call_site and insert it to CU->call_site_htab. */
6190 read_call_site_scope (struct die_info
*die
, struct dwarf2_cu
*cu
)
6192 struct objfile
*objfile
= cu
->objfile
;
6193 struct gdbarch
*gdbarch
= get_objfile_arch (objfile
);
6194 CORE_ADDR pc
, baseaddr
;
6195 struct attribute
*attr
;
6196 struct call_site
*call_site
, call_site_local
;
6199 struct die_info
*child_die
;
6201 baseaddr
= ANOFFSET (objfile
->section_offsets
, SECT_OFF_TEXT (objfile
));
6203 attr
= dwarf2_attr (die
, DW_AT_low_pc
, cu
);
6206 complaint (&symfile_complaints
,
6207 _("missing DW_AT_low_pc for DW_TAG_GNU_call_site "
6208 "DIE 0x%x [in module %s]"),
6209 die
->offset
, objfile
->name
);
6212 pc
= DW_ADDR (attr
) + baseaddr
;
6214 if (cu
->call_site_htab
== NULL
)
6215 cu
->call_site_htab
= htab_create_alloc_ex (16, core_addr_hash
, core_addr_eq
,
6216 NULL
, &objfile
->objfile_obstack
,
6217 hashtab_obstack_allocate
, NULL
);
6218 call_site_local
.pc
= pc
;
6219 slot
= htab_find_slot (cu
->call_site_htab
, &call_site_local
, INSERT
);
6222 complaint (&symfile_complaints
,
6223 _("Duplicate PC %s for DW_TAG_GNU_call_site "
6224 "DIE 0x%x [in module %s]"),
6225 paddress (gdbarch
, pc
), die
->offset
, objfile
->name
);
6229 /* Count parameters at the caller. */
6232 for (child_die
= die
->child
; child_die
&& child_die
->tag
;
6233 child_die
= sibling_die (child_die
))
6235 if (child_die
->tag
!= DW_TAG_GNU_call_site_parameter
)
6237 complaint (&symfile_complaints
,
6238 _("Tag %d is not DW_TAG_GNU_call_site_parameter in "
6239 "DW_TAG_GNU_call_site child DIE 0x%x [in module %s]"),
6240 child_die
->tag
, child_die
->offset
, objfile
->name
);
6247 call_site
= obstack_alloc (&objfile
->objfile_obstack
,
6248 (sizeof (*call_site
)
6249 + (sizeof (*call_site
->parameter
)
6252 memset (call_site
, 0, sizeof (*call_site
) - sizeof (*call_site
->parameter
));
6255 if (dwarf2_flag_true_p (die
, DW_AT_GNU_tail_call
, cu
))
6257 struct die_info
*func_die
;
6259 /* Skip also over DW_TAG_inlined_subroutine. */
6260 for (func_die
= die
->parent
;
6261 func_die
&& func_die
->tag
!= DW_TAG_subprogram
6262 && func_die
->tag
!= DW_TAG_subroutine_type
;
6263 func_die
= func_die
->parent
);
6265 /* DW_AT_GNU_all_call_sites is a superset
6266 of DW_AT_GNU_all_tail_call_sites. */
6268 && !dwarf2_flag_true_p (func_die
, DW_AT_GNU_all_call_sites
, cu
)
6269 && !dwarf2_flag_true_p (func_die
, DW_AT_GNU_all_tail_call_sites
, cu
))
6271 /* TYPE_TAIL_CALL_LIST is not interesting in functions where it is
6272 not complete. But keep CALL_SITE for look ups via call_site_htab,
6273 both the initial caller containing the real return address PC and
6274 the final callee containing the current PC of a chain of tail
6275 calls do not need to have the tail call list complete. But any
6276 function candidate for a virtual tail call frame searched via
6277 TYPE_TAIL_CALL_LIST must have the tail call list complete to be
6278 determined unambiguously. */
6282 struct type
*func_type
= NULL
;
6285 func_type
= get_die_type (func_die
, cu
);
6286 if (func_type
!= NULL
)
6288 gdb_assert (TYPE_CODE (func_type
) == TYPE_CODE_FUNC
);
6290 /* Enlist this call site to the function. */
6291 call_site
->tail_call_next
= TYPE_TAIL_CALL_LIST (func_type
);
6292 TYPE_TAIL_CALL_LIST (func_type
) = call_site
;
6295 complaint (&symfile_complaints
,
6296 _("Cannot find function owning DW_TAG_GNU_call_site "
6297 "DIE 0x%x [in module %s]"),
6298 die
->offset
, objfile
->name
);
6302 attr
= dwarf2_attr (die
, DW_AT_GNU_call_site_target
, cu
);
6304 attr
= dwarf2_attr (die
, DW_AT_abstract_origin
, cu
);
6305 SET_FIELD_DWARF_BLOCK (call_site
->target
, NULL
);
6306 if (!attr
|| (attr_form_is_block (attr
) && DW_BLOCK (attr
)->size
== 0))
6307 /* Keep NULL DWARF_BLOCK. */;
6308 else if (attr_form_is_block (attr
))
6310 struct dwarf2_locexpr_baton
*dlbaton
;
6312 dlbaton
= obstack_alloc (&objfile
->objfile_obstack
, sizeof (*dlbaton
));
6313 dlbaton
->data
= DW_BLOCK (attr
)->data
;
6314 dlbaton
->size
= DW_BLOCK (attr
)->size
;
6315 dlbaton
->per_cu
= cu
->per_cu
;
6317 SET_FIELD_DWARF_BLOCK (call_site
->target
, dlbaton
);
6319 else if (is_ref_attr (attr
))
6321 struct dwarf2_cu
*target_cu
= cu
;
6322 struct die_info
*target_die
;
6324 target_die
= follow_die_ref_or_sig (die
, attr
, &target_cu
);
6325 gdb_assert (target_cu
->objfile
== objfile
);
6326 if (die_is_declaration (target_die
, target_cu
))
6328 const char *target_physname
;
6330 target_physname
= dwarf2_physname (NULL
, target_die
, target_cu
);
6331 if (target_physname
== NULL
)
6332 complaint (&symfile_complaints
,
6333 _("DW_AT_GNU_call_site_target target DIE has invalid "
6334 "physname, for referencing DIE 0x%x [in module %s]"),
6335 die
->offset
, objfile
->name
);
6337 SET_FIELD_PHYSNAME (call_site
->target
, (char *) target_physname
);
6343 /* DW_AT_entry_pc should be preferred. */
6344 if (!dwarf2_get_pc_bounds (target_die
, &lowpc
, NULL
, target_cu
, NULL
))
6345 complaint (&symfile_complaints
,
6346 _("DW_AT_GNU_call_site_target target DIE has invalid "
6347 "low pc, for referencing DIE 0x%x [in module %s]"),
6348 die
->offset
, objfile
->name
);
6350 SET_FIELD_PHYSADDR (call_site
->target
, lowpc
+ baseaddr
);
6354 complaint (&symfile_complaints
,
6355 _("DW_TAG_GNU_call_site DW_AT_GNU_call_site_target is neither "
6356 "block nor reference, for DIE 0x%x [in module %s]"),
6357 die
->offset
, objfile
->name
);
6359 call_site
->per_cu
= cu
->per_cu
;
6361 for (child_die
= die
->child
;
6362 child_die
&& child_die
->tag
;
6363 child_die
= sibling_die (child_die
))
6365 struct dwarf2_locexpr_baton
*dlbaton
;
6366 struct call_site_parameter
*parameter
;
6368 if (child_die
->tag
!= DW_TAG_GNU_call_site_parameter
)
6370 /* Already printed the complaint above. */
6374 gdb_assert (call_site
->parameter_count
< nparams
);
6375 parameter
= &call_site
->parameter
[call_site
->parameter_count
];
6377 /* DW_AT_location specifies the register number. Value of the data
6378 assumed for the register is contained in DW_AT_GNU_call_site_value. */
6380 attr
= dwarf2_attr (child_die
, DW_AT_location
, cu
);
6381 if (!attr
|| !attr_form_is_block (attr
))
6383 complaint (&symfile_complaints
,
6384 _("No DW_FORM_block* DW_AT_location for "
6385 "DW_TAG_GNU_call_site child DIE 0x%x [in module %s]"),
6386 child_die
->offset
, objfile
->name
);
6389 parameter
->dwarf_reg
= dwarf_block_to_dwarf_reg (DW_BLOCK (attr
)->data
,
6390 &DW_BLOCK (attr
)->data
[DW_BLOCK (attr
)->size
]);
6391 if (parameter
->dwarf_reg
== -1
6392 && !dwarf_block_to_sp_offset (gdbarch
, DW_BLOCK (attr
)->data
,
6393 &DW_BLOCK (attr
)->data
[DW_BLOCK (attr
)->size
],
6394 ¶meter
->fb_offset
))
6396 complaint (&symfile_complaints
,
6397 _("Only single DW_OP_reg or DW_OP_fbreg is supported "
6398 "for DW_FORM_block* DW_AT_location for "
6399 "DW_TAG_GNU_call_site child DIE 0x%x [in module %s]"),
6400 child_die
->offset
, objfile
->name
);
6404 attr
= dwarf2_attr (child_die
, DW_AT_GNU_call_site_value
, cu
);
6405 if (!attr_form_is_block (attr
))
6407 complaint (&symfile_complaints
,
6408 _("No DW_FORM_block* DW_AT_GNU_call_site_value for "
6409 "DW_TAG_GNU_call_site child DIE 0x%x [in module %s]"),
6410 child_die
->offset
, objfile
->name
);
6413 parameter
->value
= DW_BLOCK (attr
)->data
;
6414 parameter
->value_size
= DW_BLOCK (attr
)->size
;
6416 /* Parameters are not pre-cleared by memset above. */
6417 parameter
->data_value
= NULL
;
6418 parameter
->data_value_size
= 0;
6419 call_site
->parameter_count
++;
6421 attr
= dwarf2_attr (child_die
, DW_AT_GNU_call_site_data_value
, cu
);
6424 if (!attr_form_is_block (attr
))
6425 complaint (&symfile_complaints
,
6426 _("No DW_FORM_block* DW_AT_GNU_call_site_data_value for "
6427 "DW_TAG_GNU_call_site child DIE 0x%x [in module %s]"),
6428 child_die
->offset
, objfile
->name
);
6431 parameter
->data_value
= DW_BLOCK (attr
)->data
;
6432 parameter
->data_value_size
= DW_BLOCK (attr
)->size
;
6438 /* Get low and high pc attributes from DW_AT_ranges attribute value OFFSET.
6439 Return 1 if the attributes are present and valid, otherwise, return 0.
6440 If RANGES_PST is not NULL we should setup `objfile->psymtabs_addrmap'. */
6443 dwarf2_ranges_read (unsigned offset
, CORE_ADDR
*low_return
,
6444 CORE_ADDR
*high_return
, struct dwarf2_cu
*cu
,
6445 struct partial_symtab
*ranges_pst
)
6447 struct objfile
*objfile
= cu
->objfile
;
6448 struct comp_unit_head
*cu_header
= &cu
->header
;
6449 bfd
*obfd
= objfile
->obfd
;
6450 unsigned int addr_size
= cu_header
->addr_size
;
6451 CORE_ADDR mask
= ~(~(CORE_ADDR
)1 << (addr_size
* 8 - 1));
6452 /* Base address selection entry. */
6463 found_base
= cu
->base_known
;
6464 base
= cu
->base_address
;
6466 dwarf2_read_section (objfile
, &dwarf2_per_objfile
->ranges
);
6467 if (offset
>= dwarf2_per_objfile
->ranges
.size
)
6469 complaint (&symfile_complaints
,
6470 _("Offset %d out of bounds for DW_AT_ranges attribute"),
6474 buffer
= dwarf2_per_objfile
->ranges
.buffer
+ offset
;
6476 /* Read in the largest possible address. */
6477 marker
= read_address (obfd
, buffer
, cu
, &dummy
);
6478 if ((marker
& mask
) == mask
)
6480 /* If we found the largest possible address, then
6481 read the base address. */
6482 base
= read_address (obfd
, buffer
+ addr_size
, cu
, &dummy
);
6483 buffer
+= 2 * addr_size
;
6484 offset
+= 2 * addr_size
;
6490 baseaddr
= ANOFFSET (objfile
->section_offsets
, SECT_OFF_TEXT (objfile
));
6494 CORE_ADDR range_beginning
, range_end
;
6496 range_beginning
= read_address (obfd
, buffer
, cu
, &dummy
);
6497 buffer
+= addr_size
;
6498 range_end
= read_address (obfd
, buffer
, cu
, &dummy
);
6499 buffer
+= addr_size
;
6500 offset
+= 2 * addr_size
;
6502 /* An end of list marker is a pair of zero addresses. */
6503 if (range_beginning
== 0 && range_end
== 0)
6504 /* Found the end of list entry. */
6507 /* Each base address selection entry is a pair of 2 values.
6508 The first is the largest possible address, the second is
6509 the base address. Check for a base address here. */
6510 if ((range_beginning
& mask
) == mask
)
6512 /* If we found the largest possible address, then
6513 read the base address. */
6514 base
= read_address (obfd
, buffer
+ addr_size
, cu
, &dummy
);
6521 /* We have no valid base address for the ranges
6523 complaint (&symfile_complaints
,
6524 _("Invalid .debug_ranges data (no base address)"));
6528 if (range_beginning
> range_end
)
6530 /* Inverted range entries are invalid. */
6531 complaint (&symfile_complaints
,
6532 _("Invalid .debug_ranges data (inverted range)"));
6536 /* Empty range entries have no effect. */
6537 if (range_beginning
== range_end
)
6540 range_beginning
+= base
;
6543 if (ranges_pst
!= NULL
)
6544 addrmap_set_empty (objfile
->psymtabs_addrmap
,
6545 range_beginning
+ baseaddr
,
6546 range_end
- 1 + baseaddr
,
6549 /* FIXME: This is recording everything as a low-high
6550 segment of consecutive addresses. We should have a
6551 data structure for discontiguous block ranges
6555 low
= range_beginning
;
6561 if (range_beginning
< low
)
6562 low
= range_beginning
;
6563 if (range_end
> high
)
6569 /* If the first entry is an end-of-list marker, the range
6570 describes an empty scope, i.e. no instructions. */
6576 *high_return
= high
;
6580 /* Get low and high pc attributes from a die. Return 1 if the attributes
6581 are present and valid, otherwise, return 0. Return -1 if the range is
6582 discontinuous, i.e. derived from DW_AT_ranges information. */
6584 dwarf2_get_pc_bounds (struct die_info
*die
, CORE_ADDR
*lowpc
,
6585 CORE_ADDR
*highpc
, struct dwarf2_cu
*cu
,
6586 struct partial_symtab
*pst
)
6588 struct attribute
*attr
;
6593 attr
= dwarf2_attr (die
, DW_AT_high_pc
, cu
);
6596 high
= DW_ADDR (attr
);
6597 attr
= dwarf2_attr (die
, DW_AT_low_pc
, cu
);
6599 low
= DW_ADDR (attr
);
6601 /* Found high w/o low attribute. */
6604 /* Found consecutive range of addresses. */
6609 attr
= dwarf2_attr (die
, DW_AT_ranges
, cu
);
6612 /* Value of the DW_AT_ranges attribute is the offset in the
6613 .debug_ranges section. */
6614 if (!dwarf2_ranges_read (DW_UNSND (attr
), &low
, &high
, cu
, pst
))
6616 /* Found discontinuous range of addresses. */
6621 /* read_partial_die has also the strict LOW < HIGH requirement. */
6625 /* When using the GNU linker, .gnu.linkonce. sections are used to
6626 eliminate duplicate copies of functions and vtables and such.
6627 The linker will arbitrarily choose one and discard the others.
6628 The AT_*_pc values for such functions refer to local labels in
6629 these sections. If the section from that file was discarded, the
6630 labels are not in the output, so the relocs get a value of 0.
6631 If this is a discarded function, mark the pc bounds as invalid,
6632 so that GDB will ignore it. */
6633 if (low
== 0 && !dwarf2_per_objfile
->has_section_at_zero
)
6642 /* Assuming that DIE represents a subprogram DIE or a lexical block, get
6643 its low and high PC addresses. Do nothing if these addresses could not
6644 be determined. Otherwise, set LOWPC to the low address if it is smaller,
6645 and HIGHPC to the high address if greater than HIGHPC. */
6648 dwarf2_get_subprogram_pc_bounds (struct die_info
*die
,
6649 CORE_ADDR
*lowpc
, CORE_ADDR
*highpc
,
6650 struct dwarf2_cu
*cu
)
6652 CORE_ADDR low
, high
;
6653 struct die_info
*child
= die
->child
;
6655 if (dwarf2_get_pc_bounds (die
, &low
, &high
, cu
, NULL
))
6657 *lowpc
= min (*lowpc
, low
);
6658 *highpc
= max (*highpc
, high
);
6661 /* If the language does not allow nested subprograms (either inside
6662 subprograms or lexical blocks), we're done. */
6663 if (cu
->language
!= language_ada
)
6666 /* Check all the children of the given DIE. If it contains nested
6667 subprograms, then check their pc bounds. Likewise, we need to
6668 check lexical blocks as well, as they may also contain subprogram
6670 while (child
&& child
->tag
)
6672 if (child
->tag
== DW_TAG_subprogram
6673 || child
->tag
== DW_TAG_lexical_block
)
6674 dwarf2_get_subprogram_pc_bounds (child
, lowpc
, highpc
, cu
);
6675 child
= sibling_die (child
);
6679 /* Get the low and high pc's represented by the scope DIE, and store
6680 them in *LOWPC and *HIGHPC. If the correct values can't be
6681 determined, set *LOWPC to -1 and *HIGHPC to 0. */
6684 get_scope_pc_bounds (struct die_info
*die
,
6685 CORE_ADDR
*lowpc
, CORE_ADDR
*highpc
,
6686 struct dwarf2_cu
*cu
)
6688 CORE_ADDR best_low
= (CORE_ADDR
) -1;
6689 CORE_ADDR best_high
= (CORE_ADDR
) 0;
6690 CORE_ADDR current_low
, current_high
;
6692 if (dwarf2_get_pc_bounds (die
, ¤t_low
, ¤t_high
, cu
, NULL
))
6694 best_low
= current_low
;
6695 best_high
= current_high
;
6699 struct die_info
*child
= die
->child
;
6701 while (child
&& child
->tag
)
6703 switch (child
->tag
) {
6704 case DW_TAG_subprogram
:
6705 dwarf2_get_subprogram_pc_bounds (child
, &best_low
, &best_high
, cu
);
6707 case DW_TAG_namespace
:
6709 /* FIXME: carlton/2004-01-16: Should we do this for
6710 DW_TAG_class_type/DW_TAG_structure_type, too? I think
6711 that current GCC's always emit the DIEs corresponding
6712 to definitions of methods of classes as children of a
6713 DW_TAG_compile_unit or DW_TAG_namespace (as opposed to
6714 the DIEs giving the declarations, which could be
6715 anywhere). But I don't see any reason why the
6716 standards says that they have to be there. */
6717 get_scope_pc_bounds (child
, ¤t_low
, ¤t_high
, cu
);
6719 if (current_low
!= ((CORE_ADDR
) -1))
6721 best_low
= min (best_low
, current_low
);
6722 best_high
= max (best_high
, current_high
);
6730 child
= sibling_die (child
);
6735 *highpc
= best_high
;
6738 /* Record the address ranges for BLOCK, offset by BASEADDR, as given
6741 dwarf2_record_block_ranges (struct die_info
*die
, struct block
*block
,
6742 CORE_ADDR baseaddr
, struct dwarf2_cu
*cu
)
6744 struct objfile
*objfile
= cu
->objfile
;
6745 struct attribute
*attr
;
6747 attr
= dwarf2_attr (die
, DW_AT_high_pc
, cu
);
6750 CORE_ADDR high
= DW_ADDR (attr
);
6752 attr
= dwarf2_attr (die
, DW_AT_low_pc
, cu
);
6755 CORE_ADDR low
= DW_ADDR (attr
);
6757 record_block_range (block
, baseaddr
+ low
, baseaddr
+ high
- 1);
6761 attr
= dwarf2_attr (die
, DW_AT_ranges
, cu
);
6764 bfd
*obfd
= objfile
->obfd
;
6766 /* The value of the DW_AT_ranges attribute is the offset of the
6767 address range list in the .debug_ranges section. */
6768 unsigned long offset
= DW_UNSND (attr
);
6769 gdb_byte
*buffer
= dwarf2_per_objfile
->ranges
.buffer
+ offset
;
6771 /* For some target architectures, but not others, the
6772 read_address function sign-extends the addresses it returns.
6773 To recognize base address selection entries, we need a
6775 unsigned int addr_size
= cu
->header
.addr_size
;
6776 CORE_ADDR base_select_mask
= ~(~(CORE_ADDR
)1 << (addr_size
* 8 - 1));
6778 /* The base address, to which the next pair is relative. Note
6779 that this 'base' is a DWARF concept: most entries in a range
6780 list are relative, to reduce the number of relocs against the
6781 debugging information. This is separate from this function's
6782 'baseaddr' argument, which GDB uses to relocate debugging
6783 information from a shared library based on the address at
6784 which the library was loaded. */
6785 CORE_ADDR base
= cu
->base_address
;
6786 int base_known
= cu
->base_known
;
6788 gdb_assert (dwarf2_per_objfile
->ranges
.readin
);
6789 if (offset
>= dwarf2_per_objfile
->ranges
.size
)
6791 complaint (&symfile_complaints
,
6792 _("Offset %lu out of bounds for DW_AT_ranges attribute"),
6799 unsigned int bytes_read
;
6800 CORE_ADDR start
, end
;
6802 start
= read_address (obfd
, buffer
, cu
, &bytes_read
);
6803 buffer
+= bytes_read
;
6804 end
= read_address (obfd
, buffer
, cu
, &bytes_read
);
6805 buffer
+= bytes_read
;
6807 /* Did we find the end of the range list? */
6808 if (start
== 0 && end
== 0)
6811 /* Did we find a base address selection entry? */
6812 else if ((start
& base_select_mask
) == base_select_mask
)
6818 /* We found an ordinary address range. */
6823 complaint (&symfile_complaints
,
6824 _("Invalid .debug_ranges data "
6825 "(no base address)"));
6831 /* Inverted range entries are invalid. */
6832 complaint (&symfile_complaints
,
6833 _("Invalid .debug_ranges data "
6834 "(inverted range)"));
6838 /* Empty range entries have no effect. */
6842 record_block_range (block
,
6843 baseaddr
+ base
+ start
,
6844 baseaddr
+ base
+ end
- 1);
6850 /* Check for GCC PR debug/45124 fix which is not present in any G++ version up
6851 to 4.5.any while it is present already in G++ 4.6.0 - the PR has been fixed
6852 during 4.6.0 experimental. */
6855 producer_is_gxx_lt_4_6 (struct dwarf2_cu
*cu
)
6858 int major
, minor
, release
;
6860 if (cu
->producer
== NULL
)
6862 /* For unknown compilers expect their behavior is DWARF version
6865 GCC started to support .debug_types sections by -gdwarf-4 since
6866 gcc-4.5.x. As the .debug_types sections are missing DW_AT_producer
6867 for their space efficiency GDB cannot workaround gcc-4.5.x -gdwarf-4
6868 combination. gcc-4.5.x -gdwarf-4 binaries have DW_AT_accessibility
6869 interpreted incorrectly by GDB now - GCC PR debug/48229. */
6874 /* Skip any identifier after "GNU " - such as "C++" or "Java". */
6876 if (strncmp (cu
->producer
, "GNU ", strlen ("GNU ")) != 0)
6878 /* For non-GCC compilers expect their behavior is DWARF version
6883 cs
= &cu
->producer
[strlen ("GNU ")];
6884 while (*cs
&& !isdigit (*cs
))
6886 if (sscanf (cs
, "%d.%d.%d", &major
, &minor
, &release
) != 3)
6888 /* Not recognized as GCC. */
6893 return major
< 4 || (major
== 4 && minor
< 6);
6896 /* Return the default accessibility type if it is not overriden by
6897 DW_AT_accessibility. */
6899 static enum dwarf_access_attribute
6900 dwarf2_default_access_attribute (struct die_info
*die
, struct dwarf2_cu
*cu
)
6902 if (cu
->header
.version
< 3 || producer_is_gxx_lt_4_6 (cu
))
6904 /* The default DWARF 2 accessibility for members is public, the default
6905 accessibility for inheritance is private. */
6907 if (die
->tag
!= DW_TAG_inheritance
)
6908 return DW_ACCESS_public
;
6910 return DW_ACCESS_private
;
6914 /* DWARF 3+ defines the default accessibility a different way. The same
6915 rules apply now for DW_TAG_inheritance as for the members and it only
6916 depends on the container kind. */
6918 if (die
->parent
->tag
== DW_TAG_class_type
)
6919 return DW_ACCESS_private
;
6921 return DW_ACCESS_public
;
6925 /* Look for DW_AT_data_member_location. Set *OFFSET to the byte
6926 offset. If the attribute was not found return 0, otherwise return
6927 1. If it was found but could not properly be handled, set *OFFSET
6931 handle_data_member_location (struct die_info
*die
, struct dwarf2_cu
*cu
,
6934 struct attribute
*attr
;
6936 attr
= dwarf2_attr (die
, DW_AT_data_member_location
, cu
);
6941 /* Note that we do not check for a section offset first here.
6942 This is because DW_AT_data_member_location is new in DWARF 4,
6943 so if we see it, we can assume that a constant form is really
6944 a constant and not a section offset. */
6945 if (attr_form_is_constant (attr
))
6946 *offset
= dwarf2_get_attr_constant_value (attr
, 0);
6947 else if (attr_form_is_section_offset (attr
))
6948 dwarf2_complex_location_expr_complaint ();
6949 else if (attr_form_is_block (attr
))
6950 *offset
= decode_locdesc (DW_BLOCK (attr
), cu
);
6952 dwarf2_complex_location_expr_complaint ();
6960 /* Add an aggregate field to the field list. */
6963 dwarf2_add_field (struct field_info
*fip
, struct die_info
*die
,
6964 struct dwarf2_cu
*cu
)
6966 struct objfile
*objfile
= cu
->objfile
;
6967 struct gdbarch
*gdbarch
= get_objfile_arch (objfile
);
6968 struct nextfield
*new_field
;
6969 struct attribute
*attr
;
6971 char *fieldname
= "";
6973 /* Allocate a new field list entry and link it in. */
6974 new_field
= (struct nextfield
*) xmalloc (sizeof (struct nextfield
));
6975 make_cleanup (xfree
, new_field
);
6976 memset (new_field
, 0, sizeof (struct nextfield
));
6978 if (die
->tag
== DW_TAG_inheritance
)
6980 new_field
->next
= fip
->baseclasses
;
6981 fip
->baseclasses
= new_field
;
6985 new_field
->next
= fip
->fields
;
6986 fip
->fields
= new_field
;
6990 attr
= dwarf2_attr (die
, DW_AT_accessibility
, cu
);
6992 new_field
->accessibility
= DW_UNSND (attr
);
6994 new_field
->accessibility
= dwarf2_default_access_attribute (die
, cu
);
6995 if (new_field
->accessibility
!= DW_ACCESS_public
)
6996 fip
->non_public_fields
= 1;
6998 attr
= dwarf2_attr (die
, DW_AT_virtuality
, cu
);
7000 new_field
->virtuality
= DW_UNSND (attr
);
7002 new_field
->virtuality
= DW_VIRTUALITY_none
;
7004 fp
= &new_field
->field
;
7006 if (die
->tag
== DW_TAG_member
&& ! die_is_declaration (die
, cu
))
7010 /* Data member other than a C++ static data member. */
7012 /* Get type of field. */
7013 fp
->type
= die_type (die
, cu
);
7015 SET_FIELD_BITPOS (*fp
, 0);
7017 /* Get bit size of field (zero if none). */
7018 attr
= dwarf2_attr (die
, DW_AT_bit_size
, cu
);
7021 FIELD_BITSIZE (*fp
) = DW_UNSND (attr
);
7025 FIELD_BITSIZE (*fp
) = 0;
7028 /* Get bit offset of field. */
7029 if (handle_data_member_location (die
, cu
, &offset
))
7030 SET_FIELD_BITPOS (*fp
, offset
* bits_per_byte
);
7031 attr
= dwarf2_attr (die
, DW_AT_bit_offset
, cu
);
7034 if (gdbarch_bits_big_endian (gdbarch
))
7036 /* For big endian bits, the DW_AT_bit_offset gives the
7037 additional bit offset from the MSB of the containing
7038 anonymous object to the MSB of the field. We don't
7039 have to do anything special since we don't need to
7040 know the size of the anonymous object. */
7041 FIELD_BITPOS (*fp
) += DW_UNSND (attr
);
7045 /* For little endian bits, compute the bit offset to the
7046 MSB of the anonymous object, subtract off the number of
7047 bits from the MSB of the field to the MSB of the
7048 object, and then subtract off the number of bits of
7049 the field itself. The result is the bit offset of
7050 the LSB of the field. */
7052 int bit_offset
= DW_UNSND (attr
);
7054 attr
= dwarf2_attr (die
, DW_AT_byte_size
, cu
);
7057 /* The size of the anonymous object containing
7058 the bit field is explicit, so use the
7059 indicated size (in bytes). */
7060 anonymous_size
= DW_UNSND (attr
);
7064 /* The size of the anonymous object containing
7065 the bit field must be inferred from the type
7066 attribute of the data member containing the
7068 anonymous_size
= TYPE_LENGTH (fp
->type
);
7070 FIELD_BITPOS (*fp
) += anonymous_size
* bits_per_byte
7071 - bit_offset
- FIELD_BITSIZE (*fp
);
7075 /* Get name of field. */
7076 fieldname
= dwarf2_name (die
, cu
);
7077 if (fieldname
== NULL
)
7080 /* The name is already allocated along with this objfile, so we don't
7081 need to duplicate it for the type. */
7082 fp
->name
= fieldname
;
7084 /* Change accessibility for artificial fields (e.g. virtual table
7085 pointer or virtual base class pointer) to private. */
7086 if (dwarf2_attr (die
, DW_AT_artificial
, cu
))
7088 FIELD_ARTIFICIAL (*fp
) = 1;
7089 new_field
->accessibility
= DW_ACCESS_private
;
7090 fip
->non_public_fields
= 1;
7093 else if (die
->tag
== DW_TAG_member
|| die
->tag
== DW_TAG_variable
)
7095 /* C++ static member. */
7097 /* NOTE: carlton/2002-11-05: It should be a DW_TAG_member that
7098 is a declaration, but all versions of G++ as of this writing
7099 (so through at least 3.2.1) incorrectly generate
7100 DW_TAG_variable tags. */
7102 const char *physname
;
7104 /* Get name of field. */
7105 fieldname
= dwarf2_name (die
, cu
);
7106 if (fieldname
== NULL
)
7109 attr
= dwarf2_attr (die
, DW_AT_const_value
, cu
);
7111 /* Only create a symbol if this is an external value.
7112 new_symbol checks this and puts the value in the global symbol
7113 table, which we want. If it is not external, new_symbol
7114 will try to put the value in cu->list_in_scope which is wrong. */
7115 && dwarf2_flag_true_p (die
, DW_AT_external
, cu
))
7117 /* A static const member, not much different than an enum as far as
7118 we're concerned, except that we can support more types. */
7119 new_symbol (die
, NULL
, cu
);
7122 /* Get physical name. */
7123 physname
= dwarf2_physname (fieldname
, die
, cu
);
7125 /* The name is already allocated along with this objfile, so we don't
7126 need to duplicate it for the type. */
7127 SET_FIELD_PHYSNAME (*fp
, physname
? physname
: "");
7128 FIELD_TYPE (*fp
) = die_type (die
, cu
);
7129 FIELD_NAME (*fp
) = fieldname
;
7131 else if (die
->tag
== DW_TAG_inheritance
)
7135 /* C++ base class field. */
7136 if (handle_data_member_location (die
, cu
, &offset
))
7137 SET_FIELD_BITPOS (*fp
, offset
* bits_per_byte
);
7138 FIELD_BITSIZE (*fp
) = 0;
7139 FIELD_TYPE (*fp
) = die_type (die
, cu
);
7140 FIELD_NAME (*fp
) = type_name_no_tag (fp
->type
);
7141 fip
->nbaseclasses
++;
7145 /* Add a typedef defined in the scope of the FIP's class. */
7148 dwarf2_add_typedef (struct field_info
*fip
, struct die_info
*die
,
7149 struct dwarf2_cu
*cu
)
7151 struct objfile
*objfile
= cu
->objfile
;
7152 struct typedef_field_list
*new_field
;
7153 struct attribute
*attr
;
7154 struct typedef_field
*fp
;
7155 char *fieldname
= "";
7157 /* Allocate a new field list entry and link it in. */
7158 new_field
= xzalloc (sizeof (*new_field
));
7159 make_cleanup (xfree
, new_field
);
7161 gdb_assert (die
->tag
== DW_TAG_typedef
);
7163 fp
= &new_field
->field
;
7165 /* Get name of field. */
7166 fp
->name
= dwarf2_name (die
, cu
);
7167 if (fp
->name
== NULL
)
7170 fp
->type
= read_type_die (die
, cu
);
7172 new_field
->next
= fip
->typedef_field_list
;
7173 fip
->typedef_field_list
= new_field
;
7174 fip
->typedef_field_list_count
++;
7177 /* Create the vector of fields, and attach it to the type. */
7180 dwarf2_attach_fields_to_type (struct field_info
*fip
, struct type
*type
,
7181 struct dwarf2_cu
*cu
)
7183 int nfields
= fip
->nfields
;
7185 /* Record the field count, allocate space for the array of fields,
7186 and create blank accessibility bitfields if necessary. */
7187 TYPE_NFIELDS (type
) = nfields
;
7188 TYPE_FIELDS (type
) = (struct field
*)
7189 TYPE_ALLOC (type
, sizeof (struct field
) * nfields
);
7190 memset (TYPE_FIELDS (type
), 0, sizeof (struct field
) * nfields
);
7192 if (fip
->non_public_fields
&& cu
->language
!= language_ada
)
7194 ALLOCATE_CPLUS_STRUCT_TYPE (type
);
7196 TYPE_FIELD_PRIVATE_BITS (type
) =
7197 (B_TYPE
*) TYPE_ALLOC (type
, B_BYTES (nfields
));
7198 B_CLRALL (TYPE_FIELD_PRIVATE_BITS (type
), nfields
);
7200 TYPE_FIELD_PROTECTED_BITS (type
) =
7201 (B_TYPE
*) TYPE_ALLOC (type
, B_BYTES (nfields
));
7202 B_CLRALL (TYPE_FIELD_PROTECTED_BITS (type
), nfields
);
7204 TYPE_FIELD_IGNORE_BITS (type
) =
7205 (B_TYPE
*) TYPE_ALLOC (type
, B_BYTES (nfields
));
7206 B_CLRALL (TYPE_FIELD_IGNORE_BITS (type
), nfields
);
7209 /* If the type has baseclasses, allocate and clear a bit vector for
7210 TYPE_FIELD_VIRTUAL_BITS. */
7211 if (fip
->nbaseclasses
&& cu
->language
!= language_ada
)
7213 int num_bytes
= B_BYTES (fip
->nbaseclasses
);
7214 unsigned char *pointer
;
7216 ALLOCATE_CPLUS_STRUCT_TYPE (type
);
7217 pointer
= TYPE_ALLOC (type
, num_bytes
);
7218 TYPE_FIELD_VIRTUAL_BITS (type
) = pointer
;
7219 B_CLRALL (TYPE_FIELD_VIRTUAL_BITS (type
), fip
->nbaseclasses
);
7220 TYPE_N_BASECLASSES (type
) = fip
->nbaseclasses
;
7223 /* Copy the saved-up fields into the field vector. Start from the head of
7224 the list, adding to the tail of the field array, so that they end up in
7225 the same order in the array in which they were added to the list. */
7226 while (nfields
-- > 0)
7228 struct nextfield
*fieldp
;
7232 fieldp
= fip
->fields
;
7233 fip
->fields
= fieldp
->next
;
7237 fieldp
= fip
->baseclasses
;
7238 fip
->baseclasses
= fieldp
->next
;
7241 TYPE_FIELD (type
, nfields
) = fieldp
->field
;
7242 switch (fieldp
->accessibility
)
7244 case DW_ACCESS_private
:
7245 if (cu
->language
!= language_ada
)
7246 SET_TYPE_FIELD_PRIVATE (type
, nfields
);
7249 case DW_ACCESS_protected
:
7250 if (cu
->language
!= language_ada
)
7251 SET_TYPE_FIELD_PROTECTED (type
, nfields
);
7254 case DW_ACCESS_public
:
7258 /* Unknown accessibility. Complain and treat it as public. */
7260 complaint (&symfile_complaints
, _("unsupported accessibility %d"),
7261 fieldp
->accessibility
);
7265 if (nfields
< fip
->nbaseclasses
)
7267 switch (fieldp
->virtuality
)
7269 case DW_VIRTUALITY_virtual
:
7270 case DW_VIRTUALITY_pure_virtual
:
7271 if (cu
->language
== language_ada
)
7272 error (_("unexpected virtuality in component of Ada type"));
7273 SET_TYPE_FIELD_VIRTUAL (type
, nfields
);
7280 /* Add a member function to the proper fieldlist. */
7283 dwarf2_add_member_fn (struct field_info
*fip
, struct die_info
*die
,
7284 struct type
*type
, struct dwarf2_cu
*cu
)
7286 struct objfile
*objfile
= cu
->objfile
;
7287 struct attribute
*attr
;
7288 struct fnfieldlist
*flp
;
7290 struct fn_field
*fnp
;
7292 struct nextfnfield
*new_fnfield
;
7293 struct type
*this_type
;
7294 enum dwarf_access_attribute accessibility
;
7296 if (cu
->language
== language_ada
)
7297 error (_("unexpected member function in Ada type"));
7299 /* Get name of member function. */
7300 fieldname
= dwarf2_name (die
, cu
);
7301 if (fieldname
== NULL
)
7304 /* Look up member function name in fieldlist. */
7305 for (i
= 0; i
< fip
->nfnfields
; i
++)
7307 if (strcmp (fip
->fnfieldlists
[i
].name
, fieldname
) == 0)
7311 /* Create new list element if necessary. */
7312 if (i
< fip
->nfnfields
)
7313 flp
= &fip
->fnfieldlists
[i
];
7316 if ((fip
->nfnfields
% DW_FIELD_ALLOC_CHUNK
) == 0)
7318 fip
->fnfieldlists
= (struct fnfieldlist
*)
7319 xrealloc (fip
->fnfieldlists
,
7320 (fip
->nfnfields
+ DW_FIELD_ALLOC_CHUNK
)
7321 * sizeof (struct fnfieldlist
));
7322 if (fip
->nfnfields
== 0)
7323 make_cleanup (free_current_contents
, &fip
->fnfieldlists
);
7325 flp
= &fip
->fnfieldlists
[fip
->nfnfields
];
7326 flp
->name
= fieldname
;
7329 i
= fip
->nfnfields
++;
7332 /* Create a new member function field and chain it to the field list
7334 new_fnfield
= (struct nextfnfield
*) xmalloc (sizeof (struct nextfnfield
));
7335 make_cleanup (xfree
, new_fnfield
);
7336 memset (new_fnfield
, 0, sizeof (struct nextfnfield
));
7337 new_fnfield
->next
= flp
->head
;
7338 flp
->head
= new_fnfield
;
7341 /* Fill in the member function field info. */
7342 fnp
= &new_fnfield
->fnfield
;
7344 /* Delay processing of the physname until later. */
7345 if (cu
->language
== language_cplus
|| cu
->language
== language_java
)
7347 add_to_method_list (type
, i
, flp
->length
- 1, fieldname
,
7352 const char *physname
= dwarf2_physname (fieldname
, die
, cu
);
7353 fnp
->physname
= physname
? physname
: "";
7356 fnp
->type
= alloc_type (objfile
);
7357 this_type
= read_type_die (die
, cu
);
7358 if (this_type
&& TYPE_CODE (this_type
) == TYPE_CODE_FUNC
)
7360 int nparams
= TYPE_NFIELDS (this_type
);
7362 /* TYPE is the domain of this method, and THIS_TYPE is the type
7363 of the method itself (TYPE_CODE_METHOD). */
7364 smash_to_method_type (fnp
->type
, type
,
7365 TYPE_TARGET_TYPE (this_type
),
7366 TYPE_FIELDS (this_type
),
7367 TYPE_NFIELDS (this_type
),
7368 TYPE_VARARGS (this_type
));
7370 /* Handle static member functions.
7371 Dwarf2 has no clean way to discern C++ static and non-static
7372 member functions. G++ helps GDB by marking the first
7373 parameter for non-static member functions (which is the this
7374 pointer) as artificial. We obtain this information from
7375 read_subroutine_type via TYPE_FIELD_ARTIFICIAL. */
7376 if (nparams
== 0 || TYPE_FIELD_ARTIFICIAL (this_type
, 0) == 0)
7377 fnp
->voffset
= VOFFSET_STATIC
;
7380 complaint (&symfile_complaints
, _("member function type missing for '%s'"),
7381 dwarf2_full_name (fieldname
, die
, cu
));
7383 /* Get fcontext from DW_AT_containing_type if present. */
7384 if (dwarf2_attr (die
, DW_AT_containing_type
, cu
) != NULL
)
7385 fnp
->fcontext
= die_containing_type (die
, cu
);
7387 /* dwarf2 doesn't have stubbed physical names, so the setting of is_const and
7388 is_volatile is irrelevant, as it is needed by gdb_mangle_name only. */
7390 /* Get accessibility. */
7391 attr
= dwarf2_attr (die
, DW_AT_accessibility
, cu
);
7393 accessibility
= DW_UNSND (attr
);
7395 accessibility
= dwarf2_default_access_attribute (die
, cu
);
7396 switch (accessibility
)
7398 case DW_ACCESS_private
:
7399 fnp
->is_private
= 1;
7401 case DW_ACCESS_protected
:
7402 fnp
->is_protected
= 1;
7406 /* Check for artificial methods. */
7407 attr
= dwarf2_attr (die
, DW_AT_artificial
, cu
);
7408 if (attr
&& DW_UNSND (attr
) != 0)
7409 fnp
->is_artificial
= 1;
7411 /* Get index in virtual function table if it is a virtual member
7412 function. For older versions of GCC, this is an offset in the
7413 appropriate virtual table, as specified by DW_AT_containing_type.
7414 For everyone else, it is an expression to be evaluated relative
7415 to the object address. */
7417 attr
= dwarf2_attr (die
, DW_AT_vtable_elem_location
, cu
);
7420 if (attr_form_is_block (attr
) && DW_BLOCK (attr
)->size
> 0)
7422 if (DW_BLOCK (attr
)->data
[0] == DW_OP_constu
)
7424 /* Old-style GCC. */
7425 fnp
->voffset
= decode_locdesc (DW_BLOCK (attr
), cu
) + 2;
7427 else if (DW_BLOCK (attr
)->data
[0] == DW_OP_deref
7428 || (DW_BLOCK (attr
)->size
> 1
7429 && DW_BLOCK (attr
)->data
[0] == DW_OP_deref_size
7430 && DW_BLOCK (attr
)->data
[1] == cu
->header
.addr_size
))
7432 struct dwarf_block blk
;
7435 offset
= (DW_BLOCK (attr
)->data
[0] == DW_OP_deref
7437 blk
.size
= DW_BLOCK (attr
)->size
- offset
;
7438 blk
.data
= DW_BLOCK (attr
)->data
+ offset
;
7439 fnp
->voffset
= decode_locdesc (DW_BLOCK (attr
), cu
);
7440 if ((fnp
->voffset
% cu
->header
.addr_size
) != 0)
7441 dwarf2_complex_location_expr_complaint ();
7443 fnp
->voffset
/= cu
->header
.addr_size
;
7447 dwarf2_complex_location_expr_complaint ();
7450 fnp
->fcontext
= TYPE_TARGET_TYPE (TYPE_FIELD_TYPE (this_type
, 0));
7452 else if (attr_form_is_section_offset (attr
))
7454 dwarf2_complex_location_expr_complaint ();
7458 dwarf2_invalid_attrib_class_complaint ("DW_AT_vtable_elem_location",
7464 attr
= dwarf2_attr (die
, DW_AT_virtuality
, cu
);
7465 if (attr
&& DW_UNSND (attr
))
7467 /* GCC does this, as of 2008-08-25; PR debug/37237. */
7468 complaint (&symfile_complaints
,
7469 _("Member function \"%s\" (offset %d) is virtual "
7470 "but the vtable offset is not specified"),
7471 fieldname
, die
->offset
);
7472 ALLOCATE_CPLUS_STRUCT_TYPE (type
);
7473 TYPE_CPLUS_DYNAMIC (type
) = 1;
7478 /* Create the vector of member function fields, and attach it to the type. */
7481 dwarf2_attach_fn_fields_to_type (struct field_info
*fip
, struct type
*type
,
7482 struct dwarf2_cu
*cu
)
7484 struct fnfieldlist
*flp
;
7485 int total_length
= 0;
7488 if (cu
->language
== language_ada
)
7489 error (_("unexpected member functions in Ada type"));
7491 ALLOCATE_CPLUS_STRUCT_TYPE (type
);
7492 TYPE_FN_FIELDLISTS (type
) = (struct fn_fieldlist
*)
7493 TYPE_ALLOC (type
, sizeof (struct fn_fieldlist
) * fip
->nfnfields
);
7495 for (i
= 0, flp
= fip
->fnfieldlists
; i
< fip
->nfnfields
; i
++, flp
++)
7497 struct nextfnfield
*nfp
= flp
->head
;
7498 struct fn_fieldlist
*fn_flp
= &TYPE_FN_FIELDLIST (type
, i
);
7501 TYPE_FN_FIELDLIST_NAME (type
, i
) = flp
->name
;
7502 TYPE_FN_FIELDLIST_LENGTH (type
, i
) = flp
->length
;
7503 fn_flp
->fn_fields
= (struct fn_field
*)
7504 TYPE_ALLOC (type
, sizeof (struct fn_field
) * flp
->length
);
7505 for (k
= flp
->length
; (k
--, nfp
); nfp
= nfp
->next
)
7506 fn_flp
->fn_fields
[k
] = nfp
->fnfield
;
7508 total_length
+= flp
->length
;
7511 TYPE_NFN_FIELDS (type
) = fip
->nfnfields
;
7512 TYPE_NFN_FIELDS_TOTAL (type
) = total_length
;
7515 /* Returns non-zero if NAME is the name of a vtable member in CU's
7516 language, zero otherwise. */
7518 is_vtable_name (const char *name
, struct dwarf2_cu
*cu
)
7520 static const char vptr
[] = "_vptr";
7521 static const char vtable
[] = "vtable";
7523 /* Look for the C++ and Java forms of the vtable. */
7524 if ((cu
->language
== language_java
7525 && strncmp (name
, vtable
, sizeof (vtable
) - 1) == 0)
7526 || (strncmp (name
, vptr
, sizeof (vptr
) - 1) == 0
7527 && is_cplus_marker (name
[sizeof (vptr
) - 1])))
7533 /* GCC outputs unnamed structures that are really pointers to member
7534 functions, with the ABI-specified layout. If TYPE describes
7535 such a structure, smash it into a member function type.
7537 GCC shouldn't do this; it should just output pointer to member DIEs.
7538 This is GCC PR debug/28767. */
7541 quirk_gcc_member_function_pointer (struct type
*type
, struct objfile
*objfile
)
7543 struct type
*pfn_type
, *domain_type
, *new_type
;
7545 /* Check for a structure with no name and two children. */
7546 if (TYPE_CODE (type
) != TYPE_CODE_STRUCT
|| TYPE_NFIELDS (type
) != 2)
7549 /* Check for __pfn and __delta members. */
7550 if (TYPE_FIELD_NAME (type
, 0) == NULL
7551 || strcmp (TYPE_FIELD_NAME (type
, 0), "__pfn") != 0
7552 || TYPE_FIELD_NAME (type
, 1) == NULL
7553 || strcmp (TYPE_FIELD_NAME (type
, 1), "__delta") != 0)
7556 /* Find the type of the method. */
7557 pfn_type
= TYPE_FIELD_TYPE (type
, 0);
7558 if (pfn_type
== NULL
7559 || TYPE_CODE (pfn_type
) != TYPE_CODE_PTR
7560 || TYPE_CODE (TYPE_TARGET_TYPE (pfn_type
)) != TYPE_CODE_FUNC
)
7563 /* Look for the "this" argument. */
7564 pfn_type
= TYPE_TARGET_TYPE (pfn_type
);
7565 if (TYPE_NFIELDS (pfn_type
) == 0
7566 /* || TYPE_FIELD_TYPE (pfn_type, 0) == NULL */
7567 || TYPE_CODE (TYPE_FIELD_TYPE (pfn_type
, 0)) != TYPE_CODE_PTR
)
7570 domain_type
= TYPE_TARGET_TYPE (TYPE_FIELD_TYPE (pfn_type
, 0));
7571 new_type
= alloc_type (objfile
);
7572 smash_to_method_type (new_type
, domain_type
, TYPE_TARGET_TYPE (pfn_type
),
7573 TYPE_FIELDS (pfn_type
), TYPE_NFIELDS (pfn_type
),
7574 TYPE_VARARGS (pfn_type
));
7575 smash_to_methodptr_type (type
, new_type
);
7578 /* Called when we find the DIE that starts a structure or union scope
7579 (definition) to create a type for the structure or union. Fill in
7580 the type's name and general properties; the members will not be
7581 processed until process_structure_type.
7583 NOTE: we need to call these functions regardless of whether or not the
7584 DIE has a DW_AT_name attribute, since it might be an anonymous
7585 structure or union. This gets the type entered into our set of
7588 However, if the structure is incomplete (an opaque struct/union)
7589 then suppress creating a symbol table entry for it since gdb only
7590 wants to find the one with the complete definition. Note that if
7591 it is complete, we just call new_symbol, which does it's own
7592 checking about whether the struct/union is anonymous or not (and
7593 suppresses creating a symbol table entry itself). */
7595 static struct type
*
7596 read_structure_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
7598 struct objfile
*objfile
= cu
->objfile
;
7600 struct attribute
*attr
;
7603 /* If the definition of this type lives in .debug_types, read that type.
7604 Don't follow DW_AT_specification though, that will take us back up
7605 the chain and we want to go down. */
7606 attr
= dwarf2_attr_no_follow (die
, DW_AT_signature
, cu
);
7609 struct dwarf2_cu
*type_cu
= cu
;
7610 struct die_info
*type_die
= follow_die_ref_or_sig (die
, attr
, &type_cu
);
7612 /* We could just recurse on read_structure_type, but we need to call
7613 get_die_type to ensure only one type for this DIE is created.
7614 This is important, for example, because for c++ classes we need
7615 TYPE_NAME set which is only done by new_symbol. Blech. */
7616 type
= read_type_die (type_die
, type_cu
);
7618 /* TYPE_CU may not be the same as CU.
7619 Ensure TYPE is recorded in CU's type_hash table. */
7620 return set_die_type (die
, type
, cu
);
7623 type
= alloc_type (objfile
);
7624 INIT_CPLUS_SPECIFIC (type
);
7626 name
= dwarf2_name (die
, cu
);
7629 if (cu
->language
== language_cplus
7630 || cu
->language
== language_java
)
7632 char *full_name
= (char *) dwarf2_full_name (name
, die
, cu
);
7634 /* dwarf2_full_name might have already finished building the DIE's
7635 type. If so, there is no need to continue. */
7636 if (get_die_type (die
, cu
) != NULL
)
7637 return get_die_type (die
, cu
);
7639 TYPE_TAG_NAME (type
) = full_name
;
7640 if (die
->tag
== DW_TAG_structure_type
7641 || die
->tag
== DW_TAG_class_type
)
7642 TYPE_NAME (type
) = TYPE_TAG_NAME (type
);
7646 /* The name is already allocated along with this objfile, so
7647 we don't need to duplicate it for the type. */
7648 TYPE_TAG_NAME (type
) = (char *) name
;
7649 if (die
->tag
== DW_TAG_class_type
)
7650 TYPE_NAME (type
) = TYPE_TAG_NAME (type
);
7654 if (die
->tag
== DW_TAG_structure_type
)
7656 TYPE_CODE (type
) = TYPE_CODE_STRUCT
;
7658 else if (die
->tag
== DW_TAG_union_type
)
7660 TYPE_CODE (type
) = TYPE_CODE_UNION
;
7664 TYPE_CODE (type
) = TYPE_CODE_CLASS
;
7667 if (cu
->language
== language_cplus
&& die
->tag
== DW_TAG_class_type
)
7668 TYPE_DECLARED_CLASS (type
) = 1;
7670 attr
= dwarf2_attr (die
, DW_AT_byte_size
, cu
);
7673 TYPE_LENGTH (type
) = DW_UNSND (attr
);
7677 TYPE_LENGTH (type
) = 0;
7680 TYPE_STUB_SUPPORTED (type
) = 1;
7681 if (die_is_declaration (die
, cu
))
7682 TYPE_STUB (type
) = 1;
7683 else if (attr
== NULL
&& die
->child
== NULL
7684 && producer_is_realview (cu
->producer
))
7685 /* RealView does not output the required DW_AT_declaration
7686 on incomplete types. */
7687 TYPE_STUB (type
) = 1;
7689 /* We need to add the type field to the die immediately so we don't
7690 infinitely recurse when dealing with pointers to the structure
7691 type within the structure itself. */
7692 set_die_type (die
, type
, cu
);
7694 /* set_die_type should be already done. */
7695 set_descriptive_type (type
, die
, cu
);
7700 /* Finish creating a structure or union type, including filling in
7701 its members and creating a symbol for it. */
7704 process_structure_scope (struct die_info
*die
, struct dwarf2_cu
*cu
)
7706 struct objfile
*objfile
= cu
->objfile
;
7707 struct die_info
*child_die
= die
->child
;
7710 type
= get_die_type (die
, cu
);
7712 type
= read_structure_type (die
, cu
);
7714 if (die
->child
!= NULL
&& ! die_is_declaration (die
, cu
))
7716 struct field_info fi
;
7717 struct die_info
*child_die
;
7718 VEC (symbolp
) *template_args
= NULL
;
7719 struct cleanup
*back_to
= make_cleanup (null_cleanup
, 0);
7721 memset (&fi
, 0, sizeof (struct field_info
));
7723 child_die
= die
->child
;
7725 while (child_die
&& child_die
->tag
)
7727 if (child_die
->tag
== DW_TAG_member
7728 || child_die
->tag
== DW_TAG_variable
)
7730 /* NOTE: carlton/2002-11-05: A C++ static data member
7731 should be a DW_TAG_member that is a declaration, but
7732 all versions of G++ as of this writing (so through at
7733 least 3.2.1) incorrectly generate DW_TAG_variable
7734 tags for them instead. */
7735 dwarf2_add_field (&fi
, child_die
, cu
);
7737 else if (child_die
->tag
== DW_TAG_subprogram
)
7739 /* C++ member function. */
7740 dwarf2_add_member_fn (&fi
, child_die
, type
, cu
);
7742 else if (child_die
->tag
== DW_TAG_inheritance
)
7744 /* C++ base class field. */
7745 dwarf2_add_field (&fi
, child_die
, cu
);
7747 else if (child_die
->tag
== DW_TAG_typedef
)
7748 dwarf2_add_typedef (&fi
, child_die
, cu
);
7749 else if (child_die
->tag
== DW_TAG_template_type_param
7750 || child_die
->tag
== DW_TAG_template_value_param
)
7752 struct symbol
*arg
= new_symbol (child_die
, NULL
, cu
);
7755 VEC_safe_push (symbolp
, template_args
, arg
);
7758 child_die
= sibling_die (child_die
);
7761 /* Attach template arguments to type. */
7762 if (! VEC_empty (symbolp
, template_args
))
7764 ALLOCATE_CPLUS_STRUCT_TYPE (type
);
7765 TYPE_N_TEMPLATE_ARGUMENTS (type
)
7766 = VEC_length (symbolp
, template_args
);
7767 TYPE_TEMPLATE_ARGUMENTS (type
)
7768 = obstack_alloc (&objfile
->objfile_obstack
,
7769 (TYPE_N_TEMPLATE_ARGUMENTS (type
)
7770 * sizeof (struct symbol
*)));
7771 memcpy (TYPE_TEMPLATE_ARGUMENTS (type
),
7772 VEC_address (symbolp
, template_args
),
7773 (TYPE_N_TEMPLATE_ARGUMENTS (type
)
7774 * sizeof (struct symbol
*)));
7775 VEC_free (symbolp
, template_args
);
7778 /* Attach fields and member functions to the type. */
7780 dwarf2_attach_fields_to_type (&fi
, type
, cu
);
7783 dwarf2_attach_fn_fields_to_type (&fi
, type
, cu
);
7785 /* Get the type which refers to the base class (possibly this
7786 class itself) which contains the vtable pointer for the current
7787 class from the DW_AT_containing_type attribute. This use of
7788 DW_AT_containing_type is a GNU extension. */
7790 if (dwarf2_attr (die
, DW_AT_containing_type
, cu
) != NULL
)
7792 struct type
*t
= die_containing_type (die
, cu
);
7794 TYPE_VPTR_BASETYPE (type
) = t
;
7799 /* Our own class provides vtbl ptr. */
7800 for (i
= TYPE_NFIELDS (t
) - 1;
7801 i
>= TYPE_N_BASECLASSES (t
);
7804 char *fieldname
= TYPE_FIELD_NAME (t
, i
);
7806 if (is_vtable_name (fieldname
, cu
))
7808 TYPE_VPTR_FIELDNO (type
) = i
;
7813 /* Complain if virtual function table field not found. */
7814 if (i
< TYPE_N_BASECLASSES (t
))
7815 complaint (&symfile_complaints
,
7816 _("virtual function table pointer "
7817 "not found when defining class '%s'"),
7818 TYPE_TAG_NAME (type
) ? TYPE_TAG_NAME (type
) :
7823 TYPE_VPTR_FIELDNO (type
) = TYPE_VPTR_FIELDNO (t
);
7826 else if (cu
->producer
7827 && strncmp (cu
->producer
,
7828 "IBM(R) XL C/C++ Advanced Edition", 32) == 0)
7830 /* The IBM XLC compiler does not provide direct indication
7831 of the containing type, but the vtable pointer is
7832 always named __vfp. */
7836 for (i
= TYPE_NFIELDS (type
) - 1;
7837 i
>= TYPE_N_BASECLASSES (type
);
7840 if (strcmp (TYPE_FIELD_NAME (type
, i
), "__vfp") == 0)
7842 TYPE_VPTR_FIELDNO (type
) = i
;
7843 TYPE_VPTR_BASETYPE (type
) = type
;
7850 /* Copy fi.typedef_field_list linked list elements content into the
7851 allocated array TYPE_TYPEDEF_FIELD_ARRAY (type). */
7852 if (fi
.typedef_field_list
)
7854 int i
= fi
.typedef_field_list_count
;
7856 ALLOCATE_CPLUS_STRUCT_TYPE (type
);
7857 TYPE_TYPEDEF_FIELD_ARRAY (type
)
7858 = TYPE_ALLOC (type
, sizeof (TYPE_TYPEDEF_FIELD (type
, 0)) * i
);
7859 TYPE_TYPEDEF_FIELD_COUNT (type
) = i
;
7861 /* Reverse the list order to keep the debug info elements order. */
7864 struct typedef_field
*dest
, *src
;
7866 dest
= &TYPE_TYPEDEF_FIELD (type
, i
);
7867 src
= &fi
.typedef_field_list
->field
;
7868 fi
.typedef_field_list
= fi
.typedef_field_list
->next
;
7873 do_cleanups (back_to
);
7875 if (HAVE_CPLUS_STRUCT (type
))
7876 TYPE_CPLUS_REALLY_JAVA (type
) = cu
->language
== language_java
;
7879 quirk_gcc_member_function_pointer (type
, objfile
);
7881 /* NOTE: carlton/2004-03-16: GCC 3.4 (or at least one of its
7882 snapshots) has been known to create a die giving a declaration
7883 for a class that has, as a child, a die giving a definition for a
7884 nested class. So we have to process our children even if the
7885 current die is a declaration. Normally, of course, a declaration
7886 won't have any children at all. */
7888 while (child_die
!= NULL
&& child_die
->tag
)
7890 if (child_die
->tag
== DW_TAG_member
7891 || child_die
->tag
== DW_TAG_variable
7892 || child_die
->tag
== DW_TAG_inheritance
7893 || child_die
->tag
== DW_TAG_template_value_param
7894 || child_die
->tag
== DW_TAG_template_type_param
)
7899 process_die (child_die
, cu
);
7901 child_die
= sibling_die (child_die
);
7904 /* Do not consider external references. According to the DWARF standard,
7905 these DIEs are identified by the fact that they have no byte_size
7906 attribute, and a declaration attribute. */
7907 if (dwarf2_attr (die
, DW_AT_byte_size
, cu
) != NULL
7908 || !die_is_declaration (die
, cu
))
7909 new_symbol (die
, type
, cu
);
7912 /* Given a DW_AT_enumeration_type die, set its type. We do not
7913 complete the type's fields yet, or create any symbols. */
7915 static struct type
*
7916 read_enumeration_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
7918 struct objfile
*objfile
= cu
->objfile
;
7920 struct attribute
*attr
;
7923 /* If the definition of this type lives in .debug_types, read that type.
7924 Don't follow DW_AT_specification though, that will take us back up
7925 the chain and we want to go down. */
7926 attr
= dwarf2_attr_no_follow (die
, DW_AT_signature
, cu
);
7929 struct dwarf2_cu
*type_cu
= cu
;
7930 struct die_info
*type_die
= follow_die_ref_or_sig (die
, attr
, &type_cu
);
7932 type
= read_type_die (type_die
, type_cu
);
7934 /* TYPE_CU may not be the same as CU.
7935 Ensure TYPE is recorded in CU's type_hash table. */
7936 return set_die_type (die
, type
, cu
);
7939 type
= alloc_type (objfile
);
7941 TYPE_CODE (type
) = TYPE_CODE_ENUM
;
7942 name
= dwarf2_full_name (NULL
, die
, cu
);
7944 TYPE_TAG_NAME (type
) = (char *) name
;
7946 attr
= dwarf2_attr (die
, DW_AT_byte_size
, cu
);
7949 TYPE_LENGTH (type
) = DW_UNSND (attr
);
7953 TYPE_LENGTH (type
) = 0;
7956 /* The enumeration DIE can be incomplete. In Ada, any type can be
7957 declared as private in the package spec, and then defined only
7958 inside the package body. Such types are known as Taft Amendment
7959 Types. When another package uses such a type, an incomplete DIE
7960 may be generated by the compiler. */
7961 if (die_is_declaration (die
, cu
))
7962 TYPE_STUB (type
) = 1;
7964 return set_die_type (die
, type
, cu
);
7967 /* Given a pointer to a die which begins an enumeration, process all
7968 the dies that define the members of the enumeration, and create the
7969 symbol for the enumeration type.
7971 NOTE: We reverse the order of the element list. */
7974 process_enumeration_scope (struct die_info
*die
, struct dwarf2_cu
*cu
)
7976 struct type
*this_type
;
7978 this_type
= get_die_type (die
, cu
);
7979 if (this_type
== NULL
)
7980 this_type
= read_enumeration_type (die
, cu
);
7982 if (die
->child
!= NULL
)
7984 struct die_info
*child_die
;
7986 struct field
*fields
= NULL
;
7988 int unsigned_enum
= 1;
7991 child_die
= die
->child
;
7992 while (child_die
&& child_die
->tag
)
7994 if (child_die
->tag
!= DW_TAG_enumerator
)
7996 process_die (child_die
, cu
);
8000 name
= dwarf2_name (child_die
, cu
);
8003 sym
= new_symbol (child_die
, this_type
, cu
);
8004 if (SYMBOL_VALUE (sym
) < 0)
8007 if ((num_fields
% DW_FIELD_ALLOC_CHUNK
) == 0)
8009 fields
= (struct field
*)
8011 (num_fields
+ DW_FIELD_ALLOC_CHUNK
)
8012 * sizeof (struct field
));
8015 FIELD_NAME (fields
[num_fields
]) = SYMBOL_LINKAGE_NAME (sym
);
8016 FIELD_TYPE (fields
[num_fields
]) = NULL
;
8017 SET_FIELD_BITPOS (fields
[num_fields
], SYMBOL_VALUE (sym
));
8018 FIELD_BITSIZE (fields
[num_fields
]) = 0;
8024 child_die
= sibling_die (child_die
);
8029 TYPE_NFIELDS (this_type
) = num_fields
;
8030 TYPE_FIELDS (this_type
) = (struct field
*)
8031 TYPE_ALLOC (this_type
, sizeof (struct field
) * num_fields
);
8032 memcpy (TYPE_FIELDS (this_type
), fields
,
8033 sizeof (struct field
) * num_fields
);
8037 TYPE_UNSIGNED (this_type
) = 1;
8040 /* If we are reading an enum from a .debug_types unit, and the enum
8041 is a declaration, and the enum is not the signatured type in the
8042 unit, then we do not want to add a symbol for it. Adding a
8043 symbol would in some cases obscure the true definition of the
8044 enum, giving users an incomplete type when the definition is
8045 actually available. Note that we do not want to do this for all
8046 enums which are just declarations, because C++0x allows forward
8047 enum declarations. */
8048 if (cu
->per_cu
->debug_types_section
8049 && die_is_declaration (die
, cu
))
8051 struct signatured_type
*type_sig
;
8054 = lookup_signatured_type_at_offset (dwarf2_per_objfile
->objfile
,
8055 cu
->per_cu
->debug_types_section
,
8056 cu
->per_cu
->offset
);
8057 if (type_sig
->type_offset
!= die
->offset
)
8061 new_symbol (die
, this_type
, cu
);
8064 /* Extract all information from a DW_TAG_array_type DIE and put it in
8065 the DIE's type field. For now, this only handles one dimensional
8068 static struct type
*
8069 read_array_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
8071 struct objfile
*objfile
= cu
->objfile
;
8072 struct die_info
*child_die
;
8074 struct type
*element_type
, *range_type
, *index_type
;
8075 struct type
**range_types
= NULL
;
8076 struct attribute
*attr
;
8078 struct cleanup
*back_to
;
8081 element_type
= die_type (die
, cu
);
8083 /* The die_type call above may have already set the type for this DIE. */
8084 type
= get_die_type (die
, cu
);
8088 /* Irix 6.2 native cc creates array types without children for
8089 arrays with unspecified length. */
8090 if (die
->child
== NULL
)
8092 index_type
= objfile_type (objfile
)->builtin_int
;
8093 range_type
= create_range_type (NULL
, index_type
, 0, -1);
8094 type
= create_array_type (NULL
, element_type
, range_type
);
8095 return set_die_type (die
, type
, cu
);
8098 back_to
= make_cleanup (null_cleanup
, NULL
);
8099 child_die
= die
->child
;
8100 while (child_die
&& child_die
->tag
)
8102 if (child_die
->tag
== DW_TAG_subrange_type
)
8104 struct type
*child_type
= read_type_die (child_die
, cu
);
8106 if (child_type
!= NULL
)
8108 /* The range type was succesfully read. Save it for the
8109 array type creation. */
8110 if ((ndim
% DW_FIELD_ALLOC_CHUNK
) == 0)
8112 range_types
= (struct type
**)
8113 xrealloc (range_types
, (ndim
+ DW_FIELD_ALLOC_CHUNK
)
8114 * sizeof (struct type
*));
8116 make_cleanup (free_current_contents
, &range_types
);
8118 range_types
[ndim
++] = child_type
;
8121 child_die
= sibling_die (child_die
);
8124 /* Dwarf2 dimensions are output from left to right, create the
8125 necessary array types in backwards order. */
8127 type
= element_type
;
8129 if (read_array_order (die
, cu
) == DW_ORD_col_major
)
8134 type
= create_array_type (NULL
, type
, range_types
[i
++]);
8139 type
= create_array_type (NULL
, type
, range_types
[ndim
]);
8142 /* Understand Dwarf2 support for vector types (like they occur on
8143 the PowerPC w/ AltiVec). Gcc just adds another attribute to the
8144 array type. This is not part of the Dwarf2/3 standard yet, but a
8145 custom vendor extension. The main difference between a regular
8146 array and the vector variant is that vectors are passed by value
8148 attr
= dwarf2_attr (die
, DW_AT_GNU_vector
, cu
);
8150 make_vector_type (type
);
8152 /* The DIE may have DW_AT_byte_size set. For example an OpenCL
8153 implementation may choose to implement triple vectors using this
8155 attr
= dwarf2_attr (die
, DW_AT_byte_size
, cu
);
8158 if (DW_UNSND (attr
) >= TYPE_LENGTH (type
))
8159 TYPE_LENGTH (type
) = DW_UNSND (attr
);
8161 complaint (&symfile_complaints
,
8162 _("DW_AT_byte_size for array type smaller "
8163 "than the total size of elements"));
8166 name
= dwarf2_name (die
, cu
);
8168 TYPE_NAME (type
) = name
;
8170 /* Install the type in the die. */
8171 set_die_type (die
, type
, cu
);
8173 /* set_die_type should be already done. */
8174 set_descriptive_type (type
, die
, cu
);
8176 do_cleanups (back_to
);
8181 static enum dwarf_array_dim_ordering
8182 read_array_order (struct die_info
*die
, struct dwarf2_cu
*cu
)
8184 struct attribute
*attr
;
8186 attr
= dwarf2_attr (die
, DW_AT_ordering
, cu
);
8188 if (attr
) return DW_SND (attr
);
8190 /* GNU F77 is a special case, as at 08/2004 array type info is the
8191 opposite order to the dwarf2 specification, but data is still
8192 laid out as per normal fortran.
8194 FIXME: dsl/2004-8-20: If G77 is ever fixed, this will also need
8195 version checking. */
8197 if (cu
->language
== language_fortran
8198 && cu
->producer
&& strstr (cu
->producer
, "GNU F77"))
8200 return DW_ORD_row_major
;
8203 switch (cu
->language_defn
->la_array_ordering
)
8205 case array_column_major
:
8206 return DW_ORD_col_major
;
8207 case array_row_major
:
8209 return DW_ORD_row_major
;
8213 /* Extract all information from a DW_TAG_set_type DIE and put it in
8214 the DIE's type field. */
8216 static struct type
*
8217 read_set_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
8219 struct type
*domain_type
, *set_type
;
8220 struct attribute
*attr
;
8222 domain_type
= die_type (die
, cu
);
8224 /* The die_type call above may have already set the type for this DIE. */
8225 set_type
= get_die_type (die
, cu
);
8229 set_type
= create_set_type (NULL
, domain_type
);
8231 attr
= dwarf2_attr (die
, DW_AT_byte_size
, cu
);
8233 TYPE_LENGTH (set_type
) = DW_UNSND (attr
);
8235 return set_die_type (die
, set_type
, cu
);
8238 /* First cut: install each common block member as a global variable. */
8241 read_common_block (struct die_info
*die
, struct dwarf2_cu
*cu
)
8243 struct die_info
*child_die
;
8244 struct attribute
*attr
;
8246 CORE_ADDR base
= (CORE_ADDR
) 0;
8248 attr
= dwarf2_attr (die
, DW_AT_location
, cu
);
8251 /* Support the .debug_loc offsets. */
8252 if (attr_form_is_block (attr
))
8254 base
= decode_locdesc (DW_BLOCK (attr
), cu
);
8256 else if (attr_form_is_section_offset (attr
))
8258 dwarf2_complex_location_expr_complaint ();
8262 dwarf2_invalid_attrib_class_complaint ("DW_AT_location",
8263 "common block member");
8266 if (die
->child
!= NULL
)
8268 child_die
= die
->child
;
8269 while (child_die
&& child_die
->tag
)
8273 sym
= new_symbol (child_die
, NULL
, cu
);
8275 && handle_data_member_location (child_die
, cu
, &offset
))
8277 SYMBOL_VALUE_ADDRESS (sym
) = base
+ offset
;
8278 add_symbol_to_list (sym
, &global_symbols
);
8280 child_die
= sibling_die (child_die
);
8285 /* Create a type for a C++ namespace. */
8287 static struct type
*
8288 read_namespace_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
8290 struct objfile
*objfile
= cu
->objfile
;
8291 const char *previous_prefix
, *name
;
8295 /* For extensions, reuse the type of the original namespace. */
8296 if (dwarf2_attr (die
, DW_AT_extension
, cu
) != NULL
)
8298 struct die_info
*ext_die
;
8299 struct dwarf2_cu
*ext_cu
= cu
;
8301 ext_die
= dwarf2_extension (die
, &ext_cu
);
8302 type
= read_type_die (ext_die
, ext_cu
);
8304 /* EXT_CU may not be the same as CU.
8305 Ensure TYPE is recorded in CU's type_hash table. */
8306 return set_die_type (die
, type
, cu
);
8309 name
= namespace_name (die
, &is_anonymous
, cu
);
8311 /* Now build the name of the current namespace. */
8313 previous_prefix
= determine_prefix (die
, cu
);
8314 if (previous_prefix
[0] != '\0')
8315 name
= typename_concat (&objfile
->objfile_obstack
,
8316 previous_prefix
, name
, 0, cu
);
8318 /* Create the type. */
8319 type
= init_type (TYPE_CODE_NAMESPACE
, 0, 0, NULL
,
8321 TYPE_NAME (type
) = (char *) name
;
8322 TYPE_TAG_NAME (type
) = TYPE_NAME (type
);
8324 return set_die_type (die
, type
, cu
);
8327 /* Read a C++ namespace. */
8330 read_namespace (struct die_info
*die
, struct dwarf2_cu
*cu
)
8332 struct objfile
*objfile
= cu
->objfile
;
8335 /* Add a symbol associated to this if we haven't seen the namespace
8336 before. Also, add a using directive if it's an anonymous
8339 if (dwarf2_attr (die
, DW_AT_extension
, cu
) == NULL
)
8343 type
= read_type_die (die
, cu
);
8344 new_symbol (die
, type
, cu
);
8346 namespace_name (die
, &is_anonymous
, cu
);
8349 const char *previous_prefix
= determine_prefix (die
, cu
);
8351 cp_add_using_directive (previous_prefix
, TYPE_NAME (type
), NULL
,
8352 NULL
, NULL
, &objfile
->objfile_obstack
);
8356 if (die
->child
!= NULL
)
8358 struct die_info
*child_die
= die
->child
;
8360 while (child_die
&& child_die
->tag
)
8362 process_die (child_die
, cu
);
8363 child_die
= sibling_die (child_die
);
8368 /* Read a Fortran module as type. This DIE can be only a declaration used for
8369 imported module. Still we need that type as local Fortran "use ... only"
8370 declaration imports depend on the created type in determine_prefix. */
8372 static struct type
*
8373 read_module_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
8375 struct objfile
*objfile
= cu
->objfile
;
8379 module_name
= dwarf2_name (die
, cu
);
8381 complaint (&symfile_complaints
,
8382 _("DW_TAG_module has no name, offset 0x%x"),
8384 type
= init_type (TYPE_CODE_MODULE
, 0, 0, module_name
, objfile
);
8386 /* determine_prefix uses TYPE_TAG_NAME. */
8387 TYPE_TAG_NAME (type
) = TYPE_NAME (type
);
8389 return set_die_type (die
, type
, cu
);
8392 /* Read a Fortran module. */
8395 read_module (struct die_info
*die
, struct dwarf2_cu
*cu
)
8397 struct die_info
*child_die
= die
->child
;
8399 while (child_die
&& child_die
->tag
)
8401 process_die (child_die
, cu
);
8402 child_die
= sibling_die (child_die
);
8406 /* Return the name of the namespace represented by DIE. Set
8407 *IS_ANONYMOUS to tell whether or not the namespace is an anonymous
8411 namespace_name (struct die_info
*die
, int *is_anonymous
, struct dwarf2_cu
*cu
)
8413 struct die_info
*current_die
;
8414 const char *name
= NULL
;
8416 /* Loop through the extensions until we find a name. */
8418 for (current_die
= die
;
8419 current_die
!= NULL
;
8420 current_die
= dwarf2_extension (die
, &cu
))
8422 name
= dwarf2_name (current_die
, cu
);
8427 /* Is it an anonymous namespace? */
8429 *is_anonymous
= (name
== NULL
);
8431 name
= CP_ANONYMOUS_NAMESPACE_STR
;
8436 /* Extract all information from a DW_TAG_pointer_type DIE and add to
8437 the user defined type vector. */
8439 static struct type
*
8440 read_tag_pointer_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
8442 struct gdbarch
*gdbarch
= get_objfile_arch (cu
->objfile
);
8443 struct comp_unit_head
*cu_header
= &cu
->header
;
8445 struct attribute
*attr_byte_size
;
8446 struct attribute
*attr_address_class
;
8447 int byte_size
, addr_class
;
8448 struct type
*target_type
;
8450 target_type
= die_type (die
, cu
);
8452 /* The die_type call above may have already set the type for this DIE. */
8453 type
= get_die_type (die
, cu
);
8457 type
= lookup_pointer_type (target_type
);
8459 attr_byte_size
= dwarf2_attr (die
, DW_AT_byte_size
, cu
);
8461 byte_size
= DW_UNSND (attr_byte_size
);
8463 byte_size
= cu_header
->addr_size
;
8465 attr_address_class
= dwarf2_attr (die
, DW_AT_address_class
, cu
);
8466 if (attr_address_class
)
8467 addr_class
= DW_UNSND (attr_address_class
);
8469 addr_class
= DW_ADDR_none
;
8471 /* If the pointer size or address class is different than the
8472 default, create a type variant marked as such and set the
8473 length accordingly. */
8474 if (TYPE_LENGTH (type
) != byte_size
|| addr_class
!= DW_ADDR_none
)
8476 if (gdbarch_address_class_type_flags_p (gdbarch
))
8480 type_flags
= gdbarch_address_class_type_flags
8481 (gdbarch
, byte_size
, addr_class
);
8482 gdb_assert ((type_flags
& ~TYPE_INSTANCE_FLAG_ADDRESS_CLASS_ALL
)
8484 type
= make_type_with_address_space (type
, type_flags
);
8486 else if (TYPE_LENGTH (type
) != byte_size
)
8488 complaint (&symfile_complaints
,
8489 _("invalid pointer size %d"), byte_size
);
8493 /* Should we also complain about unhandled address classes? */
8497 TYPE_LENGTH (type
) = byte_size
;
8498 return set_die_type (die
, type
, cu
);
8501 /* Extract all information from a DW_TAG_ptr_to_member_type DIE and add to
8502 the user defined type vector. */
8504 static struct type
*
8505 read_tag_ptr_to_member_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
8508 struct type
*to_type
;
8509 struct type
*domain
;
8511 to_type
= die_type (die
, cu
);
8512 domain
= die_containing_type (die
, cu
);
8514 /* The calls above may have already set the type for this DIE. */
8515 type
= get_die_type (die
, cu
);
8519 if (TYPE_CODE (check_typedef (to_type
)) == TYPE_CODE_METHOD
)
8520 type
= lookup_methodptr_type (to_type
);
8522 type
= lookup_memberptr_type (to_type
, domain
);
8524 return set_die_type (die
, type
, cu
);
8527 /* Extract all information from a DW_TAG_reference_type DIE and add to
8528 the user defined type vector. */
8530 static struct type
*
8531 read_tag_reference_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
8533 struct comp_unit_head
*cu_header
= &cu
->header
;
8534 struct type
*type
, *target_type
;
8535 struct attribute
*attr
;
8537 target_type
= die_type (die
, cu
);
8539 /* The die_type call above may have already set the type for this DIE. */
8540 type
= get_die_type (die
, cu
);
8544 type
= lookup_reference_type (target_type
);
8545 attr
= dwarf2_attr (die
, DW_AT_byte_size
, cu
);
8548 TYPE_LENGTH (type
) = DW_UNSND (attr
);
8552 TYPE_LENGTH (type
) = cu_header
->addr_size
;
8554 return set_die_type (die
, type
, cu
);
8557 static struct type
*
8558 read_tag_const_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
8560 struct type
*base_type
, *cv_type
;
8562 base_type
= die_type (die
, cu
);
8564 /* The die_type call above may have already set the type for this DIE. */
8565 cv_type
= get_die_type (die
, cu
);
8569 /* In case the const qualifier is applied to an array type, the element type
8570 is so qualified, not the array type (section 6.7.3 of C99). */
8571 if (TYPE_CODE (base_type
) == TYPE_CODE_ARRAY
)
8573 struct type
*el_type
, *inner_array
;
8575 base_type
= copy_type (base_type
);
8576 inner_array
= base_type
;
8578 while (TYPE_CODE (TYPE_TARGET_TYPE (inner_array
)) == TYPE_CODE_ARRAY
)
8580 TYPE_TARGET_TYPE (inner_array
) =
8581 copy_type (TYPE_TARGET_TYPE (inner_array
));
8582 inner_array
= TYPE_TARGET_TYPE (inner_array
);
8585 el_type
= TYPE_TARGET_TYPE (inner_array
);
8586 TYPE_TARGET_TYPE (inner_array
) =
8587 make_cv_type (1, TYPE_VOLATILE (el_type
), el_type
, NULL
);
8589 return set_die_type (die
, base_type
, cu
);
8592 cv_type
= make_cv_type (1, TYPE_VOLATILE (base_type
), base_type
, 0);
8593 return set_die_type (die
, cv_type
, cu
);
8596 static struct type
*
8597 read_tag_volatile_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
8599 struct type
*base_type
, *cv_type
;
8601 base_type
= die_type (die
, cu
);
8603 /* The die_type call above may have already set the type for this DIE. */
8604 cv_type
= get_die_type (die
, cu
);
8608 cv_type
= make_cv_type (TYPE_CONST (base_type
), 1, base_type
, 0);
8609 return set_die_type (die
, cv_type
, cu
);
8612 /* Extract all information from a DW_TAG_string_type DIE and add to
8613 the user defined type vector. It isn't really a user defined type,
8614 but it behaves like one, with other DIE's using an AT_user_def_type
8615 attribute to reference it. */
8617 static struct type
*
8618 read_tag_string_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
8620 struct objfile
*objfile
= cu
->objfile
;
8621 struct gdbarch
*gdbarch
= get_objfile_arch (objfile
);
8622 struct type
*type
, *range_type
, *index_type
, *char_type
;
8623 struct attribute
*attr
;
8624 unsigned int length
;
8626 attr
= dwarf2_attr (die
, DW_AT_string_length
, cu
);
8629 length
= DW_UNSND (attr
);
8633 /* Check for the DW_AT_byte_size attribute. */
8634 attr
= dwarf2_attr (die
, DW_AT_byte_size
, cu
);
8637 length
= DW_UNSND (attr
);
8645 index_type
= objfile_type (objfile
)->builtin_int
;
8646 range_type
= create_range_type (NULL
, index_type
, 1, length
);
8647 char_type
= language_string_char_type (cu
->language_defn
, gdbarch
);
8648 type
= create_string_type (NULL
, char_type
, range_type
);
8650 return set_die_type (die
, type
, cu
);
8653 /* Handle DIES due to C code like:
8657 int (*funcp)(int a, long l);
8661 ('funcp' generates a DW_TAG_subroutine_type DIE). */
8663 static struct type
*
8664 read_subroutine_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
8666 struct objfile
*objfile
= cu
->objfile
;
8667 struct type
*type
; /* Type that this function returns. */
8668 struct type
*ftype
; /* Function that returns above type. */
8669 struct attribute
*attr
;
8671 type
= die_type (die
, cu
);
8673 /* The die_type call above may have already set the type for this DIE. */
8674 ftype
= get_die_type (die
, cu
);
8678 ftype
= lookup_function_type (type
);
8680 /* All functions in C++, Pascal and Java have prototypes. */
8681 attr
= dwarf2_attr (die
, DW_AT_prototyped
, cu
);
8682 if ((attr
&& (DW_UNSND (attr
) != 0))
8683 || cu
->language
== language_cplus
8684 || cu
->language
== language_java
8685 || cu
->language
== language_pascal
)
8686 TYPE_PROTOTYPED (ftype
) = 1;
8687 else if (producer_is_realview (cu
->producer
))
8688 /* RealView does not emit DW_AT_prototyped. We can not
8689 distinguish prototyped and unprototyped functions; default to
8690 prototyped, since that is more common in modern code (and
8691 RealView warns about unprototyped functions). */
8692 TYPE_PROTOTYPED (ftype
) = 1;
8694 /* Store the calling convention in the type if it's available in
8695 the subroutine die. Otherwise set the calling convention to
8696 the default value DW_CC_normal. */
8697 attr
= dwarf2_attr (die
, DW_AT_calling_convention
, cu
);
8699 TYPE_CALLING_CONVENTION (ftype
) = DW_UNSND (attr
);
8700 else if (cu
->producer
&& strstr (cu
->producer
, "IBM XL C for OpenCL"))
8701 TYPE_CALLING_CONVENTION (ftype
) = DW_CC_GDB_IBM_OpenCL
;
8703 TYPE_CALLING_CONVENTION (ftype
) = DW_CC_normal
;
8705 /* We need to add the subroutine type to the die immediately so
8706 we don't infinitely recurse when dealing with parameters
8707 declared as the same subroutine type. */
8708 set_die_type (die
, ftype
, cu
);
8710 if (die
->child
!= NULL
)
8712 struct type
*void_type
= objfile_type (objfile
)->builtin_void
;
8713 struct die_info
*child_die
;
8714 int nparams
, iparams
;
8716 /* Count the number of parameters.
8717 FIXME: GDB currently ignores vararg functions, but knows about
8718 vararg member functions. */
8720 child_die
= die
->child
;
8721 while (child_die
&& child_die
->tag
)
8723 if (child_die
->tag
== DW_TAG_formal_parameter
)
8725 else if (child_die
->tag
== DW_TAG_unspecified_parameters
)
8726 TYPE_VARARGS (ftype
) = 1;
8727 child_die
= sibling_die (child_die
);
8730 /* Allocate storage for parameters and fill them in. */
8731 TYPE_NFIELDS (ftype
) = nparams
;
8732 TYPE_FIELDS (ftype
) = (struct field
*)
8733 TYPE_ZALLOC (ftype
, nparams
* sizeof (struct field
));
8735 /* TYPE_FIELD_TYPE must never be NULL. Pre-fill the array to ensure it
8736 even if we error out during the parameters reading below. */
8737 for (iparams
= 0; iparams
< nparams
; iparams
++)
8738 TYPE_FIELD_TYPE (ftype
, iparams
) = void_type
;
8741 child_die
= die
->child
;
8742 while (child_die
&& child_die
->tag
)
8744 if (child_die
->tag
== DW_TAG_formal_parameter
)
8746 struct type
*arg_type
;
8748 /* DWARF version 2 has no clean way to discern C++
8749 static and non-static member functions. G++ helps
8750 GDB by marking the first parameter for non-static
8751 member functions (which is the this pointer) as
8752 artificial. We pass this information to
8753 dwarf2_add_member_fn via TYPE_FIELD_ARTIFICIAL.
8755 DWARF version 3 added DW_AT_object_pointer, which GCC
8756 4.5 does not yet generate. */
8757 attr
= dwarf2_attr (child_die
, DW_AT_artificial
, cu
);
8759 TYPE_FIELD_ARTIFICIAL (ftype
, iparams
) = DW_UNSND (attr
);
8762 TYPE_FIELD_ARTIFICIAL (ftype
, iparams
) = 0;
8764 /* GCC/43521: In java, the formal parameter
8765 "this" is sometimes not marked with DW_AT_artificial. */
8766 if (cu
->language
== language_java
)
8768 const char *name
= dwarf2_name (child_die
, cu
);
8770 if (name
&& !strcmp (name
, "this"))
8771 TYPE_FIELD_ARTIFICIAL (ftype
, iparams
) = 1;
8774 arg_type
= die_type (child_die
, cu
);
8776 /* RealView does not mark THIS as const, which the testsuite
8777 expects. GCC marks THIS as const in method definitions,
8778 but not in the class specifications (GCC PR 43053). */
8779 if (cu
->language
== language_cplus
&& !TYPE_CONST (arg_type
)
8780 && TYPE_FIELD_ARTIFICIAL (ftype
, iparams
))
8783 struct dwarf2_cu
*arg_cu
= cu
;
8784 const char *name
= dwarf2_name (child_die
, cu
);
8786 attr
= dwarf2_attr (die
, DW_AT_object_pointer
, cu
);
8789 /* If the compiler emits this, use it. */
8790 if (follow_die_ref (die
, attr
, &arg_cu
) == child_die
)
8793 else if (name
&& strcmp (name
, "this") == 0)
8794 /* Function definitions will have the argument names. */
8796 else if (name
== NULL
&& iparams
== 0)
8797 /* Declarations may not have the names, so like
8798 elsewhere in GDB, assume an artificial first
8799 argument is "this". */
8803 arg_type
= make_cv_type (1, TYPE_VOLATILE (arg_type
),
8807 TYPE_FIELD_TYPE (ftype
, iparams
) = arg_type
;
8810 child_die
= sibling_die (child_die
);
8817 static struct type
*
8818 read_typedef (struct die_info
*die
, struct dwarf2_cu
*cu
)
8820 struct objfile
*objfile
= cu
->objfile
;
8821 const char *name
= NULL
;
8822 struct type
*this_type
, *target_type
;
8824 name
= dwarf2_full_name (NULL
, die
, cu
);
8825 this_type
= init_type (TYPE_CODE_TYPEDEF
, 0,
8826 TYPE_FLAG_TARGET_STUB
, NULL
, objfile
);
8827 TYPE_NAME (this_type
) = (char *) name
;
8828 set_die_type (die
, this_type
, cu
);
8829 target_type
= die_type (die
, cu
);
8830 if (target_type
!= this_type
)
8831 TYPE_TARGET_TYPE (this_type
) = target_type
;
8834 /* Self-referential typedefs are, it seems, not allowed by the DWARF
8835 spec and cause infinite loops in GDB. */
8836 complaint (&symfile_complaints
,
8837 _("Self-referential DW_TAG_typedef "
8838 "- DIE at 0x%x [in module %s]"),
8839 die
->offset
, objfile
->name
);
8840 TYPE_TARGET_TYPE (this_type
) = NULL
;
8845 /* Find a representation of a given base type and install
8846 it in the TYPE field of the die. */
8848 static struct type
*
8849 read_base_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
8851 struct objfile
*objfile
= cu
->objfile
;
8853 struct attribute
*attr
;
8854 int encoding
= 0, size
= 0;
8856 enum type_code code
= TYPE_CODE_INT
;
8858 struct type
*target_type
= NULL
;
8860 attr
= dwarf2_attr (die
, DW_AT_encoding
, cu
);
8863 encoding
= DW_UNSND (attr
);
8865 attr
= dwarf2_attr (die
, DW_AT_byte_size
, cu
);
8868 size
= DW_UNSND (attr
);
8870 name
= dwarf2_name (die
, cu
);
8873 complaint (&symfile_complaints
,
8874 _("DW_AT_name missing from DW_TAG_base_type"));
8879 case DW_ATE_address
:
8880 /* Turn DW_ATE_address into a void * pointer. */
8881 code
= TYPE_CODE_PTR
;
8882 type_flags
|= TYPE_FLAG_UNSIGNED
;
8883 target_type
= init_type (TYPE_CODE_VOID
, 1, 0, NULL
, objfile
);
8885 case DW_ATE_boolean
:
8886 code
= TYPE_CODE_BOOL
;
8887 type_flags
|= TYPE_FLAG_UNSIGNED
;
8889 case DW_ATE_complex_float
:
8890 code
= TYPE_CODE_COMPLEX
;
8891 target_type
= init_type (TYPE_CODE_FLT
, size
/ 2, 0, NULL
, objfile
);
8893 case DW_ATE_decimal_float
:
8894 code
= TYPE_CODE_DECFLOAT
;
8897 code
= TYPE_CODE_FLT
;
8901 case DW_ATE_unsigned
:
8902 type_flags
|= TYPE_FLAG_UNSIGNED
;
8903 if (cu
->language
== language_fortran
8905 && strncmp (name
, "character(", sizeof ("character(") - 1) == 0)
8906 code
= TYPE_CODE_CHAR
;
8908 case DW_ATE_signed_char
:
8909 if (cu
->language
== language_ada
|| cu
->language
== language_m2
8910 || cu
->language
== language_pascal
8911 || cu
->language
== language_fortran
)
8912 code
= TYPE_CODE_CHAR
;
8914 case DW_ATE_unsigned_char
:
8915 if (cu
->language
== language_ada
|| cu
->language
== language_m2
8916 || cu
->language
== language_pascal
8917 || cu
->language
== language_fortran
)
8918 code
= TYPE_CODE_CHAR
;
8919 type_flags
|= TYPE_FLAG_UNSIGNED
;
8922 /* We just treat this as an integer and then recognize the
8923 type by name elsewhere. */
8927 complaint (&symfile_complaints
, _("unsupported DW_AT_encoding: '%s'"),
8928 dwarf_type_encoding_name (encoding
));
8932 type
= init_type (code
, size
, type_flags
, NULL
, objfile
);
8933 TYPE_NAME (type
) = name
;
8934 TYPE_TARGET_TYPE (type
) = target_type
;
8936 if (name
&& strcmp (name
, "char") == 0)
8937 TYPE_NOSIGN (type
) = 1;
8939 return set_die_type (die
, type
, cu
);
8942 /* Read the given DW_AT_subrange DIE. */
8944 static struct type
*
8945 read_subrange_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
8947 struct type
*base_type
;
8948 struct type
*range_type
;
8949 struct attribute
*attr
;
8953 LONGEST negative_mask
;
8955 base_type
= die_type (die
, cu
);
8956 /* Preserve BASE_TYPE's original type, just set its LENGTH. */
8957 check_typedef (base_type
);
8959 /* The die_type call above may have already set the type for this DIE. */
8960 range_type
= get_die_type (die
, cu
);
8964 if (cu
->language
== language_fortran
)
8966 /* FORTRAN implies a lower bound of 1, if not given. */
8970 /* FIXME: For variable sized arrays either of these could be
8971 a variable rather than a constant value. We'll allow it,
8972 but we don't know how to handle it. */
8973 attr
= dwarf2_attr (die
, DW_AT_lower_bound
, cu
);
8975 low
= dwarf2_get_attr_constant_value (attr
, 0);
8977 attr
= dwarf2_attr (die
, DW_AT_upper_bound
, cu
);
8980 if (attr_form_is_block (attr
) || is_ref_attr (attr
))
8982 /* GCC encodes arrays with unspecified or dynamic length
8983 with a DW_FORM_block1 attribute or a reference attribute.
8984 FIXME: GDB does not yet know how to handle dynamic
8985 arrays properly, treat them as arrays with unspecified
8988 FIXME: jimb/2003-09-22: GDB does not really know
8989 how to handle arrays of unspecified length
8990 either; we just represent them as zero-length
8991 arrays. Choose an appropriate upper bound given
8992 the lower bound we've computed above. */
8996 high
= dwarf2_get_attr_constant_value (attr
, 1);
9000 attr
= dwarf2_attr (die
, DW_AT_count
, cu
);
9003 int count
= dwarf2_get_attr_constant_value (attr
, 1);
9004 high
= low
+ count
- 1;
9008 /* Unspecified array length. */
9013 /* Dwarf-2 specifications explicitly allows to create subrange types
9014 without specifying a base type.
9015 In that case, the base type must be set to the type of
9016 the lower bound, upper bound or count, in that order, if any of these
9017 three attributes references an object that has a type.
9018 If no base type is found, the Dwarf-2 specifications say that
9019 a signed integer type of size equal to the size of an address should
9021 For the following C code: `extern char gdb_int [];'
9022 GCC produces an empty range DIE.
9023 FIXME: muller/2010-05-28: Possible references to object for low bound,
9024 high bound or count are not yet handled by this code. */
9025 if (TYPE_CODE (base_type
) == TYPE_CODE_VOID
)
9027 struct objfile
*objfile
= cu
->objfile
;
9028 struct gdbarch
*gdbarch
= get_objfile_arch (objfile
);
9029 int addr_size
= gdbarch_addr_bit (gdbarch
) /8;
9030 struct type
*int_type
= objfile_type (objfile
)->builtin_int
;
9032 /* Test "int", "long int", and "long long int" objfile types,
9033 and select the first one having a size above or equal to the
9034 architecture address size. */
9035 if (int_type
&& TYPE_LENGTH (int_type
) >= addr_size
)
9036 base_type
= int_type
;
9039 int_type
= objfile_type (objfile
)->builtin_long
;
9040 if (int_type
&& TYPE_LENGTH (int_type
) >= addr_size
)
9041 base_type
= int_type
;
9044 int_type
= objfile_type (objfile
)->builtin_long_long
;
9045 if (int_type
&& TYPE_LENGTH (int_type
) >= addr_size
)
9046 base_type
= int_type
;
9052 (LONGEST
) -1 << (TYPE_LENGTH (base_type
) * TARGET_CHAR_BIT
- 1);
9053 if (!TYPE_UNSIGNED (base_type
) && (low
& negative_mask
))
9054 low
|= negative_mask
;
9055 if (!TYPE_UNSIGNED (base_type
) && (high
& negative_mask
))
9056 high
|= negative_mask
;
9058 range_type
= create_range_type (NULL
, base_type
, low
, high
);
9060 /* Mark arrays with dynamic length at least as an array of unspecified
9061 length. GDB could check the boundary but before it gets implemented at
9062 least allow accessing the array elements. */
9063 if (attr
&& attr_form_is_block (attr
))
9064 TYPE_HIGH_BOUND_UNDEFINED (range_type
) = 1;
9066 /* Ada expects an empty array on no boundary attributes. */
9067 if (attr
== NULL
&& cu
->language
!= language_ada
)
9068 TYPE_HIGH_BOUND_UNDEFINED (range_type
) = 1;
9070 name
= dwarf2_name (die
, cu
);
9072 TYPE_NAME (range_type
) = name
;
9074 attr
= dwarf2_attr (die
, DW_AT_byte_size
, cu
);
9076 TYPE_LENGTH (range_type
) = DW_UNSND (attr
);
9078 set_die_type (die
, range_type
, cu
);
9080 /* set_die_type should be already done. */
9081 set_descriptive_type (range_type
, die
, cu
);
9086 static struct type
*
9087 read_unspecified_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
9091 /* For now, we only support the C meaning of an unspecified type: void. */
9093 type
= init_type (TYPE_CODE_VOID
, 0, 0, NULL
, cu
->objfile
);
9094 TYPE_NAME (type
) = dwarf2_name (die
, cu
);
9096 return set_die_type (die
, type
, cu
);
9099 /* Trivial hash function for die_info: the hash value of a DIE
9100 is its offset in .debug_info for this objfile. */
9103 die_hash (const void *item
)
9105 const struct die_info
*die
= item
;
9110 /* Trivial comparison function for die_info structures: two DIEs
9111 are equal if they have the same offset. */
9114 die_eq (const void *item_lhs
, const void *item_rhs
)
9116 const struct die_info
*die_lhs
= item_lhs
;
9117 const struct die_info
*die_rhs
= item_rhs
;
9119 return die_lhs
->offset
== die_rhs
->offset
;
9122 /* Read a whole compilation unit into a linked list of dies. */
9124 static struct die_info
*
9125 read_comp_unit (gdb_byte
*info_ptr
, struct dwarf2_cu
*cu
)
9127 struct die_reader_specs reader_specs
;
9128 int read_abbrevs
= 0;
9129 struct cleanup
*back_to
= NULL
;
9130 struct die_info
*die
;
9132 if (cu
->dwarf2_abbrevs
== NULL
)
9134 dwarf2_read_abbrevs (cu
);
9135 back_to
= make_cleanup (dwarf2_free_abbrev_table
, cu
);
9139 gdb_assert (cu
->die_hash
== NULL
);
9141 = htab_create_alloc_ex (cu
->header
.length
/ 12,
9145 &cu
->comp_unit_obstack
,
9146 hashtab_obstack_allocate
,
9147 dummy_obstack_deallocate
);
9149 init_cu_die_reader (&reader_specs
, cu
);
9151 die
= read_die_and_children (&reader_specs
, info_ptr
, &info_ptr
, NULL
);
9154 do_cleanups (back_to
);
9159 /* Main entry point for reading a DIE and all children.
9160 Read the DIE and dump it if requested. */
9162 static struct die_info
*
9163 read_die_and_children (const struct die_reader_specs
*reader
,
9165 gdb_byte
**new_info_ptr
,
9166 struct die_info
*parent
)
9168 struct die_info
*result
= read_die_and_children_1 (reader
, info_ptr
,
9169 new_info_ptr
, parent
);
9171 if (dwarf2_die_debug
)
9173 fprintf_unfiltered (gdb_stdlog
,
9174 "\nRead die from %s of %s:\n",
9175 (reader
->cu
->per_cu
->debug_types_section
9178 reader
->abfd
->filename
);
9179 dump_die (result
, dwarf2_die_debug
);
9185 /* Read a single die and all its descendents. Set the die's sibling
9186 field to NULL; set other fields in the die correctly, and set all
9187 of the descendents' fields correctly. Set *NEW_INFO_PTR to the
9188 location of the info_ptr after reading all of those dies. PARENT
9189 is the parent of the die in question. */
9191 static struct die_info
*
9192 read_die_and_children_1 (const struct die_reader_specs
*reader
,
9194 gdb_byte
**new_info_ptr
,
9195 struct die_info
*parent
)
9197 struct die_info
*die
;
9201 cur_ptr
= read_full_die (reader
, &die
, info_ptr
, &has_children
);
9204 *new_info_ptr
= cur_ptr
;
9207 store_in_ref_table (die
, reader
->cu
);
9210 die
->child
= read_die_and_siblings (reader
, cur_ptr
, new_info_ptr
, die
);
9214 *new_info_ptr
= cur_ptr
;
9217 die
->sibling
= NULL
;
9218 die
->parent
= parent
;
9222 /* Read a die, all of its descendents, and all of its siblings; set
9223 all of the fields of all of the dies correctly. Arguments are as
9224 in read_die_and_children. */
9226 static struct die_info
*
9227 read_die_and_siblings (const struct die_reader_specs
*reader
,
9229 gdb_byte
**new_info_ptr
,
9230 struct die_info
*parent
)
9232 struct die_info
*first_die
, *last_sibling
;
9236 first_die
= last_sibling
= NULL
;
9240 struct die_info
*die
9241 = read_die_and_children_1 (reader
, cur_ptr
, &cur_ptr
, parent
);
9245 *new_info_ptr
= cur_ptr
;
9252 last_sibling
->sibling
= die
;
9258 /* Read the die from the .debug_info section buffer. Set DIEP to
9259 point to a newly allocated die with its information, except for its
9260 child, sibling, and parent fields. Set HAS_CHILDREN to tell
9261 whether the die has children or not. */
9264 read_full_die (const struct die_reader_specs
*reader
,
9265 struct die_info
**diep
, gdb_byte
*info_ptr
,
9268 unsigned int abbrev_number
, bytes_read
, i
, offset
;
9269 struct abbrev_info
*abbrev
;
9270 struct die_info
*die
;
9271 struct dwarf2_cu
*cu
= reader
->cu
;
9272 bfd
*abfd
= reader
->abfd
;
9274 offset
= info_ptr
- reader
->buffer
;
9275 abbrev_number
= read_unsigned_leb128 (abfd
, info_ptr
, &bytes_read
);
9276 info_ptr
+= bytes_read
;
9284 abbrev
= dwarf2_lookup_abbrev (abbrev_number
, cu
);
9286 error (_("Dwarf Error: could not find abbrev number %d [in module %s]"),
9288 bfd_get_filename (abfd
));
9290 die
= dwarf_alloc_die (cu
, abbrev
->num_attrs
);
9291 die
->offset
= offset
;
9292 die
->tag
= abbrev
->tag
;
9293 die
->abbrev
= abbrev_number
;
9295 die
->num_attrs
= abbrev
->num_attrs
;
9297 for (i
= 0; i
< abbrev
->num_attrs
; ++i
)
9298 info_ptr
= read_attribute (&die
->attrs
[i
], &abbrev
->attrs
[i
],
9299 abfd
, info_ptr
, cu
);
9302 *has_children
= abbrev
->has_children
;
9306 /* In DWARF version 2, the description of the debugging information is
9307 stored in a separate .debug_abbrev section. Before we read any
9308 dies from a section we read in all abbreviations and install them
9309 in a hash table. This function also sets flags in CU describing
9310 the data found in the abbrev table. */
9313 dwarf2_read_abbrevs (struct dwarf2_cu
*cu
)
9315 bfd
*abfd
= cu
->objfile
->obfd
;
9316 struct comp_unit_head
*cu_header
= &cu
->header
;
9317 gdb_byte
*abbrev_ptr
;
9318 struct abbrev_info
*cur_abbrev
;
9319 unsigned int abbrev_number
, bytes_read
, abbrev_name
;
9320 unsigned int abbrev_form
, hash_number
;
9321 struct attr_abbrev
*cur_attrs
;
9322 unsigned int allocated_attrs
;
9324 /* Initialize dwarf2 abbrevs. */
9325 obstack_init (&cu
->abbrev_obstack
);
9326 cu
->dwarf2_abbrevs
= obstack_alloc (&cu
->abbrev_obstack
,
9328 * sizeof (struct abbrev_info
*)));
9329 memset (cu
->dwarf2_abbrevs
, 0,
9330 ABBREV_HASH_SIZE
* sizeof (struct abbrev_info
*));
9332 dwarf2_read_section (dwarf2_per_objfile
->objfile
,
9333 &dwarf2_per_objfile
->abbrev
);
9334 abbrev_ptr
= dwarf2_per_objfile
->abbrev
.buffer
+ cu_header
->abbrev_offset
;
9335 abbrev_number
= read_unsigned_leb128 (abfd
, abbrev_ptr
, &bytes_read
);
9336 abbrev_ptr
+= bytes_read
;
9338 allocated_attrs
= ATTR_ALLOC_CHUNK
;
9339 cur_attrs
= xmalloc (allocated_attrs
* sizeof (struct attr_abbrev
));
9341 /* Loop until we reach an abbrev number of 0. */
9342 while (abbrev_number
)
9344 cur_abbrev
= dwarf_alloc_abbrev (cu
);
9346 /* read in abbrev header */
9347 cur_abbrev
->number
= abbrev_number
;
9348 cur_abbrev
->tag
= read_unsigned_leb128 (abfd
, abbrev_ptr
, &bytes_read
);
9349 abbrev_ptr
+= bytes_read
;
9350 cur_abbrev
->has_children
= read_1_byte (abfd
, abbrev_ptr
);
9353 if (cur_abbrev
->tag
== DW_TAG_namespace
)
9354 cu
->has_namespace_info
= 1;
9356 /* now read in declarations */
9357 abbrev_name
= read_unsigned_leb128 (abfd
, abbrev_ptr
, &bytes_read
);
9358 abbrev_ptr
+= bytes_read
;
9359 abbrev_form
= read_unsigned_leb128 (abfd
, abbrev_ptr
, &bytes_read
);
9360 abbrev_ptr
+= bytes_read
;
9363 if (cur_abbrev
->num_attrs
== allocated_attrs
)
9365 allocated_attrs
+= ATTR_ALLOC_CHUNK
;
9367 = xrealloc (cur_attrs
, (allocated_attrs
9368 * sizeof (struct attr_abbrev
)));
9371 /* Record whether this compilation unit might have
9372 inter-compilation-unit references. If we don't know what form
9373 this attribute will have, then it might potentially be a
9374 DW_FORM_ref_addr, so we conservatively expect inter-CU
9377 if (abbrev_form
== DW_FORM_ref_addr
9378 || abbrev_form
== DW_FORM_indirect
)
9379 cu
->has_form_ref_addr
= 1;
9381 cur_attrs
[cur_abbrev
->num_attrs
].name
= abbrev_name
;
9382 cur_attrs
[cur_abbrev
->num_attrs
++].form
= abbrev_form
;
9383 abbrev_name
= read_unsigned_leb128 (abfd
, abbrev_ptr
, &bytes_read
);
9384 abbrev_ptr
+= bytes_read
;
9385 abbrev_form
= read_unsigned_leb128 (abfd
, abbrev_ptr
, &bytes_read
);
9386 abbrev_ptr
+= bytes_read
;
9389 cur_abbrev
->attrs
= obstack_alloc (&cu
->abbrev_obstack
,
9390 (cur_abbrev
->num_attrs
9391 * sizeof (struct attr_abbrev
)));
9392 memcpy (cur_abbrev
->attrs
, cur_attrs
,
9393 cur_abbrev
->num_attrs
* sizeof (struct attr_abbrev
));
9395 hash_number
= abbrev_number
% ABBREV_HASH_SIZE
;
9396 cur_abbrev
->next
= cu
->dwarf2_abbrevs
[hash_number
];
9397 cu
->dwarf2_abbrevs
[hash_number
] = cur_abbrev
;
9399 /* Get next abbreviation.
9400 Under Irix6 the abbreviations for a compilation unit are not
9401 always properly terminated with an abbrev number of 0.
9402 Exit loop if we encounter an abbreviation which we have
9403 already read (which means we are about to read the abbreviations
9404 for the next compile unit) or if the end of the abbreviation
9405 table is reached. */
9406 if ((unsigned int) (abbrev_ptr
- dwarf2_per_objfile
->abbrev
.buffer
)
9407 >= dwarf2_per_objfile
->abbrev
.size
)
9409 abbrev_number
= read_unsigned_leb128 (abfd
, abbrev_ptr
, &bytes_read
);
9410 abbrev_ptr
+= bytes_read
;
9411 if (dwarf2_lookup_abbrev (abbrev_number
, cu
) != NULL
)
9418 /* Release the memory used by the abbrev table for a compilation unit. */
9421 dwarf2_free_abbrev_table (void *ptr_to_cu
)
9423 struct dwarf2_cu
*cu
= ptr_to_cu
;
9425 obstack_free (&cu
->abbrev_obstack
, NULL
);
9426 cu
->dwarf2_abbrevs
= NULL
;
9429 /* Lookup an abbrev_info structure in the abbrev hash table. */
9431 static struct abbrev_info
*
9432 dwarf2_lookup_abbrev (unsigned int number
, struct dwarf2_cu
*cu
)
9434 unsigned int hash_number
;
9435 struct abbrev_info
*abbrev
;
9437 hash_number
= number
% ABBREV_HASH_SIZE
;
9438 abbrev
= cu
->dwarf2_abbrevs
[hash_number
];
9442 if (abbrev
->number
== number
)
9445 abbrev
= abbrev
->next
;
9450 /* Returns nonzero if TAG represents a type that we might generate a partial
9454 is_type_tag_for_partial (int tag
)
9459 /* Some types that would be reasonable to generate partial symbols for,
9460 that we don't at present. */
9461 case DW_TAG_array_type
:
9462 case DW_TAG_file_type
:
9463 case DW_TAG_ptr_to_member_type
:
9464 case DW_TAG_set_type
:
9465 case DW_TAG_string_type
:
9466 case DW_TAG_subroutine_type
:
9468 case DW_TAG_base_type
:
9469 case DW_TAG_class_type
:
9470 case DW_TAG_interface_type
:
9471 case DW_TAG_enumeration_type
:
9472 case DW_TAG_structure_type
:
9473 case DW_TAG_subrange_type
:
9474 case DW_TAG_typedef
:
9475 case DW_TAG_union_type
:
9482 /* Load all DIEs that are interesting for partial symbols into memory. */
9484 static struct partial_die_info
*
9485 load_partial_dies (bfd
*abfd
, gdb_byte
*buffer
, gdb_byte
*info_ptr
,
9486 int building_psymtab
, struct dwarf2_cu
*cu
)
9488 struct objfile
*objfile
= cu
->objfile
;
9489 struct partial_die_info
*part_die
;
9490 struct partial_die_info
*parent_die
, *last_die
, *first_die
= NULL
;
9491 struct abbrev_info
*abbrev
;
9492 unsigned int bytes_read
;
9493 unsigned int load_all
= 0;
9495 int nesting_level
= 1;
9500 if (cu
->per_cu
&& cu
->per_cu
->load_all_dies
)
9504 = htab_create_alloc_ex (cu
->header
.length
/ 12,
9508 &cu
->comp_unit_obstack
,
9509 hashtab_obstack_allocate
,
9510 dummy_obstack_deallocate
);
9512 part_die
= obstack_alloc (&cu
->comp_unit_obstack
,
9513 sizeof (struct partial_die_info
));
9517 abbrev
= peek_die_abbrev (info_ptr
, &bytes_read
, cu
);
9519 /* A NULL abbrev means the end of a series of children. */
9522 if (--nesting_level
== 0)
9524 /* PART_DIE was probably the last thing allocated on the
9525 comp_unit_obstack, so we could call obstack_free
9526 here. We don't do that because the waste is small,
9527 and will be cleaned up when we're done with this
9528 compilation unit. This way, we're also more robust
9529 against other users of the comp_unit_obstack. */
9532 info_ptr
+= bytes_read
;
9533 last_die
= parent_die
;
9534 parent_die
= parent_die
->die_parent
;
9538 /* Check for template arguments. We never save these; if
9539 they're seen, we just mark the parent, and go on our way. */
9540 if (parent_die
!= NULL
9541 && cu
->language
== language_cplus
9542 && (abbrev
->tag
== DW_TAG_template_type_param
9543 || abbrev
->tag
== DW_TAG_template_value_param
))
9545 parent_die
->has_template_arguments
= 1;
9549 /* We don't need a partial DIE for the template argument. */
9550 info_ptr
= skip_one_die (buffer
, info_ptr
+ bytes_read
, abbrev
,
9556 /* We only recurse into subprograms looking for template arguments.
9557 Skip their other children. */
9559 && cu
->language
== language_cplus
9560 && parent_die
!= NULL
9561 && parent_die
->tag
== DW_TAG_subprogram
)
9563 info_ptr
= skip_one_die (buffer
, info_ptr
+ bytes_read
, abbrev
, cu
);
9567 /* Check whether this DIE is interesting enough to save. Normally
9568 we would not be interested in members here, but there may be
9569 later variables referencing them via DW_AT_specification (for
9572 && !is_type_tag_for_partial (abbrev
->tag
)
9573 && abbrev
->tag
!= DW_TAG_constant
9574 && abbrev
->tag
!= DW_TAG_enumerator
9575 && abbrev
->tag
!= DW_TAG_subprogram
9576 && abbrev
->tag
!= DW_TAG_lexical_block
9577 && abbrev
->tag
!= DW_TAG_variable
9578 && abbrev
->tag
!= DW_TAG_namespace
9579 && abbrev
->tag
!= DW_TAG_module
9580 && abbrev
->tag
!= DW_TAG_member
)
9582 /* Otherwise we skip to the next sibling, if any. */
9583 info_ptr
= skip_one_die (buffer
, info_ptr
+ bytes_read
, abbrev
, cu
);
9587 info_ptr
= read_partial_die (part_die
, abbrev
, bytes_read
, abfd
,
9588 buffer
, info_ptr
, cu
);
9590 /* This two-pass algorithm for processing partial symbols has a
9591 high cost in cache pressure. Thus, handle some simple cases
9592 here which cover the majority of C partial symbols. DIEs
9593 which neither have specification tags in them, nor could have
9594 specification tags elsewhere pointing at them, can simply be
9595 processed and discarded.
9597 This segment is also optional; scan_partial_symbols and
9598 add_partial_symbol will handle these DIEs if we chain
9599 them in normally. When compilers which do not emit large
9600 quantities of duplicate debug information are more common,
9601 this code can probably be removed. */
9603 /* Any complete simple types at the top level (pretty much all
9604 of them, for a language without namespaces), can be processed
9606 if (parent_die
== NULL
9607 && part_die
->has_specification
== 0
9608 && part_die
->is_declaration
== 0
9609 && ((part_die
->tag
== DW_TAG_typedef
&& !part_die
->has_children
)
9610 || part_die
->tag
== DW_TAG_base_type
9611 || part_die
->tag
== DW_TAG_subrange_type
))
9613 if (building_psymtab
&& part_die
->name
!= NULL
)
9614 add_psymbol_to_list (part_die
->name
, strlen (part_die
->name
), 0,
9615 VAR_DOMAIN
, LOC_TYPEDEF
,
9616 &objfile
->static_psymbols
,
9617 0, (CORE_ADDR
) 0, cu
->language
, objfile
);
9618 info_ptr
= locate_pdi_sibling (part_die
, buffer
, info_ptr
, abfd
, cu
);
9622 /* The exception for DW_TAG_typedef with has_children above is
9623 a workaround of GCC PR debug/47510. In the case of this complaint
9624 type_name_no_tag_or_error will error on such types later.
9626 GDB skipped children of DW_TAG_typedef by the shortcut above and then
9627 it could not find the child DIEs referenced later, this is checked
9628 above. In correct DWARF DW_TAG_typedef should have no children. */
9630 if (part_die
->tag
== DW_TAG_typedef
&& part_die
->has_children
)
9631 complaint (&symfile_complaints
,
9632 _("DW_TAG_typedef has childen - GCC PR debug/47510 bug "
9633 "- DIE at 0x%x [in module %s]"),
9634 part_die
->offset
, objfile
->name
);
9636 /* If we're at the second level, and we're an enumerator, and
9637 our parent has no specification (meaning possibly lives in a
9638 namespace elsewhere), then we can add the partial symbol now
9639 instead of queueing it. */
9640 if (part_die
->tag
== DW_TAG_enumerator
9641 && parent_die
!= NULL
9642 && parent_die
->die_parent
== NULL
9643 && parent_die
->tag
== DW_TAG_enumeration_type
9644 && parent_die
->has_specification
== 0)
9646 if (part_die
->name
== NULL
)
9647 complaint (&symfile_complaints
,
9648 _("malformed enumerator DIE ignored"));
9649 else if (building_psymtab
)
9650 add_psymbol_to_list (part_die
->name
, strlen (part_die
->name
), 0,
9651 VAR_DOMAIN
, LOC_CONST
,
9652 (cu
->language
== language_cplus
9653 || cu
->language
== language_java
)
9654 ? &objfile
->global_psymbols
9655 : &objfile
->static_psymbols
,
9656 0, (CORE_ADDR
) 0, cu
->language
, objfile
);
9658 info_ptr
= locate_pdi_sibling (part_die
, buffer
, info_ptr
, abfd
, cu
);
9662 /* We'll save this DIE so link it in. */
9663 part_die
->die_parent
= parent_die
;
9664 part_die
->die_sibling
= NULL
;
9665 part_die
->die_child
= NULL
;
9667 if (last_die
&& last_die
== parent_die
)
9668 last_die
->die_child
= part_die
;
9670 last_die
->die_sibling
= part_die
;
9672 last_die
= part_die
;
9674 if (first_die
== NULL
)
9675 first_die
= part_die
;
9677 /* Maybe add the DIE to the hash table. Not all DIEs that we
9678 find interesting need to be in the hash table, because we
9679 also have the parent/sibling/child chains; only those that we
9680 might refer to by offset later during partial symbol reading.
9682 For now this means things that might have be the target of a
9683 DW_AT_specification, DW_AT_abstract_origin, or
9684 DW_AT_extension. DW_AT_extension will refer only to
9685 namespaces; DW_AT_abstract_origin refers to functions (and
9686 many things under the function DIE, but we do not recurse
9687 into function DIEs during partial symbol reading) and
9688 possibly variables as well; DW_AT_specification refers to
9689 declarations. Declarations ought to have the DW_AT_declaration
9690 flag. It happens that GCC forgets to put it in sometimes, but
9691 only for functions, not for types.
9693 Adding more things than necessary to the hash table is harmless
9694 except for the performance cost. Adding too few will result in
9695 wasted time in find_partial_die, when we reread the compilation
9696 unit with load_all_dies set. */
9699 || abbrev
->tag
== DW_TAG_constant
9700 || abbrev
->tag
== DW_TAG_subprogram
9701 || abbrev
->tag
== DW_TAG_variable
9702 || abbrev
->tag
== DW_TAG_namespace
9703 || part_die
->is_declaration
)
9707 slot
= htab_find_slot_with_hash (cu
->partial_dies
, part_die
,
9708 part_die
->offset
, INSERT
);
9712 part_die
= obstack_alloc (&cu
->comp_unit_obstack
,
9713 sizeof (struct partial_die_info
));
9715 /* For some DIEs we want to follow their children (if any). For C
9716 we have no reason to follow the children of structures; for other
9717 languages we have to, so that we can get at method physnames
9718 to infer fully qualified class names, for DW_AT_specification,
9719 and for C++ template arguments. For C++, we also look one level
9720 inside functions to find template arguments (if the name of the
9721 function does not already contain the template arguments).
9723 For Ada, we need to scan the children of subprograms and lexical
9724 blocks as well because Ada allows the definition of nested
9725 entities that could be interesting for the debugger, such as
9726 nested subprograms for instance. */
9727 if (last_die
->has_children
9729 || last_die
->tag
== DW_TAG_namespace
9730 || last_die
->tag
== DW_TAG_module
9731 || last_die
->tag
== DW_TAG_enumeration_type
9732 || (cu
->language
== language_cplus
9733 && last_die
->tag
== DW_TAG_subprogram
9734 && (last_die
->name
== NULL
9735 || strchr (last_die
->name
, '<') == NULL
))
9736 || (cu
->language
!= language_c
9737 && (last_die
->tag
== DW_TAG_class_type
9738 || last_die
->tag
== DW_TAG_interface_type
9739 || last_die
->tag
== DW_TAG_structure_type
9740 || last_die
->tag
== DW_TAG_union_type
))
9741 || (cu
->language
== language_ada
9742 && (last_die
->tag
== DW_TAG_subprogram
9743 || last_die
->tag
== DW_TAG_lexical_block
))))
9746 parent_die
= last_die
;
9750 /* Otherwise we skip to the next sibling, if any. */
9751 info_ptr
= locate_pdi_sibling (last_die
, buffer
, info_ptr
, abfd
, cu
);
9753 /* Back to the top, do it again. */
9757 /* Read a minimal amount of information into the minimal die structure. */
9760 read_partial_die (struct partial_die_info
*part_die
,
9761 struct abbrev_info
*abbrev
,
9762 unsigned int abbrev_len
, bfd
*abfd
,
9763 gdb_byte
*buffer
, gdb_byte
*info_ptr
,
9764 struct dwarf2_cu
*cu
)
9766 struct objfile
*objfile
= cu
->objfile
;
9768 struct attribute attr
;
9769 int has_low_pc_attr
= 0;
9770 int has_high_pc_attr
= 0;
9772 memset (part_die
, 0, sizeof (struct partial_die_info
));
9774 part_die
->offset
= info_ptr
- buffer
;
9776 info_ptr
+= abbrev_len
;
9781 part_die
->tag
= abbrev
->tag
;
9782 part_die
->has_children
= abbrev
->has_children
;
9784 for (i
= 0; i
< abbrev
->num_attrs
; ++i
)
9786 info_ptr
= read_attribute (&attr
, &abbrev
->attrs
[i
], abfd
, info_ptr
, cu
);
9788 /* Store the data if it is of an attribute we want to keep in a
9789 partial symbol table. */
9793 switch (part_die
->tag
)
9795 case DW_TAG_compile_unit
:
9796 case DW_TAG_type_unit
:
9797 /* Compilation units have a DW_AT_name that is a filename, not
9798 a source language identifier. */
9799 case DW_TAG_enumeration_type
:
9800 case DW_TAG_enumerator
:
9801 /* These tags always have simple identifiers already; no need
9802 to canonicalize them. */
9803 part_die
->name
= DW_STRING (&attr
);
9807 = dwarf2_canonicalize_name (DW_STRING (&attr
), cu
,
9808 &objfile
->objfile_obstack
);
9812 case DW_AT_linkage_name
:
9813 case DW_AT_MIPS_linkage_name
:
9814 /* Note that both forms of linkage name might appear. We
9815 assume they will be the same, and we only store the last
9817 if (cu
->language
== language_ada
)
9818 part_die
->name
= DW_STRING (&attr
);
9819 part_die
->linkage_name
= DW_STRING (&attr
);
9822 has_low_pc_attr
= 1;
9823 part_die
->lowpc
= DW_ADDR (&attr
);
9826 has_high_pc_attr
= 1;
9827 part_die
->highpc
= DW_ADDR (&attr
);
9829 case DW_AT_location
:
9830 /* Support the .debug_loc offsets. */
9831 if (attr_form_is_block (&attr
))
9833 part_die
->locdesc
= DW_BLOCK (&attr
);
9835 else if (attr_form_is_section_offset (&attr
))
9837 dwarf2_complex_location_expr_complaint ();
9841 dwarf2_invalid_attrib_class_complaint ("DW_AT_location",
9842 "partial symbol information");
9845 case DW_AT_external
:
9846 part_die
->is_external
= DW_UNSND (&attr
);
9848 case DW_AT_declaration
:
9849 part_die
->is_declaration
= DW_UNSND (&attr
);
9852 part_die
->has_type
= 1;
9854 case DW_AT_abstract_origin
:
9855 case DW_AT_specification
:
9856 case DW_AT_extension
:
9857 part_die
->has_specification
= 1;
9858 part_die
->spec_offset
= dwarf2_get_ref_die_offset (&attr
);
9861 /* Ignore absolute siblings, they might point outside of
9862 the current compile unit. */
9863 if (attr
.form
== DW_FORM_ref_addr
)
9864 complaint (&symfile_complaints
,
9865 _("ignoring absolute DW_AT_sibling"));
9867 part_die
->sibling
= buffer
+ dwarf2_get_ref_die_offset (&attr
);
9869 case DW_AT_byte_size
:
9870 part_die
->has_byte_size
= 1;
9872 case DW_AT_calling_convention
:
9873 /* DWARF doesn't provide a way to identify a program's source-level
9874 entry point. DW_AT_calling_convention attributes are only meant
9875 to describe functions' calling conventions.
9877 However, because it's a necessary piece of information in
9878 Fortran, and because DW_CC_program is the only piece of debugging
9879 information whose definition refers to a 'main program' at all,
9880 several compilers have begun marking Fortran main programs with
9881 DW_CC_program --- even when those functions use the standard
9882 calling conventions.
9884 So until DWARF specifies a way to provide this information and
9885 compilers pick up the new representation, we'll support this
9887 if (DW_UNSND (&attr
) == DW_CC_program
9888 && cu
->language
== language_fortran
)
9890 set_main_name (part_die
->name
);
9892 /* As this DIE has a static linkage the name would be difficult
9893 to look up later. */
9894 language_of_main
= language_fortran
;
9902 if (has_low_pc_attr
&& has_high_pc_attr
)
9904 /* When using the GNU linker, .gnu.linkonce. sections are used to
9905 eliminate duplicate copies of functions and vtables and such.
9906 The linker will arbitrarily choose one and discard the others.
9907 The AT_*_pc values for such functions refer to local labels in
9908 these sections. If the section from that file was discarded, the
9909 labels are not in the output, so the relocs get a value of 0.
9910 If this is a discarded function, mark the pc bounds as invalid,
9911 so that GDB will ignore it. */
9912 if (part_die
->lowpc
== 0 && !dwarf2_per_objfile
->has_section_at_zero
)
9914 struct gdbarch
*gdbarch
= get_objfile_arch (objfile
);
9916 complaint (&symfile_complaints
,
9917 _("DW_AT_low_pc %s is zero "
9918 "for DIE at 0x%x [in module %s]"),
9919 paddress (gdbarch
, part_die
->lowpc
),
9920 part_die
->offset
, objfile
->name
);
9922 /* dwarf2_get_pc_bounds has also the strict low < high requirement. */
9923 else if (part_die
->lowpc
>= part_die
->highpc
)
9925 struct gdbarch
*gdbarch
= get_objfile_arch (objfile
);
9927 complaint (&symfile_complaints
,
9928 _("DW_AT_low_pc %s is not < DW_AT_high_pc %s "
9929 "for DIE at 0x%x [in module %s]"),
9930 paddress (gdbarch
, part_die
->lowpc
),
9931 paddress (gdbarch
, part_die
->highpc
),
9932 part_die
->offset
, objfile
->name
);
9935 part_die
->has_pc_info
= 1;
9941 /* Find a cached partial DIE at OFFSET in CU. */
9943 static struct partial_die_info
*
9944 find_partial_die_in_comp_unit (unsigned int offset
, struct dwarf2_cu
*cu
)
9946 struct partial_die_info
*lookup_die
= NULL
;
9947 struct partial_die_info part_die
;
9949 part_die
.offset
= offset
;
9950 lookup_die
= htab_find_with_hash (cu
->partial_dies
, &part_die
, offset
);
9955 /* Find a partial DIE at OFFSET, which may or may not be in CU,
9956 except in the case of .debug_types DIEs which do not reference
9957 outside their CU (they do however referencing other types via
9958 DW_FORM_ref_sig8). */
9960 static struct partial_die_info
*
9961 find_partial_die (unsigned int offset
, struct dwarf2_cu
*cu
)
9963 struct objfile
*objfile
= cu
->objfile
;
9964 struct dwarf2_per_cu_data
*per_cu
= NULL
;
9965 struct partial_die_info
*pd
= NULL
;
9967 if (cu
->per_cu
->debug_types_section
)
9969 pd
= find_partial_die_in_comp_unit (offset
, cu
);
9975 if (offset_in_cu_p (&cu
->header
, offset
))
9977 pd
= find_partial_die_in_comp_unit (offset
, cu
);
9982 per_cu
= dwarf2_find_containing_comp_unit (offset
, objfile
);
9984 if (per_cu
->cu
== NULL
|| per_cu
->cu
->partial_dies
== NULL
)
9985 load_partial_comp_unit (per_cu
);
9987 per_cu
->cu
->last_used
= 0;
9988 pd
= find_partial_die_in_comp_unit (offset
, per_cu
->cu
);
9990 if (pd
== NULL
&& per_cu
->load_all_dies
== 0)
9992 struct cleanup
*back_to
;
9993 struct partial_die_info comp_unit_die
;
9994 struct abbrev_info
*abbrev
;
9995 unsigned int bytes_read
;
9998 per_cu
->load_all_dies
= 1;
10000 /* Re-read the DIEs. */
10001 back_to
= make_cleanup (null_cleanup
, 0);
10002 if (per_cu
->cu
->dwarf2_abbrevs
== NULL
)
10004 dwarf2_read_abbrevs (per_cu
->cu
);
10005 make_cleanup (dwarf2_free_abbrev_table
, per_cu
->cu
);
10007 info_ptr
= (dwarf2_per_objfile
->info
.buffer
10008 + per_cu
->cu
->header
.offset
10009 + per_cu
->cu
->header
.first_die_offset
);
10010 abbrev
= peek_die_abbrev (info_ptr
, &bytes_read
, per_cu
->cu
);
10011 info_ptr
= read_partial_die (&comp_unit_die
, abbrev
, bytes_read
,
10013 dwarf2_per_objfile
->info
.buffer
, info_ptr
,
10015 if (comp_unit_die
.has_children
)
10016 load_partial_dies (objfile
->obfd
,
10017 dwarf2_per_objfile
->info
.buffer
, info_ptr
,
10019 do_cleanups (back_to
);
10021 pd
= find_partial_die_in_comp_unit (offset
, per_cu
->cu
);
10027 internal_error (__FILE__
, __LINE__
,
10028 _("could not find partial DIE 0x%x "
10029 "in cache [from module %s]\n"),
10030 offset
, bfd_get_filename (objfile
->obfd
));
10034 /* See if we can figure out if the class lives in a namespace. We do
10035 this by looking for a member function; its demangled name will
10036 contain namespace info, if there is any. */
10039 guess_partial_die_structure_name (struct partial_die_info
*struct_pdi
,
10040 struct dwarf2_cu
*cu
)
10042 /* NOTE: carlton/2003-10-07: Getting the info this way changes
10043 what template types look like, because the demangler
10044 frequently doesn't give the same name as the debug info. We
10045 could fix this by only using the demangled name to get the
10046 prefix (but see comment in read_structure_type). */
10048 struct partial_die_info
*real_pdi
;
10049 struct partial_die_info
*child_pdi
;
10051 /* If this DIE (this DIE's specification, if any) has a parent, then
10052 we should not do this. We'll prepend the parent's fully qualified
10053 name when we create the partial symbol. */
10055 real_pdi
= struct_pdi
;
10056 while (real_pdi
->has_specification
)
10057 real_pdi
= find_partial_die (real_pdi
->spec_offset
, cu
);
10059 if (real_pdi
->die_parent
!= NULL
)
10062 for (child_pdi
= struct_pdi
->die_child
;
10064 child_pdi
= child_pdi
->die_sibling
)
10066 if (child_pdi
->tag
== DW_TAG_subprogram
10067 && child_pdi
->linkage_name
!= NULL
)
10069 char *actual_class_name
10070 = language_class_name_from_physname (cu
->language_defn
,
10071 child_pdi
->linkage_name
);
10072 if (actual_class_name
!= NULL
)
10075 = obsavestring (actual_class_name
,
10076 strlen (actual_class_name
),
10077 &cu
->objfile
->objfile_obstack
);
10078 xfree (actual_class_name
);
10085 /* Adjust PART_DIE before generating a symbol for it. This function
10086 may set the is_external flag or change the DIE's name. */
10089 fixup_partial_die (struct partial_die_info
*part_die
,
10090 struct dwarf2_cu
*cu
)
10092 /* Once we've fixed up a die, there's no point in doing so again.
10093 This also avoids a memory leak if we were to call
10094 guess_partial_die_structure_name multiple times. */
10095 if (part_die
->fixup_called
)
10098 /* If we found a reference attribute and the DIE has no name, try
10099 to find a name in the referred to DIE. */
10101 if (part_die
->name
== NULL
&& part_die
->has_specification
)
10103 struct partial_die_info
*spec_die
;
10105 spec_die
= find_partial_die (part_die
->spec_offset
, cu
);
10107 fixup_partial_die (spec_die
, cu
);
10109 if (spec_die
->name
)
10111 part_die
->name
= spec_die
->name
;
10113 /* Copy DW_AT_external attribute if it is set. */
10114 if (spec_die
->is_external
)
10115 part_die
->is_external
= spec_die
->is_external
;
10119 /* Set default names for some unnamed DIEs. */
10121 if (part_die
->name
== NULL
&& part_die
->tag
== DW_TAG_namespace
)
10122 part_die
->name
= CP_ANONYMOUS_NAMESPACE_STR
;
10124 /* If there is no parent die to provide a namespace, and there are
10125 children, see if we can determine the namespace from their linkage
10127 NOTE: We need to do this even if cu->has_namespace_info != 0.
10128 gcc-4.5 -gdwarf-4 can drop the enclosing namespace. */
10129 if (cu
->language
== language_cplus
10130 && !VEC_empty (dwarf2_section_info_def
, dwarf2_per_objfile
->types
)
10131 && part_die
->die_parent
== NULL
10132 && part_die
->has_children
10133 && (part_die
->tag
== DW_TAG_class_type
10134 || part_die
->tag
== DW_TAG_structure_type
10135 || part_die
->tag
== DW_TAG_union_type
))
10136 guess_partial_die_structure_name (part_die
, cu
);
10138 /* GCC might emit a nameless struct or union that has a linkage
10139 name. See http://gcc.gnu.org/bugzilla/show_bug.cgi?id=47510. */
10140 if (part_die
->name
== NULL
10141 && (part_die
->tag
== DW_TAG_class_type
10142 || part_die
->tag
== DW_TAG_interface_type
10143 || part_die
->tag
== DW_TAG_structure_type
10144 || part_die
->tag
== DW_TAG_union_type
)
10145 && part_die
->linkage_name
!= NULL
)
10149 demangled
= cplus_demangle (part_die
->linkage_name
, DMGL_TYPES
);
10154 /* Strip any leading namespaces/classes, keep only the base name.
10155 DW_AT_name for named DIEs does not contain the prefixes. */
10156 base
= strrchr (demangled
, ':');
10157 if (base
&& base
> demangled
&& base
[-1] == ':')
10162 part_die
->name
= obsavestring (base
, strlen (base
),
10163 &cu
->objfile
->objfile_obstack
);
10168 part_die
->fixup_called
= 1;
10171 /* Read an attribute value described by an attribute form. */
10174 read_attribute_value (struct attribute
*attr
, unsigned form
,
10175 bfd
*abfd
, gdb_byte
*info_ptr
,
10176 struct dwarf2_cu
*cu
)
10178 struct comp_unit_head
*cu_header
= &cu
->header
;
10179 unsigned int bytes_read
;
10180 struct dwarf_block
*blk
;
10185 case DW_FORM_ref_addr
:
10186 if (cu
->header
.version
== 2)
10187 DW_ADDR (attr
) = read_address (abfd
, info_ptr
, cu
, &bytes_read
);
10189 DW_ADDR (attr
) = read_offset (abfd
, info_ptr
,
10190 &cu
->header
, &bytes_read
);
10191 info_ptr
+= bytes_read
;
10194 DW_ADDR (attr
) = read_address (abfd
, info_ptr
, cu
, &bytes_read
);
10195 info_ptr
+= bytes_read
;
10197 case DW_FORM_block2
:
10198 blk
= dwarf_alloc_block (cu
);
10199 blk
->size
= read_2_bytes (abfd
, info_ptr
);
10201 blk
->data
= read_n_bytes (abfd
, info_ptr
, blk
->size
);
10202 info_ptr
+= blk
->size
;
10203 DW_BLOCK (attr
) = blk
;
10205 case DW_FORM_block4
:
10206 blk
= dwarf_alloc_block (cu
);
10207 blk
->size
= read_4_bytes (abfd
, info_ptr
);
10209 blk
->data
= read_n_bytes (abfd
, info_ptr
, blk
->size
);
10210 info_ptr
+= blk
->size
;
10211 DW_BLOCK (attr
) = blk
;
10213 case DW_FORM_data2
:
10214 DW_UNSND (attr
) = read_2_bytes (abfd
, info_ptr
);
10217 case DW_FORM_data4
:
10218 DW_UNSND (attr
) = read_4_bytes (abfd
, info_ptr
);
10221 case DW_FORM_data8
:
10222 DW_UNSND (attr
) = read_8_bytes (abfd
, info_ptr
);
10225 case DW_FORM_sec_offset
:
10226 DW_UNSND (attr
) = read_offset (abfd
, info_ptr
, &cu
->header
, &bytes_read
);
10227 info_ptr
+= bytes_read
;
10229 case DW_FORM_string
:
10230 DW_STRING (attr
) = read_direct_string (abfd
, info_ptr
, &bytes_read
);
10231 DW_STRING_IS_CANONICAL (attr
) = 0;
10232 info_ptr
+= bytes_read
;
10235 DW_STRING (attr
) = read_indirect_string (abfd
, info_ptr
, cu_header
,
10237 DW_STRING_IS_CANONICAL (attr
) = 0;
10238 info_ptr
+= bytes_read
;
10240 case DW_FORM_exprloc
:
10241 case DW_FORM_block
:
10242 blk
= dwarf_alloc_block (cu
);
10243 blk
->size
= read_unsigned_leb128 (abfd
, info_ptr
, &bytes_read
);
10244 info_ptr
+= bytes_read
;
10245 blk
->data
= read_n_bytes (abfd
, info_ptr
, blk
->size
);
10246 info_ptr
+= blk
->size
;
10247 DW_BLOCK (attr
) = blk
;
10249 case DW_FORM_block1
:
10250 blk
= dwarf_alloc_block (cu
);
10251 blk
->size
= read_1_byte (abfd
, info_ptr
);
10253 blk
->data
= read_n_bytes (abfd
, info_ptr
, blk
->size
);
10254 info_ptr
+= blk
->size
;
10255 DW_BLOCK (attr
) = blk
;
10257 case DW_FORM_data1
:
10258 DW_UNSND (attr
) = read_1_byte (abfd
, info_ptr
);
10262 DW_UNSND (attr
) = read_1_byte (abfd
, info_ptr
);
10265 case DW_FORM_flag_present
:
10266 DW_UNSND (attr
) = 1;
10268 case DW_FORM_sdata
:
10269 DW_SND (attr
) = read_signed_leb128 (abfd
, info_ptr
, &bytes_read
);
10270 info_ptr
+= bytes_read
;
10272 case DW_FORM_udata
:
10273 DW_UNSND (attr
) = read_unsigned_leb128 (abfd
, info_ptr
, &bytes_read
);
10274 info_ptr
+= bytes_read
;
10277 DW_ADDR (attr
) = cu
->header
.offset
+ read_1_byte (abfd
, info_ptr
);
10281 DW_ADDR (attr
) = cu
->header
.offset
+ read_2_bytes (abfd
, info_ptr
);
10285 DW_ADDR (attr
) = cu
->header
.offset
+ read_4_bytes (abfd
, info_ptr
);
10289 DW_ADDR (attr
) = cu
->header
.offset
+ read_8_bytes (abfd
, info_ptr
);
10292 case DW_FORM_ref_sig8
:
10293 /* Convert the signature to something we can record in DW_UNSND
10295 NOTE: This is NULL if the type wasn't found. */
10296 DW_SIGNATURED_TYPE (attr
) =
10297 lookup_signatured_type (cu
->objfile
, read_8_bytes (abfd
, info_ptr
));
10300 case DW_FORM_ref_udata
:
10301 DW_ADDR (attr
) = (cu
->header
.offset
10302 + read_unsigned_leb128 (abfd
, info_ptr
, &bytes_read
));
10303 info_ptr
+= bytes_read
;
10305 case DW_FORM_indirect
:
10306 form
= read_unsigned_leb128 (abfd
, info_ptr
, &bytes_read
);
10307 info_ptr
+= bytes_read
;
10308 info_ptr
= read_attribute_value (attr
, form
, abfd
, info_ptr
, cu
);
10311 error (_("Dwarf Error: Cannot handle %s in DWARF reader [in module %s]"),
10312 dwarf_form_name (form
),
10313 bfd_get_filename (abfd
));
10316 /* We have seen instances where the compiler tried to emit a byte
10317 size attribute of -1 which ended up being encoded as an unsigned
10318 0xffffffff. Although 0xffffffff is technically a valid size value,
10319 an object of this size seems pretty unlikely so we can relatively
10320 safely treat these cases as if the size attribute was invalid and
10321 treat them as zero by default. */
10322 if (attr
->name
== DW_AT_byte_size
10323 && form
== DW_FORM_data4
10324 && DW_UNSND (attr
) >= 0xffffffff)
10327 (&symfile_complaints
,
10328 _("Suspicious DW_AT_byte_size value treated as zero instead of %s"),
10329 hex_string (DW_UNSND (attr
)));
10330 DW_UNSND (attr
) = 0;
10336 /* Read an attribute described by an abbreviated attribute. */
10339 read_attribute (struct attribute
*attr
, struct attr_abbrev
*abbrev
,
10340 bfd
*abfd
, gdb_byte
*info_ptr
, struct dwarf2_cu
*cu
)
10342 attr
->name
= abbrev
->name
;
10343 return read_attribute_value (attr
, abbrev
->form
, abfd
, info_ptr
, cu
);
10346 /* Read dwarf information from a buffer. */
10348 static unsigned int
10349 read_1_byte (bfd
*abfd
, gdb_byte
*buf
)
10351 return bfd_get_8 (abfd
, buf
);
10355 read_1_signed_byte (bfd
*abfd
, gdb_byte
*buf
)
10357 return bfd_get_signed_8 (abfd
, buf
);
10360 static unsigned int
10361 read_2_bytes (bfd
*abfd
, gdb_byte
*buf
)
10363 return bfd_get_16 (abfd
, buf
);
10367 read_2_signed_bytes (bfd
*abfd
, gdb_byte
*buf
)
10369 return bfd_get_signed_16 (abfd
, buf
);
10372 static unsigned int
10373 read_4_bytes (bfd
*abfd
, gdb_byte
*buf
)
10375 return bfd_get_32 (abfd
, buf
);
10379 read_4_signed_bytes (bfd
*abfd
, gdb_byte
*buf
)
10381 return bfd_get_signed_32 (abfd
, buf
);
10385 read_8_bytes (bfd
*abfd
, gdb_byte
*buf
)
10387 return bfd_get_64 (abfd
, buf
);
10391 read_address (bfd
*abfd
, gdb_byte
*buf
, struct dwarf2_cu
*cu
,
10392 unsigned int *bytes_read
)
10394 struct comp_unit_head
*cu_header
= &cu
->header
;
10395 CORE_ADDR retval
= 0;
10397 if (cu_header
->signed_addr_p
)
10399 switch (cu_header
->addr_size
)
10402 retval
= bfd_get_signed_16 (abfd
, buf
);
10405 retval
= bfd_get_signed_32 (abfd
, buf
);
10408 retval
= bfd_get_signed_64 (abfd
, buf
);
10411 internal_error (__FILE__
, __LINE__
,
10412 _("read_address: bad switch, signed [in module %s]"),
10413 bfd_get_filename (abfd
));
10418 switch (cu_header
->addr_size
)
10421 retval
= bfd_get_16 (abfd
, buf
);
10424 retval
= bfd_get_32 (abfd
, buf
);
10427 retval
= bfd_get_64 (abfd
, buf
);
10430 internal_error (__FILE__
, __LINE__
,
10431 _("read_address: bad switch, "
10432 "unsigned [in module %s]"),
10433 bfd_get_filename (abfd
));
10437 *bytes_read
= cu_header
->addr_size
;
10441 /* Read the initial length from a section. The (draft) DWARF 3
10442 specification allows the initial length to take up either 4 bytes
10443 or 12 bytes. If the first 4 bytes are 0xffffffff, then the next 8
10444 bytes describe the length and all offsets will be 8 bytes in length
10447 An older, non-standard 64-bit format is also handled by this
10448 function. The older format in question stores the initial length
10449 as an 8-byte quantity without an escape value. Lengths greater
10450 than 2^32 aren't very common which means that the initial 4 bytes
10451 is almost always zero. Since a length value of zero doesn't make
10452 sense for the 32-bit format, this initial zero can be considered to
10453 be an escape value which indicates the presence of the older 64-bit
10454 format. As written, the code can't detect (old format) lengths
10455 greater than 4GB. If it becomes necessary to handle lengths
10456 somewhat larger than 4GB, we could allow other small values (such
10457 as the non-sensical values of 1, 2, and 3) to also be used as
10458 escape values indicating the presence of the old format.
10460 The value returned via bytes_read should be used to increment the
10461 relevant pointer after calling read_initial_length().
10463 [ Note: read_initial_length() and read_offset() are based on the
10464 document entitled "DWARF Debugging Information Format", revision
10465 3, draft 8, dated November 19, 2001. This document was obtained
10468 http://reality.sgiweb.org/davea/dwarf3-draft8-011125.pdf
10470 This document is only a draft and is subject to change. (So beware.)
10472 Details regarding the older, non-standard 64-bit format were
10473 determined empirically by examining 64-bit ELF files produced by
10474 the SGI toolchain on an IRIX 6.5 machine.
10476 - Kevin, July 16, 2002
10480 read_initial_length (bfd
*abfd
, gdb_byte
*buf
, unsigned int *bytes_read
)
10482 LONGEST length
= bfd_get_32 (abfd
, buf
);
10484 if (length
== 0xffffffff)
10486 length
= bfd_get_64 (abfd
, buf
+ 4);
10489 else if (length
== 0)
10491 /* Handle the (non-standard) 64-bit DWARF2 format used by IRIX. */
10492 length
= bfd_get_64 (abfd
, buf
);
10503 /* Cover function for read_initial_length.
10504 Returns the length of the object at BUF, and stores the size of the
10505 initial length in *BYTES_READ and stores the size that offsets will be in
10507 If the initial length size is not equivalent to that specified in
10508 CU_HEADER then issue a complaint.
10509 This is useful when reading non-comp-unit headers. */
10512 read_checked_initial_length_and_offset (bfd
*abfd
, gdb_byte
*buf
,
10513 const struct comp_unit_head
*cu_header
,
10514 unsigned int *bytes_read
,
10515 unsigned int *offset_size
)
10517 LONGEST length
= read_initial_length (abfd
, buf
, bytes_read
);
10519 gdb_assert (cu_header
->initial_length_size
== 4
10520 || cu_header
->initial_length_size
== 8
10521 || cu_header
->initial_length_size
== 12);
10523 if (cu_header
->initial_length_size
!= *bytes_read
)
10524 complaint (&symfile_complaints
,
10525 _("intermixed 32-bit and 64-bit DWARF sections"));
10527 *offset_size
= (*bytes_read
== 4) ? 4 : 8;
10531 /* Read an offset from the data stream. The size of the offset is
10532 given by cu_header->offset_size. */
10535 read_offset (bfd
*abfd
, gdb_byte
*buf
, const struct comp_unit_head
*cu_header
,
10536 unsigned int *bytes_read
)
10538 LONGEST offset
= read_offset_1 (abfd
, buf
, cu_header
->offset_size
);
10540 *bytes_read
= cu_header
->offset_size
;
10544 /* Read an offset from the data stream. */
10547 read_offset_1 (bfd
*abfd
, gdb_byte
*buf
, unsigned int offset_size
)
10549 LONGEST retval
= 0;
10551 switch (offset_size
)
10554 retval
= bfd_get_32 (abfd
, buf
);
10557 retval
= bfd_get_64 (abfd
, buf
);
10560 internal_error (__FILE__
, __LINE__
,
10561 _("read_offset_1: bad switch [in module %s]"),
10562 bfd_get_filename (abfd
));
10569 read_n_bytes (bfd
*abfd
, gdb_byte
*buf
, unsigned int size
)
10571 /* If the size of a host char is 8 bits, we can return a pointer
10572 to the buffer, otherwise we have to copy the data to a buffer
10573 allocated on the temporary obstack. */
10574 gdb_assert (HOST_CHAR_BIT
== 8);
10579 read_direct_string (bfd
*abfd
, gdb_byte
*buf
, unsigned int *bytes_read_ptr
)
10581 /* If the size of a host char is 8 bits, we can return a pointer
10582 to the string, otherwise we have to copy the string to a buffer
10583 allocated on the temporary obstack. */
10584 gdb_assert (HOST_CHAR_BIT
== 8);
10587 *bytes_read_ptr
= 1;
10590 *bytes_read_ptr
= strlen ((char *) buf
) + 1;
10591 return (char *) buf
;
10595 read_indirect_string_at_offset (bfd
*abfd
, LONGEST str_offset
)
10597 dwarf2_read_section (dwarf2_per_objfile
->objfile
, &dwarf2_per_objfile
->str
);
10598 if (dwarf2_per_objfile
->str
.buffer
== NULL
)
10599 error (_("DW_FORM_strp used without .debug_str section [in module %s]"),
10600 bfd_get_filename (abfd
));
10601 if (str_offset
>= dwarf2_per_objfile
->str
.size
)
10602 error (_("DW_FORM_strp pointing outside of "
10603 ".debug_str section [in module %s]"),
10604 bfd_get_filename (abfd
));
10605 gdb_assert (HOST_CHAR_BIT
== 8);
10606 if (dwarf2_per_objfile
->str
.buffer
[str_offset
] == '\0')
10608 return (char *) (dwarf2_per_objfile
->str
.buffer
+ str_offset
);
10612 read_indirect_string (bfd
*abfd
, gdb_byte
*buf
,
10613 const struct comp_unit_head
*cu_header
,
10614 unsigned int *bytes_read_ptr
)
10616 LONGEST str_offset
= read_offset (abfd
, buf
, cu_header
, bytes_read_ptr
);
10618 return read_indirect_string_at_offset (abfd
, str_offset
);
10621 static unsigned long
10622 read_unsigned_leb128 (bfd
*abfd
, gdb_byte
*buf
, unsigned int *bytes_read_ptr
)
10624 unsigned long result
;
10625 unsigned int num_read
;
10627 unsigned char byte
;
10635 byte
= bfd_get_8 (abfd
, buf
);
10638 result
|= ((unsigned long)(byte
& 127) << shift
);
10639 if ((byte
& 128) == 0)
10645 *bytes_read_ptr
= num_read
;
10650 read_signed_leb128 (bfd
*abfd
, gdb_byte
*buf
, unsigned int *bytes_read_ptr
)
10653 int i
, shift
, num_read
;
10654 unsigned char byte
;
10662 byte
= bfd_get_8 (abfd
, buf
);
10665 result
|= ((long)(byte
& 127) << shift
);
10667 if ((byte
& 128) == 0)
10672 if ((shift
< 8 * sizeof (result
)) && (byte
& 0x40))
10673 result
|= -(((long)1) << shift
);
10674 *bytes_read_ptr
= num_read
;
10678 /* Return a pointer to just past the end of an LEB128 number in BUF. */
10681 skip_leb128 (bfd
*abfd
, gdb_byte
*buf
)
10687 byte
= bfd_get_8 (abfd
, buf
);
10689 if ((byte
& 128) == 0)
10695 set_cu_language (unsigned int lang
, struct dwarf2_cu
*cu
)
10702 cu
->language
= language_c
;
10704 case DW_LANG_C_plus_plus
:
10705 cu
->language
= language_cplus
;
10708 cu
->language
= language_d
;
10710 case DW_LANG_Fortran77
:
10711 case DW_LANG_Fortran90
:
10712 case DW_LANG_Fortran95
:
10713 cu
->language
= language_fortran
;
10715 case DW_LANG_Mips_Assembler
:
10716 cu
->language
= language_asm
;
10719 cu
->language
= language_java
;
10721 case DW_LANG_Ada83
:
10722 case DW_LANG_Ada95
:
10723 cu
->language
= language_ada
;
10725 case DW_LANG_Modula2
:
10726 cu
->language
= language_m2
;
10728 case DW_LANG_Pascal83
:
10729 cu
->language
= language_pascal
;
10732 cu
->language
= language_objc
;
10734 case DW_LANG_Cobol74
:
10735 case DW_LANG_Cobol85
:
10737 cu
->language
= language_minimal
;
10740 cu
->language_defn
= language_def (cu
->language
);
10743 /* Return the named attribute or NULL if not there. */
10745 static struct attribute
*
10746 dwarf2_attr (struct die_info
*die
, unsigned int name
, struct dwarf2_cu
*cu
)
10749 struct attribute
*spec
= NULL
;
10751 for (i
= 0; i
< die
->num_attrs
; ++i
)
10753 if (die
->attrs
[i
].name
== name
)
10754 return &die
->attrs
[i
];
10755 if (die
->attrs
[i
].name
== DW_AT_specification
10756 || die
->attrs
[i
].name
== DW_AT_abstract_origin
)
10757 spec
= &die
->attrs
[i
];
10762 die
= follow_die_ref (die
, spec
, &cu
);
10763 return dwarf2_attr (die
, name
, cu
);
10769 /* Return the named attribute or NULL if not there,
10770 but do not follow DW_AT_specification, etc.
10771 This is for use in contexts where we're reading .debug_types dies.
10772 Following DW_AT_specification, DW_AT_abstract_origin will take us
10773 back up the chain, and we want to go down. */
10775 static struct attribute
*
10776 dwarf2_attr_no_follow (struct die_info
*die
, unsigned int name
,
10777 struct dwarf2_cu
*cu
)
10781 for (i
= 0; i
< die
->num_attrs
; ++i
)
10782 if (die
->attrs
[i
].name
== name
)
10783 return &die
->attrs
[i
];
10788 /* Return non-zero iff the attribute NAME is defined for the given DIE,
10789 and holds a non-zero value. This function should only be used for
10790 DW_FORM_flag or DW_FORM_flag_present attributes. */
10793 dwarf2_flag_true_p (struct die_info
*die
, unsigned name
, struct dwarf2_cu
*cu
)
10795 struct attribute
*attr
= dwarf2_attr (die
, name
, cu
);
10797 return (attr
&& DW_UNSND (attr
));
10801 die_is_declaration (struct die_info
*die
, struct dwarf2_cu
*cu
)
10803 /* A DIE is a declaration if it has a DW_AT_declaration attribute
10804 which value is non-zero. However, we have to be careful with
10805 DIEs having a DW_AT_specification attribute, because dwarf2_attr()
10806 (via dwarf2_flag_true_p) follows this attribute. So we may
10807 end up accidently finding a declaration attribute that belongs
10808 to a different DIE referenced by the specification attribute,
10809 even though the given DIE does not have a declaration attribute. */
10810 return (dwarf2_flag_true_p (die
, DW_AT_declaration
, cu
)
10811 && dwarf2_attr (die
, DW_AT_specification
, cu
) == NULL
);
10814 /* Return the die giving the specification for DIE, if there is
10815 one. *SPEC_CU is the CU containing DIE on input, and the CU
10816 containing the return value on output. If there is no
10817 specification, but there is an abstract origin, that is
10820 static struct die_info
*
10821 die_specification (struct die_info
*die
, struct dwarf2_cu
**spec_cu
)
10823 struct attribute
*spec_attr
= dwarf2_attr (die
, DW_AT_specification
,
10826 if (spec_attr
== NULL
)
10827 spec_attr
= dwarf2_attr (die
, DW_AT_abstract_origin
, *spec_cu
);
10829 if (spec_attr
== NULL
)
10832 return follow_die_ref (die
, spec_attr
, spec_cu
);
10835 /* Free the line_header structure *LH, and any arrays and strings it
10837 NOTE: This is also used as a "cleanup" function. */
10840 free_line_header (struct line_header
*lh
)
10842 if (lh
->standard_opcode_lengths
)
10843 xfree (lh
->standard_opcode_lengths
);
10845 /* Remember that all the lh->file_names[i].name pointers are
10846 pointers into debug_line_buffer, and don't need to be freed. */
10847 if (lh
->file_names
)
10848 xfree (lh
->file_names
);
10850 /* Similarly for the include directory names. */
10851 if (lh
->include_dirs
)
10852 xfree (lh
->include_dirs
);
10857 /* Add an entry to LH's include directory table. */
10860 add_include_dir (struct line_header
*lh
, char *include_dir
)
10862 /* Grow the array if necessary. */
10863 if (lh
->include_dirs_size
== 0)
10865 lh
->include_dirs_size
= 1; /* for testing */
10866 lh
->include_dirs
= xmalloc (lh
->include_dirs_size
10867 * sizeof (*lh
->include_dirs
));
10869 else if (lh
->num_include_dirs
>= lh
->include_dirs_size
)
10871 lh
->include_dirs_size
*= 2;
10872 lh
->include_dirs
= xrealloc (lh
->include_dirs
,
10873 (lh
->include_dirs_size
10874 * sizeof (*lh
->include_dirs
)));
10877 lh
->include_dirs
[lh
->num_include_dirs
++] = include_dir
;
10880 /* Add an entry to LH's file name table. */
10883 add_file_name (struct line_header
*lh
,
10885 unsigned int dir_index
,
10886 unsigned int mod_time
,
10887 unsigned int length
)
10889 struct file_entry
*fe
;
10891 /* Grow the array if necessary. */
10892 if (lh
->file_names_size
== 0)
10894 lh
->file_names_size
= 1; /* for testing */
10895 lh
->file_names
= xmalloc (lh
->file_names_size
10896 * sizeof (*lh
->file_names
));
10898 else if (lh
->num_file_names
>= lh
->file_names_size
)
10900 lh
->file_names_size
*= 2;
10901 lh
->file_names
= xrealloc (lh
->file_names
,
10902 (lh
->file_names_size
10903 * sizeof (*lh
->file_names
)));
10906 fe
= &lh
->file_names
[lh
->num_file_names
++];
10908 fe
->dir_index
= dir_index
;
10909 fe
->mod_time
= mod_time
;
10910 fe
->length
= length
;
10911 fe
->included_p
= 0;
10915 /* Read the statement program header starting at OFFSET in
10916 .debug_line, according to the endianness of ABFD. Return a pointer
10917 to a struct line_header, allocated using xmalloc.
10919 NOTE: the strings in the include directory and file name tables of
10920 the returned object point into debug_line_buffer, and must not be
10923 static struct line_header
*
10924 dwarf_decode_line_header (unsigned int offset
, bfd
*abfd
,
10925 struct dwarf2_cu
*cu
)
10927 struct cleanup
*back_to
;
10928 struct line_header
*lh
;
10929 gdb_byte
*line_ptr
;
10930 unsigned int bytes_read
, offset_size
;
10932 char *cur_dir
, *cur_file
;
10934 dwarf2_read_section (dwarf2_per_objfile
->objfile
, &dwarf2_per_objfile
->line
);
10935 if (dwarf2_per_objfile
->line
.buffer
== NULL
)
10937 complaint (&symfile_complaints
, _("missing .debug_line section"));
10941 /* Make sure that at least there's room for the total_length field.
10942 That could be 12 bytes long, but we're just going to fudge that. */
10943 if (offset
+ 4 >= dwarf2_per_objfile
->line
.size
)
10945 dwarf2_statement_list_fits_in_line_number_section_complaint ();
10949 lh
= xmalloc (sizeof (*lh
));
10950 memset (lh
, 0, sizeof (*lh
));
10951 back_to
= make_cleanup ((make_cleanup_ftype
*) free_line_header
,
10954 line_ptr
= dwarf2_per_objfile
->line
.buffer
+ offset
;
10956 /* Read in the header. */
10958 read_checked_initial_length_and_offset (abfd
, line_ptr
, &cu
->header
,
10959 &bytes_read
, &offset_size
);
10960 line_ptr
+= bytes_read
;
10961 if (line_ptr
+ lh
->total_length
> (dwarf2_per_objfile
->line
.buffer
10962 + dwarf2_per_objfile
->line
.size
))
10964 dwarf2_statement_list_fits_in_line_number_section_complaint ();
10967 lh
->statement_program_end
= line_ptr
+ lh
->total_length
;
10968 lh
->version
= read_2_bytes (abfd
, line_ptr
);
10970 lh
->header_length
= read_offset_1 (abfd
, line_ptr
, offset_size
);
10971 line_ptr
+= offset_size
;
10972 lh
->minimum_instruction_length
= read_1_byte (abfd
, line_ptr
);
10974 if (lh
->version
>= 4)
10976 lh
->maximum_ops_per_instruction
= read_1_byte (abfd
, line_ptr
);
10980 lh
->maximum_ops_per_instruction
= 1;
10982 if (lh
->maximum_ops_per_instruction
== 0)
10984 lh
->maximum_ops_per_instruction
= 1;
10985 complaint (&symfile_complaints
,
10986 _("invalid maximum_ops_per_instruction "
10987 "in `.debug_line' section"));
10990 lh
->default_is_stmt
= read_1_byte (abfd
, line_ptr
);
10992 lh
->line_base
= read_1_signed_byte (abfd
, line_ptr
);
10994 lh
->line_range
= read_1_byte (abfd
, line_ptr
);
10996 lh
->opcode_base
= read_1_byte (abfd
, line_ptr
);
10998 lh
->standard_opcode_lengths
10999 = xmalloc (lh
->opcode_base
* sizeof (lh
->standard_opcode_lengths
[0]));
11001 lh
->standard_opcode_lengths
[0] = 1; /* This should never be used anyway. */
11002 for (i
= 1; i
< lh
->opcode_base
; ++i
)
11004 lh
->standard_opcode_lengths
[i
] = read_1_byte (abfd
, line_ptr
);
11008 /* Read directory table. */
11009 while ((cur_dir
= read_direct_string (abfd
, line_ptr
, &bytes_read
)) != NULL
)
11011 line_ptr
+= bytes_read
;
11012 add_include_dir (lh
, cur_dir
);
11014 line_ptr
+= bytes_read
;
11016 /* Read file name table. */
11017 while ((cur_file
= read_direct_string (abfd
, line_ptr
, &bytes_read
)) != NULL
)
11019 unsigned int dir_index
, mod_time
, length
;
11021 line_ptr
+= bytes_read
;
11022 dir_index
= read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
11023 line_ptr
+= bytes_read
;
11024 mod_time
= read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
11025 line_ptr
+= bytes_read
;
11026 length
= read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
11027 line_ptr
+= bytes_read
;
11029 add_file_name (lh
, cur_file
, dir_index
, mod_time
, length
);
11031 line_ptr
+= bytes_read
;
11032 lh
->statement_program_start
= line_ptr
;
11034 if (line_ptr
> (dwarf2_per_objfile
->line
.buffer
11035 + dwarf2_per_objfile
->line
.size
))
11036 complaint (&symfile_complaints
,
11037 _("line number info header doesn't "
11038 "fit in `.debug_line' section"));
11040 discard_cleanups (back_to
);
11044 /* Subroutine of dwarf_decode_lines to simplify it.
11045 Return the file name of the psymtab for included file FILE_INDEX
11046 in line header LH of PST.
11047 COMP_DIR is the compilation directory (DW_AT_comp_dir) or NULL if unknown.
11048 If space for the result is malloc'd, it will be freed by a cleanup.
11049 Returns NULL if FILE_INDEX should be ignored, i.e., it is pst->filename. */
11052 psymtab_include_file_name (const struct line_header
*lh
, int file_index
,
11053 const struct partial_symtab
*pst
,
11054 const char *comp_dir
)
11056 const struct file_entry fe
= lh
->file_names
[file_index
];
11057 char *include_name
= fe
.name
;
11058 char *include_name_to_compare
= include_name
;
11059 char *dir_name
= NULL
;
11060 const char *pst_filename
;
11061 char *copied_name
= NULL
;
11065 dir_name
= lh
->include_dirs
[fe
.dir_index
- 1];
11067 if (!IS_ABSOLUTE_PATH (include_name
)
11068 && (dir_name
!= NULL
|| comp_dir
!= NULL
))
11070 /* Avoid creating a duplicate psymtab for PST.
11071 We do this by comparing INCLUDE_NAME and PST_FILENAME.
11072 Before we do the comparison, however, we need to account
11073 for DIR_NAME and COMP_DIR.
11074 First prepend dir_name (if non-NULL). If we still don't
11075 have an absolute path prepend comp_dir (if non-NULL).
11076 However, the directory we record in the include-file's
11077 psymtab does not contain COMP_DIR (to match the
11078 corresponding symtab(s)).
11083 bash$ gcc -g ./hello.c
11084 include_name = "hello.c"
11086 DW_AT_comp_dir = comp_dir = "/tmp"
11087 DW_AT_name = "./hello.c" */
11089 if (dir_name
!= NULL
)
11091 include_name
= concat (dir_name
, SLASH_STRING
,
11092 include_name
, (char *)NULL
);
11093 include_name_to_compare
= include_name
;
11094 make_cleanup (xfree
, include_name
);
11096 if (!IS_ABSOLUTE_PATH (include_name
) && comp_dir
!= NULL
)
11098 include_name_to_compare
= concat (comp_dir
, SLASH_STRING
,
11099 include_name
, (char *)NULL
);
11103 pst_filename
= pst
->filename
;
11104 if (!IS_ABSOLUTE_PATH (pst_filename
) && pst
->dirname
!= NULL
)
11106 copied_name
= concat (pst
->dirname
, SLASH_STRING
,
11107 pst_filename
, (char *)NULL
);
11108 pst_filename
= copied_name
;
11111 file_is_pst
= FILENAME_CMP (include_name_to_compare
, pst_filename
) == 0;
11113 if (include_name_to_compare
!= include_name
)
11114 xfree (include_name_to_compare
);
11115 if (copied_name
!= NULL
)
11116 xfree (copied_name
);
11120 return include_name
;
11123 /* Ignore this record_line request. */
11126 noop_record_line (struct subfile
*subfile
, int line
, CORE_ADDR pc
)
11131 /* Decode the Line Number Program (LNP) for the given line_header
11132 structure and CU. The actual information extracted and the type
11133 of structures created from the LNP depends on the value of PST.
11135 1. If PST is NULL, then this procedure uses the data from the program
11136 to create all necessary symbol tables, and their linetables.
11138 2. If PST is not NULL, this procedure reads the program to determine
11139 the list of files included by the unit represented by PST, and
11140 builds all the associated partial symbol tables.
11142 COMP_DIR is the compilation directory (DW_AT_comp_dir) or NULL if unknown.
11143 It is used for relative paths in the line table.
11144 NOTE: When processing partial symtabs (pst != NULL),
11145 comp_dir == pst->dirname.
11147 NOTE: It is important that psymtabs have the same file name (via strcmp)
11148 as the corresponding symtab. Since COMP_DIR is not used in the name of the
11149 symtab we don't use it in the name of the psymtabs we create.
11150 E.g. expand_line_sal requires this when finding psymtabs to expand.
11151 A good testcase for this is mb-inline.exp. */
11154 dwarf_decode_lines (struct line_header
*lh
, const char *comp_dir
, bfd
*abfd
,
11155 struct dwarf2_cu
*cu
, struct partial_symtab
*pst
)
11157 gdb_byte
*line_ptr
, *extended_end
;
11158 gdb_byte
*line_end
;
11159 unsigned int bytes_read
, extended_len
;
11160 unsigned char op_code
, extended_op
, adj_opcode
;
11161 CORE_ADDR baseaddr
;
11162 struct objfile
*objfile
= cu
->objfile
;
11163 struct gdbarch
*gdbarch
= get_objfile_arch (objfile
);
11164 const int decode_for_pst_p
= (pst
!= NULL
);
11165 struct subfile
*last_subfile
= NULL
, *first_subfile
= current_subfile
;
11166 void (*p_record_line
) (struct subfile
*subfile
, int line
, CORE_ADDR pc
)
11169 baseaddr
= ANOFFSET (objfile
->section_offsets
, SECT_OFF_TEXT (objfile
));
11171 line_ptr
= lh
->statement_program_start
;
11172 line_end
= lh
->statement_program_end
;
11174 /* Read the statement sequences until there's nothing left. */
11175 while (line_ptr
< line_end
)
11177 /* state machine registers */
11178 CORE_ADDR address
= 0;
11179 unsigned int file
= 1;
11180 unsigned int line
= 1;
11181 unsigned int column
= 0;
11182 int is_stmt
= lh
->default_is_stmt
;
11183 int basic_block
= 0;
11184 int end_sequence
= 0;
11186 unsigned char op_index
= 0;
11188 if (!decode_for_pst_p
&& lh
->num_file_names
>= file
)
11190 /* Start a subfile for the current file of the state machine. */
11191 /* lh->include_dirs and lh->file_names are 0-based, but the
11192 directory and file name numbers in the statement program
11194 struct file_entry
*fe
= &lh
->file_names
[file
- 1];
11198 dir
= lh
->include_dirs
[fe
->dir_index
- 1];
11200 dwarf2_start_subfile (fe
->name
, dir
, comp_dir
);
11203 /* Decode the table. */
11204 while (!end_sequence
)
11206 op_code
= read_1_byte (abfd
, line_ptr
);
11208 if (line_ptr
> line_end
)
11210 dwarf2_debug_line_missing_end_sequence_complaint ();
11214 if (op_code
>= lh
->opcode_base
)
11216 /* Special operand. */
11217 adj_opcode
= op_code
- lh
->opcode_base
;
11218 address
+= (((op_index
+ (adj_opcode
/ lh
->line_range
))
11219 / lh
->maximum_ops_per_instruction
)
11220 * lh
->minimum_instruction_length
);
11221 op_index
= ((op_index
+ (adj_opcode
/ lh
->line_range
))
11222 % lh
->maximum_ops_per_instruction
);
11223 line
+= lh
->line_base
+ (adj_opcode
% lh
->line_range
);
11224 if (lh
->num_file_names
< file
|| file
== 0)
11225 dwarf2_debug_line_missing_file_complaint ();
11226 /* For now we ignore lines not starting on an
11227 instruction boundary. */
11228 else if (op_index
== 0)
11230 lh
->file_names
[file
- 1].included_p
= 1;
11231 if (!decode_for_pst_p
&& is_stmt
)
11233 if (last_subfile
!= current_subfile
)
11235 addr
= gdbarch_addr_bits_remove (gdbarch
, address
);
11237 (*p_record_line
) (last_subfile
, 0, addr
);
11238 last_subfile
= current_subfile
;
11240 /* Append row to matrix using current values. */
11241 addr
= gdbarch_addr_bits_remove (gdbarch
, address
);
11242 (*p_record_line
) (current_subfile
, line
, addr
);
11247 else switch (op_code
)
11249 case DW_LNS_extended_op
:
11250 extended_len
= read_unsigned_leb128 (abfd
, line_ptr
,
11252 line_ptr
+= bytes_read
;
11253 extended_end
= line_ptr
+ extended_len
;
11254 extended_op
= read_1_byte (abfd
, line_ptr
);
11256 switch (extended_op
)
11258 case DW_LNE_end_sequence
:
11259 p_record_line
= record_line
;
11262 case DW_LNE_set_address
:
11263 address
= read_address (abfd
, line_ptr
, cu
, &bytes_read
);
11265 if (address
== 0 && !dwarf2_per_objfile
->has_section_at_zero
)
11267 /* This line table is for a function which has been
11268 GCd by the linker. Ignore it. PR gdb/12528 */
11271 = line_ptr
- dwarf2_per_objfile
->line
.buffer
;
11273 complaint (&symfile_complaints
,
11274 _(".debug_line address at offset 0x%lx is 0 "
11276 line_offset
, objfile
->name
);
11277 p_record_line
= noop_record_line
;
11281 line_ptr
+= bytes_read
;
11282 address
+= baseaddr
;
11284 case DW_LNE_define_file
:
11287 unsigned int dir_index
, mod_time
, length
;
11289 cur_file
= read_direct_string (abfd
, line_ptr
,
11291 line_ptr
+= bytes_read
;
11293 read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
11294 line_ptr
+= bytes_read
;
11296 read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
11297 line_ptr
+= bytes_read
;
11299 read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
11300 line_ptr
+= bytes_read
;
11301 add_file_name (lh
, cur_file
, dir_index
, mod_time
, length
);
11304 case DW_LNE_set_discriminator
:
11305 /* The discriminator is not interesting to the debugger;
11307 line_ptr
= extended_end
;
11310 complaint (&symfile_complaints
,
11311 _("mangled .debug_line section"));
11314 /* Make sure that we parsed the extended op correctly. If e.g.
11315 we expected a different address size than the producer used,
11316 we may have read the wrong number of bytes. */
11317 if (line_ptr
!= extended_end
)
11319 complaint (&symfile_complaints
,
11320 _("mangled .debug_line section"));
11325 if (lh
->num_file_names
< file
|| file
== 0)
11326 dwarf2_debug_line_missing_file_complaint ();
11329 lh
->file_names
[file
- 1].included_p
= 1;
11330 if (!decode_for_pst_p
&& is_stmt
)
11332 if (last_subfile
!= current_subfile
)
11334 addr
= gdbarch_addr_bits_remove (gdbarch
, address
);
11336 (*p_record_line
) (last_subfile
, 0, addr
);
11337 last_subfile
= current_subfile
;
11339 addr
= gdbarch_addr_bits_remove (gdbarch
, address
);
11340 (*p_record_line
) (current_subfile
, line
, addr
);
11345 case DW_LNS_advance_pc
:
11348 = read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
11350 address
+= (((op_index
+ adjust
)
11351 / lh
->maximum_ops_per_instruction
)
11352 * lh
->minimum_instruction_length
);
11353 op_index
= ((op_index
+ adjust
)
11354 % lh
->maximum_ops_per_instruction
);
11355 line_ptr
+= bytes_read
;
11358 case DW_LNS_advance_line
:
11359 line
+= read_signed_leb128 (abfd
, line_ptr
, &bytes_read
);
11360 line_ptr
+= bytes_read
;
11362 case DW_LNS_set_file
:
11364 /* The arrays lh->include_dirs and lh->file_names are
11365 0-based, but the directory and file name numbers in
11366 the statement program are 1-based. */
11367 struct file_entry
*fe
;
11370 file
= read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
11371 line_ptr
+= bytes_read
;
11372 if (lh
->num_file_names
< file
|| file
== 0)
11373 dwarf2_debug_line_missing_file_complaint ();
11376 fe
= &lh
->file_names
[file
- 1];
11378 dir
= lh
->include_dirs
[fe
->dir_index
- 1];
11379 if (!decode_for_pst_p
)
11381 last_subfile
= current_subfile
;
11382 dwarf2_start_subfile (fe
->name
, dir
, comp_dir
);
11387 case DW_LNS_set_column
:
11388 column
= read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
11389 line_ptr
+= bytes_read
;
11391 case DW_LNS_negate_stmt
:
11392 is_stmt
= (!is_stmt
);
11394 case DW_LNS_set_basic_block
:
11397 /* Add to the address register of the state machine the
11398 address increment value corresponding to special opcode
11399 255. I.e., this value is scaled by the minimum
11400 instruction length since special opcode 255 would have
11401 scaled the increment. */
11402 case DW_LNS_const_add_pc
:
11404 CORE_ADDR adjust
= (255 - lh
->opcode_base
) / lh
->line_range
;
11406 address
+= (((op_index
+ adjust
)
11407 / lh
->maximum_ops_per_instruction
)
11408 * lh
->minimum_instruction_length
);
11409 op_index
= ((op_index
+ adjust
)
11410 % lh
->maximum_ops_per_instruction
);
11413 case DW_LNS_fixed_advance_pc
:
11414 address
+= read_2_bytes (abfd
, line_ptr
);
11420 /* Unknown standard opcode, ignore it. */
11423 for (i
= 0; i
< lh
->standard_opcode_lengths
[op_code
]; i
++)
11425 (void) read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
11426 line_ptr
+= bytes_read
;
11431 if (lh
->num_file_names
< file
|| file
== 0)
11432 dwarf2_debug_line_missing_file_complaint ();
11435 lh
->file_names
[file
- 1].included_p
= 1;
11436 if (!decode_for_pst_p
)
11438 addr
= gdbarch_addr_bits_remove (gdbarch
, address
);
11439 (*p_record_line
) (current_subfile
, 0, addr
);
11444 if (decode_for_pst_p
)
11448 /* Now that we're done scanning the Line Header Program, we can
11449 create the psymtab of each included file. */
11450 for (file_index
= 0; file_index
< lh
->num_file_names
; file_index
++)
11451 if (lh
->file_names
[file_index
].included_p
== 1)
11453 char *include_name
=
11454 psymtab_include_file_name (lh
, file_index
, pst
, comp_dir
);
11455 if (include_name
!= NULL
)
11456 dwarf2_create_include_psymtab (include_name
, pst
, objfile
);
11461 /* Make sure a symtab is created for every file, even files
11462 which contain only variables (i.e. no code with associated
11466 struct file_entry
*fe
;
11468 for (i
= 0; i
< lh
->num_file_names
; i
++)
11472 fe
= &lh
->file_names
[i
];
11474 dir
= lh
->include_dirs
[fe
->dir_index
- 1];
11475 dwarf2_start_subfile (fe
->name
, dir
, comp_dir
);
11477 /* Skip the main file; we don't need it, and it must be
11478 allocated last, so that it will show up before the
11479 non-primary symtabs in the objfile's symtab list. */
11480 if (current_subfile
== first_subfile
)
11483 if (current_subfile
->symtab
== NULL
)
11484 current_subfile
->symtab
= allocate_symtab (current_subfile
->name
,
11486 fe
->symtab
= current_subfile
->symtab
;
11491 /* Start a subfile for DWARF. FILENAME is the name of the file and
11492 DIRNAME the name of the source directory which contains FILENAME
11493 or NULL if not known. COMP_DIR is the compilation directory for the
11494 linetable's compilation unit or NULL if not known.
11495 This routine tries to keep line numbers from identical absolute and
11496 relative file names in a common subfile.
11498 Using the `list' example from the GDB testsuite, which resides in
11499 /srcdir and compiling it with Irix6.2 cc in /compdir using a filename
11500 of /srcdir/list0.c yields the following debugging information for list0.c:
11502 DW_AT_name: /srcdir/list0.c
11503 DW_AT_comp_dir: /compdir
11504 files.files[0].name: list0.h
11505 files.files[0].dir: /srcdir
11506 files.files[1].name: list0.c
11507 files.files[1].dir: /srcdir
11509 The line number information for list0.c has to end up in a single
11510 subfile, so that `break /srcdir/list0.c:1' works as expected.
11511 start_subfile will ensure that this happens provided that we pass the
11512 concatenation of files.files[1].dir and files.files[1].name as the
11516 dwarf2_start_subfile (char *filename
, const char *dirname
,
11517 const char *comp_dir
)
11521 /* While reading the DIEs, we call start_symtab(DW_AT_name, DW_AT_comp_dir).
11522 `start_symtab' will always pass the contents of DW_AT_comp_dir as
11523 second argument to start_subfile. To be consistent, we do the
11524 same here. In order not to lose the line information directory,
11525 we concatenate it to the filename when it makes sense.
11526 Note that the Dwarf3 standard says (speaking of filenames in line
11527 information): ``The directory index is ignored for file names
11528 that represent full path names''. Thus ignoring dirname in the
11529 `else' branch below isn't an issue. */
11531 if (!IS_ABSOLUTE_PATH (filename
) && dirname
!= NULL
)
11532 fullname
= concat (dirname
, SLASH_STRING
, filename
, (char *)NULL
);
11534 fullname
= filename
;
11536 start_subfile (fullname
, comp_dir
);
11538 if (fullname
!= filename
)
11543 var_decode_location (struct attribute
*attr
, struct symbol
*sym
,
11544 struct dwarf2_cu
*cu
)
11546 struct objfile
*objfile
= cu
->objfile
;
11547 struct comp_unit_head
*cu_header
= &cu
->header
;
11549 /* NOTE drow/2003-01-30: There used to be a comment and some special
11550 code here to turn a symbol with DW_AT_external and a
11551 SYMBOL_VALUE_ADDRESS of 0 into a LOC_UNRESOLVED symbol. This was
11552 necessary for platforms (maybe Alpha, certainly PowerPC GNU/Linux
11553 with some versions of binutils) where shared libraries could have
11554 relocations against symbols in their debug information - the
11555 minimal symbol would have the right address, but the debug info
11556 would not. It's no longer necessary, because we will explicitly
11557 apply relocations when we read in the debug information now. */
11559 /* A DW_AT_location attribute with no contents indicates that a
11560 variable has been optimized away. */
11561 if (attr_form_is_block (attr
) && DW_BLOCK (attr
)->size
== 0)
11563 SYMBOL_CLASS (sym
) = LOC_OPTIMIZED_OUT
;
11567 /* Handle one degenerate form of location expression specially, to
11568 preserve GDB's previous behavior when section offsets are
11569 specified. If this is just a DW_OP_addr then mark this symbol
11572 if (attr_form_is_block (attr
)
11573 && DW_BLOCK (attr
)->size
== 1 + cu_header
->addr_size
11574 && DW_BLOCK (attr
)->data
[0] == DW_OP_addr
)
11576 unsigned int dummy
;
11578 SYMBOL_VALUE_ADDRESS (sym
) =
11579 read_address (objfile
->obfd
, DW_BLOCK (attr
)->data
+ 1, cu
, &dummy
);
11580 SYMBOL_CLASS (sym
) = LOC_STATIC
;
11581 fixup_symbol_section (sym
, objfile
);
11582 SYMBOL_VALUE_ADDRESS (sym
) += ANOFFSET (objfile
->section_offsets
,
11583 SYMBOL_SECTION (sym
));
11587 /* NOTE drow/2002-01-30: It might be worthwhile to have a static
11588 expression evaluator, and use LOC_COMPUTED only when necessary
11589 (i.e. when the value of a register or memory location is
11590 referenced, or a thread-local block, etc.). Then again, it might
11591 not be worthwhile. I'm assuming that it isn't unless performance
11592 or memory numbers show me otherwise. */
11594 dwarf2_symbol_mark_computed (attr
, sym
, cu
);
11595 SYMBOL_CLASS (sym
) = LOC_COMPUTED
;
11597 if (SYMBOL_COMPUTED_OPS (sym
) == &dwarf2_loclist_funcs
)
11598 cu
->has_loclist
= 1;
11601 /* Given a pointer to a DWARF information entry, figure out if we need
11602 to make a symbol table entry for it, and if so, create a new entry
11603 and return a pointer to it.
11604 If TYPE is NULL, determine symbol type from the die, otherwise
11605 used the passed type.
11606 If SPACE is not NULL, use it to hold the new symbol. If it is
11607 NULL, allocate a new symbol on the objfile's obstack. */
11609 static struct symbol
*
11610 new_symbol_full (struct die_info
*die
, struct type
*type
, struct dwarf2_cu
*cu
,
11611 struct symbol
*space
)
11613 struct objfile
*objfile
= cu
->objfile
;
11614 struct symbol
*sym
= NULL
;
11616 struct attribute
*attr
= NULL
;
11617 struct attribute
*attr2
= NULL
;
11618 CORE_ADDR baseaddr
;
11619 struct pending
**list_to_add
= NULL
;
11621 int inlined_func
= (die
->tag
== DW_TAG_inlined_subroutine
);
11623 baseaddr
= ANOFFSET (objfile
->section_offsets
, SECT_OFF_TEXT (objfile
));
11625 name
= dwarf2_name (die
, cu
);
11628 const char *linkagename
;
11629 int suppress_add
= 0;
11634 sym
= OBSTACK_ZALLOC (&objfile
->objfile_obstack
, struct symbol
);
11635 OBJSTAT (objfile
, n_syms
++);
11637 /* Cache this symbol's name and the name's demangled form (if any). */
11638 SYMBOL_SET_LANGUAGE (sym
, cu
->language
);
11639 linkagename
= dwarf2_physname (name
, die
, cu
);
11640 SYMBOL_SET_NAMES (sym
, linkagename
, strlen (linkagename
), 0, objfile
);
11642 /* Fortran does not have mangling standard and the mangling does differ
11643 between gfortran, iFort etc. */
11644 if (cu
->language
== language_fortran
11645 && symbol_get_demangled_name (&(sym
->ginfo
)) == NULL
)
11646 symbol_set_demangled_name (&(sym
->ginfo
),
11647 (char *) dwarf2_full_name (name
, die
, cu
),
11650 /* Default assumptions.
11651 Use the passed type or decode it from the die. */
11652 SYMBOL_DOMAIN (sym
) = VAR_DOMAIN
;
11653 SYMBOL_CLASS (sym
) = LOC_OPTIMIZED_OUT
;
11655 SYMBOL_TYPE (sym
) = type
;
11657 SYMBOL_TYPE (sym
) = die_type (die
, cu
);
11658 attr
= dwarf2_attr (die
,
11659 inlined_func
? DW_AT_call_line
: DW_AT_decl_line
,
11663 SYMBOL_LINE (sym
) = DW_UNSND (attr
);
11666 attr
= dwarf2_attr (die
,
11667 inlined_func
? DW_AT_call_file
: DW_AT_decl_file
,
11671 int file_index
= DW_UNSND (attr
);
11673 if (cu
->line_header
== NULL
11674 || file_index
> cu
->line_header
->num_file_names
)
11675 complaint (&symfile_complaints
,
11676 _("file index out of range"));
11677 else if (file_index
> 0)
11679 struct file_entry
*fe
;
11681 fe
= &cu
->line_header
->file_names
[file_index
- 1];
11682 SYMBOL_SYMTAB (sym
) = fe
->symtab
;
11689 attr
= dwarf2_attr (die
, DW_AT_low_pc
, cu
);
11692 SYMBOL_VALUE_ADDRESS (sym
) = DW_ADDR (attr
) + baseaddr
;
11694 SYMBOL_TYPE (sym
) = objfile_type (objfile
)->builtin_core_addr
;
11695 SYMBOL_DOMAIN (sym
) = LABEL_DOMAIN
;
11696 SYMBOL_CLASS (sym
) = LOC_LABEL
;
11697 add_symbol_to_list (sym
, cu
->list_in_scope
);
11699 case DW_TAG_subprogram
:
11700 /* SYMBOL_BLOCK_VALUE (sym) will be filled in later by
11702 SYMBOL_CLASS (sym
) = LOC_BLOCK
;
11703 attr2
= dwarf2_attr (die
, DW_AT_external
, cu
);
11704 if ((attr2
&& (DW_UNSND (attr2
) != 0))
11705 || cu
->language
== language_ada
)
11707 /* Subprograms marked external are stored as a global symbol.
11708 Ada subprograms, whether marked external or not, are always
11709 stored as a global symbol, because we want to be able to
11710 access them globally. For instance, we want to be able
11711 to break on a nested subprogram without having to
11712 specify the context. */
11713 list_to_add
= &global_symbols
;
11717 list_to_add
= cu
->list_in_scope
;
11720 case DW_TAG_inlined_subroutine
:
11721 /* SYMBOL_BLOCK_VALUE (sym) will be filled in later by
11723 SYMBOL_CLASS (sym
) = LOC_BLOCK
;
11724 SYMBOL_INLINED (sym
) = 1;
11725 /* Do not add the symbol to any lists. It will be found via
11726 BLOCK_FUNCTION from the blockvector. */
11728 case DW_TAG_template_value_param
:
11730 /* Fall through. */
11731 case DW_TAG_constant
:
11732 case DW_TAG_variable
:
11733 case DW_TAG_member
:
11734 /* Compilation with minimal debug info may result in
11735 variables with missing type entries. Change the
11736 misleading `void' type to something sensible. */
11737 if (TYPE_CODE (SYMBOL_TYPE (sym
)) == TYPE_CODE_VOID
)
11739 = objfile_type (objfile
)->nodebug_data_symbol
;
11741 attr
= dwarf2_attr (die
, DW_AT_const_value
, cu
);
11742 /* In the case of DW_TAG_member, we should only be called for
11743 static const members. */
11744 if (die
->tag
== DW_TAG_member
)
11746 /* dwarf2_add_field uses die_is_declaration,
11747 so we do the same. */
11748 gdb_assert (die_is_declaration (die
, cu
));
11753 dwarf2_const_value (attr
, sym
, cu
);
11754 attr2
= dwarf2_attr (die
, DW_AT_external
, cu
);
11757 if (attr2
&& (DW_UNSND (attr2
) != 0))
11758 list_to_add
= &global_symbols
;
11760 list_to_add
= cu
->list_in_scope
;
11764 attr
= dwarf2_attr (die
, DW_AT_location
, cu
);
11767 var_decode_location (attr
, sym
, cu
);
11768 attr2
= dwarf2_attr (die
, DW_AT_external
, cu
);
11769 if (SYMBOL_CLASS (sym
) == LOC_STATIC
11770 && SYMBOL_VALUE_ADDRESS (sym
) == 0
11771 && !dwarf2_per_objfile
->has_section_at_zero
)
11773 /* When a static variable is eliminated by the linker,
11774 the corresponding debug information is not stripped
11775 out, but the variable address is set to null;
11776 do not add such variables into symbol table. */
11778 else if (attr2
&& (DW_UNSND (attr2
) != 0))
11780 /* Workaround gfortran PR debug/40040 - it uses
11781 DW_AT_location for variables in -fPIC libraries which may
11782 get overriden by other libraries/executable and get
11783 a different address. Resolve it by the minimal symbol
11784 which may come from inferior's executable using copy
11785 relocation. Make this workaround only for gfortran as for
11786 other compilers GDB cannot guess the minimal symbol
11787 Fortran mangling kind. */
11788 if (cu
->language
== language_fortran
&& die
->parent
11789 && die
->parent
->tag
== DW_TAG_module
11791 && strncmp (cu
->producer
, "GNU Fortran ", 12) == 0)
11792 SYMBOL_CLASS (sym
) = LOC_UNRESOLVED
;
11794 /* A variable with DW_AT_external is never static,
11795 but it may be block-scoped. */
11796 list_to_add
= (cu
->list_in_scope
== &file_symbols
11797 ? &global_symbols
: cu
->list_in_scope
);
11800 list_to_add
= cu
->list_in_scope
;
11804 /* We do not know the address of this symbol.
11805 If it is an external symbol and we have type information
11806 for it, enter the symbol as a LOC_UNRESOLVED symbol.
11807 The address of the variable will then be determined from
11808 the minimal symbol table whenever the variable is
11810 attr2
= dwarf2_attr (die
, DW_AT_external
, cu
);
11811 if (attr2
&& (DW_UNSND (attr2
) != 0)
11812 && dwarf2_attr (die
, DW_AT_type
, cu
) != NULL
)
11814 /* A variable with DW_AT_external is never static, but it
11815 may be block-scoped. */
11816 list_to_add
= (cu
->list_in_scope
== &file_symbols
11817 ? &global_symbols
: cu
->list_in_scope
);
11819 SYMBOL_CLASS (sym
) = LOC_UNRESOLVED
;
11821 else if (!die_is_declaration (die
, cu
))
11823 /* Use the default LOC_OPTIMIZED_OUT class. */
11824 gdb_assert (SYMBOL_CLASS (sym
) == LOC_OPTIMIZED_OUT
);
11826 list_to_add
= cu
->list_in_scope
;
11830 case DW_TAG_formal_parameter
:
11831 /* If we are inside a function, mark this as an argument. If
11832 not, we might be looking at an argument to an inlined function
11833 when we do not have enough information to show inlined frames;
11834 pretend it's a local variable in that case so that the user can
11836 if (context_stack_depth
> 0
11837 && context_stack
[context_stack_depth
- 1].name
!= NULL
)
11838 SYMBOL_IS_ARGUMENT (sym
) = 1;
11839 attr
= dwarf2_attr (die
, DW_AT_location
, cu
);
11842 var_decode_location (attr
, sym
, cu
);
11844 attr
= dwarf2_attr (die
, DW_AT_const_value
, cu
);
11847 dwarf2_const_value (attr
, sym
, cu
);
11850 list_to_add
= cu
->list_in_scope
;
11852 case DW_TAG_unspecified_parameters
:
11853 /* From varargs functions; gdb doesn't seem to have any
11854 interest in this information, so just ignore it for now.
11857 case DW_TAG_template_type_param
:
11859 /* Fall through. */
11860 case DW_TAG_class_type
:
11861 case DW_TAG_interface_type
:
11862 case DW_TAG_structure_type
:
11863 case DW_TAG_union_type
:
11864 case DW_TAG_set_type
:
11865 case DW_TAG_enumeration_type
:
11866 SYMBOL_CLASS (sym
) = LOC_TYPEDEF
;
11867 SYMBOL_DOMAIN (sym
) = STRUCT_DOMAIN
;
11870 /* NOTE: carlton/2003-11-10: C++ and Java class symbols shouldn't
11871 really ever be static objects: otherwise, if you try
11872 to, say, break of a class's method and you're in a file
11873 which doesn't mention that class, it won't work unless
11874 the check for all static symbols in lookup_symbol_aux
11875 saves you. See the OtherFileClass tests in
11876 gdb.c++/namespace.exp. */
11880 list_to_add
= (cu
->list_in_scope
== &file_symbols
11881 && (cu
->language
== language_cplus
11882 || cu
->language
== language_java
)
11883 ? &global_symbols
: cu
->list_in_scope
);
11885 /* The semantics of C++ state that "struct foo {
11886 ... }" also defines a typedef for "foo". A Java
11887 class declaration also defines a typedef for the
11889 if (cu
->language
== language_cplus
11890 || cu
->language
== language_java
11891 || cu
->language
== language_ada
)
11893 /* The symbol's name is already allocated along
11894 with this objfile, so we don't need to
11895 duplicate it for the type. */
11896 if (TYPE_NAME (SYMBOL_TYPE (sym
)) == 0)
11897 TYPE_NAME (SYMBOL_TYPE (sym
)) = SYMBOL_SEARCH_NAME (sym
);
11902 case DW_TAG_typedef
:
11903 SYMBOL_CLASS (sym
) = LOC_TYPEDEF
;
11904 SYMBOL_DOMAIN (sym
) = VAR_DOMAIN
;
11905 list_to_add
= cu
->list_in_scope
;
11907 case DW_TAG_base_type
:
11908 case DW_TAG_subrange_type
:
11909 SYMBOL_CLASS (sym
) = LOC_TYPEDEF
;
11910 SYMBOL_DOMAIN (sym
) = VAR_DOMAIN
;
11911 list_to_add
= cu
->list_in_scope
;
11913 case DW_TAG_enumerator
:
11914 attr
= dwarf2_attr (die
, DW_AT_const_value
, cu
);
11917 dwarf2_const_value (attr
, sym
, cu
);
11920 /* NOTE: carlton/2003-11-10: See comment above in the
11921 DW_TAG_class_type, etc. block. */
11923 list_to_add
= (cu
->list_in_scope
== &file_symbols
11924 && (cu
->language
== language_cplus
11925 || cu
->language
== language_java
)
11926 ? &global_symbols
: cu
->list_in_scope
);
11929 case DW_TAG_namespace
:
11930 SYMBOL_CLASS (sym
) = LOC_TYPEDEF
;
11931 list_to_add
= &global_symbols
;
11934 /* Not a tag we recognize. Hopefully we aren't processing
11935 trash data, but since we must specifically ignore things
11936 we don't recognize, there is nothing else we should do at
11938 complaint (&symfile_complaints
, _("unsupported tag: '%s'"),
11939 dwarf_tag_name (die
->tag
));
11945 sym
->hash_next
= objfile
->template_symbols
;
11946 objfile
->template_symbols
= sym
;
11947 list_to_add
= NULL
;
11950 if (list_to_add
!= NULL
)
11951 add_symbol_to_list (sym
, list_to_add
);
11953 /* For the benefit of old versions of GCC, check for anonymous
11954 namespaces based on the demangled name. */
11955 if (!processing_has_namespace_info
11956 && cu
->language
== language_cplus
)
11957 cp_scan_for_anonymous_namespaces (sym
, objfile
);
11962 /* A wrapper for new_symbol_full that always allocates a new symbol. */
11964 static struct symbol
*
11965 new_symbol (struct die_info
*die
, struct type
*type
, struct dwarf2_cu
*cu
)
11967 return new_symbol_full (die
, type
, cu
, NULL
);
11970 /* Given an attr with a DW_FORM_dataN value in host byte order,
11971 zero-extend it as appropriate for the symbol's type. The DWARF
11972 standard (v4) is not entirely clear about the meaning of using
11973 DW_FORM_dataN for a constant with a signed type, where the type is
11974 wider than the data. The conclusion of a discussion on the DWARF
11975 list was that this is unspecified. We choose to always zero-extend
11976 because that is the interpretation long in use by GCC. */
11979 dwarf2_const_value_data (struct attribute
*attr
, struct type
*type
,
11980 const char *name
, struct obstack
*obstack
,
11981 struct dwarf2_cu
*cu
, long *value
, int bits
)
11983 struct objfile
*objfile
= cu
->objfile
;
11984 enum bfd_endian byte_order
= bfd_big_endian (objfile
->obfd
) ?
11985 BFD_ENDIAN_BIG
: BFD_ENDIAN_LITTLE
;
11986 LONGEST l
= DW_UNSND (attr
);
11988 if (bits
< sizeof (*value
) * 8)
11990 l
&= ((LONGEST
) 1 << bits
) - 1;
11993 else if (bits
== sizeof (*value
) * 8)
11997 gdb_byte
*bytes
= obstack_alloc (obstack
, bits
/ 8);
11998 store_unsigned_integer (bytes
, bits
/ 8, byte_order
, l
);
12005 /* Read a constant value from an attribute. Either set *VALUE, or if
12006 the value does not fit in *VALUE, set *BYTES - either already
12007 allocated on the objfile obstack, or newly allocated on OBSTACK,
12008 or, set *BATON, if we translated the constant to a location
12012 dwarf2_const_value_attr (struct attribute
*attr
, struct type
*type
,
12013 const char *name
, struct obstack
*obstack
,
12014 struct dwarf2_cu
*cu
,
12015 long *value
, gdb_byte
**bytes
,
12016 struct dwarf2_locexpr_baton
**baton
)
12018 struct objfile
*objfile
= cu
->objfile
;
12019 struct comp_unit_head
*cu_header
= &cu
->header
;
12020 struct dwarf_block
*blk
;
12021 enum bfd_endian byte_order
= (bfd_big_endian (objfile
->obfd
) ?
12022 BFD_ENDIAN_BIG
: BFD_ENDIAN_LITTLE
);
12028 switch (attr
->form
)
12034 if (TYPE_LENGTH (type
) != cu_header
->addr_size
)
12035 dwarf2_const_value_length_mismatch_complaint (name
,
12036 cu_header
->addr_size
,
12037 TYPE_LENGTH (type
));
12038 /* Symbols of this form are reasonably rare, so we just
12039 piggyback on the existing location code rather than writing
12040 a new implementation of symbol_computed_ops. */
12041 *baton
= obstack_alloc (&objfile
->objfile_obstack
,
12042 sizeof (struct dwarf2_locexpr_baton
));
12043 (*baton
)->per_cu
= cu
->per_cu
;
12044 gdb_assert ((*baton
)->per_cu
);
12046 (*baton
)->size
= 2 + cu_header
->addr_size
;
12047 data
= obstack_alloc (&objfile
->objfile_obstack
, (*baton
)->size
);
12048 (*baton
)->data
= data
;
12050 data
[0] = DW_OP_addr
;
12051 store_unsigned_integer (&data
[1], cu_header
->addr_size
,
12052 byte_order
, DW_ADDR (attr
));
12053 data
[cu_header
->addr_size
+ 1] = DW_OP_stack_value
;
12056 case DW_FORM_string
:
12058 /* DW_STRING is already allocated on the objfile obstack, point
12060 *bytes
= (gdb_byte
*) DW_STRING (attr
);
12062 case DW_FORM_block1
:
12063 case DW_FORM_block2
:
12064 case DW_FORM_block4
:
12065 case DW_FORM_block
:
12066 case DW_FORM_exprloc
:
12067 blk
= DW_BLOCK (attr
);
12068 if (TYPE_LENGTH (type
) != blk
->size
)
12069 dwarf2_const_value_length_mismatch_complaint (name
, blk
->size
,
12070 TYPE_LENGTH (type
));
12071 *bytes
= blk
->data
;
12074 /* The DW_AT_const_value attributes are supposed to carry the
12075 symbol's value "represented as it would be on the target
12076 architecture." By the time we get here, it's already been
12077 converted to host endianness, so we just need to sign- or
12078 zero-extend it as appropriate. */
12079 case DW_FORM_data1
:
12080 *bytes
= dwarf2_const_value_data (attr
, type
, name
,
12081 obstack
, cu
, value
, 8);
12083 case DW_FORM_data2
:
12084 *bytes
= dwarf2_const_value_data (attr
, type
, name
,
12085 obstack
, cu
, value
, 16);
12087 case DW_FORM_data4
:
12088 *bytes
= dwarf2_const_value_data (attr
, type
, name
,
12089 obstack
, cu
, value
, 32);
12091 case DW_FORM_data8
:
12092 *bytes
= dwarf2_const_value_data (attr
, type
, name
,
12093 obstack
, cu
, value
, 64);
12096 case DW_FORM_sdata
:
12097 *value
= DW_SND (attr
);
12100 case DW_FORM_udata
:
12101 *value
= DW_UNSND (attr
);
12105 complaint (&symfile_complaints
,
12106 _("unsupported const value attribute form: '%s'"),
12107 dwarf_form_name (attr
->form
));
12114 /* Copy constant value from an attribute to a symbol. */
12117 dwarf2_const_value (struct attribute
*attr
, struct symbol
*sym
,
12118 struct dwarf2_cu
*cu
)
12120 struct objfile
*objfile
= cu
->objfile
;
12121 struct comp_unit_head
*cu_header
= &cu
->header
;
12124 struct dwarf2_locexpr_baton
*baton
;
12126 dwarf2_const_value_attr (attr
, SYMBOL_TYPE (sym
),
12127 SYMBOL_PRINT_NAME (sym
),
12128 &objfile
->objfile_obstack
, cu
,
12129 &value
, &bytes
, &baton
);
12133 SYMBOL_COMPUTED_OPS (sym
) = &dwarf2_locexpr_funcs
;
12134 SYMBOL_LOCATION_BATON (sym
) = baton
;
12135 SYMBOL_CLASS (sym
) = LOC_COMPUTED
;
12137 else if (bytes
!= NULL
)
12139 SYMBOL_VALUE_BYTES (sym
) = bytes
;
12140 SYMBOL_CLASS (sym
) = LOC_CONST_BYTES
;
12144 SYMBOL_VALUE (sym
) = value
;
12145 SYMBOL_CLASS (sym
) = LOC_CONST
;
12149 /* Return the type of the die in question using its DW_AT_type attribute. */
12151 static struct type
*
12152 die_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
12154 struct attribute
*type_attr
;
12156 type_attr
= dwarf2_attr (die
, DW_AT_type
, cu
);
12159 /* A missing DW_AT_type represents a void type. */
12160 return objfile_type (cu
->objfile
)->builtin_void
;
12163 return lookup_die_type (die
, type_attr
, cu
);
12166 /* True iff CU's producer generates GNAT Ada auxiliary information
12167 that allows to find parallel types through that information instead
12168 of having to do expensive parallel lookups by type name. */
12171 need_gnat_info (struct dwarf2_cu
*cu
)
12173 /* FIXME: brobecker/2010-10-12: As of now, only the AdaCore version
12174 of GNAT produces this auxiliary information, without any indication
12175 that it is produced. Part of enhancing the FSF version of GNAT
12176 to produce that information will be to put in place an indicator
12177 that we can use in order to determine whether the descriptive type
12178 info is available or not. One suggestion that has been made is
12179 to use a new attribute, attached to the CU die. For now, assume
12180 that the descriptive type info is not available. */
12184 /* Return the auxiliary type of the die in question using its
12185 DW_AT_GNAT_descriptive_type attribute. Returns NULL if the
12186 attribute is not present. */
12188 static struct type
*
12189 die_descriptive_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
12191 struct attribute
*type_attr
;
12193 type_attr
= dwarf2_attr (die
, DW_AT_GNAT_descriptive_type
, cu
);
12197 return lookup_die_type (die
, type_attr
, cu
);
12200 /* If DIE has a descriptive_type attribute, then set the TYPE's
12201 descriptive type accordingly. */
12204 set_descriptive_type (struct type
*type
, struct die_info
*die
,
12205 struct dwarf2_cu
*cu
)
12207 struct type
*descriptive_type
= die_descriptive_type (die
, cu
);
12209 if (descriptive_type
)
12211 ALLOCATE_GNAT_AUX_TYPE (type
);
12212 TYPE_DESCRIPTIVE_TYPE (type
) = descriptive_type
;
12216 /* Return the containing type of the die in question using its
12217 DW_AT_containing_type attribute. */
12219 static struct type
*
12220 die_containing_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
12222 struct attribute
*type_attr
;
12224 type_attr
= dwarf2_attr (die
, DW_AT_containing_type
, cu
);
12226 error (_("Dwarf Error: Problem turning containing type into gdb type "
12227 "[in module %s]"), cu
->objfile
->name
);
12229 return lookup_die_type (die
, type_attr
, cu
);
12232 /* Look up the type of DIE in CU using its type attribute ATTR.
12233 If there is no type substitute an error marker. */
12235 static struct type
*
12236 lookup_die_type (struct die_info
*die
, struct attribute
*attr
,
12237 struct dwarf2_cu
*cu
)
12239 struct objfile
*objfile
= cu
->objfile
;
12240 struct type
*this_type
;
12242 /* First see if we have it cached. */
12244 if (is_ref_attr (attr
))
12246 unsigned int offset
= dwarf2_get_ref_die_offset (attr
);
12248 this_type
= get_die_type_at_offset (offset
, cu
->per_cu
);
12250 else if (attr
->form
== DW_FORM_ref_sig8
)
12252 struct signatured_type
*sig_type
= DW_SIGNATURED_TYPE (attr
);
12253 struct dwarf2_cu
*sig_cu
;
12254 unsigned int offset
;
12256 /* sig_type will be NULL if the signatured type is missing from
12258 if (sig_type
== NULL
)
12259 error (_("Dwarf Error: Cannot find signatured DIE referenced from DIE "
12260 "at 0x%x [in module %s]"),
12261 die
->offset
, objfile
->name
);
12263 gdb_assert (sig_type
->per_cu
.debug_types_section
);
12264 offset
= sig_type
->per_cu
.offset
+ sig_type
->type_offset
;
12265 this_type
= get_die_type_at_offset (offset
, &sig_type
->per_cu
);
12269 dump_die_for_error (die
);
12270 error (_("Dwarf Error: Bad type attribute %s [in module %s]"),
12271 dwarf_attr_name (attr
->name
), objfile
->name
);
12274 /* If not cached we need to read it in. */
12276 if (this_type
== NULL
)
12278 struct die_info
*type_die
;
12279 struct dwarf2_cu
*type_cu
= cu
;
12281 type_die
= follow_die_ref_or_sig (die
, attr
, &type_cu
);
12282 /* If the type is cached, we should have found it above. */
12283 gdb_assert (get_die_type (type_die
, type_cu
) == NULL
);
12284 this_type
= read_type_die_1 (type_die
, type_cu
);
12287 /* If we still don't have a type use an error marker. */
12289 if (this_type
== NULL
)
12291 char *message
, *saved
;
12293 /* read_type_die already issued a complaint. */
12294 message
= xstrprintf (_("<unknown type in %s, CU 0x%x, DIE 0x%x>"),
12298 saved
= obstack_copy0 (&objfile
->objfile_obstack
,
12299 message
, strlen (message
));
12302 this_type
= init_type (TYPE_CODE_ERROR
, 0, 0, saved
, objfile
);
12308 /* Return the type in DIE, CU.
12309 Returns NULL for invalid types.
12311 This first does a lookup in the appropriate type_hash table,
12312 and only reads the die in if necessary.
12314 NOTE: This can be called when reading in partial or full symbols. */
12316 static struct type
*
12317 read_type_die (struct die_info
*die
, struct dwarf2_cu
*cu
)
12319 struct type
*this_type
;
12321 this_type
= get_die_type (die
, cu
);
12325 return read_type_die_1 (die
, cu
);
12328 /* Read the type in DIE, CU.
12329 Returns NULL for invalid types. */
12331 static struct type
*
12332 read_type_die_1 (struct die_info
*die
, struct dwarf2_cu
*cu
)
12334 struct type
*this_type
= NULL
;
12338 case DW_TAG_class_type
:
12339 case DW_TAG_interface_type
:
12340 case DW_TAG_structure_type
:
12341 case DW_TAG_union_type
:
12342 this_type
= read_structure_type (die
, cu
);
12344 case DW_TAG_enumeration_type
:
12345 this_type
= read_enumeration_type (die
, cu
);
12347 case DW_TAG_subprogram
:
12348 case DW_TAG_subroutine_type
:
12349 case DW_TAG_inlined_subroutine
:
12350 this_type
= read_subroutine_type (die
, cu
);
12352 case DW_TAG_array_type
:
12353 this_type
= read_array_type (die
, cu
);
12355 case DW_TAG_set_type
:
12356 this_type
= read_set_type (die
, cu
);
12358 case DW_TAG_pointer_type
:
12359 this_type
= read_tag_pointer_type (die
, cu
);
12361 case DW_TAG_ptr_to_member_type
:
12362 this_type
= read_tag_ptr_to_member_type (die
, cu
);
12364 case DW_TAG_reference_type
:
12365 this_type
= read_tag_reference_type (die
, cu
);
12367 case DW_TAG_const_type
:
12368 this_type
= read_tag_const_type (die
, cu
);
12370 case DW_TAG_volatile_type
:
12371 this_type
= read_tag_volatile_type (die
, cu
);
12373 case DW_TAG_string_type
:
12374 this_type
= read_tag_string_type (die
, cu
);
12376 case DW_TAG_typedef
:
12377 this_type
= read_typedef (die
, cu
);
12379 case DW_TAG_subrange_type
:
12380 this_type
= read_subrange_type (die
, cu
);
12382 case DW_TAG_base_type
:
12383 this_type
= read_base_type (die
, cu
);
12385 case DW_TAG_unspecified_type
:
12386 this_type
= read_unspecified_type (die
, cu
);
12388 case DW_TAG_namespace
:
12389 this_type
= read_namespace_type (die
, cu
);
12391 case DW_TAG_module
:
12392 this_type
= read_module_type (die
, cu
);
12395 complaint (&symfile_complaints
,
12396 _("unexpected tag in read_type_die: '%s'"),
12397 dwarf_tag_name (die
->tag
));
12404 /* See if we can figure out if the class lives in a namespace. We do
12405 this by looking for a member function; its demangled name will
12406 contain namespace info, if there is any.
12407 Return the computed name or NULL.
12408 Space for the result is allocated on the objfile's obstack.
12409 This is the full-die version of guess_partial_die_structure_name.
12410 In this case we know DIE has no useful parent. */
12413 guess_full_die_structure_name (struct die_info
*die
, struct dwarf2_cu
*cu
)
12415 struct die_info
*spec_die
;
12416 struct dwarf2_cu
*spec_cu
;
12417 struct die_info
*child
;
12420 spec_die
= die_specification (die
, &spec_cu
);
12421 if (spec_die
!= NULL
)
12427 for (child
= die
->child
;
12429 child
= child
->sibling
)
12431 if (child
->tag
== DW_TAG_subprogram
)
12433 struct attribute
*attr
;
12435 attr
= dwarf2_attr (child
, DW_AT_linkage_name
, cu
);
12437 attr
= dwarf2_attr (child
, DW_AT_MIPS_linkage_name
, cu
);
12441 = language_class_name_from_physname (cu
->language_defn
,
12445 if (actual_name
!= NULL
)
12447 char *die_name
= dwarf2_name (die
, cu
);
12449 if (die_name
!= NULL
12450 && strcmp (die_name
, actual_name
) != 0)
12452 /* Strip off the class name from the full name.
12453 We want the prefix. */
12454 int die_name_len
= strlen (die_name
);
12455 int actual_name_len
= strlen (actual_name
);
12457 /* Test for '::' as a sanity check. */
12458 if (actual_name_len
> die_name_len
+ 2
12459 && actual_name
[actual_name_len
12460 - die_name_len
- 1] == ':')
12462 obsavestring (actual_name
,
12463 actual_name_len
- die_name_len
- 2,
12464 &cu
->objfile
->objfile_obstack
);
12467 xfree (actual_name
);
12476 /* GCC might emit a nameless typedef that has a linkage name. Determine the
12477 prefix part in such case. See
12478 http://gcc.gnu.org/bugzilla/show_bug.cgi?id=47510. */
12481 anonymous_struct_prefix (struct die_info
*die
, struct dwarf2_cu
*cu
)
12483 struct attribute
*attr
;
12486 if (die
->tag
!= DW_TAG_class_type
&& die
->tag
!= DW_TAG_interface_type
12487 && die
->tag
!= DW_TAG_structure_type
&& die
->tag
!= DW_TAG_union_type
)
12490 attr
= dwarf2_attr (die
, DW_AT_name
, cu
);
12491 if (attr
!= NULL
&& DW_STRING (attr
) != NULL
)
12494 attr
= dwarf2_attr (die
, DW_AT_linkage_name
, cu
);
12496 attr
= dwarf2_attr (die
, DW_AT_MIPS_linkage_name
, cu
);
12497 if (attr
== NULL
|| DW_STRING (attr
) == NULL
)
12500 /* dwarf2_name had to be already called. */
12501 gdb_assert (DW_STRING_IS_CANONICAL (attr
));
12503 /* Strip the base name, keep any leading namespaces/classes. */
12504 base
= strrchr (DW_STRING (attr
), ':');
12505 if (base
== NULL
|| base
== DW_STRING (attr
) || base
[-1] != ':')
12508 return obsavestring (DW_STRING (attr
), &base
[-1] - DW_STRING (attr
),
12509 &cu
->objfile
->objfile_obstack
);
12512 /* Return the name of the namespace/class that DIE is defined within,
12513 or "" if we can't tell. The caller should not xfree the result.
12515 For example, if we're within the method foo() in the following
12525 then determine_prefix on foo's die will return "N::C". */
12528 determine_prefix (struct die_info
*die
, struct dwarf2_cu
*cu
)
12530 struct die_info
*parent
, *spec_die
;
12531 struct dwarf2_cu
*spec_cu
;
12532 struct type
*parent_type
;
12535 if (cu
->language
!= language_cplus
&& cu
->language
!= language_java
12536 && cu
->language
!= language_fortran
)
12539 retval
= anonymous_struct_prefix (die
, cu
);
12543 /* We have to be careful in the presence of DW_AT_specification.
12544 For example, with GCC 3.4, given the code
12548 // Definition of N::foo.
12552 then we'll have a tree of DIEs like this:
12554 1: DW_TAG_compile_unit
12555 2: DW_TAG_namespace // N
12556 3: DW_TAG_subprogram // declaration of N::foo
12557 4: DW_TAG_subprogram // definition of N::foo
12558 DW_AT_specification // refers to die #3
12560 Thus, when processing die #4, we have to pretend that we're in
12561 the context of its DW_AT_specification, namely the contex of die
12564 spec_die
= die_specification (die
, &spec_cu
);
12565 if (spec_die
== NULL
)
12566 parent
= die
->parent
;
12569 parent
= spec_die
->parent
;
12573 if (parent
== NULL
)
12575 else if (parent
->building_fullname
)
12578 const char *parent_name
;
12580 /* It has been seen on RealView 2.2 built binaries,
12581 DW_TAG_template_type_param types actually _defined_ as
12582 children of the parent class:
12585 template class <class Enum> Class{};
12586 Class<enum E> class_e;
12588 1: DW_TAG_class_type (Class)
12589 2: DW_TAG_enumeration_type (E)
12590 3: DW_TAG_enumerator (enum1:0)
12591 3: DW_TAG_enumerator (enum2:1)
12593 2: DW_TAG_template_type_param
12594 DW_AT_type DW_FORM_ref_udata (E)
12596 Besides being broken debug info, it can put GDB into an
12597 infinite loop. Consider:
12599 When we're building the full name for Class<E>, we'll start
12600 at Class, and go look over its template type parameters,
12601 finding E. We'll then try to build the full name of E, and
12602 reach here. We're now trying to build the full name of E,
12603 and look over the parent DIE for containing scope. In the
12604 broken case, if we followed the parent DIE of E, we'd again
12605 find Class, and once again go look at its template type
12606 arguments, etc., etc. Simply don't consider such parent die
12607 as source-level parent of this die (it can't be, the language
12608 doesn't allow it), and break the loop here. */
12609 name
= dwarf2_name (die
, cu
);
12610 parent_name
= dwarf2_name (parent
, cu
);
12611 complaint (&symfile_complaints
,
12612 _("template param type '%s' defined within parent '%s'"),
12613 name
? name
: "<unknown>",
12614 parent_name
? parent_name
: "<unknown>");
12618 switch (parent
->tag
)
12620 case DW_TAG_namespace
:
12621 parent_type
= read_type_die (parent
, cu
);
12622 /* GCC 4.0 and 4.1 had a bug (PR c++/28460) where they generated bogus
12623 DW_TAG_namespace DIEs with a name of "::" for the global namespace.
12624 Work around this problem here. */
12625 if (cu
->language
== language_cplus
12626 && strcmp (TYPE_TAG_NAME (parent_type
), "::") == 0)
12628 /* We give a name to even anonymous namespaces. */
12629 return TYPE_TAG_NAME (parent_type
);
12630 case DW_TAG_class_type
:
12631 case DW_TAG_interface_type
:
12632 case DW_TAG_structure_type
:
12633 case DW_TAG_union_type
:
12634 case DW_TAG_module
:
12635 parent_type
= read_type_die (parent
, cu
);
12636 if (TYPE_TAG_NAME (parent_type
) != NULL
)
12637 return TYPE_TAG_NAME (parent_type
);
12639 /* An anonymous structure is only allowed non-static data
12640 members; no typedefs, no member functions, et cetera.
12641 So it does not need a prefix. */
12643 case DW_TAG_compile_unit
:
12644 /* gcc-4.5 -gdwarf-4 can drop the enclosing namespace. Cope. */
12645 if (cu
->language
== language_cplus
12646 && !VEC_empty (dwarf2_section_info_def
, dwarf2_per_objfile
->types
)
12647 && die
->child
!= NULL
12648 && (die
->tag
== DW_TAG_class_type
12649 || die
->tag
== DW_TAG_structure_type
12650 || die
->tag
== DW_TAG_union_type
))
12652 char *name
= guess_full_die_structure_name (die
, cu
);
12658 return determine_prefix (parent
, cu
);
12662 /* Return a newly-allocated string formed by concatenating PREFIX and SUFFIX
12663 with appropriate separator. If PREFIX or SUFFIX is NULL or empty, then
12664 simply copy the SUFFIX or PREFIX, respectively. If OBS is non-null, perform
12665 an obconcat, otherwise allocate storage for the result. The CU argument is
12666 used to determine the language and hence, the appropriate separator. */
12668 #define MAX_SEP_LEN 7 /* strlen ("__") + strlen ("_MOD_") */
12671 typename_concat (struct obstack
*obs
, const char *prefix
, const char *suffix
,
12672 int physname
, struct dwarf2_cu
*cu
)
12674 const char *lead
= "";
12677 if (suffix
== NULL
|| suffix
[0] == '\0'
12678 || prefix
== NULL
|| prefix
[0] == '\0')
12680 else if (cu
->language
== language_java
)
12682 else if (cu
->language
== language_fortran
&& physname
)
12684 /* This is gfortran specific mangling. Normally DW_AT_linkage_name or
12685 DW_AT_MIPS_linkage_name is preferred and used instead. */
12693 if (prefix
== NULL
)
12695 if (suffix
== NULL
)
12701 = xmalloc (strlen (prefix
) + MAX_SEP_LEN
+ strlen (suffix
) + 1);
12703 strcpy (retval
, lead
);
12704 strcat (retval
, prefix
);
12705 strcat (retval
, sep
);
12706 strcat (retval
, suffix
);
12711 /* We have an obstack. */
12712 return obconcat (obs
, lead
, prefix
, sep
, suffix
, (char *) NULL
);
12716 /* Return sibling of die, NULL if no sibling. */
12718 static struct die_info
*
12719 sibling_die (struct die_info
*die
)
12721 return die
->sibling
;
12724 /* Get name of a die, return NULL if not found. */
12727 dwarf2_canonicalize_name (char *name
, struct dwarf2_cu
*cu
,
12728 struct obstack
*obstack
)
12730 if (name
&& cu
->language
== language_cplus
)
12732 char *canon_name
= cp_canonicalize_string (name
);
12734 if (canon_name
!= NULL
)
12736 if (strcmp (canon_name
, name
) != 0)
12737 name
= obsavestring (canon_name
, strlen (canon_name
),
12739 xfree (canon_name
);
12746 /* Get name of a die, return NULL if not found. */
12749 dwarf2_name (struct die_info
*die
, struct dwarf2_cu
*cu
)
12751 struct attribute
*attr
;
12753 attr
= dwarf2_attr (die
, DW_AT_name
, cu
);
12754 if ((!attr
|| !DW_STRING (attr
))
12755 && die
->tag
!= DW_TAG_class_type
12756 && die
->tag
!= DW_TAG_interface_type
12757 && die
->tag
!= DW_TAG_structure_type
12758 && die
->tag
!= DW_TAG_union_type
)
12763 case DW_TAG_compile_unit
:
12764 /* Compilation units have a DW_AT_name that is a filename, not
12765 a source language identifier. */
12766 case DW_TAG_enumeration_type
:
12767 case DW_TAG_enumerator
:
12768 /* These tags always have simple identifiers already; no need
12769 to canonicalize them. */
12770 return DW_STRING (attr
);
12772 case DW_TAG_subprogram
:
12773 /* Java constructors will all be named "<init>", so return
12774 the class name when we see this special case. */
12775 if (cu
->language
== language_java
12776 && DW_STRING (attr
) != NULL
12777 && strcmp (DW_STRING (attr
), "<init>") == 0)
12779 struct dwarf2_cu
*spec_cu
= cu
;
12780 struct die_info
*spec_die
;
12782 /* GCJ will output '<init>' for Java constructor names.
12783 For this special case, return the name of the parent class. */
12785 /* GCJ may output suprogram DIEs with AT_specification set.
12786 If so, use the name of the specified DIE. */
12787 spec_die
= die_specification (die
, &spec_cu
);
12788 if (spec_die
!= NULL
)
12789 return dwarf2_name (spec_die
, spec_cu
);
12794 if (die
->tag
== DW_TAG_class_type
)
12795 return dwarf2_name (die
, cu
);
12797 while (die
->tag
!= DW_TAG_compile_unit
);
12801 case DW_TAG_class_type
:
12802 case DW_TAG_interface_type
:
12803 case DW_TAG_structure_type
:
12804 case DW_TAG_union_type
:
12805 /* Some GCC versions emit spurious DW_AT_name attributes for unnamed
12806 structures or unions. These were of the form "._%d" in GCC 4.1,
12807 or simply "<anonymous struct>" or "<anonymous union>" in GCC 4.3
12808 and GCC 4.4. We work around this problem by ignoring these. */
12809 if (attr
&& DW_STRING (attr
)
12810 && (strncmp (DW_STRING (attr
), "._", 2) == 0
12811 || strncmp (DW_STRING (attr
), "<anonymous", 10) == 0))
12814 /* GCC might emit a nameless typedef that has a linkage name. See
12815 http://gcc.gnu.org/bugzilla/show_bug.cgi?id=47510. */
12816 if (!attr
|| DW_STRING (attr
) == NULL
)
12818 char *demangled
= NULL
;
12820 attr
= dwarf2_attr (die
, DW_AT_linkage_name
, cu
);
12822 attr
= dwarf2_attr (die
, DW_AT_MIPS_linkage_name
, cu
);
12824 if (attr
== NULL
|| DW_STRING (attr
) == NULL
)
12827 /* Avoid demangling DW_STRING (attr) the second time on a second
12828 call for the same DIE. */
12829 if (!DW_STRING_IS_CANONICAL (attr
))
12830 demangled
= cplus_demangle (DW_STRING (attr
), DMGL_TYPES
);
12836 /* FIXME: we already did this for the partial symbol... */
12837 DW_STRING (attr
) = obsavestring (demangled
, strlen (demangled
),
12838 &cu
->objfile
->objfile_obstack
);
12839 DW_STRING_IS_CANONICAL (attr
) = 1;
12842 /* Strip any leading namespaces/classes, keep only the base name.
12843 DW_AT_name for named DIEs does not contain the prefixes. */
12844 base
= strrchr (DW_STRING (attr
), ':');
12845 if (base
&& base
> DW_STRING (attr
) && base
[-1] == ':')
12848 return DW_STRING (attr
);
12857 if (!DW_STRING_IS_CANONICAL (attr
))
12860 = dwarf2_canonicalize_name (DW_STRING (attr
), cu
,
12861 &cu
->objfile
->objfile_obstack
);
12862 DW_STRING_IS_CANONICAL (attr
) = 1;
12864 return DW_STRING (attr
);
12867 /* Return the die that this die in an extension of, or NULL if there
12868 is none. *EXT_CU is the CU containing DIE on input, and the CU
12869 containing the return value on output. */
12871 static struct die_info
*
12872 dwarf2_extension (struct die_info
*die
, struct dwarf2_cu
**ext_cu
)
12874 struct attribute
*attr
;
12876 attr
= dwarf2_attr (die
, DW_AT_extension
, *ext_cu
);
12880 return follow_die_ref (die
, attr
, ext_cu
);
12883 /* Convert a DIE tag into its string name. */
12886 dwarf_tag_name (unsigned tag
)
12890 case DW_TAG_padding
:
12891 return "DW_TAG_padding";
12892 case DW_TAG_array_type
:
12893 return "DW_TAG_array_type";
12894 case DW_TAG_class_type
:
12895 return "DW_TAG_class_type";
12896 case DW_TAG_entry_point
:
12897 return "DW_TAG_entry_point";
12898 case DW_TAG_enumeration_type
:
12899 return "DW_TAG_enumeration_type";
12900 case DW_TAG_formal_parameter
:
12901 return "DW_TAG_formal_parameter";
12902 case DW_TAG_imported_declaration
:
12903 return "DW_TAG_imported_declaration";
12905 return "DW_TAG_label";
12906 case DW_TAG_lexical_block
:
12907 return "DW_TAG_lexical_block";
12908 case DW_TAG_member
:
12909 return "DW_TAG_member";
12910 case DW_TAG_pointer_type
:
12911 return "DW_TAG_pointer_type";
12912 case DW_TAG_reference_type
:
12913 return "DW_TAG_reference_type";
12914 case DW_TAG_compile_unit
:
12915 return "DW_TAG_compile_unit";
12916 case DW_TAG_string_type
:
12917 return "DW_TAG_string_type";
12918 case DW_TAG_structure_type
:
12919 return "DW_TAG_structure_type";
12920 case DW_TAG_subroutine_type
:
12921 return "DW_TAG_subroutine_type";
12922 case DW_TAG_typedef
:
12923 return "DW_TAG_typedef";
12924 case DW_TAG_union_type
:
12925 return "DW_TAG_union_type";
12926 case DW_TAG_unspecified_parameters
:
12927 return "DW_TAG_unspecified_parameters";
12928 case DW_TAG_variant
:
12929 return "DW_TAG_variant";
12930 case DW_TAG_common_block
:
12931 return "DW_TAG_common_block";
12932 case DW_TAG_common_inclusion
:
12933 return "DW_TAG_common_inclusion";
12934 case DW_TAG_inheritance
:
12935 return "DW_TAG_inheritance";
12936 case DW_TAG_inlined_subroutine
:
12937 return "DW_TAG_inlined_subroutine";
12938 case DW_TAG_module
:
12939 return "DW_TAG_module";
12940 case DW_TAG_ptr_to_member_type
:
12941 return "DW_TAG_ptr_to_member_type";
12942 case DW_TAG_set_type
:
12943 return "DW_TAG_set_type";
12944 case DW_TAG_subrange_type
:
12945 return "DW_TAG_subrange_type";
12946 case DW_TAG_with_stmt
:
12947 return "DW_TAG_with_stmt";
12948 case DW_TAG_access_declaration
:
12949 return "DW_TAG_access_declaration";
12950 case DW_TAG_base_type
:
12951 return "DW_TAG_base_type";
12952 case DW_TAG_catch_block
:
12953 return "DW_TAG_catch_block";
12954 case DW_TAG_const_type
:
12955 return "DW_TAG_const_type";
12956 case DW_TAG_constant
:
12957 return "DW_TAG_constant";
12958 case DW_TAG_enumerator
:
12959 return "DW_TAG_enumerator";
12960 case DW_TAG_file_type
:
12961 return "DW_TAG_file_type";
12962 case DW_TAG_friend
:
12963 return "DW_TAG_friend";
12964 case DW_TAG_namelist
:
12965 return "DW_TAG_namelist";
12966 case DW_TAG_namelist_item
:
12967 return "DW_TAG_namelist_item";
12968 case DW_TAG_packed_type
:
12969 return "DW_TAG_packed_type";
12970 case DW_TAG_subprogram
:
12971 return "DW_TAG_subprogram";
12972 case DW_TAG_template_type_param
:
12973 return "DW_TAG_template_type_param";
12974 case DW_TAG_template_value_param
:
12975 return "DW_TAG_template_value_param";
12976 case DW_TAG_thrown_type
:
12977 return "DW_TAG_thrown_type";
12978 case DW_TAG_try_block
:
12979 return "DW_TAG_try_block";
12980 case DW_TAG_variant_part
:
12981 return "DW_TAG_variant_part";
12982 case DW_TAG_variable
:
12983 return "DW_TAG_variable";
12984 case DW_TAG_volatile_type
:
12985 return "DW_TAG_volatile_type";
12986 case DW_TAG_dwarf_procedure
:
12987 return "DW_TAG_dwarf_procedure";
12988 case DW_TAG_restrict_type
:
12989 return "DW_TAG_restrict_type";
12990 case DW_TAG_interface_type
:
12991 return "DW_TAG_interface_type";
12992 case DW_TAG_namespace
:
12993 return "DW_TAG_namespace";
12994 case DW_TAG_imported_module
:
12995 return "DW_TAG_imported_module";
12996 case DW_TAG_unspecified_type
:
12997 return "DW_TAG_unspecified_type";
12998 case DW_TAG_partial_unit
:
12999 return "DW_TAG_partial_unit";
13000 case DW_TAG_imported_unit
:
13001 return "DW_TAG_imported_unit";
13002 case DW_TAG_condition
:
13003 return "DW_TAG_condition";
13004 case DW_TAG_shared_type
:
13005 return "DW_TAG_shared_type";
13006 case DW_TAG_type_unit
:
13007 return "DW_TAG_type_unit";
13008 case DW_TAG_MIPS_loop
:
13009 return "DW_TAG_MIPS_loop";
13010 case DW_TAG_HP_array_descriptor
:
13011 return "DW_TAG_HP_array_descriptor";
13012 case DW_TAG_format_label
:
13013 return "DW_TAG_format_label";
13014 case DW_TAG_function_template
:
13015 return "DW_TAG_function_template";
13016 case DW_TAG_class_template
:
13017 return "DW_TAG_class_template";
13018 case DW_TAG_GNU_BINCL
:
13019 return "DW_TAG_GNU_BINCL";
13020 case DW_TAG_GNU_EINCL
:
13021 return "DW_TAG_GNU_EINCL";
13022 case DW_TAG_upc_shared_type
:
13023 return "DW_TAG_upc_shared_type";
13024 case DW_TAG_upc_strict_type
:
13025 return "DW_TAG_upc_strict_type";
13026 case DW_TAG_upc_relaxed_type
:
13027 return "DW_TAG_upc_relaxed_type";
13028 case DW_TAG_PGI_kanji_type
:
13029 return "DW_TAG_PGI_kanji_type";
13030 case DW_TAG_PGI_interface_block
:
13031 return "DW_TAG_PGI_interface_block";
13032 case DW_TAG_GNU_call_site
:
13033 return "DW_TAG_GNU_call_site";
13035 return "DW_TAG_<unknown>";
13039 /* Convert a DWARF attribute code into its string name. */
13042 dwarf_attr_name (unsigned attr
)
13046 case DW_AT_sibling
:
13047 return "DW_AT_sibling";
13048 case DW_AT_location
:
13049 return "DW_AT_location";
13051 return "DW_AT_name";
13052 case DW_AT_ordering
:
13053 return "DW_AT_ordering";
13054 case DW_AT_subscr_data
:
13055 return "DW_AT_subscr_data";
13056 case DW_AT_byte_size
:
13057 return "DW_AT_byte_size";
13058 case DW_AT_bit_offset
:
13059 return "DW_AT_bit_offset";
13060 case DW_AT_bit_size
:
13061 return "DW_AT_bit_size";
13062 case DW_AT_element_list
:
13063 return "DW_AT_element_list";
13064 case DW_AT_stmt_list
:
13065 return "DW_AT_stmt_list";
13067 return "DW_AT_low_pc";
13068 case DW_AT_high_pc
:
13069 return "DW_AT_high_pc";
13070 case DW_AT_language
:
13071 return "DW_AT_language";
13073 return "DW_AT_member";
13075 return "DW_AT_discr";
13076 case DW_AT_discr_value
:
13077 return "DW_AT_discr_value";
13078 case DW_AT_visibility
:
13079 return "DW_AT_visibility";
13081 return "DW_AT_import";
13082 case DW_AT_string_length
:
13083 return "DW_AT_string_length";
13084 case DW_AT_common_reference
:
13085 return "DW_AT_common_reference";
13086 case DW_AT_comp_dir
:
13087 return "DW_AT_comp_dir";
13088 case DW_AT_const_value
:
13089 return "DW_AT_const_value";
13090 case DW_AT_containing_type
:
13091 return "DW_AT_containing_type";
13092 case DW_AT_default_value
:
13093 return "DW_AT_default_value";
13095 return "DW_AT_inline";
13096 case DW_AT_is_optional
:
13097 return "DW_AT_is_optional";
13098 case DW_AT_lower_bound
:
13099 return "DW_AT_lower_bound";
13100 case DW_AT_producer
:
13101 return "DW_AT_producer";
13102 case DW_AT_prototyped
:
13103 return "DW_AT_prototyped";
13104 case DW_AT_return_addr
:
13105 return "DW_AT_return_addr";
13106 case DW_AT_start_scope
:
13107 return "DW_AT_start_scope";
13108 case DW_AT_bit_stride
:
13109 return "DW_AT_bit_stride";
13110 case DW_AT_upper_bound
:
13111 return "DW_AT_upper_bound";
13112 case DW_AT_abstract_origin
:
13113 return "DW_AT_abstract_origin";
13114 case DW_AT_accessibility
:
13115 return "DW_AT_accessibility";
13116 case DW_AT_address_class
:
13117 return "DW_AT_address_class";
13118 case DW_AT_artificial
:
13119 return "DW_AT_artificial";
13120 case DW_AT_base_types
:
13121 return "DW_AT_base_types";
13122 case DW_AT_calling_convention
:
13123 return "DW_AT_calling_convention";
13125 return "DW_AT_count";
13126 case DW_AT_data_member_location
:
13127 return "DW_AT_data_member_location";
13128 case DW_AT_decl_column
:
13129 return "DW_AT_decl_column";
13130 case DW_AT_decl_file
:
13131 return "DW_AT_decl_file";
13132 case DW_AT_decl_line
:
13133 return "DW_AT_decl_line";
13134 case DW_AT_declaration
:
13135 return "DW_AT_declaration";
13136 case DW_AT_discr_list
:
13137 return "DW_AT_discr_list";
13138 case DW_AT_encoding
:
13139 return "DW_AT_encoding";
13140 case DW_AT_external
:
13141 return "DW_AT_external";
13142 case DW_AT_frame_base
:
13143 return "DW_AT_frame_base";
13145 return "DW_AT_friend";
13146 case DW_AT_identifier_case
:
13147 return "DW_AT_identifier_case";
13148 case DW_AT_macro_info
:
13149 return "DW_AT_macro_info";
13150 case DW_AT_namelist_items
:
13151 return "DW_AT_namelist_items";
13152 case DW_AT_priority
:
13153 return "DW_AT_priority";
13154 case DW_AT_segment
:
13155 return "DW_AT_segment";
13156 case DW_AT_specification
:
13157 return "DW_AT_specification";
13158 case DW_AT_static_link
:
13159 return "DW_AT_static_link";
13161 return "DW_AT_type";
13162 case DW_AT_use_location
:
13163 return "DW_AT_use_location";
13164 case DW_AT_variable_parameter
:
13165 return "DW_AT_variable_parameter";
13166 case DW_AT_virtuality
:
13167 return "DW_AT_virtuality";
13168 case DW_AT_vtable_elem_location
:
13169 return "DW_AT_vtable_elem_location";
13170 /* DWARF 3 values. */
13171 case DW_AT_allocated
:
13172 return "DW_AT_allocated";
13173 case DW_AT_associated
:
13174 return "DW_AT_associated";
13175 case DW_AT_data_location
:
13176 return "DW_AT_data_location";
13177 case DW_AT_byte_stride
:
13178 return "DW_AT_byte_stride";
13179 case DW_AT_entry_pc
:
13180 return "DW_AT_entry_pc";
13181 case DW_AT_use_UTF8
:
13182 return "DW_AT_use_UTF8";
13183 case DW_AT_extension
:
13184 return "DW_AT_extension";
13186 return "DW_AT_ranges";
13187 case DW_AT_trampoline
:
13188 return "DW_AT_trampoline";
13189 case DW_AT_call_column
:
13190 return "DW_AT_call_column";
13191 case DW_AT_call_file
:
13192 return "DW_AT_call_file";
13193 case DW_AT_call_line
:
13194 return "DW_AT_call_line";
13195 case DW_AT_description
:
13196 return "DW_AT_description";
13197 case DW_AT_binary_scale
:
13198 return "DW_AT_binary_scale";
13199 case DW_AT_decimal_scale
:
13200 return "DW_AT_decimal_scale";
13202 return "DW_AT_small";
13203 case DW_AT_decimal_sign
:
13204 return "DW_AT_decimal_sign";
13205 case DW_AT_digit_count
:
13206 return "DW_AT_digit_count";
13207 case DW_AT_picture_string
:
13208 return "DW_AT_picture_string";
13209 case DW_AT_mutable
:
13210 return "DW_AT_mutable";
13211 case DW_AT_threads_scaled
:
13212 return "DW_AT_threads_scaled";
13213 case DW_AT_explicit
:
13214 return "DW_AT_explicit";
13215 case DW_AT_object_pointer
:
13216 return "DW_AT_object_pointer";
13217 case DW_AT_endianity
:
13218 return "DW_AT_endianity";
13219 case DW_AT_elemental
:
13220 return "DW_AT_elemental";
13222 return "DW_AT_pure";
13223 case DW_AT_recursive
:
13224 return "DW_AT_recursive";
13225 /* DWARF 4 values. */
13226 case DW_AT_signature
:
13227 return "DW_AT_signature";
13228 case DW_AT_linkage_name
:
13229 return "DW_AT_linkage_name";
13230 /* SGI/MIPS extensions. */
13231 #ifdef MIPS /* collides with DW_AT_HP_block_index */
13232 case DW_AT_MIPS_fde
:
13233 return "DW_AT_MIPS_fde";
13235 case DW_AT_MIPS_loop_begin
:
13236 return "DW_AT_MIPS_loop_begin";
13237 case DW_AT_MIPS_tail_loop_begin
:
13238 return "DW_AT_MIPS_tail_loop_begin";
13239 case DW_AT_MIPS_epilog_begin
:
13240 return "DW_AT_MIPS_epilog_begin";
13241 case DW_AT_MIPS_loop_unroll_factor
:
13242 return "DW_AT_MIPS_loop_unroll_factor";
13243 case DW_AT_MIPS_software_pipeline_depth
:
13244 return "DW_AT_MIPS_software_pipeline_depth";
13245 case DW_AT_MIPS_linkage_name
:
13246 return "DW_AT_MIPS_linkage_name";
13247 case DW_AT_MIPS_stride
:
13248 return "DW_AT_MIPS_stride";
13249 case DW_AT_MIPS_abstract_name
:
13250 return "DW_AT_MIPS_abstract_name";
13251 case DW_AT_MIPS_clone_origin
:
13252 return "DW_AT_MIPS_clone_origin";
13253 case DW_AT_MIPS_has_inlines
:
13254 return "DW_AT_MIPS_has_inlines";
13255 /* HP extensions. */
13256 #ifndef MIPS /* collides with DW_AT_MIPS_fde */
13257 case DW_AT_HP_block_index
:
13258 return "DW_AT_HP_block_index";
13260 case DW_AT_HP_unmodifiable
:
13261 return "DW_AT_HP_unmodifiable";
13262 case DW_AT_HP_actuals_stmt_list
:
13263 return "DW_AT_HP_actuals_stmt_list";
13264 case DW_AT_HP_proc_per_section
:
13265 return "DW_AT_HP_proc_per_section";
13266 case DW_AT_HP_raw_data_ptr
:
13267 return "DW_AT_HP_raw_data_ptr";
13268 case DW_AT_HP_pass_by_reference
:
13269 return "DW_AT_HP_pass_by_reference";
13270 case DW_AT_HP_opt_level
:
13271 return "DW_AT_HP_opt_level";
13272 case DW_AT_HP_prof_version_id
:
13273 return "DW_AT_HP_prof_version_id";
13274 case DW_AT_HP_opt_flags
:
13275 return "DW_AT_HP_opt_flags";
13276 case DW_AT_HP_cold_region_low_pc
:
13277 return "DW_AT_HP_cold_region_low_pc";
13278 case DW_AT_HP_cold_region_high_pc
:
13279 return "DW_AT_HP_cold_region_high_pc";
13280 case DW_AT_HP_all_variables_modifiable
:
13281 return "DW_AT_HP_all_variables_modifiable";
13282 case DW_AT_HP_linkage_name
:
13283 return "DW_AT_HP_linkage_name";
13284 case DW_AT_HP_prof_flags
:
13285 return "DW_AT_HP_prof_flags";
13286 /* GNU extensions. */
13287 case DW_AT_sf_names
:
13288 return "DW_AT_sf_names";
13289 case DW_AT_src_info
:
13290 return "DW_AT_src_info";
13291 case DW_AT_mac_info
:
13292 return "DW_AT_mac_info";
13293 case DW_AT_src_coords
:
13294 return "DW_AT_src_coords";
13295 case DW_AT_body_begin
:
13296 return "DW_AT_body_begin";
13297 case DW_AT_body_end
:
13298 return "DW_AT_body_end";
13299 case DW_AT_GNU_vector
:
13300 return "DW_AT_GNU_vector";
13301 case DW_AT_GNU_odr_signature
:
13302 return "DW_AT_GNU_odr_signature";
13303 /* VMS extensions. */
13304 case DW_AT_VMS_rtnbeg_pd_address
:
13305 return "DW_AT_VMS_rtnbeg_pd_address";
13306 /* UPC extension. */
13307 case DW_AT_upc_threads_scaled
:
13308 return "DW_AT_upc_threads_scaled";
13309 /* PGI (STMicroelectronics) extensions. */
13310 case DW_AT_PGI_lbase
:
13311 return "DW_AT_PGI_lbase";
13312 case DW_AT_PGI_soffset
:
13313 return "DW_AT_PGI_soffset";
13314 case DW_AT_PGI_lstride
:
13315 return "DW_AT_PGI_lstride";
13317 return "DW_AT_<unknown>";
13321 /* Convert a DWARF value form code into its string name. */
13324 dwarf_form_name (unsigned form
)
13329 return "DW_FORM_addr";
13330 case DW_FORM_block2
:
13331 return "DW_FORM_block2";
13332 case DW_FORM_block4
:
13333 return "DW_FORM_block4";
13334 case DW_FORM_data2
:
13335 return "DW_FORM_data2";
13336 case DW_FORM_data4
:
13337 return "DW_FORM_data4";
13338 case DW_FORM_data8
:
13339 return "DW_FORM_data8";
13340 case DW_FORM_string
:
13341 return "DW_FORM_string";
13342 case DW_FORM_block
:
13343 return "DW_FORM_block";
13344 case DW_FORM_block1
:
13345 return "DW_FORM_block1";
13346 case DW_FORM_data1
:
13347 return "DW_FORM_data1";
13349 return "DW_FORM_flag";
13350 case DW_FORM_sdata
:
13351 return "DW_FORM_sdata";
13353 return "DW_FORM_strp";
13354 case DW_FORM_udata
:
13355 return "DW_FORM_udata";
13356 case DW_FORM_ref_addr
:
13357 return "DW_FORM_ref_addr";
13359 return "DW_FORM_ref1";
13361 return "DW_FORM_ref2";
13363 return "DW_FORM_ref4";
13365 return "DW_FORM_ref8";
13366 case DW_FORM_ref_udata
:
13367 return "DW_FORM_ref_udata";
13368 case DW_FORM_indirect
:
13369 return "DW_FORM_indirect";
13370 case DW_FORM_sec_offset
:
13371 return "DW_FORM_sec_offset";
13372 case DW_FORM_exprloc
:
13373 return "DW_FORM_exprloc";
13374 case DW_FORM_flag_present
:
13375 return "DW_FORM_flag_present";
13376 case DW_FORM_ref_sig8
:
13377 return "DW_FORM_ref_sig8";
13379 return "DW_FORM_<unknown>";
13383 /* Convert a DWARF stack opcode into its string name. */
13386 dwarf_stack_op_name (unsigned op
)
13391 return "DW_OP_addr";
13393 return "DW_OP_deref";
13394 case DW_OP_const1u
:
13395 return "DW_OP_const1u";
13396 case DW_OP_const1s
:
13397 return "DW_OP_const1s";
13398 case DW_OP_const2u
:
13399 return "DW_OP_const2u";
13400 case DW_OP_const2s
:
13401 return "DW_OP_const2s";
13402 case DW_OP_const4u
:
13403 return "DW_OP_const4u";
13404 case DW_OP_const4s
:
13405 return "DW_OP_const4s";
13406 case DW_OP_const8u
:
13407 return "DW_OP_const8u";
13408 case DW_OP_const8s
:
13409 return "DW_OP_const8s";
13411 return "DW_OP_constu";
13413 return "DW_OP_consts";
13415 return "DW_OP_dup";
13417 return "DW_OP_drop";
13419 return "DW_OP_over";
13421 return "DW_OP_pick";
13423 return "DW_OP_swap";
13425 return "DW_OP_rot";
13427 return "DW_OP_xderef";
13429 return "DW_OP_abs";
13431 return "DW_OP_and";
13433 return "DW_OP_div";
13435 return "DW_OP_minus";
13437 return "DW_OP_mod";
13439 return "DW_OP_mul";
13441 return "DW_OP_neg";
13443 return "DW_OP_not";
13447 return "DW_OP_plus";
13448 case DW_OP_plus_uconst
:
13449 return "DW_OP_plus_uconst";
13451 return "DW_OP_shl";
13453 return "DW_OP_shr";
13455 return "DW_OP_shra";
13457 return "DW_OP_xor";
13459 return "DW_OP_bra";
13473 return "DW_OP_skip";
13475 return "DW_OP_lit0";
13477 return "DW_OP_lit1";
13479 return "DW_OP_lit2";
13481 return "DW_OP_lit3";
13483 return "DW_OP_lit4";
13485 return "DW_OP_lit5";
13487 return "DW_OP_lit6";
13489 return "DW_OP_lit7";
13491 return "DW_OP_lit8";
13493 return "DW_OP_lit9";
13495 return "DW_OP_lit10";
13497 return "DW_OP_lit11";
13499 return "DW_OP_lit12";
13501 return "DW_OP_lit13";
13503 return "DW_OP_lit14";
13505 return "DW_OP_lit15";
13507 return "DW_OP_lit16";
13509 return "DW_OP_lit17";
13511 return "DW_OP_lit18";
13513 return "DW_OP_lit19";
13515 return "DW_OP_lit20";
13517 return "DW_OP_lit21";
13519 return "DW_OP_lit22";
13521 return "DW_OP_lit23";
13523 return "DW_OP_lit24";
13525 return "DW_OP_lit25";
13527 return "DW_OP_lit26";
13529 return "DW_OP_lit27";
13531 return "DW_OP_lit28";
13533 return "DW_OP_lit29";
13535 return "DW_OP_lit30";
13537 return "DW_OP_lit31";
13539 return "DW_OP_reg0";
13541 return "DW_OP_reg1";
13543 return "DW_OP_reg2";
13545 return "DW_OP_reg3";
13547 return "DW_OP_reg4";
13549 return "DW_OP_reg5";
13551 return "DW_OP_reg6";
13553 return "DW_OP_reg7";
13555 return "DW_OP_reg8";
13557 return "DW_OP_reg9";
13559 return "DW_OP_reg10";
13561 return "DW_OP_reg11";
13563 return "DW_OP_reg12";
13565 return "DW_OP_reg13";
13567 return "DW_OP_reg14";
13569 return "DW_OP_reg15";
13571 return "DW_OP_reg16";
13573 return "DW_OP_reg17";
13575 return "DW_OP_reg18";
13577 return "DW_OP_reg19";
13579 return "DW_OP_reg20";
13581 return "DW_OP_reg21";
13583 return "DW_OP_reg22";
13585 return "DW_OP_reg23";
13587 return "DW_OP_reg24";
13589 return "DW_OP_reg25";
13591 return "DW_OP_reg26";
13593 return "DW_OP_reg27";
13595 return "DW_OP_reg28";
13597 return "DW_OP_reg29";
13599 return "DW_OP_reg30";
13601 return "DW_OP_reg31";
13603 return "DW_OP_breg0";
13605 return "DW_OP_breg1";
13607 return "DW_OP_breg2";
13609 return "DW_OP_breg3";
13611 return "DW_OP_breg4";
13613 return "DW_OP_breg5";
13615 return "DW_OP_breg6";
13617 return "DW_OP_breg7";
13619 return "DW_OP_breg8";
13621 return "DW_OP_breg9";
13623 return "DW_OP_breg10";
13625 return "DW_OP_breg11";
13627 return "DW_OP_breg12";
13629 return "DW_OP_breg13";
13631 return "DW_OP_breg14";
13633 return "DW_OP_breg15";
13635 return "DW_OP_breg16";
13637 return "DW_OP_breg17";
13639 return "DW_OP_breg18";
13641 return "DW_OP_breg19";
13643 return "DW_OP_breg20";
13645 return "DW_OP_breg21";
13647 return "DW_OP_breg22";
13649 return "DW_OP_breg23";
13651 return "DW_OP_breg24";
13653 return "DW_OP_breg25";
13655 return "DW_OP_breg26";
13657 return "DW_OP_breg27";
13659 return "DW_OP_breg28";
13661 return "DW_OP_breg29";
13663 return "DW_OP_breg30";
13665 return "DW_OP_breg31";
13667 return "DW_OP_regx";
13669 return "DW_OP_fbreg";
13671 return "DW_OP_bregx";
13673 return "DW_OP_piece";
13674 case DW_OP_deref_size
:
13675 return "DW_OP_deref_size";
13676 case DW_OP_xderef_size
:
13677 return "DW_OP_xderef_size";
13679 return "DW_OP_nop";
13680 /* DWARF 3 extensions. */
13681 case DW_OP_push_object_address
:
13682 return "DW_OP_push_object_address";
13684 return "DW_OP_call2";
13686 return "DW_OP_call4";
13687 case DW_OP_call_ref
:
13688 return "DW_OP_call_ref";
13689 case DW_OP_form_tls_address
:
13690 return "DW_OP_form_tls_address";
13691 case DW_OP_call_frame_cfa
:
13692 return "DW_OP_call_frame_cfa";
13693 case DW_OP_bit_piece
:
13694 return "DW_OP_bit_piece";
13695 /* DWARF 4 extensions. */
13696 case DW_OP_implicit_value
:
13697 return "DW_OP_implicit_value";
13698 case DW_OP_stack_value
:
13699 return "DW_OP_stack_value";
13700 /* GNU extensions. */
13701 case DW_OP_GNU_push_tls_address
:
13702 return "DW_OP_GNU_push_tls_address";
13703 case DW_OP_GNU_uninit
:
13704 return "DW_OP_GNU_uninit";
13705 case DW_OP_GNU_implicit_pointer
:
13706 return "DW_OP_GNU_implicit_pointer";
13707 case DW_OP_GNU_entry_value
:
13708 return "DW_OP_GNU_entry_value";
13709 case DW_OP_GNU_const_type
:
13710 return "DW_OP_GNU_const_type";
13711 case DW_OP_GNU_regval_type
:
13712 return "DW_OP_GNU_regval_type";
13713 case DW_OP_GNU_deref_type
:
13714 return "DW_OP_GNU_deref_type";
13715 case DW_OP_GNU_convert
:
13716 return "DW_OP_GNU_convert";
13717 case DW_OP_GNU_reinterpret
:
13718 return "DW_OP_GNU_reinterpret";
13725 dwarf_bool_name (unsigned mybool
)
13733 /* Convert a DWARF type code into its string name. */
13736 dwarf_type_encoding_name (unsigned enc
)
13741 return "DW_ATE_void";
13742 case DW_ATE_address
:
13743 return "DW_ATE_address";
13744 case DW_ATE_boolean
:
13745 return "DW_ATE_boolean";
13746 case DW_ATE_complex_float
:
13747 return "DW_ATE_complex_float";
13749 return "DW_ATE_float";
13750 case DW_ATE_signed
:
13751 return "DW_ATE_signed";
13752 case DW_ATE_signed_char
:
13753 return "DW_ATE_signed_char";
13754 case DW_ATE_unsigned
:
13755 return "DW_ATE_unsigned";
13756 case DW_ATE_unsigned_char
:
13757 return "DW_ATE_unsigned_char";
13759 case DW_ATE_imaginary_float
:
13760 return "DW_ATE_imaginary_float";
13761 case DW_ATE_packed_decimal
:
13762 return "DW_ATE_packed_decimal";
13763 case DW_ATE_numeric_string
:
13764 return "DW_ATE_numeric_string";
13765 case DW_ATE_edited
:
13766 return "DW_ATE_edited";
13767 case DW_ATE_signed_fixed
:
13768 return "DW_ATE_signed_fixed";
13769 case DW_ATE_unsigned_fixed
:
13770 return "DW_ATE_unsigned_fixed";
13771 case DW_ATE_decimal_float
:
13772 return "DW_ATE_decimal_float";
13775 return "DW_ATE_UTF";
13776 /* HP extensions. */
13777 case DW_ATE_HP_float80
:
13778 return "DW_ATE_HP_float80";
13779 case DW_ATE_HP_complex_float80
:
13780 return "DW_ATE_HP_complex_float80";
13781 case DW_ATE_HP_float128
:
13782 return "DW_ATE_HP_float128";
13783 case DW_ATE_HP_complex_float128
:
13784 return "DW_ATE_HP_complex_float128";
13785 case DW_ATE_HP_floathpintel
:
13786 return "DW_ATE_HP_floathpintel";
13787 case DW_ATE_HP_imaginary_float80
:
13788 return "DW_ATE_HP_imaginary_float80";
13789 case DW_ATE_HP_imaginary_float128
:
13790 return "DW_ATE_HP_imaginary_float128";
13792 return "DW_ATE_<unknown>";
13796 /* Convert a DWARF call frame info operation to its string name. */
13800 dwarf_cfi_name (unsigned cfi_opc
)
13804 case DW_CFA_advance_loc
:
13805 return "DW_CFA_advance_loc";
13806 case DW_CFA_offset
:
13807 return "DW_CFA_offset";
13808 case DW_CFA_restore
:
13809 return "DW_CFA_restore";
13811 return "DW_CFA_nop";
13812 case DW_CFA_set_loc
:
13813 return "DW_CFA_set_loc";
13814 case DW_CFA_advance_loc1
:
13815 return "DW_CFA_advance_loc1";
13816 case DW_CFA_advance_loc2
:
13817 return "DW_CFA_advance_loc2";
13818 case DW_CFA_advance_loc4
:
13819 return "DW_CFA_advance_loc4";
13820 case DW_CFA_offset_extended
:
13821 return "DW_CFA_offset_extended";
13822 case DW_CFA_restore_extended
:
13823 return "DW_CFA_restore_extended";
13824 case DW_CFA_undefined
:
13825 return "DW_CFA_undefined";
13826 case DW_CFA_same_value
:
13827 return "DW_CFA_same_value";
13828 case DW_CFA_register
:
13829 return "DW_CFA_register";
13830 case DW_CFA_remember_state
:
13831 return "DW_CFA_remember_state";
13832 case DW_CFA_restore_state
:
13833 return "DW_CFA_restore_state";
13834 case DW_CFA_def_cfa
:
13835 return "DW_CFA_def_cfa";
13836 case DW_CFA_def_cfa_register
:
13837 return "DW_CFA_def_cfa_register";
13838 case DW_CFA_def_cfa_offset
:
13839 return "DW_CFA_def_cfa_offset";
13841 case DW_CFA_def_cfa_expression
:
13842 return "DW_CFA_def_cfa_expression";
13843 case DW_CFA_expression
:
13844 return "DW_CFA_expression";
13845 case DW_CFA_offset_extended_sf
:
13846 return "DW_CFA_offset_extended_sf";
13847 case DW_CFA_def_cfa_sf
:
13848 return "DW_CFA_def_cfa_sf";
13849 case DW_CFA_def_cfa_offset_sf
:
13850 return "DW_CFA_def_cfa_offset_sf";
13851 case DW_CFA_val_offset
:
13852 return "DW_CFA_val_offset";
13853 case DW_CFA_val_offset_sf
:
13854 return "DW_CFA_val_offset_sf";
13855 case DW_CFA_val_expression
:
13856 return "DW_CFA_val_expression";
13857 /* SGI/MIPS specific. */
13858 case DW_CFA_MIPS_advance_loc8
:
13859 return "DW_CFA_MIPS_advance_loc8";
13860 /* GNU extensions. */
13861 case DW_CFA_GNU_window_save
:
13862 return "DW_CFA_GNU_window_save";
13863 case DW_CFA_GNU_args_size
:
13864 return "DW_CFA_GNU_args_size";
13865 case DW_CFA_GNU_negative_offset_extended
:
13866 return "DW_CFA_GNU_negative_offset_extended";
13868 return "DW_CFA_<unknown>";
13874 dump_die_shallow (struct ui_file
*f
, int indent
, struct die_info
*die
)
13878 print_spaces (indent
, f
);
13879 fprintf_unfiltered (f
, "Die: %s (abbrev %d, offset 0x%x)\n",
13880 dwarf_tag_name (die
->tag
), die
->abbrev
, die
->offset
);
13882 if (die
->parent
!= NULL
)
13884 print_spaces (indent
, f
);
13885 fprintf_unfiltered (f
, " parent at offset: 0x%x\n",
13886 die
->parent
->offset
);
13889 print_spaces (indent
, f
);
13890 fprintf_unfiltered (f
, " has children: %s\n",
13891 dwarf_bool_name (die
->child
!= NULL
));
13893 print_spaces (indent
, f
);
13894 fprintf_unfiltered (f
, " attributes:\n");
13896 for (i
= 0; i
< die
->num_attrs
; ++i
)
13898 print_spaces (indent
, f
);
13899 fprintf_unfiltered (f
, " %s (%s) ",
13900 dwarf_attr_name (die
->attrs
[i
].name
),
13901 dwarf_form_name (die
->attrs
[i
].form
));
13903 switch (die
->attrs
[i
].form
)
13905 case DW_FORM_ref_addr
:
13907 fprintf_unfiltered (f
, "address: ");
13908 fputs_filtered (hex_string (DW_ADDR (&die
->attrs
[i
])), f
);
13910 case DW_FORM_block2
:
13911 case DW_FORM_block4
:
13912 case DW_FORM_block
:
13913 case DW_FORM_block1
:
13914 fprintf_unfiltered (f
, "block: size %d",
13915 DW_BLOCK (&die
->attrs
[i
])->size
);
13917 case DW_FORM_exprloc
:
13918 fprintf_unfiltered (f
, "expression: size %u",
13919 DW_BLOCK (&die
->attrs
[i
])->size
);
13924 fprintf_unfiltered (f
, "constant ref: 0x%lx (adjusted)",
13925 (long) (DW_ADDR (&die
->attrs
[i
])));
13927 case DW_FORM_data1
:
13928 case DW_FORM_data2
:
13929 case DW_FORM_data4
:
13930 case DW_FORM_data8
:
13931 case DW_FORM_udata
:
13932 case DW_FORM_sdata
:
13933 fprintf_unfiltered (f
, "constant: %s",
13934 pulongest (DW_UNSND (&die
->attrs
[i
])));
13936 case DW_FORM_sec_offset
:
13937 fprintf_unfiltered (f
, "section offset: %s",
13938 pulongest (DW_UNSND (&die
->attrs
[i
])));
13940 case DW_FORM_ref_sig8
:
13941 if (DW_SIGNATURED_TYPE (&die
->attrs
[i
]) != NULL
)
13942 fprintf_unfiltered (f
, "signatured type, offset: 0x%x",
13943 DW_SIGNATURED_TYPE (&die
->attrs
[i
])->per_cu
.offset
);
13945 fprintf_unfiltered (f
, "signatured type, offset: unknown");
13947 case DW_FORM_string
:
13949 fprintf_unfiltered (f
, "string: \"%s\" (%s canonicalized)",
13950 DW_STRING (&die
->attrs
[i
])
13951 ? DW_STRING (&die
->attrs
[i
]) : "",
13952 DW_STRING_IS_CANONICAL (&die
->attrs
[i
]) ? "is" : "not");
13955 if (DW_UNSND (&die
->attrs
[i
]))
13956 fprintf_unfiltered (f
, "flag: TRUE");
13958 fprintf_unfiltered (f
, "flag: FALSE");
13960 case DW_FORM_flag_present
:
13961 fprintf_unfiltered (f
, "flag: TRUE");
13963 case DW_FORM_indirect
:
13964 /* The reader will have reduced the indirect form to
13965 the "base form" so this form should not occur. */
13966 fprintf_unfiltered (f
,
13967 "unexpected attribute form: DW_FORM_indirect");
13970 fprintf_unfiltered (f
, "unsupported attribute form: %d.",
13971 die
->attrs
[i
].form
);
13974 fprintf_unfiltered (f
, "\n");
13979 dump_die_for_error (struct die_info
*die
)
13981 dump_die_shallow (gdb_stderr
, 0, die
);
13985 dump_die_1 (struct ui_file
*f
, int level
, int max_level
, struct die_info
*die
)
13987 int indent
= level
* 4;
13989 gdb_assert (die
!= NULL
);
13991 if (level
>= max_level
)
13994 dump_die_shallow (f
, indent
, die
);
13996 if (die
->child
!= NULL
)
13998 print_spaces (indent
, f
);
13999 fprintf_unfiltered (f
, " Children:");
14000 if (level
+ 1 < max_level
)
14002 fprintf_unfiltered (f
, "\n");
14003 dump_die_1 (f
, level
+ 1, max_level
, die
->child
);
14007 fprintf_unfiltered (f
,
14008 " [not printed, max nesting level reached]\n");
14012 if (die
->sibling
!= NULL
&& level
> 0)
14014 dump_die_1 (f
, level
, max_level
, die
->sibling
);
14018 /* This is called from the pdie macro in gdbinit.in.
14019 It's not static so gcc will keep a copy callable from gdb. */
14022 dump_die (struct die_info
*die
, int max_level
)
14024 dump_die_1 (gdb_stdlog
, 0, max_level
, die
);
14028 store_in_ref_table (struct die_info
*die
, struct dwarf2_cu
*cu
)
14032 slot
= htab_find_slot_with_hash (cu
->die_hash
, die
, die
->offset
, INSERT
);
14038 is_ref_attr (struct attribute
*attr
)
14040 switch (attr
->form
)
14042 case DW_FORM_ref_addr
:
14047 case DW_FORM_ref_udata
:
14054 static unsigned int
14055 dwarf2_get_ref_die_offset (struct attribute
*attr
)
14057 if (is_ref_attr (attr
))
14058 return DW_ADDR (attr
);
14060 complaint (&symfile_complaints
,
14061 _("unsupported die ref attribute form: '%s'"),
14062 dwarf_form_name (attr
->form
));
14066 /* Return the constant value held by ATTR. Return DEFAULT_VALUE if
14067 * the value held by the attribute is not constant. */
14070 dwarf2_get_attr_constant_value (struct attribute
*attr
, int default_value
)
14072 if (attr
->form
== DW_FORM_sdata
)
14073 return DW_SND (attr
);
14074 else if (attr
->form
== DW_FORM_udata
14075 || attr
->form
== DW_FORM_data1
14076 || attr
->form
== DW_FORM_data2
14077 || attr
->form
== DW_FORM_data4
14078 || attr
->form
== DW_FORM_data8
)
14079 return DW_UNSND (attr
);
14082 complaint (&symfile_complaints
,
14083 _("Attribute value is not a constant (%s)"),
14084 dwarf_form_name (attr
->form
));
14085 return default_value
;
14089 /* THIS_CU has a reference to PER_CU. If necessary, load the new compilation
14090 unit and add it to our queue.
14091 The result is non-zero if PER_CU was queued, otherwise the result is zero
14092 meaning either PER_CU is already queued or it is already loaded. */
14095 maybe_queue_comp_unit (struct dwarf2_cu
*this_cu
,
14096 struct dwarf2_per_cu_data
*per_cu
)
14098 /* We may arrive here during partial symbol reading, if we need full
14099 DIEs to process an unusual case (e.g. template arguments). Do
14100 not queue PER_CU, just tell our caller to load its DIEs. */
14101 if (dwarf2_per_objfile
->reading_partial_symbols
)
14103 if (per_cu
->cu
== NULL
|| per_cu
->cu
->dies
== NULL
)
14108 /* Mark the dependence relation so that we don't flush PER_CU
14110 dwarf2_add_dependence (this_cu
, per_cu
);
14112 /* If it's already on the queue, we have nothing to do. */
14113 if (per_cu
->queued
)
14116 /* If the compilation unit is already loaded, just mark it as
14118 if (per_cu
->cu
!= NULL
)
14120 per_cu
->cu
->last_used
= 0;
14124 /* Add it to the queue. */
14125 queue_comp_unit (per_cu
);
14130 /* Follow reference or signature attribute ATTR of SRC_DIE.
14131 On entry *REF_CU is the CU of SRC_DIE.
14132 On exit *REF_CU is the CU of the result. */
14134 static struct die_info
*
14135 follow_die_ref_or_sig (struct die_info
*src_die
, struct attribute
*attr
,
14136 struct dwarf2_cu
**ref_cu
)
14138 struct die_info
*die
;
14140 if (is_ref_attr (attr
))
14141 die
= follow_die_ref (src_die
, attr
, ref_cu
);
14142 else if (attr
->form
== DW_FORM_ref_sig8
)
14143 die
= follow_die_sig (src_die
, attr
, ref_cu
);
14146 dump_die_for_error (src_die
);
14147 error (_("Dwarf Error: Expected reference attribute [in module %s]"),
14148 (*ref_cu
)->objfile
->name
);
14154 /* Follow reference OFFSET.
14155 On entry *REF_CU is the CU of the source die referencing OFFSET.
14156 On exit *REF_CU is the CU of the result.
14157 Returns NULL if OFFSET is invalid. */
14159 static struct die_info
*
14160 follow_die_offset (unsigned int offset
, struct dwarf2_cu
**ref_cu
)
14162 struct die_info temp_die
;
14163 struct dwarf2_cu
*target_cu
, *cu
= *ref_cu
;
14165 gdb_assert (cu
->per_cu
!= NULL
);
14169 if (cu
->per_cu
->debug_types_section
)
14171 /* .debug_types CUs cannot reference anything outside their CU.
14172 If they need to, they have to reference a signatured type via
14173 DW_FORM_ref_sig8. */
14174 if (! offset_in_cu_p (&cu
->header
, offset
))
14177 else if (! offset_in_cu_p (&cu
->header
, offset
))
14179 struct dwarf2_per_cu_data
*per_cu
;
14181 per_cu
= dwarf2_find_containing_comp_unit (offset
, cu
->objfile
);
14183 /* If necessary, add it to the queue and load its DIEs. */
14184 if (maybe_queue_comp_unit (cu
, per_cu
))
14185 load_full_comp_unit (per_cu
);
14187 target_cu
= per_cu
->cu
;
14189 else if (cu
->dies
== NULL
)
14191 /* We're loading full DIEs during partial symbol reading. */
14192 gdb_assert (dwarf2_per_objfile
->reading_partial_symbols
);
14193 load_full_comp_unit (cu
->per_cu
);
14196 *ref_cu
= target_cu
;
14197 temp_die
.offset
= offset
;
14198 return htab_find_with_hash (target_cu
->die_hash
, &temp_die
, offset
);
14201 /* Follow reference attribute ATTR of SRC_DIE.
14202 On entry *REF_CU is the CU of SRC_DIE.
14203 On exit *REF_CU is the CU of the result. */
14205 static struct die_info
*
14206 follow_die_ref (struct die_info
*src_die
, struct attribute
*attr
,
14207 struct dwarf2_cu
**ref_cu
)
14209 unsigned int offset
= dwarf2_get_ref_die_offset (attr
);
14210 struct dwarf2_cu
*cu
= *ref_cu
;
14211 struct die_info
*die
;
14213 die
= follow_die_offset (offset
, ref_cu
);
14215 error (_("Dwarf Error: Cannot find DIE at 0x%x referenced from DIE "
14216 "at 0x%x [in module %s]"),
14217 offset
, src_die
->offset
, cu
->objfile
->name
);
14222 /* Return DWARF block referenced by DW_AT_location of DIE at OFFSET at PER_CU.
14223 Returned value is intended for DW_OP_call*. Returned
14224 dwarf2_locexpr_baton->data has lifetime of PER_CU->OBJFILE. */
14226 struct dwarf2_locexpr_baton
14227 dwarf2_fetch_die_location_block (unsigned int offset
,
14228 struct dwarf2_per_cu_data
*per_cu
,
14229 CORE_ADDR (*get_frame_pc
) (void *baton
),
14232 struct dwarf2_cu
*cu
;
14233 struct die_info
*die
;
14234 struct attribute
*attr
;
14235 struct dwarf2_locexpr_baton retval
;
14237 dw2_setup (per_cu
->objfile
);
14239 if (per_cu
->cu
== NULL
)
14243 die
= follow_die_offset (offset
, &cu
);
14245 error (_("Dwarf Error: Cannot find DIE at 0x%x referenced in module %s"),
14246 offset
, per_cu
->objfile
->name
);
14248 attr
= dwarf2_attr (die
, DW_AT_location
, cu
);
14251 /* DWARF: "If there is no such attribute, then there is no effect.".
14252 DATA is ignored if SIZE is 0. */
14254 retval
.data
= NULL
;
14257 else if (attr_form_is_section_offset (attr
))
14259 struct dwarf2_loclist_baton loclist_baton
;
14260 CORE_ADDR pc
= (*get_frame_pc
) (baton
);
14263 fill_in_loclist_baton (cu
, &loclist_baton
, attr
);
14265 retval
.data
= dwarf2_find_location_expression (&loclist_baton
,
14267 retval
.size
= size
;
14271 if (!attr_form_is_block (attr
))
14272 error (_("Dwarf Error: DIE at 0x%x referenced in module %s "
14273 "is neither DW_FORM_block* nor DW_FORM_exprloc"),
14274 offset
, per_cu
->objfile
->name
);
14276 retval
.data
= DW_BLOCK (attr
)->data
;
14277 retval
.size
= DW_BLOCK (attr
)->size
;
14279 retval
.per_cu
= cu
->per_cu
;
14281 age_cached_comp_units ();
14286 /* Return the type of the DIE at DIE_OFFSET in the CU named by
14290 dwarf2_get_die_type (unsigned int die_offset
,
14291 struct dwarf2_per_cu_data
*per_cu
)
14293 dw2_setup (per_cu
->objfile
);
14294 return get_die_type_at_offset (die_offset
, per_cu
);
14297 /* Follow the signature attribute ATTR in 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_sig (struct die_info
*src_die
, struct attribute
*attr
,
14303 struct dwarf2_cu
**ref_cu
)
14305 struct objfile
*objfile
= (*ref_cu
)->objfile
;
14306 struct die_info temp_die
;
14307 struct signatured_type
*sig_type
= DW_SIGNATURED_TYPE (attr
);
14308 struct dwarf2_cu
*sig_cu
;
14309 struct die_info
*die
;
14311 /* sig_type will be NULL if the signatured type is missing from
14313 if (sig_type
== NULL
)
14314 error (_("Dwarf Error: Cannot find signatured DIE referenced from DIE "
14315 "at 0x%x [in module %s]"),
14316 src_die
->offset
, objfile
->name
);
14318 /* If necessary, add it to the queue and load its DIEs. */
14320 if (maybe_queue_comp_unit (*ref_cu
, &sig_type
->per_cu
))
14321 read_signatured_type (sig_type
);
14323 gdb_assert (sig_type
->per_cu
.cu
!= NULL
);
14325 sig_cu
= sig_type
->per_cu
.cu
;
14326 temp_die
.offset
= sig_cu
->header
.offset
+ sig_type
->type_offset
;
14327 die
= htab_find_with_hash (sig_cu
->die_hash
, &temp_die
, temp_die
.offset
);
14334 error (_("Dwarf Error: Cannot find signatured DIE at 0x%x referenced "
14335 "from DIE at 0x%x [in module %s]"),
14336 sig_type
->type_offset
, src_die
->offset
, objfile
->name
);
14339 /* Given an offset of a signatured type, return its signatured_type. */
14341 static struct signatured_type
*
14342 lookup_signatured_type_at_offset (struct objfile
*objfile
,
14343 struct dwarf2_section_info
*section
,
14344 unsigned int offset
)
14346 gdb_byte
*info_ptr
= section
->buffer
+ offset
;
14347 unsigned int length
, initial_length_size
;
14348 unsigned int sig_offset
;
14349 struct signatured_type find_entry
, *type_sig
;
14351 length
= read_initial_length (objfile
->obfd
, info_ptr
, &initial_length_size
);
14352 sig_offset
= (initial_length_size
14354 + (initial_length_size
== 4 ? 4 : 8) /*debug_abbrev_offset*/
14355 + 1 /*address_size*/);
14356 find_entry
.signature
= bfd_get_64 (objfile
->obfd
, info_ptr
+ sig_offset
);
14357 type_sig
= htab_find (dwarf2_per_objfile
->signatured_types
, &find_entry
);
14359 /* This is only used to lookup previously recorded types.
14360 If we didn't find it, it's our bug. */
14361 gdb_assert (type_sig
!= NULL
);
14362 gdb_assert (offset
== type_sig
->per_cu
.offset
);
14367 /* Load the DIEs associated with type unit PER_CU into memory. */
14370 load_full_type_unit (struct dwarf2_per_cu_data
*per_cu
)
14372 struct objfile
*objfile
= per_cu
->objfile
;
14373 struct dwarf2_section_info
*sect
= per_cu
->debug_types_section
;
14374 unsigned int offset
= per_cu
->offset
;
14375 struct signatured_type
*type_sig
;
14377 dwarf2_read_section (objfile
, sect
);
14379 /* We have the section offset, but we need the signature to do the
14380 hash table lookup. */
14381 /* FIXME: This is sorta unnecessary, read_signatured_type only uses
14382 the signature to assert we found the right one.
14383 Ok, but it's a lot of work. We should simplify things so any needed
14384 assert doesn't require all this clumsiness. */
14385 type_sig
= lookup_signatured_type_at_offset (objfile
, sect
, offset
);
14387 gdb_assert (type_sig
->per_cu
.cu
== NULL
);
14389 read_signatured_type (type_sig
);
14391 gdb_assert (type_sig
->per_cu
.cu
!= NULL
);
14394 /* Read in a signatured type and build its CU and DIEs. */
14397 read_signatured_type (struct signatured_type
*type_sig
)
14399 struct objfile
*objfile
= type_sig
->per_cu
.objfile
;
14400 gdb_byte
*types_ptr
;
14401 struct die_reader_specs reader_specs
;
14402 struct dwarf2_cu
*cu
;
14403 ULONGEST signature
;
14404 struct cleanup
*back_to
, *free_cu_cleanup
;
14405 struct dwarf2_section_info
*section
= type_sig
->per_cu
.debug_types_section
;
14407 dwarf2_read_section (objfile
, section
);
14408 types_ptr
= section
->buffer
+ type_sig
->per_cu
.offset
;
14410 gdb_assert (type_sig
->per_cu
.cu
== NULL
);
14412 cu
= xmalloc (sizeof (*cu
));
14413 init_one_comp_unit (cu
, &type_sig
->per_cu
);
14415 /* If an error occurs while loading, release our storage. */
14416 free_cu_cleanup
= make_cleanup (free_heap_comp_unit
, cu
);
14418 types_ptr
= read_type_comp_unit_head (&cu
->header
, section
, &signature
,
14419 types_ptr
, objfile
->obfd
);
14420 gdb_assert (signature
== type_sig
->signature
);
14423 = htab_create_alloc_ex (cu
->header
.length
/ 12,
14427 &cu
->comp_unit_obstack
,
14428 hashtab_obstack_allocate
,
14429 dummy_obstack_deallocate
);
14431 dwarf2_read_abbrevs (cu
);
14432 back_to
= make_cleanup (dwarf2_free_abbrev_table
, cu
);
14434 init_cu_die_reader (&reader_specs
, cu
);
14436 cu
->dies
= read_die_and_children (&reader_specs
, types_ptr
, &types_ptr
,
14439 /* We try not to read any attributes in this function, because not
14440 all CUs needed for references have been loaded yet, and symbol
14441 table processing isn't initialized. But we have to set the CU language,
14442 or we won't be able to build types correctly. */
14443 prepare_one_comp_unit (cu
, cu
->dies
);
14445 do_cleanups (back_to
);
14447 /* We've successfully allocated this compilation unit. Let our caller
14448 clean it up when finished with it. */
14449 discard_cleanups (free_cu_cleanup
);
14451 type_sig
->per_cu
.cu
->read_in_chain
= dwarf2_per_objfile
->read_in_chain
;
14452 dwarf2_per_objfile
->read_in_chain
= &type_sig
->per_cu
;
14455 /* Decode simple location descriptions.
14456 Given a pointer to a dwarf block that defines a location, compute
14457 the location and return the value.
14459 NOTE drow/2003-11-18: This function is called in two situations
14460 now: for the address of static or global variables (partial symbols
14461 only) and for offsets into structures which are expected to be
14462 (more or less) constant. The partial symbol case should go away,
14463 and only the constant case should remain. That will let this
14464 function complain more accurately. A few special modes are allowed
14465 without complaint for global variables (for instance, global
14466 register values and thread-local values).
14468 A location description containing no operations indicates that the
14469 object is optimized out. The return value is 0 for that case.
14470 FIXME drow/2003-11-16: No callers check for this case any more; soon all
14471 callers will only want a very basic result and this can become a
14474 Note that stack[0] is unused except as a default error return. */
14477 decode_locdesc (struct dwarf_block
*blk
, struct dwarf2_cu
*cu
)
14479 struct objfile
*objfile
= cu
->objfile
;
14481 int size
= blk
->size
;
14482 gdb_byte
*data
= blk
->data
;
14483 CORE_ADDR stack
[64];
14485 unsigned int bytes_read
, unsnd
;
14491 stack
[++stacki
] = 0;
14530 stack
[++stacki
] = op
- DW_OP_lit0
;
14565 stack
[++stacki
] = op
- DW_OP_reg0
;
14567 dwarf2_complex_location_expr_complaint ();
14571 unsnd
= read_unsigned_leb128 (NULL
, (data
+ i
), &bytes_read
);
14573 stack
[++stacki
] = unsnd
;
14575 dwarf2_complex_location_expr_complaint ();
14579 stack
[++stacki
] = read_address (objfile
->obfd
, &data
[i
],
14584 case DW_OP_const1u
:
14585 stack
[++stacki
] = read_1_byte (objfile
->obfd
, &data
[i
]);
14589 case DW_OP_const1s
:
14590 stack
[++stacki
] = read_1_signed_byte (objfile
->obfd
, &data
[i
]);
14594 case DW_OP_const2u
:
14595 stack
[++stacki
] = read_2_bytes (objfile
->obfd
, &data
[i
]);
14599 case DW_OP_const2s
:
14600 stack
[++stacki
] = read_2_signed_bytes (objfile
->obfd
, &data
[i
]);
14604 case DW_OP_const4u
:
14605 stack
[++stacki
] = read_4_bytes (objfile
->obfd
, &data
[i
]);
14609 case DW_OP_const4s
:
14610 stack
[++stacki
] = read_4_signed_bytes (objfile
->obfd
, &data
[i
]);
14614 case DW_OP_const8u
:
14615 stack
[++stacki
] = read_8_bytes (objfile
->obfd
, &data
[i
]);
14620 stack
[++stacki
] = read_unsigned_leb128 (NULL
, (data
+ i
),
14626 stack
[++stacki
] = read_signed_leb128 (NULL
, (data
+ i
), &bytes_read
);
14631 stack
[stacki
+ 1] = stack
[stacki
];
14636 stack
[stacki
- 1] += stack
[stacki
];
14640 case DW_OP_plus_uconst
:
14641 stack
[stacki
] += read_unsigned_leb128 (NULL
, (data
+ i
),
14647 stack
[stacki
- 1] -= stack
[stacki
];
14652 /* If we're not the last op, then we definitely can't encode
14653 this using GDB's address_class enum. This is valid for partial
14654 global symbols, although the variable's address will be bogus
14657 dwarf2_complex_location_expr_complaint ();
14660 case DW_OP_GNU_push_tls_address
:
14661 /* The top of the stack has the offset from the beginning
14662 of the thread control block at which the variable is located. */
14663 /* Nothing should follow this operator, so the top of stack would
14665 /* This is valid for partial global symbols, but the variable's
14666 address will be bogus in the psymtab. Make it always at least
14667 non-zero to not look as a variable garbage collected by linker
14668 which have DW_OP_addr 0. */
14670 dwarf2_complex_location_expr_complaint ();
14674 case DW_OP_GNU_uninit
:
14679 const char *name
= dwarf_stack_op_name (op
);
14682 complaint (&symfile_complaints
, _("unsupported stack op: '%s'"),
14685 complaint (&symfile_complaints
, _("unsupported stack op: '%02x'"),
14689 return (stack
[stacki
]);
14692 /* Enforce maximum stack depth of SIZE-1 to avoid writing
14693 outside of the allocated space. Also enforce minimum>0. */
14694 if (stacki
>= ARRAY_SIZE (stack
) - 1)
14696 complaint (&symfile_complaints
,
14697 _("location description stack overflow"));
14703 complaint (&symfile_complaints
,
14704 _("location description stack underflow"));
14708 return (stack
[stacki
]);
14711 /* memory allocation interface */
14713 static struct dwarf_block
*
14714 dwarf_alloc_block (struct dwarf2_cu
*cu
)
14716 struct dwarf_block
*blk
;
14718 blk
= (struct dwarf_block
*)
14719 obstack_alloc (&cu
->comp_unit_obstack
, sizeof (struct dwarf_block
));
14723 static struct abbrev_info
*
14724 dwarf_alloc_abbrev (struct dwarf2_cu
*cu
)
14726 struct abbrev_info
*abbrev
;
14728 abbrev
= (struct abbrev_info
*)
14729 obstack_alloc (&cu
->abbrev_obstack
, sizeof (struct abbrev_info
));
14730 memset (abbrev
, 0, sizeof (struct abbrev_info
));
14734 static struct die_info
*
14735 dwarf_alloc_die (struct dwarf2_cu
*cu
, int num_attrs
)
14737 struct die_info
*die
;
14738 size_t size
= sizeof (struct die_info
);
14741 size
+= (num_attrs
- 1) * sizeof (struct attribute
);
14743 die
= (struct die_info
*) obstack_alloc (&cu
->comp_unit_obstack
, size
);
14744 memset (die
, 0, sizeof (struct die_info
));
14749 /* Macro support. */
14751 /* Return the full name of file number I in *LH's file name table.
14752 Use COMP_DIR as the name of the current directory of the
14753 compilation. The result is allocated using xmalloc; the caller is
14754 responsible for freeing it. */
14756 file_full_name (int file
, struct line_header
*lh
, const char *comp_dir
)
14758 /* Is the file number a valid index into the line header's file name
14759 table? Remember that file numbers start with one, not zero. */
14760 if (1 <= file
&& file
<= lh
->num_file_names
)
14762 struct file_entry
*fe
= &lh
->file_names
[file
- 1];
14764 if (IS_ABSOLUTE_PATH (fe
->name
))
14765 return xstrdup (fe
->name
);
14773 dir
= lh
->include_dirs
[fe
->dir_index
- 1];
14779 dir_len
= strlen (dir
);
14780 full_name
= xmalloc (dir_len
+ 1 + strlen (fe
->name
) + 1);
14781 strcpy (full_name
, dir
);
14782 full_name
[dir_len
] = '/';
14783 strcpy (full_name
+ dir_len
+ 1, fe
->name
);
14787 return xstrdup (fe
->name
);
14792 /* The compiler produced a bogus file number. We can at least
14793 record the macro definitions made in the file, even if we
14794 won't be able to find the file by name. */
14795 char fake_name
[80];
14797 sprintf (fake_name
, "<bad macro file number %d>", file
);
14799 complaint (&symfile_complaints
,
14800 _("bad file number in macro information (%d)"),
14803 return xstrdup (fake_name
);
14808 static struct macro_source_file
*
14809 macro_start_file (int file
, int line
,
14810 struct macro_source_file
*current_file
,
14811 const char *comp_dir
,
14812 struct line_header
*lh
, struct objfile
*objfile
)
14814 /* The full name of this source file. */
14815 char *full_name
= file_full_name (file
, lh
, comp_dir
);
14817 /* We don't create a macro table for this compilation unit
14818 at all until we actually get a filename. */
14819 if (! pending_macros
)
14820 pending_macros
= new_macro_table (&objfile
->objfile_obstack
,
14821 objfile
->macro_cache
);
14823 if (! current_file
)
14824 /* If we have no current file, then this must be the start_file
14825 directive for the compilation unit's main source file. */
14826 current_file
= macro_set_main (pending_macros
, full_name
);
14828 current_file
= macro_include (current_file
, line
, full_name
);
14832 return current_file
;
14836 /* Copy the LEN characters at BUF to a xmalloc'ed block of memory,
14837 followed by a null byte. */
14839 copy_string (const char *buf
, int len
)
14841 char *s
= xmalloc (len
+ 1);
14843 memcpy (s
, buf
, len
);
14849 static const char *
14850 consume_improper_spaces (const char *p
, const char *body
)
14854 complaint (&symfile_complaints
,
14855 _("macro definition contains spaces "
14856 "in formal argument list:\n`%s'"),
14868 parse_macro_definition (struct macro_source_file
*file
, int line
,
14873 /* The body string takes one of two forms. For object-like macro
14874 definitions, it should be:
14876 <macro name> " " <definition>
14878 For function-like macro definitions, it should be:
14880 <macro name> "() " <definition>
14882 <macro name> "(" <arg name> ( "," <arg name> ) * ") " <definition>
14884 Spaces may appear only where explicitly indicated, and in the
14887 The Dwarf 2 spec says that an object-like macro's name is always
14888 followed by a space, but versions of GCC around March 2002 omit
14889 the space when the macro's definition is the empty string.
14891 The Dwarf 2 spec says that there should be no spaces between the
14892 formal arguments in a function-like macro's formal argument list,
14893 but versions of GCC around March 2002 include spaces after the
14897 /* Find the extent of the macro name. The macro name is terminated
14898 by either a space or null character (for an object-like macro) or
14899 an opening paren (for a function-like macro). */
14900 for (p
= body
; *p
; p
++)
14901 if (*p
== ' ' || *p
== '(')
14904 if (*p
== ' ' || *p
== '\0')
14906 /* It's an object-like macro. */
14907 int name_len
= p
- body
;
14908 char *name
= copy_string (body
, name_len
);
14909 const char *replacement
;
14912 replacement
= body
+ name_len
+ 1;
14915 dwarf2_macro_malformed_definition_complaint (body
);
14916 replacement
= body
+ name_len
;
14919 macro_define_object (file
, line
, name
, replacement
);
14923 else if (*p
== '(')
14925 /* It's a function-like macro. */
14926 char *name
= copy_string (body
, p
- body
);
14929 char **argv
= xmalloc (argv_size
* sizeof (*argv
));
14933 p
= consume_improper_spaces (p
, body
);
14935 /* Parse the formal argument list. */
14936 while (*p
&& *p
!= ')')
14938 /* Find the extent of the current argument name. */
14939 const char *arg_start
= p
;
14941 while (*p
&& *p
!= ',' && *p
!= ')' && *p
!= ' ')
14944 if (! *p
|| p
== arg_start
)
14945 dwarf2_macro_malformed_definition_complaint (body
);
14948 /* Make sure argv has room for the new argument. */
14949 if (argc
>= argv_size
)
14952 argv
= xrealloc (argv
, argv_size
* sizeof (*argv
));
14955 argv
[argc
++] = copy_string (arg_start
, p
- arg_start
);
14958 p
= consume_improper_spaces (p
, body
);
14960 /* Consume the comma, if present. */
14965 p
= consume_improper_spaces (p
, body
);
14974 /* Perfectly formed definition, no complaints. */
14975 macro_define_function (file
, line
, name
,
14976 argc
, (const char **) argv
,
14978 else if (*p
== '\0')
14980 /* Complain, but do define it. */
14981 dwarf2_macro_malformed_definition_complaint (body
);
14982 macro_define_function (file
, line
, name
,
14983 argc
, (const char **) argv
,
14987 /* Just complain. */
14988 dwarf2_macro_malformed_definition_complaint (body
);
14991 /* Just complain. */
14992 dwarf2_macro_malformed_definition_complaint (body
);
14998 for (i
= 0; i
< argc
; i
++)
15004 dwarf2_macro_malformed_definition_complaint (body
);
15007 /* Skip some bytes from BYTES according to the form given in FORM.
15008 Returns the new pointer. */
15011 skip_form_bytes (bfd
*abfd
, gdb_byte
*bytes
,
15012 enum dwarf_form form
,
15013 unsigned int offset_size
,
15014 struct dwarf2_section_info
*section
)
15016 unsigned int bytes_read
;
15020 case DW_FORM_data1
:
15025 case DW_FORM_data2
:
15029 case DW_FORM_data4
:
15033 case DW_FORM_data8
:
15037 case DW_FORM_string
:
15038 read_direct_string (abfd
, bytes
, &bytes_read
);
15039 bytes
+= bytes_read
;
15042 case DW_FORM_sec_offset
:
15044 bytes
+= offset_size
;
15047 case DW_FORM_block
:
15048 bytes
+= read_unsigned_leb128 (abfd
, bytes
, &bytes_read
);
15049 bytes
+= bytes_read
;
15052 case DW_FORM_block1
:
15053 bytes
+= 1 + read_1_byte (abfd
, bytes
);
15055 case DW_FORM_block2
:
15056 bytes
+= 2 + read_2_bytes (abfd
, bytes
);
15058 case DW_FORM_block4
:
15059 bytes
+= 4 + read_4_bytes (abfd
, bytes
);
15062 case DW_FORM_sdata
:
15063 case DW_FORM_udata
:
15064 bytes
= skip_leb128 (abfd
, bytes
);
15070 complaint (&symfile_complaints
,
15071 _("invalid form 0x%x in `%s'"),
15073 section
->asection
->name
);
15081 /* A helper for dwarf_decode_macros that handles skipping an unknown
15082 opcode. Returns an updated pointer to the macro data buffer; or,
15083 on error, issues a complaint and returns NULL. */
15086 skip_unknown_opcode (unsigned int opcode
,
15087 gdb_byte
**opcode_definitions
,
15090 unsigned int offset_size
,
15091 struct dwarf2_section_info
*section
)
15093 unsigned int bytes_read
, i
;
15097 if (opcode_definitions
[opcode
] == NULL
)
15099 complaint (&symfile_complaints
,
15100 _("unrecognized DW_MACFINO opcode 0x%x"),
15105 defn
= opcode_definitions
[opcode
];
15106 arg
= read_unsigned_leb128 (abfd
, defn
, &bytes_read
);
15107 defn
+= bytes_read
;
15109 for (i
= 0; i
< arg
; ++i
)
15111 mac_ptr
= skip_form_bytes (abfd
, mac_ptr
, defn
[i
], offset_size
, section
);
15112 if (mac_ptr
== NULL
)
15114 /* skip_form_bytes already issued the complaint. */
15122 /* A helper function which parses the header of a macro section.
15123 If the macro section is the extended (for now called "GNU") type,
15124 then this updates *OFFSET_SIZE. Returns a pointer to just after
15125 the header, or issues a complaint and returns NULL on error. */
15128 dwarf_parse_macro_header (gdb_byte
**opcode_definitions
,
15131 unsigned int *offset_size
,
15132 int section_is_gnu
)
15134 memset (opcode_definitions
, 0, 256 * sizeof (gdb_byte
*));
15136 if (section_is_gnu
)
15138 unsigned int version
, flags
;
15140 version
= read_2_bytes (abfd
, mac_ptr
);
15143 complaint (&symfile_complaints
,
15144 _("unrecognized version `%d' in .debug_macro section"),
15150 flags
= read_1_byte (abfd
, mac_ptr
);
15152 *offset_size
= (flags
& 1) ? 8 : 4;
15154 if ((flags
& 2) != 0)
15155 /* We don't need the line table offset. */
15156 mac_ptr
+= *offset_size
;
15158 /* Vendor opcode descriptions. */
15159 if ((flags
& 4) != 0)
15161 unsigned int i
, count
;
15163 count
= read_1_byte (abfd
, mac_ptr
);
15165 for (i
= 0; i
< count
; ++i
)
15167 unsigned int opcode
, bytes_read
;
15170 opcode
= read_1_byte (abfd
, mac_ptr
);
15172 opcode_definitions
[opcode
] = mac_ptr
;
15173 arg
= read_unsigned_leb128 (abfd
, mac_ptr
, &bytes_read
);
15174 mac_ptr
+= bytes_read
;
15183 /* A helper for dwarf_decode_macros that handles the GNU extensions,
15184 including DW_GNU_MACINFO_transparent_include. */
15187 dwarf_decode_macro_bytes (bfd
*abfd
, gdb_byte
*mac_ptr
, gdb_byte
*mac_end
,
15188 struct macro_source_file
*current_file
,
15189 struct line_header
*lh
, char *comp_dir
,
15190 struct dwarf2_section_info
*section
,
15191 int section_is_gnu
,
15192 unsigned int offset_size
,
15193 struct objfile
*objfile
)
15195 enum dwarf_macro_record_type macinfo_type
;
15196 int at_commandline
;
15197 gdb_byte
*opcode_definitions
[256];
15199 mac_ptr
= dwarf_parse_macro_header (opcode_definitions
, abfd
, mac_ptr
,
15200 &offset_size
, section_is_gnu
);
15201 if (mac_ptr
== NULL
)
15203 /* We already issued a complaint. */
15207 /* Determines if GDB is still before first DW_MACINFO_start_file. If true
15208 GDB is still reading the definitions from command line. First
15209 DW_MACINFO_start_file will need to be ignored as it was already executed
15210 to create CURRENT_FILE for the main source holding also the command line
15211 definitions. On first met DW_MACINFO_start_file this flag is reset to
15212 normally execute all the remaining DW_MACINFO_start_file macinfos. */
15214 at_commandline
= 1;
15218 /* Do we at least have room for a macinfo type byte? */
15219 if (mac_ptr
>= mac_end
)
15221 dwarf2_macros_too_long_complaint (section
);
15225 macinfo_type
= read_1_byte (abfd
, mac_ptr
);
15228 /* Note that we rely on the fact that the corresponding GNU and
15229 DWARF constants are the same. */
15230 switch (macinfo_type
)
15232 /* A zero macinfo type indicates the end of the macro
15237 case DW_MACRO_GNU_define
:
15238 case DW_MACRO_GNU_undef
:
15239 case DW_MACRO_GNU_define_indirect
:
15240 case DW_MACRO_GNU_undef_indirect
:
15242 unsigned int bytes_read
;
15247 line
= read_unsigned_leb128 (abfd
, mac_ptr
, &bytes_read
);
15248 mac_ptr
+= bytes_read
;
15250 if (macinfo_type
== DW_MACRO_GNU_define
15251 || macinfo_type
== DW_MACRO_GNU_undef
)
15253 body
= read_direct_string (abfd
, mac_ptr
, &bytes_read
);
15254 mac_ptr
+= bytes_read
;
15258 LONGEST str_offset
;
15260 str_offset
= read_offset_1 (abfd
, mac_ptr
, offset_size
);
15261 mac_ptr
+= offset_size
;
15263 body
= read_indirect_string_at_offset (abfd
, str_offset
);
15266 is_define
= (macinfo_type
== DW_MACRO_GNU_define
15267 || macinfo_type
== DW_MACRO_GNU_define_indirect
);
15268 if (! current_file
)
15270 /* DWARF violation as no main source is present. */
15271 complaint (&symfile_complaints
,
15272 _("debug info with no main source gives macro %s "
15274 is_define
? _("definition") : _("undefinition"),
15278 if ((line
== 0 && !at_commandline
)
15279 || (line
!= 0 && at_commandline
))
15280 complaint (&symfile_complaints
,
15281 _("debug info gives %s macro %s with %s line %d: %s"),
15282 at_commandline
? _("command-line") : _("in-file"),
15283 is_define
? _("definition") : _("undefinition"),
15284 line
== 0 ? _("zero") : _("non-zero"), line
, body
);
15287 parse_macro_definition (current_file
, line
, body
);
15290 gdb_assert (macinfo_type
== DW_MACRO_GNU_undef
15291 || macinfo_type
== DW_MACRO_GNU_undef_indirect
);
15292 macro_undef (current_file
, line
, body
);
15297 case DW_MACRO_GNU_start_file
:
15299 unsigned int bytes_read
;
15302 line
= read_unsigned_leb128 (abfd
, mac_ptr
, &bytes_read
);
15303 mac_ptr
+= bytes_read
;
15304 file
= read_unsigned_leb128 (abfd
, mac_ptr
, &bytes_read
);
15305 mac_ptr
+= bytes_read
;
15307 if ((line
== 0 && !at_commandline
)
15308 || (line
!= 0 && at_commandline
))
15309 complaint (&symfile_complaints
,
15310 _("debug info gives source %d included "
15311 "from %s at %s line %d"),
15312 file
, at_commandline
? _("command-line") : _("file"),
15313 line
== 0 ? _("zero") : _("non-zero"), line
);
15315 if (at_commandline
)
15317 /* This DW_MACRO_GNU_start_file was executed in the
15319 at_commandline
= 0;
15322 current_file
= macro_start_file (file
, line
,
15323 current_file
, comp_dir
,
15328 case DW_MACRO_GNU_end_file
:
15329 if (! current_file
)
15330 complaint (&symfile_complaints
,
15331 _("macro debug info has an unmatched "
15332 "`close_file' directive"));
15335 current_file
= current_file
->included_by
;
15336 if (! current_file
)
15338 enum dwarf_macro_record_type next_type
;
15340 /* GCC circa March 2002 doesn't produce the zero
15341 type byte marking the end of the compilation
15342 unit. Complain if it's not there, but exit no
15345 /* Do we at least have room for a macinfo type byte? */
15346 if (mac_ptr
>= mac_end
)
15348 dwarf2_macros_too_long_complaint (section
);
15352 /* We don't increment mac_ptr here, so this is just
15354 next_type
= read_1_byte (abfd
, mac_ptr
);
15355 if (next_type
!= 0)
15356 complaint (&symfile_complaints
,
15357 _("no terminating 0-type entry for "
15358 "macros in `.debug_macinfo' section"));
15365 case DW_MACRO_GNU_transparent_include
:
15369 offset
= read_offset_1 (abfd
, mac_ptr
, offset_size
);
15370 mac_ptr
+= offset_size
;
15372 dwarf_decode_macro_bytes (abfd
,
15373 section
->buffer
+ offset
,
15374 mac_end
, current_file
,
15376 section
, section_is_gnu
,
15377 offset_size
, objfile
);
15381 case DW_MACINFO_vendor_ext
:
15382 if (!section_is_gnu
)
15384 unsigned int bytes_read
;
15387 constant
= read_unsigned_leb128 (abfd
, mac_ptr
, &bytes_read
);
15388 mac_ptr
+= bytes_read
;
15389 read_direct_string (abfd
, mac_ptr
, &bytes_read
);
15390 mac_ptr
+= bytes_read
;
15392 /* We don't recognize any vendor extensions. */
15398 mac_ptr
= skip_unknown_opcode (macinfo_type
, opcode_definitions
,
15399 mac_ptr
, abfd
, offset_size
,
15401 if (mac_ptr
== NULL
)
15405 } while (macinfo_type
!= 0);
15409 dwarf_decode_macros (struct line_header
*lh
, unsigned int offset
,
15410 char *comp_dir
, bfd
*abfd
,
15411 struct dwarf2_cu
*cu
,
15412 struct dwarf2_section_info
*section
,
15413 int section_is_gnu
)
15415 struct objfile
*objfile
= dwarf2_per_objfile
->objfile
;
15416 gdb_byte
*mac_ptr
, *mac_end
;
15417 struct macro_source_file
*current_file
= 0;
15418 enum dwarf_macro_record_type macinfo_type
;
15419 unsigned int offset_size
= cu
->header
.offset_size
;
15420 gdb_byte
*opcode_definitions
[256];
15422 dwarf2_read_section (objfile
, section
);
15423 if (section
->buffer
== NULL
)
15425 complaint (&symfile_complaints
, _("missing %s section"),
15426 section
->asection
->name
);
15430 /* First pass: Find the name of the base filename.
15431 This filename is needed in order to process all macros whose definition
15432 (or undefinition) comes from the command line. These macros are defined
15433 before the first DW_MACINFO_start_file entry, and yet still need to be
15434 associated to the base file.
15436 To determine the base file name, we scan the macro definitions until we
15437 reach the first DW_MACINFO_start_file entry. We then initialize
15438 CURRENT_FILE accordingly so that any macro definition found before the
15439 first DW_MACINFO_start_file can still be associated to the base file. */
15441 mac_ptr
= section
->buffer
+ offset
;
15442 mac_end
= section
->buffer
+ section
->size
;
15444 mac_ptr
= dwarf_parse_macro_header (opcode_definitions
, abfd
, mac_ptr
,
15445 &offset_size
, section_is_gnu
);
15446 if (mac_ptr
== NULL
)
15448 /* We already issued a complaint. */
15454 /* Do we at least have room for a macinfo type byte? */
15455 if (mac_ptr
>= mac_end
)
15457 /* Complaint is printed during the second pass as GDB will probably
15458 stop the first pass earlier upon finding
15459 DW_MACINFO_start_file. */
15463 macinfo_type
= read_1_byte (abfd
, mac_ptr
);
15466 /* Note that we rely on the fact that the corresponding GNU and
15467 DWARF constants are the same. */
15468 switch (macinfo_type
)
15470 /* A zero macinfo type indicates the end of the macro
15475 case DW_MACRO_GNU_define
:
15476 case DW_MACRO_GNU_undef
:
15477 /* Only skip the data by MAC_PTR. */
15479 unsigned int bytes_read
;
15481 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
;
15488 case DW_MACRO_GNU_start_file
:
15490 unsigned int bytes_read
;
15493 line
= read_unsigned_leb128 (abfd
, mac_ptr
, &bytes_read
);
15494 mac_ptr
+= bytes_read
;
15495 file
= read_unsigned_leb128 (abfd
, mac_ptr
, &bytes_read
);
15496 mac_ptr
+= bytes_read
;
15498 current_file
= macro_start_file (file
, line
, current_file
,
15499 comp_dir
, lh
, objfile
);
15503 case DW_MACRO_GNU_end_file
:
15504 /* No data to skip by MAC_PTR. */
15507 case DW_MACRO_GNU_define_indirect
:
15508 case DW_MACRO_GNU_undef_indirect
:
15510 unsigned int bytes_read
;
15512 read_unsigned_leb128 (abfd
, mac_ptr
, &bytes_read
);
15513 mac_ptr
+= bytes_read
;
15514 mac_ptr
+= offset_size
;
15518 case DW_MACRO_GNU_transparent_include
:
15519 /* Note that, according to the spec, a transparent include
15520 chain cannot call DW_MACRO_GNU_start_file. So, we can just
15521 skip this opcode. */
15522 mac_ptr
+= offset_size
;
15525 case DW_MACINFO_vendor_ext
:
15526 /* Only skip the data by MAC_PTR. */
15527 if (!section_is_gnu
)
15529 unsigned int bytes_read
;
15531 read_unsigned_leb128 (abfd
, mac_ptr
, &bytes_read
);
15532 mac_ptr
+= bytes_read
;
15533 read_direct_string (abfd
, mac_ptr
, &bytes_read
);
15534 mac_ptr
+= bytes_read
;
15539 mac_ptr
= skip_unknown_opcode (macinfo_type
, opcode_definitions
,
15540 mac_ptr
, abfd
, offset_size
,
15542 if (mac_ptr
== NULL
)
15546 } while (macinfo_type
!= 0 && current_file
== NULL
);
15548 /* Second pass: Process all entries.
15550 Use the AT_COMMAND_LINE flag to determine whether we are still processing
15551 command-line macro definitions/undefinitions. This flag is unset when we
15552 reach the first DW_MACINFO_start_file entry. */
15554 dwarf_decode_macro_bytes (abfd
, section
->buffer
+ offset
, mac_end
,
15555 current_file
, lh
, comp_dir
, section
, section_is_gnu
,
15556 offset_size
, objfile
);
15559 /* Check if the attribute's form is a DW_FORM_block*
15560 if so return true else false. */
15562 attr_form_is_block (struct attribute
*attr
)
15564 return (attr
== NULL
? 0 :
15565 attr
->form
== DW_FORM_block1
15566 || attr
->form
== DW_FORM_block2
15567 || attr
->form
== DW_FORM_block4
15568 || attr
->form
== DW_FORM_block
15569 || attr
->form
== DW_FORM_exprloc
);
15572 /* Return non-zero if ATTR's value is a section offset --- classes
15573 lineptr, loclistptr, macptr or rangelistptr --- or zero, otherwise.
15574 You may use DW_UNSND (attr) to retrieve such offsets.
15576 Section 7.5.4, "Attribute Encodings", explains that no attribute
15577 may have a value that belongs to more than one of these classes; it
15578 would be ambiguous if we did, because we use the same forms for all
15581 attr_form_is_section_offset (struct attribute
*attr
)
15583 return (attr
->form
== DW_FORM_data4
15584 || attr
->form
== DW_FORM_data8
15585 || attr
->form
== DW_FORM_sec_offset
);
15589 /* Return non-zero if ATTR's value falls in the 'constant' class, or
15590 zero otherwise. When this function returns true, you can apply
15591 dwarf2_get_attr_constant_value to it.
15593 However, note that for some attributes you must check
15594 attr_form_is_section_offset before using this test. DW_FORM_data4
15595 and DW_FORM_data8 are members of both the constant class, and of
15596 the classes that contain offsets into other debug sections
15597 (lineptr, loclistptr, macptr or rangelistptr). The DWARF spec says
15598 that, if an attribute's can be either a constant or one of the
15599 section offset classes, DW_FORM_data4 and DW_FORM_data8 should be
15600 taken as section offsets, not constants. */
15602 attr_form_is_constant (struct attribute
*attr
)
15604 switch (attr
->form
)
15606 case DW_FORM_sdata
:
15607 case DW_FORM_udata
:
15608 case DW_FORM_data1
:
15609 case DW_FORM_data2
:
15610 case DW_FORM_data4
:
15611 case DW_FORM_data8
:
15618 /* A helper function that fills in a dwarf2_loclist_baton. */
15621 fill_in_loclist_baton (struct dwarf2_cu
*cu
,
15622 struct dwarf2_loclist_baton
*baton
,
15623 struct attribute
*attr
)
15625 dwarf2_read_section (dwarf2_per_objfile
->objfile
,
15626 &dwarf2_per_objfile
->loc
);
15628 baton
->per_cu
= cu
->per_cu
;
15629 gdb_assert (baton
->per_cu
);
15630 /* We don't know how long the location list is, but make sure we
15631 don't run off the edge of the section. */
15632 baton
->size
= dwarf2_per_objfile
->loc
.size
- DW_UNSND (attr
);
15633 baton
->data
= dwarf2_per_objfile
->loc
.buffer
+ DW_UNSND (attr
);
15634 baton
->base_address
= cu
->base_address
;
15638 dwarf2_symbol_mark_computed (struct attribute
*attr
, struct symbol
*sym
,
15639 struct dwarf2_cu
*cu
)
15641 struct objfile
*objfile
= dwarf2_per_objfile
->objfile
;
15643 if (attr_form_is_section_offset (attr
)
15644 /* ".debug_loc" may not exist at all, or the offset may be outside
15645 the section. If so, fall through to the complaint in the
15647 && DW_UNSND (attr
) < dwarf2_section_size (objfile
,
15648 &dwarf2_per_objfile
->loc
))
15650 struct dwarf2_loclist_baton
*baton
;
15652 baton
= obstack_alloc (&objfile
->objfile_obstack
,
15653 sizeof (struct dwarf2_loclist_baton
));
15655 fill_in_loclist_baton (cu
, baton
, attr
);
15657 if (cu
->base_known
== 0)
15658 complaint (&symfile_complaints
,
15659 _("Location list used without "
15660 "specifying the CU base address."));
15662 SYMBOL_COMPUTED_OPS (sym
) = &dwarf2_loclist_funcs
;
15663 SYMBOL_LOCATION_BATON (sym
) = baton
;
15667 struct dwarf2_locexpr_baton
*baton
;
15669 baton
= obstack_alloc (&objfile
->objfile_obstack
,
15670 sizeof (struct dwarf2_locexpr_baton
));
15671 baton
->per_cu
= cu
->per_cu
;
15672 gdb_assert (baton
->per_cu
);
15674 if (attr_form_is_block (attr
))
15676 /* Note that we're just copying the block's data pointer
15677 here, not the actual data. We're still pointing into the
15678 info_buffer for SYM's objfile; right now we never release
15679 that buffer, but when we do clean up properly this may
15681 baton
->size
= DW_BLOCK (attr
)->size
;
15682 baton
->data
= DW_BLOCK (attr
)->data
;
15686 dwarf2_invalid_attrib_class_complaint ("location description",
15687 SYMBOL_NATURAL_NAME (sym
));
15691 SYMBOL_COMPUTED_OPS (sym
) = &dwarf2_locexpr_funcs
;
15692 SYMBOL_LOCATION_BATON (sym
) = baton
;
15696 /* Return the OBJFILE associated with the compilation unit CU. If CU
15697 came from a separate debuginfo file, then the master objfile is
15701 dwarf2_per_cu_objfile (struct dwarf2_per_cu_data
*per_cu
)
15703 struct objfile
*objfile
= per_cu
->objfile
;
15705 /* Return the master objfile, so that we can report and look up the
15706 correct file containing this variable. */
15707 if (objfile
->separate_debug_objfile_backlink
)
15708 objfile
= objfile
->separate_debug_objfile_backlink
;
15713 /* Return comp_unit_head for PER_CU, either already available in PER_CU->CU
15714 (CU_HEADERP is unused in such case) or prepare a temporary copy at
15715 CU_HEADERP first. */
15717 static const struct comp_unit_head
*
15718 per_cu_header_read_in (struct comp_unit_head
*cu_headerp
,
15719 struct dwarf2_per_cu_data
*per_cu
)
15721 struct objfile
*objfile
;
15722 struct dwarf2_per_objfile
*per_objfile
;
15723 gdb_byte
*info_ptr
;
15726 return &per_cu
->cu
->header
;
15728 objfile
= per_cu
->objfile
;
15729 per_objfile
= objfile_data (objfile
, dwarf2_objfile_data_key
);
15730 info_ptr
= per_objfile
->info
.buffer
+ per_cu
->offset
;
15732 memset (cu_headerp
, 0, sizeof (*cu_headerp
));
15733 read_comp_unit_head (cu_headerp
, info_ptr
, objfile
->obfd
);
15738 /* Return the address size given in the compilation unit header for CU. */
15741 dwarf2_per_cu_addr_size (struct dwarf2_per_cu_data
*per_cu
)
15743 struct comp_unit_head cu_header_local
;
15744 const struct comp_unit_head
*cu_headerp
;
15746 cu_headerp
= per_cu_header_read_in (&cu_header_local
, per_cu
);
15748 return cu_headerp
->addr_size
;
15751 /* Return the offset size given in the compilation unit header for CU. */
15754 dwarf2_per_cu_offset_size (struct dwarf2_per_cu_data
*per_cu
)
15756 struct comp_unit_head cu_header_local
;
15757 const struct comp_unit_head
*cu_headerp
;
15759 cu_headerp
= per_cu_header_read_in (&cu_header_local
, per_cu
);
15761 return cu_headerp
->offset_size
;
15764 /* See its dwarf2loc.h declaration. */
15767 dwarf2_per_cu_ref_addr_size (struct dwarf2_per_cu_data
*per_cu
)
15769 struct comp_unit_head cu_header_local
;
15770 const struct comp_unit_head
*cu_headerp
;
15772 cu_headerp
= per_cu_header_read_in (&cu_header_local
, per_cu
);
15774 if (cu_headerp
->version
== 2)
15775 return cu_headerp
->addr_size
;
15777 return cu_headerp
->offset_size
;
15780 /* Return the text offset of the CU. The returned offset comes from
15781 this CU's objfile. If this objfile came from a separate debuginfo
15782 file, then the offset may be different from the corresponding
15783 offset in the parent objfile. */
15786 dwarf2_per_cu_text_offset (struct dwarf2_per_cu_data
*per_cu
)
15788 struct objfile
*objfile
= per_cu
->objfile
;
15790 return ANOFFSET (objfile
->section_offsets
, SECT_OFF_TEXT (objfile
));
15793 /* Locate the .debug_info compilation unit from CU's objfile which contains
15794 the DIE at OFFSET. Raises an error on failure. */
15796 static struct dwarf2_per_cu_data
*
15797 dwarf2_find_containing_comp_unit (unsigned int offset
,
15798 struct objfile
*objfile
)
15800 struct dwarf2_per_cu_data
*this_cu
;
15804 high
= dwarf2_per_objfile
->n_comp_units
- 1;
15807 int mid
= low
+ (high
- low
) / 2;
15809 if (dwarf2_per_objfile
->all_comp_units
[mid
]->offset
>= offset
)
15814 gdb_assert (low
== high
);
15815 if (dwarf2_per_objfile
->all_comp_units
[low
]->offset
> offset
)
15818 error (_("Dwarf Error: could not find partial DIE containing "
15819 "offset 0x%lx [in module %s]"),
15820 (long) offset
, bfd_get_filename (objfile
->obfd
));
15822 gdb_assert (dwarf2_per_objfile
->all_comp_units
[low
-1]->offset
<= offset
);
15823 return dwarf2_per_objfile
->all_comp_units
[low
-1];
15827 this_cu
= dwarf2_per_objfile
->all_comp_units
[low
];
15828 if (low
== dwarf2_per_objfile
->n_comp_units
- 1
15829 && offset
>= this_cu
->offset
+ this_cu
->length
)
15830 error (_("invalid dwarf2 offset %u"), offset
);
15831 gdb_assert (offset
< this_cu
->offset
+ this_cu
->length
);
15836 /* Locate the compilation unit from OBJFILE which is located at exactly
15837 OFFSET. Raises an error on failure. */
15839 static struct dwarf2_per_cu_data
*
15840 dwarf2_find_comp_unit (unsigned int offset
, struct objfile
*objfile
)
15842 struct dwarf2_per_cu_data
*this_cu
;
15844 this_cu
= dwarf2_find_containing_comp_unit (offset
, objfile
);
15845 if (this_cu
->offset
!= offset
)
15846 error (_("no compilation unit with offset %u."), offset
);
15850 /* Initialize dwarf2_cu CU, owned by PER_CU. */
15853 init_one_comp_unit (struct dwarf2_cu
*cu
, struct dwarf2_per_cu_data
*per_cu
)
15855 memset (cu
, 0, sizeof (*cu
));
15857 cu
->per_cu
= per_cu
;
15858 cu
->objfile
= per_cu
->objfile
;
15859 obstack_init (&cu
->comp_unit_obstack
);
15862 /* Initialize basic fields of dwarf_cu CU according to DIE COMP_UNIT_DIE. */
15865 prepare_one_comp_unit (struct dwarf2_cu
*cu
, struct die_info
*comp_unit_die
)
15867 struct attribute
*attr
;
15869 /* Set the language we're debugging. */
15870 attr
= dwarf2_attr (comp_unit_die
, DW_AT_language
, cu
);
15872 set_cu_language (DW_UNSND (attr
), cu
);
15875 cu
->language
= language_minimal
;
15876 cu
->language_defn
= language_def (cu
->language
);
15880 /* Release one cached compilation unit, CU. We unlink it from the tree
15881 of compilation units, but we don't remove it from the read_in_chain;
15882 the caller is responsible for that.
15883 NOTE: DATA is a void * because this function is also used as a
15884 cleanup routine. */
15887 free_heap_comp_unit (void *data
)
15889 struct dwarf2_cu
*cu
= data
;
15891 gdb_assert (cu
->per_cu
!= NULL
);
15892 cu
->per_cu
->cu
= NULL
;
15895 obstack_free (&cu
->comp_unit_obstack
, NULL
);
15900 /* This cleanup function is passed the address of a dwarf2_cu on the stack
15901 when we're finished with it. We can't free the pointer itself, but be
15902 sure to unlink it from the cache. Also release any associated storage
15903 and perform cache maintenance.
15905 Only used during partial symbol parsing. */
15908 free_stack_comp_unit (void *data
)
15910 struct dwarf2_cu
*cu
= data
;
15912 gdb_assert (cu
->per_cu
!= NULL
);
15913 cu
->per_cu
->cu
= NULL
;
15916 obstack_free (&cu
->comp_unit_obstack
, NULL
);
15917 cu
->partial_dies
= NULL
;
15919 /* The previous code only did this if per_cu != NULL.
15920 But that would always succeed, so now we just unconditionally do
15921 the aging. This seems like the wrong place to do such aging,
15922 but cleaning that up is left for later. */
15923 age_cached_comp_units ();
15926 /* Free all cached compilation units. */
15929 free_cached_comp_units (void *data
)
15931 struct dwarf2_per_cu_data
*per_cu
, **last_chain
;
15933 per_cu
= dwarf2_per_objfile
->read_in_chain
;
15934 last_chain
= &dwarf2_per_objfile
->read_in_chain
;
15935 while (per_cu
!= NULL
)
15937 struct dwarf2_per_cu_data
*next_cu
;
15939 next_cu
= per_cu
->cu
->read_in_chain
;
15941 free_heap_comp_unit (per_cu
->cu
);
15942 *last_chain
= next_cu
;
15948 /* Increase the age counter on each cached compilation unit, and free
15949 any that are too old. */
15952 age_cached_comp_units (void)
15954 struct dwarf2_per_cu_data
*per_cu
, **last_chain
;
15956 dwarf2_clear_marks (dwarf2_per_objfile
->read_in_chain
);
15957 per_cu
= dwarf2_per_objfile
->read_in_chain
;
15958 while (per_cu
!= NULL
)
15960 per_cu
->cu
->last_used
++;
15961 if (per_cu
->cu
->last_used
<= dwarf2_max_cache_age
)
15962 dwarf2_mark (per_cu
->cu
);
15963 per_cu
= per_cu
->cu
->read_in_chain
;
15966 per_cu
= dwarf2_per_objfile
->read_in_chain
;
15967 last_chain
= &dwarf2_per_objfile
->read_in_chain
;
15968 while (per_cu
!= NULL
)
15970 struct dwarf2_per_cu_data
*next_cu
;
15972 next_cu
= per_cu
->cu
->read_in_chain
;
15974 if (!per_cu
->cu
->mark
)
15976 free_heap_comp_unit (per_cu
->cu
);
15977 *last_chain
= next_cu
;
15980 last_chain
= &per_cu
->cu
->read_in_chain
;
15986 /* Remove a single compilation unit from the cache. */
15989 free_one_cached_comp_unit (void *target_cu
)
15991 struct dwarf2_per_cu_data
*per_cu
, **last_chain
;
15993 per_cu
= dwarf2_per_objfile
->read_in_chain
;
15994 last_chain
= &dwarf2_per_objfile
->read_in_chain
;
15995 while (per_cu
!= NULL
)
15997 struct dwarf2_per_cu_data
*next_cu
;
15999 next_cu
= per_cu
->cu
->read_in_chain
;
16001 if (per_cu
->cu
== target_cu
)
16003 free_heap_comp_unit (per_cu
->cu
);
16004 *last_chain
= next_cu
;
16008 last_chain
= &per_cu
->cu
->read_in_chain
;
16014 /* Release all extra memory associated with OBJFILE. */
16017 dwarf2_free_objfile (struct objfile
*objfile
)
16019 dwarf2_per_objfile
= objfile_data (objfile
, dwarf2_objfile_data_key
);
16021 if (dwarf2_per_objfile
== NULL
)
16024 /* Cached DIE trees use xmalloc and the comp_unit_obstack. */
16025 free_cached_comp_units (NULL
);
16027 if (dwarf2_per_objfile
->quick_file_names_table
)
16028 htab_delete (dwarf2_per_objfile
->quick_file_names_table
);
16030 /* Everything else should be on the objfile obstack. */
16033 /* A pair of DIE offset and GDB type pointer. We store these
16034 in a hash table separate from the DIEs, and preserve them
16035 when the DIEs are flushed out of cache. */
16037 struct dwarf2_offset_and_type
16039 unsigned int offset
;
16043 /* Hash function for a dwarf2_offset_and_type. */
16046 offset_and_type_hash (const void *item
)
16048 const struct dwarf2_offset_and_type
*ofs
= item
;
16050 return ofs
->offset
;
16053 /* Equality function for a dwarf2_offset_and_type. */
16056 offset_and_type_eq (const void *item_lhs
, const void *item_rhs
)
16058 const struct dwarf2_offset_and_type
*ofs_lhs
= item_lhs
;
16059 const struct dwarf2_offset_and_type
*ofs_rhs
= item_rhs
;
16061 return ofs_lhs
->offset
== ofs_rhs
->offset
;
16064 /* Set the type associated with DIE to TYPE. Save it in CU's hash
16065 table if necessary. For convenience, return TYPE.
16067 The DIEs reading must have careful ordering to:
16068 * Not cause infite loops trying to read in DIEs as a prerequisite for
16069 reading current DIE.
16070 * Not trying to dereference contents of still incompletely read in types
16071 while reading in other DIEs.
16072 * Enable referencing still incompletely read in types just by a pointer to
16073 the type without accessing its fields.
16075 Therefore caller should follow these rules:
16076 * Try to fetch any prerequisite types we may need to build this DIE type
16077 before building the type and calling set_die_type.
16078 * After building type call set_die_type for current DIE as soon as
16079 possible before fetching more types to complete the current type.
16080 * Make the type as complete as possible before fetching more types. */
16082 static struct type
*
16083 set_die_type (struct die_info
*die
, struct type
*type
, struct dwarf2_cu
*cu
)
16085 struct dwarf2_offset_and_type
**slot
, ofs
;
16086 struct objfile
*objfile
= cu
->objfile
;
16087 htab_t
*type_hash_ptr
;
16089 /* For Ada types, make sure that the gnat-specific data is always
16090 initialized (if not already set). There are a few types where
16091 we should not be doing so, because the type-specific area is
16092 already used to hold some other piece of info (eg: TYPE_CODE_FLT
16093 where the type-specific area is used to store the floatformat).
16094 But this is not a problem, because the gnat-specific information
16095 is actually not needed for these types. */
16096 if (need_gnat_info (cu
)
16097 && TYPE_CODE (type
) != TYPE_CODE_FUNC
16098 && TYPE_CODE (type
) != TYPE_CODE_FLT
16099 && !HAVE_GNAT_AUX_INFO (type
))
16100 INIT_GNAT_SPECIFIC (type
);
16102 if (cu
->per_cu
->debug_types_section
)
16103 type_hash_ptr
= &dwarf2_per_objfile
->debug_types_type_hash
;
16105 type_hash_ptr
= &dwarf2_per_objfile
->debug_info_type_hash
;
16107 if (*type_hash_ptr
== NULL
)
16110 = htab_create_alloc_ex (127,
16111 offset_and_type_hash
,
16112 offset_and_type_eq
,
16114 &objfile
->objfile_obstack
,
16115 hashtab_obstack_allocate
,
16116 dummy_obstack_deallocate
);
16119 ofs
.offset
= die
->offset
;
16121 slot
= (struct dwarf2_offset_and_type
**)
16122 htab_find_slot_with_hash (*type_hash_ptr
, &ofs
, ofs
.offset
, INSERT
);
16124 complaint (&symfile_complaints
,
16125 _("A problem internal to GDB: DIE 0x%x has type already set"),
16127 *slot
= obstack_alloc (&objfile
->objfile_obstack
, sizeof (**slot
));
16132 /* Look up the type for the die at DIE_OFFSET in the appropriate type_hash
16133 table, or return NULL if the die does not have a saved type. */
16135 static struct type
*
16136 get_die_type_at_offset (unsigned int offset
,
16137 struct dwarf2_per_cu_data
*per_cu
)
16139 struct dwarf2_offset_and_type
*slot
, ofs
;
16142 if (per_cu
->debug_types_section
)
16143 type_hash
= dwarf2_per_objfile
->debug_types_type_hash
;
16145 type_hash
= dwarf2_per_objfile
->debug_info_type_hash
;
16146 if (type_hash
== NULL
)
16149 ofs
.offset
= offset
;
16150 slot
= htab_find_with_hash (type_hash
, &ofs
, ofs
.offset
);
16157 /* Look up the type for DIE in the appropriate type_hash table,
16158 or return NULL if DIE does not have a saved type. */
16160 static struct type
*
16161 get_die_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
16163 return get_die_type_at_offset (die
->offset
, cu
->per_cu
);
16166 /* Add a dependence relationship from CU to REF_PER_CU. */
16169 dwarf2_add_dependence (struct dwarf2_cu
*cu
,
16170 struct dwarf2_per_cu_data
*ref_per_cu
)
16174 if (cu
->dependencies
== NULL
)
16176 = htab_create_alloc_ex (5, htab_hash_pointer
, htab_eq_pointer
,
16177 NULL
, &cu
->comp_unit_obstack
,
16178 hashtab_obstack_allocate
,
16179 dummy_obstack_deallocate
);
16181 slot
= htab_find_slot (cu
->dependencies
, ref_per_cu
, INSERT
);
16183 *slot
= ref_per_cu
;
16186 /* Subroutine of dwarf2_mark to pass to htab_traverse.
16187 Set the mark field in every compilation unit in the
16188 cache that we must keep because we are keeping CU. */
16191 dwarf2_mark_helper (void **slot
, void *data
)
16193 struct dwarf2_per_cu_data
*per_cu
;
16195 per_cu
= (struct dwarf2_per_cu_data
*) *slot
;
16197 /* cu->dependencies references may not yet have been ever read if QUIT aborts
16198 reading of the chain. As such dependencies remain valid it is not much
16199 useful to track and undo them during QUIT cleanups. */
16200 if (per_cu
->cu
== NULL
)
16203 if (per_cu
->cu
->mark
)
16205 per_cu
->cu
->mark
= 1;
16207 if (per_cu
->cu
->dependencies
!= NULL
)
16208 htab_traverse (per_cu
->cu
->dependencies
, dwarf2_mark_helper
, NULL
);
16213 /* Set the mark field in CU and in every other compilation unit in the
16214 cache that we must keep because we are keeping CU. */
16217 dwarf2_mark (struct dwarf2_cu
*cu
)
16222 if (cu
->dependencies
!= NULL
)
16223 htab_traverse (cu
->dependencies
, dwarf2_mark_helper
, NULL
);
16227 dwarf2_clear_marks (struct dwarf2_per_cu_data
*per_cu
)
16231 per_cu
->cu
->mark
= 0;
16232 per_cu
= per_cu
->cu
->read_in_chain
;
16236 /* Trivial hash function for partial_die_info: the hash value of a DIE
16237 is its offset in .debug_info for this objfile. */
16240 partial_die_hash (const void *item
)
16242 const struct partial_die_info
*part_die
= item
;
16244 return part_die
->offset
;
16247 /* Trivial comparison function for partial_die_info structures: two DIEs
16248 are equal if they have the same offset. */
16251 partial_die_eq (const void *item_lhs
, const void *item_rhs
)
16253 const struct partial_die_info
*part_die_lhs
= item_lhs
;
16254 const struct partial_die_info
*part_die_rhs
= item_rhs
;
16256 return part_die_lhs
->offset
== part_die_rhs
->offset
;
16259 static struct cmd_list_element
*set_dwarf2_cmdlist
;
16260 static struct cmd_list_element
*show_dwarf2_cmdlist
;
16263 set_dwarf2_cmd (char *args
, int from_tty
)
16265 help_list (set_dwarf2_cmdlist
, "maintenance set dwarf2 ", -1, gdb_stdout
);
16269 show_dwarf2_cmd (char *args
, int from_tty
)
16271 cmd_show_list (show_dwarf2_cmdlist
, from_tty
, "");
16274 /* If section described by INFO was mmapped, munmap it now. */
16277 munmap_section_buffer (struct dwarf2_section_info
*info
)
16279 if (info
->map_addr
!= NULL
)
16284 res
= munmap (info
->map_addr
, info
->map_len
);
16285 gdb_assert (res
== 0);
16287 /* Without HAVE_MMAP, we should never be here to begin with. */
16288 gdb_assert_not_reached ("no mmap support");
16293 /* munmap debug sections for OBJFILE, if necessary. */
16296 dwarf2_per_objfile_free (struct objfile
*objfile
, void *d
)
16298 struct dwarf2_per_objfile
*data
= d
;
16300 struct dwarf2_section_info
*section
;
16302 /* This is sorted according to the order they're defined in to make it easier
16303 to keep in sync. */
16304 munmap_section_buffer (&data
->info
);
16305 munmap_section_buffer (&data
->abbrev
);
16306 munmap_section_buffer (&data
->line
);
16307 munmap_section_buffer (&data
->loc
);
16308 munmap_section_buffer (&data
->macinfo
);
16309 munmap_section_buffer (&data
->macro
);
16310 munmap_section_buffer (&data
->str
);
16311 munmap_section_buffer (&data
->ranges
);
16312 munmap_section_buffer (&data
->frame
);
16313 munmap_section_buffer (&data
->eh_frame
);
16314 munmap_section_buffer (&data
->gdb_index
);
16317 VEC_iterate (dwarf2_section_info_def
, data
->types
, ix
, section
);
16319 munmap_section_buffer (section
);
16321 VEC_free (dwarf2_section_info_def
, data
->types
);
16325 /* The "save gdb-index" command. */
16327 /* The contents of the hash table we create when building the string
16329 struct strtab_entry
16331 offset_type offset
;
16335 /* Hash function for a strtab_entry.
16337 Function is used only during write_hash_table so no index format backward
16338 compatibility is needed. */
16341 hash_strtab_entry (const void *e
)
16343 const struct strtab_entry
*entry
= e
;
16344 return mapped_index_string_hash (INT_MAX
, entry
->str
);
16347 /* Equality function for a strtab_entry. */
16350 eq_strtab_entry (const void *a
, const void *b
)
16352 const struct strtab_entry
*ea
= a
;
16353 const struct strtab_entry
*eb
= b
;
16354 return !strcmp (ea
->str
, eb
->str
);
16357 /* Create a strtab_entry hash table. */
16360 create_strtab (void)
16362 return htab_create_alloc (100, hash_strtab_entry
, eq_strtab_entry
,
16363 xfree
, xcalloc
, xfree
);
16366 /* Add a string to the constant pool. Return the string's offset in
16370 add_string (htab_t table
, struct obstack
*cpool
, const char *str
)
16373 struct strtab_entry entry
;
16374 struct strtab_entry
*result
;
16377 slot
= htab_find_slot (table
, &entry
, INSERT
);
16382 result
= XNEW (struct strtab_entry
);
16383 result
->offset
= obstack_object_size (cpool
);
16385 obstack_grow_str0 (cpool
, str
);
16388 return result
->offset
;
16391 /* An entry in the symbol table. */
16392 struct symtab_index_entry
16394 /* The name of the symbol. */
16396 /* The offset of the name in the constant pool. */
16397 offset_type index_offset
;
16398 /* A sorted vector of the indices of all the CUs that hold an object
16400 VEC (offset_type
) *cu_indices
;
16403 /* The symbol table. This is a power-of-2-sized hash table. */
16404 struct mapped_symtab
16406 offset_type n_elements
;
16408 struct symtab_index_entry
**data
;
16411 /* Hash function for a symtab_index_entry. */
16414 hash_symtab_entry (const void *e
)
16416 const struct symtab_index_entry
*entry
= e
;
16417 return iterative_hash (VEC_address (offset_type
, entry
->cu_indices
),
16418 sizeof (offset_type
) * VEC_length (offset_type
,
16419 entry
->cu_indices
),
16423 /* Equality function for a symtab_index_entry. */
16426 eq_symtab_entry (const void *a
, const void *b
)
16428 const struct symtab_index_entry
*ea
= a
;
16429 const struct symtab_index_entry
*eb
= b
;
16430 int len
= VEC_length (offset_type
, ea
->cu_indices
);
16431 if (len
!= VEC_length (offset_type
, eb
->cu_indices
))
16433 return !memcmp (VEC_address (offset_type
, ea
->cu_indices
),
16434 VEC_address (offset_type
, eb
->cu_indices
),
16435 sizeof (offset_type
) * len
);
16438 /* Destroy a symtab_index_entry. */
16441 delete_symtab_entry (void *p
)
16443 struct symtab_index_entry
*entry
= p
;
16444 VEC_free (offset_type
, entry
->cu_indices
);
16448 /* Create a hash table holding symtab_index_entry objects. */
16451 create_symbol_hash_table (void)
16453 return htab_create_alloc (100, hash_symtab_entry
, eq_symtab_entry
,
16454 delete_symtab_entry
, xcalloc
, xfree
);
16457 /* Create a new mapped symtab object. */
16459 static struct mapped_symtab
*
16460 create_mapped_symtab (void)
16462 struct mapped_symtab
*symtab
= XNEW (struct mapped_symtab
);
16463 symtab
->n_elements
= 0;
16464 symtab
->size
= 1024;
16465 symtab
->data
= XCNEWVEC (struct symtab_index_entry
*, symtab
->size
);
16469 /* Destroy a mapped_symtab. */
16472 cleanup_mapped_symtab (void *p
)
16474 struct mapped_symtab
*symtab
= p
;
16475 /* The contents of the array are freed when the other hash table is
16477 xfree (symtab
->data
);
16481 /* Find a slot in SYMTAB for the symbol NAME. Returns a pointer to
16484 Function is used only during write_hash_table so no index format backward
16485 compatibility is needed. */
16487 static struct symtab_index_entry
**
16488 find_slot (struct mapped_symtab
*symtab
, const char *name
)
16490 offset_type index
, step
, hash
= mapped_index_string_hash (INT_MAX
, name
);
16492 index
= hash
& (symtab
->size
- 1);
16493 step
= ((hash
* 17) & (symtab
->size
- 1)) | 1;
16497 if (!symtab
->data
[index
] || !strcmp (name
, symtab
->data
[index
]->name
))
16498 return &symtab
->data
[index
];
16499 index
= (index
+ step
) & (symtab
->size
- 1);
16503 /* Expand SYMTAB's hash table. */
16506 hash_expand (struct mapped_symtab
*symtab
)
16508 offset_type old_size
= symtab
->size
;
16510 struct symtab_index_entry
**old_entries
= symtab
->data
;
16513 symtab
->data
= XCNEWVEC (struct symtab_index_entry
*, symtab
->size
);
16515 for (i
= 0; i
< old_size
; ++i
)
16517 if (old_entries
[i
])
16519 struct symtab_index_entry
**slot
= find_slot (symtab
,
16520 old_entries
[i
]->name
);
16521 *slot
= old_entries
[i
];
16525 xfree (old_entries
);
16528 /* Add an entry to SYMTAB. NAME is the name of the symbol. CU_INDEX
16529 is the index of the CU in which the symbol appears. */
16532 add_index_entry (struct mapped_symtab
*symtab
, const char *name
,
16533 offset_type cu_index
)
16535 struct symtab_index_entry
**slot
;
16537 ++symtab
->n_elements
;
16538 if (4 * symtab
->n_elements
/ 3 >= symtab
->size
)
16539 hash_expand (symtab
);
16541 slot
= find_slot (symtab
, name
);
16544 *slot
= XNEW (struct symtab_index_entry
);
16545 (*slot
)->name
= name
;
16546 (*slot
)->cu_indices
= NULL
;
16548 /* Don't push an index twice. Due to how we add entries we only
16549 have to check the last one. */
16550 if (VEC_empty (offset_type
, (*slot
)->cu_indices
)
16551 || VEC_last (offset_type
, (*slot
)->cu_indices
) != cu_index
)
16552 VEC_safe_push (offset_type
, (*slot
)->cu_indices
, cu_index
);
16555 /* Add a vector of indices to the constant pool. */
16558 add_indices_to_cpool (htab_t symbol_hash_table
, struct obstack
*cpool
,
16559 struct symtab_index_entry
*entry
)
16563 slot
= htab_find_slot (symbol_hash_table
, entry
, INSERT
);
16566 offset_type len
= VEC_length (offset_type
, entry
->cu_indices
);
16567 offset_type val
= MAYBE_SWAP (len
);
16572 entry
->index_offset
= obstack_object_size (cpool
);
16574 obstack_grow (cpool
, &val
, sizeof (val
));
16576 VEC_iterate (offset_type
, entry
->cu_indices
, i
, iter
);
16579 val
= MAYBE_SWAP (iter
);
16580 obstack_grow (cpool
, &val
, sizeof (val
));
16585 struct symtab_index_entry
*old_entry
= *slot
;
16586 entry
->index_offset
= old_entry
->index_offset
;
16589 return entry
->index_offset
;
16592 /* Write the mapped hash table SYMTAB to the obstack OUTPUT, with
16593 constant pool entries going into the obstack CPOOL. */
16596 write_hash_table (struct mapped_symtab
*symtab
,
16597 struct obstack
*output
, struct obstack
*cpool
)
16600 htab_t symbol_hash_table
;
16603 symbol_hash_table
= create_symbol_hash_table ();
16604 str_table
= create_strtab ();
16606 /* We add all the index vectors to the constant pool first, to
16607 ensure alignment is ok. */
16608 for (i
= 0; i
< symtab
->size
; ++i
)
16610 if (symtab
->data
[i
])
16611 add_indices_to_cpool (symbol_hash_table
, cpool
, symtab
->data
[i
]);
16614 /* Now write out the hash table. */
16615 for (i
= 0; i
< symtab
->size
; ++i
)
16617 offset_type str_off
, vec_off
;
16619 if (symtab
->data
[i
])
16621 str_off
= add_string (str_table
, cpool
, symtab
->data
[i
]->name
);
16622 vec_off
= symtab
->data
[i
]->index_offset
;
16626 /* While 0 is a valid constant pool index, it is not valid
16627 to have 0 for both offsets. */
16632 str_off
= MAYBE_SWAP (str_off
);
16633 vec_off
= MAYBE_SWAP (vec_off
);
16635 obstack_grow (output
, &str_off
, sizeof (str_off
));
16636 obstack_grow (output
, &vec_off
, sizeof (vec_off
));
16639 htab_delete (str_table
);
16640 htab_delete (symbol_hash_table
);
16643 /* Struct to map psymtab to CU index in the index file. */
16644 struct psymtab_cu_index_map
16646 struct partial_symtab
*psymtab
;
16647 unsigned int cu_index
;
16651 hash_psymtab_cu_index (const void *item
)
16653 const struct psymtab_cu_index_map
*map
= item
;
16655 return htab_hash_pointer (map
->psymtab
);
16659 eq_psymtab_cu_index (const void *item_lhs
, const void *item_rhs
)
16661 const struct psymtab_cu_index_map
*lhs
= item_lhs
;
16662 const struct psymtab_cu_index_map
*rhs
= item_rhs
;
16664 return lhs
->psymtab
== rhs
->psymtab
;
16667 /* Helper struct for building the address table. */
16668 struct addrmap_index_data
16670 struct objfile
*objfile
;
16671 struct obstack
*addr_obstack
;
16672 htab_t cu_index_htab
;
16674 /* Non-zero if the previous_* fields are valid.
16675 We can't write an entry until we see the next entry (since it is only then
16676 that we know the end of the entry). */
16677 int previous_valid
;
16678 /* Index of the CU in the table of all CUs in the index file. */
16679 unsigned int previous_cu_index
;
16680 /* Start address of the CU. */
16681 CORE_ADDR previous_cu_start
;
16684 /* Write an address entry to OBSTACK. */
16687 add_address_entry (struct objfile
*objfile
, struct obstack
*obstack
,
16688 CORE_ADDR start
, CORE_ADDR end
, unsigned int cu_index
)
16690 offset_type cu_index_to_write
;
16692 CORE_ADDR baseaddr
;
16694 baseaddr
= ANOFFSET (objfile
->section_offsets
, SECT_OFF_TEXT (objfile
));
16696 store_unsigned_integer (addr
, 8, BFD_ENDIAN_LITTLE
, start
- baseaddr
);
16697 obstack_grow (obstack
, addr
, 8);
16698 store_unsigned_integer (addr
, 8, BFD_ENDIAN_LITTLE
, end
- baseaddr
);
16699 obstack_grow (obstack
, addr
, 8);
16700 cu_index_to_write
= MAYBE_SWAP (cu_index
);
16701 obstack_grow (obstack
, &cu_index_to_write
, sizeof (offset_type
));
16704 /* Worker function for traversing an addrmap to build the address table. */
16707 add_address_entry_worker (void *datap
, CORE_ADDR start_addr
, void *obj
)
16709 struct addrmap_index_data
*data
= datap
;
16710 struct partial_symtab
*pst
= obj
;
16711 offset_type cu_index
;
16714 if (data
->previous_valid
)
16715 add_address_entry (data
->objfile
, data
->addr_obstack
,
16716 data
->previous_cu_start
, start_addr
,
16717 data
->previous_cu_index
);
16719 data
->previous_cu_start
= start_addr
;
16722 struct psymtab_cu_index_map find_map
, *map
;
16723 find_map
.psymtab
= pst
;
16724 map
= htab_find (data
->cu_index_htab
, &find_map
);
16725 gdb_assert (map
!= NULL
);
16726 data
->previous_cu_index
= map
->cu_index
;
16727 data
->previous_valid
= 1;
16730 data
->previous_valid
= 0;
16735 /* Write OBJFILE's address map to OBSTACK.
16736 CU_INDEX_HTAB is used to map addrmap entries to their CU indices
16737 in the index file. */
16740 write_address_map (struct objfile
*objfile
, struct obstack
*obstack
,
16741 htab_t cu_index_htab
)
16743 struct addrmap_index_data addrmap_index_data
;
16745 /* When writing the address table, we have to cope with the fact that
16746 the addrmap iterator only provides the start of a region; we have to
16747 wait until the next invocation to get the start of the next region. */
16749 addrmap_index_data
.objfile
= objfile
;
16750 addrmap_index_data
.addr_obstack
= obstack
;
16751 addrmap_index_data
.cu_index_htab
= cu_index_htab
;
16752 addrmap_index_data
.previous_valid
= 0;
16754 addrmap_foreach (objfile
->psymtabs_addrmap
, add_address_entry_worker
,
16755 &addrmap_index_data
);
16757 /* It's highly unlikely the last entry (end address = 0xff...ff)
16758 is valid, but we should still handle it.
16759 The end address is recorded as the start of the next region, but that
16760 doesn't work here. To cope we pass 0xff...ff, this is a rare situation
16762 if (addrmap_index_data
.previous_valid
)
16763 add_address_entry (objfile
, obstack
,
16764 addrmap_index_data
.previous_cu_start
, (CORE_ADDR
) -1,
16765 addrmap_index_data
.previous_cu_index
);
16768 /* Add a list of partial symbols to SYMTAB. */
16771 write_psymbols (struct mapped_symtab
*symtab
,
16773 struct partial_symbol
**psymp
,
16775 offset_type cu_index
,
16778 for (; count
-- > 0; ++psymp
)
16780 void **slot
, *lookup
;
16782 if (SYMBOL_LANGUAGE (*psymp
) == language_ada
)
16783 error (_("Ada is not currently supported by the index"));
16785 /* We only want to add a given psymbol once. However, we also
16786 want to account for whether it is global or static. So, we
16787 may add it twice, using slightly different values. */
16790 uintptr_t val
= 1 | (uintptr_t) *psymp
;
16792 lookup
= (void *) val
;
16797 /* Only add a given psymbol once. */
16798 slot
= htab_find_slot (psyms_seen
, lookup
, INSERT
);
16802 add_index_entry (symtab
, SYMBOL_SEARCH_NAME (*psymp
), cu_index
);
16807 /* Write the contents of an ("unfinished") obstack to FILE. Throw an
16808 exception if there is an error. */
16811 write_obstack (FILE *file
, struct obstack
*obstack
)
16813 if (fwrite (obstack_base (obstack
), 1, obstack_object_size (obstack
),
16815 != obstack_object_size (obstack
))
16816 error (_("couldn't data write to file"));
16819 /* Unlink a file if the argument is not NULL. */
16822 unlink_if_set (void *p
)
16824 char **filename
= p
;
16826 unlink (*filename
);
16829 /* A helper struct used when iterating over debug_types. */
16830 struct signatured_type_index_data
16832 struct objfile
*objfile
;
16833 struct mapped_symtab
*symtab
;
16834 struct obstack
*types_list
;
16839 /* A helper function that writes a single signatured_type to an
16843 write_one_signatured_type (void **slot
, void *d
)
16845 struct signatured_type_index_data
*info
= d
;
16846 struct signatured_type
*entry
= (struct signatured_type
*) *slot
;
16847 struct dwarf2_per_cu_data
*per_cu
= &entry
->per_cu
;
16848 struct partial_symtab
*psymtab
= per_cu
->v
.psymtab
;
16851 write_psymbols (info
->symtab
,
16853 info
->objfile
->global_psymbols
.list
16854 + psymtab
->globals_offset
,
16855 psymtab
->n_global_syms
, info
->cu_index
,
16857 write_psymbols (info
->symtab
,
16859 info
->objfile
->static_psymbols
.list
16860 + psymtab
->statics_offset
,
16861 psymtab
->n_static_syms
, info
->cu_index
,
16864 store_unsigned_integer (val
, 8, BFD_ENDIAN_LITTLE
, entry
->per_cu
.offset
);
16865 obstack_grow (info
->types_list
, val
, 8);
16866 store_unsigned_integer (val
, 8, BFD_ENDIAN_LITTLE
, entry
->type_offset
);
16867 obstack_grow (info
->types_list
, val
, 8);
16868 store_unsigned_integer (val
, 8, BFD_ENDIAN_LITTLE
, entry
->signature
);
16869 obstack_grow (info
->types_list
, val
, 8);
16876 /* Create an index file for OBJFILE in the directory DIR. */
16879 write_psymtabs_to_index (struct objfile
*objfile
, const char *dir
)
16881 struct cleanup
*cleanup
;
16882 char *filename
, *cleanup_filename
;
16883 struct obstack contents
, addr_obstack
, constant_pool
, symtab_obstack
;
16884 struct obstack cu_list
, types_cu_list
;
16887 struct mapped_symtab
*symtab
;
16888 offset_type val
, size_of_contents
, total_len
;
16892 htab_t cu_index_htab
;
16893 struct psymtab_cu_index_map
*psymtab_cu_index_map
;
16895 if (!objfile
->psymtabs
|| !objfile
->psymtabs_addrmap
)
16898 if (dwarf2_per_objfile
->using_index
)
16899 error (_("Cannot use an index to create the index"));
16901 if (VEC_length (dwarf2_section_info_def
, dwarf2_per_objfile
->types
) > 1)
16902 error (_("Cannot make an index when the file has multiple .debug_types sections"));
16904 if (stat (objfile
->name
, &st
) < 0)
16905 perror_with_name (objfile
->name
);
16907 filename
= concat (dir
, SLASH_STRING
, lbasename (objfile
->name
),
16908 INDEX_SUFFIX
, (char *) NULL
);
16909 cleanup
= make_cleanup (xfree
, filename
);
16911 out_file
= fopen (filename
, "wb");
16913 error (_("Can't open `%s' for writing"), filename
);
16915 cleanup_filename
= filename
;
16916 make_cleanup (unlink_if_set
, &cleanup_filename
);
16918 symtab
= create_mapped_symtab ();
16919 make_cleanup (cleanup_mapped_symtab
, symtab
);
16921 obstack_init (&addr_obstack
);
16922 make_cleanup_obstack_free (&addr_obstack
);
16924 obstack_init (&cu_list
);
16925 make_cleanup_obstack_free (&cu_list
);
16927 obstack_init (&types_cu_list
);
16928 make_cleanup_obstack_free (&types_cu_list
);
16930 psyms_seen
= htab_create_alloc (100, htab_hash_pointer
, htab_eq_pointer
,
16931 NULL
, xcalloc
, xfree
);
16932 make_cleanup_htab_delete (psyms_seen
);
16934 /* While we're scanning CU's create a table that maps a psymtab pointer
16935 (which is what addrmap records) to its index (which is what is recorded
16936 in the index file). This will later be needed to write the address
16938 cu_index_htab
= htab_create_alloc (100,
16939 hash_psymtab_cu_index
,
16940 eq_psymtab_cu_index
,
16941 NULL
, xcalloc
, xfree
);
16942 make_cleanup_htab_delete (cu_index_htab
);
16943 psymtab_cu_index_map
= (struct psymtab_cu_index_map
*)
16944 xmalloc (sizeof (struct psymtab_cu_index_map
)
16945 * dwarf2_per_objfile
->n_comp_units
);
16946 make_cleanup (xfree
, psymtab_cu_index_map
);
16948 /* The CU list is already sorted, so we don't need to do additional
16949 work here. Also, the debug_types entries do not appear in
16950 all_comp_units, but only in their own hash table. */
16951 for (i
= 0; i
< dwarf2_per_objfile
->n_comp_units
; ++i
)
16953 struct dwarf2_per_cu_data
*per_cu
16954 = dwarf2_per_objfile
->all_comp_units
[i
];
16955 struct partial_symtab
*psymtab
= per_cu
->v
.psymtab
;
16957 struct psymtab_cu_index_map
*map
;
16960 write_psymbols (symtab
,
16962 objfile
->global_psymbols
.list
+ psymtab
->globals_offset
,
16963 psymtab
->n_global_syms
, i
,
16965 write_psymbols (symtab
,
16967 objfile
->static_psymbols
.list
+ psymtab
->statics_offset
,
16968 psymtab
->n_static_syms
, i
,
16971 map
= &psymtab_cu_index_map
[i
];
16972 map
->psymtab
= psymtab
;
16974 slot
= htab_find_slot (cu_index_htab
, map
, INSERT
);
16975 gdb_assert (slot
!= NULL
);
16976 gdb_assert (*slot
== NULL
);
16979 store_unsigned_integer (val
, 8, BFD_ENDIAN_LITTLE
, per_cu
->offset
);
16980 obstack_grow (&cu_list
, val
, 8);
16981 store_unsigned_integer (val
, 8, BFD_ENDIAN_LITTLE
, per_cu
->length
);
16982 obstack_grow (&cu_list
, val
, 8);
16985 /* Dump the address map. */
16986 write_address_map (objfile
, &addr_obstack
, cu_index_htab
);
16988 /* Write out the .debug_type entries, if any. */
16989 if (dwarf2_per_objfile
->signatured_types
)
16991 struct signatured_type_index_data sig_data
;
16993 sig_data
.objfile
= objfile
;
16994 sig_data
.symtab
= symtab
;
16995 sig_data
.types_list
= &types_cu_list
;
16996 sig_data
.psyms_seen
= psyms_seen
;
16997 sig_data
.cu_index
= dwarf2_per_objfile
->n_comp_units
;
16998 htab_traverse_noresize (dwarf2_per_objfile
->signatured_types
,
16999 write_one_signatured_type
, &sig_data
);
17002 obstack_init (&constant_pool
);
17003 make_cleanup_obstack_free (&constant_pool
);
17004 obstack_init (&symtab_obstack
);
17005 make_cleanup_obstack_free (&symtab_obstack
);
17006 write_hash_table (symtab
, &symtab_obstack
, &constant_pool
);
17008 obstack_init (&contents
);
17009 make_cleanup_obstack_free (&contents
);
17010 size_of_contents
= 6 * sizeof (offset_type
);
17011 total_len
= size_of_contents
;
17013 /* The version number. */
17014 val
= MAYBE_SWAP (5);
17015 obstack_grow (&contents
, &val
, sizeof (val
));
17017 /* The offset of the CU list from the start of the file. */
17018 val
= MAYBE_SWAP (total_len
);
17019 obstack_grow (&contents
, &val
, sizeof (val
));
17020 total_len
+= obstack_object_size (&cu_list
);
17022 /* The offset of the types CU list from the start of the file. */
17023 val
= MAYBE_SWAP (total_len
);
17024 obstack_grow (&contents
, &val
, sizeof (val
));
17025 total_len
+= obstack_object_size (&types_cu_list
);
17027 /* The offset of the address table from the start of the file. */
17028 val
= MAYBE_SWAP (total_len
);
17029 obstack_grow (&contents
, &val
, sizeof (val
));
17030 total_len
+= obstack_object_size (&addr_obstack
);
17032 /* The offset of the symbol table from the start of the file. */
17033 val
= MAYBE_SWAP (total_len
);
17034 obstack_grow (&contents
, &val
, sizeof (val
));
17035 total_len
+= obstack_object_size (&symtab_obstack
);
17037 /* The offset of the constant pool from the start of the file. */
17038 val
= MAYBE_SWAP (total_len
);
17039 obstack_grow (&contents
, &val
, sizeof (val
));
17040 total_len
+= obstack_object_size (&constant_pool
);
17042 gdb_assert (obstack_object_size (&contents
) == size_of_contents
);
17044 write_obstack (out_file
, &contents
);
17045 write_obstack (out_file
, &cu_list
);
17046 write_obstack (out_file
, &types_cu_list
);
17047 write_obstack (out_file
, &addr_obstack
);
17048 write_obstack (out_file
, &symtab_obstack
);
17049 write_obstack (out_file
, &constant_pool
);
17053 /* We want to keep the file, so we set cleanup_filename to NULL
17054 here. See unlink_if_set. */
17055 cleanup_filename
= NULL
;
17057 do_cleanups (cleanup
);
17060 /* Implementation of the `save gdb-index' command.
17062 Note that the file format used by this command is documented in the
17063 GDB manual. Any changes here must be documented there. */
17066 save_gdb_index_command (char *arg
, int from_tty
)
17068 struct objfile
*objfile
;
17071 error (_("usage: save gdb-index DIRECTORY"));
17073 ALL_OBJFILES (objfile
)
17077 /* If the objfile does not correspond to an actual file, skip it. */
17078 if (stat (objfile
->name
, &st
) < 0)
17081 dwarf2_per_objfile
= objfile_data (objfile
, dwarf2_objfile_data_key
);
17082 if (dwarf2_per_objfile
)
17084 volatile struct gdb_exception except
;
17086 TRY_CATCH (except
, RETURN_MASK_ERROR
)
17088 write_psymtabs_to_index (objfile
, arg
);
17090 if (except
.reason
< 0)
17091 exception_fprintf (gdb_stderr
, except
,
17092 _("Error while writing index for `%s': "),
17100 int dwarf2_always_disassemble
;
17103 show_dwarf2_always_disassemble (struct ui_file
*file
, int from_tty
,
17104 struct cmd_list_element
*c
, const char *value
)
17106 fprintf_filtered (file
,
17107 _("Whether to always disassemble "
17108 "DWARF expressions is %s.\n"),
17113 show_check_physname (struct ui_file
*file
, int from_tty
,
17114 struct cmd_list_element
*c
, const char *value
)
17116 fprintf_filtered (file
,
17117 _("Whether to check \"physname\" is %s.\n"),
17121 void _initialize_dwarf2_read (void);
17124 _initialize_dwarf2_read (void)
17126 struct cmd_list_element
*c
;
17128 dwarf2_objfile_data_key
17129 = register_objfile_data_with_cleanup (NULL
, dwarf2_per_objfile_free
);
17131 add_prefix_cmd ("dwarf2", class_maintenance
, set_dwarf2_cmd
, _("\
17132 Set DWARF 2 specific variables.\n\
17133 Configure DWARF 2 variables such as the cache size"),
17134 &set_dwarf2_cmdlist
, "maintenance set dwarf2 ",
17135 0/*allow-unknown*/, &maintenance_set_cmdlist
);
17137 add_prefix_cmd ("dwarf2", class_maintenance
, show_dwarf2_cmd
, _("\
17138 Show DWARF 2 specific variables\n\
17139 Show DWARF 2 variables such as the cache size"),
17140 &show_dwarf2_cmdlist
, "maintenance show dwarf2 ",
17141 0/*allow-unknown*/, &maintenance_show_cmdlist
);
17143 add_setshow_zinteger_cmd ("max-cache-age", class_obscure
,
17144 &dwarf2_max_cache_age
, _("\
17145 Set the upper bound on the age of cached dwarf2 compilation units."), _("\
17146 Show the upper bound on the age of cached dwarf2 compilation units."), _("\
17147 A higher limit means that cached compilation units will be stored\n\
17148 in memory longer, and more total memory will be used. Zero disables\n\
17149 caching, which can slow down startup."),
17151 show_dwarf2_max_cache_age
,
17152 &set_dwarf2_cmdlist
,
17153 &show_dwarf2_cmdlist
);
17155 add_setshow_boolean_cmd ("always-disassemble", class_obscure
,
17156 &dwarf2_always_disassemble
, _("\
17157 Set whether `info address' always disassembles DWARF expressions."), _("\
17158 Show whether `info address' always disassembles DWARF expressions."), _("\
17159 When enabled, DWARF expressions are always printed in an assembly-like\n\
17160 syntax. When disabled, expressions will be printed in a more\n\
17161 conversational style, when possible."),
17163 show_dwarf2_always_disassemble
,
17164 &set_dwarf2_cmdlist
,
17165 &show_dwarf2_cmdlist
);
17167 add_setshow_zinteger_cmd ("dwarf2-die", no_class
, &dwarf2_die_debug
, _("\
17168 Set debugging of the dwarf2 DIE reader."), _("\
17169 Show debugging of the dwarf2 DIE reader."), _("\
17170 When enabled (non-zero), DIEs are dumped after they are read in.\n\
17171 The value is the maximum depth to print."),
17174 &setdebuglist
, &showdebuglist
);
17176 add_setshow_boolean_cmd ("check-physname", no_class
, &check_physname
, _("\
17177 Set cross-checking of \"physname\" code against demangler."), _("\
17178 Show cross-checking of \"physname\" code against demangler."), _("\
17179 When enabled, GDB's internal \"physname\" code is checked against\n\
17181 NULL
, show_check_physname
,
17182 &setdebuglist
, &showdebuglist
);
17184 c
= add_cmd ("gdb-index", class_files
, save_gdb_index_command
,
17186 Save a gdb-index file.\n\
17187 Usage: save gdb-index DIRECTORY"),
17189 set_cmd_completer (c
, filename_completer
);