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"
62 #include "gdb_string.h"
63 #include "gdb_assert.h"
64 #include <sys/types.h>
71 #define MAP_FAILED ((void *) -1)
75 typedef struct symbol
*symbolp
;
79 /* .debug_info header for a compilation unit
80 Because of alignment constraints, this structure has padding and cannot
81 be mapped directly onto the beginning of the .debug_info section. */
82 typedef struct comp_unit_header
84 unsigned int length
; /* length of the .debug_info
86 unsigned short version
; /* version number -- 2 for DWARF
88 unsigned int abbrev_offset
; /* offset into .debug_abbrev section */
89 unsigned char addr_size
; /* byte size of an address -- 4 */
92 #define _ACTUAL_COMP_UNIT_HEADER_SIZE 11
95 /* .debug_line statement program prologue
96 Because of alignment constraints, this structure has padding and cannot
97 be mapped directly onto the beginning of the .debug_info section. */
98 typedef struct statement_prologue
100 unsigned int total_length
; /* byte length of the statement
102 unsigned short version
; /* version number -- 2 for DWARF
104 unsigned int prologue_length
; /* # bytes between prologue &
106 unsigned char minimum_instruction_length
; /* byte size of
108 unsigned char default_is_stmt
; /* initial value of is_stmt
111 unsigned char line_range
;
112 unsigned char opcode_base
; /* number assigned to first special
114 unsigned char *standard_opcode_lengths
;
118 /* When non-zero, dump DIEs after they are read in. */
119 static int dwarf2_die_debug
= 0;
123 /* When set, the file that we're processing is known to have debugging
124 info for C++ namespaces. GCC 3.3.x did not produce this information,
125 but later versions do. */
127 static int processing_has_namespace_info
;
129 static const struct objfile_data
*dwarf2_objfile_data_key
;
131 struct dwarf2_section_info
137 /* True if we have tried to read this section. */
141 /* All offsets in the index are of this type. It must be
142 architecture-independent. */
143 typedef uint32_t offset_type
;
145 DEF_VEC_I (offset_type
);
147 /* A description of the mapped index. The file format is described in
148 a comment by the code that writes the index. */
151 /* The total length of the buffer. */
153 /* A pointer to the address table data. */
154 const gdb_byte
*address_table
;
155 /* Size of the address table data in bytes. */
156 offset_type address_table_size
;
157 /* The symbol table, implemented as a hash table. */
158 const offset_type
*symbol_table
;
159 /* Size in slots, each slot is 2 offset_types. */
160 offset_type symbol_table_slots
;
161 /* A pointer to the constant pool. */
162 const char *constant_pool
;
165 struct dwarf2_per_objfile
167 struct dwarf2_section_info info
;
168 struct dwarf2_section_info abbrev
;
169 struct dwarf2_section_info line
;
170 struct dwarf2_section_info loc
;
171 struct dwarf2_section_info macinfo
;
172 struct dwarf2_section_info str
;
173 struct dwarf2_section_info ranges
;
174 struct dwarf2_section_info types
;
175 struct dwarf2_section_info frame
;
176 struct dwarf2_section_info eh_frame
;
177 struct dwarf2_section_info gdb_index
;
180 struct objfile
*objfile
;
182 /* A list of all the compilation units. This is used to locate
183 the target compilation unit of a particular reference. */
184 struct dwarf2_per_cu_data
**all_comp_units
;
186 /* The number of compilation units in ALL_COMP_UNITS. */
189 /* The number of .debug_types-related CUs. */
190 int n_type_comp_units
;
192 /* The .debug_types-related CUs. */
193 struct dwarf2_per_cu_data
**type_comp_units
;
195 /* A chain of compilation units that are currently read in, so that
196 they can be freed later. */
197 struct dwarf2_per_cu_data
*read_in_chain
;
199 /* A table mapping .debug_types signatures to its signatured_type entry.
200 This is NULL if the .debug_types section hasn't been read in yet. */
201 htab_t signatured_types
;
203 /* A flag indicating wether this objfile has a section loaded at a
205 int has_section_at_zero
;
207 /* True if we are using the mapped index,
208 or we are faking it for OBJF_READNOW's sake. */
209 unsigned char using_index
;
211 /* The mapped index, or NULL if .gdb_index is missing or not being used. */
212 struct mapped_index
*index_table
;
214 /* When using index_table, this keeps track of all quick_file_names entries.
215 TUs can share line table entries with CUs or other TUs, and there can be
216 a lot more TUs than unique line tables, so we maintain a separate table
217 of all line table entries to support the sharing. */
218 htab_t quick_file_names_table
;
220 /* Set during partial symbol reading, to prevent queueing of full
222 int reading_partial_symbols
;
224 /* Table mapping type .debug_info DIE offsets to types.
225 This is NULL if not allocated yet.
226 It (currently) makes sense to allocate debug_types_type_hash lazily.
227 To keep things simple we allocate both lazily. */
228 htab_t debug_info_type_hash
;
230 /* Table mapping type .debug_types DIE offsets to types.
231 This is NULL if not allocated yet. */
232 htab_t debug_types_type_hash
;
235 static struct dwarf2_per_objfile
*dwarf2_per_objfile
;
237 /* names of the debugging sections */
239 /* Note that if the debugging section has been compressed, it might
240 have a name like .zdebug_info. */
242 #define INFO_SECTION "debug_info"
243 #define ABBREV_SECTION "debug_abbrev"
244 #define LINE_SECTION "debug_line"
245 #define LOC_SECTION "debug_loc"
246 #define MACINFO_SECTION "debug_macinfo"
247 #define STR_SECTION "debug_str"
248 #define RANGES_SECTION "debug_ranges"
249 #define TYPES_SECTION "debug_types"
250 #define FRAME_SECTION "debug_frame"
251 #define EH_FRAME_SECTION "eh_frame"
252 #define GDB_INDEX_SECTION "gdb_index"
254 /* local data types */
256 /* We hold several abbreviation tables in memory at the same time. */
257 #ifndef ABBREV_HASH_SIZE
258 #define ABBREV_HASH_SIZE 121
261 /* The data in a compilation unit header, after target2host
262 translation, looks like this. */
263 struct comp_unit_head
267 unsigned char addr_size
;
268 unsigned char signed_addr_p
;
269 unsigned int abbrev_offset
;
271 /* Size of file offsets; either 4 or 8. */
272 unsigned int offset_size
;
274 /* Size of the length field; either 4 or 12. */
275 unsigned int initial_length_size
;
277 /* Offset to the first byte of this compilation unit header in the
278 .debug_info section, for resolving relative reference dies. */
281 /* Offset to first die in this cu from the start of the cu.
282 This will be the first byte following the compilation unit header. */
283 unsigned int first_die_offset
;
286 /* Type used for delaying computation of method physnames.
287 See comments for compute_delayed_physnames. */
288 struct delayed_method_info
290 /* The type to which the method is attached, i.e., its parent class. */
293 /* The index of the method in the type's function fieldlists. */
296 /* The index of the method in the fieldlist. */
299 /* The name of the DIE. */
302 /* The DIE associated with this method. */
303 struct die_info
*die
;
306 typedef struct delayed_method_info delayed_method_info
;
307 DEF_VEC_O (delayed_method_info
);
309 /* Internal state when decoding a particular compilation unit. */
312 /* The objfile containing this compilation unit. */
313 struct objfile
*objfile
;
315 /* The header of the compilation unit. */
316 struct comp_unit_head header
;
318 /* Base address of this compilation unit. */
319 CORE_ADDR base_address
;
321 /* Non-zero if base_address has been set. */
324 struct function_range
*first_fn
, *last_fn
, *cached_fn
;
326 /* The language we are debugging. */
327 enum language language
;
328 const struct language_defn
*language_defn
;
330 const char *producer
;
332 /* The generic symbol table building routines have separate lists for
333 file scope symbols and all all other scopes (local scopes). So
334 we need to select the right one to pass to add_symbol_to_list().
335 We do it by keeping a pointer to the correct list in list_in_scope.
337 FIXME: The original dwarf code just treated the file scope as the
338 first local scope, and all other local scopes as nested local
339 scopes, and worked fine. Check to see if we really need to
340 distinguish these in buildsym.c. */
341 struct pending
**list_in_scope
;
343 /* DWARF abbreviation table associated with this compilation unit. */
344 struct abbrev_info
**dwarf2_abbrevs
;
346 /* Storage for the abbrev table. */
347 struct obstack abbrev_obstack
;
349 /* Hash table holding all the loaded partial DIEs. */
352 /* Storage for things with the same lifetime as this read-in compilation
353 unit, including partial DIEs. */
354 struct obstack comp_unit_obstack
;
356 /* When multiple dwarf2_cu structures are living in memory, this field
357 chains them all together, so that they can be released efficiently.
358 We will probably also want a generation counter so that most-recently-used
359 compilation units are cached... */
360 struct dwarf2_per_cu_data
*read_in_chain
;
362 /* Backchain to our per_cu entry if the tree has been built. */
363 struct dwarf2_per_cu_data
*per_cu
;
365 /* How many compilation units ago was this CU last referenced? */
368 /* A hash table of die offsets for following references. */
371 /* Full DIEs if read in. */
372 struct die_info
*dies
;
374 /* A set of pointers to dwarf2_per_cu_data objects for compilation
375 units referenced by this one. Only set during full symbol processing;
376 partial symbol tables do not have dependencies. */
379 /* Header data from the line table, during full symbol processing. */
380 struct line_header
*line_header
;
382 /* A list of methods which need to have physnames computed
383 after all type information has been read. */
384 VEC (delayed_method_info
) *method_list
;
386 /* Mark used when releasing cached dies. */
387 unsigned int mark
: 1;
389 /* This flag will be set if this compilation unit might include
390 inter-compilation-unit references. */
391 unsigned int has_form_ref_addr
: 1;
393 /* This flag will be set if this compilation unit includes any
394 DW_TAG_namespace DIEs. If we know that there are explicit
395 DIEs for namespaces, we don't need to try to infer them
396 from mangled names. */
397 unsigned int has_namespace_info
: 1;
400 /* Persistent data held for a compilation unit, even when not
401 processing it. We put a pointer to this structure in the
402 read_symtab_private field of the psymtab. If we encounter
403 inter-compilation-unit references, we also maintain a sorted
404 list of all compilation units. */
406 struct dwarf2_per_cu_data
408 /* The start offset and length of this compilation unit. 2**29-1
409 bytes should suffice to store the length of any compilation unit
410 - if it doesn't, GDB will fall over anyway.
411 NOTE: Unlike comp_unit_head.length, this length includes
412 initial_length_size. */
414 unsigned int length
: 29;
416 /* Flag indicating this compilation unit will be read in before
417 any of the current compilation units are processed. */
418 unsigned int queued
: 1;
420 /* This flag will be set if we need to load absolutely all DIEs
421 for this compilation unit, instead of just the ones we think
422 are interesting. It gets set if we look for a DIE in the
423 hash table and don't find it. */
424 unsigned int load_all_dies
: 1;
426 /* Non-zero if this CU is from .debug_types.
427 Otherwise it's from .debug_info. */
428 unsigned int from_debug_types
: 1;
430 /* Set to non-NULL iff this CU is currently loaded. When it gets freed out
431 of the CU cache it gets reset to NULL again. */
432 struct dwarf2_cu
*cu
;
434 /* The corresponding objfile. */
435 struct objfile
*objfile
;
437 /* When using partial symbol tables, the 'psymtab' field is active.
438 Otherwise the 'quick' field is active. */
441 /* The partial symbol table associated with this compilation unit,
442 or NULL for partial units (which do not have an associated
444 struct partial_symtab
*psymtab
;
446 /* Data needed by the "quick" functions. */
447 struct dwarf2_per_cu_quick_data
*quick
;
451 /* Entry in the signatured_types hash table. */
453 struct signatured_type
457 /* Offset in .debug_types of the TU (type_unit) for this type. */
460 /* Offset in .debug_types of the type defined by this TU. */
461 unsigned int type_offset
;
463 /* The CU(/TU) of this type. */
464 struct dwarf2_per_cu_data per_cu
;
467 /* Struct used to pass misc. parameters to read_die_and_children, et
468 al. which are used for both .debug_info and .debug_types dies.
469 All parameters here are unchanging for the life of the call. This
470 struct exists to abstract away the constant parameters of die
473 struct die_reader_specs
475 /* The bfd of this objfile. */
478 /* The CU of the DIE we are parsing. */
479 struct dwarf2_cu
*cu
;
481 /* Pointer to start of section buffer.
482 This is either the start of .debug_info or .debug_types. */
483 const gdb_byte
*buffer
;
486 /* The line number information for a compilation unit (found in the
487 .debug_line section) begins with a "statement program header",
488 which contains the following information. */
491 unsigned int total_length
;
492 unsigned short version
;
493 unsigned int header_length
;
494 unsigned char minimum_instruction_length
;
495 unsigned char maximum_ops_per_instruction
;
496 unsigned char default_is_stmt
;
498 unsigned char line_range
;
499 unsigned char opcode_base
;
501 /* standard_opcode_lengths[i] is the number of operands for the
502 standard opcode whose value is i. This means that
503 standard_opcode_lengths[0] is unused, and the last meaningful
504 element is standard_opcode_lengths[opcode_base - 1]. */
505 unsigned char *standard_opcode_lengths
;
507 /* The include_directories table. NOTE! These strings are not
508 allocated with xmalloc; instead, they are pointers into
509 debug_line_buffer. If you try to free them, `free' will get
511 unsigned int num_include_dirs
, include_dirs_size
;
514 /* The file_names table. NOTE! These strings are not allocated
515 with xmalloc; instead, they are pointers into debug_line_buffer.
516 Don't try to free them directly. */
517 unsigned int num_file_names
, file_names_size
;
521 unsigned int dir_index
;
522 unsigned int mod_time
;
524 int included_p
; /* Non-zero if referenced by the Line Number Program. */
525 struct symtab
*symtab
; /* The associated symbol table, if any. */
528 /* The start and end of the statement program following this
529 header. These point into dwarf2_per_objfile->line_buffer. */
530 gdb_byte
*statement_program_start
, *statement_program_end
;
533 /* When we construct a partial symbol table entry we only
534 need this much information. */
535 struct partial_die_info
537 /* Offset of this DIE. */
540 /* DWARF-2 tag for this DIE. */
541 ENUM_BITFIELD(dwarf_tag
) tag
: 16;
543 /* Assorted flags describing the data found in this DIE. */
544 unsigned int has_children
: 1;
545 unsigned int is_external
: 1;
546 unsigned int is_declaration
: 1;
547 unsigned int has_type
: 1;
548 unsigned int has_specification
: 1;
549 unsigned int has_pc_info
: 1;
551 /* Flag set if the SCOPE field of this structure has been
553 unsigned int scope_set
: 1;
555 /* Flag set if the DIE has a byte_size attribute. */
556 unsigned int has_byte_size
: 1;
558 /* Flag set if any of the DIE's children are template arguments. */
559 unsigned int has_template_arguments
: 1;
561 /* Flag set if fixup_partial_die has been called on this die. */
562 unsigned int fixup_called
: 1;
564 /* The name of this DIE. Normally the value of DW_AT_name, but
565 sometimes a default name for unnamed DIEs. */
568 /* The linkage name, if present. */
569 const char *linkage_name
;
571 /* The scope to prepend to our children. This is generally
572 allocated on the comp_unit_obstack, so will disappear
573 when this compilation unit leaves the cache. */
576 /* The location description associated with this DIE, if any. */
577 struct dwarf_block
*locdesc
;
579 /* If HAS_PC_INFO, the PC range associated with this DIE. */
583 /* Pointer into the info_buffer (or types_buffer) pointing at the target of
584 DW_AT_sibling, if any. */
585 /* NOTE: This member isn't strictly necessary, read_partial_die could
586 return DW_AT_sibling values to its caller load_partial_dies. */
589 /* If HAS_SPECIFICATION, the offset of the DIE referred to by
590 DW_AT_specification (or DW_AT_abstract_origin or
592 unsigned int spec_offset
;
594 /* Pointers to this DIE's parent, first child, and next sibling,
596 struct partial_die_info
*die_parent
, *die_child
, *die_sibling
;
599 /* This data structure holds the information of an abbrev. */
602 unsigned int number
; /* number identifying abbrev */
603 enum dwarf_tag tag
; /* dwarf tag */
604 unsigned short has_children
; /* boolean */
605 unsigned short num_attrs
; /* number of attributes */
606 struct attr_abbrev
*attrs
; /* an array of attribute descriptions */
607 struct abbrev_info
*next
; /* next in chain */
612 ENUM_BITFIELD(dwarf_attribute
) name
: 16;
613 ENUM_BITFIELD(dwarf_form
) form
: 16;
616 /* Attributes have a name and a value. */
619 ENUM_BITFIELD(dwarf_attribute
) name
: 16;
620 ENUM_BITFIELD(dwarf_form
) form
: 15;
622 /* Has DW_STRING already been updated by dwarf2_canonicalize_name? This
623 field should be in u.str (existing only for DW_STRING) but it is kept
624 here for better struct attribute alignment. */
625 unsigned int string_is_canonical
: 1;
630 struct dwarf_block
*blk
;
634 struct signatured_type
*signatured_type
;
639 /* This data structure holds a complete die structure. */
642 /* DWARF-2 tag for this DIE. */
643 ENUM_BITFIELD(dwarf_tag
) tag
: 16;
645 /* Number of attributes */
646 unsigned char num_attrs
;
648 /* True if we're presently building the full type name for the
649 type derived from this DIE. */
650 unsigned char building_fullname
: 1;
655 /* Offset in .debug_info or .debug_types section. */
658 /* The dies in a compilation unit form an n-ary tree. PARENT
659 points to this die's parent; CHILD points to the first child of
660 this node; and all the children of a given node are chained
661 together via their SIBLING fields. */
662 struct die_info
*child
; /* Its first child, if any. */
663 struct die_info
*sibling
; /* Its next sibling, if any. */
664 struct die_info
*parent
; /* Its parent, if any. */
666 /* An array of attributes, with NUM_ATTRS elements. There may be
667 zero, but it's not common and zero-sized arrays are not
668 sufficiently portable C. */
669 struct attribute attrs
[1];
672 struct function_range
675 CORE_ADDR lowpc
, highpc
;
677 struct function_range
*next
;
680 /* Get at parts of an attribute structure. */
682 #define DW_STRING(attr) ((attr)->u.str)
683 #define DW_STRING_IS_CANONICAL(attr) ((attr)->string_is_canonical)
684 #define DW_UNSND(attr) ((attr)->u.unsnd)
685 #define DW_BLOCK(attr) ((attr)->u.blk)
686 #define DW_SND(attr) ((attr)->u.snd)
687 #define DW_ADDR(attr) ((attr)->u.addr)
688 #define DW_SIGNATURED_TYPE(attr) ((attr)->u.signatured_type)
690 /* Blocks are a bunch of untyped bytes. */
697 #ifndef ATTR_ALLOC_CHUNK
698 #define ATTR_ALLOC_CHUNK 4
701 /* Allocate fields for structs, unions and enums in this size. */
702 #ifndef DW_FIELD_ALLOC_CHUNK
703 #define DW_FIELD_ALLOC_CHUNK 4
706 /* FIXME: We might want to set this from BFD via bfd_arch_bits_per_byte,
707 but this would require a corresponding change in unpack_field_as_long
709 static int bits_per_byte
= 8;
711 /* The routines that read and process dies for a C struct or C++ class
712 pass lists of data member fields and lists of member function fields
713 in an instance of a field_info structure, as defined below. */
716 /* List of data member and baseclasses fields. */
719 struct nextfield
*next
;
724 *fields
, *baseclasses
;
726 /* Number of fields (including baseclasses). */
729 /* Number of baseclasses. */
732 /* Set if the accesibility of one of the fields is not public. */
733 int non_public_fields
;
735 /* Member function fields array, entries are allocated in the order they
736 are encountered in the object file. */
739 struct nextfnfield
*next
;
740 struct fn_field fnfield
;
744 /* Member function fieldlist array, contains name of possibly overloaded
745 member function, number of overloaded member functions and a pointer
746 to the head of the member function field chain. */
751 struct nextfnfield
*head
;
755 /* Number of entries in the fnfieldlists array. */
758 /* typedefs defined inside this class. TYPEDEF_FIELD_LIST contains head of
759 a NULL terminated list of TYPEDEF_FIELD_LIST_COUNT elements. */
760 struct typedef_field_list
762 struct typedef_field field
;
763 struct typedef_field_list
*next
;
766 unsigned typedef_field_list_count
;
769 /* One item on the queue of compilation units to read in full symbols
771 struct dwarf2_queue_item
773 struct dwarf2_per_cu_data
*per_cu
;
774 struct dwarf2_queue_item
*next
;
777 /* The current queue. */
778 static struct dwarf2_queue_item
*dwarf2_queue
, *dwarf2_queue_tail
;
780 /* Loaded secondary compilation units are kept in memory until they
781 have not been referenced for the processing of this many
782 compilation units. Set this to zero to disable caching. Cache
783 sizes of up to at least twenty will improve startup time for
784 typical inter-CU-reference binaries, at an obvious memory cost. */
785 static int dwarf2_max_cache_age
= 5;
787 show_dwarf2_max_cache_age (struct ui_file
*file
, int from_tty
,
788 struct cmd_list_element
*c
, const char *value
)
790 fprintf_filtered (file
, _("The upper bound on the age of cached "
791 "dwarf2 compilation units is %s.\n"),
796 /* Various complaints about symbol reading that don't abort the process. */
799 dwarf2_statement_list_fits_in_line_number_section_complaint (void)
801 complaint (&symfile_complaints
,
802 _("statement list doesn't fit in .debug_line section"));
806 dwarf2_debug_line_missing_file_complaint (void)
808 complaint (&symfile_complaints
,
809 _(".debug_line section has line data without a file"));
813 dwarf2_debug_line_missing_end_sequence_complaint (void)
815 complaint (&symfile_complaints
,
816 _(".debug_line section has line "
817 "program sequence without an end"));
821 dwarf2_complex_location_expr_complaint (void)
823 complaint (&symfile_complaints
, _("location expression too complex"));
827 dwarf2_const_value_length_mismatch_complaint (const char *arg1
, int arg2
,
830 complaint (&symfile_complaints
,
831 _("const value length mismatch for '%s', got %d, expected %d"),
836 dwarf2_macros_too_long_complaint (void)
838 complaint (&symfile_complaints
,
839 _("macro info runs off end of `.debug_macinfo' section"));
843 dwarf2_macro_malformed_definition_complaint (const char *arg1
)
845 complaint (&symfile_complaints
,
846 _("macro debug info contains a "
847 "malformed macro definition:\n`%s'"),
852 dwarf2_invalid_attrib_class_complaint (const char *arg1
, const char *arg2
)
854 complaint (&symfile_complaints
,
855 _("invalid attribute class or form for '%s' in '%s'"),
859 /* local function prototypes */
861 static void dwarf2_locate_sections (bfd
*, asection
*, void *);
863 static void dwarf2_create_include_psymtab (char *, struct partial_symtab
*,
866 static void dwarf2_build_psymtabs_hard (struct objfile
*);
868 static void scan_partial_symbols (struct partial_die_info
*,
869 CORE_ADDR
*, CORE_ADDR
*,
870 int, struct dwarf2_cu
*);
872 static void add_partial_symbol (struct partial_die_info
*,
875 static void add_partial_namespace (struct partial_die_info
*pdi
,
876 CORE_ADDR
*lowpc
, CORE_ADDR
*highpc
,
877 int need_pc
, struct dwarf2_cu
*cu
);
879 static void add_partial_module (struct partial_die_info
*pdi
, CORE_ADDR
*lowpc
,
880 CORE_ADDR
*highpc
, int need_pc
,
881 struct dwarf2_cu
*cu
);
883 static void add_partial_enumeration (struct partial_die_info
*enum_pdi
,
884 struct dwarf2_cu
*cu
);
886 static void add_partial_subprogram (struct partial_die_info
*pdi
,
887 CORE_ADDR
*lowpc
, CORE_ADDR
*highpc
,
888 int need_pc
, struct dwarf2_cu
*cu
);
890 static gdb_byte
*locate_pdi_sibling (struct partial_die_info
*orig_pdi
,
891 gdb_byte
*buffer
, gdb_byte
*info_ptr
,
892 bfd
*abfd
, struct dwarf2_cu
*cu
);
894 static void dwarf2_psymtab_to_symtab (struct partial_symtab
*);
896 static void psymtab_to_symtab_1 (struct partial_symtab
*);
898 static void dwarf2_read_abbrevs (bfd
*abfd
, struct dwarf2_cu
*cu
);
900 static void dwarf2_free_abbrev_table (void *);
902 static struct abbrev_info
*peek_die_abbrev (gdb_byte
*, unsigned int *,
905 static struct abbrev_info
*dwarf2_lookup_abbrev (unsigned int,
908 static struct partial_die_info
*load_partial_dies (bfd
*,
909 gdb_byte
*, gdb_byte
*,
910 int, struct dwarf2_cu
*);
912 static gdb_byte
*read_partial_die (struct partial_die_info
*,
913 struct abbrev_info
*abbrev
,
915 gdb_byte
*, gdb_byte
*,
918 static struct partial_die_info
*find_partial_die (unsigned int,
921 static void fixup_partial_die (struct partial_die_info
*,
924 static gdb_byte
*read_attribute (struct attribute
*, struct attr_abbrev
*,
925 bfd
*, gdb_byte
*, struct dwarf2_cu
*);
927 static gdb_byte
*read_attribute_value (struct attribute
*, unsigned,
928 bfd
*, gdb_byte
*, struct dwarf2_cu
*);
930 static unsigned int read_1_byte (bfd
*, gdb_byte
*);
932 static int read_1_signed_byte (bfd
*, gdb_byte
*);
934 static unsigned int read_2_bytes (bfd
*, gdb_byte
*);
936 static unsigned int read_4_bytes (bfd
*, gdb_byte
*);
938 static ULONGEST
read_8_bytes (bfd
*, gdb_byte
*);
940 static CORE_ADDR
read_address (bfd
*, gdb_byte
*ptr
, struct dwarf2_cu
*,
943 static LONGEST
read_initial_length (bfd
*, gdb_byte
*, unsigned int *);
945 static LONGEST read_checked_initial_length_and_offset
946 (bfd
*, gdb_byte
*, const struct comp_unit_head
*,
947 unsigned int *, unsigned int *);
949 static LONGEST
read_offset (bfd
*, gdb_byte
*, const struct comp_unit_head
*,
952 static LONGEST
read_offset_1 (bfd
*, gdb_byte
*, unsigned int);
954 static gdb_byte
*read_n_bytes (bfd
*, gdb_byte
*, unsigned int);
956 static char *read_direct_string (bfd
*, gdb_byte
*, unsigned int *);
958 static char *read_indirect_string (bfd
*, gdb_byte
*,
959 const struct comp_unit_head
*,
962 static unsigned long read_unsigned_leb128 (bfd
*, gdb_byte
*, unsigned int *);
964 static long read_signed_leb128 (bfd
*, gdb_byte
*, unsigned int *);
966 static gdb_byte
*skip_leb128 (bfd
*, gdb_byte
*);
968 static void set_cu_language (unsigned int, struct dwarf2_cu
*);
970 static struct attribute
*dwarf2_attr (struct die_info
*, unsigned int,
973 static struct attribute
*dwarf2_attr_no_follow (struct die_info
*,
977 static int dwarf2_flag_true_p (struct die_info
*die
, unsigned name
,
978 struct dwarf2_cu
*cu
);
980 static int die_is_declaration (struct die_info
*, struct dwarf2_cu
*cu
);
982 static struct die_info
*die_specification (struct die_info
*die
,
983 struct dwarf2_cu
**);
985 static void free_line_header (struct line_header
*lh
);
987 static void add_file_name (struct line_header
*, char *, unsigned int,
988 unsigned int, unsigned int);
990 static struct line_header
*(dwarf_decode_line_header
991 (unsigned int offset
,
992 bfd
*abfd
, struct dwarf2_cu
*cu
));
994 static void dwarf_decode_lines (struct line_header
*, const char *, bfd
*,
995 struct dwarf2_cu
*, struct partial_symtab
*);
997 static void dwarf2_start_subfile (char *, const char *, const char *);
999 static struct symbol
*new_symbol (struct die_info
*, struct type
*,
1000 struct dwarf2_cu
*);
1002 static struct symbol
*new_symbol_full (struct die_info
*, struct type
*,
1003 struct dwarf2_cu
*, struct symbol
*);
1005 static void dwarf2_const_value (struct attribute
*, struct symbol
*,
1006 struct dwarf2_cu
*);
1008 static void dwarf2_const_value_attr (struct attribute
*attr
,
1011 struct obstack
*obstack
,
1012 struct dwarf2_cu
*cu
, long *value
,
1014 struct dwarf2_locexpr_baton
**baton
);
1016 static struct type
*die_type (struct die_info
*, struct dwarf2_cu
*);
1018 static int need_gnat_info (struct dwarf2_cu
*);
1020 static struct type
*die_descriptive_type (struct die_info
*,
1021 struct dwarf2_cu
*);
1023 static void set_descriptive_type (struct type
*, struct die_info
*,
1024 struct dwarf2_cu
*);
1026 static struct type
*die_containing_type (struct die_info
*,
1027 struct dwarf2_cu
*);
1029 static struct type
*lookup_die_type (struct die_info
*, struct attribute
*,
1030 struct dwarf2_cu
*);
1032 static struct type
*read_type_die (struct die_info
*, struct dwarf2_cu
*);
1034 static struct type
*read_type_die_1 (struct die_info
*, struct dwarf2_cu
*);
1036 static char *determine_prefix (struct die_info
*die
, struct dwarf2_cu
*);
1038 static char *typename_concat (struct obstack
*obs
, const char *prefix
,
1039 const char *suffix
, int physname
,
1040 struct dwarf2_cu
*cu
);
1042 static void read_file_scope (struct die_info
*, struct dwarf2_cu
*);
1044 static void read_type_unit_scope (struct die_info
*, struct dwarf2_cu
*);
1046 static void read_func_scope (struct die_info
*, struct dwarf2_cu
*);
1048 static void read_lexical_block_scope (struct die_info
*, struct dwarf2_cu
*);
1050 static int dwarf2_ranges_read (unsigned, CORE_ADDR
*, CORE_ADDR
*,
1051 struct dwarf2_cu
*, struct partial_symtab
*);
1053 static int dwarf2_get_pc_bounds (struct die_info
*,
1054 CORE_ADDR
*, CORE_ADDR
*, struct dwarf2_cu
*,
1055 struct partial_symtab
*);
1057 static void get_scope_pc_bounds (struct die_info
*,
1058 CORE_ADDR
*, CORE_ADDR
*,
1059 struct dwarf2_cu
*);
1061 static void dwarf2_record_block_ranges (struct die_info
*, struct block
*,
1062 CORE_ADDR
, struct dwarf2_cu
*);
1064 static void dwarf2_add_field (struct field_info
*, struct die_info
*,
1065 struct dwarf2_cu
*);
1067 static void dwarf2_attach_fields_to_type (struct field_info
*,
1068 struct type
*, struct dwarf2_cu
*);
1070 static void dwarf2_add_member_fn (struct field_info
*,
1071 struct die_info
*, struct type
*,
1072 struct dwarf2_cu
*);
1074 static void dwarf2_attach_fn_fields_to_type (struct field_info
*,
1076 struct dwarf2_cu
*);
1078 static void process_structure_scope (struct die_info
*, struct dwarf2_cu
*);
1080 static void read_common_block (struct die_info
*, struct dwarf2_cu
*);
1082 static void read_namespace (struct die_info
*die
, struct dwarf2_cu
*);
1084 static void read_module (struct die_info
*die
, struct dwarf2_cu
*cu
);
1086 static void read_import_statement (struct die_info
*die
, struct dwarf2_cu
*);
1088 static struct type
*read_module_type (struct die_info
*die
,
1089 struct dwarf2_cu
*cu
);
1091 static const char *namespace_name (struct die_info
*die
,
1092 int *is_anonymous
, struct dwarf2_cu
*);
1094 static void process_enumeration_scope (struct die_info
*, struct dwarf2_cu
*);
1096 static CORE_ADDR
decode_locdesc (struct dwarf_block
*, struct dwarf2_cu
*);
1098 static enum dwarf_array_dim_ordering
read_array_order (struct die_info
*,
1099 struct dwarf2_cu
*);
1101 static struct die_info
*read_comp_unit (gdb_byte
*, struct dwarf2_cu
*);
1103 static struct die_info
*read_die_and_children_1 (const struct die_reader_specs
*reader
,
1105 gdb_byte
**new_info_ptr
,
1106 struct die_info
*parent
);
1108 static struct die_info
*read_die_and_children (const struct die_reader_specs
*reader
,
1110 gdb_byte
**new_info_ptr
,
1111 struct die_info
*parent
);
1113 static struct die_info
*read_die_and_siblings (const struct die_reader_specs
*reader
,
1115 gdb_byte
**new_info_ptr
,
1116 struct die_info
*parent
);
1118 static gdb_byte
*read_full_die (const struct die_reader_specs
*reader
,
1119 struct die_info
**, gdb_byte
*,
1122 static void process_die (struct die_info
*, struct dwarf2_cu
*);
1124 static char *dwarf2_canonicalize_name (char *, struct dwarf2_cu
*,
1127 static char *dwarf2_name (struct die_info
*die
, struct dwarf2_cu
*);
1129 static const char *dwarf2_full_name (char *name
,
1130 struct die_info
*die
,
1131 struct dwarf2_cu
*cu
);
1133 static struct die_info
*dwarf2_extension (struct die_info
*die
,
1134 struct dwarf2_cu
**);
1136 static char *dwarf_tag_name (unsigned int);
1138 static char *dwarf_attr_name (unsigned int);
1140 static char *dwarf_form_name (unsigned int);
1142 static char *dwarf_bool_name (unsigned int);
1144 static char *dwarf_type_encoding_name (unsigned int);
1147 static char *dwarf_cfi_name (unsigned int);
1150 static struct die_info
*sibling_die (struct die_info
*);
1152 static void dump_die_shallow (struct ui_file
*, int indent
, struct die_info
*);
1154 static void dump_die_for_error (struct die_info
*);
1156 static void dump_die_1 (struct ui_file
*, int level
, int max_level
,
1159 /*static*/ void dump_die (struct die_info
*, int max_level
);
1161 static void store_in_ref_table (struct die_info
*,
1162 struct dwarf2_cu
*);
1164 static int is_ref_attr (struct attribute
*);
1166 static unsigned int dwarf2_get_ref_die_offset (struct attribute
*);
1168 static LONGEST
dwarf2_get_attr_constant_value (struct attribute
*, int);
1170 static struct die_info
*follow_die_ref_or_sig (struct die_info
*,
1172 struct dwarf2_cu
**);
1174 static struct die_info
*follow_die_ref (struct die_info
*,
1176 struct dwarf2_cu
**);
1178 static struct die_info
*follow_die_sig (struct die_info
*,
1180 struct dwarf2_cu
**);
1182 static void read_signatured_type_at_offset (struct objfile
*objfile
,
1183 unsigned int offset
);
1185 static void read_signatured_type (struct objfile
*,
1186 struct signatured_type
*type_sig
);
1188 /* memory allocation interface */
1190 static struct dwarf_block
*dwarf_alloc_block (struct dwarf2_cu
*);
1192 static struct abbrev_info
*dwarf_alloc_abbrev (struct dwarf2_cu
*);
1194 static struct die_info
*dwarf_alloc_die (struct dwarf2_cu
*, int);
1196 static void initialize_cu_func_list (struct dwarf2_cu
*);
1198 static void add_to_cu_func_list (const char *, CORE_ADDR
, CORE_ADDR
,
1199 struct dwarf2_cu
*);
1201 static void dwarf_decode_macros (struct line_header
*, unsigned int,
1202 char *, bfd
*, struct dwarf2_cu
*);
1204 static int attr_form_is_block (struct attribute
*);
1206 static int attr_form_is_section_offset (struct attribute
*);
1208 static int attr_form_is_constant (struct attribute
*);
1210 static void fill_in_loclist_baton (struct dwarf2_cu
*cu
,
1211 struct dwarf2_loclist_baton
*baton
,
1212 struct attribute
*attr
);
1214 static void dwarf2_symbol_mark_computed (struct attribute
*attr
,
1216 struct dwarf2_cu
*cu
);
1218 static gdb_byte
*skip_one_die (gdb_byte
*buffer
, gdb_byte
*info_ptr
,
1219 struct abbrev_info
*abbrev
,
1220 struct dwarf2_cu
*cu
);
1222 static void free_stack_comp_unit (void *);
1224 static hashval_t
partial_die_hash (const void *item
);
1226 static int partial_die_eq (const void *item_lhs
, const void *item_rhs
);
1228 static struct dwarf2_per_cu_data
*dwarf2_find_containing_comp_unit
1229 (unsigned int offset
, struct objfile
*objfile
);
1231 static struct dwarf2_per_cu_data
*dwarf2_find_comp_unit
1232 (unsigned int offset
, struct objfile
*objfile
);
1234 static void init_one_comp_unit (struct dwarf2_cu
*cu
,
1235 struct objfile
*objfile
);
1237 static void prepare_one_comp_unit (struct dwarf2_cu
*cu
,
1238 struct die_info
*comp_unit_die
);
1240 static void free_one_comp_unit (void *);
1242 static void free_cached_comp_units (void *);
1244 static void age_cached_comp_units (void);
1246 static void free_one_cached_comp_unit (void *);
1248 static struct type
*set_die_type (struct die_info
*, struct type
*,
1249 struct dwarf2_cu
*);
1251 static void create_all_comp_units (struct objfile
*);
1253 static int create_debug_types_hash_table (struct objfile
*objfile
);
1255 static void load_full_comp_unit (struct dwarf2_per_cu_data
*,
1258 static void process_full_comp_unit (struct dwarf2_per_cu_data
*);
1260 static void dwarf2_add_dependence (struct dwarf2_cu
*,
1261 struct dwarf2_per_cu_data
*);
1263 static void dwarf2_mark (struct dwarf2_cu
*);
1265 static void dwarf2_clear_marks (struct dwarf2_per_cu_data
*);
1267 static struct type
*get_die_type_at_offset (unsigned int,
1268 struct dwarf2_per_cu_data
*per_cu
);
1270 static struct type
*get_die_type (struct die_info
*die
, struct dwarf2_cu
*cu
);
1272 static void dwarf2_release_queue (void *dummy
);
1274 static void queue_comp_unit (struct dwarf2_per_cu_data
*per_cu
,
1275 struct objfile
*objfile
);
1277 static void process_queue (struct objfile
*objfile
);
1279 static void find_file_and_directory (struct die_info
*die
,
1280 struct dwarf2_cu
*cu
,
1281 char **name
, char **comp_dir
);
1283 static char *file_full_name (int file
, struct line_header
*lh
,
1284 const char *comp_dir
);
1286 static gdb_byte
*partial_read_comp_unit_head (struct comp_unit_head
*header
,
1289 unsigned int buffer_size
,
1292 static void init_cu_die_reader (struct die_reader_specs
*reader
,
1293 struct dwarf2_cu
*cu
);
1295 static htab_t
allocate_signatured_type_table (struct objfile
*objfile
);
1299 /* Convert VALUE between big- and little-endian. */
1301 byte_swap (offset_type value
)
1305 result
= (value
& 0xff) << 24;
1306 result
|= (value
& 0xff00) << 8;
1307 result
|= (value
& 0xff0000) >> 8;
1308 result
|= (value
& 0xff000000) >> 24;
1312 #define MAYBE_SWAP(V) byte_swap (V)
1315 #define MAYBE_SWAP(V) (V)
1316 #endif /* WORDS_BIGENDIAN */
1318 /* The suffix for an index file. */
1319 #define INDEX_SUFFIX ".gdb-index"
1321 static const char *dwarf2_physname (char *name
, struct die_info
*die
,
1322 struct dwarf2_cu
*cu
);
1324 /* Try to locate the sections we need for DWARF 2 debugging
1325 information and return true if we have enough to do something. */
1328 dwarf2_has_info (struct objfile
*objfile
)
1330 dwarf2_per_objfile
= objfile_data (objfile
, dwarf2_objfile_data_key
);
1331 if (!dwarf2_per_objfile
)
1333 /* Initialize per-objfile state. */
1334 struct dwarf2_per_objfile
*data
1335 = obstack_alloc (&objfile
->objfile_obstack
, sizeof (*data
));
1337 memset (data
, 0, sizeof (*data
));
1338 set_objfile_data (objfile
, dwarf2_objfile_data_key
, data
);
1339 dwarf2_per_objfile
= data
;
1341 bfd_map_over_sections (objfile
->obfd
, dwarf2_locate_sections
, NULL
);
1342 dwarf2_per_objfile
->objfile
= objfile
;
1344 return (dwarf2_per_objfile
->info
.asection
!= NULL
1345 && dwarf2_per_objfile
->abbrev
.asection
!= NULL
);
1348 /* When loading sections, we can either look for ".<name>", or for
1349 * ".z<name>", which indicates a compressed section. */
1352 section_is_p (const char *section_name
, const char *name
)
1354 return (section_name
[0] == '.'
1355 && (strcmp (section_name
+ 1, name
) == 0
1356 || (section_name
[1] == 'z'
1357 && strcmp (section_name
+ 2, name
) == 0)));
1360 /* This function is mapped across the sections and remembers the
1361 offset and size of each of the debugging sections we are interested
1365 dwarf2_locate_sections (bfd
*abfd
, asection
*sectp
, void *ignore_ptr
)
1367 if (section_is_p (sectp
->name
, INFO_SECTION
))
1369 dwarf2_per_objfile
->info
.asection
= sectp
;
1370 dwarf2_per_objfile
->info
.size
= bfd_get_section_size (sectp
);
1372 else if (section_is_p (sectp
->name
, ABBREV_SECTION
))
1374 dwarf2_per_objfile
->abbrev
.asection
= sectp
;
1375 dwarf2_per_objfile
->abbrev
.size
= bfd_get_section_size (sectp
);
1377 else if (section_is_p (sectp
->name
, LINE_SECTION
))
1379 dwarf2_per_objfile
->line
.asection
= sectp
;
1380 dwarf2_per_objfile
->line
.size
= bfd_get_section_size (sectp
);
1382 else if (section_is_p (sectp
->name
, LOC_SECTION
))
1384 dwarf2_per_objfile
->loc
.asection
= sectp
;
1385 dwarf2_per_objfile
->loc
.size
= bfd_get_section_size (sectp
);
1387 else if (section_is_p (sectp
->name
, MACINFO_SECTION
))
1389 dwarf2_per_objfile
->macinfo
.asection
= sectp
;
1390 dwarf2_per_objfile
->macinfo
.size
= bfd_get_section_size (sectp
);
1392 else if (section_is_p (sectp
->name
, STR_SECTION
))
1394 dwarf2_per_objfile
->str
.asection
= sectp
;
1395 dwarf2_per_objfile
->str
.size
= bfd_get_section_size (sectp
);
1397 else if (section_is_p (sectp
->name
, FRAME_SECTION
))
1399 dwarf2_per_objfile
->frame
.asection
= sectp
;
1400 dwarf2_per_objfile
->frame
.size
= bfd_get_section_size (sectp
);
1402 else if (section_is_p (sectp
->name
, EH_FRAME_SECTION
))
1404 flagword aflag
= bfd_get_section_flags (ignore_abfd
, sectp
);
1406 if (aflag
& SEC_HAS_CONTENTS
)
1408 dwarf2_per_objfile
->eh_frame
.asection
= sectp
;
1409 dwarf2_per_objfile
->eh_frame
.size
= bfd_get_section_size (sectp
);
1412 else if (section_is_p (sectp
->name
, RANGES_SECTION
))
1414 dwarf2_per_objfile
->ranges
.asection
= sectp
;
1415 dwarf2_per_objfile
->ranges
.size
= bfd_get_section_size (sectp
);
1417 else if (section_is_p (sectp
->name
, TYPES_SECTION
))
1419 dwarf2_per_objfile
->types
.asection
= sectp
;
1420 dwarf2_per_objfile
->types
.size
= bfd_get_section_size (sectp
);
1422 else if (section_is_p (sectp
->name
, GDB_INDEX_SECTION
))
1424 dwarf2_per_objfile
->gdb_index
.asection
= sectp
;
1425 dwarf2_per_objfile
->gdb_index
.size
= bfd_get_section_size (sectp
);
1428 if ((bfd_get_section_flags (abfd
, sectp
) & SEC_LOAD
)
1429 && bfd_section_vma (abfd
, sectp
) == 0)
1430 dwarf2_per_objfile
->has_section_at_zero
= 1;
1433 /* Decompress a section that was compressed using zlib. Store the
1434 decompressed buffer, and its size, in OUTBUF and OUTSIZE. */
1437 zlib_decompress_section (struct objfile
*objfile
, asection
*sectp
,
1438 gdb_byte
**outbuf
, bfd_size_type
*outsize
)
1440 bfd
*abfd
= objfile
->obfd
;
1442 error (_("Support for zlib-compressed DWARF data (from '%s') "
1443 "is disabled in this copy of GDB"),
1444 bfd_get_filename (abfd
));
1446 bfd_size_type compressed_size
= bfd_get_section_size (sectp
);
1447 gdb_byte
*compressed_buffer
= xmalloc (compressed_size
);
1448 struct cleanup
*cleanup
= make_cleanup (xfree
, compressed_buffer
);
1449 bfd_size_type uncompressed_size
;
1450 gdb_byte
*uncompressed_buffer
;
1453 int header_size
= 12;
1455 if (bfd_seek (abfd
, sectp
->filepos
, SEEK_SET
) != 0
1456 || bfd_bread (compressed_buffer
,
1457 compressed_size
, abfd
) != compressed_size
)
1458 error (_("Dwarf Error: Can't read DWARF data from '%s'"),
1459 bfd_get_filename (abfd
));
1461 /* Read the zlib header. In this case, it should be "ZLIB" followed
1462 by the uncompressed section size, 8 bytes in big-endian order. */
1463 if (compressed_size
< header_size
1464 || strncmp (compressed_buffer
, "ZLIB", 4) != 0)
1465 error (_("Dwarf Error: Corrupt DWARF ZLIB header from '%s'"),
1466 bfd_get_filename (abfd
));
1467 uncompressed_size
= compressed_buffer
[4]; uncompressed_size
<<= 8;
1468 uncompressed_size
+= compressed_buffer
[5]; uncompressed_size
<<= 8;
1469 uncompressed_size
+= compressed_buffer
[6]; uncompressed_size
<<= 8;
1470 uncompressed_size
+= compressed_buffer
[7]; uncompressed_size
<<= 8;
1471 uncompressed_size
+= compressed_buffer
[8]; uncompressed_size
<<= 8;
1472 uncompressed_size
+= compressed_buffer
[9]; uncompressed_size
<<= 8;
1473 uncompressed_size
+= compressed_buffer
[10]; uncompressed_size
<<= 8;
1474 uncompressed_size
+= compressed_buffer
[11];
1476 /* It is possible the section consists of several compressed
1477 buffers concatenated together, so we uncompress in a loop. */
1481 strm
.avail_in
= compressed_size
- header_size
;
1482 strm
.next_in
= (Bytef
*) compressed_buffer
+ header_size
;
1483 strm
.avail_out
= uncompressed_size
;
1484 uncompressed_buffer
= obstack_alloc (&objfile
->objfile_obstack
,
1486 rc
= inflateInit (&strm
);
1487 while (strm
.avail_in
> 0)
1490 error (_("Dwarf Error: setting up DWARF uncompression in '%s': %d"),
1491 bfd_get_filename (abfd
), rc
);
1492 strm
.next_out
= ((Bytef
*) uncompressed_buffer
1493 + (uncompressed_size
- strm
.avail_out
));
1494 rc
= inflate (&strm
, Z_FINISH
);
1495 if (rc
!= Z_STREAM_END
)
1496 error (_("Dwarf Error: zlib error uncompressing from '%s': %d"),
1497 bfd_get_filename (abfd
), rc
);
1498 rc
= inflateReset (&strm
);
1500 rc
= inflateEnd (&strm
);
1502 || strm
.avail_out
!= 0)
1503 error (_("Dwarf Error: concluding DWARF uncompression in '%s': %d"),
1504 bfd_get_filename (abfd
), rc
);
1506 do_cleanups (cleanup
);
1507 *outbuf
= uncompressed_buffer
;
1508 *outsize
= uncompressed_size
;
1512 /* A helper function that decides whether a section is empty. */
1515 dwarf2_section_empty_p (struct dwarf2_section_info
*info
)
1517 return info
->asection
== NULL
|| info
->size
== 0;
1520 /* Read the contents of the section SECTP from object file specified by
1521 OBJFILE, store info about the section into INFO.
1522 If the section is compressed, uncompress it before returning. */
1525 dwarf2_read_section (struct objfile
*objfile
, struct dwarf2_section_info
*info
)
1527 bfd
*abfd
= objfile
->obfd
;
1528 asection
*sectp
= info
->asection
;
1529 gdb_byte
*buf
, *retbuf
;
1530 unsigned char header
[4];
1534 info
->buffer
= NULL
;
1535 info
->was_mmapped
= 0;
1538 if (dwarf2_section_empty_p (info
))
1541 /* Check if the file has a 4-byte header indicating compression. */
1542 if (info
->size
> sizeof (header
)
1543 && bfd_seek (abfd
, sectp
->filepos
, SEEK_SET
) == 0
1544 && bfd_bread (header
, sizeof (header
), abfd
) == sizeof (header
))
1546 /* Upon decompression, update the buffer and its size. */
1547 if (strncmp (header
, "ZLIB", sizeof (header
)) == 0)
1549 zlib_decompress_section (objfile
, sectp
, &info
->buffer
,
1557 pagesize
= getpagesize ();
1559 /* Only try to mmap sections which are large enough: we don't want to
1560 waste space due to fragmentation. Also, only try mmap for sections
1561 without relocations. */
1563 if (info
->size
> 4 * pagesize
&& (sectp
->flags
& SEC_RELOC
) == 0)
1565 off_t pg_offset
= sectp
->filepos
& ~(pagesize
- 1);
1566 size_t map_length
= info
->size
+ sectp
->filepos
- pg_offset
;
1567 caddr_t retbuf
= bfd_mmap (abfd
, 0, map_length
, PROT_READ
,
1568 MAP_PRIVATE
, pg_offset
);
1570 if (retbuf
!= MAP_FAILED
)
1572 info
->was_mmapped
= 1;
1573 info
->buffer
= retbuf
+ (sectp
->filepos
& (pagesize
- 1)) ;
1574 #if HAVE_POSIX_MADVISE
1575 posix_madvise (retbuf
, map_length
, POSIX_MADV_WILLNEED
);
1582 /* If we get here, we are a normal, not-compressed section. */
1584 = obstack_alloc (&objfile
->objfile_obstack
, info
->size
);
1586 /* When debugging .o files, we may need to apply relocations; see
1587 http://sourceware.org/ml/gdb-patches/2002-04/msg00136.html .
1588 We never compress sections in .o files, so we only need to
1589 try this when the section is not compressed. */
1590 retbuf
= symfile_relocate_debug_section (objfile
, sectp
, buf
);
1593 info
->buffer
= retbuf
;
1597 if (bfd_seek (abfd
, sectp
->filepos
, SEEK_SET
) != 0
1598 || bfd_bread (buf
, info
->size
, abfd
) != info
->size
)
1599 error (_("Dwarf Error: Can't read DWARF data from '%s'"),
1600 bfd_get_filename (abfd
));
1603 /* A helper function that returns the size of a section in a safe way.
1604 If you are positive that the section has been read before using the
1605 size, then it is safe to refer to the dwarf2_section_info object's
1606 "size" field directly. In other cases, you must call this
1607 function, because for compressed sections the size field is not set
1608 correctly until the section has been read. */
1610 static bfd_size_type
1611 dwarf2_section_size (struct objfile
*objfile
,
1612 struct dwarf2_section_info
*info
)
1615 dwarf2_read_section (objfile
, info
);
1619 /* Fill in SECTP, BUFP and SIZEP with section info, given OBJFILE and
1623 dwarf2_get_section_info (struct objfile
*objfile
, const char *section_name
,
1624 asection
**sectp
, gdb_byte
**bufp
,
1625 bfd_size_type
*sizep
)
1627 struct dwarf2_per_objfile
*data
1628 = objfile_data (objfile
, dwarf2_objfile_data_key
);
1629 struct dwarf2_section_info
*info
;
1631 /* We may see an objfile without any DWARF, in which case we just
1640 if (section_is_p (section_name
, EH_FRAME_SECTION
))
1641 info
= &data
->eh_frame
;
1642 else if (section_is_p (section_name
, FRAME_SECTION
))
1643 info
= &data
->frame
;
1645 gdb_assert_not_reached ("unexpected section");
1647 dwarf2_read_section (objfile
, info
);
1649 *sectp
= info
->asection
;
1650 *bufp
= info
->buffer
;
1651 *sizep
= info
->size
;
1655 /* DWARF quick_symbols_functions support. */
1657 /* TUs can share .debug_line entries, and there can be a lot more TUs than
1658 unique line tables, so we maintain a separate table of all .debug_line
1659 derived entries to support the sharing.
1660 All the quick functions need is the list of file names. We discard the
1661 line_header when we're done and don't need to record it here. */
1662 struct quick_file_names
1664 /* The offset in .debug_line of the line table. We hash on this. */
1665 unsigned int offset
;
1667 /* The number of entries in file_names, real_names. */
1668 unsigned int num_file_names
;
1670 /* The file names from the line table, after being run through
1672 const char **file_names
;
1674 /* The file names from the line table after being run through
1675 gdb_realpath. These are computed lazily. */
1676 const char **real_names
;
1679 /* When using the index (and thus not using psymtabs), each CU has an
1680 object of this type. This is used to hold information needed by
1681 the various "quick" methods. */
1682 struct dwarf2_per_cu_quick_data
1684 /* The file table. This can be NULL if there was no file table
1685 or it's currently not read in.
1686 NOTE: This points into dwarf2_per_objfile->quick_file_names_table. */
1687 struct quick_file_names
*file_names
;
1689 /* The corresponding symbol table. This is NULL if symbols for this
1690 CU have not yet been read. */
1691 struct symtab
*symtab
;
1693 /* A temporary mark bit used when iterating over all CUs in
1694 expand_symtabs_matching. */
1695 unsigned int mark
: 1;
1697 /* True if we've tried to read the file table and found there isn't one.
1698 There will be no point in trying to read it again next time. */
1699 unsigned int no_file_data
: 1;
1702 /* Hash function for a quick_file_names. */
1705 hash_file_name_entry (const void *e
)
1707 const struct quick_file_names
*file_data
= e
;
1709 return file_data
->offset
;
1712 /* Equality function for a quick_file_names. */
1715 eq_file_name_entry (const void *a
, const void *b
)
1717 const struct quick_file_names
*ea
= a
;
1718 const struct quick_file_names
*eb
= b
;
1720 return ea
->offset
== eb
->offset
;
1723 /* Delete function for a quick_file_names. */
1726 delete_file_name_entry (void *e
)
1728 struct quick_file_names
*file_data
= e
;
1731 for (i
= 0; i
< file_data
->num_file_names
; ++i
)
1733 xfree ((void*) file_data
->file_names
[i
]);
1734 if (file_data
->real_names
)
1735 xfree ((void*) file_data
->real_names
[i
]);
1738 /* The space for the struct itself lives on objfile_obstack,
1739 so we don't free it here. */
1742 /* Create a quick_file_names hash table. */
1745 create_quick_file_names_table (unsigned int nr_initial_entries
)
1747 return htab_create_alloc (nr_initial_entries
,
1748 hash_file_name_entry
, eq_file_name_entry
,
1749 delete_file_name_entry
, xcalloc
, xfree
);
1752 /* Read in the symbols for PER_CU. OBJFILE is the objfile from which
1756 dw2_do_instantiate_symtab (struct objfile
*objfile
,
1757 struct dwarf2_per_cu_data
*per_cu
)
1759 struct cleanup
*back_to
;
1761 back_to
= make_cleanup (dwarf2_release_queue
, NULL
);
1763 queue_comp_unit (per_cu
, objfile
);
1765 if (per_cu
->from_debug_types
)
1766 read_signatured_type_at_offset (objfile
, per_cu
->offset
);
1768 load_full_comp_unit (per_cu
, objfile
);
1770 process_queue (objfile
);
1772 /* Age the cache, releasing compilation units that have not
1773 been used recently. */
1774 age_cached_comp_units ();
1776 do_cleanups (back_to
);
1779 /* Ensure that the symbols for PER_CU have been read in. OBJFILE is
1780 the objfile from which this CU came. Returns the resulting symbol
1783 static struct symtab
*
1784 dw2_instantiate_symtab (struct objfile
*objfile
,
1785 struct dwarf2_per_cu_data
*per_cu
)
1787 if (!per_cu
->v
.quick
->symtab
)
1789 struct cleanup
*back_to
= make_cleanup (free_cached_comp_units
, NULL
);
1790 increment_reading_symtab ();
1791 dw2_do_instantiate_symtab (objfile
, per_cu
);
1792 do_cleanups (back_to
);
1794 return per_cu
->v
.quick
->symtab
;
1797 /* Return the CU given its index. */
1799 static struct dwarf2_per_cu_data
*
1800 dw2_get_cu (int index
)
1802 if (index
>= dwarf2_per_objfile
->n_comp_units
)
1804 index
-= dwarf2_per_objfile
->n_comp_units
;
1805 return dwarf2_per_objfile
->type_comp_units
[index
];
1807 return dwarf2_per_objfile
->all_comp_units
[index
];
1810 /* A helper function that knows how to read a 64-bit value in a way
1811 that doesn't make gdb die. Returns 1 if the conversion went ok, 0
1815 extract_cu_value (const char *bytes
, ULONGEST
*result
)
1817 if (sizeof (ULONGEST
) < 8)
1821 /* Ignore the upper 4 bytes if they are all zero. */
1822 for (i
= 0; i
< 4; ++i
)
1823 if (bytes
[i
+ 4] != 0)
1826 *result
= extract_unsigned_integer (bytes
, 4, BFD_ENDIAN_LITTLE
);
1829 *result
= extract_unsigned_integer (bytes
, 8, BFD_ENDIAN_LITTLE
);
1833 /* Read the CU list from the mapped index, and use it to create all
1834 the CU objects for this objfile. Return 0 if something went wrong,
1835 1 if everything went ok. */
1838 create_cus_from_index (struct objfile
*objfile
, const gdb_byte
*cu_list
,
1839 offset_type cu_list_elements
)
1843 dwarf2_per_objfile
->n_comp_units
= cu_list_elements
/ 2;
1844 dwarf2_per_objfile
->all_comp_units
1845 = obstack_alloc (&objfile
->objfile_obstack
,
1846 dwarf2_per_objfile
->n_comp_units
1847 * sizeof (struct dwarf2_per_cu_data
*));
1849 for (i
= 0; i
< cu_list_elements
; i
+= 2)
1851 struct dwarf2_per_cu_data
*the_cu
;
1852 ULONGEST offset
, length
;
1854 if (!extract_cu_value (cu_list
, &offset
)
1855 || !extract_cu_value (cu_list
+ 8, &length
))
1859 the_cu
= OBSTACK_ZALLOC (&objfile
->objfile_obstack
,
1860 struct dwarf2_per_cu_data
);
1861 the_cu
->offset
= offset
;
1862 the_cu
->length
= length
;
1863 the_cu
->objfile
= objfile
;
1864 the_cu
->v
.quick
= OBSTACK_ZALLOC (&objfile
->objfile_obstack
,
1865 struct dwarf2_per_cu_quick_data
);
1866 dwarf2_per_objfile
->all_comp_units
[i
/ 2] = the_cu
;
1872 /* Create the signatured type hash table from the index. */
1875 create_signatured_type_table_from_index (struct objfile
*objfile
,
1876 const gdb_byte
*bytes
,
1877 offset_type elements
)
1880 htab_t sig_types_hash
;
1882 dwarf2_per_objfile
->n_type_comp_units
= elements
/ 3;
1883 dwarf2_per_objfile
->type_comp_units
1884 = obstack_alloc (&objfile
->objfile_obstack
,
1885 dwarf2_per_objfile
->n_type_comp_units
1886 * sizeof (struct dwarf2_per_cu_data
*));
1888 sig_types_hash
= allocate_signatured_type_table (objfile
);
1890 for (i
= 0; i
< elements
; i
+= 3)
1892 struct signatured_type
*type_sig
;
1893 ULONGEST offset
, type_offset
, signature
;
1896 if (!extract_cu_value (bytes
, &offset
)
1897 || !extract_cu_value (bytes
+ 8, &type_offset
))
1899 signature
= extract_unsigned_integer (bytes
+ 16, 8, BFD_ENDIAN_LITTLE
);
1902 type_sig
= OBSTACK_ZALLOC (&objfile
->objfile_obstack
,
1903 struct signatured_type
);
1904 type_sig
->signature
= signature
;
1905 type_sig
->offset
= offset
;
1906 type_sig
->type_offset
= type_offset
;
1907 type_sig
->per_cu
.from_debug_types
= 1;
1908 type_sig
->per_cu
.offset
= offset
;
1909 type_sig
->per_cu
.objfile
= objfile
;
1910 type_sig
->per_cu
.v
.quick
1911 = OBSTACK_ZALLOC (&objfile
->objfile_obstack
,
1912 struct dwarf2_per_cu_quick_data
);
1914 slot
= htab_find_slot (sig_types_hash
, type_sig
, INSERT
);
1917 dwarf2_per_objfile
->type_comp_units
[i
/ 3] = &type_sig
->per_cu
;
1920 dwarf2_per_objfile
->signatured_types
= sig_types_hash
;
1925 /* Read the address map data from the mapped index, and use it to
1926 populate the objfile's psymtabs_addrmap. */
1929 create_addrmap_from_index (struct objfile
*objfile
, struct mapped_index
*index
)
1931 const gdb_byte
*iter
, *end
;
1932 struct obstack temp_obstack
;
1933 struct addrmap
*mutable_map
;
1934 struct cleanup
*cleanup
;
1937 obstack_init (&temp_obstack
);
1938 cleanup
= make_cleanup_obstack_free (&temp_obstack
);
1939 mutable_map
= addrmap_create_mutable (&temp_obstack
);
1941 iter
= index
->address_table
;
1942 end
= iter
+ index
->address_table_size
;
1944 baseaddr
= ANOFFSET (objfile
->section_offsets
, SECT_OFF_TEXT (objfile
));
1948 ULONGEST hi
, lo
, cu_index
;
1949 lo
= extract_unsigned_integer (iter
, 8, BFD_ENDIAN_LITTLE
);
1951 hi
= extract_unsigned_integer (iter
, 8, BFD_ENDIAN_LITTLE
);
1953 cu_index
= extract_unsigned_integer (iter
, 4, BFD_ENDIAN_LITTLE
);
1956 addrmap_set_empty (mutable_map
, lo
+ baseaddr
, hi
+ baseaddr
- 1,
1957 dw2_get_cu (cu_index
));
1960 objfile
->psymtabs_addrmap
= addrmap_create_fixed (mutable_map
,
1961 &objfile
->objfile_obstack
);
1962 do_cleanups (cleanup
);
1965 /* The hash function for strings in the mapped index. This is the same as
1966 SYMBOL_HASH_NEXT, but we keep a separate copy to maintain control over the
1967 implementation. This is necessary because the hash function is tied to the
1968 format of the mapped index file. The hash values do not have to match with
1969 SYMBOL_HASH_NEXT. */
1972 mapped_index_string_hash (const void *p
)
1974 const unsigned char *str
= (const unsigned char *) p
;
1978 while ((c
= *str
++) != 0)
1979 r
= r
* 67 + c
- 113;
1984 /* Find a slot in the mapped index INDEX for the object named NAME.
1985 If NAME is found, set *VEC_OUT to point to the CU vector in the
1986 constant pool and return 1. If NAME cannot be found, return 0. */
1989 find_slot_in_mapped_hash (struct mapped_index
*index
, const char *name
,
1990 offset_type
**vec_out
)
1992 struct cleanup
*back_to
= make_cleanup (null_cleanup
, 0);
1994 offset_type slot
, step
;
1996 if (current_language
->la_language
== language_cplus
1997 || current_language
->la_language
== language_java
1998 || current_language
->la_language
== language_fortran
)
2000 /* NAME is already canonical. Drop any qualifiers as .gdb_index does
2002 const char *paren
= strchr (name
, '(');
2008 dup
= xmalloc (paren
- name
+ 1);
2009 memcpy (dup
, name
, paren
- name
);
2010 dup
[paren
- name
] = 0;
2012 make_cleanup (xfree
, dup
);
2017 hash
= mapped_index_string_hash (name
);
2018 slot
= hash
& (index
->symbol_table_slots
- 1);
2019 step
= ((hash
* 17) & (index
->symbol_table_slots
- 1)) | 1;
2023 /* Convert a slot number to an offset into the table. */
2024 offset_type i
= 2 * slot
;
2026 if (index
->symbol_table
[i
] == 0 && index
->symbol_table
[i
+ 1] == 0)
2028 do_cleanups (back_to
);
2032 str
= index
->constant_pool
+ MAYBE_SWAP (index
->symbol_table
[i
]);
2033 if (!strcmp (name
, str
))
2035 *vec_out
= (offset_type
*) (index
->constant_pool
2036 + MAYBE_SWAP (index
->symbol_table
[i
+ 1]));
2037 do_cleanups (back_to
);
2041 slot
= (slot
+ step
) & (index
->symbol_table_slots
- 1);
2045 /* Read the index file. If everything went ok, initialize the "quick"
2046 elements of all the CUs and return 1. Otherwise, return 0. */
2049 dwarf2_read_index (struct objfile
*objfile
)
2052 struct mapped_index
*map
;
2053 offset_type
*metadata
;
2054 const gdb_byte
*cu_list
;
2055 const gdb_byte
*types_list
= NULL
;
2056 offset_type version
, cu_list_elements
;
2057 offset_type types_list_elements
= 0;
2060 if (dwarf2_section_empty_p (&dwarf2_per_objfile
->gdb_index
))
2063 /* Older elfutils strip versions could keep the section in the main
2064 executable while splitting it for the separate debug info file. */
2065 if ((bfd_get_file_flags (dwarf2_per_objfile
->gdb_index
.asection
)
2066 & SEC_HAS_CONTENTS
) == 0)
2069 dwarf2_read_section (objfile
, &dwarf2_per_objfile
->gdb_index
);
2071 addr
= dwarf2_per_objfile
->gdb_index
.buffer
;
2072 /* Version check. */
2073 version
= MAYBE_SWAP (*(offset_type
*) addr
);
2074 /* Versions earlier than 3 emitted every copy of a psymbol. This
2075 causes the index to behave very poorly for certain requests. Version 3
2076 contained incomplete addrmap. So, it seems better to just ignore such
2080 /* Indexes with higher version than the one supported by GDB may be no
2081 longer backward compatible. */
2085 map
= OBSTACK_ZALLOC (&objfile
->objfile_obstack
, struct mapped_index
);
2086 map
->total_size
= dwarf2_per_objfile
->gdb_index
.size
;
2088 metadata
= (offset_type
*) (addr
+ sizeof (offset_type
));
2091 cu_list
= addr
+ MAYBE_SWAP (metadata
[i
]);
2092 cu_list_elements
= ((MAYBE_SWAP (metadata
[i
+ 1]) - MAYBE_SWAP (metadata
[i
]))
2096 types_list
= addr
+ MAYBE_SWAP (metadata
[i
]);
2097 types_list_elements
= ((MAYBE_SWAP (metadata
[i
+ 1])
2098 - MAYBE_SWAP (metadata
[i
]))
2102 map
->address_table
= addr
+ MAYBE_SWAP (metadata
[i
]);
2103 map
->address_table_size
= (MAYBE_SWAP (metadata
[i
+ 1])
2104 - MAYBE_SWAP (metadata
[i
]));
2107 map
->symbol_table
= (offset_type
*) (addr
+ MAYBE_SWAP (metadata
[i
]));
2108 map
->symbol_table_slots
= ((MAYBE_SWAP (metadata
[i
+ 1])
2109 - MAYBE_SWAP (metadata
[i
]))
2110 / (2 * sizeof (offset_type
)));
2113 map
->constant_pool
= addr
+ MAYBE_SWAP (metadata
[i
]);
2115 if (!create_cus_from_index (objfile
, cu_list
, cu_list_elements
))
2118 if (types_list_elements
2119 && !create_signatured_type_table_from_index (objfile
, types_list
,
2120 types_list_elements
))
2123 create_addrmap_from_index (objfile
, map
);
2125 dwarf2_per_objfile
->index_table
= map
;
2126 dwarf2_per_objfile
->using_index
= 1;
2127 dwarf2_per_objfile
->quick_file_names_table
=
2128 create_quick_file_names_table (dwarf2_per_objfile
->n_comp_units
);
2133 /* A helper for the "quick" functions which sets the global
2134 dwarf2_per_objfile according to OBJFILE. */
2137 dw2_setup (struct objfile
*objfile
)
2139 dwarf2_per_objfile
= objfile_data (objfile
, dwarf2_objfile_data_key
);
2140 gdb_assert (dwarf2_per_objfile
);
2143 /* A helper for the "quick" functions which attempts to read the line
2144 table for THIS_CU. */
2146 static struct quick_file_names
*
2147 dw2_get_file_names (struct objfile
*objfile
,
2148 struct dwarf2_per_cu_data
*this_cu
)
2150 bfd
*abfd
= objfile
->obfd
;
2151 struct line_header
*lh
;
2152 struct attribute
*attr
;
2153 struct cleanup
*cleanups
;
2154 struct die_info
*comp_unit_die
;
2155 struct dwarf2_section_info
* sec
;
2156 gdb_byte
*beg_of_comp_unit
, *info_ptr
, *buffer
;
2157 int has_children
, i
;
2158 struct dwarf2_cu cu
;
2159 unsigned int bytes_read
, buffer_size
;
2160 struct die_reader_specs reader_specs
;
2161 char *name
, *comp_dir
;
2163 struct quick_file_names
*qfn
;
2164 unsigned int line_offset
;
2166 if (this_cu
->v
.quick
->file_names
!= NULL
)
2167 return this_cu
->v
.quick
->file_names
;
2168 /* If we know there is no line data, no point in looking again. */
2169 if (this_cu
->v
.quick
->no_file_data
)
2172 init_one_comp_unit (&cu
, objfile
);
2173 cleanups
= make_cleanup (free_stack_comp_unit
, &cu
);
2175 if (this_cu
->from_debug_types
)
2176 sec
= &dwarf2_per_objfile
->types
;
2178 sec
= &dwarf2_per_objfile
->info
;
2179 dwarf2_read_section (objfile
, sec
);
2180 buffer_size
= sec
->size
;
2181 buffer
= sec
->buffer
;
2182 info_ptr
= buffer
+ this_cu
->offset
;
2183 beg_of_comp_unit
= info_ptr
;
2185 info_ptr
= partial_read_comp_unit_head (&cu
.header
, info_ptr
,
2186 buffer
, buffer_size
,
2189 /* Complete the cu_header. */
2190 cu
.header
.offset
= beg_of_comp_unit
- buffer
;
2191 cu
.header
.first_die_offset
= info_ptr
- beg_of_comp_unit
;
2194 cu
.per_cu
= this_cu
;
2196 dwarf2_read_abbrevs (abfd
, &cu
);
2197 make_cleanup (dwarf2_free_abbrev_table
, &cu
);
2199 if (this_cu
->from_debug_types
)
2200 info_ptr
+= 8 /*signature*/ + cu
.header
.offset_size
;
2201 init_cu_die_reader (&reader_specs
, &cu
);
2202 read_full_die (&reader_specs
, &comp_unit_die
, info_ptr
,
2208 attr
= dwarf2_attr (comp_unit_die
, DW_AT_stmt_list
, &cu
);
2211 struct quick_file_names find_entry
;
2213 line_offset
= DW_UNSND (attr
);
2215 /* We may have already read in this line header (TU line header sharing).
2216 If we have we're done. */
2217 find_entry
.offset
= line_offset
;
2218 slot
= htab_find_slot (dwarf2_per_objfile
->quick_file_names_table
,
2219 &find_entry
, INSERT
);
2222 do_cleanups (cleanups
);
2223 this_cu
->v
.quick
->file_names
= *slot
;
2227 lh
= dwarf_decode_line_header (line_offset
, abfd
, &cu
);
2231 do_cleanups (cleanups
);
2232 this_cu
->v
.quick
->no_file_data
= 1;
2236 qfn
= obstack_alloc (&objfile
->objfile_obstack
, sizeof (*qfn
));
2237 qfn
->offset
= line_offset
;
2238 gdb_assert (slot
!= NULL
);
2241 find_file_and_directory (comp_unit_die
, &cu
, &name
, &comp_dir
);
2243 qfn
->num_file_names
= lh
->num_file_names
;
2244 qfn
->file_names
= obstack_alloc (&objfile
->objfile_obstack
,
2245 lh
->num_file_names
* sizeof (char *));
2246 for (i
= 0; i
< lh
->num_file_names
; ++i
)
2247 qfn
->file_names
[i
] = file_full_name (i
+ 1, lh
, comp_dir
);
2248 qfn
->real_names
= NULL
;
2250 free_line_header (lh
);
2251 do_cleanups (cleanups
);
2253 this_cu
->v
.quick
->file_names
= qfn
;
2257 /* A helper for the "quick" functions which computes and caches the
2258 real path for a given file name from the line table. */
2261 dw2_get_real_path (struct objfile
*objfile
,
2262 struct quick_file_names
*qfn
, int index
)
2264 if (qfn
->real_names
== NULL
)
2265 qfn
->real_names
= OBSTACK_CALLOC (&objfile
->objfile_obstack
,
2266 qfn
->num_file_names
, sizeof (char *));
2268 if (qfn
->real_names
[index
] == NULL
)
2269 qfn
->real_names
[index
] = gdb_realpath (qfn
->file_names
[index
]);
2271 return qfn
->real_names
[index
];
2274 static struct symtab
*
2275 dw2_find_last_source_symtab (struct objfile
*objfile
)
2279 dw2_setup (objfile
);
2280 index
= dwarf2_per_objfile
->n_comp_units
- 1;
2281 return dw2_instantiate_symtab (objfile
, dw2_get_cu (index
));
2284 /* Traversal function for dw2_forget_cached_source_info. */
2287 dw2_free_cached_file_names (void **slot
, void *info
)
2289 struct quick_file_names
*file_data
= (struct quick_file_names
*) *slot
;
2291 if (file_data
->real_names
)
2295 for (i
= 0; i
< file_data
->num_file_names
; ++i
)
2297 xfree ((void*) file_data
->real_names
[i
]);
2298 file_data
->real_names
[i
] = NULL
;
2306 dw2_forget_cached_source_info (struct objfile
*objfile
)
2308 dw2_setup (objfile
);
2310 htab_traverse_noresize (dwarf2_per_objfile
->quick_file_names_table
,
2311 dw2_free_cached_file_names
, NULL
);
2315 dw2_lookup_symtab (struct objfile
*objfile
, const char *name
,
2316 const char *full_path
, const char *real_path
,
2317 struct symtab
**result
)
2320 int check_basename
= lbasename (name
) == name
;
2321 struct dwarf2_per_cu_data
*base_cu
= NULL
;
2323 dw2_setup (objfile
);
2325 for (i
= 0; i
< (dwarf2_per_objfile
->n_comp_units
2326 + dwarf2_per_objfile
->n_type_comp_units
); ++i
)
2329 struct dwarf2_per_cu_data
*per_cu
= dw2_get_cu (i
);
2330 struct quick_file_names
*file_data
;
2332 if (per_cu
->v
.quick
->symtab
)
2335 file_data
= dw2_get_file_names (objfile
, per_cu
);
2336 if (file_data
== NULL
)
2339 for (j
= 0; j
< file_data
->num_file_names
; ++j
)
2341 const char *this_name
= file_data
->file_names
[j
];
2343 if (FILENAME_CMP (name
, this_name
) == 0)
2345 *result
= dw2_instantiate_symtab (objfile
, per_cu
);
2349 if (check_basename
&& ! base_cu
2350 && FILENAME_CMP (lbasename (this_name
), name
) == 0)
2353 if (full_path
!= NULL
)
2355 const char *this_real_name
= dw2_get_real_path (objfile
,
2358 if (this_real_name
!= NULL
2359 && FILENAME_CMP (full_path
, this_real_name
) == 0)
2361 *result
= dw2_instantiate_symtab (objfile
, per_cu
);
2366 if (real_path
!= NULL
)
2368 const char *this_real_name
= dw2_get_real_path (objfile
,
2371 if (this_real_name
!= NULL
2372 && FILENAME_CMP (real_path
, this_real_name
) == 0)
2374 *result
= dw2_instantiate_symtab (objfile
, per_cu
);
2383 *result
= dw2_instantiate_symtab (objfile
, base_cu
);
2390 static struct symtab
*
2391 dw2_lookup_symbol (struct objfile
*objfile
, int block_index
,
2392 const char *name
, domain_enum domain
)
2394 /* We do all the work in the pre_expand_symtabs_matching hook
2399 /* A helper function that expands all symtabs that hold an object
2403 dw2_do_expand_symtabs_matching (struct objfile
*objfile
, const char *name
)
2405 dw2_setup (objfile
);
2407 /* index_table is NULL if OBJF_READNOW. */
2408 if (dwarf2_per_objfile
->index_table
)
2412 if (find_slot_in_mapped_hash (dwarf2_per_objfile
->index_table
,
2415 offset_type i
, len
= MAYBE_SWAP (*vec
);
2416 for (i
= 0; i
< len
; ++i
)
2418 offset_type cu_index
= MAYBE_SWAP (vec
[i
+ 1]);
2419 struct dwarf2_per_cu_data
*per_cu
= dw2_get_cu (cu_index
);
2421 dw2_instantiate_symtab (objfile
, per_cu
);
2428 dw2_pre_expand_symtabs_matching (struct objfile
*objfile
,
2429 enum block_enum block_kind
, const char *name
,
2432 dw2_do_expand_symtabs_matching (objfile
, name
);
2436 dw2_print_stats (struct objfile
*objfile
)
2440 dw2_setup (objfile
);
2442 for (i
= 0; i
< (dwarf2_per_objfile
->n_comp_units
2443 + dwarf2_per_objfile
->n_type_comp_units
); ++i
)
2445 struct dwarf2_per_cu_data
*per_cu
= dw2_get_cu (i
);
2447 if (!per_cu
->v
.quick
->symtab
)
2450 printf_filtered (_(" Number of unread CUs: %d\n"), count
);
2454 dw2_dump (struct objfile
*objfile
)
2456 /* Nothing worth printing. */
2460 dw2_relocate (struct objfile
*objfile
, struct section_offsets
*new_offsets
,
2461 struct section_offsets
*delta
)
2463 /* There's nothing to relocate here. */
2467 dw2_expand_symtabs_for_function (struct objfile
*objfile
,
2468 const char *func_name
)
2470 dw2_do_expand_symtabs_matching (objfile
, func_name
);
2474 dw2_expand_all_symtabs (struct objfile
*objfile
)
2478 dw2_setup (objfile
);
2480 for (i
= 0; i
< (dwarf2_per_objfile
->n_comp_units
2481 + dwarf2_per_objfile
->n_type_comp_units
); ++i
)
2483 struct dwarf2_per_cu_data
*per_cu
= dw2_get_cu (i
);
2485 dw2_instantiate_symtab (objfile
, per_cu
);
2490 dw2_expand_symtabs_with_filename (struct objfile
*objfile
,
2491 const char *filename
)
2495 dw2_setup (objfile
);
2497 /* We don't need to consider type units here.
2498 This is only called for examining code, e.g. expand_line_sal.
2499 There can be an order of magnitude (or more) more type units
2500 than comp units, and we avoid them if we can. */
2502 for (i
= 0; i
< dwarf2_per_objfile
->n_comp_units
; ++i
)
2505 struct dwarf2_per_cu_data
*per_cu
= dw2_get_cu (i
);
2506 struct quick_file_names
*file_data
;
2508 if (per_cu
->v
.quick
->symtab
)
2511 file_data
= dw2_get_file_names (objfile
, per_cu
);
2512 if (file_data
== NULL
)
2515 for (j
= 0; j
< file_data
->num_file_names
; ++j
)
2517 const char *this_name
= file_data
->file_names
[j
];
2518 if (FILENAME_CMP (this_name
, filename
) == 0)
2520 dw2_instantiate_symtab (objfile
, per_cu
);
2528 dw2_find_symbol_file (struct objfile
*objfile
, const char *name
)
2530 struct dwarf2_per_cu_data
*per_cu
;
2532 struct quick_file_names
*file_data
;
2534 dw2_setup (objfile
);
2536 /* index_table is NULL if OBJF_READNOW. */
2537 if (!dwarf2_per_objfile
->index_table
)
2540 if (!find_slot_in_mapped_hash (dwarf2_per_objfile
->index_table
,
2544 /* Note that this just looks at the very first one named NAME -- but
2545 actually we are looking for a function. find_main_filename
2546 should be rewritten so that it doesn't require a custom hook. It
2547 could just use the ordinary symbol tables. */
2548 /* vec[0] is the length, which must always be >0. */
2549 per_cu
= dw2_get_cu (MAYBE_SWAP (vec
[1]));
2551 file_data
= dw2_get_file_names (objfile
, per_cu
);
2552 if (file_data
== NULL
)
2555 return file_data
->file_names
[file_data
->num_file_names
- 1];
2559 dw2_map_matching_symbols (const char * name
, domain_enum
namespace,
2560 struct objfile
*objfile
, int global
,
2561 int (*callback
) (struct block
*,
2562 struct symbol
*, void *),
2563 void *data
, symbol_compare_ftype
*match
,
2564 symbol_compare_ftype
*ordered_compare
)
2566 /* Currently unimplemented; used for Ada. The function can be called if the
2567 current language is Ada for a non-Ada objfile using GNU index. As Ada
2568 does not look for non-Ada symbols this function should just return. */
2572 dw2_expand_symtabs_matching (struct objfile
*objfile
,
2573 int (*file_matcher
) (const char *, void *),
2574 int (*name_matcher
) (const char *, void *),
2575 enum search_domain kind
,
2580 struct mapped_index
*index
;
2582 dw2_setup (objfile
);
2584 /* index_table is NULL if OBJF_READNOW. */
2585 if (!dwarf2_per_objfile
->index_table
)
2587 index
= dwarf2_per_objfile
->index_table
;
2589 for (i
= 0; i
< (dwarf2_per_objfile
->n_comp_units
2590 + dwarf2_per_objfile
->n_type_comp_units
); ++i
)
2593 struct dwarf2_per_cu_data
*per_cu
= dw2_get_cu (i
);
2594 struct quick_file_names
*file_data
;
2596 per_cu
->v
.quick
->mark
= 0;
2597 if (per_cu
->v
.quick
->symtab
)
2600 file_data
= dw2_get_file_names (objfile
, per_cu
);
2601 if (file_data
== NULL
)
2604 for (j
= 0; j
< file_data
->num_file_names
; ++j
)
2606 if (file_matcher (file_data
->file_names
[j
], data
))
2608 per_cu
->v
.quick
->mark
= 1;
2614 for (iter
= 0; iter
< index
->symbol_table_slots
; ++iter
)
2616 offset_type idx
= 2 * iter
;
2618 offset_type
*vec
, vec_len
, vec_idx
;
2620 if (index
->symbol_table
[idx
] == 0 && index
->symbol_table
[idx
+ 1] == 0)
2623 name
= index
->constant_pool
+ MAYBE_SWAP (index
->symbol_table
[idx
]);
2625 if (! (*name_matcher
) (name
, data
))
2628 /* The name was matched, now expand corresponding CUs that were
2630 vec
= (offset_type
*) (index
->constant_pool
2631 + MAYBE_SWAP (index
->symbol_table
[idx
+ 1]));
2632 vec_len
= MAYBE_SWAP (vec
[0]);
2633 for (vec_idx
= 0; vec_idx
< vec_len
; ++vec_idx
)
2635 struct dwarf2_per_cu_data
*per_cu
;
2637 per_cu
= dw2_get_cu (MAYBE_SWAP (vec
[vec_idx
+ 1]));
2638 if (per_cu
->v
.quick
->mark
)
2639 dw2_instantiate_symtab (objfile
, per_cu
);
2644 static struct symtab
*
2645 dw2_find_pc_sect_symtab (struct objfile
*objfile
,
2646 struct minimal_symbol
*msymbol
,
2648 struct obj_section
*section
,
2651 struct dwarf2_per_cu_data
*data
;
2653 dw2_setup (objfile
);
2655 if (!objfile
->psymtabs_addrmap
)
2658 data
= addrmap_find (objfile
->psymtabs_addrmap
, pc
);
2662 if (warn_if_readin
&& data
->v
.quick
->symtab
)
2663 warning (_("(Internal error: pc %s in read in CU, but not in symtab.)"),
2664 paddress (get_objfile_arch (objfile
), pc
));
2666 return dw2_instantiate_symtab (objfile
, data
);
2670 dw2_map_symbol_names (struct objfile
*objfile
,
2671 void (*fun
) (const char *, void *),
2675 struct mapped_index
*index
;
2677 dw2_setup (objfile
);
2679 /* index_table is NULL if OBJF_READNOW. */
2680 if (!dwarf2_per_objfile
->index_table
)
2682 index
= dwarf2_per_objfile
->index_table
;
2684 for (iter
= 0; iter
< index
->symbol_table_slots
; ++iter
)
2686 offset_type idx
= 2 * iter
;
2688 offset_type
*vec
, vec_len
, vec_idx
;
2690 if (index
->symbol_table
[idx
] == 0 && index
->symbol_table
[idx
+ 1] == 0)
2693 name
= (index
->constant_pool
+ MAYBE_SWAP (index
->symbol_table
[idx
]));
2695 (*fun
) (name
, data
);
2700 dw2_map_symbol_filenames (struct objfile
*objfile
,
2701 void (*fun
) (const char *, const char *, void *),
2706 dw2_setup (objfile
);
2708 for (i
= 0; i
< (dwarf2_per_objfile
->n_comp_units
2709 + dwarf2_per_objfile
->n_type_comp_units
); ++i
)
2712 struct dwarf2_per_cu_data
*per_cu
= dw2_get_cu (i
);
2713 struct quick_file_names
*file_data
;
2715 if (per_cu
->v
.quick
->symtab
)
2718 file_data
= dw2_get_file_names (objfile
, per_cu
);
2719 if (file_data
== NULL
)
2722 for (j
= 0; j
< file_data
->num_file_names
; ++j
)
2724 const char *this_real_name
= dw2_get_real_path (objfile
, file_data
,
2726 (*fun
) (file_data
->file_names
[j
], this_real_name
, data
);
2732 dw2_has_symbols (struct objfile
*objfile
)
2737 const struct quick_symbol_functions dwarf2_gdb_index_functions
=
2740 dw2_find_last_source_symtab
,
2741 dw2_forget_cached_source_info
,
2744 dw2_pre_expand_symtabs_matching
,
2748 dw2_expand_symtabs_for_function
,
2749 dw2_expand_all_symtabs
,
2750 dw2_expand_symtabs_with_filename
,
2751 dw2_find_symbol_file
,
2752 dw2_map_matching_symbols
,
2753 dw2_expand_symtabs_matching
,
2754 dw2_find_pc_sect_symtab
,
2755 dw2_map_symbol_names
,
2756 dw2_map_symbol_filenames
2759 /* Initialize for reading DWARF for this objfile. Return 0 if this
2760 file will use psymtabs, or 1 if using the GNU index. */
2763 dwarf2_initialize_objfile (struct objfile
*objfile
)
2765 /* If we're about to read full symbols, don't bother with the
2766 indices. In this case we also don't care if some other debug
2767 format is making psymtabs, because they are all about to be
2769 if ((objfile
->flags
& OBJF_READNOW
))
2773 dwarf2_per_objfile
->using_index
= 1;
2774 create_all_comp_units (objfile
);
2775 create_debug_types_hash_table (objfile
);
2776 dwarf2_per_objfile
->quick_file_names_table
=
2777 create_quick_file_names_table (dwarf2_per_objfile
->n_comp_units
);
2779 for (i
= 0; i
< (dwarf2_per_objfile
->n_comp_units
2780 + dwarf2_per_objfile
->n_type_comp_units
); ++i
)
2782 struct dwarf2_per_cu_data
*per_cu
= dw2_get_cu (i
);
2784 per_cu
->v
.quick
= OBSTACK_ZALLOC (&objfile
->objfile_obstack
,
2785 struct dwarf2_per_cu_quick_data
);
2788 /* Return 1 so that gdb sees the "quick" functions. However,
2789 these functions will be no-ops because we will have expanded
2794 if (dwarf2_read_index (objfile
))
2802 /* Build a partial symbol table. */
2805 dwarf2_build_psymtabs (struct objfile
*objfile
)
2807 if (objfile
->global_psymbols
.size
== 0 && objfile
->static_psymbols
.size
== 0)
2809 init_psymbol_list (objfile
, 1024);
2812 dwarf2_build_psymtabs_hard (objfile
);
2815 /* Return TRUE if OFFSET is within CU_HEADER. */
2818 offset_in_cu_p (const struct comp_unit_head
*cu_header
, unsigned int offset
)
2820 unsigned int bottom
= cu_header
->offset
;
2821 unsigned int top
= (cu_header
->offset
2823 + cu_header
->initial_length_size
);
2825 return (offset
>= bottom
&& offset
< top
);
2828 /* Read in the comp unit header information from the debug_info at info_ptr.
2829 NOTE: This leaves members offset, first_die_offset to be filled in
2833 read_comp_unit_head (struct comp_unit_head
*cu_header
,
2834 gdb_byte
*info_ptr
, bfd
*abfd
)
2837 unsigned int bytes_read
;
2839 cu_header
->length
= read_initial_length (abfd
, info_ptr
, &bytes_read
);
2840 cu_header
->initial_length_size
= bytes_read
;
2841 cu_header
->offset_size
= (bytes_read
== 4) ? 4 : 8;
2842 info_ptr
+= bytes_read
;
2843 cu_header
->version
= read_2_bytes (abfd
, info_ptr
);
2845 cu_header
->abbrev_offset
= read_offset (abfd
, info_ptr
, cu_header
,
2847 info_ptr
+= bytes_read
;
2848 cu_header
->addr_size
= read_1_byte (abfd
, info_ptr
);
2850 signed_addr
= bfd_get_sign_extend_vma (abfd
);
2851 if (signed_addr
< 0)
2852 internal_error (__FILE__
, __LINE__
,
2853 _("read_comp_unit_head: dwarf from non elf file"));
2854 cu_header
->signed_addr_p
= signed_addr
;
2860 partial_read_comp_unit_head (struct comp_unit_head
*header
, gdb_byte
*info_ptr
,
2861 gdb_byte
*buffer
, unsigned int buffer_size
,
2864 gdb_byte
*beg_of_comp_unit
= info_ptr
;
2866 info_ptr
= read_comp_unit_head (header
, info_ptr
, abfd
);
2868 if (header
->version
!= 2 && header
->version
!= 3 && header
->version
!= 4)
2869 error (_("Dwarf Error: wrong version in compilation unit header "
2870 "(is %d, should be 2, 3, or 4) [in module %s]"), header
->version
,
2871 bfd_get_filename (abfd
));
2873 if (header
->abbrev_offset
2874 >= dwarf2_section_size (dwarf2_per_objfile
->objfile
,
2875 &dwarf2_per_objfile
->abbrev
))
2876 error (_("Dwarf Error: bad offset (0x%lx) in compilation unit header "
2877 "(offset 0x%lx + 6) [in module %s]"),
2878 (long) header
->abbrev_offset
,
2879 (long) (beg_of_comp_unit
- buffer
),
2880 bfd_get_filename (abfd
));
2882 if (beg_of_comp_unit
+ header
->length
+ header
->initial_length_size
2883 > buffer
+ buffer_size
)
2884 error (_("Dwarf Error: bad length (0x%lx) in compilation unit header "
2885 "(offset 0x%lx + 0) [in module %s]"),
2886 (long) header
->length
,
2887 (long) (beg_of_comp_unit
- buffer
),
2888 bfd_get_filename (abfd
));
2893 /* Read in the types comp unit header information from .debug_types entry at
2894 types_ptr. The result is a pointer to one past the end of the header. */
2897 read_type_comp_unit_head (struct comp_unit_head
*cu_header
,
2898 ULONGEST
*signature
,
2899 gdb_byte
*types_ptr
, bfd
*abfd
)
2901 gdb_byte
*initial_types_ptr
= types_ptr
;
2903 dwarf2_read_section (dwarf2_per_objfile
->objfile
,
2904 &dwarf2_per_objfile
->types
);
2905 cu_header
->offset
= types_ptr
- dwarf2_per_objfile
->types
.buffer
;
2907 types_ptr
= read_comp_unit_head (cu_header
, types_ptr
, abfd
);
2909 *signature
= read_8_bytes (abfd
, types_ptr
);
2911 types_ptr
+= cu_header
->offset_size
;
2912 cu_header
->first_die_offset
= types_ptr
- initial_types_ptr
;
2917 /* Allocate a new partial symtab for file named NAME and mark this new
2918 partial symtab as being an include of PST. */
2921 dwarf2_create_include_psymtab (char *name
, struct partial_symtab
*pst
,
2922 struct objfile
*objfile
)
2924 struct partial_symtab
*subpst
= allocate_psymtab (name
, objfile
);
2926 subpst
->section_offsets
= pst
->section_offsets
;
2927 subpst
->textlow
= 0;
2928 subpst
->texthigh
= 0;
2930 subpst
->dependencies
= (struct partial_symtab
**)
2931 obstack_alloc (&objfile
->objfile_obstack
,
2932 sizeof (struct partial_symtab
*));
2933 subpst
->dependencies
[0] = pst
;
2934 subpst
->number_of_dependencies
= 1;
2936 subpst
->globals_offset
= 0;
2937 subpst
->n_global_syms
= 0;
2938 subpst
->statics_offset
= 0;
2939 subpst
->n_static_syms
= 0;
2940 subpst
->symtab
= NULL
;
2941 subpst
->read_symtab
= pst
->read_symtab
;
2944 /* No private part is necessary for include psymtabs. This property
2945 can be used to differentiate between such include psymtabs and
2946 the regular ones. */
2947 subpst
->read_symtab_private
= NULL
;
2950 /* Read the Line Number Program data and extract the list of files
2951 included by the source file represented by PST. Build an include
2952 partial symtab for each of these included files. */
2955 dwarf2_build_include_psymtabs (struct dwarf2_cu
*cu
,
2956 struct die_info
*die
,
2957 struct partial_symtab
*pst
)
2959 struct objfile
*objfile
= cu
->objfile
;
2960 bfd
*abfd
= objfile
->obfd
;
2961 struct line_header
*lh
= NULL
;
2962 struct attribute
*attr
;
2964 attr
= dwarf2_attr (die
, DW_AT_stmt_list
, cu
);
2967 unsigned int line_offset
= DW_UNSND (attr
);
2969 lh
= dwarf_decode_line_header (line_offset
, abfd
, cu
);
2972 return; /* No linetable, so no includes. */
2974 /* NOTE: pst->dirname is DW_AT_comp_dir (if present). */
2975 dwarf_decode_lines (lh
, pst
->dirname
, abfd
, cu
, pst
);
2977 free_line_header (lh
);
2981 hash_type_signature (const void *item
)
2983 const struct signatured_type
*type_sig
= item
;
2985 /* This drops the top 32 bits of the signature, but is ok for a hash. */
2986 return type_sig
->signature
;
2990 eq_type_signature (const void *item_lhs
, const void *item_rhs
)
2992 const struct signatured_type
*lhs
= item_lhs
;
2993 const struct signatured_type
*rhs
= item_rhs
;
2995 return lhs
->signature
== rhs
->signature
;
2998 /* Allocate a hash table for signatured types. */
3001 allocate_signatured_type_table (struct objfile
*objfile
)
3003 return htab_create_alloc_ex (41,
3004 hash_type_signature
,
3007 &objfile
->objfile_obstack
,
3008 hashtab_obstack_allocate
,
3009 dummy_obstack_deallocate
);
3012 /* A helper function to add a signatured type CU to a list. */
3015 add_signatured_type_cu_to_list (void **slot
, void *datum
)
3017 struct signatured_type
*sigt
= *slot
;
3018 struct dwarf2_per_cu_data
***datap
= datum
;
3020 **datap
= &sigt
->per_cu
;
3026 /* Create the hash table of all entries in the .debug_types section.
3027 The result is zero if there is an error (e.g. missing .debug_types section),
3028 otherwise non-zero. */
3031 create_debug_types_hash_table (struct objfile
*objfile
)
3035 struct dwarf2_per_cu_data
**iter
;
3037 dwarf2_read_section (objfile
, &dwarf2_per_objfile
->types
);
3038 info_ptr
= dwarf2_per_objfile
->types
.buffer
;
3040 if (info_ptr
== NULL
)
3042 dwarf2_per_objfile
->signatured_types
= NULL
;
3046 types_htab
= allocate_signatured_type_table (objfile
);
3048 if (dwarf2_die_debug
)
3049 fprintf_unfiltered (gdb_stdlog
, "Signatured types:\n");
3051 while (info_ptr
< dwarf2_per_objfile
->types
.buffer
3052 + dwarf2_per_objfile
->types
.size
)
3054 unsigned int offset
;
3055 unsigned int offset_size
;
3056 unsigned int type_offset
;
3057 unsigned int length
, initial_length_size
;
3058 unsigned short version
;
3060 struct signatured_type
*type_sig
;
3062 gdb_byte
*ptr
= info_ptr
;
3064 offset
= ptr
- dwarf2_per_objfile
->types
.buffer
;
3066 /* We need to read the type's signature in order to build the hash
3067 table, but we don't need to read anything else just yet. */
3069 /* Sanity check to ensure entire cu is present. */
3070 length
= read_initial_length (objfile
->obfd
, ptr
, &initial_length_size
);
3071 if (ptr
+ length
+ initial_length_size
3072 > dwarf2_per_objfile
->types
.buffer
+ dwarf2_per_objfile
->types
.size
)
3074 complaint (&symfile_complaints
,
3075 _("debug type entry runs off end "
3076 "of `.debug_types' section, ignored"));
3080 offset_size
= initial_length_size
== 4 ? 4 : 8;
3081 ptr
+= initial_length_size
;
3082 version
= bfd_get_16 (objfile
->obfd
, ptr
);
3084 ptr
+= offset_size
; /* abbrev offset */
3085 ptr
+= 1; /* address size */
3086 signature
= bfd_get_64 (objfile
->obfd
, ptr
);
3088 type_offset
= read_offset_1 (objfile
->obfd
, ptr
, offset_size
);
3090 type_sig
= obstack_alloc (&objfile
->objfile_obstack
, sizeof (*type_sig
));
3091 memset (type_sig
, 0, sizeof (*type_sig
));
3092 type_sig
->signature
= signature
;
3093 type_sig
->offset
= offset
;
3094 type_sig
->type_offset
= type_offset
;
3095 type_sig
->per_cu
.objfile
= objfile
;
3096 type_sig
->per_cu
.from_debug_types
= 1;
3098 slot
= htab_find_slot (types_htab
, type_sig
, INSERT
);
3099 gdb_assert (slot
!= NULL
);
3102 if (dwarf2_die_debug
)
3103 fprintf_unfiltered (gdb_stdlog
, " offset 0x%x, signature 0x%s\n",
3104 offset
, phex (signature
, sizeof (signature
)));
3106 info_ptr
= info_ptr
+ initial_length_size
+ length
;
3109 dwarf2_per_objfile
->signatured_types
= types_htab
;
3111 dwarf2_per_objfile
->n_type_comp_units
= htab_elements (types_htab
);
3112 dwarf2_per_objfile
->type_comp_units
3113 = obstack_alloc (&objfile
->objfile_obstack
,
3114 dwarf2_per_objfile
->n_type_comp_units
3115 * sizeof (struct dwarf2_per_cu_data
*));
3116 iter
= &dwarf2_per_objfile
->type_comp_units
[0];
3117 htab_traverse_noresize (types_htab
, add_signatured_type_cu_to_list
, &iter
);
3118 gdb_assert (iter
- &dwarf2_per_objfile
->type_comp_units
[0]
3119 == dwarf2_per_objfile
->n_type_comp_units
);
3124 /* Lookup a signature based type.
3125 Returns NULL if SIG is not present in the table. */
3127 static struct signatured_type
*
3128 lookup_signatured_type (struct objfile
*objfile
, ULONGEST sig
)
3130 struct signatured_type find_entry
, *entry
;
3132 if (dwarf2_per_objfile
->signatured_types
== NULL
)
3134 complaint (&symfile_complaints
,
3135 _("missing `.debug_types' section for DW_FORM_ref_sig8 die"));
3139 find_entry
.signature
= sig
;
3140 entry
= htab_find (dwarf2_per_objfile
->signatured_types
, &find_entry
);
3144 /* Initialize a die_reader_specs struct from a dwarf2_cu struct. */
3147 init_cu_die_reader (struct die_reader_specs
*reader
,
3148 struct dwarf2_cu
*cu
)
3150 reader
->abfd
= cu
->objfile
->obfd
;
3152 if (cu
->per_cu
->from_debug_types
)
3154 gdb_assert (dwarf2_per_objfile
->types
.readin
);
3155 reader
->buffer
= dwarf2_per_objfile
->types
.buffer
;
3159 gdb_assert (dwarf2_per_objfile
->info
.readin
);
3160 reader
->buffer
= dwarf2_per_objfile
->info
.buffer
;
3164 /* Find the base address of the compilation unit for range lists and
3165 location lists. It will normally be specified by DW_AT_low_pc.
3166 In DWARF-3 draft 4, the base address could be overridden by
3167 DW_AT_entry_pc. It's been removed, but GCC still uses this for
3168 compilation units with discontinuous ranges. */
3171 dwarf2_find_base_address (struct die_info
*die
, struct dwarf2_cu
*cu
)
3173 struct attribute
*attr
;
3176 cu
->base_address
= 0;
3178 attr
= dwarf2_attr (die
, DW_AT_entry_pc
, cu
);
3181 cu
->base_address
= DW_ADDR (attr
);
3186 attr
= dwarf2_attr (die
, DW_AT_low_pc
, cu
);
3189 cu
->base_address
= DW_ADDR (attr
);
3195 /* Subroutine of process_type_comp_unit and dwarf2_build_psymtabs_hard
3196 to combine the common parts.
3197 Process a compilation unit for a psymtab.
3198 BUFFER is a pointer to the beginning of the dwarf section buffer,
3199 either .debug_info or debug_types.
3200 INFO_PTR is a pointer to the start of the CU.
3201 Returns a pointer to the next CU. */
3204 process_psymtab_comp_unit (struct objfile
*objfile
,
3205 struct dwarf2_per_cu_data
*this_cu
,
3206 gdb_byte
*buffer
, gdb_byte
*info_ptr
,
3207 unsigned int buffer_size
)
3209 bfd
*abfd
= objfile
->obfd
;
3210 gdb_byte
*beg_of_comp_unit
= info_ptr
;
3211 struct die_info
*comp_unit_die
;
3212 struct partial_symtab
*pst
;
3214 struct cleanup
*back_to_inner
;
3215 struct dwarf2_cu cu
;
3216 int has_children
, has_pc_info
;
3217 struct attribute
*attr
;
3218 CORE_ADDR best_lowpc
= 0, best_highpc
= 0;
3219 struct die_reader_specs reader_specs
;
3220 const char *filename
;
3222 init_one_comp_unit (&cu
, objfile
);
3223 back_to_inner
= make_cleanup (free_stack_comp_unit
, &cu
);
3225 info_ptr
= partial_read_comp_unit_head (&cu
.header
, info_ptr
,
3226 buffer
, buffer_size
,
3229 /* Complete the cu_header. */
3230 cu
.header
.offset
= beg_of_comp_unit
- buffer
;
3231 cu
.header
.first_die_offset
= info_ptr
- beg_of_comp_unit
;
3233 cu
.list_in_scope
= &file_symbols
;
3235 /* If this compilation unit was already read in, free the
3236 cached copy in order to read it in again. This is
3237 necessary because we skipped some symbols when we first
3238 read in the compilation unit (see load_partial_dies).
3239 This problem could be avoided, but the benefit is
3241 if (this_cu
->cu
!= NULL
)
3242 free_one_cached_comp_unit (this_cu
->cu
);
3244 /* Note that this is a pointer to our stack frame, being
3245 added to a global data structure. It will be cleaned up
3246 in free_stack_comp_unit when we finish with this
3247 compilation unit. */
3249 cu
.per_cu
= this_cu
;
3251 /* Read the abbrevs for this compilation unit into a table. */
3252 dwarf2_read_abbrevs (abfd
, &cu
);
3253 make_cleanup (dwarf2_free_abbrev_table
, &cu
);
3255 /* Read the compilation unit die. */
3256 if (this_cu
->from_debug_types
)
3257 info_ptr
+= 8 /*signature*/ + cu
.header
.offset_size
;
3258 init_cu_die_reader (&reader_specs
, &cu
);
3259 info_ptr
= read_full_die (&reader_specs
, &comp_unit_die
, info_ptr
,
3262 if (this_cu
->from_debug_types
)
3264 /* offset,length haven't been set yet for type units. */
3265 this_cu
->offset
= cu
.header
.offset
;
3266 this_cu
->length
= cu
.header
.length
+ cu
.header
.initial_length_size
;
3268 else if (comp_unit_die
->tag
== DW_TAG_partial_unit
)
3270 info_ptr
= (beg_of_comp_unit
+ cu
.header
.length
3271 + cu
.header
.initial_length_size
);
3272 do_cleanups (back_to_inner
);
3276 prepare_one_comp_unit (&cu
, comp_unit_die
);
3278 /* Allocate a new partial symbol table structure. */
3279 attr
= dwarf2_attr (comp_unit_die
, DW_AT_name
, &cu
);
3280 if (attr
== NULL
|| !DW_STRING (attr
))
3283 filename
= DW_STRING (attr
);
3284 pst
= start_psymtab_common (objfile
, objfile
->section_offsets
,
3286 /* TEXTLOW and TEXTHIGH are set below. */
3288 objfile
->global_psymbols
.next
,
3289 objfile
->static_psymbols
.next
);
3291 attr
= dwarf2_attr (comp_unit_die
, DW_AT_comp_dir
, &cu
);
3293 pst
->dirname
= DW_STRING (attr
);
3295 pst
->read_symtab_private
= this_cu
;
3297 baseaddr
= ANOFFSET (objfile
->section_offsets
, SECT_OFF_TEXT (objfile
));
3299 /* Store the function that reads in the rest of the symbol table. */
3300 pst
->read_symtab
= dwarf2_psymtab_to_symtab
;
3302 this_cu
->v
.psymtab
= pst
;
3304 dwarf2_find_base_address (comp_unit_die
, &cu
);
3306 /* Possibly set the default values of LOWPC and HIGHPC from
3308 has_pc_info
= dwarf2_get_pc_bounds (comp_unit_die
, &best_lowpc
,
3309 &best_highpc
, &cu
, pst
);
3310 if (has_pc_info
== 1 && best_lowpc
< best_highpc
)
3311 /* Store the contiguous range if it is not empty; it can be empty for
3312 CUs with no code. */
3313 addrmap_set_empty (objfile
->psymtabs_addrmap
,
3314 best_lowpc
+ baseaddr
,
3315 best_highpc
+ baseaddr
- 1, pst
);
3317 /* Check if comp unit has_children.
3318 If so, read the rest of the partial symbols from this comp unit.
3319 If not, there's no more debug_info for this comp unit. */
3322 struct partial_die_info
*first_die
;
3323 CORE_ADDR lowpc
, highpc
;
3325 lowpc
= ((CORE_ADDR
) -1);
3326 highpc
= ((CORE_ADDR
) 0);
3328 first_die
= load_partial_dies (abfd
, buffer
, info_ptr
, 1, &cu
);
3330 scan_partial_symbols (first_die
, &lowpc
, &highpc
,
3331 ! has_pc_info
, &cu
);
3333 /* If we didn't find a lowpc, set it to highpc to avoid
3334 complaints from `maint check'. */
3335 if (lowpc
== ((CORE_ADDR
) -1))
3338 /* If the compilation unit didn't have an explicit address range,
3339 then use the information extracted from its child dies. */
3343 best_highpc
= highpc
;
3346 pst
->textlow
= best_lowpc
+ baseaddr
;
3347 pst
->texthigh
= best_highpc
+ baseaddr
;
3349 pst
->n_global_syms
= objfile
->global_psymbols
.next
-
3350 (objfile
->global_psymbols
.list
+ pst
->globals_offset
);
3351 pst
->n_static_syms
= objfile
->static_psymbols
.next
-
3352 (objfile
->static_psymbols
.list
+ pst
->statics_offset
);
3353 sort_pst_symbols (pst
);
3355 info_ptr
= (beg_of_comp_unit
+ cu
.header
.length
3356 + cu
.header
.initial_length_size
);
3358 if (this_cu
->from_debug_types
)
3360 /* It's not clear we want to do anything with stmt lists here.
3361 Waiting to see what gcc ultimately does. */
3365 /* Get the list of files included in the current compilation unit,
3366 and build a psymtab for each of them. */
3367 dwarf2_build_include_psymtabs (&cu
, comp_unit_die
, pst
);
3370 do_cleanups (back_to_inner
);
3375 /* Traversal function for htab_traverse_noresize.
3376 Process one .debug_types comp-unit. */
3379 process_type_comp_unit (void **slot
, void *info
)
3381 struct signatured_type
*entry
= (struct signatured_type
*) *slot
;
3382 struct objfile
*objfile
= (struct objfile
*) info
;
3383 struct dwarf2_per_cu_data
*this_cu
;
3385 this_cu
= &entry
->per_cu
;
3387 gdb_assert (dwarf2_per_objfile
->types
.readin
);
3388 process_psymtab_comp_unit (objfile
, this_cu
,
3389 dwarf2_per_objfile
->types
.buffer
,
3390 dwarf2_per_objfile
->types
.buffer
+ entry
->offset
,
3391 dwarf2_per_objfile
->types
.size
);
3396 /* Subroutine of dwarf2_build_psymtabs_hard to simplify it.
3397 Build partial symbol tables for the .debug_types comp-units. */
3400 build_type_psymtabs (struct objfile
*objfile
)
3402 if (! create_debug_types_hash_table (objfile
))
3405 htab_traverse_noresize (dwarf2_per_objfile
->signatured_types
,
3406 process_type_comp_unit
, objfile
);
3409 /* A cleanup function that clears objfile's psymtabs_addrmap field. */
3412 psymtabs_addrmap_cleanup (void *o
)
3414 struct objfile
*objfile
= o
;
3416 objfile
->psymtabs_addrmap
= NULL
;
3419 /* Build the partial symbol table by doing a quick pass through the
3420 .debug_info and .debug_abbrev sections. */
3423 dwarf2_build_psymtabs_hard (struct objfile
*objfile
)
3426 struct cleanup
*back_to
, *addrmap_cleanup
;
3427 struct obstack temp_obstack
;
3429 dwarf2_per_objfile
->reading_partial_symbols
= 1;
3431 dwarf2_read_section (objfile
, &dwarf2_per_objfile
->info
);
3432 info_ptr
= dwarf2_per_objfile
->info
.buffer
;
3434 /* Any cached compilation units will be linked by the per-objfile
3435 read_in_chain. Make sure to free them when we're done. */
3436 back_to
= make_cleanup (free_cached_comp_units
, NULL
);
3438 build_type_psymtabs (objfile
);
3440 create_all_comp_units (objfile
);
3442 /* Create a temporary address map on a temporary obstack. We later
3443 copy this to the final obstack. */
3444 obstack_init (&temp_obstack
);
3445 make_cleanup_obstack_free (&temp_obstack
);
3446 objfile
->psymtabs_addrmap
= addrmap_create_mutable (&temp_obstack
);
3447 addrmap_cleanup
= make_cleanup (psymtabs_addrmap_cleanup
, objfile
);
3449 /* Since the objects we're extracting from .debug_info vary in
3450 length, only the individual functions to extract them (like
3451 read_comp_unit_head and load_partial_die) can really know whether
3452 the buffer is large enough to hold another complete object.
3454 At the moment, they don't actually check that. If .debug_info
3455 holds just one extra byte after the last compilation unit's dies,
3456 then read_comp_unit_head will happily read off the end of the
3457 buffer. read_partial_die is similarly casual. Those functions
3460 For this loop condition, simply checking whether there's any data
3461 left at all should be sufficient. */
3463 while (info_ptr
< (dwarf2_per_objfile
->info
.buffer
3464 + dwarf2_per_objfile
->info
.size
))
3466 struct dwarf2_per_cu_data
*this_cu
;
3468 this_cu
= dwarf2_find_comp_unit (info_ptr
3469 - dwarf2_per_objfile
->info
.buffer
,
3472 info_ptr
= process_psymtab_comp_unit (objfile
, this_cu
,
3473 dwarf2_per_objfile
->info
.buffer
,
3475 dwarf2_per_objfile
->info
.size
);
3478 objfile
->psymtabs_addrmap
= addrmap_create_fixed (objfile
->psymtabs_addrmap
,
3479 &objfile
->objfile_obstack
);
3480 discard_cleanups (addrmap_cleanup
);
3482 do_cleanups (back_to
);
3485 /* Load the partial DIEs for a secondary CU into memory. */
3488 load_partial_comp_unit (struct dwarf2_per_cu_data
*this_cu
,
3489 struct objfile
*objfile
)
3491 bfd
*abfd
= objfile
->obfd
;
3492 gdb_byte
*info_ptr
, *beg_of_comp_unit
;
3493 struct die_info
*comp_unit_die
;
3494 struct dwarf2_cu
*cu
;
3495 struct cleanup
*free_abbrevs_cleanup
, *free_cu_cleanup
= NULL
;
3497 struct die_reader_specs reader_specs
;
3500 gdb_assert (! this_cu
->from_debug_types
);
3502 gdb_assert (dwarf2_per_objfile
->info
.readin
);
3503 info_ptr
= dwarf2_per_objfile
->info
.buffer
+ this_cu
->offset
;
3504 beg_of_comp_unit
= info_ptr
;
3506 if (this_cu
->cu
== NULL
)
3508 cu
= xmalloc (sizeof (*cu
));
3509 init_one_comp_unit (cu
, objfile
);
3513 /* If an error occurs while loading, release our storage. */
3514 free_cu_cleanup
= make_cleanup (free_one_comp_unit
, cu
);
3516 info_ptr
= partial_read_comp_unit_head (&cu
->header
, info_ptr
,
3517 dwarf2_per_objfile
->info
.buffer
,
3518 dwarf2_per_objfile
->info
.size
,
3521 /* Complete the cu_header. */
3522 cu
->header
.offset
= this_cu
->offset
;
3523 cu
->header
.first_die_offset
= info_ptr
- beg_of_comp_unit
;
3525 /* Link this compilation unit into the compilation unit tree. */
3527 cu
->per_cu
= this_cu
;
3529 /* Link this CU into read_in_chain. */
3530 this_cu
->cu
->read_in_chain
= dwarf2_per_objfile
->read_in_chain
;
3531 dwarf2_per_objfile
->read_in_chain
= this_cu
;
3536 info_ptr
+= cu
->header
.first_die_offset
;
3539 /* Read the abbrevs for this compilation unit into a table. */
3540 gdb_assert (cu
->dwarf2_abbrevs
== NULL
);
3541 dwarf2_read_abbrevs (abfd
, cu
);
3542 free_abbrevs_cleanup
= make_cleanup (dwarf2_free_abbrev_table
, cu
);
3544 /* Read the compilation unit die. */
3545 init_cu_die_reader (&reader_specs
, cu
);
3546 info_ptr
= read_full_die (&reader_specs
, &comp_unit_die
, info_ptr
,
3549 prepare_one_comp_unit (cu
, comp_unit_die
);
3551 /* Check if comp unit has_children.
3552 If so, read the rest of the partial symbols from this comp unit.
3553 If not, there's no more debug_info for this comp unit. */
3555 load_partial_dies (abfd
, dwarf2_per_objfile
->info
.buffer
, info_ptr
, 0, cu
);
3557 do_cleanups (free_abbrevs_cleanup
);
3561 /* We've successfully allocated this compilation unit. Let our
3562 caller clean it up when finished with it. */
3563 discard_cleanups (free_cu_cleanup
);
3567 /* Create a list of all compilation units in OBJFILE. We do this only
3568 if an inter-comp-unit reference is found; presumably if there is one,
3569 there will be many, and one will occur early in the .debug_info section.
3570 So there's no point in building this list incrementally. */
3573 create_all_comp_units (struct objfile
*objfile
)
3577 struct dwarf2_per_cu_data
**all_comp_units
;
3580 dwarf2_read_section (objfile
, &dwarf2_per_objfile
->info
);
3581 info_ptr
= dwarf2_per_objfile
->info
.buffer
;
3585 all_comp_units
= xmalloc (n_allocated
3586 * sizeof (struct dwarf2_per_cu_data
*));
3588 while (info_ptr
< dwarf2_per_objfile
->info
.buffer
3589 + dwarf2_per_objfile
->info
.size
)
3591 unsigned int length
, initial_length_size
;
3592 struct dwarf2_per_cu_data
*this_cu
;
3593 unsigned int offset
;
3595 offset
= info_ptr
- dwarf2_per_objfile
->info
.buffer
;
3597 /* Read just enough information to find out where the next
3598 compilation unit is. */
3599 length
= read_initial_length (objfile
->obfd
, info_ptr
,
3600 &initial_length_size
);
3602 /* Save the compilation unit for later lookup. */
3603 this_cu
= obstack_alloc (&objfile
->objfile_obstack
,
3604 sizeof (struct dwarf2_per_cu_data
));
3605 memset (this_cu
, 0, sizeof (*this_cu
));
3606 this_cu
->offset
= offset
;
3607 this_cu
->length
= length
+ initial_length_size
;
3608 this_cu
->objfile
= objfile
;
3610 if (n_comp_units
== n_allocated
)
3613 all_comp_units
= xrealloc (all_comp_units
,
3615 * sizeof (struct dwarf2_per_cu_data
*));
3617 all_comp_units
[n_comp_units
++] = this_cu
;
3619 info_ptr
= info_ptr
+ this_cu
->length
;
3622 dwarf2_per_objfile
->all_comp_units
3623 = obstack_alloc (&objfile
->objfile_obstack
,
3624 n_comp_units
* sizeof (struct dwarf2_per_cu_data
*));
3625 memcpy (dwarf2_per_objfile
->all_comp_units
, all_comp_units
,
3626 n_comp_units
* sizeof (struct dwarf2_per_cu_data
*));
3627 xfree (all_comp_units
);
3628 dwarf2_per_objfile
->n_comp_units
= n_comp_units
;
3631 /* Process all loaded DIEs for compilation unit CU, starting at
3632 FIRST_DIE. The caller should pass NEED_PC == 1 if the compilation
3633 unit DIE did not have PC info (DW_AT_low_pc and DW_AT_high_pc, or
3634 DW_AT_ranges). If NEED_PC is set, then this function will set
3635 *LOWPC and *HIGHPC to the lowest and highest PC values found in CU
3636 and record the covered ranges in the addrmap. */
3639 scan_partial_symbols (struct partial_die_info
*first_die
, CORE_ADDR
*lowpc
,
3640 CORE_ADDR
*highpc
, int need_pc
, struct dwarf2_cu
*cu
)
3642 struct partial_die_info
*pdi
;
3644 /* Now, march along the PDI's, descending into ones which have
3645 interesting children but skipping the children of the other ones,
3646 until we reach the end of the compilation unit. */
3652 fixup_partial_die (pdi
, cu
);
3654 /* Anonymous namespaces or modules have no name but have interesting
3655 children, so we need to look at them. Ditto for anonymous
3658 if (pdi
->name
!= NULL
|| pdi
->tag
== DW_TAG_namespace
3659 || pdi
->tag
== DW_TAG_module
|| pdi
->tag
== DW_TAG_enumeration_type
)
3663 case DW_TAG_subprogram
:
3664 add_partial_subprogram (pdi
, lowpc
, highpc
, need_pc
, cu
);
3666 case DW_TAG_constant
:
3667 case DW_TAG_variable
:
3668 case DW_TAG_typedef
:
3669 case DW_TAG_union_type
:
3670 if (!pdi
->is_declaration
)
3672 add_partial_symbol (pdi
, cu
);
3675 case DW_TAG_class_type
:
3676 case DW_TAG_interface_type
:
3677 case DW_TAG_structure_type
:
3678 if (!pdi
->is_declaration
)
3680 add_partial_symbol (pdi
, cu
);
3683 case DW_TAG_enumeration_type
:
3684 if (!pdi
->is_declaration
)
3685 add_partial_enumeration (pdi
, cu
);
3687 case DW_TAG_base_type
:
3688 case DW_TAG_subrange_type
:
3689 /* File scope base type definitions are added to the partial
3691 add_partial_symbol (pdi
, cu
);
3693 case DW_TAG_namespace
:
3694 add_partial_namespace (pdi
, lowpc
, highpc
, need_pc
, cu
);
3697 add_partial_module (pdi
, lowpc
, highpc
, need_pc
, cu
);
3704 /* If the die has a sibling, skip to the sibling. */
3706 pdi
= pdi
->die_sibling
;
3710 /* Functions used to compute the fully scoped name of a partial DIE.
3712 Normally, this is simple. For C++, the parent DIE's fully scoped
3713 name is concatenated with "::" and the partial DIE's name. For
3714 Java, the same thing occurs except that "." is used instead of "::".
3715 Enumerators are an exception; they use the scope of their parent
3716 enumeration type, i.e. the name of the enumeration type is not
3717 prepended to the enumerator.
3719 There are two complexities. One is DW_AT_specification; in this
3720 case "parent" means the parent of the target of the specification,
3721 instead of the direct parent of the DIE. The other is compilers
3722 which do not emit DW_TAG_namespace; in this case we try to guess
3723 the fully qualified name of structure types from their members'
3724 linkage names. This must be done using the DIE's children rather
3725 than the children of any DW_AT_specification target. We only need
3726 to do this for structures at the top level, i.e. if the target of
3727 any DW_AT_specification (if any; otherwise the DIE itself) does not
3730 /* Compute the scope prefix associated with PDI's parent, in
3731 compilation unit CU. The result will be allocated on CU's
3732 comp_unit_obstack, or a copy of the already allocated PDI->NAME
3733 field. NULL is returned if no prefix is necessary. */
3735 partial_die_parent_scope (struct partial_die_info
*pdi
,
3736 struct dwarf2_cu
*cu
)
3738 char *grandparent_scope
;
3739 struct partial_die_info
*parent
, *real_pdi
;
3741 /* We need to look at our parent DIE; if we have a DW_AT_specification,
3742 then this means the parent of the specification DIE. */
3745 while (real_pdi
->has_specification
)
3746 real_pdi
= find_partial_die (real_pdi
->spec_offset
, cu
);
3748 parent
= real_pdi
->die_parent
;
3752 if (parent
->scope_set
)
3753 return parent
->scope
;
3755 fixup_partial_die (parent
, cu
);
3757 grandparent_scope
= partial_die_parent_scope (parent
, cu
);
3759 /* GCC 4.0 and 4.1 had a bug (PR c++/28460) where they generated bogus
3760 DW_TAG_namespace DIEs with a name of "::" for the global namespace.
3761 Work around this problem here. */
3762 if (cu
->language
== language_cplus
3763 && parent
->tag
== DW_TAG_namespace
3764 && strcmp (parent
->name
, "::") == 0
3765 && grandparent_scope
== NULL
)
3767 parent
->scope
= NULL
;
3768 parent
->scope_set
= 1;
3772 if (parent
->tag
== DW_TAG_namespace
3773 || parent
->tag
== DW_TAG_module
3774 || parent
->tag
== DW_TAG_structure_type
3775 || parent
->tag
== DW_TAG_class_type
3776 || parent
->tag
== DW_TAG_interface_type
3777 || parent
->tag
== DW_TAG_union_type
3778 || parent
->tag
== DW_TAG_enumeration_type
)
3780 if (grandparent_scope
== NULL
)
3781 parent
->scope
= parent
->name
;
3783 parent
->scope
= typename_concat (&cu
->comp_unit_obstack
,
3785 parent
->name
, 0, cu
);
3787 else if (parent
->tag
== DW_TAG_enumerator
)
3788 /* Enumerators should not get the name of the enumeration as a prefix. */
3789 parent
->scope
= grandparent_scope
;
3792 /* FIXME drow/2004-04-01: What should we be doing with
3793 function-local names? For partial symbols, we should probably be
3795 complaint (&symfile_complaints
,
3796 _("unhandled containing DIE tag %d for DIE at %d"),
3797 parent
->tag
, pdi
->offset
);
3798 parent
->scope
= grandparent_scope
;
3801 parent
->scope_set
= 1;
3802 return parent
->scope
;
3805 /* Return the fully scoped name associated with PDI, from compilation unit
3806 CU. The result will be allocated with malloc. */
3808 partial_die_full_name (struct partial_die_info
*pdi
,
3809 struct dwarf2_cu
*cu
)
3813 /* If this is a template instantiation, we can not work out the
3814 template arguments from partial DIEs. So, unfortunately, we have
3815 to go through the full DIEs. At least any work we do building
3816 types here will be reused if full symbols are loaded later. */
3817 if (pdi
->has_template_arguments
)
3819 fixup_partial_die (pdi
, cu
);
3821 if (pdi
->name
!= NULL
&& strchr (pdi
->name
, '<') == NULL
)
3823 struct die_info
*die
;
3824 struct attribute attr
;
3825 struct dwarf2_cu
*ref_cu
= cu
;
3828 attr
.form
= DW_FORM_ref_addr
;
3829 attr
.u
.addr
= pdi
->offset
;
3830 die
= follow_die_ref (NULL
, &attr
, &ref_cu
);
3832 return xstrdup (dwarf2_full_name (NULL
, die
, ref_cu
));
3836 parent_scope
= partial_die_parent_scope (pdi
, cu
);
3837 if (parent_scope
== NULL
)
3840 return typename_concat (NULL
, parent_scope
, pdi
->name
, 0, cu
);
3844 add_partial_symbol (struct partial_die_info
*pdi
, struct dwarf2_cu
*cu
)
3846 struct objfile
*objfile
= cu
->objfile
;
3848 char *actual_name
= NULL
;
3849 const struct partial_symbol
*psym
= NULL
;
3851 int built_actual_name
= 0;
3853 baseaddr
= ANOFFSET (objfile
->section_offsets
, SECT_OFF_TEXT (objfile
));
3855 actual_name
= partial_die_full_name (pdi
, cu
);
3857 built_actual_name
= 1;
3859 if (actual_name
== NULL
)
3860 actual_name
= pdi
->name
;
3864 case DW_TAG_subprogram
:
3865 if (pdi
->is_external
|| cu
->language
== language_ada
)
3867 /* brobecker/2007-12-26: Normally, only "external" DIEs are part
3868 of the global scope. But in Ada, we want to be able to access
3869 nested procedures globally. So all Ada subprograms are stored
3870 in the global scope. */
3871 /* prim_record_minimal_symbol (actual_name, pdi->lowpc + baseaddr,
3872 mst_text, objfile); */
3873 add_psymbol_to_list (actual_name
, strlen (actual_name
),
3875 VAR_DOMAIN
, LOC_BLOCK
,
3876 &objfile
->global_psymbols
,
3877 0, pdi
->lowpc
+ baseaddr
,
3878 cu
->language
, objfile
);
3882 /* prim_record_minimal_symbol (actual_name, pdi->lowpc + baseaddr,
3883 mst_file_text, objfile); */
3884 add_psymbol_to_list (actual_name
, strlen (actual_name
),
3886 VAR_DOMAIN
, LOC_BLOCK
,
3887 &objfile
->static_psymbols
,
3888 0, pdi
->lowpc
+ baseaddr
,
3889 cu
->language
, objfile
);
3892 case DW_TAG_constant
:
3894 struct psymbol_allocation_list
*list
;
3896 if (pdi
->is_external
)
3897 list
= &objfile
->global_psymbols
;
3899 list
= &objfile
->static_psymbols
;
3900 add_psymbol_to_list (actual_name
, strlen (actual_name
),
3901 built_actual_name
, VAR_DOMAIN
, LOC_STATIC
,
3902 list
, 0, 0, cu
->language
, objfile
);
3905 case DW_TAG_variable
:
3907 addr
= decode_locdesc (pdi
->locdesc
, cu
);
3911 && !dwarf2_per_objfile
->has_section_at_zero
)
3913 /* A global or static variable may also have been stripped
3914 out by the linker if unused, in which case its address
3915 will be nullified; do not add such variables into partial
3916 symbol table then. */
3918 else if (pdi
->is_external
)
3921 Don't enter into the minimal symbol tables as there is
3922 a minimal symbol table entry from the ELF symbols already.
3923 Enter into partial symbol table if it has a location
3924 descriptor or a type.
3925 If the location descriptor is missing, new_symbol will create
3926 a LOC_UNRESOLVED symbol, the address of the variable will then
3927 be determined from the minimal symbol table whenever the variable
3929 The address for the partial symbol table entry is not
3930 used by GDB, but it comes in handy for debugging partial symbol
3933 if (pdi
->locdesc
|| pdi
->has_type
)
3934 add_psymbol_to_list (actual_name
, strlen (actual_name
),
3936 VAR_DOMAIN
, LOC_STATIC
,
3937 &objfile
->global_psymbols
,
3939 cu
->language
, objfile
);
3943 /* Static Variable. Skip symbols without location descriptors. */
3944 if (pdi
->locdesc
== NULL
)
3946 if (built_actual_name
)
3947 xfree (actual_name
);
3950 /* prim_record_minimal_symbol (actual_name, addr + baseaddr,
3951 mst_file_data, objfile); */
3952 add_psymbol_to_list (actual_name
, strlen (actual_name
),
3954 VAR_DOMAIN
, LOC_STATIC
,
3955 &objfile
->static_psymbols
,
3957 cu
->language
, objfile
);
3960 case DW_TAG_typedef
:
3961 case DW_TAG_base_type
:
3962 case DW_TAG_subrange_type
:
3963 add_psymbol_to_list (actual_name
, strlen (actual_name
),
3965 VAR_DOMAIN
, LOC_TYPEDEF
,
3966 &objfile
->static_psymbols
,
3967 0, (CORE_ADDR
) 0, cu
->language
, objfile
);
3969 case DW_TAG_namespace
:
3970 add_psymbol_to_list (actual_name
, strlen (actual_name
),
3972 VAR_DOMAIN
, LOC_TYPEDEF
,
3973 &objfile
->global_psymbols
,
3974 0, (CORE_ADDR
) 0, cu
->language
, objfile
);
3976 case DW_TAG_class_type
:
3977 case DW_TAG_interface_type
:
3978 case DW_TAG_structure_type
:
3979 case DW_TAG_union_type
:
3980 case DW_TAG_enumeration_type
:
3981 /* Skip external references. The DWARF standard says in the section
3982 about "Structure, Union, and Class Type Entries": "An incomplete
3983 structure, union or class type is represented by a structure,
3984 union or class entry that does not have a byte size attribute
3985 and that has a DW_AT_declaration attribute." */
3986 if (!pdi
->has_byte_size
&& pdi
->is_declaration
)
3988 if (built_actual_name
)
3989 xfree (actual_name
);
3993 /* NOTE: carlton/2003-10-07: See comment in new_symbol about
3994 static vs. global. */
3995 add_psymbol_to_list (actual_name
, strlen (actual_name
),
3997 STRUCT_DOMAIN
, LOC_TYPEDEF
,
3998 (cu
->language
== language_cplus
3999 || cu
->language
== language_java
)
4000 ? &objfile
->global_psymbols
4001 : &objfile
->static_psymbols
,
4002 0, (CORE_ADDR
) 0, cu
->language
, objfile
);
4005 case DW_TAG_enumerator
:
4006 add_psymbol_to_list (actual_name
, strlen (actual_name
),
4008 VAR_DOMAIN
, LOC_CONST
,
4009 (cu
->language
== language_cplus
4010 || cu
->language
== language_java
)
4011 ? &objfile
->global_psymbols
4012 : &objfile
->static_psymbols
,
4013 0, (CORE_ADDR
) 0, cu
->language
, objfile
);
4019 if (built_actual_name
)
4020 xfree (actual_name
);
4023 /* Read a partial die corresponding to a namespace; also, add a symbol
4024 corresponding to that namespace to the symbol table. NAMESPACE is
4025 the name of the enclosing namespace. */
4028 add_partial_namespace (struct partial_die_info
*pdi
,
4029 CORE_ADDR
*lowpc
, CORE_ADDR
*highpc
,
4030 int need_pc
, struct dwarf2_cu
*cu
)
4032 /* Add a symbol for the namespace. */
4034 add_partial_symbol (pdi
, cu
);
4036 /* Now scan partial symbols in that namespace. */
4038 if (pdi
->has_children
)
4039 scan_partial_symbols (pdi
->die_child
, lowpc
, highpc
, need_pc
, cu
);
4042 /* Read a partial die corresponding to a Fortran module. */
4045 add_partial_module (struct partial_die_info
*pdi
, CORE_ADDR
*lowpc
,
4046 CORE_ADDR
*highpc
, int need_pc
, struct dwarf2_cu
*cu
)
4048 /* Now scan partial symbols in that module. */
4050 if (pdi
->has_children
)
4051 scan_partial_symbols (pdi
->die_child
, lowpc
, highpc
, need_pc
, cu
);
4054 /* Read a partial die corresponding to a subprogram and create a partial
4055 symbol for that subprogram. When the CU language allows it, this
4056 routine also defines a partial symbol for each nested subprogram
4057 that this subprogram contains.
4059 DIE my also be a lexical block, in which case we simply search
4060 recursively for suprograms defined inside that lexical block.
4061 Again, this is only performed when the CU language allows this
4062 type of definitions. */
4065 add_partial_subprogram (struct partial_die_info
*pdi
,
4066 CORE_ADDR
*lowpc
, CORE_ADDR
*highpc
,
4067 int need_pc
, struct dwarf2_cu
*cu
)
4069 if (pdi
->tag
== DW_TAG_subprogram
)
4071 if (pdi
->has_pc_info
)
4073 if (pdi
->lowpc
< *lowpc
)
4074 *lowpc
= pdi
->lowpc
;
4075 if (pdi
->highpc
> *highpc
)
4076 *highpc
= pdi
->highpc
;
4080 struct objfile
*objfile
= cu
->objfile
;
4082 baseaddr
= ANOFFSET (objfile
->section_offsets
,
4083 SECT_OFF_TEXT (objfile
));
4084 addrmap_set_empty (objfile
->psymtabs_addrmap
,
4085 pdi
->lowpc
+ baseaddr
,
4086 pdi
->highpc
- 1 + baseaddr
,
4087 cu
->per_cu
->v
.psymtab
);
4089 if (!pdi
->is_declaration
)
4090 /* Ignore subprogram DIEs that do not have a name, they are
4091 illegal. Do not emit a complaint at this point, we will
4092 do so when we convert this psymtab into a symtab. */
4094 add_partial_symbol (pdi
, cu
);
4098 if (! pdi
->has_children
)
4101 if (cu
->language
== language_ada
)
4103 pdi
= pdi
->die_child
;
4106 fixup_partial_die (pdi
, cu
);
4107 if (pdi
->tag
== DW_TAG_subprogram
4108 || pdi
->tag
== DW_TAG_lexical_block
)
4109 add_partial_subprogram (pdi
, lowpc
, highpc
, need_pc
, cu
);
4110 pdi
= pdi
->die_sibling
;
4115 /* Read a partial die corresponding to an enumeration type. */
4118 add_partial_enumeration (struct partial_die_info
*enum_pdi
,
4119 struct dwarf2_cu
*cu
)
4121 struct partial_die_info
*pdi
;
4123 if (enum_pdi
->name
!= NULL
)
4124 add_partial_symbol (enum_pdi
, cu
);
4126 pdi
= enum_pdi
->die_child
;
4129 if (pdi
->tag
!= DW_TAG_enumerator
|| pdi
->name
== NULL
)
4130 complaint (&symfile_complaints
, _("malformed enumerator DIE ignored"));
4132 add_partial_symbol (pdi
, cu
);
4133 pdi
= pdi
->die_sibling
;
4137 /* Read the initial uleb128 in the die at INFO_PTR in compilation unit CU.
4138 Return the corresponding abbrev, or NULL if the number is zero (indicating
4139 an empty DIE). In either case *BYTES_READ will be set to the length of
4140 the initial number. */
4142 static struct abbrev_info
*
4143 peek_die_abbrev (gdb_byte
*info_ptr
, unsigned int *bytes_read
,
4144 struct dwarf2_cu
*cu
)
4146 bfd
*abfd
= cu
->objfile
->obfd
;
4147 unsigned int abbrev_number
;
4148 struct abbrev_info
*abbrev
;
4150 abbrev_number
= read_unsigned_leb128 (abfd
, info_ptr
, bytes_read
);
4152 if (abbrev_number
== 0)
4155 abbrev
= dwarf2_lookup_abbrev (abbrev_number
, cu
);
4158 error (_("Dwarf Error: Could not find abbrev number %d [in module %s]"),
4159 abbrev_number
, bfd_get_filename (abfd
));
4165 /* Scan the debug information for CU starting at INFO_PTR in buffer BUFFER.
4166 Returns a pointer to the end of a series of DIEs, terminated by an empty
4167 DIE. Any children of the skipped DIEs will also be skipped. */
4170 skip_children (gdb_byte
*buffer
, gdb_byte
*info_ptr
, struct dwarf2_cu
*cu
)
4172 struct abbrev_info
*abbrev
;
4173 unsigned int bytes_read
;
4177 abbrev
= peek_die_abbrev (info_ptr
, &bytes_read
, cu
);
4179 return info_ptr
+ bytes_read
;
4181 info_ptr
= skip_one_die (buffer
, info_ptr
+ bytes_read
, abbrev
, cu
);
4185 /* Scan the debug information for CU starting at INFO_PTR in buffer BUFFER.
4186 INFO_PTR should point just after the initial uleb128 of a DIE, and the
4187 abbrev corresponding to that skipped uleb128 should be passed in
4188 ABBREV. Returns a pointer to this DIE's sibling, skipping any
4192 skip_one_die (gdb_byte
*buffer
, gdb_byte
*info_ptr
,
4193 struct abbrev_info
*abbrev
, struct dwarf2_cu
*cu
)
4195 unsigned int bytes_read
;
4196 struct attribute attr
;
4197 bfd
*abfd
= cu
->objfile
->obfd
;
4198 unsigned int form
, i
;
4200 for (i
= 0; i
< abbrev
->num_attrs
; i
++)
4202 /* The only abbrev we care about is DW_AT_sibling. */
4203 if (abbrev
->attrs
[i
].name
== DW_AT_sibling
)
4205 read_attribute (&attr
, &abbrev
->attrs
[i
],
4206 abfd
, info_ptr
, cu
);
4207 if (attr
.form
== DW_FORM_ref_addr
)
4208 complaint (&symfile_complaints
,
4209 _("ignoring absolute DW_AT_sibling"));
4211 return buffer
+ dwarf2_get_ref_die_offset (&attr
);
4214 /* If it isn't DW_AT_sibling, skip this attribute. */
4215 form
= abbrev
->attrs
[i
].form
;
4219 case DW_FORM_ref_addr
:
4220 /* In DWARF 2, DW_FORM_ref_addr is address sized; in DWARF 3
4221 and later it is offset sized. */
4222 if (cu
->header
.version
== 2)
4223 info_ptr
+= cu
->header
.addr_size
;
4225 info_ptr
+= cu
->header
.offset_size
;
4228 info_ptr
+= cu
->header
.addr_size
;
4235 case DW_FORM_flag_present
:
4247 case DW_FORM_ref_sig8
:
4250 case DW_FORM_string
:
4251 read_direct_string (abfd
, info_ptr
, &bytes_read
);
4252 info_ptr
+= bytes_read
;
4254 case DW_FORM_sec_offset
:
4256 info_ptr
+= cu
->header
.offset_size
;
4258 case DW_FORM_exprloc
:
4260 info_ptr
+= read_unsigned_leb128 (abfd
, info_ptr
, &bytes_read
);
4261 info_ptr
+= bytes_read
;
4263 case DW_FORM_block1
:
4264 info_ptr
+= 1 + read_1_byte (abfd
, info_ptr
);
4266 case DW_FORM_block2
:
4267 info_ptr
+= 2 + read_2_bytes (abfd
, info_ptr
);
4269 case DW_FORM_block4
:
4270 info_ptr
+= 4 + read_4_bytes (abfd
, info_ptr
);
4274 case DW_FORM_ref_udata
:
4275 info_ptr
= skip_leb128 (abfd
, info_ptr
);
4277 case DW_FORM_indirect
:
4278 form
= read_unsigned_leb128 (abfd
, info_ptr
, &bytes_read
);
4279 info_ptr
+= bytes_read
;
4280 /* We need to continue parsing from here, so just go back to
4282 goto skip_attribute
;
4285 error (_("Dwarf Error: Cannot handle %s "
4286 "in DWARF reader [in module %s]"),
4287 dwarf_form_name (form
),
4288 bfd_get_filename (abfd
));
4292 if (abbrev
->has_children
)
4293 return skip_children (buffer
, info_ptr
, cu
);
4298 /* Locate ORIG_PDI's sibling.
4299 INFO_PTR should point to the start of the next DIE after ORIG_PDI
4303 locate_pdi_sibling (struct partial_die_info
*orig_pdi
,
4304 gdb_byte
*buffer
, gdb_byte
*info_ptr
,
4305 bfd
*abfd
, struct dwarf2_cu
*cu
)
4307 /* Do we know the sibling already? */
4309 if (orig_pdi
->sibling
)
4310 return orig_pdi
->sibling
;
4312 /* Are there any children to deal with? */
4314 if (!orig_pdi
->has_children
)
4317 /* Skip the children the long way. */
4319 return skip_children (buffer
, info_ptr
, cu
);
4322 /* Expand this partial symbol table into a full symbol table. */
4325 dwarf2_psymtab_to_symtab (struct partial_symtab
*pst
)
4331 warning (_("bug: psymtab for %s is already read in."),
4338 printf_filtered (_("Reading in symbols for %s..."),
4340 gdb_flush (gdb_stdout
);
4343 /* Restore our global data. */
4344 dwarf2_per_objfile
= objfile_data (pst
->objfile
,
4345 dwarf2_objfile_data_key
);
4347 /* If this psymtab is constructed from a debug-only objfile, the
4348 has_section_at_zero flag will not necessarily be correct. We
4349 can get the correct value for this flag by looking at the data
4350 associated with the (presumably stripped) associated objfile. */
4351 if (pst
->objfile
->separate_debug_objfile_backlink
)
4353 struct dwarf2_per_objfile
*dpo_backlink
4354 = objfile_data (pst
->objfile
->separate_debug_objfile_backlink
,
4355 dwarf2_objfile_data_key
);
4357 dwarf2_per_objfile
->has_section_at_zero
4358 = dpo_backlink
->has_section_at_zero
;
4361 dwarf2_per_objfile
->reading_partial_symbols
= 0;
4363 psymtab_to_symtab_1 (pst
);
4365 /* Finish up the debug error message. */
4367 printf_filtered (_("done.\n"));
4372 /* Add PER_CU to the queue. */
4375 queue_comp_unit (struct dwarf2_per_cu_data
*per_cu
, struct objfile
*objfile
)
4377 struct dwarf2_queue_item
*item
;
4380 item
= xmalloc (sizeof (*item
));
4381 item
->per_cu
= per_cu
;
4384 if (dwarf2_queue
== NULL
)
4385 dwarf2_queue
= item
;
4387 dwarf2_queue_tail
->next
= item
;
4389 dwarf2_queue_tail
= item
;
4392 /* Process the queue. */
4395 process_queue (struct objfile
*objfile
)
4397 struct dwarf2_queue_item
*item
, *next_item
;
4399 /* The queue starts out with one item, but following a DIE reference
4400 may load a new CU, adding it to the end of the queue. */
4401 for (item
= dwarf2_queue
; item
!= NULL
; dwarf2_queue
= item
= next_item
)
4403 if (dwarf2_per_objfile
->using_index
4404 ? !item
->per_cu
->v
.quick
->symtab
4405 : (item
->per_cu
->v
.psymtab
&& !item
->per_cu
->v
.psymtab
->readin
))
4406 process_full_comp_unit (item
->per_cu
);
4408 item
->per_cu
->queued
= 0;
4409 next_item
= item
->next
;
4413 dwarf2_queue_tail
= NULL
;
4416 /* Free all allocated queue entries. This function only releases anything if
4417 an error was thrown; if the queue was processed then it would have been
4418 freed as we went along. */
4421 dwarf2_release_queue (void *dummy
)
4423 struct dwarf2_queue_item
*item
, *last
;
4425 item
= dwarf2_queue
;
4428 /* Anything still marked queued is likely to be in an
4429 inconsistent state, so discard it. */
4430 if (item
->per_cu
->queued
)
4432 if (item
->per_cu
->cu
!= NULL
)
4433 free_one_cached_comp_unit (item
->per_cu
->cu
);
4434 item
->per_cu
->queued
= 0;
4442 dwarf2_queue
= dwarf2_queue_tail
= NULL
;
4445 /* Read in full symbols for PST, and anything it depends on. */
4448 psymtab_to_symtab_1 (struct partial_symtab
*pst
)
4450 struct dwarf2_per_cu_data
*per_cu
;
4451 struct cleanup
*back_to
;
4454 for (i
= 0; i
< pst
->number_of_dependencies
; i
++)
4455 if (!pst
->dependencies
[i
]->readin
)
4457 /* Inform about additional files that need to be read in. */
4460 /* FIXME: i18n: Need to make this a single string. */
4461 fputs_filtered (" ", gdb_stdout
);
4463 fputs_filtered ("and ", gdb_stdout
);
4465 printf_filtered ("%s...", pst
->dependencies
[i
]->filename
);
4466 wrap_here (""); /* Flush output. */
4467 gdb_flush (gdb_stdout
);
4469 psymtab_to_symtab_1 (pst
->dependencies
[i
]);
4472 per_cu
= pst
->read_symtab_private
;
4476 /* It's an include file, no symbols to read for it.
4477 Everything is in the parent symtab. */
4482 dw2_do_instantiate_symtab (pst
->objfile
, per_cu
);
4485 /* Load the DIEs associated with PER_CU into memory. */
4488 load_full_comp_unit (struct dwarf2_per_cu_data
*per_cu
,
4489 struct objfile
*objfile
)
4491 bfd
*abfd
= objfile
->obfd
;
4492 struct dwarf2_cu
*cu
;
4493 unsigned int offset
;
4494 gdb_byte
*info_ptr
, *beg_of_comp_unit
;
4495 struct cleanup
*free_abbrevs_cleanup
= NULL
, *free_cu_cleanup
= NULL
;
4496 struct attribute
*attr
;
4499 gdb_assert (! per_cu
->from_debug_types
);
4501 /* Set local variables from the partial symbol table info. */
4502 offset
= per_cu
->offset
;
4504 dwarf2_read_section (objfile
, &dwarf2_per_objfile
->info
);
4505 info_ptr
= dwarf2_per_objfile
->info
.buffer
+ offset
;
4506 beg_of_comp_unit
= info_ptr
;
4508 if (per_cu
->cu
== NULL
)
4510 cu
= xmalloc (sizeof (*cu
));
4511 init_one_comp_unit (cu
, objfile
);
4515 /* If an error occurs while loading, release our storage. */
4516 free_cu_cleanup
= make_cleanup (free_one_comp_unit
, cu
);
4518 /* Read in the comp_unit header. */
4519 info_ptr
= read_comp_unit_head (&cu
->header
, info_ptr
, abfd
);
4521 /* Complete the cu_header. */
4522 cu
->header
.offset
= offset
;
4523 cu
->header
.first_die_offset
= info_ptr
- beg_of_comp_unit
;
4525 /* Read the abbrevs for this compilation unit. */
4526 dwarf2_read_abbrevs (abfd
, cu
);
4527 free_abbrevs_cleanup
= make_cleanup (dwarf2_free_abbrev_table
, cu
);
4529 /* Link this compilation unit into the compilation unit tree. */
4531 cu
->per_cu
= per_cu
;
4533 /* Link this CU into read_in_chain. */
4534 per_cu
->cu
->read_in_chain
= dwarf2_per_objfile
->read_in_chain
;
4535 dwarf2_per_objfile
->read_in_chain
= per_cu
;
4540 info_ptr
+= cu
->header
.first_die_offset
;
4543 cu
->dies
= read_comp_unit (info_ptr
, cu
);
4545 /* We try not to read any attributes in this function, because not
4546 all objfiles needed for references have been loaded yet, and symbol
4547 table processing isn't initialized. But we have to set the CU language,
4548 or we won't be able to build types correctly. */
4549 prepare_one_comp_unit (cu
, cu
->dies
);
4551 /* Similarly, if we do not read the producer, we can not apply
4552 producer-specific interpretation. */
4553 attr
= dwarf2_attr (cu
->dies
, DW_AT_producer
, cu
);
4555 cu
->producer
= DW_STRING (attr
);
4559 do_cleanups (free_abbrevs_cleanup
);
4561 /* We've successfully allocated this compilation unit. Let our
4562 caller clean it up when finished with it. */
4563 discard_cleanups (free_cu_cleanup
);
4567 /* Add a DIE to the delayed physname list. */
4570 add_to_method_list (struct type
*type
, int fnfield_index
, int index
,
4571 const char *name
, struct die_info
*die
,
4572 struct dwarf2_cu
*cu
)
4574 struct delayed_method_info mi
;
4576 mi
.fnfield_index
= fnfield_index
;
4580 VEC_safe_push (delayed_method_info
, cu
->method_list
, &mi
);
4583 /* A cleanup for freeing the delayed method list. */
4586 free_delayed_list (void *ptr
)
4588 struct dwarf2_cu
*cu
= (struct dwarf2_cu
*) ptr
;
4589 if (cu
->method_list
!= NULL
)
4591 VEC_free (delayed_method_info
, cu
->method_list
);
4592 cu
->method_list
= NULL
;
4596 /* Compute the physnames of any methods on the CU's method list.
4598 The computation of method physnames is delayed in order to avoid the
4599 (bad) condition that one of the method's formal parameters is of an as yet
4603 compute_delayed_physnames (struct dwarf2_cu
*cu
)
4606 struct delayed_method_info
*mi
;
4607 for (i
= 0; VEC_iterate (delayed_method_info
, cu
->method_list
, i
, mi
) ; ++i
)
4610 struct fn_fieldlist
*fn_flp
4611 = &TYPE_FN_FIELDLIST (mi
->type
, mi
->fnfield_index
);
4612 physname
= (char *) dwarf2_physname ((char *) mi
->name
, mi
->die
, cu
);
4613 fn_flp
->fn_fields
[mi
->index
].physname
= physname
? physname
: "";
4617 /* Generate full symbol information for PST and CU, whose DIEs have
4618 already been loaded into memory. */
4621 process_full_comp_unit (struct dwarf2_per_cu_data
*per_cu
)
4623 struct dwarf2_cu
*cu
= per_cu
->cu
;
4624 struct objfile
*objfile
= per_cu
->objfile
;
4625 CORE_ADDR lowpc
, highpc
;
4626 struct symtab
*symtab
;
4627 struct cleanup
*back_to
, *delayed_list_cleanup
;
4630 baseaddr
= ANOFFSET (objfile
->section_offsets
, SECT_OFF_TEXT (objfile
));
4633 back_to
= make_cleanup (really_free_pendings
, NULL
);
4634 delayed_list_cleanup
= make_cleanup (free_delayed_list
, cu
);
4636 cu
->list_in_scope
= &file_symbols
;
4638 dwarf2_find_base_address (cu
->dies
, cu
);
4640 /* Do line number decoding in read_file_scope () */
4641 process_die (cu
->dies
, cu
);
4643 /* Now that we have processed all the DIEs in the CU, all the types
4644 should be complete, and it should now be safe to compute all of the
4646 compute_delayed_physnames (cu
);
4647 do_cleanups (delayed_list_cleanup
);
4649 /* Some compilers don't define a DW_AT_high_pc attribute for the
4650 compilation unit. If the DW_AT_high_pc is missing, synthesize
4651 it, by scanning the DIE's below the compilation unit. */
4652 get_scope_pc_bounds (cu
->dies
, &lowpc
, &highpc
, cu
);
4654 symtab
= end_symtab (highpc
+ baseaddr
, objfile
, SECT_OFF_TEXT (objfile
));
4656 /* Set symtab language to language from DW_AT_language.
4657 If the compilation is from a C file generated by language preprocessors,
4658 do not set the language if it was already deduced by start_subfile. */
4660 && !(cu
->language
== language_c
&& symtab
->language
!= language_c
))
4662 symtab
->language
= cu
->language
;
4665 if (dwarf2_per_objfile
->using_index
)
4666 per_cu
->v
.quick
->symtab
= symtab
;
4669 struct partial_symtab
*pst
= per_cu
->v
.psymtab
;
4670 pst
->symtab
= symtab
;
4674 do_cleanups (back_to
);
4677 /* Process a die and its children. */
4680 process_die (struct die_info
*die
, struct dwarf2_cu
*cu
)
4684 case DW_TAG_padding
:
4686 case DW_TAG_compile_unit
:
4687 read_file_scope (die
, cu
);
4689 case DW_TAG_type_unit
:
4690 read_type_unit_scope (die
, cu
);
4692 case DW_TAG_subprogram
:
4693 case DW_TAG_inlined_subroutine
:
4694 read_func_scope (die
, cu
);
4696 case DW_TAG_lexical_block
:
4697 case DW_TAG_try_block
:
4698 case DW_TAG_catch_block
:
4699 read_lexical_block_scope (die
, cu
);
4701 case DW_TAG_class_type
:
4702 case DW_TAG_interface_type
:
4703 case DW_TAG_structure_type
:
4704 case DW_TAG_union_type
:
4705 process_structure_scope (die
, cu
);
4707 case DW_TAG_enumeration_type
:
4708 process_enumeration_scope (die
, cu
);
4711 /* These dies have a type, but processing them does not create
4712 a symbol or recurse to process the children. Therefore we can
4713 read them on-demand through read_type_die. */
4714 case DW_TAG_subroutine_type
:
4715 case DW_TAG_set_type
:
4716 case DW_TAG_array_type
:
4717 case DW_TAG_pointer_type
:
4718 case DW_TAG_ptr_to_member_type
:
4719 case DW_TAG_reference_type
:
4720 case DW_TAG_string_type
:
4723 case DW_TAG_base_type
:
4724 case DW_TAG_subrange_type
:
4725 case DW_TAG_typedef
:
4726 /* Add a typedef symbol for the type definition, if it has a
4728 new_symbol (die
, read_type_die (die
, cu
), cu
);
4730 case DW_TAG_common_block
:
4731 read_common_block (die
, cu
);
4733 case DW_TAG_common_inclusion
:
4735 case DW_TAG_namespace
:
4736 processing_has_namespace_info
= 1;
4737 read_namespace (die
, cu
);
4740 processing_has_namespace_info
= 1;
4741 read_module (die
, cu
);
4743 case DW_TAG_imported_declaration
:
4744 case DW_TAG_imported_module
:
4745 processing_has_namespace_info
= 1;
4746 if (die
->child
!= NULL
&& (die
->tag
== DW_TAG_imported_declaration
4747 || cu
->language
!= language_fortran
))
4748 complaint (&symfile_complaints
, _("Tag '%s' has unexpected children"),
4749 dwarf_tag_name (die
->tag
));
4750 read_import_statement (die
, cu
);
4753 new_symbol (die
, NULL
, cu
);
4758 /* A helper function for dwarf2_compute_name which determines whether DIE
4759 needs to have the name of the scope prepended to the name listed in the
4763 die_needs_namespace (struct die_info
*die
, struct dwarf2_cu
*cu
)
4765 struct attribute
*attr
;
4769 case DW_TAG_namespace
:
4770 case DW_TAG_typedef
:
4771 case DW_TAG_class_type
:
4772 case DW_TAG_interface_type
:
4773 case DW_TAG_structure_type
:
4774 case DW_TAG_union_type
:
4775 case DW_TAG_enumeration_type
:
4776 case DW_TAG_enumerator
:
4777 case DW_TAG_subprogram
:
4781 case DW_TAG_variable
:
4782 case DW_TAG_constant
:
4783 /* We only need to prefix "globally" visible variables. These include
4784 any variable marked with DW_AT_external or any variable that
4785 lives in a namespace. [Variables in anonymous namespaces
4786 require prefixing, but they are not DW_AT_external.] */
4788 if (dwarf2_attr (die
, DW_AT_specification
, cu
))
4790 struct dwarf2_cu
*spec_cu
= cu
;
4792 return die_needs_namespace (die_specification (die
, &spec_cu
),
4796 attr
= dwarf2_attr (die
, DW_AT_external
, cu
);
4797 if (attr
== NULL
&& die
->parent
->tag
!= DW_TAG_namespace
4798 && die
->parent
->tag
!= DW_TAG_module
)
4800 /* A variable in a lexical block of some kind does not need a
4801 namespace, even though in C++ such variables may be external
4802 and have a mangled name. */
4803 if (die
->parent
->tag
== DW_TAG_lexical_block
4804 || die
->parent
->tag
== DW_TAG_try_block
4805 || die
->parent
->tag
== DW_TAG_catch_block
4806 || die
->parent
->tag
== DW_TAG_subprogram
)
4815 /* Retrieve the last character from a mem_file. */
4818 do_ui_file_peek_last (void *object
, const char *buffer
, long length
)
4820 char *last_char_p
= (char *) object
;
4823 *last_char_p
= buffer
[length
- 1];
4826 /* Compute the fully qualified name of DIE in CU. If PHYSNAME is nonzero,
4827 compute the physname for the object, which include a method's
4828 formal parameters (C++/Java) and return type (Java).
4830 For Ada, return the DIE's linkage name rather than the fully qualified
4831 name. PHYSNAME is ignored..
4833 The result is allocated on the objfile_obstack and canonicalized. */
4836 dwarf2_compute_name (char *name
, struct die_info
*die
, struct dwarf2_cu
*cu
,
4840 name
= dwarf2_name (die
, cu
);
4842 /* For Fortran GDB prefers DW_AT_*linkage_name if present but otherwise
4843 compute it by typename_concat inside GDB. */
4844 if (cu
->language
== language_ada
4845 || (cu
->language
== language_fortran
&& physname
))
4847 /* For Ada unit, we prefer the linkage name over the name, as
4848 the former contains the exported name, which the user expects
4849 to be able to reference. Ideally, we want the user to be able
4850 to reference this entity using either natural or linkage name,
4851 but we haven't started looking at this enhancement yet. */
4852 struct attribute
*attr
;
4854 attr
= dwarf2_attr (die
, DW_AT_linkage_name
, cu
);
4856 attr
= dwarf2_attr (die
, DW_AT_MIPS_linkage_name
, cu
);
4857 if (attr
&& DW_STRING (attr
))
4858 return DW_STRING (attr
);
4861 /* These are the only languages we know how to qualify names in. */
4863 && (cu
->language
== language_cplus
|| cu
->language
== language_java
4864 || cu
->language
== language_fortran
))
4866 if (die_needs_namespace (die
, cu
))
4870 struct ui_file
*buf
;
4872 prefix
= determine_prefix (die
, cu
);
4873 buf
= mem_fileopen ();
4874 if (*prefix
!= '\0')
4876 char *prefixed_name
= typename_concat (NULL
, prefix
, name
,
4879 fputs_unfiltered (prefixed_name
, buf
);
4880 xfree (prefixed_name
);
4883 fputs_unfiltered (name
, buf
);
4885 /* Template parameters may be specified in the DIE's DW_AT_name, or
4886 as children with DW_TAG_template_type_param or
4887 DW_TAG_value_type_param. If the latter, add them to the name
4888 here. If the name already has template parameters, then
4889 skip this step; some versions of GCC emit both, and
4890 it is more efficient to use the pre-computed name.
4892 Something to keep in mind about this process: it is very
4893 unlikely, or in some cases downright impossible, to produce
4894 something that will match the mangled name of a function.
4895 If the definition of the function has the same debug info,
4896 we should be able to match up with it anyway. But fallbacks
4897 using the minimal symbol, for instance to find a method
4898 implemented in a stripped copy of libstdc++, will not work.
4899 If we do not have debug info for the definition, we will have to
4900 match them up some other way.
4902 When we do name matching there is a related problem with function
4903 templates; two instantiated function templates are allowed to
4904 differ only by their return types, which we do not add here. */
4906 if (cu
->language
== language_cplus
&& strchr (name
, '<') == NULL
)
4908 struct attribute
*attr
;
4909 struct die_info
*child
;
4912 die
->building_fullname
= 1;
4914 for (child
= die
->child
; child
!= NULL
; child
= child
->sibling
)
4919 struct dwarf2_locexpr_baton
*baton
;
4922 if (child
->tag
!= DW_TAG_template_type_param
4923 && child
->tag
!= DW_TAG_template_value_param
)
4928 fputs_unfiltered ("<", buf
);
4932 fputs_unfiltered (", ", buf
);
4934 attr
= dwarf2_attr (child
, DW_AT_type
, cu
);
4937 complaint (&symfile_complaints
,
4938 _("template parameter missing DW_AT_type"));
4939 fputs_unfiltered ("UNKNOWN_TYPE", buf
);
4942 type
= die_type (child
, cu
);
4944 if (child
->tag
== DW_TAG_template_type_param
)
4946 c_print_type (type
, "", buf
, -1, 0);
4950 attr
= dwarf2_attr (child
, DW_AT_const_value
, cu
);
4953 complaint (&symfile_complaints
,
4954 _("template parameter missing "
4955 "DW_AT_const_value"));
4956 fputs_unfiltered ("UNKNOWN_VALUE", buf
);
4960 dwarf2_const_value_attr (attr
, type
, name
,
4961 &cu
->comp_unit_obstack
, cu
,
4962 &value
, &bytes
, &baton
);
4964 if (TYPE_NOSIGN (type
))
4965 /* GDB prints characters as NUMBER 'CHAR'. If that's
4966 changed, this can use value_print instead. */
4967 c_printchar (value
, type
, buf
);
4970 struct value_print_options opts
;
4973 v
= dwarf2_evaluate_loc_desc (type
, NULL
,
4977 else if (bytes
!= NULL
)
4979 v
= allocate_value (type
);
4980 memcpy (value_contents_writeable (v
), bytes
,
4981 TYPE_LENGTH (type
));
4984 v
= value_from_longest (type
, value
);
4986 /* Specify decimal so that we do not depend on
4988 get_formatted_print_options (&opts
, 'd');
4990 value_print (v
, buf
, &opts
);
4996 die
->building_fullname
= 0;
5000 /* Close the argument list, with a space if necessary
5001 (nested templates). */
5002 char last_char
= '\0';
5003 ui_file_put (buf
, do_ui_file_peek_last
, &last_char
);
5004 if (last_char
== '>')
5005 fputs_unfiltered (" >", buf
);
5007 fputs_unfiltered (">", buf
);
5011 /* For Java and C++ methods, append formal parameter type
5012 information, if PHYSNAME. */
5014 if (physname
&& die
->tag
== DW_TAG_subprogram
5015 && (cu
->language
== language_cplus
5016 || cu
->language
== language_java
))
5018 struct type
*type
= read_type_die (die
, cu
);
5020 c_type_print_args (type
, buf
, 1, cu
->language
);
5022 if (cu
->language
== language_java
)
5024 /* For java, we must append the return type to method
5026 if (die
->tag
== DW_TAG_subprogram
)
5027 java_print_type (TYPE_TARGET_TYPE (type
), "", buf
,
5030 else if (cu
->language
== language_cplus
)
5032 /* Assume that an artificial first parameter is
5033 "this", but do not crash if it is not. RealView
5034 marks unnamed (and thus unused) parameters as
5035 artificial; there is no way to differentiate
5037 if (TYPE_NFIELDS (type
) > 0
5038 && TYPE_FIELD_ARTIFICIAL (type
, 0)
5039 && TYPE_CODE (TYPE_FIELD_TYPE (type
, 0)) == TYPE_CODE_PTR
5040 && TYPE_CONST (TYPE_TARGET_TYPE (TYPE_FIELD_TYPE (type
,
5042 fputs_unfiltered (" const", buf
);
5046 name
= ui_file_obsavestring (buf
, &cu
->objfile
->objfile_obstack
,
5048 ui_file_delete (buf
);
5050 if (cu
->language
== language_cplus
)
5053 = dwarf2_canonicalize_name (name
, cu
,
5054 &cu
->objfile
->objfile_obstack
);
5065 /* Return the fully qualified name of DIE, based on its DW_AT_name.
5066 If scope qualifiers are appropriate they will be added. The result
5067 will be allocated on the objfile_obstack, or NULL if the DIE does
5068 not have a name. NAME may either be from a previous call to
5069 dwarf2_name or NULL.
5071 The output string will be canonicalized (if C++/Java). */
5074 dwarf2_full_name (char *name
, struct die_info
*die
, struct dwarf2_cu
*cu
)
5076 return dwarf2_compute_name (name
, die
, cu
, 0);
5079 /* Construct a physname for the given DIE in CU. NAME may either be
5080 from a previous call to dwarf2_name or NULL. The result will be
5081 allocated on the objfile_objstack or NULL if the DIE does not have a
5084 The output string will be canonicalized (if C++/Java). */
5087 dwarf2_physname (char *name
, struct die_info
*die
, struct dwarf2_cu
*cu
)
5089 return dwarf2_compute_name (name
, die
, cu
, 1);
5092 /* Read the import statement specified by the given die and record it. */
5095 read_import_statement (struct die_info
*die
, struct dwarf2_cu
*cu
)
5097 struct attribute
*import_attr
;
5098 struct die_info
*imported_die
;
5099 struct dwarf2_cu
*imported_cu
;
5100 const char *imported_name
;
5101 const char *imported_name_prefix
;
5102 const char *canonical_name
;
5103 const char *import_alias
;
5104 const char *imported_declaration
= NULL
;
5105 const char *import_prefix
;
5109 import_attr
= dwarf2_attr (die
, DW_AT_import
, cu
);
5110 if (import_attr
== NULL
)
5112 complaint (&symfile_complaints
, _("Tag '%s' has no DW_AT_import"),
5113 dwarf_tag_name (die
->tag
));
5118 imported_die
= follow_die_ref_or_sig (die
, import_attr
, &imported_cu
);
5119 imported_name
= dwarf2_name (imported_die
, imported_cu
);
5120 if (imported_name
== NULL
)
5122 /* GCC bug: https://bugzilla.redhat.com/show_bug.cgi?id=506524
5124 The import in the following code:
5138 <2><51>: Abbrev Number: 3 (DW_TAG_imported_declaration)
5139 <52> DW_AT_decl_file : 1
5140 <53> DW_AT_decl_line : 6
5141 <54> DW_AT_import : <0x75>
5142 <2><58>: Abbrev Number: 4 (DW_TAG_typedef)
5144 <5b> DW_AT_decl_file : 1
5145 <5c> DW_AT_decl_line : 2
5146 <5d> DW_AT_type : <0x6e>
5148 <1><75>: Abbrev Number: 7 (DW_TAG_base_type)
5149 <76> DW_AT_byte_size : 4
5150 <77> DW_AT_encoding : 5 (signed)
5152 imports the wrong die ( 0x75 instead of 0x58 ).
5153 This case will be ignored until the gcc bug is fixed. */
5157 /* Figure out the local name after import. */
5158 import_alias
= dwarf2_name (die
, cu
);
5160 /* Figure out where the statement is being imported to. */
5161 import_prefix
= determine_prefix (die
, cu
);
5163 /* Figure out what the scope of the imported die is and prepend it
5164 to the name of the imported die. */
5165 imported_name_prefix
= determine_prefix (imported_die
, imported_cu
);
5167 if (imported_die
->tag
!= DW_TAG_namespace
5168 && imported_die
->tag
!= DW_TAG_module
)
5170 imported_declaration
= imported_name
;
5171 canonical_name
= imported_name_prefix
;
5173 else if (strlen (imported_name_prefix
) > 0)
5175 temp
= alloca (strlen (imported_name_prefix
)
5176 + 2 + strlen (imported_name
) + 1);
5177 strcpy (temp
, imported_name_prefix
);
5178 strcat (temp
, "::");
5179 strcat (temp
, imported_name
);
5180 canonical_name
= temp
;
5183 canonical_name
= imported_name
;
5185 cp_add_using_directive (import_prefix
,
5188 imported_declaration
,
5189 &cu
->objfile
->objfile_obstack
);
5193 initialize_cu_func_list (struct dwarf2_cu
*cu
)
5195 cu
->first_fn
= cu
->last_fn
= cu
->cached_fn
= NULL
;
5198 /* Cleanup function for read_file_scope. */
5201 free_cu_line_header (void *arg
)
5203 struct dwarf2_cu
*cu
= arg
;
5205 free_line_header (cu
->line_header
);
5206 cu
->line_header
= NULL
;
5210 find_file_and_directory (struct die_info
*die
, struct dwarf2_cu
*cu
,
5211 char **name
, char **comp_dir
)
5213 struct attribute
*attr
;
5218 /* Find the filename. Do not use dwarf2_name here, since the filename
5219 is not a source language identifier. */
5220 attr
= dwarf2_attr (die
, DW_AT_name
, cu
);
5223 *name
= DW_STRING (attr
);
5226 attr
= dwarf2_attr (die
, DW_AT_comp_dir
, cu
);
5228 *comp_dir
= DW_STRING (attr
);
5229 else if (*name
!= NULL
&& IS_ABSOLUTE_PATH (*name
))
5231 *comp_dir
= ldirname (*name
);
5232 if (*comp_dir
!= NULL
)
5233 make_cleanup (xfree
, *comp_dir
);
5235 if (*comp_dir
!= NULL
)
5237 /* Irix 6.2 native cc prepends <machine>.: to the compilation
5238 directory, get rid of it. */
5239 char *cp
= strchr (*comp_dir
, ':');
5241 if (cp
&& cp
!= *comp_dir
&& cp
[-1] == '.' && cp
[1] == '/')
5246 *name
= "<unknown>";
5249 /* Process DW_TAG_compile_unit. */
5252 read_file_scope (struct die_info
*die
, struct dwarf2_cu
*cu
)
5254 struct objfile
*objfile
= cu
->objfile
;
5255 struct cleanup
*back_to
= make_cleanup (null_cleanup
, 0);
5256 CORE_ADDR lowpc
= ((CORE_ADDR
) -1);
5257 CORE_ADDR highpc
= ((CORE_ADDR
) 0);
5258 struct attribute
*attr
;
5260 char *comp_dir
= NULL
;
5261 struct die_info
*child_die
;
5262 bfd
*abfd
= objfile
->obfd
;
5263 struct line_header
*line_header
= 0;
5266 baseaddr
= ANOFFSET (objfile
->section_offsets
, SECT_OFF_TEXT (objfile
));
5268 get_scope_pc_bounds (die
, &lowpc
, &highpc
, cu
);
5270 /* If we didn't find a lowpc, set it to highpc to avoid complaints
5271 from finish_block. */
5272 if (lowpc
== ((CORE_ADDR
) -1))
5277 find_file_and_directory (die
, cu
, &name
, &comp_dir
);
5279 attr
= dwarf2_attr (die
, DW_AT_language
, cu
);
5282 set_cu_language (DW_UNSND (attr
), cu
);
5285 attr
= dwarf2_attr (die
, DW_AT_producer
, cu
);
5287 cu
->producer
= DW_STRING (attr
);
5289 /* The XLCL doesn't generate DW_LANG_OpenCL because this attribute is not
5290 standardised yet. As a workaround for the language detection we fall
5291 back to the DW_AT_producer string. */
5292 if (cu
->producer
&& strstr (cu
->producer
, "IBM XL C for OpenCL") != NULL
)
5293 cu
->language
= language_opencl
;
5295 /* We assume that we're processing GCC output. */
5296 processing_gcc_compilation
= 2;
5298 processing_has_namespace_info
= 0;
5300 start_symtab (name
, comp_dir
, lowpc
);
5301 record_debugformat ("DWARF 2");
5302 record_producer (cu
->producer
);
5304 initialize_cu_func_list (cu
);
5306 /* Decode line number information if present. We do this before
5307 processing child DIEs, so that the line header table is available
5308 for DW_AT_decl_file. */
5309 attr
= dwarf2_attr (die
, DW_AT_stmt_list
, cu
);
5312 unsigned int line_offset
= DW_UNSND (attr
);
5313 line_header
= dwarf_decode_line_header (line_offset
, abfd
, cu
);
5316 cu
->line_header
= line_header
;
5317 make_cleanup (free_cu_line_header
, cu
);
5318 dwarf_decode_lines (line_header
, comp_dir
, abfd
, cu
, NULL
);
5322 /* Process all dies in compilation unit. */
5323 if (die
->child
!= NULL
)
5325 child_die
= die
->child
;
5326 while (child_die
&& child_die
->tag
)
5328 process_die (child_die
, cu
);
5329 child_die
= sibling_die (child_die
);
5333 /* Decode macro information, if present. Dwarf 2 macro information
5334 refers to information in the line number info statement program
5335 header, so we can only read it if we've read the header
5337 attr
= dwarf2_attr (die
, DW_AT_macro_info
, cu
);
5338 if (attr
&& line_header
)
5340 unsigned int macro_offset
= DW_UNSND (attr
);
5342 dwarf_decode_macros (line_header
, macro_offset
,
5343 comp_dir
, abfd
, cu
);
5345 do_cleanups (back_to
);
5348 /* Process DW_TAG_type_unit.
5349 For TUs we want to skip the first top level sibling if it's not the
5350 actual type being defined by this TU. In this case the first top
5351 level sibling is there to provide context only. */
5354 read_type_unit_scope (struct die_info
*die
, struct dwarf2_cu
*cu
)
5356 struct objfile
*objfile
= cu
->objfile
;
5357 struct cleanup
*back_to
= make_cleanup (null_cleanup
, 0);
5359 struct attribute
*attr
;
5361 char *comp_dir
= NULL
;
5362 struct die_info
*child_die
;
5363 bfd
*abfd
= objfile
->obfd
;
5365 /* start_symtab needs a low pc, but we don't really have one.
5366 Do what read_file_scope would do in the absence of such info. */
5367 lowpc
= ANOFFSET (objfile
->section_offsets
, SECT_OFF_TEXT (objfile
));
5369 /* Find the filename. Do not use dwarf2_name here, since the filename
5370 is not a source language identifier. */
5371 attr
= dwarf2_attr (die
, DW_AT_name
, cu
);
5373 name
= DW_STRING (attr
);
5375 attr
= dwarf2_attr (die
, DW_AT_comp_dir
, cu
);
5377 comp_dir
= DW_STRING (attr
);
5378 else if (name
!= NULL
&& IS_ABSOLUTE_PATH (name
))
5380 comp_dir
= ldirname (name
);
5381 if (comp_dir
!= NULL
)
5382 make_cleanup (xfree
, comp_dir
);
5388 attr
= dwarf2_attr (die
, DW_AT_language
, cu
);
5390 set_cu_language (DW_UNSND (attr
), cu
);
5392 /* This isn't technically needed today. It is done for symmetry
5393 with read_file_scope. */
5394 attr
= dwarf2_attr (die
, DW_AT_producer
, cu
);
5396 cu
->producer
= DW_STRING (attr
);
5398 /* We assume that we're processing GCC output. */
5399 processing_gcc_compilation
= 2;
5401 processing_has_namespace_info
= 0;
5403 start_symtab (name
, comp_dir
, lowpc
);
5404 record_debugformat ("DWARF 2");
5405 record_producer (cu
->producer
);
5407 /* Process the dies in the type unit. */
5408 if (die
->child
== NULL
)
5410 dump_die_for_error (die
);
5411 error (_("Dwarf Error: Missing children for type unit [in module %s]"),
5412 bfd_get_filename (abfd
));
5415 child_die
= die
->child
;
5417 while (child_die
&& child_die
->tag
)
5419 process_die (child_die
, cu
);
5421 child_die
= sibling_die (child_die
);
5424 do_cleanups (back_to
);
5428 add_to_cu_func_list (const char *name
, CORE_ADDR lowpc
, CORE_ADDR highpc
,
5429 struct dwarf2_cu
*cu
)
5431 struct function_range
*thisfn
;
5433 thisfn
= (struct function_range
*)
5434 obstack_alloc (&cu
->comp_unit_obstack
, sizeof (struct function_range
));
5435 thisfn
->name
= name
;
5436 thisfn
->lowpc
= lowpc
;
5437 thisfn
->highpc
= highpc
;
5438 thisfn
->seen_line
= 0;
5439 thisfn
->next
= NULL
;
5441 if (cu
->last_fn
== NULL
)
5442 cu
->first_fn
= thisfn
;
5444 cu
->last_fn
->next
= thisfn
;
5446 cu
->last_fn
= thisfn
;
5449 /* qsort helper for inherit_abstract_dies. */
5452 unsigned_int_compar (const void *ap
, const void *bp
)
5454 unsigned int a
= *(unsigned int *) ap
;
5455 unsigned int b
= *(unsigned int *) bp
;
5457 return (a
> b
) - (b
> a
);
5460 /* DW_AT_abstract_origin inherits whole DIEs (not just their attributes).
5461 Inherit only the children of the DW_AT_abstract_origin DIE not being
5462 already referenced by DW_AT_abstract_origin from the children of the
5466 inherit_abstract_dies (struct die_info
*die
, struct dwarf2_cu
*cu
)
5468 struct die_info
*child_die
;
5469 unsigned die_children_count
;
5470 /* CU offsets which were referenced by children of the current DIE. */
5472 unsigned *offsets_end
, *offsetp
;
5473 /* Parent of DIE - referenced by DW_AT_abstract_origin. */
5474 struct die_info
*origin_die
;
5475 /* Iterator of the ORIGIN_DIE children. */
5476 struct die_info
*origin_child_die
;
5477 struct cleanup
*cleanups
;
5478 struct attribute
*attr
;
5479 struct dwarf2_cu
*origin_cu
;
5480 struct pending
**origin_previous_list_in_scope
;
5482 attr
= dwarf2_attr (die
, DW_AT_abstract_origin
, cu
);
5486 /* Note that following die references may follow to a die in a
5490 origin_die
= follow_die_ref (die
, attr
, &origin_cu
);
5492 /* We're inheriting ORIGIN's children into the scope we'd put DIE's
5494 origin_previous_list_in_scope
= origin_cu
->list_in_scope
;
5495 origin_cu
->list_in_scope
= cu
->list_in_scope
;
5497 if (die
->tag
!= origin_die
->tag
5498 && !(die
->tag
== DW_TAG_inlined_subroutine
5499 && origin_die
->tag
== DW_TAG_subprogram
))
5500 complaint (&symfile_complaints
,
5501 _("DIE 0x%x and its abstract origin 0x%x have different tags"),
5502 die
->offset
, origin_die
->offset
);
5504 child_die
= die
->child
;
5505 die_children_count
= 0;
5506 while (child_die
&& child_die
->tag
)
5508 child_die
= sibling_die (child_die
);
5509 die_children_count
++;
5511 offsets
= xmalloc (sizeof (*offsets
) * die_children_count
);
5512 cleanups
= make_cleanup (xfree
, offsets
);
5514 offsets_end
= offsets
;
5515 child_die
= die
->child
;
5516 while (child_die
&& child_die
->tag
)
5518 /* For each CHILD_DIE, find the corresponding child of
5519 ORIGIN_DIE. If there is more than one layer of
5520 DW_AT_abstract_origin, follow them all; there shouldn't be,
5521 but GCC versions at least through 4.4 generate this (GCC PR
5523 struct die_info
*child_origin_die
= child_die
;
5524 struct dwarf2_cu
*child_origin_cu
= cu
;
5528 attr
= dwarf2_attr (child_origin_die
, DW_AT_abstract_origin
,
5532 child_origin_die
= follow_die_ref (child_origin_die
, attr
,
5536 /* According to DWARF3 3.3.8.2 #3 new entries without their abstract
5537 counterpart may exist. */
5538 if (child_origin_die
!= child_die
)
5540 if (child_die
->tag
!= child_origin_die
->tag
5541 && !(child_die
->tag
== DW_TAG_inlined_subroutine
5542 && child_origin_die
->tag
== DW_TAG_subprogram
))
5543 complaint (&symfile_complaints
,
5544 _("Child DIE 0x%x and its abstract origin 0x%x have "
5545 "different tags"), child_die
->offset
,
5546 child_origin_die
->offset
);
5547 if (child_origin_die
->parent
!= origin_die
)
5548 complaint (&symfile_complaints
,
5549 _("Child DIE 0x%x and its abstract origin 0x%x have "
5550 "different parents"), child_die
->offset
,
5551 child_origin_die
->offset
);
5553 *offsets_end
++ = child_origin_die
->offset
;
5555 child_die
= sibling_die (child_die
);
5557 qsort (offsets
, offsets_end
- offsets
, sizeof (*offsets
),
5558 unsigned_int_compar
);
5559 for (offsetp
= offsets
+ 1; offsetp
< offsets_end
; offsetp
++)
5560 if (offsetp
[-1] == *offsetp
)
5561 complaint (&symfile_complaints
,
5562 _("Multiple children of DIE 0x%x refer "
5563 "to DIE 0x%x as their abstract origin"),
5564 die
->offset
, *offsetp
);
5567 origin_child_die
= origin_die
->child
;
5568 while (origin_child_die
&& origin_child_die
->tag
)
5570 /* Is ORIGIN_CHILD_DIE referenced by any of the DIE children? */
5571 while (offsetp
< offsets_end
&& *offsetp
< origin_child_die
->offset
)
5573 if (offsetp
>= offsets_end
|| *offsetp
> origin_child_die
->offset
)
5575 /* Found that ORIGIN_CHILD_DIE is really not referenced. */
5576 process_die (origin_child_die
, origin_cu
);
5578 origin_child_die
= sibling_die (origin_child_die
);
5580 origin_cu
->list_in_scope
= origin_previous_list_in_scope
;
5582 do_cleanups (cleanups
);
5586 read_func_scope (struct die_info
*die
, struct dwarf2_cu
*cu
)
5588 struct objfile
*objfile
= cu
->objfile
;
5589 struct context_stack
*new;
5592 struct die_info
*child_die
;
5593 struct attribute
*attr
, *call_line
, *call_file
;
5596 struct block
*block
;
5597 int inlined_func
= (die
->tag
== DW_TAG_inlined_subroutine
);
5598 VEC (symbolp
) *template_args
= NULL
;
5599 struct template_symbol
*templ_func
= NULL
;
5603 /* If we do not have call site information, we can't show the
5604 caller of this inlined function. That's too confusing, so
5605 only use the scope for local variables. */
5606 call_line
= dwarf2_attr (die
, DW_AT_call_line
, cu
);
5607 call_file
= dwarf2_attr (die
, DW_AT_call_file
, cu
);
5608 if (call_line
== NULL
|| call_file
== NULL
)
5610 read_lexical_block_scope (die
, cu
);
5615 baseaddr
= ANOFFSET (objfile
->section_offsets
, SECT_OFF_TEXT (objfile
));
5617 name
= dwarf2_name (die
, cu
);
5619 /* Ignore functions with missing or empty names. These are actually
5620 illegal according to the DWARF standard. */
5623 complaint (&symfile_complaints
,
5624 _("missing name for subprogram DIE at %d"), die
->offset
);
5628 /* Ignore functions with missing or invalid low and high pc attributes. */
5629 if (!dwarf2_get_pc_bounds (die
, &lowpc
, &highpc
, cu
, NULL
))
5631 attr
= dwarf2_attr (die
, DW_AT_external
, cu
);
5632 if (!attr
|| !DW_UNSND (attr
))
5633 complaint (&symfile_complaints
,
5634 _("cannot get low and high bounds "
5635 "for subprogram DIE at %d"),
5643 /* Record the function range for dwarf_decode_lines. */
5644 add_to_cu_func_list (name
, lowpc
, highpc
, cu
);
5646 /* If we have any template arguments, then we must allocate a
5647 different sort of symbol. */
5648 for (child_die
= die
->child
; child_die
; child_die
= sibling_die (child_die
))
5650 if (child_die
->tag
== DW_TAG_template_type_param
5651 || child_die
->tag
== DW_TAG_template_value_param
)
5653 templ_func
= OBSTACK_ZALLOC (&objfile
->objfile_obstack
,
5654 struct template_symbol
);
5655 templ_func
->base
.is_cplus_template_function
= 1;
5660 new = push_context (0, lowpc
);
5661 new->name
= new_symbol_full (die
, read_type_die (die
, cu
), cu
,
5662 (struct symbol
*) templ_func
);
5664 /* If there is a location expression for DW_AT_frame_base, record
5666 attr
= dwarf2_attr (die
, DW_AT_frame_base
, cu
);
5668 /* FIXME: cagney/2004-01-26: The DW_AT_frame_base's location
5669 expression is being recorded directly in the function's symbol
5670 and not in a separate frame-base object. I guess this hack is
5671 to avoid adding some sort of frame-base adjunct/annex to the
5672 function's symbol :-(. The problem with doing this is that it
5673 results in a function symbol with a location expression that
5674 has nothing to do with the location of the function, ouch! The
5675 relationship should be: a function's symbol has-a frame base; a
5676 frame-base has-a location expression. */
5677 dwarf2_symbol_mark_computed (attr
, new->name
, cu
);
5679 cu
->list_in_scope
= &local_symbols
;
5681 if (die
->child
!= NULL
)
5683 child_die
= die
->child
;
5684 while (child_die
&& child_die
->tag
)
5686 if (child_die
->tag
== DW_TAG_template_type_param
5687 || child_die
->tag
== DW_TAG_template_value_param
)
5689 struct symbol
*arg
= new_symbol (child_die
, NULL
, cu
);
5692 VEC_safe_push (symbolp
, template_args
, arg
);
5695 process_die (child_die
, cu
);
5696 child_die
= sibling_die (child_die
);
5700 inherit_abstract_dies (die
, cu
);
5702 /* If we have a DW_AT_specification, we might need to import using
5703 directives from the context of the specification DIE. See the
5704 comment in determine_prefix. */
5705 if (cu
->language
== language_cplus
5706 && dwarf2_attr (die
, DW_AT_specification
, cu
))
5708 struct dwarf2_cu
*spec_cu
= cu
;
5709 struct die_info
*spec_die
= die_specification (die
, &spec_cu
);
5713 child_die
= spec_die
->child
;
5714 while (child_die
&& child_die
->tag
)
5716 if (child_die
->tag
== DW_TAG_imported_module
)
5717 process_die (child_die
, spec_cu
);
5718 child_die
= sibling_die (child_die
);
5721 /* In some cases, GCC generates specification DIEs that
5722 themselves contain DW_AT_specification attributes. */
5723 spec_die
= die_specification (spec_die
, &spec_cu
);
5727 new = pop_context ();
5728 /* Make a block for the local symbols within. */
5729 block
= finish_block (new->name
, &local_symbols
, new->old_blocks
,
5730 lowpc
, highpc
, objfile
);
5732 /* For C++, set the block's scope. */
5733 if (cu
->language
== language_cplus
|| cu
->language
== language_fortran
)
5734 cp_set_block_scope (new->name
, block
, &objfile
->objfile_obstack
,
5735 determine_prefix (die
, cu
),
5736 processing_has_namespace_info
);
5738 /* If we have address ranges, record them. */
5739 dwarf2_record_block_ranges (die
, block
, baseaddr
, cu
);
5741 /* Attach template arguments to function. */
5742 if (! VEC_empty (symbolp
, template_args
))
5744 gdb_assert (templ_func
!= NULL
);
5746 templ_func
->n_template_arguments
= VEC_length (symbolp
, template_args
);
5747 templ_func
->template_arguments
5748 = obstack_alloc (&objfile
->objfile_obstack
,
5749 (templ_func
->n_template_arguments
5750 * sizeof (struct symbol
*)));
5751 memcpy (templ_func
->template_arguments
,
5752 VEC_address (symbolp
, template_args
),
5753 (templ_func
->n_template_arguments
* sizeof (struct symbol
*)));
5754 VEC_free (symbolp
, template_args
);
5757 /* In C++, we can have functions nested inside functions (e.g., when
5758 a function declares a class that has methods). This means that
5759 when we finish processing a function scope, we may need to go
5760 back to building a containing block's symbol lists. */
5761 local_symbols
= new->locals
;
5762 param_symbols
= new->params
;
5763 using_directives
= new->using_directives
;
5765 /* If we've finished processing a top-level function, subsequent
5766 symbols go in the file symbol list. */
5767 if (outermost_context_p ())
5768 cu
->list_in_scope
= &file_symbols
;
5771 /* Process all the DIES contained within a lexical block scope. Start
5772 a new scope, process the dies, and then close the scope. */
5775 read_lexical_block_scope (struct die_info
*die
, struct dwarf2_cu
*cu
)
5777 struct objfile
*objfile
= cu
->objfile
;
5778 struct context_stack
*new;
5779 CORE_ADDR lowpc
, highpc
;
5780 struct die_info
*child_die
;
5783 baseaddr
= ANOFFSET (objfile
->section_offsets
, SECT_OFF_TEXT (objfile
));
5785 /* Ignore blocks with missing or invalid low and high pc attributes. */
5786 /* ??? Perhaps consider discontiguous blocks defined by DW_AT_ranges
5787 as multiple lexical blocks? Handling children in a sane way would
5788 be nasty. Might be easier to properly extend generic blocks to
5790 if (!dwarf2_get_pc_bounds (die
, &lowpc
, &highpc
, cu
, NULL
))
5795 push_context (0, lowpc
);
5796 if (die
->child
!= NULL
)
5798 child_die
= die
->child
;
5799 while (child_die
&& child_die
->tag
)
5801 process_die (child_die
, cu
);
5802 child_die
= sibling_die (child_die
);
5805 new = pop_context ();
5807 if (local_symbols
!= NULL
|| using_directives
!= NULL
)
5810 = finish_block (0, &local_symbols
, new->old_blocks
, new->start_addr
,
5813 /* Note that recording ranges after traversing children, as we
5814 do here, means that recording a parent's ranges entails
5815 walking across all its children's ranges as they appear in
5816 the address map, which is quadratic behavior.
5818 It would be nicer to record the parent's ranges before
5819 traversing its children, simply overriding whatever you find
5820 there. But since we don't even decide whether to create a
5821 block until after we've traversed its children, that's hard
5823 dwarf2_record_block_ranges (die
, block
, baseaddr
, cu
);
5825 local_symbols
= new->locals
;
5826 using_directives
= new->using_directives
;
5829 /* Get low and high pc attributes from DW_AT_ranges attribute value OFFSET.
5830 Return 1 if the attributes are present and valid, otherwise, return 0.
5831 If RANGES_PST is not NULL we should setup `objfile->psymtabs_addrmap'. */
5834 dwarf2_ranges_read (unsigned offset
, CORE_ADDR
*low_return
,
5835 CORE_ADDR
*high_return
, struct dwarf2_cu
*cu
,
5836 struct partial_symtab
*ranges_pst
)
5838 struct objfile
*objfile
= cu
->objfile
;
5839 struct comp_unit_head
*cu_header
= &cu
->header
;
5840 bfd
*obfd
= objfile
->obfd
;
5841 unsigned int addr_size
= cu_header
->addr_size
;
5842 CORE_ADDR mask
= ~(~(CORE_ADDR
)1 << (addr_size
* 8 - 1));
5843 /* Base address selection entry. */
5854 found_base
= cu
->base_known
;
5855 base
= cu
->base_address
;
5857 dwarf2_read_section (objfile
, &dwarf2_per_objfile
->ranges
);
5858 if (offset
>= dwarf2_per_objfile
->ranges
.size
)
5860 complaint (&symfile_complaints
,
5861 _("Offset %d out of bounds for DW_AT_ranges attribute"),
5865 buffer
= dwarf2_per_objfile
->ranges
.buffer
+ offset
;
5867 /* Read in the largest possible address. */
5868 marker
= read_address (obfd
, buffer
, cu
, &dummy
);
5869 if ((marker
& mask
) == mask
)
5871 /* If we found the largest possible address, then
5872 read the base address. */
5873 base
= read_address (obfd
, buffer
+ addr_size
, cu
, &dummy
);
5874 buffer
+= 2 * addr_size
;
5875 offset
+= 2 * addr_size
;
5881 baseaddr
= ANOFFSET (objfile
->section_offsets
, SECT_OFF_TEXT (objfile
));
5885 CORE_ADDR range_beginning
, range_end
;
5887 range_beginning
= read_address (obfd
, buffer
, cu
, &dummy
);
5888 buffer
+= addr_size
;
5889 range_end
= read_address (obfd
, buffer
, cu
, &dummy
);
5890 buffer
+= addr_size
;
5891 offset
+= 2 * addr_size
;
5893 /* An end of list marker is a pair of zero addresses. */
5894 if (range_beginning
== 0 && range_end
== 0)
5895 /* Found the end of list entry. */
5898 /* Each base address selection entry is a pair of 2 values.
5899 The first is the largest possible address, the second is
5900 the base address. Check for a base address here. */
5901 if ((range_beginning
& mask
) == mask
)
5903 /* If we found the largest possible address, then
5904 read the base address. */
5905 base
= read_address (obfd
, buffer
+ addr_size
, cu
, &dummy
);
5912 /* We have no valid base address for the ranges
5914 complaint (&symfile_complaints
,
5915 _("Invalid .debug_ranges data (no base address)"));
5919 if (range_beginning
> range_end
)
5921 /* Inverted range entries are invalid. */
5922 complaint (&symfile_complaints
,
5923 _("Invalid .debug_ranges data (inverted range)"));
5927 /* Empty range entries have no effect. */
5928 if (range_beginning
== range_end
)
5931 range_beginning
+= base
;
5934 if (ranges_pst
!= NULL
)
5935 addrmap_set_empty (objfile
->psymtabs_addrmap
,
5936 range_beginning
+ baseaddr
,
5937 range_end
- 1 + baseaddr
,
5940 /* FIXME: This is recording everything as a low-high
5941 segment of consecutive addresses. We should have a
5942 data structure for discontiguous block ranges
5946 low
= range_beginning
;
5952 if (range_beginning
< low
)
5953 low
= range_beginning
;
5954 if (range_end
> high
)
5960 /* If the first entry is an end-of-list marker, the range
5961 describes an empty scope, i.e. no instructions. */
5967 *high_return
= high
;
5971 /* Get low and high pc attributes from a die. Return 1 if the attributes
5972 are present and valid, otherwise, return 0. Return -1 if the range is
5973 discontinuous, i.e. derived from DW_AT_ranges information. */
5975 dwarf2_get_pc_bounds (struct die_info
*die
, CORE_ADDR
*lowpc
,
5976 CORE_ADDR
*highpc
, struct dwarf2_cu
*cu
,
5977 struct partial_symtab
*pst
)
5979 struct attribute
*attr
;
5984 attr
= dwarf2_attr (die
, DW_AT_high_pc
, cu
);
5987 high
= DW_ADDR (attr
);
5988 attr
= dwarf2_attr (die
, DW_AT_low_pc
, cu
);
5990 low
= DW_ADDR (attr
);
5992 /* Found high w/o low attribute. */
5995 /* Found consecutive range of addresses. */
6000 attr
= dwarf2_attr (die
, DW_AT_ranges
, cu
);
6003 /* Value of the DW_AT_ranges attribute is the offset in the
6004 .debug_ranges section. */
6005 if (!dwarf2_ranges_read (DW_UNSND (attr
), &low
, &high
, cu
, pst
))
6007 /* Found discontinuous range of addresses. */
6012 /* read_partial_die has also the strict LOW < HIGH requirement. */
6016 /* When using the GNU linker, .gnu.linkonce. sections are used to
6017 eliminate duplicate copies of functions and vtables and such.
6018 The linker will arbitrarily choose one and discard the others.
6019 The AT_*_pc values for such functions refer to local labels in
6020 these sections. If the section from that file was discarded, the
6021 labels are not in the output, so the relocs get a value of 0.
6022 If this is a discarded function, mark the pc bounds as invalid,
6023 so that GDB will ignore it. */
6024 if (low
== 0 && !dwarf2_per_objfile
->has_section_at_zero
)
6032 /* Assuming that DIE represents a subprogram DIE or a lexical block, get
6033 its low and high PC addresses. Do nothing if these addresses could not
6034 be determined. Otherwise, set LOWPC to the low address if it is smaller,
6035 and HIGHPC to the high address if greater than HIGHPC. */
6038 dwarf2_get_subprogram_pc_bounds (struct die_info
*die
,
6039 CORE_ADDR
*lowpc
, CORE_ADDR
*highpc
,
6040 struct dwarf2_cu
*cu
)
6042 CORE_ADDR low
, high
;
6043 struct die_info
*child
= die
->child
;
6045 if (dwarf2_get_pc_bounds (die
, &low
, &high
, cu
, NULL
))
6047 *lowpc
= min (*lowpc
, low
);
6048 *highpc
= max (*highpc
, high
);
6051 /* If the language does not allow nested subprograms (either inside
6052 subprograms or lexical blocks), we're done. */
6053 if (cu
->language
!= language_ada
)
6056 /* Check all the children of the given DIE. If it contains nested
6057 subprograms, then check their pc bounds. Likewise, we need to
6058 check lexical blocks as well, as they may also contain subprogram
6060 while (child
&& child
->tag
)
6062 if (child
->tag
== DW_TAG_subprogram
6063 || child
->tag
== DW_TAG_lexical_block
)
6064 dwarf2_get_subprogram_pc_bounds (child
, lowpc
, highpc
, cu
);
6065 child
= sibling_die (child
);
6069 /* Get the low and high pc's represented by the scope DIE, and store
6070 them in *LOWPC and *HIGHPC. If the correct values can't be
6071 determined, set *LOWPC to -1 and *HIGHPC to 0. */
6074 get_scope_pc_bounds (struct die_info
*die
,
6075 CORE_ADDR
*lowpc
, CORE_ADDR
*highpc
,
6076 struct dwarf2_cu
*cu
)
6078 CORE_ADDR best_low
= (CORE_ADDR
) -1;
6079 CORE_ADDR best_high
= (CORE_ADDR
) 0;
6080 CORE_ADDR current_low
, current_high
;
6082 if (dwarf2_get_pc_bounds (die
, ¤t_low
, ¤t_high
, cu
, NULL
))
6084 best_low
= current_low
;
6085 best_high
= current_high
;
6089 struct die_info
*child
= die
->child
;
6091 while (child
&& child
->tag
)
6093 switch (child
->tag
) {
6094 case DW_TAG_subprogram
:
6095 dwarf2_get_subprogram_pc_bounds (child
, &best_low
, &best_high
, cu
);
6097 case DW_TAG_namespace
:
6099 /* FIXME: carlton/2004-01-16: Should we do this for
6100 DW_TAG_class_type/DW_TAG_structure_type, too? I think
6101 that current GCC's always emit the DIEs corresponding
6102 to definitions of methods of classes as children of a
6103 DW_TAG_compile_unit or DW_TAG_namespace (as opposed to
6104 the DIEs giving the declarations, which could be
6105 anywhere). But I don't see any reason why the
6106 standards says that they have to be there. */
6107 get_scope_pc_bounds (child
, ¤t_low
, ¤t_high
, cu
);
6109 if (current_low
!= ((CORE_ADDR
) -1))
6111 best_low
= min (best_low
, current_low
);
6112 best_high
= max (best_high
, current_high
);
6120 child
= sibling_die (child
);
6125 *highpc
= best_high
;
6128 /* Record the address ranges for BLOCK, offset by BASEADDR, as given
6131 dwarf2_record_block_ranges (struct die_info
*die
, struct block
*block
,
6132 CORE_ADDR baseaddr
, struct dwarf2_cu
*cu
)
6134 struct attribute
*attr
;
6136 attr
= dwarf2_attr (die
, DW_AT_high_pc
, cu
);
6139 CORE_ADDR high
= DW_ADDR (attr
);
6141 attr
= dwarf2_attr (die
, DW_AT_low_pc
, cu
);
6144 CORE_ADDR low
= DW_ADDR (attr
);
6146 record_block_range (block
, baseaddr
+ low
, baseaddr
+ high
- 1);
6150 attr
= dwarf2_attr (die
, DW_AT_ranges
, cu
);
6153 bfd
*obfd
= cu
->objfile
->obfd
;
6155 /* The value of the DW_AT_ranges attribute is the offset of the
6156 address range list in the .debug_ranges section. */
6157 unsigned long offset
= DW_UNSND (attr
);
6158 gdb_byte
*buffer
= dwarf2_per_objfile
->ranges
.buffer
+ offset
;
6160 /* For some target architectures, but not others, the
6161 read_address function sign-extends the addresses it returns.
6162 To recognize base address selection entries, we need a
6164 unsigned int addr_size
= cu
->header
.addr_size
;
6165 CORE_ADDR base_select_mask
= ~(~(CORE_ADDR
)1 << (addr_size
* 8 - 1));
6167 /* The base address, to which the next pair is relative. Note
6168 that this 'base' is a DWARF concept: most entries in a range
6169 list are relative, to reduce the number of relocs against the
6170 debugging information. This is separate from this function's
6171 'baseaddr' argument, which GDB uses to relocate debugging
6172 information from a shared library based on the address at
6173 which the library was loaded. */
6174 CORE_ADDR base
= cu
->base_address
;
6175 int base_known
= cu
->base_known
;
6177 gdb_assert (dwarf2_per_objfile
->ranges
.readin
);
6178 if (offset
>= dwarf2_per_objfile
->ranges
.size
)
6180 complaint (&symfile_complaints
,
6181 _("Offset %lu out of bounds for DW_AT_ranges attribute"),
6188 unsigned int bytes_read
;
6189 CORE_ADDR start
, end
;
6191 start
= read_address (obfd
, buffer
, cu
, &bytes_read
);
6192 buffer
+= bytes_read
;
6193 end
= read_address (obfd
, buffer
, cu
, &bytes_read
);
6194 buffer
+= bytes_read
;
6196 /* Did we find the end of the range list? */
6197 if (start
== 0 && end
== 0)
6200 /* Did we find a base address selection entry? */
6201 else if ((start
& base_select_mask
) == base_select_mask
)
6207 /* We found an ordinary address range. */
6212 complaint (&symfile_complaints
,
6213 _("Invalid .debug_ranges data "
6214 "(no base address)"));
6220 /* Inverted range entries are invalid. */
6221 complaint (&symfile_complaints
,
6222 _("Invalid .debug_ranges data "
6223 "(inverted range)"));
6227 /* Empty range entries have no effect. */
6231 record_block_range (block
,
6232 baseaddr
+ base
+ start
,
6233 baseaddr
+ base
+ end
- 1);
6239 /* Add an aggregate field to the field list. */
6242 dwarf2_add_field (struct field_info
*fip
, struct die_info
*die
,
6243 struct dwarf2_cu
*cu
)
6245 struct objfile
*objfile
= cu
->objfile
;
6246 struct gdbarch
*gdbarch
= get_objfile_arch (objfile
);
6247 struct nextfield
*new_field
;
6248 struct attribute
*attr
;
6250 char *fieldname
= "";
6252 /* Allocate a new field list entry and link it in. */
6253 new_field
= (struct nextfield
*) xmalloc (sizeof (struct nextfield
));
6254 make_cleanup (xfree
, new_field
);
6255 memset (new_field
, 0, sizeof (struct nextfield
));
6257 if (die
->tag
== DW_TAG_inheritance
)
6259 new_field
->next
= fip
->baseclasses
;
6260 fip
->baseclasses
= new_field
;
6264 new_field
->next
= fip
->fields
;
6265 fip
->fields
= new_field
;
6269 /* Handle accessibility and virtuality of field.
6270 The default accessibility for members is public, the default
6271 accessibility for inheritance is private. */
6272 if (die
->tag
!= DW_TAG_inheritance
)
6273 new_field
->accessibility
= DW_ACCESS_public
;
6275 new_field
->accessibility
= DW_ACCESS_private
;
6276 new_field
->virtuality
= DW_VIRTUALITY_none
;
6278 attr
= dwarf2_attr (die
, DW_AT_accessibility
, cu
);
6280 new_field
->accessibility
= DW_UNSND (attr
);
6281 if (new_field
->accessibility
!= DW_ACCESS_public
)
6282 fip
->non_public_fields
= 1;
6283 attr
= dwarf2_attr (die
, DW_AT_virtuality
, cu
);
6285 new_field
->virtuality
= DW_UNSND (attr
);
6287 fp
= &new_field
->field
;
6289 if (die
->tag
== DW_TAG_member
&& ! die_is_declaration (die
, cu
))
6291 /* Data member other than a C++ static data member. */
6293 /* Get type of field. */
6294 fp
->type
= die_type (die
, cu
);
6296 SET_FIELD_BITPOS (*fp
, 0);
6298 /* Get bit size of field (zero if none). */
6299 attr
= dwarf2_attr (die
, DW_AT_bit_size
, cu
);
6302 FIELD_BITSIZE (*fp
) = DW_UNSND (attr
);
6306 FIELD_BITSIZE (*fp
) = 0;
6309 /* Get bit offset of field. */
6310 attr
= dwarf2_attr (die
, DW_AT_data_member_location
, cu
);
6313 int byte_offset
= 0;
6315 if (attr_form_is_section_offset (attr
))
6316 dwarf2_complex_location_expr_complaint ();
6317 else if (attr_form_is_constant (attr
))
6318 byte_offset
= dwarf2_get_attr_constant_value (attr
, 0);
6319 else if (attr_form_is_block (attr
))
6320 byte_offset
= decode_locdesc (DW_BLOCK (attr
), cu
);
6322 dwarf2_complex_location_expr_complaint ();
6324 SET_FIELD_BITPOS (*fp
, byte_offset
* bits_per_byte
);
6326 attr
= dwarf2_attr (die
, DW_AT_bit_offset
, cu
);
6329 if (gdbarch_bits_big_endian (gdbarch
))
6331 /* For big endian bits, the DW_AT_bit_offset gives the
6332 additional bit offset from the MSB of the containing
6333 anonymous object to the MSB of the field. We don't
6334 have to do anything special since we don't need to
6335 know the size of the anonymous object. */
6336 FIELD_BITPOS (*fp
) += DW_UNSND (attr
);
6340 /* For little endian bits, compute the bit offset to the
6341 MSB of the anonymous object, subtract off the number of
6342 bits from the MSB of the field to the MSB of the
6343 object, and then subtract off the number of bits of
6344 the field itself. The result is the bit offset of
6345 the LSB of the field. */
6347 int bit_offset
= DW_UNSND (attr
);
6349 attr
= dwarf2_attr (die
, DW_AT_byte_size
, cu
);
6352 /* The size of the anonymous object containing
6353 the bit field is explicit, so use the
6354 indicated size (in bytes). */
6355 anonymous_size
= DW_UNSND (attr
);
6359 /* The size of the anonymous object containing
6360 the bit field must be inferred from the type
6361 attribute of the data member containing the
6363 anonymous_size
= TYPE_LENGTH (fp
->type
);
6365 FIELD_BITPOS (*fp
) += anonymous_size
* bits_per_byte
6366 - bit_offset
- FIELD_BITSIZE (*fp
);
6370 /* Get name of field. */
6371 fieldname
= dwarf2_name (die
, cu
);
6372 if (fieldname
== NULL
)
6375 /* The name is already allocated along with this objfile, so we don't
6376 need to duplicate it for the type. */
6377 fp
->name
= fieldname
;
6379 /* Change accessibility for artificial fields (e.g. virtual table
6380 pointer or virtual base class pointer) to private. */
6381 if (dwarf2_attr (die
, DW_AT_artificial
, cu
))
6383 FIELD_ARTIFICIAL (*fp
) = 1;
6384 new_field
->accessibility
= DW_ACCESS_private
;
6385 fip
->non_public_fields
= 1;
6388 else if (die
->tag
== DW_TAG_member
|| die
->tag
== DW_TAG_variable
)
6390 /* C++ static member. */
6392 /* NOTE: carlton/2002-11-05: It should be a DW_TAG_member that
6393 is a declaration, but all versions of G++ as of this writing
6394 (so through at least 3.2.1) incorrectly generate
6395 DW_TAG_variable tags. */
6399 /* Get name of field. */
6400 fieldname
= dwarf2_name (die
, cu
);
6401 if (fieldname
== NULL
)
6404 attr
= dwarf2_attr (die
, DW_AT_const_value
, cu
);
6406 /* Only create a symbol if this is an external value.
6407 new_symbol checks this and puts the value in the global symbol
6408 table, which we want. If it is not external, new_symbol
6409 will try to put the value in cu->list_in_scope which is wrong. */
6410 && dwarf2_flag_true_p (die
, DW_AT_external
, cu
))
6412 /* A static const member, not much different than an enum as far as
6413 we're concerned, except that we can support more types. */
6414 new_symbol (die
, NULL
, cu
);
6417 /* Get physical name. */
6418 physname
= (char *) dwarf2_physname (fieldname
, die
, cu
);
6420 /* The name is already allocated along with this objfile, so we don't
6421 need to duplicate it for the type. */
6422 SET_FIELD_PHYSNAME (*fp
, physname
? physname
: "");
6423 FIELD_TYPE (*fp
) = die_type (die
, cu
);
6424 FIELD_NAME (*fp
) = fieldname
;
6426 else if (die
->tag
== DW_TAG_inheritance
)
6428 /* C++ base class field. */
6429 attr
= dwarf2_attr (die
, DW_AT_data_member_location
, cu
);
6432 int byte_offset
= 0;
6434 if (attr_form_is_section_offset (attr
))
6435 dwarf2_complex_location_expr_complaint ();
6436 else if (attr_form_is_constant (attr
))
6437 byte_offset
= dwarf2_get_attr_constant_value (attr
, 0);
6438 else if (attr_form_is_block (attr
))
6439 byte_offset
= decode_locdesc (DW_BLOCK (attr
), cu
);
6441 dwarf2_complex_location_expr_complaint ();
6443 SET_FIELD_BITPOS (*fp
, byte_offset
* bits_per_byte
);
6445 FIELD_BITSIZE (*fp
) = 0;
6446 FIELD_TYPE (*fp
) = die_type (die
, cu
);
6447 FIELD_NAME (*fp
) = type_name_no_tag (fp
->type
);
6448 fip
->nbaseclasses
++;
6452 /* Add a typedef defined in the scope of the FIP's class. */
6455 dwarf2_add_typedef (struct field_info
*fip
, struct die_info
*die
,
6456 struct dwarf2_cu
*cu
)
6458 struct objfile
*objfile
= cu
->objfile
;
6459 struct typedef_field_list
*new_field
;
6460 struct attribute
*attr
;
6461 struct typedef_field
*fp
;
6462 char *fieldname
= "";
6464 /* Allocate a new field list entry and link it in. */
6465 new_field
= xzalloc (sizeof (*new_field
));
6466 make_cleanup (xfree
, new_field
);
6468 gdb_assert (die
->tag
== DW_TAG_typedef
);
6470 fp
= &new_field
->field
;
6472 /* Get name of field. */
6473 fp
->name
= dwarf2_name (die
, cu
);
6474 if (fp
->name
== NULL
)
6477 fp
->type
= read_type_die (die
, cu
);
6479 new_field
->next
= fip
->typedef_field_list
;
6480 fip
->typedef_field_list
= new_field
;
6481 fip
->typedef_field_list_count
++;
6484 /* Create the vector of fields, and attach it to the type. */
6487 dwarf2_attach_fields_to_type (struct field_info
*fip
, struct type
*type
,
6488 struct dwarf2_cu
*cu
)
6490 int nfields
= fip
->nfields
;
6492 /* Record the field count, allocate space for the array of fields,
6493 and create blank accessibility bitfields if necessary. */
6494 TYPE_NFIELDS (type
) = nfields
;
6495 TYPE_FIELDS (type
) = (struct field
*)
6496 TYPE_ALLOC (type
, sizeof (struct field
) * nfields
);
6497 memset (TYPE_FIELDS (type
), 0, sizeof (struct field
) * nfields
);
6499 if (fip
->non_public_fields
&& cu
->language
!= language_ada
)
6501 ALLOCATE_CPLUS_STRUCT_TYPE (type
);
6503 TYPE_FIELD_PRIVATE_BITS (type
) =
6504 (B_TYPE
*) TYPE_ALLOC (type
, B_BYTES (nfields
));
6505 B_CLRALL (TYPE_FIELD_PRIVATE_BITS (type
), nfields
);
6507 TYPE_FIELD_PROTECTED_BITS (type
) =
6508 (B_TYPE
*) TYPE_ALLOC (type
, B_BYTES (nfields
));
6509 B_CLRALL (TYPE_FIELD_PROTECTED_BITS (type
), nfields
);
6511 TYPE_FIELD_IGNORE_BITS (type
) =
6512 (B_TYPE
*) TYPE_ALLOC (type
, B_BYTES (nfields
));
6513 B_CLRALL (TYPE_FIELD_IGNORE_BITS (type
), nfields
);
6516 /* If the type has baseclasses, allocate and clear a bit vector for
6517 TYPE_FIELD_VIRTUAL_BITS. */
6518 if (fip
->nbaseclasses
&& cu
->language
!= language_ada
)
6520 int num_bytes
= B_BYTES (fip
->nbaseclasses
);
6521 unsigned char *pointer
;
6523 ALLOCATE_CPLUS_STRUCT_TYPE (type
);
6524 pointer
= TYPE_ALLOC (type
, num_bytes
);
6525 TYPE_FIELD_VIRTUAL_BITS (type
) = pointer
;
6526 B_CLRALL (TYPE_FIELD_VIRTUAL_BITS (type
), fip
->nbaseclasses
);
6527 TYPE_N_BASECLASSES (type
) = fip
->nbaseclasses
;
6530 /* Copy the saved-up fields into the field vector. Start from the head of
6531 the list, adding to the tail of the field array, so that they end up in
6532 the same order in the array in which they were added to the list. */
6533 while (nfields
-- > 0)
6535 struct nextfield
*fieldp
;
6539 fieldp
= fip
->fields
;
6540 fip
->fields
= fieldp
->next
;
6544 fieldp
= fip
->baseclasses
;
6545 fip
->baseclasses
= fieldp
->next
;
6548 TYPE_FIELD (type
, nfields
) = fieldp
->field
;
6549 switch (fieldp
->accessibility
)
6551 case DW_ACCESS_private
:
6552 if (cu
->language
!= language_ada
)
6553 SET_TYPE_FIELD_PRIVATE (type
, nfields
);
6556 case DW_ACCESS_protected
:
6557 if (cu
->language
!= language_ada
)
6558 SET_TYPE_FIELD_PROTECTED (type
, nfields
);
6561 case DW_ACCESS_public
:
6565 /* Unknown accessibility. Complain and treat it as public. */
6567 complaint (&symfile_complaints
, _("unsupported accessibility %d"),
6568 fieldp
->accessibility
);
6572 if (nfields
< fip
->nbaseclasses
)
6574 switch (fieldp
->virtuality
)
6576 case DW_VIRTUALITY_virtual
:
6577 case DW_VIRTUALITY_pure_virtual
:
6578 if (cu
->language
== language_ada
)
6579 error (_("unexpected virtuality in component of Ada type"));
6580 SET_TYPE_FIELD_VIRTUAL (type
, nfields
);
6587 /* Add a member function to the proper fieldlist. */
6590 dwarf2_add_member_fn (struct field_info
*fip
, struct die_info
*die
,
6591 struct type
*type
, struct dwarf2_cu
*cu
)
6593 struct objfile
*objfile
= cu
->objfile
;
6594 struct attribute
*attr
;
6595 struct fnfieldlist
*flp
;
6597 struct fn_field
*fnp
;
6599 struct nextfnfield
*new_fnfield
;
6600 struct type
*this_type
;
6602 if (cu
->language
== language_ada
)
6603 error (_("unexpected member function in Ada type"));
6605 /* Get name of member function. */
6606 fieldname
= dwarf2_name (die
, cu
);
6607 if (fieldname
== NULL
)
6610 /* Look up member function name in fieldlist. */
6611 for (i
= 0; i
< fip
->nfnfields
; i
++)
6613 if (strcmp (fip
->fnfieldlists
[i
].name
, fieldname
) == 0)
6617 /* Create new list element if necessary. */
6618 if (i
< fip
->nfnfields
)
6619 flp
= &fip
->fnfieldlists
[i
];
6622 if ((fip
->nfnfields
% DW_FIELD_ALLOC_CHUNK
) == 0)
6624 fip
->fnfieldlists
= (struct fnfieldlist
*)
6625 xrealloc (fip
->fnfieldlists
,
6626 (fip
->nfnfields
+ DW_FIELD_ALLOC_CHUNK
)
6627 * sizeof (struct fnfieldlist
));
6628 if (fip
->nfnfields
== 0)
6629 make_cleanup (free_current_contents
, &fip
->fnfieldlists
);
6631 flp
= &fip
->fnfieldlists
[fip
->nfnfields
];
6632 flp
->name
= fieldname
;
6635 i
= fip
->nfnfields
++;
6638 /* Create a new member function field and chain it to the field list
6640 new_fnfield
= (struct nextfnfield
*) xmalloc (sizeof (struct nextfnfield
));
6641 make_cleanup (xfree
, new_fnfield
);
6642 memset (new_fnfield
, 0, sizeof (struct nextfnfield
));
6643 new_fnfield
->next
= flp
->head
;
6644 flp
->head
= new_fnfield
;
6647 /* Fill in the member function field info. */
6648 fnp
= &new_fnfield
->fnfield
;
6650 /* Delay processing of the physname until later. */
6651 if (cu
->language
== language_cplus
|| cu
->language
== language_java
)
6653 add_to_method_list (type
, i
, flp
->length
- 1, fieldname
,
6658 char *physname
= (char *) dwarf2_physname (fieldname
, die
, cu
);
6659 fnp
->physname
= physname
? physname
: "";
6662 fnp
->type
= alloc_type (objfile
);
6663 this_type
= read_type_die (die
, cu
);
6664 if (this_type
&& TYPE_CODE (this_type
) == TYPE_CODE_FUNC
)
6666 int nparams
= TYPE_NFIELDS (this_type
);
6668 /* TYPE is the domain of this method, and THIS_TYPE is the type
6669 of the method itself (TYPE_CODE_METHOD). */
6670 smash_to_method_type (fnp
->type
, type
,
6671 TYPE_TARGET_TYPE (this_type
),
6672 TYPE_FIELDS (this_type
),
6673 TYPE_NFIELDS (this_type
),
6674 TYPE_VARARGS (this_type
));
6676 /* Handle static member functions.
6677 Dwarf2 has no clean way to discern C++ static and non-static
6678 member functions. G++ helps GDB by marking the first
6679 parameter for non-static member functions (which is the this
6680 pointer) as artificial. We obtain this information from
6681 read_subroutine_type via TYPE_FIELD_ARTIFICIAL. */
6682 if (nparams
== 0 || TYPE_FIELD_ARTIFICIAL (this_type
, 0) == 0)
6683 fnp
->voffset
= VOFFSET_STATIC
;
6686 complaint (&symfile_complaints
, _("member function type missing for '%s'"),
6687 dwarf2_full_name (fieldname
, die
, cu
));
6689 /* Get fcontext from DW_AT_containing_type if present. */
6690 if (dwarf2_attr (die
, DW_AT_containing_type
, cu
) != NULL
)
6691 fnp
->fcontext
= die_containing_type (die
, cu
);
6693 /* dwarf2 doesn't have stubbed physical names, so the setting of is_const and
6694 is_volatile is irrelevant, as it is needed by gdb_mangle_name only. */
6696 /* Get accessibility. */
6697 attr
= dwarf2_attr (die
, DW_AT_accessibility
, cu
);
6700 switch (DW_UNSND (attr
))
6702 case DW_ACCESS_private
:
6703 fnp
->is_private
= 1;
6705 case DW_ACCESS_protected
:
6706 fnp
->is_protected
= 1;
6711 /* Check for artificial methods. */
6712 attr
= dwarf2_attr (die
, DW_AT_artificial
, cu
);
6713 if (attr
&& DW_UNSND (attr
) != 0)
6714 fnp
->is_artificial
= 1;
6716 /* Get index in virtual function table if it is a virtual member
6717 function. For older versions of GCC, this is an offset in the
6718 appropriate virtual table, as specified by DW_AT_containing_type.
6719 For everyone else, it is an expression to be evaluated relative
6720 to the object address. */
6722 attr
= dwarf2_attr (die
, DW_AT_vtable_elem_location
, cu
);
6725 if (attr_form_is_block (attr
) && DW_BLOCK (attr
)->size
> 0)
6727 if (DW_BLOCK (attr
)->data
[0] == DW_OP_constu
)
6729 /* Old-style GCC. */
6730 fnp
->voffset
= decode_locdesc (DW_BLOCK (attr
), cu
) + 2;
6732 else if (DW_BLOCK (attr
)->data
[0] == DW_OP_deref
6733 || (DW_BLOCK (attr
)->size
> 1
6734 && DW_BLOCK (attr
)->data
[0] == DW_OP_deref_size
6735 && DW_BLOCK (attr
)->data
[1] == cu
->header
.addr_size
))
6737 struct dwarf_block blk
;
6740 offset
= (DW_BLOCK (attr
)->data
[0] == DW_OP_deref
6742 blk
.size
= DW_BLOCK (attr
)->size
- offset
;
6743 blk
.data
= DW_BLOCK (attr
)->data
+ offset
;
6744 fnp
->voffset
= decode_locdesc (DW_BLOCK (attr
), cu
);
6745 if ((fnp
->voffset
% cu
->header
.addr_size
) != 0)
6746 dwarf2_complex_location_expr_complaint ();
6748 fnp
->voffset
/= cu
->header
.addr_size
;
6752 dwarf2_complex_location_expr_complaint ();
6755 fnp
->fcontext
= TYPE_TARGET_TYPE (TYPE_FIELD_TYPE (this_type
, 0));
6757 else if (attr_form_is_section_offset (attr
))
6759 dwarf2_complex_location_expr_complaint ();
6763 dwarf2_invalid_attrib_class_complaint ("DW_AT_vtable_elem_location",
6769 attr
= dwarf2_attr (die
, DW_AT_virtuality
, cu
);
6770 if (attr
&& DW_UNSND (attr
))
6772 /* GCC does this, as of 2008-08-25; PR debug/37237. */
6773 complaint (&symfile_complaints
,
6774 _("Member function \"%s\" (offset %d) is virtual "
6775 "but the vtable offset is not specified"),
6776 fieldname
, die
->offset
);
6777 ALLOCATE_CPLUS_STRUCT_TYPE (type
);
6778 TYPE_CPLUS_DYNAMIC (type
) = 1;
6783 /* Create the vector of member function fields, and attach it to the type. */
6786 dwarf2_attach_fn_fields_to_type (struct field_info
*fip
, struct type
*type
,
6787 struct dwarf2_cu
*cu
)
6789 struct fnfieldlist
*flp
;
6790 int total_length
= 0;
6793 if (cu
->language
== language_ada
)
6794 error (_("unexpected member functions in Ada type"));
6796 ALLOCATE_CPLUS_STRUCT_TYPE (type
);
6797 TYPE_FN_FIELDLISTS (type
) = (struct fn_fieldlist
*)
6798 TYPE_ALLOC (type
, sizeof (struct fn_fieldlist
) * fip
->nfnfields
);
6800 for (i
= 0, flp
= fip
->fnfieldlists
; i
< fip
->nfnfields
; i
++, flp
++)
6802 struct nextfnfield
*nfp
= flp
->head
;
6803 struct fn_fieldlist
*fn_flp
= &TYPE_FN_FIELDLIST (type
, i
);
6806 TYPE_FN_FIELDLIST_NAME (type
, i
) = flp
->name
;
6807 TYPE_FN_FIELDLIST_LENGTH (type
, i
) = flp
->length
;
6808 fn_flp
->fn_fields
= (struct fn_field
*)
6809 TYPE_ALLOC (type
, sizeof (struct fn_field
) * flp
->length
);
6810 for (k
= flp
->length
; (k
--, nfp
); nfp
= nfp
->next
)
6811 fn_flp
->fn_fields
[k
] = nfp
->fnfield
;
6813 total_length
+= flp
->length
;
6816 TYPE_NFN_FIELDS (type
) = fip
->nfnfields
;
6817 TYPE_NFN_FIELDS_TOTAL (type
) = total_length
;
6820 /* Returns non-zero if NAME is the name of a vtable member in CU's
6821 language, zero otherwise. */
6823 is_vtable_name (const char *name
, struct dwarf2_cu
*cu
)
6825 static const char vptr
[] = "_vptr";
6826 static const char vtable
[] = "vtable";
6828 /* Look for the C++ and Java forms of the vtable. */
6829 if ((cu
->language
== language_java
6830 && strncmp (name
, vtable
, sizeof (vtable
) - 1) == 0)
6831 || (strncmp (name
, vptr
, sizeof (vptr
) - 1) == 0
6832 && is_cplus_marker (name
[sizeof (vptr
) - 1])))
6838 /* GCC outputs unnamed structures that are really pointers to member
6839 functions, with the ABI-specified layout. If TYPE describes
6840 such a structure, smash it into a member function type.
6842 GCC shouldn't do this; it should just output pointer to member DIEs.
6843 This is GCC PR debug/28767. */
6846 quirk_gcc_member_function_pointer (struct type
*type
, struct objfile
*objfile
)
6848 struct type
*pfn_type
, *domain_type
, *new_type
;
6850 /* Check for a structure with no name and two children. */
6851 if (TYPE_CODE (type
) != TYPE_CODE_STRUCT
|| TYPE_NFIELDS (type
) != 2)
6854 /* Check for __pfn and __delta members. */
6855 if (TYPE_FIELD_NAME (type
, 0) == NULL
6856 || strcmp (TYPE_FIELD_NAME (type
, 0), "__pfn") != 0
6857 || TYPE_FIELD_NAME (type
, 1) == NULL
6858 || strcmp (TYPE_FIELD_NAME (type
, 1), "__delta") != 0)
6861 /* Find the type of the method. */
6862 pfn_type
= TYPE_FIELD_TYPE (type
, 0);
6863 if (pfn_type
== NULL
6864 || TYPE_CODE (pfn_type
) != TYPE_CODE_PTR
6865 || TYPE_CODE (TYPE_TARGET_TYPE (pfn_type
)) != TYPE_CODE_FUNC
)
6868 /* Look for the "this" argument. */
6869 pfn_type
= TYPE_TARGET_TYPE (pfn_type
);
6870 if (TYPE_NFIELDS (pfn_type
) == 0
6871 /* || TYPE_FIELD_TYPE (pfn_type, 0) == NULL */
6872 || TYPE_CODE (TYPE_FIELD_TYPE (pfn_type
, 0)) != TYPE_CODE_PTR
)
6875 domain_type
= TYPE_TARGET_TYPE (TYPE_FIELD_TYPE (pfn_type
, 0));
6876 new_type
= alloc_type (objfile
);
6877 smash_to_method_type (new_type
, domain_type
, TYPE_TARGET_TYPE (pfn_type
),
6878 TYPE_FIELDS (pfn_type
), TYPE_NFIELDS (pfn_type
),
6879 TYPE_VARARGS (pfn_type
));
6880 smash_to_methodptr_type (type
, new_type
);
6883 /* Called when we find the DIE that starts a structure or union scope
6884 (definition) to create a type for the structure or union. Fill in
6885 the type's name and general properties; the members will not be
6886 processed until process_structure_type.
6888 NOTE: we need to call these functions regardless of whether or not the
6889 DIE has a DW_AT_name attribute, since it might be an anonymous
6890 structure or union. This gets the type entered into our set of
6893 However, if the structure is incomplete (an opaque struct/union)
6894 then suppress creating a symbol table entry for it since gdb only
6895 wants to find the one with the complete definition. Note that if
6896 it is complete, we just call new_symbol, which does it's own
6897 checking about whether the struct/union is anonymous or not (and
6898 suppresses creating a symbol table entry itself). */
6900 static struct type
*
6901 read_structure_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
6903 struct objfile
*objfile
= cu
->objfile
;
6905 struct attribute
*attr
;
6908 /* If the definition of this type lives in .debug_types, read that type.
6909 Don't follow DW_AT_specification though, that will take us back up
6910 the chain and we want to go down. */
6911 attr
= dwarf2_attr_no_follow (die
, DW_AT_signature
, cu
);
6914 struct dwarf2_cu
*type_cu
= cu
;
6915 struct die_info
*type_die
= follow_die_ref_or_sig (die
, attr
, &type_cu
);
6917 /* We could just recurse on read_structure_type, but we need to call
6918 get_die_type to ensure only one type for this DIE is created.
6919 This is important, for example, because for c++ classes we need
6920 TYPE_NAME set which is only done by new_symbol. Blech. */
6921 type
= read_type_die (type_die
, type_cu
);
6923 /* TYPE_CU may not be the same as CU.
6924 Ensure TYPE is recorded in CU's type_hash table. */
6925 return set_die_type (die
, type
, cu
);
6928 type
= alloc_type (objfile
);
6929 INIT_CPLUS_SPECIFIC (type
);
6931 name
= dwarf2_name (die
, cu
);
6934 if (cu
->language
== language_cplus
6935 || cu
->language
== language_java
)
6937 char *full_name
= (char *) dwarf2_full_name (name
, die
, cu
);
6939 /* dwarf2_full_name might have already finished building the DIE's
6940 type. If so, there is no need to continue. */
6941 if (get_die_type (die
, cu
) != NULL
)
6942 return get_die_type (die
, cu
);
6944 TYPE_TAG_NAME (type
) = full_name
;
6945 if (die
->tag
== DW_TAG_structure_type
6946 || die
->tag
== DW_TAG_class_type
)
6947 TYPE_NAME (type
) = TYPE_TAG_NAME (type
);
6951 /* The name is already allocated along with this objfile, so
6952 we don't need to duplicate it for the type. */
6953 TYPE_TAG_NAME (type
) = (char *) name
;
6954 if (die
->tag
== DW_TAG_class_type
)
6955 TYPE_NAME (type
) = TYPE_TAG_NAME (type
);
6959 if (die
->tag
== DW_TAG_structure_type
)
6961 TYPE_CODE (type
) = TYPE_CODE_STRUCT
;
6963 else if (die
->tag
== DW_TAG_union_type
)
6965 TYPE_CODE (type
) = TYPE_CODE_UNION
;
6969 TYPE_CODE (type
) = TYPE_CODE_CLASS
;
6972 if (cu
->language
== language_cplus
&& die
->tag
== DW_TAG_class_type
)
6973 TYPE_DECLARED_CLASS (type
) = 1;
6975 attr
= dwarf2_attr (die
, DW_AT_byte_size
, cu
);
6978 TYPE_LENGTH (type
) = DW_UNSND (attr
);
6982 TYPE_LENGTH (type
) = 0;
6985 TYPE_STUB_SUPPORTED (type
) = 1;
6986 if (die_is_declaration (die
, cu
))
6987 TYPE_STUB (type
) = 1;
6988 else if (attr
== NULL
&& die
->child
== NULL
6989 && producer_is_realview (cu
->producer
))
6990 /* RealView does not output the required DW_AT_declaration
6991 on incomplete types. */
6992 TYPE_STUB (type
) = 1;
6994 /* We need to add the type field to the die immediately so we don't
6995 infinitely recurse when dealing with pointers to the structure
6996 type within the structure itself. */
6997 set_die_type (die
, type
, cu
);
6999 /* set_die_type should be already done. */
7000 set_descriptive_type (type
, die
, cu
);
7005 /* Finish creating a structure or union type, including filling in
7006 its members and creating a symbol for it. */
7009 process_structure_scope (struct die_info
*die
, struct dwarf2_cu
*cu
)
7011 struct objfile
*objfile
= cu
->objfile
;
7012 struct die_info
*child_die
= die
->child
;
7015 type
= get_die_type (die
, cu
);
7017 type
= read_structure_type (die
, cu
);
7019 if (die
->child
!= NULL
&& ! die_is_declaration (die
, cu
))
7021 struct field_info fi
;
7022 struct die_info
*child_die
;
7023 VEC (symbolp
) *template_args
= NULL
;
7024 struct cleanup
*back_to
= make_cleanup (null_cleanup
, 0);
7026 memset (&fi
, 0, sizeof (struct field_info
));
7028 child_die
= die
->child
;
7030 while (child_die
&& child_die
->tag
)
7032 if (child_die
->tag
== DW_TAG_member
7033 || child_die
->tag
== DW_TAG_variable
)
7035 /* NOTE: carlton/2002-11-05: A C++ static data member
7036 should be a DW_TAG_member that is a declaration, but
7037 all versions of G++ as of this writing (so through at
7038 least 3.2.1) incorrectly generate DW_TAG_variable
7039 tags for them instead. */
7040 dwarf2_add_field (&fi
, child_die
, cu
);
7042 else if (child_die
->tag
== DW_TAG_subprogram
)
7044 /* C++ member function. */
7045 dwarf2_add_member_fn (&fi
, child_die
, type
, cu
);
7047 else if (child_die
->tag
== DW_TAG_inheritance
)
7049 /* C++ base class field. */
7050 dwarf2_add_field (&fi
, child_die
, cu
);
7052 else if (child_die
->tag
== DW_TAG_typedef
)
7053 dwarf2_add_typedef (&fi
, child_die
, cu
);
7054 else if (child_die
->tag
== DW_TAG_template_type_param
7055 || child_die
->tag
== DW_TAG_template_value_param
)
7057 struct symbol
*arg
= new_symbol (child_die
, NULL
, cu
);
7060 VEC_safe_push (symbolp
, template_args
, arg
);
7063 child_die
= sibling_die (child_die
);
7066 /* Attach template arguments to type. */
7067 if (! VEC_empty (symbolp
, template_args
))
7069 ALLOCATE_CPLUS_STRUCT_TYPE (type
);
7070 TYPE_N_TEMPLATE_ARGUMENTS (type
)
7071 = VEC_length (symbolp
, template_args
);
7072 TYPE_TEMPLATE_ARGUMENTS (type
)
7073 = obstack_alloc (&objfile
->objfile_obstack
,
7074 (TYPE_N_TEMPLATE_ARGUMENTS (type
)
7075 * sizeof (struct symbol
*)));
7076 memcpy (TYPE_TEMPLATE_ARGUMENTS (type
),
7077 VEC_address (symbolp
, template_args
),
7078 (TYPE_N_TEMPLATE_ARGUMENTS (type
)
7079 * sizeof (struct symbol
*)));
7080 VEC_free (symbolp
, template_args
);
7083 /* Attach fields and member functions to the type. */
7085 dwarf2_attach_fields_to_type (&fi
, type
, cu
);
7088 dwarf2_attach_fn_fields_to_type (&fi
, type
, cu
);
7090 /* Get the type which refers to the base class (possibly this
7091 class itself) which contains the vtable pointer for the current
7092 class from the DW_AT_containing_type attribute. This use of
7093 DW_AT_containing_type is a GNU extension. */
7095 if (dwarf2_attr (die
, DW_AT_containing_type
, cu
) != NULL
)
7097 struct type
*t
= die_containing_type (die
, cu
);
7099 TYPE_VPTR_BASETYPE (type
) = t
;
7104 /* Our own class provides vtbl ptr. */
7105 for (i
= TYPE_NFIELDS (t
) - 1;
7106 i
>= TYPE_N_BASECLASSES (t
);
7109 char *fieldname
= TYPE_FIELD_NAME (t
, i
);
7111 if (is_vtable_name (fieldname
, cu
))
7113 TYPE_VPTR_FIELDNO (type
) = i
;
7118 /* Complain if virtual function table field not found. */
7119 if (i
< TYPE_N_BASECLASSES (t
))
7120 complaint (&symfile_complaints
,
7121 _("virtual function table pointer "
7122 "not found when defining class '%s'"),
7123 TYPE_TAG_NAME (type
) ? TYPE_TAG_NAME (type
) :
7128 TYPE_VPTR_FIELDNO (type
) = TYPE_VPTR_FIELDNO (t
);
7131 else if (cu
->producer
7132 && strncmp (cu
->producer
,
7133 "IBM(R) XL C/C++ Advanced Edition", 32) == 0)
7135 /* The IBM XLC compiler does not provide direct indication
7136 of the containing type, but the vtable pointer is
7137 always named __vfp. */
7141 for (i
= TYPE_NFIELDS (type
) - 1;
7142 i
>= TYPE_N_BASECLASSES (type
);
7145 if (strcmp (TYPE_FIELD_NAME (type
, i
), "__vfp") == 0)
7147 TYPE_VPTR_FIELDNO (type
) = i
;
7148 TYPE_VPTR_BASETYPE (type
) = type
;
7155 /* Copy fi.typedef_field_list linked list elements content into the
7156 allocated array TYPE_TYPEDEF_FIELD_ARRAY (type). */
7157 if (fi
.typedef_field_list
)
7159 int i
= fi
.typedef_field_list_count
;
7161 ALLOCATE_CPLUS_STRUCT_TYPE (type
);
7162 TYPE_TYPEDEF_FIELD_ARRAY (type
)
7163 = TYPE_ALLOC (type
, sizeof (TYPE_TYPEDEF_FIELD (type
, 0)) * i
);
7164 TYPE_TYPEDEF_FIELD_COUNT (type
) = i
;
7166 /* Reverse the list order to keep the debug info elements order. */
7169 struct typedef_field
*dest
, *src
;
7171 dest
= &TYPE_TYPEDEF_FIELD (type
, i
);
7172 src
= &fi
.typedef_field_list
->field
;
7173 fi
.typedef_field_list
= fi
.typedef_field_list
->next
;
7178 do_cleanups (back_to
);
7181 quirk_gcc_member_function_pointer (type
, cu
->objfile
);
7183 /* NOTE: carlton/2004-03-16: GCC 3.4 (or at least one of its
7184 snapshots) has been known to create a die giving a declaration
7185 for a class that has, as a child, a die giving a definition for a
7186 nested class. So we have to process our children even if the
7187 current die is a declaration. Normally, of course, a declaration
7188 won't have any children at all. */
7190 while (child_die
!= NULL
&& child_die
->tag
)
7192 if (child_die
->tag
== DW_TAG_member
7193 || child_die
->tag
== DW_TAG_variable
7194 || child_die
->tag
== DW_TAG_inheritance
7195 || child_die
->tag
== DW_TAG_template_value_param
7196 || child_die
->tag
== DW_TAG_template_type_param
)
7201 process_die (child_die
, cu
);
7203 child_die
= sibling_die (child_die
);
7206 /* Do not consider external references. According to the DWARF standard,
7207 these DIEs are identified by the fact that they have no byte_size
7208 attribute, and a declaration attribute. */
7209 if (dwarf2_attr (die
, DW_AT_byte_size
, cu
) != NULL
7210 || !die_is_declaration (die
, cu
))
7211 new_symbol (die
, type
, cu
);
7214 /* Given a DW_AT_enumeration_type die, set its type. We do not
7215 complete the type's fields yet, or create any symbols. */
7217 static struct type
*
7218 read_enumeration_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
7220 struct objfile
*objfile
= cu
->objfile
;
7222 struct attribute
*attr
;
7225 /* If the definition of this type lives in .debug_types, read that type.
7226 Don't follow DW_AT_specification though, that will take us back up
7227 the chain and we want to go down. */
7228 attr
= dwarf2_attr_no_follow (die
, DW_AT_signature
, cu
);
7231 struct dwarf2_cu
*type_cu
= cu
;
7232 struct die_info
*type_die
= follow_die_ref_or_sig (die
, attr
, &type_cu
);
7234 type
= read_type_die (type_die
, type_cu
);
7236 /* TYPE_CU may not be the same as CU.
7237 Ensure TYPE is recorded in CU's type_hash table. */
7238 return set_die_type (die
, type
, cu
);
7241 type
= alloc_type (objfile
);
7243 TYPE_CODE (type
) = TYPE_CODE_ENUM
;
7244 name
= dwarf2_full_name (NULL
, die
, cu
);
7246 TYPE_TAG_NAME (type
) = (char *) name
;
7248 attr
= dwarf2_attr (die
, DW_AT_byte_size
, cu
);
7251 TYPE_LENGTH (type
) = DW_UNSND (attr
);
7255 TYPE_LENGTH (type
) = 0;
7258 /* The enumeration DIE can be incomplete. In Ada, any type can be
7259 declared as private in the package spec, and then defined only
7260 inside the package body. Such types are known as Taft Amendment
7261 Types. When another package uses such a type, an incomplete DIE
7262 may be generated by the compiler. */
7263 if (die_is_declaration (die
, cu
))
7264 TYPE_STUB (type
) = 1;
7266 return set_die_type (die
, type
, cu
);
7269 /* Given a pointer to a die which begins an enumeration, process all
7270 the dies that define the members of the enumeration, and create the
7271 symbol for the enumeration type.
7273 NOTE: We reverse the order of the element list. */
7276 process_enumeration_scope (struct die_info
*die
, struct dwarf2_cu
*cu
)
7278 struct type
*this_type
;
7280 this_type
= get_die_type (die
, cu
);
7281 if (this_type
== NULL
)
7282 this_type
= read_enumeration_type (die
, cu
);
7284 if (die
->child
!= NULL
)
7286 struct die_info
*child_die
;
7288 struct field
*fields
= NULL
;
7290 int unsigned_enum
= 1;
7293 child_die
= die
->child
;
7294 while (child_die
&& child_die
->tag
)
7296 if (child_die
->tag
!= DW_TAG_enumerator
)
7298 process_die (child_die
, cu
);
7302 name
= dwarf2_name (child_die
, cu
);
7305 sym
= new_symbol (child_die
, this_type
, cu
);
7306 if (SYMBOL_VALUE (sym
) < 0)
7309 if ((num_fields
% DW_FIELD_ALLOC_CHUNK
) == 0)
7311 fields
= (struct field
*)
7313 (num_fields
+ DW_FIELD_ALLOC_CHUNK
)
7314 * sizeof (struct field
));
7317 FIELD_NAME (fields
[num_fields
]) = SYMBOL_LINKAGE_NAME (sym
);
7318 FIELD_TYPE (fields
[num_fields
]) = NULL
;
7319 SET_FIELD_BITPOS (fields
[num_fields
], SYMBOL_VALUE (sym
));
7320 FIELD_BITSIZE (fields
[num_fields
]) = 0;
7326 child_die
= sibling_die (child_die
);
7331 TYPE_NFIELDS (this_type
) = num_fields
;
7332 TYPE_FIELDS (this_type
) = (struct field
*)
7333 TYPE_ALLOC (this_type
, sizeof (struct field
) * num_fields
);
7334 memcpy (TYPE_FIELDS (this_type
), fields
,
7335 sizeof (struct field
) * num_fields
);
7339 TYPE_UNSIGNED (this_type
) = 1;
7342 new_symbol (die
, this_type
, cu
);
7345 /* Extract all information from a DW_TAG_array_type DIE and put it in
7346 the DIE's type field. For now, this only handles one dimensional
7349 static struct type
*
7350 read_array_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
7352 struct objfile
*objfile
= cu
->objfile
;
7353 struct die_info
*child_die
;
7355 struct type
*element_type
, *range_type
, *index_type
;
7356 struct type
**range_types
= NULL
;
7357 struct attribute
*attr
;
7359 struct cleanup
*back_to
;
7362 element_type
= die_type (die
, cu
);
7364 /* The die_type call above may have already set the type for this DIE. */
7365 type
= get_die_type (die
, cu
);
7369 /* Irix 6.2 native cc creates array types without children for
7370 arrays with unspecified length. */
7371 if (die
->child
== NULL
)
7373 index_type
= objfile_type (objfile
)->builtin_int
;
7374 range_type
= create_range_type (NULL
, index_type
, 0, -1);
7375 type
= create_array_type (NULL
, element_type
, range_type
);
7376 return set_die_type (die
, type
, cu
);
7379 back_to
= make_cleanup (null_cleanup
, NULL
);
7380 child_die
= die
->child
;
7381 while (child_die
&& child_die
->tag
)
7383 if (child_die
->tag
== DW_TAG_subrange_type
)
7385 struct type
*child_type
= read_type_die (child_die
, cu
);
7387 if (child_type
!= NULL
)
7389 /* The range type was succesfully read. Save it for the
7390 array type creation. */
7391 if ((ndim
% DW_FIELD_ALLOC_CHUNK
) == 0)
7393 range_types
= (struct type
**)
7394 xrealloc (range_types
, (ndim
+ DW_FIELD_ALLOC_CHUNK
)
7395 * sizeof (struct type
*));
7397 make_cleanup (free_current_contents
, &range_types
);
7399 range_types
[ndim
++] = child_type
;
7402 child_die
= sibling_die (child_die
);
7405 /* Dwarf2 dimensions are output from left to right, create the
7406 necessary array types in backwards order. */
7408 type
= element_type
;
7410 if (read_array_order (die
, cu
) == DW_ORD_col_major
)
7415 type
= create_array_type (NULL
, type
, range_types
[i
++]);
7420 type
= create_array_type (NULL
, type
, range_types
[ndim
]);
7423 /* Understand Dwarf2 support for vector types (like they occur on
7424 the PowerPC w/ AltiVec). Gcc just adds another attribute to the
7425 array type. This is not part of the Dwarf2/3 standard yet, but a
7426 custom vendor extension. The main difference between a regular
7427 array and the vector variant is that vectors are passed by value
7429 attr
= dwarf2_attr (die
, DW_AT_GNU_vector
, cu
);
7431 make_vector_type (type
);
7433 /* The DIE may have DW_AT_byte_size set. For example an OpenCL
7434 implementation may choose to implement triple vectors using this
7436 attr
= dwarf2_attr (die
, DW_AT_byte_size
, cu
);
7439 if (DW_UNSND (attr
) >= TYPE_LENGTH (type
))
7440 TYPE_LENGTH (type
) = DW_UNSND (attr
);
7442 complaint (&symfile_complaints
,
7443 _("DW_AT_byte_size for array type smaller "
7444 "than the total size of elements"));
7447 name
= dwarf2_name (die
, cu
);
7449 TYPE_NAME (type
) = name
;
7451 /* Install the type in the die. */
7452 set_die_type (die
, type
, cu
);
7454 /* set_die_type should be already done. */
7455 set_descriptive_type (type
, die
, cu
);
7457 do_cleanups (back_to
);
7462 static enum dwarf_array_dim_ordering
7463 read_array_order (struct die_info
*die
, struct dwarf2_cu
*cu
)
7465 struct attribute
*attr
;
7467 attr
= dwarf2_attr (die
, DW_AT_ordering
, cu
);
7469 if (attr
) return DW_SND (attr
);
7471 /* GNU F77 is a special case, as at 08/2004 array type info is the
7472 opposite order to the dwarf2 specification, but data is still
7473 laid out as per normal fortran.
7475 FIXME: dsl/2004-8-20: If G77 is ever fixed, this will also need
7476 version checking. */
7478 if (cu
->language
== language_fortran
7479 && cu
->producer
&& strstr (cu
->producer
, "GNU F77"))
7481 return DW_ORD_row_major
;
7484 switch (cu
->language_defn
->la_array_ordering
)
7486 case array_column_major
:
7487 return DW_ORD_col_major
;
7488 case array_row_major
:
7490 return DW_ORD_row_major
;
7494 /* Extract all information from a DW_TAG_set_type DIE and put it in
7495 the DIE's type field. */
7497 static struct type
*
7498 read_set_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
7500 struct type
*domain_type
, *set_type
;
7501 struct attribute
*attr
;
7503 domain_type
= die_type (die
, cu
);
7505 /* The die_type call above may have already set the type for this DIE. */
7506 set_type
= get_die_type (die
, cu
);
7510 set_type
= create_set_type (NULL
, domain_type
);
7512 attr
= dwarf2_attr (die
, DW_AT_byte_size
, cu
);
7514 TYPE_LENGTH (set_type
) = DW_UNSND (attr
);
7516 return set_die_type (die
, set_type
, cu
);
7519 /* First cut: install each common block member as a global variable. */
7522 read_common_block (struct die_info
*die
, struct dwarf2_cu
*cu
)
7524 struct die_info
*child_die
;
7525 struct attribute
*attr
;
7527 CORE_ADDR base
= (CORE_ADDR
) 0;
7529 attr
= dwarf2_attr (die
, DW_AT_location
, cu
);
7532 /* Support the .debug_loc offsets. */
7533 if (attr_form_is_block (attr
))
7535 base
= decode_locdesc (DW_BLOCK (attr
), cu
);
7537 else if (attr_form_is_section_offset (attr
))
7539 dwarf2_complex_location_expr_complaint ();
7543 dwarf2_invalid_attrib_class_complaint ("DW_AT_location",
7544 "common block member");
7547 if (die
->child
!= NULL
)
7549 child_die
= die
->child
;
7550 while (child_die
&& child_die
->tag
)
7552 sym
= new_symbol (child_die
, NULL
, cu
);
7553 attr
= dwarf2_attr (child_die
, DW_AT_data_member_location
, cu
);
7554 if (sym
!= NULL
&& attr
!= NULL
)
7556 CORE_ADDR byte_offset
= 0;
7558 if (attr_form_is_section_offset (attr
))
7559 dwarf2_complex_location_expr_complaint ();
7560 else if (attr_form_is_constant (attr
))
7561 byte_offset
= dwarf2_get_attr_constant_value (attr
, 0);
7562 else if (attr_form_is_block (attr
))
7563 byte_offset
= decode_locdesc (DW_BLOCK (attr
), cu
);
7565 dwarf2_complex_location_expr_complaint ();
7567 SYMBOL_VALUE_ADDRESS (sym
) = base
+ byte_offset
;
7568 add_symbol_to_list (sym
, &global_symbols
);
7570 child_die
= sibling_die (child_die
);
7575 /* Create a type for a C++ namespace. */
7577 static struct type
*
7578 read_namespace_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
7580 struct objfile
*objfile
= cu
->objfile
;
7581 const char *previous_prefix
, *name
;
7585 /* For extensions, reuse the type of the original namespace. */
7586 if (dwarf2_attr (die
, DW_AT_extension
, cu
) != NULL
)
7588 struct die_info
*ext_die
;
7589 struct dwarf2_cu
*ext_cu
= cu
;
7591 ext_die
= dwarf2_extension (die
, &ext_cu
);
7592 type
= read_type_die (ext_die
, ext_cu
);
7594 /* EXT_CU may not be the same as CU.
7595 Ensure TYPE is recorded in CU's type_hash table. */
7596 return set_die_type (die
, type
, cu
);
7599 name
= namespace_name (die
, &is_anonymous
, cu
);
7601 /* Now build the name of the current namespace. */
7603 previous_prefix
= determine_prefix (die
, cu
);
7604 if (previous_prefix
[0] != '\0')
7605 name
= typename_concat (&objfile
->objfile_obstack
,
7606 previous_prefix
, name
, 0, cu
);
7608 /* Create the type. */
7609 type
= init_type (TYPE_CODE_NAMESPACE
, 0, 0, NULL
,
7611 TYPE_NAME (type
) = (char *) name
;
7612 TYPE_TAG_NAME (type
) = TYPE_NAME (type
);
7614 return set_die_type (die
, type
, cu
);
7617 /* Read a C++ namespace. */
7620 read_namespace (struct die_info
*die
, struct dwarf2_cu
*cu
)
7622 struct objfile
*objfile
= cu
->objfile
;
7625 /* Add a symbol associated to this if we haven't seen the namespace
7626 before. Also, add a using directive if it's an anonymous
7629 if (dwarf2_attr (die
, DW_AT_extension
, cu
) == NULL
)
7633 type
= read_type_die (die
, cu
);
7634 new_symbol (die
, type
, cu
);
7636 namespace_name (die
, &is_anonymous
, cu
);
7639 const char *previous_prefix
= determine_prefix (die
, cu
);
7641 cp_add_using_directive (previous_prefix
, TYPE_NAME (type
), NULL
,
7642 NULL
, &objfile
->objfile_obstack
);
7646 if (die
->child
!= NULL
)
7648 struct die_info
*child_die
= die
->child
;
7650 while (child_die
&& child_die
->tag
)
7652 process_die (child_die
, cu
);
7653 child_die
= sibling_die (child_die
);
7658 /* Read a Fortran module as type. This DIE can be only a declaration used for
7659 imported module. Still we need that type as local Fortran "use ... only"
7660 declaration imports depend on the created type in determine_prefix. */
7662 static struct type
*
7663 read_module_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
7665 struct objfile
*objfile
= cu
->objfile
;
7669 module_name
= dwarf2_name (die
, cu
);
7671 complaint (&symfile_complaints
,
7672 _("DW_TAG_module has no name, offset 0x%x"),
7674 type
= init_type (TYPE_CODE_MODULE
, 0, 0, module_name
, objfile
);
7676 /* determine_prefix uses TYPE_TAG_NAME. */
7677 TYPE_TAG_NAME (type
) = TYPE_NAME (type
);
7679 return set_die_type (die
, type
, cu
);
7682 /* Read a Fortran module. */
7685 read_module (struct die_info
*die
, struct dwarf2_cu
*cu
)
7687 struct die_info
*child_die
= die
->child
;
7689 while (child_die
&& child_die
->tag
)
7691 process_die (child_die
, cu
);
7692 child_die
= sibling_die (child_die
);
7696 /* Return the name of the namespace represented by DIE. Set
7697 *IS_ANONYMOUS to tell whether or not the namespace is an anonymous
7701 namespace_name (struct die_info
*die
, int *is_anonymous
, struct dwarf2_cu
*cu
)
7703 struct die_info
*current_die
;
7704 const char *name
= NULL
;
7706 /* Loop through the extensions until we find a name. */
7708 for (current_die
= die
;
7709 current_die
!= NULL
;
7710 current_die
= dwarf2_extension (die
, &cu
))
7712 name
= dwarf2_name (current_die
, cu
);
7717 /* Is it an anonymous namespace? */
7719 *is_anonymous
= (name
== NULL
);
7721 name
= "(anonymous namespace)";
7726 /* Extract all information from a DW_TAG_pointer_type DIE and add to
7727 the user defined type vector. */
7729 static struct type
*
7730 read_tag_pointer_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
7732 struct gdbarch
*gdbarch
= get_objfile_arch (cu
->objfile
);
7733 struct comp_unit_head
*cu_header
= &cu
->header
;
7735 struct attribute
*attr_byte_size
;
7736 struct attribute
*attr_address_class
;
7737 int byte_size
, addr_class
;
7738 struct type
*target_type
;
7740 target_type
= die_type (die
, cu
);
7742 /* The die_type call above may have already set the type for this DIE. */
7743 type
= get_die_type (die
, cu
);
7747 type
= lookup_pointer_type (target_type
);
7749 attr_byte_size
= dwarf2_attr (die
, DW_AT_byte_size
, cu
);
7751 byte_size
= DW_UNSND (attr_byte_size
);
7753 byte_size
= cu_header
->addr_size
;
7755 attr_address_class
= dwarf2_attr (die
, DW_AT_address_class
, cu
);
7756 if (attr_address_class
)
7757 addr_class
= DW_UNSND (attr_address_class
);
7759 addr_class
= DW_ADDR_none
;
7761 /* If the pointer size or address class is different than the
7762 default, create a type variant marked as such and set the
7763 length accordingly. */
7764 if (TYPE_LENGTH (type
) != byte_size
|| addr_class
!= DW_ADDR_none
)
7766 if (gdbarch_address_class_type_flags_p (gdbarch
))
7770 type_flags
= gdbarch_address_class_type_flags
7771 (gdbarch
, byte_size
, addr_class
);
7772 gdb_assert ((type_flags
& ~TYPE_INSTANCE_FLAG_ADDRESS_CLASS_ALL
)
7774 type
= make_type_with_address_space (type
, type_flags
);
7776 else if (TYPE_LENGTH (type
) != byte_size
)
7778 complaint (&symfile_complaints
,
7779 _("invalid pointer size %d"), byte_size
);
7783 /* Should we also complain about unhandled address classes? */
7787 TYPE_LENGTH (type
) = byte_size
;
7788 return set_die_type (die
, type
, cu
);
7791 /* Extract all information from a DW_TAG_ptr_to_member_type DIE and add to
7792 the user defined type vector. */
7794 static struct type
*
7795 read_tag_ptr_to_member_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
7798 struct type
*to_type
;
7799 struct type
*domain
;
7801 to_type
= die_type (die
, cu
);
7802 domain
= die_containing_type (die
, cu
);
7804 /* The calls above may have already set the type for this DIE. */
7805 type
= get_die_type (die
, cu
);
7809 if (TYPE_CODE (check_typedef (to_type
)) == TYPE_CODE_METHOD
)
7810 type
= lookup_methodptr_type (to_type
);
7812 type
= lookup_memberptr_type (to_type
, domain
);
7814 return set_die_type (die
, type
, cu
);
7817 /* Extract all information from a DW_TAG_reference_type DIE and add to
7818 the user defined type vector. */
7820 static struct type
*
7821 read_tag_reference_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
7823 struct comp_unit_head
*cu_header
= &cu
->header
;
7824 struct type
*type
, *target_type
;
7825 struct attribute
*attr
;
7827 target_type
= die_type (die
, cu
);
7829 /* The die_type call above may have already set the type for this DIE. */
7830 type
= get_die_type (die
, cu
);
7834 type
= lookup_reference_type (target_type
);
7835 attr
= dwarf2_attr (die
, DW_AT_byte_size
, cu
);
7838 TYPE_LENGTH (type
) = DW_UNSND (attr
);
7842 TYPE_LENGTH (type
) = cu_header
->addr_size
;
7844 return set_die_type (die
, type
, cu
);
7847 static struct type
*
7848 read_tag_const_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
7850 struct type
*base_type
, *cv_type
;
7852 base_type
= die_type (die
, cu
);
7854 /* The die_type call above may have already set the type for this DIE. */
7855 cv_type
= get_die_type (die
, cu
);
7859 /* In case the const qualifier is applied to an array type, the element type
7860 is so qualified, not the array type (section 6.7.3 of C99). */
7861 if (TYPE_CODE (base_type
) == TYPE_CODE_ARRAY
)
7863 struct type
*el_type
, *inner_array
;
7865 base_type
= copy_type (base_type
);
7866 inner_array
= base_type
;
7868 while (TYPE_CODE (TYPE_TARGET_TYPE (inner_array
)) == TYPE_CODE_ARRAY
)
7870 TYPE_TARGET_TYPE (inner_array
) =
7871 copy_type (TYPE_TARGET_TYPE (inner_array
));
7872 inner_array
= TYPE_TARGET_TYPE (inner_array
);
7875 el_type
= TYPE_TARGET_TYPE (inner_array
);
7876 TYPE_TARGET_TYPE (inner_array
) =
7877 make_cv_type (1, TYPE_VOLATILE (el_type
), el_type
, NULL
);
7879 return set_die_type (die
, base_type
, cu
);
7882 cv_type
= make_cv_type (1, TYPE_VOLATILE (base_type
), base_type
, 0);
7883 return set_die_type (die
, cv_type
, cu
);
7886 static struct type
*
7887 read_tag_volatile_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
7889 struct type
*base_type
, *cv_type
;
7891 base_type
= die_type (die
, cu
);
7893 /* The die_type call above may have already set the type for this DIE. */
7894 cv_type
= get_die_type (die
, cu
);
7898 cv_type
= make_cv_type (TYPE_CONST (base_type
), 1, base_type
, 0);
7899 return set_die_type (die
, cv_type
, cu
);
7902 /* Extract all information from a DW_TAG_string_type DIE and add to
7903 the user defined type vector. It isn't really a user defined type,
7904 but it behaves like one, with other DIE's using an AT_user_def_type
7905 attribute to reference it. */
7907 static struct type
*
7908 read_tag_string_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
7910 struct objfile
*objfile
= cu
->objfile
;
7911 struct gdbarch
*gdbarch
= get_objfile_arch (objfile
);
7912 struct type
*type
, *range_type
, *index_type
, *char_type
;
7913 struct attribute
*attr
;
7914 unsigned int length
;
7916 attr
= dwarf2_attr (die
, DW_AT_string_length
, cu
);
7919 length
= DW_UNSND (attr
);
7923 /* Check for the DW_AT_byte_size attribute. */
7924 attr
= dwarf2_attr (die
, DW_AT_byte_size
, cu
);
7927 length
= DW_UNSND (attr
);
7935 index_type
= objfile_type (objfile
)->builtin_int
;
7936 range_type
= create_range_type (NULL
, index_type
, 1, length
);
7937 char_type
= language_string_char_type (cu
->language_defn
, gdbarch
);
7938 type
= create_string_type (NULL
, char_type
, range_type
);
7940 return set_die_type (die
, type
, cu
);
7943 /* Handle DIES due to C code like:
7947 int (*funcp)(int a, long l);
7951 ('funcp' generates a DW_TAG_subroutine_type DIE). */
7953 static struct type
*
7954 read_subroutine_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
7956 struct type
*type
; /* Type that this function returns. */
7957 struct type
*ftype
; /* Function that returns above type. */
7958 struct attribute
*attr
;
7960 type
= die_type (die
, cu
);
7962 /* The die_type call above may have already set the type for this DIE. */
7963 ftype
= get_die_type (die
, cu
);
7967 ftype
= lookup_function_type (type
);
7969 /* All functions in C++, Pascal and Java have prototypes. */
7970 attr
= dwarf2_attr (die
, DW_AT_prototyped
, cu
);
7971 if ((attr
&& (DW_UNSND (attr
) != 0))
7972 || cu
->language
== language_cplus
7973 || cu
->language
== language_java
7974 || cu
->language
== language_pascal
)
7975 TYPE_PROTOTYPED (ftype
) = 1;
7976 else if (producer_is_realview (cu
->producer
))
7977 /* RealView does not emit DW_AT_prototyped. We can not
7978 distinguish prototyped and unprototyped functions; default to
7979 prototyped, since that is more common in modern code (and
7980 RealView warns about unprototyped functions). */
7981 TYPE_PROTOTYPED (ftype
) = 1;
7983 /* Store the calling convention in the type if it's available in
7984 the subroutine die. Otherwise set the calling convention to
7985 the default value DW_CC_normal. */
7986 attr
= dwarf2_attr (die
, DW_AT_calling_convention
, cu
);
7988 TYPE_CALLING_CONVENTION (ftype
) = DW_UNSND (attr
);
7989 else if (cu
->producer
&& strstr (cu
->producer
, "IBM XL C for OpenCL"))
7990 TYPE_CALLING_CONVENTION (ftype
) = DW_CC_GDB_IBM_OpenCL
;
7992 TYPE_CALLING_CONVENTION (ftype
) = DW_CC_normal
;
7994 /* We need to add the subroutine type to the die immediately so
7995 we don't infinitely recurse when dealing with parameters
7996 declared as the same subroutine type. */
7997 set_die_type (die
, ftype
, cu
);
7999 if (die
->child
!= NULL
)
8001 struct type
*void_type
= objfile_type (cu
->objfile
)->builtin_void
;
8002 struct die_info
*child_die
;
8003 int nparams
, iparams
;
8005 /* Count the number of parameters.
8006 FIXME: GDB currently ignores vararg functions, but knows about
8007 vararg member functions. */
8009 child_die
= die
->child
;
8010 while (child_die
&& child_die
->tag
)
8012 if (child_die
->tag
== DW_TAG_formal_parameter
)
8014 else if (child_die
->tag
== DW_TAG_unspecified_parameters
)
8015 TYPE_VARARGS (ftype
) = 1;
8016 child_die
= sibling_die (child_die
);
8019 /* Allocate storage for parameters and fill them in. */
8020 TYPE_NFIELDS (ftype
) = nparams
;
8021 TYPE_FIELDS (ftype
) = (struct field
*)
8022 TYPE_ZALLOC (ftype
, nparams
* sizeof (struct field
));
8024 /* TYPE_FIELD_TYPE must never be NULL. Pre-fill the array to ensure it
8025 even if we error out during the parameters reading below. */
8026 for (iparams
= 0; iparams
< nparams
; iparams
++)
8027 TYPE_FIELD_TYPE (ftype
, iparams
) = void_type
;
8030 child_die
= die
->child
;
8031 while (child_die
&& child_die
->tag
)
8033 if (child_die
->tag
== DW_TAG_formal_parameter
)
8035 struct type
*arg_type
;
8037 /* DWARF version 2 has no clean way to discern C++
8038 static and non-static member functions. G++ helps
8039 GDB by marking the first parameter for non-static
8040 member functions (which is the this pointer) as
8041 artificial. We pass this information to
8042 dwarf2_add_member_fn via TYPE_FIELD_ARTIFICIAL.
8044 DWARF version 3 added DW_AT_object_pointer, which GCC
8045 4.5 does not yet generate. */
8046 attr
= dwarf2_attr (child_die
, DW_AT_artificial
, cu
);
8048 TYPE_FIELD_ARTIFICIAL (ftype
, iparams
) = DW_UNSND (attr
);
8051 TYPE_FIELD_ARTIFICIAL (ftype
, iparams
) = 0;
8053 /* GCC/43521: In java, the formal parameter
8054 "this" is sometimes not marked with DW_AT_artificial. */
8055 if (cu
->language
== language_java
)
8057 const char *name
= dwarf2_name (child_die
, cu
);
8059 if (name
&& !strcmp (name
, "this"))
8060 TYPE_FIELD_ARTIFICIAL (ftype
, iparams
) = 1;
8063 arg_type
= die_type (child_die
, cu
);
8065 /* RealView does not mark THIS as const, which the testsuite
8066 expects. GCC marks THIS as const in method definitions,
8067 but not in the class specifications (GCC PR 43053). */
8068 if (cu
->language
== language_cplus
&& !TYPE_CONST (arg_type
)
8069 && TYPE_FIELD_ARTIFICIAL (ftype
, iparams
))
8072 struct dwarf2_cu
*arg_cu
= cu
;
8073 const char *name
= dwarf2_name (child_die
, cu
);
8075 attr
= dwarf2_attr (die
, DW_AT_object_pointer
, cu
);
8078 /* If the compiler emits this, use it. */
8079 if (follow_die_ref (die
, attr
, &arg_cu
) == child_die
)
8082 else if (name
&& strcmp (name
, "this") == 0)
8083 /* Function definitions will have the argument names. */
8085 else if (name
== NULL
&& iparams
== 0)
8086 /* Declarations may not have the names, so like
8087 elsewhere in GDB, assume an artificial first
8088 argument is "this". */
8092 arg_type
= make_cv_type (1, TYPE_VOLATILE (arg_type
),
8096 TYPE_FIELD_TYPE (ftype
, iparams
) = arg_type
;
8099 child_die
= sibling_die (child_die
);
8106 static struct type
*
8107 read_typedef (struct die_info
*die
, struct dwarf2_cu
*cu
)
8109 struct objfile
*objfile
= cu
->objfile
;
8110 const char *name
= NULL
;
8111 struct type
*this_type
;
8113 name
= dwarf2_full_name (NULL
, die
, cu
);
8114 this_type
= init_type (TYPE_CODE_TYPEDEF
, 0,
8115 TYPE_FLAG_TARGET_STUB
, NULL
, objfile
);
8116 TYPE_NAME (this_type
) = (char *) name
;
8117 set_die_type (die
, this_type
, cu
);
8118 TYPE_TARGET_TYPE (this_type
) = die_type (die
, cu
);
8122 /* Find a representation of a given base type and install
8123 it in the TYPE field of the die. */
8125 static struct type
*
8126 read_base_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
8128 struct objfile
*objfile
= cu
->objfile
;
8130 struct attribute
*attr
;
8131 int encoding
= 0, size
= 0;
8133 enum type_code code
= TYPE_CODE_INT
;
8135 struct type
*target_type
= NULL
;
8137 attr
= dwarf2_attr (die
, DW_AT_encoding
, cu
);
8140 encoding
= DW_UNSND (attr
);
8142 attr
= dwarf2_attr (die
, DW_AT_byte_size
, cu
);
8145 size
= DW_UNSND (attr
);
8147 name
= dwarf2_name (die
, cu
);
8150 complaint (&symfile_complaints
,
8151 _("DW_AT_name missing from DW_TAG_base_type"));
8156 case DW_ATE_address
:
8157 /* Turn DW_ATE_address into a void * pointer. */
8158 code
= TYPE_CODE_PTR
;
8159 type_flags
|= TYPE_FLAG_UNSIGNED
;
8160 target_type
= init_type (TYPE_CODE_VOID
, 1, 0, NULL
, objfile
);
8162 case DW_ATE_boolean
:
8163 code
= TYPE_CODE_BOOL
;
8164 type_flags
|= TYPE_FLAG_UNSIGNED
;
8166 case DW_ATE_complex_float
:
8167 code
= TYPE_CODE_COMPLEX
;
8168 target_type
= init_type (TYPE_CODE_FLT
, size
/ 2, 0, NULL
, objfile
);
8170 case DW_ATE_decimal_float
:
8171 code
= TYPE_CODE_DECFLOAT
;
8174 code
= TYPE_CODE_FLT
;
8178 case DW_ATE_unsigned
:
8179 type_flags
|= TYPE_FLAG_UNSIGNED
;
8181 case DW_ATE_signed_char
:
8182 if (cu
->language
== language_ada
|| cu
->language
== language_m2
8183 || cu
->language
== language_pascal
)
8184 code
= TYPE_CODE_CHAR
;
8186 case DW_ATE_unsigned_char
:
8187 if (cu
->language
== language_ada
|| cu
->language
== language_m2
8188 || cu
->language
== language_pascal
)
8189 code
= TYPE_CODE_CHAR
;
8190 type_flags
|= TYPE_FLAG_UNSIGNED
;
8193 /* We just treat this as an integer and then recognize the
8194 type by name elsewhere. */
8198 complaint (&symfile_complaints
, _("unsupported DW_AT_encoding: '%s'"),
8199 dwarf_type_encoding_name (encoding
));
8203 type
= init_type (code
, size
, type_flags
, NULL
, objfile
);
8204 TYPE_NAME (type
) = name
;
8205 TYPE_TARGET_TYPE (type
) = target_type
;
8207 if (name
&& strcmp (name
, "char") == 0)
8208 TYPE_NOSIGN (type
) = 1;
8210 return set_die_type (die
, type
, cu
);
8213 /* Read the given DW_AT_subrange DIE. */
8215 static struct type
*
8216 read_subrange_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
8218 struct type
*base_type
;
8219 struct type
*range_type
;
8220 struct attribute
*attr
;
8224 LONGEST negative_mask
;
8226 base_type
= die_type (die
, cu
);
8227 /* Preserve BASE_TYPE's original type, just set its LENGTH. */
8228 check_typedef (base_type
);
8230 /* The die_type call above may have already set the type for this DIE. */
8231 range_type
= get_die_type (die
, cu
);
8235 if (cu
->language
== language_fortran
)
8237 /* FORTRAN implies a lower bound of 1, if not given. */
8241 /* FIXME: For variable sized arrays either of these could be
8242 a variable rather than a constant value. We'll allow it,
8243 but we don't know how to handle it. */
8244 attr
= dwarf2_attr (die
, DW_AT_lower_bound
, cu
);
8246 low
= dwarf2_get_attr_constant_value (attr
, 0);
8248 attr
= dwarf2_attr (die
, DW_AT_upper_bound
, cu
);
8251 if (attr
->form
== DW_FORM_block1
|| is_ref_attr (attr
))
8253 /* GCC encodes arrays with unspecified or dynamic length
8254 with a DW_FORM_block1 attribute or a reference attribute.
8255 FIXME: GDB does not yet know how to handle dynamic
8256 arrays properly, treat them as arrays with unspecified
8259 FIXME: jimb/2003-09-22: GDB does not really know
8260 how to handle arrays of unspecified length
8261 either; we just represent them as zero-length
8262 arrays. Choose an appropriate upper bound given
8263 the lower bound we've computed above. */
8267 high
= dwarf2_get_attr_constant_value (attr
, 1);
8271 attr
= dwarf2_attr (die
, DW_AT_count
, cu
);
8274 int count
= dwarf2_get_attr_constant_value (attr
, 1);
8275 high
= low
+ count
- 1;
8279 /* Unspecified array length. */
8284 /* Dwarf-2 specifications explicitly allows to create subrange types
8285 without specifying a base type.
8286 In that case, the base type must be set to the type of
8287 the lower bound, upper bound or count, in that order, if any of these
8288 three attributes references an object that has a type.
8289 If no base type is found, the Dwarf-2 specifications say that
8290 a signed integer type of size equal to the size of an address should
8292 For the following C code: `extern char gdb_int [];'
8293 GCC produces an empty range DIE.
8294 FIXME: muller/2010-05-28: Possible references to object for low bound,
8295 high bound or count are not yet handled by this code. */
8296 if (TYPE_CODE (base_type
) == TYPE_CODE_VOID
)
8298 struct objfile
*objfile
= cu
->objfile
;
8299 struct gdbarch
*gdbarch
= get_objfile_arch (objfile
);
8300 int addr_size
= gdbarch_addr_bit (gdbarch
) /8;
8301 struct type
*int_type
= objfile_type (objfile
)->builtin_int
;
8303 /* Test "int", "long int", and "long long int" objfile types,
8304 and select the first one having a size above or equal to the
8305 architecture address size. */
8306 if (int_type
&& TYPE_LENGTH (int_type
) >= addr_size
)
8307 base_type
= int_type
;
8310 int_type
= objfile_type (objfile
)->builtin_long
;
8311 if (int_type
&& TYPE_LENGTH (int_type
) >= addr_size
)
8312 base_type
= int_type
;
8315 int_type
= objfile_type (objfile
)->builtin_long_long
;
8316 if (int_type
&& TYPE_LENGTH (int_type
) >= addr_size
)
8317 base_type
= int_type
;
8323 (LONGEST
) -1 << (TYPE_LENGTH (base_type
) * TARGET_CHAR_BIT
- 1);
8324 if (!TYPE_UNSIGNED (base_type
) && (low
& negative_mask
))
8325 low
|= negative_mask
;
8326 if (!TYPE_UNSIGNED (base_type
) && (high
& negative_mask
))
8327 high
|= negative_mask
;
8329 range_type
= create_range_type (NULL
, base_type
, low
, high
);
8331 /* Mark arrays with dynamic length at least as an array of unspecified
8332 length. GDB could check the boundary but before it gets implemented at
8333 least allow accessing the array elements. */
8334 if (attr
&& attr
->form
== DW_FORM_block1
)
8335 TYPE_HIGH_BOUND_UNDEFINED (range_type
) = 1;
8337 /* Ada expects an empty array on no boundary attributes. */
8338 if (attr
== NULL
&& cu
->language
!= language_ada
)
8339 TYPE_HIGH_BOUND_UNDEFINED (range_type
) = 1;
8341 name
= dwarf2_name (die
, cu
);
8343 TYPE_NAME (range_type
) = name
;
8345 attr
= dwarf2_attr (die
, DW_AT_byte_size
, cu
);
8347 TYPE_LENGTH (range_type
) = DW_UNSND (attr
);
8349 set_die_type (die
, range_type
, cu
);
8351 /* set_die_type should be already done. */
8352 set_descriptive_type (range_type
, die
, cu
);
8357 static struct type
*
8358 read_unspecified_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
8362 /* For now, we only support the C meaning of an unspecified type: void. */
8364 type
= init_type (TYPE_CODE_VOID
, 0, 0, NULL
, cu
->objfile
);
8365 TYPE_NAME (type
) = dwarf2_name (die
, cu
);
8367 return set_die_type (die
, type
, cu
);
8370 /* Trivial hash function for die_info: the hash value of a DIE
8371 is its offset in .debug_info for this objfile. */
8374 die_hash (const void *item
)
8376 const struct die_info
*die
= item
;
8381 /* Trivial comparison function for die_info structures: two DIEs
8382 are equal if they have the same offset. */
8385 die_eq (const void *item_lhs
, const void *item_rhs
)
8387 const struct die_info
*die_lhs
= item_lhs
;
8388 const struct die_info
*die_rhs
= item_rhs
;
8390 return die_lhs
->offset
== die_rhs
->offset
;
8393 /* Read a whole compilation unit into a linked list of dies. */
8395 static struct die_info
*
8396 read_comp_unit (gdb_byte
*info_ptr
, struct dwarf2_cu
*cu
)
8398 struct die_reader_specs reader_specs
;
8399 int read_abbrevs
= 0;
8400 struct cleanup
*back_to
= NULL
;
8401 struct die_info
*die
;
8403 if (cu
->dwarf2_abbrevs
== NULL
)
8405 dwarf2_read_abbrevs (cu
->objfile
->obfd
, cu
);
8406 back_to
= make_cleanup (dwarf2_free_abbrev_table
, cu
);
8410 gdb_assert (cu
->die_hash
== NULL
);
8412 = htab_create_alloc_ex (cu
->header
.length
/ 12,
8416 &cu
->comp_unit_obstack
,
8417 hashtab_obstack_allocate
,
8418 dummy_obstack_deallocate
);
8420 init_cu_die_reader (&reader_specs
, cu
);
8422 die
= read_die_and_children (&reader_specs
, info_ptr
, &info_ptr
, NULL
);
8425 do_cleanups (back_to
);
8430 /* Main entry point for reading a DIE and all children.
8431 Read the DIE and dump it if requested. */
8433 static struct die_info
*
8434 read_die_and_children (const struct die_reader_specs
*reader
,
8436 gdb_byte
**new_info_ptr
,
8437 struct die_info
*parent
)
8439 struct die_info
*result
= read_die_and_children_1 (reader
, info_ptr
,
8440 new_info_ptr
, parent
);
8442 if (dwarf2_die_debug
)
8444 fprintf_unfiltered (gdb_stdlog
,
8445 "\nRead die from %s of %s:\n",
8446 reader
->buffer
== dwarf2_per_objfile
->info
.buffer
8448 : reader
->buffer
== dwarf2_per_objfile
->types
.buffer
8450 : "unknown section",
8451 reader
->abfd
->filename
);
8452 dump_die (result
, dwarf2_die_debug
);
8458 /* Read a single die and all its descendents. Set the die's sibling
8459 field to NULL; set other fields in the die correctly, and set all
8460 of the descendents' fields correctly. Set *NEW_INFO_PTR to the
8461 location of the info_ptr after reading all of those dies. PARENT
8462 is the parent of the die in question. */
8464 static struct die_info
*
8465 read_die_and_children_1 (const struct die_reader_specs
*reader
,
8467 gdb_byte
**new_info_ptr
,
8468 struct die_info
*parent
)
8470 struct die_info
*die
;
8474 cur_ptr
= read_full_die (reader
, &die
, info_ptr
, &has_children
);
8477 *new_info_ptr
= cur_ptr
;
8480 store_in_ref_table (die
, reader
->cu
);
8483 die
->child
= read_die_and_siblings (reader
, cur_ptr
, new_info_ptr
, die
);
8487 *new_info_ptr
= cur_ptr
;
8490 die
->sibling
= NULL
;
8491 die
->parent
= parent
;
8495 /* Read a die, all of its descendents, and all of its siblings; set
8496 all of the fields of all of the dies correctly. Arguments are as
8497 in read_die_and_children. */
8499 static struct die_info
*
8500 read_die_and_siblings (const struct die_reader_specs
*reader
,
8502 gdb_byte
**new_info_ptr
,
8503 struct die_info
*parent
)
8505 struct die_info
*first_die
, *last_sibling
;
8509 first_die
= last_sibling
= NULL
;
8513 struct die_info
*die
8514 = read_die_and_children_1 (reader
, cur_ptr
, &cur_ptr
, parent
);
8518 *new_info_ptr
= cur_ptr
;
8525 last_sibling
->sibling
= die
;
8531 /* Read the die from the .debug_info section buffer. Set DIEP to
8532 point to a newly allocated die with its information, except for its
8533 child, sibling, and parent fields. Set HAS_CHILDREN to tell
8534 whether the die has children or not. */
8537 read_full_die (const struct die_reader_specs
*reader
,
8538 struct die_info
**diep
, gdb_byte
*info_ptr
,
8541 unsigned int abbrev_number
, bytes_read
, i
, offset
;
8542 struct abbrev_info
*abbrev
;
8543 struct die_info
*die
;
8544 struct dwarf2_cu
*cu
= reader
->cu
;
8545 bfd
*abfd
= reader
->abfd
;
8547 offset
= info_ptr
- reader
->buffer
;
8548 abbrev_number
= read_unsigned_leb128 (abfd
, info_ptr
, &bytes_read
);
8549 info_ptr
+= bytes_read
;
8557 abbrev
= dwarf2_lookup_abbrev (abbrev_number
, cu
);
8559 error (_("Dwarf Error: could not find abbrev number %d [in module %s]"),
8561 bfd_get_filename (abfd
));
8563 die
= dwarf_alloc_die (cu
, abbrev
->num_attrs
);
8564 die
->offset
= offset
;
8565 die
->tag
= abbrev
->tag
;
8566 die
->abbrev
= abbrev_number
;
8568 die
->num_attrs
= abbrev
->num_attrs
;
8570 for (i
= 0; i
< abbrev
->num_attrs
; ++i
)
8571 info_ptr
= read_attribute (&die
->attrs
[i
], &abbrev
->attrs
[i
],
8572 abfd
, info_ptr
, cu
);
8575 *has_children
= abbrev
->has_children
;
8579 /* In DWARF version 2, the description of the debugging information is
8580 stored in a separate .debug_abbrev section. Before we read any
8581 dies from a section we read in all abbreviations and install them
8582 in a hash table. This function also sets flags in CU describing
8583 the data found in the abbrev table. */
8586 dwarf2_read_abbrevs (bfd
*abfd
, struct dwarf2_cu
*cu
)
8588 struct comp_unit_head
*cu_header
= &cu
->header
;
8589 gdb_byte
*abbrev_ptr
;
8590 struct abbrev_info
*cur_abbrev
;
8591 unsigned int abbrev_number
, bytes_read
, abbrev_name
;
8592 unsigned int abbrev_form
, hash_number
;
8593 struct attr_abbrev
*cur_attrs
;
8594 unsigned int allocated_attrs
;
8596 /* Initialize dwarf2 abbrevs. */
8597 obstack_init (&cu
->abbrev_obstack
);
8598 cu
->dwarf2_abbrevs
= obstack_alloc (&cu
->abbrev_obstack
,
8600 * sizeof (struct abbrev_info
*)));
8601 memset (cu
->dwarf2_abbrevs
, 0,
8602 ABBREV_HASH_SIZE
* sizeof (struct abbrev_info
*));
8604 dwarf2_read_section (dwarf2_per_objfile
->objfile
,
8605 &dwarf2_per_objfile
->abbrev
);
8606 abbrev_ptr
= dwarf2_per_objfile
->abbrev
.buffer
+ cu_header
->abbrev_offset
;
8607 abbrev_number
= read_unsigned_leb128 (abfd
, abbrev_ptr
, &bytes_read
);
8608 abbrev_ptr
+= bytes_read
;
8610 allocated_attrs
= ATTR_ALLOC_CHUNK
;
8611 cur_attrs
= xmalloc (allocated_attrs
* sizeof (struct attr_abbrev
));
8613 /* Loop until we reach an abbrev number of 0. */
8614 while (abbrev_number
)
8616 cur_abbrev
= dwarf_alloc_abbrev (cu
);
8618 /* read in abbrev header */
8619 cur_abbrev
->number
= abbrev_number
;
8620 cur_abbrev
->tag
= read_unsigned_leb128 (abfd
, abbrev_ptr
, &bytes_read
);
8621 abbrev_ptr
+= bytes_read
;
8622 cur_abbrev
->has_children
= read_1_byte (abfd
, abbrev_ptr
);
8625 if (cur_abbrev
->tag
== DW_TAG_namespace
)
8626 cu
->has_namespace_info
= 1;
8628 /* now read in declarations */
8629 abbrev_name
= read_unsigned_leb128 (abfd
, abbrev_ptr
, &bytes_read
);
8630 abbrev_ptr
+= bytes_read
;
8631 abbrev_form
= read_unsigned_leb128 (abfd
, abbrev_ptr
, &bytes_read
);
8632 abbrev_ptr
+= bytes_read
;
8635 if (cur_abbrev
->num_attrs
== allocated_attrs
)
8637 allocated_attrs
+= ATTR_ALLOC_CHUNK
;
8639 = xrealloc (cur_attrs
, (allocated_attrs
8640 * sizeof (struct attr_abbrev
)));
8643 /* Record whether this compilation unit might have
8644 inter-compilation-unit references. If we don't know what form
8645 this attribute will have, then it might potentially be a
8646 DW_FORM_ref_addr, so we conservatively expect inter-CU
8649 if (abbrev_form
== DW_FORM_ref_addr
8650 || abbrev_form
== DW_FORM_indirect
)
8651 cu
->has_form_ref_addr
= 1;
8653 cur_attrs
[cur_abbrev
->num_attrs
].name
= abbrev_name
;
8654 cur_attrs
[cur_abbrev
->num_attrs
++].form
= abbrev_form
;
8655 abbrev_name
= read_unsigned_leb128 (abfd
, abbrev_ptr
, &bytes_read
);
8656 abbrev_ptr
+= bytes_read
;
8657 abbrev_form
= read_unsigned_leb128 (abfd
, abbrev_ptr
, &bytes_read
);
8658 abbrev_ptr
+= bytes_read
;
8661 cur_abbrev
->attrs
= obstack_alloc (&cu
->abbrev_obstack
,
8662 (cur_abbrev
->num_attrs
8663 * sizeof (struct attr_abbrev
)));
8664 memcpy (cur_abbrev
->attrs
, cur_attrs
,
8665 cur_abbrev
->num_attrs
* sizeof (struct attr_abbrev
));
8667 hash_number
= abbrev_number
% ABBREV_HASH_SIZE
;
8668 cur_abbrev
->next
= cu
->dwarf2_abbrevs
[hash_number
];
8669 cu
->dwarf2_abbrevs
[hash_number
] = cur_abbrev
;
8671 /* Get next abbreviation.
8672 Under Irix6 the abbreviations for a compilation unit are not
8673 always properly terminated with an abbrev number of 0.
8674 Exit loop if we encounter an abbreviation which we have
8675 already read (which means we are about to read the abbreviations
8676 for the next compile unit) or if the end of the abbreviation
8677 table is reached. */
8678 if ((unsigned int) (abbrev_ptr
- dwarf2_per_objfile
->abbrev
.buffer
)
8679 >= dwarf2_per_objfile
->abbrev
.size
)
8681 abbrev_number
= read_unsigned_leb128 (abfd
, abbrev_ptr
, &bytes_read
);
8682 abbrev_ptr
+= bytes_read
;
8683 if (dwarf2_lookup_abbrev (abbrev_number
, cu
) != NULL
)
8690 /* Release the memory used by the abbrev table for a compilation unit. */
8693 dwarf2_free_abbrev_table (void *ptr_to_cu
)
8695 struct dwarf2_cu
*cu
= ptr_to_cu
;
8697 obstack_free (&cu
->abbrev_obstack
, NULL
);
8698 cu
->dwarf2_abbrevs
= NULL
;
8701 /* Lookup an abbrev_info structure in the abbrev hash table. */
8703 static struct abbrev_info
*
8704 dwarf2_lookup_abbrev (unsigned int number
, struct dwarf2_cu
*cu
)
8706 unsigned int hash_number
;
8707 struct abbrev_info
*abbrev
;
8709 hash_number
= number
% ABBREV_HASH_SIZE
;
8710 abbrev
= cu
->dwarf2_abbrevs
[hash_number
];
8714 if (abbrev
->number
== number
)
8717 abbrev
= abbrev
->next
;
8722 /* Returns nonzero if TAG represents a type that we might generate a partial
8726 is_type_tag_for_partial (int tag
)
8731 /* Some types that would be reasonable to generate partial symbols for,
8732 that we don't at present. */
8733 case DW_TAG_array_type
:
8734 case DW_TAG_file_type
:
8735 case DW_TAG_ptr_to_member_type
:
8736 case DW_TAG_set_type
:
8737 case DW_TAG_string_type
:
8738 case DW_TAG_subroutine_type
:
8740 case DW_TAG_base_type
:
8741 case DW_TAG_class_type
:
8742 case DW_TAG_interface_type
:
8743 case DW_TAG_enumeration_type
:
8744 case DW_TAG_structure_type
:
8745 case DW_TAG_subrange_type
:
8746 case DW_TAG_typedef
:
8747 case DW_TAG_union_type
:
8754 /* Load all DIEs that are interesting for partial symbols into memory. */
8756 static struct partial_die_info
*
8757 load_partial_dies (bfd
*abfd
, gdb_byte
*buffer
, gdb_byte
*info_ptr
,
8758 int building_psymtab
, struct dwarf2_cu
*cu
)
8760 struct partial_die_info
*part_die
;
8761 struct partial_die_info
*parent_die
, *last_die
, *first_die
= NULL
;
8762 struct abbrev_info
*abbrev
;
8763 unsigned int bytes_read
;
8764 unsigned int load_all
= 0;
8766 int nesting_level
= 1;
8771 if (cu
->per_cu
&& cu
->per_cu
->load_all_dies
)
8775 = htab_create_alloc_ex (cu
->header
.length
/ 12,
8779 &cu
->comp_unit_obstack
,
8780 hashtab_obstack_allocate
,
8781 dummy_obstack_deallocate
);
8783 part_die
= obstack_alloc (&cu
->comp_unit_obstack
,
8784 sizeof (struct partial_die_info
));
8788 abbrev
= peek_die_abbrev (info_ptr
, &bytes_read
, cu
);
8790 /* A NULL abbrev means the end of a series of children. */
8793 if (--nesting_level
== 0)
8795 /* PART_DIE was probably the last thing allocated on the
8796 comp_unit_obstack, so we could call obstack_free
8797 here. We don't do that because the waste is small,
8798 and will be cleaned up when we're done with this
8799 compilation unit. This way, we're also more robust
8800 against other users of the comp_unit_obstack. */
8803 info_ptr
+= bytes_read
;
8804 last_die
= parent_die
;
8805 parent_die
= parent_die
->die_parent
;
8809 /* Check for template arguments. We never save these; if
8810 they're seen, we just mark the parent, and go on our way. */
8811 if (parent_die
!= NULL
8812 && cu
->language
== language_cplus
8813 && (abbrev
->tag
== DW_TAG_template_type_param
8814 || abbrev
->tag
== DW_TAG_template_value_param
))
8816 parent_die
->has_template_arguments
= 1;
8820 /* We don't need a partial DIE for the template argument. */
8821 info_ptr
= skip_one_die (buffer
, info_ptr
+ bytes_read
, abbrev
,
8827 /* We only recurse into subprograms looking for template arguments.
8828 Skip their other children. */
8830 && cu
->language
== language_cplus
8831 && parent_die
!= NULL
8832 && parent_die
->tag
== DW_TAG_subprogram
)
8834 info_ptr
= skip_one_die (buffer
, info_ptr
+ bytes_read
, abbrev
, cu
);
8838 /* Check whether this DIE is interesting enough to save. Normally
8839 we would not be interested in members here, but there may be
8840 later variables referencing them via DW_AT_specification (for
8843 && !is_type_tag_for_partial (abbrev
->tag
)
8844 && abbrev
->tag
!= DW_TAG_constant
8845 && abbrev
->tag
!= DW_TAG_enumerator
8846 && abbrev
->tag
!= DW_TAG_subprogram
8847 && abbrev
->tag
!= DW_TAG_lexical_block
8848 && abbrev
->tag
!= DW_TAG_variable
8849 && abbrev
->tag
!= DW_TAG_namespace
8850 && abbrev
->tag
!= DW_TAG_module
8851 && abbrev
->tag
!= DW_TAG_member
)
8853 /* Otherwise we skip to the next sibling, if any. */
8854 info_ptr
= skip_one_die (buffer
, info_ptr
+ bytes_read
, abbrev
, cu
);
8858 info_ptr
= read_partial_die (part_die
, abbrev
, bytes_read
, abfd
,
8859 buffer
, info_ptr
, cu
);
8861 /* This two-pass algorithm for processing partial symbols has a
8862 high cost in cache pressure. Thus, handle some simple cases
8863 here which cover the majority of C partial symbols. DIEs
8864 which neither have specification tags in them, nor could have
8865 specification tags elsewhere pointing at them, can simply be
8866 processed and discarded.
8868 This segment is also optional; scan_partial_symbols and
8869 add_partial_symbol will handle these DIEs if we chain
8870 them in normally. When compilers which do not emit large
8871 quantities of duplicate debug information are more common,
8872 this code can probably be removed. */
8874 /* Any complete simple types at the top level (pretty much all
8875 of them, for a language without namespaces), can be processed
8877 if (parent_die
== NULL
8878 && part_die
->has_specification
== 0
8879 && part_die
->is_declaration
== 0
8880 && (part_die
->tag
== DW_TAG_typedef
8881 || part_die
->tag
== DW_TAG_base_type
8882 || part_die
->tag
== DW_TAG_subrange_type
))
8884 if (building_psymtab
&& part_die
->name
!= NULL
)
8885 add_psymbol_to_list (part_die
->name
, strlen (part_die
->name
), 0,
8886 VAR_DOMAIN
, LOC_TYPEDEF
,
8887 &cu
->objfile
->static_psymbols
,
8888 0, (CORE_ADDR
) 0, cu
->language
, cu
->objfile
);
8889 info_ptr
= locate_pdi_sibling (part_die
, buffer
, info_ptr
, abfd
, cu
);
8893 /* If we're at the second level, and we're an enumerator, and
8894 our parent has no specification (meaning possibly lives in a
8895 namespace elsewhere), then we can add the partial symbol now
8896 instead of queueing it. */
8897 if (part_die
->tag
== DW_TAG_enumerator
8898 && parent_die
!= NULL
8899 && parent_die
->die_parent
== NULL
8900 && parent_die
->tag
== DW_TAG_enumeration_type
8901 && parent_die
->has_specification
== 0)
8903 if (part_die
->name
== NULL
)
8904 complaint (&symfile_complaints
,
8905 _("malformed enumerator DIE ignored"));
8906 else if (building_psymtab
)
8907 add_psymbol_to_list (part_die
->name
, strlen (part_die
->name
), 0,
8908 VAR_DOMAIN
, LOC_CONST
,
8909 (cu
->language
== language_cplus
8910 || cu
->language
== language_java
)
8911 ? &cu
->objfile
->global_psymbols
8912 : &cu
->objfile
->static_psymbols
,
8913 0, (CORE_ADDR
) 0, cu
->language
, cu
->objfile
);
8915 info_ptr
= locate_pdi_sibling (part_die
, buffer
, info_ptr
, abfd
, cu
);
8919 /* We'll save this DIE so link it in. */
8920 part_die
->die_parent
= parent_die
;
8921 part_die
->die_sibling
= NULL
;
8922 part_die
->die_child
= NULL
;
8924 if (last_die
&& last_die
== parent_die
)
8925 last_die
->die_child
= part_die
;
8927 last_die
->die_sibling
= part_die
;
8929 last_die
= part_die
;
8931 if (first_die
== NULL
)
8932 first_die
= part_die
;
8934 /* Maybe add the DIE to the hash table. Not all DIEs that we
8935 find interesting need to be in the hash table, because we
8936 also have the parent/sibling/child chains; only those that we
8937 might refer to by offset later during partial symbol reading.
8939 For now this means things that might have be the target of a
8940 DW_AT_specification, DW_AT_abstract_origin, or
8941 DW_AT_extension. DW_AT_extension will refer only to
8942 namespaces; DW_AT_abstract_origin refers to functions (and
8943 many things under the function DIE, but we do not recurse
8944 into function DIEs during partial symbol reading) and
8945 possibly variables as well; DW_AT_specification refers to
8946 declarations. Declarations ought to have the DW_AT_declaration
8947 flag. It happens that GCC forgets to put it in sometimes, but
8948 only for functions, not for types.
8950 Adding more things than necessary to the hash table is harmless
8951 except for the performance cost. Adding too few will result in
8952 wasted time in find_partial_die, when we reread the compilation
8953 unit with load_all_dies set. */
8956 || abbrev
->tag
== DW_TAG_constant
8957 || abbrev
->tag
== DW_TAG_subprogram
8958 || abbrev
->tag
== DW_TAG_variable
8959 || abbrev
->tag
== DW_TAG_namespace
8960 || part_die
->is_declaration
)
8964 slot
= htab_find_slot_with_hash (cu
->partial_dies
, part_die
,
8965 part_die
->offset
, INSERT
);
8969 part_die
= obstack_alloc (&cu
->comp_unit_obstack
,
8970 sizeof (struct partial_die_info
));
8972 /* For some DIEs we want to follow their children (if any). For C
8973 we have no reason to follow the children of structures; for other
8974 languages we have to, so that we can get at method physnames
8975 to infer fully qualified class names, for DW_AT_specification,
8976 and for C++ template arguments. For C++, we also look one level
8977 inside functions to find template arguments (if the name of the
8978 function does not already contain the template arguments).
8980 For Ada, we need to scan the children of subprograms and lexical
8981 blocks as well because Ada allows the definition of nested
8982 entities that could be interesting for the debugger, such as
8983 nested subprograms for instance. */
8984 if (last_die
->has_children
8986 || last_die
->tag
== DW_TAG_namespace
8987 || last_die
->tag
== DW_TAG_module
8988 || last_die
->tag
== DW_TAG_enumeration_type
8989 || (cu
->language
== language_cplus
8990 && last_die
->tag
== DW_TAG_subprogram
8991 && (last_die
->name
== NULL
8992 || strchr (last_die
->name
, '<') == NULL
))
8993 || (cu
->language
!= language_c
8994 && (last_die
->tag
== DW_TAG_class_type
8995 || last_die
->tag
== DW_TAG_interface_type
8996 || last_die
->tag
== DW_TAG_structure_type
8997 || last_die
->tag
== DW_TAG_union_type
))
8998 || (cu
->language
== language_ada
8999 && (last_die
->tag
== DW_TAG_subprogram
9000 || last_die
->tag
== DW_TAG_lexical_block
))))
9003 parent_die
= last_die
;
9007 /* Otherwise we skip to the next sibling, if any. */
9008 info_ptr
= locate_pdi_sibling (last_die
, buffer
, info_ptr
, abfd
, cu
);
9010 /* Back to the top, do it again. */
9014 /* Read a minimal amount of information into the minimal die structure. */
9017 read_partial_die (struct partial_die_info
*part_die
,
9018 struct abbrev_info
*abbrev
,
9019 unsigned int abbrev_len
, bfd
*abfd
,
9020 gdb_byte
*buffer
, gdb_byte
*info_ptr
,
9021 struct dwarf2_cu
*cu
)
9024 struct attribute attr
;
9025 int has_low_pc_attr
= 0;
9026 int has_high_pc_attr
= 0;
9028 memset (part_die
, 0, sizeof (struct partial_die_info
));
9030 part_die
->offset
= info_ptr
- buffer
;
9032 info_ptr
+= abbrev_len
;
9037 part_die
->tag
= abbrev
->tag
;
9038 part_die
->has_children
= abbrev
->has_children
;
9040 for (i
= 0; i
< abbrev
->num_attrs
; ++i
)
9042 info_ptr
= read_attribute (&attr
, &abbrev
->attrs
[i
], abfd
, info_ptr
, cu
);
9044 /* Store the data if it is of an attribute we want to keep in a
9045 partial symbol table. */
9049 switch (part_die
->tag
)
9051 case DW_TAG_compile_unit
:
9052 case DW_TAG_type_unit
:
9053 /* Compilation units have a DW_AT_name that is a filename, not
9054 a source language identifier. */
9055 case DW_TAG_enumeration_type
:
9056 case DW_TAG_enumerator
:
9057 /* These tags always have simple identifiers already; no need
9058 to canonicalize them. */
9059 part_die
->name
= DW_STRING (&attr
);
9063 = dwarf2_canonicalize_name (DW_STRING (&attr
), cu
,
9064 &cu
->objfile
->objfile_obstack
);
9068 case DW_AT_linkage_name
:
9069 case DW_AT_MIPS_linkage_name
:
9070 /* Note that both forms of linkage name might appear. We
9071 assume they will be the same, and we only store the last
9073 if (cu
->language
== language_ada
)
9074 part_die
->name
= DW_STRING (&attr
);
9075 part_die
->linkage_name
= DW_STRING (&attr
);
9078 has_low_pc_attr
= 1;
9079 part_die
->lowpc
= DW_ADDR (&attr
);
9082 has_high_pc_attr
= 1;
9083 part_die
->highpc
= DW_ADDR (&attr
);
9085 case DW_AT_location
:
9086 /* Support the .debug_loc offsets. */
9087 if (attr_form_is_block (&attr
))
9089 part_die
->locdesc
= DW_BLOCK (&attr
);
9091 else if (attr_form_is_section_offset (&attr
))
9093 dwarf2_complex_location_expr_complaint ();
9097 dwarf2_invalid_attrib_class_complaint ("DW_AT_location",
9098 "partial symbol information");
9101 case DW_AT_external
:
9102 part_die
->is_external
= DW_UNSND (&attr
);
9104 case DW_AT_declaration
:
9105 part_die
->is_declaration
= DW_UNSND (&attr
);
9108 part_die
->has_type
= 1;
9110 case DW_AT_abstract_origin
:
9111 case DW_AT_specification
:
9112 case DW_AT_extension
:
9113 part_die
->has_specification
= 1;
9114 part_die
->spec_offset
= dwarf2_get_ref_die_offset (&attr
);
9117 /* Ignore absolute siblings, they might point outside of
9118 the current compile unit. */
9119 if (attr
.form
== DW_FORM_ref_addr
)
9120 complaint (&symfile_complaints
,
9121 _("ignoring absolute DW_AT_sibling"));
9123 part_die
->sibling
= buffer
+ dwarf2_get_ref_die_offset (&attr
);
9125 case DW_AT_byte_size
:
9126 part_die
->has_byte_size
= 1;
9128 case DW_AT_calling_convention
:
9129 /* DWARF doesn't provide a way to identify a program's source-level
9130 entry point. DW_AT_calling_convention attributes are only meant
9131 to describe functions' calling conventions.
9133 However, because it's a necessary piece of information in
9134 Fortran, and because DW_CC_program is the only piece of debugging
9135 information whose definition refers to a 'main program' at all,
9136 several compilers have begun marking Fortran main programs with
9137 DW_CC_program --- even when those functions use the standard
9138 calling conventions.
9140 So until DWARF specifies a way to provide this information and
9141 compilers pick up the new representation, we'll support this
9143 if (DW_UNSND (&attr
) == DW_CC_program
9144 && cu
->language
== language_fortran
)
9146 set_main_name (part_die
->name
);
9148 /* As this DIE has a static linkage the name would be difficult
9149 to look up later. */
9150 language_of_main
= language_fortran
;
9158 if (has_low_pc_attr
&& has_high_pc_attr
)
9160 /* When using the GNU linker, .gnu.linkonce. sections are used to
9161 eliminate duplicate copies of functions and vtables and such.
9162 The linker will arbitrarily choose one and discard the others.
9163 The AT_*_pc values for such functions refer to local labels in
9164 these sections. If the section from that file was discarded, the
9165 labels are not in the output, so the relocs get a value of 0.
9166 If this is a discarded function, mark the pc bounds as invalid,
9167 so that GDB will ignore it. */
9168 if (part_die
->lowpc
== 0 && !dwarf2_per_objfile
->has_section_at_zero
)
9170 struct gdbarch
*gdbarch
= get_objfile_arch (cu
->objfile
);
9172 complaint (&symfile_complaints
,
9173 _("DW_AT_low_pc %s is zero "
9174 "for DIE at 0x%x [in module %s]"),
9175 paddress (gdbarch
, part_die
->lowpc
),
9176 part_die
->offset
, cu
->objfile
->name
);
9178 /* dwarf2_get_pc_bounds has also the strict low < high requirement. */
9179 else if (part_die
->lowpc
>= part_die
->highpc
)
9181 struct gdbarch
*gdbarch
= get_objfile_arch (cu
->objfile
);
9183 complaint (&symfile_complaints
,
9184 _("DW_AT_low_pc %s is not < DW_AT_high_pc %s "
9185 "for DIE at 0x%x [in module %s]"),
9186 paddress (gdbarch
, part_die
->lowpc
),
9187 paddress (gdbarch
, part_die
->highpc
),
9188 part_die
->offset
, cu
->objfile
->name
);
9191 part_die
->has_pc_info
= 1;
9197 /* Find a cached partial DIE at OFFSET in CU. */
9199 static struct partial_die_info
*
9200 find_partial_die_in_comp_unit (unsigned int offset
, struct dwarf2_cu
*cu
)
9202 struct partial_die_info
*lookup_die
= NULL
;
9203 struct partial_die_info part_die
;
9205 part_die
.offset
= offset
;
9206 lookup_die
= htab_find_with_hash (cu
->partial_dies
, &part_die
, offset
);
9211 /* Find a partial DIE at OFFSET, which may or may not be in CU,
9212 except in the case of .debug_types DIEs which do not reference
9213 outside their CU (they do however referencing other types via
9214 DW_FORM_ref_sig8). */
9216 static struct partial_die_info
*
9217 find_partial_die (unsigned int offset
, struct dwarf2_cu
*cu
)
9219 struct dwarf2_per_cu_data
*per_cu
= NULL
;
9220 struct partial_die_info
*pd
= NULL
;
9222 if (cu
->per_cu
->from_debug_types
)
9224 pd
= find_partial_die_in_comp_unit (offset
, cu
);
9230 if (offset_in_cu_p (&cu
->header
, offset
))
9232 pd
= find_partial_die_in_comp_unit (offset
, cu
);
9237 per_cu
= dwarf2_find_containing_comp_unit (offset
, cu
->objfile
);
9239 if (per_cu
->cu
== NULL
|| per_cu
->cu
->partial_dies
== NULL
)
9240 load_partial_comp_unit (per_cu
, cu
->objfile
);
9242 per_cu
->cu
->last_used
= 0;
9243 pd
= find_partial_die_in_comp_unit (offset
, per_cu
->cu
);
9245 if (pd
== NULL
&& per_cu
->load_all_dies
== 0)
9247 struct cleanup
*back_to
;
9248 struct partial_die_info comp_unit_die
;
9249 struct abbrev_info
*abbrev
;
9250 unsigned int bytes_read
;
9253 per_cu
->load_all_dies
= 1;
9255 /* Re-read the DIEs. */
9256 back_to
= make_cleanup (null_cleanup
, 0);
9257 if (per_cu
->cu
->dwarf2_abbrevs
== NULL
)
9259 dwarf2_read_abbrevs (per_cu
->cu
->objfile
->obfd
, per_cu
->cu
);
9260 make_cleanup (dwarf2_free_abbrev_table
, per_cu
->cu
);
9262 info_ptr
= (dwarf2_per_objfile
->info
.buffer
9263 + per_cu
->cu
->header
.offset
9264 + per_cu
->cu
->header
.first_die_offset
);
9265 abbrev
= peek_die_abbrev (info_ptr
, &bytes_read
, per_cu
->cu
);
9266 info_ptr
= read_partial_die (&comp_unit_die
, abbrev
, bytes_read
,
9267 per_cu
->cu
->objfile
->obfd
,
9268 dwarf2_per_objfile
->info
.buffer
, info_ptr
,
9270 if (comp_unit_die
.has_children
)
9271 load_partial_dies (per_cu
->cu
->objfile
->obfd
,
9272 dwarf2_per_objfile
->info
.buffer
, info_ptr
,
9274 do_cleanups (back_to
);
9276 pd
= find_partial_die_in_comp_unit (offset
, per_cu
->cu
);
9282 internal_error (__FILE__
, __LINE__
,
9283 _("could not find partial DIE 0x%x "
9284 "in cache [from module %s]\n"),
9285 offset
, bfd_get_filename (cu
->objfile
->obfd
));
9289 /* See if we can figure out if the class lives in a namespace. We do
9290 this by looking for a member function; its demangled name will
9291 contain namespace info, if there is any. */
9294 guess_partial_die_structure_name (struct partial_die_info
*struct_pdi
,
9295 struct dwarf2_cu
*cu
)
9297 /* NOTE: carlton/2003-10-07: Getting the info this way changes
9298 what template types look like, because the demangler
9299 frequently doesn't give the same name as the debug info. We
9300 could fix this by only using the demangled name to get the
9301 prefix (but see comment in read_structure_type). */
9303 struct partial_die_info
*real_pdi
;
9304 struct partial_die_info
*child_pdi
;
9306 /* If this DIE (this DIE's specification, if any) has a parent, then
9307 we should not do this. We'll prepend the parent's fully qualified
9308 name when we create the partial symbol. */
9310 real_pdi
= struct_pdi
;
9311 while (real_pdi
->has_specification
)
9312 real_pdi
= find_partial_die (real_pdi
->spec_offset
, cu
);
9314 if (real_pdi
->die_parent
!= NULL
)
9317 for (child_pdi
= struct_pdi
->die_child
;
9319 child_pdi
= child_pdi
->die_sibling
)
9321 if (child_pdi
->tag
== DW_TAG_subprogram
9322 && child_pdi
->linkage_name
!= NULL
)
9324 char *actual_class_name
9325 = language_class_name_from_physname (cu
->language_defn
,
9326 child_pdi
->linkage_name
);
9327 if (actual_class_name
!= NULL
)
9330 = obsavestring (actual_class_name
,
9331 strlen (actual_class_name
),
9332 &cu
->objfile
->objfile_obstack
);
9333 xfree (actual_class_name
);
9340 /* Adjust PART_DIE before generating a symbol for it. This function
9341 may set the is_external flag or change the DIE's name. */
9344 fixup_partial_die (struct partial_die_info
*part_die
,
9345 struct dwarf2_cu
*cu
)
9347 /* Once we've fixed up a die, there's no point in doing so again.
9348 This also avoids a memory leak if we were to call
9349 guess_partial_die_structure_name multiple times. */
9350 if (part_die
->fixup_called
)
9353 /* If we found a reference attribute and the DIE has no name, try
9354 to find a name in the referred to DIE. */
9356 if (part_die
->name
== NULL
&& part_die
->has_specification
)
9358 struct partial_die_info
*spec_die
;
9360 spec_die
= find_partial_die (part_die
->spec_offset
, cu
);
9362 fixup_partial_die (spec_die
, cu
);
9366 part_die
->name
= spec_die
->name
;
9368 /* Copy DW_AT_external attribute if it is set. */
9369 if (spec_die
->is_external
)
9370 part_die
->is_external
= spec_die
->is_external
;
9374 /* Set default names for some unnamed DIEs. */
9376 if (part_die
->name
== NULL
&& part_die
->tag
== DW_TAG_namespace
)
9377 part_die
->name
= "(anonymous namespace)";
9379 /* If there is no parent die to provide a namespace, and there are
9380 children, see if we can determine the namespace from their linkage
9382 NOTE: We need to do this even if cu->has_namespace_info != 0.
9383 gcc-4.5 -gdwarf-4 can drop the enclosing namespace. */
9384 if (cu
->language
== language_cplus
9385 && dwarf2_per_objfile
->types
.asection
!= NULL
9386 && part_die
->die_parent
== NULL
9387 && part_die
->has_children
9388 && (part_die
->tag
== DW_TAG_class_type
9389 || part_die
->tag
== DW_TAG_structure_type
9390 || part_die
->tag
== DW_TAG_union_type
))
9391 guess_partial_die_structure_name (part_die
, cu
);
9393 /* GCC might emit a nameless struct or union that has a linkage
9394 name. See http://gcc.gnu.org/bugzilla/show_bug.cgi?id=47510. */
9395 if (part_die
->name
== NULL
9396 && (part_die
->tag
== DW_TAG_structure_type
9397 || part_die
->tag
== DW_TAG_union_type
9398 || part_die
->tag
== DW_TAG_class_type
)
9399 && part_die
->linkage_name
!= NULL
)
9403 demangled
= cplus_demangle (part_die
->linkage_name
, DMGL_TYPES
);
9406 part_die
->name
= obsavestring (demangled
, strlen (demangled
),
9407 &cu
->objfile
->objfile_obstack
);
9412 part_die
->fixup_called
= 1;
9415 /* Read an attribute value described by an attribute form. */
9418 read_attribute_value (struct attribute
*attr
, unsigned form
,
9419 bfd
*abfd
, gdb_byte
*info_ptr
,
9420 struct dwarf2_cu
*cu
)
9422 struct comp_unit_head
*cu_header
= &cu
->header
;
9423 unsigned int bytes_read
;
9424 struct dwarf_block
*blk
;
9429 case DW_FORM_ref_addr
:
9430 if (cu
->header
.version
== 2)
9431 DW_ADDR (attr
) = read_address (abfd
, info_ptr
, cu
, &bytes_read
);
9433 DW_ADDR (attr
) = read_offset (abfd
, info_ptr
,
9434 &cu
->header
, &bytes_read
);
9435 info_ptr
+= bytes_read
;
9438 DW_ADDR (attr
) = read_address (abfd
, info_ptr
, cu
, &bytes_read
);
9439 info_ptr
+= bytes_read
;
9441 case DW_FORM_block2
:
9442 blk
= dwarf_alloc_block (cu
);
9443 blk
->size
= read_2_bytes (abfd
, info_ptr
);
9445 blk
->data
= read_n_bytes (abfd
, info_ptr
, blk
->size
);
9446 info_ptr
+= blk
->size
;
9447 DW_BLOCK (attr
) = blk
;
9449 case DW_FORM_block4
:
9450 blk
= dwarf_alloc_block (cu
);
9451 blk
->size
= read_4_bytes (abfd
, info_ptr
);
9453 blk
->data
= read_n_bytes (abfd
, info_ptr
, blk
->size
);
9454 info_ptr
+= blk
->size
;
9455 DW_BLOCK (attr
) = blk
;
9458 DW_UNSND (attr
) = read_2_bytes (abfd
, info_ptr
);
9462 DW_UNSND (attr
) = read_4_bytes (abfd
, info_ptr
);
9466 DW_UNSND (attr
) = read_8_bytes (abfd
, info_ptr
);
9469 case DW_FORM_sec_offset
:
9470 DW_UNSND (attr
) = read_offset (abfd
, info_ptr
, &cu
->header
, &bytes_read
);
9471 info_ptr
+= bytes_read
;
9473 case DW_FORM_string
:
9474 DW_STRING (attr
) = read_direct_string (abfd
, info_ptr
, &bytes_read
);
9475 DW_STRING_IS_CANONICAL (attr
) = 0;
9476 info_ptr
+= bytes_read
;
9479 DW_STRING (attr
) = read_indirect_string (abfd
, info_ptr
, cu_header
,
9481 DW_STRING_IS_CANONICAL (attr
) = 0;
9482 info_ptr
+= bytes_read
;
9484 case DW_FORM_exprloc
:
9486 blk
= dwarf_alloc_block (cu
);
9487 blk
->size
= read_unsigned_leb128 (abfd
, info_ptr
, &bytes_read
);
9488 info_ptr
+= bytes_read
;
9489 blk
->data
= read_n_bytes (abfd
, info_ptr
, blk
->size
);
9490 info_ptr
+= blk
->size
;
9491 DW_BLOCK (attr
) = blk
;
9493 case DW_FORM_block1
:
9494 blk
= dwarf_alloc_block (cu
);
9495 blk
->size
= read_1_byte (abfd
, info_ptr
);
9497 blk
->data
= read_n_bytes (abfd
, info_ptr
, blk
->size
);
9498 info_ptr
+= blk
->size
;
9499 DW_BLOCK (attr
) = blk
;
9502 DW_UNSND (attr
) = read_1_byte (abfd
, info_ptr
);
9506 DW_UNSND (attr
) = read_1_byte (abfd
, info_ptr
);
9509 case DW_FORM_flag_present
:
9510 DW_UNSND (attr
) = 1;
9513 DW_SND (attr
) = read_signed_leb128 (abfd
, info_ptr
, &bytes_read
);
9514 info_ptr
+= bytes_read
;
9517 DW_UNSND (attr
) = read_unsigned_leb128 (abfd
, info_ptr
, &bytes_read
);
9518 info_ptr
+= bytes_read
;
9521 DW_ADDR (attr
) = cu
->header
.offset
+ read_1_byte (abfd
, info_ptr
);
9525 DW_ADDR (attr
) = cu
->header
.offset
+ read_2_bytes (abfd
, info_ptr
);
9529 DW_ADDR (attr
) = cu
->header
.offset
+ read_4_bytes (abfd
, info_ptr
);
9533 DW_ADDR (attr
) = cu
->header
.offset
+ read_8_bytes (abfd
, info_ptr
);
9536 case DW_FORM_ref_sig8
:
9537 /* Convert the signature to something we can record in DW_UNSND
9539 NOTE: This is NULL if the type wasn't found. */
9540 DW_SIGNATURED_TYPE (attr
) =
9541 lookup_signatured_type (cu
->objfile
, read_8_bytes (abfd
, info_ptr
));
9544 case DW_FORM_ref_udata
:
9545 DW_ADDR (attr
) = (cu
->header
.offset
9546 + read_unsigned_leb128 (abfd
, info_ptr
, &bytes_read
));
9547 info_ptr
+= bytes_read
;
9549 case DW_FORM_indirect
:
9550 form
= read_unsigned_leb128 (abfd
, info_ptr
, &bytes_read
);
9551 info_ptr
+= bytes_read
;
9552 info_ptr
= read_attribute_value (attr
, form
, abfd
, info_ptr
, cu
);
9555 error (_("Dwarf Error: Cannot handle %s in DWARF reader [in module %s]"),
9556 dwarf_form_name (form
),
9557 bfd_get_filename (abfd
));
9560 /* We have seen instances where the compiler tried to emit a byte
9561 size attribute of -1 which ended up being encoded as an unsigned
9562 0xffffffff. Although 0xffffffff is technically a valid size value,
9563 an object of this size seems pretty unlikely so we can relatively
9564 safely treat these cases as if the size attribute was invalid and
9565 treat them as zero by default. */
9566 if (attr
->name
== DW_AT_byte_size
9567 && form
== DW_FORM_data4
9568 && DW_UNSND (attr
) >= 0xffffffff)
9571 (&symfile_complaints
,
9572 _("Suspicious DW_AT_byte_size value treated as zero instead of %s"),
9573 hex_string (DW_UNSND (attr
)));
9574 DW_UNSND (attr
) = 0;
9580 /* Read an attribute described by an abbreviated attribute. */
9583 read_attribute (struct attribute
*attr
, struct attr_abbrev
*abbrev
,
9584 bfd
*abfd
, gdb_byte
*info_ptr
, struct dwarf2_cu
*cu
)
9586 attr
->name
= abbrev
->name
;
9587 return read_attribute_value (attr
, abbrev
->form
, abfd
, info_ptr
, cu
);
9590 /* Read dwarf information from a buffer. */
9593 read_1_byte (bfd
*abfd
, gdb_byte
*buf
)
9595 return bfd_get_8 (abfd
, buf
);
9599 read_1_signed_byte (bfd
*abfd
, gdb_byte
*buf
)
9601 return bfd_get_signed_8 (abfd
, buf
);
9605 read_2_bytes (bfd
*abfd
, gdb_byte
*buf
)
9607 return bfd_get_16 (abfd
, buf
);
9611 read_2_signed_bytes (bfd
*abfd
, gdb_byte
*buf
)
9613 return bfd_get_signed_16 (abfd
, buf
);
9617 read_4_bytes (bfd
*abfd
, gdb_byte
*buf
)
9619 return bfd_get_32 (abfd
, buf
);
9623 read_4_signed_bytes (bfd
*abfd
, gdb_byte
*buf
)
9625 return bfd_get_signed_32 (abfd
, buf
);
9629 read_8_bytes (bfd
*abfd
, gdb_byte
*buf
)
9631 return bfd_get_64 (abfd
, buf
);
9635 read_address (bfd
*abfd
, gdb_byte
*buf
, struct dwarf2_cu
*cu
,
9636 unsigned int *bytes_read
)
9638 struct comp_unit_head
*cu_header
= &cu
->header
;
9639 CORE_ADDR retval
= 0;
9641 if (cu_header
->signed_addr_p
)
9643 switch (cu_header
->addr_size
)
9646 retval
= bfd_get_signed_16 (abfd
, buf
);
9649 retval
= bfd_get_signed_32 (abfd
, buf
);
9652 retval
= bfd_get_signed_64 (abfd
, buf
);
9655 internal_error (__FILE__
, __LINE__
,
9656 _("read_address: bad switch, signed [in module %s]"),
9657 bfd_get_filename (abfd
));
9662 switch (cu_header
->addr_size
)
9665 retval
= bfd_get_16 (abfd
, buf
);
9668 retval
= bfd_get_32 (abfd
, buf
);
9671 retval
= bfd_get_64 (abfd
, buf
);
9674 internal_error (__FILE__
, __LINE__
,
9675 _("read_address: bad switch, "
9676 "unsigned [in module %s]"),
9677 bfd_get_filename (abfd
));
9681 *bytes_read
= cu_header
->addr_size
;
9685 /* Read the initial length from a section. The (draft) DWARF 3
9686 specification allows the initial length to take up either 4 bytes
9687 or 12 bytes. If the first 4 bytes are 0xffffffff, then the next 8
9688 bytes describe the length and all offsets will be 8 bytes in length
9691 An older, non-standard 64-bit format is also handled by this
9692 function. The older format in question stores the initial length
9693 as an 8-byte quantity without an escape value. Lengths greater
9694 than 2^32 aren't very common which means that the initial 4 bytes
9695 is almost always zero. Since a length value of zero doesn't make
9696 sense for the 32-bit format, this initial zero can be considered to
9697 be an escape value which indicates the presence of the older 64-bit
9698 format. As written, the code can't detect (old format) lengths
9699 greater than 4GB. If it becomes necessary to handle lengths
9700 somewhat larger than 4GB, we could allow other small values (such
9701 as the non-sensical values of 1, 2, and 3) to also be used as
9702 escape values indicating the presence of the old format.
9704 The value returned via bytes_read should be used to increment the
9705 relevant pointer after calling read_initial_length().
9707 [ Note: read_initial_length() and read_offset() are based on the
9708 document entitled "DWARF Debugging Information Format", revision
9709 3, draft 8, dated November 19, 2001. This document was obtained
9712 http://reality.sgiweb.org/davea/dwarf3-draft8-011125.pdf
9714 This document is only a draft and is subject to change. (So beware.)
9716 Details regarding the older, non-standard 64-bit format were
9717 determined empirically by examining 64-bit ELF files produced by
9718 the SGI toolchain on an IRIX 6.5 machine.
9720 - Kevin, July 16, 2002
9724 read_initial_length (bfd
*abfd
, gdb_byte
*buf
, unsigned int *bytes_read
)
9726 LONGEST length
= bfd_get_32 (abfd
, buf
);
9728 if (length
== 0xffffffff)
9730 length
= bfd_get_64 (abfd
, buf
+ 4);
9733 else if (length
== 0)
9735 /* Handle the (non-standard) 64-bit DWARF2 format used by IRIX. */
9736 length
= bfd_get_64 (abfd
, buf
);
9747 /* Cover function for read_initial_length.
9748 Returns the length of the object at BUF, and stores the size of the
9749 initial length in *BYTES_READ and stores the size that offsets will be in
9751 If the initial length size is not equivalent to that specified in
9752 CU_HEADER then issue a complaint.
9753 This is useful when reading non-comp-unit headers. */
9756 read_checked_initial_length_and_offset (bfd
*abfd
, gdb_byte
*buf
,
9757 const struct comp_unit_head
*cu_header
,
9758 unsigned int *bytes_read
,
9759 unsigned int *offset_size
)
9761 LONGEST length
= read_initial_length (abfd
, buf
, bytes_read
);
9763 gdb_assert (cu_header
->initial_length_size
== 4
9764 || cu_header
->initial_length_size
== 8
9765 || cu_header
->initial_length_size
== 12);
9767 if (cu_header
->initial_length_size
!= *bytes_read
)
9768 complaint (&symfile_complaints
,
9769 _("intermixed 32-bit and 64-bit DWARF sections"));
9771 *offset_size
= (*bytes_read
== 4) ? 4 : 8;
9775 /* Read an offset from the data stream. The size of the offset is
9776 given by cu_header->offset_size. */
9779 read_offset (bfd
*abfd
, gdb_byte
*buf
, const struct comp_unit_head
*cu_header
,
9780 unsigned int *bytes_read
)
9782 LONGEST offset
= read_offset_1 (abfd
, buf
, cu_header
->offset_size
);
9784 *bytes_read
= cu_header
->offset_size
;
9788 /* Read an offset from the data stream. */
9791 read_offset_1 (bfd
*abfd
, gdb_byte
*buf
, unsigned int offset_size
)
9795 switch (offset_size
)
9798 retval
= bfd_get_32 (abfd
, buf
);
9801 retval
= bfd_get_64 (abfd
, buf
);
9804 internal_error (__FILE__
, __LINE__
,
9805 _("read_offset_1: bad switch [in module %s]"),
9806 bfd_get_filename (abfd
));
9813 read_n_bytes (bfd
*abfd
, gdb_byte
*buf
, unsigned int size
)
9815 /* If the size of a host char is 8 bits, we can return a pointer
9816 to the buffer, otherwise we have to copy the data to a buffer
9817 allocated on the temporary obstack. */
9818 gdb_assert (HOST_CHAR_BIT
== 8);
9823 read_direct_string (bfd
*abfd
, gdb_byte
*buf
, unsigned int *bytes_read_ptr
)
9825 /* If the size of a host char is 8 bits, we can return a pointer
9826 to the string, otherwise we have to copy the string to a buffer
9827 allocated on the temporary obstack. */
9828 gdb_assert (HOST_CHAR_BIT
== 8);
9831 *bytes_read_ptr
= 1;
9834 *bytes_read_ptr
= strlen ((char *) buf
) + 1;
9835 return (char *) buf
;
9839 read_indirect_string (bfd
*abfd
, gdb_byte
*buf
,
9840 const struct comp_unit_head
*cu_header
,
9841 unsigned int *bytes_read_ptr
)
9843 LONGEST str_offset
= read_offset (abfd
, buf
, cu_header
, bytes_read_ptr
);
9845 dwarf2_read_section (dwarf2_per_objfile
->objfile
, &dwarf2_per_objfile
->str
);
9846 if (dwarf2_per_objfile
->str
.buffer
== NULL
)
9848 error (_("DW_FORM_strp used without .debug_str section [in module %s]"),
9849 bfd_get_filename (abfd
));
9852 if (str_offset
>= dwarf2_per_objfile
->str
.size
)
9854 error (_("DW_FORM_strp pointing outside of "
9855 ".debug_str section [in module %s]"),
9856 bfd_get_filename (abfd
));
9859 gdb_assert (HOST_CHAR_BIT
== 8);
9860 if (dwarf2_per_objfile
->str
.buffer
[str_offset
] == '\0')
9862 return (char *) (dwarf2_per_objfile
->str
.buffer
+ str_offset
);
9865 static unsigned long
9866 read_unsigned_leb128 (bfd
*abfd
, gdb_byte
*buf
, unsigned int *bytes_read_ptr
)
9868 unsigned long result
;
9869 unsigned int num_read
;
9879 byte
= bfd_get_8 (abfd
, buf
);
9882 result
|= ((unsigned long)(byte
& 127) << shift
);
9883 if ((byte
& 128) == 0)
9889 *bytes_read_ptr
= num_read
;
9894 read_signed_leb128 (bfd
*abfd
, gdb_byte
*buf
, unsigned int *bytes_read_ptr
)
9897 int i
, shift
, num_read
;
9906 byte
= bfd_get_8 (abfd
, buf
);
9909 result
|= ((long)(byte
& 127) << shift
);
9911 if ((byte
& 128) == 0)
9916 if ((shift
< 8 * sizeof (result
)) && (byte
& 0x40))
9917 result
|= -(((long)1) << shift
);
9918 *bytes_read_ptr
= num_read
;
9922 /* Return a pointer to just past the end of an LEB128 number in BUF. */
9925 skip_leb128 (bfd
*abfd
, gdb_byte
*buf
)
9931 byte
= bfd_get_8 (abfd
, buf
);
9933 if ((byte
& 128) == 0)
9939 set_cu_language (unsigned int lang
, struct dwarf2_cu
*cu
)
9946 cu
->language
= language_c
;
9948 case DW_LANG_C_plus_plus
:
9949 cu
->language
= language_cplus
;
9952 cu
->language
= language_d
;
9954 case DW_LANG_Fortran77
:
9955 case DW_LANG_Fortran90
:
9956 case DW_LANG_Fortran95
:
9957 cu
->language
= language_fortran
;
9959 case DW_LANG_Mips_Assembler
:
9960 cu
->language
= language_asm
;
9963 cu
->language
= language_java
;
9967 cu
->language
= language_ada
;
9969 case DW_LANG_Modula2
:
9970 cu
->language
= language_m2
;
9972 case DW_LANG_Pascal83
:
9973 cu
->language
= language_pascal
;
9976 cu
->language
= language_objc
;
9978 case DW_LANG_Cobol74
:
9979 case DW_LANG_Cobol85
:
9981 cu
->language
= language_minimal
;
9984 cu
->language_defn
= language_def (cu
->language
);
9987 /* Return the named attribute or NULL if not there. */
9989 static struct attribute
*
9990 dwarf2_attr (struct die_info
*die
, unsigned int name
, struct dwarf2_cu
*cu
)
9993 struct attribute
*spec
= NULL
;
9995 for (i
= 0; i
< die
->num_attrs
; ++i
)
9997 if (die
->attrs
[i
].name
== name
)
9998 return &die
->attrs
[i
];
9999 if (die
->attrs
[i
].name
== DW_AT_specification
10000 || die
->attrs
[i
].name
== DW_AT_abstract_origin
)
10001 spec
= &die
->attrs
[i
];
10006 die
= follow_die_ref (die
, spec
, &cu
);
10007 return dwarf2_attr (die
, name
, cu
);
10013 /* Return the named attribute or NULL if not there,
10014 but do not follow DW_AT_specification, etc.
10015 This is for use in contexts where we're reading .debug_types dies.
10016 Following DW_AT_specification, DW_AT_abstract_origin will take us
10017 back up the chain, and we want to go down. */
10019 static struct attribute
*
10020 dwarf2_attr_no_follow (struct die_info
*die
, unsigned int name
,
10021 struct dwarf2_cu
*cu
)
10025 for (i
= 0; i
< die
->num_attrs
; ++i
)
10026 if (die
->attrs
[i
].name
== name
)
10027 return &die
->attrs
[i
];
10032 /* Return non-zero iff the attribute NAME is defined for the given DIE,
10033 and holds a non-zero value. This function should only be used for
10034 DW_FORM_flag or DW_FORM_flag_present attributes. */
10037 dwarf2_flag_true_p (struct die_info
*die
, unsigned name
, struct dwarf2_cu
*cu
)
10039 struct attribute
*attr
= dwarf2_attr (die
, name
, cu
);
10041 return (attr
&& DW_UNSND (attr
));
10045 die_is_declaration (struct die_info
*die
, struct dwarf2_cu
*cu
)
10047 /* A DIE is a declaration if it has a DW_AT_declaration attribute
10048 which value is non-zero. However, we have to be careful with
10049 DIEs having a DW_AT_specification attribute, because dwarf2_attr()
10050 (via dwarf2_flag_true_p) follows this attribute. So we may
10051 end up accidently finding a declaration attribute that belongs
10052 to a different DIE referenced by the specification attribute,
10053 even though the given DIE does not have a declaration attribute. */
10054 return (dwarf2_flag_true_p (die
, DW_AT_declaration
, cu
)
10055 && dwarf2_attr (die
, DW_AT_specification
, cu
) == NULL
);
10058 /* Return the die giving the specification for DIE, if there is
10059 one. *SPEC_CU is the CU containing DIE on input, and the CU
10060 containing the return value on output. If there is no
10061 specification, but there is an abstract origin, that is
10064 static struct die_info
*
10065 die_specification (struct die_info
*die
, struct dwarf2_cu
**spec_cu
)
10067 struct attribute
*spec_attr
= dwarf2_attr (die
, DW_AT_specification
,
10070 if (spec_attr
== NULL
)
10071 spec_attr
= dwarf2_attr (die
, DW_AT_abstract_origin
, *spec_cu
);
10073 if (spec_attr
== NULL
)
10076 return follow_die_ref (die
, spec_attr
, spec_cu
);
10079 /* Free the line_header structure *LH, and any arrays and strings it
10081 NOTE: This is also used as a "cleanup" function. */
10084 free_line_header (struct line_header
*lh
)
10086 if (lh
->standard_opcode_lengths
)
10087 xfree (lh
->standard_opcode_lengths
);
10089 /* Remember that all the lh->file_names[i].name pointers are
10090 pointers into debug_line_buffer, and don't need to be freed. */
10091 if (lh
->file_names
)
10092 xfree (lh
->file_names
);
10094 /* Similarly for the include directory names. */
10095 if (lh
->include_dirs
)
10096 xfree (lh
->include_dirs
);
10101 /* Add an entry to LH's include directory table. */
10104 add_include_dir (struct line_header
*lh
, char *include_dir
)
10106 /* Grow the array if necessary. */
10107 if (lh
->include_dirs_size
== 0)
10109 lh
->include_dirs_size
= 1; /* for testing */
10110 lh
->include_dirs
= xmalloc (lh
->include_dirs_size
10111 * sizeof (*lh
->include_dirs
));
10113 else if (lh
->num_include_dirs
>= lh
->include_dirs_size
)
10115 lh
->include_dirs_size
*= 2;
10116 lh
->include_dirs
= xrealloc (lh
->include_dirs
,
10117 (lh
->include_dirs_size
10118 * sizeof (*lh
->include_dirs
)));
10121 lh
->include_dirs
[lh
->num_include_dirs
++] = include_dir
;
10124 /* Add an entry to LH's file name table. */
10127 add_file_name (struct line_header
*lh
,
10129 unsigned int dir_index
,
10130 unsigned int mod_time
,
10131 unsigned int length
)
10133 struct file_entry
*fe
;
10135 /* Grow the array if necessary. */
10136 if (lh
->file_names_size
== 0)
10138 lh
->file_names_size
= 1; /* for testing */
10139 lh
->file_names
= xmalloc (lh
->file_names_size
10140 * sizeof (*lh
->file_names
));
10142 else if (lh
->num_file_names
>= lh
->file_names_size
)
10144 lh
->file_names_size
*= 2;
10145 lh
->file_names
= xrealloc (lh
->file_names
,
10146 (lh
->file_names_size
10147 * sizeof (*lh
->file_names
)));
10150 fe
= &lh
->file_names
[lh
->num_file_names
++];
10152 fe
->dir_index
= dir_index
;
10153 fe
->mod_time
= mod_time
;
10154 fe
->length
= length
;
10155 fe
->included_p
= 0;
10159 /* Read the statement program header starting at OFFSET in
10160 .debug_line, according to the endianness of ABFD. Return a pointer
10161 to a struct line_header, allocated using xmalloc.
10163 NOTE: the strings in the include directory and file name tables of
10164 the returned object point into debug_line_buffer, and must not be
10167 static struct line_header
*
10168 dwarf_decode_line_header (unsigned int offset
, bfd
*abfd
,
10169 struct dwarf2_cu
*cu
)
10171 struct cleanup
*back_to
;
10172 struct line_header
*lh
;
10173 gdb_byte
*line_ptr
;
10174 unsigned int bytes_read
, offset_size
;
10176 char *cur_dir
, *cur_file
;
10178 dwarf2_read_section (dwarf2_per_objfile
->objfile
, &dwarf2_per_objfile
->line
);
10179 if (dwarf2_per_objfile
->line
.buffer
== NULL
)
10181 complaint (&symfile_complaints
, _("missing .debug_line section"));
10185 /* Make sure that at least there's room for the total_length field.
10186 That could be 12 bytes long, but we're just going to fudge that. */
10187 if (offset
+ 4 >= dwarf2_per_objfile
->line
.size
)
10189 dwarf2_statement_list_fits_in_line_number_section_complaint ();
10193 lh
= xmalloc (sizeof (*lh
));
10194 memset (lh
, 0, sizeof (*lh
));
10195 back_to
= make_cleanup ((make_cleanup_ftype
*) free_line_header
,
10198 line_ptr
= dwarf2_per_objfile
->line
.buffer
+ offset
;
10200 /* Read in the header. */
10202 read_checked_initial_length_and_offset (abfd
, line_ptr
, &cu
->header
,
10203 &bytes_read
, &offset_size
);
10204 line_ptr
+= bytes_read
;
10205 if (line_ptr
+ lh
->total_length
> (dwarf2_per_objfile
->line
.buffer
10206 + dwarf2_per_objfile
->line
.size
))
10208 dwarf2_statement_list_fits_in_line_number_section_complaint ();
10211 lh
->statement_program_end
= line_ptr
+ lh
->total_length
;
10212 lh
->version
= read_2_bytes (abfd
, line_ptr
);
10214 lh
->header_length
= read_offset_1 (abfd
, line_ptr
, offset_size
);
10215 line_ptr
+= offset_size
;
10216 lh
->minimum_instruction_length
= read_1_byte (abfd
, line_ptr
);
10218 if (lh
->version
>= 4)
10220 lh
->maximum_ops_per_instruction
= read_1_byte (abfd
, line_ptr
);
10224 lh
->maximum_ops_per_instruction
= 1;
10226 if (lh
->maximum_ops_per_instruction
== 0)
10228 lh
->maximum_ops_per_instruction
= 1;
10229 complaint (&symfile_complaints
,
10230 _("invalid maximum_ops_per_instruction "
10231 "in `.debug_line' section"));
10234 lh
->default_is_stmt
= read_1_byte (abfd
, line_ptr
);
10236 lh
->line_base
= read_1_signed_byte (abfd
, line_ptr
);
10238 lh
->line_range
= read_1_byte (abfd
, line_ptr
);
10240 lh
->opcode_base
= read_1_byte (abfd
, line_ptr
);
10242 lh
->standard_opcode_lengths
10243 = xmalloc (lh
->opcode_base
* sizeof (lh
->standard_opcode_lengths
[0]));
10245 lh
->standard_opcode_lengths
[0] = 1; /* This should never be used anyway. */
10246 for (i
= 1; i
< lh
->opcode_base
; ++i
)
10248 lh
->standard_opcode_lengths
[i
] = read_1_byte (abfd
, line_ptr
);
10252 /* Read directory table. */
10253 while ((cur_dir
= read_direct_string (abfd
, line_ptr
, &bytes_read
)) != NULL
)
10255 line_ptr
+= bytes_read
;
10256 add_include_dir (lh
, cur_dir
);
10258 line_ptr
+= bytes_read
;
10260 /* Read file name table. */
10261 while ((cur_file
= read_direct_string (abfd
, line_ptr
, &bytes_read
)) != NULL
)
10263 unsigned int dir_index
, mod_time
, length
;
10265 line_ptr
+= bytes_read
;
10266 dir_index
= read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
10267 line_ptr
+= bytes_read
;
10268 mod_time
= read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
10269 line_ptr
+= bytes_read
;
10270 length
= read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
10271 line_ptr
+= bytes_read
;
10273 add_file_name (lh
, cur_file
, dir_index
, mod_time
, length
);
10275 line_ptr
+= bytes_read
;
10276 lh
->statement_program_start
= line_ptr
;
10278 if (line_ptr
> (dwarf2_per_objfile
->line
.buffer
10279 + dwarf2_per_objfile
->line
.size
))
10280 complaint (&symfile_complaints
,
10281 _("line number info header doesn't "
10282 "fit in `.debug_line' section"));
10284 discard_cleanups (back_to
);
10288 /* This function exists to work around a bug in certain compilers
10289 (particularly GCC 2.95), in which the first line number marker of a
10290 function does not show up until after the prologue, right before
10291 the second line number marker. This function shifts ADDRESS down
10292 to the beginning of the function if necessary, and is called on
10293 addresses passed to record_line. */
10296 check_cu_functions (CORE_ADDR address
, struct dwarf2_cu
*cu
)
10298 struct function_range
*fn
;
10300 /* Find the function_range containing address. */
10304 if (!cu
->cached_fn
)
10305 cu
->cached_fn
= cu
->first_fn
;
10307 fn
= cu
->cached_fn
;
10309 if (fn
->lowpc
<= address
&& fn
->highpc
> address
)
10315 while (fn
&& fn
!= cu
->cached_fn
)
10316 if (fn
->lowpc
<= address
&& fn
->highpc
> address
)
10326 if (address
!= fn
->lowpc
)
10327 complaint (&symfile_complaints
,
10328 _("misplaced first line number at 0x%lx for '%s'"),
10329 (unsigned long) address
, fn
->name
);
10334 /* Subroutine of dwarf_decode_lines to simplify it.
10335 Return the file name of the psymtab for included file FILE_INDEX
10336 in line header LH of PST.
10337 COMP_DIR is the compilation directory (DW_AT_comp_dir) or NULL if unknown.
10338 If space for the result is malloc'd, it will be freed by a cleanup.
10339 Returns NULL if FILE_INDEX should be ignored, i.e., it is pst->filename. */
10342 psymtab_include_file_name (const struct line_header
*lh
, int file_index
,
10343 const struct partial_symtab
*pst
,
10344 const char *comp_dir
)
10346 const struct file_entry fe
= lh
->file_names
[file_index
];
10347 char *include_name
= fe
.name
;
10348 char *include_name_to_compare
= include_name
;
10349 char *dir_name
= NULL
;
10350 const char *pst_filename
;
10351 char *copied_name
= NULL
;
10355 dir_name
= lh
->include_dirs
[fe
.dir_index
- 1];
10357 if (!IS_ABSOLUTE_PATH (include_name
)
10358 && (dir_name
!= NULL
|| comp_dir
!= NULL
))
10360 /* Avoid creating a duplicate psymtab for PST.
10361 We do this by comparing INCLUDE_NAME and PST_FILENAME.
10362 Before we do the comparison, however, we need to account
10363 for DIR_NAME and COMP_DIR.
10364 First prepend dir_name (if non-NULL). If we still don't
10365 have an absolute path prepend comp_dir (if non-NULL).
10366 However, the directory we record in the include-file's
10367 psymtab does not contain COMP_DIR (to match the
10368 corresponding symtab(s)).
10373 bash$ gcc -g ./hello.c
10374 include_name = "hello.c"
10376 DW_AT_comp_dir = comp_dir = "/tmp"
10377 DW_AT_name = "./hello.c" */
10379 if (dir_name
!= NULL
)
10381 include_name
= concat (dir_name
, SLASH_STRING
,
10382 include_name
, (char *)NULL
);
10383 include_name_to_compare
= include_name
;
10384 make_cleanup (xfree
, include_name
);
10386 if (!IS_ABSOLUTE_PATH (include_name
) && comp_dir
!= NULL
)
10388 include_name_to_compare
= concat (comp_dir
, SLASH_STRING
,
10389 include_name
, (char *)NULL
);
10393 pst_filename
= pst
->filename
;
10394 if (!IS_ABSOLUTE_PATH (pst_filename
) && pst
->dirname
!= NULL
)
10396 copied_name
= concat (pst
->dirname
, SLASH_STRING
,
10397 pst_filename
, (char *)NULL
);
10398 pst_filename
= copied_name
;
10401 file_is_pst
= FILENAME_CMP (include_name_to_compare
, pst_filename
) == 0;
10403 if (include_name_to_compare
!= include_name
)
10404 xfree (include_name_to_compare
);
10405 if (copied_name
!= NULL
)
10406 xfree (copied_name
);
10410 return include_name
;
10413 /* Ignore this record_line request. */
10416 noop_record_line (struct subfile
*subfile
, int line
, CORE_ADDR pc
)
10421 /* Decode the Line Number Program (LNP) for the given line_header
10422 structure and CU. The actual information extracted and the type
10423 of structures created from the LNP depends on the value of PST.
10425 1. If PST is NULL, then this procedure uses the data from the program
10426 to create all necessary symbol tables, and their linetables.
10428 2. If PST is not NULL, this procedure reads the program to determine
10429 the list of files included by the unit represented by PST, and
10430 builds all the associated partial symbol tables.
10432 COMP_DIR is the compilation directory (DW_AT_comp_dir) or NULL if unknown.
10433 It is used for relative paths in the line table.
10434 NOTE: When processing partial symtabs (pst != NULL),
10435 comp_dir == pst->dirname.
10437 NOTE: It is important that psymtabs have the same file name (via strcmp)
10438 as the corresponding symtab. Since COMP_DIR is not used in the name of the
10439 symtab we don't use it in the name of the psymtabs we create.
10440 E.g. expand_line_sal requires this when finding psymtabs to expand.
10441 A good testcase for this is mb-inline.exp. */
10444 dwarf_decode_lines (struct line_header
*lh
, const char *comp_dir
, bfd
*abfd
,
10445 struct dwarf2_cu
*cu
, struct partial_symtab
*pst
)
10447 gdb_byte
*line_ptr
, *extended_end
;
10448 gdb_byte
*line_end
;
10449 unsigned int bytes_read
, extended_len
;
10450 unsigned char op_code
, extended_op
, adj_opcode
;
10451 CORE_ADDR baseaddr
;
10452 struct objfile
*objfile
= cu
->objfile
;
10453 struct gdbarch
*gdbarch
= get_objfile_arch (objfile
);
10454 const int decode_for_pst_p
= (pst
!= NULL
);
10455 struct subfile
*last_subfile
= NULL
, *first_subfile
= current_subfile
;
10456 void (*p_record_line
) (struct subfile
*subfile
, int line
, CORE_ADDR pc
)
10459 baseaddr
= ANOFFSET (objfile
->section_offsets
, SECT_OFF_TEXT (objfile
));
10461 line_ptr
= lh
->statement_program_start
;
10462 line_end
= lh
->statement_program_end
;
10464 /* Read the statement sequences until there's nothing left. */
10465 while (line_ptr
< line_end
)
10467 /* state machine registers */
10468 CORE_ADDR address
= 0;
10469 unsigned int file
= 1;
10470 unsigned int line
= 1;
10471 unsigned int column
= 0;
10472 int is_stmt
= lh
->default_is_stmt
;
10473 int basic_block
= 0;
10474 int end_sequence
= 0;
10476 unsigned char op_index
= 0;
10478 if (!decode_for_pst_p
&& lh
->num_file_names
>= file
)
10480 /* Start a subfile for the current file of the state machine. */
10481 /* lh->include_dirs and lh->file_names are 0-based, but the
10482 directory and file name numbers in the statement program
10484 struct file_entry
*fe
= &lh
->file_names
[file
- 1];
10488 dir
= lh
->include_dirs
[fe
->dir_index
- 1];
10490 dwarf2_start_subfile (fe
->name
, dir
, comp_dir
);
10493 /* Decode the table. */
10494 while (!end_sequence
)
10496 op_code
= read_1_byte (abfd
, line_ptr
);
10498 if (line_ptr
> line_end
)
10500 dwarf2_debug_line_missing_end_sequence_complaint ();
10504 if (op_code
>= lh
->opcode_base
)
10506 /* Special operand. */
10507 adj_opcode
= op_code
- lh
->opcode_base
;
10508 address
+= (((op_index
+ (adj_opcode
/ lh
->line_range
))
10509 / lh
->maximum_ops_per_instruction
)
10510 * lh
->minimum_instruction_length
);
10511 op_index
= ((op_index
+ (adj_opcode
/ lh
->line_range
))
10512 % lh
->maximum_ops_per_instruction
);
10513 line
+= lh
->line_base
+ (adj_opcode
% lh
->line_range
);
10514 if (lh
->num_file_names
< file
|| file
== 0)
10515 dwarf2_debug_line_missing_file_complaint ();
10516 /* For now we ignore lines not starting on an
10517 instruction boundary. */
10518 else if (op_index
== 0)
10520 lh
->file_names
[file
- 1].included_p
= 1;
10521 if (!decode_for_pst_p
&& is_stmt
)
10523 if (last_subfile
!= current_subfile
)
10525 addr
= gdbarch_addr_bits_remove (gdbarch
, address
);
10527 (*p_record_line
) (last_subfile
, 0, addr
);
10528 last_subfile
= current_subfile
;
10530 /* Append row to matrix using current values. */
10531 addr
= check_cu_functions (address
, cu
);
10532 addr
= gdbarch_addr_bits_remove (gdbarch
, addr
);
10533 (*p_record_line
) (current_subfile
, line
, addr
);
10538 else switch (op_code
)
10540 case DW_LNS_extended_op
:
10541 extended_len
= read_unsigned_leb128 (abfd
, line_ptr
,
10543 line_ptr
+= bytes_read
;
10544 extended_end
= line_ptr
+ extended_len
;
10545 extended_op
= read_1_byte (abfd
, line_ptr
);
10547 switch (extended_op
)
10549 case DW_LNE_end_sequence
:
10550 p_record_line
= record_line
;
10553 case DW_LNE_set_address
:
10554 address
= read_address (abfd
, line_ptr
, cu
, &bytes_read
);
10556 if (address
== 0 && !dwarf2_per_objfile
->has_section_at_zero
)
10558 /* This line table is for a function which has been
10559 GCd by the linker. Ignore it. PR gdb/12528 */
10562 = line_ptr
- dwarf2_per_objfile
->line
.buffer
;
10564 complaint (&symfile_complaints
,
10565 _(".debug_line address at offset 0x%lx is 0 "
10567 line_offset
, cu
->objfile
->name
);
10568 p_record_line
= noop_record_line
;
10572 line_ptr
+= bytes_read
;
10573 address
+= baseaddr
;
10575 case DW_LNE_define_file
:
10578 unsigned int dir_index
, mod_time
, length
;
10580 cur_file
= read_direct_string (abfd
, line_ptr
,
10582 line_ptr
+= bytes_read
;
10584 read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
10585 line_ptr
+= bytes_read
;
10587 read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
10588 line_ptr
+= bytes_read
;
10590 read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
10591 line_ptr
+= bytes_read
;
10592 add_file_name (lh
, cur_file
, dir_index
, mod_time
, length
);
10595 case DW_LNE_set_discriminator
:
10596 /* The discriminator is not interesting to the debugger;
10598 line_ptr
= extended_end
;
10601 complaint (&symfile_complaints
,
10602 _("mangled .debug_line section"));
10605 /* Make sure that we parsed the extended op correctly. If e.g.
10606 we expected a different address size than the producer used,
10607 we may have read the wrong number of bytes. */
10608 if (line_ptr
!= extended_end
)
10610 complaint (&symfile_complaints
,
10611 _("mangled .debug_line section"));
10616 if (lh
->num_file_names
< file
|| file
== 0)
10617 dwarf2_debug_line_missing_file_complaint ();
10620 lh
->file_names
[file
- 1].included_p
= 1;
10621 if (!decode_for_pst_p
&& is_stmt
)
10623 if (last_subfile
!= current_subfile
)
10625 addr
= gdbarch_addr_bits_remove (gdbarch
, address
);
10627 (*p_record_line
) (last_subfile
, 0, addr
);
10628 last_subfile
= current_subfile
;
10630 addr
= check_cu_functions (address
, cu
);
10631 addr
= gdbarch_addr_bits_remove (gdbarch
, addr
);
10632 (*p_record_line
) (current_subfile
, line
, addr
);
10637 case DW_LNS_advance_pc
:
10640 = read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
10642 address
+= (((op_index
+ adjust
)
10643 / lh
->maximum_ops_per_instruction
)
10644 * lh
->minimum_instruction_length
);
10645 op_index
= ((op_index
+ adjust
)
10646 % lh
->maximum_ops_per_instruction
);
10647 line_ptr
+= bytes_read
;
10650 case DW_LNS_advance_line
:
10651 line
+= read_signed_leb128 (abfd
, line_ptr
, &bytes_read
);
10652 line_ptr
+= bytes_read
;
10654 case DW_LNS_set_file
:
10656 /* The arrays lh->include_dirs and lh->file_names are
10657 0-based, but the directory and file name numbers in
10658 the statement program are 1-based. */
10659 struct file_entry
*fe
;
10662 file
= read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
10663 line_ptr
+= bytes_read
;
10664 if (lh
->num_file_names
< file
|| file
== 0)
10665 dwarf2_debug_line_missing_file_complaint ();
10668 fe
= &lh
->file_names
[file
- 1];
10670 dir
= lh
->include_dirs
[fe
->dir_index
- 1];
10671 if (!decode_for_pst_p
)
10673 last_subfile
= current_subfile
;
10674 dwarf2_start_subfile (fe
->name
, dir
, comp_dir
);
10679 case DW_LNS_set_column
:
10680 column
= read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
10681 line_ptr
+= bytes_read
;
10683 case DW_LNS_negate_stmt
:
10684 is_stmt
= (!is_stmt
);
10686 case DW_LNS_set_basic_block
:
10689 /* Add to the address register of the state machine the
10690 address increment value corresponding to special opcode
10691 255. I.e., this value is scaled by the minimum
10692 instruction length since special opcode 255 would have
10693 scaled the increment. */
10694 case DW_LNS_const_add_pc
:
10696 CORE_ADDR adjust
= (255 - lh
->opcode_base
) / lh
->line_range
;
10698 address
+= (((op_index
+ adjust
)
10699 / lh
->maximum_ops_per_instruction
)
10700 * lh
->minimum_instruction_length
);
10701 op_index
= ((op_index
+ adjust
)
10702 % lh
->maximum_ops_per_instruction
);
10705 case DW_LNS_fixed_advance_pc
:
10706 address
+= read_2_bytes (abfd
, line_ptr
);
10712 /* Unknown standard opcode, ignore it. */
10715 for (i
= 0; i
< lh
->standard_opcode_lengths
[op_code
]; i
++)
10717 (void) read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
10718 line_ptr
+= bytes_read
;
10723 if (lh
->num_file_names
< file
|| file
== 0)
10724 dwarf2_debug_line_missing_file_complaint ();
10727 lh
->file_names
[file
- 1].included_p
= 1;
10728 if (!decode_for_pst_p
)
10730 addr
= gdbarch_addr_bits_remove (gdbarch
, address
);
10731 (*p_record_line
) (current_subfile
, 0, addr
);
10736 if (decode_for_pst_p
)
10740 /* Now that we're done scanning the Line Header Program, we can
10741 create the psymtab of each included file. */
10742 for (file_index
= 0; file_index
< lh
->num_file_names
; file_index
++)
10743 if (lh
->file_names
[file_index
].included_p
== 1)
10745 char *include_name
=
10746 psymtab_include_file_name (lh
, file_index
, pst
, comp_dir
);
10747 if (include_name
!= NULL
)
10748 dwarf2_create_include_psymtab (include_name
, pst
, objfile
);
10753 /* Make sure a symtab is created for every file, even files
10754 which contain only variables (i.e. no code with associated
10758 struct file_entry
*fe
;
10760 for (i
= 0; i
< lh
->num_file_names
; i
++)
10764 fe
= &lh
->file_names
[i
];
10766 dir
= lh
->include_dirs
[fe
->dir_index
- 1];
10767 dwarf2_start_subfile (fe
->name
, dir
, comp_dir
);
10769 /* Skip the main file; we don't need it, and it must be
10770 allocated last, so that it will show up before the
10771 non-primary symtabs in the objfile's symtab list. */
10772 if (current_subfile
== first_subfile
)
10775 if (current_subfile
->symtab
== NULL
)
10776 current_subfile
->symtab
= allocate_symtab (current_subfile
->name
,
10778 fe
->symtab
= current_subfile
->symtab
;
10783 /* Start a subfile for DWARF. FILENAME is the name of the file and
10784 DIRNAME the name of the source directory which contains FILENAME
10785 or NULL if not known. COMP_DIR is the compilation directory for the
10786 linetable's compilation unit or NULL if not known.
10787 This routine tries to keep line numbers from identical absolute and
10788 relative file names in a common subfile.
10790 Using the `list' example from the GDB testsuite, which resides in
10791 /srcdir and compiling it with Irix6.2 cc in /compdir using a filename
10792 of /srcdir/list0.c yields the following debugging information for list0.c:
10794 DW_AT_name: /srcdir/list0.c
10795 DW_AT_comp_dir: /compdir
10796 files.files[0].name: list0.h
10797 files.files[0].dir: /srcdir
10798 files.files[1].name: list0.c
10799 files.files[1].dir: /srcdir
10801 The line number information for list0.c has to end up in a single
10802 subfile, so that `break /srcdir/list0.c:1' works as expected.
10803 start_subfile will ensure that this happens provided that we pass the
10804 concatenation of files.files[1].dir and files.files[1].name as the
10808 dwarf2_start_subfile (char *filename
, const char *dirname
,
10809 const char *comp_dir
)
10813 /* While reading the DIEs, we call start_symtab(DW_AT_name, DW_AT_comp_dir).
10814 `start_symtab' will always pass the contents of DW_AT_comp_dir as
10815 second argument to start_subfile. To be consistent, we do the
10816 same here. In order not to lose the line information directory,
10817 we concatenate it to the filename when it makes sense.
10818 Note that the Dwarf3 standard says (speaking of filenames in line
10819 information): ``The directory index is ignored for file names
10820 that represent full path names''. Thus ignoring dirname in the
10821 `else' branch below isn't an issue. */
10823 if (!IS_ABSOLUTE_PATH (filename
) && dirname
!= NULL
)
10824 fullname
= concat (dirname
, SLASH_STRING
, filename
, (char *)NULL
);
10826 fullname
= filename
;
10828 start_subfile (fullname
, comp_dir
);
10830 if (fullname
!= filename
)
10835 var_decode_location (struct attribute
*attr
, struct symbol
*sym
,
10836 struct dwarf2_cu
*cu
)
10838 struct objfile
*objfile
= cu
->objfile
;
10839 struct comp_unit_head
*cu_header
= &cu
->header
;
10841 /* NOTE drow/2003-01-30: There used to be a comment and some special
10842 code here to turn a symbol with DW_AT_external and a
10843 SYMBOL_VALUE_ADDRESS of 0 into a LOC_UNRESOLVED symbol. This was
10844 necessary for platforms (maybe Alpha, certainly PowerPC GNU/Linux
10845 with some versions of binutils) where shared libraries could have
10846 relocations against symbols in their debug information - the
10847 minimal symbol would have the right address, but the debug info
10848 would not. It's no longer necessary, because we will explicitly
10849 apply relocations when we read in the debug information now. */
10851 /* A DW_AT_location attribute with no contents indicates that a
10852 variable has been optimized away. */
10853 if (attr_form_is_block (attr
) && DW_BLOCK (attr
)->size
== 0)
10855 SYMBOL_CLASS (sym
) = LOC_OPTIMIZED_OUT
;
10859 /* Handle one degenerate form of location expression specially, to
10860 preserve GDB's previous behavior when section offsets are
10861 specified. If this is just a DW_OP_addr then mark this symbol
10864 if (attr_form_is_block (attr
)
10865 && DW_BLOCK (attr
)->size
== 1 + cu_header
->addr_size
10866 && DW_BLOCK (attr
)->data
[0] == DW_OP_addr
)
10868 unsigned int dummy
;
10870 SYMBOL_VALUE_ADDRESS (sym
) =
10871 read_address (objfile
->obfd
, DW_BLOCK (attr
)->data
+ 1, cu
, &dummy
);
10872 SYMBOL_CLASS (sym
) = LOC_STATIC
;
10873 fixup_symbol_section (sym
, objfile
);
10874 SYMBOL_VALUE_ADDRESS (sym
) += ANOFFSET (objfile
->section_offsets
,
10875 SYMBOL_SECTION (sym
));
10879 /* NOTE drow/2002-01-30: It might be worthwhile to have a static
10880 expression evaluator, and use LOC_COMPUTED only when necessary
10881 (i.e. when the value of a register or memory location is
10882 referenced, or a thread-local block, etc.). Then again, it might
10883 not be worthwhile. I'm assuming that it isn't unless performance
10884 or memory numbers show me otherwise. */
10886 dwarf2_symbol_mark_computed (attr
, sym
, cu
);
10887 SYMBOL_CLASS (sym
) = LOC_COMPUTED
;
10890 /* Given a pointer to a DWARF information entry, figure out if we need
10891 to make a symbol table entry for it, and if so, create a new entry
10892 and return a pointer to it.
10893 If TYPE is NULL, determine symbol type from the die, otherwise
10894 used the passed type.
10895 If SPACE is not NULL, use it to hold the new symbol. If it is
10896 NULL, allocate a new symbol on the objfile's obstack. */
10898 static struct symbol
*
10899 new_symbol_full (struct die_info
*die
, struct type
*type
, struct dwarf2_cu
*cu
,
10900 struct symbol
*space
)
10902 struct objfile
*objfile
= cu
->objfile
;
10903 struct symbol
*sym
= NULL
;
10905 struct attribute
*attr
= NULL
;
10906 struct attribute
*attr2
= NULL
;
10907 CORE_ADDR baseaddr
;
10908 struct pending
**list_to_add
= NULL
;
10910 int inlined_func
= (die
->tag
== DW_TAG_inlined_subroutine
);
10912 baseaddr
= ANOFFSET (objfile
->section_offsets
, SECT_OFF_TEXT (objfile
));
10914 name
= dwarf2_name (die
, cu
);
10917 const char *linkagename
;
10918 int suppress_add
= 0;
10923 sym
= OBSTACK_ZALLOC (&objfile
->objfile_obstack
, struct symbol
);
10924 OBJSTAT (objfile
, n_syms
++);
10926 /* Cache this symbol's name and the name's demangled form (if any). */
10927 SYMBOL_SET_LANGUAGE (sym
, cu
->language
);
10928 linkagename
= dwarf2_physname (name
, die
, cu
);
10929 SYMBOL_SET_NAMES (sym
, linkagename
, strlen (linkagename
), 0, objfile
);
10931 /* Fortran does not have mangling standard and the mangling does differ
10932 between gfortran, iFort etc. */
10933 if (cu
->language
== language_fortran
10934 && symbol_get_demangled_name (&(sym
->ginfo
)) == NULL
)
10935 symbol_set_demangled_name (&(sym
->ginfo
),
10936 (char *) dwarf2_full_name (name
, die
, cu
),
10939 /* Default assumptions.
10940 Use the passed type or decode it from the die. */
10941 SYMBOL_DOMAIN (sym
) = VAR_DOMAIN
;
10942 SYMBOL_CLASS (sym
) = LOC_OPTIMIZED_OUT
;
10944 SYMBOL_TYPE (sym
) = type
;
10946 SYMBOL_TYPE (sym
) = die_type (die
, cu
);
10947 attr
= dwarf2_attr (die
,
10948 inlined_func
? DW_AT_call_line
: DW_AT_decl_line
,
10952 SYMBOL_LINE (sym
) = DW_UNSND (attr
);
10955 attr
= dwarf2_attr (die
,
10956 inlined_func
? DW_AT_call_file
: DW_AT_decl_file
,
10960 int file_index
= DW_UNSND (attr
);
10962 if (cu
->line_header
== NULL
10963 || file_index
> cu
->line_header
->num_file_names
)
10964 complaint (&symfile_complaints
,
10965 _("file index out of range"));
10966 else if (file_index
> 0)
10968 struct file_entry
*fe
;
10970 fe
= &cu
->line_header
->file_names
[file_index
- 1];
10971 SYMBOL_SYMTAB (sym
) = fe
->symtab
;
10978 attr
= dwarf2_attr (die
, DW_AT_low_pc
, cu
);
10981 SYMBOL_VALUE_ADDRESS (sym
) = DW_ADDR (attr
) + baseaddr
;
10983 SYMBOL_TYPE (sym
) = objfile_type (objfile
)->builtin_core_addr
;
10984 SYMBOL_DOMAIN (sym
) = LABEL_DOMAIN
;
10985 SYMBOL_CLASS (sym
) = LOC_LABEL
;
10986 add_symbol_to_list (sym
, cu
->list_in_scope
);
10988 case DW_TAG_subprogram
:
10989 /* SYMBOL_BLOCK_VALUE (sym) will be filled in later by
10991 SYMBOL_CLASS (sym
) = LOC_BLOCK
;
10992 attr2
= dwarf2_attr (die
, DW_AT_external
, cu
);
10993 if ((attr2
&& (DW_UNSND (attr2
) != 0))
10994 || cu
->language
== language_ada
)
10996 /* Subprograms marked external are stored as a global symbol.
10997 Ada subprograms, whether marked external or not, are always
10998 stored as a global symbol, because we want to be able to
10999 access them globally. For instance, we want to be able
11000 to break on a nested subprogram without having to
11001 specify the context. */
11002 list_to_add
= &global_symbols
;
11006 list_to_add
= cu
->list_in_scope
;
11009 case DW_TAG_inlined_subroutine
:
11010 /* SYMBOL_BLOCK_VALUE (sym) will be filled in later by
11012 SYMBOL_CLASS (sym
) = LOC_BLOCK
;
11013 SYMBOL_INLINED (sym
) = 1;
11014 /* Do not add the symbol to any lists. It will be found via
11015 BLOCK_FUNCTION from the blockvector. */
11017 case DW_TAG_template_value_param
:
11019 /* Fall through. */
11020 case DW_TAG_constant
:
11021 case DW_TAG_variable
:
11022 case DW_TAG_member
:
11023 /* Compilation with minimal debug info may result in
11024 variables with missing type entries. Change the
11025 misleading `void' type to something sensible. */
11026 if (TYPE_CODE (SYMBOL_TYPE (sym
)) == TYPE_CODE_VOID
)
11028 = objfile_type (objfile
)->nodebug_data_symbol
;
11030 attr
= dwarf2_attr (die
, DW_AT_const_value
, cu
);
11031 /* In the case of DW_TAG_member, we should only be called for
11032 static const members. */
11033 if (die
->tag
== DW_TAG_member
)
11035 /* dwarf2_add_field uses die_is_declaration,
11036 so we do the same. */
11037 gdb_assert (die_is_declaration (die
, cu
));
11042 dwarf2_const_value (attr
, sym
, cu
);
11043 attr2
= dwarf2_attr (die
, DW_AT_external
, cu
);
11046 if (attr2
&& (DW_UNSND (attr2
) != 0))
11047 list_to_add
= &global_symbols
;
11049 list_to_add
= cu
->list_in_scope
;
11053 attr
= dwarf2_attr (die
, DW_AT_location
, cu
);
11056 var_decode_location (attr
, sym
, cu
);
11057 attr2
= dwarf2_attr (die
, DW_AT_external
, cu
);
11058 if (SYMBOL_CLASS (sym
) == LOC_STATIC
11059 && SYMBOL_VALUE_ADDRESS (sym
) == 0
11060 && !dwarf2_per_objfile
->has_section_at_zero
)
11062 /* When a static variable is eliminated by the linker,
11063 the corresponding debug information is not stripped
11064 out, but the variable address is set to null;
11065 do not add such variables into symbol table. */
11067 else if (attr2
&& (DW_UNSND (attr2
) != 0))
11069 /* Workaround gfortran PR debug/40040 - it uses
11070 DW_AT_location for variables in -fPIC libraries which may
11071 get overriden by other libraries/executable and get
11072 a different address. Resolve it by the minimal symbol
11073 which may come from inferior's executable using copy
11074 relocation. Make this workaround only for gfortran as for
11075 other compilers GDB cannot guess the minimal symbol
11076 Fortran mangling kind. */
11077 if (cu
->language
== language_fortran
&& die
->parent
11078 && die
->parent
->tag
== DW_TAG_module
11080 && strncmp (cu
->producer
, "GNU Fortran ", 12) == 0)
11081 SYMBOL_CLASS (sym
) = LOC_UNRESOLVED
;
11083 /* A variable with DW_AT_external is never static,
11084 but it may be block-scoped. */
11085 list_to_add
= (cu
->list_in_scope
== &file_symbols
11086 ? &global_symbols
: cu
->list_in_scope
);
11089 list_to_add
= cu
->list_in_scope
;
11093 /* We do not know the address of this symbol.
11094 If it is an external symbol and we have type information
11095 for it, enter the symbol as a LOC_UNRESOLVED symbol.
11096 The address of the variable will then be determined from
11097 the minimal symbol table whenever the variable is
11099 attr2
= dwarf2_attr (die
, DW_AT_external
, cu
);
11100 if (attr2
&& (DW_UNSND (attr2
) != 0)
11101 && dwarf2_attr (die
, DW_AT_type
, cu
) != NULL
)
11103 /* A variable with DW_AT_external is never static, but it
11104 may be block-scoped. */
11105 list_to_add
= (cu
->list_in_scope
== &file_symbols
11106 ? &global_symbols
: cu
->list_in_scope
);
11108 SYMBOL_CLASS (sym
) = LOC_UNRESOLVED
;
11110 else if (!die_is_declaration (die
, cu
))
11112 /* Use the default LOC_OPTIMIZED_OUT class. */
11113 gdb_assert (SYMBOL_CLASS (sym
) == LOC_OPTIMIZED_OUT
);
11115 list_to_add
= cu
->list_in_scope
;
11119 case DW_TAG_formal_parameter
:
11120 /* If we are inside a function, mark this as an argument. If
11121 not, we might be looking at an argument to an inlined function
11122 when we do not have enough information to show inlined frames;
11123 pretend it's a local variable in that case so that the user can
11125 if (context_stack_depth
> 0
11126 && context_stack
[context_stack_depth
- 1].name
!= NULL
)
11127 SYMBOL_IS_ARGUMENT (sym
) = 1;
11128 attr
= dwarf2_attr (die
, DW_AT_location
, cu
);
11131 var_decode_location (attr
, sym
, cu
);
11133 attr
= dwarf2_attr (die
, DW_AT_const_value
, cu
);
11136 dwarf2_const_value (attr
, sym
, cu
);
11138 attr
= dwarf2_attr (die
, DW_AT_variable_parameter
, cu
);
11139 if (attr
&& DW_UNSND (attr
))
11141 struct type
*ref_type
;
11143 ref_type
= lookup_reference_type (SYMBOL_TYPE (sym
));
11144 SYMBOL_TYPE (sym
) = ref_type
;
11147 list_to_add
= cu
->list_in_scope
;
11149 case DW_TAG_unspecified_parameters
:
11150 /* From varargs functions; gdb doesn't seem to have any
11151 interest in this information, so just ignore it for now.
11154 case DW_TAG_template_type_param
:
11156 /* Fall through. */
11157 case DW_TAG_class_type
:
11158 case DW_TAG_interface_type
:
11159 case DW_TAG_structure_type
:
11160 case DW_TAG_union_type
:
11161 case DW_TAG_set_type
:
11162 case DW_TAG_enumeration_type
:
11163 SYMBOL_CLASS (sym
) = LOC_TYPEDEF
;
11164 SYMBOL_DOMAIN (sym
) = STRUCT_DOMAIN
;
11167 /* NOTE: carlton/2003-11-10: C++ and Java class symbols shouldn't
11168 really ever be static objects: otherwise, if you try
11169 to, say, break of a class's method and you're in a file
11170 which doesn't mention that class, it won't work unless
11171 the check for all static symbols in lookup_symbol_aux
11172 saves you. See the OtherFileClass tests in
11173 gdb.c++/namespace.exp. */
11177 list_to_add
= (cu
->list_in_scope
== &file_symbols
11178 && (cu
->language
== language_cplus
11179 || cu
->language
== language_java
)
11180 ? &global_symbols
: cu
->list_in_scope
);
11182 /* The semantics of C++ state that "struct foo {
11183 ... }" also defines a typedef for "foo". A Java
11184 class declaration also defines a typedef for the
11186 if (cu
->language
== language_cplus
11187 || cu
->language
== language_java
11188 || cu
->language
== language_ada
)
11190 /* The symbol's name is already allocated along
11191 with this objfile, so we don't need to
11192 duplicate it for the type. */
11193 if (TYPE_NAME (SYMBOL_TYPE (sym
)) == 0)
11194 TYPE_NAME (SYMBOL_TYPE (sym
)) = SYMBOL_SEARCH_NAME (sym
);
11199 case DW_TAG_typedef
:
11200 SYMBOL_CLASS (sym
) = LOC_TYPEDEF
;
11201 SYMBOL_DOMAIN (sym
) = VAR_DOMAIN
;
11202 list_to_add
= cu
->list_in_scope
;
11204 case DW_TAG_base_type
:
11205 case DW_TAG_subrange_type
:
11206 SYMBOL_CLASS (sym
) = LOC_TYPEDEF
;
11207 SYMBOL_DOMAIN (sym
) = VAR_DOMAIN
;
11208 list_to_add
= cu
->list_in_scope
;
11210 case DW_TAG_enumerator
:
11211 attr
= dwarf2_attr (die
, DW_AT_const_value
, cu
);
11214 dwarf2_const_value (attr
, sym
, cu
);
11217 /* NOTE: carlton/2003-11-10: See comment above in the
11218 DW_TAG_class_type, etc. block. */
11220 list_to_add
= (cu
->list_in_scope
== &file_symbols
11221 && (cu
->language
== language_cplus
11222 || cu
->language
== language_java
)
11223 ? &global_symbols
: cu
->list_in_scope
);
11226 case DW_TAG_namespace
:
11227 SYMBOL_CLASS (sym
) = LOC_TYPEDEF
;
11228 list_to_add
= &global_symbols
;
11231 /* Not a tag we recognize. Hopefully we aren't processing
11232 trash data, but since we must specifically ignore things
11233 we don't recognize, there is nothing else we should do at
11235 complaint (&symfile_complaints
, _("unsupported tag: '%s'"),
11236 dwarf_tag_name (die
->tag
));
11242 sym
->hash_next
= objfile
->template_symbols
;
11243 objfile
->template_symbols
= sym
;
11244 list_to_add
= NULL
;
11247 if (list_to_add
!= NULL
)
11248 add_symbol_to_list (sym
, list_to_add
);
11250 /* For the benefit of old versions of GCC, check for anonymous
11251 namespaces based on the demangled name. */
11252 if (!processing_has_namespace_info
11253 && cu
->language
== language_cplus
)
11254 cp_scan_for_anonymous_namespaces (sym
);
11259 /* A wrapper for new_symbol_full that always allocates a new symbol. */
11261 static struct symbol
*
11262 new_symbol (struct die_info
*die
, struct type
*type
, struct dwarf2_cu
*cu
)
11264 return new_symbol_full (die
, type
, cu
, NULL
);
11267 /* Given an attr with a DW_FORM_dataN value in host byte order,
11268 zero-extend it as appropriate for the symbol's type. The DWARF
11269 standard (v4) is not entirely clear about the meaning of using
11270 DW_FORM_dataN for a constant with a signed type, where the type is
11271 wider than the data. The conclusion of a discussion on the DWARF
11272 list was that this is unspecified. We choose to always zero-extend
11273 because that is the interpretation long in use by GCC. */
11276 dwarf2_const_value_data (struct attribute
*attr
, struct type
*type
,
11277 const char *name
, struct obstack
*obstack
,
11278 struct dwarf2_cu
*cu
, long *value
, int bits
)
11280 struct objfile
*objfile
= cu
->objfile
;
11281 enum bfd_endian byte_order
= bfd_big_endian (objfile
->obfd
) ?
11282 BFD_ENDIAN_BIG
: BFD_ENDIAN_LITTLE
;
11283 LONGEST l
= DW_UNSND (attr
);
11285 if (bits
< sizeof (*value
) * 8)
11287 l
&= ((LONGEST
) 1 << bits
) - 1;
11290 else if (bits
== sizeof (*value
) * 8)
11294 gdb_byte
*bytes
= obstack_alloc (obstack
, bits
/ 8);
11295 store_unsigned_integer (bytes
, bits
/ 8, byte_order
, l
);
11302 /* Read a constant value from an attribute. Either set *VALUE, or if
11303 the value does not fit in *VALUE, set *BYTES - either already
11304 allocated on the objfile obstack, or newly allocated on OBSTACK,
11305 or, set *BATON, if we translated the constant to a location
11309 dwarf2_const_value_attr (struct attribute
*attr
, struct type
*type
,
11310 const char *name
, struct obstack
*obstack
,
11311 struct dwarf2_cu
*cu
,
11312 long *value
, gdb_byte
**bytes
,
11313 struct dwarf2_locexpr_baton
**baton
)
11315 struct objfile
*objfile
= cu
->objfile
;
11316 struct comp_unit_head
*cu_header
= &cu
->header
;
11317 struct dwarf_block
*blk
;
11318 enum bfd_endian byte_order
= (bfd_big_endian (objfile
->obfd
) ?
11319 BFD_ENDIAN_BIG
: BFD_ENDIAN_LITTLE
);
11325 switch (attr
->form
)
11331 if (TYPE_LENGTH (type
) != cu_header
->addr_size
)
11332 dwarf2_const_value_length_mismatch_complaint (name
,
11333 cu_header
->addr_size
,
11334 TYPE_LENGTH (type
));
11335 /* Symbols of this form are reasonably rare, so we just
11336 piggyback on the existing location code rather than writing
11337 a new implementation of symbol_computed_ops. */
11338 *baton
= obstack_alloc (&objfile
->objfile_obstack
,
11339 sizeof (struct dwarf2_locexpr_baton
));
11340 (*baton
)->per_cu
= cu
->per_cu
;
11341 gdb_assert ((*baton
)->per_cu
);
11343 (*baton
)->size
= 2 + cu_header
->addr_size
;
11344 data
= obstack_alloc (&objfile
->objfile_obstack
, (*baton
)->size
);
11345 (*baton
)->data
= data
;
11347 data
[0] = DW_OP_addr
;
11348 store_unsigned_integer (&data
[1], cu_header
->addr_size
,
11349 byte_order
, DW_ADDR (attr
));
11350 data
[cu_header
->addr_size
+ 1] = DW_OP_stack_value
;
11353 case DW_FORM_string
:
11355 /* DW_STRING is already allocated on the objfile obstack, point
11357 *bytes
= (gdb_byte
*) DW_STRING (attr
);
11359 case DW_FORM_block1
:
11360 case DW_FORM_block2
:
11361 case DW_FORM_block4
:
11362 case DW_FORM_block
:
11363 case DW_FORM_exprloc
:
11364 blk
= DW_BLOCK (attr
);
11365 if (TYPE_LENGTH (type
) != blk
->size
)
11366 dwarf2_const_value_length_mismatch_complaint (name
, blk
->size
,
11367 TYPE_LENGTH (type
));
11368 *bytes
= blk
->data
;
11371 /* The DW_AT_const_value attributes are supposed to carry the
11372 symbol's value "represented as it would be on the target
11373 architecture." By the time we get here, it's already been
11374 converted to host endianness, so we just need to sign- or
11375 zero-extend it as appropriate. */
11376 case DW_FORM_data1
:
11377 *bytes
= dwarf2_const_value_data (attr
, type
, name
,
11378 obstack
, cu
, value
, 8);
11380 case DW_FORM_data2
:
11381 *bytes
= dwarf2_const_value_data (attr
, type
, name
,
11382 obstack
, cu
, value
, 16);
11384 case DW_FORM_data4
:
11385 *bytes
= dwarf2_const_value_data (attr
, type
, name
,
11386 obstack
, cu
, value
, 32);
11388 case DW_FORM_data8
:
11389 *bytes
= dwarf2_const_value_data (attr
, type
, name
,
11390 obstack
, cu
, value
, 64);
11393 case DW_FORM_sdata
:
11394 *value
= DW_SND (attr
);
11397 case DW_FORM_udata
:
11398 *value
= DW_UNSND (attr
);
11402 complaint (&symfile_complaints
,
11403 _("unsupported const value attribute form: '%s'"),
11404 dwarf_form_name (attr
->form
));
11411 /* Copy constant value from an attribute to a symbol. */
11414 dwarf2_const_value (struct attribute
*attr
, struct symbol
*sym
,
11415 struct dwarf2_cu
*cu
)
11417 struct objfile
*objfile
= cu
->objfile
;
11418 struct comp_unit_head
*cu_header
= &cu
->header
;
11421 struct dwarf2_locexpr_baton
*baton
;
11423 dwarf2_const_value_attr (attr
, SYMBOL_TYPE (sym
),
11424 SYMBOL_PRINT_NAME (sym
),
11425 &objfile
->objfile_obstack
, cu
,
11426 &value
, &bytes
, &baton
);
11430 SYMBOL_COMPUTED_OPS (sym
) = &dwarf2_locexpr_funcs
;
11431 SYMBOL_LOCATION_BATON (sym
) = baton
;
11432 SYMBOL_CLASS (sym
) = LOC_COMPUTED
;
11434 else if (bytes
!= NULL
)
11436 SYMBOL_VALUE_BYTES (sym
) = bytes
;
11437 SYMBOL_CLASS (sym
) = LOC_CONST_BYTES
;
11441 SYMBOL_VALUE (sym
) = value
;
11442 SYMBOL_CLASS (sym
) = LOC_CONST
;
11446 /* Return the type of the die in question using its DW_AT_type attribute. */
11448 static struct type
*
11449 die_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
11451 struct attribute
*type_attr
;
11453 type_attr
= dwarf2_attr (die
, DW_AT_type
, cu
);
11456 /* A missing DW_AT_type represents a void type. */
11457 return objfile_type (cu
->objfile
)->builtin_void
;
11460 return lookup_die_type (die
, type_attr
, cu
);
11463 /* True iff CU's producer generates GNAT Ada auxiliary information
11464 that allows to find parallel types through that information instead
11465 of having to do expensive parallel lookups by type name. */
11468 need_gnat_info (struct dwarf2_cu
*cu
)
11470 /* FIXME: brobecker/2010-10-12: As of now, only the AdaCore version
11471 of GNAT produces this auxiliary information, without any indication
11472 that it is produced. Part of enhancing the FSF version of GNAT
11473 to produce that information will be to put in place an indicator
11474 that we can use in order to determine whether the descriptive type
11475 info is available or not. One suggestion that has been made is
11476 to use a new attribute, attached to the CU die. For now, assume
11477 that the descriptive type info is not available. */
11481 /* Return the auxiliary type of the die in question using its
11482 DW_AT_GNAT_descriptive_type attribute. Returns NULL if the
11483 attribute is not present. */
11485 static struct type
*
11486 die_descriptive_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
11488 struct attribute
*type_attr
;
11490 type_attr
= dwarf2_attr (die
, DW_AT_GNAT_descriptive_type
, cu
);
11494 return lookup_die_type (die
, type_attr
, cu
);
11497 /* If DIE has a descriptive_type attribute, then set the TYPE's
11498 descriptive type accordingly. */
11501 set_descriptive_type (struct type
*type
, struct die_info
*die
,
11502 struct dwarf2_cu
*cu
)
11504 struct type
*descriptive_type
= die_descriptive_type (die
, cu
);
11506 if (descriptive_type
)
11508 ALLOCATE_GNAT_AUX_TYPE (type
);
11509 TYPE_DESCRIPTIVE_TYPE (type
) = descriptive_type
;
11513 /* Return the containing type of the die in question using its
11514 DW_AT_containing_type attribute. */
11516 static struct type
*
11517 die_containing_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
11519 struct attribute
*type_attr
;
11521 type_attr
= dwarf2_attr (die
, DW_AT_containing_type
, cu
);
11523 error (_("Dwarf Error: Problem turning containing type into gdb type "
11524 "[in module %s]"), cu
->objfile
->name
);
11526 return lookup_die_type (die
, type_attr
, cu
);
11529 /* Look up the type of DIE in CU using its type attribute ATTR.
11530 If there is no type substitute an error marker. */
11532 static struct type
*
11533 lookup_die_type (struct die_info
*die
, struct attribute
*attr
,
11534 struct dwarf2_cu
*cu
)
11536 struct type
*this_type
;
11538 /* First see if we have it cached. */
11540 if (is_ref_attr (attr
))
11542 unsigned int offset
= dwarf2_get_ref_die_offset (attr
);
11544 this_type
= get_die_type_at_offset (offset
, cu
->per_cu
);
11546 else if (attr
->form
== DW_FORM_ref_sig8
)
11548 struct signatured_type
*sig_type
= DW_SIGNATURED_TYPE (attr
);
11549 struct dwarf2_cu
*sig_cu
;
11550 unsigned int offset
;
11552 /* sig_type will be NULL if the signatured type is missing from
11554 if (sig_type
== NULL
)
11555 error (_("Dwarf Error: Cannot find signatured DIE referenced from DIE "
11556 "at 0x%x [in module %s]"),
11557 die
->offset
, cu
->objfile
->name
);
11559 gdb_assert (sig_type
->per_cu
.from_debug_types
);
11560 offset
= sig_type
->offset
+ sig_type
->type_offset
;
11561 this_type
= get_die_type_at_offset (offset
, &sig_type
->per_cu
);
11565 dump_die_for_error (die
);
11566 error (_("Dwarf Error: Bad type attribute %s [in module %s]"),
11567 dwarf_attr_name (attr
->name
), cu
->objfile
->name
);
11570 /* If not cached we need to read it in. */
11572 if (this_type
== NULL
)
11574 struct die_info
*type_die
;
11575 struct dwarf2_cu
*type_cu
= cu
;
11577 type_die
= follow_die_ref_or_sig (die
, attr
, &type_cu
);
11578 /* If the type is cached, we should have found it above. */
11579 gdb_assert (get_die_type (type_die
, type_cu
) == NULL
);
11580 this_type
= read_type_die_1 (type_die
, type_cu
);
11583 /* If we still don't have a type use an error marker. */
11585 if (this_type
== NULL
)
11587 char *message
, *saved
;
11589 /* read_type_die already issued a complaint. */
11590 message
= xstrprintf (_("<unknown type in %s, CU 0x%x, DIE 0x%x>"),
11594 saved
= obstack_copy0 (&cu
->objfile
->objfile_obstack
,
11595 message
, strlen (message
));
11598 this_type
= init_type (TYPE_CODE_ERROR
, 0, 0, saved
, cu
->objfile
);
11604 /* Return the type in DIE, CU.
11605 Returns NULL for invalid types.
11607 This first does a lookup in the appropriate type_hash table,
11608 and only reads the die in if necessary.
11610 NOTE: This can be called when reading in partial or full symbols. */
11612 static struct type
*
11613 read_type_die (struct die_info
*die
, struct dwarf2_cu
*cu
)
11615 struct type
*this_type
;
11617 this_type
= get_die_type (die
, cu
);
11621 return read_type_die_1 (die
, cu
);
11624 /* Read the type in DIE, CU.
11625 Returns NULL for invalid types. */
11627 static struct type
*
11628 read_type_die_1 (struct die_info
*die
, struct dwarf2_cu
*cu
)
11630 struct type
*this_type
= NULL
;
11634 case DW_TAG_class_type
:
11635 case DW_TAG_interface_type
:
11636 case DW_TAG_structure_type
:
11637 case DW_TAG_union_type
:
11638 this_type
= read_structure_type (die
, cu
);
11640 case DW_TAG_enumeration_type
:
11641 this_type
= read_enumeration_type (die
, cu
);
11643 case DW_TAG_subprogram
:
11644 case DW_TAG_subroutine_type
:
11645 case DW_TAG_inlined_subroutine
:
11646 this_type
= read_subroutine_type (die
, cu
);
11648 case DW_TAG_array_type
:
11649 this_type
= read_array_type (die
, cu
);
11651 case DW_TAG_set_type
:
11652 this_type
= read_set_type (die
, cu
);
11654 case DW_TAG_pointer_type
:
11655 this_type
= read_tag_pointer_type (die
, cu
);
11657 case DW_TAG_ptr_to_member_type
:
11658 this_type
= read_tag_ptr_to_member_type (die
, cu
);
11660 case DW_TAG_reference_type
:
11661 this_type
= read_tag_reference_type (die
, cu
);
11663 case DW_TAG_const_type
:
11664 this_type
= read_tag_const_type (die
, cu
);
11666 case DW_TAG_volatile_type
:
11667 this_type
= read_tag_volatile_type (die
, cu
);
11669 case DW_TAG_string_type
:
11670 this_type
= read_tag_string_type (die
, cu
);
11672 case DW_TAG_typedef
:
11673 this_type
= read_typedef (die
, cu
);
11675 case DW_TAG_subrange_type
:
11676 this_type
= read_subrange_type (die
, cu
);
11678 case DW_TAG_base_type
:
11679 this_type
= read_base_type (die
, cu
);
11681 case DW_TAG_unspecified_type
:
11682 this_type
= read_unspecified_type (die
, cu
);
11684 case DW_TAG_namespace
:
11685 this_type
= read_namespace_type (die
, cu
);
11687 case DW_TAG_module
:
11688 this_type
= read_module_type (die
, cu
);
11691 complaint (&symfile_complaints
,
11692 _("unexpected tag in read_type_die: '%s'"),
11693 dwarf_tag_name (die
->tag
));
11700 /* See if we can figure out if the class lives in a namespace. We do
11701 this by looking for a member function; its demangled name will
11702 contain namespace info, if there is any.
11703 Return the computed name or NULL.
11704 Space for the result is allocated on the objfile's obstack.
11705 This is the full-die version of guess_partial_die_structure_name.
11706 In this case we know DIE has no useful parent. */
11709 guess_full_die_structure_name (struct die_info
*die
, struct dwarf2_cu
*cu
)
11711 struct die_info
*spec_die
;
11712 struct dwarf2_cu
*spec_cu
;
11713 struct die_info
*child
;
11716 spec_die
= die_specification (die
, &spec_cu
);
11717 if (spec_die
!= NULL
)
11723 for (child
= die
->child
;
11725 child
= child
->sibling
)
11727 if (child
->tag
== DW_TAG_subprogram
)
11729 struct attribute
*attr
;
11731 attr
= dwarf2_attr (child
, DW_AT_linkage_name
, cu
);
11733 attr
= dwarf2_attr (child
, DW_AT_MIPS_linkage_name
, cu
);
11737 = language_class_name_from_physname (cu
->language_defn
,
11741 if (actual_name
!= NULL
)
11743 char *die_name
= dwarf2_name (die
, cu
);
11745 if (die_name
!= NULL
11746 && strcmp (die_name
, actual_name
) != 0)
11748 /* Strip off the class name from the full name.
11749 We want the prefix. */
11750 int die_name_len
= strlen (die_name
);
11751 int actual_name_len
= strlen (actual_name
);
11753 /* Test for '::' as a sanity check. */
11754 if (actual_name_len
> die_name_len
+ 2
11755 && actual_name
[actual_name_len
11756 - die_name_len
- 1] == ':')
11758 obsavestring (actual_name
,
11759 actual_name_len
- die_name_len
- 2,
11760 &cu
->objfile
->objfile_obstack
);
11763 xfree (actual_name
);
11772 /* Return the name of the namespace/class that DIE is defined within,
11773 or "" if we can't tell. The caller should not xfree the result.
11775 For example, if we're within the method foo() in the following
11785 then determine_prefix on foo's die will return "N::C". */
11788 determine_prefix (struct die_info
*die
, struct dwarf2_cu
*cu
)
11790 struct die_info
*parent
, *spec_die
;
11791 struct dwarf2_cu
*spec_cu
;
11792 struct type
*parent_type
;
11794 if (cu
->language
!= language_cplus
&& cu
->language
!= language_java
11795 && cu
->language
!= language_fortran
)
11798 /* We have to be careful in the presence of DW_AT_specification.
11799 For example, with GCC 3.4, given the code
11803 // Definition of N::foo.
11807 then we'll have a tree of DIEs like this:
11809 1: DW_TAG_compile_unit
11810 2: DW_TAG_namespace // N
11811 3: DW_TAG_subprogram // declaration of N::foo
11812 4: DW_TAG_subprogram // definition of N::foo
11813 DW_AT_specification // refers to die #3
11815 Thus, when processing die #4, we have to pretend that we're in
11816 the context of its DW_AT_specification, namely the contex of die
11819 spec_die
= die_specification (die
, &spec_cu
);
11820 if (spec_die
== NULL
)
11821 parent
= die
->parent
;
11824 parent
= spec_die
->parent
;
11828 if (parent
== NULL
)
11830 else if (parent
->building_fullname
)
11833 const char *parent_name
;
11835 /* It has been seen on RealView 2.2 built binaries,
11836 DW_TAG_template_type_param types actually _defined_ as
11837 children of the parent class:
11840 template class <class Enum> Class{};
11841 Class<enum E> class_e;
11843 1: DW_TAG_class_type (Class)
11844 2: DW_TAG_enumeration_type (E)
11845 3: DW_TAG_enumerator (enum1:0)
11846 3: DW_TAG_enumerator (enum2:1)
11848 2: DW_TAG_template_type_param
11849 DW_AT_type DW_FORM_ref_udata (E)
11851 Besides being broken debug info, it can put GDB into an
11852 infinite loop. Consider:
11854 When we're building the full name for Class<E>, we'll start
11855 at Class, and go look over its template type parameters,
11856 finding E. We'll then try to build the full name of E, and
11857 reach here. We're now trying to build the full name of E,
11858 and look over the parent DIE for containing scope. In the
11859 broken case, if we followed the parent DIE of E, we'd again
11860 find Class, and once again go look at its template type
11861 arguments, etc., etc. Simply don't consider such parent die
11862 as source-level parent of this die (it can't be, the language
11863 doesn't allow it), and break the loop here. */
11864 name
= dwarf2_name (die
, cu
);
11865 parent_name
= dwarf2_name (parent
, cu
);
11866 complaint (&symfile_complaints
,
11867 _("template param type '%s' defined within parent '%s'"),
11868 name
? name
: "<unknown>",
11869 parent_name
? parent_name
: "<unknown>");
11873 switch (parent
->tag
)
11875 case DW_TAG_namespace
:
11876 parent_type
= read_type_die (parent
, cu
);
11877 /* GCC 4.0 and 4.1 had a bug (PR c++/28460) where they generated bogus
11878 DW_TAG_namespace DIEs with a name of "::" for the global namespace.
11879 Work around this problem here. */
11880 if (cu
->language
== language_cplus
11881 && strcmp (TYPE_TAG_NAME (parent_type
), "::") == 0)
11883 /* We give a name to even anonymous namespaces. */
11884 return TYPE_TAG_NAME (parent_type
);
11885 case DW_TAG_class_type
:
11886 case DW_TAG_interface_type
:
11887 case DW_TAG_structure_type
:
11888 case DW_TAG_union_type
:
11889 case DW_TAG_module
:
11890 parent_type
= read_type_die (parent
, cu
);
11891 if (TYPE_TAG_NAME (parent_type
) != NULL
)
11892 return TYPE_TAG_NAME (parent_type
);
11894 /* An anonymous structure is only allowed non-static data
11895 members; no typedefs, no member functions, et cetera.
11896 So it does not need a prefix. */
11898 case DW_TAG_compile_unit
:
11899 /* gcc-4.5 -gdwarf-4 can drop the enclosing namespace. Cope. */
11900 if (cu
->language
== language_cplus
11901 && dwarf2_per_objfile
->types
.asection
!= NULL
11902 && die
->child
!= NULL
11903 && (die
->tag
== DW_TAG_class_type
11904 || die
->tag
== DW_TAG_structure_type
11905 || die
->tag
== DW_TAG_union_type
))
11907 char *name
= guess_full_die_structure_name (die
, cu
);
11913 return determine_prefix (parent
, cu
);
11917 /* Return a newly-allocated string formed by concatenating PREFIX and SUFFIX
11918 with appropriate separator. If PREFIX or SUFFIX is NULL or empty, then
11919 simply copy the SUFFIX or PREFIX, respectively. If OBS is non-null, perform
11920 an obconcat, otherwise allocate storage for the result. The CU argument is
11921 used to determine the language and hence, the appropriate separator. */
11923 #define MAX_SEP_LEN 7 /* strlen ("__") + strlen ("_MOD_") */
11926 typename_concat (struct obstack
*obs
, const char *prefix
, const char *suffix
,
11927 int physname
, struct dwarf2_cu
*cu
)
11929 const char *lead
= "";
11932 if (suffix
== NULL
|| suffix
[0] == '\0'
11933 || prefix
== NULL
|| prefix
[0] == '\0')
11935 else if (cu
->language
== language_java
)
11937 else if (cu
->language
== language_fortran
&& physname
)
11939 /* This is gfortran specific mangling. Normally DW_AT_linkage_name or
11940 DW_AT_MIPS_linkage_name is preferred and used instead. */
11948 if (prefix
== NULL
)
11950 if (suffix
== NULL
)
11956 = xmalloc (strlen (prefix
) + MAX_SEP_LEN
+ strlen (suffix
) + 1);
11958 strcpy (retval
, lead
);
11959 strcat (retval
, prefix
);
11960 strcat (retval
, sep
);
11961 strcat (retval
, suffix
);
11966 /* We have an obstack. */
11967 return obconcat (obs
, lead
, prefix
, sep
, suffix
, (char *) NULL
);
11971 /* Return sibling of die, NULL if no sibling. */
11973 static struct die_info
*
11974 sibling_die (struct die_info
*die
)
11976 return die
->sibling
;
11979 /* Get name of a die, return NULL if not found. */
11982 dwarf2_canonicalize_name (char *name
, struct dwarf2_cu
*cu
,
11983 struct obstack
*obstack
)
11985 if (name
&& cu
->language
== language_cplus
)
11987 char *canon_name
= cp_canonicalize_string (name
);
11989 if (canon_name
!= NULL
)
11991 if (strcmp (canon_name
, name
) != 0)
11992 name
= obsavestring (canon_name
, strlen (canon_name
),
11994 xfree (canon_name
);
12001 /* Get name of a die, return NULL if not found. */
12004 dwarf2_name (struct die_info
*die
, struct dwarf2_cu
*cu
)
12006 struct attribute
*attr
;
12008 attr
= dwarf2_attr (die
, DW_AT_name
, cu
);
12009 if ((!attr
|| !DW_STRING (attr
))
12010 && die
->tag
!= DW_TAG_class_type
12011 && die
->tag
!= DW_TAG_interface_type
12012 && die
->tag
!= DW_TAG_structure_type
12013 && die
->tag
!= DW_TAG_union_type
)
12018 case DW_TAG_compile_unit
:
12019 /* Compilation units have a DW_AT_name that is a filename, not
12020 a source language identifier. */
12021 case DW_TAG_enumeration_type
:
12022 case DW_TAG_enumerator
:
12023 /* These tags always have simple identifiers already; no need
12024 to canonicalize them. */
12025 return DW_STRING (attr
);
12027 case DW_TAG_subprogram
:
12028 /* Java constructors will all be named "<init>", so return
12029 the class name when we see this special case. */
12030 if (cu
->language
== language_java
12031 && DW_STRING (attr
) != NULL
12032 && strcmp (DW_STRING (attr
), "<init>") == 0)
12034 struct dwarf2_cu
*spec_cu
= cu
;
12035 struct die_info
*spec_die
;
12037 /* GCJ will output '<init>' for Java constructor names.
12038 For this special case, return the name of the parent class. */
12040 /* GCJ may output suprogram DIEs with AT_specification set.
12041 If so, use the name of the specified DIE. */
12042 spec_die
= die_specification (die
, &spec_cu
);
12043 if (spec_die
!= NULL
)
12044 return dwarf2_name (spec_die
, spec_cu
);
12049 if (die
->tag
== DW_TAG_class_type
)
12050 return dwarf2_name (die
, cu
);
12052 while (die
->tag
!= DW_TAG_compile_unit
);
12056 case DW_TAG_class_type
:
12057 case DW_TAG_interface_type
:
12058 case DW_TAG_structure_type
:
12059 case DW_TAG_union_type
:
12060 /* Some GCC versions emit spurious DW_AT_name attributes for unnamed
12061 structures or unions. These were of the form "._%d" in GCC 4.1,
12062 or simply "<anonymous struct>" or "<anonymous union>" in GCC 4.3
12063 and GCC 4.4. We work around this problem by ignoring these. */
12064 if (attr
&& DW_STRING (attr
)
12065 && (strncmp (DW_STRING (attr
), "._", 2) == 0
12066 || strncmp (DW_STRING (attr
), "<anonymous", 10) == 0))
12069 /* GCC might emit a nameless typedef that has a linkage name. See
12070 http://gcc.gnu.org/bugzilla/show_bug.cgi?id=47510. */
12071 if (!attr
|| DW_STRING (attr
) == NULL
)
12073 char *demangled
= NULL
;
12075 attr
= dwarf2_attr (die
, DW_AT_linkage_name
, cu
);
12077 attr
= dwarf2_attr (die
, DW_AT_MIPS_linkage_name
, cu
);
12079 if (attr
== NULL
|| DW_STRING (attr
) == NULL
)
12082 /* Avoid demangling DW_STRING (attr) the second time on a second
12083 call for the same DIE. */
12084 if (!DW_STRING_IS_CANONICAL (attr
))
12085 demangled
= cplus_demangle (DW_STRING (attr
), DMGL_TYPES
);
12089 /* FIXME: we already did this for the partial symbol... */
12091 = obsavestring (demangled
, strlen (demangled
),
12092 &cu
->objfile
->objfile_obstack
);
12093 DW_STRING_IS_CANONICAL (attr
) = 1;
12103 if (!DW_STRING_IS_CANONICAL (attr
))
12106 = dwarf2_canonicalize_name (DW_STRING (attr
), cu
,
12107 &cu
->objfile
->objfile_obstack
);
12108 DW_STRING_IS_CANONICAL (attr
) = 1;
12110 return DW_STRING (attr
);
12113 /* Return the die that this die in an extension of, or NULL if there
12114 is none. *EXT_CU is the CU containing DIE on input, and the CU
12115 containing the return value on output. */
12117 static struct die_info
*
12118 dwarf2_extension (struct die_info
*die
, struct dwarf2_cu
**ext_cu
)
12120 struct attribute
*attr
;
12122 attr
= dwarf2_attr (die
, DW_AT_extension
, *ext_cu
);
12126 return follow_die_ref (die
, attr
, ext_cu
);
12129 /* Convert a DIE tag into its string name. */
12132 dwarf_tag_name (unsigned tag
)
12136 case DW_TAG_padding
:
12137 return "DW_TAG_padding";
12138 case DW_TAG_array_type
:
12139 return "DW_TAG_array_type";
12140 case DW_TAG_class_type
:
12141 return "DW_TAG_class_type";
12142 case DW_TAG_entry_point
:
12143 return "DW_TAG_entry_point";
12144 case DW_TAG_enumeration_type
:
12145 return "DW_TAG_enumeration_type";
12146 case DW_TAG_formal_parameter
:
12147 return "DW_TAG_formal_parameter";
12148 case DW_TAG_imported_declaration
:
12149 return "DW_TAG_imported_declaration";
12151 return "DW_TAG_label";
12152 case DW_TAG_lexical_block
:
12153 return "DW_TAG_lexical_block";
12154 case DW_TAG_member
:
12155 return "DW_TAG_member";
12156 case DW_TAG_pointer_type
:
12157 return "DW_TAG_pointer_type";
12158 case DW_TAG_reference_type
:
12159 return "DW_TAG_reference_type";
12160 case DW_TAG_compile_unit
:
12161 return "DW_TAG_compile_unit";
12162 case DW_TAG_string_type
:
12163 return "DW_TAG_string_type";
12164 case DW_TAG_structure_type
:
12165 return "DW_TAG_structure_type";
12166 case DW_TAG_subroutine_type
:
12167 return "DW_TAG_subroutine_type";
12168 case DW_TAG_typedef
:
12169 return "DW_TAG_typedef";
12170 case DW_TAG_union_type
:
12171 return "DW_TAG_union_type";
12172 case DW_TAG_unspecified_parameters
:
12173 return "DW_TAG_unspecified_parameters";
12174 case DW_TAG_variant
:
12175 return "DW_TAG_variant";
12176 case DW_TAG_common_block
:
12177 return "DW_TAG_common_block";
12178 case DW_TAG_common_inclusion
:
12179 return "DW_TAG_common_inclusion";
12180 case DW_TAG_inheritance
:
12181 return "DW_TAG_inheritance";
12182 case DW_TAG_inlined_subroutine
:
12183 return "DW_TAG_inlined_subroutine";
12184 case DW_TAG_module
:
12185 return "DW_TAG_module";
12186 case DW_TAG_ptr_to_member_type
:
12187 return "DW_TAG_ptr_to_member_type";
12188 case DW_TAG_set_type
:
12189 return "DW_TAG_set_type";
12190 case DW_TAG_subrange_type
:
12191 return "DW_TAG_subrange_type";
12192 case DW_TAG_with_stmt
:
12193 return "DW_TAG_with_stmt";
12194 case DW_TAG_access_declaration
:
12195 return "DW_TAG_access_declaration";
12196 case DW_TAG_base_type
:
12197 return "DW_TAG_base_type";
12198 case DW_TAG_catch_block
:
12199 return "DW_TAG_catch_block";
12200 case DW_TAG_const_type
:
12201 return "DW_TAG_const_type";
12202 case DW_TAG_constant
:
12203 return "DW_TAG_constant";
12204 case DW_TAG_enumerator
:
12205 return "DW_TAG_enumerator";
12206 case DW_TAG_file_type
:
12207 return "DW_TAG_file_type";
12208 case DW_TAG_friend
:
12209 return "DW_TAG_friend";
12210 case DW_TAG_namelist
:
12211 return "DW_TAG_namelist";
12212 case DW_TAG_namelist_item
:
12213 return "DW_TAG_namelist_item";
12214 case DW_TAG_packed_type
:
12215 return "DW_TAG_packed_type";
12216 case DW_TAG_subprogram
:
12217 return "DW_TAG_subprogram";
12218 case DW_TAG_template_type_param
:
12219 return "DW_TAG_template_type_param";
12220 case DW_TAG_template_value_param
:
12221 return "DW_TAG_template_value_param";
12222 case DW_TAG_thrown_type
:
12223 return "DW_TAG_thrown_type";
12224 case DW_TAG_try_block
:
12225 return "DW_TAG_try_block";
12226 case DW_TAG_variant_part
:
12227 return "DW_TAG_variant_part";
12228 case DW_TAG_variable
:
12229 return "DW_TAG_variable";
12230 case DW_TAG_volatile_type
:
12231 return "DW_TAG_volatile_type";
12232 case DW_TAG_dwarf_procedure
:
12233 return "DW_TAG_dwarf_procedure";
12234 case DW_TAG_restrict_type
:
12235 return "DW_TAG_restrict_type";
12236 case DW_TAG_interface_type
:
12237 return "DW_TAG_interface_type";
12238 case DW_TAG_namespace
:
12239 return "DW_TAG_namespace";
12240 case DW_TAG_imported_module
:
12241 return "DW_TAG_imported_module";
12242 case DW_TAG_unspecified_type
:
12243 return "DW_TAG_unspecified_type";
12244 case DW_TAG_partial_unit
:
12245 return "DW_TAG_partial_unit";
12246 case DW_TAG_imported_unit
:
12247 return "DW_TAG_imported_unit";
12248 case DW_TAG_condition
:
12249 return "DW_TAG_condition";
12250 case DW_TAG_shared_type
:
12251 return "DW_TAG_shared_type";
12252 case DW_TAG_type_unit
:
12253 return "DW_TAG_type_unit";
12254 case DW_TAG_MIPS_loop
:
12255 return "DW_TAG_MIPS_loop";
12256 case DW_TAG_HP_array_descriptor
:
12257 return "DW_TAG_HP_array_descriptor";
12258 case DW_TAG_format_label
:
12259 return "DW_TAG_format_label";
12260 case DW_TAG_function_template
:
12261 return "DW_TAG_function_template";
12262 case DW_TAG_class_template
:
12263 return "DW_TAG_class_template";
12264 case DW_TAG_GNU_BINCL
:
12265 return "DW_TAG_GNU_BINCL";
12266 case DW_TAG_GNU_EINCL
:
12267 return "DW_TAG_GNU_EINCL";
12268 case DW_TAG_upc_shared_type
:
12269 return "DW_TAG_upc_shared_type";
12270 case DW_TAG_upc_strict_type
:
12271 return "DW_TAG_upc_strict_type";
12272 case DW_TAG_upc_relaxed_type
:
12273 return "DW_TAG_upc_relaxed_type";
12274 case DW_TAG_PGI_kanji_type
:
12275 return "DW_TAG_PGI_kanji_type";
12276 case DW_TAG_PGI_interface_block
:
12277 return "DW_TAG_PGI_interface_block";
12279 return "DW_TAG_<unknown>";
12283 /* Convert a DWARF attribute code into its string name. */
12286 dwarf_attr_name (unsigned attr
)
12290 case DW_AT_sibling
:
12291 return "DW_AT_sibling";
12292 case DW_AT_location
:
12293 return "DW_AT_location";
12295 return "DW_AT_name";
12296 case DW_AT_ordering
:
12297 return "DW_AT_ordering";
12298 case DW_AT_subscr_data
:
12299 return "DW_AT_subscr_data";
12300 case DW_AT_byte_size
:
12301 return "DW_AT_byte_size";
12302 case DW_AT_bit_offset
:
12303 return "DW_AT_bit_offset";
12304 case DW_AT_bit_size
:
12305 return "DW_AT_bit_size";
12306 case DW_AT_element_list
:
12307 return "DW_AT_element_list";
12308 case DW_AT_stmt_list
:
12309 return "DW_AT_stmt_list";
12311 return "DW_AT_low_pc";
12312 case DW_AT_high_pc
:
12313 return "DW_AT_high_pc";
12314 case DW_AT_language
:
12315 return "DW_AT_language";
12317 return "DW_AT_member";
12319 return "DW_AT_discr";
12320 case DW_AT_discr_value
:
12321 return "DW_AT_discr_value";
12322 case DW_AT_visibility
:
12323 return "DW_AT_visibility";
12325 return "DW_AT_import";
12326 case DW_AT_string_length
:
12327 return "DW_AT_string_length";
12328 case DW_AT_common_reference
:
12329 return "DW_AT_common_reference";
12330 case DW_AT_comp_dir
:
12331 return "DW_AT_comp_dir";
12332 case DW_AT_const_value
:
12333 return "DW_AT_const_value";
12334 case DW_AT_containing_type
:
12335 return "DW_AT_containing_type";
12336 case DW_AT_default_value
:
12337 return "DW_AT_default_value";
12339 return "DW_AT_inline";
12340 case DW_AT_is_optional
:
12341 return "DW_AT_is_optional";
12342 case DW_AT_lower_bound
:
12343 return "DW_AT_lower_bound";
12344 case DW_AT_producer
:
12345 return "DW_AT_producer";
12346 case DW_AT_prototyped
:
12347 return "DW_AT_prototyped";
12348 case DW_AT_return_addr
:
12349 return "DW_AT_return_addr";
12350 case DW_AT_start_scope
:
12351 return "DW_AT_start_scope";
12352 case DW_AT_bit_stride
:
12353 return "DW_AT_bit_stride";
12354 case DW_AT_upper_bound
:
12355 return "DW_AT_upper_bound";
12356 case DW_AT_abstract_origin
:
12357 return "DW_AT_abstract_origin";
12358 case DW_AT_accessibility
:
12359 return "DW_AT_accessibility";
12360 case DW_AT_address_class
:
12361 return "DW_AT_address_class";
12362 case DW_AT_artificial
:
12363 return "DW_AT_artificial";
12364 case DW_AT_base_types
:
12365 return "DW_AT_base_types";
12366 case DW_AT_calling_convention
:
12367 return "DW_AT_calling_convention";
12369 return "DW_AT_count";
12370 case DW_AT_data_member_location
:
12371 return "DW_AT_data_member_location";
12372 case DW_AT_decl_column
:
12373 return "DW_AT_decl_column";
12374 case DW_AT_decl_file
:
12375 return "DW_AT_decl_file";
12376 case DW_AT_decl_line
:
12377 return "DW_AT_decl_line";
12378 case DW_AT_declaration
:
12379 return "DW_AT_declaration";
12380 case DW_AT_discr_list
:
12381 return "DW_AT_discr_list";
12382 case DW_AT_encoding
:
12383 return "DW_AT_encoding";
12384 case DW_AT_external
:
12385 return "DW_AT_external";
12386 case DW_AT_frame_base
:
12387 return "DW_AT_frame_base";
12389 return "DW_AT_friend";
12390 case DW_AT_identifier_case
:
12391 return "DW_AT_identifier_case";
12392 case DW_AT_macro_info
:
12393 return "DW_AT_macro_info";
12394 case DW_AT_namelist_items
:
12395 return "DW_AT_namelist_items";
12396 case DW_AT_priority
:
12397 return "DW_AT_priority";
12398 case DW_AT_segment
:
12399 return "DW_AT_segment";
12400 case DW_AT_specification
:
12401 return "DW_AT_specification";
12402 case DW_AT_static_link
:
12403 return "DW_AT_static_link";
12405 return "DW_AT_type";
12406 case DW_AT_use_location
:
12407 return "DW_AT_use_location";
12408 case DW_AT_variable_parameter
:
12409 return "DW_AT_variable_parameter";
12410 case DW_AT_virtuality
:
12411 return "DW_AT_virtuality";
12412 case DW_AT_vtable_elem_location
:
12413 return "DW_AT_vtable_elem_location";
12414 /* DWARF 3 values. */
12415 case DW_AT_allocated
:
12416 return "DW_AT_allocated";
12417 case DW_AT_associated
:
12418 return "DW_AT_associated";
12419 case DW_AT_data_location
:
12420 return "DW_AT_data_location";
12421 case DW_AT_byte_stride
:
12422 return "DW_AT_byte_stride";
12423 case DW_AT_entry_pc
:
12424 return "DW_AT_entry_pc";
12425 case DW_AT_use_UTF8
:
12426 return "DW_AT_use_UTF8";
12427 case DW_AT_extension
:
12428 return "DW_AT_extension";
12430 return "DW_AT_ranges";
12431 case DW_AT_trampoline
:
12432 return "DW_AT_trampoline";
12433 case DW_AT_call_column
:
12434 return "DW_AT_call_column";
12435 case DW_AT_call_file
:
12436 return "DW_AT_call_file";
12437 case DW_AT_call_line
:
12438 return "DW_AT_call_line";
12439 case DW_AT_description
:
12440 return "DW_AT_description";
12441 case DW_AT_binary_scale
:
12442 return "DW_AT_binary_scale";
12443 case DW_AT_decimal_scale
:
12444 return "DW_AT_decimal_scale";
12446 return "DW_AT_small";
12447 case DW_AT_decimal_sign
:
12448 return "DW_AT_decimal_sign";
12449 case DW_AT_digit_count
:
12450 return "DW_AT_digit_count";
12451 case DW_AT_picture_string
:
12452 return "DW_AT_picture_string";
12453 case DW_AT_mutable
:
12454 return "DW_AT_mutable";
12455 case DW_AT_threads_scaled
:
12456 return "DW_AT_threads_scaled";
12457 case DW_AT_explicit
:
12458 return "DW_AT_explicit";
12459 case DW_AT_object_pointer
:
12460 return "DW_AT_object_pointer";
12461 case DW_AT_endianity
:
12462 return "DW_AT_endianity";
12463 case DW_AT_elemental
:
12464 return "DW_AT_elemental";
12466 return "DW_AT_pure";
12467 case DW_AT_recursive
:
12468 return "DW_AT_recursive";
12469 /* DWARF 4 values. */
12470 case DW_AT_signature
:
12471 return "DW_AT_signature";
12472 case DW_AT_linkage_name
:
12473 return "DW_AT_linkage_name";
12474 /* SGI/MIPS extensions. */
12475 #ifdef MIPS /* collides with DW_AT_HP_block_index */
12476 case DW_AT_MIPS_fde
:
12477 return "DW_AT_MIPS_fde";
12479 case DW_AT_MIPS_loop_begin
:
12480 return "DW_AT_MIPS_loop_begin";
12481 case DW_AT_MIPS_tail_loop_begin
:
12482 return "DW_AT_MIPS_tail_loop_begin";
12483 case DW_AT_MIPS_epilog_begin
:
12484 return "DW_AT_MIPS_epilog_begin";
12485 case DW_AT_MIPS_loop_unroll_factor
:
12486 return "DW_AT_MIPS_loop_unroll_factor";
12487 case DW_AT_MIPS_software_pipeline_depth
:
12488 return "DW_AT_MIPS_software_pipeline_depth";
12489 case DW_AT_MIPS_linkage_name
:
12490 return "DW_AT_MIPS_linkage_name";
12491 case DW_AT_MIPS_stride
:
12492 return "DW_AT_MIPS_stride";
12493 case DW_AT_MIPS_abstract_name
:
12494 return "DW_AT_MIPS_abstract_name";
12495 case DW_AT_MIPS_clone_origin
:
12496 return "DW_AT_MIPS_clone_origin";
12497 case DW_AT_MIPS_has_inlines
:
12498 return "DW_AT_MIPS_has_inlines";
12499 /* HP extensions. */
12500 #ifndef MIPS /* collides with DW_AT_MIPS_fde */
12501 case DW_AT_HP_block_index
:
12502 return "DW_AT_HP_block_index";
12504 case DW_AT_HP_unmodifiable
:
12505 return "DW_AT_HP_unmodifiable";
12506 case DW_AT_HP_actuals_stmt_list
:
12507 return "DW_AT_HP_actuals_stmt_list";
12508 case DW_AT_HP_proc_per_section
:
12509 return "DW_AT_HP_proc_per_section";
12510 case DW_AT_HP_raw_data_ptr
:
12511 return "DW_AT_HP_raw_data_ptr";
12512 case DW_AT_HP_pass_by_reference
:
12513 return "DW_AT_HP_pass_by_reference";
12514 case DW_AT_HP_opt_level
:
12515 return "DW_AT_HP_opt_level";
12516 case DW_AT_HP_prof_version_id
:
12517 return "DW_AT_HP_prof_version_id";
12518 case DW_AT_HP_opt_flags
:
12519 return "DW_AT_HP_opt_flags";
12520 case DW_AT_HP_cold_region_low_pc
:
12521 return "DW_AT_HP_cold_region_low_pc";
12522 case DW_AT_HP_cold_region_high_pc
:
12523 return "DW_AT_HP_cold_region_high_pc";
12524 case DW_AT_HP_all_variables_modifiable
:
12525 return "DW_AT_HP_all_variables_modifiable";
12526 case DW_AT_HP_linkage_name
:
12527 return "DW_AT_HP_linkage_name";
12528 case DW_AT_HP_prof_flags
:
12529 return "DW_AT_HP_prof_flags";
12530 /* GNU extensions. */
12531 case DW_AT_sf_names
:
12532 return "DW_AT_sf_names";
12533 case DW_AT_src_info
:
12534 return "DW_AT_src_info";
12535 case DW_AT_mac_info
:
12536 return "DW_AT_mac_info";
12537 case DW_AT_src_coords
:
12538 return "DW_AT_src_coords";
12539 case DW_AT_body_begin
:
12540 return "DW_AT_body_begin";
12541 case DW_AT_body_end
:
12542 return "DW_AT_body_end";
12543 case DW_AT_GNU_vector
:
12544 return "DW_AT_GNU_vector";
12545 case DW_AT_GNU_odr_signature
:
12546 return "DW_AT_GNU_odr_signature";
12547 /* VMS extensions. */
12548 case DW_AT_VMS_rtnbeg_pd_address
:
12549 return "DW_AT_VMS_rtnbeg_pd_address";
12550 /* UPC extension. */
12551 case DW_AT_upc_threads_scaled
:
12552 return "DW_AT_upc_threads_scaled";
12553 /* PGI (STMicroelectronics) extensions. */
12554 case DW_AT_PGI_lbase
:
12555 return "DW_AT_PGI_lbase";
12556 case DW_AT_PGI_soffset
:
12557 return "DW_AT_PGI_soffset";
12558 case DW_AT_PGI_lstride
:
12559 return "DW_AT_PGI_lstride";
12561 return "DW_AT_<unknown>";
12565 /* Convert a DWARF value form code into its string name. */
12568 dwarf_form_name (unsigned form
)
12573 return "DW_FORM_addr";
12574 case DW_FORM_block2
:
12575 return "DW_FORM_block2";
12576 case DW_FORM_block4
:
12577 return "DW_FORM_block4";
12578 case DW_FORM_data2
:
12579 return "DW_FORM_data2";
12580 case DW_FORM_data4
:
12581 return "DW_FORM_data4";
12582 case DW_FORM_data8
:
12583 return "DW_FORM_data8";
12584 case DW_FORM_string
:
12585 return "DW_FORM_string";
12586 case DW_FORM_block
:
12587 return "DW_FORM_block";
12588 case DW_FORM_block1
:
12589 return "DW_FORM_block1";
12590 case DW_FORM_data1
:
12591 return "DW_FORM_data1";
12593 return "DW_FORM_flag";
12594 case DW_FORM_sdata
:
12595 return "DW_FORM_sdata";
12597 return "DW_FORM_strp";
12598 case DW_FORM_udata
:
12599 return "DW_FORM_udata";
12600 case DW_FORM_ref_addr
:
12601 return "DW_FORM_ref_addr";
12603 return "DW_FORM_ref1";
12605 return "DW_FORM_ref2";
12607 return "DW_FORM_ref4";
12609 return "DW_FORM_ref8";
12610 case DW_FORM_ref_udata
:
12611 return "DW_FORM_ref_udata";
12612 case DW_FORM_indirect
:
12613 return "DW_FORM_indirect";
12614 case DW_FORM_sec_offset
:
12615 return "DW_FORM_sec_offset";
12616 case DW_FORM_exprloc
:
12617 return "DW_FORM_exprloc";
12618 case DW_FORM_flag_present
:
12619 return "DW_FORM_flag_present";
12620 case DW_FORM_ref_sig8
:
12621 return "DW_FORM_ref_sig8";
12623 return "DW_FORM_<unknown>";
12627 /* Convert a DWARF stack opcode into its string name. */
12630 dwarf_stack_op_name (unsigned op
)
12635 return "DW_OP_addr";
12637 return "DW_OP_deref";
12638 case DW_OP_const1u
:
12639 return "DW_OP_const1u";
12640 case DW_OP_const1s
:
12641 return "DW_OP_const1s";
12642 case DW_OP_const2u
:
12643 return "DW_OP_const2u";
12644 case DW_OP_const2s
:
12645 return "DW_OP_const2s";
12646 case DW_OP_const4u
:
12647 return "DW_OP_const4u";
12648 case DW_OP_const4s
:
12649 return "DW_OP_const4s";
12650 case DW_OP_const8u
:
12651 return "DW_OP_const8u";
12652 case DW_OP_const8s
:
12653 return "DW_OP_const8s";
12655 return "DW_OP_constu";
12657 return "DW_OP_consts";
12659 return "DW_OP_dup";
12661 return "DW_OP_drop";
12663 return "DW_OP_over";
12665 return "DW_OP_pick";
12667 return "DW_OP_swap";
12669 return "DW_OP_rot";
12671 return "DW_OP_xderef";
12673 return "DW_OP_abs";
12675 return "DW_OP_and";
12677 return "DW_OP_div";
12679 return "DW_OP_minus";
12681 return "DW_OP_mod";
12683 return "DW_OP_mul";
12685 return "DW_OP_neg";
12687 return "DW_OP_not";
12691 return "DW_OP_plus";
12692 case DW_OP_plus_uconst
:
12693 return "DW_OP_plus_uconst";
12695 return "DW_OP_shl";
12697 return "DW_OP_shr";
12699 return "DW_OP_shra";
12701 return "DW_OP_xor";
12703 return "DW_OP_bra";
12717 return "DW_OP_skip";
12719 return "DW_OP_lit0";
12721 return "DW_OP_lit1";
12723 return "DW_OP_lit2";
12725 return "DW_OP_lit3";
12727 return "DW_OP_lit4";
12729 return "DW_OP_lit5";
12731 return "DW_OP_lit6";
12733 return "DW_OP_lit7";
12735 return "DW_OP_lit8";
12737 return "DW_OP_lit9";
12739 return "DW_OP_lit10";
12741 return "DW_OP_lit11";
12743 return "DW_OP_lit12";
12745 return "DW_OP_lit13";
12747 return "DW_OP_lit14";
12749 return "DW_OP_lit15";
12751 return "DW_OP_lit16";
12753 return "DW_OP_lit17";
12755 return "DW_OP_lit18";
12757 return "DW_OP_lit19";
12759 return "DW_OP_lit20";
12761 return "DW_OP_lit21";
12763 return "DW_OP_lit22";
12765 return "DW_OP_lit23";
12767 return "DW_OP_lit24";
12769 return "DW_OP_lit25";
12771 return "DW_OP_lit26";
12773 return "DW_OP_lit27";
12775 return "DW_OP_lit28";
12777 return "DW_OP_lit29";
12779 return "DW_OP_lit30";
12781 return "DW_OP_lit31";
12783 return "DW_OP_reg0";
12785 return "DW_OP_reg1";
12787 return "DW_OP_reg2";
12789 return "DW_OP_reg3";
12791 return "DW_OP_reg4";
12793 return "DW_OP_reg5";
12795 return "DW_OP_reg6";
12797 return "DW_OP_reg7";
12799 return "DW_OP_reg8";
12801 return "DW_OP_reg9";
12803 return "DW_OP_reg10";
12805 return "DW_OP_reg11";
12807 return "DW_OP_reg12";
12809 return "DW_OP_reg13";
12811 return "DW_OP_reg14";
12813 return "DW_OP_reg15";
12815 return "DW_OP_reg16";
12817 return "DW_OP_reg17";
12819 return "DW_OP_reg18";
12821 return "DW_OP_reg19";
12823 return "DW_OP_reg20";
12825 return "DW_OP_reg21";
12827 return "DW_OP_reg22";
12829 return "DW_OP_reg23";
12831 return "DW_OP_reg24";
12833 return "DW_OP_reg25";
12835 return "DW_OP_reg26";
12837 return "DW_OP_reg27";
12839 return "DW_OP_reg28";
12841 return "DW_OP_reg29";
12843 return "DW_OP_reg30";
12845 return "DW_OP_reg31";
12847 return "DW_OP_breg0";
12849 return "DW_OP_breg1";
12851 return "DW_OP_breg2";
12853 return "DW_OP_breg3";
12855 return "DW_OP_breg4";
12857 return "DW_OP_breg5";
12859 return "DW_OP_breg6";
12861 return "DW_OP_breg7";
12863 return "DW_OP_breg8";
12865 return "DW_OP_breg9";
12867 return "DW_OP_breg10";
12869 return "DW_OP_breg11";
12871 return "DW_OP_breg12";
12873 return "DW_OP_breg13";
12875 return "DW_OP_breg14";
12877 return "DW_OP_breg15";
12879 return "DW_OP_breg16";
12881 return "DW_OP_breg17";
12883 return "DW_OP_breg18";
12885 return "DW_OP_breg19";
12887 return "DW_OP_breg20";
12889 return "DW_OP_breg21";
12891 return "DW_OP_breg22";
12893 return "DW_OP_breg23";
12895 return "DW_OP_breg24";
12897 return "DW_OP_breg25";
12899 return "DW_OP_breg26";
12901 return "DW_OP_breg27";
12903 return "DW_OP_breg28";
12905 return "DW_OP_breg29";
12907 return "DW_OP_breg30";
12909 return "DW_OP_breg31";
12911 return "DW_OP_regx";
12913 return "DW_OP_fbreg";
12915 return "DW_OP_bregx";
12917 return "DW_OP_piece";
12918 case DW_OP_deref_size
:
12919 return "DW_OP_deref_size";
12920 case DW_OP_xderef_size
:
12921 return "DW_OP_xderef_size";
12923 return "DW_OP_nop";
12924 /* DWARF 3 extensions. */
12925 case DW_OP_push_object_address
:
12926 return "DW_OP_push_object_address";
12928 return "DW_OP_call2";
12930 return "DW_OP_call4";
12931 case DW_OP_call_ref
:
12932 return "DW_OP_call_ref";
12933 case DW_OP_form_tls_address
:
12934 return "DW_OP_form_tls_address";
12935 case DW_OP_call_frame_cfa
:
12936 return "DW_OP_call_frame_cfa";
12937 case DW_OP_bit_piece
:
12938 return "DW_OP_bit_piece";
12939 /* DWARF 4 extensions. */
12940 case DW_OP_implicit_value
:
12941 return "DW_OP_implicit_value";
12942 case DW_OP_stack_value
:
12943 return "DW_OP_stack_value";
12944 /* GNU extensions. */
12945 case DW_OP_GNU_push_tls_address
:
12946 return "DW_OP_GNU_push_tls_address";
12947 case DW_OP_GNU_uninit
:
12948 return "DW_OP_GNU_uninit";
12949 case DW_OP_GNU_implicit_pointer
:
12950 return "DW_OP_GNU_implicit_pointer";
12957 dwarf_bool_name (unsigned mybool
)
12965 /* Convert a DWARF type code into its string name. */
12968 dwarf_type_encoding_name (unsigned enc
)
12973 return "DW_ATE_void";
12974 case DW_ATE_address
:
12975 return "DW_ATE_address";
12976 case DW_ATE_boolean
:
12977 return "DW_ATE_boolean";
12978 case DW_ATE_complex_float
:
12979 return "DW_ATE_complex_float";
12981 return "DW_ATE_float";
12982 case DW_ATE_signed
:
12983 return "DW_ATE_signed";
12984 case DW_ATE_signed_char
:
12985 return "DW_ATE_signed_char";
12986 case DW_ATE_unsigned
:
12987 return "DW_ATE_unsigned";
12988 case DW_ATE_unsigned_char
:
12989 return "DW_ATE_unsigned_char";
12991 case DW_ATE_imaginary_float
:
12992 return "DW_ATE_imaginary_float";
12993 case DW_ATE_packed_decimal
:
12994 return "DW_ATE_packed_decimal";
12995 case DW_ATE_numeric_string
:
12996 return "DW_ATE_numeric_string";
12997 case DW_ATE_edited
:
12998 return "DW_ATE_edited";
12999 case DW_ATE_signed_fixed
:
13000 return "DW_ATE_signed_fixed";
13001 case DW_ATE_unsigned_fixed
:
13002 return "DW_ATE_unsigned_fixed";
13003 case DW_ATE_decimal_float
:
13004 return "DW_ATE_decimal_float";
13007 return "DW_ATE_UTF";
13008 /* HP extensions. */
13009 case DW_ATE_HP_float80
:
13010 return "DW_ATE_HP_float80";
13011 case DW_ATE_HP_complex_float80
:
13012 return "DW_ATE_HP_complex_float80";
13013 case DW_ATE_HP_float128
:
13014 return "DW_ATE_HP_float128";
13015 case DW_ATE_HP_complex_float128
:
13016 return "DW_ATE_HP_complex_float128";
13017 case DW_ATE_HP_floathpintel
:
13018 return "DW_ATE_HP_floathpintel";
13019 case DW_ATE_HP_imaginary_float80
:
13020 return "DW_ATE_HP_imaginary_float80";
13021 case DW_ATE_HP_imaginary_float128
:
13022 return "DW_ATE_HP_imaginary_float128";
13024 return "DW_ATE_<unknown>";
13028 /* Convert a DWARF call frame info operation to its string name. */
13032 dwarf_cfi_name (unsigned cfi_opc
)
13036 case DW_CFA_advance_loc
:
13037 return "DW_CFA_advance_loc";
13038 case DW_CFA_offset
:
13039 return "DW_CFA_offset";
13040 case DW_CFA_restore
:
13041 return "DW_CFA_restore";
13043 return "DW_CFA_nop";
13044 case DW_CFA_set_loc
:
13045 return "DW_CFA_set_loc";
13046 case DW_CFA_advance_loc1
:
13047 return "DW_CFA_advance_loc1";
13048 case DW_CFA_advance_loc2
:
13049 return "DW_CFA_advance_loc2";
13050 case DW_CFA_advance_loc4
:
13051 return "DW_CFA_advance_loc4";
13052 case DW_CFA_offset_extended
:
13053 return "DW_CFA_offset_extended";
13054 case DW_CFA_restore_extended
:
13055 return "DW_CFA_restore_extended";
13056 case DW_CFA_undefined
:
13057 return "DW_CFA_undefined";
13058 case DW_CFA_same_value
:
13059 return "DW_CFA_same_value";
13060 case DW_CFA_register
:
13061 return "DW_CFA_register";
13062 case DW_CFA_remember_state
:
13063 return "DW_CFA_remember_state";
13064 case DW_CFA_restore_state
:
13065 return "DW_CFA_restore_state";
13066 case DW_CFA_def_cfa
:
13067 return "DW_CFA_def_cfa";
13068 case DW_CFA_def_cfa_register
:
13069 return "DW_CFA_def_cfa_register";
13070 case DW_CFA_def_cfa_offset
:
13071 return "DW_CFA_def_cfa_offset";
13073 case DW_CFA_def_cfa_expression
:
13074 return "DW_CFA_def_cfa_expression";
13075 case DW_CFA_expression
:
13076 return "DW_CFA_expression";
13077 case DW_CFA_offset_extended_sf
:
13078 return "DW_CFA_offset_extended_sf";
13079 case DW_CFA_def_cfa_sf
:
13080 return "DW_CFA_def_cfa_sf";
13081 case DW_CFA_def_cfa_offset_sf
:
13082 return "DW_CFA_def_cfa_offset_sf";
13083 case DW_CFA_val_offset
:
13084 return "DW_CFA_val_offset";
13085 case DW_CFA_val_offset_sf
:
13086 return "DW_CFA_val_offset_sf";
13087 case DW_CFA_val_expression
:
13088 return "DW_CFA_val_expression";
13089 /* SGI/MIPS specific. */
13090 case DW_CFA_MIPS_advance_loc8
:
13091 return "DW_CFA_MIPS_advance_loc8";
13092 /* GNU extensions. */
13093 case DW_CFA_GNU_window_save
:
13094 return "DW_CFA_GNU_window_save";
13095 case DW_CFA_GNU_args_size
:
13096 return "DW_CFA_GNU_args_size";
13097 case DW_CFA_GNU_negative_offset_extended
:
13098 return "DW_CFA_GNU_negative_offset_extended";
13100 return "DW_CFA_<unknown>";
13106 dump_die_shallow (struct ui_file
*f
, int indent
, struct die_info
*die
)
13110 print_spaces (indent
, f
);
13111 fprintf_unfiltered (f
, "Die: %s (abbrev %d, offset 0x%x)\n",
13112 dwarf_tag_name (die
->tag
), die
->abbrev
, die
->offset
);
13114 if (die
->parent
!= NULL
)
13116 print_spaces (indent
, f
);
13117 fprintf_unfiltered (f
, " parent at offset: 0x%x\n",
13118 die
->parent
->offset
);
13121 print_spaces (indent
, f
);
13122 fprintf_unfiltered (f
, " has children: %s\n",
13123 dwarf_bool_name (die
->child
!= NULL
));
13125 print_spaces (indent
, f
);
13126 fprintf_unfiltered (f
, " attributes:\n");
13128 for (i
= 0; i
< die
->num_attrs
; ++i
)
13130 print_spaces (indent
, f
);
13131 fprintf_unfiltered (f
, " %s (%s) ",
13132 dwarf_attr_name (die
->attrs
[i
].name
),
13133 dwarf_form_name (die
->attrs
[i
].form
));
13135 switch (die
->attrs
[i
].form
)
13137 case DW_FORM_ref_addr
:
13139 fprintf_unfiltered (f
, "address: ");
13140 fputs_filtered (hex_string (DW_ADDR (&die
->attrs
[i
])), f
);
13142 case DW_FORM_block2
:
13143 case DW_FORM_block4
:
13144 case DW_FORM_block
:
13145 case DW_FORM_block1
:
13146 fprintf_unfiltered (f
, "block: size %d",
13147 DW_BLOCK (&die
->attrs
[i
])->size
);
13149 case DW_FORM_exprloc
:
13150 fprintf_unfiltered (f
, "expression: size %u",
13151 DW_BLOCK (&die
->attrs
[i
])->size
);
13156 fprintf_unfiltered (f
, "constant ref: 0x%lx (adjusted)",
13157 (long) (DW_ADDR (&die
->attrs
[i
])));
13159 case DW_FORM_data1
:
13160 case DW_FORM_data2
:
13161 case DW_FORM_data4
:
13162 case DW_FORM_data8
:
13163 case DW_FORM_udata
:
13164 case DW_FORM_sdata
:
13165 fprintf_unfiltered (f
, "constant: %s",
13166 pulongest (DW_UNSND (&die
->attrs
[i
])));
13168 case DW_FORM_sec_offset
:
13169 fprintf_unfiltered (f
, "section offset: %s",
13170 pulongest (DW_UNSND (&die
->attrs
[i
])));
13172 case DW_FORM_ref_sig8
:
13173 if (DW_SIGNATURED_TYPE (&die
->attrs
[i
]) != NULL
)
13174 fprintf_unfiltered (f
, "signatured type, offset: 0x%x",
13175 DW_SIGNATURED_TYPE (&die
->attrs
[i
])->offset
);
13177 fprintf_unfiltered (f
, "signatured type, offset: unknown");
13179 case DW_FORM_string
:
13181 fprintf_unfiltered (f
, "string: \"%s\" (%s canonicalized)",
13182 DW_STRING (&die
->attrs
[i
])
13183 ? DW_STRING (&die
->attrs
[i
]) : "",
13184 DW_STRING_IS_CANONICAL (&die
->attrs
[i
]) ? "is" : "not");
13187 if (DW_UNSND (&die
->attrs
[i
]))
13188 fprintf_unfiltered (f
, "flag: TRUE");
13190 fprintf_unfiltered (f
, "flag: FALSE");
13192 case DW_FORM_flag_present
:
13193 fprintf_unfiltered (f
, "flag: TRUE");
13195 case DW_FORM_indirect
:
13196 /* The reader will have reduced the indirect form to
13197 the "base form" so this form should not occur. */
13198 fprintf_unfiltered (f
,
13199 "unexpected attribute form: DW_FORM_indirect");
13202 fprintf_unfiltered (f
, "unsupported attribute form: %d.",
13203 die
->attrs
[i
].form
);
13206 fprintf_unfiltered (f
, "\n");
13211 dump_die_for_error (struct die_info
*die
)
13213 dump_die_shallow (gdb_stderr
, 0, die
);
13217 dump_die_1 (struct ui_file
*f
, int level
, int max_level
, struct die_info
*die
)
13219 int indent
= level
* 4;
13221 gdb_assert (die
!= NULL
);
13223 if (level
>= max_level
)
13226 dump_die_shallow (f
, indent
, die
);
13228 if (die
->child
!= NULL
)
13230 print_spaces (indent
, f
);
13231 fprintf_unfiltered (f
, " Children:");
13232 if (level
+ 1 < max_level
)
13234 fprintf_unfiltered (f
, "\n");
13235 dump_die_1 (f
, level
+ 1, max_level
, die
->child
);
13239 fprintf_unfiltered (f
,
13240 " [not printed, max nesting level reached]\n");
13244 if (die
->sibling
!= NULL
&& level
> 0)
13246 dump_die_1 (f
, level
, max_level
, die
->sibling
);
13250 /* This is called from the pdie macro in gdbinit.in.
13251 It's not static so gcc will keep a copy callable from gdb. */
13254 dump_die (struct die_info
*die
, int max_level
)
13256 dump_die_1 (gdb_stdlog
, 0, max_level
, die
);
13260 store_in_ref_table (struct die_info
*die
, struct dwarf2_cu
*cu
)
13264 slot
= htab_find_slot_with_hash (cu
->die_hash
, die
, die
->offset
, INSERT
);
13270 is_ref_attr (struct attribute
*attr
)
13272 switch (attr
->form
)
13274 case DW_FORM_ref_addr
:
13279 case DW_FORM_ref_udata
:
13286 static unsigned int
13287 dwarf2_get_ref_die_offset (struct attribute
*attr
)
13289 if (is_ref_attr (attr
))
13290 return DW_ADDR (attr
);
13292 complaint (&symfile_complaints
,
13293 _("unsupported die ref attribute form: '%s'"),
13294 dwarf_form_name (attr
->form
));
13298 /* Return the constant value held by ATTR. Return DEFAULT_VALUE if
13299 * the value held by the attribute is not constant. */
13302 dwarf2_get_attr_constant_value (struct attribute
*attr
, int default_value
)
13304 if (attr
->form
== DW_FORM_sdata
)
13305 return DW_SND (attr
);
13306 else if (attr
->form
== DW_FORM_udata
13307 || attr
->form
== DW_FORM_data1
13308 || attr
->form
== DW_FORM_data2
13309 || attr
->form
== DW_FORM_data4
13310 || attr
->form
== DW_FORM_data8
)
13311 return DW_UNSND (attr
);
13314 complaint (&symfile_complaints
,
13315 _("Attribute value is not a constant (%s)"),
13316 dwarf_form_name (attr
->form
));
13317 return default_value
;
13321 /* THIS_CU has a reference to PER_CU. If necessary, load the new compilation
13322 unit and add it to our queue.
13323 The result is non-zero if PER_CU was queued, otherwise the result is zero
13324 meaning either PER_CU is already queued or it is already loaded. */
13327 maybe_queue_comp_unit (struct dwarf2_cu
*this_cu
,
13328 struct dwarf2_per_cu_data
*per_cu
)
13330 /* We may arrive here during partial symbol reading, if we need full
13331 DIEs to process an unusual case (e.g. template arguments). Do
13332 not queue PER_CU, just tell our caller to load its DIEs. */
13333 if (dwarf2_per_objfile
->reading_partial_symbols
)
13335 if (per_cu
->cu
== NULL
|| per_cu
->cu
->dies
== NULL
)
13340 /* Mark the dependence relation so that we don't flush PER_CU
13342 dwarf2_add_dependence (this_cu
, per_cu
);
13344 /* If it's already on the queue, we have nothing to do. */
13345 if (per_cu
->queued
)
13348 /* If the compilation unit is already loaded, just mark it as
13350 if (per_cu
->cu
!= NULL
)
13352 per_cu
->cu
->last_used
= 0;
13356 /* Add it to the queue. */
13357 queue_comp_unit (per_cu
, this_cu
->objfile
);
13362 /* Follow reference or signature attribute ATTR of SRC_DIE.
13363 On entry *REF_CU is the CU of SRC_DIE.
13364 On exit *REF_CU is the CU of the result. */
13366 static struct die_info
*
13367 follow_die_ref_or_sig (struct die_info
*src_die
, struct attribute
*attr
,
13368 struct dwarf2_cu
**ref_cu
)
13370 struct die_info
*die
;
13372 if (is_ref_attr (attr
))
13373 die
= follow_die_ref (src_die
, attr
, ref_cu
);
13374 else if (attr
->form
== DW_FORM_ref_sig8
)
13375 die
= follow_die_sig (src_die
, attr
, ref_cu
);
13378 dump_die_for_error (src_die
);
13379 error (_("Dwarf Error: Expected reference attribute [in module %s]"),
13380 (*ref_cu
)->objfile
->name
);
13386 /* Follow reference OFFSET.
13387 On entry *REF_CU is the CU of the source die referencing OFFSET.
13388 On exit *REF_CU is the CU of the result.
13389 Returns NULL if OFFSET is invalid. */
13391 static struct die_info
*
13392 follow_die_offset (unsigned int offset
, struct dwarf2_cu
**ref_cu
)
13394 struct die_info temp_die
;
13395 struct dwarf2_cu
*target_cu
, *cu
= *ref_cu
;
13397 gdb_assert (cu
->per_cu
!= NULL
);
13401 if (cu
->per_cu
->from_debug_types
)
13403 /* .debug_types CUs cannot reference anything outside their CU.
13404 If they need to, they have to reference a signatured type via
13405 DW_FORM_ref_sig8. */
13406 if (! offset_in_cu_p (&cu
->header
, offset
))
13409 else if (! offset_in_cu_p (&cu
->header
, offset
))
13411 struct dwarf2_per_cu_data
*per_cu
;
13413 per_cu
= dwarf2_find_containing_comp_unit (offset
, cu
->objfile
);
13415 /* If necessary, add it to the queue and load its DIEs. */
13416 if (maybe_queue_comp_unit (cu
, per_cu
))
13417 load_full_comp_unit (per_cu
, cu
->objfile
);
13419 target_cu
= per_cu
->cu
;
13421 else if (cu
->dies
== NULL
)
13423 /* We're loading full DIEs during partial symbol reading. */
13424 gdb_assert (dwarf2_per_objfile
->reading_partial_symbols
);
13425 load_full_comp_unit (cu
->per_cu
, cu
->objfile
);
13428 *ref_cu
= target_cu
;
13429 temp_die
.offset
= offset
;
13430 return htab_find_with_hash (target_cu
->die_hash
, &temp_die
, offset
);
13433 /* Follow reference attribute ATTR of SRC_DIE.
13434 On entry *REF_CU is the CU of SRC_DIE.
13435 On exit *REF_CU is the CU of the result. */
13437 static struct die_info
*
13438 follow_die_ref (struct die_info
*src_die
, struct attribute
*attr
,
13439 struct dwarf2_cu
**ref_cu
)
13441 unsigned int offset
= dwarf2_get_ref_die_offset (attr
);
13442 struct dwarf2_cu
*cu
= *ref_cu
;
13443 struct die_info
*die
;
13445 die
= follow_die_offset (offset
, ref_cu
);
13447 error (_("Dwarf Error: Cannot find DIE at 0x%x referenced from DIE "
13448 "at 0x%x [in module %s]"),
13449 offset
, src_die
->offset
, cu
->objfile
->name
);
13454 /* Return DWARF block and its CU referenced by OFFSET at PER_CU. Returned
13455 value is intended for DW_OP_call*. */
13457 struct dwarf2_locexpr_baton
13458 dwarf2_fetch_die_location_block (unsigned int offset
,
13459 struct dwarf2_per_cu_data
*per_cu
,
13460 CORE_ADDR (*get_frame_pc
) (void *baton
),
13463 struct dwarf2_cu
*cu
= per_cu
->cu
;
13464 struct die_info
*die
;
13465 struct attribute
*attr
;
13466 struct dwarf2_locexpr_baton retval
;
13468 dw2_setup (per_cu
->objfile
);
13470 die
= follow_die_offset (offset
, &cu
);
13472 error (_("Dwarf Error: Cannot find DIE at 0x%x referenced in module %s"),
13473 offset
, per_cu
->cu
->objfile
->name
);
13475 attr
= dwarf2_attr (die
, DW_AT_location
, cu
);
13478 /* DWARF: "If there is no such attribute, then there is no effect.". */
13480 retval
.data
= NULL
;
13483 else if (attr_form_is_section_offset (attr
))
13485 struct dwarf2_loclist_baton loclist_baton
;
13486 CORE_ADDR pc
= (*get_frame_pc
) (baton
);
13489 fill_in_loclist_baton (cu
, &loclist_baton
, attr
);
13491 retval
.data
= dwarf2_find_location_expression (&loclist_baton
,
13493 retval
.size
= size
;
13497 if (!attr_form_is_block (attr
))
13498 error (_("Dwarf Error: DIE at 0x%x referenced in module %s "
13499 "is neither DW_FORM_block* nor DW_FORM_exprloc"),
13500 offset
, per_cu
->cu
->objfile
->name
);
13502 retval
.data
= DW_BLOCK (attr
)->data
;
13503 retval
.size
= DW_BLOCK (attr
)->size
;
13505 retval
.per_cu
= cu
->per_cu
;
13509 /* Follow the signature attribute ATTR in SRC_DIE.
13510 On entry *REF_CU is the CU of SRC_DIE.
13511 On exit *REF_CU is the CU of the result. */
13513 static struct die_info
*
13514 follow_die_sig (struct die_info
*src_die
, struct attribute
*attr
,
13515 struct dwarf2_cu
**ref_cu
)
13517 struct objfile
*objfile
= (*ref_cu
)->objfile
;
13518 struct die_info temp_die
;
13519 struct signatured_type
*sig_type
= DW_SIGNATURED_TYPE (attr
);
13520 struct dwarf2_cu
*sig_cu
;
13521 struct die_info
*die
;
13523 /* sig_type will be NULL if the signatured type is missing from
13525 if (sig_type
== NULL
)
13526 error (_("Dwarf Error: Cannot find signatured DIE referenced from DIE "
13527 "at 0x%x [in module %s]"),
13528 src_die
->offset
, objfile
->name
);
13530 /* If necessary, add it to the queue and load its DIEs. */
13532 if (maybe_queue_comp_unit (*ref_cu
, &sig_type
->per_cu
))
13533 read_signatured_type (objfile
, sig_type
);
13535 gdb_assert (sig_type
->per_cu
.cu
!= NULL
);
13537 sig_cu
= sig_type
->per_cu
.cu
;
13538 temp_die
.offset
= sig_cu
->header
.offset
+ sig_type
->type_offset
;
13539 die
= htab_find_with_hash (sig_cu
->die_hash
, &temp_die
, temp_die
.offset
);
13546 error (_("Dwarf Error: Cannot find signatured DIE at 0x%x referenced "
13547 "from DIE at 0x%x [in module %s]"),
13548 sig_type
->type_offset
, src_die
->offset
, objfile
->name
);
13551 /* Given an offset of a signatured type, return its signatured_type. */
13553 static struct signatured_type
*
13554 lookup_signatured_type_at_offset (struct objfile
*objfile
, unsigned int offset
)
13556 gdb_byte
*info_ptr
= dwarf2_per_objfile
->types
.buffer
+ offset
;
13557 unsigned int length
, initial_length_size
;
13558 unsigned int sig_offset
;
13559 struct signatured_type find_entry
, *type_sig
;
13561 length
= read_initial_length (objfile
->obfd
, info_ptr
, &initial_length_size
);
13562 sig_offset
= (initial_length_size
13564 + (initial_length_size
== 4 ? 4 : 8) /*debug_abbrev_offset*/
13565 + 1 /*address_size*/);
13566 find_entry
.signature
= bfd_get_64 (objfile
->obfd
, info_ptr
+ sig_offset
);
13567 type_sig
= htab_find (dwarf2_per_objfile
->signatured_types
, &find_entry
);
13569 /* This is only used to lookup previously recorded types.
13570 If we didn't find it, it's our bug. */
13571 gdb_assert (type_sig
!= NULL
);
13572 gdb_assert (offset
== type_sig
->offset
);
13577 /* Read in signatured type at OFFSET and build its CU and die(s). */
13580 read_signatured_type_at_offset (struct objfile
*objfile
,
13581 unsigned int offset
)
13583 struct signatured_type
*type_sig
;
13585 dwarf2_read_section (objfile
, &dwarf2_per_objfile
->types
);
13587 /* We have the section offset, but we need the signature to do the
13588 hash table lookup. */
13589 type_sig
= lookup_signatured_type_at_offset (objfile
, offset
);
13591 gdb_assert (type_sig
->per_cu
.cu
== NULL
);
13593 read_signatured_type (objfile
, type_sig
);
13595 gdb_assert (type_sig
->per_cu
.cu
!= NULL
);
13598 /* Read in a signatured type and build its CU and DIEs. */
13601 read_signatured_type (struct objfile
*objfile
,
13602 struct signatured_type
*type_sig
)
13604 gdb_byte
*types_ptr
;
13605 struct die_reader_specs reader_specs
;
13606 struct dwarf2_cu
*cu
;
13607 ULONGEST signature
;
13608 struct cleanup
*back_to
, *free_cu_cleanup
;
13610 dwarf2_read_section (objfile
, &dwarf2_per_objfile
->types
);
13611 types_ptr
= dwarf2_per_objfile
->types
.buffer
+ type_sig
->offset
;
13613 gdb_assert (type_sig
->per_cu
.cu
== NULL
);
13615 cu
= xmalloc (sizeof (*cu
));
13616 init_one_comp_unit (cu
, objfile
);
13618 type_sig
->per_cu
.cu
= cu
;
13619 cu
->per_cu
= &type_sig
->per_cu
;
13621 /* If an error occurs while loading, release our storage. */
13622 free_cu_cleanup
= make_cleanup (free_one_comp_unit
, cu
);
13624 types_ptr
= read_type_comp_unit_head (&cu
->header
, &signature
,
13625 types_ptr
, objfile
->obfd
);
13626 gdb_assert (signature
== type_sig
->signature
);
13629 = htab_create_alloc_ex (cu
->header
.length
/ 12,
13633 &cu
->comp_unit_obstack
,
13634 hashtab_obstack_allocate
,
13635 dummy_obstack_deallocate
);
13637 dwarf2_read_abbrevs (cu
->objfile
->obfd
, cu
);
13638 back_to
= make_cleanup (dwarf2_free_abbrev_table
, cu
);
13640 init_cu_die_reader (&reader_specs
, cu
);
13642 cu
->dies
= read_die_and_children (&reader_specs
, types_ptr
, &types_ptr
,
13645 /* We try not to read any attributes in this function, because not
13646 all objfiles needed for references have been loaded yet, and symbol
13647 table processing isn't initialized. But we have to set the CU language,
13648 or we won't be able to build types correctly. */
13649 prepare_one_comp_unit (cu
, cu
->dies
);
13651 do_cleanups (back_to
);
13653 /* We've successfully allocated this compilation unit. Let our caller
13654 clean it up when finished with it. */
13655 discard_cleanups (free_cu_cleanup
);
13657 type_sig
->per_cu
.cu
->read_in_chain
= dwarf2_per_objfile
->read_in_chain
;
13658 dwarf2_per_objfile
->read_in_chain
= &type_sig
->per_cu
;
13661 /* Decode simple location descriptions.
13662 Given a pointer to a dwarf block that defines a location, compute
13663 the location and return the value.
13665 NOTE drow/2003-11-18: This function is called in two situations
13666 now: for the address of static or global variables (partial symbols
13667 only) and for offsets into structures which are expected to be
13668 (more or less) constant. The partial symbol case should go away,
13669 and only the constant case should remain. That will let this
13670 function complain more accurately. A few special modes are allowed
13671 without complaint for global variables (for instance, global
13672 register values and thread-local values).
13674 A location description containing no operations indicates that the
13675 object is optimized out. The return value is 0 for that case.
13676 FIXME drow/2003-11-16: No callers check for this case any more; soon all
13677 callers will only want a very basic result and this can become a
13680 Note that stack[0] is unused except as a default error return. */
13683 decode_locdesc (struct dwarf_block
*blk
, struct dwarf2_cu
*cu
)
13685 struct objfile
*objfile
= cu
->objfile
;
13687 int size
= blk
->size
;
13688 gdb_byte
*data
= blk
->data
;
13689 CORE_ADDR stack
[64];
13691 unsigned int bytes_read
, unsnd
;
13697 stack
[++stacki
] = 0;
13736 stack
[++stacki
] = op
- DW_OP_lit0
;
13771 stack
[++stacki
] = op
- DW_OP_reg0
;
13773 dwarf2_complex_location_expr_complaint ();
13777 unsnd
= read_unsigned_leb128 (NULL
, (data
+ i
), &bytes_read
);
13779 stack
[++stacki
] = unsnd
;
13781 dwarf2_complex_location_expr_complaint ();
13785 stack
[++stacki
] = read_address (objfile
->obfd
, &data
[i
],
13790 case DW_OP_const1u
:
13791 stack
[++stacki
] = read_1_byte (objfile
->obfd
, &data
[i
]);
13795 case DW_OP_const1s
:
13796 stack
[++stacki
] = read_1_signed_byte (objfile
->obfd
, &data
[i
]);
13800 case DW_OP_const2u
:
13801 stack
[++stacki
] = read_2_bytes (objfile
->obfd
, &data
[i
]);
13805 case DW_OP_const2s
:
13806 stack
[++stacki
] = read_2_signed_bytes (objfile
->obfd
, &data
[i
]);
13810 case DW_OP_const4u
:
13811 stack
[++stacki
] = read_4_bytes (objfile
->obfd
, &data
[i
]);
13815 case DW_OP_const4s
:
13816 stack
[++stacki
] = read_4_signed_bytes (objfile
->obfd
, &data
[i
]);
13821 stack
[++stacki
] = read_unsigned_leb128 (NULL
, (data
+ i
),
13827 stack
[++stacki
] = read_signed_leb128 (NULL
, (data
+ i
), &bytes_read
);
13832 stack
[stacki
+ 1] = stack
[stacki
];
13837 stack
[stacki
- 1] += stack
[stacki
];
13841 case DW_OP_plus_uconst
:
13842 stack
[stacki
] += read_unsigned_leb128 (NULL
, (data
+ i
),
13848 stack
[stacki
- 1] -= stack
[stacki
];
13853 /* If we're not the last op, then we definitely can't encode
13854 this using GDB's address_class enum. This is valid for partial
13855 global symbols, although the variable's address will be bogus
13858 dwarf2_complex_location_expr_complaint ();
13861 case DW_OP_GNU_push_tls_address
:
13862 /* The top of the stack has the offset from the beginning
13863 of the thread control block at which the variable is located. */
13864 /* Nothing should follow this operator, so the top of stack would
13866 /* This is valid for partial global symbols, but the variable's
13867 address will be bogus in the psymtab. */
13869 dwarf2_complex_location_expr_complaint ();
13872 case DW_OP_GNU_uninit
:
13877 const char *name
= dwarf_stack_op_name (op
);
13880 complaint (&symfile_complaints
, _("unsupported stack op: '%s'"),
13883 complaint (&symfile_complaints
, _("unsupported stack op: '%02x'"),
13887 return (stack
[stacki
]);
13890 /* Enforce maximum stack depth of SIZE-1 to avoid writing
13891 outside of the allocated space. Also enforce minimum>0. */
13892 if (stacki
>= ARRAY_SIZE (stack
) - 1)
13894 complaint (&symfile_complaints
,
13895 _("location description stack overflow"));
13901 complaint (&symfile_complaints
,
13902 _("location description stack underflow"));
13906 return (stack
[stacki
]);
13909 /* memory allocation interface */
13911 static struct dwarf_block
*
13912 dwarf_alloc_block (struct dwarf2_cu
*cu
)
13914 struct dwarf_block
*blk
;
13916 blk
= (struct dwarf_block
*)
13917 obstack_alloc (&cu
->comp_unit_obstack
, sizeof (struct dwarf_block
));
13921 static struct abbrev_info
*
13922 dwarf_alloc_abbrev (struct dwarf2_cu
*cu
)
13924 struct abbrev_info
*abbrev
;
13926 abbrev
= (struct abbrev_info
*)
13927 obstack_alloc (&cu
->abbrev_obstack
, sizeof (struct abbrev_info
));
13928 memset (abbrev
, 0, sizeof (struct abbrev_info
));
13932 static struct die_info
*
13933 dwarf_alloc_die (struct dwarf2_cu
*cu
, int num_attrs
)
13935 struct die_info
*die
;
13936 size_t size
= sizeof (struct die_info
);
13939 size
+= (num_attrs
- 1) * sizeof (struct attribute
);
13941 die
= (struct die_info
*) obstack_alloc (&cu
->comp_unit_obstack
, size
);
13942 memset (die
, 0, sizeof (struct die_info
));
13947 /* Macro support. */
13949 /* Return the full name of file number I in *LH's file name table.
13950 Use COMP_DIR as the name of the current directory of the
13951 compilation. The result is allocated using xmalloc; the caller is
13952 responsible for freeing it. */
13954 file_full_name (int file
, struct line_header
*lh
, const char *comp_dir
)
13956 /* Is the file number a valid index into the line header's file name
13957 table? Remember that file numbers start with one, not zero. */
13958 if (1 <= file
&& file
<= lh
->num_file_names
)
13960 struct file_entry
*fe
= &lh
->file_names
[file
- 1];
13962 if (IS_ABSOLUTE_PATH (fe
->name
))
13963 return xstrdup (fe
->name
);
13971 dir
= lh
->include_dirs
[fe
->dir_index
- 1];
13977 dir_len
= strlen (dir
);
13978 full_name
= xmalloc (dir_len
+ 1 + strlen (fe
->name
) + 1);
13979 strcpy (full_name
, dir
);
13980 full_name
[dir_len
] = '/';
13981 strcpy (full_name
+ dir_len
+ 1, fe
->name
);
13985 return xstrdup (fe
->name
);
13990 /* The compiler produced a bogus file number. We can at least
13991 record the macro definitions made in the file, even if we
13992 won't be able to find the file by name. */
13993 char fake_name
[80];
13995 sprintf (fake_name
, "<bad macro file number %d>", file
);
13997 complaint (&symfile_complaints
,
13998 _("bad file number in macro information (%d)"),
14001 return xstrdup (fake_name
);
14006 static struct macro_source_file
*
14007 macro_start_file (int file
, int line
,
14008 struct macro_source_file
*current_file
,
14009 const char *comp_dir
,
14010 struct line_header
*lh
, struct objfile
*objfile
)
14012 /* The full name of this source file. */
14013 char *full_name
= file_full_name (file
, lh
, comp_dir
);
14015 /* We don't create a macro table for this compilation unit
14016 at all until we actually get a filename. */
14017 if (! pending_macros
)
14018 pending_macros
= new_macro_table (&objfile
->objfile_obstack
,
14019 objfile
->macro_cache
);
14021 if (! current_file
)
14022 /* If we have no current file, then this must be the start_file
14023 directive for the compilation unit's main source file. */
14024 current_file
= macro_set_main (pending_macros
, full_name
);
14026 current_file
= macro_include (current_file
, line
, full_name
);
14030 return current_file
;
14034 /* Copy the LEN characters at BUF to a xmalloc'ed block of memory,
14035 followed by a null byte. */
14037 copy_string (const char *buf
, int len
)
14039 char *s
= xmalloc (len
+ 1);
14041 memcpy (s
, buf
, len
);
14047 static const char *
14048 consume_improper_spaces (const char *p
, const char *body
)
14052 complaint (&symfile_complaints
,
14053 _("macro definition contains spaces "
14054 "in formal argument list:\n`%s'"),
14066 parse_macro_definition (struct macro_source_file
*file
, int line
,
14071 /* The body string takes one of two forms. For object-like macro
14072 definitions, it should be:
14074 <macro name> " " <definition>
14076 For function-like macro definitions, it should be:
14078 <macro name> "() " <definition>
14080 <macro name> "(" <arg name> ( "," <arg name> ) * ") " <definition>
14082 Spaces may appear only where explicitly indicated, and in the
14085 The Dwarf 2 spec says that an object-like macro's name is always
14086 followed by a space, but versions of GCC around March 2002 omit
14087 the space when the macro's definition is the empty string.
14089 The Dwarf 2 spec says that there should be no spaces between the
14090 formal arguments in a function-like macro's formal argument list,
14091 but versions of GCC around March 2002 include spaces after the
14095 /* Find the extent of the macro name. The macro name is terminated
14096 by either a space or null character (for an object-like macro) or
14097 an opening paren (for a function-like macro). */
14098 for (p
= body
; *p
; p
++)
14099 if (*p
== ' ' || *p
== '(')
14102 if (*p
== ' ' || *p
== '\0')
14104 /* It's an object-like macro. */
14105 int name_len
= p
- body
;
14106 char *name
= copy_string (body
, name_len
);
14107 const char *replacement
;
14110 replacement
= body
+ name_len
+ 1;
14113 dwarf2_macro_malformed_definition_complaint (body
);
14114 replacement
= body
+ name_len
;
14117 macro_define_object (file
, line
, name
, replacement
);
14121 else if (*p
== '(')
14123 /* It's a function-like macro. */
14124 char *name
= copy_string (body
, p
- body
);
14127 char **argv
= xmalloc (argv_size
* sizeof (*argv
));
14131 p
= consume_improper_spaces (p
, body
);
14133 /* Parse the formal argument list. */
14134 while (*p
&& *p
!= ')')
14136 /* Find the extent of the current argument name. */
14137 const char *arg_start
= p
;
14139 while (*p
&& *p
!= ',' && *p
!= ')' && *p
!= ' ')
14142 if (! *p
|| p
== arg_start
)
14143 dwarf2_macro_malformed_definition_complaint (body
);
14146 /* Make sure argv has room for the new argument. */
14147 if (argc
>= argv_size
)
14150 argv
= xrealloc (argv
, argv_size
* sizeof (*argv
));
14153 argv
[argc
++] = copy_string (arg_start
, p
- arg_start
);
14156 p
= consume_improper_spaces (p
, body
);
14158 /* Consume the comma, if present. */
14163 p
= consume_improper_spaces (p
, body
);
14172 /* Perfectly formed definition, no complaints. */
14173 macro_define_function (file
, line
, name
,
14174 argc
, (const char **) argv
,
14176 else if (*p
== '\0')
14178 /* Complain, but do define it. */
14179 dwarf2_macro_malformed_definition_complaint (body
);
14180 macro_define_function (file
, line
, name
,
14181 argc
, (const char **) argv
,
14185 /* Just complain. */
14186 dwarf2_macro_malformed_definition_complaint (body
);
14189 /* Just complain. */
14190 dwarf2_macro_malformed_definition_complaint (body
);
14196 for (i
= 0; i
< argc
; i
++)
14202 dwarf2_macro_malformed_definition_complaint (body
);
14207 dwarf_decode_macros (struct line_header
*lh
, unsigned int offset
,
14208 char *comp_dir
, bfd
*abfd
,
14209 struct dwarf2_cu
*cu
)
14211 gdb_byte
*mac_ptr
, *mac_end
;
14212 struct macro_source_file
*current_file
= 0;
14213 enum dwarf_macinfo_record_type macinfo_type
;
14214 int at_commandline
;
14216 dwarf2_read_section (dwarf2_per_objfile
->objfile
,
14217 &dwarf2_per_objfile
->macinfo
);
14218 if (dwarf2_per_objfile
->macinfo
.buffer
== NULL
)
14220 complaint (&symfile_complaints
, _("missing .debug_macinfo section"));
14224 /* First pass: Find the name of the base filename.
14225 This filename is needed in order to process all macros whose definition
14226 (or undefinition) comes from the command line. These macros are defined
14227 before the first DW_MACINFO_start_file entry, and yet still need to be
14228 associated to the base file.
14230 To determine the base file name, we scan the macro definitions until we
14231 reach the first DW_MACINFO_start_file entry. We then initialize
14232 CURRENT_FILE accordingly so that any macro definition found before the
14233 first DW_MACINFO_start_file can still be associated to the base file. */
14235 mac_ptr
= dwarf2_per_objfile
->macinfo
.buffer
+ offset
;
14236 mac_end
= dwarf2_per_objfile
->macinfo
.buffer
14237 + dwarf2_per_objfile
->macinfo
.size
;
14241 /* Do we at least have room for a macinfo type byte? */
14242 if (mac_ptr
>= mac_end
)
14244 /* Complaint is printed during the second pass as GDB will probably
14245 stop the first pass earlier upon finding
14246 DW_MACINFO_start_file. */
14250 macinfo_type
= read_1_byte (abfd
, mac_ptr
);
14253 switch (macinfo_type
)
14255 /* A zero macinfo type indicates the end of the macro
14260 case DW_MACINFO_define
:
14261 case DW_MACINFO_undef
:
14262 /* Only skip the data by MAC_PTR. */
14264 unsigned int bytes_read
;
14266 read_unsigned_leb128 (abfd
, mac_ptr
, &bytes_read
);
14267 mac_ptr
+= bytes_read
;
14268 read_direct_string (abfd
, mac_ptr
, &bytes_read
);
14269 mac_ptr
+= bytes_read
;
14273 case DW_MACINFO_start_file
:
14275 unsigned int bytes_read
;
14278 line
= read_unsigned_leb128 (abfd
, mac_ptr
, &bytes_read
);
14279 mac_ptr
+= bytes_read
;
14280 file
= read_unsigned_leb128 (abfd
, mac_ptr
, &bytes_read
);
14281 mac_ptr
+= bytes_read
;
14283 current_file
= macro_start_file (file
, line
, current_file
,
14284 comp_dir
, lh
, cu
->objfile
);
14288 case DW_MACINFO_end_file
:
14289 /* No data to skip by MAC_PTR. */
14292 case DW_MACINFO_vendor_ext
:
14293 /* Only skip the data by MAC_PTR. */
14295 unsigned int bytes_read
;
14297 read_unsigned_leb128 (abfd
, mac_ptr
, &bytes_read
);
14298 mac_ptr
+= bytes_read
;
14299 read_direct_string (abfd
, mac_ptr
, &bytes_read
);
14300 mac_ptr
+= bytes_read
;
14307 } while (macinfo_type
!= 0 && current_file
== NULL
);
14309 /* Second pass: Process all entries.
14311 Use the AT_COMMAND_LINE flag to determine whether we are still processing
14312 command-line macro definitions/undefinitions. This flag is unset when we
14313 reach the first DW_MACINFO_start_file entry. */
14315 mac_ptr
= dwarf2_per_objfile
->macinfo
.buffer
+ offset
;
14317 /* Determines if GDB is still before first DW_MACINFO_start_file. If true
14318 GDB is still reading the definitions from command line. First
14319 DW_MACINFO_start_file will need to be ignored as it was already executed
14320 to create CURRENT_FILE for the main source holding also the command line
14321 definitions. On first met DW_MACINFO_start_file this flag is reset to
14322 normally execute all the remaining DW_MACINFO_start_file macinfos. */
14324 at_commandline
= 1;
14328 /* Do we at least have room for a macinfo type byte? */
14329 if (mac_ptr
>= mac_end
)
14331 dwarf2_macros_too_long_complaint ();
14335 macinfo_type
= read_1_byte (abfd
, mac_ptr
);
14338 switch (macinfo_type
)
14340 /* A zero macinfo type indicates the end of the macro
14345 case DW_MACINFO_define
:
14346 case DW_MACINFO_undef
:
14348 unsigned int bytes_read
;
14352 line
= read_unsigned_leb128 (abfd
, mac_ptr
, &bytes_read
);
14353 mac_ptr
+= bytes_read
;
14354 body
= read_direct_string (abfd
, mac_ptr
, &bytes_read
);
14355 mac_ptr
+= bytes_read
;
14357 if (! current_file
)
14359 /* DWARF violation as no main source is present. */
14360 complaint (&symfile_complaints
,
14361 _("debug info with no main source gives macro %s "
14363 macinfo_type
== DW_MACINFO_define
?
14365 macinfo_type
== DW_MACINFO_undef
?
14366 _("undefinition") :
14367 _("something-or-other"), line
, body
);
14370 if ((line
== 0 && !at_commandline
)
14371 || (line
!= 0 && at_commandline
))
14372 complaint (&symfile_complaints
,
14373 _("debug info gives %s macro %s with %s line %d: %s"),
14374 at_commandline
? _("command-line") : _("in-file"),
14375 macinfo_type
== DW_MACINFO_define
?
14377 macinfo_type
== DW_MACINFO_undef
?
14378 _("undefinition") :
14379 _("something-or-other"),
14380 line
== 0 ? _("zero") : _("non-zero"), line
, body
);
14382 if (macinfo_type
== DW_MACINFO_define
)
14383 parse_macro_definition (current_file
, line
, body
);
14384 else if (macinfo_type
== DW_MACINFO_undef
)
14385 macro_undef (current_file
, line
, body
);
14389 case DW_MACINFO_start_file
:
14391 unsigned int bytes_read
;
14394 line
= read_unsigned_leb128 (abfd
, mac_ptr
, &bytes_read
);
14395 mac_ptr
+= bytes_read
;
14396 file
= read_unsigned_leb128 (abfd
, mac_ptr
, &bytes_read
);
14397 mac_ptr
+= bytes_read
;
14399 if ((line
== 0 && !at_commandline
)
14400 || (line
!= 0 && at_commandline
))
14401 complaint (&symfile_complaints
,
14402 _("debug info gives source %d included "
14403 "from %s at %s line %d"),
14404 file
, at_commandline
? _("command-line") : _("file"),
14405 line
== 0 ? _("zero") : _("non-zero"), line
);
14407 if (at_commandline
)
14409 /* This DW_MACINFO_start_file was executed in the pass one. */
14410 at_commandline
= 0;
14413 current_file
= macro_start_file (file
, line
,
14414 current_file
, comp_dir
,
14419 case DW_MACINFO_end_file
:
14420 if (! current_file
)
14421 complaint (&symfile_complaints
,
14422 _("macro debug info has an unmatched "
14423 "`close_file' directive"));
14426 current_file
= current_file
->included_by
;
14427 if (! current_file
)
14429 enum dwarf_macinfo_record_type next_type
;
14431 /* GCC circa March 2002 doesn't produce the zero
14432 type byte marking the end of the compilation
14433 unit. Complain if it's not there, but exit no
14436 /* Do we at least have room for a macinfo type byte? */
14437 if (mac_ptr
>= mac_end
)
14439 dwarf2_macros_too_long_complaint ();
14443 /* We don't increment mac_ptr here, so this is just
14445 next_type
= read_1_byte (abfd
, mac_ptr
);
14446 if (next_type
!= 0)
14447 complaint (&symfile_complaints
,
14448 _("no terminating 0-type entry for "
14449 "macros in `.debug_macinfo' section"));
14456 case DW_MACINFO_vendor_ext
:
14458 unsigned int bytes_read
;
14461 constant
= read_unsigned_leb128 (abfd
, mac_ptr
, &bytes_read
);
14462 mac_ptr
+= bytes_read
;
14463 read_direct_string (abfd
, mac_ptr
, &bytes_read
);
14464 mac_ptr
+= bytes_read
;
14466 /* We don't recognize any vendor extensions. */
14470 } while (macinfo_type
!= 0);
14473 /* Check if the attribute's form is a DW_FORM_block*
14474 if so return true else false. */
14476 attr_form_is_block (struct attribute
*attr
)
14478 return (attr
== NULL
? 0 :
14479 attr
->form
== DW_FORM_block1
14480 || attr
->form
== DW_FORM_block2
14481 || attr
->form
== DW_FORM_block4
14482 || attr
->form
== DW_FORM_block
14483 || attr
->form
== DW_FORM_exprloc
);
14486 /* Return non-zero if ATTR's value is a section offset --- classes
14487 lineptr, loclistptr, macptr or rangelistptr --- or zero, otherwise.
14488 You may use DW_UNSND (attr) to retrieve such offsets.
14490 Section 7.5.4, "Attribute Encodings", explains that no attribute
14491 may have a value that belongs to more than one of these classes; it
14492 would be ambiguous if we did, because we use the same forms for all
14495 attr_form_is_section_offset (struct attribute
*attr
)
14497 return (attr
->form
== DW_FORM_data4
14498 || attr
->form
== DW_FORM_data8
14499 || attr
->form
== DW_FORM_sec_offset
);
14503 /* Return non-zero if ATTR's value falls in the 'constant' class, or
14504 zero otherwise. When this function returns true, you can apply
14505 dwarf2_get_attr_constant_value to it.
14507 However, note that for some attributes you must check
14508 attr_form_is_section_offset before using this test. DW_FORM_data4
14509 and DW_FORM_data8 are members of both the constant class, and of
14510 the classes that contain offsets into other debug sections
14511 (lineptr, loclistptr, macptr or rangelistptr). The DWARF spec says
14512 that, if an attribute's can be either a constant or one of the
14513 section offset classes, DW_FORM_data4 and DW_FORM_data8 should be
14514 taken as section offsets, not constants. */
14516 attr_form_is_constant (struct attribute
*attr
)
14518 switch (attr
->form
)
14520 case DW_FORM_sdata
:
14521 case DW_FORM_udata
:
14522 case DW_FORM_data1
:
14523 case DW_FORM_data2
:
14524 case DW_FORM_data4
:
14525 case DW_FORM_data8
:
14532 /* A helper function that fills in a dwarf2_loclist_baton. */
14535 fill_in_loclist_baton (struct dwarf2_cu
*cu
,
14536 struct dwarf2_loclist_baton
*baton
,
14537 struct attribute
*attr
)
14539 dwarf2_read_section (dwarf2_per_objfile
->objfile
,
14540 &dwarf2_per_objfile
->loc
);
14542 baton
->per_cu
= cu
->per_cu
;
14543 gdb_assert (baton
->per_cu
);
14544 /* We don't know how long the location list is, but make sure we
14545 don't run off the edge of the section. */
14546 baton
->size
= dwarf2_per_objfile
->loc
.size
- DW_UNSND (attr
);
14547 baton
->data
= dwarf2_per_objfile
->loc
.buffer
+ DW_UNSND (attr
);
14548 baton
->base_address
= cu
->base_address
;
14552 dwarf2_symbol_mark_computed (struct attribute
*attr
, struct symbol
*sym
,
14553 struct dwarf2_cu
*cu
)
14555 if (attr_form_is_section_offset (attr
)
14556 /* ".debug_loc" may not exist at all, or the offset may be outside
14557 the section. If so, fall through to the complaint in the
14559 && DW_UNSND (attr
) < dwarf2_section_size (dwarf2_per_objfile
->objfile
,
14560 &dwarf2_per_objfile
->loc
))
14562 struct dwarf2_loclist_baton
*baton
;
14564 baton
= obstack_alloc (&cu
->objfile
->objfile_obstack
,
14565 sizeof (struct dwarf2_loclist_baton
));
14567 fill_in_loclist_baton (cu
, baton
, attr
);
14569 if (cu
->base_known
== 0)
14570 complaint (&symfile_complaints
,
14571 _("Location list used without "
14572 "specifying the CU base address."));
14574 SYMBOL_COMPUTED_OPS (sym
) = &dwarf2_loclist_funcs
;
14575 SYMBOL_LOCATION_BATON (sym
) = baton
;
14579 struct dwarf2_locexpr_baton
*baton
;
14581 baton
= obstack_alloc (&cu
->objfile
->objfile_obstack
,
14582 sizeof (struct dwarf2_locexpr_baton
));
14583 baton
->per_cu
= cu
->per_cu
;
14584 gdb_assert (baton
->per_cu
);
14586 if (attr_form_is_block (attr
))
14588 /* Note that we're just copying the block's data pointer
14589 here, not the actual data. We're still pointing into the
14590 info_buffer for SYM's objfile; right now we never release
14591 that buffer, but when we do clean up properly this may
14593 baton
->size
= DW_BLOCK (attr
)->size
;
14594 baton
->data
= DW_BLOCK (attr
)->data
;
14598 dwarf2_invalid_attrib_class_complaint ("location description",
14599 SYMBOL_NATURAL_NAME (sym
));
14601 baton
->data
= NULL
;
14604 SYMBOL_COMPUTED_OPS (sym
) = &dwarf2_locexpr_funcs
;
14605 SYMBOL_LOCATION_BATON (sym
) = baton
;
14609 /* Return the OBJFILE associated with the compilation unit CU. If CU
14610 came from a separate debuginfo file, then the master objfile is
14614 dwarf2_per_cu_objfile (struct dwarf2_per_cu_data
*per_cu
)
14616 struct objfile
*objfile
= per_cu
->objfile
;
14618 /* Return the master objfile, so that we can report and look up the
14619 correct file containing this variable. */
14620 if (objfile
->separate_debug_objfile_backlink
)
14621 objfile
= objfile
->separate_debug_objfile_backlink
;
14626 /* Return the address size given in the compilation unit header for CU. */
14629 dwarf2_per_cu_addr_size (struct dwarf2_per_cu_data
*per_cu
)
14632 return per_cu
->cu
->header
.addr_size
;
14635 /* If the CU is not currently read in, we re-read its header. */
14636 struct objfile
*objfile
= per_cu
->objfile
;
14637 struct dwarf2_per_objfile
*per_objfile
14638 = objfile_data (objfile
, dwarf2_objfile_data_key
);
14639 gdb_byte
*info_ptr
= per_objfile
->info
.buffer
+ per_cu
->offset
;
14640 struct comp_unit_head cu_header
;
14642 memset (&cu_header
, 0, sizeof cu_header
);
14643 read_comp_unit_head (&cu_header
, info_ptr
, objfile
->obfd
);
14644 return cu_header
.addr_size
;
14648 /* Return the offset size given in the compilation unit header for CU. */
14651 dwarf2_per_cu_offset_size (struct dwarf2_per_cu_data
*per_cu
)
14654 return per_cu
->cu
->header
.offset_size
;
14657 /* If the CU is not currently read in, we re-read its header. */
14658 struct objfile
*objfile
= per_cu
->objfile
;
14659 struct dwarf2_per_objfile
*per_objfile
14660 = objfile_data (objfile
, dwarf2_objfile_data_key
);
14661 gdb_byte
*info_ptr
= per_objfile
->info
.buffer
+ per_cu
->offset
;
14662 struct comp_unit_head cu_header
;
14664 memset (&cu_header
, 0, sizeof cu_header
);
14665 read_comp_unit_head (&cu_header
, info_ptr
, objfile
->obfd
);
14666 return cu_header
.offset_size
;
14670 /* Return the text offset of the CU. The returned offset comes from
14671 this CU's objfile. If this objfile came from a separate debuginfo
14672 file, then the offset may be different from the corresponding
14673 offset in the parent objfile. */
14676 dwarf2_per_cu_text_offset (struct dwarf2_per_cu_data
*per_cu
)
14678 struct objfile
*objfile
= per_cu
->objfile
;
14680 return ANOFFSET (objfile
->section_offsets
, SECT_OFF_TEXT (objfile
));
14683 /* Locate the .debug_info compilation unit from CU's objfile which contains
14684 the DIE at OFFSET. Raises an error on failure. */
14686 static struct dwarf2_per_cu_data
*
14687 dwarf2_find_containing_comp_unit (unsigned int offset
,
14688 struct objfile
*objfile
)
14690 struct dwarf2_per_cu_data
*this_cu
;
14694 high
= dwarf2_per_objfile
->n_comp_units
- 1;
14697 int mid
= low
+ (high
- low
) / 2;
14699 if (dwarf2_per_objfile
->all_comp_units
[mid
]->offset
>= offset
)
14704 gdb_assert (low
== high
);
14705 if (dwarf2_per_objfile
->all_comp_units
[low
]->offset
> offset
)
14708 error (_("Dwarf Error: could not find partial DIE containing "
14709 "offset 0x%lx [in module %s]"),
14710 (long) offset
, bfd_get_filename (objfile
->obfd
));
14712 gdb_assert (dwarf2_per_objfile
->all_comp_units
[low
-1]->offset
<= offset
);
14713 return dwarf2_per_objfile
->all_comp_units
[low
-1];
14717 this_cu
= dwarf2_per_objfile
->all_comp_units
[low
];
14718 if (low
== dwarf2_per_objfile
->n_comp_units
- 1
14719 && offset
>= this_cu
->offset
+ this_cu
->length
)
14720 error (_("invalid dwarf2 offset %u"), offset
);
14721 gdb_assert (offset
< this_cu
->offset
+ this_cu
->length
);
14726 /* Locate the compilation unit from OBJFILE which is located at exactly
14727 OFFSET. Raises an error on failure. */
14729 static struct dwarf2_per_cu_data
*
14730 dwarf2_find_comp_unit (unsigned int offset
, struct objfile
*objfile
)
14732 struct dwarf2_per_cu_data
*this_cu
;
14734 this_cu
= dwarf2_find_containing_comp_unit (offset
, objfile
);
14735 if (this_cu
->offset
!= offset
)
14736 error (_("no compilation unit with offset %u."), offset
);
14740 /* Initialize dwarf2_cu CU for OBJFILE in a pre-allocated space. */
14743 init_one_comp_unit (struct dwarf2_cu
*cu
, struct objfile
*objfile
)
14745 memset (cu
, 0, sizeof (*cu
));
14746 cu
->objfile
= objfile
;
14747 obstack_init (&cu
->comp_unit_obstack
);
14750 /* Initialize basic fields of dwarf_cu CU according to DIE COMP_UNIT_DIE. */
14753 prepare_one_comp_unit (struct dwarf2_cu
*cu
, struct die_info
*comp_unit_die
)
14755 struct attribute
*attr
;
14757 /* Set the language we're debugging. */
14758 attr
= dwarf2_attr (comp_unit_die
, DW_AT_language
, cu
);
14760 set_cu_language (DW_UNSND (attr
), cu
);
14763 cu
->language
= language_minimal
;
14764 cu
->language_defn
= language_def (cu
->language
);
14768 /* Release one cached compilation unit, CU. We unlink it from the tree
14769 of compilation units, but we don't remove it from the read_in_chain;
14770 the caller is responsible for that.
14771 NOTE: DATA is a void * because this function is also used as a
14772 cleanup routine. */
14775 free_one_comp_unit (void *data
)
14777 struct dwarf2_cu
*cu
= data
;
14779 if (cu
->per_cu
!= NULL
)
14780 cu
->per_cu
->cu
= NULL
;
14783 obstack_free (&cu
->comp_unit_obstack
, NULL
);
14788 /* This cleanup function is passed the address of a dwarf2_cu on the stack
14789 when we're finished with it. We can't free the pointer itself, but be
14790 sure to unlink it from the cache. Also release any associated storage
14791 and perform cache maintenance.
14793 Only used during partial symbol parsing. */
14796 free_stack_comp_unit (void *data
)
14798 struct dwarf2_cu
*cu
= data
;
14800 obstack_free (&cu
->comp_unit_obstack
, NULL
);
14801 cu
->partial_dies
= NULL
;
14803 if (cu
->per_cu
!= NULL
)
14805 /* This compilation unit is on the stack in our caller, so we
14806 should not xfree it. Just unlink it. */
14807 cu
->per_cu
->cu
= NULL
;
14810 /* If we had a per-cu pointer, then we may have other compilation
14811 units loaded, so age them now. */
14812 age_cached_comp_units ();
14816 /* Free all cached compilation units. */
14819 free_cached_comp_units (void *data
)
14821 struct dwarf2_per_cu_data
*per_cu
, **last_chain
;
14823 per_cu
= dwarf2_per_objfile
->read_in_chain
;
14824 last_chain
= &dwarf2_per_objfile
->read_in_chain
;
14825 while (per_cu
!= NULL
)
14827 struct dwarf2_per_cu_data
*next_cu
;
14829 next_cu
= per_cu
->cu
->read_in_chain
;
14831 free_one_comp_unit (per_cu
->cu
);
14832 *last_chain
= next_cu
;
14838 /* Increase the age counter on each cached compilation unit, and free
14839 any that are too old. */
14842 age_cached_comp_units (void)
14844 struct dwarf2_per_cu_data
*per_cu
, **last_chain
;
14846 dwarf2_clear_marks (dwarf2_per_objfile
->read_in_chain
);
14847 per_cu
= dwarf2_per_objfile
->read_in_chain
;
14848 while (per_cu
!= NULL
)
14850 per_cu
->cu
->last_used
++;
14851 if (per_cu
->cu
->last_used
<= dwarf2_max_cache_age
)
14852 dwarf2_mark (per_cu
->cu
);
14853 per_cu
= per_cu
->cu
->read_in_chain
;
14856 per_cu
= dwarf2_per_objfile
->read_in_chain
;
14857 last_chain
= &dwarf2_per_objfile
->read_in_chain
;
14858 while (per_cu
!= NULL
)
14860 struct dwarf2_per_cu_data
*next_cu
;
14862 next_cu
= per_cu
->cu
->read_in_chain
;
14864 if (!per_cu
->cu
->mark
)
14866 free_one_comp_unit (per_cu
->cu
);
14867 *last_chain
= next_cu
;
14870 last_chain
= &per_cu
->cu
->read_in_chain
;
14876 /* Remove a single compilation unit from the cache. */
14879 free_one_cached_comp_unit (void *target_cu
)
14881 struct dwarf2_per_cu_data
*per_cu
, **last_chain
;
14883 per_cu
= dwarf2_per_objfile
->read_in_chain
;
14884 last_chain
= &dwarf2_per_objfile
->read_in_chain
;
14885 while (per_cu
!= NULL
)
14887 struct dwarf2_per_cu_data
*next_cu
;
14889 next_cu
= per_cu
->cu
->read_in_chain
;
14891 if (per_cu
->cu
== target_cu
)
14893 free_one_comp_unit (per_cu
->cu
);
14894 *last_chain
= next_cu
;
14898 last_chain
= &per_cu
->cu
->read_in_chain
;
14904 /* Release all extra memory associated with OBJFILE. */
14907 dwarf2_free_objfile (struct objfile
*objfile
)
14909 dwarf2_per_objfile
= objfile_data (objfile
, dwarf2_objfile_data_key
);
14911 if (dwarf2_per_objfile
== NULL
)
14914 /* Cached DIE trees use xmalloc and the comp_unit_obstack. */
14915 free_cached_comp_units (NULL
);
14917 if (dwarf2_per_objfile
->quick_file_names_table
)
14918 htab_delete (dwarf2_per_objfile
->quick_file_names_table
);
14920 /* Everything else should be on the objfile obstack. */
14923 /* A pair of DIE offset and GDB type pointer. We store these
14924 in a hash table separate from the DIEs, and preserve them
14925 when the DIEs are flushed out of cache. */
14927 struct dwarf2_offset_and_type
14929 unsigned int offset
;
14933 /* Hash function for a dwarf2_offset_and_type. */
14936 offset_and_type_hash (const void *item
)
14938 const struct dwarf2_offset_and_type
*ofs
= item
;
14940 return ofs
->offset
;
14943 /* Equality function for a dwarf2_offset_and_type. */
14946 offset_and_type_eq (const void *item_lhs
, const void *item_rhs
)
14948 const struct dwarf2_offset_and_type
*ofs_lhs
= item_lhs
;
14949 const struct dwarf2_offset_and_type
*ofs_rhs
= item_rhs
;
14951 return ofs_lhs
->offset
== ofs_rhs
->offset
;
14954 /* Set the type associated with DIE to TYPE. Save it in CU's hash
14955 table if necessary. For convenience, return TYPE.
14957 The DIEs reading must have careful ordering to:
14958 * Not cause infite loops trying to read in DIEs as a prerequisite for
14959 reading current DIE.
14960 * Not trying to dereference contents of still incompletely read in types
14961 while reading in other DIEs.
14962 * Enable referencing still incompletely read in types just by a pointer to
14963 the type without accessing its fields.
14965 Therefore caller should follow these rules:
14966 * Try to fetch any prerequisite types we may need to build this DIE type
14967 before building the type and calling set_die_type.
14968 * After building type call set_die_type for current DIE as soon as
14969 possible before fetching more types to complete the current type.
14970 * Make the type as complete as possible before fetching more types. */
14972 static struct type
*
14973 set_die_type (struct die_info
*die
, struct type
*type
, struct dwarf2_cu
*cu
)
14975 struct dwarf2_offset_and_type
**slot
, ofs
;
14976 struct objfile
*objfile
= cu
->objfile
;
14977 htab_t
*type_hash_ptr
;
14979 /* For Ada types, make sure that the gnat-specific data is always
14980 initialized (if not already set). There are a few types where
14981 we should not be doing so, because the type-specific area is
14982 already used to hold some other piece of info (eg: TYPE_CODE_FLT
14983 where the type-specific area is used to store the floatformat).
14984 But this is not a problem, because the gnat-specific information
14985 is actually not needed for these types. */
14986 if (need_gnat_info (cu
)
14987 && TYPE_CODE (type
) != TYPE_CODE_FUNC
14988 && TYPE_CODE (type
) != TYPE_CODE_FLT
14989 && !HAVE_GNAT_AUX_INFO (type
))
14990 INIT_GNAT_SPECIFIC (type
);
14992 if (cu
->per_cu
->from_debug_types
)
14993 type_hash_ptr
= &dwarf2_per_objfile
->debug_types_type_hash
;
14995 type_hash_ptr
= &dwarf2_per_objfile
->debug_info_type_hash
;
14997 if (*type_hash_ptr
== NULL
)
15000 = htab_create_alloc_ex (127,
15001 offset_and_type_hash
,
15002 offset_and_type_eq
,
15004 &objfile
->objfile_obstack
,
15005 hashtab_obstack_allocate
,
15006 dummy_obstack_deallocate
);
15009 ofs
.offset
= die
->offset
;
15011 slot
= (struct dwarf2_offset_and_type
**)
15012 htab_find_slot_with_hash (*type_hash_ptr
, &ofs
, ofs
.offset
, INSERT
);
15014 complaint (&symfile_complaints
,
15015 _("A problem internal to GDB: DIE 0x%x has type already set"),
15017 *slot
= obstack_alloc (&objfile
->objfile_obstack
, sizeof (**slot
));
15022 /* Look up the type for the die at DIE_OFFSET in the appropriate type_hash
15023 table, or return NULL if the die does not have a saved type. */
15025 static struct type
*
15026 get_die_type_at_offset (unsigned int offset
,
15027 struct dwarf2_per_cu_data
*per_cu
)
15029 struct dwarf2_offset_and_type
*slot
, ofs
;
15032 if (per_cu
->from_debug_types
)
15033 type_hash
= dwarf2_per_objfile
->debug_types_type_hash
;
15035 type_hash
= dwarf2_per_objfile
->debug_info_type_hash
;
15036 if (type_hash
== NULL
)
15039 ofs
.offset
= offset
;
15040 slot
= htab_find_with_hash (type_hash
, &ofs
, ofs
.offset
);
15047 /* Look up the type for DIE in the appropriate type_hash table,
15048 or return NULL if DIE does not have a saved type. */
15050 static struct type
*
15051 get_die_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
15053 return get_die_type_at_offset (die
->offset
, cu
->per_cu
);
15056 /* Add a dependence relationship from CU to REF_PER_CU. */
15059 dwarf2_add_dependence (struct dwarf2_cu
*cu
,
15060 struct dwarf2_per_cu_data
*ref_per_cu
)
15064 if (cu
->dependencies
== NULL
)
15066 = htab_create_alloc_ex (5, htab_hash_pointer
, htab_eq_pointer
,
15067 NULL
, &cu
->comp_unit_obstack
,
15068 hashtab_obstack_allocate
,
15069 dummy_obstack_deallocate
);
15071 slot
= htab_find_slot (cu
->dependencies
, ref_per_cu
, INSERT
);
15073 *slot
= ref_per_cu
;
15076 /* Subroutine of dwarf2_mark to pass to htab_traverse.
15077 Set the mark field in every compilation unit in the
15078 cache that we must keep because we are keeping CU. */
15081 dwarf2_mark_helper (void **slot
, void *data
)
15083 struct dwarf2_per_cu_data
*per_cu
;
15085 per_cu
= (struct dwarf2_per_cu_data
*) *slot
;
15086 if (per_cu
->cu
->mark
)
15088 per_cu
->cu
->mark
= 1;
15090 if (per_cu
->cu
->dependencies
!= NULL
)
15091 htab_traverse (per_cu
->cu
->dependencies
, dwarf2_mark_helper
, NULL
);
15096 /* Set the mark field in CU and in every other compilation unit in the
15097 cache that we must keep because we are keeping CU. */
15100 dwarf2_mark (struct dwarf2_cu
*cu
)
15105 if (cu
->dependencies
!= NULL
)
15106 htab_traverse (cu
->dependencies
, dwarf2_mark_helper
, NULL
);
15110 dwarf2_clear_marks (struct dwarf2_per_cu_data
*per_cu
)
15114 per_cu
->cu
->mark
= 0;
15115 per_cu
= per_cu
->cu
->read_in_chain
;
15119 /* Trivial hash function for partial_die_info: the hash value of a DIE
15120 is its offset in .debug_info for this objfile. */
15123 partial_die_hash (const void *item
)
15125 const struct partial_die_info
*part_die
= item
;
15127 return part_die
->offset
;
15130 /* Trivial comparison function for partial_die_info structures: two DIEs
15131 are equal if they have the same offset. */
15134 partial_die_eq (const void *item_lhs
, const void *item_rhs
)
15136 const struct partial_die_info
*part_die_lhs
= item_lhs
;
15137 const struct partial_die_info
*part_die_rhs
= item_rhs
;
15139 return part_die_lhs
->offset
== part_die_rhs
->offset
;
15142 static struct cmd_list_element
*set_dwarf2_cmdlist
;
15143 static struct cmd_list_element
*show_dwarf2_cmdlist
;
15146 set_dwarf2_cmd (char *args
, int from_tty
)
15148 help_list (set_dwarf2_cmdlist
, "maintenance set dwarf2 ", -1, gdb_stdout
);
15152 show_dwarf2_cmd (char *args
, int from_tty
)
15154 cmd_show_list (show_dwarf2_cmdlist
, from_tty
, "");
15157 /* If section described by INFO was mmapped, munmap it now. */
15160 munmap_section_buffer (struct dwarf2_section_info
*info
)
15162 if (info
->was_mmapped
)
15165 intptr_t begin
= (intptr_t) info
->buffer
;
15166 intptr_t map_begin
= begin
& ~(pagesize
- 1);
15167 size_t map_length
= info
->size
+ begin
- map_begin
;
15169 gdb_assert (munmap ((void *) map_begin
, map_length
) == 0);
15171 /* Without HAVE_MMAP, we should never be here to begin with. */
15172 gdb_assert_not_reached ("no mmap support");
15177 /* munmap debug sections for OBJFILE, if necessary. */
15180 dwarf2_per_objfile_free (struct objfile
*objfile
, void *d
)
15182 struct dwarf2_per_objfile
*data
= d
;
15184 /* This is sorted according to the order they're defined in to make it easier
15185 to keep in sync. */
15186 munmap_section_buffer (&data
->info
);
15187 munmap_section_buffer (&data
->abbrev
);
15188 munmap_section_buffer (&data
->line
);
15189 munmap_section_buffer (&data
->loc
);
15190 munmap_section_buffer (&data
->macinfo
);
15191 munmap_section_buffer (&data
->str
);
15192 munmap_section_buffer (&data
->ranges
);
15193 munmap_section_buffer (&data
->types
);
15194 munmap_section_buffer (&data
->frame
);
15195 munmap_section_buffer (&data
->eh_frame
);
15196 munmap_section_buffer (&data
->gdb_index
);
15200 /* The "save gdb-index" command. */
15202 /* The contents of the hash table we create when building the string
15204 struct strtab_entry
15206 offset_type offset
;
15210 /* Hash function for a strtab_entry. */
15213 hash_strtab_entry (const void *e
)
15215 const struct strtab_entry
*entry
= e
;
15216 return mapped_index_string_hash (entry
->str
);
15219 /* Equality function for a strtab_entry. */
15222 eq_strtab_entry (const void *a
, const void *b
)
15224 const struct strtab_entry
*ea
= a
;
15225 const struct strtab_entry
*eb
= b
;
15226 return !strcmp (ea
->str
, eb
->str
);
15229 /* Create a strtab_entry hash table. */
15232 create_strtab (void)
15234 return htab_create_alloc (100, hash_strtab_entry
, eq_strtab_entry
,
15235 xfree
, xcalloc
, xfree
);
15238 /* Add a string to the constant pool. Return the string's offset in
15242 add_string (htab_t table
, struct obstack
*cpool
, const char *str
)
15245 struct strtab_entry entry
;
15246 struct strtab_entry
*result
;
15249 slot
= htab_find_slot (table
, &entry
, INSERT
);
15254 result
= XNEW (struct strtab_entry
);
15255 result
->offset
= obstack_object_size (cpool
);
15257 obstack_grow_str0 (cpool
, str
);
15260 return result
->offset
;
15263 /* An entry in the symbol table. */
15264 struct symtab_index_entry
15266 /* The name of the symbol. */
15268 /* The offset of the name in the constant pool. */
15269 offset_type index_offset
;
15270 /* A sorted vector of the indices of all the CUs that hold an object
15272 VEC (offset_type
) *cu_indices
;
15275 /* The symbol table. This is a power-of-2-sized hash table. */
15276 struct mapped_symtab
15278 offset_type n_elements
;
15280 struct symtab_index_entry
**data
;
15283 /* Hash function for a symtab_index_entry. */
15286 hash_symtab_entry (const void *e
)
15288 const struct symtab_index_entry
*entry
= e
;
15289 return iterative_hash (VEC_address (offset_type
, entry
->cu_indices
),
15290 sizeof (offset_type
) * VEC_length (offset_type
,
15291 entry
->cu_indices
),
15295 /* Equality function for a symtab_index_entry. */
15298 eq_symtab_entry (const void *a
, const void *b
)
15300 const struct symtab_index_entry
*ea
= a
;
15301 const struct symtab_index_entry
*eb
= b
;
15302 int len
= VEC_length (offset_type
, ea
->cu_indices
);
15303 if (len
!= VEC_length (offset_type
, eb
->cu_indices
))
15305 return !memcmp (VEC_address (offset_type
, ea
->cu_indices
),
15306 VEC_address (offset_type
, eb
->cu_indices
),
15307 sizeof (offset_type
) * len
);
15310 /* Destroy a symtab_index_entry. */
15313 delete_symtab_entry (void *p
)
15315 struct symtab_index_entry
*entry
= p
;
15316 VEC_free (offset_type
, entry
->cu_indices
);
15320 /* Create a hash table holding symtab_index_entry objects. */
15323 create_symbol_hash_table (void)
15325 return htab_create_alloc (100, hash_symtab_entry
, eq_symtab_entry
,
15326 delete_symtab_entry
, xcalloc
, xfree
);
15329 /* Create a new mapped symtab object. */
15331 static struct mapped_symtab
*
15332 create_mapped_symtab (void)
15334 struct mapped_symtab
*symtab
= XNEW (struct mapped_symtab
);
15335 symtab
->n_elements
= 0;
15336 symtab
->size
= 1024;
15337 symtab
->data
= XCNEWVEC (struct symtab_index_entry
*, symtab
->size
);
15341 /* Destroy a mapped_symtab. */
15344 cleanup_mapped_symtab (void *p
)
15346 struct mapped_symtab
*symtab
= p
;
15347 /* The contents of the array are freed when the other hash table is
15349 xfree (symtab
->data
);
15353 /* Find a slot in SYMTAB for the symbol NAME. Returns a pointer to
15356 static struct symtab_index_entry
**
15357 find_slot (struct mapped_symtab
*symtab
, const char *name
)
15359 offset_type index
, step
, hash
= mapped_index_string_hash (name
);
15361 index
= hash
& (symtab
->size
- 1);
15362 step
= ((hash
* 17) & (symtab
->size
- 1)) | 1;
15366 if (!symtab
->data
[index
] || !strcmp (name
, symtab
->data
[index
]->name
))
15367 return &symtab
->data
[index
];
15368 index
= (index
+ step
) & (symtab
->size
- 1);
15372 /* Expand SYMTAB's hash table. */
15375 hash_expand (struct mapped_symtab
*symtab
)
15377 offset_type old_size
= symtab
->size
;
15379 struct symtab_index_entry
**old_entries
= symtab
->data
;
15382 symtab
->data
= XCNEWVEC (struct symtab_index_entry
*, symtab
->size
);
15384 for (i
= 0; i
< old_size
; ++i
)
15386 if (old_entries
[i
])
15388 struct symtab_index_entry
**slot
= find_slot (symtab
,
15389 old_entries
[i
]->name
);
15390 *slot
= old_entries
[i
];
15394 xfree (old_entries
);
15397 /* Add an entry to SYMTAB. NAME is the name of the symbol. CU_INDEX
15398 is the index of the CU in which the symbol appears. */
15401 add_index_entry (struct mapped_symtab
*symtab
, const char *name
,
15402 offset_type cu_index
)
15404 struct symtab_index_entry
**slot
;
15406 ++symtab
->n_elements
;
15407 if (4 * symtab
->n_elements
/ 3 >= symtab
->size
)
15408 hash_expand (symtab
);
15410 slot
= find_slot (symtab
, name
);
15413 *slot
= XNEW (struct symtab_index_entry
);
15414 (*slot
)->name
= name
;
15415 (*slot
)->cu_indices
= NULL
;
15417 /* Don't push an index twice. Due to how we add entries we only
15418 have to check the last one. */
15419 if (VEC_empty (offset_type
, (*slot
)->cu_indices
)
15420 || VEC_length (offset_type
, (*slot
)->cu_indices
) != cu_index
)
15421 VEC_safe_push (offset_type
, (*slot
)->cu_indices
, cu_index
);
15424 /* Add a vector of indices to the constant pool. */
15427 add_indices_to_cpool (htab_t symbol_hash_table
, struct obstack
*cpool
,
15428 struct symtab_index_entry
*entry
)
15432 slot
= htab_find_slot (symbol_hash_table
, entry
, INSERT
);
15435 offset_type len
= VEC_length (offset_type
, entry
->cu_indices
);
15436 offset_type val
= MAYBE_SWAP (len
);
15441 entry
->index_offset
= obstack_object_size (cpool
);
15443 obstack_grow (cpool
, &val
, sizeof (val
));
15445 VEC_iterate (offset_type
, entry
->cu_indices
, i
, iter
);
15448 val
= MAYBE_SWAP (iter
);
15449 obstack_grow (cpool
, &val
, sizeof (val
));
15454 struct symtab_index_entry
*old_entry
= *slot
;
15455 entry
->index_offset
= old_entry
->index_offset
;
15458 return entry
->index_offset
;
15461 /* Write the mapped hash table SYMTAB to the obstack OUTPUT, with
15462 constant pool entries going into the obstack CPOOL. */
15465 write_hash_table (struct mapped_symtab
*symtab
,
15466 struct obstack
*output
, struct obstack
*cpool
)
15469 htab_t symbol_hash_table
;
15472 symbol_hash_table
= create_symbol_hash_table ();
15473 str_table
= create_strtab ();
15475 /* We add all the index vectors to the constant pool first, to
15476 ensure alignment is ok. */
15477 for (i
= 0; i
< symtab
->size
; ++i
)
15479 if (symtab
->data
[i
])
15480 add_indices_to_cpool (symbol_hash_table
, cpool
, symtab
->data
[i
]);
15483 /* Now write out the hash table. */
15484 for (i
= 0; i
< symtab
->size
; ++i
)
15486 offset_type str_off
, vec_off
;
15488 if (symtab
->data
[i
])
15490 str_off
= add_string (str_table
, cpool
, symtab
->data
[i
]->name
);
15491 vec_off
= symtab
->data
[i
]->index_offset
;
15495 /* While 0 is a valid constant pool index, it is not valid
15496 to have 0 for both offsets. */
15501 str_off
= MAYBE_SWAP (str_off
);
15502 vec_off
= MAYBE_SWAP (vec_off
);
15504 obstack_grow (output
, &str_off
, sizeof (str_off
));
15505 obstack_grow (output
, &vec_off
, sizeof (vec_off
));
15508 htab_delete (str_table
);
15509 htab_delete (symbol_hash_table
);
15512 /* Struct to map psymtab to CU index in the index file. */
15513 struct psymtab_cu_index_map
15515 struct partial_symtab
*psymtab
;
15516 unsigned int cu_index
;
15520 hash_psymtab_cu_index (const void *item
)
15522 const struct psymtab_cu_index_map
*map
= item
;
15524 return htab_hash_pointer (map
->psymtab
);
15528 eq_psymtab_cu_index (const void *item_lhs
, const void *item_rhs
)
15530 const struct psymtab_cu_index_map
*lhs
= item_lhs
;
15531 const struct psymtab_cu_index_map
*rhs
= item_rhs
;
15533 return lhs
->psymtab
== rhs
->psymtab
;
15536 /* Helper struct for building the address table. */
15537 struct addrmap_index_data
15539 struct objfile
*objfile
;
15540 struct obstack
*addr_obstack
;
15541 htab_t cu_index_htab
;
15543 /* Non-zero if the previous_* fields are valid.
15544 We can't write an entry until we see the next entry (since it is only then
15545 that we know the end of the entry). */
15546 int previous_valid
;
15547 /* Index of the CU in the table of all CUs in the index file. */
15548 unsigned int previous_cu_index
;
15549 /* Start address of the CU. */
15550 CORE_ADDR previous_cu_start
;
15553 /* Write an address entry to OBSTACK. */
15556 add_address_entry (struct objfile
*objfile
, struct obstack
*obstack
,
15557 CORE_ADDR start
, CORE_ADDR end
, unsigned int cu_index
)
15559 offset_type cu_index_to_write
;
15561 CORE_ADDR baseaddr
;
15563 baseaddr
= ANOFFSET (objfile
->section_offsets
, SECT_OFF_TEXT (objfile
));
15565 store_unsigned_integer (addr
, 8, BFD_ENDIAN_LITTLE
, start
- baseaddr
);
15566 obstack_grow (obstack
, addr
, 8);
15567 store_unsigned_integer (addr
, 8, BFD_ENDIAN_LITTLE
, end
- baseaddr
);
15568 obstack_grow (obstack
, addr
, 8);
15569 cu_index_to_write
= MAYBE_SWAP (cu_index
);
15570 obstack_grow (obstack
, &cu_index_to_write
, sizeof (offset_type
));
15573 /* Worker function for traversing an addrmap to build the address table. */
15576 add_address_entry_worker (void *datap
, CORE_ADDR start_addr
, void *obj
)
15578 struct addrmap_index_data
*data
= datap
;
15579 struct partial_symtab
*pst
= obj
;
15580 offset_type cu_index
;
15583 if (data
->previous_valid
)
15584 add_address_entry (data
->objfile
, data
->addr_obstack
,
15585 data
->previous_cu_start
, start_addr
,
15586 data
->previous_cu_index
);
15588 data
->previous_cu_start
= start_addr
;
15591 struct psymtab_cu_index_map find_map
, *map
;
15592 find_map
.psymtab
= pst
;
15593 map
= htab_find (data
->cu_index_htab
, &find_map
);
15594 gdb_assert (map
!= NULL
);
15595 data
->previous_cu_index
= map
->cu_index
;
15596 data
->previous_valid
= 1;
15599 data
->previous_valid
= 0;
15604 /* Write OBJFILE's address map to OBSTACK.
15605 CU_INDEX_HTAB is used to map addrmap entries to their CU indices
15606 in the index file. */
15609 write_address_map (struct objfile
*objfile
, struct obstack
*obstack
,
15610 htab_t cu_index_htab
)
15612 struct addrmap_index_data addrmap_index_data
;
15614 /* When writing the address table, we have to cope with the fact that
15615 the addrmap iterator only provides the start of a region; we have to
15616 wait until the next invocation to get the start of the next region. */
15618 addrmap_index_data
.objfile
= objfile
;
15619 addrmap_index_data
.addr_obstack
= obstack
;
15620 addrmap_index_data
.cu_index_htab
= cu_index_htab
;
15621 addrmap_index_data
.previous_valid
= 0;
15623 addrmap_foreach (objfile
->psymtabs_addrmap
, add_address_entry_worker
,
15624 &addrmap_index_data
);
15626 /* It's highly unlikely the last entry (end address = 0xff...ff)
15627 is valid, but we should still handle it.
15628 The end address is recorded as the start of the next region, but that
15629 doesn't work here. To cope we pass 0xff...ff, this is a rare situation
15631 if (addrmap_index_data
.previous_valid
)
15632 add_address_entry (objfile
, obstack
,
15633 addrmap_index_data
.previous_cu_start
, (CORE_ADDR
) -1,
15634 addrmap_index_data
.previous_cu_index
);
15637 /* Add a list of partial symbols to SYMTAB. */
15640 write_psymbols (struct mapped_symtab
*symtab
,
15642 struct partial_symbol
**psymp
,
15644 offset_type cu_index
,
15647 for (; count
-- > 0; ++psymp
)
15649 void **slot
, *lookup
;
15651 if (SYMBOL_LANGUAGE (*psymp
) == language_ada
)
15652 error (_("Ada is not currently supported by the index"));
15654 /* We only want to add a given psymbol once. However, we also
15655 want to account for whether it is global or static. So, we
15656 may add it twice, using slightly different values. */
15659 uintptr_t val
= 1 | (uintptr_t) *psymp
;
15661 lookup
= (void *) val
;
15666 /* Only add a given psymbol once. */
15667 slot
= htab_find_slot (psyms_seen
, lookup
, INSERT
);
15671 add_index_entry (symtab
, SYMBOL_NATURAL_NAME (*psymp
), cu_index
);
15676 /* Write the contents of an ("unfinished") obstack to FILE. Throw an
15677 exception if there is an error. */
15680 write_obstack (FILE *file
, struct obstack
*obstack
)
15682 if (fwrite (obstack_base (obstack
), 1, obstack_object_size (obstack
),
15684 != obstack_object_size (obstack
))
15685 error (_("couldn't data write to file"));
15688 /* Unlink a file if the argument is not NULL. */
15691 unlink_if_set (void *p
)
15693 char **filename
= p
;
15695 unlink (*filename
);
15698 /* A helper struct used when iterating over debug_types. */
15699 struct signatured_type_index_data
15701 struct objfile
*objfile
;
15702 struct mapped_symtab
*symtab
;
15703 struct obstack
*types_list
;
15708 /* A helper function that writes a single signatured_type to an
15712 write_one_signatured_type (void **slot
, void *d
)
15714 struct signatured_type_index_data
*info
= d
;
15715 struct signatured_type
*entry
= (struct signatured_type
*) *slot
;
15716 struct dwarf2_per_cu_data
*per_cu
= &entry
->per_cu
;
15717 struct partial_symtab
*psymtab
= per_cu
->v
.psymtab
;
15720 write_psymbols (info
->symtab
,
15722 info
->objfile
->global_psymbols
.list
15723 + psymtab
->globals_offset
,
15724 psymtab
->n_global_syms
, info
->cu_index
,
15726 write_psymbols (info
->symtab
,
15728 info
->objfile
->static_psymbols
.list
15729 + psymtab
->statics_offset
,
15730 psymtab
->n_static_syms
, info
->cu_index
,
15733 store_unsigned_integer (val
, 8, BFD_ENDIAN_LITTLE
, entry
->offset
);
15734 obstack_grow (info
->types_list
, val
, 8);
15735 store_unsigned_integer (val
, 8, BFD_ENDIAN_LITTLE
, entry
->type_offset
);
15736 obstack_grow (info
->types_list
, val
, 8);
15737 store_unsigned_integer (val
, 8, BFD_ENDIAN_LITTLE
, entry
->signature
);
15738 obstack_grow (info
->types_list
, val
, 8);
15745 /* A cleanup function for an htab_t. */
15748 cleanup_htab (void *arg
)
15753 /* Create an index file for OBJFILE in the directory DIR. */
15756 write_psymtabs_to_index (struct objfile
*objfile
, const char *dir
)
15758 struct cleanup
*cleanup
;
15759 char *filename
, *cleanup_filename
;
15760 struct obstack contents
, addr_obstack
, constant_pool
, symtab_obstack
;
15761 struct obstack cu_list
, types_cu_list
;
15764 struct mapped_symtab
*symtab
;
15765 offset_type val
, size_of_contents
, total_len
;
15769 htab_t cu_index_htab
;
15770 struct psymtab_cu_index_map
*psymtab_cu_index_map
;
15772 if (!objfile
->psymtabs
)
15774 if (dwarf2_per_objfile
->using_index
)
15775 error (_("Cannot use an index to create the index"));
15777 if (stat (objfile
->name
, &st
) < 0)
15778 perror_with_name (objfile
->name
);
15780 filename
= concat (dir
, SLASH_STRING
, lbasename (objfile
->name
),
15781 INDEX_SUFFIX
, (char *) NULL
);
15782 cleanup
= make_cleanup (xfree
, filename
);
15784 out_file
= fopen (filename
, "wb");
15786 error (_("Can't open `%s' for writing"), filename
);
15788 cleanup_filename
= filename
;
15789 make_cleanup (unlink_if_set
, &cleanup_filename
);
15791 symtab
= create_mapped_symtab ();
15792 make_cleanup (cleanup_mapped_symtab
, symtab
);
15794 obstack_init (&addr_obstack
);
15795 make_cleanup_obstack_free (&addr_obstack
);
15797 obstack_init (&cu_list
);
15798 make_cleanup_obstack_free (&cu_list
);
15800 obstack_init (&types_cu_list
);
15801 make_cleanup_obstack_free (&types_cu_list
);
15803 psyms_seen
= htab_create_alloc (100, htab_hash_pointer
, htab_eq_pointer
,
15804 NULL
, xcalloc
, xfree
);
15805 make_cleanup (cleanup_htab
, psyms_seen
);
15807 /* While we're scanning CU's create a table that maps a psymtab pointer
15808 (which is what addrmap records) to its index (which is what is recorded
15809 in the index file). This will later be needed to write the address
15811 cu_index_htab
= htab_create_alloc (100,
15812 hash_psymtab_cu_index
,
15813 eq_psymtab_cu_index
,
15814 NULL
, xcalloc
, xfree
);
15815 make_cleanup (cleanup_htab
, cu_index_htab
);
15816 psymtab_cu_index_map
= (struct psymtab_cu_index_map
*)
15817 xmalloc (sizeof (struct psymtab_cu_index_map
)
15818 * dwarf2_per_objfile
->n_comp_units
);
15819 make_cleanup (xfree
, psymtab_cu_index_map
);
15821 /* The CU list is already sorted, so we don't need to do additional
15822 work here. Also, the debug_types entries do not appear in
15823 all_comp_units, but only in their own hash table. */
15824 for (i
= 0; i
< dwarf2_per_objfile
->n_comp_units
; ++i
)
15826 struct dwarf2_per_cu_data
*per_cu
15827 = dwarf2_per_objfile
->all_comp_units
[i
];
15828 struct partial_symtab
*psymtab
= per_cu
->v
.psymtab
;
15830 struct psymtab_cu_index_map
*map
;
15833 write_psymbols (symtab
,
15835 objfile
->global_psymbols
.list
+ psymtab
->globals_offset
,
15836 psymtab
->n_global_syms
, i
,
15838 write_psymbols (symtab
,
15840 objfile
->static_psymbols
.list
+ psymtab
->statics_offset
,
15841 psymtab
->n_static_syms
, i
,
15844 map
= &psymtab_cu_index_map
[i
];
15845 map
->psymtab
= psymtab
;
15847 slot
= htab_find_slot (cu_index_htab
, map
, INSERT
);
15848 gdb_assert (slot
!= NULL
);
15849 gdb_assert (*slot
== NULL
);
15852 store_unsigned_integer (val
, 8, BFD_ENDIAN_LITTLE
, per_cu
->offset
);
15853 obstack_grow (&cu_list
, val
, 8);
15854 store_unsigned_integer (val
, 8, BFD_ENDIAN_LITTLE
, per_cu
->length
);
15855 obstack_grow (&cu_list
, val
, 8);
15858 /* Dump the address map. */
15859 write_address_map (objfile
, &addr_obstack
, cu_index_htab
);
15861 /* Write out the .debug_type entries, if any. */
15862 if (dwarf2_per_objfile
->signatured_types
)
15864 struct signatured_type_index_data sig_data
;
15866 sig_data
.objfile
= objfile
;
15867 sig_data
.symtab
= symtab
;
15868 sig_data
.types_list
= &types_cu_list
;
15869 sig_data
.psyms_seen
= psyms_seen
;
15870 sig_data
.cu_index
= dwarf2_per_objfile
->n_comp_units
;
15871 htab_traverse_noresize (dwarf2_per_objfile
->signatured_types
,
15872 write_one_signatured_type
, &sig_data
);
15875 obstack_init (&constant_pool
);
15876 make_cleanup_obstack_free (&constant_pool
);
15877 obstack_init (&symtab_obstack
);
15878 make_cleanup_obstack_free (&symtab_obstack
);
15879 write_hash_table (symtab
, &symtab_obstack
, &constant_pool
);
15881 obstack_init (&contents
);
15882 make_cleanup_obstack_free (&contents
);
15883 size_of_contents
= 6 * sizeof (offset_type
);
15884 total_len
= size_of_contents
;
15886 /* The version number. */
15887 val
= MAYBE_SWAP (4);
15888 obstack_grow (&contents
, &val
, sizeof (val
));
15890 /* The offset of the CU list from the start of the file. */
15891 val
= MAYBE_SWAP (total_len
);
15892 obstack_grow (&contents
, &val
, sizeof (val
));
15893 total_len
+= obstack_object_size (&cu_list
);
15895 /* The offset of the types CU list from the start of the file. */
15896 val
= MAYBE_SWAP (total_len
);
15897 obstack_grow (&contents
, &val
, sizeof (val
));
15898 total_len
+= obstack_object_size (&types_cu_list
);
15900 /* The offset of the address table from the start of the file. */
15901 val
= MAYBE_SWAP (total_len
);
15902 obstack_grow (&contents
, &val
, sizeof (val
));
15903 total_len
+= obstack_object_size (&addr_obstack
);
15905 /* The offset of the symbol table from the start of the file. */
15906 val
= MAYBE_SWAP (total_len
);
15907 obstack_grow (&contents
, &val
, sizeof (val
));
15908 total_len
+= obstack_object_size (&symtab_obstack
);
15910 /* The offset of the constant pool from the start of the file. */
15911 val
= MAYBE_SWAP (total_len
);
15912 obstack_grow (&contents
, &val
, sizeof (val
));
15913 total_len
+= obstack_object_size (&constant_pool
);
15915 gdb_assert (obstack_object_size (&contents
) == size_of_contents
);
15917 write_obstack (out_file
, &contents
);
15918 write_obstack (out_file
, &cu_list
);
15919 write_obstack (out_file
, &types_cu_list
);
15920 write_obstack (out_file
, &addr_obstack
);
15921 write_obstack (out_file
, &symtab_obstack
);
15922 write_obstack (out_file
, &constant_pool
);
15926 /* We want to keep the file, so we set cleanup_filename to NULL
15927 here. See unlink_if_set. */
15928 cleanup_filename
= NULL
;
15930 do_cleanups (cleanup
);
15933 /* The mapped index file format is designed to be directly mmap()able
15934 on any architecture. In most cases, a datum is represented using a
15935 little-endian 32-bit integer value, called an offset_type. Big
15936 endian machines must byte-swap the values before using them.
15937 Exceptions to this rule are noted. The data is laid out such that
15938 alignment is always respected.
15940 A mapped index consists of several sections.
15942 1. The file header. This is a sequence of values, of offset_type
15943 unless otherwise noted:
15945 [0] The version number, currently 4. Versions 1, 2 and 3 are
15947 [1] The offset, from the start of the file, of the CU list.
15948 [2] The offset, from the start of the file, of the types CU list.
15949 Note that this section can be empty, in which case this offset will
15950 be equal to the next offset.
15951 [3] The offset, from the start of the file, of the address section.
15952 [4] The offset, from the start of the file, of the symbol table.
15953 [5] The offset, from the start of the file, of the constant pool.
15955 2. The CU list. This is a sequence of pairs of 64-bit
15956 little-endian values, sorted by the CU offset. The first element
15957 in each pair is the offset of a CU in the .debug_info section. The
15958 second element in each pair is the length of that CU. References
15959 to a CU elsewhere in the map are done using a CU index, which is
15960 just the 0-based index into this table. Note that if there are
15961 type CUs, then conceptually CUs and type CUs form a single list for
15962 the purposes of CU indices.
15964 3. The types CU list. This is a sequence of triplets of 64-bit
15965 little-endian values. In a triplet, the first value is the CU
15966 offset, the second value is the type offset in the CU, and the
15967 third value is the type signature. The types CU list is not
15970 4. The address section. The address section consists of a sequence
15971 of address entries. Each address entry has three elements.
15972 [0] The low address. This is a 64-bit little-endian value.
15973 [1] The high address. This is a 64-bit little-endian value.
15974 Like DW_AT_high_pc, the value is one byte beyond the end.
15975 [2] The CU index. This is an offset_type value.
15977 5. The symbol table. This is a hash table. The size of the hash
15978 table is always a power of 2. The initial hash and the step are
15979 currently defined by the `find_slot' function.
15981 Each slot in the hash table consists of a pair of offset_type
15982 values. The first value is the offset of the symbol's name in the
15983 constant pool. The second value is the offset of the CU vector in
15986 If both values are 0, then this slot in the hash table is empty.
15987 This is ok because while 0 is a valid constant pool index, it
15988 cannot be a valid index for both a string and a CU vector.
15990 A string in the constant pool is stored as a \0-terminated string,
15993 A CU vector in the constant pool is a sequence of offset_type
15994 values. The first value is the number of CU indices in the vector.
15995 Each subsequent value is the index of a CU in the CU list. This
15996 element in the hash table is used to indicate which CUs define the
15999 6. The constant pool. This is simply a bunch of bytes. It is
16000 organized so that alignment is correct: CU vectors are stored
16001 first, followed by strings. */
16004 save_gdb_index_command (char *arg
, int from_tty
)
16006 struct objfile
*objfile
;
16009 error (_("usage: save gdb-index DIRECTORY"));
16011 ALL_OBJFILES (objfile
)
16015 /* If the objfile does not correspond to an actual file, skip it. */
16016 if (stat (objfile
->name
, &st
) < 0)
16019 dwarf2_per_objfile
= objfile_data (objfile
, dwarf2_objfile_data_key
);
16020 if (dwarf2_per_objfile
)
16022 volatile struct gdb_exception except
;
16024 TRY_CATCH (except
, RETURN_MASK_ERROR
)
16026 write_psymtabs_to_index (objfile
, arg
);
16028 if (except
.reason
< 0)
16029 exception_fprintf (gdb_stderr
, except
,
16030 _("Error while writing index for `%s': "),
16038 int dwarf2_always_disassemble
;
16041 show_dwarf2_always_disassemble (struct ui_file
*file
, int from_tty
,
16042 struct cmd_list_element
*c
, const char *value
)
16044 fprintf_filtered (file
,
16045 _("Whether to always disassemble "
16046 "DWARF expressions is %s.\n"),
16050 void _initialize_dwarf2_read (void);
16053 _initialize_dwarf2_read (void)
16055 struct cmd_list_element
*c
;
16057 dwarf2_objfile_data_key
16058 = register_objfile_data_with_cleanup (NULL
, dwarf2_per_objfile_free
);
16060 add_prefix_cmd ("dwarf2", class_maintenance
, set_dwarf2_cmd
, _("\
16061 Set DWARF 2 specific variables.\n\
16062 Configure DWARF 2 variables such as the cache size"),
16063 &set_dwarf2_cmdlist
, "maintenance set dwarf2 ",
16064 0/*allow-unknown*/, &maintenance_set_cmdlist
);
16066 add_prefix_cmd ("dwarf2", class_maintenance
, show_dwarf2_cmd
, _("\
16067 Show DWARF 2 specific variables\n\
16068 Show DWARF 2 variables such as the cache size"),
16069 &show_dwarf2_cmdlist
, "maintenance show dwarf2 ",
16070 0/*allow-unknown*/, &maintenance_show_cmdlist
);
16072 add_setshow_zinteger_cmd ("max-cache-age", class_obscure
,
16073 &dwarf2_max_cache_age
, _("\
16074 Set the upper bound on the age of cached dwarf2 compilation units."), _("\
16075 Show the upper bound on the age of cached dwarf2 compilation units."), _("\
16076 A higher limit means that cached compilation units will be stored\n\
16077 in memory longer, and more total memory will be used. Zero disables\n\
16078 caching, which can slow down startup."),
16080 show_dwarf2_max_cache_age
,
16081 &set_dwarf2_cmdlist
,
16082 &show_dwarf2_cmdlist
);
16084 add_setshow_boolean_cmd ("always-disassemble", class_obscure
,
16085 &dwarf2_always_disassemble
, _("\
16086 Set whether `info address' always disassembles DWARF expressions."), _("\
16087 Show whether `info address' always disassembles DWARF expressions."), _("\
16088 When enabled, DWARF expressions are always printed in an assembly-like\n\
16089 syntax. When disabled, expressions will be printed in a more\n\
16090 conversational style, when possible."),
16092 show_dwarf2_always_disassemble
,
16093 &set_dwarf2_cmdlist
,
16094 &show_dwarf2_cmdlist
);
16096 add_setshow_zinteger_cmd ("dwarf2-die", no_class
, &dwarf2_die_debug
, _("\
16097 Set debugging of the dwarf2 DIE reader."), _("\
16098 Show debugging of the dwarf2 DIE reader."), _("\
16099 When enabled (non-zero), DIEs are dumped after they are read in.\n\
16100 The value is the maximum depth to print."),
16103 &setdebuglist
, &showdebuglist
);
16105 c
= add_cmd ("gdb-index", class_files
, save_gdb_index_command
,
16107 Save a gdb-index file.\n\
16108 Usage: save gdb-index DIRECTORY"),
16110 set_cmd_completer (c
, filename_completer
);