1 /* DWARF 2 debugging format support for GDB.
3 Copyright (C) 1994-2012 Free Software Foundation, Inc.
5 Adapted by Gary Funck (gary@intrepid.com), Intrepid Technology,
6 Inc. with support from Florida State University (under contract
7 with the Ada Joint Program Office), and Silicon Graphics, Inc.
8 Initial contribution by Brent Benson, Harris Computer Systems, Inc.,
9 based on Fred Fish's (Cygnus Support) implementation of DWARF 1
12 This file is part of GDB.
14 This program is free software; you can redistribute it and/or modify
15 it under the terms of the GNU General Public License as published by
16 the Free Software Foundation; either version 3 of the License, or
17 (at your option) any later version.
19 This program is distributed in the hope that it will be useful,
20 but WITHOUT ANY WARRANTY; without even the implied warranty of
21 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
22 GNU General Public License for more details.
24 You should have received a copy of the GNU General Public License
25 along with this program. If not, see <http://www.gnu.org/licenses/>. */
27 /* FIXME: Various die-reading functions need to be more careful with
28 reading off the end of the section.
29 E.g., load_partial_dies, read_partial_die. */
39 #include "gdb-demangle.h"
40 #include "expression.h"
41 #include "filenames.h" /* for DOSish file names */
44 #include "complaints.h"
46 #include "dwarf2expr.h"
47 #include "dwarf2loc.h"
48 #include "cp-support.h"
54 #include "typeprint.h"
57 #include "exceptions.h"
59 #include "completer.h"
66 #include "gdb_string.h"
67 #include "gdb_assert.h"
68 #include <sys/types.h>
75 #define MAP_FAILED ((void *) -1)
79 typedef struct symbol *symbolp;
82 /* When non-zero, dump DIEs after they are read in. */
83 static int dwarf2_die_debug = 0;
85 /* When non-zero, cross-check physname against demangler. */
86 static int check_physname = 0;
90 /* When set, the file that we're processing is known to have debugging
91 info for C++ namespaces. GCC 3.3.x did not produce this information,
92 but later versions do. */
94 static int processing_has_namespace_info;
96 static const struct objfile_data *dwarf2_objfile_data_key;
98 struct dwarf2_section_info
103 /* Not NULL if the section was actually mmapped. */
105 /* Page aligned size of mmapped area. */
106 bfd_size_type map_len;
107 /* True if we have tried to read this section. */
111 typedef struct dwarf2_section_info dwarf2_section_info_def;
112 DEF_VEC_O (dwarf2_section_info_def);
114 /* All offsets in the index are of this type. It must be
115 architecture-independent. */
116 typedef uint32_t offset_type;
118 DEF_VEC_I (offset_type);
120 /* A description of the mapped index. The file format is described in
121 a comment by the code that writes the index. */
124 /* Index data format version. */
127 /* The total length of the buffer. */
130 /* A pointer to the address table data. */
131 const gdb_byte *address_table;
133 /* Size of the address table data in bytes. */
134 offset_type address_table_size;
136 /* The symbol table, implemented as a hash table. */
137 const offset_type *symbol_table;
139 /* Size in slots, each slot is 2 offset_types. */
140 offset_type symbol_table_slots;
142 /* A pointer to the constant pool. */
143 const char *constant_pool;
146 /* Collection of data recorded per objfile.
147 This hangs off of dwarf2_objfile_data_key. */
149 struct dwarf2_per_objfile
151 struct dwarf2_section_info info;
152 struct dwarf2_section_info abbrev;
153 struct dwarf2_section_info line;
154 struct dwarf2_section_info loc;
155 struct dwarf2_section_info macinfo;
156 struct dwarf2_section_info macro;
157 struct dwarf2_section_info str;
158 struct dwarf2_section_info ranges;
159 struct dwarf2_section_info frame;
160 struct dwarf2_section_info eh_frame;
161 struct dwarf2_section_info gdb_index;
163 VEC (dwarf2_section_info_def) *types;
166 struct objfile *objfile;
168 /* Table of all the compilation units. This is used to locate
169 the target compilation unit of a particular reference. */
170 struct dwarf2_per_cu_data **all_comp_units;
172 /* The number of compilation units in ALL_COMP_UNITS. */
175 /* The number of .debug_types-related CUs. */
178 /* The .debug_types-related CUs (TUs). */
179 struct dwarf2_per_cu_data **all_type_units;
181 /* A chain of compilation units that are currently read in, so that
182 they can be freed later. */
183 struct dwarf2_per_cu_data *read_in_chain;
185 /* A table mapping .debug_types signatures to its signatured_type entry.
186 This is NULL if the .debug_types section hasn't been read in yet. */
187 htab_t signatured_types;
189 /* A flag indicating wether this objfile has a section loaded at a
191 int has_section_at_zero;
193 /* True if we are using the mapped index,
194 or we are faking it for OBJF_READNOW's sake. */
195 unsigned char using_index;
197 /* The mapped index, or NULL if .gdb_index is missing or not being used. */
198 struct mapped_index *index_table;
200 /* When using index_table, this keeps track of all quick_file_names entries.
201 TUs can share line table entries with CUs or other TUs, and there can be
202 a lot more TUs than unique line tables, so we maintain a separate table
203 of all line table entries to support the sharing. */
204 htab_t quick_file_names_table;
206 /* Set during partial symbol reading, to prevent queueing of full
208 int reading_partial_symbols;
210 /* Table mapping type .debug_info DIE offsets to types.
211 This is NULL if not allocated yet.
212 It (currently) makes sense to allocate debug_types_type_hash lazily.
213 To keep things simple we allocate both lazily. */
214 htab_t debug_info_type_hash;
216 /* Table mapping type .debug_types DIE offsets to types.
217 This is NULL if not allocated yet. */
218 htab_t debug_types_type_hash;
221 static struct dwarf2_per_objfile *dwarf2_per_objfile;
223 /* Default names of the debugging sections. */
225 /* Note that if the debugging section has been compressed, it might
226 have a name like .zdebug_info. */
228 static const struct dwarf2_debug_sections dwarf2_elf_names =
230 { ".debug_info", ".zdebug_info" },
231 { ".debug_abbrev", ".zdebug_abbrev" },
232 { ".debug_line", ".zdebug_line" },
233 { ".debug_loc", ".zdebug_loc" },
234 { ".debug_macinfo", ".zdebug_macinfo" },
235 { ".debug_macro", ".zdebug_macro" },
236 { ".debug_str", ".zdebug_str" },
237 { ".debug_ranges", ".zdebug_ranges" },
238 { ".debug_types", ".zdebug_types" },
239 { ".debug_frame", ".zdebug_frame" },
240 { ".eh_frame", NULL },
241 { ".gdb_index", ".zgdb_index" },
245 /* local data types */
247 /* We hold several abbreviation tables in memory at the same time. */
248 #ifndef ABBREV_HASH_SIZE
249 #define ABBREV_HASH_SIZE 121
252 /* The data in a compilation unit header, after target2host
253 translation, looks like this. */
254 struct comp_unit_head
258 unsigned char addr_size;
259 unsigned char signed_addr_p;
260 unsigned int abbrev_offset;
262 /* Size of file offsets; either 4 or 8. */
263 unsigned int offset_size;
265 /* Size of the length field; either 4 or 12. */
266 unsigned int initial_length_size;
268 /* Offset to the first byte of this compilation unit header in the
269 .debug_info section, for resolving relative reference dies. */
272 /* Offset to first die in this cu from the start of the cu.
273 This will be the first byte following the compilation unit header. */
274 unsigned int first_die_offset;
277 /* Type used for delaying computation of method physnames.
278 See comments for compute_delayed_physnames. */
279 struct delayed_method_info
281 /* The type to which the method is attached, i.e., its parent class. */
284 /* The index of the method in the type's function fieldlists. */
287 /* The index of the method in the fieldlist. */
290 /* The name of the DIE. */
293 /* The DIE associated with this method. */
294 struct die_info *die;
297 typedef struct delayed_method_info delayed_method_info;
298 DEF_VEC_O (delayed_method_info);
300 /* Internal state when decoding a particular compilation unit. */
303 /* The objfile containing this compilation unit. */
304 struct objfile *objfile;
306 /* The header of the compilation unit. */
307 struct comp_unit_head header;
309 /* Base address of this compilation unit. */
310 CORE_ADDR base_address;
312 /* Non-zero if base_address has been set. */
315 /* The language we are debugging. */
316 enum language language;
317 const struct language_defn *language_defn;
319 const char *producer;
321 /* The generic symbol table building routines have separate lists for
322 file scope symbols and all all other scopes (local scopes). So
323 we need to select the right one to pass to add_symbol_to_list().
324 We do it by keeping a pointer to the correct list in list_in_scope.
326 FIXME: The original dwarf code just treated the file scope as the
327 first local scope, and all other local scopes as nested local
328 scopes, and worked fine. Check to see if we really need to
329 distinguish these in buildsym.c. */
330 struct pending **list_in_scope;
332 /* DWARF abbreviation table associated with this compilation unit. */
333 struct abbrev_info **dwarf2_abbrevs;
335 /* Storage for the abbrev table. */
336 struct obstack abbrev_obstack;
338 /* Hash table holding all the loaded partial DIEs. */
341 /* Storage for things with the same lifetime as this read-in compilation
342 unit, including partial DIEs. */
343 struct obstack comp_unit_obstack;
345 /* When multiple dwarf2_cu structures are living in memory, this field
346 chains them all together, so that they can be released efficiently.
347 We will probably also want a generation counter so that most-recently-used
348 compilation units are cached... */
349 struct dwarf2_per_cu_data *read_in_chain;
351 /* Backchain to our per_cu entry if the tree has been built. */
352 struct dwarf2_per_cu_data *per_cu;
354 /* How many compilation units ago was this CU last referenced? */
357 /* A hash table of die offsets for following references. */
360 /* Full DIEs if read in. */
361 struct die_info *dies;
363 /* A set of pointers to dwarf2_per_cu_data objects for compilation
364 units referenced by this one. Only set during full symbol processing;
365 partial symbol tables do not have dependencies. */
368 /* Header data from the line table, during full symbol processing. */
369 struct line_header *line_header;
371 /* A list of methods which need to have physnames computed
372 after all type information has been read. */
373 VEC (delayed_method_info) *method_list;
375 /* To be copied to symtab->call_site_htab. */
376 htab_t call_site_htab;
378 /* Mark used when releasing cached dies. */
379 unsigned int mark : 1;
381 /* This flag will be set if this compilation unit might include
382 inter-compilation-unit references. */
383 unsigned int has_form_ref_addr : 1;
385 /* This flag will be set if this compilation unit includes any
386 DW_TAG_namespace DIEs. If we know that there are explicit
387 DIEs for namespaces, we don't need to try to infer them
388 from mangled names. */
389 unsigned int has_namespace_info : 1;
391 /* This CU references .debug_loc. See the symtab->locations_valid field.
392 This test is imperfect as there may exist optimized debug code not using
393 any location list and still facing inlining issues if handled as
394 unoptimized code. For a future better test see GCC PR other/32998. */
395 unsigned int has_loclist : 1;
398 /* Persistent data held for a compilation unit, even when not
399 processing it. We put a pointer to this structure in the
400 read_symtab_private field of the psymtab. */
402 struct dwarf2_per_cu_data
404 /* The start offset and length of this compilation unit. 2**29-1
405 bytes should suffice to store the length of any compilation unit
406 - if it doesn't, GDB will fall over anyway.
407 NOTE: Unlike comp_unit_head.length, this length includes
408 initial_length_size. */
410 unsigned int length : 29;
412 /* Flag indicating this compilation unit will be read in before
413 any of the current compilation units are processed. */
414 unsigned int queued : 1;
416 /* This flag will be set if we need to load absolutely all DIEs
417 for this compilation unit, instead of just the ones we think
418 are interesting. It gets set if we look for a DIE in the
419 hash table and don't find it. */
420 unsigned int load_all_dies : 1;
422 /* Non-null if this CU is from .debug_types; in which case it points
423 to the section. Otherwise it's from .debug_info. */
424 struct dwarf2_section_info *debug_types_section;
426 /* Set to non-NULL iff this CU is currently loaded. When it gets freed out
427 of the CU cache it gets reset to NULL again. */
428 struct dwarf2_cu *cu;
430 /* The corresponding objfile.
431 Normally we can get the objfile from dwarf2_per_objfile.
432 However we can enter this file with just a "per_cu" handle. */
433 struct objfile *objfile;
435 /* When using partial symbol tables, the 'psymtab' field is active.
436 Otherwise the 'quick' field is active. */
439 /* The partial symbol table associated with this compilation unit,
440 or NULL for partial units (which do not have an associated
442 struct partial_symtab *psymtab;
444 /* Data needed by the "quick" functions. */
445 struct dwarf2_per_cu_quick_data *quick;
449 /* Entry in the signatured_types hash table. */
451 struct signatured_type
455 /* Offset in .debug_types of the type defined by this TU. */
456 unsigned int type_offset;
458 /* The CU(/TU) of this type. */
459 struct dwarf2_per_cu_data per_cu;
462 /* Struct used to pass misc. parameters to read_die_and_children, et
463 al. which are used for both .debug_info and .debug_types dies.
464 All parameters here are unchanging for the life of the call. This
465 struct exists to abstract away the constant parameters of die
468 struct die_reader_specs
470 /* The bfd of this objfile. */
473 /* The CU of the DIE we are parsing. */
474 struct dwarf2_cu *cu;
476 /* Pointer to start of section buffer.
477 This is either the start of .debug_info or .debug_types. */
478 const gdb_byte *buffer;
481 /* The line number information for a compilation unit (found in the
482 .debug_line section) begins with a "statement program header",
483 which contains the following information. */
486 unsigned int total_length;
487 unsigned short version;
488 unsigned int header_length;
489 unsigned char minimum_instruction_length;
490 unsigned char maximum_ops_per_instruction;
491 unsigned char default_is_stmt;
493 unsigned char line_range;
494 unsigned char opcode_base;
496 /* standard_opcode_lengths[i] is the number of operands for the
497 standard opcode whose value is i. This means that
498 standard_opcode_lengths[0] is unused, and the last meaningful
499 element is standard_opcode_lengths[opcode_base - 1]. */
500 unsigned char *standard_opcode_lengths;
502 /* The include_directories table. NOTE! These strings are not
503 allocated with xmalloc; instead, they are pointers into
504 debug_line_buffer. If you try to free them, `free' will get
506 unsigned int num_include_dirs, include_dirs_size;
509 /* The file_names table. NOTE! These strings are not allocated
510 with xmalloc; instead, they are pointers into debug_line_buffer.
511 Don't try to free them directly. */
512 unsigned int num_file_names, file_names_size;
516 unsigned int dir_index;
517 unsigned int mod_time;
519 int included_p; /* Non-zero if referenced by the Line Number Program. */
520 struct symtab *symtab; /* The associated symbol table, if any. */
523 /* The start and end of the statement program following this
524 header. These point into dwarf2_per_objfile->line_buffer. */
525 gdb_byte *statement_program_start, *statement_program_end;
528 /* When we construct a partial symbol table entry we only
529 need this much information. */
530 struct partial_die_info
532 /* Offset of this DIE. */
535 /* DWARF-2 tag for this DIE. */
536 ENUM_BITFIELD(dwarf_tag) tag : 16;
538 /* Assorted flags describing the data found in this DIE. */
539 unsigned int has_children : 1;
540 unsigned int is_external : 1;
541 unsigned int is_declaration : 1;
542 unsigned int has_type : 1;
543 unsigned int has_specification : 1;
544 unsigned int has_pc_info : 1;
546 /* Flag set if the SCOPE field of this structure has been
548 unsigned int scope_set : 1;
550 /* Flag set if the DIE has a byte_size attribute. */
551 unsigned int has_byte_size : 1;
553 /* Flag set if any of the DIE's children are template arguments. */
554 unsigned int has_template_arguments : 1;
556 /* Flag set if fixup_partial_die has been called on this die. */
557 unsigned int fixup_called : 1;
559 /* The name of this DIE. Normally the value of DW_AT_name, but
560 sometimes a default name for unnamed DIEs. */
563 /* The linkage name, if present. */
564 const char *linkage_name;
566 /* The scope to prepend to our children. This is generally
567 allocated on the comp_unit_obstack, so will disappear
568 when this compilation unit leaves the cache. */
571 /* The location description associated with this DIE, if any. */
572 struct dwarf_block *locdesc;
574 /* If HAS_PC_INFO, the PC range associated with this DIE. */
578 /* Pointer into the info_buffer (or types_buffer) pointing at the target of
579 DW_AT_sibling, if any. */
580 /* NOTE: This member isn't strictly necessary, read_partial_die could
581 return DW_AT_sibling values to its caller load_partial_dies. */
584 /* If HAS_SPECIFICATION, the offset of the DIE referred to by
585 DW_AT_specification (or DW_AT_abstract_origin or
587 unsigned int spec_offset;
589 /* Pointers to this DIE's parent, first child, and next sibling,
591 struct partial_die_info *die_parent, *die_child, *die_sibling;
594 /* This data structure holds the information of an abbrev. */
597 unsigned int number; /* number identifying abbrev */
598 enum dwarf_tag tag; /* dwarf tag */
599 unsigned short has_children; /* boolean */
600 unsigned short num_attrs; /* number of attributes */
601 struct attr_abbrev *attrs; /* an array of attribute descriptions */
602 struct abbrev_info *next; /* next in chain */
607 ENUM_BITFIELD(dwarf_attribute) name : 16;
608 ENUM_BITFIELD(dwarf_form) form : 16;
611 /* Attributes have a name and a value. */
614 ENUM_BITFIELD(dwarf_attribute) name : 16;
615 ENUM_BITFIELD(dwarf_form) form : 15;
617 /* Has DW_STRING already been updated by dwarf2_canonicalize_name? This
618 field should be in u.str (existing only for DW_STRING) but it is kept
619 here for better struct attribute alignment. */
620 unsigned int string_is_canonical : 1;
625 struct dwarf_block *blk;
629 struct signatured_type *signatured_type;
634 /* This data structure holds a complete die structure. */
637 /* DWARF-2 tag for this DIE. */
638 ENUM_BITFIELD(dwarf_tag) tag : 16;
640 /* Number of attributes */
641 unsigned char num_attrs;
643 /* True if we're presently building the full type name for the
644 type derived from this DIE. */
645 unsigned char building_fullname : 1;
650 /* Offset in .debug_info or .debug_types section. */
653 /* The dies in a compilation unit form an n-ary tree. PARENT
654 points to this die's parent; CHILD points to the first child of
655 this node; and all the children of a given node are chained
656 together via their SIBLING fields. */
657 struct die_info *child; /* Its first child, if any. */
658 struct die_info *sibling; /* Its next sibling, if any. */
659 struct die_info *parent; /* Its parent, if any. */
661 /* An array of attributes, with NUM_ATTRS elements. There may be
662 zero, but it's not common and zero-sized arrays are not
663 sufficiently portable C. */
664 struct attribute attrs[1];
667 /* Get at parts of an attribute structure. */
669 #define DW_STRING(attr) ((attr)->u.str)
670 #define DW_STRING_IS_CANONICAL(attr) ((attr)->string_is_canonical)
671 #define DW_UNSND(attr) ((attr)->u.unsnd)
672 #define DW_BLOCK(attr) ((attr)->u.blk)
673 #define DW_SND(attr) ((attr)->u.snd)
674 #define DW_ADDR(attr) ((attr)->u.addr)
675 #define DW_SIGNATURED_TYPE(attr) ((attr)->u.signatured_type)
677 /* Blocks are a bunch of untyped bytes. */
682 /* Valid only if SIZE is not zero. */
686 #ifndef ATTR_ALLOC_CHUNK
687 #define ATTR_ALLOC_CHUNK 4
690 /* Allocate fields for structs, unions and enums in this size. */
691 #ifndef DW_FIELD_ALLOC_CHUNK
692 #define DW_FIELD_ALLOC_CHUNK 4
695 /* FIXME: We might want to set this from BFD via bfd_arch_bits_per_byte,
696 but this would require a corresponding change in unpack_field_as_long
698 static int bits_per_byte = 8;
700 /* The routines that read and process dies for a C struct or C++ class
701 pass lists of data member fields and lists of member function fields
702 in an instance of a field_info structure, as defined below. */
705 /* List of data member and baseclasses fields. */
708 struct nextfield *next;
713 *fields, *baseclasses;
715 /* Number of fields (including baseclasses). */
718 /* Number of baseclasses. */
721 /* Set if the accesibility of one of the fields is not public. */
722 int non_public_fields;
724 /* Member function fields array, entries are allocated in the order they
725 are encountered in the object file. */
728 struct nextfnfield *next;
729 struct fn_field fnfield;
733 /* Member function fieldlist array, contains name of possibly overloaded
734 member function, number of overloaded member functions and a pointer
735 to the head of the member function field chain. */
740 struct nextfnfield *head;
744 /* Number of entries in the fnfieldlists array. */
747 /* typedefs defined inside this class. TYPEDEF_FIELD_LIST contains head of
748 a NULL terminated list of TYPEDEF_FIELD_LIST_COUNT elements. */
749 struct typedef_field_list
751 struct typedef_field field;
752 struct typedef_field_list *next;
755 unsigned typedef_field_list_count;
758 /* One item on the queue of compilation units to read in full symbols
760 struct dwarf2_queue_item
762 struct dwarf2_per_cu_data *per_cu;
763 struct dwarf2_queue_item *next;
766 /* The current queue. */
767 static struct dwarf2_queue_item *dwarf2_queue, *dwarf2_queue_tail;
769 /* Loaded secondary compilation units are kept in memory until they
770 have not been referenced for the processing of this many
771 compilation units. Set this to zero to disable caching. Cache
772 sizes of up to at least twenty will improve startup time for
773 typical inter-CU-reference binaries, at an obvious memory cost. */
774 static int dwarf2_max_cache_age = 5;
776 show_dwarf2_max_cache_age (struct ui_file *file, int from_tty,
777 struct cmd_list_element *c, const char *value)
779 fprintf_filtered (file, _("The upper bound on the age of cached "
780 "dwarf2 compilation units is %s.\n"),
785 /* Various complaints about symbol reading that don't abort the process. */
788 dwarf2_statement_list_fits_in_line_number_section_complaint (void)
790 complaint (&symfile_complaints,
791 _("statement list doesn't fit in .debug_line section"));
795 dwarf2_debug_line_missing_file_complaint (void)
797 complaint (&symfile_complaints,
798 _(".debug_line section has line data without a file"));
802 dwarf2_debug_line_missing_end_sequence_complaint (void)
804 complaint (&symfile_complaints,
805 _(".debug_line section has line "
806 "program sequence without an end"));
810 dwarf2_complex_location_expr_complaint (void)
812 complaint (&symfile_complaints, _("location expression too complex"));
816 dwarf2_const_value_length_mismatch_complaint (const char *arg1, int arg2,
819 complaint (&symfile_complaints,
820 _("const value length mismatch for '%s', got %d, expected %d"),
825 dwarf2_macros_too_long_complaint (struct dwarf2_section_info *section)
827 complaint (&symfile_complaints,
828 _("macro info runs off end of `%s' section"),
829 section->asection->name);
833 dwarf2_macro_malformed_definition_complaint (const char *arg1)
835 complaint (&symfile_complaints,
836 _("macro debug info contains a "
837 "malformed macro definition:\n`%s'"),
842 dwarf2_invalid_attrib_class_complaint (const char *arg1, const char *arg2)
844 complaint (&symfile_complaints,
845 _("invalid attribute class or form for '%s' in '%s'"),
849 /* local function prototypes */
851 static void dwarf2_locate_sections (bfd *, asection *, void *);
853 static void dwarf2_create_include_psymtab (char *, struct partial_symtab *,
856 static void dwarf2_find_base_address (struct die_info *die,
857 struct dwarf2_cu *cu);
859 static void dwarf2_build_psymtabs_hard (struct objfile *);
861 static void scan_partial_symbols (struct partial_die_info *,
862 CORE_ADDR *, CORE_ADDR *,
863 int, struct dwarf2_cu *);
865 static void add_partial_symbol (struct partial_die_info *,
868 static void add_partial_namespace (struct partial_die_info *pdi,
869 CORE_ADDR *lowpc, CORE_ADDR *highpc,
870 int need_pc, struct dwarf2_cu *cu);
872 static void add_partial_module (struct partial_die_info *pdi, CORE_ADDR *lowpc,
873 CORE_ADDR *highpc, int need_pc,
874 struct dwarf2_cu *cu);
876 static void add_partial_enumeration (struct partial_die_info *enum_pdi,
877 struct dwarf2_cu *cu);
879 static void add_partial_subprogram (struct partial_die_info *pdi,
880 CORE_ADDR *lowpc, CORE_ADDR *highpc,
881 int need_pc, struct dwarf2_cu *cu);
883 static gdb_byte *locate_pdi_sibling (struct partial_die_info *orig_pdi,
884 gdb_byte *buffer, gdb_byte *info_ptr,
885 bfd *abfd, struct dwarf2_cu *cu);
887 static void dwarf2_psymtab_to_symtab (struct partial_symtab *);
889 static void psymtab_to_symtab_1 (struct partial_symtab *);
891 static void dwarf2_read_abbrevs (struct dwarf2_cu *cu);
893 static void dwarf2_free_abbrev_table (void *);
895 static unsigned int peek_abbrev_code (bfd *, gdb_byte *);
897 static struct abbrev_info *peek_die_abbrev (gdb_byte *, unsigned int *,
900 static struct abbrev_info *dwarf2_lookup_abbrev (unsigned int,
903 static struct partial_die_info *load_partial_dies (bfd *,
904 gdb_byte *, gdb_byte *,
905 int, struct dwarf2_cu *);
907 static gdb_byte *read_partial_die (struct partial_die_info *,
908 struct abbrev_info *abbrev,
910 gdb_byte *, gdb_byte *,
913 static struct partial_die_info *find_partial_die (unsigned int,
916 static void fixup_partial_die (struct partial_die_info *,
919 static gdb_byte *read_attribute (struct attribute *, struct attr_abbrev *,
920 bfd *, gdb_byte *, struct dwarf2_cu *);
922 static gdb_byte *read_attribute_value (struct attribute *, unsigned,
923 bfd *, gdb_byte *, struct dwarf2_cu *);
925 static unsigned int read_1_byte (bfd *, gdb_byte *);
927 static int read_1_signed_byte (bfd *, gdb_byte *);
929 static unsigned int read_2_bytes (bfd *, gdb_byte *);
931 static unsigned int read_4_bytes (bfd *, gdb_byte *);
933 static ULONGEST read_8_bytes (bfd *, gdb_byte *);
935 static CORE_ADDR read_address (bfd *, gdb_byte *ptr, struct dwarf2_cu *,
938 static LONGEST read_initial_length (bfd *, gdb_byte *, unsigned int *);
940 static LONGEST read_checked_initial_length_and_offset
941 (bfd *, gdb_byte *, const struct comp_unit_head *,
942 unsigned int *, unsigned int *);
944 static LONGEST read_offset (bfd *, gdb_byte *, const struct comp_unit_head *,
947 static LONGEST read_offset_1 (bfd *, gdb_byte *, unsigned int);
949 static gdb_byte *read_n_bytes (bfd *, gdb_byte *, unsigned int);
951 static char *read_direct_string (bfd *, gdb_byte *, unsigned int *);
953 static char *read_indirect_string (bfd *, gdb_byte *,
954 const struct comp_unit_head *,
957 static unsigned long read_unsigned_leb128 (bfd *, gdb_byte *, unsigned int *);
959 static long read_signed_leb128 (bfd *, gdb_byte *, unsigned int *);
961 static gdb_byte *skip_leb128 (bfd *, gdb_byte *);
963 static void set_cu_language (unsigned int, struct dwarf2_cu *);
965 static struct attribute *dwarf2_attr (struct die_info *, unsigned int,
968 static struct attribute *dwarf2_attr_no_follow (struct die_info *,
972 static int dwarf2_flag_true_p (struct die_info *die, unsigned name,
973 struct dwarf2_cu *cu);
975 static int die_is_declaration (struct die_info *, struct dwarf2_cu *cu);
977 static struct die_info *die_specification (struct die_info *die,
978 struct dwarf2_cu **);
980 static void free_line_header (struct line_header *lh);
982 static void add_file_name (struct line_header *, char *, unsigned int,
983 unsigned int, unsigned int);
985 static struct line_header *(dwarf_decode_line_header
986 (unsigned int offset,
987 bfd *abfd, struct dwarf2_cu *cu));
989 static void dwarf_decode_lines (struct line_header *, const char *,
990 struct dwarf2_cu *, struct partial_symtab *,
993 static void dwarf2_start_subfile (char *, const char *, const char *);
995 static struct symbol *new_symbol (struct die_info *, struct type *,
998 static struct symbol *new_symbol_full (struct die_info *, struct type *,
999 struct dwarf2_cu *, struct symbol *);
1001 static void dwarf2_const_value (struct attribute *, struct symbol *,
1002 struct dwarf2_cu *);
1004 static void dwarf2_const_value_attr (struct attribute *attr,
1007 struct obstack *obstack,
1008 struct dwarf2_cu *cu, long *value,
1010 struct dwarf2_locexpr_baton **baton);
1012 static struct type *die_type (struct die_info *, struct dwarf2_cu *);
1014 static int need_gnat_info (struct dwarf2_cu *);
1016 static struct type *die_descriptive_type (struct die_info *,
1017 struct dwarf2_cu *);
1019 static void set_descriptive_type (struct type *, struct die_info *,
1020 struct dwarf2_cu *);
1022 static struct type *die_containing_type (struct die_info *,
1023 struct dwarf2_cu *);
1025 static struct type *lookup_die_type (struct die_info *, struct attribute *,
1026 struct dwarf2_cu *);
1028 static struct type *read_type_die (struct die_info *, struct dwarf2_cu *);
1030 static struct type *read_type_die_1 (struct die_info *, struct dwarf2_cu *);
1032 static char *determine_prefix (struct die_info *die, struct dwarf2_cu *);
1034 static char *typename_concat (struct obstack *obs, const char *prefix,
1035 const char *suffix, int physname,
1036 struct dwarf2_cu *cu);
1038 static void read_file_scope (struct die_info *, struct dwarf2_cu *);
1040 static void read_type_unit_scope (struct die_info *, struct dwarf2_cu *);
1042 static void read_func_scope (struct die_info *, struct dwarf2_cu *);
1044 static void read_lexical_block_scope (struct die_info *, struct dwarf2_cu *);
1046 static void read_call_site_scope (struct die_info *die, struct dwarf2_cu *cu);
1048 static int dwarf2_ranges_read (unsigned, CORE_ADDR *, CORE_ADDR *,
1049 struct dwarf2_cu *, struct partial_symtab *);
1051 static int dwarf2_get_pc_bounds (struct die_info *,
1052 CORE_ADDR *, CORE_ADDR *, struct dwarf2_cu *,
1053 struct partial_symtab *);
1055 static void get_scope_pc_bounds (struct die_info *,
1056 CORE_ADDR *, CORE_ADDR *,
1057 struct dwarf2_cu *);
1059 static void dwarf2_record_block_ranges (struct die_info *, struct block *,
1060 CORE_ADDR, struct dwarf2_cu *);
1062 static void dwarf2_add_field (struct field_info *, struct die_info *,
1063 struct dwarf2_cu *);
1065 static void dwarf2_attach_fields_to_type (struct field_info *,
1066 struct type *, struct dwarf2_cu *);
1068 static void dwarf2_add_member_fn (struct field_info *,
1069 struct die_info *, struct type *,
1070 struct dwarf2_cu *);
1072 static void dwarf2_attach_fn_fields_to_type (struct field_info *,
1074 struct dwarf2_cu *);
1076 static void process_structure_scope (struct die_info *, struct dwarf2_cu *);
1078 static void read_common_block (struct die_info *, struct dwarf2_cu *);
1080 static void read_namespace (struct die_info *die, struct dwarf2_cu *);
1082 static void read_module (struct die_info *die, struct dwarf2_cu *cu);
1084 static void read_import_statement (struct die_info *die, struct dwarf2_cu *);
1086 static struct type *read_module_type (struct die_info *die,
1087 struct dwarf2_cu *cu);
1089 static const char *namespace_name (struct die_info *die,
1090 int *is_anonymous, struct dwarf2_cu *);
1092 static void process_enumeration_scope (struct die_info *, struct dwarf2_cu *);
1094 static CORE_ADDR decode_locdesc (struct dwarf_block *, struct dwarf2_cu *);
1096 static enum dwarf_array_dim_ordering read_array_order (struct die_info *,
1097 struct dwarf2_cu *);
1099 static struct die_info *read_comp_unit (gdb_byte *, struct dwarf2_cu *);
1101 static struct die_info *read_die_and_children_1 (const struct die_reader_specs *reader,
1103 gdb_byte **new_info_ptr,
1104 struct die_info *parent);
1106 static struct die_info *read_die_and_children (const struct die_reader_specs *reader,
1108 gdb_byte **new_info_ptr,
1109 struct die_info *parent);
1111 static struct die_info *read_die_and_siblings (const struct die_reader_specs *reader,
1113 gdb_byte **new_info_ptr,
1114 struct die_info *parent);
1116 static gdb_byte *read_full_die (const struct die_reader_specs *reader,
1117 struct die_info **, gdb_byte *,
1120 static void process_die (struct die_info *, struct dwarf2_cu *);
1122 static char *dwarf2_canonicalize_name (char *, struct dwarf2_cu *,
1125 static char *dwarf2_name (struct die_info *die, struct dwarf2_cu *);
1127 static const char *dwarf2_full_name (char *name,
1128 struct die_info *die,
1129 struct dwarf2_cu *cu);
1131 static struct die_info *dwarf2_extension (struct die_info *die,
1132 struct dwarf2_cu **);
1134 static char *dwarf_tag_name (unsigned int);
1136 static char *dwarf_attr_name (unsigned int);
1138 static char *dwarf_form_name (unsigned int);
1140 static char *dwarf_bool_name (unsigned int);
1142 static char *dwarf_type_encoding_name (unsigned int);
1145 static char *dwarf_cfi_name (unsigned int);
1148 static struct die_info *sibling_die (struct die_info *);
1150 static void dump_die_shallow (struct ui_file *, int indent, struct die_info *);
1152 static void dump_die_for_error (struct die_info *);
1154 static void dump_die_1 (struct ui_file *, int level, int max_level,
1157 /*static*/ void dump_die (struct die_info *, int max_level);
1159 static void store_in_ref_table (struct die_info *,
1160 struct dwarf2_cu *);
1162 static int is_ref_attr (struct attribute *);
1164 static unsigned int dwarf2_get_ref_die_offset (struct attribute *);
1166 static LONGEST dwarf2_get_attr_constant_value (struct attribute *, int);
1168 static struct die_info *follow_die_ref_or_sig (struct die_info *,
1170 struct dwarf2_cu **);
1172 static struct die_info *follow_die_ref (struct die_info *,
1174 struct dwarf2_cu **);
1176 static struct die_info *follow_die_sig (struct die_info *,
1178 struct dwarf2_cu **);
1180 static struct signatured_type *lookup_signatured_type_at_offset
1181 (struct objfile *objfile,
1182 struct dwarf2_section_info *section,
1183 unsigned int offset);
1185 static void load_full_type_unit (struct dwarf2_per_cu_data *per_cu);
1187 static void read_signatured_type (struct signatured_type *type_sig);
1189 /* memory allocation interface */
1191 static struct dwarf_block *dwarf_alloc_block (struct dwarf2_cu *);
1193 static struct abbrev_info *dwarf_alloc_abbrev (struct dwarf2_cu *);
1195 static struct die_info *dwarf_alloc_die (struct dwarf2_cu *, int);
1197 static void dwarf_decode_macros (struct line_header *, unsigned int,
1198 char *, bfd *, struct dwarf2_cu *,
1199 struct dwarf2_section_info *,
1202 static int attr_form_is_block (struct attribute *);
1204 static int attr_form_is_section_offset (struct attribute *);
1206 static int attr_form_is_constant (struct attribute *);
1208 static void fill_in_loclist_baton (struct dwarf2_cu *cu,
1209 struct dwarf2_loclist_baton *baton,
1210 struct attribute *attr);
1212 static void dwarf2_symbol_mark_computed (struct attribute *attr,
1214 struct dwarf2_cu *cu);
1216 static gdb_byte *skip_one_die (gdb_byte *buffer, gdb_byte *info_ptr,
1217 struct abbrev_info *abbrev,
1218 struct dwarf2_cu *cu);
1220 static void free_stack_comp_unit (void *);
1222 static hashval_t partial_die_hash (const void *item);
1224 static int partial_die_eq (const void *item_lhs, const void *item_rhs);
1226 static struct dwarf2_per_cu_data *dwarf2_find_containing_comp_unit
1227 (unsigned int offset, struct objfile *objfile);
1229 static void init_one_comp_unit (struct dwarf2_cu *cu,
1230 struct dwarf2_per_cu_data *per_cu);
1232 static void prepare_one_comp_unit (struct dwarf2_cu *cu,
1233 struct die_info *comp_unit_die);
1235 static void free_heap_comp_unit (void *);
1237 static void free_cached_comp_units (void *);
1239 static void age_cached_comp_units (void);
1241 static void free_one_cached_comp_unit (void *);
1243 static struct type *set_die_type (struct die_info *, struct type *,
1244 struct dwarf2_cu *);
1246 static void create_all_comp_units (struct objfile *);
1248 static int create_debug_types_hash_table (struct objfile *objfile);
1250 static void load_full_comp_unit (struct dwarf2_per_cu_data *);
1252 static void process_full_comp_unit (struct dwarf2_per_cu_data *);
1254 static void dwarf2_add_dependence (struct dwarf2_cu *,
1255 struct dwarf2_per_cu_data *);
1257 static void dwarf2_mark (struct dwarf2_cu *);
1259 static void dwarf2_clear_marks (struct dwarf2_per_cu_data *);
1261 static struct type *get_die_type_at_offset (unsigned int,
1262 struct dwarf2_per_cu_data *per_cu);
1264 static struct type *get_die_type (struct die_info *die, struct dwarf2_cu *cu);
1266 static void dwarf2_release_queue (void *dummy);
1268 static void queue_comp_unit (struct dwarf2_per_cu_data *per_cu);
1270 static void process_queue (void);
1272 static void find_file_and_directory (struct die_info *die,
1273 struct dwarf2_cu *cu,
1274 char **name, char **comp_dir);
1276 static char *file_full_name (int file, struct line_header *lh,
1277 const char *comp_dir);
1279 static gdb_byte *read_and_check_comp_unit_head
1280 (struct comp_unit_head *header,
1281 struct dwarf2_section_info *section, gdb_byte *info_ptr,
1282 int is_debug_types_section);
1284 static void init_cu_die_reader (struct die_reader_specs *reader,
1285 struct dwarf2_cu *cu);
1287 static htab_t allocate_signatured_type_table (struct objfile *objfile);
1291 /* Convert VALUE between big- and little-endian. */
1293 byte_swap (offset_type value)
1297 result = (value & 0xff) << 24;
1298 result |= (value & 0xff00) << 8;
1299 result |= (value & 0xff0000) >> 8;
1300 result |= (value & 0xff000000) >> 24;
1304 #define MAYBE_SWAP(V) byte_swap (V)
1307 #define MAYBE_SWAP(V) (V)
1308 #endif /* WORDS_BIGENDIAN */
1310 /* The suffix for an index file. */
1311 #define INDEX_SUFFIX ".gdb-index"
1313 static const char *dwarf2_physname (char *name, struct die_info *die,
1314 struct dwarf2_cu *cu);
1316 /* Try to locate the sections we need for DWARF 2 debugging
1317 information and return true if we have enough to do something.
1318 NAMES points to the dwarf2 section names, or is NULL if the standard
1319 ELF names are used. */
1322 dwarf2_has_info (struct objfile *objfile,
1323 const struct dwarf2_debug_sections *names)
1325 dwarf2_per_objfile = objfile_data (objfile, dwarf2_objfile_data_key);
1326 if (!dwarf2_per_objfile)
1328 /* Initialize per-objfile state. */
1329 struct dwarf2_per_objfile *data
1330 = obstack_alloc (&objfile->objfile_obstack, sizeof (*data));
1332 memset (data, 0, sizeof (*data));
1333 set_objfile_data (objfile, dwarf2_objfile_data_key, data);
1334 dwarf2_per_objfile = data;
1336 bfd_map_over_sections (objfile->obfd, dwarf2_locate_sections,
1338 dwarf2_per_objfile->objfile = objfile;
1340 return (dwarf2_per_objfile->info.asection != NULL
1341 && dwarf2_per_objfile->abbrev.asection != NULL);
1344 /* When loading sections, we look either for uncompressed section or for
1345 compressed section names. */
1348 section_is_p (const char *section_name,
1349 const struct dwarf2_section_names *names)
1351 if (names->normal != NULL
1352 && strcmp (section_name, names->normal) == 0)
1354 if (names->compressed != NULL
1355 && strcmp (section_name, names->compressed) == 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 *vnames)
1367 const struct dwarf2_debug_sections *names;
1370 names = &dwarf2_elf_names;
1372 names = (const struct dwarf2_debug_sections *) vnames;
1374 if (section_is_p (sectp->name, &names->info))
1376 dwarf2_per_objfile->info.asection = sectp;
1377 dwarf2_per_objfile->info.size = bfd_get_section_size (sectp);
1379 else if (section_is_p (sectp->name, &names->abbrev))
1381 dwarf2_per_objfile->abbrev.asection = sectp;
1382 dwarf2_per_objfile->abbrev.size = bfd_get_section_size (sectp);
1384 else if (section_is_p (sectp->name, &names->line))
1386 dwarf2_per_objfile->line.asection = sectp;
1387 dwarf2_per_objfile->line.size = bfd_get_section_size (sectp);
1389 else if (section_is_p (sectp->name, &names->loc))
1391 dwarf2_per_objfile->loc.asection = sectp;
1392 dwarf2_per_objfile->loc.size = bfd_get_section_size (sectp);
1394 else if (section_is_p (sectp->name, &names->macinfo))
1396 dwarf2_per_objfile->macinfo.asection = sectp;
1397 dwarf2_per_objfile->macinfo.size = bfd_get_section_size (sectp);
1399 else if (section_is_p (sectp->name, &names->macro))
1401 dwarf2_per_objfile->macro.asection = sectp;
1402 dwarf2_per_objfile->macro.size = bfd_get_section_size (sectp);
1404 else if (section_is_p (sectp->name, &names->str))
1406 dwarf2_per_objfile->str.asection = sectp;
1407 dwarf2_per_objfile->str.size = bfd_get_section_size (sectp);
1409 else if (section_is_p (sectp->name, &names->frame))
1411 dwarf2_per_objfile->frame.asection = sectp;
1412 dwarf2_per_objfile->frame.size = bfd_get_section_size (sectp);
1414 else if (section_is_p (sectp->name, &names->eh_frame))
1416 flagword aflag = bfd_get_section_flags (ignore_abfd, sectp);
1418 if (aflag & SEC_HAS_CONTENTS)
1420 dwarf2_per_objfile->eh_frame.asection = sectp;
1421 dwarf2_per_objfile->eh_frame.size = bfd_get_section_size (sectp);
1424 else if (section_is_p (sectp->name, &names->ranges))
1426 dwarf2_per_objfile->ranges.asection = sectp;
1427 dwarf2_per_objfile->ranges.size = bfd_get_section_size (sectp);
1429 else if (section_is_p (sectp->name, &names->types))
1431 struct dwarf2_section_info type_section;
1433 memset (&type_section, 0, sizeof (type_section));
1434 type_section.asection = sectp;
1435 type_section.size = bfd_get_section_size (sectp);
1437 VEC_safe_push (dwarf2_section_info_def, dwarf2_per_objfile->types,
1440 else if (section_is_p (sectp->name, &names->gdb_index))
1442 dwarf2_per_objfile->gdb_index.asection = sectp;
1443 dwarf2_per_objfile->gdb_index.size = bfd_get_section_size (sectp);
1446 if ((bfd_get_section_flags (abfd, sectp) & SEC_LOAD)
1447 && bfd_section_vma (abfd, sectp) == 0)
1448 dwarf2_per_objfile->has_section_at_zero = 1;
1451 /* Decompress a section that was compressed using zlib. Store the
1452 decompressed buffer, and its size, in OUTBUF and OUTSIZE. */
1455 zlib_decompress_section (struct objfile *objfile, asection *sectp,
1456 gdb_byte **outbuf, bfd_size_type *outsize)
1458 bfd *abfd = objfile->obfd;
1460 error (_("Support for zlib-compressed DWARF data (from '%s') "
1461 "is disabled in this copy of GDB"),
1462 bfd_get_filename (abfd));
1464 bfd_size_type compressed_size = bfd_get_section_size (sectp);
1465 gdb_byte *compressed_buffer = xmalloc (compressed_size);
1466 struct cleanup *cleanup = make_cleanup (xfree, compressed_buffer);
1467 bfd_size_type uncompressed_size;
1468 gdb_byte *uncompressed_buffer;
1471 int header_size = 12;
1473 if (bfd_seek (abfd, sectp->filepos, SEEK_SET) != 0
1474 || bfd_bread (compressed_buffer,
1475 compressed_size, abfd) != compressed_size)
1476 error (_("Dwarf Error: Can't read DWARF data from '%s'"),
1477 bfd_get_filename (abfd));
1479 /* Read the zlib header. In this case, it should be "ZLIB" followed
1480 by the uncompressed section size, 8 bytes in big-endian order. */
1481 if (compressed_size < header_size
1482 || strncmp (compressed_buffer, "ZLIB", 4) != 0)
1483 error (_("Dwarf Error: Corrupt DWARF ZLIB header from '%s'"),
1484 bfd_get_filename (abfd));
1485 uncompressed_size = compressed_buffer[4]; uncompressed_size <<= 8;
1486 uncompressed_size += compressed_buffer[5]; uncompressed_size <<= 8;
1487 uncompressed_size += compressed_buffer[6]; uncompressed_size <<= 8;
1488 uncompressed_size += compressed_buffer[7]; uncompressed_size <<= 8;
1489 uncompressed_size += compressed_buffer[8]; uncompressed_size <<= 8;
1490 uncompressed_size += compressed_buffer[9]; uncompressed_size <<= 8;
1491 uncompressed_size += compressed_buffer[10]; uncompressed_size <<= 8;
1492 uncompressed_size += compressed_buffer[11];
1494 /* It is possible the section consists of several compressed
1495 buffers concatenated together, so we uncompress in a loop. */
1499 strm.avail_in = compressed_size - header_size;
1500 strm.next_in = (Bytef*) compressed_buffer + header_size;
1501 strm.avail_out = uncompressed_size;
1502 uncompressed_buffer = obstack_alloc (&objfile->objfile_obstack,
1504 rc = inflateInit (&strm);
1505 while (strm.avail_in > 0)
1508 error (_("Dwarf Error: setting up DWARF uncompression in '%s': %d"),
1509 bfd_get_filename (abfd), rc);
1510 strm.next_out = ((Bytef*) uncompressed_buffer
1511 + (uncompressed_size - strm.avail_out));
1512 rc = inflate (&strm, Z_FINISH);
1513 if (rc != Z_STREAM_END)
1514 error (_("Dwarf Error: zlib error uncompressing from '%s': %d"),
1515 bfd_get_filename (abfd), rc);
1516 rc = inflateReset (&strm);
1518 rc = inflateEnd (&strm);
1520 || strm.avail_out != 0)
1521 error (_("Dwarf Error: concluding DWARF uncompression in '%s': %d"),
1522 bfd_get_filename (abfd), rc);
1524 do_cleanups (cleanup);
1525 *outbuf = uncompressed_buffer;
1526 *outsize = uncompressed_size;
1530 /* A helper function that decides whether a section is empty. */
1533 dwarf2_section_empty_p (struct dwarf2_section_info *info)
1535 return info->asection == NULL || info->size == 0;
1538 /* Read the contents of the section INFO from object file specified by
1539 OBJFILE, store info about the section into INFO.
1540 If the section is compressed, uncompress it before returning. */
1543 dwarf2_read_section (struct objfile *objfile, struct dwarf2_section_info *info)
1545 bfd *abfd = objfile->obfd;
1546 asection *sectp = info->asection;
1547 gdb_byte *buf, *retbuf;
1548 unsigned char header[4];
1552 info->buffer = NULL;
1553 info->map_addr = NULL;
1556 if (dwarf2_section_empty_p (info))
1559 /* Check if the file has a 4-byte header indicating compression. */
1560 if (info->size > sizeof (header)
1561 && bfd_seek (abfd, sectp->filepos, SEEK_SET) == 0
1562 && bfd_bread (header, sizeof (header), abfd) == sizeof (header))
1564 /* Upon decompression, update the buffer and its size. */
1565 if (strncmp (header, "ZLIB", sizeof (header)) == 0)
1567 zlib_decompress_section (objfile, sectp, &info->buffer,
1575 pagesize = getpagesize ();
1577 /* Only try to mmap sections which are large enough: we don't want to
1578 waste space due to fragmentation. Also, only try mmap for sections
1579 without relocations. */
1581 if (info->size > 4 * pagesize && (sectp->flags & SEC_RELOC) == 0)
1583 info->buffer = bfd_mmap (abfd, 0, info->size, PROT_READ,
1584 MAP_PRIVATE, sectp->filepos,
1585 &info->map_addr, &info->map_len);
1587 if ((caddr_t)info->buffer != MAP_FAILED)
1589 #if HAVE_POSIX_MADVISE
1590 posix_madvise (info->map_addr, info->map_len, POSIX_MADV_WILLNEED);
1597 /* If we get here, we are a normal, not-compressed section. */
1599 = obstack_alloc (&objfile->objfile_obstack, info->size);
1601 /* When debugging .o files, we may need to apply relocations; see
1602 http://sourceware.org/ml/gdb-patches/2002-04/msg00136.html .
1603 We never compress sections in .o files, so we only need to
1604 try this when the section is not compressed. */
1605 retbuf = symfile_relocate_debug_section (objfile, sectp, buf);
1608 info->buffer = retbuf;
1612 if (bfd_seek (abfd, sectp->filepos, SEEK_SET) != 0
1613 || bfd_bread (buf, info->size, abfd) != info->size)
1614 error (_("Dwarf Error: Can't read DWARF data from '%s'"),
1615 bfd_get_filename (abfd));
1618 /* A helper function that returns the size of a section in a safe way.
1619 If you are positive that the section has been read before using the
1620 size, then it is safe to refer to the dwarf2_section_info object's
1621 "size" field directly. In other cases, you must call this
1622 function, because for compressed sections the size field is not set
1623 correctly until the section has been read. */
1625 static bfd_size_type
1626 dwarf2_section_size (struct objfile *objfile,
1627 struct dwarf2_section_info *info)
1630 dwarf2_read_section (objfile, info);
1634 /* Fill in SECTP, BUFP and SIZEP with section info, given OBJFILE and
1638 dwarf2_get_section_info (struct objfile *objfile,
1639 enum dwarf2_section_enum sect,
1640 asection **sectp, gdb_byte **bufp,
1641 bfd_size_type *sizep)
1643 struct dwarf2_per_objfile *data
1644 = objfile_data (objfile, dwarf2_objfile_data_key);
1645 struct dwarf2_section_info *info;
1647 /* We may see an objfile without any DWARF, in which case we just
1658 case DWARF2_DEBUG_FRAME:
1659 info = &data->frame;
1661 case DWARF2_EH_FRAME:
1662 info = &data->eh_frame;
1665 gdb_assert_not_reached ("unexpected section");
1668 dwarf2_read_section (objfile, info);
1670 *sectp = info->asection;
1671 *bufp = info->buffer;
1672 *sizep = info->size;
1676 /* DWARF quick_symbols_functions support. */
1678 /* TUs can share .debug_line entries, and there can be a lot more TUs than
1679 unique line tables, so we maintain a separate table of all .debug_line
1680 derived entries to support the sharing.
1681 All the quick functions need is the list of file names. We discard the
1682 line_header when we're done and don't need to record it here. */
1683 struct quick_file_names
1685 /* The offset in .debug_line of the line table. We hash on this. */
1686 unsigned int offset;
1688 /* The number of entries in file_names, real_names. */
1689 unsigned int num_file_names;
1691 /* The file names from the line table, after being run through
1693 const char **file_names;
1695 /* The file names from the line table after being run through
1696 gdb_realpath. These are computed lazily. */
1697 const char **real_names;
1700 /* When using the index (and thus not using psymtabs), each CU has an
1701 object of this type. This is used to hold information needed by
1702 the various "quick" methods. */
1703 struct dwarf2_per_cu_quick_data
1705 /* The file table. This can be NULL if there was no file table
1706 or it's currently not read in.
1707 NOTE: This points into dwarf2_per_objfile->quick_file_names_table. */
1708 struct quick_file_names *file_names;
1710 /* The corresponding symbol table. This is NULL if symbols for this
1711 CU have not yet been read. */
1712 struct symtab *symtab;
1714 /* A temporary mark bit used when iterating over all CUs in
1715 expand_symtabs_matching. */
1716 unsigned int mark : 1;
1718 /* True if we've tried to read the file table and found there isn't one.
1719 There will be no point in trying to read it again next time. */
1720 unsigned int no_file_data : 1;
1723 /* Hash function for a quick_file_names. */
1726 hash_file_name_entry (const void *e)
1728 const struct quick_file_names *file_data = e;
1730 return file_data->offset;
1733 /* Equality function for a quick_file_names. */
1736 eq_file_name_entry (const void *a, const void *b)
1738 const struct quick_file_names *ea = a;
1739 const struct quick_file_names *eb = b;
1741 return ea->offset == eb->offset;
1744 /* Delete function for a quick_file_names. */
1747 delete_file_name_entry (void *e)
1749 struct quick_file_names *file_data = e;
1752 for (i = 0; i < file_data->num_file_names; ++i)
1754 xfree ((void*) file_data->file_names[i]);
1755 if (file_data->real_names)
1756 xfree ((void*) file_data->real_names[i]);
1759 /* The space for the struct itself lives on objfile_obstack,
1760 so we don't free it here. */
1763 /* Create a quick_file_names hash table. */
1766 create_quick_file_names_table (unsigned int nr_initial_entries)
1768 return htab_create_alloc (nr_initial_entries,
1769 hash_file_name_entry, eq_file_name_entry,
1770 delete_file_name_entry, xcalloc, xfree);
1773 /* Read in PER_CU->CU. This function is unrelated to symtabs, symtab would
1774 have to be created afterwards. You should call age_cached_comp_units after
1775 processing PER_CU->CU. dw2_setup must have been already called. */
1778 load_cu (struct dwarf2_per_cu_data *per_cu)
1780 if (per_cu->debug_types_section)
1781 load_full_type_unit (per_cu);
1783 load_full_comp_unit (per_cu);
1785 gdb_assert (per_cu->cu != NULL);
1787 dwarf2_find_base_address (per_cu->cu->dies, per_cu->cu);
1790 /* Read in the symbols for PER_CU. */
1793 dw2_do_instantiate_symtab (struct dwarf2_per_cu_data *per_cu)
1795 struct cleanup *back_to;
1797 back_to = make_cleanup (dwarf2_release_queue, NULL);
1799 queue_comp_unit (per_cu);
1805 /* Age the cache, releasing compilation units that have not
1806 been used recently. */
1807 age_cached_comp_units ();
1809 do_cleanups (back_to);
1812 /* Ensure that the symbols for PER_CU have been read in. OBJFILE is
1813 the objfile from which this CU came. Returns the resulting symbol
1816 static struct symtab *
1817 dw2_instantiate_symtab (struct dwarf2_per_cu_data *per_cu)
1819 if (!per_cu->v.quick->symtab)
1821 struct cleanup *back_to = make_cleanup (free_cached_comp_units, NULL);
1822 increment_reading_symtab ();
1823 dw2_do_instantiate_symtab (per_cu);
1824 do_cleanups (back_to);
1826 return per_cu->v.quick->symtab;
1829 /* Return the CU given its index. */
1831 static struct dwarf2_per_cu_data *
1832 dw2_get_cu (int index)
1834 if (index >= dwarf2_per_objfile->n_comp_units)
1836 index -= dwarf2_per_objfile->n_comp_units;
1837 return dwarf2_per_objfile->all_type_units[index];
1839 return dwarf2_per_objfile->all_comp_units[index];
1842 /* A helper function that knows how to read a 64-bit value in a way
1843 that doesn't make gdb die. Returns 1 if the conversion went ok, 0
1847 extract_cu_value (const char *bytes, ULONGEST *result)
1849 if (sizeof (ULONGEST) < 8)
1853 /* Ignore the upper 4 bytes if they are all zero. */
1854 for (i = 0; i < 4; ++i)
1855 if (bytes[i + 4] != 0)
1858 *result = extract_unsigned_integer (bytes, 4, BFD_ENDIAN_LITTLE);
1861 *result = extract_unsigned_integer (bytes, 8, BFD_ENDIAN_LITTLE);
1865 /* Read the CU list from the mapped index, and use it to create all
1866 the CU objects for this objfile. Return 0 if something went wrong,
1867 1 if everything went ok. */
1870 create_cus_from_index (struct objfile *objfile, const gdb_byte *cu_list,
1871 offset_type cu_list_elements)
1875 dwarf2_per_objfile->n_comp_units = cu_list_elements / 2;
1876 dwarf2_per_objfile->all_comp_units
1877 = obstack_alloc (&objfile->objfile_obstack,
1878 dwarf2_per_objfile->n_comp_units
1879 * sizeof (struct dwarf2_per_cu_data *));
1881 for (i = 0; i < cu_list_elements; i += 2)
1883 struct dwarf2_per_cu_data *the_cu;
1884 ULONGEST offset, length;
1886 if (!extract_cu_value (cu_list, &offset)
1887 || !extract_cu_value (cu_list + 8, &length))
1891 the_cu = OBSTACK_ZALLOC (&objfile->objfile_obstack,
1892 struct dwarf2_per_cu_data);
1893 the_cu->offset = offset;
1894 the_cu->length = length;
1895 the_cu->objfile = objfile;
1896 the_cu->v.quick = OBSTACK_ZALLOC (&objfile->objfile_obstack,
1897 struct dwarf2_per_cu_quick_data);
1898 dwarf2_per_objfile->all_comp_units[i / 2] = the_cu;
1904 /* Create the signatured type hash table from the index. */
1907 create_signatured_type_table_from_index (struct objfile *objfile,
1908 struct dwarf2_section_info *section,
1909 const gdb_byte *bytes,
1910 offset_type elements)
1913 htab_t sig_types_hash;
1915 dwarf2_per_objfile->n_type_units = elements / 3;
1916 dwarf2_per_objfile->all_type_units
1917 = obstack_alloc (&objfile->objfile_obstack,
1918 dwarf2_per_objfile->n_type_units
1919 * sizeof (struct dwarf2_per_cu_data *));
1921 sig_types_hash = allocate_signatured_type_table (objfile);
1923 for (i = 0; i < elements; i += 3)
1925 struct signatured_type *type_sig;
1926 ULONGEST offset, type_offset, signature;
1929 if (!extract_cu_value (bytes, &offset)
1930 || !extract_cu_value (bytes + 8, &type_offset))
1932 signature = extract_unsigned_integer (bytes + 16, 8, BFD_ENDIAN_LITTLE);
1935 type_sig = OBSTACK_ZALLOC (&objfile->objfile_obstack,
1936 struct signatured_type);
1937 type_sig->signature = signature;
1938 type_sig->type_offset = type_offset;
1939 type_sig->per_cu.debug_types_section = section;
1940 type_sig->per_cu.offset = offset;
1941 type_sig->per_cu.objfile = objfile;
1942 type_sig->per_cu.v.quick
1943 = OBSTACK_ZALLOC (&objfile->objfile_obstack,
1944 struct dwarf2_per_cu_quick_data);
1946 slot = htab_find_slot (sig_types_hash, type_sig, INSERT);
1949 dwarf2_per_objfile->all_type_units[i / 3] = &type_sig->per_cu;
1952 dwarf2_per_objfile->signatured_types = sig_types_hash;
1957 /* Read the address map data from the mapped index, and use it to
1958 populate the objfile's psymtabs_addrmap. */
1961 create_addrmap_from_index (struct objfile *objfile, struct mapped_index *index)
1963 const gdb_byte *iter, *end;
1964 struct obstack temp_obstack;
1965 struct addrmap *mutable_map;
1966 struct cleanup *cleanup;
1969 obstack_init (&temp_obstack);
1970 cleanup = make_cleanup_obstack_free (&temp_obstack);
1971 mutable_map = addrmap_create_mutable (&temp_obstack);
1973 iter = index->address_table;
1974 end = iter + index->address_table_size;
1976 baseaddr = ANOFFSET (objfile->section_offsets, SECT_OFF_TEXT (objfile));
1980 ULONGEST hi, lo, cu_index;
1981 lo = extract_unsigned_integer (iter, 8, BFD_ENDIAN_LITTLE);
1983 hi = extract_unsigned_integer (iter, 8, BFD_ENDIAN_LITTLE);
1985 cu_index = extract_unsigned_integer (iter, 4, BFD_ENDIAN_LITTLE);
1988 addrmap_set_empty (mutable_map, lo + baseaddr, hi + baseaddr - 1,
1989 dw2_get_cu (cu_index));
1992 objfile->psymtabs_addrmap = addrmap_create_fixed (mutable_map,
1993 &objfile->objfile_obstack);
1994 do_cleanups (cleanup);
1997 /* The hash function for strings in the mapped index. This is the same as
1998 SYMBOL_HASH_NEXT, but we keep a separate copy to maintain control over the
1999 implementation. This is necessary because the hash function is tied to the
2000 format of the mapped index file. The hash values do not have to match with
2003 Use INT_MAX for INDEX_VERSION if you generate the current index format. */
2006 mapped_index_string_hash (int index_version, const void *p)
2008 const unsigned char *str = (const unsigned char *) p;
2012 while ((c = *str++) != 0)
2014 if (index_version >= 5)
2016 r = r * 67 + c - 113;
2022 /* Find a slot in the mapped index INDEX for the object named NAME.
2023 If NAME is found, set *VEC_OUT to point to the CU vector in the
2024 constant pool and return 1. If NAME cannot be found, return 0. */
2027 find_slot_in_mapped_hash (struct mapped_index *index, const char *name,
2028 offset_type **vec_out)
2030 struct cleanup *back_to = make_cleanup (null_cleanup, 0);
2032 offset_type slot, step;
2033 int (*cmp) (const char *, const char *);
2035 if (current_language->la_language == language_cplus
2036 || current_language->la_language == language_java
2037 || current_language->la_language == language_fortran)
2039 /* NAME is already canonical. Drop any qualifiers as .gdb_index does
2041 const char *paren = strchr (name, '(');
2047 dup = xmalloc (paren - name + 1);
2048 memcpy (dup, name, paren - name);
2049 dup[paren - name] = 0;
2051 make_cleanup (xfree, dup);
2056 /* Index version 4 did not support case insensitive searches. But the
2057 indexes for case insensitive languages are built in lowercase, therefore
2058 simulate our NAME being searched is also lowercased. */
2059 hash = mapped_index_string_hash ((index->version == 4
2060 && case_sensitivity == case_sensitive_off
2061 ? 5 : index->version),
2064 slot = hash & (index->symbol_table_slots - 1);
2065 step = ((hash * 17) & (index->symbol_table_slots - 1)) | 1;
2066 cmp = (case_sensitivity == case_sensitive_on ? strcmp : strcasecmp);
2070 /* Convert a slot number to an offset into the table. */
2071 offset_type i = 2 * slot;
2073 if (index->symbol_table[i] == 0 && index->symbol_table[i + 1] == 0)
2075 do_cleanups (back_to);
2079 str = index->constant_pool + MAYBE_SWAP (index->symbol_table[i]);
2080 if (!cmp (name, str))
2082 *vec_out = (offset_type *) (index->constant_pool
2083 + MAYBE_SWAP (index->symbol_table[i + 1]));
2084 do_cleanups (back_to);
2088 slot = (slot + step) & (index->symbol_table_slots - 1);
2092 /* Read the index file. If everything went ok, initialize the "quick"
2093 elements of all the CUs and return 1. Otherwise, return 0. */
2096 dwarf2_read_index (struct objfile *objfile)
2099 struct mapped_index *map;
2100 offset_type *metadata;
2101 const gdb_byte *cu_list;
2102 const gdb_byte *types_list = NULL;
2103 offset_type version, cu_list_elements;
2104 offset_type types_list_elements = 0;
2107 if (dwarf2_section_empty_p (&dwarf2_per_objfile->gdb_index))
2110 /* Older elfutils strip versions could keep the section in the main
2111 executable while splitting it for the separate debug info file. */
2112 if ((bfd_get_file_flags (dwarf2_per_objfile->gdb_index.asection)
2113 & SEC_HAS_CONTENTS) == 0)
2116 dwarf2_read_section (objfile, &dwarf2_per_objfile->gdb_index);
2118 addr = dwarf2_per_objfile->gdb_index.buffer;
2119 /* Version check. */
2120 version = MAYBE_SWAP (*(offset_type *) addr);
2121 /* Versions earlier than 3 emitted every copy of a psymbol. This
2122 causes the index to behave very poorly for certain requests. Version 3
2123 contained incomplete addrmap. So, it seems better to just ignore such
2124 indices. Index version 4 uses a different hash function than index
2125 version 5 and later. */
2128 /* Indexes with higher version than the one supported by GDB may be no
2129 longer backward compatible. */
2133 map = OBSTACK_ZALLOC (&objfile->objfile_obstack, struct mapped_index);
2134 map->version = version;
2135 map->total_size = dwarf2_per_objfile->gdb_index.size;
2137 metadata = (offset_type *) (addr + sizeof (offset_type));
2140 cu_list = addr + MAYBE_SWAP (metadata[i]);
2141 cu_list_elements = ((MAYBE_SWAP (metadata[i + 1]) - MAYBE_SWAP (metadata[i]))
2145 types_list = addr + MAYBE_SWAP (metadata[i]);
2146 types_list_elements = ((MAYBE_SWAP (metadata[i + 1])
2147 - MAYBE_SWAP (metadata[i]))
2151 map->address_table = addr + MAYBE_SWAP (metadata[i]);
2152 map->address_table_size = (MAYBE_SWAP (metadata[i + 1])
2153 - MAYBE_SWAP (metadata[i]));
2156 map->symbol_table = (offset_type *) (addr + MAYBE_SWAP (metadata[i]));
2157 map->symbol_table_slots = ((MAYBE_SWAP (metadata[i + 1])
2158 - MAYBE_SWAP (metadata[i]))
2159 / (2 * sizeof (offset_type)));
2162 map->constant_pool = addr + MAYBE_SWAP (metadata[i]);
2164 if (!create_cus_from_index (objfile, cu_list, cu_list_elements))
2167 if (types_list_elements)
2169 struct dwarf2_section_info *section;
2171 /* We can only handle a single .debug_types when we have an
2173 if (VEC_length (dwarf2_section_info_def, dwarf2_per_objfile->types) != 1)
2176 section = VEC_index (dwarf2_section_info_def,
2177 dwarf2_per_objfile->types, 0);
2179 if (!create_signatured_type_table_from_index (objfile, section,
2181 types_list_elements))
2185 create_addrmap_from_index (objfile, map);
2187 dwarf2_per_objfile->index_table = map;
2188 dwarf2_per_objfile->using_index = 1;
2189 dwarf2_per_objfile->quick_file_names_table =
2190 create_quick_file_names_table (dwarf2_per_objfile->n_comp_units);
2195 /* A helper for the "quick" functions which sets the global
2196 dwarf2_per_objfile according to OBJFILE. */
2199 dw2_setup (struct objfile *objfile)
2201 dwarf2_per_objfile = objfile_data (objfile, dwarf2_objfile_data_key);
2202 gdb_assert (dwarf2_per_objfile);
2205 /* A helper for the "quick" functions which attempts to read the line
2206 table for THIS_CU. */
2208 static struct quick_file_names *
2209 dw2_get_file_names (struct objfile *objfile,
2210 struct dwarf2_per_cu_data *this_cu)
2212 bfd *abfd = objfile->obfd;
2213 struct line_header *lh;
2214 struct attribute *attr;
2215 struct cleanup *cleanups;
2216 struct die_info *comp_unit_die;
2217 struct dwarf2_section_info* sec;
2219 int has_children, i;
2220 struct dwarf2_cu cu;
2221 unsigned int bytes_read;
2222 struct die_reader_specs reader_specs;
2223 char *name, *comp_dir;
2225 struct quick_file_names *qfn;
2226 unsigned int line_offset;
2228 if (this_cu->v.quick->file_names != NULL)
2229 return this_cu->v.quick->file_names;
2230 /* If we know there is no line data, no point in looking again. */
2231 if (this_cu->v.quick->no_file_data)
2234 init_one_comp_unit (&cu, this_cu);
2235 cleanups = make_cleanup (free_stack_comp_unit, &cu);
2237 if (this_cu->debug_types_section)
2238 sec = this_cu->debug_types_section;
2240 sec = &dwarf2_per_objfile->info;
2241 dwarf2_read_section (objfile, sec);
2242 info_ptr = sec->buffer + this_cu->offset;
2244 info_ptr = read_and_check_comp_unit_head (&cu.header, sec, info_ptr,
2245 this_cu->debug_types_section != NULL);
2247 /* Skip dummy compilation units. */
2248 if (info_ptr >= (sec->buffer + sec->size)
2249 || peek_abbrev_code (abfd, info_ptr) == 0)
2251 do_cleanups (cleanups);
2255 dwarf2_read_abbrevs (&cu);
2256 make_cleanup (dwarf2_free_abbrev_table, &cu);
2258 init_cu_die_reader (&reader_specs, &cu);
2259 read_full_die (&reader_specs, &comp_unit_die, info_ptr,
2265 attr = dwarf2_attr (comp_unit_die, DW_AT_stmt_list, &cu);
2268 struct quick_file_names find_entry;
2270 line_offset = DW_UNSND (attr);
2272 /* We may have already read in this line header (TU line header sharing).
2273 If we have we're done. */
2274 find_entry.offset = line_offset;
2275 slot = htab_find_slot (dwarf2_per_objfile->quick_file_names_table,
2276 &find_entry, INSERT);
2279 do_cleanups (cleanups);
2280 this_cu->v.quick->file_names = *slot;
2284 lh = dwarf_decode_line_header (line_offset, abfd, &cu);
2288 do_cleanups (cleanups);
2289 this_cu->v.quick->no_file_data = 1;
2293 qfn = obstack_alloc (&objfile->objfile_obstack, sizeof (*qfn));
2294 qfn->offset = line_offset;
2295 gdb_assert (slot != NULL);
2298 find_file_and_directory (comp_unit_die, &cu, &name, &comp_dir);
2300 qfn->num_file_names = lh->num_file_names;
2301 qfn->file_names = obstack_alloc (&objfile->objfile_obstack,
2302 lh->num_file_names * sizeof (char *));
2303 for (i = 0; i < lh->num_file_names; ++i)
2304 qfn->file_names[i] = file_full_name (i + 1, lh, comp_dir);
2305 qfn->real_names = NULL;
2307 free_line_header (lh);
2308 do_cleanups (cleanups);
2310 this_cu->v.quick->file_names = qfn;
2314 /* A helper for the "quick" functions which computes and caches the
2315 real path for a given file name from the line table. */
2318 dw2_get_real_path (struct objfile *objfile,
2319 struct quick_file_names *qfn, int index)
2321 if (qfn->real_names == NULL)
2322 qfn->real_names = OBSTACK_CALLOC (&objfile->objfile_obstack,
2323 qfn->num_file_names, sizeof (char *));
2325 if (qfn->real_names[index] == NULL)
2326 qfn->real_names[index] = gdb_realpath (qfn->file_names[index]);
2328 return qfn->real_names[index];
2331 static struct symtab *
2332 dw2_find_last_source_symtab (struct objfile *objfile)
2336 dw2_setup (objfile);
2337 index = dwarf2_per_objfile->n_comp_units - 1;
2338 return dw2_instantiate_symtab (dw2_get_cu (index));
2341 /* Traversal function for dw2_forget_cached_source_info. */
2344 dw2_free_cached_file_names (void **slot, void *info)
2346 struct quick_file_names *file_data = (struct quick_file_names *) *slot;
2348 if (file_data->real_names)
2352 for (i = 0; i < file_data->num_file_names; ++i)
2354 xfree ((void*) file_data->real_names[i]);
2355 file_data->real_names[i] = NULL;
2363 dw2_forget_cached_source_info (struct objfile *objfile)
2365 dw2_setup (objfile);
2367 htab_traverse_noresize (dwarf2_per_objfile->quick_file_names_table,
2368 dw2_free_cached_file_names, NULL);
2371 /* Helper function for dw2_map_symtabs_matching_filename that expands
2372 the symtabs and calls the iterator. */
2375 dw2_map_expand_apply (struct objfile *objfile,
2376 struct dwarf2_per_cu_data *per_cu,
2378 const char *full_path, const char *real_path,
2379 int (*callback) (struct symtab *, void *),
2382 struct symtab *last_made = objfile->symtabs;
2384 /* Don't visit already-expanded CUs. */
2385 if (per_cu->v.quick->symtab)
2388 /* This may expand more than one symtab, and we want to iterate over
2390 dw2_instantiate_symtab (per_cu);
2392 return iterate_over_some_symtabs (name, full_path, real_path, callback, data,
2393 objfile->symtabs, last_made);
2396 /* Implementation of the map_symtabs_matching_filename method. */
2399 dw2_map_symtabs_matching_filename (struct objfile *objfile, const char *name,
2400 const char *full_path, const char *real_path,
2401 int (*callback) (struct symtab *, void *),
2405 const char *name_basename = lbasename (name);
2406 int name_len = strlen (name);
2407 int is_abs = IS_ABSOLUTE_PATH (name);
2409 dw2_setup (objfile);
2411 for (i = 0; i < (dwarf2_per_objfile->n_comp_units
2412 + dwarf2_per_objfile->n_type_units); ++i)
2415 struct dwarf2_per_cu_data *per_cu = dw2_get_cu (i);
2416 struct quick_file_names *file_data;
2418 /* We only need to look at symtabs not already expanded. */
2419 if (per_cu->v.quick->symtab)
2422 file_data = dw2_get_file_names (objfile, per_cu);
2423 if (file_data == NULL)
2426 for (j = 0; j < file_data->num_file_names; ++j)
2428 const char *this_name = file_data->file_names[j];
2430 if (FILENAME_CMP (name, this_name) == 0
2431 || (!is_abs && compare_filenames_for_search (this_name,
2434 if (dw2_map_expand_apply (objfile, per_cu,
2435 name, full_path, real_path,
2441 if (dw2_map_expand_apply (objfile, per_cu,
2442 name, full_path, real_path,
2447 /* Before we invoke realpath, which can get expensive when many
2448 files are involved, do a quick comparison of the basenames. */
2449 if (! basenames_may_differ
2450 && FILENAME_CMP (lbasename (this_name), name_basename) != 0)
2453 if (full_path != NULL)
2455 const char *this_real_name = dw2_get_real_path (objfile,
2458 if (this_real_name != NULL
2459 && (FILENAME_CMP (full_path, this_real_name) == 0
2461 && compare_filenames_for_search (this_real_name,
2464 if (dw2_map_expand_apply (objfile, per_cu,
2465 name, full_path, real_path,
2471 if (real_path != NULL)
2473 const char *this_real_name = dw2_get_real_path (objfile,
2476 if (this_real_name != NULL
2477 && (FILENAME_CMP (real_path, this_real_name) == 0
2479 && compare_filenames_for_search (this_real_name,
2482 if (dw2_map_expand_apply (objfile, per_cu,
2483 name, full_path, real_path,
2494 static struct symtab *
2495 dw2_lookup_symbol (struct objfile *objfile, int block_index,
2496 const char *name, domain_enum domain)
2498 /* We do all the work in the pre_expand_symtabs_matching hook
2503 /* A helper function that expands all symtabs that hold an object
2507 dw2_do_expand_symtabs_matching (struct objfile *objfile, const char *name)
2509 dw2_setup (objfile);
2511 /* index_table is NULL if OBJF_READNOW. */
2512 if (dwarf2_per_objfile->index_table)
2516 if (find_slot_in_mapped_hash (dwarf2_per_objfile->index_table,
2519 offset_type i, len = MAYBE_SWAP (*vec);
2520 for (i = 0; i < len; ++i)
2522 offset_type cu_index = MAYBE_SWAP (vec[i + 1]);
2523 struct dwarf2_per_cu_data *per_cu = dw2_get_cu (cu_index);
2525 dw2_instantiate_symtab (per_cu);
2532 dw2_pre_expand_symtabs_matching (struct objfile *objfile,
2533 enum block_enum block_kind, const char *name,
2536 dw2_do_expand_symtabs_matching (objfile, name);
2540 dw2_print_stats (struct objfile *objfile)
2544 dw2_setup (objfile);
2546 for (i = 0; i < (dwarf2_per_objfile->n_comp_units
2547 + dwarf2_per_objfile->n_type_units); ++i)
2549 struct dwarf2_per_cu_data *per_cu = dw2_get_cu (i);
2551 if (!per_cu->v.quick->symtab)
2554 printf_filtered (_(" Number of unread CUs: %d\n"), count);
2558 dw2_dump (struct objfile *objfile)
2560 /* Nothing worth printing. */
2564 dw2_relocate (struct objfile *objfile, struct section_offsets *new_offsets,
2565 struct section_offsets *delta)
2567 /* There's nothing to relocate here. */
2571 dw2_expand_symtabs_for_function (struct objfile *objfile,
2572 const char *func_name)
2574 dw2_do_expand_symtabs_matching (objfile, func_name);
2578 dw2_expand_all_symtabs (struct objfile *objfile)
2582 dw2_setup (objfile);
2584 for (i = 0; i < (dwarf2_per_objfile->n_comp_units
2585 + dwarf2_per_objfile->n_type_units); ++i)
2587 struct dwarf2_per_cu_data *per_cu = dw2_get_cu (i);
2589 dw2_instantiate_symtab (per_cu);
2594 dw2_expand_symtabs_with_filename (struct objfile *objfile,
2595 const char *filename)
2599 dw2_setup (objfile);
2601 /* We don't need to consider type units here.
2602 This is only called for examining code, e.g. expand_line_sal.
2603 There can be an order of magnitude (or more) more type units
2604 than comp units, and we avoid them if we can. */
2606 for (i = 0; i < dwarf2_per_objfile->n_comp_units; ++i)
2609 struct dwarf2_per_cu_data *per_cu = dw2_get_cu (i);
2610 struct quick_file_names *file_data;
2612 /* We only need to look at symtabs not already expanded. */
2613 if (per_cu->v.quick->symtab)
2616 file_data = dw2_get_file_names (objfile, per_cu);
2617 if (file_data == NULL)
2620 for (j = 0; j < file_data->num_file_names; ++j)
2622 const char *this_name = file_data->file_names[j];
2623 if (FILENAME_CMP (this_name, filename) == 0)
2625 dw2_instantiate_symtab (per_cu);
2633 dw2_find_symbol_file (struct objfile *objfile, const char *name)
2635 struct dwarf2_per_cu_data *per_cu;
2637 struct quick_file_names *file_data;
2639 dw2_setup (objfile);
2641 /* index_table is NULL if OBJF_READNOW. */
2642 if (!dwarf2_per_objfile->index_table)
2646 ALL_OBJFILE_SYMTABS (objfile, s)
2649 struct blockvector *bv = BLOCKVECTOR (s);
2650 const struct block *block = BLOCKVECTOR_BLOCK (bv, GLOBAL_BLOCK);
2651 struct symbol *sym = lookup_block_symbol (block, name, VAR_DOMAIN);
2654 return sym->symtab->filename;
2659 if (!find_slot_in_mapped_hash (dwarf2_per_objfile->index_table,
2663 /* Note that this just looks at the very first one named NAME -- but
2664 actually we are looking for a function. find_main_filename
2665 should be rewritten so that it doesn't require a custom hook. It
2666 could just use the ordinary symbol tables. */
2667 /* vec[0] is the length, which must always be >0. */
2668 per_cu = dw2_get_cu (MAYBE_SWAP (vec[1]));
2670 file_data = dw2_get_file_names (objfile, per_cu);
2671 if (file_data == NULL)
2674 return file_data->file_names[file_data->num_file_names - 1];
2678 dw2_map_matching_symbols (const char * name, domain_enum namespace,
2679 struct objfile *objfile, int global,
2680 int (*callback) (struct block *,
2681 struct symbol *, void *),
2682 void *data, symbol_compare_ftype *match,
2683 symbol_compare_ftype *ordered_compare)
2685 /* Currently unimplemented; used for Ada. The function can be called if the
2686 current language is Ada for a non-Ada objfile using GNU index. As Ada
2687 does not look for non-Ada symbols this function should just return. */
2691 dw2_expand_symtabs_matching
2692 (struct objfile *objfile,
2693 int (*file_matcher) (const char *, void *),
2694 int (*name_matcher) (const struct language_defn *, const char *, void *),
2695 enum search_domain kind,
2700 struct mapped_index *index;
2702 dw2_setup (objfile);
2704 /* index_table is NULL if OBJF_READNOW. */
2705 if (!dwarf2_per_objfile->index_table)
2707 index = dwarf2_per_objfile->index_table;
2709 if (file_matcher != NULL)
2710 for (i = 0; i < (dwarf2_per_objfile->n_comp_units
2711 + dwarf2_per_objfile->n_type_units); ++i)
2714 struct dwarf2_per_cu_data *per_cu = dw2_get_cu (i);
2715 struct quick_file_names *file_data;
2717 per_cu->v.quick->mark = 0;
2719 /* We only need to look at symtabs not already expanded. */
2720 if (per_cu->v.quick->symtab)
2723 file_data = dw2_get_file_names (objfile, per_cu);
2724 if (file_data == NULL)
2727 for (j = 0; j < file_data->num_file_names; ++j)
2729 if (file_matcher (file_data->file_names[j], data))
2731 per_cu->v.quick->mark = 1;
2737 for (iter = 0; iter < index->symbol_table_slots; ++iter)
2739 offset_type idx = 2 * iter;
2741 offset_type *vec, vec_len, vec_idx;
2743 if (index->symbol_table[idx] == 0 && index->symbol_table[idx + 1] == 0)
2746 name = index->constant_pool + MAYBE_SWAP (index->symbol_table[idx]);
2748 if (! (*name_matcher) (current_language, name, data))
2751 /* The name was matched, now expand corresponding CUs that were
2753 vec = (offset_type *) (index->constant_pool
2754 + MAYBE_SWAP (index->symbol_table[idx + 1]));
2755 vec_len = MAYBE_SWAP (vec[0]);
2756 for (vec_idx = 0; vec_idx < vec_len; ++vec_idx)
2758 struct dwarf2_per_cu_data *per_cu;
2760 per_cu = dw2_get_cu (MAYBE_SWAP (vec[vec_idx + 1]));
2761 if (file_matcher == NULL || per_cu->v.quick->mark)
2762 dw2_instantiate_symtab (per_cu);
2767 static struct symtab *
2768 dw2_find_pc_sect_symtab (struct objfile *objfile,
2769 struct minimal_symbol *msymbol,
2771 struct obj_section *section,
2774 struct dwarf2_per_cu_data *data;
2776 dw2_setup (objfile);
2778 if (!objfile->psymtabs_addrmap)
2781 data = addrmap_find (objfile->psymtabs_addrmap, pc);
2785 if (warn_if_readin && data->v.quick->symtab)
2786 warning (_("(Internal error: pc %s in read in CU, but not in symtab.)"),
2787 paddress (get_objfile_arch (objfile), pc));
2789 return dw2_instantiate_symtab (data);
2793 dw2_map_symbol_filenames (struct objfile *objfile, symbol_filename_ftype *fun,
2794 void *data, int need_fullname)
2798 dw2_setup (objfile);
2800 for (i = 0; i < (dwarf2_per_objfile->n_comp_units
2801 + dwarf2_per_objfile->n_type_units); ++i)
2804 struct dwarf2_per_cu_data *per_cu = dw2_get_cu (i);
2805 struct quick_file_names *file_data;
2807 /* We only need to look at symtabs not already expanded. */
2808 if (per_cu->v.quick->symtab)
2811 file_data = dw2_get_file_names (objfile, per_cu);
2812 if (file_data == NULL)
2815 for (j = 0; j < file_data->num_file_names; ++j)
2817 const char *this_real_name;
2820 this_real_name = dw2_get_real_path (objfile, file_data, j);
2822 this_real_name = NULL;
2823 (*fun) (file_data->file_names[j], this_real_name, data);
2829 dw2_has_symbols (struct objfile *objfile)
2834 const struct quick_symbol_functions dwarf2_gdb_index_functions =
2837 dw2_find_last_source_symtab,
2838 dw2_forget_cached_source_info,
2839 dw2_map_symtabs_matching_filename,
2841 dw2_pre_expand_symtabs_matching,
2845 dw2_expand_symtabs_for_function,
2846 dw2_expand_all_symtabs,
2847 dw2_expand_symtabs_with_filename,
2848 dw2_find_symbol_file,
2849 dw2_map_matching_symbols,
2850 dw2_expand_symtabs_matching,
2851 dw2_find_pc_sect_symtab,
2852 dw2_map_symbol_filenames
2855 /* Initialize for reading DWARF for this objfile. Return 0 if this
2856 file will use psymtabs, or 1 if using the GNU index. */
2859 dwarf2_initialize_objfile (struct objfile *objfile)
2861 /* If we're about to read full symbols, don't bother with the
2862 indices. In this case we also don't care if some other debug
2863 format is making psymtabs, because they are all about to be
2865 if ((objfile->flags & OBJF_READNOW))
2869 dwarf2_per_objfile->using_index = 1;
2870 create_all_comp_units (objfile);
2871 create_debug_types_hash_table (objfile);
2872 dwarf2_per_objfile->quick_file_names_table =
2873 create_quick_file_names_table (dwarf2_per_objfile->n_comp_units);
2875 for (i = 0; i < (dwarf2_per_objfile->n_comp_units
2876 + dwarf2_per_objfile->n_type_units); ++i)
2878 struct dwarf2_per_cu_data *per_cu = dw2_get_cu (i);
2880 per_cu->v.quick = OBSTACK_ZALLOC (&objfile->objfile_obstack,
2881 struct dwarf2_per_cu_quick_data);
2884 /* Return 1 so that gdb sees the "quick" functions. However,
2885 these functions will be no-ops because we will have expanded
2890 if (dwarf2_read_index (objfile))
2898 /* Build a partial symbol table. */
2901 dwarf2_build_psymtabs (struct objfile *objfile)
2903 if (objfile->global_psymbols.size == 0 && objfile->static_psymbols.size == 0)
2905 init_psymbol_list (objfile, 1024);
2908 dwarf2_build_psymtabs_hard (objfile);
2911 /* Return TRUE if OFFSET is within CU_HEADER. */
2914 offset_in_cu_p (const struct comp_unit_head *cu_header, unsigned int offset)
2916 unsigned int bottom = cu_header->offset;
2917 unsigned int top = (cu_header->offset
2919 + cu_header->initial_length_size);
2921 return (offset >= bottom && offset < top);
2924 /* Read in the comp unit header information from the debug_info at info_ptr.
2925 NOTE: This leaves members offset, first_die_offset to be filled in
2929 read_comp_unit_head (struct comp_unit_head *cu_header,
2930 gdb_byte *info_ptr, bfd *abfd)
2933 unsigned int bytes_read;
2935 cu_header->length = read_initial_length (abfd, info_ptr, &bytes_read);
2936 cu_header->initial_length_size = bytes_read;
2937 cu_header->offset_size = (bytes_read == 4) ? 4 : 8;
2938 info_ptr += bytes_read;
2939 cu_header->version = read_2_bytes (abfd, info_ptr);
2941 cu_header->abbrev_offset = read_offset (abfd, info_ptr, cu_header,
2943 info_ptr += bytes_read;
2944 cu_header->addr_size = read_1_byte (abfd, info_ptr);
2946 signed_addr = bfd_get_sign_extend_vma (abfd);
2947 if (signed_addr < 0)
2948 internal_error (__FILE__, __LINE__,
2949 _("read_comp_unit_head: dwarf from non elf file"));
2950 cu_header->signed_addr_p = signed_addr;
2955 /* Subroutine of read_and_check_comp_unit_head and
2956 read_and_check_type_unit_head to simplify them.
2957 Perform various error checking on the header. */
2960 error_check_comp_unit_head (struct comp_unit_head *header,
2961 struct dwarf2_section_info *section)
2963 bfd *abfd = section->asection->owner;
2964 const char *filename = bfd_get_filename (abfd);
2966 if (header->version != 2 && header->version != 3 && header->version != 4)
2967 error (_("Dwarf Error: wrong version in compilation unit header "
2968 "(is %d, should be 2, 3, or 4) [in module %s]"), header->version,
2971 if (header->abbrev_offset
2972 >= dwarf2_section_size (dwarf2_per_objfile->objfile,
2973 &dwarf2_per_objfile->abbrev))
2974 error (_("Dwarf Error: bad offset (0x%lx) in compilation unit header "
2975 "(offset 0x%lx + 6) [in module %s]"),
2976 (long) header->abbrev_offset, (long) header->offset,
2979 /* Cast to unsigned long to use 64-bit arithmetic when possible to
2980 avoid potential 32-bit overflow. */
2981 if (((unsigned long) header->offset
2982 + header->length + header->initial_length_size)
2984 error (_("Dwarf Error: bad length (0x%lx) in compilation unit header "
2985 "(offset 0x%lx + 0) [in module %s]"),
2986 (long) header->length, (long) header->offset,
2990 /* Read in a CU/TU header and perform some basic error checking.
2991 The contents of the header are stored in HEADER.
2992 The result is a pointer to the start of the first DIE. */
2995 read_and_check_comp_unit_head (struct comp_unit_head *header,
2996 struct dwarf2_section_info *section,
2998 int is_debug_types_section)
3000 gdb_byte *beg_of_comp_unit = info_ptr;
3001 bfd *abfd = section->asection->owner;
3003 header->offset = beg_of_comp_unit - section->buffer;
3005 info_ptr = read_comp_unit_head (header, info_ptr, abfd);
3007 /* If we're reading a type unit, skip over the signature and
3008 type_offset fields. */
3009 if (is_debug_types_section)
3010 info_ptr += 8 /*signature*/ + header->offset_size;
3012 header->first_die_offset = info_ptr - beg_of_comp_unit;
3014 error_check_comp_unit_head (header, section);
3019 /* Read in the types comp unit header information from .debug_types entry at
3020 types_ptr. The result is a pointer to one past the end of the header. */
3023 read_and_check_type_unit_head (struct comp_unit_head *header,
3024 struct dwarf2_section_info *section,
3026 ULONGEST *signature, unsigned int *type_offset)
3028 gdb_byte *beg_of_comp_unit = info_ptr;
3029 bfd *abfd = section->asection->owner;
3031 header->offset = beg_of_comp_unit - section->buffer;
3033 info_ptr = read_comp_unit_head (header, info_ptr, abfd);
3035 /* If we're reading a type unit, skip over the signature and
3036 type_offset fields. */
3037 if (signature != NULL)
3038 *signature = read_8_bytes (abfd, info_ptr);
3040 if (type_offset != NULL)
3041 *type_offset = read_offset_1 (abfd, info_ptr, header->offset_size);
3042 info_ptr += header->offset_size;
3044 header->first_die_offset = info_ptr - beg_of_comp_unit;
3046 error_check_comp_unit_head (header, section);
3051 /* Allocate a new partial symtab for file named NAME and mark this new
3052 partial symtab as being an include of PST. */
3055 dwarf2_create_include_psymtab (char *name, struct partial_symtab *pst,
3056 struct objfile *objfile)
3058 struct partial_symtab *subpst = allocate_psymtab (name, objfile);
3060 subpst->section_offsets = pst->section_offsets;
3061 subpst->textlow = 0;
3062 subpst->texthigh = 0;
3064 subpst->dependencies = (struct partial_symtab **)
3065 obstack_alloc (&objfile->objfile_obstack,
3066 sizeof (struct partial_symtab *));
3067 subpst->dependencies[0] = pst;
3068 subpst->number_of_dependencies = 1;
3070 subpst->globals_offset = 0;
3071 subpst->n_global_syms = 0;
3072 subpst->statics_offset = 0;
3073 subpst->n_static_syms = 0;
3074 subpst->symtab = NULL;
3075 subpst->read_symtab = pst->read_symtab;
3078 /* No private part is necessary for include psymtabs. This property
3079 can be used to differentiate between such include psymtabs and
3080 the regular ones. */
3081 subpst->read_symtab_private = NULL;
3084 /* Read the Line Number Program data and extract the list of files
3085 included by the source file represented by PST. Build an include
3086 partial symtab for each of these included files. */
3089 dwarf2_build_include_psymtabs (struct dwarf2_cu *cu,
3090 struct die_info *die,
3091 struct partial_symtab *pst)
3093 struct objfile *objfile = cu->objfile;
3094 bfd *abfd = objfile->obfd;
3095 struct line_header *lh = NULL;
3096 struct attribute *attr;
3098 attr = dwarf2_attr (die, DW_AT_stmt_list, cu);
3101 unsigned int line_offset = DW_UNSND (attr);
3103 lh = dwarf_decode_line_header (line_offset, abfd, cu);
3106 return; /* No linetable, so no includes. */
3108 /* NOTE: pst->dirname is DW_AT_comp_dir (if present). */
3109 dwarf_decode_lines (lh, pst->dirname, cu, pst, 1);
3111 free_line_header (lh);
3115 hash_type_signature (const void *item)
3117 const struct signatured_type *type_sig = item;
3119 /* This drops the top 32 bits of the signature, but is ok for a hash. */
3120 return type_sig->signature;
3124 eq_type_signature (const void *item_lhs, const void *item_rhs)
3126 const struct signatured_type *lhs = item_lhs;
3127 const struct signatured_type *rhs = item_rhs;
3129 return lhs->signature == rhs->signature;
3132 /* Allocate a hash table for signatured types. */
3135 allocate_signatured_type_table (struct objfile *objfile)
3137 return htab_create_alloc_ex (41,
3138 hash_type_signature,
3141 &objfile->objfile_obstack,
3142 hashtab_obstack_allocate,
3143 dummy_obstack_deallocate);
3146 /* A helper function to add a signatured type CU to a table. */
3149 add_signatured_type_cu_to_table (void **slot, void *datum)
3151 struct signatured_type *sigt = *slot;
3152 struct dwarf2_per_cu_data ***datap = datum;
3154 **datap = &sigt->per_cu;
3160 /* Create the hash table of all entries in the .debug_types section(s).
3161 The result is zero if there is an error (e.g. missing .debug_types section),
3162 otherwise non-zero. */
3165 create_debug_types_hash_table (struct objfile *objfile)
3167 htab_t types_htab = NULL;
3168 struct dwarf2_per_cu_data **iter;
3170 struct dwarf2_section_info *section;
3172 if (VEC_empty (dwarf2_section_info_def, dwarf2_per_objfile->types))
3174 dwarf2_per_objfile->signatured_types = NULL;
3179 VEC_iterate (dwarf2_section_info_def, dwarf2_per_objfile->types,
3183 gdb_byte *info_ptr, *end_ptr;
3185 dwarf2_read_section (objfile, section);
3186 info_ptr = section->buffer;
3188 if (info_ptr == NULL)
3191 if (types_htab == NULL)
3192 types_htab = allocate_signatured_type_table (objfile);
3194 if (dwarf2_die_debug)
3195 fprintf_unfiltered (gdb_stdlog, "Signatured types:\n");
3197 end_ptr = info_ptr + section->size;
3198 while (info_ptr < end_ptr)
3200 unsigned int offset;
3201 unsigned int type_offset;
3203 struct signatured_type *type_sig;
3205 gdb_byte *ptr = info_ptr;
3206 struct comp_unit_head header;
3208 offset = ptr - section->buffer;
3210 /* We need to read the type's signature in order to build the hash
3211 table, but we don't need anything else just yet. */
3213 ptr = read_and_check_type_unit_head (&header, section, ptr,
3214 &signature, &type_offset);
3216 /* Skip dummy type units. */
3217 if (ptr >= end_ptr || peek_abbrev_code (objfile->obfd, ptr) == 0)
3219 info_ptr = info_ptr + header.initial_length_size + header.length;
3223 type_sig = obstack_alloc (&objfile->objfile_obstack, sizeof (*type_sig));
3224 memset (type_sig, 0, sizeof (*type_sig));
3225 type_sig->signature = signature;
3226 type_sig->type_offset = type_offset;
3227 type_sig->per_cu.objfile = objfile;
3228 type_sig->per_cu.debug_types_section = section;
3229 type_sig->per_cu.offset = offset;
3231 slot = htab_find_slot (types_htab, type_sig, INSERT);
3232 gdb_assert (slot != NULL);
3235 const struct signatured_type *dup_sig = *slot;
3237 complaint (&symfile_complaints,
3238 _("debug type entry at offset 0x%x is duplicate to the "
3239 "entry at offset 0x%x, signature 0x%s"),
3240 offset, dup_sig->per_cu.offset,
3241 phex (signature, sizeof (signature)));
3242 gdb_assert (signature == dup_sig->signature);
3246 if (dwarf2_die_debug)
3247 fprintf_unfiltered (gdb_stdlog, " offset 0x%x, signature 0x%s\n",
3248 offset, phex (signature, sizeof (signature)));
3250 info_ptr = info_ptr + header.initial_length_size + header.length;
3254 dwarf2_per_objfile->signatured_types = types_htab;
3256 dwarf2_per_objfile->n_type_units = htab_elements (types_htab);
3257 dwarf2_per_objfile->all_type_units
3258 = obstack_alloc (&objfile->objfile_obstack,
3259 dwarf2_per_objfile->n_type_units
3260 * sizeof (struct dwarf2_per_cu_data *));
3261 iter = &dwarf2_per_objfile->all_type_units[0];
3262 htab_traverse_noresize (types_htab, add_signatured_type_cu_to_table, &iter);
3263 gdb_assert (iter - &dwarf2_per_objfile->all_type_units[0]
3264 == dwarf2_per_objfile->n_type_units);
3269 /* Lookup a signature based type.
3270 Returns NULL if SIG is not present in the table. */
3272 static struct signatured_type *
3273 lookup_signatured_type (struct objfile *objfile, ULONGEST sig)
3275 struct signatured_type find_entry, *entry;
3277 if (dwarf2_per_objfile->signatured_types == NULL)
3279 complaint (&symfile_complaints,
3280 _("missing `.debug_types' section for DW_FORM_ref_sig8 die"));
3284 find_entry.signature = sig;
3285 entry = htab_find (dwarf2_per_objfile->signatured_types, &find_entry);
3289 /* Initialize a die_reader_specs struct from a dwarf2_cu struct. */
3292 init_cu_die_reader (struct die_reader_specs *reader,
3293 struct dwarf2_cu *cu)
3295 reader->abfd = cu->objfile->obfd;
3297 if (cu->per_cu->debug_types_section)
3299 gdb_assert (cu->per_cu->debug_types_section->readin);
3300 reader->buffer = cu->per_cu->debug_types_section->buffer;
3304 gdb_assert (dwarf2_per_objfile->info.readin);
3305 reader->buffer = dwarf2_per_objfile->info.buffer;
3309 /* Find the base address of the compilation unit for range lists and
3310 location lists. It will normally be specified by DW_AT_low_pc.
3311 In DWARF-3 draft 4, the base address could be overridden by
3312 DW_AT_entry_pc. It's been removed, but GCC still uses this for
3313 compilation units with discontinuous ranges. */
3316 dwarf2_find_base_address (struct die_info *die, struct dwarf2_cu *cu)
3318 struct attribute *attr;
3321 cu->base_address = 0;
3323 attr = dwarf2_attr (die, DW_AT_entry_pc, cu);
3326 cu->base_address = DW_ADDR (attr);
3331 attr = dwarf2_attr (die, DW_AT_low_pc, cu);
3334 cu->base_address = DW_ADDR (attr);
3340 /* Subroutine of process_type_comp_unit and dwarf2_build_psymtabs_hard
3341 to combine the common parts.
3342 Process compilation unit THIS_CU for a psymtab.
3343 SECTION is the section the CU/TU comes from,
3344 either .debug_info or .debug_types. */
3347 process_psymtab_comp_unit (struct dwarf2_per_cu_data *this_cu,
3348 struct dwarf2_section_info *section,
3349 int is_debug_types_section)
3351 struct objfile *objfile = this_cu->objfile;
3352 bfd *abfd = objfile->obfd;
3353 gdb_byte *buffer = section->buffer;
3354 gdb_byte *info_ptr = buffer + this_cu->offset;
3355 unsigned int buffer_size = section->size;
3356 gdb_byte *beg_of_comp_unit = info_ptr;
3357 struct die_info *comp_unit_die;
3358 struct partial_symtab *pst;
3360 struct cleanup *back_to_inner;
3361 struct dwarf2_cu cu;
3362 int has_children, has_pc_info;
3363 struct attribute *attr;
3364 CORE_ADDR best_lowpc = 0, best_highpc = 0;
3365 struct die_reader_specs reader_specs;
3366 const char *filename;
3368 /* If this compilation unit was already read in, free the
3369 cached copy in order to read it in again. This is
3370 necessary because we skipped some symbols when we first
3371 read in the compilation unit (see load_partial_dies).
3372 This problem could be avoided, but the benefit is
3374 if (this_cu->cu != NULL)
3375 free_one_cached_comp_unit (this_cu->cu);
3377 /* Note that this is a pointer to our stack frame, being
3378 added to a global data structure. It will be cleaned up
3379 in free_stack_comp_unit when we finish with this
3380 compilation unit. */
3381 init_one_comp_unit (&cu, this_cu);
3382 back_to_inner = make_cleanup (free_stack_comp_unit, &cu);
3384 info_ptr = read_and_check_comp_unit_head (&cu.header, section, info_ptr,
3385 is_debug_types_section);
3387 /* Skip dummy compilation units. */
3388 if (info_ptr >= buffer + buffer_size
3389 || peek_abbrev_code (abfd, info_ptr) == 0)
3391 do_cleanups (back_to_inner);
3395 cu.list_in_scope = &file_symbols;
3397 /* Read the abbrevs for this compilation unit into a table. */
3398 dwarf2_read_abbrevs (&cu);
3399 make_cleanup (dwarf2_free_abbrev_table, &cu);
3401 /* Read the compilation unit die. */
3402 init_cu_die_reader (&reader_specs, &cu);
3403 info_ptr = read_full_die (&reader_specs, &comp_unit_die, info_ptr,
3406 if (is_debug_types_section)
3408 /* LENGTH has not been set yet for type units. */
3409 gdb_assert (this_cu->offset == cu.header.offset);
3410 this_cu->length = cu.header.length + cu.header.initial_length_size;
3412 else if (comp_unit_die->tag == DW_TAG_partial_unit)
3414 do_cleanups (back_to_inner);
3418 prepare_one_comp_unit (&cu, comp_unit_die);
3420 /* Allocate a new partial symbol table structure. */
3421 attr = dwarf2_attr (comp_unit_die, DW_AT_name, &cu);
3422 if (attr == NULL || !DW_STRING (attr))
3425 filename = DW_STRING (attr);
3426 pst = start_psymtab_common (objfile, objfile->section_offsets,
3428 /* TEXTLOW and TEXTHIGH are set below. */
3430 objfile->global_psymbols.next,
3431 objfile->static_psymbols.next);
3432 pst->psymtabs_addrmap_supported = 1;
3434 attr = dwarf2_attr (comp_unit_die, DW_AT_comp_dir, &cu);
3436 pst->dirname = DW_STRING (attr);
3438 pst->read_symtab_private = this_cu;
3440 baseaddr = ANOFFSET (objfile->section_offsets, SECT_OFF_TEXT (objfile));
3442 /* Store the function that reads in the rest of the symbol table. */
3443 pst->read_symtab = dwarf2_psymtab_to_symtab;
3445 this_cu->v.psymtab = pst;
3447 dwarf2_find_base_address (comp_unit_die, &cu);
3449 /* Possibly set the default values of LOWPC and HIGHPC from
3451 has_pc_info = dwarf2_get_pc_bounds (comp_unit_die, &best_lowpc,
3452 &best_highpc, &cu, pst);
3453 if (has_pc_info == 1 && best_lowpc < best_highpc)
3454 /* Store the contiguous range if it is not empty; it can be empty for
3455 CUs with no code. */
3456 addrmap_set_empty (objfile->psymtabs_addrmap,
3457 best_lowpc + baseaddr,
3458 best_highpc + baseaddr - 1, pst);
3460 /* Check if comp unit has_children.
3461 If so, read the rest of the partial symbols from this comp unit.
3462 If not, there's no more debug_info for this comp unit. */
3465 struct partial_die_info *first_die;
3466 CORE_ADDR lowpc, highpc;
3468 lowpc = ((CORE_ADDR) -1);
3469 highpc = ((CORE_ADDR) 0);
3471 first_die = load_partial_dies (abfd, buffer, info_ptr, 1, &cu);
3473 scan_partial_symbols (first_die, &lowpc, &highpc,
3474 ! has_pc_info, &cu);
3476 /* If we didn't find a lowpc, set it to highpc to avoid
3477 complaints from `maint check'. */
3478 if (lowpc == ((CORE_ADDR) -1))
3481 /* If the compilation unit didn't have an explicit address range,
3482 then use the information extracted from its child dies. */
3486 best_highpc = highpc;
3489 pst->textlow = best_lowpc + baseaddr;
3490 pst->texthigh = best_highpc + baseaddr;
3492 pst->n_global_syms = objfile->global_psymbols.next -
3493 (objfile->global_psymbols.list + pst->globals_offset);
3494 pst->n_static_syms = objfile->static_psymbols.next -
3495 (objfile->static_psymbols.list + pst->statics_offset);
3496 sort_pst_symbols (pst);
3498 if (is_debug_types_section)
3500 /* It's not clear we want to do anything with stmt lists here.
3501 Waiting to see what gcc ultimately does. */
3505 /* Get the list of files included in the current compilation unit,
3506 and build a psymtab for each of them. */
3507 dwarf2_build_include_psymtabs (&cu, comp_unit_die, pst);
3510 do_cleanups (back_to_inner);
3513 /* Traversal function for htab_traverse_noresize.
3514 Process one .debug_types comp-unit. */
3517 process_type_comp_unit (void **slot, void *info)
3519 struct signatured_type *entry = (struct signatured_type *) *slot;
3520 struct dwarf2_per_cu_data *this_cu;
3522 gdb_assert (info == NULL);
3523 this_cu = &entry->per_cu;
3525 gdb_assert (this_cu->debug_types_section->readin);
3526 process_psymtab_comp_unit (this_cu, this_cu->debug_types_section, 1);
3531 /* Subroutine of dwarf2_build_psymtabs_hard to simplify it.
3532 Build partial symbol tables for the .debug_types comp-units. */
3535 build_type_psymtabs (struct objfile *objfile)
3537 if (! create_debug_types_hash_table (objfile))
3540 htab_traverse_noresize (dwarf2_per_objfile->signatured_types,
3541 process_type_comp_unit, NULL);
3544 /* A cleanup function that clears objfile's psymtabs_addrmap field. */
3547 psymtabs_addrmap_cleanup (void *o)
3549 struct objfile *objfile = o;
3551 objfile->psymtabs_addrmap = NULL;
3554 /* Build the partial symbol table by doing a quick pass through the
3555 .debug_info and .debug_abbrev sections. */
3558 dwarf2_build_psymtabs_hard (struct objfile *objfile)
3560 struct cleanup *back_to, *addrmap_cleanup;
3561 struct obstack temp_obstack;
3564 dwarf2_per_objfile->reading_partial_symbols = 1;
3566 dwarf2_read_section (objfile, &dwarf2_per_objfile->info);
3568 /* Any cached compilation units will be linked by the per-objfile
3569 read_in_chain. Make sure to free them when we're done. */
3570 back_to = make_cleanup (free_cached_comp_units, NULL);
3572 build_type_psymtabs (objfile);
3574 create_all_comp_units (objfile);
3576 /* Create a temporary address map on a temporary obstack. We later
3577 copy this to the final obstack. */
3578 obstack_init (&temp_obstack);
3579 make_cleanup_obstack_free (&temp_obstack);
3580 objfile->psymtabs_addrmap = addrmap_create_mutable (&temp_obstack);
3581 addrmap_cleanup = make_cleanup (psymtabs_addrmap_cleanup, objfile);
3583 for (i = 0; i < dwarf2_per_objfile->n_comp_units; ++i)
3585 struct dwarf2_per_cu_data *per_cu = dw2_get_cu (i);
3587 process_psymtab_comp_unit (per_cu, &dwarf2_per_objfile->info, 0);
3590 objfile->psymtabs_addrmap = addrmap_create_fixed (objfile->psymtabs_addrmap,
3591 &objfile->objfile_obstack);
3592 discard_cleanups (addrmap_cleanup);
3594 do_cleanups (back_to);
3597 /* Load the partial DIEs for a secondary CU into memory. */
3600 load_partial_comp_unit (struct dwarf2_per_cu_data *this_cu)
3602 struct objfile *objfile = this_cu->objfile;
3603 bfd *abfd = objfile->obfd;
3605 struct die_info *comp_unit_die;
3606 struct dwarf2_cu *cu;
3607 struct cleanup *free_abbrevs_cleanup, *free_cu_cleanup = NULL;
3609 struct die_reader_specs reader_specs;
3611 struct dwarf2_section_info *section = &dwarf2_per_objfile->info;
3613 gdb_assert (! this_cu->debug_types_section);
3615 gdb_assert (section->readin);
3616 info_ptr = section->buffer + this_cu->offset;
3618 if (this_cu->cu == NULL)
3620 cu = xmalloc (sizeof (*cu));
3621 init_one_comp_unit (cu, this_cu);
3625 /* If an error occurs while loading, release our storage. */
3626 free_cu_cleanup = make_cleanup (free_heap_comp_unit, cu);
3628 info_ptr = read_and_check_comp_unit_head (&cu->header, section, info_ptr,
3631 /* Skip dummy compilation units. */
3632 if (info_ptr >= (section->buffer + section->size)
3633 || peek_abbrev_code (abfd, info_ptr) == 0)
3635 do_cleanups (free_cu_cleanup);
3639 /* Link this CU into read_in_chain. */
3640 this_cu->cu->read_in_chain = dwarf2_per_objfile->read_in_chain;
3641 dwarf2_per_objfile->read_in_chain = this_cu;
3646 info_ptr += cu->header.first_die_offset;
3649 /* Read the abbrevs for this compilation unit into a table. */
3650 gdb_assert (cu->dwarf2_abbrevs == NULL);
3651 dwarf2_read_abbrevs (cu);
3652 free_abbrevs_cleanup = make_cleanup (dwarf2_free_abbrev_table, cu);
3654 /* Read the compilation unit die. */
3655 init_cu_die_reader (&reader_specs, cu);
3656 info_ptr = read_full_die (&reader_specs, &comp_unit_die, info_ptr,
3659 prepare_one_comp_unit (cu, comp_unit_die);
3661 /* Check if comp unit has_children.
3662 If so, read the rest of the partial symbols from this comp unit.
3663 If not, there's no more debug_info for this comp unit. */
3665 load_partial_dies (abfd, section->buffer, info_ptr, 0, cu);
3667 do_cleanups (free_abbrevs_cleanup);
3671 /* We've successfully allocated this compilation unit. Let our
3672 caller clean it up when finished with it. */
3673 discard_cleanups (free_cu_cleanup);
3677 /* Create a list of all compilation units in OBJFILE.
3678 This is only done for -readnow and building partial symtabs. */
3681 create_all_comp_units (struct objfile *objfile)
3685 struct dwarf2_per_cu_data **all_comp_units;
3688 dwarf2_read_section (objfile, &dwarf2_per_objfile->info);
3689 info_ptr = dwarf2_per_objfile->info.buffer;
3693 all_comp_units = xmalloc (n_allocated
3694 * sizeof (struct dwarf2_per_cu_data *));
3696 while (info_ptr < dwarf2_per_objfile->info.buffer
3697 + dwarf2_per_objfile->info.size)
3699 unsigned int length, initial_length_size;
3700 struct dwarf2_per_cu_data *this_cu;
3701 unsigned int offset;
3703 offset = info_ptr - dwarf2_per_objfile->info.buffer;
3705 /* Read just enough information to find out where the next
3706 compilation unit is. */
3707 length = read_initial_length (objfile->obfd, info_ptr,
3708 &initial_length_size);
3710 /* Save the compilation unit for later lookup. */
3711 this_cu = obstack_alloc (&objfile->objfile_obstack,
3712 sizeof (struct dwarf2_per_cu_data));
3713 memset (this_cu, 0, sizeof (*this_cu));
3714 this_cu->offset = offset;
3715 this_cu->length = length + initial_length_size;
3716 this_cu->objfile = objfile;
3718 if (n_comp_units == n_allocated)
3721 all_comp_units = xrealloc (all_comp_units,
3723 * sizeof (struct dwarf2_per_cu_data *));
3725 all_comp_units[n_comp_units++] = this_cu;
3727 info_ptr = info_ptr + this_cu->length;
3730 dwarf2_per_objfile->all_comp_units
3731 = obstack_alloc (&objfile->objfile_obstack,
3732 n_comp_units * sizeof (struct dwarf2_per_cu_data *));
3733 memcpy (dwarf2_per_objfile->all_comp_units, all_comp_units,
3734 n_comp_units * sizeof (struct dwarf2_per_cu_data *));
3735 xfree (all_comp_units);
3736 dwarf2_per_objfile->n_comp_units = n_comp_units;
3739 /* Process all loaded DIEs for compilation unit CU, starting at
3740 FIRST_DIE. The caller should pass NEED_PC == 1 if the compilation
3741 unit DIE did not have PC info (DW_AT_low_pc and DW_AT_high_pc, or
3742 DW_AT_ranges). If NEED_PC is set, then this function will set
3743 *LOWPC and *HIGHPC to the lowest and highest PC values found in CU
3744 and record the covered ranges in the addrmap. */
3747 scan_partial_symbols (struct partial_die_info *first_die, CORE_ADDR *lowpc,
3748 CORE_ADDR *highpc, int need_pc, struct dwarf2_cu *cu)
3750 struct partial_die_info *pdi;
3752 /* Now, march along the PDI's, descending into ones which have
3753 interesting children but skipping the children of the other ones,
3754 until we reach the end of the compilation unit. */
3760 fixup_partial_die (pdi, cu);
3762 /* Anonymous namespaces or modules have no name but have interesting
3763 children, so we need to look at them. Ditto for anonymous
3766 if (pdi->name != NULL || pdi->tag == DW_TAG_namespace
3767 || pdi->tag == DW_TAG_module || pdi->tag == DW_TAG_enumeration_type)
3771 case DW_TAG_subprogram:
3772 add_partial_subprogram (pdi, lowpc, highpc, need_pc, cu);
3774 case DW_TAG_constant:
3775 case DW_TAG_variable:
3776 case DW_TAG_typedef:
3777 case DW_TAG_union_type:
3778 if (!pdi->is_declaration)
3780 add_partial_symbol (pdi, cu);
3783 case DW_TAG_class_type:
3784 case DW_TAG_interface_type:
3785 case DW_TAG_structure_type:
3786 if (!pdi->is_declaration)
3788 add_partial_symbol (pdi, cu);
3791 case DW_TAG_enumeration_type:
3792 if (!pdi->is_declaration)
3793 add_partial_enumeration (pdi, cu);
3795 case DW_TAG_base_type:
3796 case DW_TAG_subrange_type:
3797 /* File scope base type definitions are added to the partial
3799 add_partial_symbol (pdi, cu);
3801 case DW_TAG_namespace:
3802 add_partial_namespace (pdi, lowpc, highpc, need_pc, cu);
3805 add_partial_module (pdi, lowpc, highpc, need_pc, cu);
3812 /* If the die has a sibling, skip to the sibling. */
3814 pdi = pdi->die_sibling;
3818 /* Functions used to compute the fully scoped name of a partial DIE.
3820 Normally, this is simple. For C++, the parent DIE's fully scoped
3821 name is concatenated with "::" and the partial DIE's name. For
3822 Java, the same thing occurs except that "." is used instead of "::".
3823 Enumerators are an exception; they use the scope of their parent
3824 enumeration type, i.e. the name of the enumeration type is not
3825 prepended to the enumerator.
3827 There are two complexities. One is DW_AT_specification; in this
3828 case "parent" means the parent of the target of the specification,
3829 instead of the direct parent of the DIE. The other is compilers
3830 which do not emit DW_TAG_namespace; in this case we try to guess
3831 the fully qualified name of structure types from their members'
3832 linkage names. This must be done using the DIE's children rather
3833 than the children of any DW_AT_specification target. We only need
3834 to do this for structures at the top level, i.e. if the target of
3835 any DW_AT_specification (if any; otherwise the DIE itself) does not
3838 /* Compute the scope prefix associated with PDI's parent, in
3839 compilation unit CU. The result will be allocated on CU's
3840 comp_unit_obstack, or a copy of the already allocated PDI->NAME
3841 field. NULL is returned if no prefix is necessary. */
3843 partial_die_parent_scope (struct partial_die_info *pdi,
3844 struct dwarf2_cu *cu)
3846 char *grandparent_scope;
3847 struct partial_die_info *parent, *real_pdi;
3849 /* We need to look at our parent DIE; if we have a DW_AT_specification,
3850 then this means the parent of the specification DIE. */
3853 while (real_pdi->has_specification)
3854 real_pdi = find_partial_die (real_pdi->spec_offset, cu);
3856 parent = real_pdi->die_parent;
3860 if (parent->scope_set)
3861 return parent->scope;
3863 fixup_partial_die (parent, cu);
3865 grandparent_scope = partial_die_parent_scope (parent, cu);
3867 /* GCC 4.0 and 4.1 had a bug (PR c++/28460) where they generated bogus
3868 DW_TAG_namespace DIEs with a name of "::" for the global namespace.
3869 Work around this problem here. */
3870 if (cu->language == language_cplus
3871 && parent->tag == DW_TAG_namespace
3872 && strcmp (parent->name, "::") == 0
3873 && grandparent_scope == NULL)
3875 parent->scope = NULL;
3876 parent->scope_set = 1;
3880 if (pdi->tag == DW_TAG_enumerator)
3881 /* Enumerators should not get the name of the enumeration as a prefix. */
3882 parent->scope = grandparent_scope;
3883 else if (parent->tag == DW_TAG_namespace
3884 || parent->tag == DW_TAG_module
3885 || parent->tag == DW_TAG_structure_type
3886 || parent->tag == DW_TAG_class_type
3887 || parent->tag == DW_TAG_interface_type
3888 || parent->tag == DW_TAG_union_type
3889 || parent->tag == DW_TAG_enumeration_type)
3891 if (grandparent_scope == NULL)
3892 parent->scope = parent->name;
3894 parent->scope = typename_concat (&cu->comp_unit_obstack,
3896 parent->name, 0, cu);
3900 /* FIXME drow/2004-04-01: What should we be doing with
3901 function-local names? For partial symbols, we should probably be
3903 complaint (&symfile_complaints,
3904 _("unhandled containing DIE tag %d for DIE at %d"),
3905 parent->tag, pdi->offset);
3906 parent->scope = grandparent_scope;
3909 parent->scope_set = 1;
3910 return parent->scope;
3913 /* Return the fully scoped name associated with PDI, from compilation unit
3914 CU. The result will be allocated with malloc. */
3916 partial_die_full_name (struct partial_die_info *pdi,
3917 struct dwarf2_cu *cu)
3921 /* If this is a template instantiation, we can not work out the
3922 template arguments from partial DIEs. So, unfortunately, we have
3923 to go through the full DIEs. At least any work we do building
3924 types here will be reused if full symbols are loaded later. */
3925 if (pdi->has_template_arguments)
3927 fixup_partial_die (pdi, cu);
3929 if (pdi->name != NULL && strchr (pdi->name, '<') == NULL)
3931 struct die_info *die;
3932 struct attribute attr;
3933 struct dwarf2_cu *ref_cu = cu;
3936 attr.form = DW_FORM_ref_addr;
3937 attr.u.addr = pdi->offset;
3938 die = follow_die_ref (NULL, &attr, &ref_cu);
3940 return xstrdup (dwarf2_full_name (NULL, die, ref_cu));
3944 parent_scope = partial_die_parent_scope (pdi, cu);
3945 if (parent_scope == NULL)
3948 return typename_concat (NULL, parent_scope, pdi->name, 0, cu);
3952 add_partial_symbol (struct partial_die_info *pdi, struct dwarf2_cu *cu)
3954 struct objfile *objfile = cu->objfile;
3956 char *actual_name = NULL;
3957 const struct partial_symbol *psym = NULL;
3959 int built_actual_name = 0;
3961 baseaddr = ANOFFSET (objfile->section_offsets, SECT_OFF_TEXT (objfile));
3963 actual_name = partial_die_full_name (pdi, cu);
3965 built_actual_name = 1;
3967 if (actual_name == NULL)
3968 actual_name = pdi->name;
3972 case DW_TAG_subprogram:
3973 if (pdi->is_external || cu->language == language_ada)
3975 /* brobecker/2007-12-26: Normally, only "external" DIEs are part
3976 of the global scope. But in Ada, we want to be able to access
3977 nested procedures globally. So all Ada subprograms are stored
3978 in the global scope. */
3979 /* prim_record_minimal_symbol (actual_name, pdi->lowpc + baseaddr,
3980 mst_text, objfile); */
3981 add_psymbol_to_list (actual_name, strlen (actual_name),
3983 VAR_DOMAIN, LOC_BLOCK,
3984 &objfile->global_psymbols,
3985 0, pdi->lowpc + baseaddr,
3986 cu->language, objfile);
3990 /* prim_record_minimal_symbol (actual_name, pdi->lowpc + baseaddr,
3991 mst_file_text, objfile); */
3992 add_psymbol_to_list (actual_name, strlen (actual_name),
3994 VAR_DOMAIN, LOC_BLOCK,
3995 &objfile->static_psymbols,
3996 0, pdi->lowpc + baseaddr,
3997 cu->language, objfile);
4000 case DW_TAG_constant:
4002 struct psymbol_allocation_list *list;
4004 if (pdi->is_external)
4005 list = &objfile->global_psymbols;
4007 list = &objfile->static_psymbols;
4008 add_psymbol_to_list (actual_name, strlen (actual_name),
4009 built_actual_name, VAR_DOMAIN, LOC_STATIC,
4010 list, 0, 0, cu->language, objfile);
4013 case DW_TAG_variable:
4015 addr = decode_locdesc (pdi->locdesc, cu);
4019 && !dwarf2_per_objfile->has_section_at_zero)
4021 /* A global or static variable may also have been stripped
4022 out by the linker if unused, in which case its address
4023 will be nullified; do not add such variables into partial
4024 symbol table then. */
4026 else if (pdi->is_external)
4029 Don't enter into the minimal symbol tables as there is
4030 a minimal symbol table entry from the ELF symbols already.
4031 Enter into partial symbol table if it has a location
4032 descriptor or a type.
4033 If the location descriptor is missing, new_symbol will create
4034 a LOC_UNRESOLVED symbol, the address of the variable will then
4035 be determined from the minimal symbol table whenever the variable
4037 The address for the partial symbol table entry is not
4038 used by GDB, but it comes in handy for debugging partial symbol
4041 if (pdi->locdesc || pdi->has_type)
4042 add_psymbol_to_list (actual_name, strlen (actual_name),
4044 VAR_DOMAIN, LOC_STATIC,
4045 &objfile->global_psymbols,
4047 cu->language, objfile);
4051 /* Static Variable. Skip symbols without location descriptors. */
4052 if (pdi->locdesc == NULL)
4054 if (built_actual_name)
4055 xfree (actual_name);
4058 /* prim_record_minimal_symbol (actual_name, addr + baseaddr,
4059 mst_file_data, objfile); */
4060 add_psymbol_to_list (actual_name, strlen (actual_name),
4062 VAR_DOMAIN, LOC_STATIC,
4063 &objfile->static_psymbols,
4065 cu->language, objfile);
4068 case DW_TAG_typedef:
4069 case DW_TAG_base_type:
4070 case DW_TAG_subrange_type:
4071 add_psymbol_to_list (actual_name, strlen (actual_name),
4073 VAR_DOMAIN, LOC_TYPEDEF,
4074 &objfile->static_psymbols,
4075 0, (CORE_ADDR) 0, cu->language, objfile);
4077 case DW_TAG_namespace:
4078 add_psymbol_to_list (actual_name, strlen (actual_name),
4080 VAR_DOMAIN, LOC_TYPEDEF,
4081 &objfile->global_psymbols,
4082 0, (CORE_ADDR) 0, cu->language, objfile);
4084 case DW_TAG_class_type:
4085 case DW_TAG_interface_type:
4086 case DW_TAG_structure_type:
4087 case DW_TAG_union_type:
4088 case DW_TAG_enumeration_type:
4089 /* Skip external references. The DWARF standard says in the section
4090 about "Structure, Union, and Class Type Entries": "An incomplete
4091 structure, union or class type is represented by a structure,
4092 union or class entry that does not have a byte size attribute
4093 and that has a DW_AT_declaration attribute." */
4094 if (!pdi->has_byte_size && pdi->is_declaration)
4096 if (built_actual_name)
4097 xfree (actual_name);
4101 /* NOTE: carlton/2003-10-07: See comment in new_symbol about
4102 static vs. global. */
4103 add_psymbol_to_list (actual_name, strlen (actual_name),
4105 STRUCT_DOMAIN, LOC_TYPEDEF,
4106 (cu->language == language_cplus
4107 || cu->language == language_java)
4108 ? &objfile->global_psymbols
4109 : &objfile->static_psymbols,
4110 0, (CORE_ADDR) 0, cu->language, objfile);
4113 case DW_TAG_enumerator:
4114 add_psymbol_to_list (actual_name, strlen (actual_name),
4116 VAR_DOMAIN, LOC_CONST,
4117 (cu->language == language_cplus
4118 || cu->language == language_java)
4119 ? &objfile->global_psymbols
4120 : &objfile->static_psymbols,
4121 0, (CORE_ADDR) 0, cu->language, objfile);
4127 if (built_actual_name)
4128 xfree (actual_name);
4131 /* Read a partial die corresponding to a namespace; also, add a symbol
4132 corresponding to that namespace to the symbol table. NAMESPACE is
4133 the name of the enclosing namespace. */
4136 add_partial_namespace (struct partial_die_info *pdi,
4137 CORE_ADDR *lowpc, CORE_ADDR *highpc,
4138 int need_pc, struct dwarf2_cu *cu)
4140 /* Add a symbol for the namespace. */
4142 add_partial_symbol (pdi, cu);
4144 /* Now scan partial symbols in that namespace. */
4146 if (pdi->has_children)
4147 scan_partial_symbols (pdi->die_child, lowpc, highpc, need_pc, cu);
4150 /* Read a partial die corresponding to a Fortran module. */
4153 add_partial_module (struct partial_die_info *pdi, CORE_ADDR *lowpc,
4154 CORE_ADDR *highpc, int need_pc, struct dwarf2_cu *cu)
4156 /* Now scan partial symbols in that module. */
4158 if (pdi->has_children)
4159 scan_partial_symbols (pdi->die_child, lowpc, highpc, need_pc, cu);
4162 /* Read a partial die corresponding to a subprogram and create a partial
4163 symbol for that subprogram. When the CU language allows it, this
4164 routine also defines a partial symbol for each nested subprogram
4165 that this subprogram contains.
4167 DIE my also be a lexical block, in which case we simply search
4168 recursively for suprograms defined inside that lexical block.
4169 Again, this is only performed when the CU language allows this
4170 type of definitions. */
4173 add_partial_subprogram (struct partial_die_info *pdi,
4174 CORE_ADDR *lowpc, CORE_ADDR *highpc,
4175 int need_pc, struct dwarf2_cu *cu)
4177 if (pdi->tag == DW_TAG_subprogram)
4179 if (pdi->has_pc_info)
4181 if (pdi->lowpc < *lowpc)
4182 *lowpc = pdi->lowpc;
4183 if (pdi->highpc > *highpc)
4184 *highpc = pdi->highpc;
4188 struct objfile *objfile = cu->objfile;
4190 baseaddr = ANOFFSET (objfile->section_offsets,
4191 SECT_OFF_TEXT (objfile));
4192 addrmap_set_empty (objfile->psymtabs_addrmap,
4193 pdi->lowpc + baseaddr,
4194 pdi->highpc - 1 + baseaddr,
4195 cu->per_cu->v.psymtab);
4197 if (!pdi->is_declaration)
4198 /* Ignore subprogram DIEs that do not have a name, they are
4199 illegal. Do not emit a complaint at this point, we will
4200 do so when we convert this psymtab into a symtab. */
4202 add_partial_symbol (pdi, cu);
4206 if (! pdi->has_children)
4209 if (cu->language == language_ada)
4211 pdi = pdi->die_child;
4214 fixup_partial_die (pdi, cu);
4215 if (pdi->tag == DW_TAG_subprogram
4216 || pdi->tag == DW_TAG_lexical_block)
4217 add_partial_subprogram (pdi, lowpc, highpc, need_pc, cu);
4218 pdi = pdi->die_sibling;
4223 /* Read a partial die corresponding to an enumeration type. */
4226 add_partial_enumeration (struct partial_die_info *enum_pdi,
4227 struct dwarf2_cu *cu)
4229 struct partial_die_info *pdi;
4231 if (enum_pdi->name != NULL)
4232 add_partial_symbol (enum_pdi, cu);
4234 pdi = enum_pdi->die_child;
4237 if (pdi->tag != DW_TAG_enumerator || pdi->name == NULL)
4238 complaint (&symfile_complaints, _("malformed enumerator DIE ignored"));
4240 add_partial_symbol (pdi, cu);
4241 pdi = pdi->die_sibling;
4245 /* Return the initial uleb128 in the die at INFO_PTR. */
4248 peek_abbrev_code (bfd *abfd, gdb_byte *info_ptr)
4250 unsigned int bytes_read;
4252 return read_unsigned_leb128 (abfd, info_ptr, &bytes_read);
4255 /* Read the initial uleb128 in the die at INFO_PTR in compilation unit CU.
4256 Return the corresponding abbrev, or NULL if the number is zero (indicating
4257 an empty DIE). In either case *BYTES_READ will be set to the length of
4258 the initial number. */
4260 static struct abbrev_info *
4261 peek_die_abbrev (gdb_byte *info_ptr, unsigned int *bytes_read,
4262 struct dwarf2_cu *cu)
4264 bfd *abfd = cu->objfile->obfd;
4265 unsigned int abbrev_number;
4266 struct abbrev_info *abbrev;
4268 abbrev_number = read_unsigned_leb128 (abfd, info_ptr, bytes_read);
4270 if (abbrev_number == 0)
4273 abbrev = dwarf2_lookup_abbrev (abbrev_number, cu);
4276 error (_("Dwarf Error: Could not find abbrev number %d [in module %s]"),
4277 abbrev_number, bfd_get_filename (abfd));
4283 /* Scan the debug information for CU starting at INFO_PTR in buffer BUFFER.
4284 Returns a pointer to the end of a series of DIEs, terminated by an empty
4285 DIE. Any children of the skipped DIEs will also be skipped. */
4288 skip_children (gdb_byte *buffer, gdb_byte *info_ptr, struct dwarf2_cu *cu)
4290 struct abbrev_info *abbrev;
4291 unsigned int bytes_read;
4295 abbrev = peek_die_abbrev (info_ptr, &bytes_read, cu);
4297 return info_ptr + bytes_read;
4299 info_ptr = skip_one_die (buffer, info_ptr + bytes_read, abbrev, cu);
4303 /* Scan the debug information for CU starting at INFO_PTR in buffer BUFFER.
4304 INFO_PTR should point just after the initial uleb128 of a DIE, and the
4305 abbrev corresponding to that skipped uleb128 should be passed in
4306 ABBREV. Returns a pointer to this DIE's sibling, skipping any
4310 skip_one_die (gdb_byte *buffer, gdb_byte *info_ptr,
4311 struct abbrev_info *abbrev, struct dwarf2_cu *cu)
4313 unsigned int bytes_read;
4314 struct attribute attr;
4315 bfd *abfd = cu->objfile->obfd;
4316 unsigned int form, i;
4318 for (i = 0; i < abbrev->num_attrs; i++)
4320 /* The only abbrev we care about is DW_AT_sibling. */
4321 if (abbrev->attrs[i].name == DW_AT_sibling)
4323 read_attribute (&attr, &abbrev->attrs[i],
4324 abfd, info_ptr, cu);
4325 if (attr.form == DW_FORM_ref_addr)
4326 complaint (&symfile_complaints,
4327 _("ignoring absolute DW_AT_sibling"));
4329 return buffer + dwarf2_get_ref_die_offset (&attr);
4332 /* If it isn't DW_AT_sibling, skip this attribute. */
4333 form = abbrev->attrs[i].form;
4337 case DW_FORM_ref_addr:
4338 /* In DWARF 2, DW_FORM_ref_addr is address sized; in DWARF 3
4339 and later it is offset sized. */
4340 if (cu->header.version == 2)
4341 info_ptr += cu->header.addr_size;
4343 info_ptr += cu->header.offset_size;
4346 info_ptr += cu->header.addr_size;
4353 case DW_FORM_flag_present:
4365 case DW_FORM_ref_sig8:
4368 case DW_FORM_string:
4369 read_direct_string (abfd, info_ptr, &bytes_read);
4370 info_ptr += bytes_read;
4372 case DW_FORM_sec_offset:
4374 info_ptr += cu->header.offset_size;
4376 case DW_FORM_exprloc:
4378 info_ptr += read_unsigned_leb128 (abfd, info_ptr, &bytes_read);
4379 info_ptr += bytes_read;
4381 case DW_FORM_block1:
4382 info_ptr += 1 + read_1_byte (abfd, info_ptr);
4384 case DW_FORM_block2:
4385 info_ptr += 2 + read_2_bytes (abfd, info_ptr);
4387 case DW_FORM_block4:
4388 info_ptr += 4 + read_4_bytes (abfd, info_ptr);
4392 case DW_FORM_ref_udata:
4393 info_ptr = skip_leb128 (abfd, info_ptr);
4395 case DW_FORM_indirect:
4396 form = read_unsigned_leb128 (abfd, info_ptr, &bytes_read);
4397 info_ptr += bytes_read;
4398 /* We need to continue parsing from here, so just go back to
4400 goto skip_attribute;
4403 error (_("Dwarf Error: Cannot handle %s "
4404 "in DWARF reader [in module %s]"),
4405 dwarf_form_name (form),
4406 bfd_get_filename (abfd));
4410 if (abbrev->has_children)
4411 return skip_children (buffer, info_ptr, cu);
4416 /* Locate ORIG_PDI's sibling.
4417 INFO_PTR should point to the start of the next DIE after ORIG_PDI
4421 locate_pdi_sibling (struct partial_die_info *orig_pdi,
4422 gdb_byte *buffer, gdb_byte *info_ptr,
4423 bfd *abfd, struct dwarf2_cu *cu)
4425 /* Do we know the sibling already? */
4427 if (orig_pdi->sibling)
4428 return orig_pdi->sibling;
4430 /* Are there any children to deal with? */
4432 if (!orig_pdi->has_children)
4435 /* Skip the children the long way. */
4437 return skip_children (buffer, info_ptr, cu);
4440 /* Expand this partial symbol table into a full symbol table. */
4443 dwarf2_psymtab_to_symtab (struct partial_symtab *pst)
4449 warning (_("bug: psymtab for %s is already read in."),
4456 printf_filtered (_("Reading in symbols for %s..."),
4458 gdb_flush (gdb_stdout);
4461 /* Restore our global data. */
4462 dwarf2_per_objfile = objfile_data (pst->objfile,
4463 dwarf2_objfile_data_key);
4465 /* If this psymtab is constructed from a debug-only objfile, the
4466 has_section_at_zero flag will not necessarily be correct. We
4467 can get the correct value for this flag by looking at the data
4468 associated with the (presumably stripped) associated objfile. */
4469 if (pst->objfile->separate_debug_objfile_backlink)
4471 struct dwarf2_per_objfile *dpo_backlink
4472 = objfile_data (pst->objfile->separate_debug_objfile_backlink,
4473 dwarf2_objfile_data_key);
4475 dwarf2_per_objfile->has_section_at_zero
4476 = dpo_backlink->has_section_at_zero;
4479 dwarf2_per_objfile->reading_partial_symbols = 0;
4481 psymtab_to_symtab_1 (pst);
4483 /* Finish up the debug error message. */
4485 printf_filtered (_("done.\n"));
4490 /* Reading in full CUs. */
4492 /* Add PER_CU to the queue. */
4495 queue_comp_unit (struct dwarf2_per_cu_data *per_cu)
4497 struct dwarf2_queue_item *item;
4500 item = xmalloc (sizeof (*item));
4501 item->per_cu = per_cu;
4504 if (dwarf2_queue == NULL)
4505 dwarf2_queue = item;
4507 dwarf2_queue_tail->next = item;
4509 dwarf2_queue_tail = item;
4512 /* Process the queue. */
4515 process_queue (void)
4517 struct dwarf2_queue_item *item, *next_item;
4519 /* The queue starts out with one item, but following a DIE reference
4520 may load a new CU, adding it to the end of the queue. */
4521 for (item = dwarf2_queue; item != NULL; dwarf2_queue = item = next_item)
4523 if (dwarf2_per_objfile->using_index
4524 ? !item->per_cu->v.quick->symtab
4525 : (item->per_cu->v.psymtab && !item->per_cu->v.psymtab->readin))
4526 process_full_comp_unit (item->per_cu);
4528 item->per_cu->queued = 0;
4529 next_item = item->next;
4533 dwarf2_queue_tail = NULL;
4536 /* Free all allocated queue entries. This function only releases anything if
4537 an error was thrown; if the queue was processed then it would have been
4538 freed as we went along. */
4541 dwarf2_release_queue (void *dummy)
4543 struct dwarf2_queue_item *item, *last;
4545 item = dwarf2_queue;
4548 /* Anything still marked queued is likely to be in an
4549 inconsistent state, so discard it. */
4550 if (item->per_cu->queued)
4552 if (item->per_cu->cu != NULL)
4553 free_one_cached_comp_unit (item->per_cu->cu);
4554 item->per_cu->queued = 0;
4562 dwarf2_queue = dwarf2_queue_tail = NULL;
4565 /* Read in full symbols for PST, and anything it depends on. */
4568 psymtab_to_symtab_1 (struct partial_symtab *pst)
4570 struct dwarf2_per_cu_data *per_cu;
4571 struct cleanup *back_to;
4574 for (i = 0; i < pst->number_of_dependencies; i++)
4575 if (!pst->dependencies[i]->readin)
4577 /* Inform about additional files that need to be read in. */
4580 /* FIXME: i18n: Need to make this a single string. */
4581 fputs_filtered (" ", gdb_stdout);
4583 fputs_filtered ("and ", gdb_stdout);
4585 printf_filtered ("%s...", pst->dependencies[i]->filename);
4586 wrap_here (""); /* Flush output. */
4587 gdb_flush (gdb_stdout);
4589 psymtab_to_symtab_1 (pst->dependencies[i]);
4592 per_cu = pst->read_symtab_private;
4596 /* It's an include file, no symbols to read for it.
4597 Everything is in the parent symtab. */
4602 dw2_do_instantiate_symtab (per_cu);
4605 /* Load the DIEs associated with PER_CU into memory. */
4608 load_full_comp_unit (struct dwarf2_per_cu_data *per_cu)
4610 struct objfile *objfile = per_cu->objfile;
4611 bfd *abfd = objfile->obfd;
4612 struct dwarf2_cu *cu;
4613 unsigned int offset;
4614 gdb_byte *info_ptr, *beg_of_comp_unit;
4615 struct cleanup *free_abbrevs_cleanup = NULL, *free_cu_cleanup = NULL;
4616 struct attribute *attr;
4619 gdb_assert (! per_cu->debug_types_section);
4621 /* Set local variables from the partial symbol table info. */
4622 offset = per_cu->offset;
4624 dwarf2_read_section (objfile, &dwarf2_per_objfile->info);
4625 info_ptr = dwarf2_per_objfile->info.buffer + offset;
4626 beg_of_comp_unit = info_ptr;
4628 if (per_cu->cu == NULL)
4630 cu = xmalloc (sizeof (*cu));
4631 init_one_comp_unit (cu, per_cu);
4635 /* If an error occurs while loading, release our storage. */
4636 free_cu_cleanup = make_cleanup (free_heap_comp_unit, cu);
4638 /* Read in the comp_unit header. */
4639 info_ptr = read_comp_unit_head (&cu->header, info_ptr, abfd);
4641 /* Skip dummy compilation units. */
4642 if (info_ptr >= (dwarf2_per_objfile->info.buffer
4643 + dwarf2_per_objfile->info.size)
4644 || peek_abbrev_code (abfd, info_ptr) == 0)
4646 do_cleanups (free_cu_cleanup);
4650 /* Complete the cu_header. */
4651 cu->header.offset = offset;
4652 cu->header.first_die_offset = info_ptr - beg_of_comp_unit;
4654 /* Read the abbrevs for this compilation unit. */
4655 dwarf2_read_abbrevs (cu);
4656 free_abbrevs_cleanup = make_cleanup (dwarf2_free_abbrev_table, cu);
4658 /* Link this CU into read_in_chain. */
4659 per_cu->cu->read_in_chain = dwarf2_per_objfile->read_in_chain;
4660 dwarf2_per_objfile->read_in_chain = per_cu;
4665 info_ptr += cu->header.first_die_offset;
4668 cu->dies = read_comp_unit (info_ptr, cu);
4670 /* We try not to read any attributes in this function, because not
4671 all CUs needed for references have been loaded yet, and symbol
4672 table processing isn't initialized. But we have to set the CU language,
4673 or we won't be able to build types correctly. */
4674 prepare_one_comp_unit (cu, cu->dies);
4676 /* Similarly, if we do not read the producer, we can not apply
4677 producer-specific interpretation. */
4678 attr = dwarf2_attr (cu->dies, DW_AT_producer, cu);
4680 cu->producer = DW_STRING (attr);
4684 do_cleanups (free_abbrevs_cleanup);
4686 /* We've successfully allocated this compilation unit. Let our
4687 caller clean it up when finished with it. */
4688 discard_cleanups (free_cu_cleanup);
4692 /* Add a DIE to the delayed physname list. */
4695 add_to_method_list (struct type *type, int fnfield_index, int index,
4696 const char *name, struct die_info *die,
4697 struct dwarf2_cu *cu)
4699 struct delayed_method_info mi;
4701 mi.fnfield_index = fnfield_index;
4705 VEC_safe_push (delayed_method_info, cu->method_list, &mi);
4708 /* A cleanup for freeing the delayed method list. */
4711 free_delayed_list (void *ptr)
4713 struct dwarf2_cu *cu = (struct dwarf2_cu *) ptr;
4714 if (cu->method_list != NULL)
4716 VEC_free (delayed_method_info, cu->method_list);
4717 cu->method_list = NULL;
4721 /* Compute the physnames of any methods on the CU's method list.
4723 The computation of method physnames is delayed in order to avoid the
4724 (bad) condition that one of the method's formal parameters is of an as yet
4728 compute_delayed_physnames (struct dwarf2_cu *cu)
4731 struct delayed_method_info *mi;
4732 for (i = 0; VEC_iterate (delayed_method_info, cu->method_list, i, mi) ; ++i)
4734 const char *physname;
4735 struct fn_fieldlist *fn_flp
4736 = &TYPE_FN_FIELDLIST (mi->type, mi->fnfield_index);
4737 physname = dwarf2_physname ((char *) mi->name, mi->die, cu);
4738 fn_flp->fn_fields[mi->index].physname = physname ? physname : "";
4742 /* Generate full symbol information for PER_CU, whose DIEs have
4743 already been loaded into memory. */
4746 process_full_comp_unit (struct dwarf2_per_cu_data *per_cu)
4748 struct dwarf2_cu *cu = per_cu->cu;
4749 struct objfile *objfile = per_cu->objfile;
4750 CORE_ADDR lowpc, highpc;
4751 struct symtab *symtab;
4752 struct cleanup *back_to, *delayed_list_cleanup;
4755 baseaddr = ANOFFSET (objfile->section_offsets, SECT_OFF_TEXT (objfile));
4758 back_to = make_cleanup (really_free_pendings, NULL);
4759 delayed_list_cleanup = make_cleanup (free_delayed_list, cu);
4761 cu->list_in_scope = &file_symbols;
4763 /* Do line number decoding in read_file_scope () */
4764 process_die (cu->dies, cu);
4766 /* Now that we have processed all the DIEs in the CU, all the types
4767 should be complete, and it should now be safe to compute all of the
4769 compute_delayed_physnames (cu);
4770 do_cleanups (delayed_list_cleanup);
4772 /* Some compilers don't define a DW_AT_high_pc attribute for the
4773 compilation unit. If the DW_AT_high_pc is missing, synthesize
4774 it, by scanning the DIE's below the compilation unit. */
4775 get_scope_pc_bounds (cu->dies, &lowpc, &highpc, cu);
4777 symtab = end_symtab (highpc + baseaddr, objfile, SECT_OFF_TEXT (objfile));
4781 int gcc_4_minor = producer_is_gcc_ge_4 (cu->producer);
4783 /* Set symtab language to language from DW_AT_language. If the
4784 compilation is from a C file generated by language preprocessors, do
4785 not set the language if it was already deduced by start_subfile. */
4786 if (!(cu->language == language_c && symtab->language != language_c))
4787 symtab->language = cu->language;
4789 /* GCC-4.0 has started to support -fvar-tracking. GCC-3.x still can
4790 produce DW_AT_location with location lists but it can be possibly
4791 invalid without -fvar-tracking.
4793 For -gdwarf-4 type units LOCATIONS_VALID indication is fortunately not
4794 needed, it would be wrong due to missing DW_AT_producer there.
4796 Still one can confuse GDB by using non-standard GCC compilation
4797 options - this waits on GCC PR other/32998 (-frecord-gcc-switches).
4799 if (cu->has_loclist && gcc_4_minor >= 0)
4800 symtab->locations_valid = 1;
4802 if (gcc_4_minor >= 5)
4803 symtab->epilogue_unwind_valid = 1;
4805 symtab->call_site_htab = cu->call_site_htab;
4808 if (dwarf2_per_objfile->using_index)
4809 per_cu->v.quick->symtab = symtab;
4812 struct partial_symtab *pst = per_cu->v.psymtab;
4813 pst->symtab = symtab;
4817 do_cleanups (back_to);
4820 /* Process a die and its children. */
4823 process_die (struct die_info *die, struct dwarf2_cu *cu)
4827 case DW_TAG_padding:
4829 case DW_TAG_compile_unit:
4830 read_file_scope (die, cu);
4832 case DW_TAG_type_unit:
4833 read_type_unit_scope (die, cu);
4835 case DW_TAG_subprogram:
4836 case DW_TAG_inlined_subroutine:
4837 read_func_scope (die, cu);
4839 case DW_TAG_lexical_block:
4840 case DW_TAG_try_block:
4841 case DW_TAG_catch_block:
4842 read_lexical_block_scope (die, cu);
4844 case DW_TAG_GNU_call_site:
4845 read_call_site_scope (die, cu);
4847 case DW_TAG_class_type:
4848 case DW_TAG_interface_type:
4849 case DW_TAG_structure_type:
4850 case DW_TAG_union_type:
4851 process_structure_scope (die, cu);
4853 case DW_TAG_enumeration_type:
4854 process_enumeration_scope (die, cu);
4857 /* These dies have a type, but processing them does not create
4858 a symbol or recurse to process the children. Therefore we can
4859 read them on-demand through read_type_die. */
4860 case DW_TAG_subroutine_type:
4861 case DW_TAG_set_type:
4862 case DW_TAG_array_type:
4863 case DW_TAG_pointer_type:
4864 case DW_TAG_ptr_to_member_type:
4865 case DW_TAG_reference_type:
4866 case DW_TAG_string_type:
4869 case DW_TAG_base_type:
4870 case DW_TAG_subrange_type:
4871 case DW_TAG_typedef:
4872 /* Add a typedef symbol for the type definition, if it has a
4874 new_symbol (die, read_type_die (die, cu), cu);
4876 case DW_TAG_common_block:
4877 read_common_block (die, cu);
4879 case DW_TAG_common_inclusion:
4881 case DW_TAG_namespace:
4882 processing_has_namespace_info = 1;
4883 read_namespace (die, cu);
4886 processing_has_namespace_info = 1;
4887 read_module (die, cu);
4889 case DW_TAG_imported_declaration:
4890 case DW_TAG_imported_module:
4891 processing_has_namespace_info = 1;
4892 if (die->child != NULL && (die->tag == DW_TAG_imported_declaration
4893 || cu->language != language_fortran))
4894 complaint (&symfile_complaints, _("Tag '%s' has unexpected children"),
4895 dwarf_tag_name (die->tag));
4896 read_import_statement (die, cu);
4899 new_symbol (die, NULL, cu);
4904 /* A helper function for dwarf2_compute_name which determines whether DIE
4905 needs to have the name of the scope prepended to the name listed in the
4909 die_needs_namespace (struct die_info *die, struct dwarf2_cu *cu)
4911 struct attribute *attr;
4915 case DW_TAG_namespace:
4916 case DW_TAG_typedef:
4917 case DW_TAG_class_type:
4918 case DW_TAG_interface_type:
4919 case DW_TAG_structure_type:
4920 case DW_TAG_union_type:
4921 case DW_TAG_enumeration_type:
4922 case DW_TAG_enumerator:
4923 case DW_TAG_subprogram:
4927 case DW_TAG_variable:
4928 case DW_TAG_constant:
4929 /* We only need to prefix "globally" visible variables. These include
4930 any variable marked with DW_AT_external or any variable that
4931 lives in a namespace. [Variables in anonymous namespaces
4932 require prefixing, but they are not DW_AT_external.] */
4934 if (dwarf2_attr (die, DW_AT_specification, cu))
4936 struct dwarf2_cu *spec_cu = cu;
4938 return die_needs_namespace (die_specification (die, &spec_cu),
4942 attr = dwarf2_attr (die, DW_AT_external, cu);
4943 if (attr == NULL && die->parent->tag != DW_TAG_namespace
4944 && die->parent->tag != DW_TAG_module)
4946 /* A variable in a lexical block of some kind does not need a
4947 namespace, even though in C++ such variables may be external
4948 and have a mangled name. */
4949 if (die->parent->tag == DW_TAG_lexical_block
4950 || die->parent->tag == DW_TAG_try_block
4951 || die->parent->tag == DW_TAG_catch_block
4952 || die->parent->tag == DW_TAG_subprogram)
4961 /* Retrieve the last character from a mem_file. */
4964 do_ui_file_peek_last (void *object, const char *buffer, long length)
4966 char *last_char_p = (char *) object;
4969 *last_char_p = buffer[length - 1];
4972 /* Compute the fully qualified name of DIE in CU. If PHYSNAME is nonzero,
4973 compute the physname for the object, which include a method's
4974 formal parameters (C++/Java) and return type (Java).
4976 For Ada, return the DIE's linkage name rather than the fully qualified
4977 name. PHYSNAME is ignored..
4979 The result is allocated on the objfile_obstack and canonicalized. */
4982 dwarf2_compute_name (char *name, struct die_info *die, struct dwarf2_cu *cu,
4985 struct objfile *objfile = cu->objfile;
4988 name = dwarf2_name (die, cu);
4990 /* For Fortran GDB prefers DW_AT_*linkage_name if present but otherwise
4991 compute it by typename_concat inside GDB. */
4992 if (cu->language == language_ada
4993 || (cu->language == language_fortran && physname))
4995 /* For Ada unit, we prefer the linkage name over the name, as
4996 the former contains the exported name, which the user expects
4997 to be able to reference. Ideally, we want the user to be able
4998 to reference this entity using either natural or linkage name,
4999 but we haven't started looking at this enhancement yet. */
5000 struct attribute *attr;
5002 attr = dwarf2_attr (die, DW_AT_linkage_name, cu);
5004 attr = dwarf2_attr (die, DW_AT_MIPS_linkage_name, cu);
5005 if (attr && DW_STRING (attr))
5006 return DW_STRING (attr);
5009 /* These are the only languages we know how to qualify names in. */
5011 && (cu->language == language_cplus || cu->language == language_java
5012 || cu->language == language_fortran))
5014 if (die_needs_namespace (die, cu))
5018 struct ui_file *buf;
5020 prefix = determine_prefix (die, cu);
5021 buf = mem_fileopen ();
5022 if (*prefix != '\0')
5024 char *prefixed_name = typename_concat (NULL, prefix, name,
5027 fputs_unfiltered (prefixed_name, buf);
5028 xfree (prefixed_name);
5031 fputs_unfiltered (name, buf);
5033 /* Template parameters may be specified in the DIE's DW_AT_name, or
5034 as children with DW_TAG_template_type_param or
5035 DW_TAG_value_type_param. If the latter, add them to the name
5036 here. If the name already has template parameters, then
5037 skip this step; some versions of GCC emit both, and
5038 it is more efficient to use the pre-computed name.
5040 Something to keep in mind about this process: it is very
5041 unlikely, or in some cases downright impossible, to produce
5042 something that will match the mangled name of a function.
5043 If the definition of the function has the same debug info,
5044 we should be able to match up with it anyway. But fallbacks
5045 using the minimal symbol, for instance to find a method
5046 implemented in a stripped copy of libstdc++, will not work.
5047 If we do not have debug info for the definition, we will have to
5048 match them up some other way.
5050 When we do name matching there is a related problem with function
5051 templates; two instantiated function templates are allowed to
5052 differ only by their return types, which we do not add here. */
5054 if (cu->language == language_cplus && strchr (name, '<') == NULL)
5056 struct attribute *attr;
5057 struct die_info *child;
5060 die->building_fullname = 1;
5062 for (child = die->child; child != NULL; child = child->sibling)
5067 struct dwarf2_locexpr_baton *baton;
5070 if (child->tag != DW_TAG_template_type_param
5071 && child->tag != DW_TAG_template_value_param)
5076 fputs_unfiltered ("<", buf);
5080 fputs_unfiltered (", ", buf);
5082 attr = dwarf2_attr (child, DW_AT_type, cu);
5085 complaint (&symfile_complaints,
5086 _("template parameter missing DW_AT_type"));
5087 fputs_unfiltered ("UNKNOWN_TYPE", buf);
5090 type = die_type (child, cu);
5092 if (child->tag == DW_TAG_template_type_param)
5094 c_print_type (type, "", buf, -1, 0);
5098 attr = dwarf2_attr (child, DW_AT_const_value, cu);
5101 complaint (&symfile_complaints,
5102 _("template parameter missing "
5103 "DW_AT_const_value"));
5104 fputs_unfiltered ("UNKNOWN_VALUE", buf);
5108 dwarf2_const_value_attr (attr, type, name,
5109 &cu->comp_unit_obstack, cu,
5110 &value, &bytes, &baton);
5112 if (TYPE_NOSIGN (type))
5113 /* GDB prints characters as NUMBER 'CHAR'. If that's
5114 changed, this can use value_print instead. */
5115 c_printchar (value, type, buf);
5118 struct value_print_options opts;
5121 v = dwarf2_evaluate_loc_desc (type, NULL,
5125 else if (bytes != NULL)
5127 v = allocate_value (type);
5128 memcpy (value_contents_writeable (v), bytes,
5129 TYPE_LENGTH (type));
5132 v = value_from_longest (type, value);
5134 /* Specify decimal so that we do not depend on
5136 get_formatted_print_options (&opts, 'd');
5138 value_print (v, buf, &opts);
5144 die->building_fullname = 0;
5148 /* Close the argument list, with a space if necessary
5149 (nested templates). */
5150 char last_char = '\0';
5151 ui_file_put (buf, do_ui_file_peek_last, &last_char);
5152 if (last_char == '>')
5153 fputs_unfiltered (" >", buf);
5155 fputs_unfiltered (">", buf);
5159 /* For Java and C++ methods, append formal parameter type
5160 information, if PHYSNAME. */
5162 if (physname && die->tag == DW_TAG_subprogram
5163 && (cu->language == language_cplus
5164 || cu->language == language_java))
5166 struct type *type = read_type_die (die, cu);
5168 c_type_print_args (type, buf, 1, cu->language);
5170 if (cu->language == language_java)
5172 /* For java, we must append the return type to method
5174 if (die->tag == DW_TAG_subprogram)
5175 java_print_type (TYPE_TARGET_TYPE (type), "", buf,
5178 else if (cu->language == language_cplus)
5180 /* Assume that an artificial first parameter is
5181 "this", but do not crash if it is not. RealView
5182 marks unnamed (and thus unused) parameters as
5183 artificial; there is no way to differentiate
5185 if (TYPE_NFIELDS (type) > 0
5186 && TYPE_FIELD_ARTIFICIAL (type, 0)
5187 && TYPE_CODE (TYPE_FIELD_TYPE (type, 0)) == TYPE_CODE_PTR
5188 && TYPE_CONST (TYPE_TARGET_TYPE (TYPE_FIELD_TYPE (type,
5190 fputs_unfiltered (" const", buf);
5194 name = ui_file_obsavestring (buf, &objfile->objfile_obstack,
5196 ui_file_delete (buf);
5198 if (cu->language == language_cplus)
5201 = dwarf2_canonicalize_name (name, cu,
5202 &objfile->objfile_obstack);
5213 /* Return the fully qualified name of DIE, based on its DW_AT_name.
5214 If scope qualifiers are appropriate they will be added. The result
5215 will be allocated on the objfile_obstack, or NULL if the DIE does
5216 not have a name. NAME may either be from a previous call to
5217 dwarf2_name or NULL.
5219 The output string will be canonicalized (if C++/Java). */
5222 dwarf2_full_name (char *name, struct die_info *die, struct dwarf2_cu *cu)
5224 return dwarf2_compute_name (name, die, cu, 0);
5227 /* Construct a physname for the given DIE in CU. NAME may either be
5228 from a previous call to dwarf2_name or NULL. The result will be
5229 allocated on the objfile_objstack or NULL if the DIE does not have a
5232 The output string will be canonicalized (if C++/Java). */
5235 dwarf2_physname (char *name, struct die_info *die, struct dwarf2_cu *cu)
5237 struct objfile *objfile = cu->objfile;
5238 struct attribute *attr;
5239 const char *retval, *mangled = NULL, *canon = NULL;
5240 struct cleanup *back_to;
5243 /* In this case dwarf2_compute_name is just a shortcut not building anything
5245 if (!die_needs_namespace (die, cu))
5246 return dwarf2_compute_name (name, die, cu, 1);
5248 back_to = make_cleanup (null_cleanup, NULL);
5250 attr = dwarf2_attr (die, DW_AT_linkage_name, cu);
5252 attr = dwarf2_attr (die, DW_AT_MIPS_linkage_name, cu);
5254 /* DW_AT_linkage_name is missing in some cases - depend on what GDB
5256 if (attr && DW_STRING (attr))
5260 mangled = DW_STRING (attr);
5262 /* Use DMGL_RET_DROP for C++ template functions to suppress their return
5263 type. It is easier for GDB users to search for such functions as
5264 `name(params)' than `long name(params)'. In such case the minimal
5265 symbol names do not match the full symbol names but for template
5266 functions there is never a need to look up their definition from their
5267 declaration so the only disadvantage remains the minimal symbol
5268 variant `long name(params)' does not have the proper inferior type.
5271 demangled = cplus_demangle (mangled, (DMGL_PARAMS | DMGL_ANSI
5272 | (cu->language == language_java
5273 ? DMGL_JAVA | DMGL_RET_POSTFIX
5277 make_cleanup (xfree, demangled);
5287 if (canon == NULL || check_physname)
5289 const char *physname = dwarf2_compute_name (name, die, cu, 1);
5291 if (canon != NULL && strcmp (physname, canon) != 0)
5293 /* It may not mean a bug in GDB. The compiler could also
5294 compute DW_AT_linkage_name incorrectly. But in such case
5295 GDB would need to be bug-to-bug compatible. */
5297 complaint (&symfile_complaints,
5298 _("Computed physname <%s> does not match demangled <%s> "
5299 "(from linkage <%s>) - DIE at 0x%x [in module %s]"),
5300 physname, canon, mangled, die->offset, objfile->name);
5302 /* Prefer DW_AT_linkage_name (in the CANON form) - when it
5303 is available here - over computed PHYSNAME. It is safer
5304 against both buggy GDB and buggy compilers. */
5318 retval = obsavestring (retval, strlen (retval),
5319 &objfile->objfile_obstack);
5321 do_cleanups (back_to);
5325 /* Read the import statement specified by the given die and record it. */
5328 read_import_statement (struct die_info *die, struct dwarf2_cu *cu)
5330 struct objfile *objfile = cu->objfile;
5331 struct attribute *import_attr;
5332 struct die_info *imported_die, *child_die;
5333 struct dwarf2_cu *imported_cu;
5334 const char *imported_name;
5335 const char *imported_name_prefix;
5336 const char *canonical_name;
5337 const char *import_alias;
5338 const char *imported_declaration = NULL;
5339 const char *import_prefix;
5340 VEC (const_char_ptr) *excludes = NULL;
5341 struct cleanup *cleanups;
5345 import_attr = dwarf2_attr (die, DW_AT_import, cu);
5346 if (import_attr == NULL)
5348 complaint (&symfile_complaints, _("Tag '%s' has no DW_AT_import"),
5349 dwarf_tag_name (die->tag));
5354 imported_die = follow_die_ref_or_sig (die, import_attr, &imported_cu);
5355 imported_name = dwarf2_name (imported_die, imported_cu);
5356 if (imported_name == NULL)
5358 /* GCC bug: https://bugzilla.redhat.com/show_bug.cgi?id=506524
5360 The import in the following code:
5374 <2><51>: Abbrev Number: 3 (DW_TAG_imported_declaration)
5375 <52> DW_AT_decl_file : 1
5376 <53> DW_AT_decl_line : 6
5377 <54> DW_AT_import : <0x75>
5378 <2><58>: Abbrev Number: 4 (DW_TAG_typedef)
5380 <5b> DW_AT_decl_file : 1
5381 <5c> DW_AT_decl_line : 2
5382 <5d> DW_AT_type : <0x6e>
5384 <1><75>: Abbrev Number: 7 (DW_TAG_base_type)
5385 <76> DW_AT_byte_size : 4
5386 <77> DW_AT_encoding : 5 (signed)
5388 imports the wrong die ( 0x75 instead of 0x58 ).
5389 This case will be ignored until the gcc bug is fixed. */
5393 /* Figure out the local name after import. */
5394 import_alias = dwarf2_name (die, cu);
5396 /* Figure out where the statement is being imported to. */
5397 import_prefix = determine_prefix (die, cu);
5399 /* Figure out what the scope of the imported die is and prepend it
5400 to the name of the imported die. */
5401 imported_name_prefix = determine_prefix (imported_die, imported_cu);
5403 if (imported_die->tag != DW_TAG_namespace
5404 && imported_die->tag != DW_TAG_module)
5406 imported_declaration = imported_name;
5407 canonical_name = imported_name_prefix;
5409 else if (strlen (imported_name_prefix) > 0)
5411 temp = alloca (strlen (imported_name_prefix)
5412 + 2 + strlen (imported_name) + 1);
5413 strcpy (temp, imported_name_prefix);
5414 strcat (temp, "::");
5415 strcat (temp, imported_name);
5416 canonical_name = temp;
5419 canonical_name = imported_name;
5421 cleanups = make_cleanup (VEC_cleanup (const_char_ptr), &excludes);
5423 if (die->tag == DW_TAG_imported_module && cu->language == language_fortran)
5424 for (child_die = die->child; child_die && child_die->tag;
5425 child_die = sibling_die (child_die))
5427 /* DWARF-4: A Fortran use statement with a “rename list” may be
5428 represented by an imported module entry with an import attribute
5429 referring to the module and owned entries corresponding to those
5430 entities that are renamed as part of being imported. */
5432 if (child_die->tag != DW_TAG_imported_declaration)
5434 complaint (&symfile_complaints,
5435 _("child DW_TAG_imported_declaration expected "
5436 "- DIE at 0x%x [in module %s]"),
5437 child_die->offset, objfile->name);
5441 import_attr = dwarf2_attr (child_die, DW_AT_import, cu);
5442 if (import_attr == NULL)
5444 complaint (&symfile_complaints, _("Tag '%s' has no DW_AT_import"),
5445 dwarf_tag_name (child_die->tag));
5450 imported_die = follow_die_ref_or_sig (child_die, import_attr,
5452 imported_name = dwarf2_name (imported_die, imported_cu);
5453 if (imported_name == NULL)
5455 complaint (&symfile_complaints,
5456 _("child DW_TAG_imported_declaration has unknown "
5457 "imported name - DIE at 0x%x [in module %s]"),
5458 child_die->offset, objfile->name);
5462 VEC_safe_push (const_char_ptr, excludes, imported_name);
5464 process_die (child_die, cu);
5467 cp_add_using_directive (import_prefix,
5470 imported_declaration,
5472 &objfile->objfile_obstack);
5474 do_cleanups (cleanups);
5477 /* Cleanup function for read_file_scope. */
5480 free_cu_line_header (void *arg)
5482 struct dwarf2_cu *cu = arg;
5484 free_line_header (cu->line_header);
5485 cu->line_header = NULL;
5489 find_file_and_directory (struct die_info *die, struct dwarf2_cu *cu,
5490 char **name, char **comp_dir)
5492 struct attribute *attr;
5497 /* Find the filename. Do not use dwarf2_name here, since the filename
5498 is not a source language identifier. */
5499 attr = dwarf2_attr (die, DW_AT_name, cu);
5502 *name = DW_STRING (attr);
5505 attr = dwarf2_attr (die, DW_AT_comp_dir, cu);
5507 *comp_dir = DW_STRING (attr);
5508 else if (*name != NULL && IS_ABSOLUTE_PATH (*name))
5510 *comp_dir = ldirname (*name);
5511 if (*comp_dir != NULL)
5512 make_cleanup (xfree, *comp_dir);
5514 if (*comp_dir != NULL)
5516 /* Irix 6.2 native cc prepends <machine>.: to the compilation
5517 directory, get rid of it. */
5518 char *cp = strchr (*comp_dir, ':');
5520 if (cp && cp != *comp_dir && cp[-1] == '.' && cp[1] == '/')
5525 *name = "<unknown>";
5528 /* Handle DW_AT_stmt_list for a compilation unit or type unit.
5529 DIE is the DW_TAG_compile_unit or DW_TAG_type_unit die for CU.
5530 COMP_DIR is the compilation directory.
5531 WANT_LINE_INFO is non-zero if the pc/line-number mapping is needed. */
5534 handle_DW_AT_stmt_list (struct die_info *die, struct dwarf2_cu *cu,
5535 const char *comp_dir, int want_line_info)
5537 struct attribute *attr;
5538 struct objfile *objfile = cu->objfile;
5539 bfd *abfd = objfile->obfd;
5541 attr = dwarf2_attr (die, DW_AT_stmt_list, cu);
5544 unsigned int line_offset = DW_UNSND (attr);
5545 struct line_header *line_header
5546 = dwarf_decode_line_header (line_offset, abfd, cu);
5550 cu->line_header = line_header;
5551 make_cleanup (free_cu_line_header, cu);
5552 dwarf_decode_lines (line_header, comp_dir, cu, NULL, want_line_info);
5557 /* Process DW_TAG_compile_unit. */
5560 read_file_scope (struct die_info *die, struct dwarf2_cu *cu)
5562 struct objfile *objfile = cu->objfile;
5563 struct cleanup *back_to = make_cleanup (null_cleanup, 0);
5564 CORE_ADDR lowpc = ((CORE_ADDR) -1);
5565 CORE_ADDR highpc = ((CORE_ADDR) 0);
5566 struct attribute *attr;
5568 char *comp_dir = NULL;
5569 struct die_info *child_die;
5570 bfd *abfd = objfile->obfd;
5573 baseaddr = ANOFFSET (objfile->section_offsets, SECT_OFF_TEXT (objfile));
5575 get_scope_pc_bounds (die, &lowpc, &highpc, cu);
5577 /* If we didn't find a lowpc, set it to highpc to avoid complaints
5578 from finish_block. */
5579 if (lowpc == ((CORE_ADDR) -1))
5584 find_file_and_directory (die, cu, &name, &comp_dir);
5586 attr = dwarf2_attr (die, DW_AT_language, cu);
5589 set_cu_language (DW_UNSND (attr), cu);
5592 attr = dwarf2_attr (die, DW_AT_producer, cu);
5594 cu->producer = DW_STRING (attr);
5596 /* The XLCL doesn't generate DW_LANG_OpenCL because this attribute is not
5597 standardised yet. As a workaround for the language detection we fall
5598 back to the DW_AT_producer string. */
5599 if (cu->producer && strstr (cu->producer, "IBM XL C for OpenCL") != NULL)
5600 cu->language = language_opencl;
5602 /* We assume that we're processing GCC output. */
5603 processing_gcc_compilation = 2;
5605 processing_has_namespace_info = 0;
5607 start_symtab (name, comp_dir, lowpc);
5608 record_debugformat ("DWARF 2");
5609 record_producer (cu->producer);
5611 /* Decode line number information if present. We do this before
5612 processing child DIEs, so that the line header table is available
5613 for DW_AT_decl_file. */
5614 handle_DW_AT_stmt_list (die, cu, comp_dir, 1);
5616 /* Process all dies in compilation unit. */
5617 if (die->child != NULL)
5619 child_die = die->child;
5620 while (child_die && child_die->tag)
5622 process_die (child_die, cu);
5623 child_die = sibling_die (child_die);
5627 /* Decode macro information, if present. Dwarf 2 macro information
5628 refers to information in the line number info statement program
5629 header, so we can only read it if we've read the header
5631 attr = dwarf2_attr (die, DW_AT_GNU_macros, cu);
5632 if (attr && cu->line_header)
5634 if (dwarf2_attr (die, DW_AT_macro_info, cu))
5635 complaint (&symfile_complaints,
5636 _("CU refers to both DW_AT_GNU_macros and DW_AT_macro_info"));
5638 dwarf_decode_macros (cu->line_header, DW_UNSND (attr),
5640 &dwarf2_per_objfile->macro, 1);
5644 attr = dwarf2_attr (die, DW_AT_macro_info, cu);
5645 if (attr && cu->line_header)
5647 unsigned int macro_offset = DW_UNSND (attr);
5649 dwarf_decode_macros (cu->line_header, macro_offset,
5651 &dwarf2_per_objfile->macinfo, 0);
5655 do_cleanups (back_to);
5658 /* Process DW_TAG_type_unit.
5659 For TUs we want to skip the first top level sibling if it's not the
5660 actual type being defined by this TU. In this case the first top
5661 level sibling is there to provide context only. */
5664 read_type_unit_scope (struct die_info *die, struct dwarf2_cu *cu)
5666 struct objfile *objfile = cu->objfile;
5667 struct cleanup *back_to = make_cleanup (null_cleanup, 0);
5669 struct attribute *attr;
5671 char *comp_dir = NULL;
5672 struct die_info *child_die;
5673 bfd *abfd = objfile->obfd;
5675 /* start_symtab needs a low pc, but we don't really have one.
5676 Do what read_file_scope would do in the absence of such info. */
5677 lowpc = ANOFFSET (objfile->section_offsets, SECT_OFF_TEXT (objfile));
5679 /* Find the filename. Do not use dwarf2_name here, since the filename
5680 is not a source language identifier. */
5681 attr = dwarf2_attr (die, DW_AT_name, cu);
5683 name = DW_STRING (attr);
5685 attr = dwarf2_attr (die, DW_AT_comp_dir, cu);
5687 comp_dir = DW_STRING (attr);
5688 else if (name != NULL && IS_ABSOLUTE_PATH (name))
5690 comp_dir = ldirname (name);
5691 if (comp_dir != NULL)
5692 make_cleanup (xfree, comp_dir);
5698 attr = dwarf2_attr (die, DW_AT_language, cu);
5700 set_cu_language (DW_UNSND (attr), cu);
5702 /* This isn't technically needed today. It is done for symmetry
5703 with read_file_scope. */
5704 attr = dwarf2_attr (die, DW_AT_producer, cu);
5706 cu->producer = DW_STRING (attr);
5708 /* We assume that we're processing GCC output. */
5709 processing_gcc_compilation = 2;
5711 processing_has_namespace_info = 0;
5713 start_symtab (name, comp_dir, lowpc);
5714 record_debugformat ("DWARF 2");
5715 record_producer (cu->producer);
5717 /* Decode line number information if present. We do this before
5718 processing child DIEs, so that the line header table is available
5719 for DW_AT_decl_file.
5720 We don't need the pc/line-number mapping for type units. */
5721 handle_DW_AT_stmt_list (die, cu, comp_dir, 0);
5723 /* Process the dies in the type unit. */
5724 if (die->child == NULL)
5726 dump_die_for_error (die);
5727 error (_("Dwarf Error: Missing children for type unit [in module %s]"),
5728 bfd_get_filename (abfd));
5731 child_die = die->child;
5733 while (child_die && child_die->tag)
5735 process_die (child_die, cu);
5737 child_die = sibling_die (child_die);
5740 do_cleanups (back_to);
5743 /* qsort helper for inherit_abstract_dies. */
5746 unsigned_int_compar (const void *ap, const void *bp)
5748 unsigned int a = *(unsigned int *) ap;
5749 unsigned int b = *(unsigned int *) bp;
5751 return (a > b) - (b > a);
5754 /* DW_AT_abstract_origin inherits whole DIEs (not just their attributes).
5755 Inherit only the children of the DW_AT_abstract_origin DIE not being
5756 already referenced by DW_AT_abstract_origin from the children of the
5760 inherit_abstract_dies (struct die_info *die, struct dwarf2_cu *cu)
5762 struct die_info *child_die;
5763 unsigned die_children_count;
5764 /* CU offsets which were referenced by children of the current DIE. */
5766 unsigned *offsets_end, *offsetp;
5767 /* Parent of DIE - referenced by DW_AT_abstract_origin. */
5768 struct die_info *origin_die;
5769 /* Iterator of the ORIGIN_DIE children. */
5770 struct die_info *origin_child_die;
5771 struct cleanup *cleanups;
5772 struct attribute *attr;
5773 struct dwarf2_cu *origin_cu;
5774 struct pending **origin_previous_list_in_scope;
5776 attr = dwarf2_attr (die, DW_AT_abstract_origin, cu);
5780 /* Note that following die references may follow to a die in a
5784 origin_die = follow_die_ref (die, attr, &origin_cu);
5786 /* We're inheriting ORIGIN's children into the scope we'd put DIE's
5788 origin_previous_list_in_scope = origin_cu->list_in_scope;
5789 origin_cu->list_in_scope = cu->list_in_scope;
5791 if (die->tag != origin_die->tag
5792 && !(die->tag == DW_TAG_inlined_subroutine
5793 && origin_die->tag == DW_TAG_subprogram))
5794 complaint (&symfile_complaints,
5795 _("DIE 0x%x and its abstract origin 0x%x have different tags"),
5796 die->offset, origin_die->offset);
5798 child_die = die->child;
5799 die_children_count = 0;
5800 while (child_die && child_die->tag)
5802 child_die = sibling_die (child_die);
5803 die_children_count++;
5805 offsets = xmalloc (sizeof (*offsets) * die_children_count);
5806 cleanups = make_cleanup (xfree, offsets);
5808 offsets_end = offsets;
5809 child_die = die->child;
5810 while (child_die && child_die->tag)
5812 /* For each CHILD_DIE, find the corresponding child of
5813 ORIGIN_DIE. If there is more than one layer of
5814 DW_AT_abstract_origin, follow them all; there shouldn't be,
5815 but GCC versions at least through 4.4 generate this (GCC PR
5817 struct die_info *child_origin_die = child_die;
5818 struct dwarf2_cu *child_origin_cu = cu;
5822 attr = dwarf2_attr (child_origin_die, DW_AT_abstract_origin,
5826 child_origin_die = follow_die_ref (child_origin_die, attr,
5830 /* According to DWARF3 3.3.8.2 #3 new entries without their abstract
5831 counterpart may exist. */
5832 if (child_origin_die != child_die)
5834 if (child_die->tag != child_origin_die->tag
5835 && !(child_die->tag == DW_TAG_inlined_subroutine
5836 && child_origin_die->tag == DW_TAG_subprogram))
5837 complaint (&symfile_complaints,
5838 _("Child DIE 0x%x and its abstract origin 0x%x have "
5839 "different tags"), child_die->offset,
5840 child_origin_die->offset);
5841 if (child_origin_die->parent != origin_die)
5842 complaint (&symfile_complaints,
5843 _("Child DIE 0x%x and its abstract origin 0x%x have "
5844 "different parents"), child_die->offset,
5845 child_origin_die->offset);
5847 *offsets_end++ = child_origin_die->offset;
5849 child_die = sibling_die (child_die);
5851 qsort (offsets, offsets_end - offsets, sizeof (*offsets),
5852 unsigned_int_compar);
5853 for (offsetp = offsets + 1; offsetp < offsets_end; offsetp++)
5854 if (offsetp[-1] == *offsetp)
5855 complaint (&symfile_complaints,
5856 _("Multiple children of DIE 0x%x refer "
5857 "to DIE 0x%x as their abstract origin"),
5858 die->offset, *offsetp);
5861 origin_child_die = origin_die->child;
5862 while (origin_child_die && origin_child_die->tag)
5864 /* Is ORIGIN_CHILD_DIE referenced by any of the DIE children? */
5865 while (offsetp < offsets_end && *offsetp < origin_child_die->offset)
5867 if (offsetp >= offsets_end || *offsetp > origin_child_die->offset)
5869 /* Found that ORIGIN_CHILD_DIE is really not referenced. */
5870 process_die (origin_child_die, origin_cu);
5872 origin_child_die = sibling_die (origin_child_die);
5874 origin_cu->list_in_scope = origin_previous_list_in_scope;
5876 do_cleanups (cleanups);
5880 read_func_scope (struct die_info *die, struct dwarf2_cu *cu)
5882 struct objfile *objfile = cu->objfile;
5883 struct context_stack *new;
5886 struct die_info *child_die;
5887 struct attribute *attr, *call_line, *call_file;
5890 struct block *block;
5891 int inlined_func = (die->tag == DW_TAG_inlined_subroutine);
5892 VEC (symbolp) *template_args = NULL;
5893 struct template_symbol *templ_func = NULL;
5897 /* If we do not have call site information, we can't show the
5898 caller of this inlined function. That's too confusing, so
5899 only use the scope for local variables. */
5900 call_line = dwarf2_attr (die, DW_AT_call_line, cu);
5901 call_file = dwarf2_attr (die, DW_AT_call_file, cu);
5902 if (call_line == NULL || call_file == NULL)
5904 read_lexical_block_scope (die, cu);
5909 baseaddr = ANOFFSET (objfile->section_offsets, SECT_OFF_TEXT (objfile));
5911 name = dwarf2_name (die, cu);
5913 /* Ignore functions with missing or empty names. These are actually
5914 illegal according to the DWARF standard. */
5917 complaint (&symfile_complaints,
5918 _("missing name for subprogram DIE at %d"), die->offset);
5922 /* Ignore functions with missing or invalid low and high pc attributes. */
5923 if (!dwarf2_get_pc_bounds (die, &lowpc, &highpc, cu, NULL))
5925 attr = dwarf2_attr (die, DW_AT_external, cu);
5926 if (!attr || !DW_UNSND (attr))
5927 complaint (&symfile_complaints,
5928 _("cannot get low and high bounds "
5929 "for subprogram DIE at %d"),
5937 /* If we have any template arguments, then we must allocate a
5938 different sort of symbol. */
5939 for (child_die = die->child; child_die; child_die = sibling_die (child_die))
5941 if (child_die->tag == DW_TAG_template_type_param
5942 || child_die->tag == DW_TAG_template_value_param)
5944 templ_func = OBSTACK_ZALLOC (&objfile->objfile_obstack,
5945 struct template_symbol);
5946 templ_func->base.is_cplus_template_function = 1;
5951 new = push_context (0, lowpc);
5952 new->name = new_symbol_full (die, read_type_die (die, cu), cu,
5953 (struct symbol *) templ_func);
5955 /* If there is a location expression for DW_AT_frame_base, record
5957 attr = dwarf2_attr (die, DW_AT_frame_base, cu);
5959 /* FIXME: cagney/2004-01-26: The DW_AT_frame_base's location
5960 expression is being recorded directly in the function's symbol
5961 and not in a separate frame-base object. I guess this hack is
5962 to avoid adding some sort of frame-base adjunct/annex to the
5963 function's symbol :-(. The problem with doing this is that it
5964 results in a function symbol with a location expression that
5965 has nothing to do with the location of the function, ouch! The
5966 relationship should be: a function's symbol has-a frame base; a
5967 frame-base has-a location expression. */
5968 dwarf2_symbol_mark_computed (attr, new->name, cu);
5970 cu->list_in_scope = &local_symbols;
5972 if (die->child != NULL)
5974 child_die = die->child;
5975 while (child_die && child_die->tag)
5977 if (child_die->tag == DW_TAG_template_type_param
5978 || child_die->tag == DW_TAG_template_value_param)
5980 struct symbol *arg = new_symbol (child_die, NULL, cu);
5983 VEC_safe_push (symbolp, template_args, arg);
5986 process_die (child_die, cu);
5987 child_die = sibling_die (child_die);
5991 inherit_abstract_dies (die, cu);
5993 /* If we have a DW_AT_specification, we might need to import using
5994 directives from the context of the specification DIE. See the
5995 comment in determine_prefix. */
5996 if (cu->language == language_cplus
5997 && dwarf2_attr (die, DW_AT_specification, cu))
5999 struct dwarf2_cu *spec_cu = cu;
6000 struct die_info *spec_die = die_specification (die, &spec_cu);
6004 child_die = spec_die->child;
6005 while (child_die && child_die->tag)
6007 if (child_die->tag == DW_TAG_imported_module)
6008 process_die (child_die, spec_cu);
6009 child_die = sibling_die (child_die);
6012 /* In some cases, GCC generates specification DIEs that
6013 themselves contain DW_AT_specification attributes. */
6014 spec_die = die_specification (spec_die, &spec_cu);
6018 new = pop_context ();
6019 /* Make a block for the local symbols within. */
6020 block = finish_block (new->name, &local_symbols, new->old_blocks,
6021 lowpc, highpc, objfile);
6023 /* For C++, set the block's scope. */
6024 if (cu->language == language_cplus || cu->language == language_fortran)
6025 cp_set_block_scope (new->name, block, &objfile->objfile_obstack,
6026 determine_prefix (die, cu),
6027 processing_has_namespace_info);
6029 /* If we have address ranges, record them. */
6030 dwarf2_record_block_ranges (die, block, baseaddr, cu);
6032 /* Attach template arguments to function. */
6033 if (! VEC_empty (symbolp, template_args))
6035 gdb_assert (templ_func != NULL);
6037 templ_func->n_template_arguments = VEC_length (symbolp, template_args);
6038 templ_func->template_arguments
6039 = obstack_alloc (&objfile->objfile_obstack,
6040 (templ_func->n_template_arguments
6041 * sizeof (struct symbol *)));
6042 memcpy (templ_func->template_arguments,
6043 VEC_address (symbolp, template_args),
6044 (templ_func->n_template_arguments * sizeof (struct symbol *)));
6045 VEC_free (symbolp, template_args);
6048 /* In C++, we can have functions nested inside functions (e.g., when
6049 a function declares a class that has methods). This means that
6050 when we finish processing a function scope, we may need to go
6051 back to building a containing block's symbol lists. */
6052 local_symbols = new->locals;
6053 param_symbols = new->params;
6054 using_directives = new->using_directives;
6056 /* If we've finished processing a top-level function, subsequent
6057 symbols go in the file symbol list. */
6058 if (outermost_context_p ())
6059 cu->list_in_scope = &file_symbols;
6062 /* Process all the DIES contained within a lexical block scope. Start
6063 a new scope, process the dies, and then close the scope. */
6066 read_lexical_block_scope (struct die_info *die, struct dwarf2_cu *cu)
6068 struct objfile *objfile = cu->objfile;
6069 struct context_stack *new;
6070 CORE_ADDR lowpc, highpc;
6071 struct die_info *child_die;
6074 baseaddr = ANOFFSET (objfile->section_offsets, SECT_OFF_TEXT (objfile));
6076 /* Ignore blocks with missing or invalid low and high pc attributes. */
6077 /* ??? Perhaps consider discontiguous blocks defined by DW_AT_ranges
6078 as multiple lexical blocks? Handling children in a sane way would
6079 be nasty. Might be easier to properly extend generic blocks to
6081 if (!dwarf2_get_pc_bounds (die, &lowpc, &highpc, cu, NULL))
6086 push_context (0, lowpc);
6087 if (die->child != NULL)
6089 child_die = die->child;
6090 while (child_die && child_die->tag)
6092 process_die (child_die, cu);
6093 child_die = sibling_die (child_die);
6096 new = pop_context ();
6098 if (local_symbols != NULL || using_directives != NULL)
6101 = finish_block (0, &local_symbols, new->old_blocks, new->start_addr,
6104 /* Note that recording ranges after traversing children, as we
6105 do here, means that recording a parent's ranges entails
6106 walking across all its children's ranges as they appear in
6107 the address map, which is quadratic behavior.
6109 It would be nicer to record the parent's ranges before
6110 traversing its children, simply overriding whatever you find
6111 there. But since we don't even decide whether to create a
6112 block until after we've traversed its children, that's hard
6114 dwarf2_record_block_ranges (die, block, baseaddr, cu);
6116 local_symbols = new->locals;
6117 using_directives = new->using_directives;
6120 /* Read in DW_TAG_GNU_call_site and insert it to CU->call_site_htab. */
6123 read_call_site_scope (struct die_info *die, struct dwarf2_cu *cu)
6125 struct objfile *objfile = cu->objfile;
6126 struct gdbarch *gdbarch = get_objfile_arch (objfile);
6127 CORE_ADDR pc, baseaddr;
6128 struct attribute *attr;
6129 struct call_site *call_site, call_site_local;
6132 struct die_info *child_die;
6134 baseaddr = ANOFFSET (objfile->section_offsets, SECT_OFF_TEXT (objfile));
6136 attr = dwarf2_attr (die, DW_AT_low_pc, cu);
6139 complaint (&symfile_complaints,
6140 _("missing DW_AT_low_pc for DW_TAG_GNU_call_site "
6141 "DIE 0x%x [in module %s]"),
6142 die->offset, objfile->name);
6145 pc = DW_ADDR (attr) + baseaddr;
6147 if (cu->call_site_htab == NULL)
6148 cu->call_site_htab = htab_create_alloc_ex (16, core_addr_hash, core_addr_eq,
6149 NULL, &objfile->objfile_obstack,
6150 hashtab_obstack_allocate, NULL);
6151 call_site_local.pc = pc;
6152 slot = htab_find_slot (cu->call_site_htab, &call_site_local, INSERT);
6155 complaint (&symfile_complaints,
6156 _("Duplicate PC %s for DW_TAG_GNU_call_site "
6157 "DIE 0x%x [in module %s]"),
6158 paddress (gdbarch, pc), die->offset, objfile->name);
6162 /* Count parameters at the caller. */
6165 for (child_die = die->child; child_die && child_die->tag;
6166 child_die = sibling_die (child_die))
6168 if (child_die->tag != DW_TAG_GNU_call_site_parameter)
6170 complaint (&symfile_complaints,
6171 _("Tag %d is not DW_TAG_GNU_call_site_parameter in "
6172 "DW_TAG_GNU_call_site child DIE 0x%x [in module %s]"),
6173 child_die->tag, child_die->offset, objfile->name);
6180 call_site = obstack_alloc (&objfile->objfile_obstack,
6181 (sizeof (*call_site)
6182 + (sizeof (*call_site->parameter)
6185 memset (call_site, 0, sizeof (*call_site) - sizeof (*call_site->parameter));
6188 if (dwarf2_flag_true_p (die, DW_AT_GNU_tail_call, cu))
6190 struct die_info *func_die;
6192 /* Skip also over DW_TAG_inlined_subroutine. */
6193 for (func_die = die->parent;
6194 func_die && func_die->tag != DW_TAG_subprogram
6195 && func_die->tag != DW_TAG_subroutine_type;
6196 func_die = func_die->parent);
6198 /* DW_AT_GNU_all_call_sites is a superset
6199 of DW_AT_GNU_all_tail_call_sites. */
6201 && !dwarf2_flag_true_p (func_die, DW_AT_GNU_all_call_sites, cu)
6202 && !dwarf2_flag_true_p (func_die, DW_AT_GNU_all_tail_call_sites, cu))
6204 /* TYPE_TAIL_CALL_LIST is not interesting in functions where it is
6205 not complete. But keep CALL_SITE for look ups via call_site_htab,
6206 both the initial caller containing the real return address PC and
6207 the final callee containing the current PC of a chain of tail
6208 calls do not need to have the tail call list complete. But any
6209 function candidate for a virtual tail call frame searched via
6210 TYPE_TAIL_CALL_LIST must have the tail call list complete to be
6211 determined unambiguously. */
6215 struct type *func_type = NULL;
6218 func_type = get_die_type (func_die, cu);
6219 if (func_type != NULL)
6221 gdb_assert (TYPE_CODE (func_type) == TYPE_CODE_FUNC);
6223 /* Enlist this call site to the function. */
6224 call_site->tail_call_next = TYPE_TAIL_CALL_LIST (func_type);
6225 TYPE_TAIL_CALL_LIST (func_type) = call_site;
6228 complaint (&symfile_complaints,
6229 _("Cannot find function owning DW_TAG_GNU_call_site "
6230 "DIE 0x%x [in module %s]"),
6231 die->offset, objfile->name);
6235 attr = dwarf2_attr (die, DW_AT_GNU_call_site_target, cu);
6237 attr = dwarf2_attr (die, DW_AT_abstract_origin, cu);
6238 SET_FIELD_DWARF_BLOCK (call_site->target, NULL);
6239 if (!attr || (attr_form_is_block (attr) && DW_BLOCK (attr)->size == 0))
6240 /* Keep NULL DWARF_BLOCK. */;
6241 else if (attr_form_is_block (attr))
6243 struct dwarf2_locexpr_baton *dlbaton;
6245 dlbaton = obstack_alloc (&objfile->objfile_obstack, sizeof (*dlbaton));
6246 dlbaton->data = DW_BLOCK (attr)->data;
6247 dlbaton->size = DW_BLOCK (attr)->size;
6248 dlbaton->per_cu = cu->per_cu;
6250 SET_FIELD_DWARF_BLOCK (call_site->target, dlbaton);
6252 else if (is_ref_attr (attr))
6254 struct dwarf2_cu *target_cu = cu;
6255 struct die_info *target_die;
6257 target_die = follow_die_ref_or_sig (die, attr, &target_cu);
6258 gdb_assert (target_cu->objfile == objfile);
6259 if (die_is_declaration (target_die, target_cu))
6261 const char *target_physname;
6263 target_physname = dwarf2_physname (NULL, target_die, target_cu);
6264 if (target_physname == NULL)
6265 complaint (&symfile_complaints,
6266 _("DW_AT_GNU_call_site_target target DIE has invalid "
6267 "physname, for referencing DIE 0x%x [in module %s]"),
6268 die->offset, objfile->name);
6270 SET_FIELD_PHYSNAME (call_site->target, (char *) target_physname);
6276 /* DW_AT_entry_pc should be preferred. */
6277 if (!dwarf2_get_pc_bounds (target_die, &lowpc, NULL, target_cu, NULL))
6278 complaint (&symfile_complaints,
6279 _("DW_AT_GNU_call_site_target target DIE has invalid "
6280 "low pc, for referencing DIE 0x%x [in module %s]"),
6281 die->offset, objfile->name);
6283 SET_FIELD_PHYSADDR (call_site->target, lowpc + baseaddr);
6287 complaint (&symfile_complaints,
6288 _("DW_TAG_GNU_call_site DW_AT_GNU_call_site_target is neither "
6289 "block nor reference, for DIE 0x%x [in module %s]"),
6290 die->offset, objfile->name);
6292 call_site->per_cu = cu->per_cu;
6294 for (child_die = die->child;
6295 child_die && child_die->tag;
6296 child_die = sibling_die (child_die))
6298 struct dwarf2_locexpr_baton *dlbaton;
6299 struct call_site_parameter *parameter;
6301 if (child_die->tag != DW_TAG_GNU_call_site_parameter)
6303 /* Already printed the complaint above. */
6307 gdb_assert (call_site->parameter_count < nparams);
6308 parameter = &call_site->parameter[call_site->parameter_count];
6310 /* DW_AT_location specifies the register number. Value of the data
6311 assumed for the register is contained in DW_AT_GNU_call_site_value. */
6313 attr = dwarf2_attr (child_die, DW_AT_location, cu);
6314 if (!attr || !attr_form_is_block (attr))
6316 complaint (&symfile_complaints,
6317 _("No DW_FORM_block* DW_AT_location for "
6318 "DW_TAG_GNU_call_site child DIE 0x%x [in module %s]"),
6319 child_die->offset, objfile->name);
6322 parameter->dwarf_reg = dwarf_block_to_dwarf_reg (DW_BLOCK (attr)->data,
6323 &DW_BLOCK (attr)->data[DW_BLOCK (attr)->size]);
6324 if (parameter->dwarf_reg == -1
6325 && !dwarf_block_to_sp_offset (gdbarch, DW_BLOCK (attr)->data,
6326 &DW_BLOCK (attr)->data[DW_BLOCK (attr)->size],
6327 ¶meter->fb_offset))
6329 complaint (&symfile_complaints,
6330 _("Only single DW_OP_reg or DW_OP_fbreg is supported "
6331 "for DW_FORM_block* DW_AT_location for "
6332 "DW_TAG_GNU_call_site child DIE 0x%x [in module %s]"),
6333 child_die->offset, objfile->name);
6337 attr = dwarf2_attr (child_die, DW_AT_GNU_call_site_value, cu);
6338 if (!attr_form_is_block (attr))
6340 complaint (&symfile_complaints,
6341 _("No DW_FORM_block* DW_AT_GNU_call_site_value for "
6342 "DW_TAG_GNU_call_site child DIE 0x%x [in module %s]"),
6343 child_die->offset, objfile->name);
6346 parameter->value = DW_BLOCK (attr)->data;
6347 parameter->value_size = DW_BLOCK (attr)->size;
6349 /* Parameters are not pre-cleared by memset above. */
6350 parameter->data_value = NULL;
6351 parameter->data_value_size = 0;
6352 call_site->parameter_count++;
6354 attr = dwarf2_attr (child_die, DW_AT_GNU_call_site_data_value, cu);
6357 if (!attr_form_is_block (attr))
6358 complaint (&symfile_complaints,
6359 _("No DW_FORM_block* DW_AT_GNU_call_site_data_value for "
6360 "DW_TAG_GNU_call_site child DIE 0x%x [in module %s]"),
6361 child_die->offset, objfile->name);
6364 parameter->data_value = DW_BLOCK (attr)->data;
6365 parameter->data_value_size = DW_BLOCK (attr)->size;
6371 /* Get low and high pc attributes from DW_AT_ranges attribute value OFFSET.
6372 Return 1 if the attributes are present and valid, otherwise, return 0.
6373 If RANGES_PST is not NULL we should setup `objfile->psymtabs_addrmap'. */
6376 dwarf2_ranges_read (unsigned offset, CORE_ADDR *low_return,
6377 CORE_ADDR *high_return, struct dwarf2_cu *cu,
6378 struct partial_symtab *ranges_pst)
6380 struct objfile *objfile = cu->objfile;
6381 struct comp_unit_head *cu_header = &cu->header;
6382 bfd *obfd = objfile->obfd;
6383 unsigned int addr_size = cu_header->addr_size;
6384 CORE_ADDR mask = ~(~(CORE_ADDR)1 << (addr_size * 8 - 1));
6385 /* Base address selection entry. */
6396 found_base = cu->base_known;
6397 base = cu->base_address;
6399 dwarf2_read_section (objfile, &dwarf2_per_objfile->ranges);
6400 if (offset >= dwarf2_per_objfile->ranges.size)
6402 complaint (&symfile_complaints,
6403 _("Offset %d out of bounds for DW_AT_ranges attribute"),
6407 buffer = dwarf2_per_objfile->ranges.buffer + offset;
6409 /* Read in the largest possible address. */
6410 marker = read_address (obfd, buffer, cu, &dummy);
6411 if ((marker & mask) == mask)
6413 /* If we found the largest possible address, then
6414 read the base address. */
6415 base = read_address (obfd, buffer + addr_size, cu, &dummy);
6416 buffer += 2 * addr_size;
6417 offset += 2 * addr_size;
6423 baseaddr = ANOFFSET (objfile->section_offsets, SECT_OFF_TEXT (objfile));
6427 CORE_ADDR range_beginning, range_end;
6429 range_beginning = read_address (obfd, buffer, cu, &dummy);
6430 buffer += addr_size;
6431 range_end = read_address (obfd, buffer, cu, &dummy);
6432 buffer += addr_size;
6433 offset += 2 * addr_size;
6435 /* An end of list marker is a pair of zero addresses. */
6436 if (range_beginning == 0 && range_end == 0)
6437 /* Found the end of list entry. */
6440 /* Each base address selection entry is a pair of 2 values.
6441 The first is the largest possible address, the second is
6442 the base address. Check for a base address here. */
6443 if ((range_beginning & mask) == mask)
6445 /* If we found the largest possible address, then
6446 read the base address. */
6447 base = read_address (obfd, buffer + addr_size, cu, &dummy);
6454 /* We have no valid base address for the ranges
6456 complaint (&symfile_complaints,
6457 _("Invalid .debug_ranges data (no base address)"));
6461 if (range_beginning > range_end)
6463 /* Inverted range entries are invalid. */
6464 complaint (&symfile_complaints,
6465 _("Invalid .debug_ranges data (inverted range)"));
6469 /* Empty range entries have no effect. */
6470 if (range_beginning == range_end)
6473 range_beginning += base;
6476 if (ranges_pst != NULL)
6477 addrmap_set_empty (objfile->psymtabs_addrmap,
6478 range_beginning + baseaddr,
6479 range_end - 1 + baseaddr,
6482 /* FIXME: This is recording everything as a low-high
6483 segment of consecutive addresses. We should have a
6484 data structure for discontiguous block ranges
6488 low = range_beginning;
6494 if (range_beginning < low)
6495 low = range_beginning;
6496 if (range_end > high)
6502 /* If the first entry is an end-of-list marker, the range
6503 describes an empty scope, i.e. no instructions. */
6509 *high_return = high;
6513 /* Get low and high pc attributes from a die. Return 1 if the attributes
6514 are present and valid, otherwise, return 0. Return -1 if the range is
6515 discontinuous, i.e. derived from DW_AT_ranges information. */
6517 dwarf2_get_pc_bounds (struct die_info *die, CORE_ADDR *lowpc,
6518 CORE_ADDR *highpc, struct dwarf2_cu *cu,
6519 struct partial_symtab *pst)
6521 struct attribute *attr;
6526 attr = dwarf2_attr (die, DW_AT_high_pc, cu);
6529 high = DW_ADDR (attr);
6530 attr = dwarf2_attr (die, DW_AT_low_pc, cu);
6532 low = DW_ADDR (attr);
6534 /* Found high w/o low attribute. */
6537 /* Found consecutive range of addresses. */
6542 attr = dwarf2_attr (die, DW_AT_ranges, cu);
6545 /* Value of the DW_AT_ranges attribute is the offset in the
6546 .debug_ranges section. */
6547 if (!dwarf2_ranges_read (DW_UNSND (attr), &low, &high, cu, pst))
6549 /* Found discontinuous range of addresses. */
6554 /* read_partial_die has also the strict LOW < HIGH requirement. */
6558 /* When using the GNU linker, .gnu.linkonce. sections are used to
6559 eliminate duplicate copies of functions and vtables and such.
6560 The linker will arbitrarily choose one and discard the others.
6561 The AT_*_pc values for such functions refer to local labels in
6562 these sections. If the section from that file was discarded, the
6563 labels are not in the output, so the relocs get a value of 0.
6564 If this is a discarded function, mark the pc bounds as invalid,
6565 so that GDB will ignore it. */
6566 if (low == 0 && !dwarf2_per_objfile->has_section_at_zero)
6575 /* Assuming that DIE represents a subprogram DIE or a lexical block, get
6576 its low and high PC addresses. Do nothing if these addresses could not
6577 be determined. Otherwise, set LOWPC to the low address if it is smaller,
6578 and HIGHPC to the high address if greater than HIGHPC. */
6581 dwarf2_get_subprogram_pc_bounds (struct die_info *die,
6582 CORE_ADDR *lowpc, CORE_ADDR *highpc,
6583 struct dwarf2_cu *cu)
6585 CORE_ADDR low, high;
6586 struct die_info *child = die->child;
6588 if (dwarf2_get_pc_bounds (die, &low, &high, cu, NULL))
6590 *lowpc = min (*lowpc, low);
6591 *highpc = max (*highpc, high);
6594 /* If the language does not allow nested subprograms (either inside
6595 subprograms or lexical blocks), we're done. */
6596 if (cu->language != language_ada)
6599 /* Check all the children of the given DIE. If it contains nested
6600 subprograms, then check their pc bounds. Likewise, we need to
6601 check lexical blocks as well, as they may also contain subprogram
6603 while (child && child->tag)
6605 if (child->tag == DW_TAG_subprogram
6606 || child->tag == DW_TAG_lexical_block)
6607 dwarf2_get_subprogram_pc_bounds (child, lowpc, highpc, cu);
6608 child = sibling_die (child);
6612 /* Get the low and high pc's represented by the scope DIE, and store
6613 them in *LOWPC and *HIGHPC. If the correct values can't be
6614 determined, set *LOWPC to -1 and *HIGHPC to 0. */
6617 get_scope_pc_bounds (struct die_info *die,
6618 CORE_ADDR *lowpc, CORE_ADDR *highpc,
6619 struct dwarf2_cu *cu)
6621 CORE_ADDR best_low = (CORE_ADDR) -1;
6622 CORE_ADDR best_high = (CORE_ADDR) 0;
6623 CORE_ADDR current_low, current_high;
6625 if (dwarf2_get_pc_bounds (die, ¤t_low, ¤t_high, cu, NULL))
6627 best_low = current_low;
6628 best_high = current_high;
6632 struct die_info *child = die->child;
6634 while (child && child->tag)
6636 switch (child->tag) {
6637 case DW_TAG_subprogram:
6638 dwarf2_get_subprogram_pc_bounds (child, &best_low, &best_high, cu);
6640 case DW_TAG_namespace:
6642 /* FIXME: carlton/2004-01-16: Should we do this for
6643 DW_TAG_class_type/DW_TAG_structure_type, too? I think
6644 that current GCC's always emit the DIEs corresponding
6645 to definitions of methods of classes as children of a
6646 DW_TAG_compile_unit or DW_TAG_namespace (as opposed to
6647 the DIEs giving the declarations, which could be
6648 anywhere). But I don't see any reason why the
6649 standards says that they have to be there. */
6650 get_scope_pc_bounds (child, ¤t_low, ¤t_high, cu);
6652 if (current_low != ((CORE_ADDR) -1))
6654 best_low = min (best_low, current_low);
6655 best_high = max (best_high, current_high);
6663 child = sibling_die (child);
6668 *highpc = best_high;
6671 /* Record the address ranges for BLOCK, offset by BASEADDR, as given
6674 dwarf2_record_block_ranges (struct die_info *die, struct block *block,
6675 CORE_ADDR baseaddr, struct dwarf2_cu *cu)
6677 struct objfile *objfile = cu->objfile;
6678 struct attribute *attr;
6680 attr = dwarf2_attr (die, DW_AT_high_pc, cu);
6683 CORE_ADDR high = DW_ADDR (attr);
6685 attr = dwarf2_attr (die, DW_AT_low_pc, cu);
6688 CORE_ADDR low = DW_ADDR (attr);
6690 record_block_range (block, baseaddr + low, baseaddr + high - 1);
6694 attr = dwarf2_attr (die, DW_AT_ranges, cu);
6697 bfd *obfd = objfile->obfd;
6699 /* The value of the DW_AT_ranges attribute is the offset of the
6700 address range list in the .debug_ranges section. */
6701 unsigned long offset = DW_UNSND (attr);
6702 gdb_byte *buffer = dwarf2_per_objfile->ranges.buffer + offset;
6704 /* For some target architectures, but not others, the
6705 read_address function sign-extends the addresses it returns.
6706 To recognize base address selection entries, we need a
6708 unsigned int addr_size = cu->header.addr_size;
6709 CORE_ADDR base_select_mask = ~(~(CORE_ADDR)1 << (addr_size * 8 - 1));
6711 /* The base address, to which the next pair is relative. Note
6712 that this 'base' is a DWARF concept: most entries in a range
6713 list are relative, to reduce the number of relocs against the
6714 debugging information. This is separate from this function's
6715 'baseaddr' argument, which GDB uses to relocate debugging
6716 information from a shared library based on the address at
6717 which the library was loaded. */
6718 CORE_ADDR base = cu->base_address;
6719 int base_known = cu->base_known;
6721 gdb_assert (dwarf2_per_objfile->ranges.readin);
6722 if (offset >= dwarf2_per_objfile->ranges.size)
6724 complaint (&symfile_complaints,
6725 _("Offset %lu out of bounds for DW_AT_ranges attribute"),
6732 unsigned int bytes_read;
6733 CORE_ADDR start, end;
6735 start = read_address (obfd, buffer, cu, &bytes_read);
6736 buffer += bytes_read;
6737 end = read_address (obfd, buffer, cu, &bytes_read);
6738 buffer += bytes_read;
6740 /* Did we find the end of the range list? */
6741 if (start == 0 && end == 0)
6744 /* Did we find a base address selection entry? */
6745 else if ((start & base_select_mask) == base_select_mask)
6751 /* We found an ordinary address range. */
6756 complaint (&symfile_complaints,
6757 _("Invalid .debug_ranges data "
6758 "(no base address)"));
6764 /* Inverted range entries are invalid. */
6765 complaint (&symfile_complaints,
6766 _("Invalid .debug_ranges data "
6767 "(inverted range)"));
6771 /* Empty range entries have no effect. */
6775 record_block_range (block,
6776 baseaddr + base + start,
6777 baseaddr + base + end - 1);
6783 /* Check for GCC PR debug/45124 fix which is not present in any G++ version up
6784 to 4.5.any while it is present already in G++ 4.6.0 - the PR has been fixed
6785 during 4.6.0 experimental. */
6788 producer_is_gxx_lt_4_6 (struct dwarf2_cu *cu)
6791 int major, minor, release;
6793 if (cu->producer == NULL)
6795 /* For unknown compilers expect their behavior is DWARF version
6798 GCC started to support .debug_types sections by -gdwarf-4 since
6799 gcc-4.5.x. As the .debug_types sections are missing DW_AT_producer
6800 for their space efficiency GDB cannot workaround gcc-4.5.x -gdwarf-4
6801 combination. gcc-4.5.x -gdwarf-4 binaries have DW_AT_accessibility
6802 interpreted incorrectly by GDB now - GCC PR debug/48229. */
6807 /* Skip any identifier after "GNU " - such as "C++" or "Java". */
6809 if (strncmp (cu->producer, "GNU ", strlen ("GNU ")) != 0)
6811 /* For non-GCC compilers expect their behavior is DWARF version
6816 cs = &cu->producer[strlen ("GNU ")];
6817 while (*cs && !isdigit (*cs))
6819 if (sscanf (cs, "%d.%d.%d", &major, &minor, &release) != 3)
6821 /* Not recognized as GCC. */
6826 return major < 4 || (major == 4 && minor < 6);
6829 /* Return the default accessibility type if it is not overriden by
6830 DW_AT_accessibility. */
6832 static enum dwarf_access_attribute
6833 dwarf2_default_access_attribute (struct die_info *die, struct dwarf2_cu *cu)
6835 if (cu->header.version < 3 || producer_is_gxx_lt_4_6 (cu))
6837 /* The default DWARF 2 accessibility for members is public, the default
6838 accessibility for inheritance is private. */
6840 if (die->tag != DW_TAG_inheritance)
6841 return DW_ACCESS_public;
6843 return DW_ACCESS_private;
6847 /* DWARF 3+ defines the default accessibility a different way. The same
6848 rules apply now for DW_TAG_inheritance as for the members and it only
6849 depends on the container kind. */
6851 if (die->parent->tag == DW_TAG_class_type)
6852 return DW_ACCESS_private;
6854 return DW_ACCESS_public;
6858 /* Look for DW_AT_data_member_location. Set *OFFSET to the byte
6859 offset. If the attribute was not found return 0, otherwise return
6860 1. If it was found but could not properly be handled, set *OFFSET
6864 handle_data_member_location (struct die_info *die, struct dwarf2_cu *cu,
6867 struct attribute *attr;
6869 attr = dwarf2_attr (die, DW_AT_data_member_location, cu);
6874 /* Note that we do not check for a section offset first here.
6875 This is because DW_AT_data_member_location is new in DWARF 4,
6876 so if we see it, we can assume that a constant form is really
6877 a constant and not a section offset. */
6878 if (attr_form_is_constant (attr))
6879 *offset = dwarf2_get_attr_constant_value (attr, 0);
6880 else if (attr_form_is_section_offset (attr))
6881 dwarf2_complex_location_expr_complaint ();
6882 else if (attr_form_is_block (attr))
6883 *offset = decode_locdesc (DW_BLOCK (attr), cu);
6885 dwarf2_complex_location_expr_complaint ();
6893 /* Add an aggregate field to the field list. */
6896 dwarf2_add_field (struct field_info *fip, struct die_info *die,
6897 struct dwarf2_cu *cu)
6899 struct objfile *objfile = cu->objfile;
6900 struct gdbarch *gdbarch = get_objfile_arch (objfile);
6901 struct nextfield *new_field;
6902 struct attribute *attr;
6904 char *fieldname = "";
6906 /* Allocate a new field list entry and link it in. */
6907 new_field = (struct nextfield *) xmalloc (sizeof (struct nextfield));
6908 make_cleanup (xfree, new_field);
6909 memset (new_field, 0, sizeof (struct nextfield));
6911 if (die->tag == DW_TAG_inheritance)
6913 new_field->next = fip->baseclasses;
6914 fip->baseclasses = new_field;
6918 new_field->next = fip->fields;
6919 fip->fields = new_field;
6923 attr = dwarf2_attr (die, DW_AT_accessibility, cu);
6925 new_field->accessibility = DW_UNSND (attr);
6927 new_field->accessibility = dwarf2_default_access_attribute (die, cu);
6928 if (new_field->accessibility != DW_ACCESS_public)
6929 fip->non_public_fields = 1;
6931 attr = dwarf2_attr (die, DW_AT_virtuality, cu);
6933 new_field->virtuality = DW_UNSND (attr);
6935 new_field->virtuality = DW_VIRTUALITY_none;
6937 fp = &new_field->field;
6939 if (die->tag == DW_TAG_member && ! die_is_declaration (die, cu))
6943 /* Data member other than a C++ static data member. */
6945 /* Get type of field. */
6946 fp->type = die_type (die, cu);
6948 SET_FIELD_BITPOS (*fp, 0);
6950 /* Get bit size of field (zero if none). */
6951 attr = dwarf2_attr (die, DW_AT_bit_size, cu);
6954 FIELD_BITSIZE (*fp) = DW_UNSND (attr);
6958 FIELD_BITSIZE (*fp) = 0;
6961 /* Get bit offset of field. */
6962 if (handle_data_member_location (die, cu, &offset))
6963 SET_FIELD_BITPOS (*fp, offset * bits_per_byte);
6964 attr = dwarf2_attr (die, DW_AT_bit_offset, cu);
6967 if (gdbarch_bits_big_endian (gdbarch))
6969 /* For big endian bits, the DW_AT_bit_offset gives the
6970 additional bit offset from the MSB of the containing
6971 anonymous object to the MSB of the field. We don't
6972 have to do anything special since we don't need to
6973 know the size of the anonymous object. */
6974 FIELD_BITPOS (*fp) += DW_UNSND (attr);
6978 /* For little endian bits, compute the bit offset to the
6979 MSB of the anonymous object, subtract off the number of
6980 bits from the MSB of the field to the MSB of the
6981 object, and then subtract off the number of bits of
6982 the field itself. The result is the bit offset of
6983 the LSB of the field. */
6985 int bit_offset = DW_UNSND (attr);
6987 attr = dwarf2_attr (die, DW_AT_byte_size, cu);
6990 /* The size of the anonymous object containing
6991 the bit field is explicit, so use the
6992 indicated size (in bytes). */
6993 anonymous_size = DW_UNSND (attr);
6997 /* The size of the anonymous object containing
6998 the bit field must be inferred from the type
6999 attribute of the data member containing the
7001 anonymous_size = TYPE_LENGTH (fp->type);
7003 FIELD_BITPOS (*fp) += anonymous_size * bits_per_byte
7004 - bit_offset - FIELD_BITSIZE (*fp);
7008 /* Get name of field. */
7009 fieldname = dwarf2_name (die, cu);
7010 if (fieldname == NULL)
7013 /* The name is already allocated along with this objfile, so we don't
7014 need to duplicate it for the type. */
7015 fp->name = fieldname;
7017 /* Change accessibility for artificial fields (e.g. virtual table
7018 pointer or virtual base class pointer) to private. */
7019 if (dwarf2_attr (die, DW_AT_artificial, cu))
7021 FIELD_ARTIFICIAL (*fp) = 1;
7022 new_field->accessibility = DW_ACCESS_private;
7023 fip->non_public_fields = 1;
7026 else if (die->tag == DW_TAG_member || die->tag == DW_TAG_variable)
7028 /* C++ static member. */
7030 /* NOTE: carlton/2002-11-05: It should be a DW_TAG_member that
7031 is a declaration, but all versions of G++ as of this writing
7032 (so through at least 3.2.1) incorrectly generate
7033 DW_TAG_variable tags. */
7035 const char *physname;
7037 /* Get name of field. */
7038 fieldname = dwarf2_name (die, cu);
7039 if (fieldname == NULL)
7042 attr = dwarf2_attr (die, DW_AT_const_value, cu);
7044 /* Only create a symbol if this is an external value.
7045 new_symbol checks this and puts the value in the global symbol
7046 table, which we want. If it is not external, new_symbol
7047 will try to put the value in cu->list_in_scope which is wrong. */
7048 && dwarf2_flag_true_p (die, DW_AT_external, cu))
7050 /* A static const member, not much different than an enum as far as
7051 we're concerned, except that we can support more types. */
7052 new_symbol (die, NULL, cu);
7055 /* Get physical name. */
7056 physname = dwarf2_physname (fieldname, die, cu);
7058 /* The name is already allocated along with this objfile, so we don't
7059 need to duplicate it for the type. */
7060 SET_FIELD_PHYSNAME (*fp, physname ? physname : "");
7061 FIELD_TYPE (*fp) = die_type (die, cu);
7062 FIELD_NAME (*fp) = fieldname;
7064 else if (die->tag == DW_TAG_inheritance)
7068 /* C++ base class field. */
7069 if (handle_data_member_location (die, cu, &offset))
7070 SET_FIELD_BITPOS (*fp, offset * bits_per_byte);
7071 FIELD_BITSIZE (*fp) = 0;
7072 FIELD_TYPE (*fp) = die_type (die, cu);
7073 FIELD_NAME (*fp) = type_name_no_tag (fp->type);
7074 fip->nbaseclasses++;
7078 /* Add a typedef defined in the scope of the FIP's class. */
7081 dwarf2_add_typedef (struct field_info *fip, struct die_info *die,
7082 struct dwarf2_cu *cu)
7084 struct objfile *objfile = cu->objfile;
7085 struct typedef_field_list *new_field;
7086 struct attribute *attr;
7087 struct typedef_field *fp;
7088 char *fieldname = "";
7090 /* Allocate a new field list entry and link it in. */
7091 new_field = xzalloc (sizeof (*new_field));
7092 make_cleanup (xfree, new_field);
7094 gdb_assert (die->tag == DW_TAG_typedef);
7096 fp = &new_field->field;
7098 /* Get name of field. */
7099 fp->name = dwarf2_name (die, cu);
7100 if (fp->name == NULL)
7103 fp->type = read_type_die (die, cu);
7105 new_field->next = fip->typedef_field_list;
7106 fip->typedef_field_list = new_field;
7107 fip->typedef_field_list_count++;
7110 /* Create the vector of fields, and attach it to the type. */
7113 dwarf2_attach_fields_to_type (struct field_info *fip, struct type *type,
7114 struct dwarf2_cu *cu)
7116 int nfields = fip->nfields;
7118 /* Record the field count, allocate space for the array of fields,
7119 and create blank accessibility bitfields if necessary. */
7120 TYPE_NFIELDS (type) = nfields;
7121 TYPE_FIELDS (type) = (struct field *)
7122 TYPE_ALLOC (type, sizeof (struct field) * nfields);
7123 memset (TYPE_FIELDS (type), 0, sizeof (struct field) * nfields);
7125 if (fip->non_public_fields && cu->language != language_ada)
7127 ALLOCATE_CPLUS_STRUCT_TYPE (type);
7129 TYPE_FIELD_PRIVATE_BITS (type) =
7130 (B_TYPE *) TYPE_ALLOC (type, B_BYTES (nfields));
7131 B_CLRALL (TYPE_FIELD_PRIVATE_BITS (type), nfields);
7133 TYPE_FIELD_PROTECTED_BITS (type) =
7134 (B_TYPE *) TYPE_ALLOC (type, B_BYTES (nfields));
7135 B_CLRALL (TYPE_FIELD_PROTECTED_BITS (type), nfields);
7137 TYPE_FIELD_IGNORE_BITS (type) =
7138 (B_TYPE *) TYPE_ALLOC (type, B_BYTES (nfields));
7139 B_CLRALL (TYPE_FIELD_IGNORE_BITS (type), nfields);
7142 /* If the type has baseclasses, allocate and clear a bit vector for
7143 TYPE_FIELD_VIRTUAL_BITS. */
7144 if (fip->nbaseclasses && cu->language != language_ada)
7146 int num_bytes = B_BYTES (fip->nbaseclasses);
7147 unsigned char *pointer;
7149 ALLOCATE_CPLUS_STRUCT_TYPE (type);
7150 pointer = TYPE_ALLOC (type, num_bytes);
7151 TYPE_FIELD_VIRTUAL_BITS (type) = pointer;
7152 B_CLRALL (TYPE_FIELD_VIRTUAL_BITS (type), fip->nbaseclasses);
7153 TYPE_N_BASECLASSES (type) = fip->nbaseclasses;
7156 /* Copy the saved-up fields into the field vector. Start from the head of
7157 the list, adding to the tail of the field array, so that they end up in
7158 the same order in the array in which they were added to the list. */
7159 while (nfields-- > 0)
7161 struct nextfield *fieldp;
7165 fieldp = fip->fields;
7166 fip->fields = fieldp->next;
7170 fieldp = fip->baseclasses;
7171 fip->baseclasses = fieldp->next;
7174 TYPE_FIELD (type, nfields) = fieldp->field;
7175 switch (fieldp->accessibility)
7177 case DW_ACCESS_private:
7178 if (cu->language != language_ada)
7179 SET_TYPE_FIELD_PRIVATE (type, nfields);
7182 case DW_ACCESS_protected:
7183 if (cu->language != language_ada)
7184 SET_TYPE_FIELD_PROTECTED (type, nfields);
7187 case DW_ACCESS_public:
7191 /* Unknown accessibility. Complain and treat it as public. */
7193 complaint (&symfile_complaints, _("unsupported accessibility %d"),
7194 fieldp->accessibility);
7198 if (nfields < fip->nbaseclasses)
7200 switch (fieldp->virtuality)
7202 case DW_VIRTUALITY_virtual:
7203 case DW_VIRTUALITY_pure_virtual:
7204 if (cu->language == language_ada)
7205 error (_("unexpected virtuality in component of Ada type"));
7206 SET_TYPE_FIELD_VIRTUAL (type, nfields);
7213 /* Add a member function to the proper fieldlist. */
7216 dwarf2_add_member_fn (struct field_info *fip, struct die_info *die,
7217 struct type *type, struct dwarf2_cu *cu)
7219 struct objfile *objfile = cu->objfile;
7220 struct attribute *attr;
7221 struct fnfieldlist *flp;
7223 struct fn_field *fnp;
7225 struct nextfnfield *new_fnfield;
7226 struct type *this_type;
7227 enum dwarf_access_attribute accessibility;
7229 if (cu->language == language_ada)
7230 error (_("unexpected member function in Ada type"));
7232 /* Get name of member function. */
7233 fieldname = dwarf2_name (die, cu);
7234 if (fieldname == NULL)
7237 /* Look up member function name in fieldlist. */
7238 for (i = 0; i < fip->nfnfields; i++)
7240 if (strcmp (fip->fnfieldlists[i].name, fieldname) == 0)
7244 /* Create new list element if necessary. */
7245 if (i < fip->nfnfields)
7246 flp = &fip->fnfieldlists[i];
7249 if ((fip->nfnfields % DW_FIELD_ALLOC_CHUNK) == 0)
7251 fip->fnfieldlists = (struct fnfieldlist *)
7252 xrealloc (fip->fnfieldlists,
7253 (fip->nfnfields + DW_FIELD_ALLOC_CHUNK)
7254 * sizeof (struct fnfieldlist));
7255 if (fip->nfnfields == 0)
7256 make_cleanup (free_current_contents, &fip->fnfieldlists);
7258 flp = &fip->fnfieldlists[fip->nfnfields];
7259 flp->name = fieldname;
7262 i = fip->nfnfields++;
7265 /* Create a new member function field and chain it to the field list
7267 new_fnfield = (struct nextfnfield *) xmalloc (sizeof (struct nextfnfield));
7268 make_cleanup (xfree, new_fnfield);
7269 memset (new_fnfield, 0, sizeof (struct nextfnfield));
7270 new_fnfield->next = flp->head;
7271 flp->head = new_fnfield;
7274 /* Fill in the member function field info. */
7275 fnp = &new_fnfield->fnfield;
7277 /* Delay processing of the physname until later. */
7278 if (cu->language == language_cplus || cu->language == language_java)
7280 add_to_method_list (type, i, flp->length - 1, fieldname,
7285 const char *physname = dwarf2_physname (fieldname, die, cu);
7286 fnp->physname = physname ? physname : "";
7289 fnp->type = alloc_type (objfile);
7290 this_type = read_type_die (die, cu);
7291 if (this_type && TYPE_CODE (this_type) == TYPE_CODE_FUNC)
7293 int nparams = TYPE_NFIELDS (this_type);
7295 /* TYPE is the domain of this method, and THIS_TYPE is the type
7296 of the method itself (TYPE_CODE_METHOD). */
7297 smash_to_method_type (fnp->type, type,
7298 TYPE_TARGET_TYPE (this_type),
7299 TYPE_FIELDS (this_type),
7300 TYPE_NFIELDS (this_type),
7301 TYPE_VARARGS (this_type));
7303 /* Handle static member functions.
7304 Dwarf2 has no clean way to discern C++ static and non-static
7305 member functions. G++ helps GDB by marking the first
7306 parameter for non-static member functions (which is the this
7307 pointer) as artificial. We obtain this information from
7308 read_subroutine_type via TYPE_FIELD_ARTIFICIAL. */
7309 if (nparams == 0 || TYPE_FIELD_ARTIFICIAL (this_type, 0) == 0)
7310 fnp->voffset = VOFFSET_STATIC;
7313 complaint (&symfile_complaints, _("member function type missing for '%s'"),
7314 dwarf2_full_name (fieldname, die, cu));
7316 /* Get fcontext from DW_AT_containing_type if present. */
7317 if (dwarf2_attr (die, DW_AT_containing_type, cu) != NULL)
7318 fnp->fcontext = die_containing_type (die, cu);
7320 /* dwarf2 doesn't have stubbed physical names, so the setting of is_const and
7321 is_volatile is irrelevant, as it is needed by gdb_mangle_name only. */
7323 /* Get accessibility. */
7324 attr = dwarf2_attr (die, DW_AT_accessibility, cu);
7326 accessibility = DW_UNSND (attr);
7328 accessibility = dwarf2_default_access_attribute (die, cu);
7329 switch (accessibility)
7331 case DW_ACCESS_private:
7332 fnp->is_private = 1;
7334 case DW_ACCESS_protected:
7335 fnp->is_protected = 1;
7339 /* Check for artificial methods. */
7340 attr = dwarf2_attr (die, DW_AT_artificial, cu);
7341 if (attr && DW_UNSND (attr) != 0)
7342 fnp->is_artificial = 1;
7344 /* Get index in virtual function table if it is a virtual member
7345 function. For older versions of GCC, this is an offset in the
7346 appropriate virtual table, as specified by DW_AT_containing_type.
7347 For everyone else, it is an expression to be evaluated relative
7348 to the object address. */
7350 attr = dwarf2_attr (die, DW_AT_vtable_elem_location, cu);
7353 if (attr_form_is_block (attr) && DW_BLOCK (attr)->size > 0)
7355 if (DW_BLOCK (attr)->data[0] == DW_OP_constu)
7357 /* Old-style GCC. */
7358 fnp->voffset = decode_locdesc (DW_BLOCK (attr), cu) + 2;
7360 else if (DW_BLOCK (attr)->data[0] == DW_OP_deref
7361 || (DW_BLOCK (attr)->size > 1
7362 && DW_BLOCK (attr)->data[0] == DW_OP_deref_size
7363 && DW_BLOCK (attr)->data[1] == cu->header.addr_size))
7365 struct dwarf_block blk;
7368 offset = (DW_BLOCK (attr)->data[0] == DW_OP_deref
7370 blk.size = DW_BLOCK (attr)->size - offset;
7371 blk.data = DW_BLOCK (attr)->data + offset;
7372 fnp->voffset = decode_locdesc (DW_BLOCK (attr), cu);
7373 if ((fnp->voffset % cu->header.addr_size) != 0)
7374 dwarf2_complex_location_expr_complaint ();
7376 fnp->voffset /= cu->header.addr_size;
7380 dwarf2_complex_location_expr_complaint ();
7383 fnp->fcontext = TYPE_TARGET_TYPE (TYPE_FIELD_TYPE (this_type, 0));
7385 else if (attr_form_is_section_offset (attr))
7387 dwarf2_complex_location_expr_complaint ();
7391 dwarf2_invalid_attrib_class_complaint ("DW_AT_vtable_elem_location",
7397 attr = dwarf2_attr (die, DW_AT_virtuality, cu);
7398 if (attr && DW_UNSND (attr))
7400 /* GCC does this, as of 2008-08-25; PR debug/37237. */
7401 complaint (&symfile_complaints,
7402 _("Member function \"%s\" (offset %d) is virtual "
7403 "but the vtable offset is not specified"),
7404 fieldname, die->offset);
7405 ALLOCATE_CPLUS_STRUCT_TYPE (type);
7406 TYPE_CPLUS_DYNAMIC (type) = 1;
7411 /* Create the vector of member function fields, and attach it to the type. */
7414 dwarf2_attach_fn_fields_to_type (struct field_info *fip, struct type *type,
7415 struct dwarf2_cu *cu)
7417 struct fnfieldlist *flp;
7420 if (cu->language == language_ada)
7421 error (_("unexpected member functions in Ada type"));
7423 ALLOCATE_CPLUS_STRUCT_TYPE (type);
7424 TYPE_FN_FIELDLISTS (type) = (struct fn_fieldlist *)
7425 TYPE_ALLOC (type, sizeof (struct fn_fieldlist) * fip->nfnfields);
7427 for (i = 0, flp = fip->fnfieldlists; i < fip->nfnfields; i++, flp++)
7429 struct nextfnfield *nfp = flp->head;
7430 struct fn_fieldlist *fn_flp = &TYPE_FN_FIELDLIST (type, i);
7433 TYPE_FN_FIELDLIST_NAME (type, i) = flp->name;
7434 TYPE_FN_FIELDLIST_LENGTH (type, i) = flp->length;
7435 fn_flp->fn_fields = (struct fn_field *)
7436 TYPE_ALLOC (type, sizeof (struct fn_field) * flp->length);
7437 for (k = flp->length; (k--, nfp); nfp = nfp->next)
7438 fn_flp->fn_fields[k] = nfp->fnfield;
7441 TYPE_NFN_FIELDS (type) = fip->nfnfields;
7444 /* Returns non-zero if NAME is the name of a vtable member in CU's
7445 language, zero otherwise. */
7447 is_vtable_name (const char *name, struct dwarf2_cu *cu)
7449 static const char vptr[] = "_vptr";
7450 static const char vtable[] = "vtable";
7452 /* Look for the C++ and Java forms of the vtable. */
7453 if ((cu->language == language_java
7454 && strncmp (name, vtable, sizeof (vtable) - 1) == 0)
7455 || (strncmp (name, vptr, sizeof (vptr) - 1) == 0
7456 && is_cplus_marker (name[sizeof (vptr) - 1])))
7462 /* GCC outputs unnamed structures that are really pointers to member
7463 functions, with the ABI-specified layout. If TYPE describes
7464 such a structure, smash it into a member function type.
7466 GCC shouldn't do this; it should just output pointer to member DIEs.
7467 This is GCC PR debug/28767. */
7470 quirk_gcc_member_function_pointer (struct type *type, struct objfile *objfile)
7472 struct type *pfn_type, *domain_type, *new_type;
7474 /* Check for a structure with no name and two children. */
7475 if (TYPE_CODE (type) != TYPE_CODE_STRUCT || TYPE_NFIELDS (type) != 2)
7478 /* Check for __pfn and __delta members. */
7479 if (TYPE_FIELD_NAME (type, 0) == NULL
7480 || strcmp (TYPE_FIELD_NAME (type, 0), "__pfn") != 0
7481 || TYPE_FIELD_NAME (type, 1) == NULL
7482 || strcmp (TYPE_FIELD_NAME (type, 1), "__delta") != 0)
7485 /* Find the type of the method. */
7486 pfn_type = TYPE_FIELD_TYPE (type, 0);
7487 if (pfn_type == NULL
7488 || TYPE_CODE (pfn_type) != TYPE_CODE_PTR
7489 || TYPE_CODE (TYPE_TARGET_TYPE (pfn_type)) != TYPE_CODE_FUNC)
7492 /* Look for the "this" argument. */
7493 pfn_type = TYPE_TARGET_TYPE (pfn_type);
7494 if (TYPE_NFIELDS (pfn_type) == 0
7495 /* || TYPE_FIELD_TYPE (pfn_type, 0) == NULL */
7496 || TYPE_CODE (TYPE_FIELD_TYPE (pfn_type, 0)) != TYPE_CODE_PTR)
7499 domain_type = TYPE_TARGET_TYPE (TYPE_FIELD_TYPE (pfn_type, 0));
7500 new_type = alloc_type (objfile);
7501 smash_to_method_type (new_type, domain_type, TYPE_TARGET_TYPE (pfn_type),
7502 TYPE_FIELDS (pfn_type), TYPE_NFIELDS (pfn_type),
7503 TYPE_VARARGS (pfn_type));
7504 smash_to_methodptr_type (type, new_type);
7507 /* Called when we find the DIE that starts a structure or union scope
7508 (definition) to create a type for the structure or union. Fill in
7509 the type's name and general properties; the members will not be
7510 processed until process_structure_type.
7512 NOTE: we need to call these functions regardless of whether or not the
7513 DIE has a DW_AT_name attribute, since it might be an anonymous
7514 structure or union. This gets the type entered into our set of
7517 However, if the structure is incomplete (an opaque struct/union)
7518 then suppress creating a symbol table entry for it since gdb only
7519 wants to find the one with the complete definition. Note that if
7520 it is complete, we just call new_symbol, which does it's own
7521 checking about whether the struct/union is anonymous or not (and
7522 suppresses creating a symbol table entry itself). */
7524 static struct type *
7525 read_structure_type (struct die_info *die, struct dwarf2_cu *cu)
7527 struct objfile *objfile = cu->objfile;
7529 struct attribute *attr;
7532 /* If the definition of this type lives in .debug_types, read that type.
7533 Don't follow DW_AT_specification though, that will take us back up
7534 the chain and we want to go down. */
7535 attr = dwarf2_attr_no_follow (die, DW_AT_signature, cu);
7538 struct dwarf2_cu *type_cu = cu;
7539 struct die_info *type_die = follow_die_ref_or_sig (die, attr, &type_cu);
7541 /* We could just recurse on read_structure_type, but we need to call
7542 get_die_type to ensure only one type for this DIE is created.
7543 This is important, for example, because for c++ classes we need
7544 TYPE_NAME set which is only done by new_symbol. Blech. */
7545 type = read_type_die (type_die, type_cu);
7547 /* TYPE_CU may not be the same as CU.
7548 Ensure TYPE is recorded in CU's type_hash table. */
7549 return set_die_type (die, type, cu);
7552 type = alloc_type (objfile);
7553 INIT_CPLUS_SPECIFIC (type);
7555 name = dwarf2_name (die, cu);
7558 if (cu->language == language_cplus
7559 || cu->language == language_java)
7561 char *full_name = (char *) dwarf2_full_name (name, die, cu);
7563 /* dwarf2_full_name might have already finished building the DIE's
7564 type. If so, there is no need to continue. */
7565 if (get_die_type (die, cu) != NULL)
7566 return get_die_type (die, cu);
7568 TYPE_TAG_NAME (type) = full_name;
7569 if (die->tag == DW_TAG_structure_type
7570 || die->tag == DW_TAG_class_type)
7571 TYPE_NAME (type) = TYPE_TAG_NAME (type);
7575 /* The name is already allocated along with this objfile, so
7576 we don't need to duplicate it for the type. */
7577 TYPE_TAG_NAME (type) = (char *) name;
7578 if (die->tag == DW_TAG_class_type)
7579 TYPE_NAME (type) = TYPE_TAG_NAME (type);
7583 if (die->tag == DW_TAG_structure_type)
7585 TYPE_CODE (type) = TYPE_CODE_STRUCT;
7587 else if (die->tag == DW_TAG_union_type)
7589 TYPE_CODE (type) = TYPE_CODE_UNION;
7593 TYPE_CODE (type) = TYPE_CODE_CLASS;
7596 if (cu->language == language_cplus && die->tag == DW_TAG_class_type)
7597 TYPE_DECLARED_CLASS (type) = 1;
7599 attr = dwarf2_attr (die, DW_AT_byte_size, cu);
7602 TYPE_LENGTH (type) = DW_UNSND (attr);
7606 TYPE_LENGTH (type) = 0;
7609 TYPE_STUB_SUPPORTED (type) = 1;
7610 if (die_is_declaration (die, cu))
7611 TYPE_STUB (type) = 1;
7612 else if (attr == NULL && die->child == NULL
7613 && producer_is_realview (cu->producer))
7614 /* RealView does not output the required DW_AT_declaration
7615 on incomplete types. */
7616 TYPE_STUB (type) = 1;
7618 /* We need to add the type field to the die immediately so we don't
7619 infinitely recurse when dealing with pointers to the structure
7620 type within the structure itself. */
7621 set_die_type (die, type, cu);
7623 /* set_die_type should be already done. */
7624 set_descriptive_type (type, die, cu);
7629 /* Finish creating a structure or union type, including filling in
7630 its members and creating a symbol for it. */
7633 process_structure_scope (struct die_info *die, struct dwarf2_cu *cu)
7635 struct objfile *objfile = cu->objfile;
7636 struct die_info *child_die = die->child;
7639 type = get_die_type (die, cu);
7641 type = read_structure_type (die, cu);
7643 if (die->child != NULL && ! die_is_declaration (die, cu))
7645 struct field_info fi;
7646 struct die_info *child_die;
7647 VEC (symbolp) *template_args = NULL;
7648 struct cleanup *back_to = make_cleanup (null_cleanup, 0);
7650 memset (&fi, 0, sizeof (struct field_info));
7652 child_die = die->child;
7654 while (child_die && child_die->tag)
7656 if (child_die->tag == DW_TAG_member
7657 || child_die->tag == DW_TAG_variable)
7659 /* NOTE: carlton/2002-11-05: A C++ static data member
7660 should be a DW_TAG_member that is a declaration, but
7661 all versions of G++ as of this writing (so through at
7662 least 3.2.1) incorrectly generate DW_TAG_variable
7663 tags for them instead. */
7664 dwarf2_add_field (&fi, child_die, cu);
7666 else if (child_die->tag == DW_TAG_subprogram)
7668 /* C++ member function. */
7669 dwarf2_add_member_fn (&fi, child_die, type, cu);
7671 else if (child_die->tag == DW_TAG_inheritance)
7673 /* C++ base class field. */
7674 dwarf2_add_field (&fi, child_die, cu);
7676 else if (child_die->tag == DW_TAG_typedef)
7677 dwarf2_add_typedef (&fi, child_die, cu);
7678 else if (child_die->tag == DW_TAG_template_type_param
7679 || child_die->tag == DW_TAG_template_value_param)
7681 struct symbol *arg = new_symbol (child_die, NULL, cu);
7684 VEC_safe_push (symbolp, template_args, arg);
7687 child_die = sibling_die (child_die);
7690 /* Attach template arguments to type. */
7691 if (! VEC_empty (symbolp, template_args))
7693 ALLOCATE_CPLUS_STRUCT_TYPE (type);
7694 TYPE_N_TEMPLATE_ARGUMENTS (type)
7695 = VEC_length (symbolp, template_args);
7696 TYPE_TEMPLATE_ARGUMENTS (type)
7697 = obstack_alloc (&objfile->objfile_obstack,
7698 (TYPE_N_TEMPLATE_ARGUMENTS (type)
7699 * sizeof (struct symbol *)));
7700 memcpy (TYPE_TEMPLATE_ARGUMENTS (type),
7701 VEC_address (symbolp, template_args),
7702 (TYPE_N_TEMPLATE_ARGUMENTS (type)
7703 * sizeof (struct symbol *)));
7704 VEC_free (symbolp, template_args);
7707 /* Attach fields and member functions to the type. */
7709 dwarf2_attach_fields_to_type (&fi, type, cu);
7712 dwarf2_attach_fn_fields_to_type (&fi, type, cu);
7714 /* Get the type which refers to the base class (possibly this
7715 class itself) which contains the vtable pointer for the current
7716 class from the DW_AT_containing_type attribute. This use of
7717 DW_AT_containing_type is a GNU extension. */
7719 if (dwarf2_attr (die, DW_AT_containing_type, cu) != NULL)
7721 struct type *t = die_containing_type (die, cu);
7723 TYPE_VPTR_BASETYPE (type) = t;
7728 /* Our own class provides vtbl ptr. */
7729 for (i = TYPE_NFIELDS (t) - 1;
7730 i >= TYPE_N_BASECLASSES (t);
7733 char *fieldname = TYPE_FIELD_NAME (t, i);
7735 if (is_vtable_name (fieldname, cu))
7737 TYPE_VPTR_FIELDNO (type) = i;
7742 /* Complain if virtual function table field not found. */
7743 if (i < TYPE_N_BASECLASSES (t))
7744 complaint (&symfile_complaints,
7745 _("virtual function table pointer "
7746 "not found when defining class '%s'"),
7747 TYPE_TAG_NAME (type) ? TYPE_TAG_NAME (type) :
7752 TYPE_VPTR_FIELDNO (type) = TYPE_VPTR_FIELDNO (t);
7755 else if (cu->producer
7756 && strncmp (cu->producer,
7757 "IBM(R) XL C/C++ Advanced Edition", 32) == 0)
7759 /* The IBM XLC compiler does not provide direct indication
7760 of the containing type, but the vtable pointer is
7761 always named __vfp. */
7765 for (i = TYPE_NFIELDS (type) - 1;
7766 i >= TYPE_N_BASECLASSES (type);
7769 if (strcmp (TYPE_FIELD_NAME (type, i), "__vfp") == 0)
7771 TYPE_VPTR_FIELDNO (type) = i;
7772 TYPE_VPTR_BASETYPE (type) = type;
7779 /* Copy fi.typedef_field_list linked list elements content into the
7780 allocated array TYPE_TYPEDEF_FIELD_ARRAY (type). */
7781 if (fi.typedef_field_list)
7783 int i = fi.typedef_field_list_count;
7785 ALLOCATE_CPLUS_STRUCT_TYPE (type);
7786 TYPE_TYPEDEF_FIELD_ARRAY (type)
7787 = TYPE_ALLOC (type, sizeof (TYPE_TYPEDEF_FIELD (type, 0)) * i);
7788 TYPE_TYPEDEF_FIELD_COUNT (type) = i;
7790 /* Reverse the list order to keep the debug info elements order. */
7793 struct typedef_field *dest, *src;
7795 dest = &TYPE_TYPEDEF_FIELD (type, i);
7796 src = &fi.typedef_field_list->field;
7797 fi.typedef_field_list = fi.typedef_field_list->next;
7802 do_cleanups (back_to);
7804 if (HAVE_CPLUS_STRUCT (type))
7805 TYPE_CPLUS_REALLY_JAVA (type) = cu->language == language_java;
7808 quirk_gcc_member_function_pointer (type, objfile);
7810 /* NOTE: carlton/2004-03-16: GCC 3.4 (or at least one of its
7811 snapshots) has been known to create a die giving a declaration
7812 for a class that has, as a child, a die giving a definition for a
7813 nested class. So we have to process our children even if the
7814 current die is a declaration. Normally, of course, a declaration
7815 won't have any children at all. */
7817 while (child_die != NULL && child_die->tag)
7819 if (child_die->tag == DW_TAG_member
7820 || child_die->tag == DW_TAG_variable
7821 || child_die->tag == DW_TAG_inheritance
7822 || child_die->tag == DW_TAG_template_value_param
7823 || child_die->tag == DW_TAG_template_type_param)
7828 process_die (child_die, cu);
7830 child_die = sibling_die (child_die);
7833 /* Do not consider external references. According to the DWARF standard,
7834 these DIEs are identified by the fact that they have no byte_size
7835 attribute, and a declaration attribute. */
7836 if (dwarf2_attr (die, DW_AT_byte_size, cu) != NULL
7837 || !die_is_declaration (die, cu))
7838 new_symbol (die, type, cu);
7841 /* Given a DW_AT_enumeration_type die, set its type. We do not
7842 complete the type's fields yet, or create any symbols. */
7844 static struct type *
7845 read_enumeration_type (struct die_info *die, struct dwarf2_cu *cu)
7847 struct objfile *objfile = cu->objfile;
7849 struct attribute *attr;
7852 /* If the definition of this type lives in .debug_types, read that type.
7853 Don't follow DW_AT_specification though, that will take us back up
7854 the chain and we want to go down. */
7855 attr = dwarf2_attr_no_follow (die, DW_AT_signature, cu);
7858 struct dwarf2_cu *type_cu = cu;
7859 struct die_info *type_die = follow_die_ref_or_sig (die, attr, &type_cu);
7861 type = read_type_die (type_die, type_cu);
7863 /* TYPE_CU may not be the same as CU.
7864 Ensure TYPE is recorded in CU's type_hash table. */
7865 return set_die_type (die, type, cu);
7868 type = alloc_type (objfile);
7870 TYPE_CODE (type) = TYPE_CODE_ENUM;
7871 name = dwarf2_full_name (NULL, die, cu);
7873 TYPE_TAG_NAME (type) = (char *) name;
7875 attr = dwarf2_attr (die, DW_AT_byte_size, cu);
7878 TYPE_LENGTH (type) = DW_UNSND (attr);
7882 TYPE_LENGTH (type) = 0;
7885 /* The enumeration DIE can be incomplete. In Ada, any type can be
7886 declared as private in the package spec, and then defined only
7887 inside the package body. Such types are known as Taft Amendment
7888 Types. When another package uses such a type, an incomplete DIE
7889 may be generated by the compiler. */
7890 if (die_is_declaration (die, cu))
7891 TYPE_STUB (type) = 1;
7893 return set_die_type (die, type, cu);
7896 /* Given a pointer to a die which begins an enumeration, process all
7897 the dies that define the members of the enumeration, and create the
7898 symbol for the enumeration type.
7900 NOTE: We reverse the order of the element list. */
7903 process_enumeration_scope (struct die_info *die, struct dwarf2_cu *cu)
7905 struct type *this_type;
7907 this_type = get_die_type (die, cu);
7908 if (this_type == NULL)
7909 this_type = read_enumeration_type (die, cu);
7911 if (die->child != NULL)
7913 struct die_info *child_die;
7915 struct field *fields = NULL;
7917 int unsigned_enum = 1;
7922 child_die = die->child;
7923 while (child_die && child_die->tag)
7925 if (child_die->tag != DW_TAG_enumerator)
7927 process_die (child_die, cu);
7931 name = dwarf2_name (child_die, cu);
7934 sym = new_symbol (child_die, this_type, cu);
7935 if (SYMBOL_VALUE (sym) < 0)
7940 else if ((mask & SYMBOL_VALUE (sym)) != 0)
7943 mask |= SYMBOL_VALUE (sym);
7945 if ((num_fields % DW_FIELD_ALLOC_CHUNK) == 0)
7947 fields = (struct field *)
7949 (num_fields + DW_FIELD_ALLOC_CHUNK)
7950 * sizeof (struct field));
7953 FIELD_NAME (fields[num_fields]) = SYMBOL_LINKAGE_NAME (sym);
7954 FIELD_TYPE (fields[num_fields]) = NULL;
7955 SET_FIELD_BITPOS (fields[num_fields], SYMBOL_VALUE (sym));
7956 FIELD_BITSIZE (fields[num_fields]) = 0;
7962 child_die = sibling_die (child_die);
7967 TYPE_NFIELDS (this_type) = num_fields;
7968 TYPE_FIELDS (this_type) = (struct field *)
7969 TYPE_ALLOC (this_type, sizeof (struct field) * num_fields);
7970 memcpy (TYPE_FIELDS (this_type), fields,
7971 sizeof (struct field) * num_fields);
7975 TYPE_UNSIGNED (this_type) = 1;
7977 TYPE_FLAG_ENUM (this_type) = 1;
7980 /* If we are reading an enum from a .debug_types unit, and the enum
7981 is a declaration, and the enum is not the signatured type in the
7982 unit, then we do not want to add a symbol for it. Adding a
7983 symbol would in some cases obscure the true definition of the
7984 enum, giving users an incomplete type when the definition is
7985 actually available. Note that we do not want to do this for all
7986 enums which are just declarations, because C++0x allows forward
7987 enum declarations. */
7988 if (cu->per_cu->debug_types_section
7989 && die_is_declaration (die, cu))
7991 struct signatured_type *type_sig;
7994 = lookup_signatured_type_at_offset (dwarf2_per_objfile->objfile,
7995 cu->per_cu->debug_types_section,
7996 cu->per_cu->offset);
7997 if (type_sig->type_offset != die->offset)
8001 new_symbol (die, this_type, cu);
8004 /* Extract all information from a DW_TAG_array_type DIE and put it in
8005 the DIE's type field. For now, this only handles one dimensional
8008 static struct type *
8009 read_array_type (struct die_info *die, struct dwarf2_cu *cu)
8011 struct objfile *objfile = cu->objfile;
8012 struct die_info *child_die;
8014 struct type *element_type, *range_type, *index_type;
8015 struct type **range_types = NULL;
8016 struct attribute *attr;
8018 struct cleanup *back_to;
8021 element_type = die_type (die, cu);
8023 /* The die_type call above may have already set the type for this DIE. */
8024 type = get_die_type (die, cu);
8028 /* Irix 6.2 native cc creates array types without children for
8029 arrays with unspecified length. */
8030 if (die->child == NULL)
8032 index_type = objfile_type (objfile)->builtin_int;
8033 range_type = create_range_type (NULL, index_type, 0, -1);
8034 type = create_array_type (NULL, element_type, range_type);
8035 return set_die_type (die, type, cu);
8038 back_to = make_cleanup (null_cleanup, NULL);
8039 child_die = die->child;
8040 while (child_die && child_die->tag)
8042 if (child_die->tag == DW_TAG_subrange_type)
8044 struct type *child_type = read_type_die (child_die, cu);
8046 if (child_type != NULL)
8048 /* The range type was succesfully read. Save it for the
8049 array type creation. */
8050 if ((ndim % DW_FIELD_ALLOC_CHUNK) == 0)
8052 range_types = (struct type **)
8053 xrealloc (range_types, (ndim + DW_FIELD_ALLOC_CHUNK)
8054 * sizeof (struct type *));
8056 make_cleanup (free_current_contents, &range_types);
8058 range_types[ndim++] = child_type;
8061 child_die = sibling_die (child_die);
8064 /* Dwarf2 dimensions are output from left to right, create the
8065 necessary array types in backwards order. */
8067 type = element_type;
8069 if (read_array_order (die, cu) == DW_ORD_col_major)
8074 type = create_array_type (NULL, type, range_types[i++]);
8079 type = create_array_type (NULL, type, range_types[ndim]);
8082 /* Understand Dwarf2 support for vector types (like they occur on
8083 the PowerPC w/ AltiVec). Gcc just adds another attribute to the
8084 array type. This is not part of the Dwarf2/3 standard yet, but a
8085 custom vendor extension. The main difference between a regular
8086 array and the vector variant is that vectors are passed by value
8088 attr = dwarf2_attr (die, DW_AT_GNU_vector, cu);
8090 make_vector_type (type);
8092 /* The DIE may have DW_AT_byte_size set. For example an OpenCL
8093 implementation may choose to implement triple vectors using this
8095 attr = dwarf2_attr (die, DW_AT_byte_size, cu);
8098 if (DW_UNSND (attr) >= TYPE_LENGTH (type))
8099 TYPE_LENGTH (type) = DW_UNSND (attr);
8101 complaint (&symfile_complaints,
8102 _("DW_AT_byte_size for array type smaller "
8103 "than the total size of elements"));
8106 name = dwarf2_name (die, cu);
8108 TYPE_NAME (type) = name;
8110 /* Install the type in the die. */
8111 set_die_type (die, type, cu);
8113 /* set_die_type should be already done. */
8114 set_descriptive_type (type, die, cu);
8116 do_cleanups (back_to);
8121 static enum dwarf_array_dim_ordering
8122 read_array_order (struct die_info *die, struct dwarf2_cu *cu)
8124 struct attribute *attr;
8126 attr = dwarf2_attr (die, DW_AT_ordering, cu);
8128 if (attr) return DW_SND (attr);
8130 /* GNU F77 is a special case, as at 08/2004 array type info is the
8131 opposite order to the dwarf2 specification, but data is still
8132 laid out as per normal fortran.
8134 FIXME: dsl/2004-8-20: If G77 is ever fixed, this will also need
8135 version checking. */
8137 if (cu->language == language_fortran
8138 && cu->producer && strstr (cu->producer, "GNU F77"))
8140 return DW_ORD_row_major;
8143 switch (cu->language_defn->la_array_ordering)
8145 case array_column_major:
8146 return DW_ORD_col_major;
8147 case array_row_major:
8149 return DW_ORD_row_major;
8153 /* Extract all information from a DW_TAG_set_type DIE and put it in
8154 the DIE's type field. */
8156 static struct type *
8157 read_set_type (struct die_info *die, struct dwarf2_cu *cu)
8159 struct type *domain_type, *set_type;
8160 struct attribute *attr;
8162 domain_type = die_type (die, cu);
8164 /* The die_type call above may have already set the type for this DIE. */
8165 set_type = get_die_type (die, cu);
8169 set_type = create_set_type (NULL, domain_type);
8171 attr = dwarf2_attr (die, DW_AT_byte_size, cu);
8173 TYPE_LENGTH (set_type) = DW_UNSND (attr);
8175 return set_die_type (die, set_type, cu);
8178 /* First cut: install each common block member as a global variable. */
8181 read_common_block (struct die_info *die, struct dwarf2_cu *cu)
8183 struct die_info *child_die;
8184 struct attribute *attr;
8186 CORE_ADDR base = (CORE_ADDR) 0;
8188 attr = dwarf2_attr (die, DW_AT_location, cu);
8191 /* Support the .debug_loc offsets. */
8192 if (attr_form_is_block (attr))
8194 base = decode_locdesc (DW_BLOCK (attr), cu);
8196 else if (attr_form_is_section_offset (attr))
8198 dwarf2_complex_location_expr_complaint ();
8202 dwarf2_invalid_attrib_class_complaint ("DW_AT_location",
8203 "common block member");
8206 if (die->child != NULL)
8208 child_die = die->child;
8209 while (child_die && child_die->tag)
8213 sym = new_symbol (child_die, NULL, cu);
8215 && handle_data_member_location (child_die, cu, &offset))
8217 SYMBOL_VALUE_ADDRESS (sym) = base + offset;
8218 add_symbol_to_list (sym, &global_symbols);
8220 child_die = sibling_die (child_die);
8225 /* Create a type for a C++ namespace. */
8227 static struct type *
8228 read_namespace_type (struct die_info *die, struct dwarf2_cu *cu)
8230 struct objfile *objfile = cu->objfile;
8231 const char *previous_prefix, *name;
8235 /* For extensions, reuse the type of the original namespace. */
8236 if (dwarf2_attr (die, DW_AT_extension, cu) != NULL)
8238 struct die_info *ext_die;
8239 struct dwarf2_cu *ext_cu = cu;
8241 ext_die = dwarf2_extension (die, &ext_cu);
8242 type = read_type_die (ext_die, ext_cu);
8244 /* EXT_CU may not be the same as CU.
8245 Ensure TYPE is recorded in CU's type_hash table. */
8246 return set_die_type (die, type, cu);
8249 name = namespace_name (die, &is_anonymous, cu);
8251 /* Now build the name of the current namespace. */
8253 previous_prefix = determine_prefix (die, cu);
8254 if (previous_prefix[0] != '\0')
8255 name = typename_concat (&objfile->objfile_obstack,
8256 previous_prefix, name, 0, cu);
8258 /* Create the type. */
8259 type = init_type (TYPE_CODE_NAMESPACE, 0, 0, NULL,
8261 TYPE_NAME (type) = (char *) name;
8262 TYPE_TAG_NAME (type) = TYPE_NAME (type);
8264 return set_die_type (die, type, cu);
8267 /* Read a C++ namespace. */
8270 read_namespace (struct die_info *die, struct dwarf2_cu *cu)
8272 struct objfile *objfile = cu->objfile;
8275 /* Add a symbol associated to this if we haven't seen the namespace
8276 before. Also, add a using directive if it's an anonymous
8279 if (dwarf2_attr (die, DW_AT_extension, cu) == NULL)
8283 type = read_type_die (die, cu);
8284 new_symbol (die, type, cu);
8286 namespace_name (die, &is_anonymous, cu);
8289 const char *previous_prefix = determine_prefix (die, cu);
8291 cp_add_using_directive (previous_prefix, TYPE_NAME (type), NULL,
8292 NULL, NULL, &objfile->objfile_obstack);
8296 if (die->child != NULL)
8298 struct die_info *child_die = die->child;
8300 while (child_die && child_die->tag)
8302 process_die (child_die, cu);
8303 child_die = sibling_die (child_die);
8308 /* Read a Fortran module as type. This DIE can be only a declaration used for
8309 imported module. Still we need that type as local Fortran "use ... only"
8310 declaration imports depend on the created type in determine_prefix. */
8312 static struct type *
8313 read_module_type (struct die_info *die, struct dwarf2_cu *cu)
8315 struct objfile *objfile = cu->objfile;
8319 module_name = dwarf2_name (die, cu);
8321 complaint (&symfile_complaints,
8322 _("DW_TAG_module has no name, offset 0x%x"),
8324 type = init_type (TYPE_CODE_MODULE, 0, 0, module_name, objfile);
8326 /* determine_prefix uses TYPE_TAG_NAME. */
8327 TYPE_TAG_NAME (type) = TYPE_NAME (type);
8329 return set_die_type (die, type, cu);
8332 /* Read a Fortran module. */
8335 read_module (struct die_info *die, struct dwarf2_cu *cu)
8337 struct die_info *child_die = die->child;
8339 while (child_die && child_die->tag)
8341 process_die (child_die, cu);
8342 child_die = sibling_die (child_die);
8346 /* Return the name of the namespace represented by DIE. Set
8347 *IS_ANONYMOUS to tell whether or not the namespace is an anonymous
8351 namespace_name (struct die_info *die, int *is_anonymous, struct dwarf2_cu *cu)
8353 struct die_info *current_die;
8354 const char *name = NULL;
8356 /* Loop through the extensions until we find a name. */
8358 for (current_die = die;
8359 current_die != NULL;
8360 current_die = dwarf2_extension (die, &cu))
8362 name = dwarf2_name (current_die, cu);
8367 /* Is it an anonymous namespace? */
8369 *is_anonymous = (name == NULL);
8371 name = CP_ANONYMOUS_NAMESPACE_STR;
8376 /* Extract all information from a DW_TAG_pointer_type DIE and add to
8377 the user defined type vector. */
8379 static struct type *
8380 read_tag_pointer_type (struct die_info *die, struct dwarf2_cu *cu)
8382 struct gdbarch *gdbarch = get_objfile_arch (cu->objfile);
8383 struct comp_unit_head *cu_header = &cu->header;
8385 struct attribute *attr_byte_size;
8386 struct attribute *attr_address_class;
8387 int byte_size, addr_class;
8388 struct type *target_type;
8390 target_type = die_type (die, cu);
8392 /* The die_type call above may have already set the type for this DIE. */
8393 type = get_die_type (die, cu);
8397 type = lookup_pointer_type (target_type);
8399 attr_byte_size = dwarf2_attr (die, DW_AT_byte_size, cu);
8401 byte_size = DW_UNSND (attr_byte_size);
8403 byte_size = cu_header->addr_size;
8405 attr_address_class = dwarf2_attr (die, DW_AT_address_class, cu);
8406 if (attr_address_class)
8407 addr_class = DW_UNSND (attr_address_class);
8409 addr_class = DW_ADDR_none;
8411 /* If the pointer size or address class is different than the
8412 default, create a type variant marked as such and set the
8413 length accordingly. */
8414 if (TYPE_LENGTH (type) != byte_size || addr_class != DW_ADDR_none)
8416 if (gdbarch_address_class_type_flags_p (gdbarch))
8420 type_flags = gdbarch_address_class_type_flags
8421 (gdbarch, byte_size, addr_class);
8422 gdb_assert ((type_flags & ~TYPE_INSTANCE_FLAG_ADDRESS_CLASS_ALL)
8424 type = make_type_with_address_space (type, type_flags);
8426 else if (TYPE_LENGTH (type) != byte_size)
8428 complaint (&symfile_complaints,
8429 _("invalid pointer size %d"), byte_size);
8433 /* Should we also complain about unhandled address classes? */
8437 TYPE_LENGTH (type) = byte_size;
8438 return set_die_type (die, type, cu);
8441 /* Extract all information from a DW_TAG_ptr_to_member_type DIE and add to
8442 the user defined type vector. */
8444 static struct type *
8445 read_tag_ptr_to_member_type (struct die_info *die, struct dwarf2_cu *cu)
8448 struct type *to_type;
8449 struct type *domain;
8451 to_type = die_type (die, cu);
8452 domain = die_containing_type (die, cu);
8454 /* The calls above may have already set the type for this DIE. */
8455 type = get_die_type (die, cu);
8459 if (TYPE_CODE (check_typedef (to_type)) == TYPE_CODE_METHOD)
8460 type = lookup_methodptr_type (to_type);
8462 type = lookup_memberptr_type (to_type, domain);
8464 return set_die_type (die, type, cu);
8467 /* Extract all information from a DW_TAG_reference_type DIE and add to
8468 the user defined type vector. */
8470 static struct type *
8471 read_tag_reference_type (struct die_info *die, struct dwarf2_cu *cu)
8473 struct comp_unit_head *cu_header = &cu->header;
8474 struct type *type, *target_type;
8475 struct attribute *attr;
8477 target_type = die_type (die, cu);
8479 /* The die_type call above may have already set the type for this DIE. */
8480 type = get_die_type (die, cu);
8484 type = lookup_reference_type (target_type);
8485 attr = dwarf2_attr (die, DW_AT_byte_size, cu);
8488 TYPE_LENGTH (type) = DW_UNSND (attr);
8492 TYPE_LENGTH (type) = cu_header->addr_size;
8494 return set_die_type (die, type, cu);
8497 static struct type *
8498 read_tag_const_type (struct die_info *die, struct dwarf2_cu *cu)
8500 struct type *base_type, *cv_type;
8502 base_type = die_type (die, cu);
8504 /* The die_type call above may have already set the type for this DIE. */
8505 cv_type = get_die_type (die, cu);
8509 /* In case the const qualifier is applied to an array type, the element type
8510 is so qualified, not the array type (section 6.7.3 of C99). */
8511 if (TYPE_CODE (base_type) == TYPE_CODE_ARRAY)
8513 struct type *el_type, *inner_array;
8515 base_type = copy_type (base_type);
8516 inner_array = base_type;
8518 while (TYPE_CODE (TYPE_TARGET_TYPE (inner_array)) == TYPE_CODE_ARRAY)
8520 TYPE_TARGET_TYPE (inner_array) =
8521 copy_type (TYPE_TARGET_TYPE (inner_array));
8522 inner_array = TYPE_TARGET_TYPE (inner_array);
8525 el_type = TYPE_TARGET_TYPE (inner_array);
8526 TYPE_TARGET_TYPE (inner_array) =
8527 make_cv_type (1, TYPE_VOLATILE (el_type), el_type, NULL);
8529 return set_die_type (die, base_type, cu);
8532 cv_type = make_cv_type (1, TYPE_VOLATILE (base_type), base_type, 0);
8533 return set_die_type (die, cv_type, cu);
8536 static struct type *
8537 read_tag_volatile_type (struct die_info *die, struct dwarf2_cu *cu)
8539 struct type *base_type, *cv_type;
8541 base_type = die_type (die, cu);
8543 /* The die_type call above may have already set the type for this DIE. */
8544 cv_type = get_die_type (die, cu);
8548 cv_type = make_cv_type (TYPE_CONST (base_type), 1, base_type, 0);
8549 return set_die_type (die, cv_type, cu);
8552 /* Extract all information from a DW_TAG_string_type DIE and add to
8553 the user defined type vector. It isn't really a user defined type,
8554 but it behaves like one, with other DIE's using an AT_user_def_type
8555 attribute to reference it. */
8557 static struct type *
8558 read_tag_string_type (struct die_info *die, struct dwarf2_cu *cu)
8560 struct objfile *objfile = cu->objfile;
8561 struct gdbarch *gdbarch = get_objfile_arch (objfile);
8562 struct type *type, *range_type, *index_type, *char_type;
8563 struct attribute *attr;
8564 unsigned int length;
8566 attr = dwarf2_attr (die, DW_AT_string_length, cu);
8569 length = DW_UNSND (attr);
8573 /* Check for the DW_AT_byte_size attribute. */
8574 attr = dwarf2_attr (die, DW_AT_byte_size, cu);
8577 length = DW_UNSND (attr);
8585 index_type = objfile_type (objfile)->builtin_int;
8586 range_type = create_range_type (NULL, index_type, 1, length);
8587 char_type = language_string_char_type (cu->language_defn, gdbarch);
8588 type = create_string_type (NULL, char_type, range_type);
8590 return set_die_type (die, type, cu);
8593 /* Handle DIES due to C code like:
8597 int (*funcp)(int a, long l);
8601 ('funcp' generates a DW_TAG_subroutine_type DIE). */
8603 static struct type *
8604 read_subroutine_type (struct die_info *die, struct dwarf2_cu *cu)
8606 struct objfile *objfile = cu->objfile;
8607 struct type *type; /* Type that this function returns. */
8608 struct type *ftype; /* Function that returns above type. */
8609 struct attribute *attr;
8611 type = die_type (die, cu);
8613 /* The die_type call above may have already set the type for this DIE. */
8614 ftype = get_die_type (die, cu);
8618 ftype = lookup_function_type (type);
8620 /* All functions in C++, Pascal and Java have prototypes. */
8621 attr = dwarf2_attr (die, DW_AT_prototyped, cu);
8622 if ((attr && (DW_UNSND (attr) != 0))
8623 || cu->language == language_cplus
8624 || cu->language == language_java
8625 || cu->language == language_pascal)
8626 TYPE_PROTOTYPED (ftype) = 1;
8627 else if (producer_is_realview (cu->producer))
8628 /* RealView does not emit DW_AT_prototyped. We can not
8629 distinguish prototyped and unprototyped functions; default to
8630 prototyped, since that is more common in modern code (and
8631 RealView warns about unprototyped functions). */
8632 TYPE_PROTOTYPED (ftype) = 1;
8634 /* Store the calling convention in the type if it's available in
8635 the subroutine die. Otherwise set the calling convention to
8636 the default value DW_CC_normal. */
8637 attr = dwarf2_attr (die, DW_AT_calling_convention, cu);
8639 TYPE_CALLING_CONVENTION (ftype) = DW_UNSND (attr);
8640 else if (cu->producer && strstr (cu->producer, "IBM XL C for OpenCL"))
8641 TYPE_CALLING_CONVENTION (ftype) = DW_CC_GDB_IBM_OpenCL;
8643 TYPE_CALLING_CONVENTION (ftype) = DW_CC_normal;
8645 /* We need to add the subroutine type to the die immediately so
8646 we don't infinitely recurse when dealing with parameters
8647 declared as the same subroutine type. */
8648 set_die_type (die, ftype, cu);
8650 if (die->child != NULL)
8652 struct type *void_type = objfile_type (objfile)->builtin_void;
8653 struct die_info *child_die;
8654 int nparams, iparams;
8656 /* Count the number of parameters.
8657 FIXME: GDB currently ignores vararg functions, but knows about
8658 vararg member functions. */
8660 child_die = die->child;
8661 while (child_die && child_die->tag)
8663 if (child_die->tag == DW_TAG_formal_parameter)
8665 else if (child_die->tag == DW_TAG_unspecified_parameters)
8666 TYPE_VARARGS (ftype) = 1;
8667 child_die = sibling_die (child_die);
8670 /* Allocate storage for parameters and fill them in. */
8671 TYPE_NFIELDS (ftype) = nparams;
8672 TYPE_FIELDS (ftype) = (struct field *)
8673 TYPE_ZALLOC (ftype, nparams * sizeof (struct field));
8675 /* TYPE_FIELD_TYPE must never be NULL. Pre-fill the array to ensure it
8676 even if we error out during the parameters reading below. */
8677 for (iparams = 0; iparams < nparams; iparams++)
8678 TYPE_FIELD_TYPE (ftype, iparams) = void_type;
8681 child_die = die->child;
8682 while (child_die && child_die->tag)
8684 if (child_die->tag == DW_TAG_formal_parameter)
8686 struct type *arg_type;
8688 /* DWARF version 2 has no clean way to discern C++
8689 static and non-static member functions. G++ helps
8690 GDB by marking the first parameter for non-static
8691 member functions (which is the this pointer) as
8692 artificial. We pass this information to
8693 dwarf2_add_member_fn via TYPE_FIELD_ARTIFICIAL.
8695 DWARF version 3 added DW_AT_object_pointer, which GCC
8696 4.5 does not yet generate. */
8697 attr = dwarf2_attr (child_die, DW_AT_artificial, cu);
8699 TYPE_FIELD_ARTIFICIAL (ftype, iparams) = DW_UNSND (attr);
8702 TYPE_FIELD_ARTIFICIAL (ftype, iparams) = 0;
8704 /* GCC/43521: In java, the formal parameter
8705 "this" is sometimes not marked with DW_AT_artificial. */
8706 if (cu->language == language_java)
8708 const char *name = dwarf2_name (child_die, cu);
8710 if (name && !strcmp (name, "this"))
8711 TYPE_FIELD_ARTIFICIAL (ftype, iparams) = 1;
8714 arg_type = die_type (child_die, cu);
8716 /* RealView does not mark THIS as const, which the testsuite
8717 expects. GCC marks THIS as const in method definitions,
8718 but not in the class specifications (GCC PR 43053). */
8719 if (cu->language == language_cplus && !TYPE_CONST (arg_type)
8720 && TYPE_FIELD_ARTIFICIAL (ftype, iparams))
8723 struct dwarf2_cu *arg_cu = cu;
8724 const char *name = dwarf2_name (child_die, cu);
8726 attr = dwarf2_attr (die, DW_AT_object_pointer, cu);
8729 /* If the compiler emits this, use it. */
8730 if (follow_die_ref (die, attr, &arg_cu) == child_die)
8733 else if (name && strcmp (name, "this") == 0)
8734 /* Function definitions will have the argument names. */
8736 else if (name == NULL && iparams == 0)
8737 /* Declarations may not have the names, so like
8738 elsewhere in GDB, assume an artificial first
8739 argument is "this". */
8743 arg_type = make_cv_type (1, TYPE_VOLATILE (arg_type),
8747 TYPE_FIELD_TYPE (ftype, iparams) = arg_type;
8750 child_die = sibling_die (child_die);
8757 static struct type *
8758 read_typedef (struct die_info *die, struct dwarf2_cu *cu)
8760 struct objfile *objfile = cu->objfile;
8761 const char *name = NULL;
8762 struct type *this_type, *target_type;
8764 name = dwarf2_full_name (NULL, die, cu);
8765 this_type = init_type (TYPE_CODE_TYPEDEF, 0,
8766 TYPE_FLAG_TARGET_STUB, NULL, objfile);
8767 TYPE_NAME (this_type) = (char *) name;
8768 set_die_type (die, this_type, cu);
8769 target_type = die_type (die, cu);
8770 if (target_type != this_type)
8771 TYPE_TARGET_TYPE (this_type) = target_type;
8774 /* Self-referential typedefs are, it seems, not allowed by the DWARF
8775 spec and cause infinite loops in GDB. */
8776 complaint (&symfile_complaints,
8777 _("Self-referential DW_TAG_typedef "
8778 "- DIE at 0x%x [in module %s]"),
8779 die->offset, objfile->name);
8780 TYPE_TARGET_TYPE (this_type) = NULL;
8785 /* Find a representation of a given base type and install
8786 it in the TYPE field of the die. */
8788 static struct type *
8789 read_base_type (struct die_info *die, struct dwarf2_cu *cu)
8791 struct objfile *objfile = cu->objfile;
8793 struct attribute *attr;
8794 int encoding = 0, size = 0;
8796 enum type_code code = TYPE_CODE_INT;
8798 struct type *target_type = NULL;
8800 attr = dwarf2_attr (die, DW_AT_encoding, cu);
8803 encoding = DW_UNSND (attr);
8805 attr = dwarf2_attr (die, DW_AT_byte_size, cu);
8808 size = DW_UNSND (attr);
8810 name = dwarf2_name (die, cu);
8813 complaint (&symfile_complaints,
8814 _("DW_AT_name missing from DW_TAG_base_type"));
8819 case DW_ATE_address:
8820 /* Turn DW_ATE_address into a void * pointer. */
8821 code = TYPE_CODE_PTR;
8822 type_flags |= TYPE_FLAG_UNSIGNED;
8823 target_type = init_type (TYPE_CODE_VOID, 1, 0, NULL, objfile);
8825 case DW_ATE_boolean:
8826 code = TYPE_CODE_BOOL;
8827 type_flags |= TYPE_FLAG_UNSIGNED;
8829 case DW_ATE_complex_float:
8830 code = TYPE_CODE_COMPLEX;
8831 target_type = init_type (TYPE_CODE_FLT, size / 2, 0, NULL, objfile);
8833 case DW_ATE_decimal_float:
8834 code = TYPE_CODE_DECFLOAT;
8837 code = TYPE_CODE_FLT;
8841 case DW_ATE_unsigned:
8842 type_flags |= TYPE_FLAG_UNSIGNED;
8843 if (cu->language == language_fortran
8845 && strncmp (name, "character(", sizeof ("character(") - 1) == 0)
8846 code = TYPE_CODE_CHAR;
8848 case DW_ATE_signed_char:
8849 if (cu->language == language_ada || cu->language == language_m2
8850 || cu->language == language_pascal
8851 || cu->language == language_fortran)
8852 code = TYPE_CODE_CHAR;
8854 case DW_ATE_unsigned_char:
8855 if (cu->language == language_ada || cu->language == language_m2
8856 || cu->language == language_pascal
8857 || cu->language == language_fortran)
8858 code = TYPE_CODE_CHAR;
8859 type_flags |= TYPE_FLAG_UNSIGNED;
8862 /* We just treat this as an integer and then recognize the
8863 type by name elsewhere. */
8867 complaint (&symfile_complaints, _("unsupported DW_AT_encoding: '%s'"),
8868 dwarf_type_encoding_name (encoding));
8872 type = init_type (code, size, type_flags, NULL, objfile);
8873 TYPE_NAME (type) = name;
8874 TYPE_TARGET_TYPE (type) = target_type;
8876 if (name && strcmp (name, "char") == 0)
8877 TYPE_NOSIGN (type) = 1;
8879 return set_die_type (die, type, cu);
8882 /* Read the given DW_AT_subrange DIE. */
8884 static struct type *
8885 read_subrange_type (struct die_info *die, struct dwarf2_cu *cu)
8887 struct type *base_type;
8888 struct type *range_type;
8889 struct attribute *attr;
8893 LONGEST negative_mask;
8895 base_type = die_type (die, cu);
8896 /* Preserve BASE_TYPE's original type, just set its LENGTH. */
8897 check_typedef (base_type);
8899 /* The die_type call above may have already set the type for this DIE. */
8900 range_type = get_die_type (die, cu);
8904 if (cu->language == language_fortran)
8906 /* FORTRAN implies a lower bound of 1, if not given. */
8910 /* FIXME: For variable sized arrays either of these could be
8911 a variable rather than a constant value. We'll allow it,
8912 but we don't know how to handle it. */
8913 attr = dwarf2_attr (die, DW_AT_lower_bound, cu);
8915 low = dwarf2_get_attr_constant_value (attr, 0);
8917 attr = dwarf2_attr (die, DW_AT_upper_bound, cu);
8920 if (attr_form_is_block (attr) || is_ref_attr (attr))
8922 /* GCC encodes arrays with unspecified or dynamic length
8923 with a DW_FORM_block1 attribute or a reference attribute.
8924 FIXME: GDB does not yet know how to handle dynamic
8925 arrays properly, treat them as arrays with unspecified
8928 FIXME: jimb/2003-09-22: GDB does not really know
8929 how to handle arrays of unspecified length
8930 either; we just represent them as zero-length
8931 arrays. Choose an appropriate upper bound given
8932 the lower bound we've computed above. */
8936 high = dwarf2_get_attr_constant_value (attr, 1);
8940 attr = dwarf2_attr (die, DW_AT_count, cu);
8943 int count = dwarf2_get_attr_constant_value (attr, 1);
8944 high = low + count - 1;
8948 /* Unspecified array length. */
8953 /* Dwarf-2 specifications explicitly allows to create subrange types
8954 without specifying a base type.
8955 In that case, the base type must be set to the type of
8956 the lower bound, upper bound or count, in that order, if any of these
8957 three attributes references an object that has a type.
8958 If no base type is found, the Dwarf-2 specifications say that
8959 a signed integer type of size equal to the size of an address should
8961 For the following C code: `extern char gdb_int [];'
8962 GCC produces an empty range DIE.
8963 FIXME: muller/2010-05-28: Possible references to object for low bound,
8964 high bound or count are not yet handled by this code. */
8965 if (TYPE_CODE (base_type) == TYPE_CODE_VOID)
8967 struct objfile *objfile = cu->objfile;
8968 struct gdbarch *gdbarch = get_objfile_arch (objfile);
8969 int addr_size = gdbarch_addr_bit (gdbarch) /8;
8970 struct type *int_type = objfile_type (objfile)->builtin_int;
8972 /* Test "int", "long int", and "long long int" objfile types,
8973 and select the first one having a size above or equal to the
8974 architecture address size. */
8975 if (int_type && TYPE_LENGTH (int_type) >= addr_size)
8976 base_type = int_type;
8979 int_type = objfile_type (objfile)->builtin_long;
8980 if (int_type && TYPE_LENGTH (int_type) >= addr_size)
8981 base_type = int_type;
8984 int_type = objfile_type (objfile)->builtin_long_long;
8985 if (int_type && TYPE_LENGTH (int_type) >= addr_size)
8986 base_type = int_type;
8992 (LONGEST) -1 << (TYPE_LENGTH (base_type) * TARGET_CHAR_BIT - 1);
8993 if (!TYPE_UNSIGNED (base_type) && (low & negative_mask))
8994 low |= negative_mask;
8995 if (!TYPE_UNSIGNED (base_type) && (high & negative_mask))
8996 high |= negative_mask;
8998 range_type = create_range_type (NULL, base_type, low, high);
9000 /* Mark arrays with dynamic length at least as an array of unspecified
9001 length. GDB could check the boundary but before it gets implemented at
9002 least allow accessing the array elements. */
9003 if (attr && attr_form_is_block (attr))
9004 TYPE_HIGH_BOUND_UNDEFINED (range_type) = 1;
9006 /* Ada expects an empty array on no boundary attributes. */
9007 if (attr == NULL && cu->language != language_ada)
9008 TYPE_HIGH_BOUND_UNDEFINED (range_type) = 1;
9010 name = dwarf2_name (die, cu);
9012 TYPE_NAME (range_type) = name;
9014 attr = dwarf2_attr (die, DW_AT_byte_size, cu);
9016 TYPE_LENGTH (range_type) = DW_UNSND (attr);
9018 set_die_type (die, range_type, cu);
9020 /* set_die_type should be already done. */
9021 set_descriptive_type (range_type, die, cu);
9026 static struct type *
9027 read_unspecified_type (struct die_info *die, struct dwarf2_cu *cu)
9031 /* For now, we only support the C meaning of an unspecified type: void. */
9033 type = init_type (TYPE_CODE_VOID, 0, 0, NULL, cu->objfile);
9034 TYPE_NAME (type) = dwarf2_name (die, cu);
9036 return set_die_type (die, type, cu);
9039 /* Trivial hash function for die_info: the hash value of a DIE
9040 is its offset in .debug_info for this objfile. */
9043 die_hash (const void *item)
9045 const struct die_info *die = item;
9050 /* Trivial comparison function for die_info structures: two DIEs
9051 are equal if they have the same offset. */
9054 die_eq (const void *item_lhs, const void *item_rhs)
9056 const struct die_info *die_lhs = item_lhs;
9057 const struct die_info *die_rhs = item_rhs;
9059 return die_lhs->offset == die_rhs->offset;
9062 /* Read a whole compilation unit into a linked list of dies. */
9064 static struct die_info *
9065 read_comp_unit (gdb_byte *info_ptr, struct dwarf2_cu *cu)
9067 struct die_reader_specs reader_specs;
9068 int read_abbrevs = 0;
9069 struct cleanup *back_to = NULL;
9070 struct die_info *die;
9072 if (cu->dwarf2_abbrevs == NULL)
9074 dwarf2_read_abbrevs (cu);
9075 back_to = make_cleanup (dwarf2_free_abbrev_table, cu);
9079 gdb_assert (cu->die_hash == NULL);
9081 = htab_create_alloc_ex (cu->header.length / 12,
9085 &cu->comp_unit_obstack,
9086 hashtab_obstack_allocate,
9087 dummy_obstack_deallocate);
9089 init_cu_die_reader (&reader_specs, cu);
9091 die = read_die_and_children (&reader_specs, info_ptr, &info_ptr, NULL);
9094 do_cleanups (back_to);
9099 /* Main entry point for reading a DIE and all children.
9100 Read the DIE and dump it if requested. */
9102 static struct die_info *
9103 read_die_and_children (const struct die_reader_specs *reader,
9105 gdb_byte **new_info_ptr,
9106 struct die_info *parent)
9108 struct die_info *result = read_die_and_children_1 (reader, info_ptr,
9109 new_info_ptr, parent);
9111 if (dwarf2_die_debug)
9113 fprintf_unfiltered (gdb_stdlog,
9114 "\nRead die from %s of %s:\n",
9115 (reader->cu->per_cu->debug_types_section
9118 reader->abfd->filename);
9119 dump_die (result, dwarf2_die_debug);
9125 /* Read a single die and all its descendents. Set the die's sibling
9126 field to NULL; set other fields in the die correctly, and set all
9127 of the descendents' fields correctly. Set *NEW_INFO_PTR to the
9128 location of the info_ptr after reading all of those dies. PARENT
9129 is the parent of the die in question. */
9131 static struct die_info *
9132 read_die_and_children_1 (const struct die_reader_specs *reader,
9134 gdb_byte **new_info_ptr,
9135 struct die_info *parent)
9137 struct die_info *die;
9141 cur_ptr = read_full_die (reader, &die, info_ptr, &has_children);
9144 *new_info_ptr = cur_ptr;
9147 store_in_ref_table (die, reader->cu);
9150 die->child = read_die_and_siblings (reader, cur_ptr, new_info_ptr, die);
9154 *new_info_ptr = cur_ptr;
9157 die->sibling = NULL;
9158 die->parent = parent;
9162 /* Read a die, all of its descendents, and all of its siblings; set
9163 all of the fields of all of the dies correctly. Arguments are as
9164 in read_die_and_children. */
9166 static struct die_info *
9167 read_die_and_siblings (const struct die_reader_specs *reader,
9169 gdb_byte **new_info_ptr,
9170 struct die_info *parent)
9172 struct die_info *first_die, *last_sibling;
9176 first_die = last_sibling = NULL;
9180 struct die_info *die
9181 = read_die_and_children_1 (reader, cur_ptr, &cur_ptr, parent);
9185 *new_info_ptr = cur_ptr;
9192 last_sibling->sibling = die;
9198 /* Read the die from the .debug_info section buffer. Set DIEP to
9199 point to a newly allocated die with its information, except for its
9200 child, sibling, and parent fields. Set HAS_CHILDREN to tell
9201 whether the die has children or not. */
9204 read_full_die (const struct die_reader_specs *reader,
9205 struct die_info **diep, gdb_byte *info_ptr,
9208 unsigned int abbrev_number, bytes_read, i, offset;
9209 struct abbrev_info *abbrev;
9210 struct die_info *die;
9211 struct dwarf2_cu *cu = reader->cu;
9212 bfd *abfd = reader->abfd;
9214 offset = info_ptr - reader->buffer;
9215 abbrev_number = read_unsigned_leb128 (abfd, info_ptr, &bytes_read);
9216 info_ptr += bytes_read;
9224 abbrev = dwarf2_lookup_abbrev (abbrev_number, cu);
9226 error (_("Dwarf Error: could not find abbrev number %d [in module %s]"),
9228 bfd_get_filename (abfd));
9230 die = dwarf_alloc_die (cu, abbrev->num_attrs);
9231 die->offset = offset;
9232 die->tag = abbrev->tag;
9233 die->abbrev = abbrev_number;
9235 die->num_attrs = abbrev->num_attrs;
9237 for (i = 0; i < abbrev->num_attrs; ++i)
9238 info_ptr = read_attribute (&die->attrs[i], &abbrev->attrs[i],
9239 abfd, info_ptr, cu);
9242 *has_children = abbrev->has_children;
9246 /* In DWARF version 2, the description of the debugging information is
9247 stored in a separate .debug_abbrev section. Before we read any
9248 dies from a section we read in all abbreviations and install them
9249 in a hash table. This function also sets flags in CU describing
9250 the data found in the abbrev table. */
9253 dwarf2_read_abbrevs (struct dwarf2_cu *cu)
9255 bfd *abfd = cu->objfile->obfd;
9256 struct comp_unit_head *cu_header = &cu->header;
9257 gdb_byte *abbrev_ptr;
9258 struct abbrev_info *cur_abbrev;
9259 unsigned int abbrev_number, bytes_read, abbrev_name;
9260 unsigned int abbrev_form, hash_number;
9261 struct attr_abbrev *cur_attrs;
9262 unsigned int allocated_attrs;
9264 /* Initialize dwarf2 abbrevs. */
9265 obstack_init (&cu->abbrev_obstack);
9266 cu->dwarf2_abbrevs = obstack_alloc (&cu->abbrev_obstack,
9268 * sizeof (struct abbrev_info *)));
9269 memset (cu->dwarf2_abbrevs, 0,
9270 ABBREV_HASH_SIZE * sizeof (struct abbrev_info *));
9272 dwarf2_read_section (dwarf2_per_objfile->objfile,
9273 &dwarf2_per_objfile->abbrev);
9274 abbrev_ptr = dwarf2_per_objfile->abbrev.buffer + cu_header->abbrev_offset;
9275 abbrev_number = read_unsigned_leb128 (abfd, abbrev_ptr, &bytes_read);
9276 abbrev_ptr += bytes_read;
9278 allocated_attrs = ATTR_ALLOC_CHUNK;
9279 cur_attrs = xmalloc (allocated_attrs * sizeof (struct attr_abbrev));
9281 /* Loop until we reach an abbrev number of 0. */
9282 while (abbrev_number)
9284 cur_abbrev = dwarf_alloc_abbrev (cu);
9286 /* read in abbrev header */
9287 cur_abbrev->number = abbrev_number;
9288 cur_abbrev->tag = read_unsigned_leb128 (abfd, abbrev_ptr, &bytes_read);
9289 abbrev_ptr += bytes_read;
9290 cur_abbrev->has_children = read_1_byte (abfd, abbrev_ptr);
9293 if (cur_abbrev->tag == DW_TAG_namespace)
9294 cu->has_namespace_info = 1;
9296 /* now read in declarations */
9297 abbrev_name = read_unsigned_leb128 (abfd, abbrev_ptr, &bytes_read);
9298 abbrev_ptr += bytes_read;
9299 abbrev_form = read_unsigned_leb128 (abfd, abbrev_ptr, &bytes_read);
9300 abbrev_ptr += bytes_read;
9303 if (cur_abbrev->num_attrs == allocated_attrs)
9305 allocated_attrs += ATTR_ALLOC_CHUNK;
9307 = xrealloc (cur_attrs, (allocated_attrs
9308 * sizeof (struct attr_abbrev)));
9311 /* Record whether this compilation unit might have
9312 inter-compilation-unit references. If we don't know what form
9313 this attribute will have, then it might potentially be a
9314 DW_FORM_ref_addr, so we conservatively expect inter-CU
9317 if (abbrev_form == DW_FORM_ref_addr
9318 || abbrev_form == DW_FORM_indirect)
9319 cu->has_form_ref_addr = 1;
9321 cur_attrs[cur_abbrev->num_attrs].name = abbrev_name;
9322 cur_attrs[cur_abbrev->num_attrs++].form = abbrev_form;
9323 abbrev_name = read_unsigned_leb128 (abfd, abbrev_ptr, &bytes_read);
9324 abbrev_ptr += bytes_read;
9325 abbrev_form = read_unsigned_leb128 (abfd, abbrev_ptr, &bytes_read);
9326 abbrev_ptr += bytes_read;
9329 cur_abbrev->attrs = obstack_alloc (&cu->abbrev_obstack,
9330 (cur_abbrev->num_attrs
9331 * sizeof (struct attr_abbrev)));
9332 memcpy (cur_abbrev->attrs, cur_attrs,
9333 cur_abbrev->num_attrs * sizeof (struct attr_abbrev));
9335 hash_number = abbrev_number % ABBREV_HASH_SIZE;
9336 cur_abbrev->next = cu->dwarf2_abbrevs[hash_number];
9337 cu->dwarf2_abbrevs[hash_number] = cur_abbrev;
9339 /* Get next abbreviation.
9340 Under Irix6 the abbreviations for a compilation unit are not
9341 always properly terminated with an abbrev number of 0.
9342 Exit loop if we encounter an abbreviation which we have
9343 already read (which means we are about to read the abbreviations
9344 for the next compile unit) or if the end of the abbreviation
9345 table is reached. */
9346 if ((unsigned int) (abbrev_ptr - dwarf2_per_objfile->abbrev.buffer)
9347 >= dwarf2_per_objfile->abbrev.size)
9349 abbrev_number = read_unsigned_leb128 (abfd, abbrev_ptr, &bytes_read);
9350 abbrev_ptr += bytes_read;
9351 if (dwarf2_lookup_abbrev (abbrev_number, cu) != NULL)
9358 /* Release the memory used by the abbrev table for a compilation unit. */
9361 dwarf2_free_abbrev_table (void *ptr_to_cu)
9363 struct dwarf2_cu *cu = ptr_to_cu;
9365 obstack_free (&cu->abbrev_obstack, NULL);
9366 cu->dwarf2_abbrevs = NULL;
9369 /* Lookup an abbrev_info structure in the abbrev hash table. */
9371 static struct abbrev_info *
9372 dwarf2_lookup_abbrev (unsigned int number, struct dwarf2_cu *cu)
9374 unsigned int hash_number;
9375 struct abbrev_info *abbrev;
9377 hash_number = number % ABBREV_HASH_SIZE;
9378 abbrev = cu->dwarf2_abbrevs[hash_number];
9382 if (abbrev->number == number)
9385 abbrev = abbrev->next;
9390 /* Returns nonzero if TAG represents a type that we might generate a partial
9394 is_type_tag_for_partial (int tag)
9399 /* Some types that would be reasonable to generate partial symbols for,
9400 that we don't at present. */
9401 case DW_TAG_array_type:
9402 case DW_TAG_file_type:
9403 case DW_TAG_ptr_to_member_type:
9404 case DW_TAG_set_type:
9405 case DW_TAG_string_type:
9406 case DW_TAG_subroutine_type:
9408 case DW_TAG_base_type:
9409 case DW_TAG_class_type:
9410 case DW_TAG_interface_type:
9411 case DW_TAG_enumeration_type:
9412 case DW_TAG_structure_type:
9413 case DW_TAG_subrange_type:
9414 case DW_TAG_typedef:
9415 case DW_TAG_union_type:
9422 /* Load all DIEs that are interesting for partial symbols into memory. */
9424 static struct partial_die_info *
9425 load_partial_dies (bfd *abfd, gdb_byte *buffer, gdb_byte *info_ptr,
9426 int building_psymtab, struct dwarf2_cu *cu)
9428 struct objfile *objfile = cu->objfile;
9429 struct partial_die_info *part_die;
9430 struct partial_die_info *parent_die, *last_die, *first_die = NULL;
9431 struct abbrev_info *abbrev;
9432 unsigned int bytes_read;
9433 unsigned int load_all = 0;
9435 int nesting_level = 1;
9440 if (cu->per_cu && cu->per_cu->load_all_dies)
9444 = htab_create_alloc_ex (cu->header.length / 12,
9448 &cu->comp_unit_obstack,
9449 hashtab_obstack_allocate,
9450 dummy_obstack_deallocate);
9452 part_die = obstack_alloc (&cu->comp_unit_obstack,
9453 sizeof (struct partial_die_info));
9457 abbrev = peek_die_abbrev (info_ptr, &bytes_read, cu);
9459 /* A NULL abbrev means the end of a series of children. */
9462 if (--nesting_level == 0)
9464 /* PART_DIE was probably the last thing allocated on the
9465 comp_unit_obstack, so we could call obstack_free
9466 here. We don't do that because the waste is small,
9467 and will be cleaned up when we're done with this
9468 compilation unit. This way, we're also more robust
9469 against other users of the comp_unit_obstack. */
9472 info_ptr += bytes_read;
9473 last_die = parent_die;
9474 parent_die = parent_die->die_parent;
9478 /* Check for template arguments. We never save these; if
9479 they're seen, we just mark the parent, and go on our way. */
9480 if (parent_die != NULL
9481 && cu->language == language_cplus
9482 && (abbrev->tag == DW_TAG_template_type_param
9483 || abbrev->tag == DW_TAG_template_value_param))
9485 parent_die->has_template_arguments = 1;
9489 /* We don't need a partial DIE for the template argument. */
9490 info_ptr = skip_one_die (buffer, info_ptr + bytes_read, abbrev,
9496 /* We only recurse into subprograms looking for template arguments.
9497 Skip their other children. */
9499 && cu->language == language_cplus
9500 && parent_die != NULL
9501 && parent_die->tag == DW_TAG_subprogram)
9503 info_ptr = skip_one_die (buffer, info_ptr + bytes_read, abbrev, cu);
9507 /* Check whether this DIE is interesting enough to save. Normally
9508 we would not be interested in members here, but there may be
9509 later variables referencing them via DW_AT_specification (for
9512 && !is_type_tag_for_partial (abbrev->tag)
9513 && abbrev->tag != DW_TAG_constant
9514 && abbrev->tag != DW_TAG_enumerator
9515 && abbrev->tag != DW_TAG_subprogram
9516 && abbrev->tag != DW_TAG_lexical_block
9517 && abbrev->tag != DW_TAG_variable
9518 && abbrev->tag != DW_TAG_namespace
9519 && abbrev->tag != DW_TAG_module
9520 && abbrev->tag != DW_TAG_member)
9522 /* Otherwise we skip to the next sibling, if any. */
9523 info_ptr = skip_one_die (buffer, info_ptr + bytes_read, abbrev, cu);
9527 info_ptr = read_partial_die (part_die, abbrev, bytes_read, abfd,
9528 buffer, info_ptr, cu);
9530 /* This two-pass algorithm for processing partial symbols has a
9531 high cost in cache pressure. Thus, handle some simple cases
9532 here which cover the majority of C partial symbols. DIEs
9533 which neither have specification tags in them, nor could have
9534 specification tags elsewhere pointing at them, can simply be
9535 processed and discarded.
9537 This segment is also optional; scan_partial_symbols and
9538 add_partial_symbol will handle these DIEs if we chain
9539 them in normally. When compilers which do not emit large
9540 quantities of duplicate debug information are more common,
9541 this code can probably be removed. */
9543 /* Any complete simple types at the top level (pretty much all
9544 of them, for a language without namespaces), can be processed
9546 if (parent_die == NULL
9547 && part_die->has_specification == 0
9548 && part_die->is_declaration == 0
9549 && ((part_die->tag == DW_TAG_typedef && !part_die->has_children)
9550 || part_die->tag == DW_TAG_base_type
9551 || part_die->tag == DW_TAG_subrange_type))
9553 if (building_psymtab && part_die->name != NULL)
9554 add_psymbol_to_list (part_die->name, strlen (part_die->name), 0,
9555 VAR_DOMAIN, LOC_TYPEDEF,
9556 &objfile->static_psymbols,
9557 0, (CORE_ADDR) 0, cu->language, objfile);
9558 info_ptr = locate_pdi_sibling (part_die, buffer, info_ptr, abfd, cu);
9562 /* The exception for DW_TAG_typedef with has_children above is
9563 a workaround of GCC PR debug/47510. In the case of this complaint
9564 type_name_no_tag_or_error will error on such types later.
9566 GDB skipped children of DW_TAG_typedef by the shortcut above and then
9567 it could not find the child DIEs referenced later, this is checked
9568 above. In correct DWARF DW_TAG_typedef should have no children. */
9570 if (part_die->tag == DW_TAG_typedef && part_die->has_children)
9571 complaint (&symfile_complaints,
9572 _("DW_TAG_typedef has childen - GCC PR debug/47510 bug "
9573 "- DIE at 0x%x [in module %s]"),
9574 part_die->offset, objfile->name);
9576 /* If we're at the second level, and we're an enumerator, and
9577 our parent has no specification (meaning possibly lives in a
9578 namespace elsewhere), then we can add the partial symbol now
9579 instead of queueing it. */
9580 if (part_die->tag == DW_TAG_enumerator
9581 && parent_die != NULL
9582 && parent_die->die_parent == NULL
9583 && parent_die->tag == DW_TAG_enumeration_type
9584 && parent_die->has_specification == 0)
9586 if (part_die->name == NULL)
9587 complaint (&symfile_complaints,
9588 _("malformed enumerator DIE ignored"));
9589 else if (building_psymtab)
9590 add_psymbol_to_list (part_die->name, strlen (part_die->name), 0,
9591 VAR_DOMAIN, LOC_CONST,
9592 (cu->language == language_cplus
9593 || cu->language == language_java)
9594 ? &objfile->global_psymbols
9595 : &objfile->static_psymbols,
9596 0, (CORE_ADDR) 0, cu->language, objfile);
9598 info_ptr = locate_pdi_sibling (part_die, buffer, info_ptr, abfd, cu);
9602 /* We'll save this DIE so link it in. */
9603 part_die->die_parent = parent_die;
9604 part_die->die_sibling = NULL;
9605 part_die->die_child = NULL;
9607 if (last_die && last_die == parent_die)
9608 last_die->die_child = part_die;
9610 last_die->die_sibling = part_die;
9612 last_die = part_die;
9614 if (first_die == NULL)
9615 first_die = part_die;
9617 /* Maybe add the DIE to the hash table. Not all DIEs that we
9618 find interesting need to be in the hash table, because we
9619 also have the parent/sibling/child chains; only those that we
9620 might refer to by offset later during partial symbol reading.
9622 For now this means things that might have be the target of a
9623 DW_AT_specification, DW_AT_abstract_origin, or
9624 DW_AT_extension. DW_AT_extension will refer only to
9625 namespaces; DW_AT_abstract_origin refers to functions (and
9626 many things under the function DIE, but we do not recurse
9627 into function DIEs during partial symbol reading) and
9628 possibly variables as well; DW_AT_specification refers to
9629 declarations. Declarations ought to have the DW_AT_declaration
9630 flag. It happens that GCC forgets to put it in sometimes, but
9631 only for functions, not for types.
9633 Adding more things than necessary to the hash table is harmless
9634 except for the performance cost. Adding too few will result in
9635 wasted time in find_partial_die, when we reread the compilation
9636 unit with load_all_dies set. */
9639 || abbrev->tag == DW_TAG_constant
9640 || abbrev->tag == DW_TAG_subprogram
9641 || abbrev->tag == DW_TAG_variable
9642 || abbrev->tag == DW_TAG_namespace
9643 || part_die->is_declaration)
9647 slot = htab_find_slot_with_hash (cu->partial_dies, part_die,
9648 part_die->offset, INSERT);
9652 part_die = obstack_alloc (&cu->comp_unit_obstack,
9653 sizeof (struct partial_die_info));
9655 /* For some DIEs we want to follow their children (if any). For C
9656 we have no reason to follow the children of structures; for other
9657 languages we have to, so that we can get at method physnames
9658 to infer fully qualified class names, for DW_AT_specification,
9659 and for C++ template arguments. For C++, we also look one level
9660 inside functions to find template arguments (if the name of the
9661 function does not already contain the template arguments).
9663 For Ada, we need to scan the children of subprograms and lexical
9664 blocks as well because Ada allows the definition of nested
9665 entities that could be interesting for the debugger, such as
9666 nested subprograms for instance. */
9667 if (last_die->has_children
9669 || last_die->tag == DW_TAG_namespace
9670 || last_die->tag == DW_TAG_module
9671 || last_die->tag == DW_TAG_enumeration_type
9672 || (cu->language == language_cplus
9673 && last_die->tag == DW_TAG_subprogram
9674 && (last_die->name == NULL
9675 || strchr (last_die->name, '<') == NULL))
9676 || (cu->language != language_c
9677 && (last_die->tag == DW_TAG_class_type
9678 || last_die->tag == DW_TAG_interface_type
9679 || last_die->tag == DW_TAG_structure_type
9680 || last_die->tag == DW_TAG_union_type))
9681 || (cu->language == language_ada
9682 && (last_die->tag == DW_TAG_subprogram
9683 || last_die->tag == DW_TAG_lexical_block))))
9686 parent_die = last_die;
9690 /* Otherwise we skip to the next sibling, if any. */
9691 info_ptr = locate_pdi_sibling (last_die, buffer, info_ptr, abfd, cu);
9693 /* Back to the top, do it again. */
9697 /* Read a minimal amount of information into the minimal die structure. */
9700 read_partial_die (struct partial_die_info *part_die,
9701 struct abbrev_info *abbrev,
9702 unsigned int abbrev_len, bfd *abfd,
9703 gdb_byte *buffer, gdb_byte *info_ptr,
9704 struct dwarf2_cu *cu)
9706 struct objfile *objfile = cu->objfile;
9708 struct attribute attr;
9709 int has_low_pc_attr = 0;
9710 int has_high_pc_attr = 0;
9712 memset (part_die, 0, sizeof (struct partial_die_info));
9714 part_die->offset = info_ptr - buffer;
9716 info_ptr += abbrev_len;
9721 part_die->tag = abbrev->tag;
9722 part_die->has_children = abbrev->has_children;
9724 for (i = 0; i < abbrev->num_attrs; ++i)
9726 info_ptr = read_attribute (&attr, &abbrev->attrs[i], abfd, info_ptr, cu);
9728 /* Store the data if it is of an attribute we want to keep in a
9729 partial symbol table. */
9733 switch (part_die->tag)
9735 case DW_TAG_compile_unit:
9736 case DW_TAG_type_unit:
9737 /* Compilation units have a DW_AT_name that is a filename, not
9738 a source language identifier. */
9739 case DW_TAG_enumeration_type:
9740 case DW_TAG_enumerator:
9741 /* These tags always have simple identifiers already; no need
9742 to canonicalize them. */
9743 part_die->name = DW_STRING (&attr);
9747 = dwarf2_canonicalize_name (DW_STRING (&attr), cu,
9748 &objfile->objfile_obstack);
9752 case DW_AT_linkage_name:
9753 case DW_AT_MIPS_linkage_name:
9754 /* Note that both forms of linkage name might appear. We
9755 assume they will be the same, and we only store the last
9757 if (cu->language == language_ada)
9758 part_die->name = DW_STRING (&attr);
9759 part_die->linkage_name = DW_STRING (&attr);
9762 has_low_pc_attr = 1;
9763 part_die->lowpc = DW_ADDR (&attr);
9766 has_high_pc_attr = 1;
9767 part_die->highpc = DW_ADDR (&attr);
9769 case DW_AT_location:
9770 /* Support the .debug_loc offsets. */
9771 if (attr_form_is_block (&attr))
9773 part_die->locdesc = DW_BLOCK (&attr);
9775 else if (attr_form_is_section_offset (&attr))
9777 dwarf2_complex_location_expr_complaint ();
9781 dwarf2_invalid_attrib_class_complaint ("DW_AT_location",
9782 "partial symbol information");
9785 case DW_AT_external:
9786 part_die->is_external = DW_UNSND (&attr);
9788 case DW_AT_declaration:
9789 part_die->is_declaration = DW_UNSND (&attr);
9792 part_die->has_type = 1;
9794 case DW_AT_abstract_origin:
9795 case DW_AT_specification:
9796 case DW_AT_extension:
9797 part_die->has_specification = 1;
9798 part_die->spec_offset = dwarf2_get_ref_die_offset (&attr);
9801 /* Ignore absolute siblings, they might point outside of
9802 the current compile unit. */
9803 if (attr.form == DW_FORM_ref_addr)
9804 complaint (&symfile_complaints,
9805 _("ignoring absolute DW_AT_sibling"));
9807 part_die->sibling = buffer + dwarf2_get_ref_die_offset (&attr);
9809 case DW_AT_byte_size:
9810 part_die->has_byte_size = 1;
9812 case DW_AT_calling_convention:
9813 /* DWARF doesn't provide a way to identify a program's source-level
9814 entry point. DW_AT_calling_convention attributes are only meant
9815 to describe functions' calling conventions.
9817 However, because it's a necessary piece of information in
9818 Fortran, and because DW_CC_program is the only piece of debugging
9819 information whose definition refers to a 'main program' at all,
9820 several compilers have begun marking Fortran main programs with
9821 DW_CC_program --- even when those functions use the standard
9822 calling conventions.
9824 So until DWARF specifies a way to provide this information and
9825 compilers pick up the new representation, we'll support this
9827 if (DW_UNSND (&attr) == DW_CC_program
9828 && cu->language == language_fortran)
9830 set_main_name (part_die->name);
9832 /* As this DIE has a static linkage the name would be difficult
9833 to look up later. */
9834 language_of_main = language_fortran;
9842 if (has_low_pc_attr && has_high_pc_attr)
9844 /* When using the GNU linker, .gnu.linkonce. sections are used to
9845 eliminate duplicate copies of functions and vtables and such.
9846 The linker will arbitrarily choose one and discard the others.
9847 The AT_*_pc values for such functions refer to local labels in
9848 these sections. If the section from that file was discarded, the
9849 labels are not in the output, so the relocs get a value of 0.
9850 If this is a discarded function, mark the pc bounds as invalid,
9851 so that GDB will ignore it. */
9852 if (part_die->lowpc == 0 && !dwarf2_per_objfile->has_section_at_zero)
9854 struct gdbarch *gdbarch = get_objfile_arch (objfile);
9856 complaint (&symfile_complaints,
9857 _("DW_AT_low_pc %s is zero "
9858 "for DIE at 0x%x [in module %s]"),
9859 paddress (gdbarch, part_die->lowpc),
9860 part_die->offset, objfile->name);
9862 /* dwarf2_get_pc_bounds has also the strict low < high requirement. */
9863 else if (part_die->lowpc >= part_die->highpc)
9865 struct gdbarch *gdbarch = get_objfile_arch (objfile);
9867 complaint (&symfile_complaints,
9868 _("DW_AT_low_pc %s is not < DW_AT_high_pc %s "
9869 "for DIE at 0x%x [in module %s]"),
9870 paddress (gdbarch, part_die->lowpc),
9871 paddress (gdbarch, part_die->highpc),
9872 part_die->offset, objfile->name);
9875 part_die->has_pc_info = 1;
9881 /* Find a cached partial DIE at OFFSET in CU. */
9883 static struct partial_die_info *
9884 find_partial_die_in_comp_unit (unsigned int offset, struct dwarf2_cu *cu)
9886 struct partial_die_info *lookup_die = NULL;
9887 struct partial_die_info part_die;
9889 part_die.offset = offset;
9890 lookup_die = htab_find_with_hash (cu->partial_dies, &part_die, offset);
9895 /* Find a partial DIE at OFFSET, which may or may not be in CU,
9896 except in the case of .debug_types DIEs which do not reference
9897 outside their CU (they do however referencing other types via
9898 DW_FORM_ref_sig8). */
9900 static struct partial_die_info *
9901 find_partial_die (unsigned int offset, struct dwarf2_cu *cu)
9903 struct objfile *objfile = cu->objfile;
9904 struct dwarf2_per_cu_data *per_cu = NULL;
9905 struct partial_die_info *pd = NULL;
9907 if (cu->per_cu->debug_types_section)
9909 pd = find_partial_die_in_comp_unit (offset, cu);
9915 if (offset_in_cu_p (&cu->header, offset))
9917 pd = find_partial_die_in_comp_unit (offset, cu);
9922 per_cu = dwarf2_find_containing_comp_unit (offset, objfile);
9924 if (per_cu->cu == NULL || per_cu->cu->partial_dies == NULL)
9925 load_partial_comp_unit (per_cu);
9927 per_cu->cu->last_used = 0;
9928 pd = find_partial_die_in_comp_unit (offset, per_cu->cu);
9930 if (pd == NULL && per_cu->load_all_dies == 0)
9932 struct cleanup *back_to;
9933 struct partial_die_info comp_unit_die;
9934 struct abbrev_info *abbrev;
9935 unsigned int bytes_read;
9938 per_cu->load_all_dies = 1;
9940 /* Re-read the DIEs. */
9941 back_to = make_cleanup (null_cleanup, 0);
9942 if (per_cu->cu->dwarf2_abbrevs == NULL)
9944 dwarf2_read_abbrevs (per_cu->cu);
9945 make_cleanup (dwarf2_free_abbrev_table, per_cu->cu);
9947 info_ptr = (dwarf2_per_objfile->info.buffer
9948 + per_cu->cu->header.offset
9949 + per_cu->cu->header.first_die_offset);
9950 abbrev = peek_die_abbrev (info_ptr, &bytes_read, per_cu->cu);
9951 info_ptr = read_partial_die (&comp_unit_die, abbrev, bytes_read,
9953 dwarf2_per_objfile->info.buffer, info_ptr,
9955 if (comp_unit_die.has_children)
9956 load_partial_dies (objfile->obfd,
9957 dwarf2_per_objfile->info.buffer, info_ptr,
9959 do_cleanups (back_to);
9961 pd = find_partial_die_in_comp_unit (offset, per_cu->cu);
9967 internal_error (__FILE__, __LINE__,
9968 _("could not find partial DIE 0x%x "
9969 "in cache [from module %s]\n"),
9970 offset, bfd_get_filename (objfile->obfd));
9974 /* See if we can figure out if the class lives in a namespace. We do
9975 this by looking for a member function; its demangled name will
9976 contain namespace info, if there is any. */
9979 guess_partial_die_structure_name (struct partial_die_info *struct_pdi,
9980 struct dwarf2_cu *cu)
9982 /* NOTE: carlton/2003-10-07: Getting the info this way changes
9983 what template types look like, because the demangler
9984 frequently doesn't give the same name as the debug info. We
9985 could fix this by only using the demangled name to get the
9986 prefix (but see comment in read_structure_type). */
9988 struct partial_die_info *real_pdi;
9989 struct partial_die_info *child_pdi;
9991 /* If this DIE (this DIE's specification, if any) has a parent, then
9992 we should not do this. We'll prepend the parent's fully qualified
9993 name when we create the partial symbol. */
9995 real_pdi = struct_pdi;
9996 while (real_pdi->has_specification)
9997 real_pdi = find_partial_die (real_pdi->spec_offset, cu);
9999 if (real_pdi->die_parent != NULL)
10002 for (child_pdi = struct_pdi->die_child;
10004 child_pdi = child_pdi->die_sibling)
10006 if (child_pdi->tag == DW_TAG_subprogram
10007 && child_pdi->linkage_name != NULL)
10009 char *actual_class_name
10010 = language_class_name_from_physname (cu->language_defn,
10011 child_pdi->linkage_name);
10012 if (actual_class_name != NULL)
10015 = obsavestring (actual_class_name,
10016 strlen (actual_class_name),
10017 &cu->objfile->objfile_obstack);
10018 xfree (actual_class_name);
10025 /* Adjust PART_DIE before generating a symbol for it. This function
10026 may set the is_external flag or change the DIE's name. */
10029 fixup_partial_die (struct partial_die_info *part_die,
10030 struct dwarf2_cu *cu)
10032 /* Once we've fixed up a die, there's no point in doing so again.
10033 This also avoids a memory leak if we were to call
10034 guess_partial_die_structure_name multiple times. */
10035 if (part_die->fixup_called)
10038 /* If we found a reference attribute and the DIE has no name, try
10039 to find a name in the referred to DIE. */
10041 if (part_die->name == NULL && part_die->has_specification)
10043 struct partial_die_info *spec_die;
10045 spec_die = find_partial_die (part_die->spec_offset, cu);
10047 fixup_partial_die (spec_die, cu);
10049 if (spec_die->name)
10051 part_die->name = spec_die->name;
10053 /* Copy DW_AT_external attribute if it is set. */
10054 if (spec_die->is_external)
10055 part_die->is_external = spec_die->is_external;
10059 /* Set default names for some unnamed DIEs. */
10061 if (part_die->name == NULL && part_die->tag == DW_TAG_namespace)
10062 part_die->name = CP_ANONYMOUS_NAMESPACE_STR;
10064 /* If there is no parent die to provide a namespace, and there are
10065 children, see if we can determine the namespace from their linkage
10067 NOTE: We need to do this even if cu->has_namespace_info != 0.
10068 gcc-4.5 -gdwarf-4 can drop the enclosing namespace. */
10069 if (cu->language == language_cplus
10070 && !VEC_empty (dwarf2_section_info_def, dwarf2_per_objfile->types)
10071 && part_die->die_parent == NULL
10072 && part_die->has_children
10073 && (part_die->tag == DW_TAG_class_type
10074 || part_die->tag == DW_TAG_structure_type
10075 || part_die->tag == DW_TAG_union_type))
10076 guess_partial_die_structure_name (part_die, cu);
10078 /* GCC might emit a nameless struct or union that has a linkage
10079 name. See http://gcc.gnu.org/bugzilla/show_bug.cgi?id=47510. */
10080 if (part_die->name == NULL
10081 && (part_die->tag == DW_TAG_class_type
10082 || part_die->tag == DW_TAG_interface_type
10083 || part_die->tag == DW_TAG_structure_type
10084 || part_die->tag == DW_TAG_union_type)
10085 && part_die->linkage_name != NULL)
10089 demangled = cplus_demangle (part_die->linkage_name, DMGL_TYPES);
10094 /* Strip any leading namespaces/classes, keep only the base name.
10095 DW_AT_name for named DIEs does not contain the prefixes. */
10096 base = strrchr (demangled, ':');
10097 if (base && base > demangled && base[-1] == ':')
10102 part_die->name = obsavestring (base, strlen (base),
10103 &cu->objfile->objfile_obstack);
10108 part_die->fixup_called = 1;
10111 /* Read an attribute value described by an attribute form. */
10114 read_attribute_value (struct attribute *attr, unsigned form,
10115 bfd *abfd, gdb_byte *info_ptr,
10116 struct dwarf2_cu *cu)
10118 struct comp_unit_head *cu_header = &cu->header;
10119 unsigned int bytes_read;
10120 struct dwarf_block *blk;
10125 case DW_FORM_ref_addr:
10126 if (cu->header.version == 2)
10127 DW_ADDR (attr) = read_address (abfd, info_ptr, cu, &bytes_read);
10129 DW_ADDR (attr) = read_offset (abfd, info_ptr,
10130 &cu->header, &bytes_read);
10131 info_ptr += bytes_read;
10134 DW_ADDR (attr) = read_address (abfd, info_ptr, cu, &bytes_read);
10135 info_ptr += bytes_read;
10137 case DW_FORM_block2:
10138 blk = dwarf_alloc_block (cu);
10139 blk->size = read_2_bytes (abfd, info_ptr);
10141 blk->data = read_n_bytes (abfd, info_ptr, blk->size);
10142 info_ptr += blk->size;
10143 DW_BLOCK (attr) = blk;
10145 case DW_FORM_block4:
10146 blk = dwarf_alloc_block (cu);
10147 blk->size = read_4_bytes (abfd, info_ptr);
10149 blk->data = read_n_bytes (abfd, info_ptr, blk->size);
10150 info_ptr += blk->size;
10151 DW_BLOCK (attr) = blk;
10153 case DW_FORM_data2:
10154 DW_UNSND (attr) = read_2_bytes (abfd, info_ptr);
10157 case DW_FORM_data4:
10158 DW_UNSND (attr) = read_4_bytes (abfd, info_ptr);
10161 case DW_FORM_data8:
10162 DW_UNSND (attr) = read_8_bytes (abfd, info_ptr);
10165 case DW_FORM_sec_offset:
10166 DW_UNSND (attr) = read_offset (abfd, info_ptr, &cu->header, &bytes_read);
10167 info_ptr += bytes_read;
10169 case DW_FORM_string:
10170 DW_STRING (attr) = read_direct_string (abfd, info_ptr, &bytes_read);
10171 DW_STRING_IS_CANONICAL (attr) = 0;
10172 info_ptr += bytes_read;
10175 DW_STRING (attr) = read_indirect_string (abfd, info_ptr, cu_header,
10177 DW_STRING_IS_CANONICAL (attr) = 0;
10178 info_ptr += bytes_read;
10180 case DW_FORM_exprloc:
10181 case DW_FORM_block:
10182 blk = dwarf_alloc_block (cu);
10183 blk->size = read_unsigned_leb128 (abfd, info_ptr, &bytes_read);
10184 info_ptr += bytes_read;
10185 blk->data = read_n_bytes (abfd, info_ptr, blk->size);
10186 info_ptr += blk->size;
10187 DW_BLOCK (attr) = blk;
10189 case DW_FORM_block1:
10190 blk = dwarf_alloc_block (cu);
10191 blk->size = read_1_byte (abfd, info_ptr);
10193 blk->data = read_n_bytes (abfd, info_ptr, blk->size);
10194 info_ptr += blk->size;
10195 DW_BLOCK (attr) = blk;
10197 case DW_FORM_data1:
10198 DW_UNSND (attr) = read_1_byte (abfd, info_ptr);
10202 DW_UNSND (attr) = read_1_byte (abfd, info_ptr);
10205 case DW_FORM_flag_present:
10206 DW_UNSND (attr) = 1;
10208 case DW_FORM_sdata:
10209 DW_SND (attr) = read_signed_leb128 (abfd, info_ptr, &bytes_read);
10210 info_ptr += bytes_read;
10212 case DW_FORM_udata:
10213 DW_UNSND (attr) = read_unsigned_leb128 (abfd, info_ptr, &bytes_read);
10214 info_ptr += bytes_read;
10217 DW_ADDR (attr) = cu->header.offset + read_1_byte (abfd, info_ptr);
10221 DW_ADDR (attr) = cu->header.offset + read_2_bytes (abfd, info_ptr);
10225 DW_ADDR (attr) = cu->header.offset + read_4_bytes (abfd, info_ptr);
10229 DW_ADDR (attr) = cu->header.offset + read_8_bytes (abfd, info_ptr);
10232 case DW_FORM_ref_sig8:
10233 /* Convert the signature to something we can record in DW_UNSND
10235 NOTE: This is NULL if the type wasn't found. */
10236 DW_SIGNATURED_TYPE (attr) =
10237 lookup_signatured_type (cu->objfile, read_8_bytes (abfd, info_ptr));
10240 case DW_FORM_ref_udata:
10241 DW_ADDR (attr) = (cu->header.offset
10242 + read_unsigned_leb128 (abfd, info_ptr, &bytes_read));
10243 info_ptr += bytes_read;
10245 case DW_FORM_indirect:
10246 form = read_unsigned_leb128 (abfd, info_ptr, &bytes_read);
10247 info_ptr += bytes_read;
10248 info_ptr = read_attribute_value (attr, form, abfd, info_ptr, cu);
10251 error (_("Dwarf Error: Cannot handle %s in DWARF reader [in module %s]"),
10252 dwarf_form_name (form),
10253 bfd_get_filename (abfd));
10256 /* We have seen instances where the compiler tried to emit a byte
10257 size attribute of -1 which ended up being encoded as an unsigned
10258 0xffffffff. Although 0xffffffff is technically a valid size value,
10259 an object of this size seems pretty unlikely so we can relatively
10260 safely treat these cases as if the size attribute was invalid and
10261 treat them as zero by default. */
10262 if (attr->name == DW_AT_byte_size
10263 && form == DW_FORM_data4
10264 && DW_UNSND (attr) >= 0xffffffff)
10267 (&symfile_complaints,
10268 _("Suspicious DW_AT_byte_size value treated as zero instead of %s"),
10269 hex_string (DW_UNSND (attr)));
10270 DW_UNSND (attr) = 0;
10276 /* Read an attribute described by an abbreviated attribute. */
10279 read_attribute (struct attribute *attr, struct attr_abbrev *abbrev,
10280 bfd *abfd, gdb_byte *info_ptr, struct dwarf2_cu *cu)
10282 attr->name = abbrev->name;
10283 return read_attribute_value (attr, abbrev->form, abfd, info_ptr, cu);
10286 /* Read dwarf information from a buffer. */
10288 static unsigned int
10289 read_1_byte (bfd *abfd, gdb_byte *buf)
10291 return bfd_get_8 (abfd, buf);
10295 read_1_signed_byte (bfd *abfd, gdb_byte *buf)
10297 return bfd_get_signed_8 (abfd, buf);
10300 static unsigned int
10301 read_2_bytes (bfd *abfd, gdb_byte *buf)
10303 return bfd_get_16 (abfd, buf);
10307 read_2_signed_bytes (bfd *abfd, gdb_byte *buf)
10309 return bfd_get_signed_16 (abfd, buf);
10312 static unsigned int
10313 read_4_bytes (bfd *abfd, gdb_byte *buf)
10315 return bfd_get_32 (abfd, buf);
10319 read_4_signed_bytes (bfd *abfd, gdb_byte *buf)
10321 return bfd_get_signed_32 (abfd, buf);
10325 read_8_bytes (bfd *abfd, gdb_byte *buf)
10327 return bfd_get_64 (abfd, buf);
10331 read_address (bfd *abfd, gdb_byte *buf, struct dwarf2_cu *cu,
10332 unsigned int *bytes_read)
10334 struct comp_unit_head *cu_header = &cu->header;
10335 CORE_ADDR retval = 0;
10337 if (cu_header->signed_addr_p)
10339 switch (cu_header->addr_size)
10342 retval = bfd_get_signed_16 (abfd, buf);
10345 retval = bfd_get_signed_32 (abfd, buf);
10348 retval = bfd_get_signed_64 (abfd, buf);
10351 internal_error (__FILE__, __LINE__,
10352 _("read_address: bad switch, signed [in module %s]"),
10353 bfd_get_filename (abfd));
10358 switch (cu_header->addr_size)
10361 retval = bfd_get_16 (abfd, buf);
10364 retval = bfd_get_32 (abfd, buf);
10367 retval = bfd_get_64 (abfd, buf);
10370 internal_error (__FILE__, __LINE__,
10371 _("read_address: bad switch, "
10372 "unsigned [in module %s]"),
10373 bfd_get_filename (abfd));
10377 *bytes_read = cu_header->addr_size;
10381 /* Read the initial length from a section. The (draft) DWARF 3
10382 specification allows the initial length to take up either 4 bytes
10383 or 12 bytes. If the first 4 bytes are 0xffffffff, then the next 8
10384 bytes describe the length and all offsets will be 8 bytes in length
10387 An older, non-standard 64-bit format is also handled by this
10388 function. The older format in question stores the initial length
10389 as an 8-byte quantity without an escape value. Lengths greater
10390 than 2^32 aren't very common which means that the initial 4 bytes
10391 is almost always zero. Since a length value of zero doesn't make
10392 sense for the 32-bit format, this initial zero can be considered to
10393 be an escape value which indicates the presence of the older 64-bit
10394 format. As written, the code can't detect (old format) lengths
10395 greater than 4GB. If it becomes necessary to handle lengths
10396 somewhat larger than 4GB, we could allow other small values (such
10397 as the non-sensical values of 1, 2, and 3) to also be used as
10398 escape values indicating the presence of the old format.
10400 The value returned via bytes_read should be used to increment the
10401 relevant pointer after calling read_initial_length().
10403 [ Note: read_initial_length() and read_offset() are based on the
10404 document entitled "DWARF Debugging Information Format", revision
10405 3, draft 8, dated November 19, 2001. This document was obtained
10408 http://reality.sgiweb.org/davea/dwarf3-draft8-011125.pdf
10410 This document is only a draft and is subject to change. (So beware.)
10412 Details regarding the older, non-standard 64-bit format were
10413 determined empirically by examining 64-bit ELF files produced by
10414 the SGI toolchain on an IRIX 6.5 machine.
10416 - Kevin, July 16, 2002
10420 read_initial_length (bfd *abfd, gdb_byte *buf, unsigned int *bytes_read)
10422 LONGEST length = bfd_get_32 (abfd, buf);
10424 if (length == 0xffffffff)
10426 length = bfd_get_64 (abfd, buf + 4);
10429 else if (length == 0)
10431 /* Handle the (non-standard) 64-bit DWARF2 format used by IRIX. */
10432 length = bfd_get_64 (abfd, buf);
10443 /* Cover function for read_initial_length.
10444 Returns the length of the object at BUF, and stores the size of the
10445 initial length in *BYTES_READ and stores the size that offsets will be in
10447 If the initial length size is not equivalent to that specified in
10448 CU_HEADER then issue a complaint.
10449 This is useful when reading non-comp-unit headers. */
10452 read_checked_initial_length_and_offset (bfd *abfd, gdb_byte *buf,
10453 const struct comp_unit_head *cu_header,
10454 unsigned int *bytes_read,
10455 unsigned int *offset_size)
10457 LONGEST length = read_initial_length (abfd, buf, bytes_read);
10459 gdb_assert (cu_header->initial_length_size == 4
10460 || cu_header->initial_length_size == 8
10461 || cu_header->initial_length_size == 12);
10463 if (cu_header->initial_length_size != *bytes_read)
10464 complaint (&symfile_complaints,
10465 _("intermixed 32-bit and 64-bit DWARF sections"));
10467 *offset_size = (*bytes_read == 4) ? 4 : 8;
10471 /* Read an offset from the data stream. The size of the offset is
10472 given by cu_header->offset_size. */
10475 read_offset (bfd *abfd, gdb_byte *buf, const struct comp_unit_head *cu_header,
10476 unsigned int *bytes_read)
10478 LONGEST offset = read_offset_1 (abfd, buf, cu_header->offset_size);
10480 *bytes_read = cu_header->offset_size;
10484 /* Read an offset from the data stream. */
10487 read_offset_1 (bfd *abfd, gdb_byte *buf, unsigned int offset_size)
10489 LONGEST retval = 0;
10491 switch (offset_size)
10494 retval = bfd_get_32 (abfd, buf);
10497 retval = bfd_get_64 (abfd, buf);
10500 internal_error (__FILE__, __LINE__,
10501 _("read_offset_1: bad switch [in module %s]"),
10502 bfd_get_filename (abfd));
10509 read_n_bytes (bfd *abfd, gdb_byte *buf, unsigned int size)
10511 /* If the size of a host char is 8 bits, we can return a pointer
10512 to the buffer, otherwise we have to copy the data to a buffer
10513 allocated on the temporary obstack. */
10514 gdb_assert (HOST_CHAR_BIT == 8);
10519 read_direct_string (bfd *abfd, gdb_byte *buf, unsigned int *bytes_read_ptr)
10521 /* If the size of a host char is 8 bits, we can return a pointer
10522 to the string, otherwise we have to copy the string to a buffer
10523 allocated on the temporary obstack. */
10524 gdb_assert (HOST_CHAR_BIT == 8);
10527 *bytes_read_ptr = 1;
10530 *bytes_read_ptr = strlen ((char *) buf) + 1;
10531 return (char *) buf;
10535 read_indirect_string_at_offset (bfd *abfd, LONGEST str_offset)
10537 dwarf2_read_section (dwarf2_per_objfile->objfile, &dwarf2_per_objfile->str);
10538 if (dwarf2_per_objfile->str.buffer == NULL)
10539 error (_("DW_FORM_strp used without .debug_str section [in module %s]"),
10540 bfd_get_filename (abfd));
10541 if (str_offset >= dwarf2_per_objfile->str.size)
10542 error (_("DW_FORM_strp pointing outside of "
10543 ".debug_str section [in module %s]"),
10544 bfd_get_filename (abfd));
10545 gdb_assert (HOST_CHAR_BIT == 8);
10546 if (dwarf2_per_objfile->str.buffer[str_offset] == '\0')
10548 return (char *) (dwarf2_per_objfile->str.buffer + str_offset);
10552 read_indirect_string (bfd *abfd, gdb_byte *buf,
10553 const struct comp_unit_head *cu_header,
10554 unsigned int *bytes_read_ptr)
10556 LONGEST str_offset = read_offset (abfd, buf, cu_header, bytes_read_ptr);
10558 return read_indirect_string_at_offset (abfd, str_offset);
10561 static unsigned long
10562 read_unsigned_leb128 (bfd *abfd, gdb_byte *buf, unsigned int *bytes_read_ptr)
10564 unsigned long result;
10565 unsigned int num_read;
10567 unsigned char byte;
10575 byte = bfd_get_8 (abfd, buf);
10578 result |= ((unsigned long)(byte & 127) << shift);
10579 if ((byte & 128) == 0)
10585 *bytes_read_ptr = num_read;
10590 read_signed_leb128 (bfd *abfd, gdb_byte *buf, unsigned int *bytes_read_ptr)
10593 int i, shift, num_read;
10594 unsigned char byte;
10602 byte = bfd_get_8 (abfd, buf);
10605 result |= ((long)(byte & 127) << shift);
10607 if ((byte & 128) == 0)
10612 if ((shift < 8 * sizeof (result)) && (byte & 0x40))
10613 result |= -(((long)1) << shift);
10614 *bytes_read_ptr = num_read;
10618 /* Return a pointer to just past the end of an LEB128 number in BUF. */
10621 skip_leb128 (bfd *abfd, gdb_byte *buf)
10627 byte = bfd_get_8 (abfd, buf);
10629 if ((byte & 128) == 0)
10635 set_cu_language (unsigned int lang, struct dwarf2_cu *cu)
10642 cu->language = language_c;
10644 case DW_LANG_C_plus_plus:
10645 cu->language = language_cplus;
10648 cu->language = language_d;
10650 case DW_LANG_Fortran77:
10651 case DW_LANG_Fortran90:
10652 case DW_LANG_Fortran95:
10653 cu->language = language_fortran;
10655 case DW_LANG_Mips_Assembler:
10656 cu->language = language_asm;
10659 cu->language = language_java;
10661 case DW_LANG_Ada83:
10662 case DW_LANG_Ada95:
10663 cu->language = language_ada;
10665 case DW_LANG_Modula2:
10666 cu->language = language_m2;
10668 case DW_LANG_Pascal83:
10669 cu->language = language_pascal;
10672 cu->language = language_objc;
10674 case DW_LANG_Cobol74:
10675 case DW_LANG_Cobol85:
10677 cu->language = language_minimal;
10680 cu->language_defn = language_def (cu->language);
10683 /* Return the named attribute or NULL if not there. */
10685 static struct attribute *
10686 dwarf2_attr (struct die_info *die, unsigned int name, struct dwarf2_cu *cu)
10689 struct attribute *spec = NULL;
10691 for (i = 0; i < die->num_attrs; ++i)
10693 if (die->attrs[i].name == name)
10694 return &die->attrs[i];
10695 if (die->attrs[i].name == DW_AT_specification
10696 || die->attrs[i].name == DW_AT_abstract_origin)
10697 spec = &die->attrs[i];
10702 die = follow_die_ref (die, spec, &cu);
10703 return dwarf2_attr (die, name, cu);
10709 /* Return the named attribute or NULL if not there,
10710 but do not follow DW_AT_specification, etc.
10711 This is for use in contexts where we're reading .debug_types dies.
10712 Following DW_AT_specification, DW_AT_abstract_origin will take us
10713 back up the chain, and we want to go down. */
10715 static struct attribute *
10716 dwarf2_attr_no_follow (struct die_info *die, unsigned int name,
10717 struct dwarf2_cu *cu)
10721 for (i = 0; i < die->num_attrs; ++i)
10722 if (die->attrs[i].name == name)
10723 return &die->attrs[i];
10728 /* Return non-zero iff the attribute NAME is defined for the given DIE,
10729 and holds a non-zero value. This function should only be used for
10730 DW_FORM_flag or DW_FORM_flag_present attributes. */
10733 dwarf2_flag_true_p (struct die_info *die, unsigned name, struct dwarf2_cu *cu)
10735 struct attribute *attr = dwarf2_attr (die, name, cu);
10737 return (attr && DW_UNSND (attr));
10741 die_is_declaration (struct die_info *die, struct dwarf2_cu *cu)
10743 /* A DIE is a declaration if it has a DW_AT_declaration attribute
10744 which value is non-zero. However, we have to be careful with
10745 DIEs having a DW_AT_specification attribute, because dwarf2_attr()
10746 (via dwarf2_flag_true_p) follows this attribute. So we may
10747 end up accidently finding a declaration attribute that belongs
10748 to a different DIE referenced by the specification attribute,
10749 even though the given DIE does not have a declaration attribute. */
10750 return (dwarf2_flag_true_p (die, DW_AT_declaration, cu)
10751 && dwarf2_attr (die, DW_AT_specification, cu) == NULL);
10754 /* Return the die giving the specification for DIE, if there is
10755 one. *SPEC_CU is the CU containing DIE on input, and the CU
10756 containing the return value on output. If there is no
10757 specification, but there is an abstract origin, that is
10760 static struct die_info *
10761 die_specification (struct die_info *die, struct dwarf2_cu **spec_cu)
10763 struct attribute *spec_attr = dwarf2_attr (die, DW_AT_specification,
10766 if (spec_attr == NULL)
10767 spec_attr = dwarf2_attr (die, DW_AT_abstract_origin, *spec_cu);
10769 if (spec_attr == NULL)
10772 return follow_die_ref (die, spec_attr, spec_cu);
10775 /* Free the line_header structure *LH, and any arrays and strings it
10777 NOTE: This is also used as a "cleanup" function. */
10780 free_line_header (struct line_header *lh)
10782 if (lh->standard_opcode_lengths)
10783 xfree (lh->standard_opcode_lengths);
10785 /* Remember that all the lh->file_names[i].name pointers are
10786 pointers into debug_line_buffer, and don't need to be freed. */
10787 if (lh->file_names)
10788 xfree (lh->file_names);
10790 /* Similarly for the include directory names. */
10791 if (lh->include_dirs)
10792 xfree (lh->include_dirs);
10797 /* Add an entry to LH's include directory table. */
10800 add_include_dir (struct line_header *lh, char *include_dir)
10802 /* Grow the array if necessary. */
10803 if (lh->include_dirs_size == 0)
10805 lh->include_dirs_size = 1; /* for testing */
10806 lh->include_dirs = xmalloc (lh->include_dirs_size
10807 * sizeof (*lh->include_dirs));
10809 else if (lh->num_include_dirs >= lh->include_dirs_size)
10811 lh->include_dirs_size *= 2;
10812 lh->include_dirs = xrealloc (lh->include_dirs,
10813 (lh->include_dirs_size
10814 * sizeof (*lh->include_dirs)));
10817 lh->include_dirs[lh->num_include_dirs++] = include_dir;
10820 /* Add an entry to LH's file name table. */
10823 add_file_name (struct line_header *lh,
10825 unsigned int dir_index,
10826 unsigned int mod_time,
10827 unsigned int length)
10829 struct file_entry *fe;
10831 /* Grow the array if necessary. */
10832 if (lh->file_names_size == 0)
10834 lh->file_names_size = 1; /* for testing */
10835 lh->file_names = xmalloc (lh->file_names_size
10836 * sizeof (*lh->file_names));
10838 else if (lh->num_file_names >= lh->file_names_size)
10840 lh->file_names_size *= 2;
10841 lh->file_names = xrealloc (lh->file_names,
10842 (lh->file_names_size
10843 * sizeof (*lh->file_names)));
10846 fe = &lh->file_names[lh->num_file_names++];
10848 fe->dir_index = dir_index;
10849 fe->mod_time = mod_time;
10850 fe->length = length;
10851 fe->included_p = 0;
10855 /* Read the statement program header starting at OFFSET in
10856 .debug_line, according to the endianness of ABFD. Return a pointer
10857 to a struct line_header, allocated using xmalloc.
10859 NOTE: the strings in the include directory and file name tables of
10860 the returned object point into debug_line_buffer, and must not be
10863 static struct line_header *
10864 dwarf_decode_line_header (unsigned int offset, bfd *abfd,
10865 struct dwarf2_cu *cu)
10867 struct cleanup *back_to;
10868 struct line_header *lh;
10869 gdb_byte *line_ptr;
10870 unsigned int bytes_read, offset_size;
10872 char *cur_dir, *cur_file;
10874 dwarf2_read_section (dwarf2_per_objfile->objfile, &dwarf2_per_objfile->line);
10875 if (dwarf2_per_objfile->line.buffer == NULL)
10877 complaint (&symfile_complaints, _("missing .debug_line section"));
10881 /* Make sure that at least there's room for the total_length field.
10882 That could be 12 bytes long, but we're just going to fudge that. */
10883 if (offset + 4 >= dwarf2_per_objfile->line.size)
10885 dwarf2_statement_list_fits_in_line_number_section_complaint ();
10889 lh = xmalloc (sizeof (*lh));
10890 memset (lh, 0, sizeof (*lh));
10891 back_to = make_cleanup ((make_cleanup_ftype *) free_line_header,
10894 line_ptr = dwarf2_per_objfile->line.buffer + offset;
10896 /* Read in the header. */
10898 read_checked_initial_length_and_offset (abfd, line_ptr, &cu->header,
10899 &bytes_read, &offset_size);
10900 line_ptr += bytes_read;
10901 if (line_ptr + lh->total_length > (dwarf2_per_objfile->line.buffer
10902 + dwarf2_per_objfile->line.size))
10904 dwarf2_statement_list_fits_in_line_number_section_complaint ();
10907 lh->statement_program_end = line_ptr + lh->total_length;
10908 lh->version = read_2_bytes (abfd, line_ptr);
10910 lh->header_length = read_offset_1 (abfd, line_ptr, offset_size);
10911 line_ptr += offset_size;
10912 lh->minimum_instruction_length = read_1_byte (abfd, line_ptr);
10914 if (lh->version >= 4)
10916 lh->maximum_ops_per_instruction = read_1_byte (abfd, line_ptr);
10920 lh->maximum_ops_per_instruction = 1;
10922 if (lh->maximum_ops_per_instruction == 0)
10924 lh->maximum_ops_per_instruction = 1;
10925 complaint (&symfile_complaints,
10926 _("invalid maximum_ops_per_instruction "
10927 "in `.debug_line' section"));
10930 lh->default_is_stmt = read_1_byte (abfd, line_ptr);
10932 lh->line_base = read_1_signed_byte (abfd, line_ptr);
10934 lh->line_range = read_1_byte (abfd, line_ptr);
10936 lh->opcode_base = read_1_byte (abfd, line_ptr);
10938 lh->standard_opcode_lengths
10939 = xmalloc (lh->opcode_base * sizeof (lh->standard_opcode_lengths[0]));
10941 lh->standard_opcode_lengths[0] = 1; /* This should never be used anyway. */
10942 for (i = 1; i < lh->opcode_base; ++i)
10944 lh->standard_opcode_lengths[i] = read_1_byte (abfd, line_ptr);
10948 /* Read directory table. */
10949 while ((cur_dir = read_direct_string (abfd, line_ptr, &bytes_read)) != NULL)
10951 line_ptr += bytes_read;
10952 add_include_dir (lh, cur_dir);
10954 line_ptr += bytes_read;
10956 /* Read file name table. */
10957 while ((cur_file = read_direct_string (abfd, line_ptr, &bytes_read)) != NULL)
10959 unsigned int dir_index, mod_time, length;
10961 line_ptr += bytes_read;
10962 dir_index = read_unsigned_leb128 (abfd, line_ptr, &bytes_read);
10963 line_ptr += bytes_read;
10964 mod_time = read_unsigned_leb128 (abfd, line_ptr, &bytes_read);
10965 line_ptr += bytes_read;
10966 length = read_unsigned_leb128 (abfd, line_ptr, &bytes_read);
10967 line_ptr += bytes_read;
10969 add_file_name (lh, cur_file, dir_index, mod_time, length);
10971 line_ptr += bytes_read;
10972 lh->statement_program_start = line_ptr;
10974 if (line_ptr > (dwarf2_per_objfile->line.buffer
10975 + dwarf2_per_objfile->line.size))
10976 complaint (&symfile_complaints,
10977 _("line number info header doesn't "
10978 "fit in `.debug_line' section"));
10980 discard_cleanups (back_to);
10984 /* Subroutine of dwarf_decode_lines to simplify it.
10985 Return the file name of the psymtab for included file FILE_INDEX
10986 in line header LH of PST.
10987 COMP_DIR is the compilation directory (DW_AT_comp_dir) or NULL if unknown.
10988 If space for the result is malloc'd, it will be freed by a cleanup.
10989 Returns NULL if FILE_INDEX should be ignored, i.e., it is pst->filename. */
10992 psymtab_include_file_name (const struct line_header *lh, int file_index,
10993 const struct partial_symtab *pst,
10994 const char *comp_dir)
10996 const struct file_entry fe = lh->file_names [file_index];
10997 char *include_name = fe.name;
10998 char *include_name_to_compare = include_name;
10999 char *dir_name = NULL;
11000 const char *pst_filename;
11001 char *copied_name = NULL;
11005 dir_name = lh->include_dirs[fe.dir_index - 1];
11007 if (!IS_ABSOLUTE_PATH (include_name)
11008 && (dir_name != NULL || comp_dir != NULL))
11010 /* Avoid creating a duplicate psymtab for PST.
11011 We do this by comparing INCLUDE_NAME and PST_FILENAME.
11012 Before we do the comparison, however, we need to account
11013 for DIR_NAME and COMP_DIR.
11014 First prepend dir_name (if non-NULL). If we still don't
11015 have an absolute path prepend comp_dir (if non-NULL).
11016 However, the directory we record in the include-file's
11017 psymtab does not contain COMP_DIR (to match the
11018 corresponding symtab(s)).
11023 bash$ gcc -g ./hello.c
11024 include_name = "hello.c"
11026 DW_AT_comp_dir = comp_dir = "/tmp"
11027 DW_AT_name = "./hello.c" */
11029 if (dir_name != NULL)
11031 include_name = concat (dir_name, SLASH_STRING,
11032 include_name, (char *)NULL);
11033 include_name_to_compare = include_name;
11034 make_cleanup (xfree, include_name);
11036 if (!IS_ABSOLUTE_PATH (include_name) && comp_dir != NULL)
11038 include_name_to_compare = concat (comp_dir, SLASH_STRING,
11039 include_name, (char *)NULL);
11043 pst_filename = pst->filename;
11044 if (!IS_ABSOLUTE_PATH (pst_filename) && pst->dirname != NULL)
11046 copied_name = concat (pst->dirname, SLASH_STRING,
11047 pst_filename, (char *)NULL);
11048 pst_filename = copied_name;
11051 file_is_pst = FILENAME_CMP (include_name_to_compare, pst_filename) == 0;
11053 if (include_name_to_compare != include_name)
11054 xfree (include_name_to_compare);
11055 if (copied_name != NULL)
11056 xfree (copied_name);
11060 return include_name;
11063 /* Ignore this record_line request. */
11066 noop_record_line (struct subfile *subfile, int line, CORE_ADDR pc)
11071 /* Subroutine of dwarf_decode_lines to simplify it.
11072 Process the line number information in LH. */
11075 dwarf_decode_lines_1 (struct line_header *lh, const char *comp_dir,
11076 struct dwarf2_cu *cu, struct partial_symtab *pst)
11078 gdb_byte *line_ptr, *extended_end;
11079 gdb_byte *line_end;
11080 unsigned int bytes_read, extended_len;
11081 unsigned char op_code, extended_op, adj_opcode;
11082 CORE_ADDR baseaddr;
11083 struct objfile *objfile = cu->objfile;
11084 bfd *abfd = objfile->obfd;
11085 struct gdbarch *gdbarch = get_objfile_arch (objfile);
11086 const int decode_for_pst_p = (pst != NULL);
11087 struct subfile *last_subfile = NULL;
11088 void (*p_record_line) (struct subfile *subfile, int line, CORE_ADDR pc)
11091 baseaddr = ANOFFSET (objfile->section_offsets, SECT_OFF_TEXT (objfile));
11093 line_ptr = lh->statement_program_start;
11094 line_end = lh->statement_program_end;
11096 /* Read the statement sequences until there's nothing left. */
11097 while (line_ptr < line_end)
11099 /* state machine registers */
11100 CORE_ADDR address = 0;
11101 unsigned int file = 1;
11102 unsigned int line = 1;
11103 unsigned int column = 0;
11104 int is_stmt = lh->default_is_stmt;
11105 int basic_block = 0;
11106 int end_sequence = 0;
11108 unsigned char op_index = 0;
11110 if (!decode_for_pst_p && lh->num_file_names >= file)
11112 /* Start a subfile for the current file of the state machine. */
11113 /* lh->include_dirs and lh->file_names are 0-based, but the
11114 directory and file name numbers in the statement program
11116 struct file_entry *fe = &lh->file_names[file - 1];
11120 dir = lh->include_dirs[fe->dir_index - 1];
11122 dwarf2_start_subfile (fe->name, dir, comp_dir);
11125 /* Decode the table. */
11126 while (!end_sequence)
11128 op_code = read_1_byte (abfd, line_ptr);
11130 if (line_ptr > line_end)
11132 dwarf2_debug_line_missing_end_sequence_complaint ();
11136 if (op_code >= lh->opcode_base)
11138 /* Special operand. */
11139 adj_opcode = op_code - lh->opcode_base;
11140 address += (((op_index + (adj_opcode / lh->line_range))
11141 / lh->maximum_ops_per_instruction)
11142 * lh->minimum_instruction_length);
11143 op_index = ((op_index + (adj_opcode / lh->line_range))
11144 % lh->maximum_ops_per_instruction);
11145 line += lh->line_base + (adj_opcode % lh->line_range);
11146 if (lh->num_file_names < file || file == 0)
11147 dwarf2_debug_line_missing_file_complaint ();
11148 /* For now we ignore lines not starting on an
11149 instruction boundary. */
11150 else if (op_index == 0)
11152 lh->file_names[file - 1].included_p = 1;
11153 if (!decode_for_pst_p && is_stmt)
11155 if (last_subfile != current_subfile)
11157 addr = gdbarch_addr_bits_remove (gdbarch, address);
11159 (*p_record_line) (last_subfile, 0, addr);
11160 last_subfile = current_subfile;
11162 /* Append row to matrix using current values. */
11163 addr = gdbarch_addr_bits_remove (gdbarch, address);
11164 (*p_record_line) (current_subfile, line, addr);
11169 else switch (op_code)
11171 case DW_LNS_extended_op:
11172 extended_len = read_unsigned_leb128 (abfd, line_ptr,
11174 line_ptr += bytes_read;
11175 extended_end = line_ptr + extended_len;
11176 extended_op = read_1_byte (abfd, line_ptr);
11178 switch (extended_op)
11180 case DW_LNE_end_sequence:
11181 p_record_line = record_line;
11184 case DW_LNE_set_address:
11185 address = read_address (abfd, line_ptr, cu, &bytes_read);
11187 if (address == 0 && !dwarf2_per_objfile->has_section_at_zero)
11189 /* This line table is for a function which has been
11190 GCd by the linker. Ignore it. PR gdb/12528 */
11193 = line_ptr - dwarf2_per_objfile->line.buffer;
11195 complaint (&symfile_complaints,
11196 _(".debug_line address at offset 0x%lx is 0 "
11198 line_offset, objfile->name);
11199 p_record_line = noop_record_line;
11203 line_ptr += bytes_read;
11204 address += baseaddr;
11206 case DW_LNE_define_file:
11209 unsigned int dir_index, mod_time, length;
11211 cur_file = read_direct_string (abfd, line_ptr,
11213 line_ptr += bytes_read;
11215 read_unsigned_leb128 (abfd, line_ptr, &bytes_read);
11216 line_ptr += bytes_read;
11218 read_unsigned_leb128 (abfd, line_ptr, &bytes_read);
11219 line_ptr += bytes_read;
11221 read_unsigned_leb128 (abfd, line_ptr, &bytes_read);
11222 line_ptr += bytes_read;
11223 add_file_name (lh, cur_file, dir_index, mod_time, length);
11226 case DW_LNE_set_discriminator:
11227 /* The discriminator is not interesting to the debugger;
11229 line_ptr = extended_end;
11232 complaint (&symfile_complaints,
11233 _("mangled .debug_line section"));
11236 /* Make sure that we parsed the extended op correctly. If e.g.
11237 we expected a different address size than the producer used,
11238 we may have read the wrong number of bytes. */
11239 if (line_ptr != extended_end)
11241 complaint (&symfile_complaints,
11242 _("mangled .debug_line section"));
11247 if (lh->num_file_names < file || file == 0)
11248 dwarf2_debug_line_missing_file_complaint ();
11251 lh->file_names[file - 1].included_p = 1;
11252 if (!decode_for_pst_p && is_stmt)
11254 if (last_subfile != current_subfile)
11256 addr = gdbarch_addr_bits_remove (gdbarch, address);
11258 (*p_record_line) (last_subfile, 0, addr);
11259 last_subfile = current_subfile;
11261 addr = gdbarch_addr_bits_remove (gdbarch, address);
11262 (*p_record_line) (current_subfile, line, addr);
11267 case DW_LNS_advance_pc:
11270 = read_unsigned_leb128 (abfd, line_ptr, &bytes_read);
11272 address += (((op_index + adjust)
11273 / lh->maximum_ops_per_instruction)
11274 * lh->minimum_instruction_length);
11275 op_index = ((op_index + adjust)
11276 % lh->maximum_ops_per_instruction);
11277 line_ptr += bytes_read;
11280 case DW_LNS_advance_line:
11281 line += read_signed_leb128 (abfd, line_ptr, &bytes_read);
11282 line_ptr += bytes_read;
11284 case DW_LNS_set_file:
11286 /* The arrays lh->include_dirs and lh->file_names are
11287 0-based, but the directory and file name numbers in
11288 the statement program are 1-based. */
11289 struct file_entry *fe;
11292 file = read_unsigned_leb128 (abfd, line_ptr, &bytes_read);
11293 line_ptr += bytes_read;
11294 if (lh->num_file_names < file || file == 0)
11295 dwarf2_debug_line_missing_file_complaint ();
11298 fe = &lh->file_names[file - 1];
11300 dir = lh->include_dirs[fe->dir_index - 1];
11301 if (!decode_for_pst_p)
11303 last_subfile = current_subfile;
11304 dwarf2_start_subfile (fe->name, dir, comp_dir);
11309 case DW_LNS_set_column:
11310 column = read_unsigned_leb128 (abfd, line_ptr, &bytes_read);
11311 line_ptr += bytes_read;
11313 case DW_LNS_negate_stmt:
11314 is_stmt = (!is_stmt);
11316 case DW_LNS_set_basic_block:
11319 /* Add to the address register of the state machine the
11320 address increment value corresponding to special opcode
11321 255. I.e., this value is scaled by the minimum
11322 instruction length since special opcode 255 would have
11323 scaled the increment. */
11324 case DW_LNS_const_add_pc:
11326 CORE_ADDR adjust = (255 - lh->opcode_base) / lh->line_range;
11328 address += (((op_index + adjust)
11329 / lh->maximum_ops_per_instruction)
11330 * lh->minimum_instruction_length);
11331 op_index = ((op_index + adjust)
11332 % lh->maximum_ops_per_instruction);
11335 case DW_LNS_fixed_advance_pc:
11336 address += read_2_bytes (abfd, line_ptr);
11342 /* Unknown standard opcode, ignore it. */
11345 for (i = 0; i < lh->standard_opcode_lengths[op_code]; i++)
11347 (void) read_unsigned_leb128 (abfd, line_ptr, &bytes_read);
11348 line_ptr += bytes_read;
11353 if (lh->num_file_names < file || file == 0)
11354 dwarf2_debug_line_missing_file_complaint ();
11357 lh->file_names[file - 1].included_p = 1;
11358 if (!decode_for_pst_p)
11360 addr = gdbarch_addr_bits_remove (gdbarch, address);
11361 (*p_record_line) (current_subfile, 0, addr);
11367 /* Decode the Line Number Program (LNP) for the given line_header
11368 structure and CU. The actual information extracted and the type
11369 of structures created from the LNP depends on the value of PST.
11371 1. If PST is NULL, then this procedure uses the data from the program
11372 to create all necessary symbol tables, and their linetables.
11374 2. If PST is not NULL, this procedure reads the program to determine
11375 the list of files included by the unit represented by PST, and
11376 builds all the associated partial symbol tables.
11378 COMP_DIR is the compilation directory (DW_AT_comp_dir) or NULL if unknown.
11379 It is used for relative paths in the line table.
11380 NOTE: When processing partial symtabs (pst != NULL),
11381 comp_dir == pst->dirname.
11383 NOTE: It is important that psymtabs have the same file name (via strcmp)
11384 as the corresponding symtab. Since COMP_DIR is not used in the name of the
11385 symtab we don't use it in the name of the psymtabs we create.
11386 E.g. expand_line_sal requires this when finding psymtabs to expand.
11387 A good testcase for this is mb-inline.exp. */
11390 dwarf_decode_lines (struct line_header *lh, const char *comp_dir,
11391 struct dwarf2_cu *cu, struct partial_symtab *pst,
11392 int want_line_info)
11394 struct objfile *objfile = cu->objfile;
11395 const int decode_for_pst_p = (pst != NULL);
11396 struct subfile *first_subfile = current_subfile;
11398 if (want_line_info)
11399 dwarf_decode_lines_1 (lh, comp_dir, cu, pst);
11401 if (decode_for_pst_p)
11405 /* Now that we're done scanning the Line Header Program, we can
11406 create the psymtab of each included file. */
11407 for (file_index = 0; file_index < lh->num_file_names; file_index++)
11408 if (lh->file_names[file_index].included_p == 1)
11410 char *include_name =
11411 psymtab_include_file_name (lh, file_index, pst, comp_dir);
11412 if (include_name != NULL)
11413 dwarf2_create_include_psymtab (include_name, pst, objfile);
11418 /* Make sure a symtab is created for every file, even files
11419 which contain only variables (i.e. no code with associated
11423 for (i = 0; i < lh->num_file_names; i++)
11426 struct file_entry *fe;
11428 fe = &lh->file_names[i];
11430 dir = lh->include_dirs[fe->dir_index - 1];
11431 dwarf2_start_subfile (fe->name, dir, comp_dir);
11433 /* Skip the main file; we don't need it, and it must be
11434 allocated last, so that it will show up before the
11435 non-primary symtabs in the objfile's symtab list. */
11436 if (current_subfile == first_subfile)
11439 if (current_subfile->symtab == NULL)
11440 current_subfile->symtab = allocate_symtab (current_subfile->name,
11442 fe->symtab = current_subfile->symtab;
11447 /* Start a subfile for DWARF. FILENAME is the name of the file and
11448 DIRNAME the name of the source directory which contains FILENAME
11449 or NULL if not known. COMP_DIR is the compilation directory for the
11450 linetable's compilation unit or NULL if not known.
11451 This routine tries to keep line numbers from identical absolute and
11452 relative file names in a common subfile.
11454 Using the `list' example from the GDB testsuite, which resides in
11455 /srcdir and compiling it with Irix6.2 cc in /compdir using a filename
11456 of /srcdir/list0.c yields the following debugging information for list0.c:
11458 DW_AT_name: /srcdir/list0.c
11459 DW_AT_comp_dir: /compdir
11460 files.files[0].name: list0.h
11461 files.files[0].dir: /srcdir
11462 files.files[1].name: list0.c
11463 files.files[1].dir: /srcdir
11465 The line number information for list0.c has to end up in a single
11466 subfile, so that `break /srcdir/list0.c:1' works as expected.
11467 start_subfile will ensure that this happens provided that we pass the
11468 concatenation of files.files[1].dir and files.files[1].name as the
11472 dwarf2_start_subfile (char *filename, const char *dirname,
11473 const char *comp_dir)
11477 /* While reading the DIEs, we call start_symtab(DW_AT_name, DW_AT_comp_dir).
11478 `start_symtab' will always pass the contents of DW_AT_comp_dir as
11479 second argument to start_subfile. To be consistent, we do the
11480 same here. In order not to lose the line information directory,
11481 we concatenate it to the filename when it makes sense.
11482 Note that the Dwarf3 standard says (speaking of filenames in line
11483 information): ``The directory index is ignored for file names
11484 that represent full path names''. Thus ignoring dirname in the
11485 `else' branch below isn't an issue. */
11487 if (!IS_ABSOLUTE_PATH (filename) && dirname != NULL)
11488 fullname = concat (dirname, SLASH_STRING, filename, (char *)NULL);
11490 fullname = filename;
11492 start_subfile (fullname, comp_dir);
11494 if (fullname != filename)
11499 var_decode_location (struct attribute *attr, struct symbol *sym,
11500 struct dwarf2_cu *cu)
11502 struct objfile *objfile = cu->objfile;
11503 struct comp_unit_head *cu_header = &cu->header;
11505 /* NOTE drow/2003-01-30: There used to be a comment and some special
11506 code here to turn a symbol with DW_AT_external and a
11507 SYMBOL_VALUE_ADDRESS of 0 into a LOC_UNRESOLVED symbol. This was
11508 necessary for platforms (maybe Alpha, certainly PowerPC GNU/Linux
11509 with some versions of binutils) where shared libraries could have
11510 relocations against symbols in their debug information - the
11511 minimal symbol would have the right address, but the debug info
11512 would not. It's no longer necessary, because we will explicitly
11513 apply relocations when we read in the debug information now. */
11515 /* A DW_AT_location attribute with no contents indicates that a
11516 variable has been optimized away. */
11517 if (attr_form_is_block (attr) && DW_BLOCK (attr)->size == 0)
11519 SYMBOL_CLASS (sym) = LOC_OPTIMIZED_OUT;
11523 /* Handle one degenerate form of location expression specially, to
11524 preserve GDB's previous behavior when section offsets are
11525 specified. If this is just a DW_OP_addr then mark this symbol
11528 if (attr_form_is_block (attr)
11529 && DW_BLOCK (attr)->size == 1 + cu_header->addr_size
11530 && DW_BLOCK (attr)->data[0] == DW_OP_addr)
11532 unsigned int dummy;
11534 SYMBOL_VALUE_ADDRESS (sym) =
11535 read_address (objfile->obfd, DW_BLOCK (attr)->data + 1, cu, &dummy);
11536 SYMBOL_CLASS (sym) = LOC_STATIC;
11537 fixup_symbol_section (sym, objfile);
11538 SYMBOL_VALUE_ADDRESS (sym) += ANOFFSET (objfile->section_offsets,
11539 SYMBOL_SECTION (sym));
11543 /* NOTE drow/2002-01-30: It might be worthwhile to have a static
11544 expression evaluator, and use LOC_COMPUTED only when necessary
11545 (i.e. when the value of a register or memory location is
11546 referenced, or a thread-local block, etc.). Then again, it might
11547 not be worthwhile. I'm assuming that it isn't unless performance
11548 or memory numbers show me otherwise. */
11550 dwarf2_symbol_mark_computed (attr, sym, cu);
11551 SYMBOL_CLASS (sym) = LOC_COMPUTED;
11553 if (SYMBOL_COMPUTED_OPS (sym) == &dwarf2_loclist_funcs)
11554 cu->has_loclist = 1;
11557 /* Given a pointer to a DWARF information entry, figure out if we need
11558 to make a symbol table entry for it, and if so, create a new entry
11559 and return a pointer to it.
11560 If TYPE is NULL, determine symbol type from the die, otherwise
11561 used the passed type.
11562 If SPACE is not NULL, use it to hold the new symbol. If it is
11563 NULL, allocate a new symbol on the objfile's obstack. */
11565 static struct symbol *
11566 new_symbol_full (struct die_info *die, struct type *type, struct dwarf2_cu *cu,
11567 struct symbol *space)
11569 struct objfile *objfile = cu->objfile;
11570 struct symbol *sym = NULL;
11572 struct attribute *attr = NULL;
11573 struct attribute *attr2 = NULL;
11574 CORE_ADDR baseaddr;
11575 struct pending **list_to_add = NULL;
11577 int inlined_func = (die->tag == DW_TAG_inlined_subroutine);
11579 baseaddr = ANOFFSET (objfile->section_offsets, SECT_OFF_TEXT (objfile));
11581 name = dwarf2_name (die, cu);
11584 const char *linkagename;
11585 int suppress_add = 0;
11590 sym = OBSTACK_ZALLOC (&objfile->objfile_obstack, struct symbol);
11591 OBJSTAT (objfile, n_syms++);
11593 /* Cache this symbol's name and the name's demangled form (if any). */
11594 SYMBOL_SET_LANGUAGE (sym, cu->language);
11595 linkagename = dwarf2_physname (name, die, cu);
11596 SYMBOL_SET_NAMES (sym, linkagename, strlen (linkagename), 0, objfile);
11598 /* Fortran does not have mangling standard and the mangling does differ
11599 between gfortran, iFort etc. */
11600 if (cu->language == language_fortran
11601 && symbol_get_demangled_name (&(sym->ginfo)) == NULL)
11602 symbol_set_demangled_name (&(sym->ginfo),
11603 (char *) dwarf2_full_name (name, die, cu),
11606 /* Default assumptions.
11607 Use the passed type or decode it from the die. */
11608 SYMBOL_DOMAIN (sym) = VAR_DOMAIN;
11609 SYMBOL_CLASS (sym) = LOC_OPTIMIZED_OUT;
11611 SYMBOL_TYPE (sym) = type;
11613 SYMBOL_TYPE (sym) = die_type (die, cu);
11614 attr = dwarf2_attr (die,
11615 inlined_func ? DW_AT_call_line : DW_AT_decl_line,
11619 SYMBOL_LINE (sym) = DW_UNSND (attr);
11622 attr = dwarf2_attr (die,
11623 inlined_func ? DW_AT_call_file : DW_AT_decl_file,
11627 int file_index = DW_UNSND (attr);
11629 if (cu->line_header == NULL
11630 || file_index > cu->line_header->num_file_names)
11631 complaint (&symfile_complaints,
11632 _("file index out of range"));
11633 else if (file_index > 0)
11635 struct file_entry *fe;
11637 fe = &cu->line_header->file_names[file_index - 1];
11638 SYMBOL_SYMTAB (sym) = fe->symtab;
11645 attr = dwarf2_attr (die, DW_AT_low_pc, cu);
11648 SYMBOL_VALUE_ADDRESS (sym) = DW_ADDR (attr) + baseaddr;
11650 SYMBOL_TYPE (sym) = objfile_type (objfile)->builtin_core_addr;
11651 SYMBOL_DOMAIN (sym) = LABEL_DOMAIN;
11652 SYMBOL_CLASS (sym) = LOC_LABEL;
11653 add_symbol_to_list (sym, cu->list_in_scope);
11655 case DW_TAG_subprogram:
11656 /* SYMBOL_BLOCK_VALUE (sym) will be filled in later by
11658 SYMBOL_CLASS (sym) = LOC_BLOCK;
11659 attr2 = dwarf2_attr (die, DW_AT_external, cu);
11660 if ((attr2 && (DW_UNSND (attr2) != 0))
11661 || cu->language == language_ada)
11663 /* Subprograms marked external are stored as a global symbol.
11664 Ada subprograms, whether marked external or not, are always
11665 stored as a global symbol, because we want to be able to
11666 access them globally. For instance, we want to be able
11667 to break on a nested subprogram without having to
11668 specify the context. */
11669 list_to_add = &global_symbols;
11673 list_to_add = cu->list_in_scope;
11676 case DW_TAG_inlined_subroutine:
11677 /* SYMBOL_BLOCK_VALUE (sym) will be filled in later by
11679 SYMBOL_CLASS (sym) = LOC_BLOCK;
11680 SYMBOL_INLINED (sym) = 1;
11681 /* Do not add the symbol to any lists. It will be found via
11682 BLOCK_FUNCTION from the blockvector. */
11684 case DW_TAG_template_value_param:
11686 /* Fall through. */
11687 case DW_TAG_constant:
11688 case DW_TAG_variable:
11689 case DW_TAG_member:
11690 /* Compilation with minimal debug info may result in
11691 variables with missing type entries. Change the
11692 misleading `void' type to something sensible. */
11693 if (TYPE_CODE (SYMBOL_TYPE (sym)) == TYPE_CODE_VOID)
11695 = objfile_type (objfile)->nodebug_data_symbol;
11697 attr = dwarf2_attr (die, DW_AT_const_value, cu);
11698 /* In the case of DW_TAG_member, we should only be called for
11699 static const members. */
11700 if (die->tag == DW_TAG_member)
11702 /* dwarf2_add_field uses die_is_declaration,
11703 so we do the same. */
11704 gdb_assert (die_is_declaration (die, cu));
11709 dwarf2_const_value (attr, sym, cu);
11710 attr2 = dwarf2_attr (die, DW_AT_external, cu);
11713 if (attr2 && (DW_UNSND (attr2) != 0))
11714 list_to_add = &global_symbols;
11716 list_to_add = cu->list_in_scope;
11720 attr = dwarf2_attr (die, DW_AT_location, cu);
11723 var_decode_location (attr, sym, cu);
11724 attr2 = dwarf2_attr (die, DW_AT_external, cu);
11725 if (SYMBOL_CLASS (sym) == LOC_STATIC
11726 && SYMBOL_VALUE_ADDRESS (sym) == 0
11727 && !dwarf2_per_objfile->has_section_at_zero)
11729 /* When a static variable is eliminated by the linker,
11730 the corresponding debug information is not stripped
11731 out, but the variable address is set to null;
11732 do not add such variables into symbol table. */
11734 else if (attr2 && (DW_UNSND (attr2) != 0))
11736 /* Workaround gfortran PR debug/40040 - it uses
11737 DW_AT_location for variables in -fPIC libraries which may
11738 get overriden by other libraries/executable and get
11739 a different address. Resolve it by the minimal symbol
11740 which may come from inferior's executable using copy
11741 relocation. Make this workaround only for gfortran as for
11742 other compilers GDB cannot guess the minimal symbol
11743 Fortran mangling kind. */
11744 if (cu->language == language_fortran && die->parent
11745 && die->parent->tag == DW_TAG_module
11747 && strncmp (cu->producer, "GNU Fortran ", 12) == 0)
11748 SYMBOL_CLASS (sym) = LOC_UNRESOLVED;
11750 /* A variable with DW_AT_external is never static,
11751 but it may be block-scoped. */
11752 list_to_add = (cu->list_in_scope == &file_symbols
11753 ? &global_symbols : cu->list_in_scope);
11756 list_to_add = cu->list_in_scope;
11760 /* We do not know the address of this symbol.
11761 If it is an external symbol and we have type information
11762 for it, enter the symbol as a LOC_UNRESOLVED symbol.
11763 The address of the variable will then be determined from
11764 the minimal symbol table whenever the variable is
11766 attr2 = dwarf2_attr (die, DW_AT_external, cu);
11767 if (attr2 && (DW_UNSND (attr2) != 0)
11768 && dwarf2_attr (die, DW_AT_type, cu) != NULL)
11770 /* A variable with DW_AT_external is never static, but it
11771 may be block-scoped. */
11772 list_to_add = (cu->list_in_scope == &file_symbols
11773 ? &global_symbols : cu->list_in_scope);
11775 SYMBOL_CLASS (sym) = LOC_UNRESOLVED;
11777 else if (!die_is_declaration (die, cu))
11779 /* Use the default LOC_OPTIMIZED_OUT class. */
11780 gdb_assert (SYMBOL_CLASS (sym) == LOC_OPTIMIZED_OUT);
11782 list_to_add = cu->list_in_scope;
11786 case DW_TAG_formal_parameter:
11787 /* If we are inside a function, mark this as an argument. If
11788 not, we might be looking at an argument to an inlined function
11789 when we do not have enough information to show inlined frames;
11790 pretend it's a local variable in that case so that the user can
11792 if (context_stack_depth > 0
11793 && context_stack[context_stack_depth - 1].name != NULL)
11794 SYMBOL_IS_ARGUMENT (sym) = 1;
11795 attr = dwarf2_attr (die, DW_AT_location, cu);
11798 var_decode_location (attr, sym, cu);
11800 attr = dwarf2_attr (die, DW_AT_const_value, cu);
11803 dwarf2_const_value (attr, sym, cu);
11806 list_to_add = cu->list_in_scope;
11808 case DW_TAG_unspecified_parameters:
11809 /* From varargs functions; gdb doesn't seem to have any
11810 interest in this information, so just ignore it for now.
11813 case DW_TAG_template_type_param:
11815 /* Fall through. */
11816 case DW_TAG_class_type:
11817 case DW_TAG_interface_type:
11818 case DW_TAG_structure_type:
11819 case DW_TAG_union_type:
11820 case DW_TAG_set_type:
11821 case DW_TAG_enumeration_type:
11822 SYMBOL_CLASS (sym) = LOC_TYPEDEF;
11823 SYMBOL_DOMAIN (sym) = STRUCT_DOMAIN;
11826 /* NOTE: carlton/2003-11-10: C++ and Java class symbols shouldn't
11827 really ever be static objects: otherwise, if you try
11828 to, say, break of a class's method and you're in a file
11829 which doesn't mention that class, it won't work unless
11830 the check for all static symbols in lookup_symbol_aux
11831 saves you. See the OtherFileClass tests in
11832 gdb.c++/namespace.exp. */
11836 list_to_add = (cu->list_in_scope == &file_symbols
11837 && (cu->language == language_cplus
11838 || cu->language == language_java)
11839 ? &global_symbols : cu->list_in_scope);
11841 /* The semantics of C++ state that "struct foo {
11842 ... }" also defines a typedef for "foo". A Java
11843 class declaration also defines a typedef for the
11845 if (cu->language == language_cplus
11846 || cu->language == language_java
11847 || cu->language == language_ada)
11849 /* The symbol's name is already allocated along
11850 with this objfile, so we don't need to
11851 duplicate it for the type. */
11852 if (TYPE_NAME (SYMBOL_TYPE (sym)) == 0)
11853 TYPE_NAME (SYMBOL_TYPE (sym)) = SYMBOL_SEARCH_NAME (sym);
11858 case DW_TAG_typedef:
11859 SYMBOL_CLASS (sym) = LOC_TYPEDEF;
11860 SYMBOL_DOMAIN (sym) = VAR_DOMAIN;
11861 list_to_add = cu->list_in_scope;
11863 case DW_TAG_base_type:
11864 case DW_TAG_subrange_type:
11865 SYMBOL_CLASS (sym) = LOC_TYPEDEF;
11866 SYMBOL_DOMAIN (sym) = VAR_DOMAIN;
11867 list_to_add = cu->list_in_scope;
11869 case DW_TAG_enumerator:
11870 attr = dwarf2_attr (die, DW_AT_const_value, cu);
11873 dwarf2_const_value (attr, sym, cu);
11876 /* NOTE: carlton/2003-11-10: See comment above in the
11877 DW_TAG_class_type, etc. block. */
11879 list_to_add = (cu->list_in_scope == &file_symbols
11880 && (cu->language == language_cplus
11881 || cu->language == language_java)
11882 ? &global_symbols : cu->list_in_scope);
11885 case DW_TAG_namespace:
11886 SYMBOL_CLASS (sym) = LOC_TYPEDEF;
11887 list_to_add = &global_symbols;
11890 /* Not a tag we recognize. Hopefully we aren't processing
11891 trash data, but since we must specifically ignore things
11892 we don't recognize, there is nothing else we should do at
11894 complaint (&symfile_complaints, _("unsupported tag: '%s'"),
11895 dwarf_tag_name (die->tag));
11901 sym->hash_next = objfile->template_symbols;
11902 objfile->template_symbols = sym;
11903 list_to_add = NULL;
11906 if (list_to_add != NULL)
11907 add_symbol_to_list (sym, list_to_add);
11909 /* For the benefit of old versions of GCC, check for anonymous
11910 namespaces based on the demangled name. */
11911 if (!processing_has_namespace_info
11912 && cu->language == language_cplus)
11913 cp_scan_for_anonymous_namespaces (sym, objfile);
11918 /* A wrapper for new_symbol_full that always allocates a new symbol. */
11920 static struct symbol *
11921 new_symbol (struct die_info *die, struct type *type, struct dwarf2_cu *cu)
11923 return new_symbol_full (die, type, cu, NULL);
11926 /* Given an attr with a DW_FORM_dataN value in host byte order,
11927 zero-extend it as appropriate for the symbol's type. The DWARF
11928 standard (v4) is not entirely clear about the meaning of using
11929 DW_FORM_dataN for a constant with a signed type, where the type is
11930 wider than the data. The conclusion of a discussion on the DWARF
11931 list was that this is unspecified. We choose to always zero-extend
11932 because that is the interpretation long in use by GCC. */
11935 dwarf2_const_value_data (struct attribute *attr, struct type *type,
11936 const char *name, struct obstack *obstack,
11937 struct dwarf2_cu *cu, long *value, int bits)
11939 struct objfile *objfile = cu->objfile;
11940 enum bfd_endian byte_order = bfd_big_endian (objfile->obfd) ?
11941 BFD_ENDIAN_BIG : BFD_ENDIAN_LITTLE;
11942 LONGEST l = DW_UNSND (attr);
11944 if (bits < sizeof (*value) * 8)
11946 l &= ((LONGEST) 1 << bits) - 1;
11949 else if (bits == sizeof (*value) * 8)
11953 gdb_byte *bytes = obstack_alloc (obstack, bits / 8);
11954 store_unsigned_integer (bytes, bits / 8, byte_order, l);
11961 /* Read a constant value from an attribute. Either set *VALUE, or if
11962 the value does not fit in *VALUE, set *BYTES - either already
11963 allocated on the objfile obstack, or newly allocated on OBSTACK,
11964 or, set *BATON, if we translated the constant to a location
11968 dwarf2_const_value_attr (struct attribute *attr, struct type *type,
11969 const char *name, struct obstack *obstack,
11970 struct dwarf2_cu *cu,
11971 long *value, gdb_byte **bytes,
11972 struct dwarf2_locexpr_baton **baton)
11974 struct objfile *objfile = cu->objfile;
11975 struct comp_unit_head *cu_header = &cu->header;
11976 struct dwarf_block *blk;
11977 enum bfd_endian byte_order = (bfd_big_endian (objfile->obfd) ?
11978 BFD_ENDIAN_BIG : BFD_ENDIAN_LITTLE);
11984 switch (attr->form)
11990 if (TYPE_LENGTH (type) != cu_header->addr_size)
11991 dwarf2_const_value_length_mismatch_complaint (name,
11992 cu_header->addr_size,
11993 TYPE_LENGTH (type));
11994 /* Symbols of this form are reasonably rare, so we just
11995 piggyback on the existing location code rather than writing
11996 a new implementation of symbol_computed_ops. */
11997 *baton = obstack_alloc (&objfile->objfile_obstack,
11998 sizeof (struct dwarf2_locexpr_baton));
11999 (*baton)->per_cu = cu->per_cu;
12000 gdb_assert ((*baton)->per_cu);
12002 (*baton)->size = 2 + cu_header->addr_size;
12003 data = obstack_alloc (&objfile->objfile_obstack, (*baton)->size);
12004 (*baton)->data = data;
12006 data[0] = DW_OP_addr;
12007 store_unsigned_integer (&data[1], cu_header->addr_size,
12008 byte_order, DW_ADDR (attr));
12009 data[cu_header->addr_size + 1] = DW_OP_stack_value;
12012 case DW_FORM_string:
12014 /* DW_STRING is already allocated on the objfile obstack, point
12016 *bytes = (gdb_byte *) DW_STRING (attr);
12018 case DW_FORM_block1:
12019 case DW_FORM_block2:
12020 case DW_FORM_block4:
12021 case DW_FORM_block:
12022 case DW_FORM_exprloc:
12023 blk = DW_BLOCK (attr);
12024 if (TYPE_LENGTH (type) != blk->size)
12025 dwarf2_const_value_length_mismatch_complaint (name, blk->size,
12026 TYPE_LENGTH (type));
12027 *bytes = blk->data;
12030 /* The DW_AT_const_value attributes are supposed to carry the
12031 symbol's value "represented as it would be on the target
12032 architecture." By the time we get here, it's already been
12033 converted to host endianness, so we just need to sign- or
12034 zero-extend it as appropriate. */
12035 case DW_FORM_data1:
12036 *bytes = dwarf2_const_value_data (attr, type, name,
12037 obstack, cu, value, 8);
12039 case DW_FORM_data2:
12040 *bytes = dwarf2_const_value_data (attr, type, name,
12041 obstack, cu, value, 16);
12043 case DW_FORM_data4:
12044 *bytes = dwarf2_const_value_data (attr, type, name,
12045 obstack, cu, value, 32);
12047 case DW_FORM_data8:
12048 *bytes = dwarf2_const_value_data (attr, type, name,
12049 obstack, cu, value, 64);
12052 case DW_FORM_sdata:
12053 *value = DW_SND (attr);
12056 case DW_FORM_udata:
12057 *value = DW_UNSND (attr);
12061 complaint (&symfile_complaints,
12062 _("unsupported const value attribute form: '%s'"),
12063 dwarf_form_name (attr->form));
12070 /* Copy constant value from an attribute to a symbol. */
12073 dwarf2_const_value (struct attribute *attr, struct symbol *sym,
12074 struct dwarf2_cu *cu)
12076 struct objfile *objfile = cu->objfile;
12077 struct comp_unit_head *cu_header = &cu->header;
12080 struct dwarf2_locexpr_baton *baton;
12082 dwarf2_const_value_attr (attr, SYMBOL_TYPE (sym),
12083 SYMBOL_PRINT_NAME (sym),
12084 &objfile->objfile_obstack, cu,
12085 &value, &bytes, &baton);
12089 SYMBOL_COMPUTED_OPS (sym) = &dwarf2_locexpr_funcs;
12090 SYMBOL_LOCATION_BATON (sym) = baton;
12091 SYMBOL_CLASS (sym) = LOC_COMPUTED;
12093 else if (bytes != NULL)
12095 SYMBOL_VALUE_BYTES (sym) = bytes;
12096 SYMBOL_CLASS (sym) = LOC_CONST_BYTES;
12100 SYMBOL_VALUE (sym) = value;
12101 SYMBOL_CLASS (sym) = LOC_CONST;
12105 /* Return the type of the die in question using its DW_AT_type attribute. */
12107 static struct type *
12108 die_type (struct die_info *die, struct dwarf2_cu *cu)
12110 struct attribute *type_attr;
12112 type_attr = dwarf2_attr (die, DW_AT_type, cu);
12115 /* A missing DW_AT_type represents a void type. */
12116 return objfile_type (cu->objfile)->builtin_void;
12119 return lookup_die_type (die, type_attr, cu);
12122 /* True iff CU's producer generates GNAT Ada auxiliary information
12123 that allows to find parallel types through that information instead
12124 of having to do expensive parallel lookups by type name. */
12127 need_gnat_info (struct dwarf2_cu *cu)
12129 /* FIXME: brobecker/2010-10-12: As of now, only the AdaCore version
12130 of GNAT produces this auxiliary information, without any indication
12131 that it is produced. Part of enhancing the FSF version of GNAT
12132 to produce that information will be to put in place an indicator
12133 that we can use in order to determine whether the descriptive type
12134 info is available or not. One suggestion that has been made is
12135 to use a new attribute, attached to the CU die. For now, assume
12136 that the descriptive type info is not available. */
12140 /* Return the auxiliary type of the die in question using its
12141 DW_AT_GNAT_descriptive_type attribute. Returns NULL if the
12142 attribute is not present. */
12144 static struct type *
12145 die_descriptive_type (struct die_info *die, struct dwarf2_cu *cu)
12147 struct attribute *type_attr;
12149 type_attr = dwarf2_attr (die, DW_AT_GNAT_descriptive_type, cu);
12153 return lookup_die_type (die, type_attr, cu);
12156 /* If DIE has a descriptive_type attribute, then set the TYPE's
12157 descriptive type accordingly. */
12160 set_descriptive_type (struct type *type, struct die_info *die,
12161 struct dwarf2_cu *cu)
12163 struct type *descriptive_type = die_descriptive_type (die, cu);
12165 if (descriptive_type)
12167 ALLOCATE_GNAT_AUX_TYPE (type);
12168 TYPE_DESCRIPTIVE_TYPE (type) = descriptive_type;
12172 /* Return the containing type of the die in question using its
12173 DW_AT_containing_type attribute. */
12175 static struct type *
12176 die_containing_type (struct die_info *die, struct dwarf2_cu *cu)
12178 struct attribute *type_attr;
12180 type_attr = dwarf2_attr (die, DW_AT_containing_type, cu);
12182 error (_("Dwarf Error: Problem turning containing type into gdb type "
12183 "[in module %s]"), cu->objfile->name);
12185 return lookup_die_type (die, type_attr, cu);
12188 /* Look up the type of DIE in CU using its type attribute ATTR.
12189 If there is no type substitute an error marker. */
12191 static struct type *
12192 lookup_die_type (struct die_info *die, struct attribute *attr,
12193 struct dwarf2_cu *cu)
12195 struct objfile *objfile = cu->objfile;
12196 struct type *this_type;
12198 /* First see if we have it cached. */
12200 if (is_ref_attr (attr))
12202 unsigned int offset = dwarf2_get_ref_die_offset (attr);
12204 this_type = get_die_type_at_offset (offset, cu->per_cu);
12206 else if (attr->form == DW_FORM_ref_sig8)
12208 struct signatured_type *sig_type = DW_SIGNATURED_TYPE (attr);
12209 struct dwarf2_cu *sig_cu;
12210 unsigned int offset;
12212 /* sig_type will be NULL if the signatured type is missing from
12214 if (sig_type == NULL)
12215 error (_("Dwarf Error: Cannot find signatured DIE referenced from DIE "
12216 "at 0x%x [in module %s]"),
12217 die->offset, objfile->name);
12219 gdb_assert (sig_type->per_cu.debug_types_section);
12220 offset = sig_type->per_cu.offset + sig_type->type_offset;
12221 this_type = get_die_type_at_offset (offset, &sig_type->per_cu);
12225 dump_die_for_error (die);
12226 error (_("Dwarf Error: Bad type attribute %s [in module %s]"),
12227 dwarf_attr_name (attr->name), objfile->name);
12230 /* If not cached we need to read it in. */
12232 if (this_type == NULL)
12234 struct die_info *type_die;
12235 struct dwarf2_cu *type_cu = cu;
12237 type_die = follow_die_ref_or_sig (die, attr, &type_cu);
12238 /* If the type is cached, we should have found it above. */
12239 gdb_assert (get_die_type (type_die, type_cu) == NULL);
12240 this_type = read_type_die_1 (type_die, type_cu);
12243 /* If we still don't have a type use an error marker. */
12245 if (this_type == NULL)
12247 char *message, *saved;
12249 /* read_type_die already issued a complaint. */
12250 message = xstrprintf (_("<unknown type in %s, CU 0x%x, DIE 0x%x>"),
12254 saved = obstack_copy0 (&objfile->objfile_obstack,
12255 message, strlen (message));
12258 this_type = init_type (TYPE_CODE_ERROR, 0, 0, saved, objfile);
12264 /* Return the type in DIE, CU.
12265 Returns NULL for invalid types.
12267 This first does a lookup in the appropriate type_hash table,
12268 and only reads the die in if necessary.
12270 NOTE: This can be called when reading in partial or full symbols. */
12272 static struct type *
12273 read_type_die (struct die_info *die, struct dwarf2_cu *cu)
12275 struct type *this_type;
12277 this_type = get_die_type (die, cu);
12281 return read_type_die_1 (die, cu);
12284 /* Read the type in DIE, CU.
12285 Returns NULL for invalid types. */
12287 static struct type *
12288 read_type_die_1 (struct die_info *die, struct dwarf2_cu *cu)
12290 struct type *this_type = NULL;
12294 case DW_TAG_class_type:
12295 case DW_TAG_interface_type:
12296 case DW_TAG_structure_type:
12297 case DW_TAG_union_type:
12298 this_type = read_structure_type (die, cu);
12300 case DW_TAG_enumeration_type:
12301 this_type = read_enumeration_type (die, cu);
12303 case DW_TAG_subprogram:
12304 case DW_TAG_subroutine_type:
12305 case DW_TAG_inlined_subroutine:
12306 this_type = read_subroutine_type (die, cu);
12308 case DW_TAG_array_type:
12309 this_type = read_array_type (die, cu);
12311 case DW_TAG_set_type:
12312 this_type = read_set_type (die, cu);
12314 case DW_TAG_pointer_type:
12315 this_type = read_tag_pointer_type (die, cu);
12317 case DW_TAG_ptr_to_member_type:
12318 this_type = read_tag_ptr_to_member_type (die, cu);
12320 case DW_TAG_reference_type:
12321 this_type = read_tag_reference_type (die, cu);
12323 case DW_TAG_const_type:
12324 this_type = read_tag_const_type (die, cu);
12326 case DW_TAG_volatile_type:
12327 this_type = read_tag_volatile_type (die, cu);
12329 case DW_TAG_string_type:
12330 this_type = read_tag_string_type (die, cu);
12332 case DW_TAG_typedef:
12333 this_type = read_typedef (die, cu);
12335 case DW_TAG_subrange_type:
12336 this_type = read_subrange_type (die, cu);
12338 case DW_TAG_base_type:
12339 this_type = read_base_type (die, cu);
12341 case DW_TAG_unspecified_type:
12342 this_type = read_unspecified_type (die, cu);
12344 case DW_TAG_namespace:
12345 this_type = read_namespace_type (die, cu);
12347 case DW_TAG_module:
12348 this_type = read_module_type (die, cu);
12351 complaint (&symfile_complaints,
12352 _("unexpected tag in read_type_die: '%s'"),
12353 dwarf_tag_name (die->tag));
12360 /* See if we can figure out if the class lives in a namespace. We do
12361 this by looking for a member function; its demangled name will
12362 contain namespace info, if there is any.
12363 Return the computed name or NULL.
12364 Space for the result is allocated on the objfile's obstack.
12365 This is the full-die version of guess_partial_die_structure_name.
12366 In this case we know DIE has no useful parent. */
12369 guess_full_die_structure_name (struct die_info *die, struct dwarf2_cu *cu)
12371 struct die_info *spec_die;
12372 struct dwarf2_cu *spec_cu;
12373 struct die_info *child;
12376 spec_die = die_specification (die, &spec_cu);
12377 if (spec_die != NULL)
12383 for (child = die->child;
12385 child = child->sibling)
12387 if (child->tag == DW_TAG_subprogram)
12389 struct attribute *attr;
12391 attr = dwarf2_attr (child, DW_AT_linkage_name, cu);
12393 attr = dwarf2_attr (child, DW_AT_MIPS_linkage_name, cu);
12397 = language_class_name_from_physname (cu->language_defn,
12401 if (actual_name != NULL)
12403 char *die_name = dwarf2_name (die, cu);
12405 if (die_name != NULL
12406 && strcmp (die_name, actual_name) != 0)
12408 /* Strip off the class name from the full name.
12409 We want the prefix. */
12410 int die_name_len = strlen (die_name);
12411 int actual_name_len = strlen (actual_name);
12413 /* Test for '::' as a sanity check. */
12414 if (actual_name_len > die_name_len + 2
12415 && actual_name[actual_name_len
12416 - die_name_len - 1] == ':')
12418 obsavestring (actual_name,
12419 actual_name_len - die_name_len - 2,
12420 &cu->objfile->objfile_obstack);
12423 xfree (actual_name);
12432 /* GCC might emit a nameless typedef that has a linkage name. Determine the
12433 prefix part in such case. See
12434 http://gcc.gnu.org/bugzilla/show_bug.cgi?id=47510. */
12437 anonymous_struct_prefix (struct die_info *die, struct dwarf2_cu *cu)
12439 struct attribute *attr;
12442 if (die->tag != DW_TAG_class_type && die->tag != DW_TAG_interface_type
12443 && die->tag != DW_TAG_structure_type && die->tag != DW_TAG_union_type)
12446 attr = dwarf2_attr (die, DW_AT_name, cu);
12447 if (attr != NULL && DW_STRING (attr) != NULL)
12450 attr = dwarf2_attr (die, DW_AT_linkage_name, cu);
12452 attr = dwarf2_attr (die, DW_AT_MIPS_linkage_name, cu);
12453 if (attr == NULL || DW_STRING (attr) == NULL)
12456 /* dwarf2_name had to be already called. */
12457 gdb_assert (DW_STRING_IS_CANONICAL (attr));
12459 /* Strip the base name, keep any leading namespaces/classes. */
12460 base = strrchr (DW_STRING (attr), ':');
12461 if (base == NULL || base == DW_STRING (attr) || base[-1] != ':')
12464 return obsavestring (DW_STRING (attr), &base[-1] - DW_STRING (attr),
12465 &cu->objfile->objfile_obstack);
12468 /* Return the name of the namespace/class that DIE is defined within,
12469 or "" if we can't tell. The caller should not xfree the result.
12471 For example, if we're within the method foo() in the following
12481 then determine_prefix on foo's die will return "N::C". */
12484 determine_prefix (struct die_info *die, struct dwarf2_cu *cu)
12486 struct die_info *parent, *spec_die;
12487 struct dwarf2_cu *spec_cu;
12488 struct type *parent_type;
12491 if (cu->language != language_cplus && cu->language != language_java
12492 && cu->language != language_fortran)
12495 retval = anonymous_struct_prefix (die, cu);
12499 /* We have to be careful in the presence of DW_AT_specification.
12500 For example, with GCC 3.4, given the code
12504 // Definition of N::foo.
12508 then we'll have a tree of DIEs like this:
12510 1: DW_TAG_compile_unit
12511 2: DW_TAG_namespace // N
12512 3: DW_TAG_subprogram // declaration of N::foo
12513 4: DW_TAG_subprogram // definition of N::foo
12514 DW_AT_specification // refers to die #3
12516 Thus, when processing die #4, we have to pretend that we're in
12517 the context of its DW_AT_specification, namely the contex of die
12520 spec_die = die_specification (die, &spec_cu);
12521 if (spec_die == NULL)
12522 parent = die->parent;
12525 parent = spec_die->parent;
12529 if (parent == NULL)
12531 else if (parent->building_fullname)
12534 const char *parent_name;
12536 /* It has been seen on RealView 2.2 built binaries,
12537 DW_TAG_template_type_param types actually _defined_ as
12538 children of the parent class:
12541 template class <class Enum> Class{};
12542 Class<enum E> class_e;
12544 1: DW_TAG_class_type (Class)
12545 2: DW_TAG_enumeration_type (E)
12546 3: DW_TAG_enumerator (enum1:0)
12547 3: DW_TAG_enumerator (enum2:1)
12549 2: DW_TAG_template_type_param
12550 DW_AT_type DW_FORM_ref_udata (E)
12552 Besides being broken debug info, it can put GDB into an
12553 infinite loop. Consider:
12555 When we're building the full name for Class<E>, we'll start
12556 at Class, and go look over its template type parameters,
12557 finding E. We'll then try to build the full name of E, and
12558 reach here. We're now trying to build the full name of E,
12559 and look over the parent DIE for containing scope. In the
12560 broken case, if we followed the parent DIE of E, we'd again
12561 find Class, and once again go look at its template type
12562 arguments, etc., etc. Simply don't consider such parent die
12563 as source-level parent of this die (it can't be, the language
12564 doesn't allow it), and break the loop here. */
12565 name = dwarf2_name (die, cu);
12566 parent_name = dwarf2_name (parent, cu);
12567 complaint (&symfile_complaints,
12568 _("template param type '%s' defined within parent '%s'"),
12569 name ? name : "<unknown>",
12570 parent_name ? parent_name : "<unknown>");
12574 switch (parent->tag)
12576 case DW_TAG_namespace:
12577 parent_type = read_type_die (parent, cu);
12578 /* GCC 4.0 and 4.1 had a bug (PR c++/28460) where they generated bogus
12579 DW_TAG_namespace DIEs with a name of "::" for the global namespace.
12580 Work around this problem here. */
12581 if (cu->language == language_cplus
12582 && strcmp (TYPE_TAG_NAME (parent_type), "::") == 0)
12584 /* We give a name to even anonymous namespaces. */
12585 return TYPE_TAG_NAME (parent_type);
12586 case DW_TAG_class_type:
12587 case DW_TAG_interface_type:
12588 case DW_TAG_structure_type:
12589 case DW_TAG_union_type:
12590 case DW_TAG_module:
12591 parent_type = read_type_die (parent, cu);
12592 if (TYPE_TAG_NAME (parent_type) != NULL)
12593 return TYPE_TAG_NAME (parent_type);
12595 /* An anonymous structure is only allowed non-static data
12596 members; no typedefs, no member functions, et cetera.
12597 So it does not need a prefix. */
12599 case DW_TAG_compile_unit:
12600 /* gcc-4.5 -gdwarf-4 can drop the enclosing namespace. Cope. */
12601 if (cu->language == language_cplus
12602 && !VEC_empty (dwarf2_section_info_def, dwarf2_per_objfile->types)
12603 && die->child != NULL
12604 && (die->tag == DW_TAG_class_type
12605 || die->tag == DW_TAG_structure_type
12606 || die->tag == DW_TAG_union_type))
12608 char *name = guess_full_die_structure_name (die, cu);
12614 return determine_prefix (parent, cu);
12618 /* Return a newly-allocated string formed by concatenating PREFIX and SUFFIX
12619 with appropriate separator. If PREFIX or SUFFIX is NULL or empty, then
12620 simply copy the SUFFIX or PREFIX, respectively. If OBS is non-null, perform
12621 an obconcat, otherwise allocate storage for the result. The CU argument is
12622 used to determine the language and hence, the appropriate separator. */
12624 #define MAX_SEP_LEN 7 /* strlen ("__") + strlen ("_MOD_") */
12627 typename_concat (struct obstack *obs, const char *prefix, const char *suffix,
12628 int physname, struct dwarf2_cu *cu)
12630 const char *lead = "";
12633 if (suffix == NULL || suffix[0] == '\0'
12634 || prefix == NULL || prefix[0] == '\0')
12636 else if (cu->language == language_java)
12638 else if (cu->language == language_fortran && physname)
12640 /* This is gfortran specific mangling. Normally DW_AT_linkage_name or
12641 DW_AT_MIPS_linkage_name is preferred and used instead. */
12649 if (prefix == NULL)
12651 if (suffix == NULL)
12657 = xmalloc (strlen (prefix) + MAX_SEP_LEN + strlen (suffix) + 1);
12659 strcpy (retval, lead);
12660 strcat (retval, prefix);
12661 strcat (retval, sep);
12662 strcat (retval, suffix);
12667 /* We have an obstack. */
12668 return obconcat (obs, lead, prefix, sep, suffix, (char *) NULL);
12672 /* Return sibling of die, NULL if no sibling. */
12674 static struct die_info *
12675 sibling_die (struct die_info *die)
12677 return die->sibling;
12680 /* Get name of a die, return NULL if not found. */
12683 dwarf2_canonicalize_name (char *name, struct dwarf2_cu *cu,
12684 struct obstack *obstack)
12686 if (name && cu->language == language_cplus)
12688 char *canon_name = cp_canonicalize_string (name);
12690 if (canon_name != NULL)
12692 if (strcmp (canon_name, name) != 0)
12693 name = obsavestring (canon_name, strlen (canon_name),
12695 xfree (canon_name);
12702 /* Get name of a die, return NULL if not found. */
12705 dwarf2_name (struct die_info *die, struct dwarf2_cu *cu)
12707 struct attribute *attr;
12709 attr = dwarf2_attr (die, DW_AT_name, cu);
12710 if ((!attr || !DW_STRING (attr))
12711 && die->tag != DW_TAG_class_type
12712 && die->tag != DW_TAG_interface_type
12713 && die->tag != DW_TAG_structure_type
12714 && die->tag != DW_TAG_union_type)
12719 case DW_TAG_compile_unit:
12720 /* Compilation units have a DW_AT_name that is a filename, not
12721 a source language identifier. */
12722 case DW_TAG_enumeration_type:
12723 case DW_TAG_enumerator:
12724 /* These tags always have simple identifiers already; no need
12725 to canonicalize them. */
12726 return DW_STRING (attr);
12728 case DW_TAG_subprogram:
12729 /* Java constructors will all be named "<init>", so return
12730 the class name when we see this special case. */
12731 if (cu->language == language_java
12732 && DW_STRING (attr) != NULL
12733 && strcmp (DW_STRING (attr), "<init>") == 0)
12735 struct dwarf2_cu *spec_cu = cu;
12736 struct die_info *spec_die;
12738 /* GCJ will output '<init>' for Java constructor names.
12739 For this special case, return the name of the parent class. */
12741 /* GCJ may output suprogram DIEs with AT_specification set.
12742 If so, use the name of the specified DIE. */
12743 spec_die = die_specification (die, &spec_cu);
12744 if (spec_die != NULL)
12745 return dwarf2_name (spec_die, spec_cu);
12750 if (die->tag == DW_TAG_class_type)
12751 return dwarf2_name (die, cu);
12753 while (die->tag != DW_TAG_compile_unit);
12757 case DW_TAG_class_type:
12758 case DW_TAG_interface_type:
12759 case DW_TAG_structure_type:
12760 case DW_TAG_union_type:
12761 /* Some GCC versions emit spurious DW_AT_name attributes for unnamed
12762 structures or unions. These were of the form "._%d" in GCC 4.1,
12763 or simply "<anonymous struct>" or "<anonymous union>" in GCC 4.3
12764 and GCC 4.4. We work around this problem by ignoring these. */
12765 if (attr && DW_STRING (attr)
12766 && (strncmp (DW_STRING (attr), "._", 2) == 0
12767 || strncmp (DW_STRING (attr), "<anonymous", 10) == 0))
12770 /* GCC might emit a nameless typedef that has a linkage name. See
12771 http://gcc.gnu.org/bugzilla/show_bug.cgi?id=47510. */
12772 if (!attr || DW_STRING (attr) == NULL)
12774 char *demangled = NULL;
12776 attr = dwarf2_attr (die, DW_AT_linkage_name, cu);
12778 attr = dwarf2_attr (die, DW_AT_MIPS_linkage_name, cu);
12780 if (attr == NULL || DW_STRING (attr) == NULL)
12783 /* Avoid demangling DW_STRING (attr) the second time on a second
12784 call for the same DIE. */
12785 if (!DW_STRING_IS_CANONICAL (attr))
12786 demangled = cplus_demangle (DW_STRING (attr), DMGL_TYPES);
12792 /* FIXME: we already did this for the partial symbol... */
12793 DW_STRING (attr) = obsavestring (demangled, strlen (demangled),
12794 &cu->objfile->objfile_obstack);
12795 DW_STRING_IS_CANONICAL (attr) = 1;
12798 /* Strip any leading namespaces/classes, keep only the base name.
12799 DW_AT_name for named DIEs does not contain the prefixes. */
12800 base = strrchr (DW_STRING (attr), ':');
12801 if (base && base > DW_STRING (attr) && base[-1] == ':')
12804 return DW_STRING (attr);
12813 if (!DW_STRING_IS_CANONICAL (attr))
12816 = dwarf2_canonicalize_name (DW_STRING (attr), cu,
12817 &cu->objfile->objfile_obstack);
12818 DW_STRING_IS_CANONICAL (attr) = 1;
12820 return DW_STRING (attr);
12823 /* Return the die that this die in an extension of, or NULL if there
12824 is none. *EXT_CU is the CU containing DIE on input, and the CU
12825 containing the return value on output. */
12827 static struct die_info *
12828 dwarf2_extension (struct die_info *die, struct dwarf2_cu **ext_cu)
12830 struct attribute *attr;
12832 attr = dwarf2_attr (die, DW_AT_extension, *ext_cu);
12836 return follow_die_ref (die, attr, ext_cu);
12839 /* Convert a DIE tag into its string name. */
12842 dwarf_tag_name (unsigned tag)
12846 case DW_TAG_padding:
12847 return "DW_TAG_padding";
12848 case DW_TAG_array_type:
12849 return "DW_TAG_array_type";
12850 case DW_TAG_class_type:
12851 return "DW_TAG_class_type";
12852 case DW_TAG_entry_point:
12853 return "DW_TAG_entry_point";
12854 case DW_TAG_enumeration_type:
12855 return "DW_TAG_enumeration_type";
12856 case DW_TAG_formal_parameter:
12857 return "DW_TAG_formal_parameter";
12858 case DW_TAG_imported_declaration:
12859 return "DW_TAG_imported_declaration";
12861 return "DW_TAG_label";
12862 case DW_TAG_lexical_block:
12863 return "DW_TAG_lexical_block";
12864 case DW_TAG_member:
12865 return "DW_TAG_member";
12866 case DW_TAG_pointer_type:
12867 return "DW_TAG_pointer_type";
12868 case DW_TAG_reference_type:
12869 return "DW_TAG_reference_type";
12870 case DW_TAG_compile_unit:
12871 return "DW_TAG_compile_unit";
12872 case DW_TAG_string_type:
12873 return "DW_TAG_string_type";
12874 case DW_TAG_structure_type:
12875 return "DW_TAG_structure_type";
12876 case DW_TAG_subroutine_type:
12877 return "DW_TAG_subroutine_type";
12878 case DW_TAG_typedef:
12879 return "DW_TAG_typedef";
12880 case DW_TAG_union_type:
12881 return "DW_TAG_union_type";
12882 case DW_TAG_unspecified_parameters:
12883 return "DW_TAG_unspecified_parameters";
12884 case DW_TAG_variant:
12885 return "DW_TAG_variant";
12886 case DW_TAG_common_block:
12887 return "DW_TAG_common_block";
12888 case DW_TAG_common_inclusion:
12889 return "DW_TAG_common_inclusion";
12890 case DW_TAG_inheritance:
12891 return "DW_TAG_inheritance";
12892 case DW_TAG_inlined_subroutine:
12893 return "DW_TAG_inlined_subroutine";
12894 case DW_TAG_module:
12895 return "DW_TAG_module";
12896 case DW_TAG_ptr_to_member_type:
12897 return "DW_TAG_ptr_to_member_type";
12898 case DW_TAG_set_type:
12899 return "DW_TAG_set_type";
12900 case DW_TAG_subrange_type:
12901 return "DW_TAG_subrange_type";
12902 case DW_TAG_with_stmt:
12903 return "DW_TAG_with_stmt";
12904 case DW_TAG_access_declaration:
12905 return "DW_TAG_access_declaration";
12906 case DW_TAG_base_type:
12907 return "DW_TAG_base_type";
12908 case DW_TAG_catch_block:
12909 return "DW_TAG_catch_block";
12910 case DW_TAG_const_type:
12911 return "DW_TAG_const_type";
12912 case DW_TAG_constant:
12913 return "DW_TAG_constant";
12914 case DW_TAG_enumerator:
12915 return "DW_TAG_enumerator";
12916 case DW_TAG_file_type:
12917 return "DW_TAG_file_type";
12918 case DW_TAG_friend:
12919 return "DW_TAG_friend";
12920 case DW_TAG_namelist:
12921 return "DW_TAG_namelist";
12922 case DW_TAG_namelist_item:
12923 return "DW_TAG_namelist_item";
12924 case DW_TAG_packed_type:
12925 return "DW_TAG_packed_type";
12926 case DW_TAG_subprogram:
12927 return "DW_TAG_subprogram";
12928 case DW_TAG_template_type_param:
12929 return "DW_TAG_template_type_param";
12930 case DW_TAG_template_value_param:
12931 return "DW_TAG_template_value_param";
12932 case DW_TAG_thrown_type:
12933 return "DW_TAG_thrown_type";
12934 case DW_TAG_try_block:
12935 return "DW_TAG_try_block";
12936 case DW_TAG_variant_part:
12937 return "DW_TAG_variant_part";
12938 case DW_TAG_variable:
12939 return "DW_TAG_variable";
12940 case DW_TAG_volatile_type:
12941 return "DW_TAG_volatile_type";
12942 case DW_TAG_dwarf_procedure:
12943 return "DW_TAG_dwarf_procedure";
12944 case DW_TAG_restrict_type:
12945 return "DW_TAG_restrict_type";
12946 case DW_TAG_interface_type:
12947 return "DW_TAG_interface_type";
12948 case DW_TAG_namespace:
12949 return "DW_TAG_namespace";
12950 case DW_TAG_imported_module:
12951 return "DW_TAG_imported_module";
12952 case DW_TAG_unspecified_type:
12953 return "DW_TAG_unspecified_type";
12954 case DW_TAG_partial_unit:
12955 return "DW_TAG_partial_unit";
12956 case DW_TAG_imported_unit:
12957 return "DW_TAG_imported_unit";
12958 case DW_TAG_condition:
12959 return "DW_TAG_condition";
12960 case DW_TAG_shared_type:
12961 return "DW_TAG_shared_type";
12962 case DW_TAG_type_unit:
12963 return "DW_TAG_type_unit";
12964 case DW_TAG_MIPS_loop:
12965 return "DW_TAG_MIPS_loop";
12966 case DW_TAG_HP_array_descriptor:
12967 return "DW_TAG_HP_array_descriptor";
12968 case DW_TAG_format_label:
12969 return "DW_TAG_format_label";
12970 case DW_TAG_function_template:
12971 return "DW_TAG_function_template";
12972 case DW_TAG_class_template:
12973 return "DW_TAG_class_template";
12974 case DW_TAG_GNU_BINCL:
12975 return "DW_TAG_GNU_BINCL";
12976 case DW_TAG_GNU_EINCL:
12977 return "DW_TAG_GNU_EINCL";
12978 case DW_TAG_upc_shared_type:
12979 return "DW_TAG_upc_shared_type";
12980 case DW_TAG_upc_strict_type:
12981 return "DW_TAG_upc_strict_type";
12982 case DW_TAG_upc_relaxed_type:
12983 return "DW_TAG_upc_relaxed_type";
12984 case DW_TAG_PGI_kanji_type:
12985 return "DW_TAG_PGI_kanji_type";
12986 case DW_TAG_PGI_interface_block:
12987 return "DW_TAG_PGI_interface_block";
12988 case DW_TAG_GNU_call_site:
12989 return "DW_TAG_GNU_call_site";
12991 return "DW_TAG_<unknown>";
12995 /* Convert a DWARF attribute code into its string name. */
12998 dwarf_attr_name (unsigned attr)
13002 case DW_AT_sibling:
13003 return "DW_AT_sibling";
13004 case DW_AT_location:
13005 return "DW_AT_location";
13007 return "DW_AT_name";
13008 case DW_AT_ordering:
13009 return "DW_AT_ordering";
13010 case DW_AT_subscr_data:
13011 return "DW_AT_subscr_data";
13012 case DW_AT_byte_size:
13013 return "DW_AT_byte_size";
13014 case DW_AT_bit_offset:
13015 return "DW_AT_bit_offset";
13016 case DW_AT_bit_size:
13017 return "DW_AT_bit_size";
13018 case DW_AT_element_list:
13019 return "DW_AT_element_list";
13020 case DW_AT_stmt_list:
13021 return "DW_AT_stmt_list";
13023 return "DW_AT_low_pc";
13024 case DW_AT_high_pc:
13025 return "DW_AT_high_pc";
13026 case DW_AT_language:
13027 return "DW_AT_language";
13029 return "DW_AT_member";
13031 return "DW_AT_discr";
13032 case DW_AT_discr_value:
13033 return "DW_AT_discr_value";
13034 case DW_AT_visibility:
13035 return "DW_AT_visibility";
13037 return "DW_AT_import";
13038 case DW_AT_string_length:
13039 return "DW_AT_string_length";
13040 case DW_AT_common_reference:
13041 return "DW_AT_common_reference";
13042 case DW_AT_comp_dir:
13043 return "DW_AT_comp_dir";
13044 case DW_AT_const_value:
13045 return "DW_AT_const_value";
13046 case DW_AT_containing_type:
13047 return "DW_AT_containing_type";
13048 case DW_AT_default_value:
13049 return "DW_AT_default_value";
13051 return "DW_AT_inline";
13052 case DW_AT_is_optional:
13053 return "DW_AT_is_optional";
13054 case DW_AT_lower_bound:
13055 return "DW_AT_lower_bound";
13056 case DW_AT_producer:
13057 return "DW_AT_producer";
13058 case DW_AT_prototyped:
13059 return "DW_AT_prototyped";
13060 case DW_AT_return_addr:
13061 return "DW_AT_return_addr";
13062 case DW_AT_start_scope:
13063 return "DW_AT_start_scope";
13064 case DW_AT_bit_stride:
13065 return "DW_AT_bit_stride";
13066 case DW_AT_upper_bound:
13067 return "DW_AT_upper_bound";
13068 case DW_AT_abstract_origin:
13069 return "DW_AT_abstract_origin";
13070 case DW_AT_accessibility:
13071 return "DW_AT_accessibility";
13072 case DW_AT_address_class:
13073 return "DW_AT_address_class";
13074 case DW_AT_artificial:
13075 return "DW_AT_artificial";
13076 case DW_AT_base_types:
13077 return "DW_AT_base_types";
13078 case DW_AT_calling_convention:
13079 return "DW_AT_calling_convention";
13081 return "DW_AT_count";
13082 case DW_AT_data_member_location:
13083 return "DW_AT_data_member_location";
13084 case DW_AT_decl_column:
13085 return "DW_AT_decl_column";
13086 case DW_AT_decl_file:
13087 return "DW_AT_decl_file";
13088 case DW_AT_decl_line:
13089 return "DW_AT_decl_line";
13090 case DW_AT_declaration:
13091 return "DW_AT_declaration";
13092 case DW_AT_discr_list:
13093 return "DW_AT_discr_list";
13094 case DW_AT_encoding:
13095 return "DW_AT_encoding";
13096 case DW_AT_external:
13097 return "DW_AT_external";
13098 case DW_AT_frame_base:
13099 return "DW_AT_frame_base";
13101 return "DW_AT_friend";
13102 case DW_AT_identifier_case:
13103 return "DW_AT_identifier_case";
13104 case DW_AT_macro_info:
13105 return "DW_AT_macro_info";
13106 case DW_AT_namelist_items:
13107 return "DW_AT_namelist_items";
13108 case DW_AT_priority:
13109 return "DW_AT_priority";
13110 case DW_AT_segment:
13111 return "DW_AT_segment";
13112 case DW_AT_specification:
13113 return "DW_AT_specification";
13114 case DW_AT_static_link:
13115 return "DW_AT_static_link";
13117 return "DW_AT_type";
13118 case DW_AT_use_location:
13119 return "DW_AT_use_location";
13120 case DW_AT_variable_parameter:
13121 return "DW_AT_variable_parameter";
13122 case DW_AT_virtuality:
13123 return "DW_AT_virtuality";
13124 case DW_AT_vtable_elem_location:
13125 return "DW_AT_vtable_elem_location";
13126 /* DWARF 3 values. */
13127 case DW_AT_allocated:
13128 return "DW_AT_allocated";
13129 case DW_AT_associated:
13130 return "DW_AT_associated";
13131 case DW_AT_data_location:
13132 return "DW_AT_data_location";
13133 case DW_AT_byte_stride:
13134 return "DW_AT_byte_stride";
13135 case DW_AT_entry_pc:
13136 return "DW_AT_entry_pc";
13137 case DW_AT_use_UTF8:
13138 return "DW_AT_use_UTF8";
13139 case DW_AT_extension:
13140 return "DW_AT_extension";
13142 return "DW_AT_ranges";
13143 case DW_AT_trampoline:
13144 return "DW_AT_trampoline";
13145 case DW_AT_call_column:
13146 return "DW_AT_call_column";
13147 case DW_AT_call_file:
13148 return "DW_AT_call_file";
13149 case DW_AT_call_line:
13150 return "DW_AT_call_line";
13151 case DW_AT_description:
13152 return "DW_AT_description";
13153 case DW_AT_binary_scale:
13154 return "DW_AT_binary_scale";
13155 case DW_AT_decimal_scale:
13156 return "DW_AT_decimal_scale";
13158 return "DW_AT_small";
13159 case DW_AT_decimal_sign:
13160 return "DW_AT_decimal_sign";
13161 case DW_AT_digit_count:
13162 return "DW_AT_digit_count";
13163 case DW_AT_picture_string:
13164 return "DW_AT_picture_string";
13165 case DW_AT_mutable:
13166 return "DW_AT_mutable";
13167 case DW_AT_threads_scaled:
13168 return "DW_AT_threads_scaled";
13169 case DW_AT_explicit:
13170 return "DW_AT_explicit";
13171 case DW_AT_object_pointer:
13172 return "DW_AT_object_pointer";
13173 case DW_AT_endianity:
13174 return "DW_AT_endianity";
13175 case DW_AT_elemental:
13176 return "DW_AT_elemental";
13178 return "DW_AT_pure";
13179 case DW_AT_recursive:
13180 return "DW_AT_recursive";
13181 /* DWARF 4 values. */
13182 case DW_AT_signature:
13183 return "DW_AT_signature";
13184 case DW_AT_linkage_name:
13185 return "DW_AT_linkage_name";
13186 /* SGI/MIPS extensions. */
13187 #ifdef MIPS /* collides with DW_AT_HP_block_index */
13188 case DW_AT_MIPS_fde:
13189 return "DW_AT_MIPS_fde";
13191 case DW_AT_MIPS_loop_begin:
13192 return "DW_AT_MIPS_loop_begin";
13193 case DW_AT_MIPS_tail_loop_begin:
13194 return "DW_AT_MIPS_tail_loop_begin";
13195 case DW_AT_MIPS_epilog_begin:
13196 return "DW_AT_MIPS_epilog_begin";
13197 case DW_AT_MIPS_loop_unroll_factor:
13198 return "DW_AT_MIPS_loop_unroll_factor";
13199 case DW_AT_MIPS_software_pipeline_depth:
13200 return "DW_AT_MIPS_software_pipeline_depth";
13201 case DW_AT_MIPS_linkage_name:
13202 return "DW_AT_MIPS_linkage_name";
13203 case DW_AT_MIPS_stride:
13204 return "DW_AT_MIPS_stride";
13205 case DW_AT_MIPS_abstract_name:
13206 return "DW_AT_MIPS_abstract_name";
13207 case DW_AT_MIPS_clone_origin:
13208 return "DW_AT_MIPS_clone_origin";
13209 case DW_AT_MIPS_has_inlines:
13210 return "DW_AT_MIPS_has_inlines";
13211 /* HP extensions. */
13212 #ifndef MIPS /* collides with DW_AT_MIPS_fde */
13213 case DW_AT_HP_block_index:
13214 return "DW_AT_HP_block_index";
13216 case DW_AT_HP_unmodifiable:
13217 return "DW_AT_HP_unmodifiable";
13218 case DW_AT_HP_actuals_stmt_list:
13219 return "DW_AT_HP_actuals_stmt_list";
13220 case DW_AT_HP_proc_per_section:
13221 return "DW_AT_HP_proc_per_section";
13222 case DW_AT_HP_raw_data_ptr:
13223 return "DW_AT_HP_raw_data_ptr";
13224 case DW_AT_HP_pass_by_reference:
13225 return "DW_AT_HP_pass_by_reference";
13226 case DW_AT_HP_opt_level:
13227 return "DW_AT_HP_opt_level";
13228 case DW_AT_HP_prof_version_id:
13229 return "DW_AT_HP_prof_version_id";
13230 case DW_AT_HP_opt_flags:
13231 return "DW_AT_HP_opt_flags";
13232 case DW_AT_HP_cold_region_low_pc:
13233 return "DW_AT_HP_cold_region_low_pc";
13234 case DW_AT_HP_cold_region_high_pc:
13235 return "DW_AT_HP_cold_region_high_pc";
13236 case DW_AT_HP_all_variables_modifiable:
13237 return "DW_AT_HP_all_variables_modifiable";
13238 case DW_AT_HP_linkage_name:
13239 return "DW_AT_HP_linkage_name";
13240 case DW_AT_HP_prof_flags:
13241 return "DW_AT_HP_prof_flags";
13242 /* GNU extensions. */
13243 case DW_AT_sf_names:
13244 return "DW_AT_sf_names";
13245 case DW_AT_src_info:
13246 return "DW_AT_src_info";
13247 case DW_AT_mac_info:
13248 return "DW_AT_mac_info";
13249 case DW_AT_src_coords:
13250 return "DW_AT_src_coords";
13251 case DW_AT_body_begin:
13252 return "DW_AT_body_begin";
13253 case DW_AT_body_end:
13254 return "DW_AT_body_end";
13255 case DW_AT_GNU_vector:
13256 return "DW_AT_GNU_vector";
13257 case DW_AT_GNU_odr_signature:
13258 return "DW_AT_GNU_odr_signature";
13259 /* VMS extensions. */
13260 case DW_AT_VMS_rtnbeg_pd_address:
13261 return "DW_AT_VMS_rtnbeg_pd_address";
13262 /* UPC extension. */
13263 case DW_AT_upc_threads_scaled:
13264 return "DW_AT_upc_threads_scaled";
13265 /* PGI (STMicroelectronics) extensions. */
13266 case DW_AT_PGI_lbase:
13267 return "DW_AT_PGI_lbase";
13268 case DW_AT_PGI_soffset:
13269 return "DW_AT_PGI_soffset";
13270 case DW_AT_PGI_lstride:
13271 return "DW_AT_PGI_lstride";
13273 return "DW_AT_<unknown>";
13277 /* Convert a DWARF value form code into its string name. */
13280 dwarf_form_name (unsigned form)
13285 return "DW_FORM_addr";
13286 case DW_FORM_block2:
13287 return "DW_FORM_block2";
13288 case DW_FORM_block4:
13289 return "DW_FORM_block4";
13290 case DW_FORM_data2:
13291 return "DW_FORM_data2";
13292 case DW_FORM_data4:
13293 return "DW_FORM_data4";
13294 case DW_FORM_data8:
13295 return "DW_FORM_data8";
13296 case DW_FORM_string:
13297 return "DW_FORM_string";
13298 case DW_FORM_block:
13299 return "DW_FORM_block";
13300 case DW_FORM_block1:
13301 return "DW_FORM_block1";
13302 case DW_FORM_data1:
13303 return "DW_FORM_data1";
13305 return "DW_FORM_flag";
13306 case DW_FORM_sdata:
13307 return "DW_FORM_sdata";
13309 return "DW_FORM_strp";
13310 case DW_FORM_udata:
13311 return "DW_FORM_udata";
13312 case DW_FORM_ref_addr:
13313 return "DW_FORM_ref_addr";
13315 return "DW_FORM_ref1";
13317 return "DW_FORM_ref2";
13319 return "DW_FORM_ref4";
13321 return "DW_FORM_ref8";
13322 case DW_FORM_ref_udata:
13323 return "DW_FORM_ref_udata";
13324 case DW_FORM_indirect:
13325 return "DW_FORM_indirect";
13326 case DW_FORM_sec_offset:
13327 return "DW_FORM_sec_offset";
13328 case DW_FORM_exprloc:
13329 return "DW_FORM_exprloc";
13330 case DW_FORM_flag_present:
13331 return "DW_FORM_flag_present";
13332 case DW_FORM_ref_sig8:
13333 return "DW_FORM_ref_sig8";
13335 return "DW_FORM_<unknown>";
13339 /* Convert a DWARF stack opcode into its string name. */
13342 dwarf_stack_op_name (unsigned op)
13347 return "DW_OP_addr";
13349 return "DW_OP_deref";
13350 case DW_OP_const1u:
13351 return "DW_OP_const1u";
13352 case DW_OP_const1s:
13353 return "DW_OP_const1s";
13354 case DW_OP_const2u:
13355 return "DW_OP_const2u";
13356 case DW_OP_const2s:
13357 return "DW_OP_const2s";
13358 case DW_OP_const4u:
13359 return "DW_OP_const4u";
13360 case DW_OP_const4s:
13361 return "DW_OP_const4s";
13362 case DW_OP_const8u:
13363 return "DW_OP_const8u";
13364 case DW_OP_const8s:
13365 return "DW_OP_const8s";
13367 return "DW_OP_constu";
13369 return "DW_OP_consts";
13371 return "DW_OP_dup";
13373 return "DW_OP_drop";
13375 return "DW_OP_over";
13377 return "DW_OP_pick";
13379 return "DW_OP_swap";
13381 return "DW_OP_rot";
13383 return "DW_OP_xderef";
13385 return "DW_OP_abs";
13387 return "DW_OP_and";
13389 return "DW_OP_div";
13391 return "DW_OP_minus";
13393 return "DW_OP_mod";
13395 return "DW_OP_mul";
13397 return "DW_OP_neg";
13399 return "DW_OP_not";
13403 return "DW_OP_plus";
13404 case DW_OP_plus_uconst:
13405 return "DW_OP_plus_uconst";
13407 return "DW_OP_shl";
13409 return "DW_OP_shr";
13411 return "DW_OP_shra";
13413 return "DW_OP_xor";
13415 return "DW_OP_bra";
13429 return "DW_OP_skip";
13431 return "DW_OP_lit0";
13433 return "DW_OP_lit1";
13435 return "DW_OP_lit2";
13437 return "DW_OP_lit3";
13439 return "DW_OP_lit4";
13441 return "DW_OP_lit5";
13443 return "DW_OP_lit6";
13445 return "DW_OP_lit7";
13447 return "DW_OP_lit8";
13449 return "DW_OP_lit9";
13451 return "DW_OP_lit10";
13453 return "DW_OP_lit11";
13455 return "DW_OP_lit12";
13457 return "DW_OP_lit13";
13459 return "DW_OP_lit14";
13461 return "DW_OP_lit15";
13463 return "DW_OP_lit16";
13465 return "DW_OP_lit17";
13467 return "DW_OP_lit18";
13469 return "DW_OP_lit19";
13471 return "DW_OP_lit20";
13473 return "DW_OP_lit21";
13475 return "DW_OP_lit22";
13477 return "DW_OP_lit23";
13479 return "DW_OP_lit24";
13481 return "DW_OP_lit25";
13483 return "DW_OP_lit26";
13485 return "DW_OP_lit27";
13487 return "DW_OP_lit28";
13489 return "DW_OP_lit29";
13491 return "DW_OP_lit30";
13493 return "DW_OP_lit31";
13495 return "DW_OP_reg0";
13497 return "DW_OP_reg1";
13499 return "DW_OP_reg2";
13501 return "DW_OP_reg3";
13503 return "DW_OP_reg4";
13505 return "DW_OP_reg5";
13507 return "DW_OP_reg6";
13509 return "DW_OP_reg7";
13511 return "DW_OP_reg8";
13513 return "DW_OP_reg9";
13515 return "DW_OP_reg10";
13517 return "DW_OP_reg11";
13519 return "DW_OP_reg12";
13521 return "DW_OP_reg13";
13523 return "DW_OP_reg14";
13525 return "DW_OP_reg15";
13527 return "DW_OP_reg16";
13529 return "DW_OP_reg17";
13531 return "DW_OP_reg18";
13533 return "DW_OP_reg19";
13535 return "DW_OP_reg20";
13537 return "DW_OP_reg21";
13539 return "DW_OP_reg22";
13541 return "DW_OP_reg23";
13543 return "DW_OP_reg24";
13545 return "DW_OP_reg25";
13547 return "DW_OP_reg26";
13549 return "DW_OP_reg27";
13551 return "DW_OP_reg28";
13553 return "DW_OP_reg29";
13555 return "DW_OP_reg30";
13557 return "DW_OP_reg31";
13559 return "DW_OP_breg0";
13561 return "DW_OP_breg1";
13563 return "DW_OP_breg2";
13565 return "DW_OP_breg3";
13567 return "DW_OP_breg4";
13569 return "DW_OP_breg5";
13571 return "DW_OP_breg6";
13573 return "DW_OP_breg7";
13575 return "DW_OP_breg8";
13577 return "DW_OP_breg9";
13579 return "DW_OP_breg10";
13581 return "DW_OP_breg11";
13583 return "DW_OP_breg12";
13585 return "DW_OP_breg13";
13587 return "DW_OP_breg14";
13589 return "DW_OP_breg15";
13591 return "DW_OP_breg16";
13593 return "DW_OP_breg17";
13595 return "DW_OP_breg18";
13597 return "DW_OP_breg19";
13599 return "DW_OP_breg20";
13601 return "DW_OP_breg21";
13603 return "DW_OP_breg22";
13605 return "DW_OP_breg23";
13607 return "DW_OP_breg24";
13609 return "DW_OP_breg25";
13611 return "DW_OP_breg26";
13613 return "DW_OP_breg27";
13615 return "DW_OP_breg28";
13617 return "DW_OP_breg29";
13619 return "DW_OP_breg30";
13621 return "DW_OP_breg31";
13623 return "DW_OP_regx";
13625 return "DW_OP_fbreg";
13627 return "DW_OP_bregx";
13629 return "DW_OP_piece";
13630 case DW_OP_deref_size:
13631 return "DW_OP_deref_size";
13632 case DW_OP_xderef_size:
13633 return "DW_OP_xderef_size";
13635 return "DW_OP_nop";
13636 /* DWARF 3 extensions. */
13637 case DW_OP_push_object_address:
13638 return "DW_OP_push_object_address";
13640 return "DW_OP_call2";
13642 return "DW_OP_call4";
13643 case DW_OP_call_ref:
13644 return "DW_OP_call_ref";
13645 case DW_OP_form_tls_address:
13646 return "DW_OP_form_tls_address";
13647 case DW_OP_call_frame_cfa:
13648 return "DW_OP_call_frame_cfa";
13649 case DW_OP_bit_piece:
13650 return "DW_OP_bit_piece";
13651 /* DWARF 4 extensions. */
13652 case DW_OP_implicit_value:
13653 return "DW_OP_implicit_value";
13654 case DW_OP_stack_value:
13655 return "DW_OP_stack_value";
13656 /* GNU extensions. */
13657 case DW_OP_GNU_push_tls_address:
13658 return "DW_OP_GNU_push_tls_address";
13659 case DW_OP_GNU_uninit:
13660 return "DW_OP_GNU_uninit";
13661 case DW_OP_GNU_implicit_pointer:
13662 return "DW_OP_GNU_implicit_pointer";
13663 case DW_OP_GNU_entry_value:
13664 return "DW_OP_GNU_entry_value";
13665 case DW_OP_GNU_const_type:
13666 return "DW_OP_GNU_const_type";
13667 case DW_OP_GNU_regval_type:
13668 return "DW_OP_GNU_regval_type";
13669 case DW_OP_GNU_deref_type:
13670 return "DW_OP_GNU_deref_type";
13671 case DW_OP_GNU_convert:
13672 return "DW_OP_GNU_convert";
13673 case DW_OP_GNU_reinterpret:
13674 return "DW_OP_GNU_reinterpret";
13681 dwarf_bool_name (unsigned mybool)
13689 /* Convert a DWARF type code into its string name. */
13692 dwarf_type_encoding_name (unsigned enc)
13697 return "DW_ATE_void";
13698 case DW_ATE_address:
13699 return "DW_ATE_address";
13700 case DW_ATE_boolean:
13701 return "DW_ATE_boolean";
13702 case DW_ATE_complex_float:
13703 return "DW_ATE_complex_float";
13705 return "DW_ATE_float";
13706 case DW_ATE_signed:
13707 return "DW_ATE_signed";
13708 case DW_ATE_signed_char:
13709 return "DW_ATE_signed_char";
13710 case DW_ATE_unsigned:
13711 return "DW_ATE_unsigned";
13712 case DW_ATE_unsigned_char:
13713 return "DW_ATE_unsigned_char";
13715 case DW_ATE_imaginary_float:
13716 return "DW_ATE_imaginary_float";
13717 case DW_ATE_packed_decimal:
13718 return "DW_ATE_packed_decimal";
13719 case DW_ATE_numeric_string:
13720 return "DW_ATE_numeric_string";
13721 case DW_ATE_edited:
13722 return "DW_ATE_edited";
13723 case DW_ATE_signed_fixed:
13724 return "DW_ATE_signed_fixed";
13725 case DW_ATE_unsigned_fixed:
13726 return "DW_ATE_unsigned_fixed";
13727 case DW_ATE_decimal_float:
13728 return "DW_ATE_decimal_float";
13731 return "DW_ATE_UTF";
13732 /* HP extensions. */
13733 case DW_ATE_HP_float80:
13734 return "DW_ATE_HP_float80";
13735 case DW_ATE_HP_complex_float80:
13736 return "DW_ATE_HP_complex_float80";
13737 case DW_ATE_HP_float128:
13738 return "DW_ATE_HP_float128";
13739 case DW_ATE_HP_complex_float128:
13740 return "DW_ATE_HP_complex_float128";
13741 case DW_ATE_HP_floathpintel:
13742 return "DW_ATE_HP_floathpintel";
13743 case DW_ATE_HP_imaginary_float80:
13744 return "DW_ATE_HP_imaginary_float80";
13745 case DW_ATE_HP_imaginary_float128:
13746 return "DW_ATE_HP_imaginary_float128";
13748 return "DW_ATE_<unknown>";
13752 /* Convert a DWARF call frame info operation to its string name. */
13756 dwarf_cfi_name (unsigned cfi_opc)
13760 case DW_CFA_advance_loc:
13761 return "DW_CFA_advance_loc";
13762 case DW_CFA_offset:
13763 return "DW_CFA_offset";
13764 case DW_CFA_restore:
13765 return "DW_CFA_restore";
13767 return "DW_CFA_nop";
13768 case DW_CFA_set_loc:
13769 return "DW_CFA_set_loc";
13770 case DW_CFA_advance_loc1:
13771 return "DW_CFA_advance_loc1";
13772 case DW_CFA_advance_loc2:
13773 return "DW_CFA_advance_loc2";
13774 case DW_CFA_advance_loc4:
13775 return "DW_CFA_advance_loc4";
13776 case DW_CFA_offset_extended:
13777 return "DW_CFA_offset_extended";
13778 case DW_CFA_restore_extended:
13779 return "DW_CFA_restore_extended";
13780 case DW_CFA_undefined:
13781 return "DW_CFA_undefined";
13782 case DW_CFA_same_value:
13783 return "DW_CFA_same_value";
13784 case DW_CFA_register:
13785 return "DW_CFA_register";
13786 case DW_CFA_remember_state:
13787 return "DW_CFA_remember_state";
13788 case DW_CFA_restore_state:
13789 return "DW_CFA_restore_state";
13790 case DW_CFA_def_cfa:
13791 return "DW_CFA_def_cfa";
13792 case DW_CFA_def_cfa_register:
13793 return "DW_CFA_def_cfa_register";
13794 case DW_CFA_def_cfa_offset:
13795 return "DW_CFA_def_cfa_offset";
13797 case DW_CFA_def_cfa_expression:
13798 return "DW_CFA_def_cfa_expression";
13799 case DW_CFA_expression:
13800 return "DW_CFA_expression";
13801 case DW_CFA_offset_extended_sf:
13802 return "DW_CFA_offset_extended_sf";
13803 case DW_CFA_def_cfa_sf:
13804 return "DW_CFA_def_cfa_sf";
13805 case DW_CFA_def_cfa_offset_sf:
13806 return "DW_CFA_def_cfa_offset_sf";
13807 case DW_CFA_val_offset:
13808 return "DW_CFA_val_offset";
13809 case DW_CFA_val_offset_sf:
13810 return "DW_CFA_val_offset_sf";
13811 case DW_CFA_val_expression:
13812 return "DW_CFA_val_expression";
13813 /* SGI/MIPS specific. */
13814 case DW_CFA_MIPS_advance_loc8:
13815 return "DW_CFA_MIPS_advance_loc8";
13816 /* GNU extensions. */
13817 case DW_CFA_GNU_window_save:
13818 return "DW_CFA_GNU_window_save";
13819 case DW_CFA_GNU_args_size:
13820 return "DW_CFA_GNU_args_size";
13821 case DW_CFA_GNU_negative_offset_extended:
13822 return "DW_CFA_GNU_negative_offset_extended";
13824 return "DW_CFA_<unknown>";
13830 dump_die_shallow (struct ui_file *f, int indent, struct die_info *die)
13834 print_spaces (indent, f);
13835 fprintf_unfiltered (f, "Die: %s (abbrev %d, offset 0x%x)\n",
13836 dwarf_tag_name (die->tag), die->abbrev, die->offset);
13838 if (die->parent != NULL)
13840 print_spaces (indent, f);
13841 fprintf_unfiltered (f, " parent at offset: 0x%x\n",
13842 die->parent->offset);
13845 print_spaces (indent, f);
13846 fprintf_unfiltered (f, " has children: %s\n",
13847 dwarf_bool_name (die->child != NULL));
13849 print_spaces (indent, f);
13850 fprintf_unfiltered (f, " attributes:\n");
13852 for (i = 0; i < die->num_attrs; ++i)
13854 print_spaces (indent, f);
13855 fprintf_unfiltered (f, " %s (%s) ",
13856 dwarf_attr_name (die->attrs[i].name),
13857 dwarf_form_name (die->attrs[i].form));
13859 switch (die->attrs[i].form)
13861 case DW_FORM_ref_addr:
13863 fprintf_unfiltered (f, "address: ");
13864 fputs_filtered (hex_string (DW_ADDR (&die->attrs[i])), f);
13866 case DW_FORM_block2:
13867 case DW_FORM_block4:
13868 case DW_FORM_block:
13869 case DW_FORM_block1:
13870 fprintf_unfiltered (f, "block: size %d",
13871 DW_BLOCK (&die->attrs[i])->size);
13873 case DW_FORM_exprloc:
13874 fprintf_unfiltered (f, "expression: size %u",
13875 DW_BLOCK (&die->attrs[i])->size);
13880 fprintf_unfiltered (f, "constant ref: 0x%lx (adjusted)",
13881 (long) (DW_ADDR (&die->attrs[i])));
13883 case DW_FORM_data1:
13884 case DW_FORM_data2:
13885 case DW_FORM_data4:
13886 case DW_FORM_data8:
13887 case DW_FORM_udata:
13888 case DW_FORM_sdata:
13889 fprintf_unfiltered (f, "constant: %s",
13890 pulongest (DW_UNSND (&die->attrs[i])));
13892 case DW_FORM_sec_offset:
13893 fprintf_unfiltered (f, "section offset: %s",
13894 pulongest (DW_UNSND (&die->attrs[i])));
13896 case DW_FORM_ref_sig8:
13897 if (DW_SIGNATURED_TYPE (&die->attrs[i]) != NULL)
13898 fprintf_unfiltered (f, "signatured type, offset: 0x%x",
13899 DW_SIGNATURED_TYPE (&die->attrs[i])->per_cu.offset);
13901 fprintf_unfiltered (f, "signatured type, offset: unknown");
13903 case DW_FORM_string:
13905 fprintf_unfiltered (f, "string: \"%s\" (%s canonicalized)",
13906 DW_STRING (&die->attrs[i])
13907 ? DW_STRING (&die->attrs[i]) : "",
13908 DW_STRING_IS_CANONICAL (&die->attrs[i]) ? "is" : "not");
13911 if (DW_UNSND (&die->attrs[i]))
13912 fprintf_unfiltered (f, "flag: TRUE");
13914 fprintf_unfiltered (f, "flag: FALSE");
13916 case DW_FORM_flag_present:
13917 fprintf_unfiltered (f, "flag: TRUE");
13919 case DW_FORM_indirect:
13920 /* The reader will have reduced the indirect form to
13921 the "base form" so this form should not occur. */
13922 fprintf_unfiltered (f,
13923 "unexpected attribute form: DW_FORM_indirect");
13926 fprintf_unfiltered (f, "unsupported attribute form: %d.",
13927 die->attrs[i].form);
13930 fprintf_unfiltered (f, "\n");
13935 dump_die_for_error (struct die_info *die)
13937 dump_die_shallow (gdb_stderr, 0, die);
13941 dump_die_1 (struct ui_file *f, int level, int max_level, struct die_info *die)
13943 int indent = level * 4;
13945 gdb_assert (die != NULL);
13947 if (level >= max_level)
13950 dump_die_shallow (f, indent, die);
13952 if (die->child != NULL)
13954 print_spaces (indent, f);
13955 fprintf_unfiltered (f, " Children:");
13956 if (level + 1 < max_level)
13958 fprintf_unfiltered (f, "\n");
13959 dump_die_1 (f, level + 1, max_level, die->child);
13963 fprintf_unfiltered (f,
13964 " [not printed, max nesting level reached]\n");
13968 if (die->sibling != NULL && level > 0)
13970 dump_die_1 (f, level, max_level, die->sibling);
13974 /* This is called from the pdie macro in gdbinit.in.
13975 It's not static so gcc will keep a copy callable from gdb. */
13978 dump_die (struct die_info *die, int max_level)
13980 dump_die_1 (gdb_stdlog, 0, max_level, die);
13984 store_in_ref_table (struct die_info *die, struct dwarf2_cu *cu)
13988 slot = htab_find_slot_with_hash (cu->die_hash, die, die->offset, INSERT);
13994 is_ref_attr (struct attribute *attr)
13996 switch (attr->form)
13998 case DW_FORM_ref_addr:
14003 case DW_FORM_ref_udata:
14010 static unsigned int
14011 dwarf2_get_ref_die_offset (struct attribute *attr)
14013 if (is_ref_attr (attr))
14014 return DW_ADDR (attr);
14016 complaint (&symfile_complaints,
14017 _("unsupported die ref attribute form: '%s'"),
14018 dwarf_form_name (attr->form));
14022 /* Return the constant value held by ATTR. Return DEFAULT_VALUE if
14023 * the value held by the attribute is not constant. */
14026 dwarf2_get_attr_constant_value (struct attribute *attr, int default_value)
14028 if (attr->form == DW_FORM_sdata)
14029 return DW_SND (attr);
14030 else if (attr->form == DW_FORM_udata
14031 || attr->form == DW_FORM_data1
14032 || attr->form == DW_FORM_data2
14033 || attr->form == DW_FORM_data4
14034 || attr->form == DW_FORM_data8)
14035 return DW_UNSND (attr);
14038 complaint (&symfile_complaints,
14039 _("Attribute value is not a constant (%s)"),
14040 dwarf_form_name (attr->form));
14041 return default_value;
14045 /* THIS_CU has a reference to PER_CU. If necessary, load the new compilation
14046 unit and add it to our queue.
14047 The result is non-zero if PER_CU was queued, otherwise the result is zero
14048 meaning either PER_CU is already queued or it is already loaded. */
14051 maybe_queue_comp_unit (struct dwarf2_cu *this_cu,
14052 struct dwarf2_per_cu_data *per_cu)
14054 /* We may arrive here during partial symbol reading, if we need full
14055 DIEs to process an unusual case (e.g. template arguments). Do
14056 not queue PER_CU, just tell our caller to load its DIEs. */
14057 if (dwarf2_per_objfile->reading_partial_symbols)
14059 if (per_cu->cu == NULL || per_cu->cu->dies == NULL)
14064 /* Mark the dependence relation so that we don't flush PER_CU
14066 dwarf2_add_dependence (this_cu, per_cu);
14068 /* If it's already on the queue, we have nothing to do. */
14069 if (per_cu->queued)
14072 /* If the compilation unit is already loaded, just mark it as
14074 if (per_cu->cu != NULL)
14076 per_cu->cu->last_used = 0;
14080 /* Add it to the queue. */
14081 queue_comp_unit (per_cu);
14086 /* Follow reference or signature attribute ATTR of SRC_DIE.
14087 On entry *REF_CU is the CU of SRC_DIE.
14088 On exit *REF_CU is the CU of the result. */
14090 static struct die_info *
14091 follow_die_ref_or_sig (struct die_info *src_die, struct attribute *attr,
14092 struct dwarf2_cu **ref_cu)
14094 struct die_info *die;
14096 if (is_ref_attr (attr))
14097 die = follow_die_ref (src_die, attr, ref_cu);
14098 else if (attr->form == DW_FORM_ref_sig8)
14099 die = follow_die_sig (src_die, attr, ref_cu);
14102 dump_die_for_error (src_die);
14103 error (_("Dwarf Error: Expected reference attribute [in module %s]"),
14104 (*ref_cu)->objfile->name);
14110 /* Follow reference OFFSET.
14111 On entry *REF_CU is the CU of the source die referencing OFFSET.
14112 On exit *REF_CU is the CU of the result.
14113 Returns NULL if OFFSET is invalid. */
14115 static struct die_info *
14116 follow_die_offset (unsigned int offset, struct dwarf2_cu **ref_cu)
14118 struct die_info temp_die;
14119 struct dwarf2_cu *target_cu, *cu = *ref_cu;
14121 gdb_assert (cu->per_cu != NULL);
14125 if (cu->per_cu->debug_types_section)
14127 /* .debug_types CUs cannot reference anything outside their CU.
14128 If they need to, they have to reference a signatured type via
14129 DW_FORM_ref_sig8. */
14130 if (! offset_in_cu_p (&cu->header, offset))
14133 else if (! offset_in_cu_p (&cu->header, offset))
14135 struct dwarf2_per_cu_data *per_cu;
14137 per_cu = dwarf2_find_containing_comp_unit (offset, cu->objfile);
14139 /* If necessary, add it to the queue and load its DIEs. */
14140 if (maybe_queue_comp_unit (cu, per_cu))
14141 load_full_comp_unit (per_cu);
14143 target_cu = per_cu->cu;
14145 else if (cu->dies == NULL)
14147 /* We're loading full DIEs during partial symbol reading. */
14148 gdb_assert (dwarf2_per_objfile->reading_partial_symbols);
14149 load_full_comp_unit (cu->per_cu);
14152 *ref_cu = target_cu;
14153 temp_die.offset = offset;
14154 return htab_find_with_hash (target_cu->die_hash, &temp_die, offset);
14157 /* Follow reference attribute ATTR of SRC_DIE.
14158 On entry *REF_CU is the CU of SRC_DIE.
14159 On exit *REF_CU is the CU of the result. */
14161 static struct die_info *
14162 follow_die_ref (struct die_info *src_die, struct attribute *attr,
14163 struct dwarf2_cu **ref_cu)
14165 unsigned int offset = dwarf2_get_ref_die_offset (attr);
14166 struct dwarf2_cu *cu = *ref_cu;
14167 struct die_info *die;
14169 die = follow_die_offset (offset, ref_cu);
14171 error (_("Dwarf Error: Cannot find DIE at 0x%x referenced from DIE "
14172 "at 0x%x [in module %s]"),
14173 offset, src_die->offset, cu->objfile->name);
14178 /* Return DWARF block referenced by DW_AT_location of DIE at OFFSET at PER_CU.
14179 Returned value is intended for DW_OP_call*. Returned
14180 dwarf2_locexpr_baton->data has lifetime of PER_CU->OBJFILE. */
14182 struct dwarf2_locexpr_baton
14183 dwarf2_fetch_die_location_block (unsigned int offset,
14184 struct dwarf2_per_cu_data *per_cu,
14185 CORE_ADDR (*get_frame_pc) (void *baton),
14188 struct dwarf2_cu *cu;
14189 struct die_info *die;
14190 struct attribute *attr;
14191 struct dwarf2_locexpr_baton retval;
14193 dw2_setup (per_cu->objfile);
14195 if (per_cu->cu == NULL)
14199 die = follow_die_offset (offset, &cu);
14201 error (_("Dwarf Error: Cannot find DIE at 0x%x referenced in module %s"),
14202 offset, per_cu->objfile->name);
14204 attr = dwarf2_attr (die, DW_AT_location, cu);
14207 /* DWARF: "If there is no such attribute, then there is no effect.".
14208 DATA is ignored if SIZE is 0. */
14210 retval.data = NULL;
14213 else if (attr_form_is_section_offset (attr))
14215 struct dwarf2_loclist_baton loclist_baton;
14216 CORE_ADDR pc = (*get_frame_pc) (baton);
14219 fill_in_loclist_baton (cu, &loclist_baton, attr);
14221 retval.data = dwarf2_find_location_expression (&loclist_baton,
14223 retval.size = size;
14227 if (!attr_form_is_block (attr))
14228 error (_("Dwarf Error: DIE at 0x%x referenced in module %s "
14229 "is neither DW_FORM_block* nor DW_FORM_exprloc"),
14230 offset, per_cu->objfile->name);
14232 retval.data = DW_BLOCK (attr)->data;
14233 retval.size = DW_BLOCK (attr)->size;
14235 retval.per_cu = cu->per_cu;
14237 age_cached_comp_units ();
14242 /* Return the type of the DIE at DIE_OFFSET in the CU named by
14246 dwarf2_get_die_type (unsigned int die_offset,
14247 struct dwarf2_per_cu_data *per_cu)
14249 dw2_setup (per_cu->objfile);
14250 return get_die_type_at_offset (die_offset, per_cu);
14253 /* Follow the signature attribute ATTR in SRC_DIE.
14254 On entry *REF_CU is the CU of SRC_DIE.
14255 On exit *REF_CU is the CU of the result. */
14257 static struct die_info *
14258 follow_die_sig (struct die_info *src_die, struct attribute *attr,
14259 struct dwarf2_cu **ref_cu)
14261 struct objfile *objfile = (*ref_cu)->objfile;
14262 struct die_info temp_die;
14263 struct signatured_type *sig_type = DW_SIGNATURED_TYPE (attr);
14264 struct dwarf2_cu *sig_cu;
14265 struct die_info *die;
14267 /* sig_type will be NULL if the signatured type is missing from
14269 if (sig_type == NULL)
14270 error (_("Dwarf Error: Cannot find signatured DIE referenced from DIE "
14271 "at 0x%x [in module %s]"),
14272 src_die->offset, objfile->name);
14274 /* If necessary, add it to the queue and load its DIEs. */
14276 if (maybe_queue_comp_unit (*ref_cu, &sig_type->per_cu))
14277 read_signatured_type (sig_type);
14279 gdb_assert (sig_type->per_cu.cu != NULL);
14281 sig_cu = sig_type->per_cu.cu;
14282 temp_die.offset = sig_cu->header.offset + sig_type->type_offset;
14283 die = htab_find_with_hash (sig_cu->die_hash, &temp_die, temp_die.offset);
14290 error (_("Dwarf Error: Cannot find signatured DIE at 0x%x referenced "
14291 "from DIE at 0x%x [in module %s]"),
14292 sig_type->type_offset, src_die->offset, objfile->name);
14295 /* Given an offset of a signatured type, return its signatured_type. */
14297 static struct signatured_type *
14298 lookup_signatured_type_at_offset (struct objfile *objfile,
14299 struct dwarf2_section_info *section,
14300 unsigned int offset)
14302 gdb_byte *info_ptr = section->buffer + offset;
14303 unsigned int length, initial_length_size;
14304 unsigned int sig_offset;
14305 struct signatured_type find_entry, *type_sig;
14307 length = read_initial_length (objfile->obfd, info_ptr, &initial_length_size);
14308 sig_offset = (initial_length_size
14310 + (initial_length_size == 4 ? 4 : 8) /*debug_abbrev_offset*/
14311 + 1 /*address_size*/);
14312 find_entry.signature = bfd_get_64 (objfile->obfd, info_ptr + sig_offset);
14313 type_sig = htab_find (dwarf2_per_objfile->signatured_types, &find_entry);
14315 /* This is only used to lookup previously recorded types.
14316 If we didn't find it, it's our bug. */
14317 gdb_assert (type_sig != NULL);
14318 gdb_assert (offset == type_sig->per_cu.offset);
14323 /* Load the DIEs associated with type unit PER_CU into memory. */
14326 load_full_type_unit (struct dwarf2_per_cu_data *per_cu)
14328 struct objfile *objfile = per_cu->objfile;
14329 struct dwarf2_section_info *sect = per_cu->debug_types_section;
14330 unsigned int offset = per_cu->offset;
14331 struct signatured_type *type_sig;
14333 dwarf2_read_section (objfile, sect);
14335 /* We have the section offset, but we need the signature to do the
14336 hash table lookup. */
14337 /* FIXME: This is sorta unnecessary, read_signatured_type only uses
14338 the signature to assert we found the right one.
14339 Ok, but it's a lot of work. We should simplify things so any needed
14340 assert doesn't require all this clumsiness. */
14341 type_sig = lookup_signatured_type_at_offset (objfile, sect, offset);
14343 gdb_assert (type_sig->per_cu.cu == NULL);
14345 read_signatured_type (type_sig);
14347 gdb_assert (type_sig->per_cu.cu != NULL);
14350 /* Read in a signatured type and build its CU and DIEs. */
14353 read_signatured_type (struct signatured_type *type_sig)
14355 struct objfile *objfile = type_sig->per_cu.objfile;
14356 gdb_byte *types_ptr;
14357 struct die_reader_specs reader_specs;
14358 struct dwarf2_cu *cu;
14359 ULONGEST signature;
14360 struct cleanup *back_to, *free_cu_cleanup;
14361 struct dwarf2_section_info *section = type_sig->per_cu.debug_types_section;
14363 dwarf2_read_section (objfile, section);
14364 types_ptr = section->buffer + type_sig->per_cu.offset;
14366 gdb_assert (type_sig->per_cu.cu == NULL);
14368 cu = xmalloc (sizeof (*cu));
14369 init_one_comp_unit (cu, &type_sig->per_cu);
14371 /* If an error occurs while loading, release our storage. */
14372 free_cu_cleanup = make_cleanup (free_heap_comp_unit, cu);
14374 types_ptr = read_and_check_type_unit_head (&cu->header, section, types_ptr,
14376 gdb_assert (signature == type_sig->signature);
14379 = htab_create_alloc_ex (cu->header.length / 12,
14383 &cu->comp_unit_obstack,
14384 hashtab_obstack_allocate,
14385 dummy_obstack_deallocate);
14387 dwarf2_read_abbrevs (cu);
14388 back_to = make_cleanup (dwarf2_free_abbrev_table, cu);
14390 init_cu_die_reader (&reader_specs, cu);
14392 cu->dies = read_die_and_children (&reader_specs, types_ptr, &types_ptr,
14395 /* We try not to read any attributes in this function, because not
14396 all CUs needed for references have been loaded yet, and symbol
14397 table processing isn't initialized. But we have to set the CU language,
14398 or we won't be able to build types correctly. */
14399 prepare_one_comp_unit (cu, cu->dies);
14401 do_cleanups (back_to);
14403 /* We've successfully allocated this compilation unit. Let our caller
14404 clean it up when finished with it. */
14405 discard_cleanups (free_cu_cleanup);
14407 type_sig->per_cu.cu->read_in_chain = dwarf2_per_objfile->read_in_chain;
14408 dwarf2_per_objfile->read_in_chain = &type_sig->per_cu;
14411 /* Decode simple location descriptions.
14412 Given a pointer to a dwarf block that defines a location, compute
14413 the location and return the value.
14415 NOTE drow/2003-11-18: This function is called in two situations
14416 now: for the address of static or global variables (partial symbols
14417 only) and for offsets into structures which are expected to be
14418 (more or less) constant. The partial symbol case should go away,
14419 and only the constant case should remain. That will let this
14420 function complain more accurately. A few special modes are allowed
14421 without complaint for global variables (for instance, global
14422 register values and thread-local values).
14424 A location description containing no operations indicates that the
14425 object is optimized out. The return value is 0 for that case.
14426 FIXME drow/2003-11-16: No callers check for this case any more; soon all
14427 callers will only want a very basic result and this can become a
14430 Note that stack[0] is unused except as a default error return. */
14433 decode_locdesc (struct dwarf_block *blk, struct dwarf2_cu *cu)
14435 struct objfile *objfile = cu->objfile;
14437 int size = blk->size;
14438 gdb_byte *data = blk->data;
14439 CORE_ADDR stack[64];
14441 unsigned int bytes_read, unsnd;
14447 stack[++stacki] = 0;
14486 stack[++stacki] = op - DW_OP_lit0;
14521 stack[++stacki] = op - DW_OP_reg0;
14523 dwarf2_complex_location_expr_complaint ();
14527 unsnd = read_unsigned_leb128 (NULL, (data + i), &bytes_read);
14529 stack[++stacki] = unsnd;
14531 dwarf2_complex_location_expr_complaint ();
14535 stack[++stacki] = read_address (objfile->obfd, &data[i],
14540 case DW_OP_const1u:
14541 stack[++stacki] = read_1_byte (objfile->obfd, &data[i]);
14545 case DW_OP_const1s:
14546 stack[++stacki] = read_1_signed_byte (objfile->obfd, &data[i]);
14550 case DW_OP_const2u:
14551 stack[++stacki] = read_2_bytes (objfile->obfd, &data[i]);
14555 case DW_OP_const2s:
14556 stack[++stacki] = read_2_signed_bytes (objfile->obfd, &data[i]);
14560 case DW_OP_const4u:
14561 stack[++stacki] = read_4_bytes (objfile->obfd, &data[i]);
14565 case DW_OP_const4s:
14566 stack[++stacki] = read_4_signed_bytes (objfile->obfd, &data[i]);
14570 case DW_OP_const8u:
14571 stack[++stacki] = read_8_bytes (objfile->obfd, &data[i]);
14576 stack[++stacki] = read_unsigned_leb128 (NULL, (data + i),
14582 stack[++stacki] = read_signed_leb128 (NULL, (data + i), &bytes_read);
14587 stack[stacki + 1] = stack[stacki];
14592 stack[stacki - 1] += stack[stacki];
14596 case DW_OP_plus_uconst:
14597 stack[stacki] += read_unsigned_leb128 (NULL, (data + i),
14603 stack[stacki - 1] -= stack[stacki];
14608 /* If we're not the last op, then we definitely can't encode
14609 this using GDB's address_class enum. This is valid for partial
14610 global symbols, although the variable's address will be bogus
14613 dwarf2_complex_location_expr_complaint ();
14616 case DW_OP_GNU_push_tls_address:
14617 /* The top of the stack has the offset from the beginning
14618 of the thread control block at which the variable is located. */
14619 /* Nothing should follow this operator, so the top of stack would
14621 /* This is valid for partial global symbols, but the variable's
14622 address will be bogus in the psymtab. Make it always at least
14623 non-zero to not look as a variable garbage collected by linker
14624 which have DW_OP_addr 0. */
14626 dwarf2_complex_location_expr_complaint ();
14630 case DW_OP_GNU_uninit:
14635 const char *name = dwarf_stack_op_name (op);
14638 complaint (&symfile_complaints, _("unsupported stack op: '%s'"),
14641 complaint (&symfile_complaints, _("unsupported stack op: '%02x'"),
14645 return (stack[stacki]);
14648 /* Enforce maximum stack depth of SIZE-1 to avoid writing
14649 outside of the allocated space. Also enforce minimum>0. */
14650 if (stacki >= ARRAY_SIZE (stack) - 1)
14652 complaint (&symfile_complaints,
14653 _("location description stack overflow"));
14659 complaint (&symfile_complaints,
14660 _("location description stack underflow"));
14664 return (stack[stacki]);
14667 /* memory allocation interface */
14669 static struct dwarf_block *
14670 dwarf_alloc_block (struct dwarf2_cu *cu)
14672 struct dwarf_block *blk;
14674 blk = (struct dwarf_block *)
14675 obstack_alloc (&cu->comp_unit_obstack, sizeof (struct dwarf_block));
14679 static struct abbrev_info *
14680 dwarf_alloc_abbrev (struct dwarf2_cu *cu)
14682 struct abbrev_info *abbrev;
14684 abbrev = (struct abbrev_info *)
14685 obstack_alloc (&cu->abbrev_obstack, sizeof (struct abbrev_info));
14686 memset (abbrev, 0, sizeof (struct abbrev_info));
14690 static struct die_info *
14691 dwarf_alloc_die (struct dwarf2_cu *cu, int num_attrs)
14693 struct die_info *die;
14694 size_t size = sizeof (struct die_info);
14697 size += (num_attrs - 1) * sizeof (struct attribute);
14699 die = (struct die_info *) obstack_alloc (&cu->comp_unit_obstack, size);
14700 memset (die, 0, sizeof (struct die_info));
14705 /* Macro support. */
14707 /* Return the full name of file number I in *LH's file name table.
14708 Use COMP_DIR as the name of the current directory of the
14709 compilation. The result is allocated using xmalloc; the caller is
14710 responsible for freeing it. */
14712 file_full_name (int file, struct line_header *lh, const char *comp_dir)
14714 /* Is the file number a valid index into the line header's file name
14715 table? Remember that file numbers start with one, not zero. */
14716 if (1 <= file && file <= lh->num_file_names)
14718 struct file_entry *fe = &lh->file_names[file - 1];
14720 if (IS_ABSOLUTE_PATH (fe->name))
14721 return xstrdup (fe->name);
14729 dir = lh->include_dirs[fe->dir_index - 1];
14735 dir_len = strlen (dir);
14736 full_name = xmalloc (dir_len + 1 + strlen (fe->name) + 1);
14737 strcpy (full_name, dir);
14738 full_name[dir_len] = '/';
14739 strcpy (full_name + dir_len + 1, fe->name);
14743 return xstrdup (fe->name);
14748 /* The compiler produced a bogus file number. We can at least
14749 record the macro definitions made in the file, even if we
14750 won't be able to find the file by name. */
14751 char fake_name[80];
14753 sprintf (fake_name, "<bad macro file number %d>", file);
14755 complaint (&symfile_complaints,
14756 _("bad file number in macro information (%d)"),
14759 return xstrdup (fake_name);
14764 static struct macro_source_file *
14765 macro_start_file (int file, int line,
14766 struct macro_source_file *current_file,
14767 const char *comp_dir,
14768 struct line_header *lh, struct objfile *objfile)
14770 /* The full name of this source file. */
14771 char *full_name = file_full_name (file, lh, comp_dir);
14773 /* We don't create a macro table for this compilation unit
14774 at all until we actually get a filename. */
14775 if (! pending_macros)
14776 pending_macros = new_macro_table (&objfile->objfile_obstack,
14777 objfile->macro_cache);
14779 if (! current_file)
14780 /* If we have no current file, then this must be the start_file
14781 directive for the compilation unit's main source file. */
14782 current_file = macro_set_main (pending_macros, full_name);
14784 current_file = macro_include (current_file, line, full_name);
14788 return current_file;
14792 /* Copy the LEN characters at BUF to a xmalloc'ed block of memory,
14793 followed by a null byte. */
14795 copy_string (const char *buf, int len)
14797 char *s = xmalloc (len + 1);
14799 memcpy (s, buf, len);
14805 static const char *
14806 consume_improper_spaces (const char *p, const char *body)
14810 complaint (&symfile_complaints,
14811 _("macro definition contains spaces "
14812 "in formal argument list:\n`%s'"),
14824 parse_macro_definition (struct macro_source_file *file, int line,
14829 /* The body string takes one of two forms. For object-like macro
14830 definitions, it should be:
14832 <macro name> " " <definition>
14834 For function-like macro definitions, it should be:
14836 <macro name> "() " <definition>
14838 <macro name> "(" <arg name> ( "," <arg name> ) * ") " <definition>
14840 Spaces may appear only where explicitly indicated, and in the
14843 The Dwarf 2 spec says that an object-like macro's name is always
14844 followed by a space, but versions of GCC around March 2002 omit
14845 the space when the macro's definition is the empty string.
14847 The Dwarf 2 spec says that there should be no spaces between the
14848 formal arguments in a function-like macro's formal argument list,
14849 but versions of GCC around March 2002 include spaces after the
14853 /* Find the extent of the macro name. The macro name is terminated
14854 by either a space or null character (for an object-like macro) or
14855 an opening paren (for a function-like macro). */
14856 for (p = body; *p; p++)
14857 if (*p == ' ' || *p == '(')
14860 if (*p == ' ' || *p == '\0')
14862 /* It's an object-like macro. */
14863 int name_len = p - body;
14864 char *name = copy_string (body, name_len);
14865 const char *replacement;
14868 replacement = body + name_len + 1;
14871 dwarf2_macro_malformed_definition_complaint (body);
14872 replacement = body + name_len;
14875 macro_define_object (file, line, name, replacement);
14879 else if (*p == '(')
14881 /* It's a function-like macro. */
14882 char *name = copy_string (body, p - body);
14885 char **argv = xmalloc (argv_size * sizeof (*argv));
14889 p = consume_improper_spaces (p, body);
14891 /* Parse the formal argument list. */
14892 while (*p && *p != ')')
14894 /* Find the extent of the current argument name. */
14895 const char *arg_start = p;
14897 while (*p && *p != ',' && *p != ')' && *p != ' ')
14900 if (! *p || p == arg_start)
14901 dwarf2_macro_malformed_definition_complaint (body);
14904 /* Make sure argv has room for the new argument. */
14905 if (argc >= argv_size)
14908 argv = xrealloc (argv, argv_size * sizeof (*argv));
14911 argv[argc++] = copy_string (arg_start, p - arg_start);
14914 p = consume_improper_spaces (p, body);
14916 /* Consume the comma, if present. */
14921 p = consume_improper_spaces (p, body);
14930 /* Perfectly formed definition, no complaints. */
14931 macro_define_function (file, line, name,
14932 argc, (const char **) argv,
14934 else if (*p == '\0')
14936 /* Complain, but do define it. */
14937 dwarf2_macro_malformed_definition_complaint (body);
14938 macro_define_function (file, line, name,
14939 argc, (const char **) argv,
14943 /* Just complain. */
14944 dwarf2_macro_malformed_definition_complaint (body);
14947 /* Just complain. */
14948 dwarf2_macro_malformed_definition_complaint (body);
14954 for (i = 0; i < argc; i++)
14960 dwarf2_macro_malformed_definition_complaint (body);
14963 /* Skip some bytes from BYTES according to the form given in FORM.
14964 Returns the new pointer. */
14967 skip_form_bytes (bfd *abfd, gdb_byte *bytes,
14968 enum dwarf_form form,
14969 unsigned int offset_size,
14970 struct dwarf2_section_info *section)
14972 unsigned int bytes_read;
14976 case DW_FORM_data1:
14981 case DW_FORM_data2:
14985 case DW_FORM_data4:
14989 case DW_FORM_data8:
14993 case DW_FORM_string:
14994 read_direct_string (abfd, bytes, &bytes_read);
14995 bytes += bytes_read;
14998 case DW_FORM_sec_offset:
15000 bytes += offset_size;
15003 case DW_FORM_block:
15004 bytes += read_unsigned_leb128 (abfd, bytes, &bytes_read);
15005 bytes += bytes_read;
15008 case DW_FORM_block1:
15009 bytes += 1 + read_1_byte (abfd, bytes);
15011 case DW_FORM_block2:
15012 bytes += 2 + read_2_bytes (abfd, bytes);
15014 case DW_FORM_block4:
15015 bytes += 4 + read_4_bytes (abfd, bytes);
15018 case DW_FORM_sdata:
15019 case DW_FORM_udata:
15020 bytes = skip_leb128 (abfd, bytes);
15026 complaint (&symfile_complaints,
15027 _("invalid form 0x%x in `%s'"),
15029 section->asection->name);
15037 /* A helper for dwarf_decode_macros that handles skipping an unknown
15038 opcode. Returns an updated pointer to the macro data buffer; or,
15039 on error, issues a complaint and returns NULL. */
15042 skip_unknown_opcode (unsigned int opcode,
15043 gdb_byte **opcode_definitions,
15046 unsigned int offset_size,
15047 struct dwarf2_section_info *section)
15049 unsigned int bytes_read, i;
15053 if (opcode_definitions[opcode] == NULL)
15055 complaint (&symfile_complaints,
15056 _("unrecognized DW_MACFINO opcode 0x%x"),
15061 defn = opcode_definitions[opcode];
15062 arg = read_unsigned_leb128 (abfd, defn, &bytes_read);
15063 defn += bytes_read;
15065 for (i = 0; i < arg; ++i)
15067 mac_ptr = skip_form_bytes (abfd, mac_ptr, defn[i], offset_size, section);
15068 if (mac_ptr == NULL)
15070 /* skip_form_bytes already issued the complaint. */
15078 /* A helper function which parses the header of a macro section.
15079 If the macro section is the extended (for now called "GNU") type,
15080 then this updates *OFFSET_SIZE. Returns a pointer to just after
15081 the header, or issues a complaint and returns NULL on error. */
15084 dwarf_parse_macro_header (gdb_byte **opcode_definitions,
15087 unsigned int *offset_size,
15088 int section_is_gnu)
15090 memset (opcode_definitions, 0, 256 * sizeof (gdb_byte *));
15092 if (section_is_gnu)
15094 unsigned int version, flags;
15096 version = read_2_bytes (abfd, mac_ptr);
15099 complaint (&symfile_complaints,
15100 _("unrecognized version `%d' in .debug_macro section"),
15106 flags = read_1_byte (abfd, mac_ptr);
15108 *offset_size = (flags & 1) ? 8 : 4;
15110 if ((flags & 2) != 0)
15111 /* We don't need the line table offset. */
15112 mac_ptr += *offset_size;
15114 /* Vendor opcode descriptions. */
15115 if ((flags & 4) != 0)
15117 unsigned int i, count;
15119 count = read_1_byte (abfd, mac_ptr);
15121 for (i = 0; i < count; ++i)
15123 unsigned int opcode, bytes_read;
15126 opcode = read_1_byte (abfd, mac_ptr);
15128 opcode_definitions[opcode] = mac_ptr;
15129 arg = read_unsigned_leb128 (abfd, mac_ptr, &bytes_read);
15130 mac_ptr += bytes_read;
15139 /* A helper for dwarf_decode_macros that handles the GNU extensions,
15140 including DW_GNU_MACINFO_transparent_include. */
15143 dwarf_decode_macro_bytes (bfd *abfd, gdb_byte *mac_ptr, gdb_byte *mac_end,
15144 struct macro_source_file *current_file,
15145 struct line_header *lh, char *comp_dir,
15146 struct dwarf2_section_info *section,
15147 int section_is_gnu,
15148 unsigned int offset_size,
15149 struct objfile *objfile)
15151 enum dwarf_macro_record_type macinfo_type;
15152 int at_commandline;
15153 gdb_byte *opcode_definitions[256];
15155 mac_ptr = dwarf_parse_macro_header (opcode_definitions, abfd, mac_ptr,
15156 &offset_size, section_is_gnu);
15157 if (mac_ptr == NULL)
15159 /* We already issued a complaint. */
15163 /* Determines if GDB is still before first DW_MACINFO_start_file. If true
15164 GDB is still reading the definitions from command line. First
15165 DW_MACINFO_start_file will need to be ignored as it was already executed
15166 to create CURRENT_FILE for the main source holding also the command line
15167 definitions. On first met DW_MACINFO_start_file this flag is reset to
15168 normally execute all the remaining DW_MACINFO_start_file macinfos. */
15170 at_commandline = 1;
15174 /* Do we at least have room for a macinfo type byte? */
15175 if (mac_ptr >= mac_end)
15177 dwarf2_macros_too_long_complaint (section);
15181 macinfo_type = read_1_byte (abfd, mac_ptr);
15184 /* Note that we rely on the fact that the corresponding GNU and
15185 DWARF constants are the same. */
15186 switch (macinfo_type)
15188 /* A zero macinfo type indicates the end of the macro
15193 case DW_MACRO_GNU_define:
15194 case DW_MACRO_GNU_undef:
15195 case DW_MACRO_GNU_define_indirect:
15196 case DW_MACRO_GNU_undef_indirect:
15198 unsigned int bytes_read;
15203 line = read_unsigned_leb128 (abfd, mac_ptr, &bytes_read);
15204 mac_ptr += bytes_read;
15206 if (macinfo_type == DW_MACRO_GNU_define
15207 || macinfo_type == DW_MACRO_GNU_undef)
15209 body = read_direct_string (abfd, mac_ptr, &bytes_read);
15210 mac_ptr += bytes_read;
15214 LONGEST str_offset;
15216 str_offset = read_offset_1 (abfd, mac_ptr, offset_size);
15217 mac_ptr += offset_size;
15219 body = read_indirect_string_at_offset (abfd, str_offset);
15222 is_define = (macinfo_type == DW_MACRO_GNU_define
15223 || macinfo_type == DW_MACRO_GNU_define_indirect);
15224 if (! current_file)
15226 /* DWARF violation as no main source is present. */
15227 complaint (&symfile_complaints,
15228 _("debug info with no main source gives macro %s "
15230 is_define ? _("definition") : _("undefinition"),
15234 if ((line == 0 && !at_commandline)
15235 || (line != 0 && at_commandline))
15236 complaint (&symfile_complaints,
15237 _("debug info gives %s macro %s with %s line %d: %s"),
15238 at_commandline ? _("command-line") : _("in-file"),
15239 is_define ? _("definition") : _("undefinition"),
15240 line == 0 ? _("zero") : _("non-zero"), line, body);
15243 parse_macro_definition (current_file, line, body);
15246 gdb_assert (macinfo_type == DW_MACRO_GNU_undef
15247 || macinfo_type == DW_MACRO_GNU_undef_indirect);
15248 macro_undef (current_file, line, body);
15253 case DW_MACRO_GNU_start_file:
15255 unsigned int bytes_read;
15258 line = read_unsigned_leb128 (abfd, mac_ptr, &bytes_read);
15259 mac_ptr += bytes_read;
15260 file = read_unsigned_leb128 (abfd, mac_ptr, &bytes_read);
15261 mac_ptr += bytes_read;
15263 if ((line == 0 && !at_commandline)
15264 || (line != 0 && at_commandline))
15265 complaint (&symfile_complaints,
15266 _("debug info gives source %d included "
15267 "from %s at %s line %d"),
15268 file, at_commandline ? _("command-line") : _("file"),
15269 line == 0 ? _("zero") : _("non-zero"), line);
15271 if (at_commandline)
15273 /* This DW_MACRO_GNU_start_file was executed in the
15275 at_commandline = 0;
15278 current_file = macro_start_file (file, line,
15279 current_file, comp_dir,
15284 case DW_MACRO_GNU_end_file:
15285 if (! current_file)
15286 complaint (&symfile_complaints,
15287 _("macro debug info has an unmatched "
15288 "`close_file' directive"));
15291 current_file = current_file->included_by;
15292 if (! current_file)
15294 enum dwarf_macro_record_type next_type;
15296 /* GCC circa March 2002 doesn't produce the zero
15297 type byte marking the end of the compilation
15298 unit. Complain if it's not there, but exit no
15301 /* Do we at least have room for a macinfo type byte? */
15302 if (mac_ptr >= mac_end)
15304 dwarf2_macros_too_long_complaint (section);
15308 /* We don't increment mac_ptr here, so this is just
15310 next_type = read_1_byte (abfd, mac_ptr);
15311 if (next_type != 0)
15312 complaint (&symfile_complaints,
15313 _("no terminating 0-type entry for "
15314 "macros in `.debug_macinfo' section"));
15321 case DW_MACRO_GNU_transparent_include:
15325 offset = read_offset_1 (abfd, mac_ptr, offset_size);
15326 mac_ptr += offset_size;
15328 dwarf_decode_macro_bytes (abfd,
15329 section->buffer + offset,
15330 mac_end, current_file,
15332 section, section_is_gnu,
15333 offset_size, objfile);
15337 case DW_MACINFO_vendor_ext:
15338 if (!section_is_gnu)
15340 unsigned int bytes_read;
15343 constant = read_unsigned_leb128 (abfd, mac_ptr, &bytes_read);
15344 mac_ptr += bytes_read;
15345 read_direct_string (abfd, mac_ptr, &bytes_read);
15346 mac_ptr += bytes_read;
15348 /* We don't recognize any vendor extensions. */
15354 mac_ptr = skip_unknown_opcode (macinfo_type, opcode_definitions,
15355 mac_ptr, abfd, offset_size,
15357 if (mac_ptr == NULL)
15361 } while (macinfo_type != 0);
15365 dwarf_decode_macros (struct line_header *lh, unsigned int offset,
15366 char *comp_dir, bfd *abfd,
15367 struct dwarf2_cu *cu,
15368 struct dwarf2_section_info *section,
15369 int section_is_gnu)
15371 struct objfile *objfile = dwarf2_per_objfile->objfile;
15372 gdb_byte *mac_ptr, *mac_end;
15373 struct macro_source_file *current_file = 0;
15374 enum dwarf_macro_record_type macinfo_type;
15375 unsigned int offset_size = cu->header.offset_size;
15376 gdb_byte *opcode_definitions[256];
15378 dwarf2_read_section (objfile, section);
15379 if (section->buffer == NULL)
15381 complaint (&symfile_complaints, _("missing %s section"),
15382 section->asection->name);
15386 /* First pass: Find the name of the base filename.
15387 This filename is needed in order to process all macros whose definition
15388 (or undefinition) comes from the command line. These macros are defined
15389 before the first DW_MACINFO_start_file entry, and yet still need to be
15390 associated to the base file.
15392 To determine the base file name, we scan the macro definitions until we
15393 reach the first DW_MACINFO_start_file entry. We then initialize
15394 CURRENT_FILE accordingly so that any macro definition found before the
15395 first DW_MACINFO_start_file can still be associated to the base file. */
15397 mac_ptr = section->buffer + offset;
15398 mac_end = section->buffer + section->size;
15400 mac_ptr = dwarf_parse_macro_header (opcode_definitions, abfd, mac_ptr,
15401 &offset_size, section_is_gnu);
15402 if (mac_ptr == NULL)
15404 /* We already issued a complaint. */
15410 /* Do we at least have room for a macinfo type byte? */
15411 if (mac_ptr >= mac_end)
15413 /* Complaint is printed during the second pass as GDB will probably
15414 stop the first pass earlier upon finding
15415 DW_MACINFO_start_file. */
15419 macinfo_type = read_1_byte (abfd, mac_ptr);
15422 /* Note that we rely on the fact that the corresponding GNU and
15423 DWARF constants are the same. */
15424 switch (macinfo_type)
15426 /* A zero macinfo type indicates the end of the macro
15431 case DW_MACRO_GNU_define:
15432 case DW_MACRO_GNU_undef:
15433 /* Only skip the data by MAC_PTR. */
15435 unsigned int bytes_read;
15437 read_unsigned_leb128 (abfd, mac_ptr, &bytes_read);
15438 mac_ptr += bytes_read;
15439 read_direct_string (abfd, mac_ptr, &bytes_read);
15440 mac_ptr += bytes_read;
15444 case DW_MACRO_GNU_start_file:
15446 unsigned int bytes_read;
15449 line = read_unsigned_leb128 (abfd, mac_ptr, &bytes_read);
15450 mac_ptr += bytes_read;
15451 file = read_unsigned_leb128 (abfd, mac_ptr, &bytes_read);
15452 mac_ptr += bytes_read;
15454 current_file = macro_start_file (file, line, current_file,
15455 comp_dir, lh, objfile);
15459 case DW_MACRO_GNU_end_file:
15460 /* No data to skip by MAC_PTR. */
15463 case DW_MACRO_GNU_define_indirect:
15464 case DW_MACRO_GNU_undef_indirect:
15466 unsigned int bytes_read;
15468 read_unsigned_leb128 (abfd, mac_ptr, &bytes_read);
15469 mac_ptr += bytes_read;
15470 mac_ptr += offset_size;
15474 case DW_MACRO_GNU_transparent_include:
15475 /* Note that, according to the spec, a transparent include
15476 chain cannot call DW_MACRO_GNU_start_file. So, we can just
15477 skip this opcode. */
15478 mac_ptr += offset_size;
15481 case DW_MACINFO_vendor_ext:
15482 /* Only skip the data by MAC_PTR. */
15483 if (!section_is_gnu)
15485 unsigned int bytes_read;
15487 read_unsigned_leb128 (abfd, mac_ptr, &bytes_read);
15488 mac_ptr += bytes_read;
15489 read_direct_string (abfd, mac_ptr, &bytes_read);
15490 mac_ptr += bytes_read;
15495 mac_ptr = skip_unknown_opcode (macinfo_type, opcode_definitions,
15496 mac_ptr, abfd, offset_size,
15498 if (mac_ptr == NULL)
15502 } while (macinfo_type != 0 && current_file == NULL);
15504 /* Second pass: Process all entries.
15506 Use the AT_COMMAND_LINE flag to determine whether we are still processing
15507 command-line macro definitions/undefinitions. This flag is unset when we
15508 reach the first DW_MACINFO_start_file entry. */
15510 dwarf_decode_macro_bytes (abfd, section->buffer + offset, mac_end,
15511 current_file, lh, comp_dir, section, section_is_gnu,
15512 offset_size, objfile);
15515 /* Check if the attribute's form is a DW_FORM_block*
15516 if so return true else false. */
15518 attr_form_is_block (struct attribute *attr)
15520 return (attr == NULL ? 0 :
15521 attr->form == DW_FORM_block1
15522 || attr->form == DW_FORM_block2
15523 || attr->form == DW_FORM_block4
15524 || attr->form == DW_FORM_block
15525 || attr->form == DW_FORM_exprloc);
15528 /* Return non-zero if ATTR's value is a section offset --- classes
15529 lineptr, loclistptr, macptr or rangelistptr --- or zero, otherwise.
15530 You may use DW_UNSND (attr) to retrieve such offsets.
15532 Section 7.5.4, "Attribute Encodings", explains that no attribute
15533 may have a value that belongs to more than one of these classes; it
15534 would be ambiguous if we did, because we use the same forms for all
15537 attr_form_is_section_offset (struct attribute *attr)
15539 return (attr->form == DW_FORM_data4
15540 || attr->form == DW_FORM_data8
15541 || attr->form == DW_FORM_sec_offset);
15545 /* Return non-zero if ATTR's value falls in the 'constant' class, or
15546 zero otherwise. When this function returns true, you can apply
15547 dwarf2_get_attr_constant_value to it.
15549 However, note that for some attributes you must check
15550 attr_form_is_section_offset before using this test. DW_FORM_data4
15551 and DW_FORM_data8 are members of both the constant class, and of
15552 the classes that contain offsets into other debug sections
15553 (lineptr, loclistptr, macptr or rangelistptr). The DWARF spec says
15554 that, if an attribute's can be either a constant or one of the
15555 section offset classes, DW_FORM_data4 and DW_FORM_data8 should be
15556 taken as section offsets, not constants. */
15558 attr_form_is_constant (struct attribute *attr)
15560 switch (attr->form)
15562 case DW_FORM_sdata:
15563 case DW_FORM_udata:
15564 case DW_FORM_data1:
15565 case DW_FORM_data2:
15566 case DW_FORM_data4:
15567 case DW_FORM_data8:
15574 /* A helper function that fills in a dwarf2_loclist_baton. */
15577 fill_in_loclist_baton (struct dwarf2_cu *cu,
15578 struct dwarf2_loclist_baton *baton,
15579 struct attribute *attr)
15581 dwarf2_read_section (dwarf2_per_objfile->objfile,
15582 &dwarf2_per_objfile->loc);
15584 baton->per_cu = cu->per_cu;
15585 gdb_assert (baton->per_cu);
15586 /* We don't know how long the location list is, but make sure we
15587 don't run off the edge of the section. */
15588 baton->size = dwarf2_per_objfile->loc.size - DW_UNSND (attr);
15589 baton->data = dwarf2_per_objfile->loc.buffer + DW_UNSND (attr);
15590 baton->base_address = cu->base_address;
15594 dwarf2_symbol_mark_computed (struct attribute *attr, struct symbol *sym,
15595 struct dwarf2_cu *cu)
15597 struct objfile *objfile = dwarf2_per_objfile->objfile;
15599 if (attr_form_is_section_offset (attr)
15600 /* ".debug_loc" may not exist at all, or the offset may be outside
15601 the section. If so, fall through to the complaint in the
15603 && DW_UNSND (attr) < dwarf2_section_size (objfile,
15604 &dwarf2_per_objfile->loc))
15606 struct dwarf2_loclist_baton *baton;
15608 baton = obstack_alloc (&objfile->objfile_obstack,
15609 sizeof (struct dwarf2_loclist_baton));
15611 fill_in_loclist_baton (cu, baton, attr);
15613 if (cu->base_known == 0)
15614 complaint (&symfile_complaints,
15615 _("Location list used without "
15616 "specifying the CU base address."));
15618 SYMBOL_COMPUTED_OPS (sym) = &dwarf2_loclist_funcs;
15619 SYMBOL_LOCATION_BATON (sym) = baton;
15623 struct dwarf2_locexpr_baton *baton;
15625 baton = obstack_alloc (&objfile->objfile_obstack,
15626 sizeof (struct dwarf2_locexpr_baton));
15627 baton->per_cu = cu->per_cu;
15628 gdb_assert (baton->per_cu);
15630 if (attr_form_is_block (attr))
15632 /* Note that we're just copying the block's data pointer
15633 here, not the actual data. We're still pointing into the
15634 info_buffer for SYM's objfile; right now we never release
15635 that buffer, but when we do clean up properly this may
15637 baton->size = DW_BLOCK (attr)->size;
15638 baton->data = DW_BLOCK (attr)->data;
15642 dwarf2_invalid_attrib_class_complaint ("location description",
15643 SYMBOL_NATURAL_NAME (sym));
15647 SYMBOL_COMPUTED_OPS (sym) = &dwarf2_locexpr_funcs;
15648 SYMBOL_LOCATION_BATON (sym) = baton;
15652 /* Return the OBJFILE associated with the compilation unit CU. If CU
15653 came from a separate debuginfo file, then the master objfile is
15657 dwarf2_per_cu_objfile (struct dwarf2_per_cu_data *per_cu)
15659 struct objfile *objfile = per_cu->objfile;
15661 /* Return the master objfile, so that we can report and look up the
15662 correct file containing this variable. */
15663 if (objfile->separate_debug_objfile_backlink)
15664 objfile = objfile->separate_debug_objfile_backlink;
15669 /* Return comp_unit_head for PER_CU, either already available in PER_CU->CU
15670 (CU_HEADERP is unused in such case) or prepare a temporary copy at
15671 CU_HEADERP first. */
15673 static const struct comp_unit_head *
15674 per_cu_header_read_in (struct comp_unit_head *cu_headerp,
15675 struct dwarf2_per_cu_data *per_cu)
15677 struct objfile *objfile;
15678 struct dwarf2_per_objfile *per_objfile;
15679 gdb_byte *info_ptr;
15682 return &per_cu->cu->header;
15684 objfile = per_cu->objfile;
15685 per_objfile = objfile_data (objfile, dwarf2_objfile_data_key);
15686 info_ptr = per_objfile->info.buffer + per_cu->offset;
15688 memset (cu_headerp, 0, sizeof (*cu_headerp));
15689 read_comp_unit_head (cu_headerp, info_ptr, objfile->obfd);
15694 /* Return the address size given in the compilation unit header for CU. */
15697 dwarf2_per_cu_addr_size (struct dwarf2_per_cu_data *per_cu)
15699 struct comp_unit_head cu_header_local;
15700 const struct comp_unit_head *cu_headerp;
15702 cu_headerp = per_cu_header_read_in (&cu_header_local, per_cu);
15704 return cu_headerp->addr_size;
15707 /* Return the offset size given in the compilation unit header for CU. */
15710 dwarf2_per_cu_offset_size (struct dwarf2_per_cu_data *per_cu)
15712 struct comp_unit_head cu_header_local;
15713 const struct comp_unit_head *cu_headerp;
15715 cu_headerp = per_cu_header_read_in (&cu_header_local, per_cu);
15717 return cu_headerp->offset_size;
15720 /* See its dwarf2loc.h declaration. */
15723 dwarf2_per_cu_ref_addr_size (struct dwarf2_per_cu_data *per_cu)
15725 struct comp_unit_head cu_header_local;
15726 const struct comp_unit_head *cu_headerp;
15728 cu_headerp = per_cu_header_read_in (&cu_header_local, per_cu);
15730 if (cu_headerp->version == 2)
15731 return cu_headerp->addr_size;
15733 return cu_headerp->offset_size;
15736 /* Return the text offset of the CU. The returned offset comes from
15737 this CU's objfile. If this objfile came from a separate debuginfo
15738 file, then the offset may be different from the corresponding
15739 offset in the parent objfile. */
15742 dwarf2_per_cu_text_offset (struct dwarf2_per_cu_data *per_cu)
15744 struct objfile *objfile = per_cu->objfile;
15746 return ANOFFSET (objfile->section_offsets, SECT_OFF_TEXT (objfile));
15749 /* Locate the .debug_info compilation unit from CU's objfile which contains
15750 the DIE at OFFSET. Raises an error on failure. */
15752 static struct dwarf2_per_cu_data *
15753 dwarf2_find_containing_comp_unit (unsigned int offset,
15754 struct objfile *objfile)
15756 struct dwarf2_per_cu_data *this_cu;
15760 high = dwarf2_per_objfile->n_comp_units - 1;
15763 int mid = low + (high - low) / 2;
15765 if (dwarf2_per_objfile->all_comp_units[mid]->offset >= offset)
15770 gdb_assert (low == high);
15771 if (dwarf2_per_objfile->all_comp_units[low]->offset > offset)
15774 error (_("Dwarf Error: could not find partial DIE containing "
15775 "offset 0x%lx [in module %s]"),
15776 (long) offset, bfd_get_filename (objfile->obfd));
15778 gdb_assert (dwarf2_per_objfile->all_comp_units[low-1]->offset <= offset);
15779 return dwarf2_per_objfile->all_comp_units[low-1];
15783 this_cu = dwarf2_per_objfile->all_comp_units[low];
15784 if (low == dwarf2_per_objfile->n_comp_units - 1
15785 && offset >= this_cu->offset + this_cu->length)
15786 error (_("invalid dwarf2 offset %u"), offset);
15787 gdb_assert (offset < this_cu->offset + this_cu->length);
15792 /* Initialize dwarf2_cu CU, owned by PER_CU. */
15795 init_one_comp_unit (struct dwarf2_cu *cu, struct dwarf2_per_cu_data *per_cu)
15797 memset (cu, 0, sizeof (*cu));
15799 cu->per_cu = per_cu;
15800 cu->objfile = per_cu->objfile;
15801 obstack_init (&cu->comp_unit_obstack);
15804 /* Initialize basic fields of dwarf_cu CU according to DIE COMP_UNIT_DIE. */
15807 prepare_one_comp_unit (struct dwarf2_cu *cu, struct die_info *comp_unit_die)
15809 struct attribute *attr;
15811 /* Set the language we're debugging. */
15812 attr = dwarf2_attr (comp_unit_die, DW_AT_language, cu);
15814 set_cu_language (DW_UNSND (attr), cu);
15817 cu->language = language_minimal;
15818 cu->language_defn = language_def (cu->language);
15822 /* Release one cached compilation unit, CU. We unlink it from the tree
15823 of compilation units, but we don't remove it from the read_in_chain;
15824 the caller is responsible for that.
15825 NOTE: DATA is a void * because this function is also used as a
15826 cleanup routine. */
15829 free_heap_comp_unit (void *data)
15831 struct dwarf2_cu *cu = data;
15833 gdb_assert (cu->per_cu != NULL);
15834 cu->per_cu->cu = NULL;
15837 obstack_free (&cu->comp_unit_obstack, NULL);
15842 /* This cleanup function is passed the address of a dwarf2_cu on the stack
15843 when we're finished with it. We can't free the pointer itself, but be
15844 sure to unlink it from the cache. Also release any associated storage
15845 and perform cache maintenance.
15847 Only used during partial symbol parsing. */
15850 free_stack_comp_unit (void *data)
15852 struct dwarf2_cu *cu = data;
15854 gdb_assert (cu->per_cu != NULL);
15855 cu->per_cu->cu = NULL;
15858 obstack_free (&cu->comp_unit_obstack, NULL);
15859 cu->partial_dies = NULL;
15861 /* The previous code only did this if per_cu != NULL.
15862 But that would always succeed, so now we just unconditionally do
15863 the aging. This seems like the wrong place to do such aging,
15864 but cleaning that up is left for later. */
15865 age_cached_comp_units ();
15868 /* Free all cached compilation units. */
15871 free_cached_comp_units (void *data)
15873 struct dwarf2_per_cu_data *per_cu, **last_chain;
15875 per_cu = dwarf2_per_objfile->read_in_chain;
15876 last_chain = &dwarf2_per_objfile->read_in_chain;
15877 while (per_cu != NULL)
15879 struct dwarf2_per_cu_data *next_cu;
15881 next_cu = per_cu->cu->read_in_chain;
15883 free_heap_comp_unit (per_cu->cu);
15884 *last_chain = next_cu;
15890 /* Increase the age counter on each cached compilation unit, and free
15891 any that are too old. */
15894 age_cached_comp_units (void)
15896 struct dwarf2_per_cu_data *per_cu, **last_chain;
15898 dwarf2_clear_marks (dwarf2_per_objfile->read_in_chain);
15899 per_cu = dwarf2_per_objfile->read_in_chain;
15900 while (per_cu != NULL)
15902 per_cu->cu->last_used ++;
15903 if (per_cu->cu->last_used <= dwarf2_max_cache_age)
15904 dwarf2_mark (per_cu->cu);
15905 per_cu = per_cu->cu->read_in_chain;
15908 per_cu = dwarf2_per_objfile->read_in_chain;
15909 last_chain = &dwarf2_per_objfile->read_in_chain;
15910 while (per_cu != NULL)
15912 struct dwarf2_per_cu_data *next_cu;
15914 next_cu = per_cu->cu->read_in_chain;
15916 if (!per_cu->cu->mark)
15918 free_heap_comp_unit (per_cu->cu);
15919 *last_chain = next_cu;
15922 last_chain = &per_cu->cu->read_in_chain;
15928 /* Remove a single compilation unit from the cache. */
15931 free_one_cached_comp_unit (void *target_cu)
15933 struct dwarf2_per_cu_data *per_cu, **last_chain;
15935 per_cu = dwarf2_per_objfile->read_in_chain;
15936 last_chain = &dwarf2_per_objfile->read_in_chain;
15937 while (per_cu != NULL)
15939 struct dwarf2_per_cu_data *next_cu;
15941 next_cu = per_cu->cu->read_in_chain;
15943 if (per_cu->cu == target_cu)
15945 free_heap_comp_unit (per_cu->cu);
15946 *last_chain = next_cu;
15950 last_chain = &per_cu->cu->read_in_chain;
15956 /* Release all extra memory associated with OBJFILE. */
15959 dwarf2_free_objfile (struct objfile *objfile)
15961 dwarf2_per_objfile = objfile_data (objfile, dwarf2_objfile_data_key);
15963 if (dwarf2_per_objfile == NULL)
15966 /* Cached DIE trees use xmalloc and the comp_unit_obstack. */
15967 free_cached_comp_units (NULL);
15969 if (dwarf2_per_objfile->quick_file_names_table)
15970 htab_delete (dwarf2_per_objfile->quick_file_names_table);
15972 /* Everything else should be on the objfile obstack. */
15975 /* A pair of DIE offset and GDB type pointer. We store these
15976 in a hash table separate from the DIEs, and preserve them
15977 when the DIEs are flushed out of cache. */
15979 struct dwarf2_offset_and_type
15981 unsigned int offset;
15985 /* Hash function for a dwarf2_offset_and_type. */
15988 offset_and_type_hash (const void *item)
15990 const struct dwarf2_offset_and_type *ofs = item;
15992 return ofs->offset;
15995 /* Equality function for a dwarf2_offset_and_type. */
15998 offset_and_type_eq (const void *item_lhs, const void *item_rhs)
16000 const struct dwarf2_offset_and_type *ofs_lhs = item_lhs;
16001 const struct dwarf2_offset_and_type *ofs_rhs = item_rhs;
16003 return ofs_lhs->offset == ofs_rhs->offset;
16006 /* Set the type associated with DIE to TYPE. Save it in CU's hash
16007 table if necessary. For convenience, return TYPE.
16009 The DIEs reading must have careful ordering to:
16010 * Not cause infite loops trying to read in DIEs as a prerequisite for
16011 reading current DIE.
16012 * Not trying to dereference contents of still incompletely read in types
16013 while reading in other DIEs.
16014 * Enable referencing still incompletely read in types just by a pointer to
16015 the type without accessing its fields.
16017 Therefore caller should follow these rules:
16018 * Try to fetch any prerequisite types we may need to build this DIE type
16019 before building the type and calling set_die_type.
16020 * After building type call set_die_type for current DIE as soon as
16021 possible before fetching more types to complete the current type.
16022 * Make the type as complete as possible before fetching more types. */
16024 static struct type *
16025 set_die_type (struct die_info *die, struct type *type, struct dwarf2_cu *cu)
16027 struct dwarf2_offset_and_type **slot, ofs;
16028 struct objfile *objfile = cu->objfile;
16029 htab_t *type_hash_ptr;
16031 /* For Ada types, make sure that the gnat-specific data is always
16032 initialized (if not already set). There are a few types where
16033 we should not be doing so, because the type-specific area is
16034 already used to hold some other piece of info (eg: TYPE_CODE_FLT
16035 where the type-specific area is used to store the floatformat).
16036 But this is not a problem, because the gnat-specific information
16037 is actually not needed for these types. */
16038 if (need_gnat_info (cu)
16039 && TYPE_CODE (type) != TYPE_CODE_FUNC
16040 && TYPE_CODE (type) != TYPE_CODE_FLT
16041 && !HAVE_GNAT_AUX_INFO (type))
16042 INIT_GNAT_SPECIFIC (type);
16044 if (cu->per_cu->debug_types_section)
16045 type_hash_ptr = &dwarf2_per_objfile->debug_types_type_hash;
16047 type_hash_ptr = &dwarf2_per_objfile->debug_info_type_hash;
16049 if (*type_hash_ptr == NULL)
16052 = htab_create_alloc_ex (127,
16053 offset_and_type_hash,
16054 offset_and_type_eq,
16056 &objfile->objfile_obstack,
16057 hashtab_obstack_allocate,
16058 dummy_obstack_deallocate);
16061 ofs.offset = die->offset;
16063 slot = (struct dwarf2_offset_and_type **)
16064 htab_find_slot_with_hash (*type_hash_ptr, &ofs, ofs.offset, INSERT);
16066 complaint (&symfile_complaints,
16067 _("A problem internal to GDB: DIE 0x%x has type already set"),
16069 *slot = obstack_alloc (&objfile->objfile_obstack, sizeof (**slot));
16074 /* Look up the type for the die at DIE_OFFSET in the appropriate type_hash
16075 table, or return NULL if the die does not have a saved type. */
16077 static struct type *
16078 get_die_type_at_offset (unsigned int offset,
16079 struct dwarf2_per_cu_data *per_cu)
16081 struct dwarf2_offset_and_type *slot, ofs;
16084 if (per_cu->debug_types_section)
16085 type_hash = dwarf2_per_objfile->debug_types_type_hash;
16087 type_hash = dwarf2_per_objfile->debug_info_type_hash;
16088 if (type_hash == NULL)
16091 ofs.offset = offset;
16092 slot = htab_find_with_hash (type_hash, &ofs, ofs.offset);
16099 /* Look up the type for DIE in the appropriate type_hash table,
16100 or return NULL if DIE does not have a saved type. */
16102 static struct type *
16103 get_die_type (struct die_info *die, struct dwarf2_cu *cu)
16105 return get_die_type_at_offset (die->offset, cu->per_cu);
16108 /* Add a dependence relationship from CU to REF_PER_CU. */
16111 dwarf2_add_dependence (struct dwarf2_cu *cu,
16112 struct dwarf2_per_cu_data *ref_per_cu)
16116 if (cu->dependencies == NULL)
16118 = htab_create_alloc_ex (5, htab_hash_pointer, htab_eq_pointer,
16119 NULL, &cu->comp_unit_obstack,
16120 hashtab_obstack_allocate,
16121 dummy_obstack_deallocate);
16123 slot = htab_find_slot (cu->dependencies, ref_per_cu, INSERT);
16125 *slot = ref_per_cu;
16128 /* Subroutine of dwarf2_mark to pass to htab_traverse.
16129 Set the mark field in every compilation unit in the
16130 cache that we must keep because we are keeping CU. */
16133 dwarf2_mark_helper (void **slot, void *data)
16135 struct dwarf2_per_cu_data *per_cu;
16137 per_cu = (struct dwarf2_per_cu_data *) *slot;
16139 /* cu->dependencies references may not yet have been ever read if QUIT aborts
16140 reading of the chain. As such dependencies remain valid it is not much
16141 useful to track and undo them during QUIT cleanups. */
16142 if (per_cu->cu == NULL)
16145 if (per_cu->cu->mark)
16147 per_cu->cu->mark = 1;
16149 if (per_cu->cu->dependencies != NULL)
16150 htab_traverse (per_cu->cu->dependencies, dwarf2_mark_helper, NULL);
16155 /* Set the mark field in CU and in every other compilation unit in the
16156 cache that we must keep because we are keeping CU. */
16159 dwarf2_mark (struct dwarf2_cu *cu)
16164 if (cu->dependencies != NULL)
16165 htab_traverse (cu->dependencies, dwarf2_mark_helper, NULL);
16169 dwarf2_clear_marks (struct dwarf2_per_cu_data *per_cu)
16173 per_cu->cu->mark = 0;
16174 per_cu = per_cu->cu->read_in_chain;
16178 /* Trivial hash function for partial_die_info: the hash value of a DIE
16179 is its offset in .debug_info for this objfile. */
16182 partial_die_hash (const void *item)
16184 const struct partial_die_info *part_die = item;
16186 return part_die->offset;
16189 /* Trivial comparison function for partial_die_info structures: two DIEs
16190 are equal if they have the same offset. */
16193 partial_die_eq (const void *item_lhs, const void *item_rhs)
16195 const struct partial_die_info *part_die_lhs = item_lhs;
16196 const struct partial_die_info *part_die_rhs = item_rhs;
16198 return part_die_lhs->offset == part_die_rhs->offset;
16201 static struct cmd_list_element *set_dwarf2_cmdlist;
16202 static struct cmd_list_element *show_dwarf2_cmdlist;
16205 set_dwarf2_cmd (char *args, int from_tty)
16207 help_list (set_dwarf2_cmdlist, "maintenance set dwarf2 ", -1, gdb_stdout);
16211 show_dwarf2_cmd (char *args, int from_tty)
16213 cmd_show_list (show_dwarf2_cmdlist, from_tty, "");
16216 /* If section described by INFO was mmapped, munmap it now. */
16219 munmap_section_buffer (struct dwarf2_section_info *info)
16221 if (info->map_addr != NULL)
16226 res = munmap (info->map_addr, info->map_len);
16227 gdb_assert (res == 0);
16229 /* Without HAVE_MMAP, we should never be here to begin with. */
16230 gdb_assert_not_reached ("no mmap support");
16235 /* munmap debug sections for OBJFILE, if necessary. */
16238 dwarf2_per_objfile_free (struct objfile *objfile, void *d)
16240 struct dwarf2_per_objfile *data = d;
16242 struct dwarf2_section_info *section;
16244 /* This is sorted according to the order they're defined in to make it easier
16245 to keep in sync. */
16246 munmap_section_buffer (&data->info);
16247 munmap_section_buffer (&data->abbrev);
16248 munmap_section_buffer (&data->line);
16249 munmap_section_buffer (&data->loc);
16250 munmap_section_buffer (&data->macinfo);
16251 munmap_section_buffer (&data->macro);
16252 munmap_section_buffer (&data->str);
16253 munmap_section_buffer (&data->ranges);
16254 munmap_section_buffer (&data->frame);
16255 munmap_section_buffer (&data->eh_frame);
16256 munmap_section_buffer (&data->gdb_index);
16259 VEC_iterate (dwarf2_section_info_def, data->types, ix, section);
16261 munmap_section_buffer (section);
16263 VEC_free (dwarf2_section_info_def, data->types);
16267 /* The "save gdb-index" command. */
16269 /* The contents of the hash table we create when building the string
16271 struct strtab_entry
16273 offset_type offset;
16277 /* Hash function for a strtab_entry.
16279 Function is used only during write_hash_table so no index format backward
16280 compatibility is needed. */
16283 hash_strtab_entry (const void *e)
16285 const struct strtab_entry *entry = e;
16286 return mapped_index_string_hash (INT_MAX, entry->str);
16289 /* Equality function for a strtab_entry. */
16292 eq_strtab_entry (const void *a, const void *b)
16294 const struct strtab_entry *ea = a;
16295 const struct strtab_entry *eb = b;
16296 return !strcmp (ea->str, eb->str);
16299 /* Create a strtab_entry hash table. */
16302 create_strtab (void)
16304 return htab_create_alloc (100, hash_strtab_entry, eq_strtab_entry,
16305 xfree, xcalloc, xfree);
16308 /* Add a string to the constant pool. Return the string's offset in
16312 add_string (htab_t table, struct obstack *cpool, const char *str)
16315 struct strtab_entry entry;
16316 struct strtab_entry *result;
16319 slot = htab_find_slot (table, &entry, INSERT);
16324 result = XNEW (struct strtab_entry);
16325 result->offset = obstack_object_size (cpool);
16327 obstack_grow_str0 (cpool, str);
16330 return result->offset;
16333 /* An entry in the symbol table. */
16334 struct symtab_index_entry
16336 /* The name of the symbol. */
16338 /* The offset of the name in the constant pool. */
16339 offset_type index_offset;
16340 /* A sorted vector of the indices of all the CUs that hold an object
16342 VEC (offset_type) *cu_indices;
16345 /* The symbol table. This is a power-of-2-sized hash table. */
16346 struct mapped_symtab
16348 offset_type n_elements;
16350 struct symtab_index_entry **data;
16353 /* Hash function for a symtab_index_entry. */
16356 hash_symtab_entry (const void *e)
16358 const struct symtab_index_entry *entry = e;
16359 return iterative_hash (VEC_address (offset_type, entry->cu_indices),
16360 sizeof (offset_type) * VEC_length (offset_type,
16361 entry->cu_indices),
16365 /* Equality function for a symtab_index_entry. */
16368 eq_symtab_entry (const void *a, const void *b)
16370 const struct symtab_index_entry *ea = a;
16371 const struct symtab_index_entry *eb = b;
16372 int len = VEC_length (offset_type, ea->cu_indices);
16373 if (len != VEC_length (offset_type, eb->cu_indices))
16375 return !memcmp (VEC_address (offset_type, ea->cu_indices),
16376 VEC_address (offset_type, eb->cu_indices),
16377 sizeof (offset_type) * len);
16380 /* Destroy a symtab_index_entry. */
16383 delete_symtab_entry (void *p)
16385 struct symtab_index_entry *entry = p;
16386 VEC_free (offset_type, entry->cu_indices);
16390 /* Create a hash table holding symtab_index_entry objects. */
16393 create_symbol_hash_table (void)
16395 return htab_create_alloc (100, hash_symtab_entry, eq_symtab_entry,
16396 delete_symtab_entry, xcalloc, xfree);
16399 /* Create a new mapped symtab object. */
16401 static struct mapped_symtab *
16402 create_mapped_symtab (void)
16404 struct mapped_symtab *symtab = XNEW (struct mapped_symtab);
16405 symtab->n_elements = 0;
16406 symtab->size = 1024;
16407 symtab->data = XCNEWVEC (struct symtab_index_entry *, symtab->size);
16411 /* Destroy a mapped_symtab. */
16414 cleanup_mapped_symtab (void *p)
16416 struct mapped_symtab *symtab = p;
16417 /* The contents of the array are freed when the other hash table is
16419 xfree (symtab->data);
16423 /* Find a slot in SYMTAB for the symbol NAME. Returns a pointer to
16426 Function is used only during write_hash_table so no index format backward
16427 compatibility is needed. */
16429 static struct symtab_index_entry **
16430 find_slot (struct mapped_symtab *symtab, const char *name)
16432 offset_type index, step, hash = mapped_index_string_hash (INT_MAX, name);
16434 index = hash & (symtab->size - 1);
16435 step = ((hash * 17) & (symtab->size - 1)) | 1;
16439 if (!symtab->data[index] || !strcmp (name, symtab->data[index]->name))
16440 return &symtab->data[index];
16441 index = (index + step) & (symtab->size - 1);
16445 /* Expand SYMTAB's hash table. */
16448 hash_expand (struct mapped_symtab *symtab)
16450 offset_type old_size = symtab->size;
16452 struct symtab_index_entry **old_entries = symtab->data;
16455 symtab->data = XCNEWVEC (struct symtab_index_entry *, symtab->size);
16457 for (i = 0; i < old_size; ++i)
16459 if (old_entries[i])
16461 struct symtab_index_entry **slot = find_slot (symtab,
16462 old_entries[i]->name);
16463 *slot = old_entries[i];
16467 xfree (old_entries);
16470 /* Add an entry to SYMTAB. NAME is the name of the symbol. CU_INDEX
16471 is the index of the CU in which the symbol appears. */
16474 add_index_entry (struct mapped_symtab *symtab, const char *name,
16475 offset_type cu_index)
16477 struct symtab_index_entry **slot;
16479 ++symtab->n_elements;
16480 if (4 * symtab->n_elements / 3 >= symtab->size)
16481 hash_expand (symtab);
16483 slot = find_slot (symtab, name);
16486 *slot = XNEW (struct symtab_index_entry);
16487 (*slot)->name = name;
16488 (*slot)->cu_indices = NULL;
16490 /* Don't push an index twice. Due to how we add entries we only
16491 have to check the last one. */
16492 if (VEC_empty (offset_type, (*slot)->cu_indices)
16493 || VEC_last (offset_type, (*slot)->cu_indices) != cu_index)
16494 VEC_safe_push (offset_type, (*slot)->cu_indices, cu_index);
16497 /* Add a vector of indices to the constant pool. */
16500 add_indices_to_cpool (htab_t symbol_hash_table, struct obstack *cpool,
16501 struct symtab_index_entry *entry)
16505 slot = htab_find_slot (symbol_hash_table, entry, INSERT);
16508 offset_type len = VEC_length (offset_type, entry->cu_indices);
16509 offset_type val = MAYBE_SWAP (len);
16514 entry->index_offset = obstack_object_size (cpool);
16516 obstack_grow (cpool, &val, sizeof (val));
16518 VEC_iterate (offset_type, entry->cu_indices, i, iter);
16521 val = MAYBE_SWAP (iter);
16522 obstack_grow (cpool, &val, sizeof (val));
16527 struct symtab_index_entry *old_entry = *slot;
16528 entry->index_offset = old_entry->index_offset;
16531 return entry->index_offset;
16534 /* Write the mapped hash table SYMTAB to the obstack OUTPUT, with
16535 constant pool entries going into the obstack CPOOL. */
16538 write_hash_table (struct mapped_symtab *symtab,
16539 struct obstack *output, struct obstack *cpool)
16542 htab_t symbol_hash_table;
16545 symbol_hash_table = create_symbol_hash_table ();
16546 str_table = create_strtab ();
16548 /* We add all the index vectors to the constant pool first, to
16549 ensure alignment is ok. */
16550 for (i = 0; i < symtab->size; ++i)
16552 if (symtab->data[i])
16553 add_indices_to_cpool (symbol_hash_table, cpool, symtab->data[i]);
16556 /* Now write out the hash table. */
16557 for (i = 0; i < symtab->size; ++i)
16559 offset_type str_off, vec_off;
16561 if (symtab->data[i])
16563 str_off = add_string (str_table, cpool, symtab->data[i]->name);
16564 vec_off = symtab->data[i]->index_offset;
16568 /* While 0 is a valid constant pool index, it is not valid
16569 to have 0 for both offsets. */
16574 str_off = MAYBE_SWAP (str_off);
16575 vec_off = MAYBE_SWAP (vec_off);
16577 obstack_grow (output, &str_off, sizeof (str_off));
16578 obstack_grow (output, &vec_off, sizeof (vec_off));
16581 htab_delete (str_table);
16582 htab_delete (symbol_hash_table);
16585 /* Struct to map psymtab to CU index in the index file. */
16586 struct psymtab_cu_index_map
16588 struct partial_symtab *psymtab;
16589 unsigned int cu_index;
16593 hash_psymtab_cu_index (const void *item)
16595 const struct psymtab_cu_index_map *map = item;
16597 return htab_hash_pointer (map->psymtab);
16601 eq_psymtab_cu_index (const void *item_lhs, const void *item_rhs)
16603 const struct psymtab_cu_index_map *lhs = item_lhs;
16604 const struct psymtab_cu_index_map *rhs = item_rhs;
16606 return lhs->psymtab == rhs->psymtab;
16609 /* Helper struct for building the address table. */
16610 struct addrmap_index_data
16612 struct objfile *objfile;
16613 struct obstack *addr_obstack;
16614 htab_t cu_index_htab;
16616 /* Non-zero if the previous_* fields are valid.
16617 We can't write an entry until we see the next entry (since it is only then
16618 that we know the end of the entry). */
16619 int previous_valid;
16620 /* Index of the CU in the table of all CUs in the index file. */
16621 unsigned int previous_cu_index;
16622 /* Start address of the CU. */
16623 CORE_ADDR previous_cu_start;
16626 /* Write an address entry to OBSTACK. */
16629 add_address_entry (struct objfile *objfile, struct obstack *obstack,
16630 CORE_ADDR start, CORE_ADDR end, unsigned int cu_index)
16632 offset_type cu_index_to_write;
16634 CORE_ADDR baseaddr;
16636 baseaddr = ANOFFSET (objfile->section_offsets, SECT_OFF_TEXT (objfile));
16638 store_unsigned_integer (addr, 8, BFD_ENDIAN_LITTLE, start - baseaddr);
16639 obstack_grow (obstack, addr, 8);
16640 store_unsigned_integer (addr, 8, BFD_ENDIAN_LITTLE, end - baseaddr);
16641 obstack_grow (obstack, addr, 8);
16642 cu_index_to_write = MAYBE_SWAP (cu_index);
16643 obstack_grow (obstack, &cu_index_to_write, sizeof (offset_type));
16646 /* Worker function for traversing an addrmap to build the address table. */
16649 add_address_entry_worker (void *datap, CORE_ADDR start_addr, void *obj)
16651 struct addrmap_index_data *data = datap;
16652 struct partial_symtab *pst = obj;
16653 offset_type cu_index;
16656 if (data->previous_valid)
16657 add_address_entry (data->objfile, data->addr_obstack,
16658 data->previous_cu_start, start_addr,
16659 data->previous_cu_index);
16661 data->previous_cu_start = start_addr;
16664 struct psymtab_cu_index_map find_map, *map;
16665 find_map.psymtab = pst;
16666 map = htab_find (data->cu_index_htab, &find_map);
16667 gdb_assert (map != NULL);
16668 data->previous_cu_index = map->cu_index;
16669 data->previous_valid = 1;
16672 data->previous_valid = 0;
16677 /* Write OBJFILE's address map to OBSTACK.
16678 CU_INDEX_HTAB is used to map addrmap entries to their CU indices
16679 in the index file. */
16682 write_address_map (struct objfile *objfile, struct obstack *obstack,
16683 htab_t cu_index_htab)
16685 struct addrmap_index_data addrmap_index_data;
16687 /* When writing the address table, we have to cope with the fact that
16688 the addrmap iterator only provides the start of a region; we have to
16689 wait until the next invocation to get the start of the next region. */
16691 addrmap_index_data.objfile = objfile;
16692 addrmap_index_data.addr_obstack = obstack;
16693 addrmap_index_data.cu_index_htab = cu_index_htab;
16694 addrmap_index_data.previous_valid = 0;
16696 addrmap_foreach (objfile->psymtabs_addrmap, add_address_entry_worker,
16697 &addrmap_index_data);
16699 /* It's highly unlikely the last entry (end address = 0xff...ff)
16700 is valid, but we should still handle it.
16701 The end address is recorded as the start of the next region, but that
16702 doesn't work here. To cope we pass 0xff...ff, this is a rare situation
16704 if (addrmap_index_data.previous_valid)
16705 add_address_entry (objfile, obstack,
16706 addrmap_index_data.previous_cu_start, (CORE_ADDR) -1,
16707 addrmap_index_data.previous_cu_index);
16710 /* Add a list of partial symbols to SYMTAB. */
16713 write_psymbols (struct mapped_symtab *symtab,
16715 struct partial_symbol **psymp,
16717 offset_type cu_index,
16720 for (; count-- > 0; ++psymp)
16722 void **slot, *lookup;
16724 if (SYMBOL_LANGUAGE (*psymp) == language_ada)
16725 error (_("Ada is not currently supported by the index"));
16727 /* We only want to add a given psymbol once. However, we also
16728 want to account for whether it is global or static. So, we
16729 may add it twice, using slightly different values. */
16732 uintptr_t val = 1 | (uintptr_t) *psymp;
16734 lookup = (void *) val;
16739 /* Only add a given psymbol once. */
16740 slot = htab_find_slot (psyms_seen, lookup, INSERT);
16744 add_index_entry (symtab, SYMBOL_SEARCH_NAME (*psymp), cu_index);
16749 /* Write the contents of an ("unfinished") obstack to FILE. Throw an
16750 exception if there is an error. */
16753 write_obstack (FILE *file, struct obstack *obstack)
16755 if (fwrite (obstack_base (obstack), 1, obstack_object_size (obstack),
16757 != obstack_object_size (obstack))
16758 error (_("couldn't data write to file"));
16761 /* Unlink a file if the argument is not NULL. */
16764 unlink_if_set (void *p)
16766 char **filename = p;
16768 unlink (*filename);
16771 /* A helper struct used when iterating over debug_types. */
16772 struct signatured_type_index_data
16774 struct objfile *objfile;
16775 struct mapped_symtab *symtab;
16776 struct obstack *types_list;
16781 /* A helper function that writes a single signatured_type to an
16785 write_one_signatured_type (void **slot, void *d)
16787 struct signatured_type_index_data *info = d;
16788 struct signatured_type *entry = (struct signatured_type *) *slot;
16789 struct dwarf2_per_cu_data *per_cu = &entry->per_cu;
16790 struct partial_symtab *psymtab = per_cu->v.psymtab;
16793 write_psymbols (info->symtab,
16795 info->objfile->global_psymbols.list
16796 + psymtab->globals_offset,
16797 psymtab->n_global_syms, info->cu_index,
16799 write_psymbols (info->symtab,
16801 info->objfile->static_psymbols.list
16802 + psymtab->statics_offset,
16803 psymtab->n_static_syms, info->cu_index,
16806 store_unsigned_integer (val, 8, BFD_ENDIAN_LITTLE, entry->per_cu.offset);
16807 obstack_grow (info->types_list, val, 8);
16808 store_unsigned_integer (val, 8, BFD_ENDIAN_LITTLE, entry->type_offset);
16809 obstack_grow (info->types_list, val, 8);
16810 store_unsigned_integer (val, 8, BFD_ENDIAN_LITTLE, entry->signature);
16811 obstack_grow (info->types_list, val, 8);
16818 /* Create an index file for OBJFILE in the directory DIR. */
16821 write_psymtabs_to_index (struct objfile *objfile, const char *dir)
16823 struct cleanup *cleanup;
16824 char *filename, *cleanup_filename;
16825 struct obstack contents, addr_obstack, constant_pool, symtab_obstack;
16826 struct obstack cu_list, types_cu_list;
16829 struct mapped_symtab *symtab;
16830 offset_type val, size_of_contents, total_len;
16834 htab_t cu_index_htab;
16835 struct psymtab_cu_index_map *psymtab_cu_index_map;
16837 if (!objfile->psymtabs || !objfile->psymtabs_addrmap)
16840 if (dwarf2_per_objfile->using_index)
16841 error (_("Cannot use an index to create the index"));
16843 if (VEC_length (dwarf2_section_info_def, dwarf2_per_objfile->types) > 1)
16844 error (_("Cannot make an index when the file has multiple .debug_types sections"));
16846 if (stat (objfile->name, &st) < 0)
16847 perror_with_name (objfile->name);
16849 filename = concat (dir, SLASH_STRING, lbasename (objfile->name),
16850 INDEX_SUFFIX, (char *) NULL);
16851 cleanup = make_cleanup (xfree, filename);
16853 out_file = fopen (filename, "wb");
16855 error (_("Can't open `%s' for writing"), filename);
16857 cleanup_filename = filename;
16858 make_cleanup (unlink_if_set, &cleanup_filename);
16860 symtab = create_mapped_symtab ();
16861 make_cleanup (cleanup_mapped_symtab, symtab);
16863 obstack_init (&addr_obstack);
16864 make_cleanup_obstack_free (&addr_obstack);
16866 obstack_init (&cu_list);
16867 make_cleanup_obstack_free (&cu_list);
16869 obstack_init (&types_cu_list);
16870 make_cleanup_obstack_free (&types_cu_list);
16872 psyms_seen = htab_create_alloc (100, htab_hash_pointer, htab_eq_pointer,
16873 NULL, xcalloc, xfree);
16874 make_cleanup_htab_delete (psyms_seen);
16876 /* While we're scanning CU's create a table that maps a psymtab pointer
16877 (which is what addrmap records) to its index (which is what is recorded
16878 in the index file). This will later be needed to write the address
16880 cu_index_htab = htab_create_alloc (100,
16881 hash_psymtab_cu_index,
16882 eq_psymtab_cu_index,
16883 NULL, xcalloc, xfree);
16884 make_cleanup_htab_delete (cu_index_htab);
16885 psymtab_cu_index_map = (struct psymtab_cu_index_map *)
16886 xmalloc (sizeof (struct psymtab_cu_index_map)
16887 * dwarf2_per_objfile->n_comp_units);
16888 make_cleanup (xfree, psymtab_cu_index_map);
16890 /* The CU list is already sorted, so we don't need to do additional
16891 work here. Also, the debug_types entries do not appear in
16892 all_comp_units, but only in their own hash table. */
16893 for (i = 0; i < dwarf2_per_objfile->n_comp_units; ++i)
16895 struct dwarf2_per_cu_data *per_cu
16896 = dwarf2_per_objfile->all_comp_units[i];
16897 struct partial_symtab *psymtab = per_cu->v.psymtab;
16899 struct psymtab_cu_index_map *map;
16902 write_psymbols (symtab,
16904 objfile->global_psymbols.list + psymtab->globals_offset,
16905 psymtab->n_global_syms, i,
16907 write_psymbols (symtab,
16909 objfile->static_psymbols.list + psymtab->statics_offset,
16910 psymtab->n_static_syms, i,
16913 map = &psymtab_cu_index_map[i];
16914 map->psymtab = psymtab;
16916 slot = htab_find_slot (cu_index_htab, map, INSERT);
16917 gdb_assert (slot != NULL);
16918 gdb_assert (*slot == NULL);
16921 store_unsigned_integer (val, 8, BFD_ENDIAN_LITTLE, per_cu->offset);
16922 obstack_grow (&cu_list, val, 8);
16923 store_unsigned_integer (val, 8, BFD_ENDIAN_LITTLE, per_cu->length);
16924 obstack_grow (&cu_list, val, 8);
16927 /* Dump the address map. */
16928 write_address_map (objfile, &addr_obstack, cu_index_htab);
16930 /* Write out the .debug_type entries, if any. */
16931 if (dwarf2_per_objfile->signatured_types)
16933 struct signatured_type_index_data sig_data;
16935 sig_data.objfile = objfile;
16936 sig_data.symtab = symtab;
16937 sig_data.types_list = &types_cu_list;
16938 sig_data.psyms_seen = psyms_seen;
16939 sig_data.cu_index = dwarf2_per_objfile->n_comp_units;
16940 htab_traverse_noresize (dwarf2_per_objfile->signatured_types,
16941 write_one_signatured_type, &sig_data);
16944 obstack_init (&constant_pool);
16945 make_cleanup_obstack_free (&constant_pool);
16946 obstack_init (&symtab_obstack);
16947 make_cleanup_obstack_free (&symtab_obstack);
16948 write_hash_table (symtab, &symtab_obstack, &constant_pool);
16950 obstack_init (&contents);
16951 make_cleanup_obstack_free (&contents);
16952 size_of_contents = 6 * sizeof (offset_type);
16953 total_len = size_of_contents;
16955 /* The version number. */
16956 val = MAYBE_SWAP (5);
16957 obstack_grow (&contents, &val, sizeof (val));
16959 /* The offset of the CU list from the start of the file. */
16960 val = MAYBE_SWAP (total_len);
16961 obstack_grow (&contents, &val, sizeof (val));
16962 total_len += obstack_object_size (&cu_list);
16964 /* The offset of the types CU list from the start of the file. */
16965 val = MAYBE_SWAP (total_len);
16966 obstack_grow (&contents, &val, sizeof (val));
16967 total_len += obstack_object_size (&types_cu_list);
16969 /* The offset of the address table from the start of the file. */
16970 val = MAYBE_SWAP (total_len);
16971 obstack_grow (&contents, &val, sizeof (val));
16972 total_len += obstack_object_size (&addr_obstack);
16974 /* The offset of the symbol table from the start of the file. */
16975 val = MAYBE_SWAP (total_len);
16976 obstack_grow (&contents, &val, sizeof (val));
16977 total_len += obstack_object_size (&symtab_obstack);
16979 /* The offset of the constant pool from the start of the file. */
16980 val = MAYBE_SWAP (total_len);
16981 obstack_grow (&contents, &val, sizeof (val));
16982 total_len += obstack_object_size (&constant_pool);
16984 gdb_assert (obstack_object_size (&contents) == size_of_contents);
16986 write_obstack (out_file, &contents);
16987 write_obstack (out_file, &cu_list);
16988 write_obstack (out_file, &types_cu_list);
16989 write_obstack (out_file, &addr_obstack);
16990 write_obstack (out_file, &symtab_obstack);
16991 write_obstack (out_file, &constant_pool);
16995 /* We want to keep the file, so we set cleanup_filename to NULL
16996 here. See unlink_if_set. */
16997 cleanup_filename = NULL;
16999 do_cleanups (cleanup);
17002 /* Implementation of the `save gdb-index' command.
17004 Note that the file format used by this command is documented in the
17005 GDB manual. Any changes here must be documented there. */
17008 save_gdb_index_command (char *arg, int from_tty)
17010 struct objfile *objfile;
17013 error (_("usage: save gdb-index DIRECTORY"));
17015 ALL_OBJFILES (objfile)
17019 /* If the objfile does not correspond to an actual file, skip it. */
17020 if (stat (objfile->name, &st) < 0)
17023 dwarf2_per_objfile = objfile_data (objfile, dwarf2_objfile_data_key);
17024 if (dwarf2_per_objfile)
17026 volatile struct gdb_exception except;
17028 TRY_CATCH (except, RETURN_MASK_ERROR)
17030 write_psymtabs_to_index (objfile, arg);
17032 if (except.reason < 0)
17033 exception_fprintf (gdb_stderr, except,
17034 _("Error while writing index for `%s': "),
17042 int dwarf2_always_disassemble;
17045 show_dwarf2_always_disassemble (struct ui_file *file, int from_tty,
17046 struct cmd_list_element *c, const char *value)
17048 fprintf_filtered (file,
17049 _("Whether to always disassemble "
17050 "DWARF expressions is %s.\n"),
17055 show_check_physname (struct ui_file *file, int from_tty,
17056 struct cmd_list_element *c, const char *value)
17058 fprintf_filtered (file,
17059 _("Whether to check \"physname\" is %s.\n"),
17063 void _initialize_dwarf2_read (void);
17066 _initialize_dwarf2_read (void)
17068 struct cmd_list_element *c;
17070 dwarf2_objfile_data_key
17071 = register_objfile_data_with_cleanup (NULL, dwarf2_per_objfile_free);
17073 add_prefix_cmd ("dwarf2", class_maintenance, set_dwarf2_cmd, _("\
17074 Set DWARF 2 specific variables.\n\
17075 Configure DWARF 2 variables such as the cache size"),
17076 &set_dwarf2_cmdlist, "maintenance set dwarf2 ",
17077 0/*allow-unknown*/, &maintenance_set_cmdlist);
17079 add_prefix_cmd ("dwarf2", class_maintenance, show_dwarf2_cmd, _("\
17080 Show DWARF 2 specific variables\n\
17081 Show DWARF 2 variables such as the cache size"),
17082 &show_dwarf2_cmdlist, "maintenance show dwarf2 ",
17083 0/*allow-unknown*/, &maintenance_show_cmdlist);
17085 add_setshow_zinteger_cmd ("max-cache-age", class_obscure,
17086 &dwarf2_max_cache_age, _("\
17087 Set the upper bound on the age of cached dwarf2 compilation units."), _("\
17088 Show the upper bound on the age of cached dwarf2 compilation units."), _("\
17089 A higher limit means that cached compilation units will be stored\n\
17090 in memory longer, and more total memory will be used. Zero disables\n\
17091 caching, which can slow down startup."),
17093 show_dwarf2_max_cache_age,
17094 &set_dwarf2_cmdlist,
17095 &show_dwarf2_cmdlist);
17097 add_setshow_boolean_cmd ("always-disassemble", class_obscure,
17098 &dwarf2_always_disassemble, _("\
17099 Set whether `info address' always disassembles DWARF expressions."), _("\
17100 Show whether `info address' always disassembles DWARF expressions."), _("\
17101 When enabled, DWARF expressions are always printed in an assembly-like\n\
17102 syntax. When disabled, expressions will be printed in a more\n\
17103 conversational style, when possible."),
17105 show_dwarf2_always_disassemble,
17106 &set_dwarf2_cmdlist,
17107 &show_dwarf2_cmdlist);
17109 add_setshow_zinteger_cmd ("dwarf2-die", no_class, &dwarf2_die_debug, _("\
17110 Set debugging of the dwarf2 DIE reader."), _("\
17111 Show debugging of the dwarf2 DIE reader."), _("\
17112 When enabled (non-zero), DIEs are dumped after they are read in.\n\
17113 The value is the maximum depth to print."),
17116 &setdebuglist, &showdebuglist);
17118 add_setshow_boolean_cmd ("check-physname", no_class, &check_physname, _("\
17119 Set cross-checking of \"physname\" code against demangler."), _("\
17120 Show cross-checking of \"physname\" code against demangler."), _("\
17121 When enabled, GDB's internal \"physname\" code is checked against\n\
17123 NULL, show_check_physname,
17124 &setdebuglist, &showdebuglist);
17126 c = add_cmd ("gdb-index", class_files, save_gdb_index_command,
17128 Save a gdb-index file.\n\
17129 Usage: save gdb-index DIRECTORY"),
17131 set_cmd_completer (c, filename_completer);