1 /* DWARF 2 debugging format support for GDB.
3 Copyright (C) 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003,
4 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2011
5 Free Software Foundation, Inc.
7 Adapted by Gary Funck (gary@intrepid.com), Intrepid Technology,
8 Inc. with support from Florida State University (under contract
9 with the Ada Joint Program Office), and Silicon Graphics, Inc.
10 Initial contribution by Brent Benson, Harris Computer Systems, Inc.,
11 based on Fred Fish's (Cygnus Support) implementation of DWARF 1
14 This file is part of GDB.
16 This program is free software; you can redistribute it and/or modify
17 it under the terms of the GNU General Public License as published by
18 the Free Software Foundation; either version 3 of the License, or
19 (at your option) any later version.
21 This program is distributed in the hope that it will be useful,
22 but WITHOUT ANY WARRANTY; without even the implied warranty of
23 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
24 GNU General Public License for more details.
26 You should have received a copy of the GNU General Public License
27 along with this program. If not, see <http://www.gnu.org/licenses/>. */
37 #include "expression.h"
38 #include "filenames.h" /* for DOSish file names */
41 #include "complaints.h"
43 #include "dwarf2expr.h"
44 #include "dwarf2loc.h"
45 #include "cp-support.h"
51 #include "typeprint.h"
54 #include "exceptions.h"
56 #include "completer.h"
63 #include "gdb_string.h"
64 #include "gdb_assert.h"
65 #include <sys/types.h>
72 #define MAP_FAILED ((void *) -1)
76 typedef struct symbol
*symbolp
;
80 /* .debug_info header for a compilation unit
81 Because of alignment constraints, this structure has padding and cannot
82 be mapped directly onto the beginning of the .debug_info section. */
83 typedef struct comp_unit_header
85 unsigned int length
; /* length of the .debug_info
87 unsigned short version
; /* version number -- 2 for DWARF
89 unsigned int abbrev_offset
; /* offset into .debug_abbrev section */
90 unsigned char addr_size
; /* byte size of an address -- 4 */
93 #define _ACTUAL_COMP_UNIT_HEADER_SIZE 11
96 /* .debug_line statement program prologue
97 Because of alignment constraints, this structure has padding and cannot
98 be mapped directly onto the beginning of the .debug_info section. */
99 typedef struct statement_prologue
101 unsigned int total_length
; /* byte length of the statement
103 unsigned short version
; /* version number -- 2 for DWARF
105 unsigned int prologue_length
; /* # bytes between prologue &
107 unsigned char minimum_instruction_length
; /* byte size of
109 unsigned char default_is_stmt
; /* initial value of is_stmt
112 unsigned char line_range
;
113 unsigned char opcode_base
; /* number assigned to first special
115 unsigned char *standard_opcode_lengths
;
119 /* When non-zero, dump DIEs after they are read in. */
120 static int dwarf2_die_debug
= 0;
122 /* When non-zero, cross-check physname against demangler. */
123 static int check_physname
= 0;
127 /* When set, the file that we're processing is known to have debugging
128 info for C++ namespaces. GCC 3.3.x did not produce this information,
129 but later versions do. */
131 static int processing_has_namespace_info
;
133 static const struct objfile_data
*dwarf2_objfile_data_key
;
135 struct dwarf2_section_info
140 /* Not NULL if the section was actually mmapped. */
142 /* Page aligned size of mmapped area. */
143 bfd_size_type map_len
;
144 /* True if we have tried to read this section. */
148 typedef struct dwarf2_section_info dwarf2_section_info_def
;
149 DEF_VEC_O (dwarf2_section_info_def
);
151 /* All offsets in the index are of this type. It must be
152 architecture-independent. */
153 typedef uint32_t offset_type
;
155 DEF_VEC_I (offset_type
);
157 /* A description of the mapped index. The file format is described in
158 a comment by the code that writes the index. */
161 /* Index data format version. */
164 /* The total length of the buffer. */
167 /* A pointer to the address table data. */
168 const gdb_byte
*address_table
;
170 /* Size of the address table data in bytes. */
171 offset_type address_table_size
;
173 /* The symbol table, implemented as a hash table. */
174 const offset_type
*symbol_table
;
176 /* Size in slots, each slot is 2 offset_types. */
177 offset_type symbol_table_slots
;
179 /* A pointer to the constant pool. */
180 const char *constant_pool
;
183 struct dwarf2_per_objfile
185 struct dwarf2_section_info info
;
186 struct dwarf2_section_info abbrev
;
187 struct dwarf2_section_info line
;
188 struct dwarf2_section_info loc
;
189 struct dwarf2_section_info macinfo
;
190 struct dwarf2_section_info macro
;
191 struct dwarf2_section_info str
;
192 struct dwarf2_section_info ranges
;
193 struct dwarf2_section_info frame
;
194 struct dwarf2_section_info eh_frame
;
195 struct dwarf2_section_info gdb_index
;
197 VEC (dwarf2_section_info_def
) *types
;
200 struct objfile
*objfile
;
202 /* A list of all the compilation units. This is used to locate
203 the target compilation unit of a particular reference. */
204 struct dwarf2_per_cu_data
**all_comp_units
;
206 /* The number of compilation units in ALL_COMP_UNITS. */
209 /* The number of .debug_types-related CUs. */
210 int n_type_comp_units
;
212 /* The .debug_types-related CUs. */
213 struct dwarf2_per_cu_data
**type_comp_units
;
215 /* A chain of compilation units that are currently read in, so that
216 they can be freed later. */
217 struct dwarf2_per_cu_data
*read_in_chain
;
219 /* A table mapping .debug_types signatures to its signatured_type entry.
220 This is NULL if the .debug_types section hasn't been read in yet. */
221 htab_t signatured_types
;
223 /* A flag indicating wether this objfile has a section loaded at a
225 int has_section_at_zero
;
227 /* True if we are using the mapped index,
228 or we are faking it for OBJF_READNOW's sake. */
229 unsigned char using_index
;
231 /* The mapped index, or NULL if .gdb_index is missing or not being used. */
232 struct mapped_index
*index_table
;
234 /* When using index_table, this keeps track of all quick_file_names entries.
235 TUs can share line table entries with CUs or other TUs, and there can be
236 a lot more TUs than unique line tables, so we maintain a separate table
237 of all line table entries to support the sharing. */
238 htab_t quick_file_names_table
;
240 /* Set during partial symbol reading, to prevent queueing of full
242 int reading_partial_symbols
;
244 /* Table mapping type .debug_info DIE offsets to types.
245 This is NULL if not allocated yet.
246 It (currently) makes sense to allocate debug_types_type_hash lazily.
247 To keep things simple we allocate both lazily. */
248 htab_t debug_info_type_hash
;
250 /* Table mapping type .debug_types DIE offsets to types.
251 This is NULL if not allocated yet. */
252 htab_t debug_types_type_hash
;
255 static struct dwarf2_per_objfile
*dwarf2_per_objfile
;
257 /* Default names of the debugging sections. */
259 /* Note that if the debugging section has been compressed, it might
260 have a name like .zdebug_info. */
262 static const struct dwarf2_debug_sections dwarf2_elf_names
= {
263 { ".debug_info", ".zdebug_info" },
264 { ".debug_abbrev", ".zdebug_abbrev" },
265 { ".debug_line", ".zdebug_line" },
266 { ".debug_loc", ".zdebug_loc" },
267 { ".debug_macinfo", ".zdebug_macinfo" },
268 { ".debug_macro", ".zdebug_macro" },
269 { ".debug_str", ".zdebug_str" },
270 { ".debug_ranges", ".zdebug_ranges" },
271 { ".debug_types", ".zdebug_types" },
272 { ".debug_frame", ".zdebug_frame" },
273 { ".eh_frame", NULL
},
274 { ".gdb_index", ".zgdb_index" },
278 /* local data types */
280 /* We hold several abbreviation tables in memory at the same time. */
281 #ifndef ABBREV_HASH_SIZE
282 #define ABBREV_HASH_SIZE 121
285 /* The data in a compilation unit header, after target2host
286 translation, looks like this. */
287 struct comp_unit_head
291 unsigned char addr_size
;
292 unsigned char signed_addr_p
;
293 unsigned int abbrev_offset
;
295 /* Size of file offsets; either 4 or 8. */
296 unsigned int offset_size
;
298 /* Size of the length field; either 4 or 12. */
299 unsigned int initial_length_size
;
301 /* Offset to the first byte of this compilation unit header in the
302 .debug_info section, for resolving relative reference dies. */
305 /* Offset to first die in this cu from the start of the cu.
306 This will be the first byte following the compilation unit header. */
307 unsigned int first_die_offset
;
310 /* Type used for delaying computation of method physnames.
311 See comments for compute_delayed_physnames. */
312 struct delayed_method_info
314 /* The type to which the method is attached, i.e., its parent class. */
317 /* The index of the method in the type's function fieldlists. */
320 /* The index of the method in the fieldlist. */
323 /* The name of the DIE. */
326 /* The DIE associated with this method. */
327 struct die_info
*die
;
330 typedef struct delayed_method_info delayed_method_info
;
331 DEF_VEC_O (delayed_method_info
);
333 /* Internal state when decoding a particular compilation unit. */
336 /* The objfile containing this compilation unit. */
337 struct objfile
*objfile
;
339 /* The header of the compilation unit. */
340 struct comp_unit_head header
;
342 /* Base address of this compilation unit. */
343 CORE_ADDR base_address
;
345 /* Non-zero if base_address has been set. */
348 struct function_range
*first_fn
, *last_fn
, *cached_fn
;
350 /* The language we are debugging. */
351 enum language language
;
352 const struct language_defn
*language_defn
;
354 const char *producer
;
356 /* The generic symbol table building routines have separate lists for
357 file scope symbols and all all other scopes (local scopes). So
358 we need to select the right one to pass to add_symbol_to_list().
359 We do it by keeping a pointer to the correct list in list_in_scope.
361 FIXME: The original dwarf code just treated the file scope as the
362 first local scope, and all other local scopes as nested local
363 scopes, and worked fine. Check to see if we really need to
364 distinguish these in buildsym.c. */
365 struct pending
**list_in_scope
;
367 /* DWARF abbreviation table associated with this compilation unit. */
368 struct abbrev_info
**dwarf2_abbrevs
;
370 /* Storage for the abbrev table. */
371 struct obstack abbrev_obstack
;
373 /* Hash table holding all the loaded partial DIEs. */
376 /* Storage for things with the same lifetime as this read-in compilation
377 unit, including partial DIEs. */
378 struct obstack comp_unit_obstack
;
380 /* When multiple dwarf2_cu structures are living in memory, this field
381 chains them all together, so that they can be released efficiently.
382 We will probably also want a generation counter so that most-recently-used
383 compilation units are cached... */
384 struct dwarf2_per_cu_data
*read_in_chain
;
386 /* Backchain to our per_cu entry if the tree has been built. */
387 struct dwarf2_per_cu_data
*per_cu
;
389 /* How many compilation units ago was this CU last referenced? */
392 /* A hash table of die offsets for following references. */
395 /* Full DIEs if read in. */
396 struct die_info
*dies
;
398 /* A set of pointers to dwarf2_per_cu_data objects for compilation
399 units referenced by this one. Only set during full symbol processing;
400 partial symbol tables do not have dependencies. */
403 /* Header data from the line table, during full symbol processing. */
404 struct line_header
*line_header
;
406 /* A list of methods which need to have physnames computed
407 after all type information has been read. */
408 VEC (delayed_method_info
) *method_list
;
410 /* To be copied to symtab->call_site_htab. */
411 htab_t call_site_htab
;
413 /* Mark used when releasing cached dies. */
414 unsigned int mark
: 1;
416 /* This flag will be set if this compilation unit might include
417 inter-compilation-unit references. */
418 unsigned int has_form_ref_addr
: 1;
420 /* This flag will be set if this compilation unit includes any
421 DW_TAG_namespace DIEs. If we know that there are explicit
422 DIEs for namespaces, we don't need to try to infer them
423 from mangled names. */
424 unsigned int has_namespace_info
: 1;
426 /* This CU references .debug_loc. See the symtab->locations_valid field.
427 This test is imperfect as there may exist optimized debug code not using
428 any location list and still facing inlining issues if handled as
429 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. If we encounter
437 inter-compilation-unit references, we also maintain a sorted
438 list of all compilation units. */
440 struct dwarf2_per_cu_data
442 /* The start offset and length of this compilation unit. 2**29-1
443 bytes should suffice to store the length of any compilation unit
444 - if it doesn't, GDB will fall over anyway.
445 NOTE: Unlike comp_unit_head.length, this length includes
446 initial_length_size. */
448 unsigned int length
: 29;
450 /* Flag indicating this compilation unit will be read in before
451 any of the current compilation units are processed. */
452 unsigned int queued
: 1;
454 /* This flag will be set if we need to load absolutely all DIEs
455 for this compilation unit, instead of just the ones we think
456 are interesting. It gets set if we look for a DIE in the
457 hash table and don't find it. */
458 unsigned int load_all_dies
: 1;
460 /* Non-null if this CU is from .debug_types; in which case it points
461 to the section. Otherwise it's from .debug_info. */
462 struct dwarf2_section_info
*debug_type_section
;
464 /* Set to non-NULL iff this CU is currently loaded. When it gets freed out
465 of the CU cache it gets reset to NULL again. */
466 struct dwarf2_cu
*cu
;
468 /* The corresponding objfile. */
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 struct function_range
706 CORE_ADDR lowpc
, highpc
;
708 struct function_range
*next
;
711 /* Get at parts of an attribute structure. */
713 #define DW_STRING(attr) ((attr)->u.str)
714 #define DW_STRING_IS_CANONICAL(attr) ((attr)->string_is_canonical)
715 #define DW_UNSND(attr) ((attr)->u.unsnd)
716 #define DW_BLOCK(attr) ((attr)->u.blk)
717 #define DW_SND(attr) ((attr)->u.snd)
718 #define DW_ADDR(attr) ((attr)->u.addr)
719 #define DW_SIGNATURED_TYPE(attr) ((attr)->u.signatured_type)
721 /* Blocks are a bunch of untyped bytes. */
728 #ifndef ATTR_ALLOC_CHUNK
729 #define ATTR_ALLOC_CHUNK 4
732 /* Allocate fields for structs, unions and enums in this size. */
733 #ifndef DW_FIELD_ALLOC_CHUNK
734 #define DW_FIELD_ALLOC_CHUNK 4
737 /* FIXME: We might want to set this from BFD via bfd_arch_bits_per_byte,
738 but this would require a corresponding change in unpack_field_as_long
740 static int bits_per_byte
= 8;
742 /* The routines that read and process dies for a C struct or C++ class
743 pass lists of data member fields and lists of member function fields
744 in an instance of a field_info structure, as defined below. */
747 /* List of data member and baseclasses fields. */
750 struct nextfield
*next
;
755 *fields
, *baseclasses
;
757 /* Number of fields (including baseclasses). */
760 /* Number of baseclasses. */
763 /* Set if the accesibility of one of the fields is not public. */
764 int non_public_fields
;
766 /* Member function fields array, entries are allocated in the order they
767 are encountered in the object file. */
770 struct nextfnfield
*next
;
771 struct fn_field fnfield
;
775 /* Member function fieldlist array, contains name of possibly overloaded
776 member function, number of overloaded member functions and a pointer
777 to the head of the member function field chain. */
782 struct nextfnfield
*head
;
786 /* Number of entries in the fnfieldlists array. */
789 /* typedefs defined inside this class. TYPEDEF_FIELD_LIST contains head of
790 a NULL terminated list of TYPEDEF_FIELD_LIST_COUNT elements. */
791 struct typedef_field_list
793 struct typedef_field field
;
794 struct typedef_field_list
*next
;
797 unsigned typedef_field_list_count
;
800 /* One item on the queue of compilation units to read in full symbols
802 struct dwarf2_queue_item
804 struct dwarf2_per_cu_data
*per_cu
;
805 struct dwarf2_queue_item
*next
;
808 /* The current queue. */
809 static struct dwarf2_queue_item
*dwarf2_queue
, *dwarf2_queue_tail
;
811 /* Loaded secondary compilation units are kept in memory until they
812 have not been referenced for the processing of this many
813 compilation units. Set this to zero to disable caching. Cache
814 sizes of up to at least twenty will improve startup time for
815 typical inter-CU-reference binaries, at an obvious memory cost. */
816 static int dwarf2_max_cache_age
= 5;
818 show_dwarf2_max_cache_age (struct ui_file
*file
, int from_tty
,
819 struct cmd_list_element
*c
, const char *value
)
821 fprintf_filtered (file
, _("The upper bound on the age of cached "
822 "dwarf2 compilation units is %s.\n"),
827 /* Various complaints about symbol reading that don't abort the process. */
830 dwarf2_statement_list_fits_in_line_number_section_complaint (void)
832 complaint (&symfile_complaints
,
833 _("statement list doesn't fit in .debug_line section"));
837 dwarf2_debug_line_missing_file_complaint (void)
839 complaint (&symfile_complaints
,
840 _(".debug_line section has line data without a file"));
844 dwarf2_debug_line_missing_end_sequence_complaint (void)
846 complaint (&symfile_complaints
,
847 _(".debug_line section has line "
848 "program sequence without an end"));
852 dwarf2_complex_location_expr_complaint (void)
854 complaint (&symfile_complaints
, _("location expression too complex"));
858 dwarf2_const_value_length_mismatch_complaint (const char *arg1
, int arg2
,
861 complaint (&symfile_complaints
,
862 _("const value length mismatch for '%s', got %d, expected %d"),
867 dwarf2_macros_too_long_complaint (struct dwarf2_section_info
*section
)
869 complaint (&symfile_complaints
,
870 _("macro info runs off end of `%s' section"),
871 section
->asection
->name
);
875 dwarf2_macro_malformed_definition_complaint (const char *arg1
)
877 complaint (&symfile_complaints
,
878 _("macro debug info contains a "
879 "malformed macro definition:\n`%s'"),
884 dwarf2_invalid_attrib_class_complaint (const char *arg1
, const char *arg2
)
886 complaint (&symfile_complaints
,
887 _("invalid attribute class or form for '%s' in '%s'"),
891 /* local function prototypes */
893 static void dwarf2_locate_sections (bfd
*, asection
*, void *);
895 static void dwarf2_create_include_psymtab (char *, struct partial_symtab
*,
898 static void dwarf2_find_base_address (struct die_info
*die
,
899 struct dwarf2_cu
*cu
);
901 static void dwarf2_build_psymtabs_hard (struct objfile
*);
903 static void scan_partial_symbols (struct partial_die_info
*,
904 CORE_ADDR
*, CORE_ADDR
*,
905 int, struct dwarf2_cu
*);
907 static void add_partial_symbol (struct partial_die_info
*,
910 static void add_partial_namespace (struct partial_die_info
*pdi
,
911 CORE_ADDR
*lowpc
, CORE_ADDR
*highpc
,
912 int need_pc
, struct dwarf2_cu
*cu
);
914 static void add_partial_module (struct partial_die_info
*pdi
, CORE_ADDR
*lowpc
,
915 CORE_ADDR
*highpc
, int need_pc
,
916 struct dwarf2_cu
*cu
);
918 static void add_partial_enumeration (struct partial_die_info
*enum_pdi
,
919 struct dwarf2_cu
*cu
);
921 static void add_partial_subprogram (struct partial_die_info
*pdi
,
922 CORE_ADDR
*lowpc
, CORE_ADDR
*highpc
,
923 int need_pc
, struct dwarf2_cu
*cu
);
925 static gdb_byte
*locate_pdi_sibling (struct partial_die_info
*orig_pdi
,
926 gdb_byte
*buffer
, gdb_byte
*info_ptr
,
927 bfd
*abfd
, struct dwarf2_cu
*cu
);
929 static void dwarf2_psymtab_to_symtab (struct partial_symtab
*);
931 static void psymtab_to_symtab_1 (struct partial_symtab
*);
933 static void dwarf2_read_abbrevs (bfd
*abfd
, struct dwarf2_cu
*cu
);
935 static void dwarf2_free_abbrev_table (void *);
937 static struct abbrev_info
*peek_die_abbrev (gdb_byte
*, unsigned int *,
940 static struct abbrev_info
*dwarf2_lookup_abbrev (unsigned int,
943 static struct partial_die_info
*load_partial_dies (bfd
*,
944 gdb_byte
*, gdb_byte
*,
945 int, struct dwarf2_cu
*);
947 static gdb_byte
*read_partial_die (struct partial_die_info
*,
948 struct abbrev_info
*abbrev
,
950 gdb_byte
*, gdb_byte
*,
953 static struct partial_die_info
*find_partial_die (unsigned int,
956 static void fixup_partial_die (struct partial_die_info
*,
959 static gdb_byte
*read_attribute (struct attribute
*, struct attr_abbrev
*,
960 bfd
*, gdb_byte
*, struct dwarf2_cu
*);
962 static gdb_byte
*read_attribute_value (struct attribute
*, unsigned,
963 bfd
*, gdb_byte
*, struct dwarf2_cu
*);
965 static unsigned int read_1_byte (bfd
*, gdb_byte
*);
967 static int read_1_signed_byte (bfd
*, gdb_byte
*);
969 static unsigned int read_2_bytes (bfd
*, gdb_byte
*);
971 static unsigned int read_4_bytes (bfd
*, gdb_byte
*);
973 static ULONGEST
read_8_bytes (bfd
*, gdb_byte
*);
975 static CORE_ADDR
read_address (bfd
*, gdb_byte
*ptr
, struct dwarf2_cu
*,
978 static LONGEST
read_initial_length (bfd
*, gdb_byte
*, unsigned int *);
980 static LONGEST read_checked_initial_length_and_offset
981 (bfd
*, gdb_byte
*, const struct comp_unit_head
*,
982 unsigned int *, unsigned int *);
984 static LONGEST
read_offset (bfd
*, gdb_byte
*, const struct comp_unit_head
*,
987 static LONGEST
read_offset_1 (bfd
*, gdb_byte
*, unsigned int);
989 static gdb_byte
*read_n_bytes (bfd
*, gdb_byte
*, unsigned int);
991 static char *read_direct_string (bfd
*, gdb_byte
*, unsigned int *);
993 static char *read_indirect_string (bfd
*, gdb_byte
*,
994 const struct comp_unit_head
*,
997 static unsigned long read_unsigned_leb128 (bfd
*, gdb_byte
*, unsigned int *);
999 static long read_signed_leb128 (bfd
*, gdb_byte
*, unsigned int *);
1001 static gdb_byte
*skip_leb128 (bfd
*, gdb_byte
*);
1003 static void set_cu_language (unsigned int, struct dwarf2_cu
*);
1005 static struct attribute
*dwarf2_attr (struct die_info
*, unsigned int,
1006 struct dwarf2_cu
*);
1008 static struct attribute
*dwarf2_attr_no_follow (struct die_info
*,
1010 struct dwarf2_cu
*);
1012 static int dwarf2_flag_true_p (struct die_info
*die
, unsigned name
,
1013 struct dwarf2_cu
*cu
);
1015 static int die_is_declaration (struct die_info
*, struct dwarf2_cu
*cu
);
1017 static struct die_info
*die_specification (struct die_info
*die
,
1018 struct dwarf2_cu
**);
1020 static void free_line_header (struct line_header
*lh
);
1022 static void add_file_name (struct line_header
*, char *, unsigned int,
1023 unsigned int, unsigned int);
1025 static struct line_header
*(dwarf_decode_line_header
1026 (unsigned int offset
,
1027 bfd
*abfd
, struct dwarf2_cu
*cu
));
1029 static void dwarf_decode_lines (struct line_header
*, const char *, bfd
*,
1030 struct dwarf2_cu
*, struct partial_symtab
*);
1032 static void dwarf2_start_subfile (char *, const char *, const char *);
1034 static struct symbol
*new_symbol (struct die_info
*, struct type
*,
1035 struct dwarf2_cu
*);
1037 static struct symbol
*new_symbol_full (struct die_info
*, struct type
*,
1038 struct dwarf2_cu
*, struct symbol
*);
1040 static void dwarf2_const_value (struct attribute
*, struct symbol
*,
1041 struct dwarf2_cu
*);
1043 static void dwarf2_const_value_attr (struct attribute
*attr
,
1046 struct obstack
*obstack
,
1047 struct dwarf2_cu
*cu
, long *value
,
1049 struct dwarf2_locexpr_baton
**baton
);
1051 static struct type
*die_type (struct die_info
*, struct dwarf2_cu
*);
1053 static int need_gnat_info (struct dwarf2_cu
*);
1055 static struct type
*die_descriptive_type (struct die_info
*,
1056 struct dwarf2_cu
*);
1058 static void set_descriptive_type (struct type
*, struct die_info
*,
1059 struct dwarf2_cu
*);
1061 static struct type
*die_containing_type (struct die_info
*,
1062 struct dwarf2_cu
*);
1064 static struct type
*lookup_die_type (struct die_info
*, struct attribute
*,
1065 struct dwarf2_cu
*);
1067 static struct type
*read_type_die (struct die_info
*, struct dwarf2_cu
*);
1069 static struct type
*read_type_die_1 (struct die_info
*, struct dwarf2_cu
*);
1071 static char *determine_prefix (struct die_info
*die
, struct dwarf2_cu
*);
1073 static char *typename_concat (struct obstack
*obs
, const char *prefix
,
1074 const char *suffix
, int physname
,
1075 struct dwarf2_cu
*cu
);
1077 static void read_file_scope (struct die_info
*, struct dwarf2_cu
*);
1079 static void read_type_unit_scope (struct die_info
*, struct dwarf2_cu
*);
1081 static void read_func_scope (struct die_info
*, struct dwarf2_cu
*);
1083 static void read_lexical_block_scope (struct die_info
*, struct dwarf2_cu
*);
1085 static void read_call_site_scope (struct die_info
*die
, struct dwarf2_cu
*cu
);
1087 static int dwarf2_ranges_read (unsigned, CORE_ADDR
*, CORE_ADDR
*,
1088 struct dwarf2_cu
*, struct partial_symtab
*);
1090 static int dwarf2_get_pc_bounds (struct die_info
*,
1091 CORE_ADDR
*, CORE_ADDR
*, struct dwarf2_cu
*,
1092 struct partial_symtab
*);
1094 static void get_scope_pc_bounds (struct die_info
*,
1095 CORE_ADDR
*, CORE_ADDR
*,
1096 struct dwarf2_cu
*);
1098 static void dwarf2_record_block_ranges (struct die_info
*, struct block
*,
1099 CORE_ADDR
, struct dwarf2_cu
*);
1101 static void dwarf2_add_field (struct field_info
*, struct die_info
*,
1102 struct dwarf2_cu
*);
1104 static void dwarf2_attach_fields_to_type (struct field_info
*,
1105 struct type
*, struct dwarf2_cu
*);
1107 static void dwarf2_add_member_fn (struct field_info
*,
1108 struct die_info
*, struct type
*,
1109 struct dwarf2_cu
*);
1111 static void dwarf2_attach_fn_fields_to_type (struct field_info
*,
1113 struct dwarf2_cu
*);
1115 static void process_structure_scope (struct die_info
*, struct dwarf2_cu
*);
1117 static void read_common_block (struct die_info
*, struct dwarf2_cu
*);
1119 static void read_namespace (struct die_info
*die
, struct dwarf2_cu
*);
1121 static void read_module (struct die_info
*die
, struct dwarf2_cu
*cu
);
1123 static void read_import_statement (struct die_info
*die
, struct dwarf2_cu
*);
1125 static struct type
*read_module_type (struct die_info
*die
,
1126 struct dwarf2_cu
*cu
);
1128 static const char *namespace_name (struct die_info
*die
,
1129 int *is_anonymous
, struct dwarf2_cu
*);
1131 static void process_enumeration_scope (struct die_info
*, struct dwarf2_cu
*);
1133 static CORE_ADDR
decode_locdesc (struct dwarf_block
*, struct dwarf2_cu
*);
1135 static enum dwarf_array_dim_ordering
read_array_order (struct die_info
*,
1136 struct dwarf2_cu
*);
1138 static struct die_info
*read_comp_unit (gdb_byte
*, struct dwarf2_cu
*);
1140 static struct die_info
*read_die_and_children_1 (const struct die_reader_specs
*reader
,
1142 gdb_byte
**new_info_ptr
,
1143 struct die_info
*parent
);
1145 static struct die_info
*read_die_and_children (const struct die_reader_specs
*reader
,
1147 gdb_byte
**new_info_ptr
,
1148 struct die_info
*parent
);
1150 static struct die_info
*read_die_and_siblings (const struct die_reader_specs
*reader
,
1152 gdb_byte
**new_info_ptr
,
1153 struct die_info
*parent
);
1155 static gdb_byte
*read_full_die (const struct die_reader_specs
*reader
,
1156 struct die_info
**, gdb_byte
*,
1159 static void process_die (struct die_info
*, struct dwarf2_cu
*);
1161 static char *dwarf2_canonicalize_name (char *, struct dwarf2_cu
*,
1164 static char *dwarf2_name (struct die_info
*die
, struct dwarf2_cu
*);
1166 static const char *dwarf2_full_name (char *name
,
1167 struct die_info
*die
,
1168 struct dwarf2_cu
*cu
);
1170 static struct die_info
*dwarf2_extension (struct die_info
*die
,
1171 struct dwarf2_cu
**);
1173 static char *dwarf_tag_name (unsigned int);
1175 static char *dwarf_attr_name (unsigned int);
1177 static char *dwarf_form_name (unsigned int);
1179 static char *dwarf_bool_name (unsigned int);
1181 static char *dwarf_type_encoding_name (unsigned int);
1184 static char *dwarf_cfi_name (unsigned int);
1187 static struct die_info
*sibling_die (struct die_info
*);
1189 static void dump_die_shallow (struct ui_file
*, int indent
, struct die_info
*);
1191 static void dump_die_for_error (struct die_info
*);
1193 static void dump_die_1 (struct ui_file
*, int level
, int max_level
,
1196 /*static*/ void dump_die (struct die_info
*, int max_level
);
1198 static void store_in_ref_table (struct die_info
*,
1199 struct dwarf2_cu
*);
1201 static int is_ref_attr (struct attribute
*);
1203 static unsigned int dwarf2_get_ref_die_offset (struct attribute
*);
1205 static LONGEST
dwarf2_get_attr_constant_value (struct attribute
*, int);
1207 static struct die_info
*follow_die_ref_or_sig (struct die_info
*,
1209 struct dwarf2_cu
**);
1211 static struct die_info
*follow_die_ref (struct die_info
*,
1213 struct dwarf2_cu
**);
1215 static struct die_info
*follow_die_sig (struct die_info
*,
1217 struct dwarf2_cu
**);
1219 static struct signatured_type
*lookup_signatured_type_at_offset
1220 (struct objfile
*objfile
,
1221 struct dwarf2_section_info
*section
,
1222 unsigned int offset
);
1224 static void read_signatured_type_at_offset (struct objfile
*objfile
,
1225 struct dwarf2_section_info
*sect
,
1226 unsigned int offset
);
1228 static void read_signatured_type (struct objfile
*,
1229 struct signatured_type
*type_sig
);
1231 /* memory allocation interface */
1233 static struct dwarf_block
*dwarf_alloc_block (struct dwarf2_cu
*);
1235 static struct abbrev_info
*dwarf_alloc_abbrev (struct dwarf2_cu
*);
1237 static struct die_info
*dwarf_alloc_die (struct dwarf2_cu
*, int);
1239 static void initialize_cu_func_list (struct dwarf2_cu
*);
1241 static void add_to_cu_func_list (const char *, CORE_ADDR
, CORE_ADDR
,
1242 struct dwarf2_cu
*);
1244 static void dwarf_decode_macros (struct line_header
*, unsigned int,
1245 char *, bfd
*, struct dwarf2_cu
*,
1246 struct dwarf2_section_info
*,
1249 static int attr_form_is_block (struct attribute
*);
1251 static int attr_form_is_section_offset (struct attribute
*);
1253 static int attr_form_is_constant (struct attribute
*);
1255 static void fill_in_loclist_baton (struct dwarf2_cu
*cu
,
1256 struct dwarf2_loclist_baton
*baton
,
1257 struct attribute
*attr
);
1259 static void dwarf2_symbol_mark_computed (struct attribute
*attr
,
1261 struct dwarf2_cu
*cu
);
1263 static gdb_byte
*skip_one_die (gdb_byte
*buffer
, gdb_byte
*info_ptr
,
1264 struct abbrev_info
*abbrev
,
1265 struct dwarf2_cu
*cu
);
1267 static void free_stack_comp_unit (void *);
1269 static hashval_t
partial_die_hash (const void *item
);
1271 static int partial_die_eq (const void *item_lhs
, const void *item_rhs
);
1273 static struct dwarf2_per_cu_data
*dwarf2_find_containing_comp_unit
1274 (unsigned int offset
, struct objfile
*objfile
);
1276 static struct dwarf2_per_cu_data
*dwarf2_find_comp_unit
1277 (unsigned int offset
, struct objfile
*objfile
);
1279 static void init_one_comp_unit (struct dwarf2_cu
*cu
,
1280 struct objfile
*objfile
);
1282 static void prepare_one_comp_unit (struct dwarf2_cu
*cu
,
1283 struct die_info
*comp_unit_die
);
1285 static void free_one_comp_unit (void *);
1287 static void free_cached_comp_units (void *);
1289 static void age_cached_comp_units (void);
1291 static void free_one_cached_comp_unit (void *);
1293 static struct type
*set_die_type (struct die_info
*, struct type
*,
1294 struct dwarf2_cu
*);
1296 static void create_all_comp_units (struct objfile
*);
1298 static int create_debug_types_hash_table (struct objfile
*objfile
);
1300 static void load_full_comp_unit (struct dwarf2_per_cu_data
*,
1303 static void process_full_comp_unit (struct dwarf2_per_cu_data
*);
1305 static void dwarf2_add_dependence (struct dwarf2_cu
*,
1306 struct dwarf2_per_cu_data
*);
1308 static void dwarf2_mark (struct dwarf2_cu
*);
1310 static void dwarf2_clear_marks (struct dwarf2_per_cu_data
*);
1312 static struct type
*get_die_type_at_offset (unsigned int,
1313 struct dwarf2_per_cu_data
*per_cu
);
1315 static struct type
*get_die_type (struct die_info
*die
, struct dwarf2_cu
*cu
);
1317 static void dwarf2_release_queue (void *dummy
);
1319 static void queue_comp_unit (struct dwarf2_per_cu_data
*per_cu
,
1320 struct objfile
*objfile
);
1322 static void process_queue (struct objfile
*objfile
);
1324 static void find_file_and_directory (struct die_info
*die
,
1325 struct dwarf2_cu
*cu
,
1326 char **name
, char **comp_dir
);
1328 static char *file_full_name (int file
, struct line_header
*lh
,
1329 const char *comp_dir
);
1331 static gdb_byte
*partial_read_comp_unit_head (struct comp_unit_head
*header
,
1334 unsigned int buffer_size
,
1337 static void init_cu_die_reader (struct die_reader_specs
*reader
,
1338 struct dwarf2_cu
*cu
);
1340 static htab_t
allocate_signatured_type_table (struct objfile
*objfile
);
1344 /* Convert VALUE between big- and little-endian. */
1346 byte_swap (offset_type value
)
1350 result
= (value
& 0xff) << 24;
1351 result
|= (value
& 0xff00) << 8;
1352 result
|= (value
& 0xff0000) >> 8;
1353 result
|= (value
& 0xff000000) >> 24;
1357 #define MAYBE_SWAP(V) byte_swap (V)
1360 #define MAYBE_SWAP(V) (V)
1361 #endif /* WORDS_BIGENDIAN */
1363 /* The suffix for an index file. */
1364 #define INDEX_SUFFIX ".gdb-index"
1366 static const char *dwarf2_physname (char *name
, struct die_info
*die
,
1367 struct dwarf2_cu
*cu
);
1369 /* Try to locate the sections we need for DWARF 2 debugging
1370 information and return true if we have enough to do something.
1371 NAMES points to the dwarf2 section names, or is NULL if the standard
1372 ELF names are used. */
1375 dwarf2_has_info (struct objfile
*objfile
,
1376 const struct dwarf2_debug_sections
*names
)
1378 dwarf2_per_objfile
= objfile_data (objfile
, dwarf2_objfile_data_key
);
1379 if (!dwarf2_per_objfile
)
1381 /* Initialize per-objfile state. */
1382 struct dwarf2_per_objfile
*data
1383 = obstack_alloc (&objfile
->objfile_obstack
, sizeof (*data
));
1385 memset (data
, 0, sizeof (*data
));
1386 set_objfile_data (objfile
, dwarf2_objfile_data_key
, data
);
1387 dwarf2_per_objfile
= data
;
1389 bfd_map_over_sections (objfile
->obfd
, dwarf2_locate_sections
,
1391 dwarf2_per_objfile
->objfile
= objfile
;
1393 return (dwarf2_per_objfile
->info
.asection
!= NULL
1394 && dwarf2_per_objfile
->abbrev
.asection
!= NULL
);
1397 /* When loading sections, we look either for uncompressed section or for
1398 compressed section names. */
1401 section_is_p (const char *section_name
,
1402 const struct dwarf2_section_names
*names
)
1404 if (names
->normal
!= NULL
1405 && strcmp (section_name
, names
->normal
) == 0)
1407 if (names
->compressed
!= NULL
1408 && strcmp (section_name
, names
->compressed
) == 0)
1413 /* This function is mapped across the sections and remembers the
1414 offset and size of each of the debugging sections we are interested
1418 dwarf2_locate_sections (bfd
*abfd
, asection
*sectp
, void *vnames
)
1420 const struct dwarf2_debug_sections
*names
;
1423 names
= &dwarf2_elf_names
;
1425 names
= (const struct dwarf2_debug_sections
*) vnames
;
1427 if (section_is_p (sectp
->name
, &names
->info
))
1429 dwarf2_per_objfile
->info
.asection
= sectp
;
1430 dwarf2_per_objfile
->info
.size
= bfd_get_section_size (sectp
);
1432 else if (section_is_p (sectp
->name
, &names
->abbrev
))
1434 dwarf2_per_objfile
->abbrev
.asection
= sectp
;
1435 dwarf2_per_objfile
->abbrev
.size
= bfd_get_section_size (sectp
);
1437 else if (section_is_p (sectp
->name
, &names
->line
))
1439 dwarf2_per_objfile
->line
.asection
= sectp
;
1440 dwarf2_per_objfile
->line
.size
= bfd_get_section_size (sectp
);
1442 else if (section_is_p (sectp
->name
, &names
->loc
))
1444 dwarf2_per_objfile
->loc
.asection
= sectp
;
1445 dwarf2_per_objfile
->loc
.size
= bfd_get_section_size (sectp
);
1447 else if (section_is_p (sectp
->name
, &names
->macinfo
))
1449 dwarf2_per_objfile
->macinfo
.asection
= sectp
;
1450 dwarf2_per_objfile
->macinfo
.size
= bfd_get_section_size (sectp
);
1452 else if (section_is_p (sectp
->name
, &names
->macro
))
1454 dwarf2_per_objfile
->macro
.asection
= sectp
;
1455 dwarf2_per_objfile
->macro
.size
= bfd_get_section_size (sectp
);
1457 else if (section_is_p (sectp
->name
, &names
->str
))
1459 dwarf2_per_objfile
->str
.asection
= sectp
;
1460 dwarf2_per_objfile
->str
.size
= bfd_get_section_size (sectp
);
1462 else if (section_is_p (sectp
->name
, &names
->frame
))
1464 dwarf2_per_objfile
->frame
.asection
= sectp
;
1465 dwarf2_per_objfile
->frame
.size
= bfd_get_section_size (sectp
);
1467 else if (section_is_p (sectp
->name
, &names
->eh_frame
))
1469 flagword aflag
= bfd_get_section_flags (ignore_abfd
, sectp
);
1471 if (aflag
& SEC_HAS_CONTENTS
)
1473 dwarf2_per_objfile
->eh_frame
.asection
= sectp
;
1474 dwarf2_per_objfile
->eh_frame
.size
= bfd_get_section_size (sectp
);
1477 else if (section_is_p (sectp
->name
, &names
->ranges
))
1479 dwarf2_per_objfile
->ranges
.asection
= sectp
;
1480 dwarf2_per_objfile
->ranges
.size
= bfd_get_section_size (sectp
);
1482 else if (section_is_p (sectp
->name
, &names
->types
))
1484 struct dwarf2_section_info type_section
;
1486 memset (&type_section
, 0, sizeof (type_section
));
1487 type_section
.asection
= sectp
;
1488 type_section
.size
= bfd_get_section_size (sectp
);
1490 VEC_safe_push (dwarf2_section_info_def
, dwarf2_per_objfile
->types
,
1493 else if (section_is_p (sectp
->name
, &names
->gdb_index
))
1495 dwarf2_per_objfile
->gdb_index
.asection
= sectp
;
1496 dwarf2_per_objfile
->gdb_index
.size
= bfd_get_section_size (sectp
);
1499 if ((bfd_get_section_flags (abfd
, sectp
) & SEC_LOAD
)
1500 && bfd_section_vma (abfd
, sectp
) == 0)
1501 dwarf2_per_objfile
->has_section_at_zero
= 1;
1504 /* Decompress a section that was compressed using zlib. Store the
1505 decompressed buffer, and its size, in OUTBUF and OUTSIZE. */
1508 zlib_decompress_section (struct objfile
*objfile
, asection
*sectp
,
1509 gdb_byte
**outbuf
, bfd_size_type
*outsize
)
1511 bfd
*abfd
= objfile
->obfd
;
1513 error (_("Support for zlib-compressed DWARF data (from '%s') "
1514 "is disabled in this copy of GDB"),
1515 bfd_get_filename (abfd
));
1517 bfd_size_type compressed_size
= bfd_get_section_size (sectp
);
1518 gdb_byte
*compressed_buffer
= xmalloc (compressed_size
);
1519 struct cleanup
*cleanup
= make_cleanup (xfree
, compressed_buffer
);
1520 bfd_size_type uncompressed_size
;
1521 gdb_byte
*uncompressed_buffer
;
1524 int header_size
= 12;
1526 if (bfd_seek (abfd
, sectp
->filepos
, SEEK_SET
) != 0
1527 || bfd_bread (compressed_buffer
,
1528 compressed_size
, abfd
) != compressed_size
)
1529 error (_("Dwarf Error: Can't read DWARF data from '%s'"),
1530 bfd_get_filename (abfd
));
1532 /* Read the zlib header. In this case, it should be "ZLIB" followed
1533 by the uncompressed section size, 8 bytes in big-endian order. */
1534 if (compressed_size
< header_size
1535 || strncmp (compressed_buffer
, "ZLIB", 4) != 0)
1536 error (_("Dwarf Error: Corrupt DWARF ZLIB header from '%s'"),
1537 bfd_get_filename (abfd
));
1538 uncompressed_size
= compressed_buffer
[4]; uncompressed_size
<<= 8;
1539 uncompressed_size
+= compressed_buffer
[5]; uncompressed_size
<<= 8;
1540 uncompressed_size
+= compressed_buffer
[6]; uncompressed_size
<<= 8;
1541 uncompressed_size
+= compressed_buffer
[7]; uncompressed_size
<<= 8;
1542 uncompressed_size
+= compressed_buffer
[8]; uncompressed_size
<<= 8;
1543 uncompressed_size
+= compressed_buffer
[9]; uncompressed_size
<<= 8;
1544 uncompressed_size
+= compressed_buffer
[10]; uncompressed_size
<<= 8;
1545 uncompressed_size
+= compressed_buffer
[11];
1547 /* It is possible the section consists of several compressed
1548 buffers concatenated together, so we uncompress in a loop. */
1552 strm
.avail_in
= compressed_size
- header_size
;
1553 strm
.next_in
= (Bytef
*) compressed_buffer
+ header_size
;
1554 strm
.avail_out
= uncompressed_size
;
1555 uncompressed_buffer
= obstack_alloc (&objfile
->objfile_obstack
,
1557 rc
= inflateInit (&strm
);
1558 while (strm
.avail_in
> 0)
1561 error (_("Dwarf Error: setting up DWARF uncompression in '%s': %d"),
1562 bfd_get_filename (abfd
), rc
);
1563 strm
.next_out
= ((Bytef
*) uncompressed_buffer
1564 + (uncompressed_size
- strm
.avail_out
));
1565 rc
= inflate (&strm
, Z_FINISH
);
1566 if (rc
!= Z_STREAM_END
)
1567 error (_("Dwarf Error: zlib error uncompressing from '%s': %d"),
1568 bfd_get_filename (abfd
), rc
);
1569 rc
= inflateReset (&strm
);
1571 rc
= inflateEnd (&strm
);
1573 || strm
.avail_out
!= 0)
1574 error (_("Dwarf Error: concluding DWARF uncompression in '%s': %d"),
1575 bfd_get_filename (abfd
), rc
);
1577 do_cleanups (cleanup
);
1578 *outbuf
= uncompressed_buffer
;
1579 *outsize
= uncompressed_size
;
1583 /* A helper function that decides whether a section is empty. */
1586 dwarf2_section_empty_p (struct dwarf2_section_info
*info
)
1588 return info
->asection
== NULL
|| info
->size
== 0;
1591 /* Read the contents of the section SECTP from object file specified by
1592 OBJFILE, store info about the section into INFO.
1593 If the section is compressed, uncompress it before returning. */
1596 dwarf2_read_section (struct objfile
*objfile
, struct dwarf2_section_info
*info
)
1598 bfd
*abfd
= objfile
->obfd
;
1599 asection
*sectp
= info
->asection
;
1600 gdb_byte
*buf
, *retbuf
;
1601 unsigned char header
[4];
1605 info
->buffer
= NULL
;
1606 info
->map_addr
= NULL
;
1609 if (dwarf2_section_empty_p (info
))
1612 /* Check if the file has a 4-byte header indicating compression. */
1613 if (info
->size
> sizeof (header
)
1614 && bfd_seek (abfd
, sectp
->filepos
, SEEK_SET
) == 0
1615 && bfd_bread (header
, sizeof (header
), abfd
) == sizeof (header
))
1617 /* Upon decompression, update the buffer and its size. */
1618 if (strncmp (header
, "ZLIB", sizeof (header
)) == 0)
1620 zlib_decompress_section (objfile
, sectp
, &info
->buffer
,
1628 pagesize
= getpagesize ();
1630 /* Only try to mmap sections which are large enough: we don't want to
1631 waste space due to fragmentation. Also, only try mmap for sections
1632 without relocations. */
1634 if (info
->size
> 4 * pagesize
&& (sectp
->flags
& SEC_RELOC
) == 0)
1636 info
->buffer
= bfd_mmap (abfd
, 0, info
->size
, PROT_READ
,
1637 MAP_PRIVATE
, sectp
->filepos
,
1638 &info
->map_addr
, &info
->map_len
);
1640 if ((caddr_t
)info
->buffer
!= MAP_FAILED
)
1642 #if HAVE_POSIX_MADVISE
1643 posix_madvise (info
->map_addr
, info
->map_len
, POSIX_MADV_WILLNEED
);
1650 /* If we get here, we are a normal, not-compressed section. */
1652 = obstack_alloc (&objfile
->objfile_obstack
, info
->size
);
1654 /* When debugging .o files, we may need to apply relocations; see
1655 http://sourceware.org/ml/gdb-patches/2002-04/msg00136.html .
1656 We never compress sections in .o files, so we only need to
1657 try this when the section is not compressed. */
1658 retbuf
= symfile_relocate_debug_section (objfile
, sectp
, buf
);
1661 info
->buffer
= retbuf
;
1665 if (bfd_seek (abfd
, sectp
->filepos
, SEEK_SET
) != 0
1666 || bfd_bread (buf
, info
->size
, abfd
) != info
->size
)
1667 error (_("Dwarf Error: Can't read DWARF data from '%s'"),
1668 bfd_get_filename (abfd
));
1671 /* A helper function that returns the size of a section in a safe way.
1672 If you are positive that the section has been read before using the
1673 size, then it is safe to refer to the dwarf2_section_info object's
1674 "size" field directly. In other cases, you must call this
1675 function, because for compressed sections the size field is not set
1676 correctly until the section has been read. */
1678 static bfd_size_type
1679 dwarf2_section_size (struct objfile
*objfile
,
1680 struct dwarf2_section_info
*info
)
1683 dwarf2_read_section (objfile
, info
);
1687 /* Fill in SECTP, BUFP and SIZEP with section info, given OBJFILE and
1691 dwarf2_get_section_info (struct objfile
*objfile
,
1692 enum dwarf2_section_enum sect
,
1693 asection
**sectp
, gdb_byte
**bufp
,
1694 bfd_size_type
*sizep
)
1696 struct dwarf2_per_objfile
*data
1697 = objfile_data (objfile
, dwarf2_objfile_data_key
);
1698 struct dwarf2_section_info
*info
;
1700 /* We may see an objfile without any DWARF, in which case we just
1711 case DWARF2_DEBUG_FRAME
:
1712 info
= &data
->frame
;
1714 case DWARF2_EH_FRAME
:
1715 info
= &data
->eh_frame
;
1718 gdb_assert_not_reached ("unexpected section");
1721 dwarf2_read_section (objfile
, info
);
1723 *sectp
= info
->asection
;
1724 *bufp
= info
->buffer
;
1725 *sizep
= info
->size
;
1729 /* DWARF quick_symbols_functions support. */
1731 /* TUs can share .debug_line entries, and there can be a lot more TUs than
1732 unique line tables, so we maintain a separate table of all .debug_line
1733 derived entries to support the sharing.
1734 All the quick functions need is the list of file names. We discard the
1735 line_header when we're done and don't need to record it here. */
1736 struct quick_file_names
1738 /* The offset in .debug_line of the line table. We hash on this. */
1739 unsigned int offset
;
1741 /* The number of entries in file_names, real_names. */
1742 unsigned int num_file_names
;
1744 /* The file names from the line table, after being run through
1746 const char **file_names
;
1748 /* The file names from the line table after being run through
1749 gdb_realpath. These are computed lazily. */
1750 const char **real_names
;
1753 /* When using the index (and thus not using psymtabs), each CU has an
1754 object of this type. This is used to hold information needed by
1755 the various "quick" methods. */
1756 struct dwarf2_per_cu_quick_data
1758 /* The file table. This can be NULL if there was no file table
1759 or it's currently not read in.
1760 NOTE: This points into dwarf2_per_objfile->quick_file_names_table. */
1761 struct quick_file_names
*file_names
;
1763 /* The corresponding symbol table. This is NULL if symbols for this
1764 CU have not yet been read. */
1765 struct symtab
*symtab
;
1767 /* A temporary mark bit used when iterating over all CUs in
1768 expand_symtabs_matching. */
1769 unsigned int mark
: 1;
1771 /* True if we've tried to read the file table and found there isn't one.
1772 There will be no point in trying to read it again next time. */
1773 unsigned int no_file_data
: 1;
1776 /* Hash function for a quick_file_names. */
1779 hash_file_name_entry (const void *e
)
1781 const struct quick_file_names
*file_data
= e
;
1783 return file_data
->offset
;
1786 /* Equality function for a quick_file_names. */
1789 eq_file_name_entry (const void *a
, const void *b
)
1791 const struct quick_file_names
*ea
= a
;
1792 const struct quick_file_names
*eb
= b
;
1794 return ea
->offset
== eb
->offset
;
1797 /* Delete function for a quick_file_names. */
1800 delete_file_name_entry (void *e
)
1802 struct quick_file_names
*file_data
= e
;
1805 for (i
= 0; i
< file_data
->num_file_names
; ++i
)
1807 xfree ((void*) file_data
->file_names
[i
]);
1808 if (file_data
->real_names
)
1809 xfree ((void*) file_data
->real_names
[i
]);
1812 /* The space for the struct itself lives on objfile_obstack,
1813 so we don't free it here. */
1816 /* Create a quick_file_names hash table. */
1819 create_quick_file_names_table (unsigned int nr_initial_entries
)
1821 return htab_create_alloc (nr_initial_entries
,
1822 hash_file_name_entry
, eq_file_name_entry
,
1823 delete_file_name_entry
, xcalloc
, xfree
);
1826 /* Read in PER_CU->CU. This function is unrelated to symtabs, symtab would
1827 have to be created afterwards. You should call age_cached_comp_units after
1828 processing PER_CU->CU. dw2_setup must have been already called. */
1831 load_cu (struct dwarf2_per_cu_data
*per_cu
)
1833 if (per_cu
->debug_type_section
)
1834 read_signatured_type_at_offset (per_cu
->objfile
,
1835 per_cu
->debug_type_section
,
1838 load_full_comp_unit (per_cu
, per_cu
->objfile
);
1840 dwarf2_find_base_address (per_cu
->cu
->dies
, per_cu
->cu
);
1842 gdb_assert (per_cu
->cu
!= NULL
);
1845 /* Read in the symbols for PER_CU. OBJFILE is the objfile from which
1849 dw2_do_instantiate_symtab (struct objfile
*objfile
,
1850 struct dwarf2_per_cu_data
*per_cu
)
1852 struct cleanup
*back_to
;
1854 back_to
= make_cleanup (dwarf2_release_queue
, NULL
);
1856 queue_comp_unit (per_cu
, objfile
);
1860 process_queue (objfile
);
1862 /* Age the cache, releasing compilation units that have not
1863 been used recently. */
1864 age_cached_comp_units ();
1866 do_cleanups (back_to
);
1869 /* Ensure that the symbols for PER_CU have been read in. OBJFILE is
1870 the objfile from which this CU came. Returns the resulting symbol
1873 static struct symtab
*
1874 dw2_instantiate_symtab (struct objfile
*objfile
,
1875 struct dwarf2_per_cu_data
*per_cu
)
1877 if (!per_cu
->v
.quick
->symtab
)
1879 struct cleanup
*back_to
= make_cleanup (free_cached_comp_units
, NULL
);
1880 increment_reading_symtab ();
1881 dw2_do_instantiate_symtab (objfile
, per_cu
);
1882 do_cleanups (back_to
);
1884 return per_cu
->v
.quick
->symtab
;
1887 /* Return the CU given its index. */
1889 static struct dwarf2_per_cu_data
*
1890 dw2_get_cu (int index
)
1892 if (index
>= dwarf2_per_objfile
->n_comp_units
)
1894 index
-= dwarf2_per_objfile
->n_comp_units
;
1895 return dwarf2_per_objfile
->type_comp_units
[index
];
1897 return dwarf2_per_objfile
->all_comp_units
[index
];
1900 /* A helper function that knows how to read a 64-bit value in a way
1901 that doesn't make gdb die. Returns 1 if the conversion went ok, 0
1905 extract_cu_value (const char *bytes
, ULONGEST
*result
)
1907 if (sizeof (ULONGEST
) < 8)
1911 /* Ignore the upper 4 bytes if they are all zero. */
1912 for (i
= 0; i
< 4; ++i
)
1913 if (bytes
[i
+ 4] != 0)
1916 *result
= extract_unsigned_integer (bytes
, 4, BFD_ENDIAN_LITTLE
);
1919 *result
= extract_unsigned_integer (bytes
, 8, BFD_ENDIAN_LITTLE
);
1923 /* Read the CU list from the mapped index, and use it to create all
1924 the CU objects for this objfile. Return 0 if something went wrong,
1925 1 if everything went ok. */
1928 create_cus_from_index (struct objfile
*objfile
, const gdb_byte
*cu_list
,
1929 offset_type cu_list_elements
)
1933 dwarf2_per_objfile
->n_comp_units
= cu_list_elements
/ 2;
1934 dwarf2_per_objfile
->all_comp_units
1935 = obstack_alloc (&objfile
->objfile_obstack
,
1936 dwarf2_per_objfile
->n_comp_units
1937 * sizeof (struct dwarf2_per_cu_data
*));
1939 for (i
= 0; i
< cu_list_elements
; i
+= 2)
1941 struct dwarf2_per_cu_data
*the_cu
;
1942 ULONGEST offset
, length
;
1944 if (!extract_cu_value (cu_list
, &offset
)
1945 || !extract_cu_value (cu_list
+ 8, &length
))
1949 the_cu
= OBSTACK_ZALLOC (&objfile
->objfile_obstack
,
1950 struct dwarf2_per_cu_data
);
1951 the_cu
->offset
= offset
;
1952 the_cu
->length
= length
;
1953 the_cu
->objfile
= objfile
;
1954 the_cu
->v
.quick
= OBSTACK_ZALLOC (&objfile
->objfile_obstack
,
1955 struct dwarf2_per_cu_quick_data
);
1956 dwarf2_per_objfile
->all_comp_units
[i
/ 2] = the_cu
;
1962 /* Create the signatured type hash table from the index. */
1965 create_signatured_type_table_from_index (struct objfile
*objfile
,
1966 struct dwarf2_section_info
*section
,
1967 const gdb_byte
*bytes
,
1968 offset_type elements
)
1971 htab_t sig_types_hash
;
1973 dwarf2_per_objfile
->n_type_comp_units
= elements
/ 3;
1974 dwarf2_per_objfile
->type_comp_units
1975 = obstack_alloc (&objfile
->objfile_obstack
,
1976 dwarf2_per_objfile
->n_type_comp_units
1977 * sizeof (struct dwarf2_per_cu_data
*));
1979 sig_types_hash
= allocate_signatured_type_table (objfile
);
1981 for (i
= 0; i
< elements
; i
+= 3)
1983 struct signatured_type
*type_sig
;
1984 ULONGEST offset
, type_offset
, signature
;
1987 if (!extract_cu_value (bytes
, &offset
)
1988 || !extract_cu_value (bytes
+ 8, &type_offset
))
1990 signature
= extract_unsigned_integer (bytes
+ 16, 8, BFD_ENDIAN_LITTLE
);
1993 type_sig
= OBSTACK_ZALLOC (&objfile
->objfile_obstack
,
1994 struct signatured_type
);
1995 type_sig
->signature
= signature
;
1996 type_sig
->type_offset
= type_offset
;
1997 type_sig
->per_cu
.debug_type_section
= section
;
1998 type_sig
->per_cu
.offset
= offset
;
1999 type_sig
->per_cu
.objfile
= objfile
;
2000 type_sig
->per_cu
.v
.quick
2001 = OBSTACK_ZALLOC (&objfile
->objfile_obstack
,
2002 struct dwarf2_per_cu_quick_data
);
2004 slot
= htab_find_slot (sig_types_hash
, type_sig
, INSERT
);
2007 dwarf2_per_objfile
->type_comp_units
[i
/ 3] = &type_sig
->per_cu
;
2010 dwarf2_per_objfile
->signatured_types
= sig_types_hash
;
2015 /* Read the address map data from the mapped index, and use it to
2016 populate the objfile's psymtabs_addrmap. */
2019 create_addrmap_from_index (struct objfile
*objfile
, struct mapped_index
*index
)
2021 const gdb_byte
*iter
, *end
;
2022 struct obstack temp_obstack
;
2023 struct addrmap
*mutable_map
;
2024 struct cleanup
*cleanup
;
2027 obstack_init (&temp_obstack
);
2028 cleanup
= make_cleanup_obstack_free (&temp_obstack
);
2029 mutable_map
= addrmap_create_mutable (&temp_obstack
);
2031 iter
= index
->address_table
;
2032 end
= iter
+ index
->address_table_size
;
2034 baseaddr
= ANOFFSET (objfile
->section_offsets
, SECT_OFF_TEXT (objfile
));
2038 ULONGEST hi
, lo
, cu_index
;
2039 lo
= extract_unsigned_integer (iter
, 8, BFD_ENDIAN_LITTLE
);
2041 hi
= extract_unsigned_integer (iter
, 8, BFD_ENDIAN_LITTLE
);
2043 cu_index
= extract_unsigned_integer (iter
, 4, BFD_ENDIAN_LITTLE
);
2046 addrmap_set_empty (mutable_map
, lo
+ baseaddr
, hi
+ baseaddr
- 1,
2047 dw2_get_cu (cu_index
));
2050 objfile
->psymtabs_addrmap
= addrmap_create_fixed (mutable_map
,
2051 &objfile
->objfile_obstack
);
2052 do_cleanups (cleanup
);
2055 /* The hash function for strings in the mapped index. This is the same as
2056 SYMBOL_HASH_NEXT, but we keep a separate copy to maintain control over the
2057 implementation. This is necessary because the hash function is tied to the
2058 format of the mapped index file. The hash values do not have to match with
2061 Use INT_MAX for INDEX_VERSION if you generate the current index format. */
2064 mapped_index_string_hash (int index_version
, const void *p
)
2066 const unsigned char *str
= (const unsigned char *) p
;
2070 while ((c
= *str
++) != 0)
2072 if (index_version
>= 5)
2074 r
= r
* 67 + c
- 113;
2080 /* Find a slot in the mapped index INDEX for the object named NAME.
2081 If NAME is found, set *VEC_OUT to point to the CU vector in the
2082 constant pool and return 1. If NAME cannot be found, return 0. */
2085 find_slot_in_mapped_hash (struct mapped_index
*index
, const char *name
,
2086 offset_type
**vec_out
)
2088 struct cleanup
*back_to
= make_cleanup (null_cleanup
, 0);
2090 offset_type slot
, step
;
2091 int (*cmp
) (const char *, const char *);
2093 if (current_language
->la_language
== language_cplus
2094 || current_language
->la_language
== language_java
2095 || current_language
->la_language
== language_fortran
)
2097 /* NAME is already canonical. Drop any qualifiers as .gdb_index does
2099 const char *paren
= strchr (name
, '(');
2105 dup
= xmalloc (paren
- name
+ 1);
2106 memcpy (dup
, name
, paren
- name
);
2107 dup
[paren
- name
] = 0;
2109 make_cleanup (xfree
, dup
);
2114 /* Index version 4 did not support case insensitive searches. But the
2115 indexes for case insensitive languages are built in lowercase, therefore
2116 simulate our NAME being searched is also lowercased. */
2117 hash
= mapped_index_string_hash ((index
->version
== 4
2118 && case_sensitivity
== case_sensitive_off
2119 ? 5 : index
->version
),
2122 slot
= hash
& (index
->symbol_table_slots
- 1);
2123 step
= ((hash
* 17) & (index
->symbol_table_slots
- 1)) | 1;
2124 cmp
= (case_sensitivity
== case_sensitive_on
? strcmp
: strcasecmp
);
2128 /* Convert a slot number to an offset into the table. */
2129 offset_type i
= 2 * slot
;
2131 if (index
->symbol_table
[i
] == 0 && index
->symbol_table
[i
+ 1] == 0)
2133 do_cleanups (back_to
);
2137 str
= index
->constant_pool
+ MAYBE_SWAP (index
->symbol_table
[i
]);
2138 if (!cmp (name
, str
))
2140 *vec_out
= (offset_type
*) (index
->constant_pool
2141 + MAYBE_SWAP (index
->symbol_table
[i
+ 1]));
2142 do_cleanups (back_to
);
2146 slot
= (slot
+ step
) & (index
->symbol_table_slots
- 1);
2150 /* Read the index file. If everything went ok, initialize the "quick"
2151 elements of all the CUs and return 1. Otherwise, return 0. */
2154 dwarf2_read_index (struct objfile
*objfile
)
2157 struct mapped_index
*map
;
2158 offset_type
*metadata
;
2159 const gdb_byte
*cu_list
;
2160 const gdb_byte
*types_list
= NULL
;
2161 offset_type version
, cu_list_elements
;
2162 offset_type types_list_elements
= 0;
2165 if (dwarf2_section_empty_p (&dwarf2_per_objfile
->gdb_index
))
2168 /* Older elfutils strip versions could keep the section in the main
2169 executable while splitting it for the separate debug info file. */
2170 if ((bfd_get_file_flags (dwarf2_per_objfile
->gdb_index
.asection
)
2171 & SEC_HAS_CONTENTS
) == 0)
2174 dwarf2_read_section (objfile
, &dwarf2_per_objfile
->gdb_index
);
2176 addr
= dwarf2_per_objfile
->gdb_index
.buffer
;
2177 /* Version check. */
2178 version
= MAYBE_SWAP (*(offset_type
*) addr
);
2179 /* Versions earlier than 3 emitted every copy of a psymbol. This
2180 causes the index to behave very poorly for certain requests. Version 3
2181 contained incomplete addrmap. So, it seems better to just ignore such
2182 indices. Index version 4 uses a different hash function than index
2183 version 5 and later. */
2186 /* Indexes with higher version than the one supported by GDB may be no
2187 longer backward compatible. */
2191 map
= OBSTACK_ZALLOC (&objfile
->objfile_obstack
, struct mapped_index
);
2192 map
->version
= version
;
2193 map
->total_size
= dwarf2_per_objfile
->gdb_index
.size
;
2195 metadata
= (offset_type
*) (addr
+ sizeof (offset_type
));
2198 cu_list
= addr
+ MAYBE_SWAP (metadata
[i
]);
2199 cu_list_elements
= ((MAYBE_SWAP (metadata
[i
+ 1]) - MAYBE_SWAP (metadata
[i
]))
2203 types_list
= addr
+ MAYBE_SWAP (metadata
[i
]);
2204 types_list_elements
= ((MAYBE_SWAP (metadata
[i
+ 1])
2205 - MAYBE_SWAP (metadata
[i
]))
2209 map
->address_table
= addr
+ MAYBE_SWAP (metadata
[i
]);
2210 map
->address_table_size
= (MAYBE_SWAP (metadata
[i
+ 1])
2211 - MAYBE_SWAP (metadata
[i
]));
2214 map
->symbol_table
= (offset_type
*) (addr
+ MAYBE_SWAP (metadata
[i
]));
2215 map
->symbol_table_slots
= ((MAYBE_SWAP (metadata
[i
+ 1])
2216 - MAYBE_SWAP (metadata
[i
]))
2217 / (2 * sizeof (offset_type
)));
2220 map
->constant_pool
= addr
+ MAYBE_SWAP (metadata
[i
]);
2222 if (!create_cus_from_index (objfile
, cu_list
, cu_list_elements
))
2225 if (types_list_elements
)
2227 struct dwarf2_section_info
*section
;
2229 /* We can only handle a single .debug_types when we have an
2231 if (VEC_length (dwarf2_section_info_def
, dwarf2_per_objfile
->types
) != 1)
2234 section
= VEC_index (dwarf2_section_info_def
,
2235 dwarf2_per_objfile
->types
, 0);
2237 if (!create_signatured_type_table_from_index (objfile
, section
,
2239 types_list_elements
))
2243 create_addrmap_from_index (objfile
, map
);
2245 dwarf2_per_objfile
->index_table
= map
;
2246 dwarf2_per_objfile
->using_index
= 1;
2247 dwarf2_per_objfile
->quick_file_names_table
=
2248 create_quick_file_names_table (dwarf2_per_objfile
->n_comp_units
);
2253 /* A helper for the "quick" functions which sets the global
2254 dwarf2_per_objfile according to OBJFILE. */
2257 dw2_setup (struct objfile
*objfile
)
2259 dwarf2_per_objfile
= objfile_data (objfile
, dwarf2_objfile_data_key
);
2260 gdb_assert (dwarf2_per_objfile
);
2263 /* A helper for the "quick" functions which attempts to read the line
2264 table for THIS_CU. */
2266 static struct quick_file_names
*
2267 dw2_get_file_names (struct objfile
*objfile
,
2268 struct dwarf2_per_cu_data
*this_cu
)
2270 bfd
*abfd
= objfile
->obfd
;
2271 struct line_header
*lh
;
2272 struct attribute
*attr
;
2273 struct cleanup
*cleanups
;
2274 struct die_info
*comp_unit_die
;
2275 struct dwarf2_section_info
* sec
;
2276 gdb_byte
*beg_of_comp_unit
, *info_ptr
, *buffer
;
2277 int has_children
, i
;
2278 struct dwarf2_cu cu
;
2279 unsigned int bytes_read
, buffer_size
;
2280 struct die_reader_specs reader_specs
;
2281 char *name
, *comp_dir
;
2283 struct quick_file_names
*qfn
;
2284 unsigned int line_offset
;
2286 if (this_cu
->v
.quick
->file_names
!= NULL
)
2287 return this_cu
->v
.quick
->file_names
;
2288 /* If we know there is no line data, no point in looking again. */
2289 if (this_cu
->v
.quick
->no_file_data
)
2292 init_one_comp_unit (&cu
, objfile
);
2293 cleanups
= make_cleanup (free_stack_comp_unit
, &cu
);
2295 if (this_cu
->debug_type_section
)
2296 sec
= this_cu
->debug_type_section
;
2298 sec
= &dwarf2_per_objfile
->info
;
2299 dwarf2_read_section (objfile
, sec
);
2300 buffer_size
= sec
->size
;
2301 buffer
= sec
->buffer
;
2302 info_ptr
= buffer
+ this_cu
->offset
;
2303 beg_of_comp_unit
= info_ptr
;
2305 info_ptr
= partial_read_comp_unit_head (&cu
.header
, info_ptr
,
2306 buffer
, buffer_size
,
2309 /* Complete the cu_header. */
2310 cu
.header
.offset
= beg_of_comp_unit
- buffer
;
2311 cu
.header
.first_die_offset
= info_ptr
- beg_of_comp_unit
;
2314 cu
.per_cu
= this_cu
;
2316 dwarf2_read_abbrevs (abfd
, &cu
);
2317 make_cleanup (dwarf2_free_abbrev_table
, &cu
);
2319 if (this_cu
->debug_type_section
)
2320 info_ptr
+= 8 /*signature*/ + cu
.header
.offset_size
;
2321 init_cu_die_reader (&reader_specs
, &cu
);
2322 read_full_die (&reader_specs
, &comp_unit_die
, info_ptr
,
2328 attr
= dwarf2_attr (comp_unit_die
, DW_AT_stmt_list
, &cu
);
2331 struct quick_file_names find_entry
;
2333 line_offset
= DW_UNSND (attr
);
2335 /* We may have already read in this line header (TU line header sharing).
2336 If we have we're done. */
2337 find_entry
.offset
= line_offset
;
2338 slot
= htab_find_slot (dwarf2_per_objfile
->quick_file_names_table
,
2339 &find_entry
, INSERT
);
2342 do_cleanups (cleanups
);
2343 this_cu
->v
.quick
->file_names
= *slot
;
2347 lh
= dwarf_decode_line_header (line_offset
, abfd
, &cu
);
2351 do_cleanups (cleanups
);
2352 this_cu
->v
.quick
->no_file_data
= 1;
2356 qfn
= obstack_alloc (&objfile
->objfile_obstack
, sizeof (*qfn
));
2357 qfn
->offset
= line_offset
;
2358 gdb_assert (slot
!= NULL
);
2361 find_file_and_directory (comp_unit_die
, &cu
, &name
, &comp_dir
);
2363 qfn
->num_file_names
= lh
->num_file_names
;
2364 qfn
->file_names
= obstack_alloc (&objfile
->objfile_obstack
,
2365 lh
->num_file_names
* sizeof (char *));
2366 for (i
= 0; i
< lh
->num_file_names
; ++i
)
2367 qfn
->file_names
[i
] = file_full_name (i
+ 1, lh
, comp_dir
);
2368 qfn
->real_names
= NULL
;
2370 free_line_header (lh
);
2371 do_cleanups (cleanups
);
2373 this_cu
->v
.quick
->file_names
= qfn
;
2377 /* A helper for the "quick" functions which computes and caches the
2378 real path for a given file name from the line table. */
2381 dw2_get_real_path (struct objfile
*objfile
,
2382 struct quick_file_names
*qfn
, int index
)
2384 if (qfn
->real_names
== NULL
)
2385 qfn
->real_names
= OBSTACK_CALLOC (&objfile
->objfile_obstack
,
2386 qfn
->num_file_names
, sizeof (char *));
2388 if (qfn
->real_names
[index
] == NULL
)
2389 qfn
->real_names
[index
] = gdb_realpath (qfn
->file_names
[index
]);
2391 return qfn
->real_names
[index
];
2394 static struct symtab
*
2395 dw2_find_last_source_symtab (struct objfile
*objfile
)
2399 dw2_setup (objfile
);
2400 index
= dwarf2_per_objfile
->n_comp_units
- 1;
2401 return dw2_instantiate_symtab (objfile
, dw2_get_cu (index
));
2404 /* Traversal function for dw2_forget_cached_source_info. */
2407 dw2_free_cached_file_names (void **slot
, void *info
)
2409 struct quick_file_names
*file_data
= (struct quick_file_names
*) *slot
;
2411 if (file_data
->real_names
)
2415 for (i
= 0; i
< file_data
->num_file_names
; ++i
)
2417 xfree ((void*) file_data
->real_names
[i
]);
2418 file_data
->real_names
[i
] = NULL
;
2426 dw2_forget_cached_source_info (struct objfile
*objfile
)
2428 dw2_setup (objfile
);
2430 htab_traverse_noresize (dwarf2_per_objfile
->quick_file_names_table
,
2431 dw2_free_cached_file_names
, NULL
);
2435 dw2_lookup_symtab (struct objfile
*objfile
, const char *name
,
2436 const char *full_path
, const char *real_path
,
2437 struct symtab
**result
)
2440 int check_basename
= lbasename (name
) == name
;
2441 struct dwarf2_per_cu_data
*base_cu
= NULL
;
2443 dw2_setup (objfile
);
2445 for (i
= 0; i
< (dwarf2_per_objfile
->n_comp_units
2446 + dwarf2_per_objfile
->n_type_comp_units
); ++i
)
2449 struct dwarf2_per_cu_data
*per_cu
= dw2_get_cu (i
);
2450 struct quick_file_names
*file_data
;
2452 if (per_cu
->v
.quick
->symtab
)
2455 file_data
= dw2_get_file_names (objfile
, per_cu
);
2456 if (file_data
== NULL
)
2459 for (j
= 0; j
< file_data
->num_file_names
; ++j
)
2461 const char *this_name
= file_data
->file_names
[j
];
2463 if (FILENAME_CMP (name
, this_name
) == 0)
2465 *result
= dw2_instantiate_symtab (objfile
, per_cu
);
2469 if (check_basename
&& ! base_cu
2470 && FILENAME_CMP (lbasename (this_name
), name
) == 0)
2473 if (full_path
!= NULL
)
2475 const char *this_real_name
= dw2_get_real_path (objfile
,
2478 if (this_real_name
!= NULL
2479 && FILENAME_CMP (full_path
, this_real_name
) == 0)
2481 *result
= dw2_instantiate_symtab (objfile
, per_cu
);
2486 if (real_path
!= NULL
)
2488 const char *this_real_name
= dw2_get_real_path (objfile
,
2491 if (this_real_name
!= NULL
2492 && FILENAME_CMP (real_path
, this_real_name
) == 0)
2494 *result
= dw2_instantiate_symtab (objfile
, per_cu
);
2503 *result
= dw2_instantiate_symtab (objfile
, base_cu
);
2510 static struct symtab
*
2511 dw2_lookup_symbol (struct objfile
*objfile
, int block_index
,
2512 const char *name
, domain_enum domain
)
2514 /* We do all the work in the pre_expand_symtabs_matching hook
2519 /* A helper function that expands all symtabs that hold an object
2523 dw2_do_expand_symtabs_matching (struct objfile
*objfile
, const char *name
)
2525 dw2_setup (objfile
);
2527 /* index_table is NULL if OBJF_READNOW. */
2528 if (dwarf2_per_objfile
->index_table
)
2532 if (find_slot_in_mapped_hash (dwarf2_per_objfile
->index_table
,
2535 offset_type i
, len
= MAYBE_SWAP (*vec
);
2536 for (i
= 0; i
< len
; ++i
)
2538 offset_type cu_index
= MAYBE_SWAP (vec
[i
+ 1]);
2539 struct dwarf2_per_cu_data
*per_cu
= dw2_get_cu (cu_index
);
2541 dw2_instantiate_symtab (objfile
, per_cu
);
2548 dw2_pre_expand_symtabs_matching (struct objfile
*objfile
,
2549 enum block_enum block_kind
, const char *name
,
2552 dw2_do_expand_symtabs_matching (objfile
, name
);
2556 dw2_print_stats (struct objfile
*objfile
)
2560 dw2_setup (objfile
);
2562 for (i
= 0; i
< (dwarf2_per_objfile
->n_comp_units
2563 + dwarf2_per_objfile
->n_type_comp_units
); ++i
)
2565 struct dwarf2_per_cu_data
*per_cu
= dw2_get_cu (i
);
2567 if (!per_cu
->v
.quick
->symtab
)
2570 printf_filtered (_(" Number of unread CUs: %d\n"), count
);
2574 dw2_dump (struct objfile
*objfile
)
2576 /* Nothing worth printing. */
2580 dw2_relocate (struct objfile
*objfile
, struct section_offsets
*new_offsets
,
2581 struct section_offsets
*delta
)
2583 /* There's nothing to relocate here. */
2587 dw2_expand_symtabs_for_function (struct objfile
*objfile
,
2588 const char *func_name
)
2590 dw2_do_expand_symtabs_matching (objfile
, func_name
);
2594 dw2_expand_all_symtabs (struct objfile
*objfile
)
2598 dw2_setup (objfile
);
2600 for (i
= 0; i
< (dwarf2_per_objfile
->n_comp_units
2601 + dwarf2_per_objfile
->n_type_comp_units
); ++i
)
2603 struct dwarf2_per_cu_data
*per_cu
= dw2_get_cu (i
);
2605 dw2_instantiate_symtab (objfile
, per_cu
);
2610 dw2_expand_symtabs_with_filename (struct objfile
*objfile
,
2611 const char *filename
)
2615 dw2_setup (objfile
);
2617 /* We don't need to consider type units here.
2618 This is only called for examining code, e.g. expand_line_sal.
2619 There can be an order of magnitude (or more) more type units
2620 than comp units, and we avoid them if we can. */
2622 for (i
= 0; i
< dwarf2_per_objfile
->n_comp_units
; ++i
)
2625 struct dwarf2_per_cu_data
*per_cu
= dw2_get_cu (i
);
2626 struct quick_file_names
*file_data
;
2628 if (per_cu
->v
.quick
->symtab
)
2631 file_data
= dw2_get_file_names (objfile
, per_cu
);
2632 if (file_data
== NULL
)
2635 for (j
= 0; j
< file_data
->num_file_names
; ++j
)
2637 const char *this_name
= file_data
->file_names
[j
];
2638 if (FILENAME_CMP (this_name
, filename
) == 0)
2640 dw2_instantiate_symtab (objfile
, per_cu
);
2648 dw2_find_symbol_file (struct objfile
*objfile
, const char *name
)
2650 struct dwarf2_per_cu_data
*per_cu
;
2652 struct quick_file_names
*file_data
;
2654 dw2_setup (objfile
);
2656 /* index_table is NULL if OBJF_READNOW. */
2657 if (!dwarf2_per_objfile
->index_table
)
2661 ALL_OBJFILE_SYMTABS (objfile
, s
)
2664 struct blockvector
*bv
= BLOCKVECTOR (s
);
2665 const struct block
*block
= BLOCKVECTOR_BLOCK (bv
, GLOBAL_BLOCK
);
2666 struct symbol
*sym
= lookup_block_symbol (block
, name
, VAR_DOMAIN
);
2669 return sym
->symtab
->filename
;
2674 if (!find_slot_in_mapped_hash (dwarf2_per_objfile
->index_table
,
2678 /* Note that this just looks at the very first one named NAME -- but
2679 actually we are looking for a function. find_main_filename
2680 should be rewritten so that it doesn't require a custom hook. It
2681 could just use the ordinary symbol tables. */
2682 /* vec[0] is the length, which must always be >0. */
2683 per_cu
= dw2_get_cu (MAYBE_SWAP (vec
[1]));
2685 file_data
= dw2_get_file_names (objfile
, per_cu
);
2686 if (file_data
== NULL
)
2689 return file_data
->file_names
[file_data
->num_file_names
- 1];
2693 dw2_map_matching_symbols (const char * name
, domain_enum
namespace,
2694 struct objfile
*objfile
, int global
,
2695 int (*callback
) (struct block
*,
2696 struct symbol
*, void *),
2697 void *data
, symbol_compare_ftype
*match
,
2698 symbol_compare_ftype
*ordered_compare
)
2700 /* Currently unimplemented; used for Ada. The function can be called if the
2701 current language is Ada for a non-Ada objfile using GNU index. As Ada
2702 does not look for non-Ada symbols this function should just return. */
2706 dw2_expand_symtabs_matching (struct objfile
*objfile
,
2707 int (*file_matcher
) (const char *, void *),
2708 int (*name_matcher
) (const char *, void *),
2709 enum search_domain kind
,
2714 struct mapped_index
*index
;
2716 dw2_setup (objfile
);
2718 /* index_table is NULL if OBJF_READNOW. */
2719 if (!dwarf2_per_objfile
->index_table
)
2721 index
= dwarf2_per_objfile
->index_table
;
2723 if (file_matcher
!= NULL
)
2724 for (i
= 0; i
< (dwarf2_per_objfile
->n_comp_units
2725 + dwarf2_per_objfile
->n_type_comp_units
); ++i
)
2728 struct dwarf2_per_cu_data
*per_cu
= dw2_get_cu (i
);
2729 struct quick_file_names
*file_data
;
2731 per_cu
->v
.quick
->mark
= 0;
2732 if (per_cu
->v
.quick
->symtab
)
2735 file_data
= dw2_get_file_names (objfile
, per_cu
);
2736 if (file_data
== NULL
)
2739 for (j
= 0; j
< file_data
->num_file_names
; ++j
)
2741 if (file_matcher (file_data
->file_names
[j
], data
))
2743 per_cu
->v
.quick
->mark
= 1;
2749 for (iter
= 0; iter
< index
->symbol_table_slots
; ++iter
)
2751 offset_type idx
= 2 * iter
;
2753 offset_type
*vec
, vec_len
, vec_idx
;
2755 if (index
->symbol_table
[idx
] == 0 && index
->symbol_table
[idx
+ 1] == 0)
2758 name
= index
->constant_pool
+ MAYBE_SWAP (index
->symbol_table
[idx
]);
2760 if (! (*name_matcher
) (name
, data
))
2763 /* The name was matched, now expand corresponding CUs that were
2765 vec
= (offset_type
*) (index
->constant_pool
2766 + MAYBE_SWAP (index
->symbol_table
[idx
+ 1]));
2767 vec_len
= MAYBE_SWAP (vec
[0]);
2768 for (vec_idx
= 0; vec_idx
< vec_len
; ++vec_idx
)
2770 struct dwarf2_per_cu_data
*per_cu
;
2772 per_cu
= dw2_get_cu (MAYBE_SWAP (vec
[vec_idx
+ 1]));
2773 if (file_matcher
== NULL
|| per_cu
->v
.quick
->mark
)
2774 dw2_instantiate_symtab (objfile
, per_cu
);
2779 static struct symtab
*
2780 dw2_find_pc_sect_symtab (struct objfile
*objfile
,
2781 struct minimal_symbol
*msymbol
,
2783 struct obj_section
*section
,
2786 struct dwarf2_per_cu_data
*data
;
2788 dw2_setup (objfile
);
2790 if (!objfile
->psymtabs_addrmap
)
2793 data
= addrmap_find (objfile
->psymtabs_addrmap
, pc
);
2797 if (warn_if_readin
&& data
->v
.quick
->symtab
)
2798 warning (_("(Internal error: pc %s in read in CU, but not in symtab.)"),
2799 paddress (get_objfile_arch (objfile
), pc
));
2801 return dw2_instantiate_symtab (objfile
, data
);
2805 dw2_map_symbol_filenames (struct objfile
*objfile
, symbol_filename_ftype
*fun
,
2810 dw2_setup (objfile
);
2812 for (i
= 0; i
< (dwarf2_per_objfile
->n_comp_units
2813 + dwarf2_per_objfile
->n_type_comp_units
); ++i
)
2816 struct dwarf2_per_cu_data
*per_cu
= dw2_get_cu (i
);
2817 struct quick_file_names
*file_data
;
2819 if (per_cu
->v
.quick
->symtab
)
2822 file_data
= dw2_get_file_names (objfile
, per_cu
);
2823 if (file_data
== NULL
)
2826 for (j
= 0; j
< file_data
->num_file_names
; ++j
)
2828 const char *this_real_name
= dw2_get_real_path (objfile
, file_data
,
2830 (*fun
) (file_data
->file_names
[j
], this_real_name
, data
);
2836 dw2_has_symbols (struct objfile
*objfile
)
2841 const struct quick_symbol_functions dwarf2_gdb_index_functions
=
2844 dw2_find_last_source_symtab
,
2845 dw2_forget_cached_source_info
,
2848 dw2_pre_expand_symtabs_matching
,
2852 dw2_expand_symtabs_for_function
,
2853 dw2_expand_all_symtabs
,
2854 dw2_expand_symtabs_with_filename
,
2855 dw2_find_symbol_file
,
2856 dw2_map_matching_symbols
,
2857 dw2_expand_symtabs_matching
,
2858 dw2_find_pc_sect_symtab
,
2859 dw2_map_symbol_filenames
2862 /* Initialize for reading DWARF for this objfile. Return 0 if this
2863 file will use psymtabs, or 1 if using the GNU index. */
2866 dwarf2_initialize_objfile (struct objfile
*objfile
)
2868 /* If we're about to read full symbols, don't bother with the
2869 indices. In this case we also don't care if some other debug
2870 format is making psymtabs, because they are all about to be
2872 if ((objfile
->flags
& OBJF_READNOW
))
2876 dwarf2_per_objfile
->using_index
= 1;
2877 create_all_comp_units (objfile
);
2878 create_debug_types_hash_table (objfile
);
2879 dwarf2_per_objfile
->quick_file_names_table
=
2880 create_quick_file_names_table (dwarf2_per_objfile
->n_comp_units
);
2882 for (i
= 0; i
< (dwarf2_per_objfile
->n_comp_units
2883 + dwarf2_per_objfile
->n_type_comp_units
); ++i
)
2885 struct dwarf2_per_cu_data
*per_cu
= dw2_get_cu (i
);
2887 per_cu
->v
.quick
= OBSTACK_ZALLOC (&objfile
->objfile_obstack
,
2888 struct dwarf2_per_cu_quick_data
);
2891 /* Return 1 so that gdb sees the "quick" functions. However,
2892 these functions will be no-ops because we will have expanded
2897 if (dwarf2_read_index (objfile
))
2905 /* Build a partial symbol table. */
2908 dwarf2_build_psymtabs (struct objfile
*objfile
)
2910 if (objfile
->global_psymbols
.size
== 0 && objfile
->static_psymbols
.size
== 0)
2912 init_psymbol_list (objfile
, 1024);
2915 dwarf2_build_psymtabs_hard (objfile
);
2918 /* Return TRUE if OFFSET is within CU_HEADER. */
2921 offset_in_cu_p (const struct comp_unit_head
*cu_header
, unsigned int offset
)
2923 unsigned int bottom
= cu_header
->offset
;
2924 unsigned int top
= (cu_header
->offset
2926 + cu_header
->initial_length_size
);
2928 return (offset
>= bottom
&& offset
< top
);
2931 /* Read in the comp unit header information from the debug_info at info_ptr.
2932 NOTE: This leaves members offset, first_die_offset to be filled in
2936 read_comp_unit_head (struct comp_unit_head
*cu_header
,
2937 gdb_byte
*info_ptr
, bfd
*abfd
)
2940 unsigned int bytes_read
;
2942 cu_header
->length
= read_initial_length (abfd
, info_ptr
, &bytes_read
);
2943 cu_header
->initial_length_size
= bytes_read
;
2944 cu_header
->offset_size
= (bytes_read
== 4) ? 4 : 8;
2945 info_ptr
+= bytes_read
;
2946 cu_header
->version
= read_2_bytes (abfd
, info_ptr
);
2948 cu_header
->abbrev_offset
= read_offset (abfd
, info_ptr
, cu_header
,
2950 info_ptr
+= bytes_read
;
2951 cu_header
->addr_size
= read_1_byte (abfd
, info_ptr
);
2953 signed_addr
= bfd_get_sign_extend_vma (abfd
);
2954 if (signed_addr
< 0)
2955 internal_error (__FILE__
, __LINE__
,
2956 _("read_comp_unit_head: dwarf from non elf file"));
2957 cu_header
->signed_addr_p
= signed_addr
;
2963 partial_read_comp_unit_head (struct comp_unit_head
*header
, gdb_byte
*info_ptr
,
2964 gdb_byte
*buffer
, unsigned int buffer_size
,
2967 gdb_byte
*beg_of_comp_unit
= info_ptr
;
2969 info_ptr
= read_comp_unit_head (header
, info_ptr
, abfd
);
2971 if (header
->version
!= 2 && header
->version
!= 3 && header
->version
!= 4)
2972 error (_("Dwarf Error: wrong version in compilation unit header "
2973 "(is %d, should be 2, 3, or 4) [in module %s]"), header
->version
,
2974 bfd_get_filename (abfd
));
2976 if (header
->abbrev_offset
2977 >= dwarf2_section_size (dwarf2_per_objfile
->objfile
,
2978 &dwarf2_per_objfile
->abbrev
))
2979 error (_("Dwarf Error: bad offset (0x%lx) in compilation unit header "
2980 "(offset 0x%lx + 6) [in module %s]"),
2981 (long) header
->abbrev_offset
,
2982 (long) (beg_of_comp_unit
- buffer
),
2983 bfd_get_filename (abfd
));
2985 if (beg_of_comp_unit
+ header
->length
+ header
->initial_length_size
2986 > buffer
+ buffer_size
)
2987 error (_("Dwarf Error: bad length (0x%lx) in compilation unit header "
2988 "(offset 0x%lx + 0) [in module %s]"),
2989 (long) header
->length
,
2990 (long) (beg_of_comp_unit
- buffer
),
2991 bfd_get_filename (abfd
));
2996 /* Read in the types comp unit header information from .debug_types entry at
2997 types_ptr. The result is a pointer to one past the end of the header. */
3000 read_type_comp_unit_head (struct comp_unit_head
*cu_header
,
3001 struct dwarf2_section_info
*section
,
3002 ULONGEST
*signature
,
3003 gdb_byte
*types_ptr
, bfd
*abfd
)
3005 gdb_byte
*initial_types_ptr
= types_ptr
;
3007 dwarf2_read_section (dwarf2_per_objfile
->objfile
, section
);
3008 cu_header
->offset
= types_ptr
- section
->buffer
;
3010 types_ptr
= read_comp_unit_head (cu_header
, types_ptr
, abfd
);
3012 *signature
= read_8_bytes (abfd
, types_ptr
);
3014 types_ptr
+= cu_header
->offset_size
;
3015 cu_header
->first_die_offset
= types_ptr
- initial_types_ptr
;
3020 /* Allocate a new partial symtab for file named NAME and mark this new
3021 partial symtab as being an include of PST. */
3024 dwarf2_create_include_psymtab (char *name
, struct partial_symtab
*pst
,
3025 struct objfile
*objfile
)
3027 struct partial_symtab
*subpst
= allocate_psymtab (name
, objfile
);
3029 subpst
->section_offsets
= pst
->section_offsets
;
3030 subpst
->textlow
= 0;
3031 subpst
->texthigh
= 0;
3033 subpst
->dependencies
= (struct partial_symtab
**)
3034 obstack_alloc (&objfile
->objfile_obstack
,
3035 sizeof (struct partial_symtab
*));
3036 subpst
->dependencies
[0] = pst
;
3037 subpst
->number_of_dependencies
= 1;
3039 subpst
->globals_offset
= 0;
3040 subpst
->n_global_syms
= 0;
3041 subpst
->statics_offset
= 0;
3042 subpst
->n_static_syms
= 0;
3043 subpst
->symtab
= NULL
;
3044 subpst
->read_symtab
= pst
->read_symtab
;
3047 /* No private part is necessary for include psymtabs. This property
3048 can be used to differentiate between such include psymtabs and
3049 the regular ones. */
3050 subpst
->read_symtab_private
= NULL
;
3053 /* Read the Line Number Program data and extract the list of files
3054 included by the source file represented by PST. Build an include
3055 partial symtab for each of these included files. */
3058 dwarf2_build_include_psymtabs (struct dwarf2_cu
*cu
,
3059 struct die_info
*die
,
3060 struct partial_symtab
*pst
)
3062 struct objfile
*objfile
= cu
->objfile
;
3063 bfd
*abfd
= objfile
->obfd
;
3064 struct line_header
*lh
= NULL
;
3065 struct attribute
*attr
;
3067 attr
= dwarf2_attr (die
, DW_AT_stmt_list
, cu
);
3070 unsigned int line_offset
= DW_UNSND (attr
);
3072 lh
= dwarf_decode_line_header (line_offset
, abfd
, cu
);
3075 return; /* No linetable, so no includes. */
3077 /* NOTE: pst->dirname is DW_AT_comp_dir (if present). */
3078 dwarf_decode_lines (lh
, pst
->dirname
, abfd
, cu
, pst
);
3080 free_line_header (lh
);
3084 hash_type_signature (const void *item
)
3086 const struct signatured_type
*type_sig
= item
;
3088 /* This drops the top 32 bits of the signature, but is ok for a hash. */
3089 return type_sig
->signature
;
3093 eq_type_signature (const void *item_lhs
, const void *item_rhs
)
3095 const struct signatured_type
*lhs
= item_lhs
;
3096 const struct signatured_type
*rhs
= item_rhs
;
3098 return lhs
->signature
== rhs
->signature
;
3101 /* Allocate a hash table for signatured types. */
3104 allocate_signatured_type_table (struct objfile
*objfile
)
3106 return htab_create_alloc_ex (41,
3107 hash_type_signature
,
3110 &objfile
->objfile_obstack
,
3111 hashtab_obstack_allocate
,
3112 dummy_obstack_deallocate
);
3115 /* A helper function to add a signatured type CU to a list. */
3118 add_signatured_type_cu_to_list (void **slot
, void *datum
)
3120 struct signatured_type
*sigt
= *slot
;
3121 struct dwarf2_per_cu_data
***datap
= datum
;
3123 **datap
= &sigt
->per_cu
;
3129 /* Create the hash table of all entries in the .debug_types section.
3130 The result is zero if there is an error (e.g. missing .debug_types section),
3131 otherwise non-zero. */
3134 create_debug_types_hash_table (struct objfile
*objfile
)
3136 htab_t types_htab
= NULL
;
3137 struct dwarf2_per_cu_data
**iter
;
3139 struct dwarf2_section_info
*section
;
3141 if (VEC_empty (dwarf2_section_info_def
, dwarf2_per_objfile
->types
))
3143 dwarf2_per_objfile
->signatured_types
= NULL
;
3148 VEC_iterate (dwarf2_section_info_def
, dwarf2_per_objfile
->types
,
3152 gdb_byte
*info_ptr
, *end_ptr
;
3154 dwarf2_read_section (objfile
, section
);
3155 info_ptr
= section
->buffer
;
3157 if (info_ptr
== NULL
)
3160 if (types_htab
== NULL
)
3161 types_htab
= allocate_signatured_type_table (objfile
);
3163 if (dwarf2_die_debug
)
3164 fprintf_unfiltered (gdb_stdlog
, "Signatured types:\n");
3166 end_ptr
= info_ptr
+ section
->size
;
3167 while (info_ptr
< end_ptr
)
3169 unsigned int offset
;
3170 unsigned int offset_size
;
3171 unsigned int type_offset
;
3172 unsigned int length
, initial_length_size
;
3173 unsigned short version
;
3175 struct signatured_type
*type_sig
;
3177 gdb_byte
*ptr
= info_ptr
;
3179 offset
= ptr
- section
->buffer
;
3181 /* We need to read the type's signature in order to build the hash
3182 table, but we don't need to read anything else just yet. */
3184 /* Sanity check to ensure entire cu is present. */
3185 length
= read_initial_length (objfile
->obfd
, ptr
,
3186 &initial_length_size
);
3187 if (ptr
+ length
+ initial_length_size
> end_ptr
)
3189 complaint (&symfile_complaints
,
3190 _("debug type entry runs off end "
3191 "of `.debug_types' section, ignored"));
3195 offset_size
= initial_length_size
== 4 ? 4 : 8;
3196 ptr
+= initial_length_size
;
3197 version
= bfd_get_16 (objfile
->obfd
, ptr
);
3199 ptr
+= offset_size
; /* abbrev offset */
3200 ptr
+= 1; /* address size */
3201 signature
= bfd_get_64 (objfile
->obfd
, ptr
);
3203 type_offset
= read_offset_1 (objfile
->obfd
, ptr
, offset_size
);
3205 type_sig
= obstack_alloc (&objfile
->objfile_obstack
, sizeof (*type_sig
));
3206 memset (type_sig
, 0, sizeof (*type_sig
));
3207 type_sig
->signature
= signature
;
3208 type_sig
->type_offset
= type_offset
;
3209 type_sig
->per_cu
.objfile
= objfile
;
3210 type_sig
->per_cu
.debug_type_section
= section
;
3211 type_sig
->per_cu
.offset
= offset
;
3213 slot
= htab_find_slot (types_htab
, type_sig
, INSERT
);
3214 gdb_assert (slot
!= NULL
);
3217 const struct signatured_type
*dup_sig
= *slot
;
3219 complaint (&symfile_complaints
,
3220 _("debug type entry at offset 0x%x is duplicate to the "
3221 "entry at offset 0x%x, signature 0x%s"),
3222 offset
, dup_sig
->per_cu
.offset
,
3223 phex (signature
, sizeof (signature
)));
3224 gdb_assert (signature
== dup_sig
->signature
);
3228 if (dwarf2_die_debug
)
3229 fprintf_unfiltered (gdb_stdlog
, " offset 0x%x, signature 0x%s\n",
3230 offset
, phex (signature
, sizeof (signature
)));
3232 info_ptr
= info_ptr
+ initial_length_size
+ length
;
3236 dwarf2_per_objfile
->signatured_types
= types_htab
;
3238 dwarf2_per_objfile
->n_type_comp_units
= htab_elements (types_htab
);
3239 dwarf2_per_objfile
->type_comp_units
3240 = obstack_alloc (&objfile
->objfile_obstack
,
3241 dwarf2_per_objfile
->n_type_comp_units
3242 * sizeof (struct dwarf2_per_cu_data
*));
3243 iter
= &dwarf2_per_objfile
->type_comp_units
[0];
3244 htab_traverse_noresize (types_htab
, add_signatured_type_cu_to_list
, &iter
);
3245 gdb_assert (iter
- &dwarf2_per_objfile
->type_comp_units
[0]
3246 == dwarf2_per_objfile
->n_type_comp_units
);
3251 /* Lookup a signature based type.
3252 Returns NULL if SIG is not present in the table. */
3254 static struct signatured_type
*
3255 lookup_signatured_type (struct objfile
*objfile
, ULONGEST sig
)
3257 struct signatured_type find_entry
, *entry
;
3259 if (dwarf2_per_objfile
->signatured_types
== NULL
)
3261 complaint (&symfile_complaints
,
3262 _("missing `.debug_types' section for DW_FORM_ref_sig8 die"));
3266 find_entry
.signature
= sig
;
3267 entry
= htab_find (dwarf2_per_objfile
->signatured_types
, &find_entry
);
3271 /* Initialize a die_reader_specs struct from a dwarf2_cu struct. */
3274 init_cu_die_reader (struct die_reader_specs
*reader
,
3275 struct dwarf2_cu
*cu
)
3277 reader
->abfd
= cu
->objfile
->obfd
;
3279 if (cu
->per_cu
->debug_type_section
)
3281 gdb_assert (cu
->per_cu
->debug_type_section
->readin
);
3282 reader
->buffer
= cu
->per_cu
->debug_type_section
->buffer
;
3286 gdb_assert (dwarf2_per_objfile
->info
.readin
);
3287 reader
->buffer
= dwarf2_per_objfile
->info
.buffer
;
3291 /* Find the base address of the compilation unit for range lists and
3292 location lists. It will normally be specified by DW_AT_low_pc.
3293 In DWARF-3 draft 4, the base address could be overridden by
3294 DW_AT_entry_pc. It's been removed, but GCC still uses this for
3295 compilation units with discontinuous ranges. */
3298 dwarf2_find_base_address (struct die_info
*die
, struct dwarf2_cu
*cu
)
3300 struct attribute
*attr
;
3303 cu
->base_address
= 0;
3305 attr
= dwarf2_attr (die
, DW_AT_entry_pc
, cu
);
3308 cu
->base_address
= DW_ADDR (attr
);
3313 attr
= dwarf2_attr (die
, DW_AT_low_pc
, cu
);
3316 cu
->base_address
= DW_ADDR (attr
);
3322 /* Subroutine of process_type_comp_unit and dwarf2_build_psymtabs_hard
3323 to combine the common parts.
3324 Process a compilation unit for a psymtab.
3325 BUFFER is a pointer to the beginning of the dwarf section buffer,
3326 either .debug_info or debug_types.
3327 INFO_PTR is a pointer to the start of the CU.
3328 Returns a pointer to the next CU. */
3331 process_psymtab_comp_unit (struct objfile
*objfile
,
3332 struct dwarf2_per_cu_data
*this_cu
,
3333 gdb_byte
*buffer
, gdb_byte
*info_ptr
,
3334 unsigned int buffer_size
)
3336 bfd
*abfd
= objfile
->obfd
;
3337 gdb_byte
*beg_of_comp_unit
= info_ptr
;
3338 struct die_info
*comp_unit_die
;
3339 struct partial_symtab
*pst
;
3341 struct cleanup
*back_to_inner
;
3342 struct dwarf2_cu cu
;
3343 int has_children
, has_pc_info
;
3344 struct attribute
*attr
;
3345 CORE_ADDR best_lowpc
= 0, best_highpc
= 0;
3346 struct die_reader_specs reader_specs
;
3347 const char *filename
;
3349 init_one_comp_unit (&cu
, objfile
);
3350 back_to_inner
= make_cleanup (free_stack_comp_unit
, &cu
);
3352 info_ptr
= partial_read_comp_unit_head (&cu
.header
, info_ptr
,
3353 buffer
, buffer_size
,
3356 /* Complete the cu_header. */
3357 cu
.header
.offset
= beg_of_comp_unit
- buffer
;
3358 cu
.header
.first_die_offset
= info_ptr
- beg_of_comp_unit
;
3360 cu
.list_in_scope
= &file_symbols
;
3362 /* If this compilation unit was already read in, free the
3363 cached copy in order to read it in again. This is
3364 necessary because we skipped some symbols when we first
3365 read in the compilation unit (see load_partial_dies).
3366 This problem could be avoided, but the benefit is
3368 if (this_cu
->cu
!= NULL
)
3369 free_one_cached_comp_unit (this_cu
->cu
);
3371 /* Note that this is a pointer to our stack frame, being
3372 added to a global data structure. It will be cleaned up
3373 in free_stack_comp_unit when we finish with this
3374 compilation unit. */
3376 cu
.per_cu
= this_cu
;
3378 /* Read the abbrevs for this compilation unit into a table. */
3379 dwarf2_read_abbrevs (abfd
, &cu
);
3380 make_cleanup (dwarf2_free_abbrev_table
, &cu
);
3382 /* Read the compilation unit die. */
3383 if (this_cu
->debug_type_section
)
3384 info_ptr
+= 8 /*signature*/ + cu
.header
.offset_size
;
3385 init_cu_die_reader (&reader_specs
, &cu
);
3386 info_ptr
= read_full_die (&reader_specs
, &comp_unit_die
, info_ptr
,
3389 if (this_cu
->debug_type_section
)
3391 /* LENGTH has not been set yet for type units. */
3392 gdb_assert (this_cu
->offset
== cu
.header
.offset
);
3393 this_cu
->length
= cu
.header
.length
+ cu
.header
.initial_length_size
;
3395 else if (comp_unit_die
->tag
== DW_TAG_partial_unit
)
3397 info_ptr
= (beg_of_comp_unit
+ cu
.header
.length
3398 + cu
.header
.initial_length_size
);
3399 do_cleanups (back_to_inner
);
3403 prepare_one_comp_unit (&cu
, comp_unit_die
);
3405 /* Allocate a new partial symbol table structure. */
3406 attr
= dwarf2_attr (comp_unit_die
, DW_AT_name
, &cu
);
3407 if (attr
== NULL
|| !DW_STRING (attr
))
3410 filename
= DW_STRING (attr
);
3411 pst
= start_psymtab_common (objfile
, objfile
->section_offsets
,
3413 /* TEXTLOW and TEXTHIGH are set below. */
3415 objfile
->global_psymbols
.next
,
3416 objfile
->static_psymbols
.next
);
3418 attr
= dwarf2_attr (comp_unit_die
, DW_AT_comp_dir
, &cu
);
3420 pst
->dirname
= DW_STRING (attr
);
3422 pst
->read_symtab_private
= this_cu
;
3424 baseaddr
= ANOFFSET (objfile
->section_offsets
, SECT_OFF_TEXT (objfile
));
3426 /* Store the function that reads in the rest of the symbol table. */
3427 pst
->read_symtab
= dwarf2_psymtab_to_symtab
;
3429 this_cu
->v
.psymtab
= pst
;
3431 dwarf2_find_base_address (comp_unit_die
, &cu
);
3433 /* Possibly set the default values of LOWPC and HIGHPC from
3435 has_pc_info
= dwarf2_get_pc_bounds (comp_unit_die
, &best_lowpc
,
3436 &best_highpc
, &cu
, pst
);
3437 if (has_pc_info
== 1 && best_lowpc
< best_highpc
)
3438 /* Store the contiguous range if it is not empty; it can be empty for
3439 CUs with no code. */
3440 addrmap_set_empty (objfile
->psymtabs_addrmap
,
3441 best_lowpc
+ baseaddr
,
3442 best_highpc
+ baseaddr
- 1, pst
);
3444 /* Check if comp unit has_children.
3445 If so, read the rest of the partial symbols from this comp unit.
3446 If not, there's no more debug_info for this comp unit. */
3449 struct partial_die_info
*first_die
;
3450 CORE_ADDR lowpc
, highpc
;
3452 lowpc
= ((CORE_ADDR
) -1);
3453 highpc
= ((CORE_ADDR
) 0);
3455 first_die
= load_partial_dies (abfd
, buffer
, info_ptr
, 1, &cu
);
3457 scan_partial_symbols (first_die
, &lowpc
, &highpc
,
3458 ! has_pc_info
, &cu
);
3460 /* If we didn't find a lowpc, set it to highpc to avoid
3461 complaints from `maint check'. */
3462 if (lowpc
== ((CORE_ADDR
) -1))
3465 /* If the compilation unit didn't have an explicit address range,
3466 then use the information extracted from its child dies. */
3470 best_highpc
= highpc
;
3473 pst
->textlow
= best_lowpc
+ baseaddr
;
3474 pst
->texthigh
= best_highpc
+ baseaddr
;
3476 pst
->n_global_syms
= objfile
->global_psymbols
.next
-
3477 (objfile
->global_psymbols
.list
+ pst
->globals_offset
);
3478 pst
->n_static_syms
= objfile
->static_psymbols
.next
-
3479 (objfile
->static_psymbols
.list
+ pst
->statics_offset
);
3480 sort_pst_symbols (pst
);
3482 info_ptr
= (beg_of_comp_unit
+ cu
.header
.length
3483 + cu
.header
.initial_length_size
);
3485 if (this_cu
->debug_type_section
)
3487 /* It's not clear we want to do anything with stmt lists here.
3488 Waiting to see what gcc ultimately does. */
3492 /* Get the list of files included in the current compilation unit,
3493 and build a psymtab for each of them. */
3494 dwarf2_build_include_psymtabs (&cu
, comp_unit_die
, pst
);
3497 do_cleanups (back_to_inner
);
3502 /* Traversal function for htab_traverse_noresize.
3503 Process one .debug_types comp-unit. */
3506 process_type_comp_unit (void **slot
, void *info
)
3508 struct signatured_type
*entry
= (struct signatured_type
*) *slot
;
3509 struct objfile
*objfile
= (struct objfile
*) info
;
3510 struct dwarf2_per_cu_data
*this_cu
;
3512 this_cu
= &entry
->per_cu
;
3514 gdb_assert (this_cu
->debug_type_section
->readin
);
3515 process_psymtab_comp_unit (objfile
, this_cu
,
3516 this_cu
->debug_type_section
->buffer
,
3517 (this_cu
->debug_type_section
->buffer
3519 this_cu
->debug_type_section
->size
);
3524 /* Subroutine of dwarf2_build_psymtabs_hard to simplify it.
3525 Build partial symbol tables for the .debug_types comp-units. */
3528 build_type_psymtabs (struct objfile
*objfile
)
3530 if (! create_debug_types_hash_table (objfile
))
3533 htab_traverse_noresize (dwarf2_per_objfile
->signatured_types
,
3534 process_type_comp_unit
, objfile
);
3537 /* A cleanup function that clears objfile's psymtabs_addrmap field. */
3540 psymtabs_addrmap_cleanup (void *o
)
3542 struct objfile
*objfile
= o
;
3544 objfile
->psymtabs_addrmap
= NULL
;
3547 /* Build the partial symbol table by doing a quick pass through the
3548 .debug_info and .debug_abbrev sections. */
3551 dwarf2_build_psymtabs_hard (struct objfile
*objfile
)
3554 struct cleanup
*back_to
, *addrmap_cleanup
;
3555 struct obstack temp_obstack
;
3557 dwarf2_per_objfile
->reading_partial_symbols
= 1;
3559 dwarf2_read_section (objfile
, &dwarf2_per_objfile
->info
);
3560 info_ptr
= dwarf2_per_objfile
->info
.buffer
;
3562 /* Any cached compilation units will be linked by the per-objfile
3563 read_in_chain. Make sure to free them when we're done. */
3564 back_to
= make_cleanup (free_cached_comp_units
, NULL
);
3566 build_type_psymtabs (objfile
);
3568 create_all_comp_units (objfile
);
3570 /* Create a temporary address map on a temporary obstack. We later
3571 copy this to the final obstack. */
3572 obstack_init (&temp_obstack
);
3573 make_cleanup_obstack_free (&temp_obstack
);
3574 objfile
->psymtabs_addrmap
= addrmap_create_mutable (&temp_obstack
);
3575 addrmap_cleanup
= make_cleanup (psymtabs_addrmap_cleanup
, objfile
);
3577 /* Since the objects we're extracting from .debug_info vary in
3578 length, only the individual functions to extract them (like
3579 read_comp_unit_head and load_partial_die) can really know whether
3580 the buffer is large enough to hold another complete object.
3582 At the moment, they don't actually check that. If .debug_info
3583 holds just one extra byte after the last compilation unit's dies,
3584 then read_comp_unit_head will happily read off the end of the
3585 buffer. read_partial_die is similarly casual. Those functions
3588 For this loop condition, simply checking whether there's any data
3589 left at all should be sufficient. */
3591 while (info_ptr
< (dwarf2_per_objfile
->info
.buffer
3592 + dwarf2_per_objfile
->info
.size
))
3594 struct dwarf2_per_cu_data
*this_cu
;
3596 this_cu
= dwarf2_find_comp_unit (info_ptr
3597 - dwarf2_per_objfile
->info
.buffer
,
3600 info_ptr
= process_psymtab_comp_unit (objfile
, this_cu
,
3601 dwarf2_per_objfile
->info
.buffer
,
3603 dwarf2_per_objfile
->info
.size
);
3606 objfile
->psymtabs_addrmap
= addrmap_create_fixed (objfile
->psymtabs_addrmap
,
3607 &objfile
->objfile_obstack
);
3608 discard_cleanups (addrmap_cleanup
);
3610 do_cleanups (back_to
);
3613 /* Load the partial DIEs for a secondary CU into memory. */
3616 load_partial_comp_unit (struct dwarf2_per_cu_data
*this_cu
,
3617 struct objfile
*objfile
)
3619 bfd
*abfd
= objfile
->obfd
;
3620 gdb_byte
*info_ptr
, *beg_of_comp_unit
;
3621 struct die_info
*comp_unit_die
;
3622 struct dwarf2_cu
*cu
;
3623 struct cleanup
*free_abbrevs_cleanup
, *free_cu_cleanup
= NULL
;
3625 struct die_reader_specs reader_specs
;
3628 gdb_assert (! this_cu
->debug_type_section
);
3630 gdb_assert (dwarf2_per_objfile
->info
.readin
);
3631 info_ptr
= dwarf2_per_objfile
->info
.buffer
+ this_cu
->offset
;
3632 beg_of_comp_unit
= info_ptr
;
3634 if (this_cu
->cu
== NULL
)
3636 cu
= xmalloc (sizeof (*cu
));
3637 init_one_comp_unit (cu
, objfile
);
3641 /* If an error occurs while loading, release our storage. */
3642 free_cu_cleanup
= make_cleanup (free_one_comp_unit
, cu
);
3644 info_ptr
= partial_read_comp_unit_head (&cu
->header
, info_ptr
,
3645 dwarf2_per_objfile
->info
.buffer
,
3646 dwarf2_per_objfile
->info
.size
,
3649 /* Complete the cu_header. */
3650 cu
->header
.offset
= this_cu
->offset
;
3651 cu
->header
.first_die_offset
= info_ptr
- beg_of_comp_unit
;
3653 /* Link this compilation unit into the compilation unit tree. */
3655 cu
->per_cu
= this_cu
;
3657 /* Link this CU into read_in_chain. */
3658 this_cu
->cu
->read_in_chain
= dwarf2_per_objfile
->read_in_chain
;
3659 dwarf2_per_objfile
->read_in_chain
= this_cu
;
3664 info_ptr
+= cu
->header
.first_die_offset
;
3667 /* Read the abbrevs for this compilation unit into a table. */
3668 gdb_assert (cu
->dwarf2_abbrevs
== NULL
);
3669 dwarf2_read_abbrevs (abfd
, cu
);
3670 free_abbrevs_cleanup
= make_cleanup (dwarf2_free_abbrev_table
, cu
);
3672 /* Read the compilation unit die. */
3673 init_cu_die_reader (&reader_specs
, cu
);
3674 info_ptr
= read_full_die (&reader_specs
, &comp_unit_die
, info_ptr
,
3677 prepare_one_comp_unit (cu
, comp_unit_die
);
3679 /* Check if comp unit has_children.
3680 If so, read the rest of the partial symbols from this comp unit.
3681 If not, there's no more debug_info for this comp unit. */
3683 load_partial_dies (abfd
, dwarf2_per_objfile
->info
.buffer
, info_ptr
, 0, cu
);
3685 do_cleanups (free_abbrevs_cleanup
);
3689 /* We've successfully allocated this compilation unit. Let our
3690 caller clean it up when finished with it. */
3691 discard_cleanups (free_cu_cleanup
);
3695 /* Create a list of all compilation units in OBJFILE. We do this only
3696 if an inter-comp-unit reference is found; presumably if there is one,
3697 there will be many, and one will occur early in the .debug_info section.
3698 So there's no point in building this list incrementally. */
3701 create_all_comp_units (struct objfile
*objfile
)
3705 struct dwarf2_per_cu_data
**all_comp_units
;
3708 dwarf2_read_section (objfile
, &dwarf2_per_objfile
->info
);
3709 info_ptr
= dwarf2_per_objfile
->info
.buffer
;
3713 all_comp_units
= xmalloc (n_allocated
3714 * sizeof (struct dwarf2_per_cu_data
*));
3716 while (info_ptr
< dwarf2_per_objfile
->info
.buffer
3717 + dwarf2_per_objfile
->info
.size
)
3719 unsigned int length
, initial_length_size
;
3720 struct dwarf2_per_cu_data
*this_cu
;
3721 unsigned int offset
;
3723 offset
= info_ptr
- dwarf2_per_objfile
->info
.buffer
;
3725 /* Read just enough information to find out where the next
3726 compilation unit is. */
3727 length
= read_initial_length (objfile
->obfd
, info_ptr
,
3728 &initial_length_size
);
3730 /* Save the compilation unit for later lookup. */
3731 this_cu
= obstack_alloc (&objfile
->objfile_obstack
,
3732 sizeof (struct dwarf2_per_cu_data
));
3733 memset (this_cu
, 0, sizeof (*this_cu
));
3734 this_cu
->offset
= offset
;
3735 this_cu
->length
= length
+ initial_length_size
;
3736 this_cu
->objfile
= objfile
;
3738 if (n_comp_units
== n_allocated
)
3741 all_comp_units
= xrealloc (all_comp_units
,
3743 * sizeof (struct dwarf2_per_cu_data
*));
3745 all_comp_units
[n_comp_units
++] = this_cu
;
3747 info_ptr
= info_ptr
+ this_cu
->length
;
3750 dwarf2_per_objfile
->all_comp_units
3751 = obstack_alloc (&objfile
->objfile_obstack
,
3752 n_comp_units
* sizeof (struct dwarf2_per_cu_data
*));
3753 memcpy (dwarf2_per_objfile
->all_comp_units
, all_comp_units
,
3754 n_comp_units
* sizeof (struct dwarf2_per_cu_data
*));
3755 xfree (all_comp_units
);
3756 dwarf2_per_objfile
->n_comp_units
= n_comp_units
;
3759 /* Process all loaded DIEs for compilation unit CU, starting at
3760 FIRST_DIE. The caller should pass NEED_PC == 1 if the compilation
3761 unit DIE did not have PC info (DW_AT_low_pc and DW_AT_high_pc, or
3762 DW_AT_ranges). If NEED_PC is set, then this function will set
3763 *LOWPC and *HIGHPC to the lowest and highest PC values found in CU
3764 and record the covered ranges in the addrmap. */
3767 scan_partial_symbols (struct partial_die_info
*first_die
, CORE_ADDR
*lowpc
,
3768 CORE_ADDR
*highpc
, int need_pc
, struct dwarf2_cu
*cu
)
3770 struct partial_die_info
*pdi
;
3772 /* Now, march along the PDI's, descending into ones which have
3773 interesting children but skipping the children of the other ones,
3774 until we reach the end of the compilation unit. */
3780 fixup_partial_die (pdi
, cu
);
3782 /* Anonymous namespaces or modules have no name but have interesting
3783 children, so we need to look at them. Ditto for anonymous
3786 if (pdi
->name
!= NULL
|| pdi
->tag
== DW_TAG_namespace
3787 || pdi
->tag
== DW_TAG_module
|| pdi
->tag
== DW_TAG_enumeration_type
)
3791 case DW_TAG_subprogram
:
3792 add_partial_subprogram (pdi
, lowpc
, highpc
, need_pc
, cu
);
3794 case DW_TAG_constant
:
3795 case DW_TAG_variable
:
3796 case DW_TAG_typedef
:
3797 case DW_TAG_union_type
:
3798 if (!pdi
->is_declaration
)
3800 add_partial_symbol (pdi
, cu
);
3803 case DW_TAG_class_type
:
3804 case DW_TAG_interface_type
:
3805 case DW_TAG_structure_type
:
3806 if (!pdi
->is_declaration
)
3808 add_partial_symbol (pdi
, cu
);
3811 case DW_TAG_enumeration_type
:
3812 if (!pdi
->is_declaration
)
3813 add_partial_enumeration (pdi
, cu
);
3815 case DW_TAG_base_type
:
3816 case DW_TAG_subrange_type
:
3817 /* File scope base type definitions are added to the partial
3819 add_partial_symbol (pdi
, cu
);
3821 case DW_TAG_namespace
:
3822 add_partial_namespace (pdi
, lowpc
, highpc
, need_pc
, cu
);
3825 add_partial_module (pdi
, lowpc
, highpc
, need_pc
, cu
);
3832 /* If the die has a sibling, skip to the sibling. */
3834 pdi
= pdi
->die_sibling
;
3838 /* Functions used to compute the fully scoped name of a partial DIE.
3840 Normally, this is simple. For C++, the parent DIE's fully scoped
3841 name is concatenated with "::" and the partial DIE's name. For
3842 Java, the same thing occurs except that "." is used instead of "::".
3843 Enumerators are an exception; they use the scope of their parent
3844 enumeration type, i.e. the name of the enumeration type is not
3845 prepended to the enumerator.
3847 There are two complexities. One is DW_AT_specification; in this
3848 case "parent" means the parent of the target of the specification,
3849 instead of the direct parent of the DIE. The other is compilers
3850 which do not emit DW_TAG_namespace; in this case we try to guess
3851 the fully qualified name of structure types from their members'
3852 linkage names. This must be done using the DIE's children rather
3853 than the children of any DW_AT_specification target. We only need
3854 to do this for structures at the top level, i.e. if the target of
3855 any DW_AT_specification (if any; otherwise the DIE itself) does not
3858 /* Compute the scope prefix associated with PDI's parent, in
3859 compilation unit CU. The result will be allocated on CU's
3860 comp_unit_obstack, or a copy of the already allocated PDI->NAME
3861 field. NULL is returned if no prefix is necessary. */
3863 partial_die_parent_scope (struct partial_die_info
*pdi
,
3864 struct dwarf2_cu
*cu
)
3866 char *grandparent_scope
;
3867 struct partial_die_info
*parent
, *real_pdi
;
3869 /* We need to look at our parent DIE; if we have a DW_AT_specification,
3870 then this means the parent of the specification DIE. */
3873 while (real_pdi
->has_specification
)
3874 real_pdi
= find_partial_die (real_pdi
->spec_offset
, cu
);
3876 parent
= real_pdi
->die_parent
;
3880 if (parent
->scope_set
)
3881 return parent
->scope
;
3883 fixup_partial_die (parent
, cu
);
3885 grandparent_scope
= partial_die_parent_scope (parent
, cu
);
3887 /* GCC 4.0 and 4.1 had a bug (PR c++/28460) where they generated bogus
3888 DW_TAG_namespace DIEs with a name of "::" for the global namespace.
3889 Work around this problem here. */
3890 if (cu
->language
== language_cplus
3891 && parent
->tag
== DW_TAG_namespace
3892 && strcmp (parent
->name
, "::") == 0
3893 && grandparent_scope
== NULL
)
3895 parent
->scope
= NULL
;
3896 parent
->scope_set
= 1;
3900 if (parent
->tag
== DW_TAG_namespace
3901 || parent
->tag
== DW_TAG_module
3902 || parent
->tag
== DW_TAG_structure_type
3903 || parent
->tag
== DW_TAG_class_type
3904 || parent
->tag
== DW_TAG_interface_type
3905 || parent
->tag
== DW_TAG_union_type
3906 || parent
->tag
== DW_TAG_enumeration_type
)
3908 if (grandparent_scope
== NULL
)
3909 parent
->scope
= parent
->name
;
3911 parent
->scope
= typename_concat (&cu
->comp_unit_obstack
,
3913 parent
->name
, 0, cu
);
3915 else if (parent
->tag
== DW_TAG_enumerator
)
3916 /* Enumerators should not get the name of the enumeration as a prefix. */
3917 parent
->scope
= grandparent_scope
;
3920 /* FIXME drow/2004-04-01: What should we be doing with
3921 function-local names? For partial symbols, we should probably be
3923 complaint (&symfile_complaints
,
3924 _("unhandled containing DIE tag %d for DIE at %d"),
3925 parent
->tag
, pdi
->offset
);
3926 parent
->scope
= grandparent_scope
;
3929 parent
->scope_set
= 1;
3930 return parent
->scope
;
3933 /* Return the fully scoped name associated with PDI, from compilation unit
3934 CU. The result will be allocated with malloc. */
3936 partial_die_full_name (struct partial_die_info
*pdi
,
3937 struct dwarf2_cu
*cu
)
3941 /* If this is a template instantiation, we can not work out the
3942 template arguments from partial DIEs. So, unfortunately, we have
3943 to go through the full DIEs. At least any work we do building
3944 types here will be reused if full symbols are loaded later. */
3945 if (pdi
->has_template_arguments
)
3947 fixup_partial_die (pdi
, cu
);
3949 if (pdi
->name
!= NULL
&& strchr (pdi
->name
, '<') == NULL
)
3951 struct die_info
*die
;
3952 struct attribute attr
;
3953 struct dwarf2_cu
*ref_cu
= cu
;
3956 attr
.form
= DW_FORM_ref_addr
;
3957 attr
.u
.addr
= pdi
->offset
;
3958 die
= follow_die_ref (NULL
, &attr
, &ref_cu
);
3960 return xstrdup (dwarf2_full_name (NULL
, die
, ref_cu
));
3964 parent_scope
= partial_die_parent_scope (pdi
, cu
);
3965 if (parent_scope
== NULL
)
3968 return typename_concat (NULL
, parent_scope
, pdi
->name
, 0, cu
);
3972 add_partial_symbol (struct partial_die_info
*pdi
, struct dwarf2_cu
*cu
)
3974 struct objfile
*objfile
= cu
->objfile
;
3976 char *actual_name
= NULL
;
3977 const struct partial_symbol
*psym
= NULL
;
3979 int built_actual_name
= 0;
3981 baseaddr
= ANOFFSET (objfile
->section_offsets
, SECT_OFF_TEXT (objfile
));
3983 actual_name
= partial_die_full_name (pdi
, cu
);
3985 built_actual_name
= 1;
3987 if (actual_name
== NULL
)
3988 actual_name
= pdi
->name
;
3992 case DW_TAG_subprogram
:
3993 if (pdi
->is_external
|| cu
->language
== language_ada
)
3995 /* brobecker/2007-12-26: Normally, only "external" DIEs are part
3996 of the global scope. But in Ada, we want to be able to access
3997 nested procedures globally. So all Ada subprograms are stored
3998 in the global scope. */
3999 /* prim_record_minimal_symbol (actual_name, pdi->lowpc + baseaddr,
4000 mst_text, objfile); */
4001 add_psymbol_to_list (actual_name
, strlen (actual_name
),
4003 VAR_DOMAIN
, LOC_BLOCK
,
4004 &objfile
->global_psymbols
,
4005 0, pdi
->lowpc
+ baseaddr
,
4006 cu
->language
, objfile
);
4010 /* prim_record_minimal_symbol (actual_name, pdi->lowpc + baseaddr,
4011 mst_file_text, objfile); */
4012 add_psymbol_to_list (actual_name
, strlen (actual_name
),
4014 VAR_DOMAIN
, LOC_BLOCK
,
4015 &objfile
->static_psymbols
,
4016 0, pdi
->lowpc
+ baseaddr
,
4017 cu
->language
, objfile
);
4020 case DW_TAG_constant
:
4022 struct psymbol_allocation_list
*list
;
4024 if (pdi
->is_external
)
4025 list
= &objfile
->global_psymbols
;
4027 list
= &objfile
->static_psymbols
;
4028 add_psymbol_to_list (actual_name
, strlen (actual_name
),
4029 built_actual_name
, VAR_DOMAIN
, LOC_STATIC
,
4030 list
, 0, 0, cu
->language
, objfile
);
4033 case DW_TAG_variable
:
4035 addr
= decode_locdesc (pdi
->locdesc
, cu
);
4039 && !dwarf2_per_objfile
->has_section_at_zero
)
4041 /* A global or static variable may also have been stripped
4042 out by the linker if unused, in which case its address
4043 will be nullified; do not add such variables into partial
4044 symbol table then. */
4046 else if (pdi
->is_external
)
4049 Don't enter into the minimal symbol tables as there is
4050 a minimal symbol table entry from the ELF symbols already.
4051 Enter into partial symbol table if it has a location
4052 descriptor or a type.
4053 If the location descriptor is missing, new_symbol will create
4054 a LOC_UNRESOLVED symbol, the address of the variable will then
4055 be determined from the minimal symbol table whenever the variable
4057 The address for the partial symbol table entry is not
4058 used by GDB, but it comes in handy for debugging partial symbol
4061 if (pdi
->locdesc
|| pdi
->has_type
)
4062 add_psymbol_to_list (actual_name
, strlen (actual_name
),
4064 VAR_DOMAIN
, LOC_STATIC
,
4065 &objfile
->global_psymbols
,
4067 cu
->language
, objfile
);
4071 /* Static Variable. Skip symbols without location descriptors. */
4072 if (pdi
->locdesc
== NULL
)
4074 if (built_actual_name
)
4075 xfree (actual_name
);
4078 /* prim_record_minimal_symbol (actual_name, addr + baseaddr,
4079 mst_file_data, objfile); */
4080 add_psymbol_to_list (actual_name
, strlen (actual_name
),
4082 VAR_DOMAIN
, LOC_STATIC
,
4083 &objfile
->static_psymbols
,
4085 cu
->language
, objfile
);
4088 case DW_TAG_typedef
:
4089 case DW_TAG_base_type
:
4090 case DW_TAG_subrange_type
:
4091 add_psymbol_to_list (actual_name
, strlen (actual_name
),
4093 VAR_DOMAIN
, LOC_TYPEDEF
,
4094 &objfile
->static_psymbols
,
4095 0, (CORE_ADDR
) 0, cu
->language
, objfile
);
4097 case DW_TAG_namespace
:
4098 add_psymbol_to_list (actual_name
, strlen (actual_name
),
4100 VAR_DOMAIN
, LOC_TYPEDEF
,
4101 &objfile
->global_psymbols
,
4102 0, (CORE_ADDR
) 0, cu
->language
, objfile
);
4104 case DW_TAG_class_type
:
4105 case DW_TAG_interface_type
:
4106 case DW_TAG_structure_type
:
4107 case DW_TAG_union_type
:
4108 case DW_TAG_enumeration_type
:
4109 /* Skip external references. The DWARF standard says in the section
4110 about "Structure, Union, and Class Type Entries": "An incomplete
4111 structure, union or class type is represented by a structure,
4112 union or class entry that does not have a byte size attribute
4113 and that has a DW_AT_declaration attribute." */
4114 if (!pdi
->has_byte_size
&& pdi
->is_declaration
)
4116 if (built_actual_name
)
4117 xfree (actual_name
);
4121 /* NOTE: carlton/2003-10-07: See comment in new_symbol about
4122 static vs. global. */
4123 add_psymbol_to_list (actual_name
, strlen (actual_name
),
4125 STRUCT_DOMAIN
, LOC_TYPEDEF
,
4126 (cu
->language
== language_cplus
4127 || cu
->language
== language_java
)
4128 ? &objfile
->global_psymbols
4129 : &objfile
->static_psymbols
,
4130 0, (CORE_ADDR
) 0, cu
->language
, objfile
);
4133 case DW_TAG_enumerator
:
4134 add_psymbol_to_list (actual_name
, strlen (actual_name
),
4136 VAR_DOMAIN
, LOC_CONST
,
4137 (cu
->language
== language_cplus
4138 || cu
->language
== language_java
)
4139 ? &objfile
->global_psymbols
4140 : &objfile
->static_psymbols
,
4141 0, (CORE_ADDR
) 0, cu
->language
, objfile
);
4147 if (built_actual_name
)
4148 xfree (actual_name
);
4151 /* Read a partial die corresponding to a namespace; also, add a symbol
4152 corresponding to that namespace to the symbol table. NAMESPACE is
4153 the name of the enclosing namespace. */
4156 add_partial_namespace (struct partial_die_info
*pdi
,
4157 CORE_ADDR
*lowpc
, CORE_ADDR
*highpc
,
4158 int need_pc
, struct dwarf2_cu
*cu
)
4160 /* Add a symbol for the namespace. */
4162 add_partial_symbol (pdi
, cu
);
4164 /* Now scan partial symbols in that namespace. */
4166 if (pdi
->has_children
)
4167 scan_partial_symbols (pdi
->die_child
, lowpc
, highpc
, need_pc
, cu
);
4170 /* Read a partial die corresponding to a Fortran module. */
4173 add_partial_module (struct partial_die_info
*pdi
, CORE_ADDR
*lowpc
,
4174 CORE_ADDR
*highpc
, int need_pc
, struct dwarf2_cu
*cu
)
4176 /* Now scan partial symbols in that module. */
4178 if (pdi
->has_children
)
4179 scan_partial_symbols (pdi
->die_child
, lowpc
, highpc
, need_pc
, cu
);
4182 /* Read a partial die corresponding to a subprogram and create a partial
4183 symbol for that subprogram. When the CU language allows it, this
4184 routine also defines a partial symbol for each nested subprogram
4185 that this subprogram contains.
4187 DIE my also be a lexical block, in which case we simply search
4188 recursively for suprograms defined inside that lexical block.
4189 Again, this is only performed when the CU language allows this
4190 type of definitions. */
4193 add_partial_subprogram (struct partial_die_info
*pdi
,
4194 CORE_ADDR
*lowpc
, CORE_ADDR
*highpc
,
4195 int need_pc
, struct dwarf2_cu
*cu
)
4197 if (pdi
->tag
== DW_TAG_subprogram
)
4199 if (pdi
->has_pc_info
)
4201 if (pdi
->lowpc
< *lowpc
)
4202 *lowpc
= pdi
->lowpc
;
4203 if (pdi
->highpc
> *highpc
)
4204 *highpc
= pdi
->highpc
;
4208 struct objfile
*objfile
= cu
->objfile
;
4210 baseaddr
= ANOFFSET (objfile
->section_offsets
,
4211 SECT_OFF_TEXT (objfile
));
4212 addrmap_set_empty (objfile
->psymtabs_addrmap
,
4213 pdi
->lowpc
+ baseaddr
,
4214 pdi
->highpc
- 1 + baseaddr
,
4215 cu
->per_cu
->v
.psymtab
);
4217 if (!pdi
->is_declaration
)
4218 /* Ignore subprogram DIEs that do not have a name, they are
4219 illegal. Do not emit a complaint at this point, we will
4220 do so when we convert this psymtab into a symtab. */
4222 add_partial_symbol (pdi
, cu
);
4226 if (! pdi
->has_children
)
4229 if (cu
->language
== language_ada
)
4231 pdi
= pdi
->die_child
;
4234 fixup_partial_die (pdi
, cu
);
4235 if (pdi
->tag
== DW_TAG_subprogram
4236 || pdi
->tag
== DW_TAG_lexical_block
)
4237 add_partial_subprogram (pdi
, lowpc
, highpc
, need_pc
, cu
);
4238 pdi
= pdi
->die_sibling
;
4243 /* Read a partial die corresponding to an enumeration type. */
4246 add_partial_enumeration (struct partial_die_info
*enum_pdi
,
4247 struct dwarf2_cu
*cu
)
4249 struct partial_die_info
*pdi
;
4251 if (enum_pdi
->name
!= NULL
)
4252 add_partial_symbol (enum_pdi
, cu
);
4254 pdi
= enum_pdi
->die_child
;
4257 if (pdi
->tag
!= DW_TAG_enumerator
|| pdi
->name
== NULL
)
4258 complaint (&symfile_complaints
, _("malformed enumerator DIE ignored"));
4260 add_partial_symbol (pdi
, cu
);
4261 pdi
= pdi
->die_sibling
;
4265 /* Read the initial uleb128 in the die at INFO_PTR in compilation unit CU.
4266 Return the corresponding abbrev, or NULL if the number is zero (indicating
4267 an empty DIE). In either case *BYTES_READ will be set to the length of
4268 the initial number. */
4270 static struct abbrev_info
*
4271 peek_die_abbrev (gdb_byte
*info_ptr
, unsigned int *bytes_read
,
4272 struct dwarf2_cu
*cu
)
4274 bfd
*abfd
= cu
->objfile
->obfd
;
4275 unsigned int abbrev_number
;
4276 struct abbrev_info
*abbrev
;
4278 abbrev_number
= read_unsigned_leb128 (abfd
, info_ptr
, bytes_read
);
4280 if (abbrev_number
== 0)
4283 abbrev
= dwarf2_lookup_abbrev (abbrev_number
, cu
);
4286 error (_("Dwarf Error: Could not find abbrev number %d [in module %s]"),
4287 abbrev_number
, bfd_get_filename (abfd
));
4293 /* Scan the debug information for CU starting at INFO_PTR in buffer BUFFER.
4294 Returns a pointer to the end of a series of DIEs, terminated by an empty
4295 DIE. Any children of the skipped DIEs will also be skipped. */
4298 skip_children (gdb_byte
*buffer
, gdb_byte
*info_ptr
, struct dwarf2_cu
*cu
)
4300 struct abbrev_info
*abbrev
;
4301 unsigned int bytes_read
;
4305 abbrev
= peek_die_abbrev (info_ptr
, &bytes_read
, cu
);
4307 return info_ptr
+ bytes_read
;
4309 info_ptr
= skip_one_die (buffer
, info_ptr
+ bytes_read
, abbrev
, cu
);
4313 /* Scan the debug information for CU starting at INFO_PTR in buffer BUFFER.
4314 INFO_PTR should point just after the initial uleb128 of a DIE, and the
4315 abbrev corresponding to that skipped uleb128 should be passed in
4316 ABBREV. Returns a pointer to this DIE's sibling, skipping any
4320 skip_one_die (gdb_byte
*buffer
, gdb_byte
*info_ptr
,
4321 struct abbrev_info
*abbrev
, struct dwarf2_cu
*cu
)
4323 unsigned int bytes_read
;
4324 struct attribute attr
;
4325 bfd
*abfd
= cu
->objfile
->obfd
;
4326 unsigned int form
, i
;
4328 for (i
= 0; i
< abbrev
->num_attrs
; i
++)
4330 /* The only abbrev we care about is DW_AT_sibling. */
4331 if (abbrev
->attrs
[i
].name
== DW_AT_sibling
)
4333 read_attribute (&attr
, &abbrev
->attrs
[i
],
4334 abfd
, info_ptr
, cu
);
4335 if (attr
.form
== DW_FORM_ref_addr
)
4336 complaint (&symfile_complaints
,
4337 _("ignoring absolute DW_AT_sibling"));
4339 return buffer
+ dwarf2_get_ref_die_offset (&attr
);
4342 /* If it isn't DW_AT_sibling, skip this attribute. */
4343 form
= abbrev
->attrs
[i
].form
;
4347 case DW_FORM_ref_addr
:
4348 /* In DWARF 2, DW_FORM_ref_addr is address sized; in DWARF 3
4349 and later it is offset sized. */
4350 if (cu
->header
.version
== 2)
4351 info_ptr
+= cu
->header
.addr_size
;
4353 info_ptr
+= cu
->header
.offset_size
;
4356 info_ptr
+= cu
->header
.addr_size
;
4363 case DW_FORM_flag_present
:
4375 case DW_FORM_ref_sig8
:
4378 case DW_FORM_string
:
4379 read_direct_string (abfd
, info_ptr
, &bytes_read
);
4380 info_ptr
+= bytes_read
;
4382 case DW_FORM_sec_offset
:
4384 info_ptr
+= cu
->header
.offset_size
;
4386 case DW_FORM_exprloc
:
4388 info_ptr
+= read_unsigned_leb128 (abfd
, info_ptr
, &bytes_read
);
4389 info_ptr
+= bytes_read
;
4391 case DW_FORM_block1
:
4392 info_ptr
+= 1 + read_1_byte (abfd
, info_ptr
);
4394 case DW_FORM_block2
:
4395 info_ptr
+= 2 + read_2_bytes (abfd
, info_ptr
);
4397 case DW_FORM_block4
:
4398 info_ptr
+= 4 + read_4_bytes (abfd
, info_ptr
);
4402 case DW_FORM_ref_udata
:
4403 info_ptr
= skip_leb128 (abfd
, info_ptr
);
4405 case DW_FORM_indirect
:
4406 form
= read_unsigned_leb128 (abfd
, info_ptr
, &bytes_read
);
4407 info_ptr
+= bytes_read
;
4408 /* We need to continue parsing from here, so just go back to
4410 goto skip_attribute
;
4413 error (_("Dwarf Error: Cannot handle %s "
4414 "in DWARF reader [in module %s]"),
4415 dwarf_form_name (form
),
4416 bfd_get_filename (abfd
));
4420 if (abbrev
->has_children
)
4421 return skip_children (buffer
, info_ptr
, cu
);
4426 /* Locate ORIG_PDI's sibling.
4427 INFO_PTR should point to the start of the next DIE after ORIG_PDI
4431 locate_pdi_sibling (struct partial_die_info
*orig_pdi
,
4432 gdb_byte
*buffer
, gdb_byte
*info_ptr
,
4433 bfd
*abfd
, struct dwarf2_cu
*cu
)
4435 /* Do we know the sibling already? */
4437 if (orig_pdi
->sibling
)
4438 return orig_pdi
->sibling
;
4440 /* Are there any children to deal with? */
4442 if (!orig_pdi
->has_children
)
4445 /* Skip the children the long way. */
4447 return skip_children (buffer
, info_ptr
, cu
);
4450 /* Expand this partial symbol table into a full symbol table. */
4453 dwarf2_psymtab_to_symtab (struct partial_symtab
*pst
)
4459 warning (_("bug: psymtab for %s is already read in."),
4466 printf_filtered (_("Reading in symbols for %s..."),
4468 gdb_flush (gdb_stdout
);
4471 /* Restore our global data. */
4472 dwarf2_per_objfile
= objfile_data (pst
->objfile
,
4473 dwarf2_objfile_data_key
);
4475 /* If this psymtab is constructed from a debug-only objfile, the
4476 has_section_at_zero flag will not necessarily be correct. We
4477 can get the correct value for this flag by looking at the data
4478 associated with the (presumably stripped) associated objfile. */
4479 if (pst
->objfile
->separate_debug_objfile_backlink
)
4481 struct dwarf2_per_objfile
*dpo_backlink
4482 = objfile_data (pst
->objfile
->separate_debug_objfile_backlink
,
4483 dwarf2_objfile_data_key
);
4485 dwarf2_per_objfile
->has_section_at_zero
4486 = dpo_backlink
->has_section_at_zero
;
4489 dwarf2_per_objfile
->reading_partial_symbols
= 0;
4491 psymtab_to_symtab_1 (pst
);
4493 /* Finish up the debug error message. */
4495 printf_filtered (_("done.\n"));
4500 /* Add PER_CU to the queue. */
4503 queue_comp_unit (struct dwarf2_per_cu_data
*per_cu
, struct objfile
*objfile
)
4505 struct dwarf2_queue_item
*item
;
4508 item
= xmalloc (sizeof (*item
));
4509 item
->per_cu
= per_cu
;
4512 if (dwarf2_queue
== NULL
)
4513 dwarf2_queue
= item
;
4515 dwarf2_queue_tail
->next
= item
;
4517 dwarf2_queue_tail
= item
;
4520 /* Process the queue. */
4523 process_queue (struct objfile
*objfile
)
4525 struct dwarf2_queue_item
*item
, *next_item
;
4527 /* The queue starts out with one item, but following a DIE reference
4528 may load a new CU, adding it to the end of the queue. */
4529 for (item
= dwarf2_queue
; item
!= NULL
; dwarf2_queue
= item
= next_item
)
4531 if (dwarf2_per_objfile
->using_index
4532 ? !item
->per_cu
->v
.quick
->symtab
4533 : (item
->per_cu
->v
.psymtab
&& !item
->per_cu
->v
.psymtab
->readin
))
4534 process_full_comp_unit (item
->per_cu
);
4536 item
->per_cu
->queued
= 0;
4537 next_item
= item
->next
;
4541 dwarf2_queue_tail
= NULL
;
4544 /* Free all allocated queue entries. This function only releases anything if
4545 an error was thrown; if the queue was processed then it would have been
4546 freed as we went along. */
4549 dwarf2_release_queue (void *dummy
)
4551 struct dwarf2_queue_item
*item
, *last
;
4553 item
= dwarf2_queue
;
4556 /* Anything still marked queued is likely to be in an
4557 inconsistent state, so discard it. */
4558 if (item
->per_cu
->queued
)
4560 if (item
->per_cu
->cu
!= NULL
)
4561 free_one_cached_comp_unit (item
->per_cu
->cu
);
4562 item
->per_cu
->queued
= 0;
4570 dwarf2_queue
= dwarf2_queue_tail
= NULL
;
4573 /* Read in full symbols for PST, and anything it depends on. */
4576 psymtab_to_symtab_1 (struct partial_symtab
*pst
)
4578 struct dwarf2_per_cu_data
*per_cu
;
4579 struct cleanup
*back_to
;
4582 for (i
= 0; i
< pst
->number_of_dependencies
; i
++)
4583 if (!pst
->dependencies
[i
]->readin
)
4585 /* Inform about additional files that need to be read in. */
4588 /* FIXME: i18n: Need to make this a single string. */
4589 fputs_filtered (" ", gdb_stdout
);
4591 fputs_filtered ("and ", gdb_stdout
);
4593 printf_filtered ("%s...", pst
->dependencies
[i
]->filename
);
4594 wrap_here (""); /* Flush output. */
4595 gdb_flush (gdb_stdout
);
4597 psymtab_to_symtab_1 (pst
->dependencies
[i
]);
4600 per_cu
= pst
->read_symtab_private
;
4604 /* It's an include file, no symbols to read for it.
4605 Everything is in the parent symtab. */
4610 dw2_do_instantiate_symtab (pst
->objfile
, per_cu
);
4613 /* Load the DIEs associated with PER_CU into memory. */
4616 load_full_comp_unit (struct dwarf2_per_cu_data
*per_cu
,
4617 struct objfile
*objfile
)
4619 bfd
*abfd
= objfile
->obfd
;
4620 struct dwarf2_cu
*cu
;
4621 unsigned int offset
;
4622 gdb_byte
*info_ptr
, *beg_of_comp_unit
;
4623 struct cleanup
*free_abbrevs_cleanup
= NULL
, *free_cu_cleanup
= NULL
;
4624 struct attribute
*attr
;
4627 gdb_assert (! per_cu
->debug_type_section
);
4629 /* Set local variables from the partial symbol table info. */
4630 offset
= per_cu
->offset
;
4632 dwarf2_read_section (objfile
, &dwarf2_per_objfile
->info
);
4633 info_ptr
= dwarf2_per_objfile
->info
.buffer
+ offset
;
4634 beg_of_comp_unit
= info_ptr
;
4636 if (per_cu
->cu
== NULL
)
4638 cu
= xmalloc (sizeof (*cu
));
4639 init_one_comp_unit (cu
, objfile
);
4643 /* If an error occurs while loading, release our storage. */
4644 free_cu_cleanup
= make_cleanup (free_one_comp_unit
, cu
);
4646 /* Read in the comp_unit header. */
4647 info_ptr
= read_comp_unit_head (&cu
->header
, info_ptr
, abfd
);
4649 /* Complete the cu_header. */
4650 cu
->header
.offset
= offset
;
4651 cu
->header
.first_die_offset
= info_ptr
- beg_of_comp_unit
;
4653 /* Read the abbrevs for this compilation unit. */
4654 dwarf2_read_abbrevs (abfd
, cu
);
4655 free_abbrevs_cleanup
= make_cleanup (dwarf2_free_abbrev_table
, cu
);
4657 /* Link this compilation unit into the compilation unit tree. */
4659 cu
->per_cu
= per_cu
;
4661 /* Link this CU into read_in_chain. */
4662 per_cu
->cu
->read_in_chain
= dwarf2_per_objfile
->read_in_chain
;
4663 dwarf2_per_objfile
->read_in_chain
= per_cu
;
4668 info_ptr
+= cu
->header
.first_die_offset
;
4671 cu
->dies
= read_comp_unit (info_ptr
, cu
);
4673 /* We try not to read any attributes in this function, because not
4674 all objfiles needed for references have been loaded yet, and symbol
4675 table processing isn't initialized. But we have to set the CU language,
4676 or we won't be able to build types correctly. */
4677 prepare_one_comp_unit (cu
, cu
->dies
);
4679 /* Similarly, if we do not read the producer, we can not apply
4680 producer-specific interpretation. */
4681 attr
= dwarf2_attr (cu
->dies
, DW_AT_producer
, cu
);
4683 cu
->producer
= DW_STRING (attr
);
4687 do_cleanups (free_abbrevs_cleanup
);
4689 /* We've successfully allocated this compilation unit. Let our
4690 caller clean it up when finished with it. */
4691 discard_cleanups (free_cu_cleanup
);
4695 /* Add a DIE to the delayed physname list. */
4698 add_to_method_list (struct type
*type
, int fnfield_index
, int index
,
4699 const char *name
, struct die_info
*die
,
4700 struct dwarf2_cu
*cu
)
4702 struct delayed_method_info mi
;
4704 mi
.fnfield_index
= fnfield_index
;
4708 VEC_safe_push (delayed_method_info
, cu
->method_list
, &mi
);
4711 /* A cleanup for freeing the delayed method list. */
4714 free_delayed_list (void *ptr
)
4716 struct dwarf2_cu
*cu
= (struct dwarf2_cu
*) ptr
;
4717 if (cu
->method_list
!= NULL
)
4719 VEC_free (delayed_method_info
, cu
->method_list
);
4720 cu
->method_list
= NULL
;
4724 /* Compute the physnames of any methods on the CU's method list.
4726 The computation of method physnames is delayed in order to avoid the
4727 (bad) condition that one of the method's formal parameters is of an as yet
4731 compute_delayed_physnames (struct dwarf2_cu
*cu
)
4734 struct delayed_method_info
*mi
;
4735 for (i
= 0; VEC_iterate (delayed_method_info
, cu
->method_list
, i
, mi
) ; ++i
)
4737 const char *physname
;
4738 struct fn_fieldlist
*fn_flp
4739 = &TYPE_FN_FIELDLIST (mi
->type
, mi
->fnfield_index
);
4740 physname
= dwarf2_physname ((char *) mi
->name
, mi
->die
, cu
);
4741 fn_flp
->fn_fields
[mi
->index
].physname
= physname
? physname
: "";
4745 /* Generate full symbol information for PST and CU, whose DIEs have
4746 already been loaded into memory. */
4749 process_full_comp_unit (struct dwarf2_per_cu_data
*per_cu
)
4751 struct dwarf2_cu
*cu
= per_cu
->cu
;
4752 struct objfile
*objfile
= per_cu
->objfile
;
4753 CORE_ADDR lowpc
, highpc
;
4754 struct symtab
*symtab
;
4755 struct cleanup
*back_to
, *delayed_list_cleanup
;
4758 baseaddr
= ANOFFSET (objfile
->section_offsets
, SECT_OFF_TEXT (objfile
));
4761 back_to
= make_cleanup (really_free_pendings
, NULL
);
4762 delayed_list_cleanup
= make_cleanup (free_delayed_list
, cu
);
4764 cu
->list_in_scope
= &file_symbols
;
4766 /* Do line number decoding in read_file_scope () */
4767 process_die (cu
->dies
, cu
);
4769 /* Now that we have processed all the DIEs in the CU, all the types
4770 should be complete, and it should now be safe to compute all of the
4772 compute_delayed_physnames (cu
);
4773 do_cleanups (delayed_list_cleanup
);
4775 /* Some compilers don't define a DW_AT_high_pc attribute for the
4776 compilation unit. If the DW_AT_high_pc is missing, synthesize
4777 it, by scanning the DIE's below the compilation unit. */
4778 get_scope_pc_bounds (cu
->dies
, &lowpc
, &highpc
, cu
);
4780 symtab
= end_symtab (highpc
+ baseaddr
, objfile
, SECT_OFF_TEXT (objfile
));
4784 int gcc_4_minor
= producer_is_gcc_ge_4 (cu
->producer
);
4786 /* Set symtab language to language from DW_AT_language. If the
4787 compilation is from a C file generated by language preprocessors, do
4788 not set the language if it was already deduced by start_subfile. */
4789 if (!(cu
->language
== language_c
&& symtab
->language
!= language_c
))
4790 symtab
->language
= cu
->language
;
4792 /* GCC-4.0 has started to support -fvar-tracking. GCC-3.x still can
4793 produce DW_AT_location with location lists but it can be possibly
4794 invalid without -fvar-tracking.
4796 For -gdwarf-4 type units LOCATIONS_VALID indication is fortunately not
4797 needed, it would be wrong due to missing DW_AT_producer there.
4799 Still one can confuse GDB by using non-standard GCC compilation
4800 options - this waits on GCC PR other/32998 (-frecord-gcc-switches).
4802 if (cu
->has_loclist
&& gcc_4_minor
>= 0)
4803 symtab
->locations_valid
= 1;
4805 if (gcc_4_minor
>= 5)
4806 symtab
->epilogue_unwind_valid
= 1;
4808 symtab
->call_site_htab
= cu
->call_site_htab
;
4811 if (dwarf2_per_objfile
->using_index
)
4812 per_cu
->v
.quick
->symtab
= symtab
;
4815 struct partial_symtab
*pst
= per_cu
->v
.psymtab
;
4816 pst
->symtab
= symtab
;
4820 do_cleanups (back_to
);
4823 /* Process a die and its children. */
4826 process_die (struct die_info
*die
, struct dwarf2_cu
*cu
)
4830 case DW_TAG_padding
:
4832 case DW_TAG_compile_unit
:
4833 read_file_scope (die
, cu
);
4835 case DW_TAG_type_unit
:
4836 read_type_unit_scope (die
, cu
);
4838 case DW_TAG_subprogram
:
4839 case DW_TAG_inlined_subroutine
:
4840 read_func_scope (die
, cu
);
4842 case DW_TAG_lexical_block
:
4843 case DW_TAG_try_block
:
4844 case DW_TAG_catch_block
:
4845 read_lexical_block_scope (die
, cu
);
4847 case DW_TAG_GNU_call_site
:
4848 read_call_site_scope (die
, cu
);
4850 case DW_TAG_class_type
:
4851 case DW_TAG_interface_type
:
4852 case DW_TAG_structure_type
:
4853 case DW_TAG_union_type
:
4854 process_structure_scope (die
, cu
);
4856 case DW_TAG_enumeration_type
:
4857 process_enumeration_scope (die
, cu
);
4860 /* These dies have a type, but processing them does not create
4861 a symbol or recurse to process the children. Therefore we can
4862 read them on-demand through read_type_die. */
4863 case DW_TAG_subroutine_type
:
4864 case DW_TAG_set_type
:
4865 case DW_TAG_array_type
:
4866 case DW_TAG_pointer_type
:
4867 case DW_TAG_ptr_to_member_type
:
4868 case DW_TAG_reference_type
:
4869 case DW_TAG_string_type
:
4872 case DW_TAG_base_type
:
4873 case DW_TAG_subrange_type
:
4874 case DW_TAG_typedef
:
4875 /* Add a typedef symbol for the type definition, if it has a
4877 new_symbol (die
, read_type_die (die
, cu
), cu
);
4879 case DW_TAG_common_block
:
4880 read_common_block (die
, cu
);
4882 case DW_TAG_common_inclusion
:
4884 case DW_TAG_namespace
:
4885 processing_has_namespace_info
= 1;
4886 read_namespace (die
, cu
);
4889 processing_has_namespace_info
= 1;
4890 read_module (die
, cu
);
4892 case DW_TAG_imported_declaration
:
4893 case DW_TAG_imported_module
:
4894 processing_has_namespace_info
= 1;
4895 if (die
->child
!= NULL
&& (die
->tag
== DW_TAG_imported_declaration
4896 || cu
->language
!= language_fortran
))
4897 complaint (&symfile_complaints
, _("Tag '%s' has unexpected children"),
4898 dwarf_tag_name (die
->tag
));
4899 read_import_statement (die
, cu
);
4902 new_symbol (die
, NULL
, cu
);
4907 /* A helper function for dwarf2_compute_name which determines whether DIE
4908 needs to have the name of the scope prepended to the name listed in the
4912 die_needs_namespace (struct die_info
*die
, struct dwarf2_cu
*cu
)
4914 struct attribute
*attr
;
4918 case DW_TAG_namespace
:
4919 case DW_TAG_typedef
:
4920 case DW_TAG_class_type
:
4921 case DW_TAG_interface_type
:
4922 case DW_TAG_structure_type
:
4923 case DW_TAG_union_type
:
4924 case DW_TAG_enumeration_type
:
4925 case DW_TAG_enumerator
:
4926 case DW_TAG_subprogram
:
4930 case DW_TAG_variable
:
4931 case DW_TAG_constant
:
4932 /* We only need to prefix "globally" visible variables. These include
4933 any variable marked with DW_AT_external or any variable that
4934 lives in a namespace. [Variables in anonymous namespaces
4935 require prefixing, but they are not DW_AT_external.] */
4937 if (dwarf2_attr (die
, DW_AT_specification
, cu
))
4939 struct dwarf2_cu
*spec_cu
= cu
;
4941 return die_needs_namespace (die_specification (die
, &spec_cu
),
4945 attr
= dwarf2_attr (die
, DW_AT_external
, cu
);
4946 if (attr
== NULL
&& die
->parent
->tag
!= DW_TAG_namespace
4947 && die
->parent
->tag
!= DW_TAG_module
)
4949 /* A variable in a lexical block of some kind does not need a
4950 namespace, even though in C++ such variables may be external
4951 and have a mangled name. */
4952 if (die
->parent
->tag
== DW_TAG_lexical_block
4953 || die
->parent
->tag
== DW_TAG_try_block
4954 || die
->parent
->tag
== DW_TAG_catch_block
4955 || die
->parent
->tag
== DW_TAG_subprogram
)
4964 /* Retrieve the last character from a mem_file. */
4967 do_ui_file_peek_last (void *object
, const char *buffer
, long length
)
4969 char *last_char_p
= (char *) object
;
4972 *last_char_p
= buffer
[length
- 1];
4975 /* Compute the fully qualified name of DIE in CU. If PHYSNAME is nonzero,
4976 compute the physname for the object, which include a method's
4977 formal parameters (C++/Java) and return type (Java).
4979 For Ada, return the DIE's linkage name rather than the fully qualified
4980 name. PHYSNAME is ignored..
4982 The result is allocated on the objfile_obstack and canonicalized. */
4985 dwarf2_compute_name (char *name
, struct die_info
*die
, struct dwarf2_cu
*cu
,
4989 name
= dwarf2_name (die
, cu
);
4991 /* For Fortran GDB prefers DW_AT_*linkage_name if present but otherwise
4992 compute it by typename_concat inside GDB. */
4993 if (cu
->language
== language_ada
4994 || (cu
->language
== language_fortran
&& physname
))
4996 /* For Ada unit, we prefer the linkage name over the name, as
4997 the former contains the exported name, which the user expects
4998 to be able to reference. Ideally, we want the user to be able
4999 to reference this entity using either natural or linkage name,
5000 but we haven't started looking at this enhancement yet. */
5001 struct attribute
*attr
;
5003 attr
= dwarf2_attr (die
, DW_AT_linkage_name
, cu
);
5005 attr
= dwarf2_attr (die
, DW_AT_MIPS_linkage_name
, cu
);
5006 if (attr
&& DW_STRING (attr
))
5007 return DW_STRING (attr
);
5010 /* These are the only languages we know how to qualify names in. */
5012 && (cu
->language
== language_cplus
|| cu
->language
== language_java
5013 || cu
->language
== language_fortran
))
5015 if (die_needs_namespace (die
, cu
))
5019 struct ui_file
*buf
;
5021 prefix
= determine_prefix (die
, cu
);
5022 buf
= mem_fileopen ();
5023 if (*prefix
!= '\0')
5025 char *prefixed_name
= typename_concat (NULL
, prefix
, name
,
5028 fputs_unfiltered (prefixed_name
, buf
);
5029 xfree (prefixed_name
);
5032 fputs_unfiltered (name
, buf
);
5034 /* Template parameters may be specified in the DIE's DW_AT_name, or
5035 as children with DW_TAG_template_type_param or
5036 DW_TAG_value_type_param. If the latter, add them to the name
5037 here. If the name already has template parameters, then
5038 skip this step; some versions of GCC emit both, and
5039 it is more efficient to use the pre-computed name.
5041 Something to keep in mind about this process: it is very
5042 unlikely, or in some cases downright impossible, to produce
5043 something that will match the mangled name of a function.
5044 If the definition of the function has the same debug info,
5045 we should be able to match up with it anyway. But fallbacks
5046 using the minimal symbol, for instance to find a method
5047 implemented in a stripped copy of libstdc++, will not work.
5048 If we do not have debug info for the definition, we will have to
5049 match them up some other way.
5051 When we do name matching there is a related problem with function
5052 templates; two instantiated function templates are allowed to
5053 differ only by their return types, which we do not add here. */
5055 if (cu
->language
== language_cplus
&& strchr (name
, '<') == NULL
)
5057 struct attribute
*attr
;
5058 struct die_info
*child
;
5061 die
->building_fullname
= 1;
5063 for (child
= die
->child
; child
!= NULL
; child
= child
->sibling
)
5068 struct dwarf2_locexpr_baton
*baton
;
5071 if (child
->tag
!= DW_TAG_template_type_param
5072 && child
->tag
!= DW_TAG_template_value_param
)
5077 fputs_unfiltered ("<", buf
);
5081 fputs_unfiltered (", ", buf
);
5083 attr
= dwarf2_attr (child
, DW_AT_type
, cu
);
5086 complaint (&symfile_complaints
,
5087 _("template parameter missing DW_AT_type"));
5088 fputs_unfiltered ("UNKNOWN_TYPE", buf
);
5091 type
= die_type (child
, cu
);
5093 if (child
->tag
== DW_TAG_template_type_param
)
5095 c_print_type (type
, "", buf
, -1, 0);
5099 attr
= dwarf2_attr (child
, DW_AT_const_value
, cu
);
5102 complaint (&symfile_complaints
,
5103 _("template parameter missing "
5104 "DW_AT_const_value"));
5105 fputs_unfiltered ("UNKNOWN_VALUE", buf
);
5109 dwarf2_const_value_attr (attr
, type
, name
,
5110 &cu
->comp_unit_obstack
, cu
,
5111 &value
, &bytes
, &baton
);
5113 if (TYPE_NOSIGN (type
))
5114 /* GDB prints characters as NUMBER 'CHAR'. If that's
5115 changed, this can use value_print instead. */
5116 c_printchar (value
, type
, buf
);
5119 struct value_print_options opts
;
5122 v
= dwarf2_evaluate_loc_desc (type
, NULL
,
5126 else if (bytes
!= NULL
)
5128 v
= allocate_value (type
);
5129 memcpy (value_contents_writeable (v
), bytes
,
5130 TYPE_LENGTH (type
));
5133 v
= value_from_longest (type
, value
);
5135 /* Specify decimal so that we do not depend on
5137 get_formatted_print_options (&opts
, 'd');
5139 value_print (v
, buf
, &opts
);
5145 die
->building_fullname
= 0;
5149 /* Close the argument list, with a space if necessary
5150 (nested templates). */
5151 char last_char
= '\0';
5152 ui_file_put (buf
, do_ui_file_peek_last
, &last_char
);
5153 if (last_char
== '>')
5154 fputs_unfiltered (" >", buf
);
5156 fputs_unfiltered (">", buf
);
5160 /* For Java and C++ methods, append formal parameter type
5161 information, if PHYSNAME. */
5163 if (physname
&& die
->tag
== DW_TAG_subprogram
5164 && (cu
->language
== language_cplus
5165 || cu
->language
== language_java
))
5167 struct type
*type
= read_type_die (die
, cu
);
5169 c_type_print_args (type
, buf
, 1, cu
->language
);
5171 if (cu
->language
== language_java
)
5173 /* For java, we must append the return type to method
5175 if (die
->tag
== DW_TAG_subprogram
)
5176 java_print_type (TYPE_TARGET_TYPE (type
), "", buf
,
5179 else if (cu
->language
== language_cplus
)
5181 /* Assume that an artificial first parameter is
5182 "this", but do not crash if it is not. RealView
5183 marks unnamed (and thus unused) parameters as
5184 artificial; there is no way to differentiate
5186 if (TYPE_NFIELDS (type
) > 0
5187 && TYPE_FIELD_ARTIFICIAL (type
, 0)
5188 && TYPE_CODE (TYPE_FIELD_TYPE (type
, 0)) == TYPE_CODE_PTR
5189 && TYPE_CONST (TYPE_TARGET_TYPE (TYPE_FIELD_TYPE (type
,
5191 fputs_unfiltered (" const", buf
);
5195 name
= ui_file_obsavestring (buf
, &cu
->objfile
->objfile_obstack
,
5197 ui_file_delete (buf
);
5199 if (cu
->language
== language_cplus
)
5202 = dwarf2_canonicalize_name (name
, cu
,
5203 &cu
->objfile
->objfile_obstack
);
5214 /* Return the fully qualified name of DIE, based on its DW_AT_name.
5215 If scope qualifiers are appropriate they will be added. The result
5216 will be allocated on the objfile_obstack, or NULL if the DIE does
5217 not have a name. NAME may either be from a previous call to
5218 dwarf2_name or NULL.
5220 The output string will be canonicalized (if C++/Java). */
5223 dwarf2_full_name (char *name
, struct die_info
*die
, struct dwarf2_cu
*cu
)
5225 return dwarf2_compute_name (name
, die
, cu
, 0);
5228 /* Construct a physname for the given DIE in CU. NAME may either be
5229 from a previous call to dwarf2_name or NULL. The result will be
5230 allocated on the objfile_objstack or NULL if the DIE does not have a
5233 The output string will be canonicalized (if C++/Java). */
5236 dwarf2_physname (char *name
, struct die_info
*die
, struct dwarf2_cu
*cu
)
5238 struct attribute
*attr
;
5239 const char *retval
, *mangled
= NULL
, *canon
= NULL
;
5240 struct cleanup
*back_to
;
5243 /* In this case dwarf2_compute_name is just a shortcut not building anything
5245 if (!die_needs_namespace (die
, cu
))
5246 return dwarf2_compute_name (name
, die
, cu
, 1);
5248 back_to
= make_cleanup (null_cleanup
, NULL
);
5250 attr
= dwarf2_attr (die
, DW_AT_linkage_name
, cu
);
5252 attr
= dwarf2_attr (die
, DW_AT_MIPS_linkage_name
, cu
);
5254 /* DW_AT_linkage_name is missing in some cases - depend on what GDB
5256 if (attr
&& DW_STRING (attr
))
5260 mangled
= DW_STRING (attr
);
5262 /* Use DMGL_RET_DROP for C++ template functions to suppress their return
5263 type. It is easier for GDB users to search for such functions as
5264 `name(params)' than `long name(params)'. In such case the minimal
5265 symbol names do not match the full symbol names but for template
5266 functions there is never a need to look up their definition from their
5267 declaration so the only disadvantage remains the minimal symbol
5268 variant `long name(params)' does not have the proper inferior type.
5271 demangled
= cplus_demangle (mangled
, (DMGL_PARAMS
| DMGL_ANSI
5272 | (cu
->language
== language_java
5273 ? DMGL_JAVA
| DMGL_RET_POSTFIX
5277 make_cleanup (xfree
, demangled
);
5287 if (canon
== NULL
|| check_physname
)
5289 const char *physname
= dwarf2_compute_name (name
, die
, cu
, 1);
5291 if (canon
!= NULL
&& strcmp (physname
, canon
) != 0)
5293 /* It may not mean a bug in GDB. The compiler could also
5294 compute DW_AT_linkage_name incorrectly. But in such case
5295 GDB would need to be bug-to-bug compatible. */
5297 complaint (&symfile_complaints
,
5298 _("Computed physname <%s> does not match demangled <%s> "
5299 "(from linkage <%s>) - DIE at 0x%x [in module %s]"),
5300 physname
, canon
, mangled
, die
->offset
, cu
->objfile
->name
);
5302 /* Prefer DW_AT_linkage_name (in the CANON form) - when it
5303 is available here - over computed PHYSNAME. It is safer
5304 against both buggy GDB and buggy compilers. */
5318 retval
= obsavestring (retval
, strlen (retval
),
5319 &cu
->objfile
->objfile_obstack
);
5321 do_cleanups (back_to
);
5325 /* Read the import statement specified by the given die and record it. */
5328 read_import_statement (struct die_info
*die
, struct dwarf2_cu
*cu
)
5330 struct attribute
*import_attr
;
5331 struct die_info
*imported_die
, *child_die
;
5332 struct dwarf2_cu
*imported_cu
;
5333 const char *imported_name
;
5334 const char *imported_name_prefix
;
5335 const char *canonical_name
;
5336 const char *import_alias
;
5337 const char *imported_declaration
= NULL
;
5338 const char *import_prefix
;
5339 VEC (const_char_ptr
) *excludes
= NULL
;
5340 struct cleanup
*cleanups
;
5344 import_attr
= dwarf2_attr (die
, DW_AT_import
, cu
);
5345 if (import_attr
== NULL
)
5347 complaint (&symfile_complaints
, _("Tag '%s' has no DW_AT_import"),
5348 dwarf_tag_name (die
->tag
));
5353 imported_die
= follow_die_ref_or_sig (die
, import_attr
, &imported_cu
);
5354 imported_name
= dwarf2_name (imported_die
, imported_cu
);
5355 if (imported_name
== NULL
)
5357 /* GCC bug: https://bugzilla.redhat.com/show_bug.cgi?id=506524
5359 The import in the following code:
5373 <2><51>: Abbrev Number: 3 (DW_TAG_imported_declaration)
5374 <52> DW_AT_decl_file : 1
5375 <53> DW_AT_decl_line : 6
5376 <54> DW_AT_import : <0x75>
5377 <2><58>: Abbrev Number: 4 (DW_TAG_typedef)
5379 <5b> DW_AT_decl_file : 1
5380 <5c> DW_AT_decl_line : 2
5381 <5d> DW_AT_type : <0x6e>
5383 <1><75>: Abbrev Number: 7 (DW_TAG_base_type)
5384 <76> DW_AT_byte_size : 4
5385 <77> DW_AT_encoding : 5 (signed)
5387 imports the wrong die ( 0x75 instead of 0x58 ).
5388 This case will be ignored until the gcc bug is fixed. */
5392 /* Figure out the local name after import. */
5393 import_alias
= dwarf2_name (die
, cu
);
5395 /* Figure out where the statement is being imported to. */
5396 import_prefix
= determine_prefix (die
, cu
);
5398 /* Figure out what the scope of the imported die is and prepend it
5399 to the name of the imported die. */
5400 imported_name_prefix
= determine_prefix (imported_die
, imported_cu
);
5402 if (imported_die
->tag
!= DW_TAG_namespace
5403 && imported_die
->tag
!= DW_TAG_module
)
5405 imported_declaration
= imported_name
;
5406 canonical_name
= imported_name_prefix
;
5408 else if (strlen (imported_name_prefix
) > 0)
5410 temp
= alloca (strlen (imported_name_prefix
)
5411 + 2 + strlen (imported_name
) + 1);
5412 strcpy (temp
, imported_name_prefix
);
5413 strcat (temp
, "::");
5414 strcat (temp
, imported_name
);
5415 canonical_name
= temp
;
5418 canonical_name
= imported_name
;
5420 cleanups
= make_cleanup (VEC_cleanup (const_char_ptr
), &excludes
);
5422 if (die
->tag
== DW_TAG_imported_module
&& cu
->language
== language_fortran
)
5423 for (child_die
= die
->child
; child_die
&& child_die
->tag
;
5424 child_die
= sibling_die (child_die
))
5426 /* DWARF-4: A Fortran use statement with a “rename list” may be
5427 represented by an imported module entry with an import attribute
5428 referring to the module and owned entries corresponding to those
5429 entities that are renamed as part of being imported. */
5431 if (child_die
->tag
!= DW_TAG_imported_declaration
)
5433 complaint (&symfile_complaints
,
5434 _("child DW_TAG_imported_declaration expected "
5435 "- DIE at 0x%x [in module %s]"),
5436 child_die
->offset
, cu
->objfile
->name
);
5440 import_attr
= dwarf2_attr (child_die
, DW_AT_import
, cu
);
5441 if (import_attr
== NULL
)
5443 complaint (&symfile_complaints
, _("Tag '%s' has no DW_AT_import"),
5444 dwarf_tag_name (child_die
->tag
));
5449 imported_die
= follow_die_ref_or_sig (child_die
, import_attr
,
5451 imported_name
= dwarf2_name (imported_die
, imported_cu
);
5452 if (imported_name
== NULL
)
5454 complaint (&symfile_complaints
,
5455 _("child DW_TAG_imported_declaration has unknown "
5456 "imported name - DIE at 0x%x [in module %s]"),
5457 child_die
->offset
, cu
->objfile
->name
);
5461 VEC_safe_push (const_char_ptr
, excludes
, imported_name
);
5463 process_die (child_die
, cu
);
5466 cp_add_using_directive (import_prefix
,
5469 imported_declaration
,
5471 &cu
->objfile
->objfile_obstack
);
5473 do_cleanups (cleanups
);
5477 initialize_cu_func_list (struct dwarf2_cu
*cu
)
5479 cu
->first_fn
= cu
->last_fn
= cu
->cached_fn
= NULL
;
5482 /* Cleanup function for read_file_scope. */
5485 free_cu_line_header (void *arg
)
5487 struct dwarf2_cu
*cu
= arg
;
5489 free_line_header (cu
->line_header
);
5490 cu
->line_header
= NULL
;
5494 find_file_and_directory (struct die_info
*die
, struct dwarf2_cu
*cu
,
5495 char **name
, char **comp_dir
)
5497 struct attribute
*attr
;
5502 /* Find the filename. Do not use dwarf2_name here, since the filename
5503 is not a source language identifier. */
5504 attr
= dwarf2_attr (die
, DW_AT_name
, cu
);
5507 *name
= DW_STRING (attr
);
5510 attr
= dwarf2_attr (die
, DW_AT_comp_dir
, cu
);
5512 *comp_dir
= DW_STRING (attr
);
5513 else if (*name
!= NULL
&& IS_ABSOLUTE_PATH (*name
))
5515 *comp_dir
= ldirname (*name
);
5516 if (*comp_dir
!= NULL
)
5517 make_cleanup (xfree
, *comp_dir
);
5519 if (*comp_dir
!= NULL
)
5521 /* Irix 6.2 native cc prepends <machine>.: to the compilation
5522 directory, get rid of it. */
5523 char *cp
= strchr (*comp_dir
, ':');
5525 if (cp
&& cp
!= *comp_dir
&& cp
[-1] == '.' && cp
[1] == '/')
5530 *name
= "<unknown>";
5533 /* Handle DW_AT_stmt_list for a compilation unit. */
5536 handle_DW_AT_stmt_list (struct die_info
*die
, struct dwarf2_cu
*cu
,
5537 const char *comp_dir
)
5539 struct attribute
*attr
;
5540 struct objfile
*objfile
= cu
->objfile
;
5541 bfd
*abfd
= objfile
->obfd
;
5543 /* Decode line number information if present. We do this before
5544 processing child DIEs, so that the line header table is available
5545 for DW_AT_decl_file. */
5546 attr
= dwarf2_attr (die
, DW_AT_stmt_list
, cu
);
5549 unsigned int line_offset
= DW_UNSND (attr
);
5550 struct line_header
*line_header
5551 = dwarf_decode_line_header (line_offset
, abfd
, cu
);
5555 cu
->line_header
= line_header
;
5556 make_cleanup (free_cu_line_header
, cu
);
5557 dwarf_decode_lines (line_header
, comp_dir
, abfd
, cu
, NULL
);
5562 /* Process DW_TAG_compile_unit. */
5565 read_file_scope (struct die_info
*die
, struct dwarf2_cu
*cu
)
5567 struct objfile
*objfile
= cu
->objfile
;
5568 struct cleanup
*back_to
= make_cleanup (null_cleanup
, 0);
5569 CORE_ADDR lowpc
= ((CORE_ADDR
) -1);
5570 CORE_ADDR highpc
= ((CORE_ADDR
) 0);
5571 struct attribute
*attr
;
5573 char *comp_dir
= NULL
;
5574 struct die_info
*child_die
;
5575 bfd
*abfd
= objfile
->obfd
;
5578 baseaddr
= ANOFFSET (objfile
->section_offsets
, SECT_OFF_TEXT (objfile
));
5580 get_scope_pc_bounds (die
, &lowpc
, &highpc
, cu
);
5582 /* If we didn't find a lowpc, set it to highpc to avoid complaints
5583 from finish_block. */
5584 if (lowpc
== ((CORE_ADDR
) -1))
5589 find_file_and_directory (die
, cu
, &name
, &comp_dir
);
5591 attr
= dwarf2_attr (die
, DW_AT_language
, cu
);
5594 set_cu_language (DW_UNSND (attr
), cu
);
5597 attr
= dwarf2_attr (die
, DW_AT_producer
, cu
);
5599 cu
->producer
= DW_STRING (attr
);
5601 /* The XLCL doesn't generate DW_LANG_OpenCL because this attribute is not
5602 standardised yet. As a workaround for the language detection we fall
5603 back to the DW_AT_producer string. */
5604 if (cu
->producer
&& strstr (cu
->producer
, "IBM XL C for OpenCL") != NULL
)
5605 cu
->language
= language_opencl
;
5607 /* We assume that we're processing GCC output. */
5608 processing_gcc_compilation
= 2;
5610 processing_has_namespace_info
= 0;
5612 start_symtab (name
, comp_dir
, lowpc
);
5613 record_debugformat ("DWARF 2");
5614 record_producer (cu
->producer
);
5616 initialize_cu_func_list (cu
);
5618 handle_DW_AT_stmt_list (die
, cu
, comp_dir
);
5620 /* Process all dies in compilation unit. */
5621 if (die
->child
!= NULL
)
5623 child_die
= die
->child
;
5624 while (child_die
&& child_die
->tag
)
5626 process_die (child_die
, cu
);
5627 child_die
= sibling_die (child_die
);
5631 /* Decode macro information, if present. Dwarf 2 macro information
5632 refers to information in the line number info statement program
5633 header, so we can only read it if we've read the header
5635 attr
= dwarf2_attr (die
, DW_AT_GNU_macros
, cu
);
5636 if (attr
&& cu
->line_header
)
5638 if (dwarf2_attr (die
, DW_AT_macro_info
, cu
))
5639 complaint (&symfile_complaints
,
5640 _("CU refers to both DW_AT_GNU_macros and DW_AT_macro_info"));
5642 dwarf_decode_macros (cu
->line_header
, DW_UNSND (attr
),
5644 &dwarf2_per_objfile
->macro
, 1);
5648 attr
= dwarf2_attr (die
, DW_AT_macro_info
, cu
);
5649 if (attr
&& cu
->line_header
)
5651 unsigned int macro_offset
= DW_UNSND (attr
);
5653 dwarf_decode_macros (cu
->line_header
, macro_offset
,
5655 &dwarf2_per_objfile
->macinfo
, 0);
5658 do_cleanups (back_to
);
5661 /* Process DW_TAG_type_unit.
5662 For TUs we want to skip the first top level sibling if it's not the
5663 actual type being defined by this TU. In this case the first top
5664 level sibling is there to provide context only. */
5667 read_type_unit_scope (struct die_info
*die
, struct dwarf2_cu
*cu
)
5669 struct objfile
*objfile
= cu
->objfile
;
5670 struct cleanup
*back_to
= make_cleanup (null_cleanup
, 0);
5672 struct attribute
*attr
;
5674 char *comp_dir
= NULL
;
5675 struct die_info
*child_die
;
5676 bfd
*abfd
= objfile
->obfd
;
5678 /* start_symtab needs a low pc, but we don't really have one.
5679 Do what read_file_scope would do in the absence of such info. */
5680 lowpc
= ANOFFSET (objfile
->section_offsets
, SECT_OFF_TEXT (objfile
));
5682 /* Find the filename. Do not use dwarf2_name here, since the filename
5683 is not a source language identifier. */
5684 attr
= dwarf2_attr (die
, DW_AT_name
, cu
);
5686 name
= DW_STRING (attr
);
5688 attr
= dwarf2_attr (die
, DW_AT_comp_dir
, cu
);
5690 comp_dir
= DW_STRING (attr
);
5691 else if (name
!= NULL
&& IS_ABSOLUTE_PATH (name
))
5693 comp_dir
= ldirname (name
);
5694 if (comp_dir
!= NULL
)
5695 make_cleanup (xfree
, comp_dir
);
5701 attr
= dwarf2_attr (die
, DW_AT_language
, cu
);
5703 set_cu_language (DW_UNSND (attr
), cu
);
5705 /* This isn't technically needed today. It is done for symmetry
5706 with read_file_scope. */
5707 attr
= dwarf2_attr (die
, DW_AT_producer
, cu
);
5709 cu
->producer
= DW_STRING (attr
);
5711 /* We assume that we're processing GCC output. */
5712 processing_gcc_compilation
= 2;
5714 processing_has_namespace_info
= 0;
5716 start_symtab (name
, comp_dir
, lowpc
);
5717 record_debugformat ("DWARF 2");
5718 record_producer (cu
->producer
);
5720 handle_DW_AT_stmt_list (die
, cu
, comp_dir
);
5722 /* Process the dies in the type unit. */
5723 if (die
->child
== NULL
)
5725 dump_die_for_error (die
);
5726 error (_("Dwarf Error: Missing children for type unit [in module %s]"),
5727 bfd_get_filename (abfd
));
5730 child_die
= die
->child
;
5732 while (child_die
&& child_die
->tag
)
5734 process_die (child_die
, cu
);
5736 child_die
= sibling_die (child_die
);
5739 do_cleanups (back_to
);
5743 add_to_cu_func_list (const char *name
, CORE_ADDR lowpc
, CORE_ADDR highpc
,
5744 struct dwarf2_cu
*cu
)
5746 struct function_range
*thisfn
;
5748 thisfn
= (struct function_range
*)
5749 obstack_alloc (&cu
->comp_unit_obstack
, sizeof (struct function_range
));
5750 thisfn
->name
= name
;
5751 thisfn
->lowpc
= lowpc
;
5752 thisfn
->highpc
= highpc
;
5753 thisfn
->seen_line
= 0;
5754 thisfn
->next
= NULL
;
5756 if (cu
->last_fn
== NULL
)
5757 cu
->first_fn
= thisfn
;
5759 cu
->last_fn
->next
= thisfn
;
5761 cu
->last_fn
= thisfn
;
5764 /* qsort helper for inherit_abstract_dies. */
5767 unsigned_int_compar (const void *ap
, const void *bp
)
5769 unsigned int a
= *(unsigned int *) ap
;
5770 unsigned int b
= *(unsigned int *) bp
;
5772 return (a
> b
) - (b
> a
);
5775 /* DW_AT_abstract_origin inherits whole DIEs (not just their attributes).
5776 Inherit only the children of the DW_AT_abstract_origin DIE not being
5777 already referenced by DW_AT_abstract_origin from the children of the
5781 inherit_abstract_dies (struct die_info
*die
, struct dwarf2_cu
*cu
)
5783 struct die_info
*child_die
;
5784 unsigned die_children_count
;
5785 /* CU offsets which were referenced by children of the current DIE. */
5787 unsigned *offsets_end
, *offsetp
;
5788 /* Parent of DIE - referenced by DW_AT_abstract_origin. */
5789 struct die_info
*origin_die
;
5790 /* Iterator of the ORIGIN_DIE children. */
5791 struct die_info
*origin_child_die
;
5792 struct cleanup
*cleanups
;
5793 struct attribute
*attr
;
5794 struct dwarf2_cu
*origin_cu
;
5795 struct pending
**origin_previous_list_in_scope
;
5797 attr
= dwarf2_attr (die
, DW_AT_abstract_origin
, cu
);
5801 /* Note that following die references may follow to a die in a
5805 origin_die
= follow_die_ref (die
, attr
, &origin_cu
);
5807 /* We're inheriting ORIGIN's children into the scope we'd put DIE's
5809 origin_previous_list_in_scope
= origin_cu
->list_in_scope
;
5810 origin_cu
->list_in_scope
= cu
->list_in_scope
;
5812 if (die
->tag
!= origin_die
->tag
5813 && !(die
->tag
== DW_TAG_inlined_subroutine
5814 && origin_die
->tag
== DW_TAG_subprogram
))
5815 complaint (&symfile_complaints
,
5816 _("DIE 0x%x and its abstract origin 0x%x have different tags"),
5817 die
->offset
, origin_die
->offset
);
5819 child_die
= die
->child
;
5820 die_children_count
= 0;
5821 while (child_die
&& child_die
->tag
)
5823 child_die
= sibling_die (child_die
);
5824 die_children_count
++;
5826 offsets
= xmalloc (sizeof (*offsets
) * die_children_count
);
5827 cleanups
= make_cleanup (xfree
, offsets
);
5829 offsets_end
= offsets
;
5830 child_die
= die
->child
;
5831 while (child_die
&& child_die
->tag
)
5833 /* For each CHILD_DIE, find the corresponding child of
5834 ORIGIN_DIE. If there is more than one layer of
5835 DW_AT_abstract_origin, follow them all; there shouldn't be,
5836 but GCC versions at least through 4.4 generate this (GCC PR
5838 struct die_info
*child_origin_die
= child_die
;
5839 struct dwarf2_cu
*child_origin_cu
= cu
;
5843 attr
= dwarf2_attr (child_origin_die
, DW_AT_abstract_origin
,
5847 child_origin_die
= follow_die_ref (child_origin_die
, attr
,
5851 /* According to DWARF3 3.3.8.2 #3 new entries without their abstract
5852 counterpart may exist. */
5853 if (child_origin_die
!= child_die
)
5855 if (child_die
->tag
!= child_origin_die
->tag
5856 && !(child_die
->tag
== DW_TAG_inlined_subroutine
5857 && child_origin_die
->tag
== DW_TAG_subprogram
))
5858 complaint (&symfile_complaints
,
5859 _("Child DIE 0x%x and its abstract origin 0x%x have "
5860 "different tags"), child_die
->offset
,
5861 child_origin_die
->offset
);
5862 if (child_origin_die
->parent
!= origin_die
)
5863 complaint (&symfile_complaints
,
5864 _("Child DIE 0x%x and its abstract origin 0x%x have "
5865 "different parents"), child_die
->offset
,
5866 child_origin_die
->offset
);
5868 *offsets_end
++ = child_origin_die
->offset
;
5870 child_die
= sibling_die (child_die
);
5872 qsort (offsets
, offsets_end
- offsets
, sizeof (*offsets
),
5873 unsigned_int_compar
);
5874 for (offsetp
= offsets
+ 1; offsetp
< offsets_end
; offsetp
++)
5875 if (offsetp
[-1] == *offsetp
)
5876 complaint (&symfile_complaints
,
5877 _("Multiple children of DIE 0x%x refer "
5878 "to DIE 0x%x as their abstract origin"),
5879 die
->offset
, *offsetp
);
5882 origin_child_die
= origin_die
->child
;
5883 while (origin_child_die
&& origin_child_die
->tag
)
5885 /* Is ORIGIN_CHILD_DIE referenced by any of the DIE children? */
5886 while (offsetp
< offsets_end
&& *offsetp
< origin_child_die
->offset
)
5888 if (offsetp
>= offsets_end
|| *offsetp
> origin_child_die
->offset
)
5890 /* Found that ORIGIN_CHILD_DIE is really not referenced. */
5891 process_die (origin_child_die
, origin_cu
);
5893 origin_child_die
= sibling_die (origin_child_die
);
5895 origin_cu
->list_in_scope
= origin_previous_list_in_scope
;
5897 do_cleanups (cleanups
);
5901 read_func_scope (struct die_info
*die
, struct dwarf2_cu
*cu
)
5903 struct objfile
*objfile
= cu
->objfile
;
5904 struct context_stack
*new;
5907 struct die_info
*child_die
;
5908 struct attribute
*attr
, *call_line
, *call_file
;
5911 struct block
*block
;
5912 int inlined_func
= (die
->tag
== DW_TAG_inlined_subroutine
);
5913 VEC (symbolp
) *template_args
= NULL
;
5914 struct template_symbol
*templ_func
= NULL
;
5918 /* If we do not have call site information, we can't show the
5919 caller of this inlined function. That's too confusing, so
5920 only use the scope for local variables. */
5921 call_line
= dwarf2_attr (die
, DW_AT_call_line
, cu
);
5922 call_file
= dwarf2_attr (die
, DW_AT_call_file
, cu
);
5923 if (call_line
== NULL
|| call_file
== NULL
)
5925 read_lexical_block_scope (die
, cu
);
5930 baseaddr
= ANOFFSET (objfile
->section_offsets
, SECT_OFF_TEXT (objfile
));
5932 name
= dwarf2_name (die
, cu
);
5934 /* Ignore functions with missing or empty names. These are actually
5935 illegal according to the DWARF standard. */
5938 complaint (&symfile_complaints
,
5939 _("missing name for subprogram DIE at %d"), die
->offset
);
5943 /* Ignore functions with missing or invalid low and high pc attributes. */
5944 if (!dwarf2_get_pc_bounds (die
, &lowpc
, &highpc
, cu
, NULL
))
5946 attr
= dwarf2_attr (die
, DW_AT_external
, cu
);
5947 if (!attr
|| !DW_UNSND (attr
))
5948 complaint (&symfile_complaints
,
5949 _("cannot get low and high bounds "
5950 "for subprogram DIE at %d"),
5958 /* Record the function range for dwarf_decode_lines. */
5959 add_to_cu_func_list (name
, lowpc
, highpc
, cu
);
5961 /* If we have any template arguments, then we must allocate a
5962 different sort of symbol. */
5963 for (child_die
= die
->child
; child_die
; child_die
= sibling_die (child_die
))
5965 if (child_die
->tag
== DW_TAG_template_type_param
5966 || child_die
->tag
== DW_TAG_template_value_param
)
5968 templ_func
= OBSTACK_ZALLOC (&objfile
->objfile_obstack
,
5969 struct template_symbol
);
5970 templ_func
->base
.is_cplus_template_function
= 1;
5975 new = push_context (0, lowpc
);
5976 new->name
= new_symbol_full (die
, read_type_die (die
, cu
), cu
,
5977 (struct symbol
*) templ_func
);
5979 /* If there is a location expression for DW_AT_frame_base, record
5981 attr
= dwarf2_attr (die
, DW_AT_frame_base
, cu
);
5983 /* FIXME: cagney/2004-01-26: The DW_AT_frame_base's location
5984 expression is being recorded directly in the function's symbol
5985 and not in a separate frame-base object. I guess this hack is
5986 to avoid adding some sort of frame-base adjunct/annex to the
5987 function's symbol :-(. The problem with doing this is that it
5988 results in a function symbol with a location expression that
5989 has nothing to do with the location of the function, ouch! The
5990 relationship should be: a function's symbol has-a frame base; a
5991 frame-base has-a location expression. */
5992 dwarf2_symbol_mark_computed (attr
, new->name
, cu
);
5994 cu
->list_in_scope
= &local_symbols
;
5996 if (die
->child
!= NULL
)
5998 child_die
= die
->child
;
5999 while (child_die
&& child_die
->tag
)
6001 if (child_die
->tag
== DW_TAG_template_type_param
6002 || child_die
->tag
== DW_TAG_template_value_param
)
6004 struct symbol
*arg
= new_symbol (child_die
, NULL
, cu
);
6007 VEC_safe_push (symbolp
, template_args
, arg
);
6010 process_die (child_die
, cu
);
6011 child_die
= sibling_die (child_die
);
6015 inherit_abstract_dies (die
, cu
);
6017 /* If we have a DW_AT_specification, we might need to import using
6018 directives from the context of the specification DIE. See the
6019 comment in determine_prefix. */
6020 if (cu
->language
== language_cplus
6021 && dwarf2_attr (die
, DW_AT_specification
, cu
))
6023 struct dwarf2_cu
*spec_cu
= cu
;
6024 struct die_info
*spec_die
= die_specification (die
, &spec_cu
);
6028 child_die
= spec_die
->child
;
6029 while (child_die
&& child_die
->tag
)
6031 if (child_die
->tag
== DW_TAG_imported_module
)
6032 process_die (child_die
, spec_cu
);
6033 child_die
= sibling_die (child_die
);
6036 /* In some cases, GCC generates specification DIEs that
6037 themselves contain DW_AT_specification attributes. */
6038 spec_die
= die_specification (spec_die
, &spec_cu
);
6042 new = pop_context ();
6043 /* Make a block for the local symbols within. */
6044 block
= finish_block (new->name
, &local_symbols
, new->old_blocks
,
6045 lowpc
, highpc
, objfile
);
6047 /* For C++, set the block's scope. */
6048 if (cu
->language
== language_cplus
|| cu
->language
== language_fortran
)
6049 cp_set_block_scope (new->name
, block
, &objfile
->objfile_obstack
,
6050 determine_prefix (die
, cu
),
6051 processing_has_namespace_info
);
6053 /* If we have address ranges, record them. */
6054 dwarf2_record_block_ranges (die
, block
, baseaddr
, cu
);
6056 /* Attach template arguments to function. */
6057 if (! VEC_empty (symbolp
, template_args
))
6059 gdb_assert (templ_func
!= NULL
);
6061 templ_func
->n_template_arguments
= VEC_length (symbolp
, template_args
);
6062 templ_func
->template_arguments
6063 = obstack_alloc (&objfile
->objfile_obstack
,
6064 (templ_func
->n_template_arguments
6065 * sizeof (struct symbol
*)));
6066 memcpy (templ_func
->template_arguments
,
6067 VEC_address (symbolp
, template_args
),
6068 (templ_func
->n_template_arguments
* sizeof (struct symbol
*)));
6069 VEC_free (symbolp
, template_args
);
6072 /* In C++, we can have functions nested inside functions (e.g., when
6073 a function declares a class that has methods). This means that
6074 when we finish processing a function scope, we may need to go
6075 back to building a containing block's symbol lists. */
6076 local_symbols
= new->locals
;
6077 param_symbols
= new->params
;
6078 using_directives
= new->using_directives
;
6080 /* If we've finished processing a top-level function, subsequent
6081 symbols go in the file symbol list. */
6082 if (outermost_context_p ())
6083 cu
->list_in_scope
= &file_symbols
;
6086 /* Process all the DIES contained within a lexical block scope. Start
6087 a new scope, process the dies, and then close the scope. */
6090 read_lexical_block_scope (struct die_info
*die
, struct dwarf2_cu
*cu
)
6092 struct objfile
*objfile
= cu
->objfile
;
6093 struct context_stack
*new;
6094 CORE_ADDR lowpc
, highpc
;
6095 struct die_info
*child_die
;
6098 baseaddr
= ANOFFSET (objfile
->section_offsets
, SECT_OFF_TEXT (objfile
));
6100 /* Ignore blocks with missing or invalid low and high pc attributes. */
6101 /* ??? Perhaps consider discontiguous blocks defined by DW_AT_ranges
6102 as multiple lexical blocks? Handling children in a sane way would
6103 be nasty. Might be easier to properly extend generic blocks to
6105 if (!dwarf2_get_pc_bounds (die
, &lowpc
, &highpc
, cu
, NULL
))
6110 push_context (0, lowpc
);
6111 if (die
->child
!= NULL
)
6113 child_die
= die
->child
;
6114 while (child_die
&& child_die
->tag
)
6116 process_die (child_die
, cu
);
6117 child_die
= sibling_die (child_die
);
6120 new = pop_context ();
6122 if (local_symbols
!= NULL
|| using_directives
!= NULL
)
6125 = finish_block (0, &local_symbols
, new->old_blocks
, new->start_addr
,
6128 /* Note that recording ranges after traversing children, as we
6129 do here, means that recording a parent's ranges entails
6130 walking across all its children's ranges as they appear in
6131 the address map, which is quadratic behavior.
6133 It would be nicer to record the parent's ranges before
6134 traversing its children, simply overriding whatever you find
6135 there. But since we don't even decide whether to create a
6136 block until after we've traversed its children, that's hard
6138 dwarf2_record_block_ranges (die
, block
, baseaddr
, cu
);
6140 local_symbols
= new->locals
;
6141 using_directives
= new->using_directives
;
6144 /* Read in DW_TAG_GNU_call_site and insert it to CU->call_site_htab. */
6147 read_call_site_scope (struct die_info
*die
, struct dwarf2_cu
*cu
)
6149 struct objfile
*objfile
= cu
->objfile
;
6150 struct gdbarch
*gdbarch
= get_objfile_arch (objfile
);
6151 CORE_ADDR pc
, baseaddr
;
6152 struct attribute
*attr
;
6153 struct call_site
*call_site
, call_site_local
;
6156 struct die_info
*child_die
;
6158 baseaddr
= ANOFFSET (objfile
->section_offsets
, SECT_OFF_TEXT (objfile
));
6160 attr
= dwarf2_attr (die
, DW_AT_low_pc
, cu
);
6163 complaint (&symfile_complaints
,
6164 _("missing DW_AT_low_pc for DW_TAG_GNU_call_site "
6165 "DIE 0x%x [in module %s]"),
6166 die
->offset
, cu
->objfile
->name
);
6169 pc
= DW_ADDR (attr
) + baseaddr
;
6171 if (cu
->call_site_htab
== NULL
)
6172 cu
->call_site_htab
= htab_create_alloc_ex (16, core_addr_hash
, core_addr_eq
,
6173 NULL
, &objfile
->objfile_obstack
,
6174 hashtab_obstack_allocate
, NULL
);
6175 call_site_local
.pc
= pc
;
6176 slot
= htab_find_slot (cu
->call_site_htab
, &call_site_local
, INSERT
);
6179 complaint (&symfile_complaints
,
6180 _("Duplicate PC %s for DW_TAG_GNU_call_site "
6181 "DIE 0x%x [in module %s]"),
6182 paddress (gdbarch
, pc
), die
->offset
, cu
->objfile
->name
);
6186 /* Count parameters at the caller. */
6189 for (child_die
= die
->child
; child_die
&& child_die
->tag
;
6190 child_die
= sibling_die (child_die
))
6192 if (child_die
->tag
!= DW_TAG_GNU_call_site_parameter
)
6194 complaint (&symfile_complaints
,
6195 _("Tag %d is not DW_TAG_GNU_call_site_parameter in "
6196 "DW_TAG_GNU_call_site child DIE 0x%x [in module %s]"),
6197 child_die
->tag
, child_die
->offset
, cu
->objfile
->name
);
6204 call_site
= obstack_alloc (&objfile
->objfile_obstack
,
6205 (sizeof (*call_site
)
6206 + (sizeof (*call_site
->parameter
)
6209 memset (call_site
, 0, sizeof (*call_site
) - sizeof (*call_site
->parameter
));
6212 attr
= dwarf2_attr (die
, DW_AT_GNU_call_site_target
, cu
);
6214 attr
= dwarf2_attr (die
, DW_AT_abstract_origin
, cu
);
6215 SET_FIELD_DWARF_BLOCK (call_site
->target
, NULL
);
6216 if (!attr
|| (attr_form_is_block (attr
) && DW_BLOCK (attr
)->size
== 0))
6217 /* Keep NULL DWARF_BLOCK. */;
6218 else if (attr_form_is_block (attr
))
6220 struct dwarf2_locexpr_baton
*dlbaton
;
6222 dlbaton
= obstack_alloc (&objfile
->objfile_obstack
, sizeof (*dlbaton
));
6223 dlbaton
->data
= DW_BLOCK (attr
)->data
;
6224 dlbaton
->size
= DW_BLOCK (attr
)->size
;
6225 dlbaton
->per_cu
= cu
->per_cu
;
6227 SET_FIELD_DWARF_BLOCK (call_site
->target
, dlbaton
);
6229 else if (is_ref_attr (attr
))
6231 struct objfile
*objfile
= cu
->objfile
;
6232 struct dwarf2_cu
*target_cu
= cu
;
6233 struct die_info
*target_die
;
6235 target_die
= follow_die_ref_or_sig (die
, attr
, &target_cu
);
6236 gdb_assert (target_cu
->objfile
== objfile
);
6237 if (die_is_declaration (target_die
, target_cu
))
6239 const char *target_physname
;
6241 target_physname
= dwarf2_physname (NULL
, target_die
, target_cu
);
6242 if (target_physname
== NULL
)
6243 complaint (&symfile_complaints
,
6244 _("DW_AT_GNU_call_site_target target DIE has invalid "
6245 "physname, for referencing DIE 0x%x [in module %s]"),
6246 die
->offset
, cu
->objfile
->name
);
6248 SET_FIELD_PHYSNAME (call_site
->target
, (char *) target_physname
);
6254 /* DW_AT_entry_pc should be preferred. */
6255 if (!dwarf2_get_pc_bounds (target_die
, &lowpc
, NULL
, target_cu
, NULL
))
6256 complaint (&symfile_complaints
,
6257 _("DW_AT_GNU_call_site_target target DIE has invalid "
6258 "low pc, for referencing DIE 0x%x [in module %s]"),
6259 die
->offset
, cu
->objfile
->name
);
6261 SET_FIELD_PHYSADDR (call_site
->target
, lowpc
+ baseaddr
);
6265 complaint (&symfile_complaints
,
6266 _("DW_TAG_GNU_call_site DW_AT_GNU_call_site_target is neither "
6267 "block nor reference, for DIE 0x%x [in module %s]"),
6268 die
->offset
, cu
->objfile
->name
);
6270 call_site
->per_cu
= cu
->per_cu
;
6272 for (child_die
= die
->child
;
6273 child_die
&& child_die
->tag
;
6274 child_die
= sibling_die (child_die
))
6276 struct dwarf2_locexpr_baton
*dlbaton
;
6277 struct call_site_parameter
*parameter
;
6279 if (child_die
->tag
!= DW_TAG_GNU_call_site_parameter
)
6281 /* Already printed the complaint above. */
6285 gdb_assert (call_site
->parameter_count
< nparams
);
6286 parameter
= &call_site
->parameter
[call_site
->parameter_count
];
6288 /* DW_AT_location specifies the register number. Value of the data
6289 assumed for the register is contained in DW_AT_GNU_call_site_value. */
6291 attr
= dwarf2_attr (child_die
, DW_AT_location
, cu
);
6292 if (!attr
|| !attr_form_is_block (attr
))
6294 complaint (&symfile_complaints
,
6295 _("No DW_FORM_block* DW_AT_location for "
6296 "DW_TAG_GNU_call_site child DIE 0x%x [in module %s]"),
6297 child_die
->offset
, cu
->objfile
->name
);
6300 parameter
->dwarf_reg
= dwarf_block_to_dwarf_reg (DW_BLOCK (attr
)->data
,
6301 &DW_BLOCK (attr
)->data
[DW_BLOCK (attr
)->size
]);
6302 if (parameter
->dwarf_reg
== -1)
6304 complaint (&symfile_complaints
,
6305 _("Only single DW_OP_reg is supported "
6306 "for DW_FORM_block* DW_AT_location for "
6307 "DW_TAG_GNU_call_site child DIE 0x%x [in module %s]"),
6308 child_die
->offset
, cu
->objfile
->name
);
6312 attr
= dwarf2_attr (child_die
, DW_AT_GNU_call_site_value
, cu
);
6313 if (!attr_form_is_block (attr
))
6315 complaint (&symfile_complaints
,
6316 _("No DW_FORM_block* DW_AT_GNU_call_site_value for "
6317 "DW_TAG_GNU_call_site child DIE 0x%x [in module %s]"),
6318 child_die
->offset
, cu
->objfile
->name
);
6321 parameter
->value
= DW_BLOCK (attr
)->data
;
6322 parameter
->value_size
= DW_BLOCK (attr
)->size
;
6324 /* Parameters are not pre-cleared by memset above. */
6325 parameter
->data_value
= NULL
;
6326 parameter
->data_value_size
= 0;
6327 call_site
->parameter_count
++;
6329 attr
= dwarf2_attr (child_die
, DW_AT_GNU_call_site_data_value
, cu
);
6332 if (!attr_form_is_block (attr
))
6333 complaint (&symfile_complaints
,
6334 _("No DW_FORM_block* DW_AT_GNU_call_site_data_value for "
6335 "DW_TAG_GNU_call_site child DIE 0x%x [in module %s]"),
6336 child_die
->offset
, cu
->objfile
->name
);
6339 parameter
->data_value
= DW_BLOCK (attr
)->data
;
6340 parameter
->data_value_size
= DW_BLOCK (attr
)->size
;
6346 /* Get low and high pc attributes from DW_AT_ranges attribute value OFFSET.
6347 Return 1 if the attributes are present and valid, otherwise, return 0.
6348 If RANGES_PST is not NULL we should setup `objfile->psymtabs_addrmap'. */
6351 dwarf2_ranges_read (unsigned offset
, CORE_ADDR
*low_return
,
6352 CORE_ADDR
*high_return
, struct dwarf2_cu
*cu
,
6353 struct partial_symtab
*ranges_pst
)
6355 struct objfile
*objfile
= cu
->objfile
;
6356 struct comp_unit_head
*cu_header
= &cu
->header
;
6357 bfd
*obfd
= objfile
->obfd
;
6358 unsigned int addr_size
= cu_header
->addr_size
;
6359 CORE_ADDR mask
= ~(~(CORE_ADDR
)1 << (addr_size
* 8 - 1));
6360 /* Base address selection entry. */
6371 found_base
= cu
->base_known
;
6372 base
= cu
->base_address
;
6374 dwarf2_read_section (objfile
, &dwarf2_per_objfile
->ranges
);
6375 if (offset
>= dwarf2_per_objfile
->ranges
.size
)
6377 complaint (&symfile_complaints
,
6378 _("Offset %d out of bounds for DW_AT_ranges attribute"),
6382 buffer
= dwarf2_per_objfile
->ranges
.buffer
+ offset
;
6384 /* Read in the largest possible address. */
6385 marker
= read_address (obfd
, buffer
, cu
, &dummy
);
6386 if ((marker
& mask
) == mask
)
6388 /* If we found the largest possible address, then
6389 read the base address. */
6390 base
= read_address (obfd
, buffer
+ addr_size
, cu
, &dummy
);
6391 buffer
+= 2 * addr_size
;
6392 offset
+= 2 * addr_size
;
6398 baseaddr
= ANOFFSET (objfile
->section_offsets
, SECT_OFF_TEXT (objfile
));
6402 CORE_ADDR range_beginning
, range_end
;
6404 range_beginning
= read_address (obfd
, buffer
, cu
, &dummy
);
6405 buffer
+= addr_size
;
6406 range_end
= read_address (obfd
, buffer
, cu
, &dummy
);
6407 buffer
+= addr_size
;
6408 offset
+= 2 * addr_size
;
6410 /* An end of list marker is a pair of zero addresses. */
6411 if (range_beginning
== 0 && range_end
== 0)
6412 /* Found the end of list entry. */
6415 /* Each base address selection entry is a pair of 2 values.
6416 The first is the largest possible address, the second is
6417 the base address. Check for a base address here. */
6418 if ((range_beginning
& mask
) == mask
)
6420 /* If we found the largest possible address, then
6421 read the base address. */
6422 base
= read_address (obfd
, buffer
+ addr_size
, cu
, &dummy
);
6429 /* We have no valid base address for the ranges
6431 complaint (&symfile_complaints
,
6432 _("Invalid .debug_ranges data (no base address)"));
6436 if (range_beginning
> range_end
)
6438 /* Inverted range entries are invalid. */
6439 complaint (&symfile_complaints
,
6440 _("Invalid .debug_ranges data (inverted range)"));
6444 /* Empty range entries have no effect. */
6445 if (range_beginning
== range_end
)
6448 range_beginning
+= base
;
6451 if (ranges_pst
!= NULL
)
6452 addrmap_set_empty (objfile
->psymtabs_addrmap
,
6453 range_beginning
+ baseaddr
,
6454 range_end
- 1 + baseaddr
,
6457 /* FIXME: This is recording everything as a low-high
6458 segment of consecutive addresses. We should have a
6459 data structure for discontiguous block ranges
6463 low
= range_beginning
;
6469 if (range_beginning
< low
)
6470 low
= range_beginning
;
6471 if (range_end
> high
)
6477 /* If the first entry is an end-of-list marker, the range
6478 describes an empty scope, i.e. no instructions. */
6484 *high_return
= high
;
6488 /* Get low and high pc attributes from a die. Return 1 if the attributes
6489 are present and valid, otherwise, return 0. Return -1 if the range is
6490 discontinuous, i.e. derived from DW_AT_ranges information. */
6492 dwarf2_get_pc_bounds (struct die_info
*die
, CORE_ADDR
*lowpc
,
6493 CORE_ADDR
*highpc
, struct dwarf2_cu
*cu
,
6494 struct partial_symtab
*pst
)
6496 struct attribute
*attr
;
6501 attr
= dwarf2_attr (die
, DW_AT_high_pc
, cu
);
6504 high
= DW_ADDR (attr
);
6505 attr
= dwarf2_attr (die
, DW_AT_low_pc
, cu
);
6507 low
= DW_ADDR (attr
);
6509 /* Found high w/o low attribute. */
6512 /* Found consecutive range of addresses. */
6517 attr
= dwarf2_attr (die
, DW_AT_ranges
, cu
);
6520 /* Value of the DW_AT_ranges attribute is the offset in the
6521 .debug_ranges section. */
6522 if (!dwarf2_ranges_read (DW_UNSND (attr
), &low
, &high
, cu
, pst
))
6524 /* Found discontinuous range of addresses. */
6529 /* read_partial_die has also the strict LOW < HIGH requirement. */
6533 /* When using the GNU linker, .gnu.linkonce. sections are used to
6534 eliminate duplicate copies of functions and vtables and such.
6535 The linker will arbitrarily choose one and discard the others.
6536 The AT_*_pc values for such functions refer to local labels in
6537 these sections. If the section from that file was discarded, the
6538 labels are not in the output, so the relocs get a value of 0.
6539 If this is a discarded function, mark the pc bounds as invalid,
6540 so that GDB will ignore it. */
6541 if (low
== 0 && !dwarf2_per_objfile
->has_section_at_zero
)
6550 /* Assuming that DIE represents a subprogram DIE or a lexical block, get
6551 its low and high PC addresses. Do nothing if these addresses could not
6552 be determined. Otherwise, set LOWPC to the low address if it is smaller,
6553 and HIGHPC to the high address if greater than HIGHPC. */
6556 dwarf2_get_subprogram_pc_bounds (struct die_info
*die
,
6557 CORE_ADDR
*lowpc
, CORE_ADDR
*highpc
,
6558 struct dwarf2_cu
*cu
)
6560 CORE_ADDR low
, high
;
6561 struct die_info
*child
= die
->child
;
6563 if (dwarf2_get_pc_bounds (die
, &low
, &high
, cu
, NULL
))
6565 *lowpc
= min (*lowpc
, low
);
6566 *highpc
= max (*highpc
, high
);
6569 /* If the language does not allow nested subprograms (either inside
6570 subprograms or lexical blocks), we're done. */
6571 if (cu
->language
!= language_ada
)
6574 /* Check all the children of the given DIE. If it contains nested
6575 subprograms, then check their pc bounds. Likewise, we need to
6576 check lexical blocks as well, as they may also contain subprogram
6578 while (child
&& child
->tag
)
6580 if (child
->tag
== DW_TAG_subprogram
6581 || child
->tag
== DW_TAG_lexical_block
)
6582 dwarf2_get_subprogram_pc_bounds (child
, lowpc
, highpc
, cu
);
6583 child
= sibling_die (child
);
6587 /* Get the low and high pc's represented by the scope DIE, and store
6588 them in *LOWPC and *HIGHPC. If the correct values can't be
6589 determined, set *LOWPC to -1 and *HIGHPC to 0. */
6592 get_scope_pc_bounds (struct die_info
*die
,
6593 CORE_ADDR
*lowpc
, CORE_ADDR
*highpc
,
6594 struct dwarf2_cu
*cu
)
6596 CORE_ADDR best_low
= (CORE_ADDR
) -1;
6597 CORE_ADDR best_high
= (CORE_ADDR
) 0;
6598 CORE_ADDR current_low
, current_high
;
6600 if (dwarf2_get_pc_bounds (die
, ¤t_low
, ¤t_high
, cu
, NULL
))
6602 best_low
= current_low
;
6603 best_high
= current_high
;
6607 struct die_info
*child
= die
->child
;
6609 while (child
&& child
->tag
)
6611 switch (child
->tag
) {
6612 case DW_TAG_subprogram
:
6613 dwarf2_get_subprogram_pc_bounds (child
, &best_low
, &best_high
, cu
);
6615 case DW_TAG_namespace
:
6617 /* FIXME: carlton/2004-01-16: Should we do this for
6618 DW_TAG_class_type/DW_TAG_structure_type, too? I think
6619 that current GCC's always emit the DIEs corresponding
6620 to definitions of methods of classes as children of a
6621 DW_TAG_compile_unit or DW_TAG_namespace (as opposed to
6622 the DIEs giving the declarations, which could be
6623 anywhere). But I don't see any reason why the
6624 standards says that they have to be there. */
6625 get_scope_pc_bounds (child
, ¤t_low
, ¤t_high
, cu
);
6627 if (current_low
!= ((CORE_ADDR
) -1))
6629 best_low
= min (best_low
, current_low
);
6630 best_high
= max (best_high
, current_high
);
6638 child
= sibling_die (child
);
6643 *highpc
= best_high
;
6646 /* Record the address ranges for BLOCK, offset by BASEADDR, as given
6649 dwarf2_record_block_ranges (struct die_info
*die
, struct block
*block
,
6650 CORE_ADDR baseaddr
, struct dwarf2_cu
*cu
)
6652 struct attribute
*attr
;
6654 attr
= dwarf2_attr (die
, DW_AT_high_pc
, cu
);
6657 CORE_ADDR high
= DW_ADDR (attr
);
6659 attr
= dwarf2_attr (die
, DW_AT_low_pc
, cu
);
6662 CORE_ADDR low
= DW_ADDR (attr
);
6664 record_block_range (block
, baseaddr
+ low
, baseaddr
+ high
- 1);
6668 attr
= dwarf2_attr (die
, DW_AT_ranges
, cu
);
6671 bfd
*obfd
= cu
->objfile
->obfd
;
6673 /* The value of the DW_AT_ranges attribute is the offset of the
6674 address range list in the .debug_ranges section. */
6675 unsigned long offset
= DW_UNSND (attr
);
6676 gdb_byte
*buffer
= dwarf2_per_objfile
->ranges
.buffer
+ offset
;
6678 /* For some target architectures, but not others, the
6679 read_address function sign-extends the addresses it returns.
6680 To recognize base address selection entries, we need a
6682 unsigned int addr_size
= cu
->header
.addr_size
;
6683 CORE_ADDR base_select_mask
= ~(~(CORE_ADDR
)1 << (addr_size
* 8 - 1));
6685 /* The base address, to which the next pair is relative. Note
6686 that this 'base' is a DWARF concept: most entries in a range
6687 list are relative, to reduce the number of relocs against the
6688 debugging information. This is separate from this function's
6689 'baseaddr' argument, which GDB uses to relocate debugging
6690 information from a shared library based on the address at
6691 which the library was loaded. */
6692 CORE_ADDR base
= cu
->base_address
;
6693 int base_known
= cu
->base_known
;
6695 gdb_assert (dwarf2_per_objfile
->ranges
.readin
);
6696 if (offset
>= dwarf2_per_objfile
->ranges
.size
)
6698 complaint (&symfile_complaints
,
6699 _("Offset %lu out of bounds for DW_AT_ranges attribute"),
6706 unsigned int bytes_read
;
6707 CORE_ADDR start
, end
;
6709 start
= read_address (obfd
, buffer
, cu
, &bytes_read
);
6710 buffer
+= bytes_read
;
6711 end
= read_address (obfd
, buffer
, cu
, &bytes_read
);
6712 buffer
+= bytes_read
;
6714 /* Did we find the end of the range list? */
6715 if (start
== 0 && end
== 0)
6718 /* Did we find a base address selection entry? */
6719 else if ((start
& base_select_mask
) == base_select_mask
)
6725 /* We found an ordinary address range. */
6730 complaint (&symfile_complaints
,
6731 _("Invalid .debug_ranges data "
6732 "(no base address)"));
6738 /* Inverted range entries are invalid. */
6739 complaint (&symfile_complaints
,
6740 _("Invalid .debug_ranges data "
6741 "(inverted range)"));
6745 /* Empty range entries have no effect. */
6749 record_block_range (block
,
6750 baseaddr
+ base
+ start
,
6751 baseaddr
+ base
+ end
- 1);
6757 /* Check for GCC PR debug/45124 fix which is not present in any G++ version up
6758 to 4.5.any while it is present already in G++ 4.6.0 - the PR has been fixed
6759 during 4.6.0 experimental. */
6762 producer_is_gxx_lt_4_6 (struct dwarf2_cu
*cu
)
6765 int major
, minor
, release
;
6767 if (cu
->producer
== NULL
)
6769 /* For unknown compilers expect their behavior is DWARF version
6772 GCC started to support .debug_types sections by -gdwarf-4 since
6773 gcc-4.5.x. As the .debug_types sections are missing DW_AT_producer
6774 for their space efficiency GDB cannot workaround gcc-4.5.x -gdwarf-4
6775 combination. gcc-4.5.x -gdwarf-4 binaries have DW_AT_accessibility
6776 interpreted incorrectly by GDB now - GCC PR debug/48229. */
6781 /* Skip any identifier after "GNU " - such as "C++" or "Java". */
6783 if (strncmp (cu
->producer
, "GNU ", strlen ("GNU ")) != 0)
6785 /* For non-GCC compilers expect their behavior is DWARF version
6790 cs
= &cu
->producer
[strlen ("GNU ")];
6791 while (*cs
&& !isdigit (*cs
))
6793 if (sscanf (cs
, "%d.%d.%d", &major
, &minor
, &release
) != 3)
6795 /* Not recognized as GCC. */
6800 return major
< 4 || (major
== 4 && minor
< 6);
6803 /* Return the default accessibility type if it is not overriden by
6804 DW_AT_accessibility. */
6806 static enum dwarf_access_attribute
6807 dwarf2_default_access_attribute (struct die_info
*die
, struct dwarf2_cu
*cu
)
6809 if (cu
->header
.version
< 3 || producer_is_gxx_lt_4_6 (cu
))
6811 /* The default DWARF 2 accessibility for members is public, the default
6812 accessibility for inheritance is private. */
6814 if (die
->tag
!= DW_TAG_inheritance
)
6815 return DW_ACCESS_public
;
6817 return DW_ACCESS_private
;
6821 /* DWARF 3+ defines the default accessibility a different way. The same
6822 rules apply now for DW_TAG_inheritance as for the members and it only
6823 depends on the container kind. */
6825 if (die
->parent
->tag
== DW_TAG_class_type
)
6826 return DW_ACCESS_private
;
6828 return DW_ACCESS_public
;
6832 /* Look for DW_AT_data_member_location. Set *OFFSET to the byte
6833 offset. If the attribute was not found return 0, otherwise return
6834 1. If it was found but could not properly be handled, set *OFFSET
6838 handle_data_member_location (struct die_info
*die
, struct dwarf2_cu
*cu
,
6841 struct attribute
*attr
;
6843 attr
= dwarf2_attr (die
, DW_AT_data_member_location
, cu
);
6848 /* Note that we do not check for a section offset first here.
6849 This is because DW_AT_data_member_location is new in DWARF 4,
6850 so if we see it, we can assume that a constant form is really
6851 a constant and not a section offset. */
6852 if (attr_form_is_constant (attr
))
6853 *offset
= dwarf2_get_attr_constant_value (attr
, 0);
6854 else if (attr_form_is_section_offset (attr
))
6855 dwarf2_complex_location_expr_complaint ();
6856 else if (attr_form_is_block (attr
))
6857 *offset
= decode_locdesc (DW_BLOCK (attr
), cu
);
6859 dwarf2_complex_location_expr_complaint ();
6867 /* Add an aggregate field to the field list. */
6870 dwarf2_add_field (struct field_info
*fip
, struct die_info
*die
,
6871 struct dwarf2_cu
*cu
)
6873 struct objfile
*objfile
= cu
->objfile
;
6874 struct gdbarch
*gdbarch
= get_objfile_arch (objfile
);
6875 struct nextfield
*new_field
;
6876 struct attribute
*attr
;
6878 char *fieldname
= "";
6880 /* Allocate a new field list entry and link it in. */
6881 new_field
= (struct nextfield
*) xmalloc (sizeof (struct nextfield
));
6882 make_cleanup (xfree
, new_field
);
6883 memset (new_field
, 0, sizeof (struct nextfield
));
6885 if (die
->tag
== DW_TAG_inheritance
)
6887 new_field
->next
= fip
->baseclasses
;
6888 fip
->baseclasses
= new_field
;
6892 new_field
->next
= fip
->fields
;
6893 fip
->fields
= new_field
;
6897 attr
= dwarf2_attr (die
, DW_AT_accessibility
, cu
);
6899 new_field
->accessibility
= DW_UNSND (attr
);
6901 new_field
->accessibility
= dwarf2_default_access_attribute (die
, cu
);
6902 if (new_field
->accessibility
!= DW_ACCESS_public
)
6903 fip
->non_public_fields
= 1;
6905 attr
= dwarf2_attr (die
, DW_AT_virtuality
, cu
);
6907 new_field
->virtuality
= DW_UNSND (attr
);
6909 new_field
->virtuality
= DW_VIRTUALITY_none
;
6911 fp
= &new_field
->field
;
6913 if (die
->tag
== DW_TAG_member
&& ! die_is_declaration (die
, cu
))
6917 /* Data member other than a C++ static data member. */
6919 /* Get type of field. */
6920 fp
->type
= die_type (die
, cu
);
6922 SET_FIELD_BITPOS (*fp
, 0);
6924 /* Get bit size of field (zero if none). */
6925 attr
= dwarf2_attr (die
, DW_AT_bit_size
, cu
);
6928 FIELD_BITSIZE (*fp
) = DW_UNSND (attr
);
6932 FIELD_BITSIZE (*fp
) = 0;
6935 /* Get bit offset of field. */
6936 if (handle_data_member_location (die
, cu
, &offset
))
6937 SET_FIELD_BITPOS (*fp
, offset
* bits_per_byte
);
6938 attr
= dwarf2_attr (die
, DW_AT_bit_offset
, cu
);
6941 if (gdbarch_bits_big_endian (gdbarch
))
6943 /* For big endian bits, the DW_AT_bit_offset gives the
6944 additional bit offset from the MSB of the containing
6945 anonymous object to the MSB of the field. We don't
6946 have to do anything special since we don't need to
6947 know the size of the anonymous object. */
6948 FIELD_BITPOS (*fp
) += DW_UNSND (attr
);
6952 /* For little endian bits, compute the bit offset to the
6953 MSB of the anonymous object, subtract off the number of
6954 bits from the MSB of the field to the MSB of the
6955 object, and then subtract off the number of bits of
6956 the field itself. The result is the bit offset of
6957 the LSB of the field. */
6959 int bit_offset
= DW_UNSND (attr
);
6961 attr
= dwarf2_attr (die
, DW_AT_byte_size
, cu
);
6964 /* The size of the anonymous object containing
6965 the bit field is explicit, so use the
6966 indicated size (in bytes). */
6967 anonymous_size
= DW_UNSND (attr
);
6971 /* The size of the anonymous object containing
6972 the bit field must be inferred from the type
6973 attribute of the data member containing the
6975 anonymous_size
= TYPE_LENGTH (fp
->type
);
6977 FIELD_BITPOS (*fp
) += anonymous_size
* bits_per_byte
6978 - bit_offset
- FIELD_BITSIZE (*fp
);
6982 /* Get name of field. */
6983 fieldname
= dwarf2_name (die
, cu
);
6984 if (fieldname
== NULL
)
6987 /* The name is already allocated along with this objfile, so we don't
6988 need to duplicate it for the type. */
6989 fp
->name
= fieldname
;
6991 /* Change accessibility for artificial fields (e.g. virtual table
6992 pointer or virtual base class pointer) to private. */
6993 if (dwarf2_attr (die
, DW_AT_artificial
, cu
))
6995 FIELD_ARTIFICIAL (*fp
) = 1;
6996 new_field
->accessibility
= DW_ACCESS_private
;
6997 fip
->non_public_fields
= 1;
7000 else if (die
->tag
== DW_TAG_member
|| die
->tag
== DW_TAG_variable
)
7002 /* C++ static member. */
7004 /* NOTE: carlton/2002-11-05: It should be a DW_TAG_member that
7005 is a declaration, but all versions of G++ as of this writing
7006 (so through at least 3.2.1) incorrectly generate
7007 DW_TAG_variable tags. */
7009 const char *physname
;
7011 /* Get name of field. */
7012 fieldname
= dwarf2_name (die
, cu
);
7013 if (fieldname
== NULL
)
7016 attr
= dwarf2_attr (die
, DW_AT_const_value
, cu
);
7018 /* Only create a symbol if this is an external value.
7019 new_symbol checks this and puts the value in the global symbol
7020 table, which we want. If it is not external, new_symbol
7021 will try to put the value in cu->list_in_scope which is wrong. */
7022 && dwarf2_flag_true_p (die
, DW_AT_external
, cu
))
7024 /* A static const member, not much different than an enum as far as
7025 we're concerned, except that we can support more types. */
7026 new_symbol (die
, NULL
, cu
);
7029 /* Get physical name. */
7030 physname
= dwarf2_physname (fieldname
, die
, cu
);
7032 /* The name is already allocated along with this objfile, so we don't
7033 need to duplicate it for the type. */
7034 SET_FIELD_PHYSNAME (*fp
, physname
? physname
: "");
7035 FIELD_TYPE (*fp
) = die_type (die
, cu
);
7036 FIELD_NAME (*fp
) = fieldname
;
7038 else if (die
->tag
== DW_TAG_inheritance
)
7042 /* C++ base class field. */
7043 if (handle_data_member_location (die
, cu
, &offset
))
7044 SET_FIELD_BITPOS (*fp
, offset
* bits_per_byte
);
7045 FIELD_BITSIZE (*fp
) = 0;
7046 FIELD_TYPE (*fp
) = die_type (die
, cu
);
7047 FIELD_NAME (*fp
) = type_name_no_tag (fp
->type
);
7048 fip
->nbaseclasses
++;
7052 /* Add a typedef defined in the scope of the FIP's class. */
7055 dwarf2_add_typedef (struct field_info
*fip
, struct die_info
*die
,
7056 struct dwarf2_cu
*cu
)
7058 struct objfile
*objfile
= cu
->objfile
;
7059 struct typedef_field_list
*new_field
;
7060 struct attribute
*attr
;
7061 struct typedef_field
*fp
;
7062 char *fieldname
= "";
7064 /* Allocate a new field list entry and link it in. */
7065 new_field
= xzalloc (sizeof (*new_field
));
7066 make_cleanup (xfree
, new_field
);
7068 gdb_assert (die
->tag
== DW_TAG_typedef
);
7070 fp
= &new_field
->field
;
7072 /* Get name of field. */
7073 fp
->name
= dwarf2_name (die
, cu
);
7074 if (fp
->name
== NULL
)
7077 fp
->type
= read_type_die (die
, cu
);
7079 new_field
->next
= fip
->typedef_field_list
;
7080 fip
->typedef_field_list
= new_field
;
7081 fip
->typedef_field_list_count
++;
7084 /* Create the vector of fields, and attach it to the type. */
7087 dwarf2_attach_fields_to_type (struct field_info
*fip
, struct type
*type
,
7088 struct dwarf2_cu
*cu
)
7090 int nfields
= fip
->nfields
;
7092 /* Record the field count, allocate space for the array of fields,
7093 and create blank accessibility bitfields if necessary. */
7094 TYPE_NFIELDS (type
) = nfields
;
7095 TYPE_FIELDS (type
) = (struct field
*)
7096 TYPE_ALLOC (type
, sizeof (struct field
) * nfields
);
7097 memset (TYPE_FIELDS (type
), 0, sizeof (struct field
) * nfields
);
7099 if (fip
->non_public_fields
&& cu
->language
!= language_ada
)
7101 ALLOCATE_CPLUS_STRUCT_TYPE (type
);
7103 TYPE_FIELD_PRIVATE_BITS (type
) =
7104 (B_TYPE
*) TYPE_ALLOC (type
, B_BYTES (nfields
));
7105 B_CLRALL (TYPE_FIELD_PRIVATE_BITS (type
), nfields
);
7107 TYPE_FIELD_PROTECTED_BITS (type
) =
7108 (B_TYPE
*) TYPE_ALLOC (type
, B_BYTES (nfields
));
7109 B_CLRALL (TYPE_FIELD_PROTECTED_BITS (type
), nfields
);
7111 TYPE_FIELD_IGNORE_BITS (type
) =
7112 (B_TYPE
*) TYPE_ALLOC (type
, B_BYTES (nfields
));
7113 B_CLRALL (TYPE_FIELD_IGNORE_BITS (type
), nfields
);
7116 /* If the type has baseclasses, allocate and clear a bit vector for
7117 TYPE_FIELD_VIRTUAL_BITS. */
7118 if (fip
->nbaseclasses
&& cu
->language
!= language_ada
)
7120 int num_bytes
= B_BYTES (fip
->nbaseclasses
);
7121 unsigned char *pointer
;
7123 ALLOCATE_CPLUS_STRUCT_TYPE (type
);
7124 pointer
= TYPE_ALLOC (type
, num_bytes
);
7125 TYPE_FIELD_VIRTUAL_BITS (type
) = pointer
;
7126 B_CLRALL (TYPE_FIELD_VIRTUAL_BITS (type
), fip
->nbaseclasses
);
7127 TYPE_N_BASECLASSES (type
) = fip
->nbaseclasses
;
7130 /* Copy the saved-up fields into the field vector. Start from the head of
7131 the list, adding to the tail of the field array, so that they end up in
7132 the same order in the array in which they were added to the list. */
7133 while (nfields
-- > 0)
7135 struct nextfield
*fieldp
;
7139 fieldp
= fip
->fields
;
7140 fip
->fields
= fieldp
->next
;
7144 fieldp
= fip
->baseclasses
;
7145 fip
->baseclasses
= fieldp
->next
;
7148 TYPE_FIELD (type
, nfields
) = fieldp
->field
;
7149 switch (fieldp
->accessibility
)
7151 case DW_ACCESS_private
:
7152 if (cu
->language
!= language_ada
)
7153 SET_TYPE_FIELD_PRIVATE (type
, nfields
);
7156 case DW_ACCESS_protected
:
7157 if (cu
->language
!= language_ada
)
7158 SET_TYPE_FIELD_PROTECTED (type
, nfields
);
7161 case DW_ACCESS_public
:
7165 /* Unknown accessibility. Complain and treat it as public. */
7167 complaint (&symfile_complaints
, _("unsupported accessibility %d"),
7168 fieldp
->accessibility
);
7172 if (nfields
< fip
->nbaseclasses
)
7174 switch (fieldp
->virtuality
)
7176 case DW_VIRTUALITY_virtual
:
7177 case DW_VIRTUALITY_pure_virtual
:
7178 if (cu
->language
== language_ada
)
7179 error (_("unexpected virtuality in component of Ada type"));
7180 SET_TYPE_FIELD_VIRTUAL (type
, nfields
);
7187 /* Add a member function to the proper fieldlist. */
7190 dwarf2_add_member_fn (struct field_info
*fip
, struct die_info
*die
,
7191 struct type
*type
, struct dwarf2_cu
*cu
)
7193 struct objfile
*objfile
= cu
->objfile
;
7194 struct attribute
*attr
;
7195 struct fnfieldlist
*flp
;
7197 struct fn_field
*fnp
;
7199 struct nextfnfield
*new_fnfield
;
7200 struct type
*this_type
;
7201 enum dwarf_access_attribute accessibility
;
7203 if (cu
->language
== language_ada
)
7204 error (_("unexpected member function in Ada type"));
7206 /* Get name of member function. */
7207 fieldname
= dwarf2_name (die
, cu
);
7208 if (fieldname
== NULL
)
7211 /* Look up member function name in fieldlist. */
7212 for (i
= 0; i
< fip
->nfnfields
; i
++)
7214 if (strcmp (fip
->fnfieldlists
[i
].name
, fieldname
) == 0)
7218 /* Create new list element if necessary. */
7219 if (i
< fip
->nfnfields
)
7220 flp
= &fip
->fnfieldlists
[i
];
7223 if ((fip
->nfnfields
% DW_FIELD_ALLOC_CHUNK
) == 0)
7225 fip
->fnfieldlists
= (struct fnfieldlist
*)
7226 xrealloc (fip
->fnfieldlists
,
7227 (fip
->nfnfields
+ DW_FIELD_ALLOC_CHUNK
)
7228 * sizeof (struct fnfieldlist
));
7229 if (fip
->nfnfields
== 0)
7230 make_cleanup (free_current_contents
, &fip
->fnfieldlists
);
7232 flp
= &fip
->fnfieldlists
[fip
->nfnfields
];
7233 flp
->name
= fieldname
;
7236 i
= fip
->nfnfields
++;
7239 /* Create a new member function field and chain it to the field list
7241 new_fnfield
= (struct nextfnfield
*) xmalloc (sizeof (struct nextfnfield
));
7242 make_cleanup (xfree
, new_fnfield
);
7243 memset (new_fnfield
, 0, sizeof (struct nextfnfield
));
7244 new_fnfield
->next
= flp
->head
;
7245 flp
->head
= new_fnfield
;
7248 /* Fill in the member function field info. */
7249 fnp
= &new_fnfield
->fnfield
;
7251 /* Delay processing of the physname until later. */
7252 if (cu
->language
== language_cplus
|| cu
->language
== language_java
)
7254 add_to_method_list (type
, i
, flp
->length
- 1, fieldname
,
7259 const char *physname
= dwarf2_physname (fieldname
, die
, cu
);
7260 fnp
->physname
= physname
? physname
: "";
7263 fnp
->type
= alloc_type (objfile
);
7264 this_type
= read_type_die (die
, cu
);
7265 if (this_type
&& TYPE_CODE (this_type
) == TYPE_CODE_FUNC
)
7267 int nparams
= TYPE_NFIELDS (this_type
);
7269 /* TYPE is the domain of this method, and THIS_TYPE is the type
7270 of the method itself (TYPE_CODE_METHOD). */
7271 smash_to_method_type (fnp
->type
, type
,
7272 TYPE_TARGET_TYPE (this_type
),
7273 TYPE_FIELDS (this_type
),
7274 TYPE_NFIELDS (this_type
),
7275 TYPE_VARARGS (this_type
));
7277 /* Handle static member functions.
7278 Dwarf2 has no clean way to discern C++ static and non-static
7279 member functions. G++ helps GDB by marking the first
7280 parameter for non-static member functions (which is the this
7281 pointer) as artificial. We obtain this information from
7282 read_subroutine_type via TYPE_FIELD_ARTIFICIAL. */
7283 if (nparams
== 0 || TYPE_FIELD_ARTIFICIAL (this_type
, 0) == 0)
7284 fnp
->voffset
= VOFFSET_STATIC
;
7287 complaint (&symfile_complaints
, _("member function type missing for '%s'"),
7288 dwarf2_full_name (fieldname
, die
, cu
));
7290 /* Get fcontext from DW_AT_containing_type if present. */
7291 if (dwarf2_attr (die
, DW_AT_containing_type
, cu
) != NULL
)
7292 fnp
->fcontext
= die_containing_type (die
, cu
);
7294 /* dwarf2 doesn't have stubbed physical names, so the setting of is_const and
7295 is_volatile is irrelevant, as it is needed by gdb_mangle_name only. */
7297 /* Get accessibility. */
7298 attr
= dwarf2_attr (die
, DW_AT_accessibility
, cu
);
7300 accessibility
= DW_UNSND (attr
);
7302 accessibility
= dwarf2_default_access_attribute (die
, cu
);
7303 switch (accessibility
)
7305 case DW_ACCESS_private
:
7306 fnp
->is_private
= 1;
7308 case DW_ACCESS_protected
:
7309 fnp
->is_protected
= 1;
7313 /* Check for artificial methods. */
7314 attr
= dwarf2_attr (die
, DW_AT_artificial
, cu
);
7315 if (attr
&& DW_UNSND (attr
) != 0)
7316 fnp
->is_artificial
= 1;
7318 /* Get index in virtual function table if it is a virtual member
7319 function. For older versions of GCC, this is an offset in the
7320 appropriate virtual table, as specified by DW_AT_containing_type.
7321 For everyone else, it is an expression to be evaluated relative
7322 to the object address. */
7324 attr
= dwarf2_attr (die
, DW_AT_vtable_elem_location
, cu
);
7327 if (attr_form_is_block (attr
) && DW_BLOCK (attr
)->size
> 0)
7329 if (DW_BLOCK (attr
)->data
[0] == DW_OP_constu
)
7331 /* Old-style GCC. */
7332 fnp
->voffset
= decode_locdesc (DW_BLOCK (attr
), cu
) + 2;
7334 else if (DW_BLOCK (attr
)->data
[0] == DW_OP_deref
7335 || (DW_BLOCK (attr
)->size
> 1
7336 && DW_BLOCK (attr
)->data
[0] == DW_OP_deref_size
7337 && DW_BLOCK (attr
)->data
[1] == cu
->header
.addr_size
))
7339 struct dwarf_block blk
;
7342 offset
= (DW_BLOCK (attr
)->data
[0] == DW_OP_deref
7344 blk
.size
= DW_BLOCK (attr
)->size
- offset
;
7345 blk
.data
= DW_BLOCK (attr
)->data
+ offset
;
7346 fnp
->voffset
= decode_locdesc (DW_BLOCK (attr
), cu
);
7347 if ((fnp
->voffset
% cu
->header
.addr_size
) != 0)
7348 dwarf2_complex_location_expr_complaint ();
7350 fnp
->voffset
/= cu
->header
.addr_size
;
7354 dwarf2_complex_location_expr_complaint ();
7357 fnp
->fcontext
= TYPE_TARGET_TYPE (TYPE_FIELD_TYPE (this_type
, 0));
7359 else if (attr_form_is_section_offset (attr
))
7361 dwarf2_complex_location_expr_complaint ();
7365 dwarf2_invalid_attrib_class_complaint ("DW_AT_vtable_elem_location",
7371 attr
= dwarf2_attr (die
, DW_AT_virtuality
, cu
);
7372 if (attr
&& DW_UNSND (attr
))
7374 /* GCC does this, as of 2008-08-25; PR debug/37237. */
7375 complaint (&symfile_complaints
,
7376 _("Member function \"%s\" (offset %d) is virtual "
7377 "but the vtable offset is not specified"),
7378 fieldname
, die
->offset
);
7379 ALLOCATE_CPLUS_STRUCT_TYPE (type
);
7380 TYPE_CPLUS_DYNAMIC (type
) = 1;
7385 /* Create the vector of member function fields, and attach it to the type. */
7388 dwarf2_attach_fn_fields_to_type (struct field_info
*fip
, struct type
*type
,
7389 struct dwarf2_cu
*cu
)
7391 struct fnfieldlist
*flp
;
7392 int total_length
= 0;
7395 if (cu
->language
== language_ada
)
7396 error (_("unexpected member functions in Ada type"));
7398 ALLOCATE_CPLUS_STRUCT_TYPE (type
);
7399 TYPE_FN_FIELDLISTS (type
) = (struct fn_fieldlist
*)
7400 TYPE_ALLOC (type
, sizeof (struct fn_fieldlist
) * fip
->nfnfields
);
7402 for (i
= 0, flp
= fip
->fnfieldlists
; i
< fip
->nfnfields
; i
++, flp
++)
7404 struct nextfnfield
*nfp
= flp
->head
;
7405 struct fn_fieldlist
*fn_flp
= &TYPE_FN_FIELDLIST (type
, i
);
7408 TYPE_FN_FIELDLIST_NAME (type
, i
) = flp
->name
;
7409 TYPE_FN_FIELDLIST_LENGTH (type
, i
) = flp
->length
;
7410 fn_flp
->fn_fields
= (struct fn_field
*)
7411 TYPE_ALLOC (type
, sizeof (struct fn_field
) * flp
->length
);
7412 for (k
= flp
->length
; (k
--, nfp
); nfp
= nfp
->next
)
7413 fn_flp
->fn_fields
[k
] = nfp
->fnfield
;
7415 total_length
+= flp
->length
;
7418 TYPE_NFN_FIELDS (type
) = fip
->nfnfields
;
7419 TYPE_NFN_FIELDS_TOTAL (type
) = total_length
;
7422 /* Returns non-zero if NAME is the name of a vtable member in CU's
7423 language, zero otherwise. */
7425 is_vtable_name (const char *name
, struct dwarf2_cu
*cu
)
7427 static const char vptr
[] = "_vptr";
7428 static const char vtable
[] = "vtable";
7430 /* Look for the C++ and Java forms of the vtable. */
7431 if ((cu
->language
== language_java
7432 && strncmp (name
, vtable
, sizeof (vtable
) - 1) == 0)
7433 || (strncmp (name
, vptr
, sizeof (vptr
) - 1) == 0
7434 && is_cplus_marker (name
[sizeof (vptr
) - 1])))
7440 /* GCC outputs unnamed structures that are really pointers to member
7441 functions, with the ABI-specified layout. If TYPE describes
7442 such a structure, smash it into a member function type.
7444 GCC shouldn't do this; it should just output pointer to member DIEs.
7445 This is GCC PR debug/28767. */
7448 quirk_gcc_member_function_pointer (struct type
*type
, struct objfile
*objfile
)
7450 struct type
*pfn_type
, *domain_type
, *new_type
;
7452 /* Check for a structure with no name and two children. */
7453 if (TYPE_CODE (type
) != TYPE_CODE_STRUCT
|| TYPE_NFIELDS (type
) != 2)
7456 /* Check for __pfn and __delta members. */
7457 if (TYPE_FIELD_NAME (type
, 0) == NULL
7458 || strcmp (TYPE_FIELD_NAME (type
, 0), "__pfn") != 0
7459 || TYPE_FIELD_NAME (type
, 1) == NULL
7460 || strcmp (TYPE_FIELD_NAME (type
, 1), "__delta") != 0)
7463 /* Find the type of the method. */
7464 pfn_type
= TYPE_FIELD_TYPE (type
, 0);
7465 if (pfn_type
== NULL
7466 || TYPE_CODE (pfn_type
) != TYPE_CODE_PTR
7467 || TYPE_CODE (TYPE_TARGET_TYPE (pfn_type
)) != TYPE_CODE_FUNC
)
7470 /* Look for the "this" argument. */
7471 pfn_type
= TYPE_TARGET_TYPE (pfn_type
);
7472 if (TYPE_NFIELDS (pfn_type
) == 0
7473 /* || TYPE_FIELD_TYPE (pfn_type, 0) == NULL */
7474 || TYPE_CODE (TYPE_FIELD_TYPE (pfn_type
, 0)) != TYPE_CODE_PTR
)
7477 domain_type
= TYPE_TARGET_TYPE (TYPE_FIELD_TYPE (pfn_type
, 0));
7478 new_type
= alloc_type (objfile
);
7479 smash_to_method_type (new_type
, domain_type
, TYPE_TARGET_TYPE (pfn_type
),
7480 TYPE_FIELDS (pfn_type
), TYPE_NFIELDS (pfn_type
),
7481 TYPE_VARARGS (pfn_type
));
7482 smash_to_methodptr_type (type
, new_type
);
7485 /* Called when we find the DIE that starts a structure or union scope
7486 (definition) to create a type for the structure or union. Fill in
7487 the type's name and general properties; the members will not be
7488 processed until process_structure_type.
7490 NOTE: we need to call these functions regardless of whether or not the
7491 DIE has a DW_AT_name attribute, since it might be an anonymous
7492 structure or union. This gets the type entered into our set of
7495 However, if the structure is incomplete (an opaque struct/union)
7496 then suppress creating a symbol table entry for it since gdb only
7497 wants to find the one with the complete definition. Note that if
7498 it is complete, we just call new_symbol, which does it's own
7499 checking about whether the struct/union is anonymous or not (and
7500 suppresses creating a symbol table entry itself). */
7502 static struct type
*
7503 read_structure_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
7505 struct objfile
*objfile
= cu
->objfile
;
7507 struct attribute
*attr
;
7510 /* If the definition of this type lives in .debug_types, read that type.
7511 Don't follow DW_AT_specification though, that will take us back up
7512 the chain and we want to go down. */
7513 attr
= dwarf2_attr_no_follow (die
, DW_AT_signature
, cu
);
7516 struct dwarf2_cu
*type_cu
= cu
;
7517 struct die_info
*type_die
= follow_die_ref_or_sig (die
, attr
, &type_cu
);
7519 /* We could just recurse on read_structure_type, but we need to call
7520 get_die_type to ensure only one type for this DIE is created.
7521 This is important, for example, because for c++ classes we need
7522 TYPE_NAME set which is only done by new_symbol. Blech. */
7523 type
= read_type_die (type_die
, type_cu
);
7525 /* TYPE_CU may not be the same as CU.
7526 Ensure TYPE is recorded in CU's type_hash table. */
7527 return set_die_type (die
, type
, cu
);
7530 type
= alloc_type (objfile
);
7531 INIT_CPLUS_SPECIFIC (type
);
7533 name
= dwarf2_name (die
, cu
);
7536 if (cu
->language
== language_cplus
7537 || cu
->language
== language_java
)
7539 char *full_name
= (char *) dwarf2_full_name (name
, die
, cu
);
7541 /* dwarf2_full_name might have already finished building the DIE's
7542 type. If so, there is no need to continue. */
7543 if (get_die_type (die
, cu
) != NULL
)
7544 return get_die_type (die
, cu
);
7546 TYPE_TAG_NAME (type
) = full_name
;
7547 if (die
->tag
== DW_TAG_structure_type
7548 || die
->tag
== DW_TAG_class_type
)
7549 TYPE_NAME (type
) = TYPE_TAG_NAME (type
);
7553 /* The name is already allocated along with this objfile, so
7554 we don't need to duplicate it for the type. */
7555 TYPE_TAG_NAME (type
) = (char *) name
;
7556 if (die
->tag
== DW_TAG_class_type
)
7557 TYPE_NAME (type
) = TYPE_TAG_NAME (type
);
7561 if (die
->tag
== DW_TAG_structure_type
)
7563 TYPE_CODE (type
) = TYPE_CODE_STRUCT
;
7565 else if (die
->tag
== DW_TAG_union_type
)
7567 TYPE_CODE (type
) = TYPE_CODE_UNION
;
7571 TYPE_CODE (type
) = TYPE_CODE_CLASS
;
7574 if (cu
->language
== language_cplus
&& die
->tag
== DW_TAG_class_type
)
7575 TYPE_DECLARED_CLASS (type
) = 1;
7577 attr
= dwarf2_attr (die
, DW_AT_byte_size
, cu
);
7580 TYPE_LENGTH (type
) = DW_UNSND (attr
);
7584 TYPE_LENGTH (type
) = 0;
7587 TYPE_STUB_SUPPORTED (type
) = 1;
7588 if (die_is_declaration (die
, cu
))
7589 TYPE_STUB (type
) = 1;
7590 else if (attr
== NULL
&& die
->child
== NULL
7591 && producer_is_realview (cu
->producer
))
7592 /* RealView does not output the required DW_AT_declaration
7593 on incomplete types. */
7594 TYPE_STUB (type
) = 1;
7596 /* We need to add the type field to the die immediately so we don't
7597 infinitely recurse when dealing with pointers to the structure
7598 type within the structure itself. */
7599 set_die_type (die
, type
, cu
);
7601 /* set_die_type should be already done. */
7602 set_descriptive_type (type
, die
, cu
);
7607 /* Finish creating a structure or union type, including filling in
7608 its members and creating a symbol for it. */
7611 process_structure_scope (struct die_info
*die
, struct dwarf2_cu
*cu
)
7613 struct objfile
*objfile
= cu
->objfile
;
7614 struct die_info
*child_die
= die
->child
;
7617 type
= get_die_type (die
, cu
);
7619 type
= read_structure_type (die
, cu
);
7621 if (die
->child
!= NULL
&& ! die_is_declaration (die
, cu
))
7623 struct field_info fi
;
7624 struct die_info
*child_die
;
7625 VEC (symbolp
) *template_args
= NULL
;
7626 struct cleanup
*back_to
= make_cleanup (null_cleanup
, 0);
7628 memset (&fi
, 0, sizeof (struct field_info
));
7630 child_die
= die
->child
;
7632 while (child_die
&& child_die
->tag
)
7634 if (child_die
->tag
== DW_TAG_member
7635 || child_die
->tag
== DW_TAG_variable
)
7637 /* NOTE: carlton/2002-11-05: A C++ static data member
7638 should be a DW_TAG_member that is a declaration, but
7639 all versions of G++ as of this writing (so through at
7640 least 3.2.1) incorrectly generate DW_TAG_variable
7641 tags for them instead. */
7642 dwarf2_add_field (&fi
, child_die
, cu
);
7644 else if (child_die
->tag
== DW_TAG_subprogram
)
7646 /* C++ member function. */
7647 dwarf2_add_member_fn (&fi
, child_die
, type
, cu
);
7649 else if (child_die
->tag
== DW_TAG_inheritance
)
7651 /* C++ base class field. */
7652 dwarf2_add_field (&fi
, child_die
, cu
);
7654 else if (child_die
->tag
== DW_TAG_typedef
)
7655 dwarf2_add_typedef (&fi
, child_die
, cu
);
7656 else if (child_die
->tag
== DW_TAG_template_type_param
7657 || child_die
->tag
== DW_TAG_template_value_param
)
7659 struct symbol
*arg
= new_symbol (child_die
, NULL
, cu
);
7662 VEC_safe_push (symbolp
, template_args
, arg
);
7665 child_die
= sibling_die (child_die
);
7668 /* Attach template arguments to type. */
7669 if (! VEC_empty (symbolp
, template_args
))
7671 ALLOCATE_CPLUS_STRUCT_TYPE (type
);
7672 TYPE_N_TEMPLATE_ARGUMENTS (type
)
7673 = VEC_length (symbolp
, template_args
);
7674 TYPE_TEMPLATE_ARGUMENTS (type
)
7675 = obstack_alloc (&objfile
->objfile_obstack
,
7676 (TYPE_N_TEMPLATE_ARGUMENTS (type
)
7677 * sizeof (struct symbol
*)));
7678 memcpy (TYPE_TEMPLATE_ARGUMENTS (type
),
7679 VEC_address (symbolp
, template_args
),
7680 (TYPE_N_TEMPLATE_ARGUMENTS (type
)
7681 * sizeof (struct symbol
*)));
7682 VEC_free (symbolp
, template_args
);
7685 /* Attach fields and member functions to the type. */
7687 dwarf2_attach_fields_to_type (&fi
, type
, cu
);
7690 dwarf2_attach_fn_fields_to_type (&fi
, type
, cu
);
7692 /* Get the type which refers to the base class (possibly this
7693 class itself) which contains the vtable pointer for the current
7694 class from the DW_AT_containing_type attribute. This use of
7695 DW_AT_containing_type is a GNU extension. */
7697 if (dwarf2_attr (die
, DW_AT_containing_type
, cu
) != NULL
)
7699 struct type
*t
= die_containing_type (die
, cu
);
7701 TYPE_VPTR_BASETYPE (type
) = t
;
7706 /* Our own class provides vtbl ptr. */
7707 for (i
= TYPE_NFIELDS (t
) - 1;
7708 i
>= TYPE_N_BASECLASSES (t
);
7711 char *fieldname
= TYPE_FIELD_NAME (t
, i
);
7713 if (is_vtable_name (fieldname
, cu
))
7715 TYPE_VPTR_FIELDNO (type
) = i
;
7720 /* Complain if virtual function table field not found. */
7721 if (i
< TYPE_N_BASECLASSES (t
))
7722 complaint (&symfile_complaints
,
7723 _("virtual function table pointer "
7724 "not found when defining class '%s'"),
7725 TYPE_TAG_NAME (type
) ? TYPE_TAG_NAME (type
) :
7730 TYPE_VPTR_FIELDNO (type
) = TYPE_VPTR_FIELDNO (t
);
7733 else if (cu
->producer
7734 && strncmp (cu
->producer
,
7735 "IBM(R) XL C/C++ Advanced Edition", 32) == 0)
7737 /* The IBM XLC compiler does not provide direct indication
7738 of the containing type, but the vtable pointer is
7739 always named __vfp. */
7743 for (i
= TYPE_NFIELDS (type
) - 1;
7744 i
>= TYPE_N_BASECLASSES (type
);
7747 if (strcmp (TYPE_FIELD_NAME (type
, i
), "__vfp") == 0)
7749 TYPE_VPTR_FIELDNO (type
) = i
;
7750 TYPE_VPTR_BASETYPE (type
) = type
;
7757 /* Copy fi.typedef_field_list linked list elements content into the
7758 allocated array TYPE_TYPEDEF_FIELD_ARRAY (type). */
7759 if (fi
.typedef_field_list
)
7761 int i
= fi
.typedef_field_list_count
;
7763 ALLOCATE_CPLUS_STRUCT_TYPE (type
);
7764 TYPE_TYPEDEF_FIELD_ARRAY (type
)
7765 = TYPE_ALLOC (type
, sizeof (TYPE_TYPEDEF_FIELD (type
, 0)) * i
);
7766 TYPE_TYPEDEF_FIELD_COUNT (type
) = i
;
7768 /* Reverse the list order to keep the debug info elements order. */
7771 struct typedef_field
*dest
, *src
;
7773 dest
= &TYPE_TYPEDEF_FIELD (type
, i
);
7774 src
= &fi
.typedef_field_list
->field
;
7775 fi
.typedef_field_list
= fi
.typedef_field_list
->next
;
7780 do_cleanups (back_to
);
7782 if (HAVE_CPLUS_STRUCT (type
))
7783 TYPE_CPLUS_REALLY_JAVA (type
) = cu
->language
== language_java
;
7786 quirk_gcc_member_function_pointer (type
, cu
->objfile
);
7788 /* NOTE: carlton/2004-03-16: GCC 3.4 (or at least one of its
7789 snapshots) has been known to create a die giving a declaration
7790 for a class that has, as a child, a die giving a definition for a
7791 nested class. So we have to process our children even if the
7792 current die is a declaration. Normally, of course, a declaration
7793 won't have any children at all. */
7795 while (child_die
!= NULL
&& child_die
->tag
)
7797 if (child_die
->tag
== DW_TAG_member
7798 || child_die
->tag
== DW_TAG_variable
7799 || child_die
->tag
== DW_TAG_inheritance
7800 || child_die
->tag
== DW_TAG_template_value_param
7801 || child_die
->tag
== DW_TAG_template_type_param
)
7806 process_die (child_die
, cu
);
7808 child_die
= sibling_die (child_die
);
7811 /* Do not consider external references. According to the DWARF standard,
7812 these DIEs are identified by the fact that they have no byte_size
7813 attribute, and a declaration attribute. */
7814 if (dwarf2_attr (die
, DW_AT_byte_size
, cu
) != NULL
7815 || !die_is_declaration (die
, cu
))
7816 new_symbol (die
, type
, cu
);
7819 /* Given a DW_AT_enumeration_type die, set its type. We do not
7820 complete the type's fields yet, or create any symbols. */
7822 static struct type
*
7823 read_enumeration_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
7825 struct objfile
*objfile
= cu
->objfile
;
7827 struct attribute
*attr
;
7830 /* If the definition of this type lives in .debug_types, read that type.
7831 Don't follow DW_AT_specification though, that will take us back up
7832 the chain and we want to go down. */
7833 attr
= dwarf2_attr_no_follow (die
, DW_AT_signature
, cu
);
7836 struct dwarf2_cu
*type_cu
= cu
;
7837 struct die_info
*type_die
= follow_die_ref_or_sig (die
, attr
, &type_cu
);
7839 type
= read_type_die (type_die
, type_cu
);
7841 /* TYPE_CU may not be the same as CU.
7842 Ensure TYPE is recorded in CU's type_hash table. */
7843 return set_die_type (die
, type
, cu
);
7846 type
= alloc_type (objfile
);
7848 TYPE_CODE (type
) = TYPE_CODE_ENUM
;
7849 name
= dwarf2_full_name (NULL
, die
, cu
);
7851 TYPE_TAG_NAME (type
) = (char *) name
;
7853 attr
= dwarf2_attr (die
, DW_AT_byte_size
, cu
);
7856 TYPE_LENGTH (type
) = DW_UNSND (attr
);
7860 TYPE_LENGTH (type
) = 0;
7863 /* The enumeration DIE can be incomplete. In Ada, any type can be
7864 declared as private in the package spec, and then defined only
7865 inside the package body. Such types are known as Taft Amendment
7866 Types. When another package uses such a type, an incomplete DIE
7867 may be generated by the compiler. */
7868 if (die_is_declaration (die
, cu
))
7869 TYPE_STUB (type
) = 1;
7871 return set_die_type (die
, type
, cu
);
7874 /* Given a pointer to a die which begins an enumeration, process all
7875 the dies that define the members of the enumeration, and create the
7876 symbol for the enumeration type.
7878 NOTE: We reverse the order of the element list. */
7881 process_enumeration_scope (struct die_info
*die
, struct dwarf2_cu
*cu
)
7883 struct type
*this_type
;
7885 this_type
= get_die_type (die
, cu
);
7886 if (this_type
== NULL
)
7887 this_type
= read_enumeration_type (die
, cu
);
7889 if (die
->child
!= NULL
)
7891 struct die_info
*child_die
;
7893 struct field
*fields
= NULL
;
7895 int unsigned_enum
= 1;
7898 child_die
= die
->child
;
7899 while (child_die
&& child_die
->tag
)
7901 if (child_die
->tag
!= DW_TAG_enumerator
)
7903 process_die (child_die
, cu
);
7907 name
= dwarf2_name (child_die
, cu
);
7910 sym
= new_symbol (child_die
, this_type
, cu
);
7911 if (SYMBOL_VALUE (sym
) < 0)
7914 if ((num_fields
% DW_FIELD_ALLOC_CHUNK
) == 0)
7916 fields
= (struct field
*)
7918 (num_fields
+ DW_FIELD_ALLOC_CHUNK
)
7919 * sizeof (struct field
));
7922 FIELD_NAME (fields
[num_fields
]) = SYMBOL_LINKAGE_NAME (sym
);
7923 FIELD_TYPE (fields
[num_fields
]) = NULL
;
7924 SET_FIELD_BITPOS (fields
[num_fields
], SYMBOL_VALUE (sym
));
7925 FIELD_BITSIZE (fields
[num_fields
]) = 0;
7931 child_die
= sibling_die (child_die
);
7936 TYPE_NFIELDS (this_type
) = num_fields
;
7937 TYPE_FIELDS (this_type
) = (struct field
*)
7938 TYPE_ALLOC (this_type
, sizeof (struct field
) * num_fields
);
7939 memcpy (TYPE_FIELDS (this_type
), fields
,
7940 sizeof (struct field
) * num_fields
);
7944 TYPE_UNSIGNED (this_type
) = 1;
7947 /* If we are reading an enum from a .debug_types unit, and the enum
7948 is a declaration, and the enum is not the signatured type in the
7949 unit, then we do not want to add a symbol for it. Adding a
7950 symbol would in some cases obscure the true definition of the
7951 enum, giving users an incomplete type when the definition is
7952 actually available. Note that we do not want to do this for all
7953 enums which are just declarations, because C++0x allows forward
7954 enum declarations. */
7955 if (cu
->per_cu
->debug_type_section
7956 && die_is_declaration (die
, cu
))
7958 struct signatured_type
*type_sig
;
7961 = lookup_signatured_type_at_offset (dwarf2_per_objfile
->objfile
,
7962 cu
->per_cu
->debug_type_section
,
7963 cu
->per_cu
->offset
);
7964 if (type_sig
->type_offset
!= die
->offset
)
7968 new_symbol (die
, this_type
, cu
);
7971 /* Extract all information from a DW_TAG_array_type DIE and put it in
7972 the DIE's type field. For now, this only handles one dimensional
7975 static struct type
*
7976 read_array_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
7978 struct objfile
*objfile
= cu
->objfile
;
7979 struct die_info
*child_die
;
7981 struct type
*element_type
, *range_type
, *index_type
;
7982 struct type
**range_types
= NULL
;
7983 struct attribute
*attr
;
7985 struct cleanup
*back_to
;
7988 element_type
= die_type (die
, cu
);
7990 /* The die_type call above may have already set the type for this DIE. */
7991 type
= get_die_type (die
, cu
);
7995 /* Irix 6.2 native cc creates array types without children for
7996 arrays with unspecified length. */
7997 if (die
->child
== NULL
)
7999 index_type
= objfile_type (objfile
)->builtin_int
;
8000 range_type
= create_range_type (NULL
, index_type
, 0, -1);
8001 type
= create_array_type (NULL
, element_type
, range_type
);
8002 return set_die_type (die
, type
, cu
);
8005 back_to
= make_cleanup (null_cleanup
, NULL
);
8006 child_die
= die
->child
;
8007 while (child_die
&& child_die
->tag
)
8009 if (child_die
->tag
== DW_TAG_subrange_type
)
8011 struct type
*child_type
= read_type_die (child_die
, cu
);
8013 if (child_type
!= NULL
)
8015 /* The range type was succesfully read. Save it for the
8016 array type creation. */
8017 if ((ndim
% DW_FIELD_ALLOC_CHUNK
) == 0)
8019 range_types
= (struct type
**)
8020 xrealloc (range_types
, (ndim
+ DW_FIELD_ALLOC_CHUNK
)
8021 * sizeof (struct type
*));
8023 make_cleanup (free_current_contents
, &range_types
);
8025 range_types
[ndim
++] = child_type
;
8028 child_die
= sibling_die (child_die
);
8031 /* Dwarf2 dimensions are output from left to right, create the
8032 necessary array types in backwards order. */
8034 type
= element_type
;
8036 if (read_array_order (die
, cu
) == DW_ORD_col_major
)
8041 type
= create_array_type (NULL
, type
, range_types
[i
++]);
8046 type
= create_array_type (NULL
, type
, range_types
[ndim
]);
8049 /* Understand Dwarf2 support for vector types (like they occur on
8050 the PowerPC w/ AltiVec). Gcc just adds another attribute to the
8051 array type. This is not part of the Dwarf2/3 standard yet, but a
8052 custom vendor extension. The main difference between a regular
8053 array and the vector variant is that vectors are passed by value
8055 attr
= dwarf2_attr (die
, DW_AT_GNU_vector
, cu
);
8057 make_vector_type (type
);
8059 /* The DIE may have DW_AT_byte_size set. For example an OpenCL
8060 implementation may choose to implement triple vectors using this
8062 attr
= dwarf2_attr (die
, DW_AT_byte_size
, cu
);
8065 if (DW_UNSND (attr
) >= TYPE_LENGTH (type
))
8066 TYPE_LENGTH (type
) = DW_UNSND (attr
);
8068 complaint (&symfile_complaints
,
8069 _("DW_AT_byte_size for array type smaller "
8070 "than the total size of elements"));
8073 name
= dwarf2_name (die
, cu
);
8075 TYPE_NAME (type
) = name
;
8077 /* Install the type in the die. */
8078 set_die_type (die
, type
, cu
);
8080 /* set_die_type should be already done. */
8081 set_descriptive_type (type
, die
, cu
);
8083 do_cleanups (back_to
);
8088 static enum dwarf_array_dim_ordering
8089 read_array_order (struct die_info
*die
, struct dwarf2_cu
*cu
)
8091 struct attribute
*attr
;
8093 attr
= dwarf2_attr (die
, DW_AT_ordering
, cu
);
8095 if (attr
) return DW_SND (attr
);
8097 /* GNU F77 is a special case, as at 08/2004 array type info is the
8098 opposite order to the dwarf2 specification, but data is still
8099 laid out as per normal fortran.
8101 FIXME: dsl/2004-8-20: If G77 is ever fixed, this will also need
8102 version checking. */
8104 if (cu
->language
== language_fortran
8105 && cu
->producer
&& strstr (cu
->producer
, "GNU F77"))
8107 return DW_ORD_row_major
;
8110 switch (cu
->language_defn
->la_array_ordering
)
8112 case array_column_major
:
8113 return DW_ORD_col_major
;
8114 case array_row_major
:
8116 return DW_ORD_row_major
;
8120 /* Extract all information from a DW_TAG_set_type DIE and put it in
8121 the DIE's type field. */
8123 static struct type
*
8124 read_set_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
8126 struct type
*domain_type
, *set_type
;
8127 struct attribute
*attr
;
8129 domain_type
= die_type (die
, cu
);
8131 /* The die_type call above may have already set the type for this DIE. */
8132 set_type
= get_die_type (die
, cu
);
8136 set_type
= create_set_type (NULL
, domain_type
);
8138 attr
= dwarf2_attr (die
, DW_AT_byte_size
, cu
);
8140 TYPE_LENGTH (set_type
) = DW_UNSND (attr
);
8142 return set_die_type (die
, set_type
, cu
);
8145 /* First cut: install each common block member as a global variable. */
8148 read_common_block (struct die_info
*die
, struct dwarf2_cu
*cu
)
8150 struct die_info
*child_die
;
8151 struct attribute
*attr
;
8153 CORE_ADDR base
= (CORE_ADDR
) 0;
8155 attr
= dwarf2_attr (die
, DW_AT_location
, cu
);
8158 /* Support the .debug_loc offsets. */
8159 if (attr_form_is_block (attr
))
8161 base
= decode_locdesc (DW_BLOCK (attr
), cu
);
8163 else if (attr_form_is_section_offset (attr
))
8165 dwarf2_complex_location_expr_complaint ();
8169 dwarf2_invalid_attrib_class_complaint ("DW_AT_location",
8170 "common block member");
8173 if (die
->child
!= NULL
)
8175 child_die
= die
->child
;
8176 while (child_die
&& child_die
->tag
)
8180 sym
= new_symbol (child_die
, NULL
, cu
);
8182 && handle_data_member_location (child_die
, cu
, &offset
))
8184 SYMBOL_VALUE_ADDRESS (sym
) = base
+ offset
;
8185 add_symbol_to_list (sym
, &global_symbols
);
8187 child_die
= sibling_die (child_die
);
8192 /* Create a type for a C++ namespace. */
8194 static struct type
*
8195 read_namespace_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
8197 struct objfile
*objfile
= cu
->objfile
;
8198 const char *previous_prefix
, *name
;
8202 /* For extensions, reuse the type of the original namespace. */
8203 if (dwarf2_attr (die
, DW_AT_extension
, cu
) != NULL
)
8205 struct die_info
*ext_die
;
8206 struct dwarf2_cu
*ext_cu
= cu
;
8208 ext_die
= dwarf2_extension (die
, &ext_cu
);
8209 type
= read_type_die (ext_die
, ext_cu
);
8211 /* EXT_CU may not be the same as CU.
8212 Ensure TYPE is recorded in CU's type_hash table. */
8213 return set_die_type (die
, type
, cu
);
8216 name
= namespace_name (die
, &is_anonymous
, cu
);
8218 /* Now build the name of the current namespace. */
8220 previous_prefix
= determine_prefix (die
, cu
);
8221 if (previous_prefix
[0] != '\0')
8222 name
= typename_concat (&objfile
->objfile_obstack
,
8223 previous_prefix
, name
, 0, cu
);
8225 /* Create the type. */
8226 type
= init_type (TYPE_CODE_NAMESPACE
, 0, 0, NULL
,
8228 TYPE_NAME (type
) = (char *) name
;
8229 TYPE_TAG_NAME (type
) = TYPE_NAME (type
);
8231 return set_die_type (die
, type
, cu
);
8234 /* Read a C++ namespace. */
8237 read_namespace (struct die_info
*die
, struct dwarf2_cu
*cu
)
8239 struct objfile
*objfile
= cu
->objfile
;
8242 /* Add a symbol associated to this if we haven't seen the namespace
8243 before. Also, add a using directive if it's an anonymous
8246 if (dwarf2_attr (die
, DW_AT_extension
, cu
) == NULL
)
8250 type
= read_type_die (die
, cu
);
8251 new_symbol (die
, type
, cu
);
8253 namespace_name (die
, &is_anonymous
, cu
);
8256 const char *previous_prefix
= determine_prefix (die
, cu
);
8258 cp_add_using_directive (previous_prefix
, TYPE_NAME (type
), NULL
,
8259 NULL
, NULL
, &objfile
->objfile_obstack
);
8263 if (die
->child
!= NULL
)
8265 struct die_info
*child_die
= die
->child
;
8267 while (child_die
&& child_die
->tag
)
8269 process_die (child_die
, cu
);
8270 child_die
= sibling_die (child_die
);
8275 /* Read a Fortran module as type. This DIE can be only a declaration used for
8276 imported module. Still we need that type as local Fortran "use ... only"
8277 declaration imports depend on the created type in determine_prefix. */
8279 static struct type
*
8280 read_module_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
8282 struct objfile
*objfile
= cu
->objfile
;
8286 module_name
= dwarf2_name (die
, cu
);
8288 complaint (&symfile_complaints
,
8289 _("DW_TAG_module has no name, offset 0x%x"),
8291 type
= init_type (TYPE_CODE_MODULE
, 0, 0, module_name
, objfile
);
8293 /* determine_prefix uses TYPE_TAG_NAME. */
8294 TYPE_TAG_NAME (type
) = TYPE_NAME (type
);
8296 return set_die_type (die
, type
, cu
);
8299 /* Read a Fortran module. */
8302 read_module (struct die_info
*die
, struct dwarf2_cu
*cu
)
8304 struct die_info
*child_die
= die
->child
;
8306 while (child_die
&& child_die
->tag
)
8308 process_die (child_die
, cu
);
8309 child_die
= sibling_die (child_die
);
8313 /* Return the name of the namespace represented by DIE. Set
8314 *IS_ANONYMOUS to tell whether or not the namespace is an anonymous
8318 namespace_name (struct die_info
*die
, int *is_anonymous
, struct dwarf2_cu
*cu
)
8320 struct die_info
*current_die
;
8321 const char *name
= NULL
;
8323 /* Loop through the extensions until we find a name. */
8325 for (current_die
= die
;
8326 current_die
!= NULL
;
8327 current_die
= dwarf2_extension (die
, &cu
))
8329 name
= dwarf2_name (current_die
, cu
);
8334 /* Is it an anonymous namespace? */
8336 *is_anonymous
= (name
== NULL
);
8338 name
= CP_ANONYMOUS_NAMESPACE_STR
;
8343 /* Extract all information from a DW_TAG_pointer_type DIE and add to
8344 the user defined type vector. */
8346 static struct type
*
8347 read_tag_pointer_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
8349 struct gdbarch
*gdbarch
= get_objfile_arch (cu
->objfile
);
8350 struct comp_unit_head
*cu_header
= &cu
->header
;
8352 struct attribute
*attr_byte_size
;
8353 struct attribute
*attr_address_class
;
8354 int byte_size
, addr_class
;
8355 struct type
*target_type
;
8357 target_type
= die_type (die
, cu
);
8359 /* The die_type call above may have already set the type for this DIE. */
8360 type
= get_die_type (die
, cu
);
8364 type
= lookup_pointer_type (target_type
);
8366 attr_byte_size
= dwarf2_attr (die
, DW_AT_byte_size
, cu
);
8368 byte_size
= DW_UNSND (attr_byte_size
);
8370 byte_size
= cu_header
->addr_size
;
8372 attr_address_class
= dwarf2_attr (die
, DW_AT_address_class
, cu
);
8373 if (attr_address_class
)
8374 addr_class
= DW_UNSND (attr_address_class
);
8376 addr_class
= DW_ADDR_none
;
8378 /* If the pointer size or address class is different than the
8379 default, create a type variant marked as such and set the
8380 length accordingly. */
8381 if (TYPE_LENGTH (type
) != byte_size
|| addr_class
!= DW_ADDR_none
)
8383 if (gdbarch_address_class_type_flags_p (gdbarch
))
8387 type_flags
= gdbarch_address_class_type_flags
8388 (gdbarch
, byte_size
, addr_class
);
8389 gdb_assert ((type_flags
& ~TYPE_INSTANCE_FLAG_ADDRESS_CLASS_ALL
)
8391 type
= make_type_with_address_space (type
, type_flags
);
8393 else if (TYPE_LENGTH (type
) != byte_size
)
8395 complaint (&symfile_complaints
,
8396 _("invalid pointer size %d"), byte_size
);
8400 /* Should we also complain about unhandled address classes? */
8404 TYPE_LENGTH (type
) = byte_size
;
8405 return set_die_type (die
, type
, cu
);
8408 /* Extract all information from a DW_TAG_ptr_to_member_type DIE and add to
8409 the user defined type vector. */
8411 static struct type
*
8412 read_tag_ptr_to_member_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
8415 struct type
*to_type
;
8416 struct type
*domain
;
8418 to_type
= die_type (die
, cu
);
8419 domain
= die_containing_type (die
, cu
);
8421 /* The calls above may have already set the type for this DIE. */
8422 type
= get_die_type (die
, cu
);
8426 if (TYPE_CODE (check_typedef (to_type
)) == TYPE_CODE_METHOD
)
8427 type
= lookup_methodptr_type (to_type
);
8429 type
= lookup_memberptr_type (to_type
, domain
);
8431 return set_die_type (die
, type
, cu
);
8434 /* Extract all information from a DW_TAG_reference_type DIE and add to
8435 the user defined type vector. */
8437 static struct type
*
8438 read_tag_reference_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
8440 struct comp_unit_head
*cu_header
= &cu
->header
;
8441 struct type
*type
, *target_type
;
8442 struct attribute
*attr
;
8444 target_type
= die_type (die
, cu
);
8446 /* The die_type call above may have already set the type for this DIE. */
8447 type
= get_die_type (die
, cu
);
8451 type
= lookup_reference_type (target_type
);
8452 attr
= dwarf2_attr (die
, DW_AT_byte_size
, cu
);
8455 TYPE_LENGTH (type
) = DW_UNSND (attr
);
8459 TYPE_LENGTH (type
) = cu_header
->addr_size
;
8461 return set_die_type (die
, type
, cu
);
8464 static struct type
*
8465 read_tag_const_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
8467 struct type
*base_type
, *cv_type
;
8469 base_type
= die_type (die
, cu
);
8471 /* The die_type call above may have already set the type for this DIE. */
8472 cv_type
= get_die_type (die
, cu
);
8476 /* In case the const qualifier is applied to an array type, the element type
8477 is so qualified, not the array type (section 6.7.3 of C99). */
8478 if (TYPE_CODE (base_type
) == TYPE_CODE_ARRAY
)
8480 struct type
*el_type
, *inner_array
;
8482 base_type
= copy_type (base_type
);
8483 inner_array
= base_type
;
8485 while (TYPE_CODE (TYPE_TARGET_TYPE (inner_array
)) == TYPE_CODE_ARRAY
)
8487 TYPE_TARGET_TYPE (inner_array
) =
8488 copy_type (TYPE_TARGET_TYPE (inner_array
));
8489 inner_array
= TYPE_TARGET_TYPE (inner_array
);
8492 el_type
= TYPE_TARGET_TYPE (inner_array
);
8493 TYPE_TARGET_TYPE (inner_array
) =
8494 make_cv_type (1, TYPE_VOLATILE (el_type
), el_type
, NULL
);
8496 return set_die_type (die
, base_type
, cu
);
8499 cv_type
= make_cv_type (1, TYPE_VOLATILE (base_type
), base_type
, 0);
8500 return set_die_type (die
, cv_type
, cu
);
8503 static struct type
*
8504 read_tag_volatile_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
8506 struct type
*base_type
, *cv_type
;
8508 base_type
= die_type (die
, cu
);
8510 /* The die_type call above may have already set the type for this DIE. */
8511 cv_type
= get_die_type (die
, cu
);
8515 cv_type
= make_cv_type (TYPE_CONST (base_type
), 1, base_type
, 0);
8516 return set_die_type (die
, cv_type
, cu
);
8519 /* Extract all information from a DW_TAG_string_type DIE and add to
8520 the user defined type vector. It isn't really a user defined type,
8521 but it behaves like one, with other DIE's using an AT_user_def_type
8522 attribute to reference it. */
8524 static struct type
*
8525 read_tag_string_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
8527 struct objfile
*objfile
= cu
->objfile
;
8528 struct gdbarch
*gdbarch
= get_objfile_arch (objfile
);
8529 struct type
*type
, *range_type
, *index_type
, *char_type
;
8530 struct attribute
*attr
;
8531 unsigned int length
;
8533 attr
= dwarf2_attr (die
, DW_AT_string_length
, cu
);
8536 length
= DW_UNSND (attr
);
8540 /* Check for the DW_AT_byte_size attribute. */
8541 attr
= dwarf2_attr (die
, DW_AT_byte_size
, cu
);
8544 length
= DW_UNSND (attr
);
8552 index_type
= objfile_type (objfile
)->builtin_int
;
8553 range_type
= create_range_type (NULL
, index_type
, 1, length
);
8554 char_type
= language_string_char_type (cu
->language_defn
, gdbarch
);
8555 type
= create_string_type (NULL
, char_type
, range_type
);
8557 return set_die_type (die
, type
, cu
);
8560 /* Handle DIES due to C code like:
8564 int (*funcp)(int a, long l);
8568 ('funcp' generates a DW_TAG_subroutine_type DIE). */
8570 static struct type
*
8571 read_subroutine_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
8573 struct type
*type
; /* Type that this function returns. */
8574 struct type
*ftype
; /* Function that returns above type. */
8575 struct attribute
*attr
;
8577 type
= die_type (die
, cu
);
8579 /* The die_type call above may have already set the type for this DIE. */
8580 ftype
= get_die_type (die
, cu
);
8584 ftype
= lookup_function_type (type
);
8586 /* All functions in C++, Pascal and Java have prototypes. */
8587 attr
= dwarf2_attr (die
, DW_AT_prototyped
, cu
);
8588 if ((attr
&& (DW_UNSND (attr
) != 0))
8589 || cu
->language
== language_cplus
8590 || cu
->language
== language_java
8591 || cu
->language
== language_pascal
)
8592 TYPE_PROTOTYPED (ftype
) = 1;
8593 else if (producer_is_realview (cu
->producer
))
8594 /* RealView does not emit DW_AT_prototyped. We can not
8595 distinguish prototyped and unprototyped functions; default to
8596 prototyped, since that is more common in modern code (and
8597 RealView warns about unprototyped functions). */
8598 TYPE_PROTOTYPED (ftype
) = 1;
8600 /* Store the calling convention in the type if it's available in
8601 the subroutine die. Otherwise set the calling convention to
8602 the default value DW_CC_normal. */
8603 attr
= dwarf2_attr (die
, DW_AT_calling_convention
, cu
);
8605 TYPE_CALLING_CONVENTION (ftype
) = DW_UNSND (attr
);
8606 else if (cu
->producer
&& strstr (cu
->producer
, "IBM XL C for OpenCL"))
8607 TYPE_CALLING_CONVENTION (ftype
) = DW_CC_GDB_IBM_OpenCL
;
8609 TYPE_CALLING_CONVENTION (ftype
) = DW_CC_normal
;
8611 /* We need to add the subroutine type to the die immediately so
8612 we don't infinitely recurse when dealing with parameters
8613 declared as the same subroutine type. */
8614 set_die_type (die
, ftype
, cu
);
8616 if (die
->child
!= NULL
)
8618 struct type
*void_type
= objfile_type (cu
->objfile
)->builtin_void
;
8619 struct die_info
*child_die
;
8620 int nparams
, iparams
;
8622 /* Count the number of parameters.
8623 FIXME: GDB currently ignores vararg functions, but knows about
8624 vararg member functions. */
8626 child_die
= die
->child
;
8627 while (child_die
&& child_die
->tag
)
8629 if (child_die
->tag
== DW_TAG_formal_parameter
)
8631 else if (child_die
->tag
== DW_TAG_unspecified_parameters
)
8632 TYPE_VARARGS (ftype
) = 1;
8633 child_die
= sibling_die (child_die
);
8636 /* Allocate storage for parameters and fill them in. */
8637 TYPE_NFIELDS (ftype
) = nparams
;
8638 TYPE_FIELDS (ftype
) = (struct field
*)
8639 TYPE_ZALLOC (ftype
, nparams
* sizeof (struct field
));
8641 /* TYPE_FIELD_TYPE must never be NULL. Pre-fill the array to ensure it
8642 even if we error out during the parameters reading below. */
8643 for (iparams
= 0; iparams
< nparams
; iparams
++)
8644 TYPE_FIELD_TYPE (ftype
, iparams
) = void_type
;
8647 child_die
= die
->child
;
8648 while (child_die
&& child_die
->tag
)
8650 if (child_die
->tag
== DW_TAG_formal_parameter
)
8652 struct type
*arg_type
;
8654 /* DWARF version 2 has no clean way to discern C++
8655 static and non-static member functions. G++ helps
8656 GDB by marking the first parameter for non-static
8657 member functions (which is the this pointer) as
8658 artificial. We pass this information to
8659 dwarf2_add_member_fn via TYPE_FIELD_ARTIFICIAL.
8661 DWARF version 3 added DW_AT_object_pointer, which GCC
8662 4.5 does not yet generate. */
8663 attr
= dwarf2_attr (child_die
, DW_AT_artificial
, cu
);
8665 TYPE_FIELD_ARTIFICIAL (ftype
, iparams
) = DW_UNSND (attr
);
8668 TYPE_FIELD_ARTIFICIAL (ftype
, iparams
) = 0;
8670 /* GCC/43521: In java, the formal parameter
8671 "this" is sometimes not marked with DW_AT_artificial. */
8672 if (cu
->language
== language_java
)
8674 const char *name
= dwarf2_name (child_die
, cu
);
8676 if (name
&& !strcmp (name
, "this"))
8677 TYPE_FIELD_ARTIFICIAL (ftype
, iparams
) = 1;
8680 arg_type
= die_type (child_die
, cu
);
8682 /* RealView does not mark THIS as const, which the testsuite
8683 expects. GCC marks THIS as const in method definitions,
8684 but not in the class specifications (GCC PR 43053). */
8685 if (cu
->language
== language_cplus
&& !TYPE_CONST (arg_type
)
8686 && TYPE_FIELD_ARTIFICIAL (ftype
, iparams
))
8689 struct dwarf2_cu
*arg_cu
= cu
;
8690 const char *name
= dwarf2_name (child_die
, cu
);
8692 attr
= dwarf2_attr (die
, DW_AT_object_pointer
, cu
);
8695 /* If the compiler emits this, use it. */
8696 if (follow_die_ref (die
, attr
, &arg_cu
) == child_die
)
8699 else if (name
&& strcmp (name
, "this") == 0)
8700 /* Function definitions will have the argument names. */
8702 else if (name
== NULL
&& iparams
== 0)
8703 /* Declarations may not have the names, so like
8704 elsewhere in GDB, assume an artificial first
8705 argument is "this". */
8709 arg_type
= make_cv_type (1, TYPE_VOLATILE (arg_type
),
8713 TYPE_FIELD_TYPE (ftype
, iparams
) = arg_type
;
8716 child_die
= sibling_die (child_die
);
8723 static struct type
*
8724 read_typedef (struct die_info
*die
, struct dwarf2_cu
*cu
)
8726 struct objfile
*objfile
= cu
->objfile
;
8727 const char *name
= NULL
;
8728 struct type
*this_type
;
8730 name
= dwarf2_full_name (NULL
, die
, cu
);
8731 this_type
= init_type (TYPE_CODE_TYPEDEF
, 0,
8732 TYPE_FLAG_TARGET_STUB
, NULL
, objfile
);
8733 TYPE_NAME (this_type
) = (char *) name
;
8734 set_die_type (die
, this_type
, cu
);
8735 TYPE_TARGET_TYPE (this_type
) = die_type (die
, cu
);
8739 /* Find a representation of a given base type and install
8740 it in the TYPE field of the die. */
8742 static struct type
*
8743 read_base_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
8745 struct objfile
*objfile
= cu
->objfile
;
8747 struct attribute
*attr
;
8748 int encoding
= 0, size
= 0;
8750 enum type_code code
= TYPE_CODE_INT
;
8752 struct type
*target_type
= NULL
;
8754 attr
= dwarf2_attr (die
, DW_AT_encoding
, cu
);
8757 encoding
= DW_UNSND (attr
);
8759 attr
= dwarf2_attr (die
, DW_AT_byte_size
, cu
);
8762 size
= DW_UNSND (attr
);
8764 name
= dwarf2_name (die
, cu
);
8767 complaint (&symfile_complaints
,
8768 _("DW_AT_name missing from DW_TAG_base_type"));
8773 case DW_ATE_address
:
8774 /* Turn DW_ATE_address into a void * pointer. */
8775 code
= TYPE_CODE_PTR
;
8776 type_flags
|= TYPE_FLAG_UNSIGNED
;
8777 target_type
= init_type (TYPE_CODE_VOID
, 1, 0, NULL
, objfile
);
8779 case DW_ATE_boolean
:
8780 code
= TYPE_CODE_BOOL
;
8781 type_flags
|= TYPE_FLAG_UNSIGNED
;
8783 case DW_ATE_complex_float
:
8784 code
= TYPE_CODE_COMPLEX
;
8785 target_type
= init_type (TYPE_CODE_FLT
, size
/ 2, 0, NULL
, objfile
);
8787 case DW_ATE_decimal_float
:
8788 code
= TYPE_CODE_DECFLOAT
;
8791 code
= TYPE_CODE_FLT
;
8795 case DW_ATE_unsigned
:
8796 type_flags
|= TYPE_FLAG_UNSIGNED
;
8797 if (cu
->language
== language_fortran
8799 && strncmp (name
, "character(", sizeof ("character(") - 1) == 0)
8800 code
= TYPE_CODE_CHAR
;
8802 case DW_ATE_signed_char
:
8803 if (cu
->language
== language_ada
|| cu
->language
== language_m2
8804 || cu
->language
== language_pascal
8805 || cu
->language
== language_fortran
)
8806 code
= TYPE_CODE_CHAR
;
8808 case DW_ATE_unsigned_char
:
8809 if (cu
->language
== language_ada
|| cu
->language
== language_m2
8810 || cu
->language
== language_pascal
8811 || cu
->language
== language_fortran
)
8812 code
= TYPE_CODE_CHAR
;
8813 type_flags
|= TYPE_FLAG_UNSIGNED
;
8816 /* We just treat this as an integer and then recognize the
8817 type by name elsewhere. */
8821 complaint (&symfile_complaints
, _("unsupported DW_AT_encoding: '%s'"),
8822 dwarf_type_encoding_name (encoding
));
8826 type
= init_type (code
, size
, type_flags
, NULL
, objfile
);
8827 TYPE_NAME (type
) = name
;
8828 TYPE_TARGET_TYPE (type
) = target_type
;
8830 if (name
&& strcmp (name
, "char") == 0)
8831 TYPE_NOSIGN (type
) = 1;
8833 return set_die_type (die
, type
, cu
);
8836 /* Read the given DW_AT_subrange DIE. */
8838 static struct type
*
8839 read_subrange_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
8841 struct type
*base_type
;
8842 struct type
*range_type
;
8843 struct attribute
*attr
;
8847 LONGEST negative_mask
;
8849 base_type
= die_type (die
, cu
);
8850 /* Preserve BASE_TYPE's original type, just set its LENGTH. */
8851 check_typedef (base_type
);
8853 /* The die_type call above may have already set the type for this DIE. */
8854 range_type
= get_die_type (die
, cu
);
8858 if (cu
->language
== language_fortran
)
8860 /* FORTRAN implies a lower bound of 1, if not given. */
8864 /* FIXME: For variable sized arrays either of these could be
8865 a variable rather than a constant value. We'll allow it,
8866 but we don't know how to handle it. */
8867 attr
= dwarf2_attr (die
, DW_AT_lower_bound
, cu
);
8869 low
= dwarf2_get_attr_constant_value (attr
, 0);
8871 attr
= dwarf2_attr (die
, DW_AT_upper_bound
, cu
);
8874 if (attr_form_is_block (attr
) || is_ref_attr (attr
))
8876 /* GCC encodes arrays with unspecified or dynamic length
8877 with a DW_FORM_block1 attribute or a reference attribute.
8878 FIXME: GDB does not yet know how to handle dynamic
8879 arrays properly, treat them as arrays with unspecified
8882 FIXME: jimb/2003-09-22: GDB does not really know
8883 how to handle arrays of unspecified length
8884 either; we just represent them as zero-length
8885 arrays. Choose an appropriate upper bound given
8886 the lower bound we've computed above. */
8890 high
= dwarf2_get_attr_constant_value (attr
, 1);
8894 attr
= dwarf2_attr (die
, DW_AT_count
, cu
);
8897 int count
= dwarf2_get_attr_constant_value (attr
, 1);
8898 high
= low
+ count
- 1;
8902 /* Unspecified array length. */
8907 /* Dwarf-2 specifications explicitly allows to create subrange types
8908 without specifying a base type.
8909 In that case, the base type must be set to the type of
8910 the lower bound, upper bound or count, in that order, if any of these
8911 three attributes references an object that has a type.
8912 If no base type is found, the Dwarf-2 specifications say that
8913 a signed integer type of size equal to the size of an address should
8915 For the following C code: `extern char gdb_int [];'
8916 GCC produces an empty range DIE.
8917 FIXME: muller/2010-05-28: Possible references to object for low bound,
8918 high bound or count are not yet handled by this code. */
8919 if (TYPE_CODE (base_type
) == TYPE_CODE_VOID
)
8921 struct objfile
*objfile
= cu
->objfile
;
8922 struct gdbarch
*gdbarch
= get_objfile_arch (objfile
);
8923 int addr_size
= gdbarch_addr_bit (gdbarch
) /8;
8924 struct type
*int_type
= objfile_type (objfile
)->builtin_int
;
8926 /* Test "int", "long int", and "long long int" objfile types,
8927 and select the first one having a size above or equal to the
8928 architecture address size. */
8929 if (int_type
&& TYPE_LENGTH (int_type
) >= addr_size
)
8930 base_type
= int_type
;
8933 int_type
= objfile_type (objfile
)->builtin_long
;
8934 if (int_type
&& TYPE_LENGTH (int_type
) >= addr_size
)
8935 base_type
= int_type
;
8938 int_type
= objfile_type (objfile
)->builtin_long_long
;
8939 if (int_type
&& TYPE_LENGTH (int_type
) >= addr_size
)
8940 base_type
= int_type
;
8946 (LONGEST
) -1 << (TYPE_LENGTH (base_type
) * TARGET_CHAR_BIT
- 1);
8947 if (!TYPE_UNSIGNED (base_type
) && (low
& negative_mask
))
8948 low
|= negative_mask
;
8949 if (!TYPE_UNSIGNED (base_type
) && (high
& negative_mask
))
8950 high
|= negative_mask
;
8952 range_type
= create_range_type (NULL
, base_type
, low
, high
);
8954 /* Mark arrays with dynamic length at least as an array of unspecified
8955 length. GDB could check the boundary but before it gets implemented at
8956 least allow accessing the array elements. */
8957 if (attr
&& attr_form_is_block (attr
))
8958 TYPE_HIGH_BOUND_UNDEFINED (range_type
) = 1;
8960 /* Ada expects an empty array on no boundary attributes. */
8961 if (attr
== NULL
&& cu
->language
!= language_ada
)
8962 TYPE_HIGH_BOUND_UNDEFINED (range_type
) = 1;
8964 name
= dwarf2_name (die
, cu
);
8966 TYPE_NAME (range_type
) = name
;
8968 attr
= dwarf2_attr (die
, DW_AT_byte_size
, cu
);
8970 TYPE_LENGTH (range_type
) = DW_UNSND (attr
);
8972 set_die_type (die
, range_type
, cu
);
8974 /* set_die_type should be already done. */
8975 set_descriptive_type (range_type
, die
, cu
);
8980 static struct type
*
8981 read_unspecified_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
8985 /* For now, we only support the C meaning of an unspecified type: void. */
8987 type
= init_type (TYPE_CODE_VOID
, 0, 0, NULL
, cu
->objfile
);
8988 TYPE_NAME (type
) = dwarf2_name (die
, cu
);
8990 return set_die_type (die
, type
, cu
);
8993 /* Trivial hash function for die_info: the hash value of a DIE
8994 is its offset in .debug_info for this objfile. */
8997 die_hash (const void *item
)
8999 const struct die_info
*die
= item
;
9004 /* Trivial comparison function for die_info structures: two DIEs
9005 are equal if they have the same offset. */
9008 die_eq (const void *item_lhs
, const void *item_rhs
)
9010 const struct die_info
*die_lhs
= item_lhs
;
9011 const struct die_info
*die_rhs
= item_rhs
;
9013 return die_lhs
->offset
== die_rhs
->offset
;
9016 /* Read a whole compilation unit into a linked list of dies. */
9018 static struct die_info
*
9019 read_comp_unit (gdb_byte
*info_ptr
, struct dwarf2_cu
*cu
)
9021 struct die_reader_specs reader_specs
;
9022 int read_abbrevs
= 0;
9023 struct cleanup
*back_to
= NULL
;
9024 struct die_info
*die
;
9026 if (cu
->dwarf2_abbrevs
== NULL
)
9028 dwarf2_read_abbrevs (cu
->objfile
->obfd
, cu
);
9029 back_to
= make_cleanup (dwarf2_free_abbrev_table
, cu
);
9033 gdb_assert (cu
->die_hash
== NULL
);
9035 = htab_create_alloc_ex (cu
->header
.length
/ 12,
9039 &cu
->comp_unit_obstack
,
9040 hashtab_obstack_allocate
,
9041 dummy_obstack_deallocate
);
9043 init_cu_die_reader (&reader_specs
, cu
);
9045 die
= read_die_and_children (&reader_specs
, info_ptr
, &info_ptr
, NULL
);
9048 do_cleanups (back_to
);
9053 /* Main entry point for reading a DIE and all children.
9054 Read the DIE and dump it if requested. */
9056 static struct die_info
*
9057 read_die_and_children (const struct die_reader_specs
*reader
,
9059 gdb_byte
**new_info_ptr
,
9060 struct die_info
*parent
)
9062 struct die_info
*result
= read_die_and_children_1 (reader
, info_ptr
,
9063 new_info_ptr
, parent
);
9065 if (dwarf2_die_debug
)
9067 fprintf_unfiltered (gdb_stdlog
,
9068 "\nRead die from %s of %s:\n",
9069 (reader
->cu
->per_cu
->debug_type_section
9072 reader
->abfd
->filename
);
9073 dump_die (result
, dwarf2_die_debug
);
9079 /* Read a single die and all its descendents. Set the die's sibling
9080 field to NULL; set other fields in the die correctly, and set all
9081 of the descendents' fields correctly. Set *NEW_INFO_PTR to the
9082 location of the info_ptr after reading all of those dies. PARENT
9083 is the parent of the die in question. */
9085 static struct die_info
*
9086 read_die_and_children_1 (const struct die_reader_specs
*reader
,
9088 gdb_byte
**new_info_ptr
,
9089 struct die_info
*parent
)
9091 struct die_info
*die
;
9095 cur_ptr
= read_full_die (reader
, &die
, info_ptr
, &has_children
);
9098 *new_info_ptr
= cur_ptr
;
9101 store_in_ref_table (die
, reader
->cu
);
9104 die
->child
= read_die_and_siblings (reader
, cur_ptr
, new_info_ptr
, die
);
9108 *new_info_ptr
= cur_ptr
;
9111 die
->sibling
= NULL
;
9112 die
->parent
= parent
;
9116 /* Read a die, all of its descendents, and all of its siblings; set
9117 all of the fields of all of the dies correctly. Arguments are as
9118 in read_die_and_children. */
9120 static struct die_info
*
9121 read_die_and_siblings (const struct die_reader_specs
*reader
,
9123 gdb_byte
**new_info_ptr
,
9124 struct die_info
*parent
)
9126 struct die_info
*first_die
, *last_sibling
;
9130 first_die
= last_sibling
= NULL
;
9134 struct die_info
*die
9135 = read_die_and_children_1 (reader
, cur_ptr
, &cur_ptr
, parent
);
9139 *new_info_ptr
= cur_ptr
;
9146 last_sibling
->sibling
= die
;
9152 /* Read the die from the .debug_info section buffer. Set DIEP to
9153 point to a newly allocated die with its information, except for its
9154 child, sibling, and parent fields. Set HAS_CHILDREN to tell
9155 whether the die has children or not. */
9158 read_full_die (const struct die_reader_specs
*reader
,
9159 struct die_info
**diep
, gdb_byte
*info_ptr
,
9162 unsigned int abbrev_number
, bytes_read
, i
, offset
;
9163 struct abbrev_info
*abbrev
;
9164 struct die_info
*die
;
9165 struct dwarf2_cu
*cu
= reader
->cu
;
9166 bfd
*abfd
= reader
->abfd
;
9168 offset
= info_ptr
- reader
->buffer
;
9169 abbrev_number
= read_unsigned_leb128 (abfd
, info_ptr
, &bytes_read
);
9170 info_ptr
+= bytes_read
;
9178 abbrev
= dwarf2_lookup_abbrev (abbrev_number
, cu
);
9180 error (_("Dwarf Error: could not find abbrev number %d [in module %s]"),
9182 bfd_get_filename (abfd
));
9184 die
= dwarf_alloc_die (cu
, abbrev
->num_attrs
);
9185 die
->offset
= offset
;
9186 die
->tag
= abbrev
->tag
;
9187 die
->abbrev
= abbrev_number
;
9189 die
->num_attrs
= abbrev
->num_attrs
;
9191 for (i
= 0; i
< abbrev
->num_attrs
; ++i
)
9192 info_ptr
= read_attribute (&die
->attrs
[i
], &abbrev
->attrs
[i
],
9193 abfd
, info_ptr
, cu
);
9196 *has_children
= abbrev
->has_children
;
9200 /* In DWARF version 2, the description of the debugging information is
9201 stored in a separate .debug_abbrev section. Before we read any
9202 dies from a section we read in all abbreviations and install them
9203 in a hash table. This function also sets flags in CU describing
9204 the data found in the abbrev table. */
9207 dwarf2_read_abbrevs (bfd
*abfd
, struct dwarf2_cu
*cu
)
9209 struct comp_unit_head
*cu_header
= &cu
->header
;
9210 gdb_byte
*abbrev_ptr
;
9211 struct abbrev_info
*cur_abbrev
;
9212 unsigned int abbrev_number
, bytes_read
, abbrev_name
;
9213 unsigned int abbrev_form
, hash_number
;
9214 struct attr_abbrev
*cur_attrs
;
9215 unsigned int allocated_attrs
;
9217 /* Initialize dwarf2 abbrevs. */
9218 obstack_init (&cu
->abbrev_obstack
);
9219 cu
->dwarf2_abbrevs
= obstack_alloc (&cu
->abbrev_obstack
,
9221 * sizeof (struct abbrev_info
*)));
9222 memset (cu
->dwarf2_abbrevs
, 0,
9223 ABBREV_HASH_SIZE
* sizeof (struct abbrev_info
*));
9225 dwarf2_read_section (dwarf2_per_objfile
->objfile
,
9226 &dwarf2_per_objfile
->abbrev
);
9227 abbrev_ptr
= dwarf2_per_objfile
->abbrev
.buffer
+ cu_header
->abbrev_offset
;
9228 abbrev_number
= read_unsigned_leb128 (abfd
, abbrev_ptr
, &bytes_read
);
9229 abbrev_ptr
+= bytes_read
;
9231 allocated_attrs
= ATTR_ALLOC_CHUNK
;
9232 cur_attrs
= xmalloc (allocated_attrs
* sizeof (struct attr_abbrev
));
9234 /* Loop until we reach an abbrev number of 0. */
9235 while (abbrev_number
)
9237 cur_abbrev
= dwarf_alloc_abbrev (cu
);
9239 /* read in abbrev header */
9240 cur_abbrev
->number
= abbrev_number
;
9241 cur_abbrev
->tag
= read_unsigned_leb128 (abfd
, abbrev_ptr
, &bytes_read
);
9242 abbrev_ptr
+= bytes_read
;
9243 cur_abbrev
->has_children
= read_1_byte (abfd
, abbrev_ptr
);
9246 if (cur_abbrev
->tag
== DW_TAG_namespace
)
9247 cu
->has_namespace_info
= 1;
9249 /* now read in declarations */
9250 abbrev_name
= read_unsigned_leb128 (abfd
, abbrev_ptr
, &bytes_read
);
9251 abbrev_ptr
+= bytes_read
;
9252 abbrev_form
= read_unsigned_leb128 (abfd
, abbrev_ptr
, &bytes_read
);
9253 abbrev_ptr
+= bytes_read
;
9256 if (cur_abbrev
->num_attrs
== allocated_attrs
)
9258 allocated_attrs
+= ATTR_ALLOC_CHUNK
;
9260 = xrealloc (cur_attrs
, (allocated_attrs
9261 * sizeof (struct attr_abbrev
)));
9264 /* Record whether this compilation unit might have
9265 inter-compilation-unit references. If we don't know what form
9266 this attribute will have, then it might potentially be a
9267 DW_FORM_ref_addr, so we conservatively expect inter-CU
9270 if (abbrev_form
== DW_FORM_ref_addr
9271 || abbrev_form
== DW_FORM_indirect
)
9272 cu
->has_form_ref_addr
= 1;
9274 cur_attrs
[cur_abbrev
->num_attrs
].name
= abbrev_name
;
9275 cur_attrs
[cur_abbrev
->num_attrs
++].form
= abbrev_form
;
9276 abbrev_name
= read_unsigned_leb128 (abfd
, abbrev_ptr
, &bytes_read
);
9277 abbrev_ptr
+= bytes_read
;
9278 abbrev_form
= read_unsigned_leb128 (abfd
, abbrev_ptr
, &bytes_read
);
9279 abbrev_ptr
+= bytes_read
;
9282 cur_abbrev
->attrs
= obstack_alloc (&cu
->abbrev_obstack
,
9283 (cur_abbrev
->num_attrs
9284 * sizeof (struct attr_abbrev
)));
9285 memcpy (cur_abbrev
->attrs
, cur_attrs
,
9286 cur_abbrev
->num_attrs
* sizeof (struct attr_abbrev
));
9288 hash_number
= abbrev_number
% ABBREV_HASH_SIZE
;
9289 cur_abbrev
->next
= cu
->dwarf2_abbrevs
[hash_number
];
9290 cu
->dwarf2_abbrevs
[hash_number
] = cur_abbrev
;
9292 /* Get next abbreviation.
9293 Under Irix6 the abbreviations for a compilation unit are not
9294 always properly terminated with an abbrev number of 0.
9295 Exit loop if we encounter an abbreviation which we have
9296 already read (which means we are about to read the abbreviations
9297 for the next compile unit) or if the end of the abbreviation
9298 table is reached. */
9299 if ((unsigned int) (abbrev_ptr
- dwarf2_per_objfile
->abbrev
.buffer
)
9300 >= dwarf2_per_objfile
->abbrev
.size
)
9302 abbrev_number
= read_unsigned_leb128 (abfd
, abbrev_ptr
, &bytes_read
);
9303 abbrev_ptr
+= bytes_read
;
9304 if (dwarf2_lookup_abbrev (abbrev_number
, cu
) != NULL
)
9311 /* Release the memory used by the abbrev table for a compilation unit. */
9314 dwarf2_free_abbrev_table (void *ptr_to_cu
)
9316 struct dwarf2_cu
*cu
= ptr_to_cu
;
9318 obstack_free (&cu
->abbrev_obstack
, NULL
);
9319 cu
->dwarf2_abbrevs
= NULL
;
9322 /* Lookup an abbrev_info structure in the abbrev hash table. */
9324 static struct abbrev_info
*
9325 dwarf2_lookup_abbrev (unsigned int number
, struct dwarf2_cu
*cu
)
9327 unsigned int hash_number
;
9328 struct abbrev_info
*abbrev
;
9330 hash_number
= number
% ABBREV_HASH_SIZE
;
9331 abbrev
= cu
->dwarf2_abbrevs
[hash_number
];
9335 if (abbrev
->number
== number
)
9338 abbrev
= abbrev
->next
;
9343 /* Returns nonzero if TAG represents a type that we might generate a partial
9347 is_type_tag_for_partial (int tag
)
9352 /* Some types that would be reasonable to generate partial symbols for,
9353 that we don't at present. */
9354 case DW_TAG_array_type
:
9355 case DW_TAG_file_type
:
9356 case DW_TAG_ptr_to_member_type
:
9357 case DW_TAG_set_type
:
9358 case DW_TAG_string_type
:
9359 case DW_TAG_subroutine_type
:
9361 case DW_TAG_base_type
:
9362 case DW_TAG_class_type
:
9363 case DW_TAG_interface_type
:
9364 case DW_TAG_enumeration_type
:
9365 case DW_TAG_structure_type
:
9366 case DW_TAG_subrange_type
:
9367 case DW_TAG_typedef
:
9368 case DW_TAG_union_type
:
9375 /* Load all DIEs that are interesting for partial symbols into memory. */
9377 static struct partial_die_info
*
9378 load_partial_dies (bfd
*abfd
, gdb_byte
*buffer
, gdb_byte
*info_ptr
,
9379 int building_psymtab
, struct dwarf2_cu
*cu
)
9381 struct partial_die_info
*part_die
;
9382 struct partial_die_info
*parent_die
, *last_die
, *first_die
= NULL
;
9383 struct abbrev_info
*abbrev
;
9384 unsigned int bytes_read
;
9385 unsigned int load_all
= 0;
9387 int nesting_level
= 1;
9392 if (cu
->per_cu
&& cu
->per_cu
->load_all_dies
)
9396 = htab_create_alloc_ex (cu
->header
.length
/ 12,
9400 &cu
->comp_unit_obstack
,
9401 hashtab_obstack_allocate
,
9402 dummy_obstack_deallocate
);
9404 part_die
= obstack_alloc (&cu
->comp_unit_obstack
,
9405 sizeof (struct partial_die_info
));
9409 abbrev
= peek_die_abbrev (info_ptr
, &bytes_read
, cu
);
9411 /* A NULL abbrev means the end of a series of children. */
9414 if (--nesting_level
== 0)
9416 /* PART_DIE was probably the last thing allocated on the
9417 comp_unit_obstack, so we could call obstack_free
9418 here. We don't do that because the waste is small,
9419 and will be cleaned up when we're done with this
9420 compilation unit. This way, we're also more robust
9421 against other users of the comp_unit_obstack. */
9424 info_ptr
+= bytes_read
;
9425 last_die
= parent_die
;
9426 parent_die
= parent_die
->die_parent
;
9430 /* Check for template arguments. We never save these; if
9431 they're seen, we just mark the parent, and go on our way. */
9432 if (parent_die
!= NULL
9433 && cu
->language
== language_cplus
9434 && (abbrev
->tag
== DW_TAG_template_type_param
9435 || abbrev
->tag
== DW_TAG_template_value_param
))
9437 parent_die
->has_template_arguments
= 1;
9441 /* We don't need a partial DIE for the template argument. */
9442 info_ptr
= skip_one_die (buffer
, info_ptr
+ bytes_read
, abbrev
,
9448 /* We only recurse into subprograms looking for template arguments.
9449 Skip their other children. */
9451 && cu
->language
== language_cplus
9452 && parent_die
!= NULL
9453 && parent_die
->tag
== DW_TAG_subprogram
)
9455 info_ptr
= skip_one_die (buffer
, info_ptr
+ bytes_read
, abbrev
, cu
);
9459 /* Check whether this DIE is interesting enough to save. Normally
9460 we would not be interested in members here, but there may be
9461 later variables referencing them via DW_AT_specification (for
9464 && !is_type_tag_for_partial (abbrev
->tag
)
9465 && abbrev
->tag
!= DW_TAG_constant
9466 && abbrev
->tag
!= DW_TAG_enumerator
9467 && abbrev
->tag
!= DW_TAG_subprogram
9468 && abbrev
->tag
!= DW_TAG_lexical_block
9469 && abbrev
->tag
!= DW_TAG_variable
9470 && abbrev
->tag
!= DW_TAG_namespace
9471 && abbrev
->tag
!= DW_TAG_module
9472 && abbrev
->tag
!= DW_TAG_member
)
9474 /* Otherwise we skip to the next sibling, if any. */
9475 info_ptr
= skip_one_die (buffer
, info_ptr
+ bytes_read
, abbrev
, cu
);
9479 info_ptr
= read_partial_die (part_die
, abbrev
, bytes_read
, abfd
,
9480 buffer
, info_ptr
, cu
);
9482 /* This two-pass algorithm for processing partial symbols has a
9483 high cost in cache pressure. Thus, handle some simple cases
9484 here which cover the majority of C partial symbols. DIEs
9485 which neither have specification tags in them, nor could have
9486 specification tags elsewhere pointing at them, can simply be
9487 processed and discarded.
9489 This segment is also optional; scan_partial_symbols and
9490 add_partial_symbol will handle these DIEs if we chain
9491 them in normally. When compilers which do not emit large
9492 quantities of duplicate debug information are more common,
9493 this code can probably be removed. */
9495 /* Any complete simple types at the top level (pretty much all
9496 of them, for a language without namespaces), can be processed
9498 if (parent_die
== NULL
9499 && part_die
->has_specification
== 0
9500 && part_die
->is_declaration
== 0
9501 && ((part_die
->tag
== DW_TAG_typedef
&& !part_die
->has_children
)
9502 || part_die
->tag
== DW_TAG_base_type
9503 || part_die
->tag
== DW_TAG_subrange_type
))
9505 if (building_psymtab
&& part_die
->name
!= NULL
)
9506 add_psymbol_to_list (part_die
->name
, strlen (part_die
->name
), 0,
9507 VAR_DOMAIN
, LOC_TYPEDEF
,
9508 &cu
->objfile
->static_psymbols
,
9509 0, (CORE_ADDR
) 0, cu
->language
, cu
->objfile
);
9510 info_ptr
= locate_pdi_sibling (part_die
, buffer
, info_ptr
, abfd
, cu
);
9514 /* The exception for DW_TAG_typedef with has_children above is
9515 a workaround of GCC PR debug/47510. In the case of this complaint
9516 type_name_no_tag_or_error will error on such types later.
9518 GDB skipped children of DW_TAG_typedef by the shortcut above and then
9519 it could not find the child DIEs referenced later, this is checked
9520 above. In correct DWARF DW_TAG_typedef should have no children. */
9522 if (part_die
->tag
== DW_TAG_typedef
&& part_die
->has_children
)
9523 complaint (&symfile_complaints
,
9524 _("DW_TAG_typedef has childen - GCC PR debug/47510 bug "
9525 "- DIE at 0x%x [in module %s]"),
9526 part_die
->offset
, cu
->objfile
->name
);
9528 /* If we're at the second level, and we're an enumerator, and
9529 our parent has no specification (meaning possibly lives in a
9530 namespace elsewhere), then we can add the partial symbol now
9531 instead of queueing it. */
9532 if (part_die
->tag
== DW_TAG_enumerator
9533 && parent_die
!= NULL
9534 && parent_die
->die_parent
== NULL
9535 && parent_die
->tag
== DW_TAG_enumeration_type
9536 && parent_die
->has_specification
== 0)
9538 if (part_die
->name
== NULL
)
9539 complaint (&symfile_complaints
,
9540 _("malformed enumerator DIE ignored"));
9541 else if (building_psymtab
)
9542 add_psymbol_to_list (part_die
->name
, strlen (part_die
->name
), 0,
9543 VAR_DOMAIN
, LOC_CONST
,
9544 (cu
->language
== language_cplus
9545 || cu
->language
== language_java
)
9546 ? &cu
->objfile
->global_psymbols
9547 : &cu
->objfile
->static_psymbols
,
9548 0, (CORE_ADDR
) 0, cu
->language
, cu
->objfile
);
9550 info_ptr
= locate_pdi_sibling (part_die
, buffer
, info_ptr
, abfd
, cu
);
9554 /* We'll save this DIE so link it in. */
9555 part_die
->die_parent
= parent_die
;
9556 part_die
->die_sibling
= NULL
;
9557 part_die
->die_child
= NULL
;
9559 if (last_die
&& last_die
== parent_die
)
9560 last_die
->die_child
= part_die
;
9562 last_die
->die_sibling
= part_die
;
9564 last_die
= part_die
;
9566 if (first_die
== NULL
)
9567 first_die
= part_die
;
9569 /* Maybe add the DIE to the hash table. Not all DIEs that we
9570 find interesting need to be in the hash table, because we
9571 also have the parent/sibling/child chains; only those that we
9572 might refer to by offset later during partial symbol reading.
9574 For now this means things that might have be the target of a
9575 DW_AT_specification, DW_AT_abstract_origin, or
9576 DW_AT_extension. DW_AT_extension will refer only to
9577 namespaces; DW_AT_abstract_origin refers to functions (and
9578 many things under the function DIE, but we do not recurse
9579 into function DIEs during partial symbol reading) and
9580 possibly variables as well; DW_AT_specification refers to
9581 declarations. Declarations ought to have the DW_AT_declaration
9582 flag. It happens that GCC forgets to put it in sometimes, but
9583 only for functions, not for types.
9585 Adding more things than necessary to the hash table is harmless
9586 except for the performance cost. Adding too few will result in
9587 wasted time in find_partial_die, when we reread the compilation
9588 unit with load_all_dies set. */
9591 || abbrev
->tag
== DW_TAG_constant
9592 || abbrev
->tag
== DW_TAG_subprogram
9593 || abbrev
->tag
== DW_TAG_variable
9594 || abbrev
->tag
== DW_TAG_namespace
9595 || part_die
->is_declaration
)
9599 slot
= htab_find_slot_with_hash (cu
->partial_dies
, part_die
,
9600 part_die
->offset
, INSERT
);
9604 part_die
= obstack_alloc (&cu
->comp_unit_obstack
,
9605 sizeof (struct partial_die_info
));
9607 /* For some DIEs we want to follow their children (if any). For C
9608 we have no reason to follow the children of structures; for other
9609 languages we have to, so that we can get at method physnames
9610 to infer fully qualified class names, for DW_AT_specification,
9611 and for C++ template arguments. For C++, we also look one level
9612 inside functions to find template arguments (if the name of the
9613 function does not already contain the template arguments).
9615 For Ada, we need to scan the children of subprograms and lexical
9616 blocks as well because Ada allows the definition of nested
9617 entities that could be interesting for the debugger, such as
9618 nested subprograms for instance. */
9619 if (last_die
->has_children
9621 || last_die
->tag
== DW_TAG_namespace
9622 || last_die
->tag
== DW_TAG_module
9623 || last_die
->tag
== DW_TAG_enumeration_type
9624 || (cu
->language
== language_cplus
9625 && last_die
->tag
== DW_TAG_subprogram
9626 && (last_die
->name
== NULL
9627 || strchr (last_die
->name
, '<') == NULL
))
9628 || (cu
->language
!= language_c
9629 && (last_die
->tag
== DW_TAG_class_type
9630 || last_die
->tag
== DW_TAG_interface_type
9631 || last_die
->tag
== DW_TAG_structure_type
9632 || last_die
->tag
== DW_TAG_union_type
))
9633 || (cu
->language
== language_ada
9634 && (last_die
->tag
== DW_TAG_subprogram
9635 || last_die
->tag
== DW_TAG_lexical_block
))))
9638 parent_die
= last_die
;
9642 /* Otherwise we skip to the next sibling, if any. */
9643 info_ptr
= locate_pdi_sibling (last_die
, buffer
, info_ptr
, abfd
, cu
);
9645 /* Back to the top, do it again. */
9649 /* Read a minimal amount of information into the minimal die structure. */
9652 read_partial_die (struct partial_die_info
*part_die
,
9653 struct abbrev_info
*abbrev
,
9654 unsigned int abbrev_len
, bfd
*abfd
,
9655 gdb_byte
*buffer
, gdb_byte
*info_ptr
,
9656 struct dwarf2_cu
*cu
)
9659 struct attribute attr
;
9660 int has_low_pc_attr
= 0;
9661 int has_high_pc_attr
= 0;
9663 memset (part_die
, 0, sizeof (struct partial_die_info
));
9665 part_die
->offset
= info_ptr
- buffer
;
9667 info_ptr
+= abbrev_len
;
9672 part_die
->tag
= abbrev
->tag
;
9673 part_die
->has_children
= abbrev
->has_children
;
9675 for (i
= 0; i
< abbrev
->num_attrs
; ++i
)
9677 info_ptr
= read_attribute (&attr
, &abbrev
->attrs
[i
], abfd
, info_ptr
, cu
);
9679 /* Store the data if it is of an attribute we want to keep in a
9680 partial symbol table. */
9684 switch (part_die
->tag
)
9686 case DW_TAG_compile_unit
:
9687 case DW_TAG_type_unit
:
9688 /* Compilation units have a DW_AT_name that is a filename, not
9689 a source language identifier. */
9690 case DW_TAG_enumeration_type
:
9691 case DW_TAG_enumerator
:
9692 /* These tags always have simple identifiers already; no need
9693 to canonicalize them. */
9694 part_die
->name
= DW_STRING (&attr
);
9698 = dwarf2_canonicalize_name (DW_STRING (&attr
), cu
,
9699 &cu
->objfile
->objfile_obstack
);
9703 case DW_AT_linkage_name
:
9704 case DW_AT_MIPS_linkage_name
:
9705 /* Note that both forms of linkage name might appear. We
9706 assume they will be the same, and we only store the last
9708 if (cu
->language
== language_ada
)
9709 part_die
->name
= DW_STRING (&attr
);
9710 part_die
->linkage_name
= DW_STRING (&attr
);
9713 has_low_pc_attr
= 1;
9714 part_die
->lowpc
= DW_ADDR (&attr
);
9717 has_high_pc_attr
= 1;
9718 part_die
->highpc
= DW_ADDR (&attr
);
9720 case DW_AT_location
:
9721 /* Support the .debug_loc offsets. */
9722 if (attr_form_is_block (&attr
))
9724 part_die
->locdesc
= DW_BLOCK (&attr
);
9726 else if (attr_form_is_section_offset (&attr
))
9728 dwarf2_complex_location_expr_complaint ();
9732 dwarf2_invalid_attrib_class_complaint ("DW_AT_location",
9733 "partial symbol information");
9736 case DW_AT_external
:
9737 part_die
->is_external
= DW_UNSND (&attr
);
9739 case DW_AT_declaration
:
9740 part_die
->is_declaration
= DW_UNSND (&attr
);
9743 part_die
->has_type
= 1;
9745 case DW_AT_abstract_origin
:
9746 case DW_AT_specification
:
9747 case DW_AT_extension
:
9748 part_die
->has_specification
= 1;
9749 part_die
->spec_offset
= dwarf2_get_ref_die_offset (&attr
);
9752 /* Ignore absolute siblings, they might point outside of
9753 the current compile unit. */
9754 if (attr
.form
== DW_FORM_ref_addr
)
9755 complaint (&symfile_complaints
,
9756 _("ignoring absolute DW_AT_sibling"));
9758 part_die
->sibling
= buffer
+ dwarf2_get_ref_die_offset (&attr
);
9760 case DW_AT_byte_size
:
9761 part_die
->has_byte_size
= 1;
9763 case DW_AT_calling_convention
:
9764 /* DWARF doesn't provide a way to identify a program's source-level
9765 entry point. DW_AT_calling_convention attributes are only meant
9766 to describe functions' calling conventions.
9768 However, because it's a necessary piece of information in
9769 Fortran, and because DW_CC_program is the only piece of debugging
9770 information whose definition refers to a 'main program' at all,
9771 several compilers have begun marking Fortran main programs with
9772 DW_CC_program --- even when those functions use the standard
9773 calling conventions.
9775 So until DWARF specifies a way to provide this information and
9776 compilers pick up the new representation, we'll support this
9778 if (DW_UNSND (&attr
) == DW_CC_program
9779 && cu
->language
== language_fortran
)
9781 set_main_name (part_die
->name
);
9783 /* As this DIE has a static linkage the name would be difficult
9784 to look up later. */
9785 language_of_main
= language_fortran
;
9793 if (has_low_pc_attr
&& has_high_pc_attr
)
9795 /* When using the GNU linker, .gnu.linkonce. sections are used to
9796 eliminate duplicate copies of functions and vtables and such.
9797 The linker will arbitrarily choose one and discard the others.
9798 The AT_*_pc values for such functions refer to local labels in
9799 these sections. If the section from that file was discarded, the
9800 labels are not in the output, so the relocs get a value of 0.
9801 If this is a discarded function, mark the pc bounds as invalid,
9802 so that GDB will ignore it. */
9803 if (part_die
->lowpc
== 0 && !dwarf2_per_objfile
->has_section_at_zero
)
9805 struct gdbarch
*gdbarch
= get_objfile_arch (cu
->objfile
);
9807 complaint (&symfile_complaints
,
9808 _("DW_AT_low_pc %s is zero "
9809 "for DIE at 0x%x [in module %s]"),
9810 paddress (gdbarch
, part_die
->lowpc
),
9811 part_die
->offset
, cu
->objfile
->name
);
9813 /* dwarf2_get_pc_bounds has also the strict low < high requirement. */
9814 else if (part_die
->lowpc
>= part_die
->highpc
)
9816 struct gdbarch
*gdbarch
= get_objfile_arch (cu
->objfile
);
9818 complaint (&symfile_complaints
,
9819 _("DW_AT_low_pc %s is not < DW_AT_high_pc %s "
9820 "for DIE at 0x%x [in module %s]"),
9821 paddress (gdbarch
, part_die
->lowpc
),
9822 paddress (gdbarch
, part_die
->highpc
),
9823 part_die
->offset
, cu
->objfile
->name
);
9826 part_die
->has_pc_info
= 1;
9832 /* Find a cached partial DIE at OFFSET in CU. */
9834 static struct partial_die_info
*
9835 find_partial_die_in_comp_unit (unsigned int offset
, struct dwarf2_cu
*cu
)
9837 struct partial_die_info
*lookup_die
= NULL
;
9838 struct partial_die_info part_die
;
9840 part_die
.offset
= offset
;
9841 lookup_die
= htab_find_with_hash (cu
->partial_dies
, &part_die
, offset
);
9846 /* Find a partial DIE at OFFSET, which may or may not be in CU,
9847 except in the case of .debug_types DIEs which do not reference
9848 outside their CU (they do however referencing other types via
9849 DW_FORM_ref_sig8). */
9851 static struct partial_die_info
*
9852 find_partial_die (unsigned int offset
, struct dwarf2_cu
*cu
)
9854 struct dwarf2_per_cu_data
*per_cu
= NULL
;
9855 struct partial_die_info
*pd
= NULL
;
9857 if (cu
->per_cu
->debug_type_section
)
9859 pd
= find_partial_die_in_comp_unit (offset
, cu
);
9865 if (offset_in_cu_p (&cu
->header
, offset
))
9867 pd
= find_partial_die_in_comp_unit (offset
, cu
);
9872 per_cu
= dwarf2_find_containing_comp_unit (offset
, cu
->objfile
);
9874 if (per_cu
->cu
== NULL
|| per_cu
->cu
->partial_dies
== NULL
)
9875 load_partial_comp_unit (per_cu
, cu
->objfile
);
9877 per_cu
->cu
->last_used
= 0;
9878 pd
= find_partial_die_in_comp_unit (offset
, per_cu
->cu
);
9880 if (pd
== NULL
&& per_cu
->load_all_dies
== 0)
9882 struct cleanup
*back_to
;
9883 struct partial_die_info comp_unit_die
;
9884 struct abbrev_info
*abbrev
;
9885 unsigned int bytes_read
;
9888 per_cu
->load_all_dies
= 1;
9890 /* Re-read the DIEs. */
9891 back_to
= make_cleanup (null_cleanup
, 0);
9892 if (per_cu
->cu
->dwarf2_abbrevs
== NULL
)
9894 dwarf2_read_abbrevs (per_cu
->cu
->objfile
->obfd
, per_cu
->cu
);
9895 make_cleanup (dwarf2_free_abbrev_table
, per_cu
->cu
);
9897 info_ptr
= (dwarf2_per_objfile
->info
.buffer
9898 + per_cu
->cu
->header
.offset
9899 + per_cu
->cu
->header
.first_die_offset
);
9900 abbrev
= peek_die_abbrev (info_ptr
, &bytes_read
, per_cu
->cu
);
9901 info_ptr
= read_partial_die (&comp_unit_die
, abbrev
, bytes_read
,
9902 per_cu
->cu
->objfile
->obfd
,
9903 dwarf2_per_objfile
->info
.buffer
, info_ptr
,
9905 if (comp_unit_die
.has_children
)
9906 load_partial_dies (per_cu
->cu
->objfile
->obfd
,
9907 dwarf2_per_objfile
->info
.buffer
, info_ptr
,
9909 do_cleanups (back_to
);
9911 pd
= find_partial_die_in_comp_unit (offset
, per_cu
->cu
);
9917 internal_error (__FILE__
, __LINE__
,
9918 _("could not find partial DIE 0x%x "
9919 "in cache [from module %s]\n"),
9920 offset
, bfd_get_filename (cu
->objfile
->obfd
));
9924 /* See if we can figure out if the class lives in a namespace. We do
9925 this by looking for a member function; its demangled name will
9926 contain namespace info, if there is any. */
9929 guess_partial_die_structure_name (struct partial_die_info
*struct_pdi
,
9930 struct dwarf2_cu
*cu
)
9932 /* NOTE: carlton/2003-10-07: Getting the info this way changes
9933 what template types look like, because the demangler
9934 frequently doesn't give the same name as the debug info. We
9935 could fix this by only using the demangled name to get the
9936 prefix (but see comment in read_structure_type). */
9938 struct partial_die_info
*real_pdi
;
9939 struct partial_die_info
*child_pdi
;
9941 /* If this DIE (this DIE's specification, if any) has a parent, then
9942 we should not do this. We'll prepend the parent's fully qualified
9943 name when we create the partial symbol. */
9945 real_pdi
= struct_pdi
;
9946 while (real_pdi
->has_specification
)
9947 real_pdi
= find_partial_die (real_pdi
->spec_offset
, cu
);
9949 if (real_pdi
->die_parent
!= NULL
)
9952 for (child_pdi
= struct_pdi
->die_child
;
9954 child_pdi
= child_pdi
->die_sibling
)
9956 if (child_pdi
->tag
== DW_TAG_subprogram
9957 && child_pdi
->linkage_name
!= NULL
)
9959 char *actual_class_name
9960 = language_class_name_from_physname (cu
->language_defn
,
9961 child_pdi
->linkage_name
);
9962 if (actual_class_name
!= NULL
)
9965 = obsavestring (actual_class_name
,
9966 strlen (actual_class_name
),
9967 &cu
->objfile
->objfile_obstack
);
9968 xfree (actual_class_name
);
9975 /* Adjust PART_DIE before generating a symbol for it. This function
9976 may set the is_external flag or change the DIE's name. */
9979 fixup_partial_die (struct partial_die_info
*part_die
,
9980 struct dwarf2_cu
*cu
)
9982 /* Once we've fixed up a die, there's no point in doing so again.
9983 This also avoids a memory leak if we were to call
9984 guess_partial_die_structure_name multiple times. */
9985 if (part_die
->fixup_called
)
9988 /* If we found a reference attribute and the DIE has no name, try
9989 to find a name in the referred to DIE. */
9991 if (part_die
->name
== NULL
&& part_die
->has_specification
)
9993 struct partial_die_info
*spec_die
;
9995 spec_die
= find_partial_die (part_die
->spec_offset
, cu
);
9997 fixup_partial_die (spec_die
, cu
);
10001 part_die
->name
= spec_die
->name
;
10003 /* Copy DW_AT_external attribute if it is set. */
10004 if (spec_die
->is_external
)
10005 part_die
->is_external
= spec_die
->is_external
;
10009 /* Set default names for some unnamed DIEs. */
10011 if (part_die
->name
== NULL
&& part_die
->tag
== DW_TAG_namespace
)
10012 part_die
->name
= CP_ANONYMOUS_NAMESPACE_STR
;
10014 /* If there is no parent die to provide a namespace, and there are
10015 children, see if we can determine the namespace from their linkage
10017 NOTE: We need to do this even if cu->has_namespace_info != 0.
10018 gcc-4.5 -gdwarf-4 can drop the enclosing namespace. */
10019 if (cu
->language
== language_cplus
10020 && !VEC_empty (dwarf2_section_info_def
, dwarf2_per_objfile
->types
)
10021 && part_die
->die_parent
== NULL
10022 && part_die
->has_children
10023 && (part_die
->tag
== DW_TAG_class_type
10024 || part_die
->tag
== DW_TAG_structure_type
10025 || part_die
->tag
== DW_TAG_union_type
))
10026 guess_partial_die_structure_name (part_die
, cu
);
10028 /* GCC might emit a nameless struct or union that has a linkage
10029 name. See http://gcc.gnu.org/bugzilla/show_bug.cgi?id=47510. */
10030 if (part_die
->name
== NULL
10031 && (part_die
->tag
== DW_TAG_class_type
10032 || part_die
->tag
== DW_TAG_interface_type
10033 || part_die
->tag
== DW_TAG_structure_type
10034 || part_die
->tag
== DW_TAG_union_type
)
10035 && part_die
->linkage_name
!= NULL
)
10039 demangled
= cplus_demangle (part_die
->linkage_name
, DMGL_TYPES
);
10044 /* Strip any leading namespaces/classes, keep only the base name.
10045 DW_AT_name for named DIEs does not contain the prefixes. */
10046 base
= strrchr (demangled
, ':');
10047 if (base
&& base
> demangled
&& base
[-1] == ':')
10052 part_die
->name
= obsavestring (base
, strlen (base
),
10053 &cu
->objfile
->objfile_obstack
);
10058 part_die
->fixup_called
= 1;
10061 /* Read an attribute value described by an attribute form. */
10064 read_attribute_value (struct attribute
*attr
, unsigned form
,
10065 bfd
*abfd
, gdb_byte
*info_ptr
,
10066 struct dwarf2_cu
*cu
)
10068 struct comp_unit_head
*cu_header
= &cu
->header
;
10069 unsigned int bytes_read
;
10070 struct dwarf_block
*blk
;
10075 case DW_FORM_ref_addr
:
10076 if (cu
->header
.version
== 2)
10077 DW_ADDR (attr
) = read_address (abfd
, info_ptr
, cu
, &bytes_read
);
10079 DW_ADDR (attr
) = read_offset (abfd
, info_ptr
,
10080 &cu
->header
, &bytes_read
);
10081 info_ptr
+= bytes_read
;
10084 DW_ADDR (attr
) = read_address (abfd
, info_ptr
, cu
, &bytes_read
);
10085 info_ptr
+= bytes_read
;
10087 case DW_FORM_block2
:
10088 blk
= dwarf_alloc_block (cu
);
10089 blk
->size
= read_2_bytes (abfd
, info_ptr
);
10091 blk
->data
= read_n_bytes (abfd
, info_ptr
, blk
->size
);
10092 info_ptr
+= blk
->size
;
10093 DW_BLOCK (attr
) = blk
;
10095 case DW_FORM_block4
:
10096 blk
= dwarf_alloc_block (cu
);
10097 blk
->size
= read_4_bytes (abfd
, info_ptr
);
10099 blk
->data
= read_n_bytes (abfd
, info_ptr
, blk
->size
);
10100 info_ptr
+= blk
->size
;
10101 DW_BLOCK (attr
) = blk
;
10103 case DW_FORM_data2
:
10104 DW_UNSND (attr
) = read_2_bytes (abfd
, info_ptr
);
10107 case DW_FORM_data4
:
10108 DW_UNSND (attr
) = read_4_bytes (abfd
, info_ptr
);
10111 case DW_FORM_data8
:
10112 DW_UNSND (attr
) = read_8_bytes (abfd
, info_ptr
);
10115 case DW_FORM_sec_offset
:
10116 DW_UNSND (attr
) = read_offset (abfd
, info_ptr
, &cu
->header
, &bytes_read
);
10117 info_ptr
+= bytes_read
;
10119 case DW_FORM_string
:
10120 DW_STRING (attr
) = read_direct_string (abfd
, info_ptr
, &bytes_read
);
10121 DW_STRING_IS_CANONICAL (attr
) = 0;
10122 info_ptr
+= bytes_read
;
10125 DW_STRING (attr
) = read_indirect_string (abfd
, info_ptr
, cu_header
,
10127 DW_STRING_IS_CANONICAL (attr
) = 0;
10128 info_ptr
+= bytes_read
;
10130 case DW_FORM_exprloc
:
10131 case DW_FORM_block
:
10132 blk
= dwarf_alloc_block (cu
);
10133 blk
->size
= read_unsigned_leb128 (abfd
, info_ptr
, &bytes_read
);
10134 info_ptr
+= bytes_read
;
10135 blk
->data
= read_n_bytes (abfd
, info_ptr
, blk
->size
);
10136 info_ptr
+= blk
->size
;
10137 DW_BLOCK (attr
) = blk
;
10139 case DW_FORM_block1
:
10140 blk
= dwarf_alloc_block (cu
);
10141 blk
->size
= read_1_byte (abfd
, info_ptr
);
10143 blk
->data
= read_n_bytes (abfd
, info_ptr
, blk
->size
);
10144 info_ptr
+= blk
->size
;
10145 DW_BLOCK (attr
) = blk
;
10147 case DW_FORM_data1
:
10148 DW_UNSND (attr
) = read_1_byte (abfd
, info_ptr
);
10152 DW_UNSND (attr
) = read_1_byte (abfd
, info_ptr
);
10155 case DW_FORM_flag_present
:
10156 DW_UNSND (attr
) = 1;
10158 case DW_FORM_sdata
:
10159 DW_SND (attr
) = read_signed_leb128 (abfd
, info_ptr
, &bytes_read
);
10160 info_ptr
+= bytes_read
;
10162 case DW_FORM_udata
:
10163 DW_UNSND (attr
) = read_unsigned_leb128 (abfd
, info_ptr
, &bytes_read
);
10164 info_ptr
+= bytes_read
;
10167 DW_ADDR (attr
) = cu
->header
.offset
+ read_1_byte (abfd
, info_ptr
);
10171 DW_ADDR (attr
) = cu
->header
.offset
+ read_2_bytes (abfd
, info_ptr
);
10175 DW_ADDR (attr
) = cu
->header
.offset
+ read_4_bytes (abfd
, info_ptr
);
10179 DW_ADDR (attr
) = cu
->header
.offset
+ read_8_bytes (abfd
, info_ptr
);
10182 case DW_FORM_ref_sig8
:
10183 /* Convert the signature to something we can record in DW_UNSND
10185 NOTE: This is NULL if the type wasn't found. */
10186 DW_SIGNATURED_TYPE (attr
) =
10187 lookup_signatured_type (cu
->objfile
, read_8_bytes (abfd
, info_ptr
));
10190 case DW_FORM_ref_udata
:
10191 DW_ADDR (attr
) = (cu
->header
.offset
10192 + read_unsigned_leb128 (abfd
, info_ptr
, &bytes_read
));
10193 info_ptr
+= bytes_read
;
10195 case DW_FORM_indirect
:
10196 form
= read_unsigned_leb128 (abfd
, info_ptr
, &bytes_read
);
10197 info_ptr
+= bytes_read
;
10198 info_ptr
= read_attribute_value (attr
, form
, abfd
, info_ptr
, cu
);
10201 error (_("Dwarf Error: Cannot handle %s in DWARF reader [in module %s]"),
10202 dwarf_form_name (form
),
10203 bfd_get_filename (abfd
));
10206 /* We have seen instances where the compiler tried to emit a byte
10207 size attribute of -1 which ended up being encoded as an unsigned
10208 0xffffffff. Although 0xffffffff is technically a valid size value,
10209 an object of this size seems pretty unlikely so we can relatively
10210 safely treat these cases as if the size attribute was invalid and
10211 treat them as zero by default. */
10212 if (attr
->name
== DW_AT_byte_size
10213 && form
== DW_FORM_data4
10214 && DW_UNSND (attr
) >= 0xffffffff)
10217 (&symfile_complaints
,
10218 _("Suspicious DW_AT_byte_size value treated as zero instead of %s"),
10219 hex_string (DW_UNSND (attr
)));
10220 DW_UNSND (attr
) = 0;
10226 /* Read an attribute described by an abbreviated attribute. */
10229 read_attribute (struct attribute
*attr
, struct attr_abbrev
*abbrev
,
10230 bfd
*abfd
, gdb_byte
*info_ptr
, struct dwarf2_cu
*cu
)
10232 attr
->name
= abbrev
->name
;
10233 return read_attribute_value (attr
, abbrev
->form
, abfd
, info_ptr
, cu
);
10236 /* Read dwarf information from a buffer. */
10238 static unsigned int
10239 read_1_byte (bfd
*abfd
, gdb_byte
*buf
)
10241 return bfd_get_8 (abfd
, buf
);
10245 read_1_signed_byte (bfd
*abfd
, gdb_byte
*buf
)
10247 return bfd_get_signed_8 (abfd
, buf
);
10250 static unsigned int
10251 read_2_bytes (bfd
*abfd
, gdb_byte
*buf
)
10253 return bfd_get_16 (abfd
, buf
);
10256 static unsigned int
10257 read_4_bytes (bfd
*abfd
, gdb_byte
*buf
)
10259 return bfd_get_32 (abfd
, buf
);
10263 read_8_bytes (bfd
*abfd
, gdb_byte
*buf
)
10265 return bfd_get_64 (abfd
, buf
);
10269 read_address (bfd
*abfd
, gdb_byte
*buf
, struct dwarf2_cu
*cu
,
10270 unsigned int *bytes_read
)
10272 struct comp_unit_head
*cu_header
= &cu
->header
;
10273 CORE_ADDR retval
= 0;
10275 if (cu_header
->signed_addr_p
)
10277 switch (cu_header
->addr_size
)
10280 retval
= bfd_get_signed_16 (abfd
, buf
);
10283 retval
= bfd_get_signed_32 (abfd
, buf
);
10286 retval
= bfd_get_signed_64 (abfd
, buf
);
10289 internal_error (__FILE__
, __LINE__
,
10290 _("read_address: bad switch, signed [in module %s]"),
10291 bfd_get_filename (abfd
));
10296 switch (cu_header
->addr_size
)
10299 retval
= bfd_get_16 (abfd
, buf
);
10302 retval
= bfd_get_32 (abfd
, buf
);
10305 retval
= bfd_get_64 (abfd
, buf
);
10308 internal_error (__FILE__
, __LINE__
,
10309 _("read_address: bad switch, "
10310 "unsigned [in module %s]"),
10311 bfd_get_filename (abfd
));
10315 *bytes_read
= cu_header
->addr_size
;
10319 /* Read the initial length from a section. The (draft) DWARF 3
10320 specification allows the initial length to take up either 4 bytes
10321 or 12 bytes. If the first 4 bytes are 0xffffffff, then the next 8
10322 bytes describe the length and all offsets will be 8 bytes in length
10325 An older, non-standard 64-bit format is also handled by this
10326 function. The older format in question stores the initial length
10327 as an 8-byte quantity without an escape value. Lengths greater
10328 than 2^32 aren't very common which means that the initial 4 bytes
10329 is almost always zero. Since a length value of zero doesn't make
10330 sense for the 32-bit format, this initial zero can be considered to
10331 be an escape value which indicates the presence of the older 64-bit
10332 format. As written, the code can't detect (old format) lengths
10333 greater than 4GB. If it becomes necessary to handle lengths
10334 somewhat larger than 4GB, we could allow other small values (such
10335 as the non-sensical values of 1, 2, and 3) to also be used as
10336 escape values indicating the presence of the old format.
10338 The value returned via bytes_read should be used to increment the
10339 relevant pointer after calling read_initial_length().
10341 [ Note: read_initial_length() and read_offset() are based on the
10342 document entitled "DWARF Debugging Information Format", revision
10343 3, draft 8, dated November 19, 2001. This document was obtained
10346 http://reality.sgiweb.org/davea/dwarf3-draft8-011125.pdf
10348 This document is only a draft and is subject to change. (So beware.)
10350 Details regarding the older, non-standard 64-bit format were
10351 determined empirically by examining 64-bit ELF files produced by
10352 the SGI toolchain on an IRIX 6.5 machine.
10354 - Kevin, July 16, 2002
10358 read_initial_length (bfd
*abfd
, gdb_byte
*buf
, unsigned int *bytes_read
)
10360 LONGEST length
= bfd_get_32 (abfd
, buf
);
10362 if (length
== 0xffffffff)
10364 length
= bfd_get_64 (abfd
, buf
+ 4);
10367 else if (length
== 0)
10369 /* Handle the (non-standard) 64-bit DWARF2 format used by IRIX. */
10370 length
= bfd_get_64 (abfd
, buf
);
10381 /* Cover function for read_initial_length.
10382 Returns the length of the object at BUF, and stores the size of the
10383 initial length in *BYTES_READ and stores the size that offsets will be in
10385 If the initial length size is not equivalent to that specified in
10386 CU_HEADER then issue a complaint.
10387 This is useful when reading non-comp-unit headers. */
10390 read_checked_initial_length_and_offset (bfd
*abfd
, gdb_byte
*buf
,
10391 const struct comp_unit_head
*cu_header
,
10392 unsigned int *bytes_read
,
10393 unsigned int *offset_size
)
10395 LONGEST length
= read_initial_length (abfd
, buf
, bytes_read
);
10397 gdb_assert (cu_header
->initial_length_size
== 4
10398 || cu_header
->initial_length_size
== 8
10399 || cu_header
->initial_length_size
== 12);
10401 if (cu_header
->initial_length_size
!= *bytes_read
)
10402 complaint (&symfile_complaints
,
10403 _("intermixed 32-bit and 64-bit DWARF sections"));
10405 *offset_size
= (*bytes_read
== 4) ? 4 : 8;
10409 /* Read an offset from the data stream. The size of the offset is
10410 given by cu_header->offset_size. */
10413 read_offset (bfd
*abfd
, gdb_byte
*buf
, const struct comp_unit_head
*cu_header
,
10414 unsigned int *bytes_read
)
10416 LONGEST offset
= read_offset_1 (abfd
, buf
, cu_header
->offset_size
);
10418 *bytes_read
= cu_header
->offset_size
;
10422 /* Read an offset from the data stream. */
10425 read_offset_1 (bfd
*abfd
, gdb_byte
*buf
, unsigned int offset_size
)
10427 LONGEST retval
= 0;
10429 switch (offset_size
)
10432 retval
= bfd_get_32 (abfd
, buf
);
10435 retval
= bfd_get_64 (abfd
, buf
);
10438 internal_error (__FILE__
, __LINE__
,
10439 _("read_offset_1: bad switch [in module %s]"),
10440 bfd_get_filename (abfd
));
10447 read_n_bytes (bfd
*abfd
, gdb_byte
*buf
, unsigned int size
)
10449 /* If the size of a host char is 8 bits, we can return a pointer
10450 to the buffer, otherwise we have to copy the data to a buffer
10451 allocated on the temporary obstack. */
10452 gdb_assert (HOST_CHAR_BIT
== 8);
10457 read_direct_string (bfd
*abfd
, gdb_byte
*buf
, unsigned int *bytes_read_ptr
)
10459 /* If the size of a host char is 8 bits, we can return a pointer
10460 to the string, otherwise we have to copy the string to a buffer
10461 allocated on the temporary obstack. */
10462 gdb_assert (HOST_CHAR_BIT
== 8);
10465 *bytes_read_ptr
= 1;
10468 *bytes_read_ptr
= strlen ((char *) buf
) + 1;
10469 return (char *) buf
;
10473 read_indirect_string_at_offset (bfd
*abfd
, LONGEST str_offset
)
10475 dwarf2_read_section (dwarf2_per_objfile
->objfile
, &dwarf2_per_objfile
->str
);
10476 if (dwarf2_per_objfile
->str
.buffer
== NULL
)
10477 error (_("DW_FORM_strp used without .debug_str section [in module %s]"),
10478 bfd_get_filename (abfd
));
10479 if (str_offset
>= dwarf2_per_objfile
->str
.size
)
10480 error (_("DW_FORM_strp pointing outside of "
10481 ".debug_str section [in module %s]"),
10482 bfd_get_filename (abfd
));
10483 gdb_assert (HOST_CHAR_BIT
== 8);
10484 if (dwarf2_per_objfile
->str
.buffer
[str_offset
] == '\0')
10486 return (char *) (dwarf2_per_objfile
->str
.buffer
+ str_offset
);
10490 read_indirect_string (bfd
*abfd
, gdb_byte
*buf
,
10491 const struct comp_unit_head
*cu_header
,
10492 unsigned int *bytes_read_ptr
)
10494 LONGEST str_offset
= read_offset (abfd
, buf
, cu_header
, bytes_read_ptr
);
10496 return read_indirect_string_at_offset (abfd
, str_offset
);
10499 static unsigned long
10500 read_unsigned_leb128 (bfd
*abfd
, gdb_byte
*buf
, unsigned int *bytes_read_ptr
)
10502 unsigned long result
;
10503 unsigned int num_read
;
10505 unsigned char byte
;
10513 byte
= bfd_get_8 (abfd
, buf
);
10516 result
|= ((unsigned long)(byte
& 127) << shift
);
10517 if ((byte
& 128) == 0)
10523 *bytes_read_ptr
= num_read
;
10528 read_signed_leb128 (bfd
*abfd
, gdb_byte
*buf
, unsigned int *bytes_read_ptr
)
10531 int i
, shift
, num_read
;
10532 unsigned char byte
;
10540 byte
= bfd_get_8 (abfd
, buf
);
10543 result
|= ((long)(byte
& 127) << shift
);
10545 if ((byte
& 128) == 0)
10550 if ((shift
< 8 * sizeof (result
)) && (byte
& 0x40))
10551 result
|= -(((long)1) << shift
);
10552 *bytes_read_ptr
= num_read
;
10556 /* Return a pointer to just past the end of an LEB128 number in BUF. */
10559 skip_leb128 (bfd
*abfd
, gdb_byte
*buf
)
10565 byte
= bfd_get_8 (abfd
, buf
);
10567 if ((byte
& 128) == 0)
10573 set_cu_language (unsigned int lang
, struct dwarf2_cu
*cu
)
10580 cu
->language
= language_c
;
10582 case DW_LANG_C_plus_plus
:
10583 cu
->language
= language_cplus
;
10586 cu
->language
= language_d
;
10588 case DW_LANG_Fortran77
:
10589 case DW_LANG_Fortran90
:
10590 case DW_LANG_Fortran95
:
10591 cu
->language
= language_fortran
;
10593 case DW_LANG_Mips_Assembler
:
10594 cu
->language
= language_asm
;
10597 cu
->language
= language_java
;
10599 case DW_LANG_Ada83
:
10600 case DW_LANG_Ada95
:
10601 cu
->language
= language_ada
;
10603 case DW_LANG_Modula2
:
10604 cu
->language
= language_m2
;
10606 case DW_LANG_Pascal83
:
10607 cu
->language
= language_pascal
;
10610 cu
->language
= language_objc
;
10612 case DW_LANG_Cobol74
:
10613 case DW_LANG_Cobol85
:
10615 cu
->language
= language_minimal
;
10618 cu
->language_defn
= language_def (cu
->language
);
10621 /* Return the named attribute or NULL if not there. */
10623 static struct attribute
*
10624 dwarf2_attr (struct die_info
*die
, unsigned int name
, struct dwarf2_cu
*cu
)
10627 struct attribute
*spec
= NULL
;
10629 for (i
= 0; i
< die
->num_attrs
; ++i
)
10631 if (die
->attrs
[i
].name
== name
)
10632 return &die
->attrs
[i
];
10633 if (die
->attrs
[i
].name
== DW_AT_specification
10634 || die
->attrs
[i
].name
== DW_AT_abstract_origin
)
10635 spec
= &die
->attrs
[i
];
10640 die
= follow_die_ref (die
, spec
, &cu
);
10641 return dwarf2_attr (die
, name
, cu
);
10647 /* Return the named attribute or NULL if not there,
10648 but do not follow DW_AT_specification, etc.
10649 This is for use in contexts where we're reading .debug_types dies.
10650 Following DW_AT_specification, DW_AT_abstract_origin will take us
10651 back up the chain, and we want to go down. */
10653 static struct attribute
*
10654 dwarf2_attr_no_follow (struct die_info
*die
, unsigned int name
,
10655 struct dwarf2_cu
*cu
)
10659 for (i
= 0; i
< die
->num_attrs
; ++i
)
10660 if (die
->attrs
[i
].name
== name
)
10661 return &die
->attrs
[i
];
10666 /* Return non-zero iff the attribute NAME is defined for the given DIE,
10667 and holds a non-zero value. This function should only be used for
10668 DW_FORM_flag or DW_FORM_flag_present attributes. */
10671 dwarf2_flag_true_p (struct die_info
*die
, unsigned name
, struct dwarf2_cu
*cu
)
10673 struct attribute
*attr
= dwarf2_attr (die
, name
, cu
);
10675 return (attr
&& DW_UNSND (attr
));
10679 die_is_declaration (struct die_info
*die
, struct dwarf2_cu
*cu
)
10681 /* A DIE is a declaration if it has a DW_AT_declaration attribute
10682 which value is non-zero. However, we have to be careful with
10683 DIEs having a DW_AT_specification attribute, because dwarf2_attr()
10684 (via dwarf2_flag_true_p) follows this attribute. So we may
10685 end up accidently finding a declaration attribute that belongs
10686 to a different DIE referenced by the specification attribute,
10687 even though the given DIE does not have a declaration attribute. */
10688 return (dwarf2_flag_true_p (die
, DW_AT_declaration
, cu
)
10689 && dwarf2_attr (die
, DW_AT_specification
, cu
) == NULL
);
10692 /* Return the die giving the specification for DIE, if there is
10693 one. *SPEC_CU is the CU containing DIE on input, and the CU
10694 containing the return value on output. If there is no
10695 specification, but there is an abstract origin, that is
10698 static struct die_info
*
10699 die_specification (struct die_info
*die
, struct dwarf2_cu
**spec_cu
)
10701 struct attribute
*spec_attr
= dwarf2_attr (die
, DW_AT_specification
,
10704 if (spec_attr
== NULL
)
10705 spec_attr
= dwarf2_attr (die
, DW_AT_abstract_origin
, *spec_cu
);
10707 if (spec_attr
== NULL
)
10710 return follow_die_ref (die
, spec_attr
, spec_cu
);
10713 /* Free the line_header structure *LH, and any arrays and strings it
10715 NOTE: This is also used as a "cleanup" function. */
10718 free_line_header (struct line_header
*lh
)
10720 if (lh
->standard_opcode_lengths
)
10721 xfree (lh
->standard_opcode_lengths
);
10723 /* Remember that all the lh->file_names[i].name pointers are
10724 pointers into debug_line_buffer, and don't need to be freed. */
10725 if (lh
->file_names
)
10726 xfree (lh
->file_names
);
10728 /* Similarly for the include directory names. */
10729 if (lh
->include_dirs
)
10730 xfree (lh
->include_dirs
);
10735 /* Add an entry to LH's include directory table. */
10738 add_include_dir (struct line_header
*lh
, char *include_dir
)
10740 /* Grow the array if necessary. */
10741 if (lh
->include_dirs_size
== 0)
10743 lh
->include_dirs_size
= 1; /* for testing */
10744 lh
->include_dirs
= xmalloc (lh
->include_dirs_size
10745 * sizeof (*lh
->include_dirs
));
10747 else if (lh
->num_include_dirs
>= lh
->include_dirs_size
)
10749 lh
->include_dirs_size
*= 2;
10750 lh
->include_dirs
= xrealloc (lh
->include_dirs
,
10751 (lh
->include_dirs_size
10752 * sizeof (*lh
->include_dirs
)));
10755 lh
->include_dirs
[lh
->num_include_dirs
++] = include_dir
;
10758 /* Add an entry to LH's file name table. */
10761 add_file_name (struct line_header
*lh
,
10763 unsigned int dir_index
,
10764 unsigned int mod_time
,
10765 unsigned int length
)
10767 struct file_entry
*fe
;
10769 /* Grow the array if necessary. */
10770 if (lh
->file_names_size
== 0)
10772 lh
->file_names_size
= 1; /* for testing */
10773 lh
->file_names
= xmalloc (lh
->file_names_size
10774 * sizeof (*lh
->file_names
));
10776 else if (lh
->num_file_names
>= lh
->file_names_size
)
10778 lh
->file_names_size
*= 2;
10779 lh
->file_names
= xrealloc (lh
->file_names
,
10780 (lh
->file_names_size
10781 * sizeof (*lh
->file_names
)));
10784 fe
= &lh
->file_names
[lh
->num_file_names
++];
10786 fe
->dir_index
= dir_index
;
10787 fe
->mod_time
= mod_time
;
10788 fe
->length
= length
;
10789 fe
->included_p
= 0;
10793 /* Read the statement program header starting at OFFSET in
10794 .debug_line, according to the endianness of ABFD. Return a pointer
10795 to a struct line_header, allocated using xmalloc.
10797 NOTE: the strings in the include directory and file name tables of
10798 the returned object point into debug_line_buffer, and must not be
10801 static struct line_header
*
10802 dwarf_decode_line_header (unsigned int offset
, bfd
*abfd
,
10803 struct dwarf2_cu
*cu
)
10805 struct cleanup
*back_to
;
10806 struct line_header
*lh
;
10807 gdb_byte
*line_ptr
;
10808 unsigned int bytes_read
, offset_size
;
10810 char *cur_dir
, *cur_file
;
10812 dwarf2_read_section (dwarf2_per_objfile
->objfile
, &dwarf2_per_objfile
->line
);
10813 if (dwarf2_per_objfile
->line
.buffer
== NULL
)
10815 complaint (&symfile_complaints
, _("missing .debug_line section"));
10819 /* Make sure that at least there's room for the total_length field.
10820 That could be 12 bytes long, but we're just going to fudge that. */
10821 if (offset
+ 4 >= dwarf2_per_objfile
->line
.size
)
10823 dwarf2_statement_list_fits_in_line_number_section_complaint ();
10827 lh
= xmalloc (sizeof (*lh
));
10828 memset (lh
, 0, sizeof (*lh
));
10829 back_to
= make_cleanup ((make_cleanup_ftype
*) free_line_header
,
10832 line_ptr
= dwarf2_per_objfile
->line
.buffer
+ offset
;
10834 /* Read in the header. */
10836 read_checked_initial_length_and_offset (abfd
, line_ptr
, &cu
->header
,
10837 &bytes_read
, &offset_size
);
10838 line_ptr
+= bytes_read
;
10839 if (line_ptr
+ lh
->total_length
> (dwarf2_per_objfile
->line
.buffer
10840 + dwarf2_per_objfile
->line
.size
))
10842 dwarf2_statement_list_fits_in_line_number_section_complaint ();
10845 lh
->statement_program_end
= line_ptr
+ lh
->total_length
;
10846 lh
->version
= read_2_bytes (abfd
, line_ptr
);
10848 lh
->header_length
= read_offset_1 (abfd
, line_ptr
, offset_size
);
10849 line_ptr
+= offset_size
;
10850 lh
->minimum_instruction_length
= read_1_byte (abfd
, line_ptr
);
10852 if (lh
->version
>= 4)
10854 lh
->maximum_ops_per_instruction
= read_1_byte (abfd
, line_ptr
);
10858 lh
->maximum_ops_per_instruction
= 1;
10860 if (lh
->maximum_ops_per_instruction
== 0)
10862 lh
->maximum_ops_per_instruction
= 1;
10863 complaint (&symfile_complaints
,
10864 _("invalid maximum_ops_per_instruction "
10865 "in `.debug_line' section"));
10868 lh
->default_is_stmt
= read_1_byte (abfd
, line_ptr
);
10870 lh
->line_base
= read_1_signed_byte (abfd
, line_ptr
);
10872 lh
->line_range
= read_1_byte (abfd
, line_ptr
);
10874 lh
->opcode_base
= read_1_byte (abfd
, line_ptr
);
10876 lh
->standard_opcode_lengths
10877 = xmalloc (lh
->opcode_base
* sizeof (lh
->standard_opcode_lengths
[0]));
10879 lh
->standard_opcode_lengths
[0] = 1; /* This should never be used anyway. */
10880 for (i
= 1; i
< lh
->opcode_base
; ++i
)
10882 lh
->standard_opcode_lengths
[i
] = read_1_byte (abfd
, line_ptr
);
10886 /* Read directory table. */
10887 while ((cur_dir
= read_direct_string (abfd
, line_ptr
, &bytes_read
)) != NULL
)
10889 line_ptr
+= bytes_read
;
10890 add_include_dir (lh
, cur_dir
);
10892 line_ptr
+= bytes_read
;
10894 /* Read file name table. */
10895 while ((cur_file
= read_direct_string (abfd
, line_ptr
, &bytes_read
)) != NULL
)
10897 unsigned int dir_index
, mod_time
, length
;
10899 line_ptr
+= bytes_read
;
10900 dir_index
= read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
10901 line_ptr
+= bytes_read
;
10902 mod_time
= read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
10903 line_ptr
+= bytes_read
;
10904 length
= read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
10905 line_ptr
+= bytes_read
;
10907 add_file_name (lh
, cur_file
, dir_index
, mod_time
, length
);
10909 line_ptr
+= bytes_read
;
10910 lh
->statement_program_start
= line_ptr
;
10912 if (line_ptr
> (dwarf2_per_objfile
->line
.buffer
10913 + dwarf2_per_objfile
->line
.size
))
10914 complaint (&symfile_complaints
,
10915 _("line number info header doesn't "
10916 "fit in `.debug_line' section"));
10918 discard_cleanups (back_to
);
10922 /* This function exists to work around a bug in certain compilers
10923 (particularly GCC 2.95), in which the first line number marker of a
10924 function does not show up until after the prologue, right before
10925 the second line number marker. This function shifts ADDRESS down
10926 to the beginning of the function if necessary, and is called on
10927 addresses passed to record_line. */
10930 check_cu_functions (CORE_ADDR address
, struct dwarf2_cu
*cu
)
10932 struct function_range
*fn
;
10934 /* Find the function_range containing address. */
10938 if (!cu
->cached_fn
)
10939 cu
->cached_fn
= cu
->first_fn
;
10941 fn
= cu
->cached_fn
;
10943 if (fn
->lowpc
<= address
&& fn
->highpc
> address
)
10949 while (fn
&& fn
!= cu
->cached_fn
)
10950 if (fn
->lowpc
<= address
&& fn
->highpc
> address
)
10960 if (address
!= fn
->lowpc
)
10961 complaint (&symfile_complaints
,
10962 _("misplaced first line number at 0x%lx for '%s'"),
10963 (unsigned long) address
, fn
->name
);
10968 /* Subroutine of dwarf_decode_lines to simplify it.
10969 Return the file name of the psymtab for included file FILE_INDEX
10970 in line header LH of PST.
10971 COMP_DIR is the compilation directory (DW_AT_comp_dir) or NULL if unknown.
10972 If space for the result is malloc'd, it will be freed by a cleanup.
10973 Returns NULL if FILE_INDEX should be ignored, i.e., it is pst->filename. */
10976 psymtab_include_file_name (const struct line_header
*lh
, int file_index
,
10977 const struct partial_symtab
*pst
,
10978 const char *comp_dir
)
10980 const struct file_entry fe
= lh
->file_names
[file_index
];
10981 char *include_name
= fe
.name
;
10982 char *include_name_to_compare
= include_name
;
10983 char *dir_name
= NULL
;
10984 const char *pst_filename
;
10985 char *copied_name
= NULL
;
10989 dir_name
= lh
->include_dirs
[fe
.dir_index
- 1];
10991 if (!IS_ABSOLUTE_PATH (include_name
)
10992 && (dir_name
!= NULL
|| comp_dir
!= NULL
))
10994 /* Avoid creating a duplicate psymtab for PST.
10995 We do this by comparing INCLUDE_NAME and PST_FILENAME.
10996 Before we do the comparison, however, we need to account
10997 for DIR_NAME and COMP_DIR.
10998 First prepend dir_name (if non-NULL). If we still don't
10999 have an absolute path prepend comp_dir (if non-NULL).
11000 However, the directory we record in the include-file's
11001 psymtab does not contain COMP_DIR (to match the
11002 corresponding symtab(s)).
11007 bash$ gcc -g ./hello.c
11008 include_name = "hello.c"
11010 DW_AT_comp_dir = comp_dir = "/tmp"
11011 DW_AT_name = "./hello.c" */
11013 if (dir_name
!= NULL
)
11015 include_name
= concat (dir_name
, SLASH_STRING
,
11016 include_name
, (char *)NULL
);
11017 include_name_to_compare
= include_name
;
11018 make_cleanup (xfree
, include_name
);
11020 if (!IS_ABSOLUTE_PATH (include_name
) && comp_dir
!= NULL
)
11022 include_name_to_compare
= concat (comp_dir
, SLASH_STRING
,
11023 include_name
, (char *)NULL
);
11027 pst_filename
= pst
->filename
;
11028 if (!IS_ABSOLUTE_PATH (pst_filename
) && pst
->dirname
!= NULL
)
11030 copied_name
= concat (pst
->dirname
, SLASH_STRING
,
11031 pst_filename
, (char *)NULL
);
11032 pst_filename
= copied_name
;
11035 file_is_pst
= FILENAME_CMP (include_name_to_compare
, pst_filename
) == 0;
11037 if (include_name_to_compare
!= include_name
)
11038 xfree (include_name_to_compare
);
11039 if (copied_name
!= NULL
)
11040 xfree (copied_name
);
11044 return include_name
;
11047 /* Ignore this record_line request. */
11050 noop_record_line (struct subfile
*subfile
, int line
, CORE_ADDR pc
)
11055 /* Decode the Line Number Program (LNP) for the given line_header
11056 structure and CU. The actual information extracted and the type
11057 of structures created from the LNP depends on the value of PST.
11059 1. If PST is NULL, then this procedure uses the data from the program
11060 to create all necessary symbol tables, and their linetables.
11062 2. If PST is not NULL, this procedure reads the program to determine
11063 the list of files included by the unit represented by PST, and
11064 builds all the associated partial symbol tables.
11066 COMP_DIR is the compilation directory (DW_AT_comp_dir) or NULL if unknown.
11067 It is used for relative paths in the line table.
11068 NOTE: When processing partial symtabs (pst != NULL),
11069 comp_dir == pst->dirname.
11071 NOTE: It is important that psymtabs have the same file name (via strcmp)
11072 as the corresponding symtab. Since COMP_DIR is not used in the name of the
11073 symtab we don't use it in the name of the psymtabs we create.
11074 E.g. expand_line_sal requires this when finding psymtabs to expand.
11075 A good testcase for this is mb-inline.exp. */
11078 dwarf_decode_lines (struct line_header
*lh
, const char *comp_dir
, bfd
*abfd
,
11079 struct dwarf2_cu
*cu
, struct partial_symtab
*pst
)
11081 gdb_byte
*line_ptr
, *extended_end
;
11082 gdb_byte
*line_end
;
11083 unsigned int bytes_read
, extended_len
;
11084 unsigned char op_code
, extended_op
, adj_opcode
;
11085 CORE_ADDR baseaddr
;
11086 struct objfile
*objfile
= cu
->objfile
;
11087 struct gdbarch
*gdbarch
= get_objfile_arch (objfile
);
11088 const int decode_for_pst_p
= (pst
!= NULL
);
11089 struct subfile
*last_subfile
= NULL
, *first_subfile
= current_subfile
;
11090 void (*p_record_line
) (struct subfile
*subfile
, int line
, CORE_ADDR pc
)
11093 baseaddr
= ANOFFSET (objfile
->section_offsets
, SECT_OFF_TEXT (objfile
));
11095 line_ptr
= lh
->statement_program_start
;
11096 line_end
= lh
->statement_program_end
;
11098 /* Read the statement sequences until there's nothing left. */
11099 while (line_ptr
< line_end
)
11101 /* state machine registers */
11102 CORE_ADDR address
= 0;
11103 unsigned int file
= 1;
11104 unsigned int line
= 1;
11105 unsigned int column
= 0;
11106 int is_stmt
= lh
->default_is_stmt
;
11107 int basic_block
= 0;
11108 int end_sequence
= 0;
11110 unsigned char op_index
= 0;
11112 if (!decode_for_pst_p
&& lh
->num_file_names
>= file
)
11114 /* Start a subfile for the current file of the state machine. */
11115 /* lh->include_dirs and lh->file_names are 0-based, but the
11116 directory and file name numbers in the statement program
11118 struct file_entry
*fe
= &lh
->file_names
[file
- 1];
11122 dir
= lh
->include_dirs
[fe
->dir_index
- 1];
11124 dwarf2_start_subfile (fe
->name
, dir
, comp_dir
);
11127 /* Decode the table. */
11128 while (!end_sequence
)
11130 op_code
= read_1_byte (abfd
, line_ptr
);
11132 if (line_ptr
> line_end
)
11134 dwarf2_debug_line_missing_end_sequence_complaint ();
11138 if (op_code
>= lh
->opcode_base
)
11140 /* Special operand. */
11141 adj_opcode
= op_code
- lh
->opcode_base
;
11142 address
+= (((op_index
+ (adj_opcode
/ lh
->line_range
))
11143 / lh
->maximum_ops_per_instruction
)
11144 * lh
->minimum_instruction_length
);
11145 op_index
= ((op_index
+ (adj_opcode
/ lh
->line_range
))
11146 % lh
->maximum_ops_per_instruction
);
11147 line
+= lh
->line_base
+ (adj_opcode
% lh
->line_range
);
11148 if (lh
->num_file_names
< file
|| file
== 0)
11149 dwarf2_debug_line_missing_file_complaint ();
11150 /* For now we ignore lines not starting on an
11151 instruction boundary. */
11152 else if (op_index
== 0)
11154 lh
->file_names
[file
- 1].included_p
= 1;
11155 if (!decode_for_pst_p
&& is_stmt
)
11157 if (last_subfile
!= current_subfile
)
11159 addr
= gdbarch_addr_bits_remove (gdbarch
, address
);
11161 (*p_record_line
) (last_subfile
, 0, addr
);
11162 last_subfile
= current_subfile
;
11164 /* Append row to matrix using current values. */
11165 addr
= check_cu_functions (address
, cu
);
11166 addr
= gdbarch_addr_bits_remove (gdbarch
, addr
);
11167 (*p_record_line
) (current_subfile
, line
, addr
);
11172 else switch (op_code
)
11174 case DW_LNS_extended_op
:
11175 extended_len
= read_unsigned_leb128 (abfd
, line_ptr
,
11177 line_ptr
+= bytes_read
;
11178 extended_end
= line_ptr
+ extended_len
;
11179 extended_op
= read_1_byte (abfd
, line_ptr
);
11181 switch (extended_op
)
11183 case DW_LNE_end_sequence
:
11184 p_record_line
= record_line
;
11187 case DW_LNE_set_address
:
11188 address
= read_address (abfd
, line_ptr
, cu
, &bytes_read
);
11190 if (address
== 0 && !dwarf2_per_objfile
->has_section_at_zero
)
11192 /* This line table is for a function which has been
11193 GCd by the linker. Ignore it. PR gdb/12528 */
11196 = line_ptr
- dwarf2_per_objfile
->line
.buffer
;
11198 complaint (&symfile_complaints
,
11199 _(".debug_line address at offset 0x%lx is 0 "
11201 line_offset
, cu
->objfile
->name
);
11202 p_record_line
= noop_record_line
;
11206 line_ptr
+= bytes_read
;
11207 address
+= baseaddr
;
11209 case DW_LNE_define_file
:
11212 unsigned int dir_index
, mod_time
, length
;
11214 cur_file
= read_direct_string (abfd
, line_ptr
,
11216 line_ptr
+= bytes_read
;
11218 read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
11219 line_ptr
+= bytes_read
;
11221 read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
11222 line_ptr
+= bytes_read
;
11224 read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
11225 line_ptr
+= bytes_read
;
11226 add_file_name (lh
, cur_file
, dir_index
, mod_time
, length
);
11229 case DW_LNE_set_discriminator
:
11230 /* The discriminator is not interesting to the debugger;
11232 line_ptr
= extended_end
;
11235 complaint (&symfile_complaints
,
11236 _("mangled .debug_line section"));
11239 /* Make sure that we parsed the extended op correctly. If e.g.
11240 we expected a different address size than the producer used,
11241 we may have read the wrong number of bytes. */
11242 if (line_ptr
!= extended_end
)
11244 complaint (&symfile_complaints
,
11245 _("mangled .debug_line section"));
11250 if (lh
->num_file_names
< file
|| file
== 0)
11251 dwarf2_debug_line_missing_file_complaint ();
11254 lh
->file_names
[file
- 1].included_p
= 1;
11255 if (!decode_for_pst_p
&& is_stmt
)
11257 if (last_subfile
!= current_subfile
)
11259 addr
= gdbarch_addr_bits_remove (gdbarch
, address
);
11261 (*p_record_line
) (last_subfile
, 0, addr
);
11262 last_subfile
= current_subfile
;
11264 addr
= check_cu_functions (address
, cu
);
11265 addr
= gdbarch_addr_bits_remove (gdbarch
, addr
);
11266 (*p_record_line
) (current_subfile
, line
, addr
);
11271 case DW_LNS_advance_pc
:
11274 = read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
11276 address
+= (((op_index
+ adjust
)
11277 / lh
->maximum_ops_per_instruction
)
11278 * lh
->minimum_instruction_length
);
11279 op_index
= ((op_index
+ adjust
)
11280 % lh
->maximum_ops_per_instruction
);
11281 line_ptr
+= bytes_read
;
11284 case DW_LNS_advance_line
:
11285 line
+= read_signed_leb128 (abfd
, line_ptr
, &bytes_read
);
11286 line_ptr
+= bytes_read
;
11288 case DW_LNS_set_file
:
11290 /* The arrays lh->include_dirs and lh->file_names are
11291 0-based, but the directory and file name numbers in
11292 the statement program are 1-based. */
11293 struct file_entry
*fe
;
11296 file
= read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
11297 line_ptr
+= bytes_read
;
11298 if (lh
->num_file_names
< file
|| file
== 0)
11299 dwarf2_debug_line_missing_file_complaint ();
11302 fe
= &lh
->file_names
[file
- 1];
11304 dir
= lh
->include_dirs
[fe
->dir_index
- 1];
11305 if (!decode_for_pst_p
)
11307 last_subfile
= current_subfile
;
11308 dwarf2_start_subfile (fe
->name
, dir
, comp_dir
);
11313 case DW_LNS_set_column
:
11314 column
= read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
11315 line_ptr
+= bytes_read
;
11317 case DW_LNS_negate_stmt
:
11318 is_stmt
= (!is_stmt
);
11320 case DW_LNS_set_basic_block
:
11323 /* Add to the address register of the state machine the
11324 address increment value corresponding to special opcode
11325 255. I.e., this value is scaled by the minimum
11326 instruction length since special opcode 255 would have
11327 scaled the increment. */
11328 case DW_LNS_const_add_pc
:
11330 CORE_ADDR adjust
= (255 - lh
->opcode_base
) / lh
->line_range
;
11332 address
+= (((op_index
+ adjust
)
11333 / lh
->maximum_ops_per_instruction
)
11334 * lh
->minimum_instruction_length
);
11335 op_index
= ((op_index
+ adjust
)
11336 % lh
->maximum_ops_per_instruction
);
11339 case DW_LNS_fixed_advance_pc
:
11340 address
+= read_2_bytes (abfd
, line_ptr
);
11346 /* Unknown standard opcode, ignore it. */
11349 for (i
= 0; i
< lh
->standard_opcode_lengths
[op_code
]; i
++)
11351 (void) read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
11352 line_ptr
+= bytes_read
;
11357 if (lh
->num_file_names
< file
|| file
== 0)
11358 dwarf2_debug_line_missing_file_complaint ();
11361 lh
->file_names
[file
- 1].included_p
= 1;
11362 if (!decode_for_pst_p
)
11364 addr
= gdbarch_addr_bits_remove (gdbarch
, address
);
11365 (*p_record_line
) (current_subfile
, 0, addr
);
11370 if (decode_for_pst_p
)
11374 /* Now that we're done scanning the Line Header Program, we can
11375 create the psymtab of each included file. */
11376 for (file_index
= 0; file_index
< lh
->num_file_names
; file_index
++)
11377 if (lh
->file_names
[file_index
].included_p
== 1)
11379 char *include_name
=
11380 psymtab_include_file_name (lh
, file_index
, pst
, comp_dir
);
11381 if (include_name
!= NULL
)
11382 dwarf2_create_include_psymtab (include_name
, pst
, objfile
);
11387 /* Make sure a symtab is created for every file, even files
11388 which contain only variables (i.e. no code with associated
11392 struct file_entry
*fe
;
11394 for (i
= 0; i
< lh
->num_file_names
; i
++)
11398 fe
= &lh
->file_names
[i
];
11400 dir
= lh
->include_dirs
[fe
->dir_index
- 1];
11401 dwarf2_start_subfile (fe
->name
, dir
, comp_dir
);
11403 /* Skip the main file; we don't need it, and it must be
11404 allocated last, so that it will show up before the
11405 non-primary symtabs in the objfile's symtab list. */
11406 if (current_subfile
== first_subfile
)
11409 if (current_subfile
->symtab
== NULL
)
11410 current_subfile
->symtab
= allocate_symtab (current_subfile
->name
,
11412 fe
->symtab
= current_subfile
->symtab
;
11417 /* Start a subfile for DWARF. FILENAME is the name of the file and
11418 DIRNAME the name of the source directory which contains FILENAME
11419 or NULL if not known. COMP_DIR is the compilation directory for the
11420 linetable's compilation unit or NULL if not known.
11421 This routine tries to keep line numbers from identical absolute and
11422 relative file names in a common subfile.
11424 Using the `list' example from the GDB testsuite, which resides in
11425 /srcdir and compiling it with Irix6.2 cc in /compdir using a filename
11426 of /srcdir/list0.c yields the following debugging information for list0.c:
11428 DW_AT_name: /srcdir/list0.c
11429 DW_AT_comp_dir: /compdir
11430 files.files[0].name: list0.h
11431 files.files[0].dir: /srcdir
11432 files.files[1].name: list0.c
11433 files.files[1].dir: /srcdir
11435 The line number information for list0.c has to end up in a single
11436 subfile, so that `break /srcdir/list0.c:1' works as expected.
11437 start_subfile will ensure that this happens provided that we pass the
11438 concatenation of files.files[1].dir and files.files[1].name as the
11442 dwarf2_start_subfile (char *filename
, const char *dirname
,
11443 const char *comp_dir
)
11447 /* While reading the DIEs, we call start_symtab(DW_AT_name, DW_AT_comp_dir).
11448 `start_symtab' will always pass the contents of DW_AT_comp_dir as
11449 second argument to start_subfile. To be consistent, we do the
11450 same here. In order not to lose the line information directory,
11451 we concatenate it to the filename when it makes sense.
11452 Note that the Dwarf3 standard says (speaking of filenames in line
11453 information): ``The directory index is ignored for file names
11454 that represent full path names''. Thus ignoring dirname in the
11455 `else' branch below isn't an issue. */
11457 if (!IS_ABSOLUTE_PATH (filename
) && dirname
!= NULL
)
11458 fullname
= concat (dirname
, SLASH_STRING
, filename
, (char *)NULL
);
11460 fullname
= filename
;
11462 start_subfile (fullname
, comp_dir
);
11464 if (fullname
!= filename
)
11469 var_decode_location (struct attribute
*attr
, struct symbol
*sym
,
11470 struct dwarf2_cu
*cu
)
11472 struct objfile
*objfile
= cu
->objfile
;
11473 struct comp_unit_head
*cu_header
= &cu
->header
;
11475 /* NOTE drow/2003-01-30: There used to be a comment and some special
11476 code here to turn a symbol with DW_AT_external and a
11477 SYMBOL_VALUE_ADDRESS of 0 into a LOC_UNRESOLVED symbol. This was
11478 necessary for platforms (maybe Alpha, certainly PowerPC GNU/Linux
11479 with some versions of binutils) where shared libraries could have
11480 relocations against symbols in their debug information - the
11481 minimal symbol would have the right address, but the debug info
11482 would not. It's no longer necessary, because we will explicitly
11483 apply relocations when we read in the debug information now. */
11485 /* A DW_AT_location attribute with no contents indicates that a
11486 variable has been optimized away. */
11487 if (attr_form_is_block (attr
) && DW_BLOCK (attr
)->size
== 0)
11489 SYMBOL_CLASS (sym
) = LOC_OPTIMIZED_OUT
;
11493 /* Handle one degenerate form of location expression specially, to
11494 preserve GDB's previous behavior when section offsets are
11495 specified. If this is just a DW_OP_addr then mark this symbol
11498 if (attr_form_is_block (attr
)
11499 && DW_BLOCK (attr
)->size
== 1 + cu_header
->addr_size
11500 && DW_BLOCK (attr
)->data
[0] == DW_OP_addr
)
11502 unsigned int dummy
;
11504 SYMBOL_VALUE_ADDRESS (sym
) =
11505 read_address (objfile
->obfd
, DW_BLOCK (attr
)->data
+ 1, cu
, &dummy
);
11506 SYMBOL_CLASS (sym
) = LOC_STATIC
;
11507 fixup_symbol_section (sym
, objfile
);
11508 SYMBOL_VALUE_ADDRESS (sym
) += ANOFFSET (objfile
->section_offsets
,
11509 SYMBOL_SECTION (sym
));
11513 /* NOTE drow/2002-01-30: It might be worthwhile to have a static
11514 expression evaluator, and use LOC_COMPUTED only when necessary
11515 (i.e. when the value of a register or memory location is
11516 referenced, or a thread-local block, etc.). Then again, it might
11517 not be worthwhile. I'm assuming that it isn't unless performance
11518 or memory numbers show me otherwise. */
11520 dwarf2_symbol_mark_computed (attr
, sym
, cu
);
11521 SYMBOL_CLASS (sym
) = LOC_COMPUTED
;
11523 if (SYMBOL_COMPUTED_OPS (sym
) == &dwarf2_loclist_funcs
)
11524 cu
->has_loclist
= 1;
11527 /* Given a pointer to a DWARF information entry, figure out if we need
11528 to make a symbol table entry for it, and if so, create a new entry
11529 and return a pointer to it.
11530 If TYPE is NULL, determine symbol type from the die, otherwise
11531 used the passed type.
11532 If SPACE is not NULL, use it to hold the new symbol. If it is
11533 NULL, allocate a new symbol on the objfile's obstack. */
11535 static struct symbol
*
11536 new_symbol_full (struct die_info
*die
, struct type
*type
, struct dwarf2_cu
*cu
,
11537 struct symbol
*space
)
11539 struct objfile
*objfile
= cu
->objfile
;
11540 struct symbol
*sym
= NULL
;
11542 struct attribute
*attr
= NULL
;
11543 struct attribute
*attr2
= NULL
;
11544 CORE_ADDR baseaddr
;
11545 struct pending
**list_to_add
= NULL
;
11547 int inlined_func
= (die
->tag
== DW_TAG_inlined_subroutine
);
11549 baseaddr
= ANOFFSET (objfile
->section_offsets
, SECT_OFF_TEXT (objfile
));
11551 name
= dwarf2_name (die
, cu
);
11554 const char *linkagename
;
11555 int suppress_add
= 0;
11560 sym
= OBSTACK_ZALLOC (&objfile
->objfile_obstack
, struct symbol
);
11561 OBJSTAT (objfile
, n_syms
++);
11563 /* Cache this symbol's name and the name's demangled form (if any). */
11564 SYMBOL_SET_LANGUAGE (sym
, cu
->language
);
11565 linkagename
= dwarf2_physname (name
, die
, cu
);
11566 SYMBOL_SET_NAMES (sym
, linkagename
, strlen (linkagename
), 0, objfile
);
11568 /* Fortran does not have mangling standard and the mangling does differ
11569 between gfortran, iFort etc. */
11570 if (cu
->language
== language_fortran
11571 && symbol_get_demangled_name (&(sym
->ginfo
)) == NULL
)
11572 symbol_set_demangled_name (&(sym
->ginfo
),
11573 (char *) dwarf2_full_name (name
, die
, cu
),
11576 /* Default assumptions.
11577 Use the passed type or decode it from the die. */
11578 SYMBOL_DOMAIN (sym
) = VAR_DOMAIN
;
11579 SYMBOL_CLASS (sym
) = LOC_OPTIMIZED_OUT
;
11581 SYMBOL_TYPE (sym
) = type
;
11583 SYMBOL_TYPE (sym
) = die_type (die
, cu
);
11584 attr
= dwarf2_attr (die
,
11585 inlined_func
? DW_AT_call_line
: DW_AT_decl_line
,
11589 SYMBOL_LINE (sym
) = DW_UNSND (attr
);
11592 attr
= dwarf2_attr (die
,
11593 inlined_func
? DW_AT_call_file
: DW_AT_decl_file
,
11597 int file_index
= DW_UNSND (attr
);
11599 if (cu
->line_header
== NULL
11600 || file_index
> cu
->line_header
->num_file_names
)
11601 complaint (&symfile_complaints
,
11602 _("file index out of range"));
11603 else if (file_index
> 0)
11605 struct file_entry
*fe
;
11607 fe
= &cu
->line_header
->file_names
[file_index
- 1];
11608 SYMBOL_SYMTAB (sym
) = fe
->symtab
;
11615 attr
= dwarf2_attr (die
, DW_AT_low_pc
, cu
);
11618 SYMBOL_VALUE_ADDRESS (sym
) = DW_ADDR (attr
) + baseaddr
;
11620 SYMBOL_TYPE (sym
) = objfile_type (objfile
)->builtin_core_addr
;
11621 SYMBOL_DOMAIN (sym
) = LABEL_DOMAIN
;
11622 SYMBOL_CLASS (sym
) = LOC_LABEL
;
11623 add_symbol_to_list (sym
, cu
->list_in_scope
);
11625 case DW_TAG_subprogram
:
11626 /* SYMBOL_BLOCK_VALUE (sym) will be filled in later by
11628 SYMBOL_CLASS (sym
) = LOC_BLOCK
;
11629 attr2
= dwarf2_attr (die
, DW_AT_external
, cu
);
11630 if ((attr2
&& (DW_UNSND (attr2
) != 0))
11631 || cu
->language
== language_ada
)
11633 /* Subprograms marked external are stored as a global symbol.
11634 Ada subprograms, whether marked external or not, are always
11635 stored as a global symbol, because we want to be able to
11636 access them globally. For instance, we want to be able
11637 to break on a nested subprogram without having to
11638 specify the context. */
11639 list_to_add
= &global_symbols
;
11643 list_to_add
= cu
->list_in_scope
;
11646 case DW_TAG_inlined_subroutine
:
11647 /* SYMBOL_BLOCK_VALUE (sym) will be filled in later by
11649 SYMBOL_CLASS (sym
) = LOC_BLOCK
;
11650 SYMBOL_INLINED (sym
) = 1;
11651 /* Do not add the symbol to any lists. It will be found via
11652 BLOCK_FUNCTION from the blockvector. */
11654 case DW_TAG_template_value_param
:
11656 /* Fall through. */
11657 case DW_TAG_constant
:
11658 case DW_TAG_variable
:
11659 case DW_TAG_member
:
11660 /* Compilation with minimal debug info may result in
11661 variables with missing type entries. Change the
11662 misleading `void' type to something sensible. */
11663 if (TYPE_CODE (SYMBOL_TYPE (sym
)) == TYPE_CODE_VOID
)
11665 = objfile_type (objfile
)->nodebug_data_symbol
;
11667 attr
= dwarf2_attr (die
, DW_AT_const_value
, cu
);
11668 /* In the case of DW_TAG_member, we should only be called for
11669 static const members. */
11670 if (die
->tag
== DW_TAG_member
)
11672 /* dwarf2_add_field uses die_is_declaration,
11673 so we do the same. */
11674 gdb_assert (die_is_declaration (die
, cu
));
11679 dwarf2_const_value (attr
, sym
, cu
);
11680 attr2
= dwarf2_attr (die
, DW_AT_external
, cu
);
11683 if (attr2
&& (DW_UNSND (attr2
) != 0))
11684 list_to_add
= &global_symbols
;
11686 list_to_add
= cu
->list_in_scope
;
11690 attr
= dwarf2_attr (die
, DW_AT_location
, cu
);
11693 var_decode_location (attr
, sym
, cu
);
11694 attr2
= dwarf2_attr (die
, DW_AT_external
, cu
);
11695 if (SYMBOL_CLASS (sym
) == LOC_STATIC
11696 && SYMBOL_VALUE_ADDRESS (sym
) == 0
11697 && !dwarf2_per_objfile
->has_section_at_zero
)
11699 /* When a static variable is eliminated by the linker,
11700 the corresponding debug information is not stripped
11701 out, but the variable address is set to null;
11702 do not add such variables into symbol table. */
11704 else if (attr2
&& (DW_UNSND (attr2
) != 0))
11706 /* Workaround gfortran PR debug/40040 - it uses
11707 DW_AT_location for variables in -fPIC libraries which may
11708 get overriden by other libraries/executable and get
11709 a different address. Resolve it by the minimal symbol
11710 which may come from inferior's executable using copy
11711 relocation. Make this workaround only for gfortran as for
11712 other compilers GDB cannot guess the minimal symbol
11713 Fortran mangling kind. */
11714 if (cu
->language
== language_fortran
&& die
->parent
11715 && die
->parent
->tag
== DW_TAG_module
11717 && strncmp (cu
->producer
, "GNU Fortran ", 12) == 0)
11718 SYMBOL_CLASS (sym
) = LOC_UNRESOLVED
;
11720 /* A variable with DW_AT_external is never static,
11721 but it may be block-scoped. */
11722 list_to_add
= (cu
->list_in_scope
== &file_symbols
11723 ? &global_symbols
: cu
->list_in_scope
);
11726 list_to_add
= cu
->list_in_scope
;
11730 /* We do not know the address of this symbol.
11731 If it is an external symbol and we have type information
11732 for it, enter the symbol as a LOC_UNRESOLVED symbol.
11733 The address of the variable will then be determined from
11734 the minimal symbol table whenever the variable is
11736 attr2
= dwarf2_attr (die
, DW_AT_external
, cu
);
11737 if (attr2
&& (DW_UNSND (attr2
) != 0)
11738 && dwarf2_attr (die
, DW_AT_type
, cu
) != NULL
)
11740 /* A variable with DW_AT_external is never static, but it
11741 may be block-scoped. */
11742 list_to_add
= (cu
->list_in_scope
== &file_symbols
11743 ? &global_symbols
: cu
->list_in_scope
);
11745 SYMBOL_CLASS (sym
) = LOC_UNRESOLVED
;
11747 else if (!die_is_declaration (die
, cu
))
11749 /* Use the default LOC_OPTIMIZED_OUT class. */
11750 gdb_assert (SYMBOL_CLASS (sym
) == LOC_OPTIMIZED_OUT
);
11752 list_to_add
= cu
->list_in_scope
;
11756 case DW_TAG_formal_parameter
:
11757 /* If we are inside a function, mark this as an argument. If
11758 not, we might be looking at an argument to an inlined function
11759 when we do not have enough information to show inlined frames;
11760 pretend it's a local variable in that case so that the user can
11762 if (context_stack_depth
> 0
11763 && context_stack
[context_stack_depth
- 1].name
!= NULL
)
11764 SYMBOL_IS_ARGUMENT (sym
) = 1;
11765 attr
= dwarf2_attr (die
, DW_AT_location
, cu
);
11768 var_decode_location (attr
, sym
, cu
);
11770 attr
= dwarf2_attr (die
, DW_AT_const_value
, cu
);
11773 dwarf2_const_value (attr
, sym
, cu
);
11776 list_to_add
= cu
->list_in_scope
;
11778 case DW_TAG_unspecified_parameters
:
11779 /* From varargs functions; gdb doesn't seem to have any
11780 interest in this information, so just ignore it for now.
11783 case DW_TAG_template_type_param
:
11785 /* Fall through. */
11786 case DW_TAG_class_type
:
11787 case DW_TAG_interface_type
:
11788 case DW_TAG_structure_type
:
11789 case DW_TAG_union_type
:
11790 case DW_TAG_set_type
:
11791 case DW_TAG_enumeration_type
:
11792 SYMBOL_CLASS (sym
) = LOC_TYPEDEF
;
11793 SYMBOL_DOMAIN (sym
) = STRUCT_DOMAIN
;
11796 /* NOTE: carlton/2003-11-10: C++ and Java class symbols shouldn't
11797 really ever be static objects: otherwise, if you try
11798 to, say, break of a class's method and you're in a file
11799 which doesn't mention that class, it won't work unless
11800 the check for all static symbols in lookup_symbol_aux
11801 saves you. See the OtherFileClass tests in
11802 gdb.c++/namespace.exp. */
11806 list_to_add
= (cu
->list_in_scope
== &file_symbols
11807 && (cu
->language
== language_cplus
11808 || cu
->language
== language_java
)
11809 ? &global_symbols
: cu
->list_in_scope
);
11811 /* The semantics of C++ state that "struct foo {
11812 ... }" also defines a typedef for "foo". A Java
11813 class declaration also defines a typedef for the
11815 if (cu
->language
== language_cplus
11816 || cu
->language
== language_java
11817 || cu
->language
== language_ada
)
11819 /* The symbol's name is already allocated along
11820 with this objfile, so we don't need to
11821 duplicate it for the type. */
11822 if (TYPE_NAME (SYMBOL_TYPE (sym
)) == 0)
11823 TYPE_NAME (SYMBOL_TYPE (sym
)) = SYMBOL_SEARCH_NAME (sym
);
11828 case DW_TAG_typedef
:
11829 SYMBOL_CLASS (sym
) = LOC_TYPEDEF
;
11830 SYMBOL_DOMAIN (sym
) = VAR_DOMAIN
;
11831 list_to_add
= cu
->list_in_scope
;
11833 case DW_TAG_base_type
:
11834 case DW_TAG_subrange_type
:
11835 SYMBOL_CLASS (sym
) = LOC_TYPEDEF
;
11836 SYMBOL_DOMAIN (sym
) = VAR_DOMAIN
;
11837 list_to_add
= cu
->list_in_scope
;
11839 case DW_TAG_enumerator
:
11840 attr
= dwarf2_attr (die
, DW_AT_const_value
, cu
);
11843 dwarf2_const_value (attr
, sym
, cu
);
11846 /* NOTE: carlton/2003-11-10: See comment above in the
11847 DW_TAG_class_type, etc. block. */
11849 list_to_add
= (cu
->list_in_scope
== &file_symbols
11850 && (cu
->language
== language_cplus
11851 || cu
->language
== language_java
)
11852 ? &global_symbols
: cu
->list_in_scope
);
11855 case DW_TAG_namespace
:
11856 SYMBOL_CLASS (sym
) = LOC_TYPEDEF
;
11857 list_to_add
= &global_symbols
;
11860 /* Not a tag we recognize. Hopefully we aren't processing
11861 trash data, but since we must specifically ignore things
11862 we don't recognize, there is nothing else we should do at
11864 complaint (&symfile_complaints
, _("unsupported tag: '%s'"),
11865 dwarf_tag_name (die
->tag
));
11871 sym
->hash_next
= objfile
->template_symbols
;
11872 objfile
->template_symbols
= sym
;
11873 list_to_add
= NULL
;
11876 if (list_to_add
!= NULL
)
11877 add_symbol_to_list (sym
, list_to_add
);
11879 /* For the benefit of old versions of GCC, check for anonymous
11880 namespaces based on the demangled name. */
11881 if (!processing_has_namespace_info
11882 && cu
->language
== language_cplus
)
11883 cp_scan_for_anonymous_namespaces (sym
);
11888 /* A wrapper for new_symbol_full that always allocates a new symbol. */
11890 static struct symbol
*
11891 new_symbol (struct die_info
*die
, struct type
*type
, struct dwarf2_cu
*cu
)
11893 return new_symbol_full (die
, type
, cu
, NULL
);
11896 /* Given an attr with a DW_FORM_dataN value in host byte order,
11897 zero-extend it as appropriate for the symbol's type. The DWARF
11898 standard (v4) is not entirely clear about the meaning of using
11899 DW_FORM_dataN for a constant with a signed type, where the type is
11900 wider than the data. The conclusion of a discussion on the DWARF
11901 list was that this is unspecified. We choose to always zero-extend
11902 because that is the interpretation long in use by GCC. */
11905 dwarf2_const_value_data (struct attribute
*attr
, struct type
*type
,
11906 const char *name
, struct obstack
*obstack
,
11907 struct dwarf2_cu
*cu
, long *value
, int bits
)
11909 struct objfile
*objfile
= cu
->objfile
;
11910 enum bfd_endian byte_order
= bfd_big_endian (objfile
->obfd
) ?
11911 BFD_ENDIAN_BIG
: BFD_ENDIAN_LITTLE
;
11912 LONGEST l
= DW_UNSND (attr
);
11914 if (bits
< sizeof (*value
) * 8)
11916 l
&= ((LONGEST
) 1 << bits
) - 1;
11919 else if (bits
== sizeof (*value
) * 8)
11923 gdb_byte
*bytes
= obstack_alloc (obstack
, bits
/ 8);
11924 store_unsigned_integer (bytes
, bits
/ 8, byte_order
, l
);
11931 /* Read a constant value from an attribute. Either set *VALUE, or if
11932 the value does not fit in *VALUE, set *BYTES - either already
11933 allocated on the objfile obstack, or newly allocated on OBSTACK,
11934 or, set *BATON, if we translated the constant to a location
11938 dwarf2_const_value_attr (struct attribute
*attr
, struct type
*type
,
11939 const char *name
, struct obstack
*obstack
,
11940 struct dwarf2_cu
*cu
,
11941 long *value
, gdb_byte
**bytes
,
11942 struct dwarf2_locexpr_baton
**baton
)
11944 struct objfile
*objfile
= cu
->objfile
;
11945 struct comp_unit_head
*cu_header
= &cu
->header
;
11946 struct dwarf_block
*blk
;
11947 enum bfd_endian byte_order
= (bfd_big_endian (objfile
->obfd
) ?
11948 BFD_ENDIAN_BIG
: BFD_ENDIAN_LITTLE
);
11954 switch (attr
->form
)
11960 if (TYPE_LENGTH (type
) != cu_header
->addr_size
)
11961 dwarf2_const_value_length_mismatch_complaint (name
,
11962 cu_header
->addr_size
,
11963 TYPE_LENGTH (type
));
11964 /* Symbols of this form are reasonably rare, so we just
11965 piggyback on the existing location code rather than writing
11966 a new implementation of symbol_computed_ops. */
11967 *baton
= obstack_alloc (&objfile
->objfile_obstack
,
11968 sizeof (struct dwarf2_locexpr_baton
));
11969 (*baton
)->per_cu
= cu
->per_cu
;
11970 gdb_assert ((*baton
)->per_cu
);
11972 (*baton
)->size
= 2 + cu_header
->addr_size
;
11973 data
= obstack_alloc (&objfile
->objfile_obstack
, (*baton
)->size
);
11974 (*baton
)->data
= data
;
11976 data
[0] = DW_OP_addr
;
11977 store_unsigned_integer (&data
[1], cu_header
->addr_size
,
11978 byte_order
, DW_ADDR (attr
));
11979 data
[cu_header
->addr_size
+ 1] = DW_OP_stack_value
;
11982 case DW_FORM_string
:
11984 /* DW_STRING is already allocated on the objfile obstack, point
11986 *bytes
= (gdb_byte
*) DW_STRING (attr
);
11988 case DW_FORM_block1
:
11989 case DW_FORM_block2
:
11990 case DW_FORM_block4
:
11991 case DW_FORM_block
:
11992 case DW_FORM_exprloc
:
11993 blk
= DW_BLOCK (attr
);
11994 if (TYPE_LENGTH (type
) != blk
->size
)
11995 dwarf2_const_value_length_mismatch_complaint (name
, blk
->size
,
11996 TYPE_LENGTH (type
));
11997 *bytes
= blk
->data
;
12000 /* The DW_AT_const_value attributes are supposed to carry the
12001 symbol's value "represented as it would be on the target
12002 architecture." By the time we get here, it's already been
12003 converted to host endianness, so we just need to sign- or
12004 zero-extend it as appropriate. */
12005 case DW_FORM_data1
:
12006 *bytes
= dwarf2_const_value_data (attr
, type
, name
,
12007 obstack
, cu
, value
, 8);
12009 case DW_FORM_data2
:
12010 *bytes
= dwarf2_const_value_data (attr
, type
, name
,
12011 obstack
, cu
, value
, 16);
12013 case DW_FORM_data4
:
12014 *bytes
= dwarf2_const_value_data (attr
, type
, name
,
12015 obstack
, cu
, value
, 32);
12017 case DW_FORM_data8
:
12018 *bytes
= dwarf2_const_value_data (attr
, type
, name
,
12019 obstack
, cu
, value
, 64);
12022 case DW_FORM_sdata
:
12023 *value
= DW_SND (attr
);
12026 case DW_FORM_udata
:
12027 *value
= DW_UNSND (attr
);
12031 complaint (&symfile_complaints
,
12032 _("unsupported const value attribute form: '%s'"),
12033 dwarf_form_name (attr
->form
));
12040 /* Copy constant value from an attribute to a symbol. */
12043 dwarf2_const_value (struct attribute
*attr
, struct symbol
*sym
,
12044 struct dwarf2_cu
*cu
)
12046 struct objfile
*objfile
= cu
->objfile
;
12047 struct comp_unit_head
*cu_header
= &cu
->header
;
12050 struct dwarf2_locexpr_baton
*baton
;
12052 dwarf2_const_value_attr (attr
, SYMBOL_TYPE (sym
),
12053 SYMBOL_PRINT_NAME (sym
),
12054 &objfile
->objfile_obstack
, cu
,
12055 &value
, &bytes
, &baton
);
12059 SYMBOL_COMPUTED_OPS (sym
) = &dwarf2_locexpr_funcs
;
12060 SYMBOL_LOCATION_BATON (sym
) = baton
;
12061 SYMBOL_CLASS (sym
) = LOC_COMPUTED
;
12063 else if (bytes
!= NULL
)
12065 SYMBOL_VALUE_BYTES (sym
) = bytes
;
12066 SYMBOL_CLASS (sym
) = LOC_CONST_BYTES
;
12070 SYMBOL_VALUE (sym
) = value
;
12071 SYMBOL_CLASS (sym
) = LOC_CONST
;
12075 /* Return the type of the die in question using its DW_AT_type attribute. */
12077 static struct type
*
12078 die_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
12080 struct attribute
*type_attr
;
12082 type_attr
= dwarf2_attr (die
, DW_AT_type
, cu
);
12085 /* A missing DW_AT_type represents a void type. */
12086 return objfile_type (cu
->objfile
)->builtin_void
;
12089 return lookup_die_type (die
, type_attr
, cu
);
12092 /* True iff CU's producer generates GNAT Ada auxiliary information
12093 that allows to find parallel types through that information instead
12094 of having to do expensive parallel lookups by type name. */
12097 need_gnat_info (struct dwarf2_cu
*cu
)
12099 /* FIXME: brobecker/2010-10-12: As of now, only the AdaCore version
12100 of GNAT produces this auxiliary information, without any indication
12101 that it is produced. Part of enhancing the FSF version of GNAT
12102 to produce that information will be to put in place an indicator
12103 that we can use in order to determine whether the descriptive type
12104 info is available or not. One suggestion that has been made is
12105 to use a new attribute, attached to the CU die. For now, assume
12106 that the descriptive type info is not available. */
12110 /* Return the auxiliary type of the die in question using its
12111 DW_AT_GNAT_descriptive_type attribute. Returns NULL if the
12112 attribute is not present. */
12114 static struct type
*
12115 die_descriptive_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
12117 struct attribute
*type_attr
;
12119 type_attr
= dwarf2_attr (die
, DW_AT_GNAT_descriptive_type
, cu
);
12123 return lookup_die_type (die
, type_attr
, cu
);
12126 /* If DIE has a descriptive_type attribute, then set the TYPE's
12127 descriptive type accordingly. */
12130 set_descriptive_type (struct type
*type
, struct die_info
*die
,
12131 struct dwarf2_cu
*cu
)
12133 struct type
*descriptive_type
= die_descriptive_type (die
, cu
);
12135 if (descriptive_type
)
12137 ALLOCATE_GNAT_AUX_TYPE (type
);
12138 TYPE_DESCRIPTIVE_TYPE (type
) = descriptive_type
;
12142 /* Return the containing type of the die in question using its
12143 DW_AT_containing_type attribute. */
12145 static struct type
*
12146 die_containing_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
12148 struct attribute
*type_attr
;
12150 type_attr
= dwarf2_attr (die
, DW_AT_containing_type
, cu
);
12152 error (_("Dwarf Error: Problem turning containing type into gdb type "
12153 "[in module %s]"), cu
->objfile
->name
);
12155 return lookup_die_type (die
, type_attr
, cu
);
12158 /* Look up the type of DIE in CU using its type attribute ATTR.
12159 If there is no type substitute an error marker. */
12161 static struct type
*
12162 lookup_die_type (struct die_info
*die
, struct attribute
*attr
,
12163 struct dwarf2_cu
*cu
)
12165 struct type
*this_type
;
12167 /* First see if we have it cached. */
12169 if (is_ref_attr (attr
))
12171 unsigned int offset
= dwarf2_get_ref_die_offset (attr
);
12173 this_type
= get_die_type_at_offset (offset
, cu
->per_cu
);
12175 else if (attr
->form
== DW_FORM_ref_sig8
)
12177 struct signatured_type
*sig_type
= DW_SIGNATURED_TYPE (attr
);
12178 struct dwarf2_cu
*sig_cu
;
12179 unsigned int offset
;
12181 /* sig_type will be NULL if the signatured type is missing from
12183 if (sig_type
== NULL
)
12184 error (_("Dwarf Error: Cannot find signatured DIE referenced from DIE "
12185 "at 0x%x [in module %s]"),
12186 die
->offset
, cu
->objfile
->name
);
12188 gdb_assert (sig_type
->per_cu
.debug_type_section
);
12189 offset
= sig_type
->per_cu
.offset
+ sig_type
->type_offset
;
12190 this_type
= get_die_type_at_offset (offset
, &sig_type
->per_cu
);
12194 dump_die_for_error (die
);
12195 error (_("Dwarf Error: Bad type attribute %s [in module %s]"),
12196 dwarf_attr_name (attr
->name
), cu
->objfile
->name
);
12199 /* If not cached we need to read it in. */
12201 if (this_type
== NULL
)
12203 struct die_info
*type_die
;
12204 struct dwarf2_cu
*type_cu
= cu
;
12206 type_die
= follow_die_ref_or_sig (die
, attr
, &type_cu
);
12207 /* If the type is cached, we should have found it above. */
12208 gdb_assert (get_die_type (type_die
, type_cu
) == NULL
);
12209 this_type
= read_type_die_1 (type_die
, type_cu
);
12212 /* If we still don't have a type use an error marker. */
12214 if (this_type
== NULL
)
12216 char *message
, *saved
;
12218 /* read_type_die already issued a complaint. */
12219 message
= xstrprintf (_("<unknown type in %s, CU 0x%x, DIE 0x%x>"),
12223 saved
= obstack_copy0 (&cu
->objfile
->objfile_obstack
,
12224 message
, strlen (message
));
12227 this_type
= init_type (TYPE_CODE_ERROR
, 0, 0, saved
, cu
->objfile
);
12233 /* Return the type in DIE, CU.
12234 Returns NULL for invalid types.
12236 This first does a lookup in the appropriate type_hash table,
12237 and only reads the die in if necessary.
12239 NOTE: This can be called when reading in partial or full symbols. */
12241 static struct type
*
12242 read_type_die (struct die_info
*die
, struct dwarf2_cu
*cu
)
12244 struct type
*this_type
;
12246 this_type
= get_die_type (die
, cu
);
12250 return read_type_die_1 (die
, cu
);
12253 /* Read the type in DIE, CU.
12254 Returns NULL for invalid types. */
12256 static struct type
*
12257 read_type_die_1 (struct die_info
*die
, struct dwarf2_cu
*cu
)
12259 struct type
*this_type
= NULL
;
12263 case DW_TAG_class_type
:
12264 case DW_TAG_interface_type
:
12265 case DW_TAG_structure_type
:
12266 case DW_TAG_union_type
:
12267 this_type
= read_structure_type (die
, cu
);
12269 case DW_TAG_enumeration_type
:
12270 this_type
= read_enumeration_type (die
, cu
);
12272 case DW_TAG_subprogram
:
12273 case DW_TAG_subroutine_type
:
12274 case DW_TAG_inlined_subroutine
:
12275 this_type
= read_subroutine_type (die
, cu
);
12277 case DW_TAG_array_type
:
12278 this_type
= read_array_type (die
, cu
);
12280 case DW_TAG_set_type
:
12281 this_type
= read_set_type (die
, cu
);
12283 case DW_TAG_pointer_type
:
12284 this_type
= read_tag_pointer_type (die
, cu
);
12286 case DW_TAG_ptr_to_member_type
:
12287 this_type
= read_tag_ptr_to_member_type (die
, cu
);
12289 case DW_TAG_reference_type
:
12290 this_type
= read_tag_reference_type (die
, cu
);
12292 case DW_TAG_const_type
:
12293 this_type
= read_tag_const_type (die
, cu
);
12295 case DW_TAG_volatile_type
:
12296 this_type
= read_tag_volatile_type (die
, cu
);
12298 case DW_TAG_string_type
:
12299 this_type
= read_tag_string_type (die
, cu
);
12301 case DW_TAG_typedef
:
12302 this_type
= read_typedef (die
, cu
);
12304 case DW_TAG_subrange_type
:
12305 this_type
= read_subrange_type (die
, cu
);
12307 case DW_TAG_base_type
:
12308 this_type
= read_base_type (die
, cu
);
12310 case DW_TAG_unspecified_type
:
12311 this_type
= read_unspecified_type (die
, cu
);
12313 case DW_TAG_namespace
:
12314 this_type
= read_namespace_type (die
, cu
);
12316 case DW_TAG_module
:
12317 this_type
= read_module_type (die
, cu
);
12320 complaint (&symfile_complaints
,
12321 _("unexpected tag in read_type_die: '%s'"),
12322 dwarf_tag_name (die
->tag
));
12329 /* See if we can figure out if the class lives in a namespace. We do
12330 this by looking for a member function; its demangled name will
12331 contain namespace info, if there is any.
12332 Return the computed name or NULL.
12333 Space for the result is allocated on the objfile's obstack.
12334 This is the full-die version of guess_partial_die_structure_name.
12335 In this case we know DIE has no useful parent. */
12338 guess_full_die_structure_name (struct die_info
*die
, struct dwarf2_cu
*cu
)
12340 struct die_info
*spec_die
;
12341 struct dwarf2_cu
*spec_cu
;
12342 struct die_info
*child
;
12345 spec_die
= die_specification (die
, &spec_cu
);
12346 if (spec_die
!= NULL
)
12352 for (child
= die
->child
;
12354 child
= child
->sibling
)
12356 if (child
->tag
== DW_TAG_subprogram
)
12358 struct attribute
*attr
;
12360 attr
= dwarf2_attr (child
, DW_AT_linkage_name
, cu
);
12362 attr
= dwarf2_attr (child
, DW_AT_MIPS_linkage_name
, cu
);
12366 = language_class_name_from_physname (cu
->language_defn
,
12370 if (actual_name
!= NULL
)
12372 char *die_name
= dwarf2_name (die
, cu
);
12374 if (die_name
!= NULL
12375 && strcmp (die_name
, actual_name
) != 0)
12377 /* Strip off the class name from the full name.
12378 We want the prefix. */
12379 int die_name_len
= strlen (die_name
);
12380 int actual_name_len
= strlen (actual_name
);
12382 /* Test for '::' as a sanity check. */
12383 if (actual_name_len
> die_name_len
+ 2
12384 && actual_name
[actual_name_len
12385 - die_name_len
- 1] == ':')
12387 obsavestring (actual_name
,
12388 actual_name_len
- die_name_len
- 2,
12389 &cu
->objfile
->objfile_obstack
);
12392 xfree (actual_name
);
12401 /* GCC might emit a nameless typedef that has a linkage name. Determine the
12402 prefix part in such case. See
12403 http://gcc.gnu.org/bugzilla/show_bug.cgi?id=47510. */
12406 anonymous_struct_prefix (struct die_info
*die
, struct dwarf2_cu
*cu
)
12408 struct attribute
*attr
;
12411 if (die
->tag
!= DW_TAG_class_type
&& die
->tag
!= DW_TAG_interface_type
12412 && die
->tag
!= DW_TAG_structure_type
&& die
->tag
!= DW_TAG_union_type
)
12415 attr
= dwarf2_attr (die
, DW_AT_name
, cu
);
12416 if (attr
!= NULL
&& DW_STRING (attr
) != NULL
)
12419 attr
= dwarf2_attr (die
, DW_AT_linkage_name
, cu
);
12421 attr
= dwarf2_attr (die
, DW_AT_MIPS_linkage_name
, cu
);
12422 if (attr
== NULL
|| DW_STRING (attr
) == NULL
)
12425 /* dwarf2_name had to be already called. */
12426 gdb_assert (DW_STRING_IS_CANONICAL (attr
));
12428 /* Strip the base name, keep any leading namespaces/classes. */
12429 base
= strrchr (DW_STRING (attr
), ':');
12430 if (base
== NULL
|| base
== DW_STRING (attr
) || base
[-1] != ':')
12433 return obsavestring (DW_STRING (attr
), &base
[-1] - DW_STRING (attr
),
12434 &cu
->objfile
->objfile_obstack
);
12437 /* Return the name of the namespace/class that DIE is defined within,
12438 or "" if we can't tell. The caller should not xfree the result.
12440 For example, if we're within the method foo() in the following
12450 then determine_prefix on foo's die will return "N::C". */
12453 determine_prefix (struct die_info
*die
, struct dwarf2_cu
*cu
)
12455 struct die_info
*parent
, *spec_die
;
12456 struct dwarf2_cu
*spec_cu
;
12457 struct type
*parent_type
;
12460 if (cu
->language
!= language_cplus
&& cu
->language
!= language_java
12461 && cu
->language
!= language_fortran
)
12464 retval
= anonymous_struct_prefix (die
, cu
);
12468 /* We have to be careful in the presence of DW_AT_specification.
12469 For example, with GCC 3.4, given the code
12473 // Definition of N::foo.
12477 then we'll have a tree of DIEs like this:
12479 1: DW_TAG_compile_unit
12480 2: DW_TAG_namespace // N
12481 3: DW_TAG_subprogram // declaration of N::foo
12482 4: DW_TAG_subprogram // definition of N::foo
12483 DW_AT_specification // refers to die #3
12485 Thus, when processing die #4, we have to pretend that we're in
12486 the context of its DW_AT_specification, namely the contex of die
12489 spec_die
= die_specification (die
, &spec_cu
);
12490 if (spec_die
== NULL
)
12491 parent
= die
->parent
;
12494 parent
= spec_die
->parent
;
12498 if (parent
== NULL
)
12500 else if (parent
->building_fullname
)
12503 const char *parent_name
;
12505 /* It has been seen on RealView 2.2 built binaries,
12506 DW_TAG_template_type_param types actually _defined_ as
12507 children of the parent class:
12510 template class <class Enum> Class{};
12511 Class<enum E> class_e;
12513 1: DW_TAG_class_type (Class)
12514 2: DW_TAG_enumeration_type (E)
12515 3: DW_TAG_enumerator (enum1:0)
12516 3: DW_TAG_enumerator (enum2:1)
12518 2: DW_TAG_template_type_param
12519 DW_AT_type DW_FORM_ref_udata (E)
12521 Besides being broken debug info, it can put GDB into an
12522 infinite loop. Consider:
12524 When we're building the full name for Class<E>, we'll start
12525 at Class, and go look over its template type parameters,
12526 finding E. We'll then try to build the full name of E, and
12527 reach here. We're now trying to build the full name of E,
12528 and look over the parent DIE for containing scope. In the
12529 broken case, if we followed the parent DIE of E, we'd again
12530 find Class, and once again go look at its template type
12531 arguments, etc., etc. Simply don't consider such parent die
12532 as source-level parent of this die (it can't be, the language
12533 doesn't allow it), and break the loop here. */
12534 name
= dwarf2_name (die
, cu
);
12535 parent_name
= dwarf2_name (parent
, cu
);
12536 complaint (&symfile_complaints
,
12537 _("template param type '%s' defined within parent '%s'"),
12538 name
? name
: "<unknown>",
12539 parent_name
? parent_name
: "<unknown>");
12543 switch (parent
->tag
)
12545 case DW_TAG_namespace
:
12546 parent_type
= read_type_die (parent
, cu
);
12547 /* GCC 4.0 and 4.1 had a bug (PR c++/28460) where they generated bogus
12548 DW_TAG_namespace DIEs with a name of "::" for the global namespace.
12549 Work around this problem here. */
12550 if (cu
->language
== language_cplus
12551 && strcmp (TYPE_TAG_NAME (parent_type
), "::") == 0)
12553 /* We give a name to even anonymous namespaces. */
12554 return TYPE_TAG_NAME (parent_type
);
12555 case DW_TAG_class_type
:
12556 case DW_TAG_interface_type
:
12557 case DW_TAG_structure_type
:
12558 case DW_TAG_union_type
:
12559 case DW_TAG_module
:
12560 parent_type
= read_type_die (parent
, cu
);
12561 if (TYPE_TAG_NAME (parent_type
) != NULL
)
12562 return TYPE_TAG_NAME (parent_type
);
12564 /* An anonymous structure is only allowed non-static data
12565 members; no typedefs, no member functions, et cetera.
12566 So it does not need a prefix. */
12568 case DW_TAG_compile_unit
:
12569 /* gcc-4.5 -gdwarf-4 can drop the enclosing namespace. Cope. */
12570 if (cu
->language
== language_cplus
12571 && !VEC_empty (dwarf2_section_info_def
, dwarf2_per_objfile
->types
)
12572 && die
->child
!= NULL
12573 && (die
->tag
== DW_TAG_class_type
12574 || die
->tag
== DW_TAG_structure_type
12575 || die
->tag
== DW_TAG_union_type
))
12577 char *name
= guess_full_die_structure_name (die
, cu
);
12583 return determine_prefix (parent
, cu
);
12587 /* Return a newly-allocated string formed by concatenating PREFIX and SUFFIX
12588 with appropriate separator. If PREFIX or SUFFIX is NULL or empty, then
12589 simply copy the SUFFIX or PREFIX, respectively. If OBS is non-null, perform
12590 an obconcat, otherwise allocate storage for the result. The CU argument is
12591 used to determine the language and hence, the appropriate separator. */
12593 #define MAX_SEP_LEN 7 /* strlen ("__") + strlen ("_MOD_") */
12596 typename_concat (struct obstack
*obs
, const char *prefix
, const char *suffix
,
12597 int physname
, struct dwarf2_cu
*cu
)
12599 const char *lead
= "";
12602 if (suffix
== NULL
|| suffix
[0] == '\0'
12603 || prefix
== NULL
|| prefix
[0] == '\0')
12605 else if (cu
->language
== language_java
)
12607 else if (cu
->language
== language_fortran
&& physname
)
12609 /* This is gfortran specific mangling. Normally DW_AT_linkage_name or
12610 DW_AT_MIPS_linkage_name is preferred and used instead. */
12618 if (prefix
== NULL
)
12620 if (suffix
== NULL
)
12626 = xmalloc (strlen (prefix
) + MAX_SEP_LEN
+ strlen (suffix
) + 1);
12628 strcpy (retval
, lead
);
12629 strcat (retval
, prefix
);
12630 strcat (retval
, sep
);
12631 strcat (retval
, suffix
);
12636 /* We have an obstack. */
12637 return obconcat (obs
, lead
, prefix
, sep
, suffix
, (char *) NULL
);
12641 /* Return sibling of die, NULL if no sibling. */
12643 static struct die_info
*
12644 sibling_die (struct die_info
*die
)
12646 return die
->sibling
;
12649 /* Get name of a die, return NULL if not found. */
12652 dwarf2_canonicalize_name (char *name
, struct dwarf2_cu
*cu
,
12653 struct obstack
*obstack
)
12655 if (name
&& cu
->language
== language_cplus
)
12657 char *canon_name
= cp_canonicalize_string (name
);
12659 if (canon_name
!= NULL
)
12661 if (strcmp (canon_name
, name
) != 0)
12662 name
= obsavestring (canon_name
, strlen (canon_name
),
12664 xfree (canon_name
);
12671 /* Get name of a die, return NULL if not found. */
12674 dwarf2_name (struct die_info
*die
, struct dwarf2_cu
*cu
)
12676 struct attribute
*attr
;
12678 attr
= dwarf2_attr (die
, DW_AT_name
, cu
);
12679 if ((!attr
|| !DW_STRING (attr
))
12680 && die
->tag
!= DW_TAG_class_type
12681 && die
->tag
!= DW_TAG_interface_type
12682 && die
->tag
!= DW_TAG_structure_type
12683 && die
->tag
!= DW_TAG_union_type
)
12688 case DW_TAG_compile_unit
:
12689 /* Compilation units have a DW_AT_name that is a filename, not
12690 a source language identifier. */
12691 case DW_TAG_enumeration_type
:
12692 case DW_TAG_enumerator
:
12693 /* These tags always have simple identifiers already; no need
12694 to canonicalize them. */
12695 return DW_STRING (attr
);
12697 case DW_TAG_subprogram
:
12698 /* Java constructors will all be named "<init>", so return
12699 the class name when we see this special case. */
12700 if (cu
->language
== language_java
12701 && DW_STRING (attr
) != NULL
12702 && strcmp (DW_STRING (attr
), "<init>") == 0)
12704 struct dwarf2_cu
*spec_cu
= cu
;
12705 struct die_info
*spec_die
;
12707 /* GCJ will output '<init>' for Java constructor names.
12708 For this special case, return the name of the parent class. */
12710 /* GCJ may output suprogram DIEs with AT_specification set.
12711 If so, use the name of the specified DIE. */
12712 spec_die
= die_specification (die
, &spec_cu
);
12713 if (spec_die
!= NULL
)
12714 return dwarf2_name (spec_die
, spec_cu
);
12719 if (die
->tag
== DW_TAG_class_type
)
12720 return dwarf2_name (die
, cu
);
12722 while (die
->tag
!= DW_TAG_compile_unit
);
12726 case DW_TAG_class_type
:
12727 case DW_TAG_interface_type
:
12728 case DW_TAG_structure_type
:
12729 case DW_TAG_union_type
:
12730 /* Some GCC versions emit spurious DW_AT_name attributes for unnamed
12731 structures or unions. These were of the form "._%d" in GCC 4.1,
12732 or simply "<anonymous struct>" or "<anonymous union>" in GCC 4.3
12733 and GCC 4.4. We work around this problem by ignoring these. */
12734 if (attr
&& DW_STRING (attr
)
12735 && (strncmp (DW_STRING (attr
), "._", 2) == 0
12736 || strncmp (DW_STRING (attr
), "<anonymous", 10) == 0))
12739 /* GCC might emit a nameless typedef that has a linkage name. See
12740 http://gcc.gnu.org/bugzilla/show_bug.cgi?id=47510. */
12741 if (!attr
|| DW_STRING (attr
) == NULL
)
12743 char *demangled
= NULL
;
12745 attr
= dwarf2_attr (die
, DW_AT_linkage_name
, cu
);
12747 attr
= dwarf2_attr (die
, DW_AT_MIPS_linkage_name
, cu
);
12749 if (attr
== NULL
|| DW_STRING (attr
) == NULL
)
12752 /* Avoid demangling DW_STRING (attr) the second time on a second
12753 call for the same DIE. */
12754 if (!DW_STRING_IS_CANONICAL (attr
))
12755 demangled
= cplus_demangle (DW_STRING (attr
), DMGL_TYPES
);
12761 /* FIXME: we already did this for the partial symbol... */
12762 DW_STRING (attr
) = obsavestring (demangled
, strlen (demangled
),
12763 &cu
->objfile
->objfile_obstack
);
12764 DW_STRING_IS_CANONICAL (attr
) = 1;
12767 /* Strip any leading namespaces/classes, keep only the base name.
12768 DW_AT_name for named DIEs does not contain the prefixes. */
12769 base
= strrchr (DW_STRING (attr
), ':');
12770 if (base
&& base
> DW_STRING (attr
) && base
[-1] == ':')
12773 return DW_STRING (attr
);
12782 if (!DW_STRING_IS_CANONICAL (attr
))
12785 = dwarf2_canonicalize_name (DW_STRING (attr
), cu
,
12786 &cu
->objfile
->objfile_obstack
);
12787 DW_STRING_IS_CANONICAL (attr
) = 1;
12789 return DW_STRING (attr
);
12792 /* Return the die that this die in an extension of, or NULL if there
12793 is none. *EXT_CU is the CU containing DIE on input, and the CU
12794 containing the return value on output. */
12796 static struct die_info
*
12797 dwarf2_extension (struct die_info
*die
, struct dwarf2_cu
**ext_cu
)
12799 struct attribute
*attr
;
12801 attr
= dwarf2_attr (die
, DW_AT_extension
, *ext_cu
);
12805 return follow_die_ref (die
, attr
, ext_cu
);
12808 /* Convert a DIE tag into its string name. */
12811 dwarf_tag_name (unsigned tag
)
12815 case DW_TAG_padding
:
12816 return "DW_TAG_padding";
12817 case DW_TAG_array_type
:
12818 return "DW_TAG_array_type";
12819 case DW_TAG_class_type
:
12820 return "DW_TAG_class_type";
12821 case DW_TAG_entry_point
:
12822 return "DW_TAG_entry_point";
12823 case DW_TAG_enumeration_type
:
12824 return "DW_TAG_enumeration_type";
12825 case DW_TAG_formal_parameter
:
12826 return "DW_TAG_formal_parameter";
12827 case DW_TAG_imported_declaration
:
12828 return "DW_TAG_imported_declaration";
12830 return "DW_TAG_label";
12831 case DW_TAG_lexical_block
:
12832 return "DW_TAG_lexical_block";
12833 case DW_TAG_member
:
12834 return "DW_TAG_member";
12835 case DW_TAG_pointer_type
:
12836 return "DW_TAG_pointer_type";
12837 case DW_TAG_reference_type
:
12838 return "DW_TAG_reference_type";
12839 case DW_TAG_compile_unit
:
12840 return "DW_TAG_compile_unit";
12841 case DW_TAG_string_type
:
12842 return "DW_TAG_string_type";
12843 case DW_TAG_structure_type
:
12844 return "DW_TAG_structure_type";
12845 case DW_TAG_subroutine_type
:
12846 return "DW_TAG_subroutine_type";
12847 case DW_TAG_typedef
:
12848 return "DW_TAG_typedef";
12849 case DW_TAG_union_type
:
12850 return "DW_TAG_union_type";
12851 case DW_TAG_unspecified_parameters
:
12852 return "DW_TAG_unspecified_parameters";
12853 case DW_TAG_variant
:
12854 return "DW_TAG_variant";
12855 case DW_TAG_common_block
:
12856 return "DW_TAG_common_block";
12857 case DW_TAG_common_inclusion
:
12858 return "DW_TAG_common_inclusion";
12859 case DW_TAG_inheritance
:
12860 return "DW_TAG_inheritance";
12861 case DW_TAG_inlined_subroutine
:
12862 return "DW_TAG_inlined_subroutine";
12863 case DW_TAG_module
:
12864 return "DW_TAG_module";
12865 case DW_TAG_ptr_to_member_type
:
12866 return "DW_TAG_ptr_to_member_type";
12867 case DW_TAG_set_type
:
12868 return "DW_TAG_set_type";
12869 case DW_TAG_subrange_type
:
12870 return "DW_TAG_subrange_type";
12871 case DW_TAG_with_stmt
:
12872 return "DW_TAG_with_stmt";
12873 case DW_TAG_access_declaration
:
12874 return "DW_TAG_access_declaration";
12875 case DW_TAG_base_type
:
12876 return "DW_TAG_base_type";
12877 case DW_TAG_catch_block
:
12878 return "DW_TAG_catch_block";
12879 case DW_TAG_const_type
:
12880 return "DW_TAG_const_type";
12881 case DW_TAG_constant
:
12882 return "DW_TAG_constant";
12883 case DW_TAG_enumerator
:
12884 return "DW_TAG_enumerator";
12885 case DW_TAG_file_type
:
12886 return "DW_TAG_file_type";
12887 case DW_TAG_friend
:
12888 return "DW_TAG_friend";
12889 case DW_TAG_namelist
:
12890 return "DW_TAG_namelist";
12891 case DW_TAG_namelist_item
:
12892 return "DW_TAG_namelist_item";
12893 case DW_TAG_packed_type
:
12894 return "DW_TAG_packed_type";
12895 case DW_TAG_subprogram
:
12896 return "DW_TAG_subprogram";
12897 case DW_TAG_template_type_param
:
12898 return "DW_TAG_template_type_param";
12899 case DW_TAG_template_value_param
:
12900 return "DW_TAG_template_value_param";
12901 case DW_TAG_thrown_type
:
12902 return "DW_TAG_thrown_type";
12903 case DW_TAG_try_block
:
12904 return "DW_TAG_try_block";
12905 case DW_TAG_variant_part
:
12906 return "DW_TAG_variant_part";
12907 case DW_TAG_variable
:
12908 return "DW_TAG_variable";
12909 case DW_TAG_volatile_type
:
12910 return "DW_TAG_volatile_type";
12911 case DW_TAG_dwarf_procedure
:
12912 return "DW_TAG_dwarf_procedure";
12913 case DW_TAG_restrict_type
:
12914 return "DW_TAG_restrict_type";
12915 case DW_TAG_interface_type
:
12916 return "DW_TAG_interface_type";
12917 case DW_TAG_namespace
:
12918 return "DW_TAG_namespace";
12919 case DW_TAG_imported_module
:
12920 return "DW_TAG_imported_module";
12921 case DW_TAG_unspecified_type
:
12922 return "DW_TAG_unspecified_type";
12923 case DW_TAG_partial_unit
:
12924 return "DW_TAG_partial_unit";
12925 case DW_TAG_imported_unit
:
12926 return "DW_TAG_imported_unit";
12927 case DW_TAG_condition
:
12928 return "DW_TAG_condition";
12929 case DW_TAG_shared_type
:
12930 return "DW_TAG_shared_type";
12931 case DW_TAG_type_unit
:
12932 return "DW_TAG_type_unit";
12933 case DW_TAG_MIPS_loop
:
12934 return "DW_TAG_MIPS_loop";
12935 case DW_TAG_HP_array_descriptor
:
12936 return "DW_TAG_HP_array_descriptor";
12937 case DW_TAG_format_label
:
12938 return "DW_TAG_format_label";
12939 case DW_TAG_function_template
:
12940 return "DW_TAG_function_template";
12941 case DW_TAG_class_template
:
12942 return "DW_TAG_class_template";
12943 case DW_TAG_GNU_BINCL
:
12944 return "DW_TAG_GNU_BINCL";
12945 case DW_TAG_GNU_EINCL
:
12946 return "DW_TAG_GNU_EINCL";
12947 case DW_TAG_upc_shared_type
:
12948 return "DW_TAG_upc_shared_type";
12949 case DW_TAG_upc_strict_type
:
12950 return "DW_TAG_upc_strict_type";
12951 case DW_TAG_upc_relaxed_type
:
12952 return "DW_TAG_upc_relaxed_type";
12953 case DW_TAG_PGI_kanji_type
:
12954 return "DW_TAG_PGI_kanji_type";
12955 case DW_TAG_PGI_interface_block
:
12956 return "DW_TAG_PGI_interface_block";
12957 case DW_TAG_GNU_call_site
:
12958 return "DW_TAG_GNU_call_site";
12960 return "DW_TAG_<unknown>";
12964 /* Convert a DWARF attribute code into its string name. */
12967 dwarf_attr_name (unsigned attr
)
12971 case DW_AT_sibling
:
12972 return "DW_AT_sibling";
12973 case DW_AT_location
:
12974 return "DW_AT_location";
12976 return "DW_AT_name";
12977 case DW_AT_ordering
:
12978 return "DW_AT_ordering";
12979 case DW_AT_subscr_data
:
12980 return "DW_AT_subscr_data";
12981 case DW_AT_byte_size
:
12982 return "DW_AT_byte_size";
12983 case DW_AT_bit_offset
:
12984 return "DW_AT_bit_offset";
12985 case DW_AT_bit_size
:
12986 return "DW_AT_bit_size";
12987 case DW_AT_element_list
:
12988 return "DW_AT_element_list";
12989 case DW_AT_stmt_list
:
12990 return "DW_AT_stmt_list";
12992 return "DW_AT_low_pc";
12993 case DW_AT_high_pc
:
12994 return "DW_AT_high_pc";
12995 case DW_AT_language
:
12996 return "DW_AT_language";
12998 return "DW_AT_member";
13000 return "DW_AT_discr";
13001 case DW_AT_discr_value
:
13002 return "DW_AT_discr_value";
13003 case DW_AT_visibility
:
13004 return "DW_AT_visibility";
13006 return "DW_AT_import";
13007 case DW_AT_string_length
:
13008 return "DW_AT_string_length";
13009 case DW_AT_common_reference
:
13010 return "DW_AT_common_reference";
13011 case DW_AT_comp_dir
:
13012 return "DW_AT_comp_dir";
13013 case DW_AT_const_value
:
13014 return "DW_AT_const_value";
13015 case DW_AT_containing_type
:
13016 return "DW_AT_containing_type";
13017 case DW_AT_default_value
:
13018 return "DW_AT_default_value";
13020 return "DW_AT_inline";
13021 case DW_AT_is_optional
:
13022 return "DW_AT_is_optional";
13023 case DW_AT_lower_bound
:
13024 return "DW_AT_lower_bound";
13025 case DW_AT_producer
:
13026 return "DW_AT_producer";
13027 case DW_AT_prototyped
:
13028 return "DW_AT_prototyped";
13029 case DW_AT_return_addr
:
13030 return "DW_AT_return_addr";
13031 case DW_AT_start_scope
:
13032 return "DW_AT_start_scope";
13033 case DW_AT_bit_stride
:
13034 return "DW_AT_bit_stride";
13035 case DW_AT_upper_bound
:
13036 return "DW_AT_upper_bound";
13037 case DW_AT_abstract_origin
:
13038 return "DW_AT_abstract_origin";
13039 case DW_AT_accessibility
:
13040 return "DW_AT_accessibility";
13041 case DW_AT_address_class
:
13042 return "DW_AT_address_class";
13043 case DW_AT_artificial
:
13044 return "DW_AT_artificial";
13045 case DW_AT_base_types
:
13046 return "DW_AT_base_types";
13047 case DW_AT_calling_convention
:
13048 return "DW_AT_calling_convention";
13050 return "DW_AT_count";
13051 case DW_AT_data_member_location
:
13052 return "DW_AT_data_member_location";
13053 case DW_AT_decl_column
:
13054 return "DW_AT_decl_column";
13055 case DW_AT_decl_file
:
13056 return "DW_AT_decl_file";
13057 case DW_AT_decl_line
:
13058 return "DW_AT_decl_line";
13059 case DW_AT_declaration
:
13060 return "DW_AT_declaration";
13061 case DW_AT_discr_list
:
13062 return "DW_AT_discr_list";
13063 case DW_AT_encoding
:
13064 return "DW_AT_encoding";
13065 case DW_AT_external
:
13066 return "DW_AT_external";
13067 case DW_AT_frame_base
:
13068 return "DW_AT_frame_base";
13070 return "DW_AT_friend";
13071 case DW_AT_identifier_case
:
13072 return "DW_AT_identifier_case";
13073 case DW_AT_macro_info
:
13074 return "DW_AT_macro_info";
13075 case DW_AT_namelist_items
:
13076 return "DW_AT_namelist_items";
13077 case DW_AT_priority
:
13078 return "DW_AT_priority";
13079 case DW_AT_segment
:
13080 return "DW_AT_segment";
13081 case DW_AT_specification
:
13082 return "DW_AT_specification";
13083 case DW_AT_static_link
:
13084 return "DW_AT_static_link";
13086 return "DW_AT_type";
13087 case DW_AT_use_location
:
13088 return "DW_AT_use_location";
13089 case DW_AT_variable_parameter
:
13090 return "DW_AT_variable_parameter";
13091 case DW_AT_virtuality
:
13092 return "DW_AT_virtuality";
13093 case DW_AT_vtable_elem_location
:
13094 return "DW_AT_vtable_elem_location";
13095 /* DWARF 3 values. */
13096 case DW_AT_allocated
:
13097 return "DW_AT_allocated";
13098 case DW_AT_associated
:
13099 return "DW_AT_associated";
13100 case DW_AT_data_location
:
13101 return "DW_AT_data_location";
13102 case DW_AT_byte_stride
:
13103 return "DW_AT_byte_stride";
13104 case DW_AT_entry_pc
:
13105 return "DW_AT_entry_pc";
13106 case DW_AT_use_UTF8
:
13107 return "DW_AT_use_UTF8";
13108 case DW_AT_extension
:
13109 return "DW_AT_extension";
13111 return "DW_AT_ranges";
13112 case DW_AT_trampoline
:
13113 return "DW_AT_trampoline";
13114 case DW_AT_call_column
:
13115 return "DW_AT_call_column";
13116 case DW_AT_call_file
:
13117 return "DW_AT_call_file";
13118 case DW_AT_call_line
:
13119 return "DW_AT_call_line";
13120 case DW_AT_description
:
13121 return "DW_AT_description";
13122 case DW_AT_binary_scale
:
13123 return "DW_AT_binary_scale";
13124 case DW_AT_decimal_scale
:
13125 return "DW_AT_decimal_scale";
13127 return "DW_AT_small";
13128 case DW_AT_decimal_sign
:
13129 return "DW_AT_decimal_sign";
13130 case DW_AT_digit_count
:
13131 return "DW_AT_digit_count";
13132 case DW_AT_picture_string
:
13133 return "DW_AT_picture_string";
13134 case DW_AT_mutable
:
13135 return "DW_AT_mutable";
13136 case DW_AT_threads_scaled
:
13137 return "DW_AT_threads_scaled";
13138 case DW_AT_explicit
:
13139 return "DW_AT_explicit";
13140 case DW_AT_object_pointer
:
13141 return "DW_AT_object_pointer";
13142 case DW_AT_endianity
:
13143 return "DW_AT_endianity";
13144 case DW_AT_elemental
:
13145 return "DW_AT_elemental";
13147 return "DW_AT_pure";
13148 case DW_AT_recursive
:
13149 return "DW_AT_recursive";
13150 /* DWARF 4 values. */
13151 case DW_AT_signature
:
13152 return "DW_AT_signature";
13153 case DW_AT_linkage_name
:
13154 return "DW_AT_linkage_name";
13155 /* SGI/MIPS extensions. */
13156 #ifdef MIPS /* collides with DW_AT_HP_block_index */
13157 case DW_AT_MIPS_fde
:
13158 return "DW_AT_MIPS_fde";
13160 case DW_AT_MIPS_loop_begin
:
13161 return "DW_AT_MIPS_loop_begin";
13162 case DW_AT_MIPS_tail_loop_begin
:
13163 return "DW_AT_MIPS_tail_loop_begin";
13164 case DW_AT_MIPS_epilog_begin
:
13165 return "DW_AT_MIPS_epilog_begin";
13166 case DW_AT_MIPS_loop_unroll_factor
:
13167 return "DW_AT_MIPS_loop_unroll_factor";
13168 case DW_AT_MIPS_software_pipeline_depth
:
13169 return "DW_AT_MIPS_software_pipeline_depth";
13170 case DW_AT_MIPS_linkage_name
:
13171 return "DW_AT_MIPS_linkage_name";
13172 case DW_AT_MIPS_stride
:
13173 return "DW_AT_MIPS_stride";
13174 case DW_AT_MIPS_abstract_name
:
13175 return "DW_AT_MIPS_abstract_name";
13176 case DW_AT_MIPS_clone_origin
:
13177 return "DW_AT_MIPS_clone_origin";
13178 case DW_AT_MIPS_has_inlines
:
13179 return "DW_AT_MIPS_has_inlines";
13180 /* HP extensions. */
13181 #ifndef MIPS /* collides with DW_AT_MIPS_fde */
13182 case DW_AT_HP_block_index
:
13183 return "DW_AT_HP_block_index";
13185 case DW_AT_HP_unmodifiable
:
13186 return "DW_AT_HP_unmodifiable";
13187 case DW_AT_HP_actuals_stmt_list
:
13188 return "DW_AT_HP_actuals_stmt_list";
13189 case DW_AT_HP_proc_per_section
:
13190 return "DW_AT_HP_proc_per_section";
13191 case DW_AT_HP_raw_data_ptr
:
13192 return "DW_AT_HP_raw_data_ptr";
13193 case DW_AT_HP_pass_by_reference
:
13194 return "DW_AT_HP_pass_by_reference";
13195 case DW_AT_HP_opt_level
:
13196 return "DW_AT_HP_opt_level";
13197 case DW_AT_HP_prof_version_id
:
13198 return "DW_AT_HP_prof_version_id";
13199 case DW_AT_HP_opt_flags
:
13200 return "DW_AT_HP_opt_flags";
13201 case DW_AT_HP_cold_region_low_pc
:
13202 return "DW_AT_HP_cold_region_low_pc";
13203 case DW_AT_HP_cold_region_high_pc
:
13204 return "DW_AT_HP_cold_region_high_pc";
13205 case DW_AT_HP_all_variables_modifiable
:
13206 return "DW_AT_HP_all_variables_modifiable";
13207 case DW_AT_HP_linkage_name
:
13208 return "DW_AT_HP_linkage_name";
13209 case DW_AT_HP_prof_flags
:
13210 return "DW_AT_HP_prof_flags";
13211 /* GNU extensions. */
13212 case DW_AT_sf_names
:
13213 return "DW_AT_sf_names";
13214 case DW_AT_src_info
:
13215 return "DW_AT_src_info";
13216 case DW_AT_mac_info
:
13217 return "DW_AT_mac_info";
13218 case DW_AT_src_coords
:
13219 return "DW_AT_src_coords";
13220 case DW_AT_body_begin
:
13221 return "DW_AT_body_begin";
13222 case DW_AT_body_end
:
13223 return "DW_AT_body_end";
13224 case DW_AT_GNU_vector
:
13225 return "DW_AT_GNU_vector";
13226 case DW_AT_GNU_odr_signature
:
13227 return "DW_AT_GNU_odr_signature";
13228 /* VMS extensions. */
13229 case DW_AT_VMS_rtnbeg_pd_address
:
13230 return "DW_AT_VMS_rtnbeg_pd_address";
13231 /* UPC extension. */
13232 case DW_AT_upc_threads_scaled
:
13233 return "DW_AT_upc_threads_scaled";
13234 /* PGI (STMicroelectronics) extensions. */
13235 case DW_AT_PGI_lbase
:
13236 return "DW_AT_PGI_lbase";
13237 case DW_AT_PGI_soffset
:
13238 return "DW_AT_PGI_soffset";
13239 case DW_AT_PGI_lstride
:
13240 return "DW_AT_PGI_lstride";
13242 return "DW_AT_<unknown>";
13246 /* Convert a DWARF value form code into its string name. */
13249 dwarf_form_name (unsigned form
)
13254 return "DW_FORM_addr";
13255 case DW_FORM_block2
:
13256 return "DW_FORM_block2";
13257 case DW_FORM_block4
:
13258 return "DW_FORM_block4";
13259 case DW_FORM_data2
:
13260 return "DW_FORM_data2";
13261 case DW_FORM_data4
:
13262 return "DW_FORM_data4";
13263 case DW_FORM_data8
:
13264 return "DW_FORM_data8";
13265 case DW_FORM_string
:
13266 return "DW_FORM_string";
13267 case DW_FORM_block
:
13268 return "DW_FORM_block";
13269 case DW_FORM_block1
:
13270 return "DW_FORM_block1";
13271 case DW_FORM_data1
:
13272 return "DW_FORM_data1";
13274 return "DW_FORM_flag";
13275 case DW_FORM_sdata
:
13276 return "DW_FORM_sdata";
13278 return "DW_FORM_strp";
13279 case DW_FORM_udata
:
13280 return "DW_FORM_udata";
13281 case DW_FORM_ref_addr
:
13282 return "DW_FORM_ref_addr";
13284 return "DW_FORM_ref1";
13286 return "DW_FORM_ref2";
13288 return "DW_FORM_ref4";
13290 return "DW_FORM_ref8";
13291 case DW_FORM_ref_udata
:
13292 return "DW_FORM_ref_udata";
13293 case DW_FORM_indirect
:
13294 return "DW_FORM_indirect";
13295 case DW_FORM_sec_offset
:
13296 return "DW_FORM_sec_offset";
13297 case DW_FORM_exprloc
:
13298 return "DW_FORM_exprloc";
13299 case DW_FORM_flag_present
:
13300 return "DW_FORM_flag_present";
13301 case DW_FORM_ref_sig8
:
13302 return "DW_FORM_ref_sig8";
13304 return "DW_FORM_<unknown>";
13308 /* Convert a DWARF stack opcode into its string name. */
13311 dwarf_stack_op_name (unsigned op
)
13316 return "DW_OP_addr";
13318 return "DW_OP_deref";
13319 case DW_OP_const1u
:
13320 return "DW_OP_const1u";
13321 case DW_OP_const1s
:
13322 return "DW_OP_const1s";
13323 case DW_OP_const2u
:
13324 return "DW_OP_const2u";
13325 case DW_OP_const2s
:
13326 return "DW_OP_const2s";
13327 case DW_OP_const4u
:
13328 return "DW_OP_const4u";
13329 case DW_OP_const4s
:
13330 return "DW_OP_const4s";
13331 case DW_OP_const8u
:
13332 return "DW_OP_const8u";
13333 case DW_OP_const8s
:
13334 return "DW_OP_const8s";
13336 return "DW_OP_constu";
13338 return "DW_OP_consts";
13340 return "DW_OP_dup";
13342 return "DW_OP_drop";
13344 return "DW_OP_over";
13346 return "DW_OP_pick";
13348 return "DW_OP_swap";
13350 return "DW_OP_rot";
13352 return "DW_OP_xderef";
13354 return "DW_OP_abs";
13356 return "DW_OP_and";
13358 return "DW_OP_div";
13360 return "DW_OP_minus";
13362 return "DW_OP_mod";
13364 return "DW_OP_mul";
13366 return "DW_OP_neg";
13368 return "DW_OP_not";
13372 return "DW_OP_plus";
13373 case DW_OP_plus_uconst
:
13374 return "DW_OP_plus_uconst";
13376 return "DW_OP_shl";
13378 return "DW_OP_shr";
13380 return "DW_OP_shra";
13382 return "DW_OP_xor";
13384 return "DW_OP_bra";
13398 return "DW_OP_skip";
13400 return "DW_OP_lit0";
13402 return "DW_OP_lit1";
13404 return "DW_OP_lit2";
13406 return "DW_OP_lit3";
13408 return "DW_OP_lit4";
13410 return "DW_OP_lit5";
13412 return "DW_OP_lit6";
13414 return "DW_OP_lit7";
13416 return "DW_OP_lit8";
13418 return "DW_OP_lit9";
13420 return "DW_OP_lit10";
13422 return "DW_OP_lit11";
13424 return "DW_OP_lit12";
13426 return "DW_OP_lit13";
13428 return "DW_OP_lit14";
13430 return "DW_OP_lit15";
13432 return "DW_OP_lit16";
13434 return "DW_OP_lit17";
13436 return "DW_OP_lit18";
13438 return "DW_OP_lit19";
13440 return "DW_OP_lit20";
13442 return "DW_OP_lit21";
13444 return "DW_OP_lit22";
13446 return "DW_OP_lit23";
13448 return "DW_OP_lit24";
13450 return "DW_OP_lit25";
13452 return "DW_OP_lit26";
13454 return "DW_OP_lit27";
13456 return "DW_OP_lit28";
13458 return "DW_OP_lit29";
13460 return "DW_OP_lit30";
13462 return "DW_OP_lit31";
13464 return "DW_OP_reg0";
13466 return "DW_OP_reg1";
13468 return "DW_OP_reg2";
13470 return "DW_OP_reg3";
13472 return "DW_OP_reg4";
13474 return "DW_OP_reg5";
13476 return "DW_OP_reg6";
13478 return "DW_OP_reg7";
13480 return "DW_OP_reg8";
13482 return "DW_OP_reg9";
13484 return "DW_OP_reg10";
13486 return "DW_OP_reg11";
13488 return "DW_OP_reg12";
13490 return "DW_OP_reg13";
13492 return "DW_OP_reg14";
13494 return "DW_OP_reg15";
13496 return "DW_OP_reg16";
13498 return "DW_OP_reg17";
13500 return "DW_OP_reg18";
13502 return "DW_OP_reg19";
13504 return "DW_OP_reg20";
13506 return "DW_OP_reg21";
13508 return "DW_OP_reg22";
13510 return "DW_OP_reg23";
13512 return "DW_OP_reg24";
13514 return "DW_OP_reg25";
13516 return "DW_OP_reg26";
13518 return "DW_OP_reg27";
13520 return "DW_OP_reg28";
13522 return "DW_OP_reg29";
13524 return "DW_OP_reg30";
13526 return "DW_OP_reg31";
13528 return "DW_OP_breg0";
13530 return "DW_OP_breg1";
13532 return "DW_OP_breg2";
13534 return "DW_OP_breg3";
13536 return "DW_OP_breg4";
13538 return "DW_OP_breg5";
13540 return "DW_OP_breg6";
13542 return "DW_OP_breg7";
13544 return "DW_OP_breg8";
13546 return "DW_OP_breg9";
13548 return "DW_OP_breg10";
13550 return "DW_OP_breg11";
13552 return "DW_OP_breg12";
13554 return "DW_OP_breg13";
13556 return "DW_OP_breg14";
13558 return "DW_OP_breg15";
13560 return "DW_OP_breg16";
13562 return "DW_OP_breg17";
13564 return "DW_OP_breg18";
13566 return "DW_OP_breg19";
13568 return "DW_OP_breg20";
13570 return "DW_OP_breg21";
13572 return "DW_OP_breg22";
13574 return "DW_OP_breg23";
13576 return "DW_OP_breg24";
13578 return "DW_OP_breg25";
13580 return "DW_OP_breg26";
13582 return "DW_OP_breg27";
13584 return "DW_OP_breg28";
13586 return "DW_OP_breg29";
13588 return "DW_OP_breg30";
13590 return "DW_OP_breg31";
13592 return "DW_OP_regx";
13594 return "DW_OP_fbreg";
13596 return "DW_OP_bregx";
13598 return "DW_OP_piece";
13599 case DW_OP_deref_size
:
13600 return "DW_OP_deref_size";
13601 case DW_OP_xderef_size
:
13602 return "DW_OP_xderef_size";
13604 return "DW_OP_nop";
13605 /* DWARF 3 extensions. */
13606 case DW_OP_push_object_address
:
13607 return "DW_OP_push_object_address";
13609 return "DW_OP_call2";
13611 return "DW_OP_call4";
13612 case DW_OP_call_ref
:
13613 return "DW_OP_call_ref";
13614 case DW_OP_form_tls_address
:
13615 return "DW_OP_form_tls_address";
13616 case DW_OP_call_frame_cfa
:
13617 return "DW_OP_call_frame_cfa";
13618 case DW_OP_bit_piece
:
13619 return "DW_OP_bit_piece";
13620 /* DWARF 4 extensions. */
13621 case DW_OP_implicit_value
:
13622 return "DW_OP_implicit_value";
13623 case DW_OP_stack_value
:
13624 return "DW_OP_stack_value";
13625 /* GNU extensions. */
13626 case DW_OP_GNU_push_tls_address
:
13627 return "DW_OP_GNU_push_tls_address";
13628 case DW_OP_GNU_uninit
:
13629 return "DW_OP_GNU_uninit";
13630 case DW_OP_GNU_implicit_pointer
:
13631 return "DW_OP_GNU_implicit_pointer";
13632 case DW_OP_GNU_entry_value
:
13633 return "DW_OP_GNU_entry_value";
13634 case DW_OP_GNU_const_type
:
13635 return "DW_OP_GNU_const_type";
13636 case DW_OP_GNU_regval_type
:
13637 return "DW_OP_GNU_regval_type";
13638 case DW_OP_GNU_deref_type
:
13639 return "DW_OP_GNU_deref_type";
13640 case DW_OP_GNU_convert
:
13641 return "DW_OP_GNU_convert";
13642 case DW_OP_GNU_reinterpret
:
13643 return "DW_OP_GNU_reinterpret";
13650 dwarf_bool_name (unsigned mybool
)
13658 /* Convert a DWARF type code into its string name. */
13661 dwarf_type_encoding_name (unsigned enc
)
13666 return "DW_ATE_void";
13667 case DW_ATE_address
:
13668 return "DW_ATE_address";
13669 case DW_ATE_boolean
:
13670 return "DW_ATE_boolean";
13671 case DW_ATE_complex_float
:
13672 return "DW_ATE_complex_float";
13674 return "DW_ATE_float";
13675 case DW_ATE_signed
:
13676 return "DW_ATE_signed";
13677 case DW_ATE_signed_char
:
13678 return "DW_ATE_signed_char";
13679 case DW_ATE_unsigned
:
13680 return "DW_ATE_unsigned";
13681 case DW_ATE_unsigned_char
:
13682 return "DW_ATE_unsigned_char";
13684 case DW_ATE_imaginary_float
:
13685 return "DW_ATE_imaginary_float";
13686 case DW_ATE_packed_decimal
:
13687 return "DW_ATE_packed_decimal";
13688 case DW_ATE_numeric_string
:
13689 return "DW_ATE_numeric_string";
13690 case DW_ATE_edited
:
13691 return "DW_ATE_edited";
13692 case DW_ATE_signed_fixed
:
13693 return "DW_ATE_signed_fixed";
13694 case DW_ATE_unsigned_fixed
:
13695 return "DW_ATE_unsigned_fixed";
13696 case DW_ATE_decimal_float
:
13697 return "DW_ATE_decimal_float";
13700 return "DW_ATE_UTF";
13701 /* HP extensions. */
13702 case DW_ATE_HP_float80
:
13703 return "DW_ATE_HP_float80";
13704 case DW_ATE_HP_complex_float80
:
13705 return "DW_ATE_HP_complex_float80";
13706 case DW_ATE_HP_float128
:
13707 return "DW_ATE_HP_float128";
13708 case DW_ATE_HP_complex_float128
:
13709 return "DW_ATE_HP_complex_float128";
13710 case DW_ATE_HP_floathpintel
:
13711 return "DW_ATE_HP_floathpintel";
13712 case DW_ATE_HP_imaginary_float80
:
13713 return "DW_ATE_HP_imaginary_float80";
13714 case DW_ATE_HP_imaginary_float128
:
13715 return "DW_ATE_HP_imaginary_float128";
13717 return "DW_ATE_<unknown>";
13721 /* Convert a DWARF call frame info operation to its string name. */
13725 dwarf_cfi_name (unsigned cfi_opc
)
13729 case DW_CFA_advance_loc
:
13730 return "DW_CFA_advance_loc";
13731 case DW_CFA_offset
:
13732 return "DW_CFA_offset";
13733 case DW_CFA_restore
:
13734 return "DW_CFA_restore";
13736 return "DW_CFA_nop";
13737 case DW_CFA_set_loc
:
13738 return "DW_CFA_set_loc";
13739 case DW_CFA_advance_loc1
:
13740 return "DW_CFA_advance_loc1";
13741 case DW_CFA_advance_loc2
:
13742 return "DW_CFA_advance_loc2";
13743 case DW_CFA_advance_loc4
:
13744 return "DW_CFA_advance_loc4";
13745 case DW_CFA_offset_extended
:
13746 return "DW_CFA_offset_extended";
13747 case DW_CFA_restore_extended
:
13748 return "DW_CFA_restore_extended";
13749 case DW_CFA_undefined
:
13750 return "DW_CFA_undefined";
13751 case DW_CFA_same_value
:
13752 return "DW_CFA_same_value";
13753 case DW_CFA_register
:
13754 return "DW_CFA_register";
13755 case DW_CFA_remember_state
:
13756 return "DW_CFA_remember_state";
13757 case DW_CFA_restore_state
:
13758 return "DW_CFA_restore_state";
13759 case DW_CFA_def_cfa
:
13760 return "DW_CFA_def_cfa";
13761 case DW_CFA_def_cfa_register
:
13762 return "DW_CFA_def_cfa_register";
13763 case DW_CFA_def_cfa_offset
:
13764 return "DW_CFA_def_cfa_offset";
13766 case DW_CFA_def_cfa_expression
:
13767 return "DW_CFA_def_cfa_expression";
13768 case DW_CFA_expression
:
13769 return "DW_CFA_expression";
13770 case DW_CFA_offset_extended_sf
:
13771 return "DW_CFA_offset_extended_sf";
13772 case DW_CFA_def_cfa_sf
:
13773 return "DW_CFA_def_cfa_sf";
13774 case DW_CFA_def_cfa_offset_sf
:
13775 return "DW_CFA_def_cfa_offset_sf";
13776 case DW_CFA_val_offset
:
13777 return "DW_CFA_val_offset";
13778 case DW_CFA_val_offset_sf
:
13779 return "DW_CFA_val_offset_sf";
13780 case DW_CFA_val_expression
:
13781 return "DW_CFA_val_expression";
13782 /* SGI/MIPS specific. */
13783 case DW_CFA_MIPS_advance_loc8
:
13784 return "DW_CFA_MIPS_advance_loc8";
13785 /* GNU extensions. */
13786 case DW_CFA_GNU_window_save
:
13787 return "DW_CFA_GNU_window_save";
13788 case DW_CFA_GNU_args_size
:
13789 return "DW_CFA_GNU_args_size";
13790 case DW_CFA_GNU_negative_offset_extended
:
13791 return "DW_CFA_GNU_negative_offset_extended";
13793 return "DW_CFA_<unknown>";
13799 dump_die_shallow (struct ui_file
*f
, int indent
, struct die_info
*die
)
13803 print_spaces (indent
, f
);
13804 fprintf_unfiltered (f
, "Die: %s (abbrev %d, offset 0x%x)\n",
13805 dwarf_tag_name (die
->tag
), die
->abbrev
, die
->offset
);
13807 if (die
->parent
!= NULL
)
13809 print_spaces (indent
, f
);
13810 fprintf_unfiltered (f
, " parent at offset: 0x%x\n",
13811 die
->parent
->offset
);
13814 print_spaces (indent
, f
);
13815 fprintf_unfiltered (f
, " has children: %s\n",
13816 dwarf_bool_name (die
->child
!= NULL
));
13818 print_spaces (indent
, f
);
13819 fprintf_unfiltered (f
, " attributes:\n");
13821 for (i
= 0; i
< die
->num_attrs
; ++i
)
13823 print_spaces (indent
, f
);
13824 fprintf_unfiltered (f
, " %s (%s) ",
13825 dwarf_attr_name (die
->attrs
[i
].name
),
13826 dwarf_form_name (die
->attrs
[i
].form
));
13828 switch (die
->attrs
[i
].form
)
13830 case DW_FORM_ref_addr
:
13832 fprintf_unfiltered (f
, "address: ");
13833 fputs_filtered (hex_string (DW_ADDR (&die
->attrs
[i
])), f
);
13835 case DW_FORM_block2
:
13836 case DW_FORM_block4
:
13837 case DW_FORM_block
:
13838 case DW_FORM_block1
:
13839 fprintf_unfiltered (f
, "block: size %d",
13840 DW_BLOCK (&die
->attrs
[i
])->size
);
13842 case DW_FORM_exprloc
:
13843 fprintf_unfiltered (f
, "expression: size %u",
13844 DW_BLOCK (&die
->attrs
[i
])->size
);
13849 fprintf_unfiltered (f
, "constant ref: 0x%lx (adjusted)",
13850 (long) (DW_ADDR (&die
->attrs
[i
])));
13852 case DW_FORM_data1
:
13853 case DW_FORM_data2
:
13854 case DW_FORM_data4
:
13855 case DW_FORM_data8
:
13856 case DW_FORM_udata
:
13857 case DW_FORM_sdata
:
13858 fprintf_unfiltered (f
, "constant: %s",
13859 pulongest (DW_UNSND (&die
->attrs
[i
])));
13861 case DW_FORM_sec_offset
:
13862 fprintf_unfiltered (f
, "section offset: %s",
13863 pulongest (DW_UNSND (&die
->attrs
[i
])));
13865 case DW_FORM_ref_sig8
:
13866 if (DW_SIGNATURED_TYPE (&die
->attrs
[i
]) != NULL
)
13867 fprintf_unfiltered (f
, "signatured type, offset: 0x%x",
13868 DW_SIGNATURED_TYPE (&die
->attrs
[i
])->per_cu
.offset
);
13870 fprintf_unfiltered (f
, "signatured type, offset: unknown");
13872 case DW_FORM_string
:
13874 fprintf_unfiltered (f
, "string: \"%s\" (%s canonicalized)",
13875 DW_STRING (&die
->attrs
[i
])
13876 ? DW_STRING (&die
->attrs
[i
]) : "",
13877 DW_STRING_IS_CANONICAL (&die
->attrs
[i
]) ? "is" : "not");
13880 if (DW_UNSND (&die
->attrs
[i
]))
13881 fprintf_unfiltered (f
, "flag: TRUE");
13883 fprintf_unfiltered (f
, "flag: FALSE");
13885 case DW_FORM_flag_present
:
13886 fprintf_unfiltered (f
, "flag: TRUE");
13888 case DW_FORM_indirect
:
13889 /* The reader will have reduced the indirect form to
13890 the "base form" so this form should not occur. */
13891 fprintf_unfiltered (f
,
13892 "unexpected attribute form: DW_FORM_indirect");
13895 fprintf_unfiltered (f
, "unsupported attribute form: %d.",
13896 die
->attrs
[i
].form
);
13899 fprintf_unfiltered (f
, "\n");
13904 dump_die_for_error (struct die_info
*die
)
13906 dump_die_shallow (gdb_stderr
, 0, die
);
13910 dump_die_1 (struct ui_file
*f
, int level
, int max_level
, struct die_info
*die
)
13912 int indent
= level
* 4;
13914 gdb_assert (die
!= NULL
);
13916 if (level
>= max_level
)
13919 dump_die_shallow (f
, indent
, die
);
13921 if (die
->child
!= NULL
)
13923 print_spaces (indent
, f
);
13924 fprintf_unfiltered (f
, " Children:");
13925 if (level
+ 1 < max_level
)
13927 fprintf_unfiltered (f
, "\n");
13928 dump_die_1 (f
, level
+ 1, max_level
, die
->child
);
13932 fprintf_unfiltered (f
,
13933 " [not printed, max nesting level reached]\n");
13937 if (die
->sibling
!= NULL
&& level
> 0)
13939 dump_die_1 (f
, level
, max_level
, die
->sibling
);
13943 /* This is called from the pdie macro in gdbinit.in.
13944 It's not static so gcc will keep a copy callable from gdb. */
13947 dump_die (struct die_info
*die
, int max_level
)
13949 dump_die_1 (gdb_stdlog
, 0, max_level
, die
);
13953 store_in_ref_table (struct die_info
*die
, struct dwarf2_cu
*cu
)
13957 slot
= htab_find_slot_with_hash (cu
->die_hash
, die
, die
->offset
, INSERT
);
13963 is_ref_attr (struct attribute
*attr
)
13965 switch (attr
->form
)
13967 case DW_FORM_ref_addr
:
13972 case DW_FORM_ref_udata
:
13979 static unsigned int
13980 dwarf2_get_ref_die_offset (struct attribute
*attr
)
13982 if (is_ref_attr (attr
))
13983 return DW_ADDR (attr
);
13985 complaint (&symfile_complaints
,
13986 _("unsupported die ref attribute form: '%s'"),
13987 dwarf_form_name (attr
->form
));
13991 /* Return the constant value held by ATTR. Return DEFAULT_VALUE if
13992 * the value held by the attribute is not constant. */
13995 dwarf2_get_attr_constant_value (struct attribute
*attr
, int default_value
)
13997 if (attr
->form
== DW_FORM_sdata
)
13998 return DW_SND (attr
);
13999 else if (attr
->form
== DW_FORM_udata
14000 || attr
->form
== DW_FORM_data1
14001 || attr
->form
== DW_FORM_data2
14002 || attr
->form
== DW_FORM_data4
14003 || attr
->form
== DW_FORM_data8
)
14004 return DW_UNSND (attr
);
14007 complaint (&symfile_complaints
,
14008 _("Attribute value is not a constant (%s)"),
14009 dwarf_form_name (attr
->form
));
14010 return default_value
;
14014 /* THIS_CU has a reference to PER_CU. If necessary, load the new compilation
14015 unit and add it to our queue.
14016 The result is non-zero if PER_CU was queued, otherwise the result is zero
14017 meaning either PER_CU is already queued or it is already loaded. */
14020 maybe_queue_comp_unit (struct dwarf2_cu
*this_cu
,
14021 struct dwarf2_per_cu_data
*per_cu
)
14023 /* We may arrive here during partial symbol reading, if we need full
14024 DIEs to process an unusual case (e.g. template arguments). Do
14025 not queue PER_CU, just tell our caller to load its DIEs. */
14026 if (dwarf2_per_objfile
->reading_partial_symbols
)
14028 if (per_cu
->cu
== NULL
|| per_cu
->cu
->dies
== NULL
)
14033 /* Mark the dependence relation so that we don't flush PER_CU
14035 dwarf2_add_dependence (this_cu
, per_cu
);
14037 /* If it's already on the queue, we have nothing to do. */
14038 if (per_cu
->queued
)
14041 /* If the compilation unit is already loaded, just mark it as
14043 if (per_cu
->cu
!= NULL
)
14045 per_cu
->cu
->last_used
= 0;
14049 /* Add it to the queue. */
14050 queue_comp_unit (per_cu
, this_cu
->objfile
);
14055 /* Follow reference or signature attribute ATTR of SRC_DIE.
14056 On entry *REF_CU is the CU of SRC_DIE.
14057 On exit *REF_CU is the CU of the result. */
14059 static struct die_info
*
14060 follow_die_ref_or_sig (struct die_info
*src_die
, struct attribute
*attr
,
14061 struct dwarf2_cu
**ref_cu
)
14063 struct die_info
*die
;
14065 if (is_ref_attr (attr
))
14066 die
= follow_die_ref (src_die
, attr
, ref_cu
);
14067 else if (attr
->form
== DW_FORM_ref_sig8
)
14068 die
= follow_die_sig (src_die
, attr
, ref_cu
);
14071 dump_die_for_error (src_die
);
14072 error (_("Dwarf Error: Expected reference attribute [in module %s]"),
14073 (*ref_cu
)->objfile
->name
);
14079 /* Follow reference OFFSET.
14080 On entry *REF_CU is the CU of the source die referencing OFFSET.
14081 On exit *REF_CU is the CU of the result.
14082 Returns NULL if OFFSET is invalid. */
14084 static struct die_info
*
14085 follow_die_offset (unsigned int offset
, struct dwarf2_cu
**ref_cu
)
14087 struct die_info temp_die
;
14088 struct dwarf2_cu
*target_cu
, *cu
= *ref_cu
;
14090 gdb_assert (cu
->per_cu
!= NULL
);
14094 if (cu
->per_cu
->debug_type_section
)
14096 /* .debug_types CUs cannot reference anything outside their CU.
14097 If they need to, they have to reference a signatured type via
14098 DW_FORM_ref_sig8. */
14099 if (! offset_in_cu_p (&cu
->header
, offset
))
14102 else if (! offset_in_cu_p (&cu
->header
, offset
))
14104 struct dwarf2_per_cu_data
*per_cu
;
14106 per_cu
= dwarf2_find_containing_comp_unit (offset
, cu
->objfile
);
14108 /* If necessary, add it to the queue and load its DIEs. */
14109 if (maybe_queue_comp_unit (cu
, per_cu
))
14110 load_full_comp_unit (per_cu
, cu
->objfile
);
14112 target_cu
= per_cu
->cu
;
14114 else if (cu
->dies
== NULL
)
14116 /* We're loading full DIEs during partial symbol reading. */
14117 gdb_assert (dwarf2_per_objfile
->reading_partial_symbols
);
14118 load_full_comp_unit (cu
->per_cu
, cu
->objfile
);
14121 *ref_cu
= target_cu
;
14122 temp_die
.offset
= offset
;
14123 return htab_find_with_hash (target_cu
->die_hash
, &temp_die
, offset
);
14126 /* Follow reference attribute ATTR of SRC_DIE.
14127 On entry *REF_CU is the CU of SRC_DIE.
14128 On exit *REF_CU is the CU of the result. */
14130 static struct die_info
*
14131 follow_die_ref (struct die_info
*src_die
, struct attribute
*attr
,
14132 struct dwarf2_cu
**ref_cu
)
14134 unsigned int offset
= dwarf2_get_ref_die_offset (attr
);
14135 struct dwarf2_cu
*cu
= *ref_cu
;
14136 struct die_info
*die
;
14138 die
= follow_die_offset (offset
, ref_cu
);
14140 error (_("Dwarf Error: Cannot find DIE at 0x%x referenced from DIE "
14141 "at 0x%x [in module %s]"),
14142 offset
, src_die
->offset
, cu
->objfile
->name
);
14147 /* Return DWARF block referenced by DW_AT_location of DIE at OFFSET at PER_CU.
14148 Returned value is intended for DW_OP_call*. Returned
14149 dwarf2_locexpr_baton->data has lifetime of PER_CU->OBJFILE. */
14151 struct dwarf2_locexpr_baton
14152 dwarf2_fetch_die_location_block (unsigned int offset
,
14153 struct dwarf2_per_cu_data
*per_cu
,
14154 CORE_ADDR (*get_frame_pc
) (void *baton
),
14157 struct dwarf2_cu
*cu
;
14158 struct die_info
*die
;
14159 struct attribute
*attr
;
14160 struct dwarf2_locexpr_baton retval
;
14162 dw2_setup (per_cu
->objfile
);
14164 if (per_cu
->cu
== NULL
)
14168 die
= follow_die_offset (offset
, &cu
);
14170 error (_("Dwarf Error: Cannot find DIE at 0x%x referenced in module %s"),
14171 offset
, per_cu
->cu
->objfile
->name
);
14173 attr
= dwarf2_attr (die
, DW_AT_location
, cu
);
14176 /* DWARF: "If there is no such attribute, then there is no effect.". */
14178 retval
.data
= NULL
;
14181 else if (attr_form_is_section_offset (attr
))
14183 struct dwarf2_loclist_baton loclist_baton
;
14184 CORE_ADDR pc
= (*get_frame_pc
) (baton
);
14187 fill_in_loclist_baton (cu
, &loclist_baton
, attr
);
14189 retval
.data
= dwarf2_find_location_expression (&loclist_baton
,
14191 retval
.size
= size
;
14195 if (!attr_form_is_block (attr
))
14196 error (_("Dwarf Error: DIE at 0x%x referenced in module %s "
14197 "is neither DW_FORM_block* nor DW_FORM_exprloc"),
14198 offset
, per_cu
->cu
->objfile
->name
);
14200 retval
.data
= DW_BLOCK (attr
)->data
;
14201 retval
.size
= DW_BLOCK (attr
)->size
;
14203 retval
.per_cu
= cu
->per_cu
;
14205 age_cached_comp_units ();
14210 /* Return the type of the DIE at DIE_OFFSET in the CU named by
14214 dwarf2_get_die_type (unsigned int die_offset
,
14215 struct dwarf2_per_cu_data
*per_cu
)
14217 dw2_setup (per_cu
->objfile
);
14218 return get_die_type_at_offset (die_offset
, per_cu
);
14221 /* Follow the signature attribute ATTR in SRC_DIE.
14222 On entry *REF_CU is the CU of SRC_DIE.
14223 On exit *REF_CU is the CU of the result. */
14225 static struct die_info
*
14226 follow_die_sig (struct die_info
*src_die
, struct attribute
*attr
,
14227 struct dwarf2_cu
**ref_cu
)
14229 struct objfile
*objfile
= (*ref_cu
)->objfile
;
14230 struct die_info temp_die
;
14231 struct signatured_type
*sig_type
= DW_SIGNATURED_TYPE (attr
);
14232 struct dwarf2_cu
*sig_cu
;
14233 struct die_info
*die
;
14235 /* sig_type will be NULL if the signatured type is missing from
14237 if (sig_type
== NULL
)
14238 error (_("Dwarf Error: Cannot find signatured DIE referenced from DIE "
14239 "at 0x%x [in module %s]"),
14240 src_die
->offset
, objfile
->name
);
14242 /* If necessary, add it to the queue and load its DIEs. */
14244 if (maybe_queue_comp_unit (*ref_cu
, &sig_type
->per_cu
))
14245 read_signatured_type (objfile
, sig_type
);
14247 gdb_assert (sig_type
->per_cu
.cu
!= NULL
);
14249 sig_cu
= sig_type
->per_cu
.cu
;
14250 temp_die
.offset
= sig_cu
->header
.offset
+ sig_type
->type_offset
;
14251 die
= htab_find_with_hash (sig_cu
->die_hash
, &temp_die
, temp_die
.offset
);
14258 error (_("Dwarf Error: Cannot find signatured DIE at 0x%x referenced "
14259 "from DIE at 0x%x [in module %s]"),
14260 sig_type
->type_offset
, src_die
->offset
, objfile
->name
);
14263 /* Given an offset of a signatured type, return its signatured_type. */
14265 static struct signatured_type
*
14266 lookup_signatured_type_at_offset (struct objfile
*objfile
,
14267 struct dwarf2_section_info
*section
,
14268 unsigned int offset
)
14270 gdb_byte
*info_ptr
= section
->buffer
+ offset
;
14271 unsigned int length
, initial_length_size
;
14272 unsigned int sig_offset
;
14273 struct signatured_type find_entry
, *type_sig
;
14275 length
= read_initial_length (objfile
->obfd
, info_ptr
, &initial_length_size
);
14276 sig_offset
= (initial_length_size
14278 + (initial_length_size
== 4 ? 4 : 8) /*debug_abbrev_offset*/
14279 + 1 /*address_size*/);
14280 find_entry
.signature
= bfd_get_64 (objfile
->obfd
, info_ptr
+ sig_offset
);
14281 type_sig
= htab_find (dwarf2_per_objfile
->signatured_types
, &find_entry
);
14283 /* This is only used to lookup previously recorded types.
14284 If we didn't find it, it's our bug. */
14285 gdb_assert (type_sig
!= NULL
);
14286 gdb_assert (offset
== type_sig
->per_cu
.offset
);
14291 /* Read in signatured type at OFFSET and build its CU and die(s). */
14294 read_signatured_type_at_offset (struct objfile
*objfile
,
14295 struct dwarf2_section_info
*sect
,
14296 unsigned int offset
)
14298 struct signatured_type
*type_sig
;
14300 dwarf2_read_section (objfile
, sect
);
14302 /* We have the section offset, but we need the signature to do the
14303 hash table lookup. */
14304 type_sig
= lookup_signatured_type_at_offset (objfile
, sect
, offset
);
14306 gdb_assert (type_sig
->per_cu
.cu
== NULL
);
14308 read_signatured_type (objfile
, type_sig
);
14310 gdb_assert (type_sig
->per_cu
.cu
!= NULL
);
14313 /* Read in a signatured type and build its CU and DIEs. */
14316 read_signatured_type (struct objfile
*objfile
,
14317 struct signatured_type
*type_sig
)
14319 gdb_byte
*types_ptr
;
14320 struct die_reader_specs reader_specs
;
14321 struct dwarf2_cu
*cu
;
14322 ULONGEST signature
;
14323 struct cleanup
*back_to
, *free_cu_cleanup
;
14324 struct dwarf2_section_info
*section
= type_sig
->per_cu
.debug_type_section
;
14326 dwarf2_read_section (objfile
, section
);
14327 types_ptr
= section
->buffer
+ type_sig
->per_cu
.offset
;
14329 gdb_assert (type_sig
->per_cu
.cu
== NULL
);
14331 cu
= xmalloc (sizeof (*cu
));
14332 init_one_comp_unit (cu
, objfile
);
14334 type_sig
->per_cu
.cu
= cu
;
14335 cu
->per_cu
= &type_sig
->per_cu
;
14337 /* If an error occurs while loading, release our storage. */
14338 free_cu_cleanup
= make_cleanup (free_one_comp_unit
, cu
);
14340 types_ptr
= read_type_comp_unit_head (&cu
->header
, section
, &signature
,
14341 types_ptr
, objfile
->obfd
);
14342 gdb_assert (signature
== type_sig
->signature
);
14345 = htab_create_alloc_ex (cu
->header
.length
/ 12,
14349 &cu
->comp_unit_obstack
,
14350 hashtab_obstack_allocate
,
14351 dummy_obstack_deallocate
);
14353 dwarf2_read_abbrevs (cu
->objfile
->obfd
, cu
);
14354 back_to
= make_cleanup (dwarf2_free_abbrev_table
, cu
);
14356 init_cu_die_reader (&reader_specs
, cu
);
14358 cu
->dies
= read_die_and_children (&reader_specs
, types_ptr
, &types_ptr
,
14361 /* We try not to read any attributes in this function, because not
14362 all objfiles needed for references have been loaded yet, and symbol
14363 table processing isn't initialized. But we have to set the CU language,
14364 or we won't be able to build types correctly. */
14365 prepare_one_comp_unit (cu
, cu
->dies
);
14367 do_cleanups (back_to
);
14369 /* We've successfully allocated this compilation unit. Let our caller
14370 clean it up when finished with it. */
14371 discard_cleanups (free_cu_cleanup
);
14373 type_sig
->per_cu
.cu
->read_in_chain
= dwarf2_per_objfile
->read_in_chain
;
14374 dwarf2_per_objfile
->read_in_chain
= &type_sig
->per_cu
;
14377 /* Workaround as dwarf_expr_context_funcs.read_mem implementation before
14378 a proper runtime DWARF expressions evaluator gets implemented.
14379 Otherwise gnuv3_baseclass_offset would error by:
14380 Expected a negative vbase offset (old compiler?) */
14383 decode_locdesc_read_mem (void *baton
, gdb_byte
*buf
, CORE_ADDR addr
,
14386 struct dwarf_expr_context
*ctx
= baton
;
14387 struct gdbarch
*gdbarch
= ctx
->gdbarch
;
14388 struct type
*ptr_type
= builtin_type (gdbarch
)->builtin_data_ptr
;
14390 memset (buf
, 0, length
);
14392 if (TYPE_LENGTH (ptr_type
) == length
)
14393 store_typed_address (buf
, ptr_type
, addr
);
14396 static const struct dwarf_expr_context_funcs decode_locdesc_ctx_funcs
=
14399 decode_locdesc_read_mem
,
14400 ctx_no_get_frame_base
,
14401 ctx_no_get_frame_cfa
,
14402 ctx_no_get_frame_pc
,
14403 ctx_no_get_tls_address
,
14405 ctx_no_get_base_type
14408 /* Decode simple location descriptions.
14409 Given a pointer to a dwarf block that defines a location, compute
14410 the location and return the value.
14412 NOTE drow/2003-11-18: This function is called in two situations
14413 now: for the address of static or global variables (partial symbols
14414 only) and for offsets into structures which are expected to be
14415 (more or less) constant. The partial symbol case should go away,
14416 and only the constant case should remain. That will let this
14417 function complain more accurately. A few special modes are allowed
14418 without complaint for global variables (for instance, global
14419 register values and thread-local values).
14421 A location description containing no operations indicates that the
14422 object is optimized out. The return value is 0 for that case.
14423 FIXME drow/2003-11-16: No callers check for this case any more; soon all
14424 callers will only want a very basic result and this can become a
14428 decode_locdesc (struct dwarf_block
*blk
, struct dwarf2_cu
*cu
)
14430 struct objfile
*objfile
= cu
->objfile
;
14431 struct dwarf_expr_context
*ctx
;
14432 struct cleanup
*old_chain
;
14433 volatile struct gdb_exception ex
;
14435 ctx
= new_dwarf_expr_context ();
14436 old_chain
= make_cleanup_free_dwarf_expr_context (ctx
);
14437 make_cleanup_value_free_to_mark (value_mark ());
14439 ctx
->gdbarch
= get_objfile_arch (objfile
);
14440 ctx
->addr_size
= cu
->header
.addr_size
;
14441 ctx
->ref_addr_size
= dwarf2_per_cu_ref_addr_size (cu
->per_cu
);
14442 ctx
->offset
= ANOFFSET (objfile
->section_offsets
, SECT_OFF_TEXT (objfile
));
14444 ctx
->funcs
= &decode_locdesc_ctx_funcs
;
14446 /* DW_AT_data_member_location expects the structure address to be pushed on
14447 the stack. Simulate the offset by address 0. */
14448 dwarf_expr_push_address (ctx
, 0, 0);
14450 TRY_CATCH (ex
, RETURN_MASK_ERROR
)
14452 dwarf_expr_eval (ctx
, blk
->data
, blk
->size
);
14457 complaint (&symfile_complaints
, "%s", ex
.message
);
14459 else if (ctx
->num_pieces
== 0)
14460 switch (ctx
->location
)
14462 /* The returned number will be bogus, just do not complain for locations
14463 in global registers - it is here only a partial symbol address. */
14464 case DWARF_VALUE_REGISTER
:
14466 case DWARF_VALUE_MEMORY
:
14467 case DWARF_VALUE_STACK
:
14469 CORE_ADDR address
= dwarf_expr_fetch_address (ctx
, 0);
14471 do_cleanups (old_chain
);
14476 do_cleanups (old_chain
);
14477 dwarf2_complex_location_expr_complaint ();
14481 /* memory allocation interface */
14483 static struct dwarf_block
*
14484 dwarf_alloc_block (struct dwarf2_cu
*cu
)
14486 struct dwarf_block
*blk
;
14488 blk
= (struct dwarf_block
*)
14489 obstack_alloc (&cu
->comp_unit_obstack
, sizeof (struct dwarf_block
));
14493 static struct abbrev_info
*
14494 dwarf_alloc_abbrev (struct dwarf2_cu
*cu
)
14496 struct abbrev_info
*abbrev
;
14498 abbrev
= (struct abbrev_info
*)
14499 obstack_alloc (&cu
->abbrev_obstack
, sizeof (struct abbrev_info
));
14500 memset (abbrev
, 0, sizeof (struct abbrev_info
));
14504 static struct die_info
*
14505 dwarf_alloc_die (struct dwarf2_cu
*cu
, int num_attrs
)
14507 struct die_info
*die
;
14508 size_t size
= sizeof (struct die_info
);
14511 size
+= (num_attrs
- 1) * sizeof (struct attribute
);
14513 die
= (struct die_info
*) obstack_alloc (&cu
->comp_unit_obstack
, size
);
14514 memset (die
, 0, sizeof (struct die_info
));
14519 /* Macro support. */
14521 /* Return the full name of file number I in *LH's file name table.
14522 Use COMP_DIR as the name of the current directory of the
14523 compilation. The result is allocated using xmalloc; the caller is
14524 responsible for freeing it. */
14526 file_full_name (int file
, struct line_header
*lh
, const char *comp_dir
)
14528 /* Is the file number a valid index into the line header's file name
14529 table? Remember that file numbers start with one, not zero. */
14530 if (1 <= file
&& file
<= lh
->num_file_names
)
14532 struct file_entry
*fe
= &lh
->file_names
[file
- 1];
14534 if (IS_ABSOLUTE_PATH (fe
->name
))
14535 return xstrdup (fe
->name
);
14543 dir
= lh
->include_dirs
[fe
->dir_index
- 1];
14549 dir_len
= strlen (dir
);
14550 full_name
= xmalloc (dir_len
+ 1 + strlen (fe
->name
) + 1);
14551 strcpy (full_name
, dir
);
14552 full_name
[dir_len
] = '/';
14553 strcpy (full_name
+ dir_len
+ 1, fe
->name
);
14557 return xstrdup (fe
->name
);
14562 /* The compiler produced a bogus file number. We can at least
14563 record the macro definitions made in the file, even if we
14564 won't be able to find the file by name. */
14565 char fake_name
[80];
14567 sprintf (fake_name
, "<bad macro file number %d>", file
);
14569 complaint (&symfile_complaints
,
14570 _("bad file number in macro information (%d)"),
14573 return xstrdup (fake_name
);
14578 static struct macro_source_file
*
14579 macro_start_file (int file
, int line
,
14580 struct macro_source_file
*current_file
,
14581 const char *comp_dir
,
14582 struct line_header
*lh
, struct objfile
*objfile
)
14584 /* The full name of this source file. */
14585 char *full_name
= file_full_name (file
, lh
, comp_dir
);
14587 /* We don't create a macro table for this compilation unit
14588 at all until we actually get a filename. */
14589 if (! pending_macros
)
14590 pending_macros
= new_macro_table (&objfile
->objfile_obstack
,
14591 objfile
->macro_cache
);
14593 if (! current_file
)
14594 /* If we have no current file, then this must be the start_file
14595 directive for the compilation unit's main source file. */
14596 current_file
= macro_set_main (pending_macros
, full_name
);
14598 current_file
= macro_include (current_file
, line
, full_name
);
14602 return current_file
;
14606 /* Copy the LEN characters at BUF to a xmalloc'ed block of memory,
14607 followed by a null byte. */
14609 copy_string (const char *buf
, int len
)
14611 char *s
= xmalloc (len
+ 1);
14613 memcpy (s
, buf
, len
);
14619 static const char *
14620 consume_improper_spaces (const char *p
, const char *body
)
14624 complaint (&symfile_complaints
,
14625 _("macro definition contains spaces "
14626 "in formal argument list:\n`%s'"),
14638 parse_macro_definition (struct macro_source_file
*file
, int line
,
14643 /* The body string takes one of two forms. For object-like macro
14644 definitions, it should be:
14646 <macro name> " " <definition>
14648 For function-like macro definitions, it should be:
14650 <macro name> "() " <definition>
14652 <macro name> "(" <arg name> ( "," <arg name> ) * ") " <definition>
14654 Spaces may appear only where explicitly indicated, and in the
14657 The Dwarf 2 spec says that an object-like macro's name is always
14658 followed by a space, but versions of GCC around March 2002 omit
14659 the space when the macro's definition is the empty string.
14661 The Dwarf 2 spec says that there should be no spaces between the
14662 formal arguments in a function-like macro's formal argument list,
14663 but versions of GCC around March 2002 include spaces after the
14667 /* Find the extent of the macro name. The macro name is terminated
14668 by either a space or null character (for an object-like macro) or
14669 an opening paren (for a function-like macro). */
14670 for (p
= body
; *p
; p
++)
14671 if (*p
== ' ' || *p
== '(')
14674 if (*p
== ' ' || *p
== '\0')
14676 /* It's an object-like macro. */
14677 int name_len
= p
- body
;
14678 char *name
= copy_string (body
, name_len
);
14679 const char *replacement
;
14682 replacement
= body
+ name_len
+ 1;
14685 dwarf2_macro_malformed_definition_complaint (body
);
14686 replacement
= body
+ name_len
;
14689 macro_define_object (file
, line
, name
, replacement
);
14693 else if (*p
== '(')
14695 /* It's a function-like macro. */
14696 char *name
= copy_string (body
, p
- body
);
14699 char **argv
= xmalloc (argv_size
* sizeof (*argv
));
14703 p
= consume_improper_spaces (p
, body
);
14705 /* Parse the formal argument list. */
14706 while (*p
&& *p
!= ')')
14708 /* Find the extent of the current argument name. */
14709 const char *arg_start
= p
;
14711 while (*p
&& *p
!= ',' && *p
!= ')' && *p
!= ' ')
14714 if (! *p
|| p
== arg_start
)
14715 dwarf2_macro_malformed_definition_complaint (body
);
14718 /* Make sure argv has room for the new argument. */
14719 if (argc
>= argv_size
)
14722 argv
= xrealloc (argv
, argv_size
* sizeof (*argv
));
14725 argv
[argc
++] = copy_string (arg_start
, p
- arg_start
);
14728 p
= consume_improper_spaces (p
, body
);
14730 /* Consume the comma, if present. */
14735 p
= consume_improper_spaces (p
, body
);
14744 /* Perfectly formed definition, no complaints. */
14745 macro_define_function (file
, line
, name
,
14746 argc
, (const char **) argv
,
14748 else if (*p
== '\0')
14750 /* Complain, but do define it. */
14751 dwarf2_macro_malformed_definition_complaint (body
);
14752 macro_define_function (file
, line
, name
,
14753 argc
, (const char **) argv
,
14757 /* Just complain. */
14758 dwarf2_macro_malformed_definition_complaint (body
);
14761 /* Just complain. */
14762 dwarf2_macro_malformed_definition_complaint (body
);
14768 for (i
= 0; i
< argc
; i
++)
14774 dwarf2_macro_malformed_definition_complaint (body
);
14777 /* Skip some bytes from BYTES according to the form given in FORM.
14778 Returns the new pointer. */
14781 skip_form_bytes (bfd
*abfd
, gdb_byte
*bytes
,
14782 enum dwarf_form form
,
14783 unsigned int offset_size
,
14784 struct dwarf2_section_info
*section
)
14786 unsigned int bytes_read
;
14790 case DW_FORM_data1
:
14795 case DW_FORM_data2
:
14799 case DW_FORM_data4
:
14803 case DW_FORM_data8
:
14807 case DW_FORM_string
:
14808 read_direct_string (abfd
, bytes
, &bytes_read
);
14809 bytes
+= bytes_read
;
14812 case DW_FORM_sec_offset
:
14814 bytes
+= offset_size
;
14817 case DW_FORM_block
:
14818 bytes
+= read_unsigned_leb128 (abfd
, bytes
, &bytes_read
);
14819 bytes
+= bytes_read
;
14822 case DW_FORM_block1
:
14823 bytes
+= 1 + read_1_byte (abfd
, bytes
);
14825 case DW_FORM_block2
:
14826 bytes
+= 2 + read_2_bytes (abfd
, bytes
);
14828 case DW_FORM_block4
:
14829 bytes
+= 4 + read_4_bytes (abfd
, bytes
);
14832 case DW_FORM_sdata
:
14833 case DW_FORM_udata
:
14834 bytes
= skip_leb128 (abfd
, bytes
);
14840 complaint (&symfile_complaints
,
14841 _("invalid form 0x%x in `%s'"),
14843 section
->asection
->name
);
14851 /* A helper for dwarf_decode_macros that handles skipping an unknown
14852 opcode. Returns an updated pointer to the macro data buffer; or,
14853 on error, issues a complaint and returns NULL. */
14856 skip_unknown_opcode (unsigned int opcode
,
14857 gdb_byte
**opcode_definitions
,
14860 unsigned int offset_size
,
14861 struct dwarf2_section_info
*section
)
14863 unsigned int bytes_read
, i
;
14867 if (opcode_definitions
[opcode
] == NULL
)
14869 complaint (&symfile_complaints
,
14870 _("unrecognized DW_MACFINO opcode 0x%x"),
14875 defn
= opcode_definitions
[opcode
];
14876 arg
= read_unsigned_leb128 (abfd
, defn
, &bytes_read
);
14877 defn
+= bytes_read
;
14879 for (i
= 0; i
< arg
; ++i
)
14881 mac_ptr
= skip_form_bytes (abfd
, mac_ptr
, defn
[i
], offset_size
, section
);
14882 if (mac_ptr
== NULL
)
14884 /* skip_form_bytes already issued the complaint. */
14892 /* A helper function which parses the header of a macro section.
14893 If the macro section is the extended (for now called "GNU") type,
14894 then this updates *OFFSET_SIZE. Returns a pointer to just after
14895 the header, or issues a complaint and returns NULL on error. */
14898 dwarf_parse_macro_header (gdb_byte
**opcode_definitions
,
14901 unsigned int *offset_size
,
14902 int section_is_gnu
)
14904 memset (opcode_definitions
, 0, 256 * sizeof (gdb_byte
*));
14906 if (section_is_gnu
)
14908 unsigned int version
, flags
;
14910 version
= read_2_bytes (abfd
, mac_ptr
);
14913 complaint (&symfile_complaints
,
14914 _("unrecognized version `%d' in .debug_macro section"),
14920 flags
= read_1_byte (abfd
, mac_ptr
);
14922 *offset_size
= (flags
& 1) ? 8 : 4;
14924 if ((flags
& 2) != 0)
14925 /* We don't need the line table offset. */
14926 mac_ptr
+= *offset_size
;
14928 /* Vendor opcode descriptions. */
14929 if ((flags
& 4) != 0)
14931 unsigned int i
, count
;
14933 count
= read_1_byte (abfd
, mac_ptr
);
14935 for (i
= 0; i
< count
; ++i
)
14937 unsigned int opcode
, bytes_read
;
14940 opcode
= read_1_byte (abfd
, mac_ptr
);
14942 opcode_definitions
[opcode
] = mac_ptr
;
14943 arg
= read_unsigned_leb128 (abfd
, mac_ptr
, &bytes_read
);
14944 mac_ptr
+= bytes_read
;
14953 /* A helper for dwarf_decode_macros that handles the GNU extensions,
14954 including DW_GNU_MACINFO_transparent_include. */
14957 dwarf_decode_macro_bytes (bfd
*abfd
, gdb_byte
*mac_ptr
, gdb_byte
*mac_end
,
14958 struct macro_source_file
*current_file
,
14959 struct line_header
*lh
, char *comp_dir
,
14960 struct dwarf2_section_info
*section
,
14961 int section_is_gnu
,
14962 unsigned int offset_size
,
14963 struct objfile
*objfile
)
14965 enum dwarf_macro_record_type macinfo_type
;
14966 int at_commandline
;
14967 gdb_byte
*opcode_definitions
[256];
14969 mac_ptr
= dwarf_parse_macro_header (opcode_definitions
, abfd
, mac_ptr
,
14970 &offset_size
, section_is_gnu
);
14971 if (mac_ptr
== NULL
)
14973 /* We already issued a complaint. */
14977 /* Determines if GDB is still before first DW_MACINFO_start_file. If true
14978 GDB is still reading the definitions from command line. First
14979 DW_MACINFO_start_file will need to be ignored as it was already executed
14980 to create CURRENT_FILE for the main source holding also the command line
14981 definitions. On first met DW_MACINFO_start_file this flag is reset to
14982 normally execute all the remaining DW_MACINFO_start_file macinfos. */
14984 at_commandline
= 1;
14988 /* Do we at least have room for a macinfo type byte? */
14989 if (mac_ptr
>= mac_end
)
14991 dwarf2_macros_too_long_complaint (section
);
14995 macinfo_type
= read_1_byte (abfd
, mac_ptr
);
14998 /* Note that we rely on the fact that the corresponding GNU and
14999 DWARF constants are the same. */
15000 switch (macinfo_type
)
15002 /* A zero macinfo type indicates the end of the macro
15007 case DW_MACRO_GNU_define
:
15008 case DW_MACRO_GNU_undef
:
15009 case DW_MACRO_GNU_define_indirect
:
15010 case DW_MACRO_GNU_undef_indirect
:
15012 unsigned int bytes_read
;
15017 line
= read_unsigned_leb128 (abfd
, mac_ptr
, &bytes_read
);
15018 mac_ptr
+= bytes_read
;
15020 if (macinfo_type
== DW_MACRO_GNU_define
15021 || macinfo_type
== DW_MACRO_GNU_undef
)
15023 body
= read_direct_string (abfd
, mac_ptr
, &bytes_read
);
15024 mac_ptr
+= bytes_read
;
15028 LONGEST str_offset
;
15030 str_offset
= read_offset_1 (abfd
, mac_ptr
, offset_size
);
15031 mac_ptr
+= offset_size
;
15033 body
= read_indirect_string_at_offset (abfd
, str_offset
);
15036 is_define
= (macinfo_type
== DW_MACRO_GNU_define
15037 || macinfo_type
== DW_MACRO_GNU_define_indirect
);
15038 if (! current_file
)
15040 /* DWARF violation as no main source is present. */
15041 complaint (&symfile_complaints
,
15042 _("debug info with no main source gives macro %s "
15044 is_define
? _("definition") : _("undefinition"),
15048 if ((line
== 0 && !at_commandline
)
15049 || (line
!= 0 && at_commandline
))
15050 complaint (&symfile_complaints
,
15051 _("debug info gives %s macro %s with %s line %d: %s"),
15052 at_commandline
? _("command-line") : _("in-file"),
15053 is_define
? _("definition") : _("undefinition"),
15054 line
== 0 ? _("zero") : _("non-zero"), line
, body
);
15057 parse_macro_definition (current_file
, line
, body
);
15060 gdb_assert (macinfo_type
== DW_MACRO_GNU_undef
15061 || macinfo_type
== DW_MACRO_GNU_undef_indirect
);
15062 macro_undef (current_file
, line
, body
);
15067 case DW_MACRO_GNU_start_file
:
15069 unsigned int bytes_read
;
15072 line
= read_unsigned_leb128 (abfd
, mac_ptr
, &bytes_read
);
15073 mac_ptr
+= bytes_read
;
15074 file
= read_unsigned_leb128 (abfd
, mac_ptr
, &bytes_read
);
15075 mac_ptr
+= bytes_read
;
15077 if ((line
== 0 && !at_commandline
)
15078 || (line
!= 0 && at_commandline
))
15079 complaint (&symfile_complaints
,
15080 _("debug info gives source %d included "
15081 "from %s at %s line %d"),
15082 file
, at_commandline
? _("command-line") : _("file"),
15083 line
== 0 ? _("zero") : _("non-zero"), line
);
15085 if (at_commandline
)
15087 /* This DW_MACRO_GNU_start_file was executed in the
15089 at_commandline
= 0;
15092 current_file
= macro_start_file (file
, line
,
15093 current_file
, comp_dir
,
15098 case DW_MACRO_GNU_end_file
:
15099 if (! current_file
)
15100 complaint (&symfile_complaints
,
15101 _("macro debug info has an unmatched "
15102 "`close_file' directive"));
15105 current_file
= current_file
->included_by
;
15106 if (! current_file
)
15108 enum dwarf_macro_record_type next_type
;
15110 /* GCC circa March 2002 doesn't produce the zero
15111 type byte marking the end of the compilation
15112 unit. Complain if it's not there, but exit no
15115 /* Do we at least have room for a macinfo type byte? */
15116 if (mac_ptr
>= mac_end
)
15118 dwarf2_macros_too_long_complaint (section
);
15122 /* We don't increment mac_ptr here, so this is just
15124 next_type
= read_1_byte (abfd
, mac_ptr
);
15125 if (next_type
!= 0)
15126 complaint (&symfile_complaints
,
15127 _("no terminating 0-type entry for "
15128 "macros in `.debug_macinfo' section"));
15135 case DW_MACRO_GNU_transparent_include
:
15139 offset
= read_offset_1 (abfd
, mac_ptr
, offset_size
);
15140 mac_ptr
+= offset_size
;
15142 dwarf_decode_macro_bytes (abfd
,
15143 section
->buffer
+ offset
,
15144 mac_end
, current_file
,
15146 section
, section_is_gnu
,
15147 offset_size
, objfile
);
15151 case DW_MACINFO_vendor_ext
:
15152 if (!section_is_gnu
)
15154 unsigned int bytes_read
;
15157 constant
= read_unsigned_leb128 (abfd
, mac_ptr
, &bytes_read
);
15158 mac_ptr
+= bytes_read
;
15159 read_direct_string (abfd
, mac_ptr
, &bytes_read
);
15160 mac_ptr
+= bytes_read
;
15162 /* We don't recognize any vendor extensions. */
15168 mac_ptr
= skip_unknown_opcode (macinfo_type
, opcode_definitions
,
15169 mac_ptr
, abfd
, offset_size
,
15171 if (mac_ptr
== NULL
)
15175 } while (macinfo_type
!= 0);
15179 dwarf_decode_macros (struct line_header
*lh
, unsigned int offset
,
15180 char *comp_dir
, bfd
*abfd
,
15181 struct dwarf2_cu
*cu
,
15182 struct dwarf2_section_info
*section
,
15183 int section_is_gnu
)
15185 gdb_byte
*mac_ptr
, *mac_end
;
15186 struct macro_source_file
*current_file
= 0;
15187 enum dwarf_macro_record_type macinfo_type
;
15188 unsigned int offset_size
= cu
->header
.offset_size
;
15189 gdb_byte
*opcode_definitions
[256];
15191 dwarf2_read_section (dwarf2_per_objfile
->objfile
, section
);
15192 if (section
->buffer
== NULL
)
15194 complaint (&symfile_complaints
, _("missing %s section"),
15195 section
->asection
->name
);
15199 /* First pass: Find the name of the base filename.
15200 This filename is needed in order to process all macros whose definition
15201 (or undefinition) comes from the command line. These macros are defined
15202 before the first DW_MACINFO_start_file entry, and yet still need to be
15203 associated to the base file.
15205 To determine the base file name, we scan the macro definitions until we
15206 reach the first DW_MACINFO_start_file entry. We then initialize
15207 CURRENT_FILE accordingly so that any macro definition found before the
15208 first DW_MACINFO_start_file can still be associated to the base file. */
15210 mac_ptr
= section
->buffer
+ offset
;
15211 mac_end
= section
->buffer
+ section
->size
;
15213 mac_ptr
= dwarf_parse_macro_header (opcode_definitions
, abfd
, mac_ptr
,
15214 &offset_size
, section_is_gnu
);
15215 if (mac_ptr
== NULL
)
15217 /* We already issued a complaint. */
15223 /* Do we at least have room for a macinfo type byte? */
15224 if (mac_ptr
>= mac_end
)
15226 /* Complaint is printed during the second pass as GDB will probably
15227 stop the first pass earlier upon finding
15228 DW_MACINFO_start_file. */
15232 macinfo_type
= read_1_byte (abfd
, mac_ptr
);
15235 /* Note that we rely on the fact that the corresponding GNU and
15236 DWARF constants are the same. */
15237 switch (macinfo_type
)
15239 /* A zero macinfo type indicates the end of the macro
15244 case DW_MACRO_GNU_define
:
15245 case DW_MACRO_GNU_undef
:
15246 /* Only skip the data by MAC_PTR. */
15248 unsigned int bytes_read
;
15250 read_unsigned_leb128 (abfd
, mac_ptr
, &bytes_read
);
15251 mac_ptr
+= bytes_read
;
15252 read_direct_string (abfd
, mac_ptr
, &bytes_read
);
15253 mac_ptr
+= bytes_read
;
15257 case DW_MACRO_GNU_start_file
:
15259 unsigned int bytes_read
;
15262 line
= read_unsigned_leb128 (abfd
, mac_ptr
, &bytes_read
);
15263 mac_ptr
+= bytes_read
;
15264 file
= read_unsigned_leb128 (abfd
, mac_ptr
, &bytes_read
);
15265 mac_ptr
+= bytes_read
;
15267 current_file
= macro_start_file (file
, line
, current_file
,
15268 comp_dir
, lh
, cu
->objfile
);
15272 case DW_MACRO_GNU_end_file
:
15273 /* No data to skip by MAC_PTR. */
15276 case DW_MACRO_GNU_define_indirect
:
15277 case DW_MACRO_GNU_undef_indirect
:
15279 unsigned int bytes_read
;
15281 read_unsigned_leb128 (abfd
, mac_ptr
, &bytes_read
);
15282 mac_ptr
+= bytes_read
;
15283 mac_ptr
+= offset_size
;
15287 case DW_MACRO_GNU_transparent_include
:
15288 /* Note that, according to the spec, a transparent include
15289 chain cannot call DW_MACRO_GNU_start_file. So, we can just
15290 skip this opcode. */
15291 mac_ptr
+= offset_size
;
15294 case DW_MACINFO_vendor_ext
:
15295 /* Only skip the data by MAC_PTR. */
15296 if (!section_is_gnu
)
15298 unsigned int bytes_read
;
15300 read_unsigned_leb128 (abfd
, mac_ptr
, &bytes_read
);
15301 mac_ptr
+= bytes_read
;
15302 read_direct_string (abfd
, mac_ptr
, &bytes_read
);
15303 mac_ptr
+= bytes_read
;
15308 mac_ptr
= skip_unknown_opcode (macinfo_type
, opcode_definitions
,
15309 mac_ptr
, abfd
, offset_size
,
15311 if (mac_ptr
== NULL
)
15315 } while (macinfo_type
!= 0 && current_file
== NULL
);
15317 /* Second pass: Process all entries.
15319 Use the AT_COMMAND_LINE flag to determine whether we are still processing
15320 command-line macro definitions/undefinitions. This flag is unset when we
15321 reach the first DW_MACINFO_start_file entry. */
15323 dwarf_decode_macro_bytes (abfd
, section
->buffer
+ offset
, mac_end
,
15324 current_file
, lh
, comp_dir
, section
, section_is_gnu
,
15325 offset_size
, cu
->objfile
);
15328 /* Check if the attribute's form is a DW_FORM_block*
15329 if so return true else false. */
15331 attr_form_is_block (struct attribute
*attr
)
15333 return (attr
== NULL
? 0 :
15334 attr
->form
== DW_FORM_block1
15335 || attr
->form
== DW_FORM_block2
15336 || attr
->form
== DW_FORM_block4
15337 || attr
->form
== DW_FORM_block
15338 || attr
->form
== DW_FORM_exprloc
);
15341 /* Return non-zero if ATTR's value is a section offset --- classes
15342 lineptr, loclistptr, macptr or rangelistptr --- or zero, otherwise.
15343 You may use DW_UNSND (attr) to retrieve such offsets.
15345 Section 7.5.4, "Attribute Encodings", explains that no attribute
15346 may have a value that belongs to more than one of these classes; it
15347 would be ambiguous if we did, because we use the same forms for all
15350 attr_form_is_section_offset (struct attribute
*attr
)
15352 return (attr
->form
== DW_FORM_data4
15353 || attr
->form
== DW_FORM_data8
15354 || attr
->form
== DW_FORM_sec_offset
);
15358 /* Return non-zero if ATTR's value falls in the 'constant' class, or
15359 zero otherwise. When this function returns true, you can apply
15360 dwarf2_get_attr_constant_value to it.
15362 However, note that for some attributes you must check
15363 attr_form_is_section_offset before using this test. DW_FORM_data4
15364 and DW_FORM_data8 are members of both the constant class, and of
15365 the classes that contain offsets into other debug sections
15366 (lineptr, loclistptr, macptr or rangelistptr). The DWARF spec says
15367 that, if an attribute's can be either a constant or one of the
15368 section offset classes, DW_FORM_data4 and DW_FORM_data8 should be
15369 taken as section offsets, not constants. */
15371 attr_form_is_constant (struct attribute
*attr
)
15373 switch (attr
->form
)
15375 case DW_FORM_sdata
:
15376 case DW_FORM_udata
:
15377 case DW_FORM_data1
:
15378 case DW_FORM_data2
:
15379 case DW_FORM_data4
:
15380 case DW_FORM_data8
:
15387 /* A helper function that fills in a dwarf2_loclist_baton. */
15390 fill_in_loclist_baton (struct dwarf2_cu
*cu
,
15391 struct dwarf2_loclist_baton
*baton
,
15392 struct attribute
*attr
)
15394 dwarf2_read_section (dwarf2_per_objfile
->objfile
,
15395 &dwarf2_per_objfile
->loc
);
15397 baton
->per_cu
= cu
->per_cu
;
15398 gdb_assert (baton
->per_cu
);
15399 /* We don't know how long the location list is, but make sure we
15400 don't run off the edge of the section. */
15401 baton
->size
= dwarf2_per_objfile
->loc
.size
- DW_UNSND (attr
);
15402 baton
->data
= dwarf2_per_objfile
->loc
.buffer
+ DW_UNSND (attr
);
15403 baton
->base_address
= cu
->base_address
;
15407 dwarf2_symbol_mark_computed (struct attribute
*attr
, struct symbol
*sym
,
15408 struct dwarf2_cu
*cu
)
15410 if (attr_form_is_section_offset (attr
)
15411 /* ".debug_loc" may not exist at all, or the offset may be outside
15412 the section. If so, fall through to the complaint in the
15414 && DW_UNSND (attr
) < dwarf2_section_size (dwarf2_per_objfile
->objfile
,
15415 &dwarf2_per_objfile
->loc
))
15417 struct dwarf2_loclist_baton
*baton
;
15419 baton
= obstack_alloc (&cu
->objfile
->objfile_obstack
,
15420 sizeof (struct dwarf2_loclist_baton
));
15422 fill_in_loclist_baton (cu
, baton
, attr
);
15424 if (cu
->base_known
== 0)
15425 complaint (&symfile_complaints
,
15426 _("Location list used without "
15427 "specifying the CU base address."));
15429 SYMBOL_COMPUTED_OPS (sym
) = &dwarf2_loclist_funcs
;
15430 SYMBOL_LOCATION_BATON (sym
) = baton
;
15434 struct dwarf2_locexpr_baton
*baton
;
15436 baton
= obstack_alloc (&cu
->objfile
->objfile_obstack
,
15437 sizeof (struct dwarf2_locexpr_baton
));
15438 baton
->per_cu
= cu
->per_cu
;
15439 gdb_assert (baton
->per_cu
);
15441 if (attr_form_is_block (attr
))
15443 /* Note that we're just copying the block's data pointer
15444 here, not the actual data. We're still pointing into the
15445 info_buffer for SYM's objfile; right now we never release
15446 that buffer, but when we do clean up properly this may
15448 baton
->size
= DW_BLOCK (attr
)->size
;
15449 baton
->data
= DW_BLOCK (attr
)->data
;
15453 dwarf2_invalid_attrib_class_complaint ("location description",
15454 SYMBOL_NATURAL_NAME (sym
));
15456 baton
->data
= NULL
;
15459 SYMBOL_COMPUTED_OPS (sym
) = &dwarf2_locexpr_funcs
;
15460 SYMBOL_LOCATION_BATON (sym
) = baton
;
15464 /* Return the OBJFILE associated with the compilation unit CU. If CU
15465 came from a separate debuginfo file, then the master objfile is
15469 dwarf2_per_cu_objfile (struct dwarf2_per_cu_data
*per_cu
)
15471 struct objfile
*objfile
= per_cu
->objfile
;
15473 /* Return the master objfile, so that we can report and look up the
15474 correct file containing this variable. */
15475 if (objfile
->separate_debug_objfile_backlink
)
15476 objfile
= objfile
->separate_debug_objfile_backlink
;
15481 /* Return comp_unit_head for PER_CU, either already available in PER_CU->CU
15482 (CU_HEADERP is unused in such case) or prepare a temporary copy at
15483 CU_HEADERP first. */
15485 static const struct comp_unit_head
*
15486 per_cu_header_read_in (struct comp_unit_head
*cu_headerp
,
15487 struct dwarf2_per_cu_data
*per_cu
)
15489 struct objfile
*objfile
;
15490 struct dwarf2_per_objfile
*per_objfile
;
15491 gdb_byte
*info_ptr
;
15494 return &per_cu
->cu
->header
;
15496 objfile
= per_cu
->objfile
;
15497 per_objfile
= objfile_data (objfile
, dwarf2_objfile_data_key
);
15498 info_ptr
= per_objfile
->info
.buffer
+ per_cu
->offset
;
15500 memset (cu_headerp
, 0, sizeof (*cu_headerp
));
15501 read_comp_unit_head (cu_headerp
, info_ptr
, objfile
->obfd
);
15506 /* Return the address size given in the compilation unit header for CU. */
15509 dwarf2_per_cu_addr_size (struct dwarf2_per_cu_data
*per_cu
)
15511 struct comp_unit_head cu_header_local
;
15512 const struct comp_unit_head
*cu_headerp
;
15514 cu_headerp
= per_cu_header_read_in (&cu_header_local
, per_cu
);
15516 return cu_headerp
->addr_size
;
15519 /* Return the offset size given in the compilation unit header for CU. */
15522 dwarf2_per_cu_offset_size (struct dwarf2_per_cu_data
*per_cu
)
15524 struct comp_unit_head cu_header_local
;
15525 const struct comp_unit_head
*cu_headerp
;
15527 cu_headerp
= per_cu_header_read_in (&cu_header_local
, per_cu
);
15529 return cu_headerp
->offset_size
;
15532 /* See its dwarf2loc.h declaration. */
15535 dwarf2_per_cu_ref_addr_size (struct dwarf2_per_cu_data
*per_cu
)
15537 struct comp_unit_head cu_header_local
;
15538 const struct comp_unit_head
*cu_headerp
;
15540 cu_headerp
= per_cu_header_read_in (&cu_header_local
, per_cu
);
15542 if (cu_headerp
->version
== 2)
15543 return cu_headerp
->addr_size
;
15545 return cu_headerp
->offset_size
;
15548 /* Return the text offset of the CU. The returned offset comes from
15549 this CU's objfile. If this objfile came from a separate debuginfo
15550 file, then the offset may be different from the corresponding
15551 offset in the parent objfile. */
15554 dwarf2_per_cu_text_offset (struct dwarf2_per_cu_data
*per_cu
)
15556 struct objfile
*objfile
= per_cu
->objfile
;
15558 return ANOFFSET (objfile
->section_offsets
, SECT_OFF_TEXT (objfile
));
15561 /* Locate the .debug_info compilation unit from CU's objfile which contains
15562 the DIE at OFFSET. Raises an error on failure. */
15564 static struct dwarf2_per_cu_data
*
15565 dwarf2_find_containing_comp_unit (unsigned int offset
,
15566 struct objfile
*objfile
)
15568 struct dwarf2_per_cu_data
*this_cu
;
15572 high
= dwarf2_per_objfile
->n_comp_units
- 1;
15575 int mid
= low
+ (high
- low
) / 2;
15577 if (dwarf2_per_objfile
->all_comp_units
[mid
]->offset
>= offset
)
15582 gdb_assert (low
== high
);
15583 if (dwarf2_per_objfile
->all_comp_units
[low
]->offset
> offset
)
15586 error (_("Dwarf Error: could not find partial DIE containing "
15587 "offset 0x%lx [in module %s]"),
15588 (long) offset
, bfd_get_filename (objfile
->obfd
));
15590 gdb_assert (dwarf2_per_objfile
->all_comp_units
[low
-1]->offset
<= offset
);
15591 return dwarf2_per_objfile
->all_comp_units
[low
-1];
15595 this_cu
= dwarf2_per_objfile
->all_comp_units
[low
];
15596 if (low
== dwarf2_per_objfile
->n_comp_units
- 1
15597 && offset
>= this_cu
->offset
+ this_cu
->length
)
15598 error (_("invalid dwarf2 offset %u"), offset
);
15599 gdb_assert (offset
< this_cu
->offset
+ this_cu
->length
);
15604 /* Locate the compilation unit from OBJFILE which is located at exactly
15605 OFFSET. Raises an error on failure. */
15607 static struct dwarf2_per_cu_data
*
15608 dwarf2_find_comp_unit (unsigned int offset
, struct objfile
*objfile
)
15610 struct dwarf2_per_cu_data
*this_cu
;
15612 this_cu
= dwarf2_find_containing_comp_unit (offset
, objfile
);
15613 if (this_cu
->offset
!= offset
)
15614 error (_("no compilation unit with offset %u."), offset
);
15618 /* Initialize dwarf2_cu CU for OBJFILE in a pre-allocated space. */
15621 init_one_comp_unit (struct dwarf2_cu
*cu
, struct objfile
*objfile
)
15623 memset (cu
, 0, sizeof (*cu
));
15624 cu
->objfile
= objfile
;
15625 obstack_init (&cu
->comp_unit_obstack
);
15628 /* Initialize basic fields of dwarf_cu CU according to DIE COMP_UNIT_DIE. */
15631 prepare_one_comp_unit (struct dwarf2_cu
*cu
, struct die_info
*comp_unit_die
)
15633 struct attribute
*attr
;
15635 /* Set the language we're debugging. */
15636 attr
= dwarf2_attr (comp_unit_die
, DW_AT_language
, cu
);
15638 set_cu_language (DW_UNSND (attr
), cu
);
15641 cu
->language
= language_minimal
;
15642 cu
->language_defn
= language_def (cu
->language
);
15646 /* Release one cached compilation unit, CU. We unlink it from the tree
15647 of compilation units, but we don't remove it from the read_in_chain;
15648 the caller is responsible for that.
15649 NOTE: DATA is a void * because this function is also used as a
15650 cleanup routine. */
15653 free_one_comp_unit (void *data
)
15655 struct dwarf2_cu
*cu
= data
;
15657 if (cu
->per_cu
!= NULL
)
15658 cu
->per_cu
->cu
= NULL
;
15661 obstack_free (&cu
->comp_unit_obstack
, NULL
);
15666 /* This cleanup function is passed the address of a dwarf2_cu on the stack
15667 when we're finished with it. We can't free the pointer itself, but be
15668 sure to unlink it from the cache. Also release any associated storage
15669 and perform cache maintenance.
15671 Only used during partial symbol parsing. */
15674 free_stack_comp_unit (void *data
)
15676 struct dwarf2_cu
*cu
= data
;
15678 obstack_free (&cu
->comp_unit_obstack
, NULL
);
15679 cu
->partial_dies
= NULL
;
15681 if (cu
->per_cu
!= NULL
)
15683 /* This compilation unit is on the stack in our caller, so we
15684 should not xfree it. Just unlink it. */
15685 cu
->per_cu
->cu
= NULL
;
15688 /* If we had a per-cu pointer, then we may have other compilation
15689 units loaded, so age them now. */
15690 age_cached_comp_units ();
15694 /* Free all cached compilation units. */
15697 free_cached_comp_units (void *data
)
15699 struct dwarf2_per_cu_data
*per_cu
, **last_chain
;
15701 per_cu
= dwarf2_per_objfile
->read_in_chain
;
15702 last_chain
= &dwarf2_per_objfile
->read_in_chain
;
15703 while (per_cu
!= NULL
)
15705 struct dwarf2_per_cu_data
*next_cu
;
15707 next_cu
= per_cu
->cu
->read_in_chain
;
15709 free_one_comp_unit (per_cu
->cu
);
15710 *last_chain
= next_cu
;
15716 /* Increase the age counter on each cached compilation unit, and free
15717 any that are too old. */
15720 age_cached_comp_units (void)
15722 struct dwarf2_per_cu_data
*per_cu
, **last_chain
;
15724 dwarf2_clear_marks (dwarf2_per_objfile
->read_in_chain
);
15725 per_cu
= dwarf2_per_objfile
->read_in_chain
;
15726 while (per_cu
!= NULL
)
15728 per_cu
->cu
->last_used
++;
15729 if (per_cu
->cu
->last_used
<= dwarf2_max_cache_age
)
15730 dwarf2_mark (per_cu
->cu
);
15731 per_cu
= per_cu
->cu
->read_in_chain
;
15734 per_cu
= dwarf2_per_objfile
->read_in_chain
;
15735 last_chain
= &dwarf2_per_objfile
->read_in_chain
;
15736 while (per_cu
!= NULL
)
15738 struct dwarf2_per_cu_data
*next_cu
;
15740 next_cu
= per_cu
->cu
->read_in_chain
;
15742 if (!per_cu
->cu
->mark
)
15744 free_one_comp_unit (per_cu
->cu
);
15745 *last_chain
= next_cu
;
15748 last_chain
= &per_cu
->cu
->read_in_chain
;
15754 /* Remove a single compilation unit from the cache. */
15757 free_one_cached_comp_unit (void *target_cu
)
15759 struct dwarf2_per_cu_data
*per_cu
, **last_chain
;
15761 per_cu
= dwarf2_per_objfile
->read_in_chain
;
15762 last_chain
= &dwarf2_per_objfile
->read_in_chain
;
15763 while (per_cu
!= NULL
)
15765 struct dwarf2_per_cu_data
*next_cu
;
15767 next_cu
= per_cu
->cu
->read_in_chain
;
15769 if (per_cu
->cu
== target_cu
)
15771 free_one_comp_unit (per_cu
->cu
);
15772 *last_chain
= next_cu
;
15776 last_chain
= &per_cu
->cu
->read_in_chain
;
15782 /* Release all extra memory associated with OBJFILE. */
15785 dwarf2_free_objfile (struct objfile
*objfile
)
15787 dwarf2_per_objfile
= objfile_data (objfile
, dwarf2_objfile_data_key
);
15789 if (dwarf2_per_objfile
== NULL
)
15792 /* Cached DIE trees use xmalloc and the comp_unit_obstack. */
15793 free_cached_comp_units (NULL
);
15795 if (dwarf2_per_objfile
->quick_file_names_table
)
15796 htab_delete (dwarf2_per_objfile
->quick_file_names_table
);
15798 /* Everything else should be on the objfile obstack. */
15801 /* A pair of DIE offset and GDB type pointer. We store these
15802 in a hash table separate from the DIEs, and preserve them
15803 when the DIEs are flushed out of cache. */
15805 struct dwarf2_offset_and_type
15807 unsigned int offset
;
15811 /* Hash function for a dwarf2_offset_and_type. */
15814 offset_and_type_hash (const void *item
)
15816 const struct dwarf2_offset_and_type
*ofs
= item
;
15818 return ofs
->offset
;
15821 /* Equality function for a dwarf2_offset_and_type. */
15824 offset_and_type_eq (const void *item_lhs
, const void *item_rhs
)
15826 const struct dwarf2_offset_and_type
*ofs_lhs
= item_lhs
;
15827 const struct dwarf2_offset_and_type
*ofs_rhs
= item_rhs
;
15829 return ofs_lhs
->offset
== ofs_rhs
->offset
;
15832 /* Set the type associated with DIE to TYPE. Save it in CU's hash
15833 table if necessary. For convenience, return TYPE.
15835 The DIEs reading must have careful ordering to:
15836 * Not cause infite loops trying to read in DIEs as a prerequisite for
15837 reading current DIE.
15838 * Not trying to dereference contents of still incompletely read in types
15839 while reading in other DIEs.
15840 * Enable referencing still incompletely read in types just by a pointer to
15841 the type without accessing its fields.
15843 Therefore caller should follow these rules:
15844 * Try to fetch any prerequisite types we may need to build this DIE type
15845 before building the type and calling set_die_type.
15846 * After building type call set_die_type for current DIE as soon as
15847 possible before fetching more types to complete the current type.
15848 * Make the type as complete as possible before fetching more types. */
15850 static struct type
*
15851 set_die_type (struct die_info
*die
, struct type
*type
, struct dwarf2_cu
*cu
)
15853 struct dwarf2_offset_and_type
**slot
, ofs
;
15854 struct objfile
*objfile
= cu
->objfile
;
15855 htab_t
*type_hash_ptr
;
15857 /* For Ada types, make sure that the gnat-specific data is always
15858 initialized (if not already set). There are a few types where
15859 we should not be doing so, because the type-specific area is
15860 already used to hold some other piece of info (eg: TYPE_CODE_FLT
15861 where the type-specific area is used to store the floatformat).
15862 But this is not a problem, because the gnat-specific information
15863 is actually not needed for these types. */
15864 if (need_gnat_info (cu
)
15865 && TYPE_CODE (type
) != TYPE_CODE_FUNC
15866 && TYPE_CODE (type
) != TYPE_CODE_FLT
15867 && !HAVE_GNAT_AUX_INFO (type
))
15868 INIT_GNAT_SPECIFIC (type
);
15870 if (cu
->per_cu
->debug_type_section
)
15871 type_hash_ptr
= &dwarf2_per_objfile
->debug_types_type_hash
;
15873 type_hash_ptr
= &dwarf2_per_objfile
->debug_info_type_hash
;
15875 if (*type_hash_ptr
== NULL
)
15878 = htab_create_alloc_ex (127,
15879 offset_and_type_hash
,
15880 offset_and_type_eq
,
15882 &objfile
->objfile_obstack
,
15883 hashtab_obstack_allocate
,
15884 dummy_obstack_deallocate
);
15887 ofs
.offset
= die
->offset
;
15889 slot
= (struct dwarf2_offset_and_type
**)
15890 htab_find_slot_with_hash (*type_hash_ptr
, &ofs
, ofs
.offset
, INSERT
);
15892 complaint (&symfile_complaints
,
15893 _("A problem internal to GDB: DIE 0x%x has type already set"),
15895 *slot
= obstack_alloc (&objfile
->objfile_obstack
, sizeof (**slot
));
15900 /* Look up the type for the die at DIE_OFFSET in the appropriate type_hash
15901 table, or return NULL if the die does not have a saved type. */
15903 static struct type
*
15904 get_die_type_at_offset (unsigned int offset
,
15905 struct dwarf2_per_cu_data
*per_cu
)
15907 struct dwarf2_offset_and_type
*slot
, ofs
;
15910 if (per_cu
->debug_type_section
)
15911 type_hash
= dwarf2_per_objfile
->debug_types_type_hash
;
15913 type_hash
= dwarf2_per_objfile
->debug_info_type_hash
;
15914 if (type_hash
== NULL
)
15917 ofs
.offset
= offset
;
15918 slot
= htab_find_with_hash (type_hash
, &ofs
, ofs
.offset
);
15925 /* Look up the type for DIE in the appropriate type_hash table,
15926 or return NULL if DIE does not have a saved type. */
15928 static struct type
*
15929 get_die_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
15931 return get_die_type_at_offset (die
->offset
, cu
->per_cu
);
15934 /* Add a dependence relationship from CU to REF_PER_CU. */
15937 dwarf2_add_dependence (struct dwarf2_cu
*cu
,
15938 struct dwarf2_per_cu_data
*ref_per_cu
)
15942 if (cu
->dependencies
== NULL
)
15944 = htab_create_alloc_ex (5, htab_hash_pointer
, htab_eq_pointer
,
15945 NULL
, &cu
->comp_unit_obstack
,
15946 hashtab_obstack_allocate
,
15947 dummy_obstack_deallocate
);
15949 slot
= htab_find_slot (cu
->dependencies
, ref_per_cu
, INSERT
);
15951 *slot
= ref_per_cu
;
15954 /* Subroutine of dwarf2_mark to pass to htab_traverse.
15955 Set the mark field in every compilation unit in the
15956 cache that we must keep because we are keeping CU. */
15959 dwarf2_mark_helper (void **slot
, void *data
)
15961 struct dwarf2_per_cu_data
*per_cu
;
15963 per_cu
= (struct dwarf2_per_cu_data
*) *slot
;
15965 /* cu->dependencies references may not yet have been ever read if QUIT aborts
15966 reading of the chain. As such dependencies remain valid it is not much
15967 useful to track and undo them during QUIT cleanups. */
15968 if (per_cu
->cu
== NULL
)
15971 if (per_cu
->cu
->mark
)
15973 per_cu
->cu
->mark
= 1;
15975 if (per_cu
->cu
->dependencies
!= NULL
)
15976 htab_traverse (per_cu
->cu
->dependencies
, dwarf2_mark_helper
, NULL
);
15981 /* Set the mark field in CU and in every other compilation unit in the
15982 cache that we must keep because we are keeping CU. */
15985 dwarf2_mark (struct dwarf2_cu
*cu
)
15990 if (cu
->dependencies
!= NULL
)
15991 htab_traverse (cu
->dependencies
, dwarf2_mark_helper
, NULL
);
15995 dwarf2_clear_marks (struct dwarf2_per_cu_data
*per_cu
)
15999 per_cu
->cu
->mark
= 0;
16000 per_cu
= per_cu
->cu
->read_in_chain
;
16004 /* Trivial hash function for partial_die_info: the hash value of a DIE
16005 is its offset in .debug_info for this objfile. */
16008 partial_die_hash (const void *item
)
16010 const struct partial_die_info
*part_die
= item
;
16012 return part_die
->offset
;
16015 /* Trivial comparison function for partial_die_info structures: two DIEs
16016 are equal if they have the same offset. */
16019 partial_die_eq (const void *item_lhs
, const void *item_rhs
)
16021 const struct partial_die_info
*part_die_lhs
= item_lhs
;
16022 const struct partial_die_info
*part_die_rhs
= item_rhs
;
16024 return part_die_lhs
->offset
== part_die_rhs
->offset
;
16027 static struct cmd_list_element
*set_dwarf2_cmdlist
;
16028 static struct cmd_list_element
*show_dwarf2_cmdlist
;
16031 set_dwarf2_cmd (char *args
, int from_tty
)
16033 help_list (set_dwarf2_cmdlist
, "maintenance set dwarf2 ", -1, gdb_stdout
);
16037 show_dwarf2_cmd (char *args
, int from_tty
)
16039 cmd_show_list (show_dwarf2_cmdlist
, from_tty
, "");
16042 /* If section described by INFO was mmapped, munmap it now. */
16045 munmap_section_buffer (struct dwarf2_section_info
*info
)
16047 if (info
->map_addr
!= NULL
)
16052 res
= munmap (info
->map_addr
, info
->map_len
);
16053 gdb_assert (res
== 0);
16055 /* Without HAVE_MMAP, we should never be here to begin with. */
16056 gdb_assert_not_reached ("no mmap support");
16061 /* munmap debug sections for OBJFILE, if necessary. */
16064 dwarf2_per_objfile_free (struct objfile
*objfile
, void *d
)
16066 struct dwarf2_per_objfile
*data
= d
;
16068 struct dwarf2_section_info
*section
;
16070 /* This is sorted according to the order they're defined in to make it easier
16071 to keep in sync. */
16072 munmap_section_buffer (&data
->info
);
16073 munmap_section_buffer (&data
->abbrev
);
16074 munmap_section_buffer (&data
->line
);
16075 munmap_section_buffer (&data
->loc
);
16076 munmap_section_buffer (&data
->macinfo
);
16077 munmap_section_buffer (&data
->macro
);
16078 munmap_section_buffer (&data
->str
);
16079 munmap_section_buffer (&data
->ranges
);
16080 munmap_section_buffer (&data
->frame
);
16081 munmap_section_buffer (&data
->eh_frame
);
16082 munmap_section_buffer (&data
->gdb_index
);
16085 VEC_iterate (dwarf2_section_info_def
, data
->types
, ix
, section
);
16087 munmap_section_buffer (section
);
16089 VEC_free (dwarf2_section_info_def
, data
->types
);
16093 /* The "save gdb-index" command. */
16095 /* The contents of the hash table we create when building the string
16097 struct strtab_entry
16099 offset_type offset
;
16103 /* Hash function for a strtab_entry.
16105 Function is used only during write_hash_table so no index format backward
16106 compatibility is needed. */
16109 hash_strtab_entry (const void *e
)
16111 const struct strtab_entry
*entry
= e
;
16112 return mapped_index_string_hash (INT_MAX
, entry
->str
);
16115 /* Equality function for a strtab_entry. */
16118 eq_strtab_entry (const void *a
, const void *b
)
16120 const struct strtab_entry
*ea
= a
;
16121 const struct strtab_entry
*eb
= b
;
16122 return !strcmp (ea
->str
, eb
->str
);
16125 /* Create a strtab_entry hash table. */
16128 create_strtab (void)
16130 return htab_create_alloc (100, hash_strtab_entry
, eq_strtab_entry
,
16131 xfree
, xcalloc
, xfree
);
16134 /* Add a string to the constant pool. Return the string's offset in
16138 add_string (htab_t table
, struct obstack
*cpool
, const char *str
)
16141 struct strtab_entry entry
;
16142 struct strtab_entry
*result
;
16145 slot
= htab_find_slot (table
, &entry
, INSERT
);
16150 result
= XNEW (struct strtab_entry
);
16151 result
->offset
= obstack_object_size (cpool
);
16153 obstack_grow_str0 (cpool
, str
);
16156 return result
->offset
;
16159 /* An entry in the symbol table. */
16160 struct symtab_index_entry
16162 /* The name of the symbol. */
16164 /* The offset of the name in the constant pool. */
16165 offset_type index_offset
;
16166 /* A sorted vector of the indices of all the CUs that hold an object
16168 VEC (offset_type
) *cu_indices
;
16171 /* The symbol table. This is a power-of-2-sized hash table. */
16172 struct mapped_symtab
16174 offset_type n_elements
;
16176 struct symtab_index_entry
**data
;
16179 /* Hash function for a symtab_index_entry. */
16182 hash_symtab_entry (const void *e
)
16184 const struct symtab_index_entry
*entry
= e
;
16185 return iterative_hash (VEC_address (offset_type
, entry
->cu_indices
),
16186 sizeof (offset_type
) * VEC_length (offset_type
,
16187 entry
->cu_indices
),
16191 /* Equality function for a symtab_index_entry. */
16194 eq_symtab_entry (const void *a
, const void *b
)
16196 const struct symtab_index_entry
*ea
= a
;
16197 const struct symtab_index_entry
*eb
= b
;
16198 int len
= VEC_length (offset_type
, ea
->cu_indices
);
16199 if (len
!= VEC_length (offset_type
, eb
->cu_indices
))
16201 return !memcmp (VEC_address (offset_type
, ea
->cu_indices
),
16202 VEC_address (offset_type
, eb
->cu_indices
),
16203 sizeof (offset_type
) * len
);
16206 /* Destroy a symtab_index_entry. */
16209 delete_symtab_entry (void *p
)
16211 struct symtab_index_entry
*entry
= p
;
16212 VEC_free (offset_type
, entry
->cu_indices
);
16216 /* Create a hash table holding symtab_index_entry objects. */
16219 create_symbol_hash_table (void)
16221 return htab_create_alloc (100, hash_symtab_entry
, eq_symtab_entry
,
16222 delete_symtab_entry
, xcalloc
, xfree
);
16225 /* Create a new mapped symtab object. */
16227 static struct mapped_symtab
*
16228 create_mapped_symtab (void)
16230 struct mapped_symtab
*symtab
= XNEW (struct mapped_symtab
);
16231 symtab
->n_elements
= 0;
16232 symtab
->size
= 1024;
16233 symtab
->data
= XCNEWVEC (struct symtab_index_entry
*, symtab
->size
);
16237 /* Destroy a mapped_symtab. */
16240 cleanup_mapped_symtab (void *p
)
16242 struct mapped_symtab
*symtab
= p
;
16243 /* The contents of the array are freed when the other hash table is
16245 xfree (symtab
->data
);
16249 /* Find a slot in SYMTAB for the symbol NAME. Returns a pointer to
16252 Function is used only during write_hash_table so no index format backward
16253 compatibility is needed. */
16255 static struct symtab_index_entry
**
16256 find_slot (struct mapped_symtab
*symtab
, const char *name
)
16258 offset_type index
, step
, hash
= mapped_index_string_hash (INT_MAX
, name
);
16260 index
= hash
& (symtab
->size
- 1);
16261 step
= ((hash
* 17) & (symtab
->size
- 1)) | 1;
16265 if (!symtab
->data
[index
] || !strcmp (name
, symtab
->data
[index
]->name
))
16266 return &symtab
->data
[index
];
16267 index
= (index
+ step
) & (symtab
->size
- 1);
16271 /* Expand SYMTAB's hash table. */
16274 hash_expand (struct mapped_symtab
*symtab
)
16276 offset_type old_size
= symtab
->size
;
16278 struct symtab_index_entry
**old_entries
= symtab
->data
;
16281 symtab
->data
= XCNEWVEC (struct symtab_index_entry
*, symtab
->size
);
16283 for (i
= 0; i
< old_size
; ++i
)
16285 if (old_entries
[i
])
16287 struct symtab_index_entry
**slot
= find_slot (symtab
,
16288 old_entries
[i
]->name
);
16289 *slot
= old_entries
[i
];
16293 xfree (old_entries
);
16296 /* Add an entry to SYMTAB. NAME is the name of the symbol. CU_INDEX
16297 is the index of the CU in which the symbol appears. */
16300 add_index_entry (struct mapped_symtab
*symtab
, const char *name
,
16301 offset_type cu_index
)
16303 struct symtab_index_entry
**slot
;
16305 ++symtab
->n_elements
;
16306 if (4 * symtab
->n_elements
/ 3 >= symtab
->size
)
16307 hash_expand (symtab
);
16309 slot
= find_slot (symtab
, name
);
16312 *slot
= XNEW (struct symtab_index_entry
);
16313 (*slot
)->name
= name
;
16314 (*slot
)->cu_indices
= NULL
;
16316 /* Don't push an index twice. Due to how we add entries we only
16317 have to check the last one. */
16318 if (VEC_empty (offset_type
, (*slot
)->cu_indices
)
16319 || VEC_last (offset_type
, (*slot
)->cu_indices
) != cu_index
)
16320 VEC_safe_push (offset_type
, (*slot
)->cu_indices
, cu_index
);
16323 /* Add a vector of indices to the constant pool. */
16326 add_indices_to_cpool (htab_t symbol_hash_table
, struct obstack
*cpool
,
16327 struct symtab_index_entry
*entry
)
16331 slot
= htab_find_slot (symbol_hash_table
, entry
, INSERT
);
16334 offset_type len
= VEC_length (offset_type
, entry
->cu_indices
);
16335 offset_type val
= MAYBE_SWAP (len
);
16340 entry
->index_offset
= obstack_object_size (cpool
);
16342 obstack_grow (cpool
, &val
, sizeof (val
));
16344 VEC_iterate (offset_type
, entry
->cu_indices
, i
, iter
);
16347 val
= MAYBE_SWAP (iter
);
16348 obstack_grow (cpool
, &val
, sizeof (val
));
16353 struct symtab_index_entry
*old_entry
= *slot
;
16354 entry
->index_offset
= old_entry
->index_offset
;
16357 return entry
->index_offset
;
16360 /* Write the mapped hash table SYMTAB to the obstack OUTPUT, with
16361 constant pool entries going into the obstack CPOOL. */
16364 write_hash_table (struct mapped_symtab
*symtab
,
16365 struct obstack
*output
, struct obstack
*cpool
)
16368 htab_t symbol_hash_table
;
16371 symbol_hash_table
= create_symbol_hash_table ();
16372 str_table
= create_strtab ();
16374 /* We add all the index vectors to the constant pool first, to
16375 ensure alignment is ok. */
16376 for (i
= 0; i
< symtab
->size
; ++i
)
16378 if (symtab
->data
[i
])
16379 add_indices_to_cpool (symbol_hash_table
, cpool
, symtab
->data
[i
]);
16382 /* Now write out the hash table. */
16383 for (i
= 0; i
< symtab
->size
; ++i
)
16385 offset_type str_off
, vec_off
;
16387 if (symtab
->data
[i
])
16389 str_off
= add_string (str_table
, cpool
, symtab
->data
[i
]->name
);
16390 vec_off
= symtab
->data
[i
]->index_offset
;
16394 /* While 0 is a valid constant pool index, it is not valid
16395 to have 0 for both offsets. */
16400 str_off
= MAYBE_SWAP (str_off
);
16401 vec_off
= MAYBE_SWAP (vec_off
);
16403 obstack_grow (output
, &str_off
, sizeof (str_off
));
16404 obstack_grow (output
, &vec_off
, sizeof (vec_off
));
16407 htab_delete (str_table
);
16408 htab_delete (symbol_hash_table
);
16411 /* Struct to map psymtab to CU index in the index file. */
16412 struct psymtab_cu_index_map
16414 struct partial_symtab
*psymtab
;
16415 unsigned int cu_index
;
16419 hash_psymtab_cu_index (const void *item
)
16421 const struct psymtab_cu_index_map
*map
= item
;
16423 return htab_hash_pointer (map
->psymtab
);
16427 eq_psymtab_cu_index (const void *item_lhs
, const void *item_rhs
)
16429 const struct psymtab_cu_index_map
*lhs
= item_lhs
;
16430 const struct psymtab_cu_index_map
*rhs
= item_rhs
;
16432 return lhs
->psymtab
== rhs
->psymtab
;
16435 /* Helper struct for building the address table. */
16436 struct addrmap_index_data
16438 struct objfile
*objfile
;
16439 struct obstack
*addr_obstack
;
16440 htab_t cu_index_htab
;
16442 /* Non-zero if the previous_* fields are valid.
16443 We can't write an entry until we see the next entry (since it is only then
16444 that we know the end of the entry). */
16445 int previous_valid
;
16446 /* Index of the CU in the table of all CUs in the index file. */
16447 unsigned int previous_cu_index
;
16448 /* Start address of the CU. */
16449 CORE_ADDR previous_cu_start
;
16452 /* Write an address entry to OBSTACK. */
16455 add_address_entry (struct objfile
*objfile
, struct obstack
*obstack
,
16456 CORE_ADDR start
, CORE_ADDR end
, unsigned int cu_index
)
16458 offset_type cu_index_to_write
;
16460 CORE_ADDR baseaddr
;
16462 baseaddr
= ANOFFSET (objfile
->section_offsets
, SECT_OFF_TEXT (objfile
));
16464 store_unsigned_integer (addr
, 8, BFD_ENDIAN_LITTLE
, start
- baseaddr
);
16465 obstack_grow (obstack
, addr
, 8);
16466 store_unsigned_integer (addr
, 8, BFD_ENDIAN_LITTLE
, end
- baseaddr
);
16467 obstack_grow (obstack
, addr
, 8);
16468 cu_index_to_write
= MAYBE_SWAP (cu_index
);
16469 obstack_grow (obstack
, &cu_index_to_write
, sizeof (offset_type
));
16472 /* Worker function for traversing an addrmap to build the address table. */
16475 add_address_entry_worker (void *datap
, CORE_ADDR start_addr
, void *obj
)
16477 struct addrmap_index_data
*data
= datap
;
16478 struct partial_symtab
*pst
= obj
;
16479 offset_type cu_index
;
16482 if (data
->previous_valid
)
16483 add_address_entry (data
->objfile
, data
->addr_obstack
,
16484 data
->previous_cu_start
, start_addr
,
16485 data
->previous_cu_index
);
16487 data
->previous_cu_start
= start_addr
;
16490 struct psymtab_cu_index_map find_map
, *map
;
16491 find_map
.psymtab
= pst
;
16492 map
= htab_find (data
->cu_index_htab
, &find_map
);
16493 gdb_assert (map
!= NULL
);
16494 data
->previous_cu_index
= map
->cu_index
;
16495 data
->previous_valid
= 1;
16498 data
->previous_valid
= 0;
16503 /* Write OBJFILE's address map to OBSTACK.
16504 CU_INDEX_HTAB is used to map addrmap entries to their CU indices
16505 in the index file. */
16508 write_address_map (struct objfile
*objfile
, struct obstack
*obstack
,
16509 htab_t cu_index_htab
)
16511 struct addrmap_index_data addrmap_index_data
;
16513 /* When writing the address table, we have to cope with the fact that
16514 the addrmap iterator only provides the start of a region; we have to
16515 wait until the next invocation to get the start of the next region. */
16517 addrmap_index_data
.objfile
= objfile
;
16518 addrmap_index_data
.addr_obstack
= obstack
;
16519 addrmap_index_data
.cu_index_htab
= cu_index_htab
;
16520 addrmap_index_data
.previous_valid
= 0;
16522 addrmap_foreach (objfile
->psymtabs_addrmap
, add_address_entry_worker
,
16523 &addrmap_index_data
);
16525 /* It's highly unlikely the last entry (end address = 0xff...ff)
16526 is valid, but we should still handle it.
16527 The end address is recorded as the start of the next region, but that
16528 doesn't work here. To cope we pass 0xff...ff, this is a rare situation
16530 if (addrmap_index_data
.previous_valid
)
16531 add_address_entry (objfile
, obstack
,
16532 addrmap_index_data
.previous_cu_start
, (CORE_ADDR
) -1,
16533 addrmap_index_data
.previous_cu_index
);
16536 /* Add a list of partial symbols to SYMTAB. */
16539 write_psymbols (struct mapped_symtab
*symtab
,
16541 struct partial_symbol
**psymp
,
16543 offset_type cu_index
,
16546 for (; count
-- > 0; ++psymp
)
16548 void **slot
, *lookup
;
16550 if (SYMBOL_LANGUAGE (*psymp
) == language_ada
)
16551 error (_("Ada is not currently supported by the index"));
16553 /* We only want to add a given psymbol once. However, we also
16554 want to account for whether it is global or static. So, we
16555 may add it twice, using slightly different values. */
16558 uintptr_t val
= 1 | (uintptr_t) *psymp
;
16560 lookup
= (void *) val
;
16565 /* Only add a given psymbol once. */
16566 slot
= htab_find_slot (psyms_seen
, lookup
, INSERT
);
16570 add_index_entry (symtab
, SYMBOL_NATURAL_NAME (*psymp
), cu_index
);
16575 /* Write the contents of an ("unfinished") obstack to FILE. Throw an
16576 exception if there is an error. */
16579 write_obstack (FILE *file
, struct obstack
*obstack
)
16581 if (fwrite (obstack_base (obstack
), 1, obstack_object_size (obstack
),
16583 != obstack_object_size (obstack
))
16584 error (_("couldn't data write to file"));
16587 /* Unlink a file if the argument is not NULL. */
16590 unlink_if_set (void *p
)
16592 char **filename
= p
;
16594 unlink (*filename
);
16597 /* A helper struct used when iterating over debug_types. */
16598 struct signatured_type_index_data
16600 struct objfile
*objfile
;
16601 struct mapped_symtab
*symtab
;
16602 struct obstack
*types_list
;
16607 /* A helper function that writes a single signatured_type to an
16611 write_one_signatured_type (void **slot
, void *d
)
16613 struct signatured_type_index_data
*info
= d
;
16614 struct signatured_type
*entry
= (struct signatured_type
*) *slot
;
16615 struct dwarf2_per_cu_data
*per_cu
= &entry
->per_cu
;
16616 struct partial_symtab
*psymtab
= per_cu
->v
.psymtab
;
16619 write_psymbols (info
->symtab
,
16621 info
->objfile
->global_psymbols
.list
16622 + psymtab
->globals_offset
,
16623 psymtab
->n_global_syms
, info
->cu_index
,
16625 write_psymbols (info
->symtab
,
16627 info
->objfile
->static_psymbols
.list
16628 + psymtab
->statics_offset
,
16629 psymtab
->n_static_syms
, info
->cu_index
,
16632 store_unsigned_integer (val
, 8, BFD_ENDIAN_LITTLE
, entry
->per_cu
.offset
);
16633 obstack_grow (info
->types_list
, val
, 8);
16634 store_unsigned_integer (val
, 8, BFD_ENDIAN_LITTLE
, entry
->type_offset
);
16635 obstack_grow (info
->types_list
, val
, 8);
16636 store_unsigned_integer (val
, 8, BFD_ENDIAN_LITTLE
, entry
->signature
);
16637 obstack_grow (info
->types_list
, val
, 8);
16644 /* Create an index file for OBJFILE in the directory DIR. */
16647 write_psymtabs_to_index (struct objfile
*objfile
, const char *dir
)
16649 struct cleanup
*cleanup
;
16650 char *filename
, *cleanup_filename
;
16651 struct obstack contents
, addr_obstack
, constant_pool
, symtab_obstack
;
16652 struct obstack cu_list
, types_cu_list
;
16655 struct mapped_symtab
*symtab
;
16656 offset_type val
, size_of_contents
, total_len
;
16660 htab_t cu_index_htab
;
16661 struct psymtab_cu_index_map
*psymtab_cu_index_map
;
16663 if (!objfile
->psymtabs
|| !objfile
->psymtabs_addrmap
)
16666 if (dwarf2_per_objfile
->using_index
)
16667 error (_("Cannot use an index to create the index"));
16669 if (VEC_length (dwarf2_section_info_def
, dwarf2_per_objfile
->types
) > 1)
16670 error (_("Cannot make an index when the file has multiple .debug_types sections"));
16672 if (stat (objfile
->name
, &st
) < 0)
16673 perror_with_name (objfile
->name
);
16675 filename
= concat (dir
, SLASH_STRING
, lbasename (objfile
->name
),
16676 INDEX_SUFFIX
, (char *) NULL
);
16677 cleanup
= make_cleanup (xfree
, filename
);
16679 out_file
= fopen (filename
, "wb");
16681 error (_("Can't open `%s' for writing"), filename
);
16683 cleanup_filename
= filename
;
16684 make_cleanup (unlink_if_set
, &cleanup_filename
);
16686 symtab
= create_mapped_symtab ();
16687 make_cleanup (cleanup_mapped_symtab
, symtab
);
16689 obstack_init (&addr_obstack
);
16690 make_cleanup_obstack_free (&addr_obstack
);
16692 obstack_init (&cu_list
);
16693 make_cleanup_obstack_free (&cu_list
);
16695 obstack_init (&types_cu_list
);
16696 make_cleanup_obstack_free (&types_cu_list
);
16698 psyms_seen
= htab_create_alloc (100, htab_hash_pointer
, htab_eq_pointer
,
16699 NULL
, xcalloc
, xfree
);
16700 make_cleanup_htab_delete (psyms_seen
);
16702 /* While we're scanning CU's create a table that maps a psymtab pointer
16703 (which is what addrmap records) to its index (which is what is recorded
16704 in the index file). This will later be needed to write the address
16706 cu_index_htab
= htab_create_alloc (100,
16707 hash_psymtab_cu_index
,
16708 eq_psymtab_cu_index
,
16709 NULL
, xcalloc
, xfree
);
16710 make_cleanup_htab_delete (cu_index_htab
);
16711 psymtab_cu_index_map
= (struct psymtab_cu_index_map
*)
16712 xmalloc (sizeof (struct psymtab_cu_index_map
)
16713 * dwarf2_per_objfile
->n_comp_units
);
16714 make_cleanup (xfree
, psymtab_cu_index_map
);
16716 /* The CU list is already sorted, so we don't need to do additional
16717 work here. Also, the debug_types entries do not appear in
16718 all_comp_units, but only in their own hash table. */
16719 for (i
= 0; i
< dwarf2_per_objfile
->n_comp_units
; ++i
)
16721 struct dwarf2_per_cu_data
*per_cu
16722 = dwarf2_per_objfile
->all_comp_units
[i
];
16723 struct partial_symtab
*psymtab
= per_cu
->v
.psymtab
;
16725 struct psymtab_cu_index_map
*map
;
16728 write_psymbols (symtab
,
16730 objfile
->global_psymbols
.list
+ psymtab
->globals_offset
,
16731 psymtab
->n_global_syms
, i
,
16733 write_psymbols (symtab
,
16735 objfile
->static_psymbols
.list
+ psymtab
->statics_offset
,
16736 psymtab
->n_static_syms
, i
,
16739 map
= &psymtab_cu_index_map
[i
];
16740 map
->psymtab
= psymtab
;
16742 slot
= htab_find_slot (cu_index_htab
, map
, INSERT
);
16743 gdb_assert (slot
!= NULL
);
16744 gdb_assert (*slot
== NULL
);
16747 store_unsigned_integer (val
, 8, BFD_ENDIAN_LITTLE
, per_cu
->offset
);
16748 obstack_grow (&cu_list
, val
, 8);
16749 store_unsigned_integer (val
, 8, BFD_ENDIAN_LITTLE
, per_cu
->length
);
16750 obstack_grow (&cu_list
, val
, 8);
16753 /* Dump the address map. */
16754 write_address_map (objfile
, &addr_obstack
, cu_index_htab
);
16756 /* Write out the .debug_type entries, if any. */
16757 if (dwarf2_per_objfile
->signatured_types
)
16759 struct signatured_type_index_data sig_data
;
16761 sig_data
.objfile
= objfile
;
16762 sig_data
.symtab
= symtab
;
16763 sig_data
.types_list
= &types_cu_list
;
16764 sig_data
.psyms_seen
= psyms_seen
;
16765 sig_data
.cu_index
= dwarf2_per_objfile
->n_comp_units
;
16766 htab_traverse_noresize (dwarf2_per_objfile
->signatured_types
,
16767 write_one_signatured_type
, &sig_data
);
16770 obstack_init (&constant_pool
);
16771 make_cleanup_obstack_free (&constant_pool
);
16772 obstack_init (&symtab_obstack
);
16773 make_cleanup_obstack_free (&symtab_obstack
);
16774 write_hash_table (symtab
, &symtab_obstack
, &constant_pool
);
16776 obstack_init (&contents
);
16777 make_cleanup_obstack_free (&contents
);
16778 size_of_contents
= 6 * sizeof (offset_type
);
16779 total_len
= size_of_contents
;
16781 /* The version number. */
16782 val
= MAYBE_SWAP (5);
16783 obstack_grow (&contents
, &val
, sizeof (val
));
16785 /* The offset of the CU list from the start of the file. */
16786 val
= MAYBE_SWAP (total_len
);
16787 obstack_grow (&contents
, &val
, sizeof (val
));
16788 total_len
+= obstack_object_size (&cu_list
);
16790 /* The offset of the types CU list from the start of the file. */
16791 val
= MAYBE_SWAP (total_len
);
16792 obstack_grow (&contents
, &val
, sizeof (val
));
16793 total_len
+= obstack_object_size (&types_cu_list
);
16795 /* The offset of the address table from the start of the file. */
16796 val
= MAYBE_SWAP (total_len
);
16797 obstack_grow (&contents
, &val
, sizeof (val
));
16798 total_len
+= obstack_object_size (&addr_obstack
);
16800 /* The offset of the symbol table from the start of the file. */
16801 val
= MAYBE_SWAP (total_len
);
16802 obstack_grow (&contents
, &val
, sizeof (val
));
16803 total_len
+= obstack_object_size (&symtab_obstack
);
16805 /* The offset of the constant pool from the start of the file. */
16806 val
= MAYBE_SWAP (total_len
);
16807 obstack_grow (&contents
, &val
, sizeof (val
));
16808 total_len
+= obstack_object_size (&constant_pool
);
16810 gdb_assert (obstack_object_size (&contents
) == size_of_contents
);
16812 write_obstack (out_file
, &contents
);
16813 write_obstack (out_file
, &cu_list
);
16814 write_obstack (out_file
, &types_cu_list
);
16815 write_obstack (out_file
, &addr_obstack
);
16816 write_obstack (out_file
, &symtab_obstack
);
16817 write_obstack (out_file
, &constant_pool
);
16821 /* We want to keep the file, so we set cleanup_filename to NULL
16822 here. See unlink_if_set. */
16823 cleanup_filename
= NULL
;
16825 do_cleanups (cleanup
);
16828 /* Implementation of the `save gdb-index' command.
16830 Note that the file format used by this command is documented in the
16831 GDB manual. Any changes here must be documented there. */
16834 save_gdb_index_command (char *arg
, int from_tty
)
16836 struct objfile
*objfile
;
16839 error (_("usage: save gdb-index DIRECTORY"));
16841 ALL_OBJFILES (objfile
)
16845 /* If the objfile does not correspond to an actual file, skip it. */
16846 if (stat (objfile
->name
, &st
) < 0)
16849 dwarf2_per_objfile
= objfile_data (objfile
, dwarf2_objfile_data_key
);
16850 if (dwarf2_per_objfile
)
16852 volatile struct gdb_exception except
;
16854 TRY_CATCH (except
, RETURN_MASK_ERROR
)
16856 write_psymtabs_to_index (objfile
, arg
);
16858 if (except
.reason
< 0)
16859 exception_fprintf (gdb_stderr
, except
,
16860 _("Error while writing index for `%s': "),
16868 int dwarf2_always_disassemble
;
16871 show_dwarf2_always_disassemble (struct ui_file
*file
, int from_tty
,
16872 struct cmd_list_element
*c
, const char *value
)
16874 fprintf_filtered (file
,
16875 _("Whether to always disassemble "
16876 "DWARF expressions is %s.\n"),
16881 show_check_physname (struct ui_file
*file
, int from_tty
,
16882 struct cmd_list_element
*c
, const char *value
)
16884 fprintf_filtered (file
,
16885 _("Whether to check \"physname\" is %s.\n"),
16889 void _initialize_dwarf2_read (void);
16892 _initialize_dwarf2_read (void)
16894 struct cmd_list_element
*c
;
16896 dwarf2_objfile_data_key
16897 = register_objfile_data_with_cleanup (NULL
, dwarf2_per_objfile_free
);
16899 add_prefix_cmd ("dwarf2", class_maintenance
, set_dwarf2_cmd
, _("\
16900 Set DWARF 2 specific variables.\n\
16901 Configure DWARF 2 variables such as the cache size"),
16902 &set_dwarf2_cmdlist
, "maintenance set dwarf2 ",
16903 0/*allow-unknown*/, &maintenance_set_cmdlist
);
16905 add_prefix_cmd ("dwarf2", class_maintenance
, show_dwarf2_cmd
, _("\
16906 Show DWARF 2 specific variables\n\
16907 Show DWARF 2 variables such as the cache size"),
16908 &show_dwarf2_cmdlist
, "maintenance show dwarf2 ",
16909 0/*allow-unknown*/, &maintenance_show_cmdlist
);
16911 add_setshow_zinteger_cmd ("max-cache-age", class_obscure
,
16912 &dwarf2_max_cache_age
, _("\
16913 Set the upper bound on the age of cached dwarf2 compilation units."), _("\
16914 Show the upper bound on the age of cached dwarf2 compilation units."), _("\
16915 A higher limit means that cached compilation units will be stored\n\
16916 in memory longer, and more total memory will be used. Zero disables\n\
16917 caching, which can slow down startup."),
16919 show_dwarf2_max_cache_age
,
16920 &set_dwarf2_cmdlist
,
16921 &show_dwarf2_cmdlist
);
16923 add_setshow_boolean_cmd ("always-disassemble", class_obscure
,
16924 &dwarf2_always_disassemble
, _("\
16925 Set whether `info address' always disassembles DWARF expressions."), _("\
16926 Show whether `info address' always disassembles DWARF expressions."), _("\
16927 When enabled, DWARF expressions are always printed in an assembly-like\n\
16928 syntax. When disabled, expressions will be printed in a more\n\
16929 conversational style, when possible."),
16931 show_dwarf2_always_disassemble
,
16932 &set_dwarf2_cmdlist
,
16933 &show_dwarf2_cmdlist
);
16935 add_setshow_zinteger_cmd ("dwarf2-die", no_class
, &dwarf2_die_debug
, _("\
16936 Set debugging of the dwarf2 DIE reader."), _("\
16937 Show debugging of the dwarf2 DIE reader."), _("\
16938 When enabled (non-zero), DIEs are dumped after they are read in.\n\
16939 The value is the maximum depth to print."),
16942 &setdebuglist
, &showdebuglist
);
16944 add_setshow_boolean_cmd ("check-physname", no_class
, &check_physname
, _("\
16945 Set cross-checking of \"physname\" code against demangler."), _("\
16946 Show cross-checking of \"physname\" code against demangler."), _("\
16947 When enabled, GDB's internal \"physname\" code is checked against\n\
16949 NULL
, show_check_physname
,
16950 &setdebuglist
, &showdebuglist
);
16952 c
= add_cmd ("gdb-index", class_files
, save_gdb_index_command
,
16954 Save a gdb-index file.\n\
16955 Usage: save gdb-index DIRECTORY"),
16957 set_cmd_completer (c
, filename_completer
);