1 /* DWARF 2 debugging format support for GDB.
3 Copyright (C) 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003,
4 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2011
5 Free Software Foundation, Inc.
7 Adapted by Gary Funck (gary@intrepid.com), Intrepid Technology,
8 Inc. with support from Florida State University (under contract
9 with the Ada Joint Program Office), and Silicon Graphics, Inc.
10 Initial contribution by Brent Benson, Harris Computer Systems, Inc.,
11 based on Fred Fish's (Cygnus Support) implementation of DWARF 1
14 This file is part of GDB.
16 This program is free software; you can redistribute it and/or modify
17 it under the terms of the GNU General Public License as published by
18 the Free Software Foundation; either version 3 of the License, or
19 (at your option) any later version.
21 This program is distributed in the hope that it will be useful,
22 but WITHOUT ANY WARRANTY; without even the implied warranty of
23 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
24 GNU General Public License for more details.
26 You should have received a copy of the GNU General Public License
27 along with this program. If not, see <http://www.gnu.org/licenses/>. */
37 #include "expression.h"
38 #include "filenames.h" /* for DOSish file names */
41 #include "complaints.h"
43 #include "dwarf2expr.h"
44 #include "dwarf2loc.h"
45 #include "cp-support.h"
51 #include "typeprint.h"
54 #include "exceptions.h"
56 #include "completer.h"
63 #include "gdb_string.h"
64 #include "gdb_assert.h"
65 #include <sys/types.h>
72 #define MAP_FAILED ((void *) -1)
76 typedef struct symbol *symbolp;
80 /* .debug_info header for a compilation unit
81 Because of alignment constraints, this structure has padding and cannot
82 be mapped directly onto the beginning of the .debug_info section. */
83 typedef struct comp_unit_header
85 unsigned int length; /* length of the .debug_info
87 unsigned short version; /* version number -- 2 for DWARF
89 unsigned int abbrev_offset; /* offset into .debug_abbrev section */
90 unsigned char addr_size; /* byte size of an address -- 4 */
93 #define _ACTUAL_COMP_UNIT_HEADER_SIZE 11
96 /* .debug_line statement program prologue
97 Because of alignment constraints, this structure has padding and cannot
98 be mapped directly onto the beginning of the .debug_info section. */
99 typedef struct statement_prologue
101 unsigned int total_length; /* byte length of the statement
103 unsigned short version; /* version number -- 2 for DWARF
105 unsigned int prologue_length; /* # bytes between prologue &
107 unsigned char minimum_instruction_length; /* byte size of
109 unsigned char default_is_stmt; /* initial value of is_stmt
112 unsigned char line_range;
113 unsigned char opcode_base; /* number assigned to first special
115 unsigned char *standard_opcode_lengths;
119 /* When non-zero, dump DIEs after they are read in. */
120 static int dwarf2_die_debug = 0;
122 /* When non-zero, cross-check physname against demangler. */
123 static int check_physname = 0;
127 /* When set, the file that we're processing is known to have debugging
128 info for C++ namespaces. GCC 3.3.x did not produce this information,
129 but later versions do. */
131 static int processing_has_namespace_info;
133 static const struct objfile_data *dwarf2_objfile_data_key;
135 struct dwarf2_section_info
140 /* Not NULL if the section was actually mmapped. */
142 /* Page aligned size of mmapped area. */
143 bfd_size_type map_len;
144 /* True if we have tried to read this section. */
148 typedef struct dwarf2_section_info dwarf2_section_info_def;
149 DEF_VEC_O (dwarf2_section_info_def);
151 /* All offsets in the index are of this type. It must be
152 architecture-independent. */
153 typedef uint32_t offset_type;
155 DEF_VEC_I (offset_type);
157 /* A description of the mapped index. The file format is described in
158 a comment by the code that writes the index. */
161 /* Index data format version. */
164 /* The total length of the buffer. */
167 /* A pointer to the address table data. */
168 const gdb_byte *address_table;
170 /* Size of the address table data in bytes. */
171 offset_type address_table_size;
173 /* The symbol table, implemented as a hash table. */
174 const offset_type *symbol_table;
176 /* Size in slots, each slot is 2 offset_types. */
177 offset_type symbol_table_slots;
179 /* A pointer to the constant pool. */
180 const char *constant_pool;
183 struct dwarf2_per_objfile
185 struct dwarf2_section_info info;
186 struct dwarf2_section_info abbrev;
187 struct dwarf2_section_info line;
188 struct dwarf2_section_info loc;
189 struct dwarf2_section_info macinfo;
190 struct dwarf2_section_info macro;
191 struct dwarf2_section_info str;
192 struct dwarf2_section_info ranges;
193 struct dwarf2_section_info frame;
194 struct dwarf2_section_info eh_frame;
195 struct dwarf2_section_info gdb_index;
197 VEC (dwarf2_section_info_def) *types;
200 struct objfile *objfile;
202 /* A list of all the compilation units. This is used to locate
203 the target compilation unit of a particular reference. */
204 struct dwarf2_per_cu_data **all_comp_units;
206 /* The number of compilation units in ALL_COMP_UNITS. */
209 /* The number of .debug_types-related CUs. */
210 int n_type_comp_units;
212 /* The .debug_types-related CUs. */
213 struct dwarf2_per_cu_data **type_comp_units;
215 /* A chain of compilation units that are currently read in, so that
216 they can be freed later. */
217 struct dwarf2_per_cu_data *read_in_chain;
219 /* A table mapping .debug_types signatures to its signatured_type entry.
220 This is NULL if the .debug_types section hasn't been read in yet. */
221 htab_t signatured_types;
223 /* A flag indicating wether this objfile has a section loaded at a
225 int has_section_at_zero;
227 /* True if we are using the mapped index,
228 or we are faking it for OBJF_READNOW's sake. */
229 unsigned char using_index;
231 /* The mapped index, or NULL if .gdb_index is missing or not being used. */
232 struct mapped_index *index_table;
234 /* When using index_table, this keeps track of all quick_file_names entries.
235 TUs can share line table entries with CUs or other TUs, and there can be
236 a lot more TUs than unique line tables, so we maintain a separate table
237 of all line table entries to support the sharing. */
238 htab_t quick_file_names_table;
240 /* Set during partial symbol reading, to prevent queueing of full
242 int reading_partial_symbols;
244 /* Table mapping type .debug_info DIE offsets to types.
245 This is NULL if not allocated yet.
246 It (currently) makes sense to allocate debug_types_type_hash lazily.
247 To keep things simple we allocate both lazily. */
248 htab_t debug_info_type_hash;
250 /* Table mapping type .debug_types DIE offsets to types.
251 This is NULL if not allocated yet. */
252 htab_t debug_types_type_hash;
255 static struct dwarf2_per_objfile *dwarf2_per_objfile;
257 /* Default names of the debugging sections. */
259 /* Note that if the debugging section has been compressed, it might
260 have a name like .zdebug_info. */
262 static const struct dwarf2_debug_sections dwarf2_elf_names = {
263 { ".debug_info", ".zdebug_info" },
264 { ".debug_abbrev", ".zdebug_abbrev" },
265 { ".debug_line", ".zdebug_line" },
266 { ".debug_loc", ".zdebug_loc" },
267 { ".debug_macinfo", ".zdebug_macinfo" },
268 { ".debug_macro", ".zdebug_macro" },
269 { ".debug_str", ".zdebug_str" },
270 { ".debug_ranges", ".zdebug_ranges" },
271 { ".debug_types", ".zdebug_types" },
272 { ".debug_frame", ".zdebug_frame" },
273 { ".eh_frame", NULL },
274 { ".gdb_index", ".zgdb_index" },
278 /* local data types */
280 /* We hold several abbreviation tables in memory at the same time. */
281 #ifndef ABBREV_HASH_SIZE
282 #define ABBREV_HASH_SIZE 121
285 /* The data in a compilation unit header, after target2host
286 translation, looks like this. */
287 struct comp_unit_head
291 unsigned char addr_size;
292 unsigned char signed_addr_p;
293 unsigned int abbrev_offset;
295 /* Size of file offsets; either 4 or 8. */
296 unsigned int offset_size;
298 /* Size of the length field; either 4 or 12. */
299 unsigned int initial_length_size;
301 /* Offset to the first byte of this compilation unit header in the
302 .debug_info section, for resolving relative reference dies. */
305 /* Offset to first die in this cu from the start of the cu.
306 This will be the first byte following the compilation unit header. */
307 unsigned int first_die_offset;
310 /* Type used for delaying computation of method physnames.
311 See comments for compute_delayed_physnames. */
312 struct delayed_method_info
314 /* The type to which the method is attached, i.e., its parent class. */
317 /* The index of the method in the type's function fieldlists. */
320 /* The index of the method in the fieldlist. */
323 /* The name of the DIE. */
326 /* The DIE associated with this method. */
327 struct die_info *die;
330 typedef struct delayed_method_info delayed_method_info;
331 DEF_VEC_O (delayed_method_info);
333 /* Internal state when decoding a particular compilation unit. */
336 /* The objfile containing this compilation unit. */
337 struct objfile *objfile;
339 /* The header of the compilation unit. */
340 struct comp_unit_head header;
342 /* Base address of this compilation unit. */
343 CORE_ADDR base_address;
345 /* Non-zero if base_address has been set. */
348 struct function_range *first_fn, *last_fn, *cached_fn;
350 /* The language we are debugging. */
351 enum language language;
352 const struct language_defn *language_defn;
354 const char *producer;
356 /* The generic symbol table building routines have separate lists for
357 file scope symbols and all all other scopes (local scopes). So
358 we need to select the right one to pass to add_symbol_to_list().
359 We do it by keeping a pointer to the correct list in list_in_scope.
361 FIXME: The original dwarf code just treated the file scope as the
362 first local scope, and all other local scopes as nested local
363 scopes, and worked fine. Check to see if we really need to
364 distinguish these in buildsym.c. */
365 struct pending **list_in_scope;
367 /* DWARF abbreviation table associated with this compilation unit. */
368 struct abbrev_info **dwarf2_abbrevs;
370 /* Storage for the abbrev table. */
371 struct obstack abbrev_obstack;
373 /* Hash table holding all the loaded partial DIEs. */
376 /* Storage for things with the same lifetime as this read-in compilation
377 unit, including partial DIEs. */
378 struct obstack comp_unit_obstack;
380 /* When multiple dwarf2_cu structures are living in memory, this field
381 chains them all together, so that they can be released efficiently.
382 We will probably also want a generation counter so that most-recently-used
383 compilation units are cached... */
384 struct dwarf2_per_cu_data *read_in_chain;
386 /* Backchain to our per_cu entry if the tree has been built. */
387 struct dwarf2_per_cu_data *per_cu;
389 /* How many compilation units ago was this CU last referenced? */
392 /* A hash table of die offsets for following references. */
395 /* Full DIEs if read in. */
396 struct die_info *dies;
398 /* A set of pointers to dwarf2_per_cu_data objects for compilation
399 units referenced by this one. Only set during full symbol processing;
400 partial symbol tables do not have dependencies. */
403 /* Header data from the line table, during full symbol processing. */
404 struct line_header *line_header;
406 /* A list of methods which need to have physnames computed
407 after all type information has been read. */
408 VEC (delayed_method_info) *method_list;
410 /* To be copied to symtab->call_site_htab. */
411 htab_t call_site_htab;
413 /* Mark used when releasing cached dies. */
414 unsigned int mark : 1;
416 /* This flag will be set if this compilation unit might include
417 inter-compilation-unit references. */
418 unsigned int has_form_ref_addr : 1;
420 /* This flag will be set if this compilation unit includes any
421 DW_TAG_namespace DIEs. If we know that there are explicit
422 DIEs for namespaces, we don't need to try to infer them
423 from mangled names. */
424 unsigned int has_namespace_info : 1;
426 /* This CU references .debug_loc. See the symtab->locations_valid field.
427 This test is imperfect as there may exist optimized debug code not using
428 any location list and still facing inlining issues if handled as
429 unoptimized code. For a future better test see GCC PR other/32998. */
431 unsigned int has_loclist : 1;
434 /* Persistent data held for a compilation unit, even when not
435 processing it. We put a pointer to this structure in the
436 read_symtab_private field of the psymtab. If we encounter
437 inter-compilation-unit references, we also maintain a sorted
438 list of all compilation units. */
440 struct dwarf2_per_cu_data
442 /* The start offset and length of this compilation unit. 2**29-1
443 bytes should suffice to store the length of any compilation unit
444 - if it doesn't, GDB will fall over anyway.
445 NOTE: Unlike comp_unit_head.length, this length includes
446 initial_length_size. */
448 unsigned int length : 29;
450 /* Flag indicating this compilation unit will be read in before
451 any of the current compilation units are processed. */
452 unsigned int queued : 1;
454 /* This flag will be set if we need to load absolutely all DIEs
455 for this compilation unit, instead of just the ones we think
456 are interesting. It gets set if we look for a DIE in the
457 hash table and don't find it. */
458 unsigned int load_all_dies : 1;
460 /* Non-null if this CU is from .debug_types; in which case it points
461 to the section. Otherwise it's from .debug_info. */
462 struct dwarf2_section_info *debug_type_section;
464 /* Set to non-NULL iff this CU is currently loaded. When it gets freed out
465 of the CU cache it gets reset to NULL again. */
466 struct dwarf2_cu *cu;
468 /* The corresponding objfile. */
469 struct objfile *objfile;
471 /* When using partial symbol tables, the 'psymtab' field is active.
472 Otherwise the 'quick' field is active. */
475 /* The partial symbol table associated with this compilation unit,
476 or NULL for partial units (which do not have an associated
478 struct partial_symtab *psymtab;
480 /* Data needed by the "quick" functions. */
481 struct dwarf2_per_cu_quick_data *quick;
485 /* Entry in the signatured_types hash table. */
487 struct signatured_type
491 /* Offset in .debug_types of the type defined by this TU. */
492 unsigned int type_offset;
494 /* The CU(/TU) of this type. */
495 struct dwarf2_per_cu_data per_cu;
498 /* Struct used to pass misc. parameters to read_die_and_children, et
499 al. which are used for both .debug_info and .debug_types dies.
500 All parameters here are unchanging for the life of the call. This
501 struct exists to abstract away the constant parameters of die
504 struct die_reader_specs
506 /* The bfd of this objfile. */
509 /* The CU of the DIE we are parsing. */
510 struct dwarf2_cu *cu;
512 /* Pointer to start of section buffer.
513 This is either the start of .debug_info or .debug_types. */
514 const gdb_byte *buffer;
517 /* The line number information for a compilation unit (found in the
518 .debug_line section) begins with a "statement program header",
519 which contains the following information. */
522 unsigned int total_length;
523 unsigned short version;
524 unsigned int header_length;
525 unsigned char minimum_instruction_length;
526 unsigned char maximum_ops_per_instruction;
527 unsigned char default_is_stmt;
529 unsigned char line_range;
530 unsigned char opcode_base;
532 /* standard_opcode_lengths[i] is the number of operands for the
533 standard opcode whose value is i. This means that
534 standard_opcode_lengths[0] is unused, and the last meaningful
535 element is standard_opcode_lengths[opcode_base - 1]. */
536 unsigned char *standard_opcode_lengths;
538 /* The include_directories table. NOTE! These strings are not
539 allocated with xmalloc; instead, they are pointers into
540 debug_line_buffer. If you try to free them, `free' will get
542 unsigned int num_include_dirs, include_dirs_size;
545 /* The file_names table. NOTE! These strings are not allocated
546 with xmalloc; instead, they are pointers into debug_line_buffer.
547 Don't try to free them directly. */
548 unsigned int num_file_names, file_names_size;
552 unsigned int dir_index;
553 unsigned int mod_time;
555 int included_p; /* Non-zero if referenced by the Line Number Program. */
556 struct symtab *symtab; /* The associated symbol table, if any. */
559 /* The start and end of the statement program following this
560 header. These point into dwarf2_per_objfile->line_buffer. */
561 gdb_byte *statement_program_start, *statement_program_end;
564 /* When we construct a partial symbol table entry we only
565 need this much information. */
566 struct partial_die_info
568 /* Offset of this DIE. */
571 /* DWARF-2 tag for this DIE. */
572 ENUM_BITFIELD(dwarf_tag) tag : 16;
574 /* Assorted flags describing the data found in this DIE. */
575 unsigned int has_children : 1;
576 unsigned int is_external : 1;
577 unsigned int is_declaration : 1;
578 unsigned int has_type : 1;
579 unsigned int has_specification : 1;
580 unsigned int has_pc_info : 1;
582 /* Flag set if the SCOPE field of this structure has been
584 unsigned int scope_set : 1;
586 /* Flag set if the DIE has a byte_size attribute. */
587 unsigned int has_byte_size : 1;
589 /* Flag set if any of the DIE's children are template arguments. */
590 unsigned int has_template_arguments : 1;
592 /* Flag set if fixup_partial_die has been called on this die. */
593 unsigned int fixup_called : 1;
595 /* The name of this DIE. Normally the value of DW_AT_name, but
596 sometimes a default name for unnamed DIEs. */
599 /* The linkage name, if present. */
600 const char *linkage_name;
602 /* The scope to prepend to our children. This is generally
603 allocated on the comp_unit_obstack, so will disappear
604 when this compilation unit leaves the cache. */
607 /* The location description associated with this DIE, if any. */
608 struct dwarf_block *locdesc;
610 /* If HAS_PC_INFO, the PC range associated with this DIE. */
614 /* Pointer into the info_buffer (or types_buffer) pointing at the target of
615 DW_AT_sibling, if any. */
616 /* NOTE: This member isn't strictly necessary, read_partial_die could
617 return DW_AT_sibling values to its caller load_partial_dies. */
620 /* If HAS_SPECIFICATION, the offset of the DIE referred to by
621 DW_AT_specification (or DW_AT_abstract_origin or
623 unsigned int spec_offset;
625 /* Pointers to this DIE's parent, first child, and next sibling,
627 struct partial_die_info *die_parent, *die_child, *die_sibling;
630 /* This data structure holds the information of an abbrev. */
633 unsigned int number; /* number identifying abbrev */
634 enum dwarf_tag tag; /* dwarf tag */
635 unsigned short has_children; /* boolean */
636 unsigned short num_attrs; /* number of attributes */
637 struct attr_abbrev *attrs; /* an array of attribute descriptions */
638 struct abbrev_info *next; /* next in chain */
643 ENUM_BITFIELD(dwarf_attribute) name : 16;
644 ENUM_BITFIELD(dwarf_form) form : 16;
647 /* Attributes have a name and a value. */
650 ENUM_BITFIELD(dwarf_attribute) name : 16;
651 ENUM_BITFIELD(dwarf_form) form : 15;
653 /* Has DW_STRING already been updated by dwarf2_canonicalize_name? This
654 field should be in u.str (existing only for DW_STRING) but it is kept
655 here for better struct attribute alignment. */
656 unsigned int string_is_canonical : 1;
661 struct dwarf_block *blk;
665 struct signatured_type *signatured_type;
670 /* This data structure holds a complete die structure. */
673 /* DWARF-2 tag for this DIE. */
674 ENUM_BITFIELD(dwarf_tag) tag : 16;
676 /* Number of attributes */
677 unsigned char num_attrs;
679 /* True if we're presently building the full type name for the
680 type derived from this DIE. */
681 unsigned char building_fullname : 1;
686 /* Offset in .debug_info or .debug_types section. */
689 /* The dies in a compilation unit form an n-ary tree. PARENT
690 points to this die's parent; CHILD points to the first child of
691 this node; and all the children of a given node are chained
692 together via their SIBLING fields. */
693 struct die_info *child; /* Its first child, if any. */
694 struct die_info *sibling; /* Its next sibling, if any. */
695 struct die_info *parent; /* Its parent, if any. */
697 /* An array of attributes, with NUM_ATTRS elements. There may be
698 zero, but it's not common and zero-sized arrays are not
699 sufficiently portable C. */
700 struct attribute attrs[1];
703 struct function_range
706 CORE_ADDR lowpc, highpc;
708 struct function_range *next;
711 /* Get at parts of an attribute structure. */
713 #define DW_STRING(attr) ((attr)->u.str)
714 #define DW_STRING_IS_CANONICAL(attr) ((attr)->string_is_canonical)
715 #define DW_UNSND(attr) ((attr)->u.unsnd)
716 #define DW_BLOCK(attr) ((attr)->u.blk)
717 #define DW_SND(attr) ((attr)->u.snd)
718 #define DW_ADDR(attr) ((attr)->u.addr)
719 #define DW_SIGNATURED_TYPE(attr) ((attr)->u.signatured_type)
721 /* Blocks are a bunch of untyped bytes. */
726 /* Valid only if SIZE is not zero. */
730 #ifndef ATTR_ALLOC_CHUNK
731 #define ATTR_ALLOC_CHUNK 4
734 /* Allocate fields for structs, unions and enums in this size. */
735 #ifndef DW_FIELD_ALLOC_CHUNK
736 #define DW_FIELD_ALLOC_CHUNK 4
739 /* FIXME: We might want to set this from BFD via bfd_arch_bits_per_byte,
740 but this would require a corresponding change in unpack_field_as_long
742 static int bits_per_byte = 8;
744 /* The routines that read and process dies for a C struct or C++ class
745 pass lists of data member fields and lists of member function fields
746 in an instance of a field_info structure, as defined below. */
749 /* List of data member and baseclasses fields. */
752 struct nextfield *next;
757 *fields, *baseclasses;
759 /* Number of fields (including baseclasses). */
762 /* Number of baseclasses. */
765 /* Set if the accesibility of one of the fields is not public. */
766 int non_public_fields;
768 /* Member function fields array, entries are allocated in the order they
769 are encountered in the object file. */
772 struct nextfnfield *next;
773 struct fn_field fnfield;
777 /* Member function fieldlist array, contains name of possibly overloaded
778 member function, number of overloaded member functions and a pointer
779 to the head of the member function field chain. */
784 struct nextfnfield *head;
788 /* Number of entries in the fnfieldlists array. */
791 /* typedefs defined inside this class. TYPEDEF_FIELD_LIST contains head of
792 a NULL terminated list of TYPEDEF_FIELD_LIST_COUNT elements. */
793 struct typedef_field_list
795 struct typedef_field field;
796 struct typedef_field_list *next;
799 unsigned typedef_field_list_count;
802 /* One item on the queue of compilation units to read in full symbols
804 struct dwarf2_queue_item
806 struct dwarf2_per_cu_data *per_cu;
807 struct dwarf2_queue_item *next;
810 /* The current queue. */
811 static struct dwarf2_queue_item *dwarf2_queue, *dwarf2_queue_tail;
813 /* Loaded secondary compilation units are kept in memory until they
814 have not been referenced for the processing of this many
815 compilation units. Set this to zero to disable caching. Cache
816 sizes of up to at least twenty will improve startup time for
817 typical inter-CU-reference binaries, at an obvious memory cost. */
818 static int dwarf2_max_cache_age = 5;
820 show_dwarf2_max_cache_age (struct ui_file *file, int from_tty,
821 struct cmd_list_element *c, const char *value)
823 fprintf_filtered (file, _("The upper bound on the age of cached "
824 "dwarf2 compilation units is %s.\n"),
829 /* Various complaints about symbol reading that don't abort the process. */
832 dwarf2_statement_list_fits_in_line_number_section_complaint (void)
834 complaint (&symfile_complaints,
835 _("statement list doesn't fit in .debug_line section"));
839 dwarf2_debug_line_missing_file_complaint (void)
841 complaint (&symfile_complaints,
842 _(".debug_line section has line data without a file"));
846 dwarf2_debug_line_missing_end_sequence_complaint (void)
848 complaint (&symfile_complaints,
849 _(".debug_line section has line "
850 "program sequence without an end"));
854 dwarf2_complex_location_expr_complaint (void)
856 complaint (&symfile_complaints, _("location expression too complex"));
860 dwarf2_const_value_length_mismatch_complaint (const char *arg1, int arg2,
863 complaint (&symfile_complaints,
864 _("const value length mismatch for '%s', got %d, expected %d"),
869 dwarf2_macros_too_long_complaint (struct dwarf2_section_info *section)
871 complaint (&symfile_complaints,
872 _("macro info runs off end of `%s' section"),
873 section->asection->name);
877 dwarf2_macro_malformed_definition_complaint (const char *arg1)
879 complaint (&symfile_complaints,
880 _("macro debug info contains a "
881 "malformed macro definition:\n`%s'"),
886 dwarf2_invalid_attrib_class_complaint (const char *arg1, const char *arg2)
888 complaint (&symfile_complaints,
889 _("invalid attribute class or form for '%s' in '%s'"),
893 /* local function prototypes */
895 static void dwarf2_locate_sections (bfd *, asection *, void *);
897 static void dwarf2_create_include_psymtab (char *, struct partial_symtab *,
900 static void dwarf2_find_base_address (struct die_info *die,
901 struct dwarf2_cu *cu);
903 static void dwarf2_build_psymtabs_hard (struct objfile *);
905 static void scan_partial_symbols (struct partial_die_info *,
906 CORE_ADDR *, CORE_ADDR *,
907 int, struct dwarf2_cu *);
909 static void add_partial_symbol (struct partial_die_info *,
912 static void add_partial_namespace (struct partial_die_info *pdi,
913 CORE_ADDR *lowpc, CORE_ADDR *highpc,
914 int need_pc, struct dwarf2_cu *cu);
916 static void add_partial_module (struct partial_die_info *pdi, CORE_ADDR *lowpc,
917 CORE_ADDR *highpc, int need_pc,
918 struct dwarf2_cu *cu);
920 static void add_partial_enumeration (struct partial_die_info *enum_pdi,
921 struct dwarf2_cu *cu);
923 static void add_partial_subprogram (struct partial_die_info *pdi,
924 CORE_ADDR *lowpc, CORE_ADDR *highpc,
925 int need_pc, struct dwarf2_cu *cu);
927 static gdb_byte *locate_pdi_sibling (struct partial_die_info *orig_pdi,
928 gdb_byte *buffer, gdb_byte *info_ptr,
929 bfd *abfd, struct dwarf2_cu *cu);
931 static void dwarf2_psymtab_to_symtab (struct partial_symtab *);
933 static void psymtab_to_symtab_1 (struct partial_symtab *);
935 static void dwarf2_read_abbrevs (bfd *abfd, struct dwarf2_cu *cu);
937 static void dwarf2_free_abbrev_table (void *);
939 static unsigned int peek_abbrev_code (bfd *, gdb_byte *);
941 static struct abbrev_info *peek_die_abbrev (gdb_byte *, unsigned int *,
944 static struct abbrev_info *dwarf2_lookup_abbrev (unsigned int,
947 static struct partial_die_info *load_partial_dies (bfd *,
948 gdb_byte *, gdb_byte *,
949 int, struct dwarf2_cu *);
951 static gdb_byte *read_partial_die (struct partial_die_info *,
952 struct abbrev_info *abbrev,
954 gdb_byte *, gdb_byte *,
957 static struct partial_die_info *find_partial_die (unsigned int,
960 static void fixup_partial_die (struct partial_die_info *,
963 static gdb_byte *read_attribute (struct attribute *, struct attr_abbrev *,
964 bfd *, gdb_byte *, struct dwarf2_cu *);
966 static gdb_byte *read_attribute_value (struct attribute *, unsigned,
967 bfd *, gdb_byte *, struct dwarf2_cu *);
969 static unsigned int read_1_byte (bfd *, gdb_byte *);
971 static int read_1_signed_byte (bfd *, gdb_byte *);
973 static unsigned int read_2_bytes (bfd *, gdb_byte *);
975 static unsigned int read_4_bytes (bfd *, gdb_byte *);
977 static ULONGEST read_8_bytes (bfd *, gdb_byte *);
979 static CORE_ADDR read_address (bfd *, gdb_byte *ptr, struct dwarf2_cu *,
982 static LONGEST read_initial_length (bfd *, gdb_byte *, unsigned int *);
984 static LONGEST read_checked_initial_length_and_offset
985 (bfd *, gdb_byte *, const struct comp_unit_head *,
986 unsigned int *, unsigned int *);
988 static LONGEST read_offset (bfd *, gdb_byte *, const struct comp_unit_head *,
991 static LONGEST read_offset_1 (bfd *, gdb_byte *, unsigned int);
993 static gdb_byte *read_n_bytes (bfd *, gdb_byte *, unsigned int);
995 static char *read_direct_string (bfd *, gdb_byte *, unsigned int *);
997 static char *read_indirect_string (bfd *, gdb_byte *,
998 const struct comp_unit_head *,
1001 static unsigned long read_unsigned_leb128 (bfd *, gdb_byte *, unsigned int *);
1003 static long read_signed_leb128 (bfd *, gdb_byte *, unsigned int *);
1005 static gdb_byte *skip_leb128 (bfd *, gdb_byte *);
1007 static void set_cu_language (unsigned int, struct dwarf2_cu *);
1009 static struct attribute *dwarf2_attr (struct die_info *, unsigned int,
1010 struct dwarf2_cu *);
1012 static struct attribute *dwarf2_attr_no_follow (struct die_info *,
1014 struct dwarf2_cu *);
1016 static int dwarf2_flag_true_p (struct die_info *die, unsigned name,
1017 struct dwarf2_cu *cu);
1019 static int die_is_declaration (struct die_info *, struct dwarf2_cu *cu);
1021 static struct die_info *die_specification (struct die_info *die,
1022 struct dwarf2_cu **);
1024 static void free_line_header (struct line_header *lh);
1026 static void add_file_name (struct line_header *, char *, unsigned int,
1027 unsigned int, unsigned int);
1029 static struct line_header *(dwarf_decode_line_header
1030 (unsigned int offset,
1031 bfd *abfd, struct dwarf2_cu *cu));
1033 static void dwarf_decode_lines (struct line_header *, const char *, bfd *,
1034 struct dwarf2_cu *, struct partial_symtab *);
1036 static void dwarf2_start_subfile (char *, const char *, const char *);
1038 static struct symbol *new_symbol (struct die_info *, struct type *,
1039 struct dwarf2_cu *);
1041 static struct symbol *new_symbol_full (struct die_info *, struct type *,
1042 struct dwarf2_cu *, struct symbol *);
1044 static void dwarf2_const_value (struct attribute *, struct symbol *,
1045 struct dwarf2_cu *);
1047 static void dwarf2_const_value_attr (struct attribute *attr,
1050 struct obstack *obstack,
1051 struct dwarf2_cu *cu, long *value,
1053 struct dwarf2_locexpr_baton **baton);
1055 static struct type *die_type (struct die_info *, struct dwarf2_cu *);
1057 static int need_gnat_info (struct dwarf2_cu *);
1059 static struct type *die_descriptive_type (struct die_info *,
1060 struct dwarf2_cu *);
1062 static void set_descriptive_type (struct type *, struct die_info *,
1063 struct dwarf2_cu *);
1065 static struct type *die_containing_type (struct die_info *,
1066 struct dwarf2_cu *);
1068 static struct type *lookup_die_type (struct die_info *, struct attribute *,
1069 struct dwarf2_cu *);
1071 static struct type *read_type_die (struct die_info *, struct dwarf2_cu *);
1073 static struct type *read_type_die_1 (struct die_info *, struct dwarf2_cu *);
1075 static char *determine_prefix (struct die_info *die, struct dwarf2_cu *);
1077 static char *typename_concat (struct obstack *obs, const char *prefix,
1078 const char *suffix, int physname,
1079 struct dwarf2_cu *cu);
1081 static void read_file_scope (struct die_info *, struct dwarf2_cu *);
1083 static void read_type_unit_scope (struct die_info *, struct dwarf2_cu *);
1085 static void read_func_scope (struct die_info *, struct dwarf2_cu *);
1087 static void read_lexical_block_scope (struct die_info *, struct dwarf2_cu *);
1089 static void read_call_site_scope (struct die_info *die, struct dwarf2_cu *cu);
1091 static int dwarf2_ranges_read (unsigned, CORE_ADDR *, CORE_ADDR *,
1092 struct dwarf2_cu *, struct partial_symtab *);
1094 static int dwarf2_get_pc_bounds (struct die_info *,
1095 CORE_ADDR *, CORE_ADDR *, struct dwarf2_cu *,
1096 struct partial_symtab *);
1098 static void get_scope_pc_bounds (struct die_info *,
1099 CORE_ADDR *, CORE_ADDR *,
1100 struct dwarf2_cu *);
1102 static void dwarf2_record_block_ranges (struct die_info *, struct block *,
1103 CORE_ADDR, struct dwarf2_cu *);
1105 static void dwarf2_add_field (struct field_info *, struct die_info *,
1106 struct dwarf2_cu *);
1108 static void dwarf2_attach_fields_to_type (struct field_info *,
1109 struct type *, struct dwarf2_cu *);
1111 static void dwarf2_add_member_fn (struct field_info *,
1112 struct die_info *, struct type *,
1113 struct dwarf2_cu *);
1115 static void dwarf2_attach_fn_fields_to_type (struct field_info *,
1117 struct dwarf2_cu *);
1119 static void process_structure_scope (struct die_info *, struct dwarf2_cu *);
1121 static void read_common_block (struct die_info *, struct dwarf2_cu *);
1123 static void read_namespace (struct die_info *die, struct dwarf2_cu *);
1125 static void read_module (struct die_info *die, struct dwarf2_cu *cu);
1127 static void read_import_statement (struct die_info *die, struct dwarf2_cu *);
1129 static struct type *read_module_type (struct die_info *die,
1130 struct dwarf2_cu *cu);
1132 static const char *namespace_name (struct die_info *die,
1133 int *is_anonymous, struct dwarf2_cu *);
1135 static void process_enumeration_scope (struct die_info *, struct dwarf2_cu *);
1137 static CORE_ADDR decode_locdesc (struct dwarf_block *, struct dwarf2_cu *);
1139 static enum dwarf_array_dim_ordering read_array_order (struct die_info *,
1140 struct dwarf2_cu *);
1142 static struct die_info *read_comp_unit (gdb_byte *, struct dwarf2_cu *);
1144 static struct die_info *read_die_and_children_1 (const struct die_reader_specs *reader,
1146 gdb_byte **new_info_ptr,
1147 struct die_info *parent);
1149 static struct die_info *read_die_and_children (const struct die_reader_specs *reader,
1151 gdb_byte **new_info_ptr,
1152 struct die_info *parent);
1154 static struct die_info *read_die_and_siblings (const struct die_reader_specs *reader,
1156 gdb_byte **new_info_ptr,
1157 struct die_info *parent);
1159 static gdb_byte *read_full_die (const struct die_reader_specs *reader,
1160 struct die_info **, gdb_byte *,
1163 static void process_die (struct die_info *, struct dwarf2_cu *);
1165 static char *dwarf2_canonicalize_name (char *, struct dwarf2_cu *,
1168 static char *dwarf2_name (struct die_info *die, struct dwarf2_cu *);
1170 static const char *dwarf2_full_name (char *name,
1171 struct die_info *die,
1172 struct dwarf2_cu *cu);
1174 static struct die_info *dwarf2_extension (struct die_info *die,
1175 struct dwarf2_cu **);
1177 static char *dwarf_tag_name (unsigned int);
1179 static char *dwarf_attr_name (unsigned int);
1181 static char *dwarf_form_name (unsigned int);
1183 static char *dwarf_bool_name (unsigned int);
1185 static char *dwarf_type_encoding_name (unsigned int);
1188 static char *dwarf_cfi_name (unsigned int);
1191 static struct die_info *sibling_die (struct die_info *);
1193 static void dump_die_shallow (struct ui_file *, int indent, struct die_info *);
1195 static void dump_die_for_error (struct die_info *);
1197 static void dump_die_1 (struct ui_file *, int level, int max_level,
1200 /*static*/ void dump_die (struct die_info *, int max_level);
1202 static void store_in_ref_table (struct die_info *,
1203 struct dwarf2_cu *);
1205 static int is_ref_attr (struct attribute *);
1207 static unsigned int dwarf2_get_ref_die_offset (struct attribute *);
1209 static LONGEST dwarf2_get_attr_constant_value (struct attribute *, int);
1211 static struct die_info *follow_die_ref_or_sig (struct die_info *,
1213 struct dwarf2_cu **);
1215 static struct die_info *follow_die_ref (struct die_info *,
1217 struct dwarf2_cu **);
1219 static struct die_info *follow_die_sig (struct die_info *,
1221 struct dwarf2_cu **);
1223 static struct signatured_type *lookup_signatured_type_at_offset
1224 (struct objfile *objfile,
1225 struct dwarf2_section_info *section,
1226 unsigned int offset);
1228 static void read_signatured_type_at_offset (struct objfile *objfile,
1229 struct dwarf2_section_info *sect,
1230 unsigned int offset);
1232 static void read_signatured_type (struct objfile *,
1233 struct signatured_type *type_sig);
1235 /* memory allocation interface */
1237 static struct dwarf_block *dwarf_alloc_block (struct dwarf2_cu *);
1239 static struct abbrev_info *dwarf_alloc_abbrev (struct dwarf2_cu *);
1241 static struct die_info *dwarf_alloc_die (struct dwarf2_cu *, int);
1243 static void initialize_cu_func_list (struct dwarf2_cu *);
1245 static void add_to_cu_func_list (const char *, CORE_ADDR, CORE_ADDR,
1246 struct dwarf2_cu *);
1248 static void dwarf_decode_macros (struct line_header *, unsigned int,
1249 char *, bfd *, struct dwarf2_cu *,
1250 struct dwarf2_section_info *,
1253 static int attr_form_is_block (struct attribute *);
1255 static int attr_form_is_section_offset (struct attribute *);
1257 static int attr_form_is_constant (struct attribute *);
1259 static void fill_in_loclist_baton (struct dwarf2_cu *cu,
1260 struct dwarf2_loclist_baton *baton,
1261 struct attribute *attr);
1263 static void dwarf2_symbol_mark_computed (struct attribute *attr,
1265 struct dwarf2_cu *cu);
1267 static gdb_byte *skip_one_die (gdb_byte *buffer, gdb_byte *info_ptr,
1268 struct abbrev_info *abbrev,
1269 struct dwarf2_cu *cu);
1271 static void free_stack_comp_unit (void *);
1273 static hashval_t partial_die_hash (const void *item);
1275 static int partial_die_eq (const void *item_lhs, const void *item_rhs);
1277 static struct dwarf2_per_cu_data *dwarf2_find_containing_comp_unit
1278 (unsigned int offset, struct objfile *objfile);
1280 static struct dwarf2_per_cu_data *dwarf2_find_comp_unit
1281 (unsigned int offset, struct objfile *objfile);
1283 static void init_one_comp_unit (struct dwarf2_cu *cu,
1284 struct objfile *objfile);
1286 static void prepare_one_comp_unit (struct dwarf2_cu *cu,
1287 struct die_info *comp_unit_die);
1289 static void free_one_comp_unit (void *);
1291 static void free_cached_comp_units (void *);
1293 static void age_cached_comp_units (void);
1295 static void free_one_cached_comp_unit (void *);
1297 static struct type *set_die_type (struct die_info *, struct type *,
1298 struct dwarf2_cu *);
1300 static void create_all_comp_units (struct objfile *);
1302 static int create_debug_types_hash_table (struct objfile *objfile);
1304 static void load_full_comp_unit (struct dwarf2_per_cu_data *,
1307 static void process_full_comp_unit (struct dwarf2_per_cu_data *);
1309 static void dwarf2_add_dependence (struct dwarf2_cu *,
1310 struct dwarf2_per_cu_data *);
1312 static void dwarf2_mark (struct dwarf2_cu *);
1314 static void dwarf2_clear_marks (struct dwarf2_per_cu_data *);
1316 static struct type *get_die_type_at_offset (unsigned int,
1317 struct dwarf2_per_cu_data *per_cu);
1319 static struct type *get_die_type (struct die_info *die, struct dwarf2_cu *cu);
1321 static void dwarf2_release_queue (void *dummy);
1323 static void queue_comp_unit (struct dwarf2_per_cu_data *per_cu,
1324 struct objfile *objfile);
1326 static void process_queue (struct objfile *objfile);
1328 static void find_file_and_directory (struct die_info *die,
1329 struct dwarf2_cu *cu,
1330 char **name, char **comp_dir);
1332 static char *file_full_name (int file, struct line_header *lh,
1333 const char *comp_dir);
1335 static gdb_byte *partial_read_comp_unit_head (struct comp_unit_head *header,
1338 unsigned int buffer_size,
1341 static void init_cu_die_reader (struct die_reader_specs *reader,
1342 struct dwarf2_cu *cu);
1344 static htab_t allocate_signatured_type_table (struct objfile *objfile);
1348 /* Convert VALUE between big- and little-endian. */
1350 byte_swap (offset_type value)
1354 result = (value & 0xff) << 24;
1355 result |= (value & 0xff00) << 8;
1356 result |= (value & 0xff0000) >> 8;
1357 result |= (value & 0xff000000) >> 24;
1361 #define MAYBE_SWAP(V) byte_swap (V)
1364 #define MAYBE_SWAP(V) (V)
1365 #endif /* WORDS_BIGENDIAN */
1367 /* The suffix for an index file. */
1368 #define INDEX_SUFFIX ".gdb-index"
1370 static const char *dwarf2_physname (char *name, struct die_info *die,
1371 struct dwarf2_cu *cu);
1373 /* Try to locate the sections we need for DWARF 2 debugging
1374 information and return true if we have enough to do something.
1375 NAMES points to the dwarf2 section names, or is NULL if the standard
1376 ELF names are used. */
1379 dwarf2_has_info (struct objfile *objfile,
1380 const struct dwarf2_debug_sections *names)
1382 dwarf2_per_objfile = objfile_data (objfile, dwarf2_objfile_data_key);
1383 if (!dwarf2_per_objfile)
1385 /* Initialize per-objfile state. */
1386 struct dwarf2_per_objfile *data
1387 = obstack_alloc (&objfile->objfile_obstack, sizeof (*data));
1389 memset (data, 0, sizeof (*data));
1390 set_objfile_data (objfile, dwarf2_objfile_data_key, data);
1391 dwarf2_per_objfile = data;
1393 bfd_map_over_sections (objfile->obfd, dwarf2_locate_sections,
1395 dwarf2_per_objfile->objfile = objfile;
1397 return (dwarf2_per_objfile->info.asection != NULL
1398 && dwarf2_per_objfile->abbrev.asection != NULL);
1401 /* When loading sections, we look either for uncompressed section or for
1402 compressed section names. */
1405 section_is_p (const char *section_name,
1406 const struct dwarf2_section_names *names)
1408 if (names->normal != NULL
1409 && strcmp (section_name, names->normal) == 0)
1411 if (names->compressed != NULL
1412 && strcmp (section_name, names->compressed) == 0)
1417 /* This function is mapped across the sections and remembers the
1418 offset and size of each of the debugging sections we are interested
1422 dwarf2_locate_sections (bfd *abfd, asection *sectp, void *vnames)
1424 const struct dwarf2_debug_sections *names;
1427 names = &dwarf2_elf_names;
1429 names = (const struct dwarf2_debug_sections *) vnames;
1431 if (section_is_p (sectp->name, &names->info))
1433 dwarf2_per_objfile->info.asection = sectp;
1434 dwarf2_per_objfile->info.size = bfd_get_section_size (sectp);
1436 else if (section_is_p (sectp->name, &names->abbrev))
1438 dwarf2_per_objfile->abbrev.asection = sectp;
1439 dwarf2_per_objfile->abbrev.size = bfd_get_section_size (sectp);
1441 else if (section_is_p (sectp->name, &names->line))
1443 dwarf2_per_objfile->line.asection = sectp;
1444 dwarf2_per_objfile->line.size = bfd_get_section_size (sectp);
1446 else if (section_is_p (sectp->name, &names->loc))
1448 dwarf2_per_objfile->loc.asection = sectp;
1449 dwarf2_per_objfile->loc.size = bfd_get_section_size (sectp);
1451 else if (section_is_p (sectp->name, &names->macinfo))
1453 dwarf2_per_objfile->macinfo.asection = sectp;
1454 dwarf2_per_objfile->macinfo.size = bfd_get_section_size (sectp);
1456 else if (section_is_p (sectp->name, &names->macro))
1458 dwarf2_per_objfile->macro.asection = sectp;
1459 dwarf2_per_objfile->macro.size = bfd_get_section_size (sectp);
1461 else if (section_is_p (sectp->name, &names->str))
1463 dwarf2_per_objfile->str.asection = sectp;
1464 dwarf2_per_objfile->str.size = bfd_get_section_size (sectp);
1466 else if (section_is_p (sectp->name, &names->frame))
1468 dwarf2_per_objfile->frame.asection = sectp;
1469 dwarf2_per_objfile->frame.size = bfd_get_section_size (sectp);
1471 else if (section_is_p (sectp->name, &names->eh_frame))
1473 flagword aflag = bfd_get_section_flags (ignore_abfd, sectp);
1475 if (aflag & SEC_HAS_CONTENTS)
1477 dwarf2_per_objfile->eh_frame.asection = sectp;
1478 dwarf2_per_objfile->eh_frame.size = bfd_get_section_size (sectp);
1481 else if (section_is_p (sectp->name, &names->ranges))
1483 dwarf2_per_objfile->ranges.asection = sectp;
1484 dwarf2_per_objfile->ranges.size = bfd_get_section_size (sectp);
1486 else if (section_is_p (sectp->name, &names->types))
1488 struct dwarf2_section_info type_section;
1490 memset (&type_section, 0, sizeof (type_section));
1491 type_section.asection = sectp;
1492 type_section.size = bfd_get_section_size (sectp);
1494 VEC_safe_push (dwarf2_section_info_def, dwarf2_per_objfile->types,
1497 else if (section_is_p (sectp->name, &names->gdb_index))
1499 dwarf2_per_objfile->gdb_index.asection = sectp;
1500 dwarf2_per_objfile->gdb_index.size = bfd_get_section_size (sectp);
1503 if ((bfd_get_section_flags (abfd, sectp) & SEC_LOAD)
1504 && bfd_section_vma (abfd, sectp) == 0)
1505 dwarf2_per_objfile->has_section_at_zero = 1;
1508 /* Decompress a section that was compressed using zlib. Store the
1509 decompressed buffer, and its size, in OUTBUF and OUTSIZE. */
1512 zlib_decompress_section (struct objfile *objfile, asection *sectp,
1513 gdb_byte **outbuf, bfd_size_type *outsize)
1515 bfd *abfd = objfile->obfd;
1517 error (_("Support for zlib-compressed DWARF data (from '%s') "
1518 "is disabled in this copy of GDB"),
1519 bfd_get_filename (abfd));
1521 bfd_size_type compressed_size = bfd_get_section_size (sectp);
1522 gdb_byte *compressed_buffer = xmalloc (compressed_size);
1523 struct cleanup *cleanup = make_cleanup (xfree, compressed_buffer);
1524 bfd_size_type uncompressed_size;
1525 gdb_byte *uncompressed_buffer;
1528 int header_size = 12;
1530 if (bfd_seek (abfd, sectp->filepos, SEEK_SET) != 0
1531 || bfd_bread (compressed_buffer,
1532 compressed_size, abfd) != compressed_size)
1533 error (_("Dwarf Error: Can't read DWARF data from '%s'"),
1534 bfd_get_filename (abfd));
1536 /* Read the zlib header. In this case, it should be "ZLIB" followed
1537 by the uncompressed section size, 8 bytes in big-endian order. */
1538 if (compressed_size < header_size
1539 || strncmp (compressed_buffer, "ZLIB", 4) != 0)
1540 error (_("Dwarf Error: Corrupt DWARF ZLIB header from '%s'"),
1541 bfd_get_filename (abfd));
1542 uncompressed_size = compressed_buffer[4]; uncompressed_size <<= 8;
1543 uncompressed_size += compressed_buffer[5]; uncompressed_size <<= 8;
1544 uncompressed_size += compressed_buffer[6]; uncompressed_size <<= 8;
1545 uncompressed_size += compressed_buffer[7]; uncompressed_size <<= 8;
1546 uncompressed_size += compressed_buffer[8]; uncompressed_size <<= 8;
1547 uncompressed_size += compressed_buffer[9]; uncompressed_size <<= 8;
1548 uncompressed_size += compressed_buffer[10]; uncompressed_size <<= 8;
1549 uncompressed_size += compressed_buffer[11];
1551 /* It is possible the section consists of several compressed
1552 buffers concatenated together, so we uncompress in a loop. */
1556 strm.avail_in = compressed_size - header_size;
1557 strm.next_in = (Bytef*) compressed_buffer + header_size;
1558 strm.avail_out = uncompressed_size;
1559 uncompressed_buffer = obstack_alloc (&objfile->objfile_obstack,
1561 rc = inflateInit (&strm);
1562 while (strm.avail_in > 0)
1565 error (_("Dwarf Error: setting up DWARF uncompression in '%s': %d"),
1566 bfd_get_filename (abfd), rc);
1567 strm.next_out = ((Bytef*) uncompressed_buffer
1568 + (uncompressed_size - strm.avail_out));
1569 rc = inflate (&strm, Z_FINISH);
1570 if (rc != Z_STREAM_END)
1571 error (_("Dwarf Error: zlib error uncompressing from '%s': %d"),
1572 bfd_get_filename (abfd), rc);
1573 rc = inflateReset (&strm);
1575 rc = inflateEnd (&strm);
1577 || strm.avail_out != 0)
1578 error (_("Dwarf Error: concluding DWARF uncompression in '%s': %d"),
1579 bfd_get_filename (abfd), rc);
1581 do_cleanups (cleanup);
1582 *outbuf = uncompressed_buffer;
1583 *outsize = uncompressed_size;
1587 /* A helper function that decides whether a section is empty. */
1590 dwarf2_section_empty_p (struct dwarf2_section_info *info)
1592 return info->asection == NULL || info->size == 0;
1595 /* Read the contents of the section SECTP from object file specified by
1596 OBJFILE, store info about the section into INFO.
1597 If the section is compressed, uncompress it before returning. */
1600 dwarf2_read_section (struct objfile *objfile, struct dwarf2_section_info *info)
1602 bfd *abfd = objfile->obfd;
1603 asection *sectp = info->asection;
1604 gdb_byte *buf, *retbuf;
1605 unsigned char header[4];
1609 info->buffer = NULL;
1610 info->map_addr = NULL;
1613 if (dwarf2_section_empty_p (info))
1616 /* Check if the file has a 4-byte header indicating compression. */
1617 if (info->size > sizeof (header)
1618 && bfd_seek (abfd, sectp->filepos, SEEK_SET) == 0
1619 && bfd_bread (header, sizeof (header), abfd) == sizeof (header))
1621 /* Upon decompression, update the buffer and its size. */
1622 if (strncmp (header, "ZLIB", sizeof (header)) == 0)
1624 zlib_decompress_section (objfile, sectp, &info->buffer,
1632 pagesize = getpagesize ();
1634 /* Only try to mmap sections which are large enough: we don't want to
1635 waste space due to fragmentation. Also, only try mmap for sections
1636 without relocations. */
1638 if (info->size > 4 * pagesize && (sectp->flags & SEC_RELOC) == 0)
1640 info->buffer = bfd_mmap (abfd, 0, info->size, PROT_READ,
1641 MAP_PRIVATE, sectp->filepos,
1642 &info->map_addr, &info->map_len);
1644 if ((caddr_t)info->buffer != MAP_FAILED)
1646 #if HAVE_POSIX_MADVISE
1647 posix_madvise (info->map_addr, info->map_len, POSIX_MADV_WILLNEED);
1654 /* If we get here, we are a normal, not-compressed section. */
1656 = obstack_alloc (&objfile->objfile_obstack, info->size);
1658 /* When debugging .o files, we may need to apply relocations; see
1659 http://sourceware.org/ml/gdb-patches/2002-04/msg00136.html .
1660 We never compress sections in .o files, so we only need to
1661 try this when the section is not compressed. */
1662 retbuf = symfile_relocate_debug_section (objfile, sectp, buf);
1665 info->buffer = retbuf;
1669 if (bfd_seek (abfd, sectp->filepos, SEEK_SET) != 0
1670 || bfd_bread (buf, info->size, abfd) != info->size)
1671 error (_("Dwarf Error: Can't read DWARF data from '%s'"),
1672 bfd_get_filename (abfd));
1675 /* A helper function that returns the size of a section in a safe way.
1676 If you are positive that the section has been read before using the
1677 size, then it is safe to refer to the dwarf2_section_info object's
1678 "size" field directly. In other cases, you must call this
1679 function, because for compressed sections the size field is not set
1680 correctly until the section has been read. */
1682 static bfd_size_type
1683 dwarf2_section_size (struct objfile *objfile,
1684 struct dwarf2_section_info *info)
1687 dwarf2_read_section (objfile, info);
1691 /* Fill in SECTP, BUFP and SIZEP with section info, given OBJFILE and
1695 dwarf2_get_section_info (struct objfile *objfile,
1696 enum dwarf2_section_enum sect,
1697 asection **sectp, gdb_byte **bufp,
1698 bfd_size_type *sizep)
1700 struct dwarf2_per_objfile *data
1701 = objfile_data (objfile, dwarf2_objfile_data_key);
1702 struct dwarf2_section_info *info;
1704 /* We may see an objfile without any DWARF, in which case we just
1715 case DWARF2_DEBUG_FRAME:
1716 info = &data->frame;
1718 case DWARF2_EH_FRAME:
1719 info = &data->eh_frame;
1722 gdb_assert_not_reached ("unexpected section");
1725 dwarf2_read_section (objfile, info);
1727 *sectp = info->asection;
1728 *bufp = info->buffer;
1729 *sizep = info->size;
1733 /* DWARF quick_symbols_functions support. */
1735 /* TUs can share .debug_line entries, and there can be a lot more TUs than
1736 unique line tables, so we maintain a separate table of all .debug_line
1737 derived entries to support the sharing.
1738 All the quick functions need is the list of file names. We discard the
1739 line_header when we're done and don't need to record it here. */
1740 struct quick_file_names
1742 /* The offset in .debug_line of the line table. We hash on this. */
1743 unsigned int offset;
1745 /* The number of entries in file_names, real_names. */
1746 unsigned int num_file_names;
1748 /* The file names from the line table, after being run through
1750 const char **file_names;
1752 /* The file names from the line table after being run through
1753 gdb_realpath. These are computed lazily. */
1754 const char **real_names;
1757 /* When using the index (and thus not using psymtabs), each CU has an
1758 object of this type. This is used to hold information needed by
1759 the various "quick" methods. */
1760 struct dwarf2_per_cu_quick_data
1762 /* The file table. This can be NULL if there was no file table
1763 or it's currently not read in.
1764 NOTE: This points into dwarf2_per_objfile->quick_file_names_table. */
1765 struct quick_file_names *file_names;
1767 /* The corresponding symbol table. This is NULL if symbols for this
1768 CU have not yet been read. */
1769 struct symtab *symtab;
1771 /* A temporary mark bit used when iterating over all CUs in
1772 expand_symtabs_matching. */
1773 unsigned int mark : 1;
1775 /* True if we've tried to read the file table and found there isn't one.
1776 There will be no point in trying to read it again next time. */
1777 unsigned int no_file_data : 1;
1780 /* Hash function for a quick_file_names. */
1783 hash_file_name_entry (const void *e)
1785 const struct quick_file_names *file_data = e;
1787 return file_data->offset;
1790 /* Equality function for a quick_file_names. */
1793 eq_file_name_entry (const void *a, const void *b)
1795 const struct quick_file_names *ea = a;
1796 const struct quick_file_names *eb = b;
1798 return ea->offset == eb->offset;
1801 /* Delete function for a quick_file_names. */
1804 delete_file_name_entry (void *e)
1806 struct quick_file_names *file_data = e;
1809 for (i = 0; i < file_data->num_file_names; ++i)
1811 xfree ((void*) file_data->file_names[i]);
1812 if (file_data->real_names)
1813 xfree ((void*) file_data->real_names[i]);
1816 /* The space for the struct itself lives on objfile_obstack,
1817 so we don't free it here. */
1820 /* Create a quick_file_names hash table. */
1823 create_quick_file_names_table (unsigned int nr_initial_entries)
1825 return htab_create_alloc (nr_initial_entries,
1826 hash_file_name_entry, eq_file_name_entry,
1827 delete_file_name_entry, xcalloc, xfree);
1830 /* Read in PER_CU->CU. This function is unrelated to symtabs, symtab would
1831 have to be created afterwards. You should call age_cached_comp_units after
1832 processing PER_CU->CU. dw2_setup must have been already called. */
1835 load_cu (struct dwarf2_per_cu_data *per_cu)
1837 if (per_cu->debug_type_section)
1838 read_signatured_type_at_offset (per_cu->objfile,
1839 per_cu->debug_type_section,
1842 load_full_comp_unit (per_cu, per_cu->objfile);
1844 dwarf2_find_base_address (per_cu->cu->dies, per_cu->cu);
1846 gdb_assert (per_cu->cu != NULL);
1849 /* Read in the symbols for PER_CU. OBJFILE is the objfile from which
1853 dw2_do_instantiate_symtab (struct objfile *objfile,
1854 struct dwarf2_per_cu_data *per_cu)
1856 struct cleanup *back_to;
1858 back_to = make_cleanup (dwarf2_release_queue, NULL);
1860 queue_comp_unit (per_cu, objfile);
1864 process_queue (objfile);
1866 /* Age the cache, releasing compilation units that have not
1867 been used recently. */
1868 age_cached_comp_units ();
1870 do_cleanups (back_to);
1873 /* Ensure that the symbols for PER_CU have been read in. OBJFILE is
1874 the objfile from which this CU came. Returns the resulting symbol
1877 static struct symtab *
1878 dw2_instantiate_symtab (struct objfile *objfile,
1879 struct dwarf2_per_cu_data *per_cu)
1881 if (!per_cu->v.quick->symtab)
1883 struct cleanup *back_to = make_cleanup (free_cached_comp_units, NULL);
1884 increment_reading_symtab ();
1885 dw2_do_instantiate_symtab (objfile, per_cu);
1886 do_cleanups (back_to);
1888 return per_cu->v.quick->symtab;
1891 /* Return the CU given its index. */
1893 static struct dwarf2_per_cu_data *
1894 dw2_get_cu (int index)
1896 if (index >= dwarf2_per_objfile->n_comp_units)
1898 index -= dwarf2_per_objfile->n_comp_units;
1899 return dwarf2_per_objfile->type_comp_units[index];
1901 return dwarf2_per_objfile->all_comp_units[index];
1904 /* A helper function that knows how to read a 64-bit value in a way
1905 that doesn't make gdb die. Returns 1 if the conversion went ok, 0
1909 extract_cu_value (const char *bytes, ULONGEST *result)
1911 if (sizeof (ULONGEST) < 8)
1915 /* Ignore the upper 4 bytes if they are all zero. */
1916 for (i = 0; i < 4; ++i)
1917 if (bytes[i + 4] != 0)
1920 *result = extract_unsigned_integer (bytes, 4, BFD_ENDIAN_LITTLE);
1923 *result = extract_unsigned_integer (bytes, 8, BFD_ENDIAN_LITTLE);
1927 /* Read the CU list from the mapped index, and use it to create all
1928 the CU objects for this objfile. Return 0 if something went wrong,
1929 1 if everything went ok. */
1932 create_cus_from_index (struct objfile *objfile, const gdb_byte *cu_list,
1933 offset_type cu_list_elements)
1937 dwarf2_per_objfile->n_comp_units = cu_list_elements / 2;
1938 dwarf2_per_objfile->all_comp_units
1939 = obstack_alloc (&objfile->objfile_obstack,
1940 dwarf2_per_objfile->n_comp_units
1941 * sizeof (struct dwarf2_per_cu_data *));
1943 for (i = 0; i < cu_list_elements; i += 2)
1945 struct dwarf2_per_cu_data *the_cu;
1946 ULONGEST offset, length;
1948 if (!extract_cu_value (cu_list, &offset)
1949 || !extract_cu_value (cu_list + 8, &length))
1953 the_cu = OBSTACK_ZALLOC (&objfile->objfile_obstack,
1954 struct dwarf2_per_cu_data);
1955 the_cu->offset = offset;
1956 the_cu->length = length;
1957 the_cu->objfile = objfile;
1958 the_cu->v.quick = OBSTACK_ZALLOC (&objfile->objfile_obstack,
1959 struct dwarf2_per_cu_quick_data);
1960 dwarf2_per_objfile->all_comp_units[i / 2] = the_cu;
1966 /* Create the signatured type hash table from the index. */
1969 create_signatured_type_table_from_index (struct objfile *objfile,
1970 struct dwarf2_section_info *section,
1971 const gdb_byte *bytes,
1972 offset_type elements)
1975 htab_t sig_types_hash;
1977 dwarf2_per_objfile->n_type_comp_units = elements / 3;
1978 dwarf2_per_objfile->type_comp_units
1979 = obstack_alloc (&objfile->objfile_obstack,
1980 dwarf2_per_objfile->n_type_comp_units
1981 * sizeof (struct dwarf2_per_cu_data *));
1983 sig_types_hash = allocate_signatured_type_table (objfile);
1985 for (i = 0; i < elements; i += 3)
1987 struct signatured_type *type_sig;
1988 ULONGEST offset, type_offset, signature;
1991 if (!extract_cu_value (bytes, &offset)
1992 || !extract_cu_value (bytes + 8, &type_offset))
1994 signature = extract_unsigned_integer (bytes + 16, 8, BFD_ENDIAN_LITTLE);
1997 type_sig = OBSTACK_ZALLOC (&objfile->objfile_obstack,
1998 struct signatured_type);
1999 type_sig->signature = signature;
2000 type_sig->type_offset = type_offset;
2001 type_sig->per_cu.debug_type_section = section;
2002 type_sig->per_cu.offset = offset;
2003 type_sig->per_cu.objfile = objfile;
2004 type_sig->per_cu.v.quick
2005 = OBSTACK_ZALLOC (&objfile->objfile_obstack,
2006 struct dwarf2_per_cu_quick_data);
2008 slot = htab_find_slot (sig_types_hash, type_sig, INSERT);
2011 dwarf2_per_objfile->type_comp_units[i / 3] = &type_sig->per_cu;
2014 dwarf2_per_objfile->signatured_types = sig_types_hash;
2019 /* Read the address map data from the mapped index, and use it to
2020 populate the objfile's psymtabs_addrmap. */
2023 create_addrmap_from_index (struct objfile *objfile, struct mapped_index *index)
2025 const gdb_byte *iter, *end;
2026 struct obstack temp_obstack;
2027 struct addrmap *mutable_map;
2028 struct cleanup *cleanup;
2031 obstack_init (&temp_obstack);
2032 cleanup = make_cleanup_obstack_free (&temp_obstack);
2033 mutable_map = addrmap_create_mutable (&temp_obstack);
2035 iter = index->address_table;
2036 end = iter + index->address_table_size;
2038 baseaddr = ANOFFSET (objfile->section_offsets, SECT_OFF_TEXT (objfile));
2042 ULONGEST hi, lo, cu_index;
2043 lo = extract_unsigned_integer (iter, 8, BFD_ENDIAN_LITTLE);
2045 hi = extract_unsigned_integer (iter, 8, BFD_ENDIAN_LITTLE);
2047 cu_index = extract_unsigned_integer (iter, 4, BFD_ENDIAN_LITTLE);
2050 addrmap_set_empty (mutable_map, lo + baseaddr, hi + baseaddr - 1,
2051 dw2_get_cu (cu_index));
2054 objfile->psymtabs_addrmap = addrmap_create_fixed (mutable_map,
2055 &objfile->objfile_obstack);
2056 do_cleanups (cleanup);
2059 /* The hash function for strings in the mapped index. This is the same as
2060 SYMBOL_HASH_NEXT, but we keep a separate copy to maintain control over the
2061 implementation. This is necessary because the hash function is tied to the
2062 format of the mapped index file. The hash values do not have to match with
2065 Use INT_MAX for INDEX_VERSION if you generate the current index format. */
2068 mapped_index_string_hash (int index_version, const void *p)
2070 const unsigned char *str = (const unsigned char *) p;
2074 while ((c = *str++) != 0)
2076 if (index_version >= 5)
2078 r = r * 67 + c - 113;
2084 /* Find a slot in the mapped index INDEX for the object named NAME.
2085 If NAME is found, set *VEC_OUT to point to the CU vector in the
2086 constant pool and return 1. If NAME cannot be found, return 0. */
2089 find_slot_in_mapped_hash (struct mapped_index *index, const char *name,
2090 offset_type **vec_out)
2092 struct cleanup *back_to = make_cleanup (null_cleanup, 0);
2094 offset_type slot, step;
2095 int (*cmp) (const char *, const char *);
2097 if (current_language->la_language == language_cplus
2098 || current_language->la_language == language_java
2099 || current_language->la_language == language_fortran)
2101 /* NAME is already canonical. Drop any qualifiers as .gdb_index does
2103 const char *paren = strchr (name, '(');
2109 dup = xmalloc (paren - name + 1);
2110 memcpy (dup, name, paren - name);
2111 dup[paren - name] = 0;
2113 make_cleanup (xfree, dup);
2118 /* Index version 4 did not support case insensitive searches. But the
2119 indexes for case insensitive languages are built in lowercase, therefore
2120 simulate our NAME being searched is also lowercased. */
2121 hash = mapped_index_string_hash ((index->version == 4
2122 && case_sensitivity == case_sensitive_off
2123 ? 5 : index->version),
2126 slot = hash & (index->symbol_table_slots - 1);
2127 step = ((hash * 17) & (index->symbol_table_slots - 1)) | 1;
2128 cmp = (case_sensitivity == case_sensitive_on ? strcmp : strcasecmp);
2132 /* Convert a slot number to an offset into the table. */
2133 offset_type i = 2 * slot;
2135 if (index->symbol_table[i] == 0 && index->symbol_table[i + 1] == 0)
2137 do_cleanups (back_to);
2141 str = index->constant_pool + MAYBE_SWAP (index->symbol_table[i]);
2142 if (!cmp (name, str))
2144 *vec_out = (offset_type *) (index->constant_pool
2145 + MAYBE_SWAP (index->symbol_table[i + 1]));
2146 do_cleanups (back_to);
2150 slot = (slot + step) & (index->symbol_table_slots - 1);
2154 /* Read the index file. If everything went ok, initialize the "quick"
2155 elements of all the CUs and return 1. Otherwise, return 0. */
2158 dwarf2_read_index (struct objfile *objfile)
2161 struct mapped_index *map;
2162 offset_type *metadata;
2163 const gdb_byte *cu_list;
2164 const gdb_byte *types_list = NULL;
2165 offset_type version, cu_list_elements;
2166 offset_type types_list_elements = 0;
2169 if (dwarf2_section_empty_p (&dwarf2_per_objfile->gdb_index))
2172 /* Older elfutils strip versions could keep the section in the main
2173 executable while splitting it for the separate debug info file. */
2174 if ((bfd_get_file_flags (dwarf2_per_objfile->gdb_index.asection)
2175 & SEC_HAS_CONTENTS) == 0)
2178 dwarf2_read_section (objfile, &dwarf2_per_objfile->gdb_index);
2180 addr = dwarf2_per_objfile->gdb_index.buffer;
2181 /* Version check. */
2182 version = MAYBE_SWAP (*(offset_type *) addr);
2183 /* Versions earlier than 3 emitted every copy of a psymbol. This
2184 causes the index to behave very poorly for certain requests. Version 3
2185 contained incomplete addrmap. So, it seems better to just ignore such
2186 indices. Index version 4 uses a different hash function than index
2187 version 5 and later. */
2190 /* Indexes with higher version than the one supported by GDB may be no
2191 longer backward compatible. */
2195 map = OBSTACK_ZALLOC (&objfile->objfile_obstack, struct mapped_index);
2196 map->version = version;
2197 map->total_size = dwarf2_per_objfile->gdb_index.size;
2199 metadata = (offset_type *) (addr + sizeof (offset_type));
2202 cu_list = addr + MAYBE_SWAP (metadata[i]);
2203 cu_list_elements = ((MAYBE_SWAP (metadata[i + 1]) - MAYBE_SWAP (metadata[i]))
2207 types_list = addr + MAYBE_SWAP (metadata[i]);
2208 types_list_elements = ((MAYBE_SWAP (metadata[i + 1])
2209 - MAYBE_SWAP (metadata[i]))
2213 map->address_table = addr + MAYBE_SWAP (metadata[i]);
2214 map->address_table_size = (MAYBE_SWAP (metadata[i + 1])
2215 - MAYBE_SWAP (metadata[i]));
2218 map->symbol_table = (offset_type *) (addr + MAYBE_SWAP (metadata[i]));
2219 map->symbol_table_slots = ((MAYBE_SWAP (metadata[i + 1])
2220 - MAYBE_SWAP (metadata[i]))
2221 / (2 * sizeof (offset_type)));
2224 map->constant_pool = addr + MAYBE_SWAP (metadata[i]);
2226 if (!create_cus_from_index (objfile, cu_list, cu_list_elements))
2229 if (types_list_elements)
2231 struct dwarf2_section_info *section;
2233 /* We can only handle a single .debug_types when we have an
2235 if (VEC_length (dwarf2_section_info_def, dwarf2_per_objfile->types) != 1)
2238 section = VEC_index (dwarf2_section_info_def,
2239 dwarf2_per_objfile->types, 0);
2241 if (!create_signatured_type_table_from_index (objfile, section,
2243 types_list_elements))
2247 create_addrmap_from_index (objfile, map);
2249 dwarf2_per_objfile->index_table = map;
2250 dwarf2_per_objfile->using_index = 1;
2251 dwarf2_per_objfile->quick_file_names_table =
2252 create_quick_file_names_table (dwarf2_per_objfile->n_comp_units);
2257 /* A helper for the "quick" functions which sets the global
2258 dwarf2_per_objfile according to OBJFILE. */
2261 dw2_setup (struct objfile *objfile)
2263 dwarf2_per_objfile = objfile_data (objfile, dwarf2_objfile_data_key);
2264 gdb_assert (dwarf2_per_objfile);
2267 /* A helper for the "quick" functions which attempts to read the line
2268 table for THIS_CU. */
2270 static struct quick_file_names *
2271 dw2_get_file_names (struct objfile *objfile,
2272 struct dwarf2_per_cu_data *this_cu)
2274 bfd *abfd = objfile->obfd;
2275 struct line_header *lh;
2276 struct attribute *attr;
2277 struct cleanup *cleanups;
2278 struct die_info *comp_unit_die;
2279 struct dwarf2_section_info* sec;
2280 gdb_byte *info_ptr, *buffer;
2281 int has_children, i;
2282 struct dwarf2_cu cu;
2283 unsigned int bytes_read, buffer_size;
2284 struct die_reader_specs reader_specs;
2285 char *name, *comp_dir;
2287 struct quick_file_names *qfn;
2288 unsigned int line_offset;
2290 if (this_cu->v.quick->file_names != NULL)
2291 return this_cu->v.quick->file_names;
2292 /* If we know there is no line data, no point in looking again. */
2293 if (this_cu->v.quick->no_file_data)
2296 init_one_comp_unit (&cu, objfile);
2297 cleanups = make_cleanup (free_stack_comp_unit, &cu);
2299 if (this_cu->debug_type_section)
2300 sec = this_cu->debug_type_section;
2302 sec = &dwarf2_per_objfile->info;
2303 dwarf2_read_section (objfile, sec);
2304 buffer_size = sec->size;
2305 buffer = sec->buffer;
2306 info_ptr = buffer + this_cu->offset;
2308 info_ptr = partial_read_comp_unit_head (&cu.header, info_ptr,
2309 buffer, buffer_size,
2312 /* Skip dummy compilation units. */
2313 if (info_ptr >= buffer + buffer_size
2314 || peek_abbrev_code (abfd, info_ptr) == 0)
2316 do_cleanups (cleanups);
2321 cu.per_cu = this_cu;
2323 dwarf2_read_abbrevs (abfd, &cu);
2324 make_cleanup (dwarf2_free_abbrev_table, &cu);
2326 if (this_cu->debug_type_section)
2327 info_ptr += 8 /*signature*/ + cu.header.offset_size;
2328 init_cu_die_reader (&reader_specs, &cu);
2329 read_full_die (&reader_specs, &comp_unit_die, info_ptr,
2335 attr = dwarf2_attr (comp_unit_die, DW_AT_stmt_list, &cu);
2338 struct quick_file_names find_entry;
2340 line_offset = DW_UNSND (attr);
2342 /* We may have already read in this line header (TU line header sharing).
2343 If we have we're done. */
2344 find_entry.offset = line_offset;
2345 slot = htab_find_slot (dwarf2_per_objfile->quick_file_names_table,
2346 &find_entry, INSERT);
2349 do_cleanups (cleanups);
2350 this_cu->v.quick->file_names = *slot;
2354 lh = dwarf_decode_line_header (line_offset, abfd, &cu);
2358 do_cleanups (cleanups);
2359 this_cu->v.quick->no_file_data = 1;
2363 qfn = obstack_alloc (&objfile->objfile_obstack, sizeof (*qfn));
2364 qfn->offset = line_offset;
2365 gdb_assert (slot != NULL);
2368 find_file_and_directory (comp_unit_die, &cu, &name, &comp_dir);
2370 qfn->num_file_names = lh->num_file_names;
2371 qfn->file_names = obstack_alloc (&objfile->objfile_obstack,
2372 lh->num_file_names * sizeof (char *));
2373 for (i = 0; i < lh->num_file_names; ++i)
2374 qfn->file_names[i] = file_full_name (i + 1, lh, comp_dir);
2375 qfn->real_names = NULL;
2377 free_line_header (lh);
2378 do_cleanups (cleanups);
2380 this_cu->v.quick->file_names = qfn;
2384 /* A helper for the "quick" functions which computes and caches the
2385 real path for a given file name from the line table. */
2388 dw2_get_real_path (struct objfile *objfile,
2389 struct quick_file_names *qfn, int index)
2391 if (qfn->real_names == NULL)
2392 qfn->real_names = OBSTACK_CALLOC (&objfile->objfile_obstack,
2393 qfn->num_file_names, sizeof (char *));
2395 if (qfn->real_names[index] == NULL)
2396 qfn->real_names[index] = gdb_realpath (qfn->file_names[index]);
2398 return qfn->real_names[index];
2401 static struct symtab *
2402 dw2_find_last_source_symtab (struct objfile *objfile)
2406 dw2_setup (objfile);
2407 index = dwarf2_per_objfile->n_comp_units - 1;
2408 return dw2_instantiate_symtab (objfile, dw2_get_cu (index));
2411 /* Traversal function for dw2_forget_cached_source_info. */
2414 dw2_free_cached_file_names (void **slot, void *info)
2416 struct quick_file_names *file_data = (struct quick_file_names *) *slot;
2418 if (file_data->real_names)
2422 for (i = 0; i < file_data->num_file_names; ++i)
2424 xfree ((void*) file_data->real_names[i]);
2425 file_data->real_names[i] = NULL;
2433 dw2_forget_cached_source_info (struct objfile *objfile)
2435 dw2_setup (objfile);
2437 htab_traverse_noresize (dwarf2_per_objfile->quick_file_names_table,
2438 dw2_free_cached_file_names, NULL);
2442 dw2_lookup_symtab (struct objfile *objfile, const char *name,
2443 const char *full_path, const char *real_path,
2444 struct symtab **result)
2447 int check_basename = lbasename (name) == name;
2448 struct dwarf2_per_cu_data *base_cu = NULL;
2450 dw2_setup (objfile);
2452 for (i = 0; i < (dwarf2_per_objfile->n_comp_units
2453 + dwarf2_per_objfile->n_type_comp_units); ++i)
2456 struct dwarf2_per_cu_data *per_cu = dw2_get_cu (i);
2457 struct quick_file_names *file_data;
2459 if (per_cu->v.quick->symtab)
2462 file_data = dw2_get_file_names (objfile, per_cu);
2463 if (file_data == NULL)
2466 for (j = 0; j < file_data->num_file_names; ++j)
2468 const char *this_name = file_data->file_names[j];
2470 if (FILENAME_CMP (name, this_name) == 0)
2472 *result = dw2_instantiate_symtab (objfile, per_cu);
2476 if (check_basename && ! base_cu
2477 && FILENAME_CMP (lbasename (this_name), name) == 0)
2480 if (full_path != NULL)
2482 const char *this_real_name = dw2_get_real_path (objfile,
2485 if (this_real_name != NULL
2486 && FILENAME_CMP (full_path, this_real_name) == 0)
2488 *result = dw2_instantiate_symtab (objfile, per_cu);
2493 if (real_path != NULL)
2495 const char *this_real_name = dw2_get_real_path (objfile,
2498 if (this_real_name != NULL
2499 && FILENAME_CMP (real_path, this_real_name) == 0)
2501 *result = dw2_instantiate_symtab (objfile, per_cu);
2510 *result = dw2_instantiate_symtab (objfile, base_cu);
2517 static struct symtab *
2518 dw2_lookup_symbol (struct objfile *objfile, int block_index,
2519 const char *name, domain_enum domain)
2521 /* We do all the work in the pre_expand_symtabs_matching hook
2526 /* A helper function that expands all symtabs that hold an object
2530 dw2_do_expand_symtabs_matching (struct objfile *objfile, const char *name)
2532 dw2_setup (objfile);
2534 /* index_table is NULL if OBJF_READNOW. */
2535 if (dwarf2_per_objfile->index_table)
2539 if (find_slot_in_mapped_hash (dwarf2_per_objfile->index_table,
2542 offset_type i, len = MAYBE_SWAP (*vec);
2543 for (i = 0; i < len; ++i)
2545 offset_type cu_index = MAYBE_SWAP (vec[i + 1]);
2546 struct dwarf2_per_cu_data *per_cu = dw2_get_cu (cu_index);
2548 dw2_instantiate_symtab (objfile, per_cu);
2555 dw2_pre_expand_symtabs_matching (struct objfile *objfile,
2556 enum block_enum block_kind, const char *name,
2559 dw2_do_expand_symtabs_matching (objfile, name);
2563 dw2_print_stats (struct objfile *objfile)
2567 dw2_setup (objfile);
2569 for (i = 0; i < (dwarf2_per_objfile->n_comp_units
2570 + dwarf2_per_objfile->n_type_comp_units); ++i)
2572 struct dwarf2_per_cu_data *per_cu = dw2_get_cu (i);
2574 if (!per_cu->v.quick->symtab)
2577 printf_filtered (_(" Number of unread CUs: %d\n"), count);
2581 dw2_dump (struct objfile *objfile)
2583 /* Nothing worth printing. */
2587 dw2_relocate (struct objfile *objfile, struct section_offsets *new_offsets,
2588 struct section_offsets *delta)
2590 /* There's nothing to relocate here. */
2594 dw2_expand_symtabs_for_function (struct objfile *objfile,
2595 const char *func_name)
2597 dw2_do_expand_symtabs_matching (objfile, func_name);
2601 dw2_expand_all_symtabs (struct objfile *objfile)
2605 dw2_setup (objfile);
2607 for (i = 0; i < (dwarf2_per_objfile->n_comp_units
2608 + dwarf2_per_objfile->n_type_comp_units); ++i)
2610 struct dwarf2_per_cu_data *per_cu = dw2_get_cu (i);
2612 dw2_instantiate_symtab (objfile, per_cu);
2617 dw2_expand_symtabs_with_filename (struct objfile *objfile,
2618 const char *filename)
2622 dw2_setup (objfile);
2624 /* We don't need to consider type units here.
2625 This is only called for examining code, e.g. expand_line_sal.
2626 There can be an order of magnitude (or more) more type units
2627 than comp units, and we avoid them if we can. */
2629 for (i = 0; i < dwarf2_per_objfile->n_comp_units; ++i)
2632 struct dwarf2_per_cu_data *per_cu = dw2_get_cu (i);
2633 struct quick_file_names *file_data;
2635 if (per_cu->v.quick->symtab)
2638 file_data = dw2_get_file_names (objfile, per_cu);
2639 if (file_data == NULL)
2642 for (j = 0; j < file_data->num_file_names; ++j)
2644 const char *this_name = file_data->file_names[j];
2645 if (FILENAME_CMP (this_name, filename) == 0)
2647 dw2_instantiate_symtab (objfile, per_cu);
2655 dw2_find_symbol_file (struct objfile *objfile, const char *name)
2657 struct dwarf2_per_cu_data *per_cu;
2659 struct quick_file_names *file_data;
2661 dw2_setup (objfile);
2663 /* index_table is NULL if OBJF_READNOW. */
2664 if (!dwarf2_per_objfile->index_table)
2668 ALL_OBJFILE_SYMTABS (objfile, s)
2671 struct blockvector *bv = BLOCKVECTOR (s);
2672 const struct block *block = BLOCKVECTOR_BLOCK (bv, GLOBAL_BLOCK);
2673 struct symbol *sym = lookup_block_symbol (block, name, VAR_DOMAIN);
2676 return sym->symtab->filename;
2681 if (!find_slot_in_mapped_hash (dwarf2_per_objfile->index_table,
2685 /* Note that this just looks at the very first one named NAME -- but
2686 actually we are looking for a function. find_main_filename
2687 should be rewritten so that it doesn't require a custom hook. It
2688 could just use the ordinary symbol tables. */
2689 /* vec[0] is the length, which must always be >0. */
2690 per_cu = dw2_get_cu (MAYBE_SWAP (vec[1]));
2692 file_data = dw2_get_file_names (objfile, per_cu);
2693 if (file_data == NULL)
2696 return file_data->file_names[file_data->num_file_names - 1];
2700 dw2_map_matching_symbols (const char * name, domain_enum namespace,
2701 struct objfile *objfile, int global,
2702 int (*callback) (struct block *,
2703 struct symbol *, void *),
2704 void *data, symbol_compare_ftype *match,
2705 symbol_compare_ftype *ordered_compare)
2707 /* Currently unimplemented; used for Ada. The function can be called if the
2708 current language is Ada for a non-Ada objfile using GNU index. As Ada
2709 does not look for non-Ada symbols this function should just return. */
2713 dw2_expand_symtabs_matching (struct objfile *objfile,
2714 int (*file_matcher) (const char *, void *),
2715 int (*name_matcher) (const char *, void *),
2716 enum search_domain kind,
2721 struct mapped_index *index;
2723 dw2_setup (objfile);
2725 /* index_table is NULL if OBJF_READNOW. */
2726 if (!dwarf2_per_objfile->index_table)
2728 index = dwarf2_per_objfile->index_table;
2730 if (file_matcher != NULL)
2731 for (i = 0; i < (dwarf2_per_objfile->n_comp_units
2732 + dwarf2_per_objfile->n_type_comp_units); ++i)
2735 struct dwarf2_per_cu_data *per_cu = dw2_get_cu (i);
2736 struct quick_file_names *file_data;
2738 per_cu->v.quick->mark = 0;
2739 if (per_cu->v.quick->symtab)
2742 file_data = dw2_get_file_names (objfile, per_cu);
2743 if (file_data == NULL)
2746 for (j = 0; j < file_data->num_file_names; ++j)
2748 if (file_matcher (file_data->file_names[j], data))
2750 per_cu->v.quick->mark = 1;
2756 for (iter = 0; iter < index->symbol_table_slots; ++iter)
2758 offset_type idx = 2 * iter;
2760 offset_type *vec, vec_len, vec_idx;
2762 if (index->symbol_table[idx] == 0 && index->symbol_table[idx + 1] == 0)
2765 name = index->constant_pool + MAYBE_SWAP (index->symbol_table[idx]);
2767 if (! (*name_matcher) (name, data))
2770 /* The name was matched, now expand corresponding CUs that were
2772 vec = (offset_type *) (index->constant_pool
2773 + MAYBE_SWAP (index->symbol_table[idx + 1]));
2774 vec_len = MAYBE_SWAP (vec[0]);
2775 for (vec_idx = 0; vec_idx < vec_len; ++vec_idx)
2777 struct dwarf2_per_cu_data *per_cu;
2779 per_cu = dw2_get_cu (MAYBE_SWAP (vec[vec_idx + 1]));
2780 if (file_matcher == NULL || per_cu->v.quick->mark)
2781 dw2_instantiate_symtab (objfile, per_cu);
2786 static struct symtab *
2787 dw2_find_pc_sect_symtab (struct objfile *objfile,
2788 struct minimal_symbol *msymbol,
2790 struct obj_section *section,
2793 struct dwarf2_per_cu_data *data;
2795 dw2_setup (objfile);
2797 if (!objfile->psymtabs_addrmap)
2800 data = addrmap_find (objfile->psymtabs_addrmap, pc);
2804 if (warn_if_readin && data->v.quick->symtab)
2805 warning (_("(Internal error: pc %s in read in CU, but not in symtab.)"),
2806 paddress (get_objfile_arch (objfile), pc));
2808 return dw2_instantiate_symtab (objfile, data);
2812 dw2_map_symbol_filenames (struct objfile *objfile, symbol_filename_ftype *fun,
2817 dw2_setup (objfile);
2819 for (i = 0; i < (dwarf2_per_objfile->n_comp_units
2820 + dwarf2_per_objfile->n_type_comp_units); ++i)
2823 struct dwarf2_per_cu_data *per_cu = dw2_get_cu (i);
2824 struct quick_file_names *file_data;
2826 if (per_cu->v.quick->symtab)
2829 file_data = dw2_get_file_names (objfile, per_cu);
2830 if (file_data == NULL)
2833 for (j = 0; j < file_data->num_file_names; ++j)
2835 const char *this_real_name = dw2_get_real_path (objfile, file_data,
2837 (*fun) (file_data->file_names[j], this_real_name, data);
2843 dw2_has_symbols (struct objfile *objfile)
2848 const struct quick_symbol_functions dwarf2_gdb_index_functions =
2851 dw2_find_last_source_symtab,
2852 dw2_forget_cached_source_info,
2855 dw2_pre_expand_symtabs_matching,
2859 dw2_expand_symtabs_for_function,
2860 dw2_expand_all_symtabs,
2861 dw2_expand_symtabs_with_filename,
2862 dw2_find_symbol_file,
2863 dw2_map_matching_symbols,
2864 dw2_expand_symtabs_matching,
2865 dw2_find_pc_sect_symtab,
2866 dw2_map_symbol_filenames
2869 /* Initialize for reading DWARF for this objfile. Return 0 if this
2870 file will use psymtabs, or 1 if using the GNU index. */
2873 dwarf2_initialize_objfile (struct objfile *objfile)
2875 /* If we're about to read full symbols, don't bother with the
2876 indices. In this case we also don't care if some other debug
2877 format is making psymtabs, because they are all about to be
2879 if ((objfile->flags & OBJF_READNOW))
2883 dwarf2_per_objfile->using_index = 1;
2884 create_all_comp_units (objfile);
2885 create_debug_types_hash_table (objfile);
2886 dwarf2_per_objfile->quick_file_names_table =
2887 create_quick_file_names_table (dwarf2_per_objfile->n_comp_units);
2889 for (i = 0; i < (dwarf2_per_objfile->n_comp_units
2890 + dwarf2_per_objfile->n_type_comp_units); ++i)
2892 struct dwarf2_per_cu_data *per_cu = dw2_get_cu (i);
2894 per_cu->v.quick = OBSTACK_ZALLOC (&objfile->objfile_obstack,
2895 struct dwarf2_per_cu_quick_data);
2898 /* Return 1 so that gdb sees the "quick" functions. However,
2899 these functions will be no-ops because we will have expanded
2904 if (dwarf2_read_index (objfile))
2912 /* Build a partial symbol table. */
2915 dwarf2_build_psymtabs (struct objfile *objfile)
2917 if (objfile->global_psymbols.size == 0 && objfile->static_psymbols.size == 0)
2919 init_psymbol_list (objfile, 1024);
2922 dwarf2_build_psymtabs_hard (objfile);
2925 /* Return TRUE if OFFSET is within CU_HEADER. */
2928 offset_in_cu_p (const struct comp_unit_head *cu_header, unsigned int offset)
2930 unsigned int bottom = cu_header->offset;
2931 unsigned int top = (cu_header->offset
2933 + cu_header->initial_length_size);
2935 return (offset >= bottom && offset < top);
2938 /* Read in the comp unit header information from the debug_info at info_ptr.
2939 NOTE: This leaves members offset, first_die_offset to be filled in
2943 read_comp_unit_head (struct comp_unit_head *cu_header,
2944 gdb_byte *info_ptr, bfd *abfd)
2947 unsigned int bytes_read;
2949 cu_header->length = read_initial_length (abfd, info_ptr, &bytes_read);
2950 cu_header->initial_length_size = bytes_read;
2951 cu_header->offset_size = (bytes_read == 4) ? 4 : 8;
2952 info_ptr += bytes_read;
2953 cu_header->version = read_2_bytes (abfd, info_ptr);
2955 cu_header->abbrev_offset = read_offset (abfd, info_ptr, cu_header,
2957 info_ptr += bytes_read;
2958 cu_header->addr_size = read_1_byte (abfd, info_ptr);
2960 signed_addr = bfd_get_sign_extend_vma (abfd);
2961 if (signed_addr < 0)
2962 internal_error (__FILE__, __LINE__,
2963 _("read_comp_unit_head: dwarf from non elf file"));
2964 cu_header->signed_addr_p = signed_addr;
2969 /* Read in a CU header and perform some basic error checking. */
2972 partial_read_comp_unit_head (struct comp_unit_head *header, gdb_byte *info_ptr,
2973 gdb_byte *buffer, unsigned int buffer_size,
2976 gdb_byte *beg_of_comp_unit = info_ptr;
2978 header->offset = beg_of_comp_unit - buffer;
2980 info_ptr = read_comp_unit_head (header, info_ptr, abfd);
2982 header->first_die_offset = info_ptr - beg_of_comp_unit;
2984 if (header->version != 2 && header->version != 3 && header->version != 4)
2985 error (_("Dwarf Error: wrong version in compilation unit header "
2986 "(is %d, should be 2, 3, or 4) [in module %s]"), header->version,
2987 bfd_get_filename (abfd));
2989 if (header->abbrev_offset
2990 >= dwarf2_section_size (dwarf2_per_objfile->objfile,
2991 &dwarf2_per_objfile->abbrev))
2992 error (_("Dwarf Error: bad offset (0x%lx) in compilation unit header "
2993 "(offset 0x%lx + 6) [in module %s]"),
2994 (long) header->abbrev_offset,
2995 (long) (beg_of_comp_unit - buffer),
2996 bfd_get_filename (abfd));
2998 if (beg_of_comp_unit + header->length + header->initial_length_size
2999 > buffer + buffer_size)
3000 error (_("Dwarf Error: bad length (0x%lx) in compilation unit header "
3001 "(offset 0x%lx + 0) [in module %s]"),
3002 (long) header->length,
3003 (long) (beg_of_comp_unit - buffer),
3004 bfd_get_filename (abfd));
3009 /* Read in the types comp unit header information from .debug_types entry at
3010 types_ptr. The result is a pointer to one past the end of the header. */
3013 read_type_comp_unit_head (struct comp_unit_head *cu_header,
3014 struct dwarf2_section_info *section,
3015 ULONGEST *signature,
3016 gdb_byte *types_ptr, bfd *abfd)
3018 gdb_byte *initial_types_ptr = types_ptr;
3020 dwarf2_read_section (dwarf2_per_objfile->objfile, section);
3021 cu_header->offset = types_ptr - section->buffer;
3023 types_ptr = read_comp_unit_head (cu_header, types_ptr, abfd);
3025 *signature = read_8_bytes (abfd, types_ptr);
3027 types_ptr += cu_header->offset_size;
3028 cu_header->first_die_offset = types_ptr - initial_types_ptr;
3033 /* Allocate a new partial symtab for file named NAME and mark this new
3034 partial symtab as being an include of PST. */
3037 dwarf2_create_include_psymtab (char *name, struct partial_symtab *pst,
3038 struct objfile *objfile)
3040 struct partial_symtab *subpst = allocate_psymtab (name, objfile);
3042 subpst->section_offsets = pst->section_offsets;
3043 subpst->textlow = 0;
3044 subpst->texthigh = 0;
3046 subpst->dependencies = (struct partial_symtab **)
3047 obstack_alloc (&objfile->objfile_obstack,
3048 sizeof (struct partial_symtab *));
3049 subpst->dependencies[0] = pst;
3050 subpst->number_of_dependencies = 1;
3052 subpst->globals_offset = 0;
3053 subpst->n_global_syms = 0;
3054 subpst->statics_offset = 0;
3055 subpst->n_static_syms = 0;
3056 subpst->symtab = NULL;
3057 subpst->read_symtab = pst->read_symtab;
3060 /* No private part is necessary for include psymtabs. This property
3061 can be used to differentiate between such include psymtabs and
3062 the regular ones. */
3063 subpst->read_symtab_private = NULL;
3066 /* Read the Line Number Program data and extract the list of files
3067 included by the source file represented by PST. Build an include
3068 partial symtab for each of these included files. */
3071 dwarf2_build_include_psymtabs (struct dwarf2_cu *cu,
3072 struct die_info *die,
3073 struct partial_symtab *pst)
3075 struct objfile *objfile = cu->objfile;
3076 bfd *abfd = objfile->obfd;
3077 struct line_header *lh = NULL;
3078 struct attribute *attr;
3080 attr = dwarf2_attr (die, DW_AT_stmt_list, cu);
3083 unsigned int line_offset = DW_UNSND (attr);
3085 lh = dwarf_decode_line_header (line_offset, abfd, cu);
3088 return; /* No linetable, so no includes. */
3090 /* NOTE: pst->dirname is DW_AT_comp_dir (if present). */
3091 dwarf_decode_lines (lh, pst->dirname, abfd, cu, pst);
3093 free_line_header (lh);
3097 hash_type_signature (const void *item)
3099 const struct signatured_type *type_sig = item;
3101 /* This drops the top 32 bits of the signature, but is ok for a hash. */
3102 return type_sig->signature;
3106 eq_type_signature (const void *item_lhs, const void *item_rhs)
3108 const struct signatured_type *lhs = item_lhs;
3109 const struct signatured_type *rhs = item_rhs;
3111 return lhs->signature == rhs->signature;
3114 /* Allocate a hash table for signatured types. */
3117 allocate_signatured_type_table (struct objfile *objfile)
3119 return htab_create_alloc_ex (41,
3120 hash_type_signature,
3123 &objfile->objfile_obstack,
3124 hashtab_obstack_allocate,
3125 dummy_obstack_deallocate);
3128 /* A helper function to add a signatured type CU to a list. */
3131 add_signatured_type_cu_to_list (void **slot, void *datum)
3133 struct signatured_type *sigt = *slot;
3134 struct dwarf2_per_cu_data ***datap = datum;
3136 **datap = &sigt->per_cu;
3142 /* Create the hash table of all entries in the .debug_types section.
3143 The result is zero if there is an error (e.g. missing .debug_types section),
3144 otherwise non-zero. */
3147 create_debug_types_hash_table (struct objfile *objfile)
3149 htab_t types_htab = NULL;
3150 struct dwarf2_per_cu_data **iter;
3152 struct dwarf2_section_info *section;
3154 if (VEC_empty (dwarf2_section_info_def, dwarf2_per_objfile->types))
3156 dwarf2_per_objfile->signatured_types = NULL;
3161 VEC_iterate (dwarf2_section_info_def, dwarf2_per_objfile->types,
3165 gdb_byte *info_ptr, *end_ptr;
3167 dwarf2_read_section (objfile, section);
3168 info_ptr = section->buffer;
3170 if (info_ptr == NULL)
3173 if (types_htab == NULL)
3174 types_htab = allocate_signatured_type_table (objfile);
3176 if (dwarf2_die_debug)
3177 fprintf_unfiltered (gdb_stdlog, "Signatured types:\n");
3179 end_ptr = info_ptr + section->size;
3180 while (info_ptr < end_ptr)
3182 unsigned int offset;
3183 unsigned int offset_size;
3184 unsigned int type_offset;
3185 unsigned int length, initial_length_size;
3186 unsigned short version;
3188 struct signatured_type *type_sig;
3190 gdb_byte *ptr = info_ptr;
3192 offset = ptr - section->buffer;
3194 /* We need to read the type's signature in order to build the hash
3195 table, but we don't need to read anything else just yet. */
3197 /* Sanity check to ensure entire cu is present. */
3198 length = read_initial_length (objfile->obfd, ptr,
3199 &initial_length_size);
3200 if (ptr + length + initial_length_size > end_ptr)
3202 complaint (&symfile_complaints,
3203 _("debug type entry runs off end "
3204 "of `.debug_types' section, ignored"));
3208 offset_size = initial_length_size == 4 ? 4 : 8;
3209 ptr += initial_length_size;
3210 version = bfd_get_16 (objfile->obfd, ptr);
3212 ptr += offset_size; /* abbrev offset */
3213 ptr += 1; /* address size */
3214 signature = bfd_get_64 (objfile->obfd, ptr);
3216 type_offset = read_offset_1 (objfile->obfd, ptr, offset_size);
3219 /* Skip dummy type units. */
3220 if (ptr >= end_ptr || peek_abbrev_code (objfile->obfd, ptr) == 0)
3222 info_ptr = info_ptr + initial_length_size + length;
3226 type_sig = obstack_alloc (&objfile->objfile_obstack, sizeof (*type_sig));
3227 memset (type_sig, 0, sizeof (*type_sig));
3228 type_sig->signature = signature;
3229 type_sig->type_offset = type_offset;
3230 type_sig->per_cu.objfile = objfile;
3231 type_sig->per_cu.debug_type_section = section;
3232 type_sig->per_cu.offset = offset;
3234 slot = htab_find_slot (types_htab, type_sig, INSERT);
3235 gdb_assert (slot != NULL);
3238 const struct signatured_type *dup_sig = *slot;
3240 complaint (&symfile_complaints,
3241 _("debug type entry at offset 0x%x is duplicate to the "
3242 "entry at offset 0x%x, signature 0x%s"),
3243 offset, dup_sig->per_cu.offset,
3244 phex (signature, sizeof (signature)));
3245 gdb_assert (signature == dup_sig->signature);
3249 if (dwarf2_die_debug)
3250 fprintf_unfiltered (gdb_stdlog, " offset 0x%x, signature 0x%s\n",
3251 offset, phex (signature, sizeof (signature)));
3253 info_ptr = info_ptr + initial_length_size + length;
3257 dwarf2_per_objfile->signatured_types = types_htab;
3259 dwarf2_per_objfile->n_type_comp_units = htab_elements (types_htab);
3260 dwarf2_per_objfile->type_comp_units
3261 = obstack_alloc (&objfile->objfile_obstack,
3262 dwarf2_per_objfile->n_type_comp_units
3263 * sizeof (struct dwarf2_per_cu_data *));
3264 iter = &dwarf2_per_objfile->type_comp_units[0];
3265 htab_traverse_noresize (types_htab, add_signatured_type_cu_to_list, &iter);
3266 gdb_assert (iter - &dwarf2_per_objfile->type_comp_units[0]
3267 == dwarf2_per_objfile->n_type_comp_units);
3272 /* Lookup a signature based type.
3273 Returns NULL if SIG is not present in the table. */
3275 static struct signatured_type *
3276 lookup_signatured_type (struct objfile *objfile, ULONGEST sig)
3278 struct signatured_type find_entry, *entry;
3280 if (dwarf2_per_objfile->signatured_types == NULL)
3282 complaint (&symfile_complaints,
3283 _("missing `.debug_types' section for DW_FORM_ref_sig8 die"));
3287 find_entry.signature = sig;
3288 entry = htab_find (dwarf2_per_objfile->signatured_types, &find_entry);
3292 /* Initialize a die_reader_specs struct from a dwarf2_cu struct. */
3295 init_cu_die_reader (struct die_reader_specs *reader,
3296 struct dwarf2_cu *cu)
3298 reader->abfd = cu->objfile->obfd;
3300 if (cu->per_cu->debug_type_section)
3302 gdb_assert (cu->per_cu->debug_type_section->readin);
3303 reader->buffer = cu->per_cu->debug_type_section->buffer;
3307 gdb_assert (dwarf2_per_objfile->info.readin);
3308 reader->buffer = dwarf2_per_objfile->info.buffer;
3312 /* Find the base address of the compilation unit for range lists and
3313 location lists. It will normally be specified by DW_AT_low_pc.
3314 In DWARF-3 draft 4, the base address could be overridden by
3315 DW_AT_entry_pc. It's been removed, but GCC still uses this for
3316 compilation units with discontinuous ranges. */
3319 dwarf2_find_base_address (struct die_info *die, struct dwarf2_cu *cu)
3321 struct attribute *attr;
3324 cu->base_address = 0;
3326 attr = dwarf2_attr (die, DW_AT_entry_pc, cu);
3329 cu->base_address = DW_ADDR (attr);
3334 attr = dwarf2_attr (die, DW_AT_low_pc, cu);
3337 cu->base_address = DW_ADDR (attr);
3343 /* Subroutine of process_type_comp_unit and dwarf2_build_psymtabs_hard
3344 to combine the common parts.
3345 Process a compilation unit for a psymtab.
3346 BUFFER is a pointer to the beginning of the dwarf section buffer,
3347 either .debug_info or debug_types.
3348 INFO_PTR is a pointer to the start of the CU.
3349 Returns a pointer to the next CU. */
3352 process_psymtab_comp_unit (struct objfile *objfile,
3353 struct dwarf2_per_cu_data *this_cu,
3354 gdb_byte *buffer, gdb_byte *info_ptr,
3355 unsigned int buffer_size)
3357 bfd *abfd = objfile->obfd;
3358 gdb_byte *beg_of_comp_unit = info_ptr;
3359 struct die_info *comp_unit_die;
3360 struct partial_symtab *pst;
3362 struct cleanup *back_to_inner;
3363 struct dwarf2_cu cu;
3364 int has_children, has_pc_info;
3365 struct attribute *attr;
3366 CORE_ADDR best_lowpc = 0, best_highpc = 0;
3367 struct die_reader_specs reader_specs;
3368 const char *filename;
3370 init_one_comp_unit (&cu, objfile);
3371 back_to_inner = make_cleanup (free_stack_comp_unit, &cu);
3373 info_ptr = partial_read_comp_unit_head (&cu.header, info_ptr,
3374 buffer, buffer_size,
3377 /* Skip dummy compilation units. */
3378 if (info_ptr >= buffer + buffer_size
3379 || peek_abbrev_code (abfd, info_ptr) == 0)
3381 info_ptr = (beg_of_comp_unit + cu.header.length
3382 + cu.header.initial_length_size);
3383 do_cleanups (back_to_inner);
3387 cu.list_in_scope = &file_symbols;
3389 /* If this compilation unit was already read in, free the
3390 cached copy in order to read it in again. This is
3391 necessary because we skipped some symbols when we first
3392 read in the compilation unit (see load_partial_dies).
3393 This problem could be avoided, but the benefit is
3395 if (this_cu->cu != NULL)
3396 free_one_cached_comp_unit (this_cu->cu);
3398 /* Note that this is a pointer to our stack frame, being
3399 added to a global data structure. It will be cleaned up
3400 in free_stack_comp_unit when we finish with this
3401 compilation unit. */
3403 cu.per_cu = this_cu;
3405 /* Read the abbrevs for this compilation unit into a table. */
3406 dwarf2_read_abbrevs (abfd, &cu);
3407 make_cleanup (dwarf2_free_abbrev_table, &cu);
3409 /* Read the compilation unit die. */
3410 if (this_cu->debug_type_section)
3411 info_ptr += 8 /*signature*/ + cu.header.offset_size;
3412 init_cu_die_reader (&reader_specs, &cu);
3413 info_ptr = read_full_die (&reader_specs, &comp_unit_die, info_ptr,
3416 if (this_cu->debug_type_section)
3418 /* LENGTH has not been set yet for type units. */
3419 gdb_assert (this_cu->offset == cu.header.offset);
3420 this_cu->length = cu.header.length + cu.header.initial_length_size;
3422 else if (comp_unit_die->tag == DW_TAG_partial_unit)
3424 info_ptr = (beg_of_comp_unit + cu.header.length
3425 + cu.header.initial_length_size);
3426 do_cleanups (back_to_inner);
3430 prepare_one_comp_unit (&cu, comp_unit_die);
3432 /* Allocate a new partial symbol table structure. */
3433 attr = dwarf2_attr (comp_unit_die, DW_AT_name, &cu);
3434 if (attr == NULL || !DW_STRING (attr))
3437 filename = DW_STRING (attr);
3438 pst = start_psymtab_common (objfile, objfile->section_offsets,
3440 /* TEXTLOW and TEXTHIGH are set below. */
3442 objfile->global_psymbols.next,
3443 objfile->static_psymbols.next);
3445 attr = dwarf2_attr (comp_unit_die, DW_AT_comp_dir, &cu);
3447 pst->dirname = DW_STRING (attr);
3449 pst->read_symtab_private = this_cu;
3451 baseaddr = ANOFFSET (objfile->section_offsets, SECT_OFF_TEXT (objfile));
3453 /* Store the function that reads in the rest of the symbol table. */
3454 pst->read_symtab = dwarf2_psymtab_to_symtab;
3456 this_cu->v.psymtab = pst;
3458 dwarf2_find_base_address (comp_unit_die, &cu);
3460 /* Possibly set the default values of LOWPC and HIGHPC from
3462 has_pc_info = dwarf2_get_pc_bounds (comp_unit_die, &best_lowpc,
3463 &best_highpc, &cu, pst);
3464 if (has_pc_info == 1 && best_lowpc < best_highpc)
3465 /* Store the contiguous range if it is not empty; it can be empty for
3466 CUs with no code. */
3467 addrmap_set_empty (objfile->psymtabs_addrmap,
3468 best_lowpc + baseaddr,
3469 best_highpc + baseaddr - 1, pst);
3471 /* Check if comp unit has_children.
3472 If so, read the rest of the partial symbols from this comp unit.
3473 If not, there's no more debug_info for this comp unit. */
3476 struct partial_die_info *first_die;
3477 CORE_ADDR lowpc, highpc;
3479 lowpc = ((CORE_ADDR) -1);
3480 highpc = ((CORE_ADDR) 0);
3482 first_die = load_partial_dies (abfd, buffer, info_ptr, 1, &cu);
3484 scan_partial_symbols (first_die, &lowpc, &highpc,
3485 ! has_pc_info, &cu);
3487 /* If we didn't find a lowpc, set it to highpc to avoid
3488 complaints from `maint check'. */
3489 if (lowpc == ((CORE_ADDR) -1))
3492 /* If the compilation unit didn't have an explicit address range,
3493 then use the information extracted from its child dies. */
3497 best_highpc = highpc;
3500 pst->textlow = best_lowpc + baseaddr;
3501 pst->texthigh = best_highpc + baseaddr;
3503 pst->n_global_syms = objfile->global_psymbols.next -
3504 (objfile->global_psymbols.list + pst->globals_offset);
3505 pst->n_static_syms = objfile->static_psymbols.next -
3506 (objfile->static_psymbols.list + pst->statics_offset);
3507 sort_pst_symbols (pst);
3509 info_ptr = (beg_of_comp_unit + cu.header.length
3510 + cu.header.initial_length_size);
3512 if (this_cu->debug_type_section)
3514 /* It's not clear we want to do anything with stmt lists here.
3515 Waiting to see what gcc ultimately does. */
3519 /* Get the list of files included in the current compilation unit,
3520 and build a psymtab for each of them. */
3521 dwarf2_build_include_psymtabs (&cu, comp_unit_die, pst);
3524 do_cleanups (back_to_inner);
3529 /* Traversal function for htab_traverse_noresize.
3530 Process one .debug_types comp-unit. */
3533 process_type_comp_unit (void **slot, void *info)
3535 struct signatured_type *entry = (struct signatured_type *) *slot;
3536 struct objfile *objfile = (struct objfile *) info;
3537 struct dwarf2_per_cu_data *this_cu;
3539 this_cu = &entry->per_cu;
3541 gdb_assert (this_cu->debug_type_section->readin);
3542 process_psymtab_comp_unit (objfile, this_cu,
3543 this_cu->debug_type_section->buffer,
3544 (this_cu->debug_type_section->buffer
3546 this_cu->debug_type_section->size);
3551 /* Subroutine of dwarf2_build_psymtabs_hard to simplify it.
3552 Build partial symbol tables for the .debug_types comp-units. */
3555 build_type_psymtabs (struct objfile *objfile)
3557 if (! create_debug_types_hash_table (objfile))
3560 htab_traverse_noresize (dwarf2_per_objfile->signatured_types,
3561 process_type_comp_unit, objfile);
3564 /* A cleanup function that clears objfile's psymtabs_addrmap field. */
3567 psymtabs_addrmap_cleanup (void *o)
3569 struct objfile *objfile = o;
3571 objfile->psymtabs_addrmap = NULL;
3574 /* Build the partial symbol table by doing a quick pass through the
3575 .debug_info and .debug_abbrev sections. */
3578 dwarf2_build_psymtabs_hard (struct objfile *objfile)
3581 struct cleanup *back_to, *addrmap_cleanup;
3582 struct obstack temp_obstack;
3584 dwarf2_per_objfile->reading_partial_symbols = 1;
3586 dwarf2_read_section (objfile, &dwarf2_per_objfile->info);
3587 info_ptr = dwarf2_per_objfile->info.buffer;
3589 /* Any cached compilation units will be linked by the per-objfile
3590 read_in_chain. Make sure to free them when we're done. */
3591 back_to = make_cleanup (free_cached_comp_units, NULL);
3593 build_type_psymtabs (objfile);
3595 create_all_comp_units (objfile);
3597 /* Create a temporary address map on a temporary obstack. We later
3598 copy this to the final obstack. */
3599 obstack_init (&temp_obstack);
3600 make_cleanup_obstack_free (&temp_obstack);
3601 objfile->psymtabs_addrmap = addrmap_create_mutable (&temp_obstack);
3602 addrmap_cleanup = make_cleanup (psymtabs_addrmap_cleanup, objfile);
3604 /* Since the objects we're extracting from .debug_info vary in
3605 length, only the individual functions to extract them (like
3606 read_comp_unit_head and load_partial_die) can really know whether
3607 the buffer is large enough to hold another complete object.
3609 At the moment, they don't actually check that. If .debug_info
3610 holds just one extra byte after the last compilation unit's dies,
3611 then read_comp_unit_head will happily read off the end of the
3612 buffer. read_partial_die is similarly casual. Those functions
3615 For this loop condition, simply checking whether there's any data
3616 left at all should be sufficient. */
3618 while (info_ptr < (dwarf2_per_objfile->info.buffer
3619 + dwarf2_per_objfile->info.size))
3621 struct dwarf2_per_cu_data *this_cu;
3623 this_cu = dwarf2_find_comp_unit (info_ptr
3624 - dwarf2_per_objfile->info.buffer,
3627 info_ptr = process_psymtab_comp_unit (objfile, this_cu,
3628 dwarf2_per_objfile->info.buffer,
3630 dwarf2_per_objfile->info.size);
3633 objfile->psymtabs_addrmap = addrmap_create_fixed (objfile->psymtabs_addrmap,
3634 &objfile->objfile_obstack);
3635 discard_cleanups (addrmap_cleanup);
3637 do_cleanups (back_to);
3640 /* Load the partial DIEs for a secondary CU into memory. */
3643 load_partial_comp_unit (struct dwarf2_per_cu_data *this_cu,
3644 struct objfile *objfile)
3646 bfd *abfd = objfile->obfd;
3648 struct die_info *comp_unit_die;
3649 struct dwarf2_cu *cu;
3650 struct cleanup *free_abbrevs_cleanup, *free_cu_cleanup = NULL;
3652 struct die_reader_specs reader_specs;
3655 gdb_assert (! this_cu->debug_type_section);
3657 gdb_assert (dwarf2_per_objfile->info.readin);
3658 info_ptr = dwarf2_per_objfile->info.buffer + this_cu->offset;
3660 if (this_cu->cu == NULL)
3662 cu = xmalloc (sizeof (*cu));
3663 init_one_comp_unit (cu, objfile);
3667 /* If an error occurs while loading, release our storage. */
3668 free_cu_cleanup = make_cleanup (free_one_comp_unit, cu);
3670 info_ptr = partial_read_comp_unit_head (&cu->header, info_ptr,
3671 dwarf2_per_objfile->info.buffer,
3672 dwarf2_per_objfile->info.size,
3675 /* Skip dummy compilation units. */
3676 if (info_ptr >= (dwarf2_per_objfile->info.buffer
3677 + dwarf2_per_objfile->info.size)
3678 || peek_abbrev_code (abfd, info_ptr) == 0)
3680 do_cleanups (free_cu_cleanup);
3684 /* Link this compilation unit into the compilation unit tree. */
3686 cu->per_cu = this_cu;
3688 /* Link this CU into read_in_chain. */
3689 this_cu->cu->read_in_chain = dwarf2_per_objfile->read_in_chain;
3690 dwarf2_per_objfile->read_in_chain = this_cu;
3695 info_ptr += cu->header.first_die_offset;
3698 /* Read the abbrevs for this compilation unit into a table. */
3699 gdb_assert (cu->dwarf2_abbrevs == NULL);
3700 dwarf2_read_abbrevs (abfd, cu);
3701 free_abbrevs_cleanup = make_cleanup (dwarf2_free_abbrev_table, cu);
3703 /* Read the compilation unit die. */
3704 init_cu_die_reader (&reader_specs, cu);
3705 info_ptr = read_full_die (&reader_specs, &comp_unit_die, info_ptr,
3708 prepare_one_comp_unit (cu, comp_unit_die);
3710 /* Check if comp unit has_children.
3711 If so, read the rest of the partial symbols from this comp unit.
3712 If not, there's no more debug_info for this comp unit. */
3714 load_partial_dies (abfd, dwarf2_per_objfile->info.buffer, info_ptr, 0, cu);
3716 do_cleanups (free_abbrevs_cleanup);
3720 /* We've successfully allocated this compilation unit. Let our
3721 caller clean it up when finished with it. */
3722 discard_cleanups (free_cu_cleanup);
3726 /* Create a list of all compilation units in OBJFILE. We do this only
3727 if an inter-comp-unit reference is found; presumably if there is one,
3728 there will be many, and one will occur early in the .debug_info section.
3729 So there's no point in building this list incrementally. */
3732 create_all_comp_units (struct objfile *objfile)
3736 struct dwarf2_per_cu_data **all_comp_units;
3739 dwarf2_read_section (objfile, &dwarf2_per_objfile->info);
3740 info_ptr = dwarf2_per_objfile->info.buffer;
3744 all_comp_units = xmalloc (n_allocated
3745 * sizeof (struct dwarf2_per_cu_data *));
3747 while (info_ptr < dwarf2_per_objfile->info.buffer
3748 + dwarf2_per_objfile->info.size)
3750 unsigned int length, initial_length_size;
3751 struct dwarf2_per_cu_data *this_cu;
3752 unsigned int offset;
3754 offset = info_ptr - dwarf2_per_objfile->info.buffer;
3756 /* Read just enough information to find out where the next
3757 compilation unit is. */
3758 length = read_initial_length (objfile->obfd, info_ptr,
3759 &initial_length_size);
3761 /* Save the compilation unit for later lookup. */
3762 this_cu = obstack_alloc (&objfile->objfile_obstack,
3763 sizeof (struct dwarf2_per_cu_data));
3764 memset (this_cu, 0, sizeof (*this_cu));
3765 this_cu->offset = offset;
3766 this_cu->length = length + initial_length_size;
3767 this_cu->objfile = objfile;
3769 if (n_comp_units == n_allocated)
3772 all_comp_units = xrealloc (all_comp_units,
3774 * sizeof (struct dwarf2_per_cu_data *));
3776 all_comp_units[n_comp_units++] = this_cu;
3778 info_ptr = info_ptr + this_cu->length;
3781 dwarf2_per_objfile->all_comp_units
3782 = obstack_alloc (&objfile->objfile_obstack,
3783 n_comp_units * sizeof (struct dwarf2_per_cu_data *));
3784 memcpy (dwarf2_per_objfile->all_comp_units, all_comp_units,
3785 n_comp_units * sizeof (struct dwarf2_per_cu_data *));
3786 xfree (all_comp_units);
3787 dwarf2_per_objfile->n_comp_units = n_comp_units;
3790 /* Process all loaded DIEs for compilation unit CU, starting at
3791 FIRST_DIE. The caller should pass NEED_PC == 1 if the compilation
3792 unit DIE did not have PC info (DW_AT_low_pc and DW_AT_high_pc, or
3793 DW_AT_ranges). If NEED_PC is set, then this function will set
3794 *LOWPC and *HIGHPC to the lowest and highest PC values found in CU
3795 and record the covered ranges in the addrmap. */
3798 scan_partial_symbols (struct partial_die_info *first_die, CORE_ADDR *lowpc,
3799 CORE_ADDR *highpc, int need_pc, struct dwarf2_cu *cu)
3801 struct partial_die_info *pdi;
3803 /* Now, march along the PDI's, descending into ones which have
3804 interesting children but skipping the children of the other ones,
3805 until we reach the end of the compilation unit. */
3811 fixup_partial_die (pdi, cu);
3813 /* Anonymous namespaces or modules have no name but have interesting
3814 children, so we need to look at them. Ditto for anonymous
3817 if (pdi->name != NULL || pdi->tag == DW_TAG_namespace
3818 || pdi->tag == DW_TAG_module || pdi->tag == DW_TAG_enumeration_type)
3822 case DW_TAG_subprogram:
3823 add_partial_subprogram (pdi, lowpc, highpc, need_pc, cu);
3825 case DW_TAG_constant:
3826 case DW_TAG_variable:
3827 case DW_TAG_typedef:
3828 case DW_TAG_union_type:
3829 if (!pdi->is_declaration)
3831 add_partial_symbol (pdi, cu);
3834 case DW_TAG_class_type:
3835 case DW_TAG_interface_type:
3836 case DW_TAG_structure_type:
3837 if (!pdi->is_declaration)
3839 add_partial_symbol (pdi, cu);
3842 case DW_TAG_enumeration_type:
3843 if (!pdi->is_declaration)
3844 add_partial_enumeration (pdi, cu);
3846 case DW_TAG_base_type:
3847 case DW_TAG_subrange_type:
3848 /* File scope base type definitions are added to the partial
3850 add_partial_symbol (pdi, cu);
3852 case DW_TAG_namespace:
3853 add_partial_namespace (pdi, lowpc, highpc, need_pc, cu);
3856 add_partial_module (pdi, lowpc, highpc, need_pc, cu);
3863 /* If the die has a sibling, skip to the sibling. */
3865 pdi = pdi->die_sibling;
3869 /* Functions used to compute the fully scoped name of a partial DIE.
3871 Normally, this is simple. For C++, the parent DIE's fully scoped
3872 name is concatenated with "::" and the partial DIE's name. For
3873 Java, the same thing occurs except that "." is used instead of "::".
3874 Enumerators are an exception; they use the scope of their parent
3875 enumeration type, i.e. the name of the enumeration type is not
3876 prepended to the enumerator.
3878 There are two complexities. One is DW_AT_specification; in this
3879 case "parent" means the parent of the target of the specification,
3880 instead of the direct parent of the DIE. The other is compilers
3881 which do not emit DW_TAG_namespace; in this case we try to guess
3882 the fully qualified name of structure types from their members'
3883 linkage names. This must be done using the DIE's children rather
3884 than the children of any DW_AT_specification target. We only need
3885 to do this for structures at the top level, i.e. if the target of
3886 any DW_AT_specification (if any; otherwise the DIE itself) does not
3889 /* Compute the scope prefix associated with PDI's parent, in
3890 compilation unit CU. The result will be allocated on CU's
3891 comp_unit_obstack, or a copy of the already allocated PDI->NAME
3892 field. NULL is returned if no prefix is necessary. */
3894 partial_die_parent_scope (struct partial_die_info *pdi,
3895 struct dwarf2_cu *cu)
3897 char *grandparent_scope;
3898 struct partial_die_info *parent, *real_pdi;
3900 /* We need to look at our parent DIE; if we have a DW_AT_specification,
3901 then this means the parent of the specification DIE. */
3904 while (real_pdi->has_specification)
3905 real_pdi = find_partial_die (real_pdi->spec_offset, cu);
3907 parent = real_pdi->die_parent;
3911 if (parent->scope_set)
3912 return parent->scope;
3914 fixup_partial_die (parent, cu);
3916 grandparent_scope = partial_die_parent_scope (parent, cu);
3918 /* GCC 4.0 and 4.1 had a bug (PR c++/28460) where they generated bogus
3919 DW_TAG_namespace DIEs with a name of "::" for the global namespace.
3920 Work around this problem here. */
3921 if (cu->language == language_cplus
3922 && parent->tag == DW_TAG_namespace
3923 && strcmp (parent->name, "::") == 0
3924 && grandparent_scope == NULL)
3926 parent->scope = NULL;
3927 parent->scope_set = 1;
3931 if (pdi->tag == DW_TAG_enumerator)
3932 /* Enumerators should not get the name of the enumeration as a prefix. */
3933 parent->scope = grandparent_scope;
3934 else if (parent->tag == DW_TAG_namespace
3935 || parent->tag == DW_TAG_module
3936 || parent->tag == DW_TAG_structure_type
3937 || parent->tag == DW_TAG_class_type
3938 || parent->tag == DW_TAG_interface_type
3939 || parent->tag == DW_TAG_union_type
3940 || parent->tag == DW_TAG_enumeration_type)
3942 if (grandparent_scope == NULL)
3943 parent->scope = parent->name;
3945 parent->scope = typename_concat (&cu->comp_unit_obstack,
3947 parent->name, 0, cu);
3951 /* FIXME drow/2004-04-01: What should we be doing with
3952 function-local names? For partial symbols, we should probably be
3954 complaint (&symfile_complaints,
3955 _("unhandled containing DIE tag %d for DIE at %d"),
3956 parent->tag, pdi->offset);
3957 parent->scope = grandparent_scope;
3960 parent->scope_set = 1;
3961 return parent->scope;
3964 /* Return the fully scoped name associated with PDI, from compilation unit
3965 CU. The result will be allocated with malloc. */
3967 partial_die_full_name (struct partial_die_info *pdi,
3968 struct dwarf2_cu *cu)
3972 /* If this is a template instantiation, we can not work out the
3973 template arguments from partial DIEs. So, unfortunately, we have
3974 to go through the full DIEs. At least any work we do building
3975 types here will be reused if full symbols are loaded later. */
3976 if (pdi->has_template_arguments)
3978 fixup_partial_die (pdi, cu);
3980 if (pdi->name != NULL && strchr (pdi->name, '<') == NULL)
3982 struct die_info *die;
3983 struct attribute attr;
3984 struct dwarf2_cu *ref_cu = cu;
3987 attr.form = DW_FORM_ref_addr;
3988 attr.u.addr = pdi->offset;
3989 die = follow_die_ref (NULL, &attr, &ref_cu);
3991 return xstrdup (dwarf2_full_name (NULL, die, ref_cu));
3995 parent_scope = partial_die_parent_scope (pdi, cu);
3996 if (parent_scope == NULL)
3999 return typename_concat (NULL, parent_scope, pdi->name, 0, cu);
4003 add_partial_symbol (struct partial_die_info *pdi, struct dwarf2_cu *cu)
4005 struct objfile *objfile = cu->objfile;
4007 char *actual_name = NULL;
4008 const struct partial_symbol *psym = NULL;
4010 int built_actual_name = 0;
4012 baseaddr = ANOFFSET (objfile->section_offsets, SECT_OFF_TEXT (objfile));
4014 actual_name = partial_die_full_name (pdi, cu);
4016 built_actual_name = 1;
4018 if (actual_name == NULL)
4019 actual_name = pdi->name;
4023 case DW_TAG_subprogram:
4024 if (pdi->is_external || cu->language == language_ada)
4026 /* brobecker/2007-12-26: Normally, only "external" DIEs are part
4027 of the global scope. But in Ada, we want to be able to access
4028 nested procedures globally. So all Ada subprograms are stored
4029 in the global scope. */
4030 /* prim_record_minimal_symbol (actual_name, pdi->lowpc + baseaddr,
4031 mst_text, objfile); */
4032 add_psymbol_to_list (actual_name, strlen (actual_name),
4034 VAR_DOMAIN, LOC_BLOCK,
4035 &objfile->global_psymbols,
4036 0, pdi->lowpc + baseaddr,
4037 cu->language, objfile);
4041 /* prim_record_minimal_symbol (actual_name, pdi->lowpc + baseaddr,
4042 mst_file_text, objfile); */
4043 add_psymbol_to_list (actual_name, strlen (actual_name),
4045 VAR_DOMAIN, LOC_BLOCK,
4046 &objfile->static_psymbols,
4047 0, pdi->lowpc + baseaddr,
4048 cu->language, objfile);
4051 case DW_TAG_constant:
4053 struct psymbol_allocation_list *list;
4055 if (pdi->is_external)
4056 list = &objfile->global_psymbols;
4058 list = &objfile->static_psymbols;
4059 add_psymbol_to_list (actual_name, strlen (actual_name),
4060 built_actual_name, VAR_DOMAIN, LOC_STATIC,
4061 list, 0, 0, cu->language, objfile);
4064 case DW_TAG_variable:
4066 addr = decode_locdesc (pdi->locdesc, cu);
4070 && !dwarf2_per_objfile->has_section_at_zero)
4072 /* A global or static variable may also have been stripped
4073 out by the linker if unused, in which case its address
4074 will be nullified; do not add such variables into partial
4075 symbol table then. */
4077 else if (pdi->is_external)
4080 Don't enter into the minimal symbol tables as there is
4081 a minimal symbol table entry from the ELF symbols already.
4082 Enter into partial symbol table if it has a location
4083 descriptor or a type.
4084 If the location descriptor is missing, new_symbol will create
4085 a LOC_UNRESOLVED symbol, the address of the variable will then
4086 be determined from the minimal symbol table whenever the variable
4088 The address for the partial symbol table entry is not
4089 used by GDB, but it comes in handy for debugging partial symbol
4092 if (pdi->locdesc || pdi->has_type)
4093 add_psymbol_to_list (actual_name, strlen (actual_name),
4095 VAR_DOMAIN, LOC_STATIC,
4096 &objfile->global_psymbols,
4098 cu->language, objfile);
4102 /* Static Variable. Skip symbols without location descriptors. */
4103 if (pdi->locdesc == NULL)
4105 if (built_actual_name)
4106 xfree (actual_name);
4109 /* prim_record_minimal_symbol (actual_name, addr + baseaddr,
4110 mst_file_data, objfile); */
4111 add_psymbol_to_list (actual_name, strlen (actual_name),
4113 VAR_DOMAIN, LOC_STATIC,
4114 &objfile->static_psymbols,
4116 cu->language, objfile);
4119 case DW_TAG_typedef:
4120 case DW_TAG_base_type:
4121 case DW_TAG_subrange_type:
4122 add_psymbol_to_list (actual_name, strlen (actual_name),
4124 VAR_DOMAIN, LOC_TYPEDEF,
4125 &objfile->static_psymbols,
4126 0, (CORE_ADDR) 0, cu->language, objfile);
4128 case DW_TAG_namespace:
4129 add_psymbol_to_list (actual_name, strlen (actual_name),
4131 VAR_DOMAIN, LOC_TYPEDEF,
4132 &objfile->global_psymbols,
4133 0, (CORE_ADDR) 0, cu->language, objfile);
4135 case DW_TAG_class_type:
4136 case DW_TAG_interface_type:
4137 case DW_TAG_structure_type:
4138 case DW_TAG_union_type:
4139 case DW_TAG_enumeration_type:
4140 /* Skip external references. The DWARF standard says in the section
4141 about "Structure, Union, and Class Type Entries": "An incomplete
4142 structure, union or class type is represented by a structure,
4143 union or class entry that does not have a byte size attribute
4144 and that has a DW_AT_declaration attribute." */
4145 if (!pdi->has_byte_size && pdi->is_declaration)
4147 if (built_actual_name)
4148 xfree (actual_name);
4152 /* NOTE: carlton/2003-10-07: See comment in new_symbol about
4153 static vs. global. */
4154 add_psymbol_to_list (actual_name, strlen (actual_name),
4156 STRUCT_DOMAIN, LOC_TYPEDEF,
4157 (cu->language == language_cplus
4158 || cu->language == language_java)
4159 ? &objfile->global_psymbols
4160 : &objfile->static_psymbols,
4161 0, (CORE_ADDR) 0, cu->language, objfile);
4164 case DW_TAG_enumerator:
4165 add_psymbol_to_list (actual_name, strlen (actual_name),
4167 VAR_DOMAIN, LOC_CONST,
4168 (cu->language == language_cplus
4169 || cu->language == language_java)
4170 ? &objfile->global_psymbols
4171 : &objfile->static_psymbols,
4172 0, (CORE_ADDR) 0, cu->language, objfile);
4178 if (built_actual_name)
4179 xfree (actual_name);
4182 /* Read a partial die corresponding to a namespace; also, add a symbol
4183 corresponding to that namespace to the symbol table. NAMESPACE is
4184 the name of the enclosing namespace. */
4187 add_partial_namespace (struct partial_die_info *pdi,
4188 CORE_ADDR *lowpc, CORE_ADDR *highpc,
4189 int need_pc, struct dwarf2_cu *cu)
4191 /* Add a symbol for the namespace. */
4193 add_partial_symbol (pdi, cu);
4195 /* Now scan partial symbols in that namespace. */
4197 if (pdi->has_children)
4198 scan_partial_symbols (pdi->die_child, lowpc, highpc, need_pc, cu);
4201 /* Read a partial die corresponding to a Fortran module. */
4204 add_partial_module (struct partial_die_info *pdi, CORE_ADDR *lowpc,
4205 CORE_ADDR *highpc, int need_pc, struct dwarf2_cu *cu)
4207 /* Now scan partial symbols in that module. */
4209 if (pdi->has_children)
4210 scan_partial_symbols (pdi->die_child, lowpc, highpc, need_pc, cu);
4213 /* Read a partial die corresponding to a subprogram and create a partial
4214 symbol for that subprogram. When the CU language allows it, this
4215 routine also defines a partial symbol for each nested subprogram
4216 that this subprogram contains.
4218 DIE my also be a lexical block, in which case we simply search
4219 recursively for suprograms defined inside that lexical block.
4220 Again, this is only performed when the CU language allows this
4221 type of definitions. */
4224 add_partial_subprogram (struct partial_die_info *pdi,
4225 CORE_ADDR *lowpc, CORE_ADDR *highpc,
4226 int need_pc, struct dwarf2_cu *cu)
4228 if (pdi->tag == DW_TAG_subprogram)
4230 if (pdi->has_pc_info)
4232 if (pdi->lowpc < *lowpc)
4233 *lowpc = pdi->lowpc;
4234 if (pdi->highpc > *highpc)
4235 *highpc = pdi->highpc;
4239 struct objfile *objfile = cu->objfile;
4241 baseaddr = ANOFFSET (objfile->section_offsets,
4242 SECT_OFF_TEXT (objfile));
4243 addrmap_set_empty (objfile->psymtabs_addrmap,
4244 pdi->lowpc + baseaddr,
4245 pdi->highpc - 1 + baseaddr,
4246 cu->per_cu->v.psymtab);
4248 if (!pdi->is_declaration)
4249 /* Ignore subprogram DIEs that do not have a name, they are
4250 illegal. Do not emit a complaint at this point, we will
4251 do so when we convert this psymtab into a symtab. */
4253 add_partial_symbol (pdi, cu);
4257 if (! pdi->has_children)
4260 if (cu->language == language_ada)
4262 pdi = pdi->die_child;
4265 fixup_partial_die (pdi, cu);
4266 if (pdi->tag == DW_TAG_subprogram
4267 || pdi->tag == DW_TAG_lexical_block)
4268 add_partial_subprogram (pdi, lowpc, highpc, need_pc, cu);
4269 pdi = pdi->die_sibling;
4274 /* Read a partial die corresponding to an enumeration type. */
4277 add_partial_enumeration (struct partial_die_info *enum_pdi,
4278 struct dwarf2_cu *cu)
4280 struct partial_die_info *pdi;
4282 if (enum_pdi->name != NULL)
4283 add_partial_symbol (enum_pdi, cu);
4285 pdi = enum_pdi->die_child;
4288 if (pdi->tag != DW_TAG_enumerator || pdi->name == NULL)
4289 complaint (&symfile_complaints, _("malformed enumerator DIE ignored"));
4291 add_partial_symbol (pdi, cu);
4292 pdi = pdi->die_sibling;
4296 /* Return the initial uleb128 in the die at INFO_PTR. */
4299 peek_abbrev_code (bfd *abfd, gdb_byte *info_ptr)
4301 unsigned int bytes_read;
4303 return read_unsigned_leb128 (abfd, info_ptr, &bytes_read);
4306 /* Read the initial uleb128 in the die at INFO_PTR in compilation unit CU.
4307 Return the corresponding abbrev, or NULL if the number is zero (indicating
4308 an empty DIE). In either case *BYTES_READ will be set to the length of
4309 the initial number. */
4311 static struct abbrev_info *
4312 peek_die_abbrev (gdb_byte *info_ptr, unsigned int *bytes_read,
4313 struct dwarf2_cu *cu)
4315 bfd *abfd = cu->objfile->obfd;
4316 unsigned int abbrev_number;
4317 struct abbrev_info *abbrev;
4319 abbrev_number = read_unsigned_leb128 (abfd, info_ptr, bytes_read);
4321 if (abbrev_number == 0)
4324 abbrev = dwarf2_lookup_abbrev (abbrev_number, cu);
4327 error (_("Dwarf Error: Could not find abbrev number %d [in module %s]"),
4328 abbrev_number, bfd_get_filename (abfd));
4334 /* Scan the debug information for CU starting at INFO_PTR in buffer BUFFER.
4335 Returns a pointer to the end of a series of DIEs, terminated by an empty
4336 DIE. Any children of the skipped DIEs will also be skipped. */
4339 skip_children (gdb_byte *buffer, gdb_byte *info_ptr, struct dwarf2_cu *cu)
4341 struct abbrev_info *abbrev;
4342 unsigned int bytes_read;
4346 abbrev = peek_die_abbrev (info_ptr, &bytes_read, cu);
4348 return info_ptr + bytes_read;
4350 info_ptr = skip_one_die (buffer, info_ptr + bytes_read, abbrev, cu);
4354 /* Scan the debug information for CU starting at INFO_PTR in buffer BUFFER.
4355 INFO_PTR should point just after the initial uleb128 of a DIE, and the
4356 abbrev corresponding to that skipped uleb128 should be passed in
4357 ABBREV. Returns a pointer to this DIE's sibling, skipping any
4361 skip_one_die (gdb_byte *buffer, gdb_byte *info_ptr,
4362 struct abbrev_info *abbrev, struct dwarf2_cu *cu)
4364 unsigned int bytes_read;
4365 struct attribute attr;
4366 bfd *abfd = cu->objfile->obfd;
4367 unsigned int form, i;
4369 for (i = 0; i < abbrev->num_attrs; i++)
4371 /* The only abbrev we care about is DW_AT_sibling. */
4372 if (abbrev->attrs[i].name == DW_AT_sibling)
4374 read_attribute (&attr, &abbrev->attrs[i],
4375 abfd, info_ptr, cu);
4376 if (attr.form == DW_FORM_ref_addr)
4377 complaint (&symfile_complaints,
4378 _("ignoring absolute DW_AT_sibling"));
4380 return buffer + dwarf2_get_ref_die_offset (&attr);
4383 /* If it isn't DW_AT_sibling, skip this attribute. */
4384 form = abbrev->attrs[i].form;
4388 case DW_FORM_ref_addr:
4389 /* In DWARF 2, DW_FORM_ref_addr is address sized; in DWARF 3
4390 and later it is offset sized. */
4391 if (cu->header.version == 2)
4392 info_ptr += cu->header.addr_size;
4394 info_ptr += cu->header.offset_size;
4397 info_ptr += cu->header.addr_size;
4404 case DW_FORM_flag_present:
4416 case DW_FORM_ref_sig8:
4419 case DW_FORM_string:
4420 read_direct_string (abfd, info_ptr, &bytes_read);
4421 info_ptr += bytes_read;
4423 case DW_FORM_sec_offset:
4425 info_ptr += cu->header.offset_size;
4427 case DW_FORM_exprloc:
4429 info_ptr += read_unsigned_leb128 (abfd, info_ptr, &bytes_read);
4430 info_ptr += bytes_read;
4432 case DW_FORM_block1:
4433 info_ptr += 1 + read_1_byte (abfd, info_ptr);
4435 case DW_FORM_block2:
4436 info_ptr += 2 + read_2_bytes (abfd, info_ptr);
4438 case DW_FORM_block4:
4439 info_ptr += 4 + read_4_bytes (abfd, info_ptr);
4443 case DW_FORM_ref_udata:
4444 info_ptr = skip_leb128 (abfd, info_ptr);
4446 case DW_FORM_indirect:
4447 form = read_unsigned_leb128 (abfd, info_ptr, &bytes_read);
4448 info_ptr += bytes_read;
4449 /* We need to continue parsing from here, so just go back to
4451 goto skip_attribute;
4454 error (_("Dwarf Error: Cannot handle %s "
4455 "in DWARF reader [in module %s]"),
4456 dwarf_form_name (form),
4457 bfd_get_filename (abfd));
4461 if (abbrev->has_children)
4462 return skip_children (buffer, info_ptr, cu);
4467 /* Locate ORIG_PDI's sibling.
4468 INFO_PTR should point to the start of the next DIE after ORIG_PDI
4472 locate_pdi_sibling (struct partial_die_info *orig_pdi,
4473 gdb_byte *buffer, gdb_byte *info_ptr,
4474 bfd *abfd, struct dwarf2_cu *cu)
4476 /* Do we know the sibling already? */
4478 if (orig_pdi->sibling)
4479 return orig_pdi->sibling;
4481 /* Are there any children to deal with? */
4483 if (!orig_pdi->has_children)
4486 /* Skip the children the long way. */
4488 return skip_children (buffer, info_ptr, cu);
4491 /* Expand this partial symbol table into a full symbol table. */
4494 dwarf2_psymtab_to_symtab (struct partial_symtab *pst)
4500 warning (_("bug: psymtab for %s is already read in."),
4507 printf_filtered (_("Reading in symbols for %s..."),
4509 gdb_flush (gdb_stdout);
4512 /* Restore our global data. */
4513 dwarf2_per_objfile = objfile_data (pst->objfile,
4514 dwarf2_objfile_data_key);
4516 /* If this psymtab is constructed from a debug-only objfile, the
4517 has_section_at_zero flag will not necessarily be correct. We
4518 can get the correct value for this flag by looking at the data
4519 associated with the (presumably stripped) associated objfile. */
4520 if (pst->objfile->separate_debug_objfile_backlink)
4522 struct dwarf2_per_objfile *dpo_backlink
4523 = objfile_data (pst->objfile->separate_debug_objfile_backlink,
4524 dwarf2_objfile_data_key);
4526 dwarf2_per_objfile->has_section_at_zero
4527 = dpo_backlink->has_section_at_zero;
4530 dwarf2_per_objfile->reading_partial_symbols = 0;
4532 psymtab_to_symtab_1 (pst);
4534 /* Finish up the debug error message. */
4536 printf_filtered (_("done.\n"));
4541 /* Add PER_CU to the queue. */
4544 queue_comp_unit (struct dwarf2_per_cu_data *per_cu, struct objfile *objfile)
4546 struct dwarf2_queue_item *item;
4549 item = xmalloc (sizeof (*item));
4550 item->per_cu = per_cu;
4553 if (dwarf2_queue == NULL)
4554 dwarf2_queue = item;
4556 dwarf2_queue_tail->next = item;
4558 dwarf2_queue_tail = item;
4561 /* Process the queue. */
4564 process_queue (struct objfile *objfile)
4566 struct dwarf2_queue_item *item, *next_item;
4568 /* The queue starts out with one item, but following a DIE reference
4569 may load a new CU, adding it to the end of the queue. */
4570 for (item = dwarf2_queue; item != NULL; dwarf2_queue = item = next_item)
4572 if (dwarf2_per_objfile->using_index
4573 ? !item->per_cu->v.quick->symtab
4574 : (item->per_cu->v.psymtab && !item->per_cu->v.psymtab->readin))
4575 process_full_comp_unit (item->per_cu);
4577 item->per_cu->queued = 0;
4578 next_item = item->next;
4582 dwarf2_queue_tail = NULL;
4585 /* Free all allocated queue entries. This function only releases anything if
4586 an error was thrown; if the queue was processed then it would have been
4587 freed as we went along. */
4590 dwarf2_release_queue (void *dummy)
4592 struct dwarf2_queue_item *item, *last;
4594 item = dwarf2_queue;
4597 /* Anything still marked queued is likely to be in an
4598 inconsistent state, so discard it. */
4599 if (item->per_cu->queued)
4601 if (item->per_cu->cu != NULL)
4602 free_one_cached_comp_unit (item->per_cu->cu);
4603 item->per_cu->queued = 0;
4611 dwarf2_queue = dwarf2_queue_tail = NULL;
4614 /* Read in full symbols for PST, and anything it depends on. */
4617 psymtab_to_symtab_1 (struct partial_symtab *pst)
4619 struct dwarf2_per_cu_data *per_cu;
4620 struct cleanup *back_to;
4623 for (i = 0; i < pst->number_of_dependencies; i++)
4624 if (!pst->dependencies[i]->readin)
4626 /* Inform about additional files that need to be read in. */
4629 /* FIXME: i18n: Need to make this a single string. */
4630 fputs_filtered (" ", gdb_stdout);
4632 fputs_filtered ("and ", gdb_stdout);
4634 printf_filtered ("%s...", pst->dependencies[i]->filename);
4635 wrap_here (""); /* Flush output. */
4636 gdb_flush (gdb_stdout);
4638 psymtab_to_symtab_1 (pst->dependencies[i]);
4641 per_cu = pst->read_symtab_private;
4645 /* It's an include file, no symbols to read for it.
4646 Everything is in the parent symtab. */
4651 dw2_do_instantiate_symtab (pst->objfile, per_cu);
4654 /* Load the DIEs associated with PER_CU into memory. */
4657 load_full_comp_unit (struct dwarf2_per_cu_data *per_cu,
4658 struct objfile *objfile)
4660 bfd *abfd = objfile->obfd;
4661 struct dwarf2_cu *cu;
4662 unsigned int offset;
4663 gdb_byte *info_ptr, *beg_of_comp_unit;
4664 struct cleanup *free_abbrevs_cleanup = NULL, *free_cu_cleanup = NULL;
4665 struct attribute *attr;
4668 gdb_assert (! per_cu->debug_type_section);
4670 /* Set local variables from the partial symbol table info. */
4671 offset = per_cu->offset;
4673 dwarf2_read_section (objfile, &dwarf2_per_objfile->info);
4674 info_ptr = dwarf2_per_objfile->info.buffer + offset;
4675 beg_of_comp_unit = info_ptr;
4677 if (per_cu->cu == NULL)
4679 cu = xmalloc (sizeof (*cu));
4680 init_one_comp_unit (cu, objfile);
4684 /* If an error occurs while loading, release our storage. */
4685 free_cu_cleanup = make_cleanup (free_one_comp_unit, cu);
4687 /* Read in the comp_unit header. */
4688 info_ptr = read_comp_unit_head (&cu->header, info_ptr, abfd);
4690 /* Skip dummy compilation units. */
4691 if (info_ptr >= (dwarf2_per_objfile->info.buffer
4692 + dwarf2_per_objfile->info.size)
4693 || peek_abbrev_code (abfd, info_ptr) == 0)
4695 do_cleanups (free_cu_cleanup);
4699 /* Complete the cu_header. */
4700 cu->header.offset = offset;
4701 cu->header.first_die_offset = info_ptr - beg_of_comp_unit;
4703 /* Read the abbrevs for this compilation unit. */
4704 dwarf2_read_abbrevs (abfd, cu);
4705 free_abbrevs_cleanup = make_cleanup (dwarf2_free_abbrev_table, cu);
4707 /* Link this compilation unit into the compilation unit tree. */
4709 cu->per_cu = per_cu;
4711 /* Link this CU into read_in_chain. */
4712 per_cu->cu->read_in_chain = dwarf2_per_objfile->read_in_chain;
4713 dwarf2_per_objfile->read_in_chain = per_cu;
4718 info_ptr += cu->header.first_die_offset;
4721 cu->dies = read_comp_unit (info_ptr, cu);
4723 /* We try not to read any attributes in this function, because not
4724 all objfiles needed for references have been loaded yet, and symbol
4725 table processing isn't initialized. But we have to set the CU language,
4726 or we won't be able to build types correctly. */
4727 prepare_one_comp_unit (cu, cu->dies);
4729 /* Similarly, if we do not read the producer, we can not apply
4730 producer-specific interpretation. */
4731 attr = dwarf2_attr (cu->dies, DW_AT_producer, cu);
4733 cu->producer = DW_STRING (attr);
4737 do_cleanups (free_abbrevs_cleanup);
4739 /* We've successfully allocated this compilation unit. Let our
4740 caller clean it up when finished with it. */
4741 discard_cleanups (free_cu_cleanup);
4745 /* Add a DIE to the delayed physname list. */
4748 add_to_method_list (struct type *type, int fnfield_index, int index,
4749 const char *name, struct die_info *die,
4750 struct dwarf2_cu *cu)
4752 struct delayed_method_info mi;
4754 mi.fnfield_index = fnfield_index;
4758 VEC_safe_push (delayed_method_info, cu->method_list, &mi);
4761 /* A cleanup for freeing the delayed method list. */
4764 free_delayed_list (void *ptr)
4766 struct dwarf2_cu *cu = (struct dwarf2_cu *) ptr;
4767 if (cu->method_list != NULL)
4769 VEC_free (delayed_method_info, cu->method_list);
4770 cu->method_list = NULL;
4774 /* Compute the physnames of any methods on the CU's method list.
4776 The computation of method physnames is delayed in order to avoid the
4777 (bad) condition that one of the method's formal parameters is of an as yet
4781 compute_delayed_physnames (struct dwarf2_cu *cu)
4784 struct delayed_method_info *mi;
4785 for (i = 0; VEC_iterate (delayed_method_info, cu->method_list, i, mi) ; ++i)
4787 const char *physname;
4788 struct fn_fieldlist *fn_flp
4789 = &TYPE_FN_FIELDLIST (mi->type, mi->fnfield_index);
4790 physname = dwarf2_physname ((char *) mi->name, mi->die, cu);
4791 fn_flp->fn_fields[mi->index].physname = physname ? physname : "";
4795 /* Generate full symbol information for PST and CU, whose DIEs have
4796 already been loaded into memory. */
4799 process_full_comp_unit (struct dwarf2_per_cu_data *per_cu)
4801 struct dwarf2_cu *cu = per_cu->cu;
4802 struct objfile *objfile = per_cu->objfile;
4803 CORE_ADDR lowpc, highpc;
4804 struct symtab *symtab;
4805 struct cleanup *back_to, *delayed_list_cleanup;
4808 baseaddr = ANOFFSET (objfile->section_offsets, SECT_OFF_TEXT (objfile));
4811 back_to = make_cleanup (really_free_pendings, NULL);
4812 delayed_list_cleanup = make_cleanup (free_delayed_list, cu);
4814 cu->list_in_scope = &file_symbols;
4816 /* Do line number decoding in read_file_scope () */
4817 process_die (cu->dies, cu);
4819 /* Now that we have processed all the DIEs in the CU, all the types
4820 should be complete, and it should now be safe to compute all of the
4822 compute_delayed_physnames (cu);
4823 do_cleanups (delayed_list_cleanup);
4825 /* Some compilers don't define a DW_AT_high_pc attribute for the
4826 compilation unit. If the DW_AT_high_pc is missing, synthesize
4827 it, by scanning the DIE's below the compilation unit. */
4828 get_scope_pc_bounds (cu->dies, &lowpc, &highpc, cu);
4830 symtab = end_symtab (highpc + baseaddr, objfile, SECT_OFF_TEXT (objfile));
4834 int gcc_4_minor = producer_is_gcc_ge_4 (cu->producer);
4836 /* Set symtab language to language from DW_AT_language. If the
4837 compilation is from a C file generated by language preprocessors, do
4838 not set the language if it was already deduced by start_subfile. */
4839 if (!(cu->language == language_c && symtab->language != language_c))
4840 symtab->language = cu->language;
4842 /* GCC-4.0 has started to support -fvar-tracking. GCC-3.x still can
4843 produce DW_AT_location with location lists but it can be possibly
4844 invalid without -fvar-tracking.
4846 For -gdwarf-4 type units LOCATIONS_VALID indication is fortunately not
4847 needed, it would be wrong due to missing DW_AT_producer there.
4849 Still one can confuse GDB by using non-standard GCC compilation
4850 options - this waits on GCC PR other/32998 (-frecord-gcc-switches).
4852 if (cu->has_loclist && gcc_4_minor >= 0)
4853 symtab->locations_valid = 1;
4855 if (gcc_4_minor >= 5)
4856 symtab->epilogue_unwind_valid = 1;
4858 symtab->call_site_htab = cu->call_site_htab;
4861 if (dwarf2_per_objfile->using_index)
4862 per_cu->v.quick->symtab = symtab;
4865 struct partial_symtab *pst = per_cu->v.psymtab;
4866 pst->symtab = symtab;
4870 do_cleanups (back_to);
4873 /* Process a die and its children. */
4876 process_die (struct die_info *die, struct dwarf2_cu *cu)
4880 case DW_TAG_padding:
4882 case DW_TAG_compile_unit:
4883 read_file_scope (die, cu);
4885 case DW_TAG_type_unit:
4886 read_type_unit_scope (die, cu);
4888 case DW_TAG_subprogram:
4889 case DW_TAG_inlined_subroutine:
4890 read_func_scope (die, cu);
4892 case DW_TAG_lexical_block:
4893 case DW_TAG_try_block:
4894 case DW_TAG_catch_block:
4895 read_lexical_block_scope (die, cu);
4897 case DW_TAG_GNU_call_site:
4898 read_call_site_scope (die, cu);
4900 case DW_TAG_class_type:
4901 case DW_TAG_interface_type:
4902 case DW_TAG_structure_type:
4903 case DW_TAG_union_type:
4904 process_structure_scope (die, cu);
4906 case DW_TAG_enumeration_type:
4907 process_enumeration_scope (die, cu);
4910 /* These dies have a type, but processing them does not create
4911 a symbol or recurse to process the children. Therefore we can
4912 read them on-demand through read_type_die. */
4913 case DW_TAG_subroutine_type:
4914 case DW_TAG_set_type:
4915 case DW_TAG_array_type:
4916 case DW_TAG_pointer_type:
4917 case DW_TAG_ptr_to_member_type:
4918 case DW_TAG_reference_type:
4919 case DW_TAG_string_type:
4922 case DW_TAG_base_type:
4923 case DW_TAG_subrange_type:
4924 case DW_TAG_typedef:
4925 /* Add a typedef symbol for the type definition, if it has a
4927 new_symbol (die, read_type_die (die, cu), cu);
4929 case DW_TAG_common_block:
4930 read_common_block (die, cu);
4932 case DW_TAG_common_inclusion:
4934 case DW_TAG_namespace:
4935 processing_has_namespace_info = 1;
4936 read_namespace (die, cu);
4939 processing_has_namespace_info = 1;
4940 read_module (die, cu);
4942 case DW_TAG_imported_declaration:
4943 case DW_TAG_imported_module:
4944 processing_has_namespace_info = 1;
4945 if (die->child != NULL && (die->tag == DW_TAG_imported_declaration
4946 || cu->language != language_fortran))
4947 complaint (&symfile_complaints, _("Tag '%s' has unexpected children"),
4948 dwarf_tag_name (die->tag));
4949 read_import_statement (die, cu);
4952 new_symbol (die, NULL, cu);
4957 /* A helper function for dwarf2_compute_name which determines whether DIE
4958 needs to have the name of the scope prepended to the name listed in the
4962 die_needs_namespace (struct die_info *die, struct dwarf2_cu *cu)
4964 struct attribute *attr;
4968 case DW_TAG_namespace:
4969 case DW_TAG_typedef:
4970 case DW_TAG_class_type:
4971 case DW_TAG_interface_type:
4972 case DW_TAG_structure_type:
4973 case DW_TAG_union_type:
4974 case DW_TAG_enumeration_type:
4975 case DW_TAG_enumerator:
4976 case DW_TAG_subprogram:
4980 case DW_TAG_variable:
4981 case DW_TAG_constant:
4982 /* We only need to prefix "globally" visible variables. These include
4983 any variable marked with DW_AT_external or any variable that
4984 lives in a namespace. [Variables in anonymous namespaces
4985 require prefixing, but they are not DW_AT_external.] */
4987 if (dwarf2_attr (die, DW_AT_specification, cu))
4989 struct dwarf2_cu *spec_cu = cu;
4991 return die_needs_namespace (die_specification (die, &spec_cu),
4995 attr = dwarf2_attr (die, DW_AT_external, cu);
4996 if (attr == NULL && die->parent->tag != DW_TAG_namespace
4997 && die->parent->tag != DW_TAG_module)
4999 /* A variable in a lexical block of some kind does not need a
5000 namespace, even though in C++ such variables may be external
5001 and have a mangled name. */
5002 if (die->parent->tag == DW_TAG_lexical_block
5003 || die->parent->tag == DW_TAG_try_block
5004 || die->parent->tag == DW_TAG_catch_block
5005 || die->parent->tag == DW_TAG_subprogram)
5014 /* Retrieve the last character from a mem_file. */
5017 do_ui_file_peek_last (void *object, const char *buffer, long length)
5019 char *last_char_p = (char *) object;
5022 *last_char_p = buffer[length - 1];
5025 /* Compute the fully qualified name of DIE in CU. If PHYSNAME is nonzero,
5026 compute the physname for the object, which include a method's
5027 formal parameters (C++/Java) and return type (Java).
5029 For Ada, return the DIE's linkage name rather than the fully qualified
5030 name. PHYSNAME is ignored..
5032 The result is allocated on the objfile_obstack and canonicalized. */
5035 dwarf2_compute_name (char *name, struct die_info *die, struct dwarf2_cu *cu,
5039 name = dwarf2_name (die, cu);
5041 /* For Fortran GDB prefers DW_AT_*linkage_name if present but otherwise
5042 compute it by typename_concat inside GDB. */
5043 if (cu->language == language_ada
5044 || (cu->language == language_fortran && physname))
5046 /* For Ada unit, we prefer the linkage name over the name, as
5047 the former contains the exported name, which the user expects
5048 to be able to reference. Ideally, we want the user to be able
5049 to reference this entity using either natural or linkage name,
5050 but we haven't started looking at this enhancement yet. */
5051 struct attribute *attr;
5053 attr = dwarf2_attr (die, DW_AT_linkage_name, cu);
5055 attr = dwarf2_attr (die, DW_AT_MIPS_linkage_name, cu);
5056 if (attr && DW_STRING (attr))
5057 return DW_STRING (attr);
5060 /* These are the only languages we know how to qualify names in. */
5062 && (cu->language == language_cplus || cu->language == language_java
5063 || cu->language == language_fortran))
5065 if (die_needs_namespace (die, cu))
5069 struct ui_file *buf;
5071 prefix = determine_prefix (die, cu);
5072 buf = mem_fileopen ();
5073 if (*prefix != '\0')
5075 char *prefixed_name = typename_concat (NULL, prefix, name,
5078 fputs_unfiltered (prefixed_name, buf);
5079 xfree (prefixed_name);
5082 fputs_unfiltered (name, buf);
5084 /* Template parameters may be specified in the DIE's DW_AT_name, or
5085 as children with DW_TAG_template_type_param or
5086 DW_TAG_value_type_param. If the latter, add them to the name
5087 here. If the name already has template parameters, then
5088 skip this step; some versions of GCC emit both, and
5089 it is more efficient to use the pre-computed name.
5091 Something to keep in mind about this process: it is very
5092 unlikely, or in some cases downright impossible, to produce
5093 something that will match the mangled name of a function.
5094 If the definition of the function has the same debug info,
5095 we should be able to match up with it anyway. But fallbacks
5096 using the minimal symbol, for instance to find a method
5097 implemented in a stripped copy of libstdc++, will not work.
5098 If we do not have debug info for the definition, we will have to
5099 match them up some other way.
5101 When we do name matching there is a related problem with function
5102 templates; two instantiated function templates are allowed to
5103 differ only by their return types, which we do not add here. */
5105 if (cu->language == language_cplus && strchr (name, '<') == NULL)
5107 struct attribute *attr;
5108 struct die_info *child;
5111 die->building_fullname = 1;
5113 for (child = die->child; child != NULL; child = child->sibling)
5118 struct dwarf2_locexpr_baton *baton;
5121 if (child->tag != DW_TAG_template_type_param
5122 && child->tag != DW_TAG_template_value_param)
5127 fputs_unfiltered ("<", buf);
5131 fputs_unfiltered (", ", buf);
5133 attr = dwarf2_attr (child, DW_AT_type, cu);
5136 complaint (&symfile_complaints,
5137 _("template parameter missing DW_AT_type"));
5138 fputs_unfiltered ("UNKNOWN_TYPE", buf);
5141 type = die_type (child, cu);
5143 if (child->tag == DW_TAG_template_type_param)
5145 c_print_type (type, "", buf, -1, 0);
5149 attr = dwarf2_attr (child, DW_AT_const_value, cu);
5152 complaint (&symfile_complaints,
5153 _("template parameter missing "
5154 "DW_AT_const_value"));
5155 fputs_unfiltered ("UNKNOWN_VALUE", buf);
5159 dwarf2_const_value_attr (attr, type, name,
5160 &cu->comp_unit_obstack, cu,
5161 &value, &bytes, &baton);
5163 if (TYPE_NOSIGN (type))
5164 /* GDB prints characters as NUMBER 'CHAR'. If that's
5165 changed, this can use value_print instead. */
5166 c_printchar (value, type, buf);
5169 struct value_print_options opts;
5172 v = dwarf2_evaluate_loc_desc (type, NULL,
5176 else if (bytes != NULL)
5178 v = allocate_value (type);
5179 memcpy (value_contents_writeable (v), bytes,
5180 TYPE_LENGTH (type));
5183 v = value_from_longest (type, value);
5185 /* Specify decimal so that we do not depend on
5187 get_formatted_print_options (&opts, 'd');
5189 value_print (v, buf, &opts);
5195 die->building_fullname = 0;
5199 /* Close the argument list, with a space if necessary
5200 (nested templates). */
5201 char last_char = '\0';
5202 ui_file_put (buf, do_ui_file_peek_last, &last_char);
5203 if (last_char == '>')
5204 fputs_unfiltered (" >", buf);
5206 fputs_unfiltered (">", buf);
5210 /* For Java and C++ methods, append formal parameter type
5211 information, if PHYSNAME. */
5213 if (physname && die->tag == DW_TAG_subprogram
5214 && (cu->language == language_cplus
5215 || cu->language == language_java))
5217 struct type *type = read_type_die (die, cu);
5219 c_type_print_args (type, buf, 1, cu->language);
5221 if (cu->language == language_java)
5223 /* For java, we must append the return type to method
5225 if (die->tag == DW_TAG_subprogram)
5226 java_print_type (TYPE_TARGET_TYPE (type), "", buf,
5229 else if (cu->language == language_cplus)
5231 /* Assume that an artificial first parameter is
5232 "this", but do not crash if it is not. RealView
5233 marks unnamed (and thus unused) parameters as
5234 artificial; there is no way to differentiate
5236 if (TYPE_NFIELDS (type) > 0
5237 && TYPE_FIELD_ARTIFICIAL (type, 0)
5238 && TYPE_CODE (TYPE_FIELD_TYPE (type, 0)) == TYPE_CODE_PTR
5239 && TYPE_CONST (TYPE_TARGET_TYPE (TYPE_FIELD_TYPE (type,
5241 fputs_unfiltered (" const", buf);
5245 name = ui_file_obsavestring (buf, &cu->objfile->objfile_obstack,
5247 ui_file_delete (buf);
5249 if (cu->language == language_cplus)
5252 = dwarf2_canonicalize_name (name, cu,
5253 &cu->objfile->objfile_obstack);
5264 /* Return the fully qualified name of DIE, based on its DW_AT_name.
5265 If scope qualifiers are appropriate they will be added. The result
5266 will be allocated on the objfile_obstack, or NULL if the DIE does
5267 not have a name. NAME may either be from a previous call to
5268 dwarf2_name or NULL.
5270 The output string will be canonicalized (if C++/Java). */
5273 dwarf2_full_name (char *name, struct die_info *die, struct dwarf2_cu *cu)
5275 return dwarf2_compute_name (name, die, cu, 0);
5278 /* Construct a physname for the given DIE in CU. NAME may either be
5279 from a previous call to dwarf2_name or NULL. The result will be
5280 allocated on the objfile_objstack or NULL if the DIE does not have a
5283 The output string will be canonicalized (if C++/Java). */
5286 dwarf2_physname (char *name, struct die_info *die, struct dwarf2_cu *cu)
5288 struct attribute *attr;
5289 const char *retval, *mangled = NULL, *canon = NULL;
5290 struct cleanup *back_to;
5293 /* In this case dwarf2_compute_name is just a shortcut not building anything
5295 if (!die_needs_namespace (die, cu))
5296 return dwarf2_compute_name (name, die, cu, 1);
5298 back_to = make_cleanup (null_cleanup, NULL);
5300 attr = dwarf2_attr (die, DW_AT_linkage_name, cu);
5302 attr = dwarf2_attr (die, DW_AT_MIPS_linkage_name, cu);
5304 /* DW_AT_linkage_name is missing in some cases - depend on what GDB
5306 if (attr && DW_STRING (attr))
5310 mangled = DW_STRING (attr);
5312 /* Use DMGL_RET_DROP for C++ template functions to suppress their return
5313 type. It is easier for GDB users to search for such functions as
5314 `name(params)' than `long name(params)'. In such case the minimal
5315 symbol names do not match the full symbol names but for template
5316 functions there is never a need to look up their definition from their
5317 declaration so the only disadvantage remains the minimal symbol
5318 variant `long name(params)' does not have the proper inferior type.
5321 demangled = cplus_demangle (mangled, (DMGL_PARAMS | DMGL_ANSI
5322 | (cu->language == language_java
5323 ? DMGL_JAVA | DMGL_RET_POSTFIX
5327 make_cleanup (xfree, demangled);
5337 if (canon == NULL || check_physname)
5339 const char *physname = dwarf2_compute_name (name, die, cu, 1);
5341 if (canon != NULL && strcmp (physname, canon) != 0)
5343 /* It may not mean a bug in GDB. The compiler could also
5344 compute DW_AT_linkage_name incorrectly. But in such case
5345 GDB would need to be bug-to-bug compatible. */
5347 complaint (&symfile_complaints,
5348 _("Computed physname <%s> does not match demangled <%s> "
5349 "(from linkage <%s>) - DIE at 0x%x [in module %s]"),
5350 physname, canon, mangled, die->offset, cu->objfile->name);
5352 /* Prefer DW_AT_linkage_name (in the CANON form) - when it
5353 is available here - over computed PHYSNAME. It is safer
5354 against both buggy GDB and buggy compilers. */
5368 retval = obsavestring (retval, strlen (retval),
5369 &cu->objfile->objfile_obstack);
5371 do_cleanups (back_to);
5375 /* Read the import statement specified by the given die and record it. */
5378 read_import_statement (struct die_info *die, struct dwarf2_cu *cu)
5380 struct attribute *import_attr;
5381 struct die_info *imported_die, *child_die;
5382 struct dwarf2_cu *imported_cu;
5383 const char *imported_name;
5384 const char *imported_name_prefix;
5385 const char *canonical_name;
5386 const char *import_alias;
5387 const char *imported_declaration = NULL;
5388 const char *import_prefix;
5389 VEC (const_char_ptr) *excludes = NULL;
5390 struct cleanup *cleanups;
5394 import_attr = dwarf2_attr (die, DW_AT_import, cu);
5395 if (import_attr == NULL)
5397 complaint (&symfile_complaints, _("Tag '%s' has no DW_AT_import"),
5398 dwarf_tag_name (die->tag));
5403 imported_die = follow_die_ref_or_sig (die, import_attr, &imported_cu);
5404 imported_name = dwarf2_name (imported_die, imported_cu);
5405 if (imported_name == NULL)
5407 /* GCC bug: https://bugzilla.redhat.com/show_bug.cgi?id=506524
5409 The import in the following code:
5423 <2><51>: Abbrev Number: 3 (DW_TAG_imported_declaration)
5424 <52> DW_AT_decl_file : 1
5425 <53> DW_AT_decl_line : 6
5426 <54> DW_AT_import : <0x75>
5427 <2><58>: Abbrev Number: 4 (DW_TAG_typedef)
5429 <5b> DW_AT_decl_file : 1
5430 <5c> DW_AT_decl_line : 2
5431 <5d> DW_AT_type : <0x6e>
5433 <1><75>: Abbrev Number: 7 (DW_TAG_base_type)
5434 <76> DW_AT_byte_size : 4
5435 <77> DW_AT_encoding : 5 (signed)
5437 imports the wrong die ( 0x75 instead of 0x58 ).
5438 This case will be ignored until the gcc bug is fixed. */
5442 /* Figure out the local name after import. */
5443 import_alias = dwarf2_name (die, cu);
5445 /* Figure out where the statement is being imported to. */
5446 import_prefix = determine_prefix (die, cu);
5448 /* Figure out what the scope of the imported die is and prepend it
5449 to the name of the imported die. */
5450 imported_name_prefix = determine_prefix (imported_die, imported_cu);
5452 if (imported_die->tag != DW_TAG_namespace
5453 && imported_die->tag != DW_TAG_module)
5455 imported_declaration = imported_name;
5456 canonical_name = imported_name_prefix;
5458 else if (strlen (imported_name_prefix) > 0)
5460 temp = alloca (strlen (imported_name_prefix)
5461 + 2 + strlen (imported_name) + 1);
5462 strcpy (temp, imported_name_prefix);
5463 strcat (temp, "::");
5464 strcat (temp, imported_name);
5465 canonical_name = temp;
5468 canonical_name = imported_name;
5470 cleanups = make_cleanup (VEC_cleanup (const_char_ptr), &excludes);
5472 if (die->tag == DW_TAG_imported_module && cu->language == language_fortran)
5473 for (child_die = die->child; child_die && child_die->tag;
5474 child_die = sibling_die (child_die))
5476 /* DWARF-4: A Fortran use statement with a “rename list” may be
5477 represented by an imported module entry with an import attribute
5478 referring to the module and owned entries corresponding to those
5479 entities that are renamed as part of being imported. */
5481 if (child_die->tag != DW_TAG_imported_declaration)
5483 complaint (&symfile_complaints,
5484 _("child DW_TAG_imported_declaration expected "
5485 "- DIE at 0x%x [in module %s]"),
5486 child_die->offset, cu->objfile->name);
5490 import_attr = dwarf2_attr (child_die, DW_AT_import, cu);
5491 if (import_attr == NULL)
5493 complaint (&symfile_complaints, _("Tag '%s' has no DW_AT_import"),
5494 dwarf_tag_name (child_die->tag));
5499 imported_die = follow_die_ref_or_sig (child_die, import_attr,
5501 imported_name = dwarf2_name (imported_die, imported_cu);
5502 if (imported_name == NULL)
5504 complaint (&symfile_complaints,
5505 _("child DW_TAG_imported_declaration has unknown "
5506 "imported name - DIE at 0x%x [in module %s]"),
5507 child_die->offset, cu->objfile->name);
5511 VEC_safe_push (const_char_ptr, excludes, imported_name);
5513 process_die (child_die, cu);
5516 cp_add_using_directive (import_prefix,
5519 imported_declaration,
5521 &cu->objfile->objfile_obstack);
5523 do_cleanups (cleanups);
5527 initialize_cu_func_list (struct dwarf2_cu *cu)
5529 cu->first_fn = cu->last_fn = cu->cached_fn = NULL;
5532 /* Cleanup function for read_file_scope. */
5535 free_cu_line_header (void *arg)
5537 struct dwarf2_cu *cu = arg;
5539 free_line_header (cu->line_header);
5540 cu->line_header = NULL;
5544 find_file_and_directory (struct die_info *die, struct dwarf2_cu *cu,
5545 char **name, char **comp_dir)
5547 struct attribute *attr;
5552 /* Find the filename. Do not use dwarf2_name here, since the filename
5553 is not a source language identifier. */
5554 attr = dwarf2_attr (die, DW_AT_name, cu);
5557 *name = DW_STRING (attr);
5560 attr = dwarf2_attr (die, DW_AT_comp_dir, cu);
5562 *comp_dir = DW_STRING (attr);
5563 else if (*name != NULL && IS_ABSOLUTE_PATH (*name))
5565 *comp_dir = ldirname (*name);
5566 if (*comp_dir != NULL)
5567 make_cleanup (xfree, *comp_dir);
5569 if (*comp_dir != NULL)
5571 /* Irix 6.2 native cc prepends <machine>.: to the compilation
5572 directory, get rid of it. */
5573 char *cp = strchr (*comp_dir, ':');
5575 if (cp && cp != *comp_dir && cp[-1] == '.' && cp[1] == '/')
5580 *name = "<unknown>";
5583 /* Handle DW_AT_stmt_list for a compilation unit. */
5586 handle_DW_AT_stmt_list (struct die_info *die, struct dwarf2_cu *cu,
5587 const char *comp_dir)
5589 struct attribute *attr;
5590 struct objfile *objfile = cu->objfile;
5591 bfd *abfd = objfile->obfd;
5593 /* Decode line number information if present. We do this before
5594 processing child DIEs, so that the line header table is available
5595 for DW_AT_decl_file. */
5596 attr = dwarf2_attr (die, DW_AT_stmt_list, cu);
5599 unsigned int line_offset = DW_UNSND (attr);
5600 struct line_header *line_header
5601 = dwarf_decode_line_header (line_offset, abfd, cu);
5605 cu->line_header = line_header;
5606 make_cleanup (free_cu_line_header, cu);
5607 dwarf_decode_lines (line_header, comp_dir, abfd, cu, NULL);
5612 /* Process DW_TAG_compile_unit. */
5615 read_file_scope (struct die_info *die, struct dwarf2_cu *cu)
5617 struct objfile *objfile = cu->objfile;
5618 struct cleanup *back_to = make_cleanup (null_cleanup, 0);
5619 CORE_ADDR lowpc = ((CORE_ADDR) -1);
5620 CORE_ADDR highpc = ((CORE_ADDR) 0);
5621 struct attribute *attr;
5623 char *comp_dir = NULL;
5624 struct die_info *child_die;
5625 bfd *abfd = objfile->obfd;
5628 baseaddr = ANOFFSET (objfile->section_offsets, SECT_OFF_TEXT (objfile));
5630 get_scope_pc_bounds (die, &lowpc, &highpc, cu);
5632 /* If we didn't find a lowpc, set it to highpc to avoid complaints
5633 from finish_block. */
5634 if (lowpc == ((CORE_ADDR) -1))
5639 find_file_and_directory (die, cu, &name, &comp_dir);
5641 attr = dwarf2_attr (die, DW_AT_language, cu);
5644 set_cu_language (DW_UNSND (attr), cu);
5647 attr = dwarf2_attr (die, DW_AT_producer, cu);
5649 cu->producer = DW_STRING (attr);
5651 /* The XLCL doesn't generate DW_LANG_OpenCL because this attribute is not
5652 standardised yet. As a workaround for the language detection we fall
5653 back to the DW_AT_producer string. */
5654 if (cu->producer && strstr (cu->producer, "IBM XL C for OpenCL") != NULL)
5655 cu->language = language_opencl;
5657 /* We assume that we're processing GCC output. */
5658 processing_gcc_compilation = 2;
5660 processing_has_namespace_info = 0;
5662 start_symtab (name, comp_dir, lowpc);
5663 record_debugformat ("DWARF 2");
5664 record_producer (cu->producer);
5666 initialize_cu_func_list (cu);
5668 handle_DW_AT_stmt_list (die, cu, comp_dir);
5670 /* Process all dies in compilation unit. */
5671 if (die->child != NULL)
5673 child_die = die->child;
5674 while (child_die && child_die->tag)
5676 process_die (child_die, cu);
5677 child_die = sibling_die (child_die);
5681 /* Decode macro information, if present. Dwarf 2 macro information
5682 refers to information in the line number info statement program
5683 header, so we can only read it if we've read the header
5685 attr = dwarf2_attr (die, DW_AT_GNU_macros, cu);
5686 if (attr && cu->line_header)
5688 if (dwarf2_attr (die, DW_AT_macro_info, cu))
5689 complaint (&symfile_complaints,
5690 _("CU refers to both DW_AT_GNU_macros and DW_AT_macro_info"));
5692 dwarf_decode_macros (cu->line_header, DW_UNSND (attr),
5694 &dwarf2_per_objfile->macro, 1);
5698 attr = dwarf2_attr (die, DW_AT_macro_info, cu);
5699 if (attr && cu->line_header)
5701 unsigned int macro_offset = DW_UNSND (attr);
5703 dwarf_decode_macros (cu->line_header, macro_offset,
5705 &dwarf2_per_objfile->macinfo, 0);
5708 do_cleanups (back_to);
5711 /* Process DW_TAG_type_unit.
5712 For TUs we want to skip the first top level sibling if it's not the
5713 actual type being defined by this TU. In this case the first top
5714 level sibling is there to provide context only. */
5717 read_type_unit_scope (struct die_info *die, struct dwarf2_cu *cu)
5719 struct objfile *objfile = cu->objfile;
5720 struct cleanup *back_to = make_cleanup (null_cleanup, 0);
5722 struct attribute *attr;
5724 char *comp_dir = NULL;
5725 struct die_info *child_die;
5726 bfd *abfd = objfile->obfd;
5728 /* start_symtab needs a low pc, but we don't really have one.
5729 Do what read_file_scope would do in the absence of such info. */
5730 lowpc = ANOFFSET (objfile->section_offsets, SECT_OFF_TEXT (objfile));
5732 /* Find the filename. Do not use dwarf2_name here, since the filename
5733 is not a source language identifier. */
5734 attr = dwarf2_attr (die, DW_AT_name, cu);
5736 name = DW_STRING (attr);
5738 attr = dwarf2_attr (die, DW_AT_comp_dir, cu);
5740 comp_dir = DW_STRING (attr);
5741 else if (name != NULL && IS_ABSOLUTE_PATH (name))
5743 comp_dir = ldirname (name);
5744 if (comp_dir != NULL)
5745 make_cleanup (xfree, comp_dir);
5751 attr = dwarf2_attr (die, DW_AT_language, cu);
5753 set_cu_language (DW_UNSND (attr), cu);
5755 /* This isn't technically needed today. It is done for symmetry
5756 with read_file_scope. */
5757 attr = dwarf2_attr (die, DW_AT_producer, cu);
5759 cu->producer = DW_STRING (attr);
5761 /* We assume that we're processing GCC output. */
5762 processing_gcc_compilation = 2;
5764 processing_has_namespace_info = 0;
5766 start_symtab (name, comp_dir, lowpc);
5767 record_debugformat ("DWARF 2");
5768 record_producer (cu->producer);
5770 handle_DW_AT_stmt_list (die, cu, comp_dir);
5772 /* Process the dies in the type unit. */
5773 if (die->child == NULL)
5775 dump_die_for_error (die);
5776 error (_("Dwarf Error: Missing children for type unit [in module %s]"),
5777 bfd_get_filename (abfd));
5780 child_die = die->child;
5782 while (child_die && child_die->tag)
5784 process_die (child_die, cu);
5786 child_die = sibling_die (child_die);
5789 do_cleanups (back_to);
5793 add_to_cu_func_list (const char *name, CORE_ADDR lowpc, CORE_ADDR highpc,
5794 struct dwarf2_cu *cu)
5796 struct function_range *thisfn;
5798 thisfn = (struct function_range *)
5799 obstack_alloc (&cu->comp_unit_obstack, sizeof (struct function_range));
5800 thisfn->name = name;
5801 thisfn->lowpc = lowpc;
5802 thisfn->highpc = highpc;
5803 thisfn->seen_line = 0;
5804 thisfn->next = NULL;
5806 if (cu->last_fn == NULL)
5807 cu->first_fn = thisfn;
5809 cu->last_fn->next = thisfn;
5811 cu->last_fn = thisfn;
5814 /* qsort helper for inherit_abstract_dies. */
5817 unsigned_int_compar (const void *ap, const void *bp)
5819 unsigned int a = *(unsigned int *) ap;
5820 unsigned int b = *(unsigned int *) bp;
5822 return (a > b) - (b > a);
5825 /* DW_AT_abstract_origin inherits whole DIEs (not just their attributes).
5826 Inherit only the children of the DW_AT_abstract_origin DIE not being
5827 already referenced by DW_AT_abstract_origin from the children of the
5831 inherit_abstract_dies (struct die_info *die, struct dwarf2_cu *cu)
5833 struct die_info *child_die;
5834 unsigned die_children_count;
5835 /* CU offsets which were referenced by children of the current DIE. */
5837 unsigned *offsets_end, *offsetp;
5838 /* Parent of DIE - referenced by DW_AT_abstract_origin. */
5839 struct die_info *origin_die;
5840 /* Iterator of the ORIGIN_DIE children. */
5841 struct die_info *origin_child_die;
5842 struct cleanup *cleanups;
5843 struct attribute *attr;
5844 struct dwarf2_cu *origin_cu;
5845 struct pending **origin_previous_list_in_scope;
5847 attr = dwarf2_attr (die, DW_AT_abstract_origin, cu);
5851 /* Note that following die references may follow to a die in a
5855 origin_die = follow_die_ref (die, attr, &origin_cu);
5857 /* We're inheriting ORIGIN's children into the scope we'd put DIE's
5859 origin_previous_list_in_scope = origin_cu->list_in_scope;
5860 origin_cu->list_in_scope = cu->list_in_scope;
5862 if (die->tag != origin_die->tag
5863 && !(die->tag == DW_TAG_inlined_subroutine
5864 && origin_die->tag == DW_TAG_subprogram))
5865 complaint (&symfile_complaints,
5866 _("DIE 0x%x and its abstract origin 0x%x have different tags"),
5867 die->offset, origin_die->offset);
5869 child_die = die->child;
5870 die_children_count = 0;
5871 while (child_die && child_die->tag)
5873 child_die = sibling_die (child_die);
5874 die_children_count++;
5876 offsets = xmalloc (sizeof (*offsets) * die_children_count);
5877 cleanups = make_cleanup (xfree, offsets);
5879 offsets_end = offsets;
5880 child_die = die->child;
5881 while (child_die && child_die->tag)
5883 /* For each CHILD_DIE, find the corresponding child of
5884 ORIGIN_DIE. If there is more than one layer of
5885 DW_AT_abstract_origin, follow them all; there shouldn't be,
5886 but GCC versions at least through 4.4 generate this (GCC PR
5888 struct die_info *child_origin_die = child_die;
5889 struct dwarf2_cu *child_origin_cu = cu;
5893 attr = dwarf2_attr (child_origin_die, DW_AT_abstract_origin,
5897 child_origin_die = follow_die_ref (child_origin_die, attr,
5901 /* According to DWARF3 3.3.8.2 #3 new entries without their abstract
5902 counterpart may exist. */
5903 if (child_origin_die != child_die)
5905 if (child_die->tag != child_origin_die->tag
5906 && !(child_die->tag == DW_TAG_inlined_subroutine
5907 && child_origin_die->tag == DW_TAG_subprogram))
5908 complaint (&symfile_complaints,
5909 _("Child DIE 0x%x and its abstract origin 0x%x have "
5910 "different tags"), child_die->offset,
5911 child_origin_die->offset);
5912 if (child_origin_die->parent != origin_die)
5913 complaint (&symfile_complaints,
5914 _("Child DIE 0x%x and its abstract origin 0x%x have "
5915 "different parents"), child_die->offset,
5916 child_origin_die->offset);
5918 *offsets_end++ = child_origin_die->offset;
5920 child_die = sibling_die (child_die);
5922 qsort (offsets, offsets_end - offsets, sizeof (*offsets),
5923 unsigned_int_compar);
5924 for (offsetp = offsets + 1; offsetp < offsets_end; offsetp++)
5925 if (offsetp[-1] == *offsetp)
5926 complaint (&symfile_complaints,
5927 _("Multiple children of DIE 0x%x refer "
5928 "to DIE 0x%x as their abstract origin"),
5929 die->offset, *offsetp);
5932 origin_child_die = origin_die->child;
5933 while (origin_child_die && origin_child_die->tag)
5935 /* Is ORIGIN_CHILD_DIE referenced by any of the DIE children? */
5936 while (offsetp < offsets_end && *offsetp < origin_child_die->offset)
5938 if (offsetp >= offsets_end || *offsetp > origin_child_die->offset)
5940 /* Found that ORIGIN_CHILD_DIE is really not referenced. */
5941 process_die (origin_child_die, origin_cu);
5943 origin_child_die = sibling_die (origin_child_die);
5945 origin_cu->list_in_scope = origin_previous_list_in_scope;
5947 do_cleanups (cleanups);
5951 read_func_scope (struct die_info *die, struct dwarf2_cu *cu)
5953 struct objfile *objfile = cu->objfile;
5954 struct context_stack *new;
5957 struct die_info *child_die;
5958 struct attribute *attr, *call_line, *call_file;
5961 struct block *block;
5962 int inlined_func = (die->tag == DW_TAG_inlined_subroutine);
5963 VEC (symbolp) *template_args = NULL;
5964 struct template_symbol *templ_func = NULL;
5968 /* If we do not have call site information, we can't show the
5969 caller of this inlined function. That's too confusing, so
5970 only use the scope for local variables. */
5971 call_line = dwarf2_attr (die, DW_AT_call_line, cu);
5972 call_file = dwarf2_attr (die, DW_AT_call_file, cu);
5973 if (call_line == NULL || call_file == NULL)
5975 read_lexical_block_scope (die, cu);
5980 baseaddr = ANOFFSET (objfile->section_offsets, SECT_OFF_TEXT (objfile));
5982 name = dwarf2_name (die, cu);
5984 /* Ignore functions with missing or empty names. These are actually
5985 illegal according to the DWARF standard. */
5988 complaint (&symfile_complaints,
5989 _("missing name for subprogram DIE at %d"), die->offset);
5993 /* Ignore functions with missing or invalid low and high pc attributes. */
5994 if (!dwarf2_get_pc_bounds (die, &lowpc, &highpc, cu, NULL))
5996 attr = dwarf2_attr (die, DW_AT_external, cu);
5997 if (!attr || !DW_UNSND (attr))
5998 complaint (&symfile_complaints,
5999 _("cannot get low and high bounds "
6000 "for subprogram DIE at %d"),
6008 /* Record the function range for dwarf_decode_lines. */
6009 add_to_cu_func_list (name, lowpc, highpc, cu);
6011 /* If we have any template arguments, then we must allocate a
6012 different sort of symbol. */
6013 for (child_die = die->child; child_die; child_die = sibling_die (child_die))
6015 if (child_die->tag == DW_TAG_template_type_param
6016 || child_die->tag == DW_TAG_template_value_param)
6018 templ_func = OBSTACK_ZALLOC (&objfile->objfile_obstack,
6019 struct template_symbol);
6020 templ_func->base.is_cplus_template_function = 1;
6025 new = push_context (0, lowpc);
6026 new->name = new_symbol_full (die, read_type_die (die, cu), cu,
6027 (struct symbol *) templ_func);
6029 /* If there is a location expression for DW_AT_frame_base, record
6031 attr = dwarf2_attr (die, DW_AT_frame_base, cu);
6033 /* FIXME: cagney/2004-01-26: The DW_AT_frame_base's location
6034 expression is being recorded directly in the function's symbol
6035 and not in a separate frame-base object. I guess this hack is
6036 to avoid adding some sort of frame-base adjunct/annex to the
6037 function's symbol :-(. The problem with doing this is that it
6038 results in a function symbol with a location expression that
6039 has nothing to do with the location of the function, ouch! The
6040 relationship should be: a function's symbol has-a frame base; a
6041 frame-base has-a location expression. */
6042 dwarf2_symbol_mark_computed (attr, new->name, cu);
6044 cu->list_in_scope = &local_symbols;
6046 if (die->child != NULL)
6048 child_die = die->child;
6049 while (child_die && child_die->tag)
6051 if (child_die->tag == DW_TAG_template_type_param
6052 || child_die->tag == DW_TAG_template_value_param)
6054 struct symbol *arg = new_symbol (child_die, NULL, cu);
6057 VEC_safe_push (symbolp, template_args, arg);
6060 process_die (child_die, cu);
6061 child_die = sibling_die (child_die);
6065 inherit_abstract_dies (die, cu);
6067 /* If we have a DW_AT_specification, we might need to import using
6068 directives from the context of the specification DIE. See the
6069 comment in determine_prefix. */
6070 if (cu->language == language_cplus
6071 && dwarf2_attr (die, DW_AT_specification, cu))
6073 struct dwarf2_cu *spec_cu = cu;
6074 struct die_info *spec_die = die_specification (die, &spec_cu);
6078 child_die = spec_die->child;
6079 while (child_die && child_die->tag)
6081 if (child_die->tag == DW_TAG_imported_module)
6082 process_die (child_die, spec_cu);
6083 child_die = sibling_die (child_die);
6086 /* In some cases, GCC generates specification DIEs that
6087 themselves contain DW_AT_specification attributes. */
6088 spec_die = die_specification (spec_die, &spec_cu);
6092 new = pop_context ();
6093 /* Make a block for the local symbols within. */
6094 block = finish_block (new->name, &local_symbols, new->old_blocks,
6095 lowpc, highpc, objfile);
6097 /* For C++, set the block's scope. */
6098 if (cu->language == language_cplus || cu->language == language_fortran)
6099 cp_set_block_scope (new->name, block, &objfile->objfile_obstack,
6100 determine_prefix (die, cu),
6101 processing_has_namespace_info);
6103 /* If we have address ranges, record them. */
6104 dwarf2_record_block_ranges (die, block, baseaddr, cu);
6106 /* Attach template arguments to function. */
6107 if (! VEC_empty (symbolp, template_args))
6109 gdb_assert (templ_func != NULL);
6111 templ_func->n_template_arguments = VEC_length (symbolp, template_args);
6112 templ_func->template_arguments
6113 = obstack_alloc (&objfile->objfile_obstack,
6114 (templ_func->n_template_arguments
6115 * sizeof (struct symbol *)));
6116 memcpy (templ_func->template_arguments,
6117 VEC_address (symbolp, template_args),
6118 (templ_func->n_template_arguments * sizeof (struct symbol *)));
6119 VEC_free (symbolp, template_args);
6122 /* In C++, we can have functions nested inside functions (e.g., when
6123 a function declares a class that has methods). This means that
6124 when we finish processing a function scope, we may need to go
6125 back to building a containing block's symbol lists. */
6126 local_symbols = new->locals;
6127 param_symbols = new->params;
6128 using_directives = new->using_directives;
6130 /* If we've finished processing a top-level function, subsequent
6131 symbols go in the file symbol list. */
6132 if (outermost_context_p ())
6133 cu->list_in_scope = &file_symbols;
6136 /* Process all the DIES contained within a lexical block scope. Start
6137 a new scope, process the dies, and then close the scope. */
6140 read_lexical_block_scope (struct die_info *die, struct dwarf2_cu *cu)
6142 struct objfile *objfile = cu->objfile;
6143 struct context_stack *new;
6144 CORE_ADDR lowpc, highpc;
6145 struct die_info *child_die;
6148 baseaddr = ANOFFSET (objfile->section_offsets, SECT_OFF_TEXT (objfile));
6150 /* Ignore blocks with missing or invalid low and high pc attributes. */
6151 /* ??? Perhaps consider discontiguous blocks defined by DW_AT_ranges
6152 as multiple lexical blocks? Handling children in a sane way would
6153 be nasty. Might be easier to properly extend generic blocks to
6155 if (!dwarf2_get_pc_bounds (die, &lowpc, &highpc, cu, NULL))
6160 push_context (0, lowpc);
6161 if (die->child != NULL)
6163 child_die = die->child;
6164 while (child_die && child_die->tag)
6166 process_die (child_die, cu);
6167 child_die = sibling_die (child_die);
6170 new = pop_context ();
6172 if (local_symbols != NULL || using_directives != NULL)
6175 = finish_block (0, &local_symbols, new->old_blocks, new->start_addr,
6178 /* Note that recording ranges after traversing children, as we
6179 do here, means that recording a parent's ranges entails
6180 walking across all its children's ranges as they appear in
6181 the address map, which is quadratic behavior.
6183 It would be nicer to record the parent's ranges before
6184 traversing its children, simply overriding whatever you find
6185 there. But since we don't even decide whether to create a
6186 block until after we've traversed its children, that's hard
6188 dwarf2_record_block_ranges (die, block, baseaddr, cu);
6190 local_symbols = new->locals;
6191 using_directives = new->using_directives;
6194 /* Read in DW_TAG_GNU_call_site and insert it to CU->call_site_htab. */
6197 read_call_site_scope (struct die_info *die, struct dwarf2_cu *cu)
6199 struct objfile *objfile = cu->objfile;
6200 struct gdbarch *gdbarch = get_objfile_arch (objfile);
6201 CORE_ADDR pc, baseaddr;
6202 struct attribute *attr;
6203 struct call_site *call_site, call_site_local;
6206 struct die_info *child_die;
6208 baseaddr = ANOFFSET (objfile->section_offsets, SECT_OFF_TEXT (objfile));
6210 attr = dwarf2_attr (die, DW_AT_low_pc, cu);
6213 complaint (&symfile_complaints,
6214 _("missing DW_AT_low_pc for DW_TAG_GNU_call_site "
6215 "DIE 0x%x [in module %s]"),
6216 die->offset, cu->objfile->name);
6219 pc = DW_ADDR (attr) + baseaddr;
6221 if (cu->call_site_htab == NULL)
6222 cu->call_site_htab = htab_create_alloc_ex (16, core_addr_hash, core_addr_eq,
6223 NULL, &objfile->objfile_obstack,
6224 hashtab_obstack_allocate, NULL);
6225 call_site_local.pc = pc;
6226 slot = htab_find_slot (cu->call_site_htab, &call_site_local, INSERT);
6229 complaint (&symfile_complaints,
6230 _("Duplicate PC %s for DW_TAG_GNU_call_site "
6231 "DIE 0x%x [in module %s]"),
6232 paddress (gdbarch, pc), die->offset, cu->objfile->name);
6236 /* Count parameters at the caller. */
6239 for (child_die = die->child; child_die && child_die->tag;
6240 child_die = sibling_die (child_die))
6242 if (child_die->tag != DW_TAG_GNU_call_site_parameter)
6244 complaint (&symfile_complaints,
6245 _("Tag %d is not DW_TAG_GNU_call_site_parameter in "
6246 "DW_TAG_GNU_call_site child DIE 0x%x [in module %s]"),
6247 child_die->tag, child_die->offset, cu->objfile->name);
6254 call_site = obstack_alloc (&objfile->objfile_obstack,
6255 (sizeof (*call_site)
6256 + (sizeof (*call_site->parameter)
6259 memset (call_site, 0, sizeof (*call_site) - sizeof (*call_site->parameter));
6262 if (dwarf2_flag_true_p (die, DW_AT_GNU_tail_call, cu))
6264 struct die_info *func_die;
6266 /* Skip also over DW_TAG_inlined_subroutine. */
6267 for (func_die = die->parent;
6268 func_die && func_die->tag != DW_TAG_subprogram
6269 && func_die->tag != DW_TAG_subroutine_type;
6270 func_die = func_die->parent);
6272 /* DW_AT_GNU_all_call_sites is a superset
6273 of DW_AT_GNU_all_tail_call_sites. */
6275 && !dwarf2_flag_true_p (func_die, DW_AT_GNU_all_call_sites, cu)
6276 && !dwarf2_flag_true_p (func_die, DW_AT_GNU_all_tail_call_sites, cu))
6278 /* TYPE_TAIL_CALL_LIST is not interesting in functions where it is
6279 not complete. But keep CALL_SITE for look ups via call_site_htab,
6280 both the initial caller containing the real return address PC and
6281 the final callee containing the current PC of a chain of tail
6282 calls do not need to have the tail call list complete. But any
6283 function candidate for a virtual tail call frame searched via
6284 TYPE_TAIL_CALL_LIST must have the tail call list complete to be
6285 determined unambiguously. */
6289 struct type *func_type = NULL;
6292 func_type = get_die_type (func_die, cu);
6293 if (func_type != NULL)
6295 gdb_assert (TYPE_CODE (func_type) == TYPE_CODE_FUNC);
6297 /* Enlist this call site to the function. */
6298 call_site->tail_call_next = TYPE_TAIL_CALL_LIST (func_type);
6299 TYPE_TAIL_CALL_LIST (func_type) = call_site;
6302 complaint (&symfile_complaints,
6303 _("Cannot find function owning DW_TAG_GNU_call_site "
6304 "DIE 0x%x [in module %s]"),
6305 die->offset, cu->objfile->name);
6309 attr = dwarf2_attr (die, DW_AT_GNU_call_site_target, cu);
6311 attr = dwarf2_attr (die, DW_AT_abstract_origin, cu);
6312 SET_FIELD_DWARF_BLOCK (call_site->target, NULL);
6313 if (!attr || (attr_form_is_block (attr) && DW_BLOCK (attr)->size == 0))
6314 /* Keep NULL DWARF_BLOCK. */;
6315 else if (attr_form_is_block (attr))
6317 struct dwarf2_locexpr_baton *dlbaton;
6319 dlbaton = obstack_alloc (&objfile->objfile_obstack, sizeof (*dlbaton));
6320 dlbaton->data = DW_BLOCK (attr)->data;
6321 dlbaton->size = DW_BLOCK (attr)->size;
6322 dlbaton->per_cu = cu->per_cu;
6324 SET_FIELD_DWARF_BLOCK (call_site->target, dlbaton);
6326 else if (is_ref_attr (attr))
6328 struct objfile *objfile = cu->objfile;
6329 struct dwarf2_cu *target_cu = cu;
6330 struct die_info *target_die;
6332 target_die = follow_die_ref_or_sig (die, attr, &target_cu);
6333 gdb_assert (target_cu->objfile == objfile);
6334 if (die_is_declaration (target_die, target_cu))
6336 const char *target_physname;
6338 target_physname = dwarf2_physname (NULL, target_die, target_cu);
6339 if (target_physname == NULL)
6340 complaint (&symfile_complaints,
6341 _("DW_AT_GNU_call_site_target target DIE has invalid "
6342 "physname, for referencing DIE 0x%x [in module %s]"),
6343 die->offset, cu->objfile->name);
6345 SET_FIELD_PHYSNAME (call_site->target, (char *) target_physname);
6351 /* DW_AT_entry_pc should be preferred. */
6352 if (!dwarf2_get_pc_bounds (target_die, &lowpc, NULL, target_cu, NULL))
6353 complaint (&symfile_complaints,
6354 _("DW_AT_GNU_call_site_target target DIE has invalid "
6355 "low pc, for referencing DIE 0x%x [in module %s]"),
6356 die->offset, cu->objfile->name);
6358 SET_FIELD_PHYSADDR (call_site->target, lowpc + baseaddr);
6362 complaint (&symfile_complaints,
6363 _("DW_TAG_GNU_call_site DW_AT_GNU_call_site_target is neither "
6364 "block nor reference, for DIE 0x%x [in module %s]"),
6365 die->offset, cu->objfile->name);
6367 call_site->per_cu = cu->per_cu;
6369 for (child_die = die->child;
6370 child_die && child_die->tag;
6371 child_die = sibling_die (child_die))
6373 struct dwarf2_locexpr_baton *dlbaton;
6374 struct call_site_parameter *parameter;
6376 if (child_die->tag != DW_TAG_GNU_call_site_parameter)
6378 /* Already printed the complaint above. */
6382 gdb_assert (call_site->parameter_count < nparams);
6383 parameter = &call_site->parameter[call_site->parameter_count];
6385 /* DW_AT_location specifies the register number. Value of the data
6386 assumed for the register is contained in DW_AT_GNU_call_site_value. */
6388 attr = dwarf2_attr (child_die, DW_AT_location, cu);
6389 if (!attr || !attr_form_is_block (attr))
6391 complaint (&symfile_complaints,
6392 _("No DW_FORM_block* DW_AT_location for "
6393 "DW_TAG_GNU_call_site child DIE 0x%x [in module %s]"),
6394 child_die->offset, cu->objfile->name);
6397 parameter->dwarf_reg = dwarf_block_to_dwarf_reg (DW_BLOCK (attr)->data,
6398 &DW_BLOCK (attr)->data[DW_BLOCK (attr)->size]);
6399 if (parameter->dwarf_reg == -1
6400 && !dwarf_block_to_sp_offset (gdbarch, DW_BLOCK (attr)->data,
6401 &DW_BLOCK (attr)->data[DW_BLOCK (attr)->size],
6402 ¶meter->fb_offset))
6404 complaint (&symfile_complaints,
6405 _("Only single DW_OP_reg or DW_OP_fbreg is supported "
6406 "for DW_FORM_block* DW_AT_location for "
6407 "DW_TAG_GNU_call_site child DIE 0x%x [in module %s]"),
6408 child_die->offset, cu->objfile->name);
6412 attr = dwarf2_attr (child_die, DW_AT_GNU_call_site_value, cu);
6413 if (!attr_form_is_block (attr))
6415 complaint (&symfile_complaints,
6416 _("No DW_FORM_block* DW_AT_GNU_call_site_value for "
6417 "DW_TAG_GNU_call_site child DIE 0x%x [in module %s]"),
6418 child_die->offset, cu->objfile->name);
6421 parameter->value = DW_BLOCK (attr)->data;
6422 parameter->value_size = DW_BLOCK (attr)->size;
6424 /* Parameters are not pre-cleared by memset above. */
6425 parameter->data_value = NULL;
6426 parameter->data_value_size = 0;
6427 call_site->parameter_count++;
6429 attr = dwarf2_attr (child_die, DW_AT_GNU_call_site_data_value, cu);
6432 if (!attr_form_is_block (attr))
6433 complaint (&symfile_complaints,
6434 _("No DW_FORM_block* DW_AT_GNU_call_site_data_value for "
6435 "DW_TAG_GNU_call_site child DIE 0x%x [in module %s]"),
6436 child_die->offset, cu->objfile->name);
6439 parameter->data_value = DW_BLOCK (attr)->data;
6440 parameter->data_value_size = DW_BLOCK (attr)->size;
6446 /* Get low and high pc attributes from DW_AT_ranges attribute value OFFSET.
6447 Return 1 if the attributes are present and valid, otherwise, return 0.
6448 If RANGES_PST is not NULL we should setup `objfile->psymtabs_addrmap'. */
6451 dwarf2_ranges_read (unsigned offset, CORE_ADDR *low_return,
6452 CORE_ADDR *high_return, struct dwarf2_cu *cu,
6453 struct partial_symtab *ranges_pst)
6455 struct objfile *objfile = cu->objfile;
6456 struct comp_unit_head *cu_header = &cu->header;
6457 bfd *obfd = objfile->obfd;
6458 unsigned int addr_size = cu_header->addr_size;
6459 CORE_ADDR mask = ~(~(CORE_ADDR)1 << (addr_size * 8 - 1));
6460 /* Base address selection entry. */
6471 found_base = cu->base_known;
6472 base = cu->base_address;
6474 dwarf2_read_section (objfile, &dwarf2_per_objfile->ranges);
6475 if (offset >= dwarf2_per_objfile->ranges.size)
6477 complaint (&symfile_complaints,
6478 _("Offset %d out of bounds for DW_AT_ranges attribute"),
6482 buffer = dwarf2_per_objfile->ranges.buffer + offset;
6484 /* Read in the largest possible address. */
6485 marker = read_address (obfd, buffer, cu, &dummy);
6486 if ((marker & mask) == mask)
6488 /* If we found the largest possible address, then
6489 read the base address. */
6490 base = read_address (obfd, buffer + addr_size, cu, &dummy);
6491 buffer += 2 * addr_size;
6492 offset += 2 * addr_size;
6498 baseaddr = ANOFFSET (objfile->section_offsets, SECT_OFF_TEXT (objfile));
6502 CORE_ADDR range_beginning, range_end;
6504 range_beginning = read_address (obfd, buffer, cu, &dummy);
6505 buffer += addr_size;
6506 range_end = read_address (obfd, buffer, cu, &dummy);
6507 buffer += addr_size;
6508 offset += 2 * addr_size;
6510 /* An end of list marker is a pair of zero addresses. */
6511 if (range_beginning == 0 && range_end == 0)
6512 /* Found the end of list entry. */
6515 /* Each base address selection entry is a pair of 2 values.
6516 The first is the largest possible address, the second is
6517 the base address. Check for a base address here. */
6518 if ((range_beginning & mask) == mask)
6520 /* If we found the largest possible address, then
6521 read the base address. */
6522 base = read_address (obfd, buffer + addr_size, cu, &dummy);
6529 /* We have no valid base address for the ranges
6531 complaint (&symfile_complaints,
6532 _("Invalid .debug_ranges data (no base address)"));
6536 if (range_beginning > range_end)
6538 /* Inverted range entries are invalid. */
6539 complaint (&symfile_complaints,
6540 _("Invalid .debug_ranges data (inverted range)"));
6544 /* Empty range entries have no effect. */
6545 if (range_beginning == range_end)
6548 range_beginning += base;
6551 if (ranges_pst != NULL)
6552 addrmap_set_empty (objfile->psymtabs_addrmap,
6553 range_beginning + baseaddr,
6554 range_end - 1 + baseaddr,
6557 /* FIXME: This is recording everything as a low-high
6558 segment of consecutive addresses. We should have a
6559 data structure for discontiguous block ranges
6563 low = range_beginning;
6569 if (range_beginning < low)
6570 low = range_beginning;
6571 if (range_end > high)
6577 /* If the first entry is an end-of-list marker, the range
6578 describes an empty scope, i.e. no instructions. */
6584 *high_return = high;
6588 /* Get low and high pc attributes from a die. Return 1 if the attributes
6589 are present and valid, otherwise, return 0. Return -1 if the range is
6590 discontinuous, i.e. derived from DW_AT_ranges information. */
6592 dwarf2_get_pc_bounds (struct die_info *die, CORE_ADDR *lowpc,
6593 CORE_ADDR *highpc, struct dwarf2_cu *cu,
6594 struct partial_symtab *pst)
6596 struct attribute *attr;
6601 attr = dwarf2_attr (die, DW_AT_high_pc, cu);
6604 high = DW_ADDR (attr);
6605 attr = dwarf2_attr (die, DW_AT_low_pc, cu);
6607 low = DW_ADDR (attr);
6609 /* Found high w/o low attribute. */
6612 /* Found consecutive range of addresses. */
6617 attr = dwarf2_attr (die, DW_AT_ranges, cu);
6620 /* Value of the DW_AT_ranges attribute is the offset in the
6621 .debug_ranges section. */
6622 if (!dwarf2_ranges_read (DW_UNSND (attr), &low, &high, cu, pst))
6624 /* Found discontinuous range of addresses. */
6629 /* read_partial_die has also the strict LOW < HIGH requirement. */
6633 /* When using the GNU linker, .gnu.linkonce. sections are used to
6634 eliminate duplicate copies of functions and vtables and such.
6635 The linker will arbitrarily choose one and discard the others.
6636 The AT_*_pc values for such functions refer to local labels in
6637 these sections. If the section from that file was discarded, the
6638 labels are not in the output, so the relocs get a value of 0.
6639 If this is a discarded function, mark the pc bounds as invalid,
6640 so that GDB will ignore it. */
6641 if (low == 0 && !dwarf2_per_objfile->has_section_at_zero)
6650 /* Assuming that DIE represents a subprogram DIE or a lexical block, get
6651 its low and high PC addresses. Do nothing if these addresses could not
6652 be determined. Otherwise, set LOWPC to the low address if it is smaller,
6653 and HIGHPC to the high address if greater than HIGHPC. */
6656 dwarf2_get_subprogram_pc_bounds (struct die_info *die,
6657 CORE_ADDR *lowpc, CORE_ADDR *highpc,
6658 struct dwarf2_cu *cu)
6660 CORE_ADDR low, high;
6661 struct die_info *child = die->child;
6663 if (dwarf2_get_pc_bounds (die, &low, &high, cu, NULL))
6665 *lowpc = min (*lowpc, low);
6666 *highpc = max (*highpc, high);
6669 /* If the language does not allow nested subprograms (either inside
6670 subprograms or lexical blocks), we're done. */
6671 if (cu->language != language_ada)
6674 /* Check all the children of the given DIE. If it contains nested
6675 subprograms, then check their pc bounds. Likewise, we need to
6676 check lexical blocks as well, as they may also contain subprogram
6678 while (child && child->tag)
6680 if (child->tag == DW_TAG_subprogram
6681 || child->tag == DW_TAG_lexical_block)
6682 dwarf2_get_subprogram_pc_bounds (child, lowpc, highpc, cu);
6683 child = sibling_die (child);
6687 /* Get the low and high pc's represented by the scope DIE, and store
6688 them in *LOWPC and *HIGHPC. If the correct values can't be
6689 determined, set *LOWPC to -1 and *HIGHPC to 0. */
6692 get_scope_pc_bounds (struct die_info *die,
6693 CORE_ADDR *lowpc, CORE_ADDR *highpc,
6694 struct dwarf2_cu *cu)
6696 CORE_ADDR best_low = (CORE_ADDR) -1;
6697 CORE_ADDR best_high = (CORE_ADDR) 0;
6698 CORE_ADDR current_low, current_high;
6700 if (dwarf2_get_pc_bounds (die, ¤t_low, ¤t_high, cu, NULL))
6702 best_low = current_low;
6703 best_high = current_high;
6707 struct die_info *child = die->child;
6709 while (child && child->tag)
6711 switch (child->tag) {
6712 case DW_TAG_subprogram:
6713 dwarf2_get_subprogram_pc_bounds (child, &best_low, &best_high, cu);
6715 case DW_TAG_namespace:
6717 /* FIXME: carlton/2004-01-16: Should we do this for
6718 DW_TAG_class_type/DW_TAG_structure_type, too? I think
6719 that current GCC's always emit the DIEs corresponding
6720 to definitions of methods of classes as children of a
6721 DW_TAG_compile_unit or DW_TAG_namespace (as opposed to
6722 the DIEs giving the declarations, which could be
6723 anywhere). But I don't see any reason why the
6724 standards says that they have to be there. */
6725 get_scope_pc_bounds (child, ¤t_low, ¤t_high, cu);
6727 if (current_low != ((CORE_ADDR) -1))
6729 best_low = min (best_low, current_low);
6730 best_high = max (best_high, current_high);
6738 child = sibling_die (child);
6743 *highpc = best_high;
6746 /* Record the address ranges for BLOCK, offset by BASEADDR, as given
6749 dwarf2_record_block_ranges (struct die_info *die, struct block *block,
6750 CORE_ADDR baseaddr, struct dwarf2_cu *cu)
6752 struct attribute *attr;
6754 attr = dwarf2_attr (die, DW_AT_high_pc, cu);
6757 CORE_ADDR high = DW_ADDR (attr);
6759 attr = dwarf2_attr (die, DW_AT_low_pc, cu);
6762 CORE_ADDR low = DW_ADDR (attr);
6764 record_block_range (block, baseaddr + low, baseaddr + high - 1);
6768 attr = dwarf2_attr (die, DW_AT_ranges, cu);
6771 bfd *obfd = cu->objfile->obfd;
6773 /* The value of the DW_AT_ranges attribute is the offset of the
6774 address range list in the .debug_ranges section. */
6775 unsigned long offset = DW_UNSND (attr);
6776 gdb_byte *buffer = dwarf2_per_objfile->ranges.buffer + offset;
6778 /* For some target architectures, but not others, the
6779 read_address function sign-extends the addresses it returns.
6780 To recognize base address selection entries, we need a
6782 unsigned int addr_size = cu->header.addr_size;
6783 CORE_ADDR base_select_mask = ~(~(CORE_ADDR)1 << (addr_size * 8 - 1));
6785 /* The base address, to which the next pair is relative. Note
6786 that this 'base' is a DWARF concept: most entries in a range
6787 list are relative, to reduce the number of relocs against the
6788 debugging information. This is separate from this function's
6789 'baseaddr' argument, which GDB uses to relocate debugging
6790 information from a shared library based on the address at
6791 which the library was loaded. */
6792 CORE_ADDR base = cu->base_address;
6793 int base_known = cu->base_known;
6795 gdb_assert (dwarf2_per_objfile->ranges.readin);
6796 if (offset >= dwarf2_per_objfile->ranges.size)
6798 complaint (&symfile_complaints,
6799 _("Offset %lu out of bounds for DW_AT_ranges attribute"),
6806 unsigned int bytes_read;
6807 CORE_ADDR start, end;
6809 start = read_address (obfd, buffer, cu, &bytes_read);
6810 buffer += bytes_read;
6811 end = read_address (obfd, buffer, cu, &bytes_read);
6812 buffer += bytes_read;
6814 /* Did we find the end of the range list? */
6815 if (start == 0 && end == 0)
6818 /* Did we find a base address selection entry? */
6819 else if ((start & base_select_mask) == base_select_mask)
6825 /* We found an ordinary address range. */
6830 complaint (&symfile_complaints,
6831 _("Invalid .debug_ranges data "
6832 "(no base address)"));
6838 /* Inverted range entries are invalid. */
6839 complaint (&symfile_complaints,
6840 _("Invalid .debug_ranges data "
6841 "(inverted range)"));
6845 /* Empty range entries have no effect. */
6849 record_block_range (block,
6850 baseaddr + base + start,
6851 baseaddr + base + end - 1);
6857 /* Check for GCC PR debug/45124 fix which is not present in any G++ version up
6858 to 4.5.any while it is present already in G++ 4.6.0 - the PR has been fixed
6859 during 4.6.0 experimental. */
6862 producer_is_gxx_lt_4_6 (struct dwarf2_cu *cu)
6865 int major, minor, release;
6867 if (cu->producer == NULL)
6869 /* For unknown compilers expect their behavior is DWARF version
6872 GCC started to support .debug_types sections by -gdwarf-4 since
6873 gcc-4.5.x. As the .debug_types sections are missing DW_AT_producer
6874 for their space efficiency GDB cannot workaround gcc-4.5.x -gdwarf-4
6875 combination. gcc-4.5.x -gdwarf-4 binaries have DW_AT_accessibility
6876 interpreted incorrectly by GDB now - GCC PR debug/48229. */
6881 /* Skip any identifier after "GNU " - such as "C++" or "Java". */
6883 if (strncmp (cu->producer, "GNU ", strlen ("GNU ")) != 0)
6885 /* For non-GCC compilers expect their behavior is DWARF version
6890 cs = &cu->producer[strlen ("GNU ")];
6891 while (*cs && !isdigit (*cs))
6893 if (sscanf (cs, "%d.%d.%d", &major, &minor, &release) != 3)
6895 /* Not recognized as GCC. */
6900 return major < 4 || (major == 4 && minor < 6);
6903 /* Return the default accessibility type if it is not overriden by
6904 DW_AT_accessibility. */
6906 static enum dwarf_access_attribute
6907 dwarf2_default_access_attribute (struct die_info *die, struct dwarf2_cu *cu)
6909 if (cu->header.version < 3 || producer_is_gxx_lt_4_6 (cu))
6911 /* The default DWARF 2 accessibility for members is public, the default
6912 accessibility for inheritance is private. */
6914 if (die->tag != DW_TAG_inheritance)
6915 return DW_ACCESS_public;
6917 return DW_ACCESS_private;
6921 /* DWARF 3+ defines the default accessibility a different way. The same
6922 rules apply now for DW_TAG_inheritance as for the members and it only
6923 depends on the container kind. */
6925 if (die->parent->tag == DW_TAG_class_type)
6926 return DW_ACCESS_private;
6928 return DW_ACCESS_public;
6932 /* Look for DW_AT_data_member_location. Set *OFFSET to the byte
6933 offset. If the attribute was not found return 0, otherwise return
6934 1. If it was found but could not properly be handled, set *OFFSET
6938 handle_data_member_location (struct die_info *die, struct dwarf2_cu *cu,
6941 struct attribute *attr;
6943 attr = dwarf2_attr (die, DW_AT_data_member_location, cu);
6948 /* Note that we do not check for a section offset first here.
6949 This is because DW_AT_data_member_location is new in DWARF 4,
6950 so if we see it, we can assume that a constant form is really
6951 a constant and not a section offset. */
6952 if (attr_form_is_constant (attr))
6953 *offset = dwarf2_get_attr_constant_value (attr, 0);
6954 else if (attr_form_is_section_offset (attr))
6955 dwarf2_complex_location_expr_complaint ();
6956 else if (attr_form_is_block (attr))
6957 *offset = decode_locdesc (DW_BLOCK (attr), cu);
6959 dwarf2_complex_location_expr_complaint ();
6967 /* Add an aggregate field to the field list. */
6970 dwarf2_add_field (struct field_info *fip, struct die_info *die,
6971 struct dwarf2_cu *cu)
6973 struct objfile *objfile = cu->objfile;
6974 struct gdbarch *gdbarch = get_objfile_arch (objfile);
6975 struct nextfield *new_field;
6976 struct attribute *attr;
6978 char *fieldname = "";
6980 /* Allocate a new field list entry and link it in. */
6981 new_field = (struct nextfield *) xmalloc (sizeof (struct nextfield));
6982 make_cleanup (xfree, new_field);
6983 memset (new_field, 0, sizeof (struct nextfield));
6985 if (die->tag == DW_TAG_inheritance)
6987 new_field->next = fip->baseclasses;
6988 fip->baseclasses = new_field;
6992 new_field->next = fip->fields;
6993 fip->fields = new_field;
6997 attr = dwarf2_attr (die, DW_AT_accessibility, cu);
6999 new_field->accessibility = DW_UNSND (attr);
7001 new_field->accessibility = dwarf2_default_access_attribute (die, cu);
7002 if (new_field->accessibility != DW_ACCESS_public)
7003 fip->non_public_fields = 1;
7005 attr = dwarf2_attr (die, DW_AT_virtuality, cu);
7007 new_field->virtuality = DW_UNSND (attr);
7009 new_field->virtuality = DW_VIRTUALITY_none;
7011 fp = &new_field->field;
7013 if (die->tag == DW_TAG_member && ! die_is_declaration (die, cu))
7017 /* Data member other than a C++ static data member. */
7019 /* Get type of field. */
7020 fp->type = die_type (die, cu);
7022 SET_FIELD_BITPOS (*fp, 0);
7024 /* Get bit size of field (zero if none). */
7025 attr = dwarf2_attr (die, DW_AT_bit_size, cu);
7028 FIELD_BITSIZE (*fp) = DW_UNSND (attr);
7032 FIELD_BITSIZE (*fp) = 0;
7035 /* Get bit offset of field. */
7036 if (handle_data_member_location (die, cu, &offset))
7037 SET_FIELD_BITPOS (*fp, offset * bits_per_byte);
7038 attr = dwarf2_attr (die, DW_AT_bit_offset, cu);
7041 if (gdbarch_bits_big_endian (gdbarch))
7043 /* For big endian bits, the DW_AT_bit_offset gives the
7044 additional bit offset from the MSB of the containing
7045 anonymous object to the MSB of the field. We don't
7046 have to do anything special since we don't need to
7047 know the size of the anonymous object. */
7048 FIELD_BITPOS (*fp) += DW_UNSND (attr);
7052 /* For little endian bits, compute the bit offset to the
7053 MSB of the anonymous object, subtract off the number of
7054 bits from the MSB of the field to the MSB of the
7055 object, and then subtract off the number of bits of
7056 the field itself. The result is the bit offset of
7057 the LSB of the field. */
7059 int bit_offset = DW_UNSND (attr);
7061 attr = dwarf2_attr (die, DW_AT_byte_size, cu);
7064 /* The size of the anonymous object containing
7065 the bit field is explicit, so use the
7066 indicated size (in bytes). */
7067 anonymous_size = DW_UNSND (attr);
7071 /* The size of the anonymous object containing
7072 the bit field must be inferred from the type
7073 attribute of the data member containing the
7075 anonymous_size = TYPE_LENGTH (fp->type);
7077 FIELD_BITPOS (*fp) += anonymous_size * bits_per_byte
7078 - bit_offset - FIELD_BITSIZE (*fp);
7082 /* Get name of field. */
7083 fieldname = dwarf2_name (die, cu);
7084 if (fieldname == NULL)
7087 /* The name is already allocated along with this objfile, so we don't
7088 need to duplicate it for the type. */
7089 fp->name = fieldname;
7091 /* Change accessibility for artificial fields (e.g. virtual table
7092 pointer or virtual base class pointer) to private. */
7093 if (dwarf2_attr (die, DW_AT_artificial, cu))
7095 FIELD_ARTIFICIAL (*fp) = 1;
7096 new_field->accessibility = DW_ACCESS_private;
7097 fip->non_public_fields = 1;
7100 else if (die->tag == DW_TAG_member || die->tag == DW_TAG_variable)
7102 /* C++ static member. */
7104 /* NOTE: carlton/2002-11-05: It should be a DW_TAG_member that
7105 is a declaration, but all versions of G++ as of this writing
7106 (so through at least 3.2.1) incorrectly generate
7107 DW_TAG_variable tags. */
7109 const char *physname;
7111 /* Get name of field. */
7112 fieldname = dwarf2_name (die, cu);
7113 if (fieldname == NULL)
7116 attr = dwarf2_attr (die, DW_AT_const_value, cu);
7118 /* Only create a symbol if this is an external value.
7119 new_symbol checks this and puts the value in the global symbol
7120 table, which we want. If it is not external, new_symbol
7121 will try to put the value in cu->list_in_scope which is wrong. */
7122 && dwarf2_flag_true_p (die, DW_AT_external, cu))
7124 /* A static const member, not much different than an enum as far as
7125 we're concerned, except that we can support more types. */
7126 new_symbol (die, NULL, cu);
7129 /* Get physical name. */
7130 physname = dwarf2_physname (fieldname, die, cu);
7132 /* The name is already allocated along with this objfile, so we don't
7133 need to duplicate it for the type. */
7134 SET_FIELD_PHYSNAME (*fp, physname ? physname : "");
7135 FIELD_TYPE (*fp) = die_type (die, cu);
7136 FIELD_NAME (*fp) = fieldname;
7138 else if (die->tag == DW_TAG_inheritance)
7142 /* C++ base class field. */
7143 if (handle_data_member_location (die, cu, &offset))
7144 SET_FIELD_BITPOS (*fp, offset * bits_per_byte);
7145 FIELD_BITSIZE (*fp) = 0;
7146 FIELD_TYPE (*fp) = die_type (die, cu);
7147 FIELD_NAME (*fp) = type_name_no_tag (fp->type);
7148 fip->nbaseclasses++;
7152 /* Add a typedef defined in the scope of the FIP's class. */
7155 dwarf2_add_typedef (struct field_info *fip, struct die_info *die,
7156 struct dwarf2_cu *cu)
7158 struct objfile *objfile = cu->objfile;
7159 struct typedef_field_list *new_field;
7160 struct attribute *attr;
7161 struct typedef_field *fp;
7162 char *fieldname = "";
7164 /* Allocate a new field list entry and link it in. */
7165 new_field = xzalloc (sizeof (*new_field));
7166 make_cleanup (xfree, new_field);
7168 gdb_assert (die->tag == DW_TAG_typedef);
7170 fp = &new_field->field;
7172 /* Get name of field. */
7173 fp->name = dwarf2_name (die, cu);
7174 if (fp->name == NULL)
7177 fp->type = read_type_die (die, cu);
7179 new_field->next = fip->typedef_field_list;
7180 fip->typedef_field_list = new_field;
7181 fip->typedef_field_list_count++;
7184 /* Create the vector of fields, and attach it to the type. */
7187 dwarf2_attach_fields_to_type (struct field_info *fip, struct type *type,
7188 struct dwarf2_cu *cu)
7190 int nfields = fip->nfields;
7192 /* Record the field count, allocate space for the array of fields,
7193 and create blank accessibility bitfields if necessary. */
7194 TYPE_NFIELDS (type) = nfields;
7195 TYPE_FIELDS (type) = (struct field *)
7196 TYPE_ALLOC (type, sizeof (struct field) * nfields);
7197 memset (TYPE_FIELDS (type), 0, sizeof (struct field) * nfields);
7199 if (fip->non_public_fields && cu->language != language_ada)
7201 ALLOCATE_CPLUS_STRUCT_TYPE (type);
7203 TYPE_FIELD_PRIVATE_BITS (type) =
7204 (B_TYPE *) TYPE_ALLOC (type, B_BYTES (nfields));
7205 B_CLRALL (TYPE_FIELD_PRIVATE_BITS (type), nfields);
7207 TYPE_FIELD_PROTECTED_BITS (type) =
7208 (B_TYPE *) TYPE_ALLOC (type, B_BYTES (nfields));
7209 B_CLRALL (TYPE_FIELD_PROTECTED_BITS (type), nfields);
7211 TYPE_FIELD_IGNORE_BITS (type) =
7212 (B_TYPE *) TYPE_ALLOC (type, B_BYTES (nfields));
7213 B_CLRALL (TYPE_FIELD_IGNORE_BITS (type), nfields);
7216 /* If the type has baseclasses, allocate and clear a bit vector for
7217 TYPE_FIELD_VIRTUAL_BITS. */
7218 if (fip->nbaseclasses && cu->language != language_ada)
7220 int num_bytes = B_BYTES (fip->nbaseclasses);
7221 unsigned char *pointer;
7223 ALLOCATE_CPLUS_STRUCT_TYPE (type);
7224 pointer = TYPE_ALLOC (type, num_bytes);
7225 TYPE_FIELD_VIRTUAL_BITS (type) = pointer;
7226 B_CLRALL (TYPE_FIELD_VIRTUAL_BITS (type), fip->nbaseclasses);
7227 TYPE_N_BASECLASSES (type) = fip->nbaseclasses;
7230 /* Copy the saved-up fields into the field vector. Start from the head of
7231 the list, adding to the tail of the field array, so that they end up in
7232 the same order in the array in which they were added to the list. */
7233 while (nfields-- > 0)
7235 struct nextfield *fieldp;
7239 fieldp = fip->fields;
7240 fip->fields = fieldp->next;
7244 fieldp = fip->baseclasses;
7245 fip->baseclasses = fieldp->next;
7248 TYPE_FIELD (type, nfields) = fieldp->field;
7249 switch (fieldp->accessibility)
7251 case DW_ACCESS_private:
7252 if (cu->language != language_ada)
7253 SET_TYPE_FIELD_PRIVATE (type, nfields);
7256 case DW_ACCESS_protected:
7257 if (cu->language != language_ada)
7258 SET_TYPE_FIELD_PROTECTED (type, nfields);
7261 case DW_ACCESS_public:
7265 /* Unknown accessibility. Complain and treat it as public. */
7267 complaint (&symfile_complaints, _("unsupported accessibility %d"),
7268 fieldp->accessibility);
7272 if (nfields < fip->nbaseclasses)
7274 switch (fieldp->virtuality)
7276 case DW_VIRTUALITY_virtual:
7277 case DW_VIRTUALITY_pure_virtual:
7278 if (cu->language == language_ada)
7279 error (_("unexpected virtuality in component of Ada type"));
7280 SET_TYPE_FIELD_VIRTUAL (type, nfields);
7287 /* Add a member function to the proper fieldlist. */
7290 dwarf2_add_member_fn (struct field_info *fip, struct die_info *die,
7291 struct type *type, struct dwarf2_cu *cu)
7293 struct objfile *objfile = cu->objfile;
7294 struct attribute *attr;
7295 struct fnfieldlist *flp;
7297 struct fn_field *fnp;
7299 struct nextfnfield *new_fnfield;
7300 struct type *this_type;
7301 enum dwarf_access_attribute accessibility;
7303 if (cu->language == language_ada)
7304 error (_("unexpected member function in Ada type"));
7306 /* Get name of member function. */
7307 fieldname = dwarf2_name (die, cu);
7308 if (fieldname == NULL)
7311 /* Look up member function name in fieldlist. */
7312 for (i = 0; i < fip->nfnfields; i++)
7314 if (strcmp (fip->fnfieldlists[i].name, fieldname) == 0)
7318 /* Create new list element if necessary. */
7319 if (i < fip->nfnfields)
7320 flp = &fip->fnfieldlists[i];
7323 if ((fip->nfnfields % DW_FIELD_ALLOC_CHUNK) == 0)
7325 fip->fnfieldlists = (struct fnfieldlist *)
7326 xrealloc (fip->fnfieldlists,
7327 (fip->nfnfields + DW_FIELD_ALLOC_CHUNK)
7328 * sizeof (struct fnfieldlist));
7329 if (fip->nfnfields == 0)
7330 make_cleanup (free_current_contents, &fip->fnfieldlists);
7332 flp = &fip->fnfieldlists[fip->nfnfields];
7333 flp->name = fieldname;
7336 i = fip->nfnfields++;
7339 /* Create a new member function field and chain it to the field list
7341 new_fnfield = (struct nextfnfield *) xmalloc (sizeof (struct nextfnfield));
7342 make_cleanup (xfree, new_fnfield);
7343 memset (new_fnfield, 0, sizeof (struct nextfnfield));
7344 new_fnfield->next = flp->head;
7345 flp->head = new_fnfield;
7348 /* Fill in the member function field info. */
7349 fnp = &new_fnfield->fnfield;
7351 /* Delay processing of the physname until later. */
7352 if (cu->language == language_cplus || cu->language == language_java)
7354 add_to_method_list (type, i, flp->length - 1, fieldname,
7359 const char *physname = dwarf2_physname (fieldname, die, cu);
7360 fnp->physname = physname ? physname : "";
7363 fnp->type = alloc_type (objfile);
7364 this_type = read_type_die (die, cu);
7365 if (this_type && TYPE_CODE (this_type) == TYPE_CODE_FUNC)
7367 int nparams = TYPE_NFIELDS (this_type);
7369 /* TYPE is the domain of this method, and THIS_TYPE is the type
7370 of the method itself (TYPE_CODE_METHOD). */
7371 smash_to_method_type (fnp->type, type,
7372 TYPE_TARGET_TYPE (this_type),
7373 TYPE_FIELDS (this_type),
7374 TYPE_NFIELDS (this_type),
7375 TYPE_VARARGS (this_type));
7377 /* Handle static member functions.
7378 Dwarf2 has no clean way to discern C++ static and non-static
7379 member functions. G++ helps GDB by marking the first
7380 parameter for non-static member functions (which is the this
7381 pointer) as artificial. We obtain this information from
7382 read_subroutine_type via TYPE_FIELD_ARTIFICIAL. */
7383 if (nparams == 0 || TYPE_FIELD_ARTIFICIAL (this_type, 0) == 0)
7384 fnp->voffset = VOFFSET_STATIC;
7387 complaint (&symfile_complaints, _("member function type missing for '%s'"),
7388 dwarf2_full_name (fieldname, die, cu));
7390 /* Get fcontext from DW_AT_containing_type if present. */
7391 if (dwarf2_attr (die, DW_AT_containing_type, cu) != NULL)
7392 fnp->fcontext = die_containing_type (die, cu);
7394 /* dwarf2 doesn't have stubbed physical names, so the setting of is_const and
7395 is_volatile is irrelevant, as it is needed by gdb_mangle_name only. */
7397 /* Get accessibility. */
7398 attr = dwarf2_attr (die, DW_AT_accessibility, cu);
7400 accessibility = DW_UNSND (attr);
7402 accessibility = dwarf2_default_access_attribute (die, cu);
7403 switch (accessibility)
7405 case DW_ACCESS_private:
7406 fnp->is_private = 1;
7408 case DW_ACCESS_protected:
7409 fnp->is_protected = 1;
7413 /* Check for artificial methods. */
7414 attr = dwarf2_attr (die, DW_AT_artificial, cu);
7415 if (attr && DW_UNSND (attr) != 0)
7416 fnp->is_artificial = 1;
7418 /* Get index in virtual function table if it is a virtual member
7419 function. For older versions of GCC, this is an offset in the
7420 appropriate virtual table, as specified by DW_AT_containing_type.
7421 For everyone else, it is an expression to be evaluated relative
7422 to the object address. */
7424 attr = dwarf2_attr (die, DW_AT_vtable_elem_location, cu);
7427 if (attr_form_is_block (attr) && DW_BLOCK (attr)->size > 0)
7429 if (DW_BLOCK (attr)->data[0] == DW_OP_constu)
7431 /* Old-style GCC. */
7432 fnp->voffset = decode_locdesc (DW_BLOCK (attr), cu) + 2;
7434 else if (DW_BLOCK (attr)->data[0] == DW_OP_deref
7435 || (DW_BLOCK (attr)->size > 1
7436 && DW_BLOCK (attr)->data[0] == DW_OP_deref_size
7437 && DW_BLOCK (attr)->data[1] == cu->header.addr_size))
7439 struct dwarf_block blk;
7442 offset = (DW_BLOCK (attr)->data[0] == DW_OP_deref
7444 blk.size = DW_BLOCK (attr)->size - offset;
7445 blk.data = DW_BLOCK (attr)->data + offset;
7446 fnp->voffset = decode_locdesc (DW_BLOCK (attr), cu);
7447 if ((fnp->voffset % cu->header.addr_size) != 0)
7448 dwarf2_complex_location_expr_complaint ();
7450 fnp->voffset /= cu->header.addr_size;
7454 dwarf2_complex_location_expr_complaint ();
7457 fnp->fcontext = TYPE_TARGET_TYPE (TYPE_FIELD_TYPE (this_type, 0));
7459 else if (attr_form_is_section_offset (attr))
7461 dwarf2_complex_location_expr_complaint ();
7465 dwarf2_invalid_attrib_class_complaint ("DW_AT_vtable_elem_location",
7471 attr = dwarf2_attr (die, DW_AT_virtuality, cu);
7472 if (attr && DW_UNSND (attr))
7474 /* GCC does this, as of 2008-08-25; PR debug/37237. */
7475 complaint (&symfile_complaints,
7476 _("Member function \"%s\" (offset %d) is virtual "
7477 "but the vtable offset is not specified"),
7478 fieldname, die->offset);
7479 ALLOCATE_CPLUS_STRUCT_TYPE (type);
7480 TYPE_CPLUS_DYNAMIC (type) = 1;
7485 /* Create the vector of member function fields, and attach it to the type. */
7488 dwarf2_attach_fn_fields_to_type (struct field_info *fip, struct type *type,
7489 struct dwarf2_cu *cu)
7491 struct fnfieldlist *flp;
7492 int total_length = 0;
7495 if (cu->language == language_ada)
7496 error (_("unexpected member functions in Ada type"));
7498 ALLOCATE_CPLUS_STRUCT_TYPE (type);
7499 TYPE_FN_FIELDLISTS (type) = (struct fn_fieldlist *)
7500 TYPE_ALLOC (type, sizeof (struct fn_fieldlist) * fip->nfnfields);
7502 for (i = 0, flp = fip->fnfieldlists; i < fip->nfnfields; i++, flp++)
7504 struct nextfnfield *nfp = flp->head;
7505 struct fn_fieldlist *fn_flp = &TYPE_FN_FIELDLIST (type, i);
7508 TYPE_FN_FIELDLIST_NAME (type, i) = flp->name;
7509 TYPE_FN_FIELDLIST_LENGTH (type, i) = flp->length;
7510 fn_flp->fn_fields = (struct fn_field *)
7511 TYPE_ALLOC (type, sizeof (struct fn_field) * flp->length);
7512 for (k = flp->length; (k--, nfp); nfp = nfp->next)
7513 fn_flp->fn_fields[k] = nfp->fnfield;
7515 total_length += flp->length;
7518 TYPE_NFN_FIELDS (type) = fip->nfnfields;
7519 TYPE_NFN_FIELDS_TOTAL (type) = total_length;
7522 /* Returns non-zero if NAME is the name of a vtable member in CU's
7523 language, zero otherwise. */
7525 is_vtable_name (const char *name, struct dwarf2_cu *cu)
7527 static const char vptr[] = "_vptr";
7528 static const char vtable[] = "vtable";
7530 /* Look for the C++ and Java forms of the vtable. */
7531 if ((cu->language == language_java
7532 && strncmp (name, vtable, sizeof (vtable) - 1) == 0)
7533 || (strncmp (name, vptr, sizeof (vptr) - 1) == 0
7534 && is_cplus_marker (name[sizeof (vptr) - 1])))
7540 /* GCC outputs unnamed structures that are really pointers to member
7541 functions, with the ABI-specified layout. If TYPE describes
7542 such a structure, smash it into a member function type.
7544 GCC shouldn't do this; it should just output pointer to member DIEs.
7545 This is GCC PR debug/28767. */
7548 quirk_gcc_member_function_pointer (struct type *type, struct objfile *objfile)
7550 struct type *pfn_type, *domain_type, *new_type;
7552 /* Check for a structure with no name and two children. */
7553 if (TYPE_CODE (type) != TYPE_CODE_STRUCT || TYPE_NFIELDS (type) != 2)
7556 /* Check for __pfn and __delta members. */
7557 if (TYPE_FIELD_NAME (type, 0) == NULL
7558 || strcmp (TYPE_FIELD_NAME (type, 0), "__pfn") != 0
7559 || TYPE_FIELD_NAME (type, 1) == NULL
7560 || strcmp (TYPE_FIELD_NAME (type, 1), "__delta") != 0)
7563 /* Find the type of the method. */
7564 pfn_type = TYPE_FIELD_TYPE (type, 0);
7565 if (pfn_type == NULL
7566 || TYPE_CODE (pfn_type) != TYPE_CODE_PTR
7567 || TYPE_CODE (TYPE_TARGET_TYPE (pfn_type)) != TYPE_CODE_FUNC)
7570 /* Look for the "this" argument. */
7571 pfn_type = TYPE_TARGET_TYPE (pfn_type);
7572 if (TYPE_NFIELDS (pfn_type) == 0
7573 /* || TYPE_FIELD_TYPE (pfn_type, 0) == NULL */
7574 || TYPE_CODE (TYPE_FIELD_TYPE (pfn_type, 0)) != TYPE_CODE_PTR)
7577 domain_type = TYPE_TARGET_TYPE (TYPE_FIELD_TYPE (pfn_type, 0));
7578 new_type = alloc_type (objfile);
7579 smash_to_method_type (new_type, domain_type, TYPE_TARGET_TYPE (pfn_type),
7580 TYPE_FIELDS (pfn_type), TYPE_NFIELDS (pfn_type),
7581 TYPE_VARARGS (pfn_type));
7582 smash_to_methodptr_type (type, new_type);
7585 /* Called when we find the DIE that starts a structure or union scope
7586 (definition) to create a type for the structure or union. Fill in
7587 the type's name and general properties; the members will not be
7588 processed until process_structure_type.
7590 NOTE: we need to call these functions regardless of whether or not the
7591 DIE has a DW_AT_name attribute, since it might be an anonymous
7592 structure or union. This gets the type entered into our set of
7595 However, if the structure is incomplete (an opaque struct/union)
7596 then suppress creating a symbol table entry for it since gdb only
7597 wants to find the one with the complete definition. Note that if
7598 it is complete, we just call new_symbol, which does it's own
7599 checking about whether the struct/union is anonymous or not (and
7600 suppresses creating a symbol table entry itself). */
7602 static struct type *
7603 read_structure_type (struct die_info *die, struct dwarf2_cu *cu)
7605 struct objfile *objfile = cu->objfile;
7607 struct attribute *attr;
7610 /* If the definition of this type lives in .debug_types, read that type.
7611 Don't follow DW_AT_specification though, that will take us back up
7612 the chain and we want to go down. */
7613 attr = dwarf2_attr_no_follow (die, DW_AT_signature, cu);
7616 struct dwarf2_cu *type_cu = cu;
7617 struct die_info *type_die = follow_die_ref_or_sig (die, attr, &type_cu);
7619 /* We could just recurse on read_structure_type, but we need to call
7620 get_die_type to ensure only one type for this DIE is created.
7621 This is important, for example, because for c++ classes we need
7622 TYPE_NAME set which is only done by new_symbol. Blech. */
7623 type = read_type_die (type_die, type_cu);
7625 /* TYPE_CU may not be the same as CU.
7626 Ensure TYPE is recorded in CU's type_hash table. */
7627 return set_die_type (die, type, cu);
7630 type = alloc_type (objfile);
7631 INIT_CPLUS_SPECIFIC (type);
7633 name = dwarf2_name (die, cu);
7636 if (cu->language == language_cplus
7637 || cu->language == language_java)
7639 char *full_name = (char *) dwarf2_full_name (name, die, cu);
7641 /* dwarf2_full_name might have already finished building the DIE's
7642 type. If so, there is no need to continue. */
7643 if (get_die_type (die, cu) != NULL)
7644 return get_die_type (die, cu);
7646 TYPE_TAG_NAME (type) = full_name;
7647 if (die->tag == DW_TAG_structure_type
7648 || die->tag == DW_TAG_class_type)
7649 TYPE_NAME (type) = TYPE_TAG_NAME (type);
7653 /* The name is already allocated along with this objfile, so
7654 we don't need to duplicate it for the type. */
7655 TYPE_TAG_NAME (type) = (char *) name;
7656 if (die->tag == DW_TAG_class_type)
7657 TYPE_NAME (type) = TYPE_TAG_NAME (type);
7661 if (die->tag == DW_TAG_structure_type)
7663 TYPE_CODE (type) = TYPE_CODE_STRUCT;
7665 else if (die->tag == DW_TAG_union_type)
7667 TYPE_CODE (type) = TYPE_CODE_UNION;
7671 TYPE_CODE (type) = TYPE_CODE_CLASS;
7674 if (cu->language == language_cplus && die->tag == DW_TAG_class_type)
7675 TYPE_DECLARED_CLASS (type) = 1;
7677 attr = dwarf2_attr (die, DW_AT_byte_size, cu);
7680 TYPE_LENGTH (type) = DW_UNSND (attr);
7684 TYPE_LENGTH (type) = 0;
7687 TYPE_STUB_SUPPORTED (type) = 1;
7688 if (die_is_declaration (die, cu))
7689 TYPE_STUB (type) = 1;
7690 else if (attr == NULL && die->child == NULL
7691 && producer_is_realview (cu->producer))
7692 /* RealView does not output the required DW_AT_declaration
7693 on incomplete types. */
7694 TYPE_STUB (type) = 1;
7696 /* We need to add the type field to the die immediately so we don't
7697 infinitely recurse when dealing with pointers to the structure
7698 type within the structure itself. */
7699 set_die_type (die, type, cu);
7701 /* set_die_type should be already done. */
7702 set_descriptive_type (type, die, cu);
7707 /* Finish creating a structure or union type, including filling in
7708 its members and creating a symbol for it. */
7711 process_structure_scope (struct die_info *die, struct dwarf2_cu *cu)
7713 struct objfile *objfile = cu->objfile;
7714 struct die_info *child_die = die->child;
7717 type = get_die_type (die, cu);
7719 type = read_structure_type (die, cu);
7721 if (die->child != NULL && ! die_is_declaration (die, cu))
7723 struct field_info fi;
7724 struct die_info *child_die;
7725 VEC (symbolp) *template_args = NULL;
7726 struct cleanup *back_to = make_cleanup (null_cleanup, 0);
7728 memset (&fi, 0, sizeof (struct field_info));
7730 child_die = die->child;
7732 while (child_die && child_die->tag)
7734 if (child_die->tag == DW_TAG_member
7735 || child_die->tag == DW_TAG_variable)
7737 /* NOTE: carlton/2002-11-05: A C++ static data member
7738 should be a DW_TAG_member that is a declaration, but
7739 all versions of G++ as of this writing (so through at
7740 least 3.2.1) incorrectly generate DW_TAG_variable
7741 tags for them instead. */
7742 dwarf2_add_field (&fi, child_die, cu);
7744 else if (child_die->tag == DW_TAG_subprogram)
7746 /* C++ member function. */
7747 dwarf2_add_member_fn (&fi, child_die, type, cu);
7749 else if (child_die->tag == DW_TAG_inheritance)
7751 /* C++ base class field. */
7752 dwarf2_add_field (&fi, child_die, cu);
7754 else if (child_die->tag == DW_TAG_typedef)
7755 dwarf2_add_typedef (&fi, child_die, cu);
7756 else if (child_die->tag == DW_TAG_template_type_param
7757 || child_die->tag == DW_TAG_template_value_param)
7759 struct symbol *arg = new_symbol (child_die, NULL, cu);
7762 VEC_safe_push (symbolp, template_args, arg);
7765 child_die = sibling_die (child_die);
7768 /* Attach template arguments to type. */
7769 if (! VEC_empty (symbolp, template_args))
7771 ALLOCATE_CPLUS_STRUCT_TYPE (type);
7772 TYPE_N_TEMPLATE_ARGUMENTS (type)
7773 = VEC_length (symbolp, template_args);
7774 TYPE_TEMPLATE_ARGUMENTS (type)
7775 = obstack_alloc (&objfile->objfile_obstack,
7776 (TYPE_N_TEMPLATE_ARGUMENTS (type)
7777 * sizeof (struct symbol *)));
7778 memcpy (TYPE_TEMPLATE_ARGUMENTS (type),
7779 VEC_address (symbolp, template_args),
7780 (TYPE_N_TEMPLATE_ARGUMENTS (type)
7781 * sizeof (struct symbol *)));
7782 VEC_free (symbolp, template_args);
7785 /* Attach fields and member functions to the type. */
7787 dwarf2_attach_fields_to_type (&fi, type, cu);
7790 dwarf2_attach_fn_fields_to_type (&fi, type, cu);
7792 /* Get the type which refers to the base class (possibly this
7793 class itself) which contains the vtable pointer for the current
7794 class from the DW_AT_containing_type attribute. This use of
7795 DW_AT_containing_type is a GNU extension. */
7797 if (dwarf2_attr (die, DW_AT_containing_type, cu) != NULL)
7799 struct type *t = die_containing_type (die, cu);
7801 TYPE_VPTR_BASETYPE (type) = t;
7806 /* Our own class provides vtbl ptr. */
7807 for (i = TYPE_NFIELDS (t) - 1;
7808 i >= TYPE_N_BASECLASSES (t);
7811 char *fieldname = TYPE_FIELD_NAME (t, i);
7813 if (is_vtable_name (fieldname, cu))
7815 TYPE_VPTR_FIELDNO (type) = i;
7820 /* Complain if virtual function table field not found. */
7821 if (i < TYPE_N_BASECLASSES (t))
7822 complaint (&symfile_complaints,
7823 _("virtual function table pointer "
7824 "not found when defining class '%s'"),
7825 TYPE_TAG_NAME (type) ? TYPE_TAG_NAME (type) :
7830 TYPE_VPTR_FIELDNO (type) = TYPE_VPTR_FIELDNO (t);
7833 else if (cu->producer
7834 && strncmp (cu->producer,
7835 "IBM(R) XL C/C++ Advanced Edition", 32) == 0)
7837 /* The IBM XLC compiler does not provide direct indication
7838 of the containing type, but the vtable pointer is
7839 always named __vfp. */
7843 for (i = TYPE_NFIELDS (type) - 1;
7844 i >= TYPE_N_BASECLASSES (type);
7847 if (strcmp (TYPE_FIELD_NAME (type, i), "__vfp") == 0)
7849 TYPE_VPTR_FIELDNO (type) = i;
7850 TYPE_VPTR_BASETYPE (type) = type;
7857 /* Copy fi.typedef_field_list linked list elements content into the
7858 allocated array TYPE_TYPEDEF_FIELD_ARRAY (type). */
7859 if (fi.typedef_field_list)
7861 int i = fi.typedef_field_list_count;
7863 ALLOCATE_CPLUS_STRUCT_TYPE (type);
7864 TYPE_TYPEDEF_FIELD_ARRAY (type)
7865 = TYPE_ALLOC (type, sizeof (TYPE_TYPEDEF_FIELD (type, 0)) * i);
7866 TYPE_TYPEDEF_FIELD_COUNT (type) = i;
7868 /* Reverse the list order to keep the debug info elements order. */
7871 struct typedef_field *dest, *src;
7873 dest = &TYPE_TYPEDEF_FIELD (type, i);
7874 src = &fi.typedef_field_list->field;
7875 fi.typedef_field_list = fi.typedef_field_list->next;
7880 do_cleanups (back_to);
7882 if (HAVE_CPLUS_STRUCT (type))
7883 TYPE_CPLUS_REALLY_JAVA (type) = cu->language == language_java;
7886 quirk_gcc_member_function_pointer (type, cu->objfile);
7888 /* NOTE: carlton/2004-03-16: GCC 3.4 (or at least one of its
7889 snapshots) has been known to create a die giving a declaration
7890 for a class that has, as a child, a die giving a definition for a
7891 nested class. So we have to process our children even if the
7892 current die is a declaration. Normally, of course, a declaration
7893 won't have any children at all. */
7895 while (child_die != NULL && child_die->tag)
7897 if (child_die->tag == DW_TAG_member
7898 || child_die->tag == DW_TAG_variable
7899 || child_die->tag == DW_TAG_inheritance
7900 || child_die->tag == DW_TAG_template_value_param
7901 || child_die->tag == DW_TAG_template_type_param)
7906 process_die (child_die, cu);
7908 child_die = sibling_die (child_die);
7911 /* Do not consider external references. According to the DWARF standard,
7912 these DIEs are identified by the fact that they have no byte_size
7913 attribute, and a declaration attribute. */
7914 if (dwarf2_attr (die, DW_AT_byte_size, cu) != NULL
7915 || !die_is_declaration (die, cu))
7916 new_symbol (die, type, cu);
7919 /* Given a DW_AT_enumeration_type die, set its type. We do not
7920 complete the type's fields yet, or create any symbols. */
7922 static struct type *
7923 read_enumeration_type (struct die_info *die, struct dwarf2_cu *cu)
7925 struct objfile *objfile = cu->objfile;
7927 struct attribute *attr;
7930 /* If the definition of this type lives in .debug_types, read that type.
7931 Don't follow DW_AT_specification though, that will take us back up
7932 the chain and we want to go down. */
7933 attr = dwarf2_attr_no_follow (die, DW_AT_signature, cu);
7936 struct dwarf2_cu *type_cu = cu;
7937 struct die_info *type_die = follow_die_ref_or_sig (die, attr, &type_cu);
7939 type = read_type_die (type_die, type_cu);
7941 /* TYPE_CU may not be the same as CU.
7942 Ensure TYPE is recorded in CU's type_hash table. */
7943 return set_die_type (die, type, cu);
7946 type = alloc_type (objfile);
7948 TYPE_CODE (type) = TYPE_CODE_ENUM;
7949 name = dwarf2_full_name (NULL, die, cu);
7951 TYPE_TAG_NAME (type) = (char *) name;
7953 attr = dwarf2_attr (die, DW_AT_byte_size, cu);
7956 TYPE_LENGTH (type) = DW_UNSND (attr);
7960 TYPE_LENGTH (type) = 0;
7963 /* The enumeration DIE can be incomplete. In Ada, any type can be
7964 declared as private in the package spec, and then defined only
7965 inside the package body. Such types are known as Taft Amendment
7966 Types. When another package uses such a type, an incomplete DIE
7967 may be generated by the compiler. */
7968 if (die_is_declaration (die, cu))
7969 TYPE_STUB (type) = 1;
7971 return set_die_type (die, type, cu);
7974 /* Given a pointer to a die which begins an enumeration, process all
7975 the dies that define the members of the enumeration, and create the
7976 symbol for the enumeration type.
7978 NOTE: We reverse the order of the element list. */
7981 process_enumeration_scope (struct die_info *die, struct dwarf2_cu *cu)
7983 struct type *this_type;
7985 this_type = get_die_type (die, cu);
7986 if (this_type == NULL)
7987 this_type = read_enumeration_type (die, cu);
7989 if (die->child != NULL)
7991 struct die_info *child_die;
7993 struct field *fields = NULL;
7995 int unsigned_enum = 1;
7998 child_die = die->child;
7999 while (child_die && child_die->tag)
8001 if (child_die->tag != DW_TAG_enumerator)
8003 process_die (child_die, cu);
8007 name = dwarf2_name (child_die, cu);
8010 sym = new_symbol (child_die, this_type, cu);
8011 if (SYMBOL_VALUE (sym) < 0)
8014 if ((num_fields % DW_FIELD_ALLOC_CHUNK) == 0)
8016 fields = (struct field *)
8018 (num_fields + DW_FIELD_ALLOC_CHUNK)
8019 * sizeof (struct field));
8022 FIELD_NAME (fields[num_fields]) = SYMBOL_LINKAGE_NAME (sym);
8023 FIELD_TYPE (fields[num_fields]) = NULL;
8024 SET_FIELD_BITPOS (fields[num_fields], SYMBOL_VALUE (sym));
8025 FIELD_BITSIZE (fields[num_fields]) = 0;
8031 child_die = sibling_die (child_die);
8036 TYPE_NFIELDS (this_type) = num_fields;
8037 TYPE_FIELDS (this_type) = (struct field *)
8038 TYPE_ALLOC (this_type, sizeof (struct field) * num_fields);
8039 memcpy (TYPE_FIELDS (this_type), fields,
8040 sizeof (struct field) * num_fields);
8044 TYPE_UNSIGNED (this_type) = 1;
8047 /* If we are reading an enum from a .debug_types unit, and the enum
8048 is a declaration, and the enum is not the signatured type in the
8049 unit, then we do not want to add a symbol for it. Adding a
8050 symbol would in some cases obscure the true definition of the
8051 enum, giving users an incomplete type when the definition is
8052 actually available. Note that we do not want to do this for all
8053 enums which are just declarations, because C++0x allows forward
8054 enum declarations. */
8055 if (cu->per_cu->debug_type_section
8056 && die_is_declaration (die, cu))
8058 struct signatured_type *type_sig;
8061 = lookup_signatured_type_at_offset (dwarf2_per_objfile->objfile,
8062 cu->per_cu->debug_type_section,
8063 cu->per_cu->offset);
8064 if (type_sig->type_offset != die->offset)
8068 new_symbol (die, this_type, cu);
8071 /* Extract all information from a DW_TAG_array_type DIE and put it in
8072 the DIE's type field. For now, this only handles one dimensional
8075 static struct type *
8076 read_array_type (struct die_info *die, struct dwarf2_cu *cu)
8078 struct objfile *objfile = cu->objfile;
8079 struct die_info *child_die;
8081 struct type *element_type, *range_type, *index_type;
8082 struct type **range_types = NULL;
8083 struct attribute *attr;
8085 struct cleanup *back_to;
8088 element_type = die_type (die, cu);
8090 /* The die_type call above may have already set the type for this DIE. */
8091 type = get_die_type (die, cu);
8095 /* Irix 6.2 native cc creates array types without children for
8096 arrays with unspecified length. */
8097 if (die->child == NULL)
8099 index_type = objfile_type (objfile)->builtin_int;
8100 range_type = create_range_type (NULL, index_type, 0, -1);
8101 type = create_array_type (NULL, element_type, range_type);
8102 return set_die_type (die, type, cu);
8105 back_to = make_cleanup (null_cleanup, NULL);
8106 child_die = die->child;
8107 while (child_die && child_die->tag)
8109 if (child_die->tag == DW_TAG_subrange_type)
8111 struct type *child_type = read_type_die (child_die, cu);
8113 if (child_type != NULL)
8115 /* The range type was succesfully read. Save it for the
8116 array type creation. */
8117 if ((ndim % DW_FIELD_ALLOC_CHUNK) == 0)
8119 range_types = (struct type **)
8120 xrealloc (range_types, (ndim + DW_FIELD_ALLOC_CHUNK)
8121 * sizeof (struct type *));
8123 make_cleanup (free_current_contents, &range_types);
8125 range_types[ndim++] = child_type;
8128 child_die = sibling_die (child_die);
8131 /* Dwarf2 dimensions are output from left to right, create the
8132 necessary array types in backwards order. */
8134 type = element_type;
8136 if (read_array_order (die, cu) == DW_ORD_col_major)
8141 type = create_array_type (NULL, type, range_types[i++]);
8146 type = create_array_type (NULL, type, range_types[ndim]);
8149 /* Understand Dwarf2 support for vector types (like they occur on
8150 the PowerPC w/ AltiVec). Gcc just adds another attribute to the
8151 array type. This is not part of the Dwarf2/3 standard yet, but a
8152 custom vendor extension. The main difference between a regular
8153 array and the vector variant is that vectors are passed by value
8155 attr = dwarf2_attr (die, DW_AT_GNU_vector, cu);
8157 make_vector_type (type);
8159 /* The DIE may have DW_AT_byte_size set. For example an OpenCL
8160 implementation may choose to implement triple vectors using this
8162 attr = dwarf2_attr (die, DW_AT_byte_size, cu);
8165 if (DW_UNSND (attr) >= TYPE_LENGTH (type))
8166 TYPE_LENGTH (type) = DW_UNSND (attr);
8168 complaint (&symfile_complaints,
8169 _("DW_AT_byte_size for array type smaller "
8170 "than the total size of elements"));
8173 name = dwarf2_name (die, cu);
8175 TYPE_NAME (type) = name;
8177 /* Install the type in the die. */
8178 set_die_type (die, type, cu);
8180 /* set_die_type should be already done. */
8181 set_descriptive_type (type, die, cu);
8183 do_cleanups (back_to);
8188 static enum dwarf_array_dim_ordering
8189 read_array_order (struct die_info *die, struct dwarf2_cu *cu)
8191 struct attribute *attr;
8193 attr = dwarf2_attr (die, DW_AT_ordering, cu);
8195 if (attr) return DW_SND (attr);
8197 /* GNU F77 is a special case, as at 08/2004 array type info is the
8198 opposite order to the dwarf2 specification, but data is still
8199 laid out as per normal fortran.
8201 FIXME: dsl/2004-8-20: If G77 is ever fixed, this will also need
8202 version checking. */
8204 if (cu->language == language_fortran
8205 && cu->producer && strstr (cu->producer, "GNU F77"))
8207 return DW_ORD_row_major;
8210 switch (cu->language_defn->la_array_ordering)
8212 case array_column_major:
8213 return DW_ORD_col_major;
8214 case array_row_major:
8216 return DW_ORD_row_major;
8220 /* Extract all information from a DW_TAG_set_type DIE and put it in
8221 the DIE's type field. */
8223 static struct type *
8224 read_set_type (struct die_info *die, struct dwarf2_cu *cu)
8226 struct type *domain_type, *set_type;
8227 struct attribute *attr;
8229 domain_type = die_type (die, cu);
8231 /* The die_type call above may have already set the type for this DIE. */
8232 set_type = get_die_type (die, cu);
8236 set_type = create_set_type (NULL, domain_type);
8238 attr = dwarf2_attr (die, DW_AT_byte_size, cu);
8240 TYPE_LENGTH (set_type) = DW_UNSND (attr);
8242 return set_die_type (die, set_type, cu);
8245 /* First cut: install each common block member as a global variable. */
8248 read_common_block (struct die_info *die, struct dwarf2_cu *cu)
8250 struct die_info *child_die;
8251 struct attribute *attr;
8253 CORE_ADDR base = (CORE_ADDR) 0;
8255 attr = dwarf2_attr (die, DW_AT_location, cu);
8258 /* Support the .debug_loc offsets. */
8259 if (attr_form_is_block (attr))
8261 base = decode_locdesc (DW_BLOCK (attr), cu);
8263 else if (attr_form_is_section_offset (attr))
8265 dwarf2_complex_location_expr_complaint ();
8269 dwarf2_invalid_attrib_class_complaint ("DW_AT_location",
8270 "common block member");
8273 if (die->child != NULL)
8275 child_die = die->child;
8276 while (child_die && child_die->tag)
8280 sym = new_symbol (child_die, NULL, cu);
8282 && handle_data_member_location (child_die, cu, &offset))
8284 SYMBOL_VALUE_ADDRESS (sym) = base + offset;
8285 add_symbol_to_list (sym, &global_symbols);
8287 child_die = sibling_die (child_die);
8292 /* Create a type for a C++ namespace. */
8294 static struct type *
8295 read_namespace_type (struct die_info *die, struct dwarf2_cu *cu)
8297 struct objfile *objfile = cu->objfile;
8298 const char *previous_prefix, *name;
8302 /* For extensions, reuse the type of the original namespace. */
8303 if (dwarf2_attr (die, DW_AT_extension, cu) != NULL)
8305 struct die_info *ext_die;
8306 struct dwarf2_cu *ext_cu = cu;
8308 ext_die = dwarf2_extension (die, &ext_cu);
8309 type = read_type_die (ext_die, ext_cu);
8311 /* EXT_CU may not be the same as CU.
8312 Ensure TYPE is recorded in CU's type_hash table. */
8313 return set_die_type (die, type, cu);
8316 name = namespace_name (die, &is_anonymous, cu);
8318 /* Now build the name of the current namespace. */
8320 previous_prefix = determine_prefix (die, cu);
8321 if (previous_prefix[0] != '\0')
8322 name = typename_concat (&objfile->objfile_obstack,
8323 previous_prefix, name, 0, cu);
8325 /* Create the type. */
8326 type = init_type (TYPE_CODE_NAMESPACE, 0, 0, NULL,
8328 TYPE_NAME (type) = (char *) name;
8329 TYPE_TAG_NAME (type) = TYPE_NAME (type);
8331 return set_die_type (die, type, cu);
8334 /* Read a C++ namespace. */
8337 read_namespace (struct die_info *die, struct dwarf2_cu *cu)
8339 struct objfile *objfile = cu->objfile;
8342 /* Add a symbol associated to this if we haven't seen the namespace
8343 before. Also, add a using directive if it's an anonymous
8346 if (dwarf2_attr (die, DW_AT_extension, cu) == NULL)
8350 type = read_type_die (die, cu);
8351 new_symbol (die, type, cu);
8353 namespace_name (die, &is_anonymous, cu);
8356 const char *previous_prefix = determine_prefix (die, cu);
8358 cp_add_using_directive (previous_prefix, TYPE_NAME (type), NULL,
8359 NULL, NULL, &objfile->objfile_obstack);
8363 if (die->child != NULL)
8365 struct die_info *child_die = die->child;
8367 while (child_die && child_die->tag)
8369 process_die (child_die, cu);
8370 child_die = sibling_die (child_die);
8375 /* Read a Fortran module as type. This DIE can be only a declaration used for
8376 imported module. Still we need that type as local Fortran "use ... only"
8377 declaration imports depend on the created type in determine_prefix. */
8379 static struct type *
8380 read_module_type (struct die_info *die, struct dwarf2_cu *cu)
8382 struct objfile *objfile = cu->objfile;
8386 module_name = dwarf2_name (die, cu);
8388 complaint (&symfile_complaints,
8389 _("DW_TAG_module has no name, offset 0x%x"),
8391 type = init_type (TYPE_CODE_MODULE, 0, 0, module_name, objfile);
8393 /* determine_prefix uses TYPE_TAG_NAME. */
8394 TYPE_TAG_NAME (type) = TYPE_NAME (type);
8396 return set_die_type (die, type, cu);
8399 /* Read a Fortran module. */
8402 read_module (struct die_info *die, struct dwarf2_cu *cu)
8404 struct die_info *child_die = die->child;
8406 while (child_die && child_die->tag)
8408 process_die (child_die, cu);
8409 child_die = sibling_die (child_die);
8413 /* Return the name of the namespace represented by DIE. Set
8414 *IS_ANONYMOUS to tell whether or not the namespace is an anonymous
8418 namespace_name (struct die_info *die, int *is_anonymous, struct dwarf2_cu *cu)
8420 struct die_info *current_die;
8421 const char *name = NULL;
8423 /* Loop through the extensions until we find a name. */
8425 for (current_die = die;
8426 current_die != NULL;
8427 current_die = dwarf2_extension (die, &cu))
8429 name = dwarf2_name (current_die, cu);
8434 /* Is it an anonymous namespace? */
8436 *is_anonymous = (name == NULL);
8438 name = CP_ANONYMOUS_NAMESPACE_STR;
8443 /* Extract all information from a DW_TAG_pointer_type DIE and add to
8444 the user defined type vector. */
8446 static struct type *
8447 read_tag_pointer_type (struct die_info *die, struct dwarf2_cu *cu)
8449 struct gdbarch *gdbarch = get_objfile_arch (cu->objfile);
8450 struct comp_unit_head *cu_header = &cu->header;
8452 struct attribute *attr_byte_size;
8453 struct attribute *attr_address_class;
8454 int byte_size, addr_class;
8455 struct type *target_type;
8457 target_type = die_type (die, cu);
8459 /* The die_type call above may have already set the type for this DIE. */
8460 type = get_die_type (die, cu);
8464 type = lookup_pointer_type (target_type);
8466 attr_byte_size = dwarf2_attr (die, DW_AT_byte_size, cu);
8468 byte_size = DW_UNSND (attr_byte_size);
8470 byte_size = cu_header->addr_size;
8472 attr_address_class = dwarf2_attr (die, DW_AT_address_class, cu);
8473 if (attr_address_class)
8474 addr_class = DW_UNSND (attr_address_class);
8476 addr_class = DW_ADDR_none;
8478 /* If the pointer size or address class is different than the
8479 default, create a type variant marked as such and set the
8480 length accordingly. */
8481 if (TYPE_LENGTH (type) != byte_size || addr_class != DW_ADDR_none)
8483 if (gdbarch_address_class_type_flags_p (gdbarch))
8487 type_flags = gdbarch_address_class_type_flags
8488 (gdbarch, byte_size, addr_class);
8489 gdb_assert ((type_flags & ~TYPE_INSTANCE_FLAG_ADDRESS_CLASS_ALL)
8491 type = make_type_with_address_space (type, type_flags);
8493 else if (TYPE_LENGTH (type) != byte_size)
8495 complaint (&symfile_complaints,
8496 _("invalid pointer size %d"), byte_size);
8500 /* Should we also complain about unhandled address classes? */
8504 TYPE_LENGTH (type) = byte_size;
8505 return set_die_type (die, type, cu);
8508 /* Extract all information from a DW_TAG_ptr_to_member_type DIE and add to
8509 the user defined type vector. */
8511 static struct type *
8512 read_tag_ptr_to_member_type (struct die_info *die, struct dwarf2_cu *cu)
8515 struct type *to_type;
8516 struct type *domain;
8518 to_type = die_type (die, cu);
8519 domain = die_containing_type (die, cu);
8521 /* The calls above may have already set the type for this DIE. */
8522 type = get_die_type (die, cu);
8526 if (TYPE_CODE (check_typedef (to_type)) == TYPE_CODE_METHOD)
8527 type = lookup_methodptr_type (to_type);
8529 type = lookup_memberptr_type (to_type, domain);
8531 return set_die_type (die, type, cu);
8534 /* Extract all information from a DW_TAG_reference_type DIE and add to
8535 the user defined type vector. */
8537 static struct type *
8538 read_tag_reference_type (struct die_info *die, struct dwarf2_cu *cu)
8540 struct comp_unit_head *cu_header = &cu->header;
8541 struct type *type, *target_type;
8542 struct attribute *attr;
8544 target_type = die_type (die, cu);
8546 /* The die_type call above may have already set the type for this DIE. */
8547 type = get_die_type (die, cu);
8551 type = lookup_reference_type (target_type);
8552 attr = dwarf2_attr (die, DW_AT_byte_size, cu);
8555 TYPE_LENGTH (type) = DW_UNSND (attr);
8559 TYPE_LENGTH (type) = cu_header->addr_size;
8561 return set_die_type (die, type, cu);
8564 static struct type *
8565 read_tag_const_type (struct die_info *die, struct dwarf2_cu *cu)
8567 struct type *base_type, *cv_type;
8569 base_type = die_type (die, cu);
8571 /* The die_type call above may have already set the type for this DIE. */
8572 cv_type = get_die_type (die, cu);
8576 /* In case the const qualifier is applied to an array type, the element type
8577 is so qualified, not the array type (section 6.7.3 of C99). */
8578 if (TYPE_CODE (base_type) == TYPE_CODE_ARRAY)
8580 struct type *el_type, *inner_array;
8582 base_type = copy_type (base_type);
8583 inner_array = base_type;
8585 while (TYPE_CODE (TYPE_TARGET_TYPE (inner_array)) == TYPE_CODE_ARRAY)
8587 TYPE_TARGET_TYPE (inner_array) =
8588 copy_type (TYPE_TARGET_TYPE (inner_array));
8589 inner_array = TYPE_TARGET_TYPE (inner_array);
8592 el_type = TYPE_TARGET_TYPE (inner_array);
8593 TYPE_TARGET_TYPE (inner_array) =
8594 make_cv_type (1, TYPE_VOLATILE (el_type), el_type, NULL);
8596 return set_die_type (die, base_type, cu);
8599 cv_type = make_cv_type (1, TYPE_VOLATILE (base_type), base_type, 0);
8600 return set_die_type (die, cv_type, cu);
8603 static struct type *
8604 read_tag_volatile_type (struct die_info *die, struct dwarf2_cu *cu)
8606 struct type *base_type, *cv_type;
8608 base_type = die_type (die, cu);
8610 /* The die_type call above may have already set the type for this DIE. */
8611 cv_type = get_die_type (die, cu);
8615 cv_type = make_cv_type (TYPE_CONST (base_type), 1, base_type, 0);
8616 return set_die_type (die, cv_type, cu);
8619 /* Extract all information from a DW_TAG_string_type DIE and add to
8620 the user defined type vector. It isn't really a user defined type,
8621 but it behaves like one, with other DIE's using an AT_user_def_type
8622 attribute to reference it. */
8624 static struct type *
8625 read_tag_string_type (struct die_info *die, struct dwarf2_cu *cu)
8627 struct objfile *objfile = cu->objfile;
8628 struct gdbarch *gdbarch = get_objfile_arch (objfile);
8629 struct type *type, *range_type, *index_type, *char_type;
8630 struct attribute *attr;
8631 unsigned int length;
8633 attr = dwarf2_attr (die, DW_AT_string_length, cu);
8636 length = DW_UNSND (attr);
8640 /* Check for the DW_AT_byte_size attribute. */
8641 attr = dwarf2_attr (die, DW_AT_byte_size, cu);
8644 length = DW_UNSND (attr);
8652 index_type = objfile_type (objfile)->builtin_int;
8653 range_type = create_range_type (NULL, index_type, 1, length);
8654 char_type = language_string_char_type (cu->language_defn, gdbarch);
8655 type = create_string_type (NULL, char_type, range_type);
8657 return set_die_type (die, type, cu);
8660 /* Handle DIES due to C code like:
8664 int (*funcp)(int a, long l);
8668 ('funcp' generates a DW_TAG_subroutine_type DIE). */
8670 static struct type *
8671 read_subroutine_type (struct die_info *die, struct dwarf2_cu *cu)
8673 struct type *type; /* Type that this function returns. */
8674 struct type *ftype; /* Function that returns above type. */
8675 struct attribute *attr;
8677 type = die_type (die, cu);
8679 /* The die_type call above may have already set the type for this DIE. */
8680 ftype = get_die_type (die, cu);
8684 ftype = lookup_function_type (type);
8686 /* All functions in C++, Pascal and Java have prototypes. */
8687 attr = dwarf2_attr (die, DW_AT_prototyped, cu);
8688 if ((attr && (DW_UNSND (attr) != 0))
8689 || cu->language == language_cplus
8690 || cu->language == language_java
8691 || cu->language == language_pascal)
8692 TYPE_PROTOTYPED (ftype) = 1;
8693 else if (producer_is_realview (cu->producer))
8694 /* RealView does not emit DW_AT_prototyped. We can not
8695 distinguish prototyped and unprototyped functions; default to
8696 prototyped, since that is more common in modern code (and
8697 RealView warns about unprototyped functions). */
8698 TYPE_PROTOTYPED (ftype) = 1;
8700 /* Store the calling convention in the type if it's available in
8701 the subroutine die. Otherwise set the calling convention to
8702 the default value DW_CC_normal. */
8703 attr = dwarf2_attr (die, DW_AT_calling_convention, cu);
8705 TYPE_CALLING_CONVENTION (ftype) = DW_UNSND (attr);
8706 else if (cu->producer && strstr (cu->producer, "IBM XL C for OpenCL"))
8707 TYPE_CALLING_CONVENTION (ftype) = DW_CC_GDB_IBM_OpenCL;
8709 TYPE_CALLING_CONVENTION (ftype) = DW_CC_normal;
8711 /* We need to add the subroutine type to the die immediately so
8712 we don't infinitely recurse when dealing with parameters
8713 declared as the same subroutine type. */
8714 set_die_type (die, ftype, cu);
8716 if (die->child != NULL)
8718 struct type *void_type = objfile_type (cu->objfile)->builtin_void;
8719 struct die_info *child_die;
8720 int nparams, iparams;
8722 /* Count the number of parameters.
8723 FIXME: GDB currently ignores vararg functions, but knows about
8724 vararg member functions. */
8726 child_die = die->child;
8727 while (child_die && child_die->tag)
8729 if (child_die->tag == DW_TAG_formal_parameter)
8731 else if (child_die->tag == DW_TAG_unspecified_parameters)
8732 TYPE_VARARGS (ftype) = 1;
8733 child_die = sibling_die (child_die);
8736 /* Allocate storage for parameters and fill them in. */
8737 TYPE_NFIELDS (ftype) = nparams;
8738 TYPE_FIELDS (ftype) = (struct field *)
8739 TYPE_ZALLOC (ftype, nparams * sizeof (struct field));
8741 /* TYPE_FIELD_TYPE must never be NULL. Pre-fill the array to ensure it
8742 even if we error out during the parameters reading below. */
8743 for (iparams = 0; iparams < nparams; iparams++)
8744 TYPE_FIELD_TYPE (ftype, iparams) = void_type;
8747 child_die = die->child;
8748 while (child_die && child_die->tag)
8750 if (child_die->tag == DW_TAG_formal_parameter)
8752 struct type *arg_type;
8754 /* DWARF version 2 has no clean way to discern C++
8755 static and non-static member functions. G++ helps
8756 GDB by marking the first parameter for non-static
8757 member functions (which is the this pointer) as
8758 artificial. We pass this information to
8759 dwarf2_add_member_fn via TYPE_FIELD_ARTIFICIAL.
8761 DWARF version 3 added DW_AT_object_pointer, which GCC
8762 4.5 does not yet generate. */
8763 attr = dwarf2_attr (child_die, DW_AT_artificial, cu);
8765 TYPE_FIELD_ARTIFICIAL (ftype, iparams) = DW_UNSND (attr);
8768 TYPE_FIELD_ARTIFICIAL (ftype, iparams) = 0;
8770 /* GCC/43521: In java, the formal parameter
8771 "this" is sometimes not marked with DW_AT_artificial. */
8772 if (cu->language == language_java)
8774 const char *name = dwarf2_name (child_die, cu);
8776 if (name && !strcmp (name, "this"))
8777 TYPE_FIELD_ARTIFICIAL (ftype, iparams) = 1;
8780 arg_type = die_type (child_die, cu);
8782 /* RealView does not mark THIS as const, which the testsuite
8783 expects. GCC marks THIS as const in method definitions,
8784 but not in the class specifications (GCC PR 43053). */
8785 if (cu->language == language_cplus && !TYPE_CONST (arg_type)
8786 && TYPE_FIELD_ARTIFICIAL (ftype, iparams))
8789 struct dwarf2_cu *arg_cu = cu;
8790 const char *name = dwarf2_name (child_die, cu);
8792 attr = dwarf2_attr (die, DW_AT_object_pointer, cu);
8795 /* If the compiler emits this, use it. */
8796 if (follow_die_ref (die, attr, &arg_cu) == child_die)
8799 else if (name && strcmp (name, "this") == 0)
8800 /* Function definitions will have the argument names. */
8802 else if (name == NULL && iparams == 0)
8803 /* Declarations may not have the names, so like
8804 elsewhere in GDB, assume an artificial first
8805 argument is "this". */
8809 arg_type = make_cv_type (1, TYPE_VOLATILE (arg_type),
8813 TYPE_FIELD_TYPE (ftype, iparams) = arg_type;
8816 child_die = sibling_die (child_die);
8823 static struct type *
8824 read_typedef (struct die_info *die, struct dwarf2_cu *cu)
8826 struct objfile *objfile = cu->objfile;
8827 const char *name = NULL;
8828 struct type *this_type;
8830 name = dwarf2_full_name (NULL, die, cu);
8831 this_type = init_type (TYPE_CODE_TYPEDEF, 0,
8832 TYPE_FLAG_TARGET_STUB, NULL, objfile);
8833 TYPE_NAME (this_type) = (char *) name;
8834 set_die_type (die, this_type, cu);
8835 TYPE_TARGET_TYPE (this_type) = die_type (die, cu);
8839 /* Find a representation of a given base type and install
8840 it in the TYPE field of the die. */
8842 static struct type *
8843 read_base_type (struct die_info *die, struct dwarf2_cu *cu)
8845 struct objfile *objfile = cu->objfile;
8847 struct attribute *attr;
8848 int encoding = 0, size = 0;
8850 enum type_code code = TYPE_CODE_INT;
8852 struct type *target_type = NULL;
8854 attr = dwarf2_attr (die, DW_AT_encoding, cu);
8857 encoding = DW_UNSND (attr);
8859 attr = dwarf2_attr (die, DW_AT_byte_size, cu);
8862 size = DW_UNSND (attr);
8864 name = dwarf2_name (die, cu);
8867 complaint (&symfile_complaints,
8868 _("DW_AT_name missing from DW_TAG_base_type"));
8873 case DW_ATE_address:
8874 /* Turn DW_ATE_address into a void * pointer. */
8875 code = TYPE_CODE_PTR;
8876 type_flags |= TYPE_FLAG_UNSIGNED;
8877 target_type = init_type (TYPE_CODE_VOID, 1, 0, NULL, objfile);
8879 case DW_ATE_boolean:
8880 code = TYPE_CODE_BOOL;
8881 type_flags |= TYPE_FLAG_UNSIGNED;
8883 case DW_ATE_complex_float:
8884 code = TYPE_CODE_COMPLEX;
8885 target_type = init_type (TYPE_CODE_FLT, size / 2, 0, NULL, objfile);
8887 case DW_ATE_decimal_float:
8888 code = TYPE_CODE_DECFLOAT;
8891 code = TYPE_CODE_FLT;
8895 case DW_ATE_unsigned:
8896 type_flags |= TYPE_FLAG_UNSIGNED;
8897 if (cu->language == language_fortran
8899 && strncmp (name, "character(", sizeof ("character(") - 1) == 0)
8900 code = TYPE_CODE_CHAR;
8902 case DW_ATE_signed_char:
8903 if (cu->language == language_ada || cu->language == language_m2
8904 || cu->language == language_pascal
8905 || cu->language == language_fortran)
8906 code = TYPE_CODE_CHAR;
8908 case DW_ATE_unsigned_char:
8909 if (cu->language == language_ada || cu->language == language_m2
8910 || cu->language == language_pascal
8911 || cu->language == language_fortran)
8912 code = TYPE_CODE_CHAR;
8913 type_flags |= TYPE_FLAG_UNSIGNED;
8916 /* We just treat this as an integer and then recognize the
8917 type by name elsewhere. */
8921 complaint (&symfile_complaints, _("unsupported DW_AT_encoding: '%s'"),
8922 dwarf_type_encoding_name (encoding));
8926 type = init_type (code, size, type_flags, NULL, objfile);
8927 TYPE_NAME (type) = name;
8928 TYPE_TARGET_TYPE (type) = target_type;
8930 if (name && strcmp (name, "char") == 0)
8931 TYPE_NOSIGN (type) = 1;
8933 return set_die_type (die, type, cu);
8936 /* Read the given DW_AT_subrange DIE. */
8938 static struct type *
8939 read_subrange_type (struct die_info *die, struct dwarf2_cu *cu)
8941 struct type *base_type;
8942 struct type *range_type;
8943 struct attribute *attr;
8947 LONGEST negative_mask;
8949 base_type = die_type (die, cu);
8950 /* Preserve BASE_TYPE's original type, just set its LENGTH. */
8951 check_typedef (base_type);
8953 /* The die_type call above may have already set the type for this DIE. */
8954 range_type = get_die_type (die, cu);
8958 if (cu->language == language_fortran)
8960 /* FORTRAN implies a lower bound of 1, if not given. */
8964 /* FIXME: For variable sized arrays either of these could be
8965 a variable rather than a constant value. We'll allow it,
8966 but we don't know how to handle it. */
8967 attr = dwarf2_attr (die, DW_AT_lower_bound, cu);
8969 low = dwarf2_get_attr_constant_value (attr, 0);
8971 attr = dwarf2_attr (die, DW_AT_upper_bound, cu);
8974 if (attr_form_is_block (attr) || is_ref_attr (attr))
8976 /* GCC encodes arrays with unspecified or dynamic length
8977 with a DW_FORM_block1 attribute or a reference attribute.
8978 FIXME: GDB does not yet know how to handle dynamic
8979 arrays properly, treat them as arrays with unspecified
8982 FIXME: jimb/2003-09-22: GDB does not really know
8983 how to handle arrays of unspecified length
8984 either; we just represent them as zero-length
8985 arrays. Choose an appropriate upper bound given
8986 the lower bound we've computed above. */
8990 high = dwarf2_get_attr_constant_value (attr, 1);
8994 attr = dwarf2_attr (die, DW_AT_count, cu);
8997 int count = dwarf2_get_attr_constant_value (attr, 1);
8998 high = low + count - 1;
9002 /* Unspecified array length. */
9007 /* Dwarf-2 specifications explicitly allows to create subrange types
9008 without specifying a base type.
9009 In that case, the base type must be set to the type of
9010 the lower bound, upper bound or count, in that order, if any of these
9011 three attributes references an object that has a type.
9012 If no base type is found, the Dwarf-2 specifications say that
9013 a signed integer type of size equal to the size of an address should
9015 For the following C code: `extern char gdb_int [];'
9016 GCC produces an empty range DIE.
9017 FIXME: muller/2010-05-28: Possible references to object for low bound,
9018 high bound or count are not yet handled by this code. */
9019 if (TYPE_CODE (base_type) == TYPE_CODE_VOID)
9021 struct objfile *objfile = cu->objfile;
9022 struct gdbarch *gdbarch = get_objfile_arch (objfile);
9023 int addr_size = gdbarch_addr_bit (gdbarch) /8;
9024 struct type *int_type = objfile_type (objfile)->builtin_int;
9026 /* Test "int", "long int", and "long long int" objfile types,
9027 and select the first one having a size above or equal to the
9028 architecture address size. */
9029 if (int_type && TYPE_LENGTH (int_type) >= addr_size)
9030 base_type = int_type;
9033 int_type = objfile_type (objfile)->builtin_long;
9034 if (int_type && TYPE_LENGTH (int_type) >= addr_size)
9035 base_type = int_type;
9038 int_type = objfile_type (objfile)->builtin_long_long;
9039 if (int_type && TYPE_LENGTH (int_type) >= addr_size)
9040 base_type = int_type;
9046 (LONGEST) -1 << (TYPE_LENGTH (base_type) * TARGET_CHAR_BIT - 1);
9047 if (!TYPE_UNSIGNED (base_type) && (low & negative_mask))
9048 low |= negative_mask;
9049 if (!TYPE_UNSIGNED (base_type) && (high & negative_mask))
9050 high |= negative_mask;
9052 range_type = create_range_type (NULL, base_type, low, high);
9054 /* Mark arrays with dynamic length at least as an array of unspecified
9055 length. GDB could check the boundary but before it gets implemented at
9056 least allow accessing the array elements. */
9057 if (attr && attr_form_is_block (attr))
9058 TYPE_HIGH_BOUND_UNDEFINED (range_type) = 1;
9060 /* Ada expects an empty array on no boundary attributes. */
9061 if (attr == NULL && cu->language != language_ada)
9062 TYPE_HIGH_BOUND_UNDEFINED (range_type) = 1;
9064 name = dwarf2_name (die, cu);
9066 TYPE_NAME (range_type) = name;
9068 attr = dwarf2_attr (die, DW_AT_byte_size, cu);
9070 TYPE_LENGTH (range_type) = DW_UNSND (attr);
9072 set_die_type (die, range_type, cu);
9074 /* set_die_type should be already done. */
9075 set_descriptive_type (range_type, die, cu);
9080 static struct type *
9081 read_unspecified_type (struct die_info *die, struct dwarf2_cu *cu)
9085 /* For now, we only support the C meaning of an unspecified type: void. */
9087 type = init_type (TYPE_CODE_VOID, 0, 0, NULL, cu->objfile);
9088 TYPE_NAME (type) = dwarf2_name (die, cu);
9090 return set_die_type (die, type, cu);
9093 /* Trivial hash function for die_info: the hash value of a DIE
9094 is its offset in .debug_info for this objfile. */
9097 die_hash (const void *item)
9099 const struct die_info *die = item;
9104 /* Trivial comparison function for die_info structures: two DIEs
9105 are equal if they have the same offset. */
9108 die_eq (const void *item_lhs, const void *item_rhs)
9110 const struct die_info *die_lhs = item_lhs;
9111 const struct die_info *die_rhs = item_rhs;
9113 return die_lhs->offset == die_rhs->offset;
9116 /* Read a whole compilation unit into a linked list of dies. */
9118 static struct die_info *
9119 read_comp_unit (gdb_byte *info_ptr, struct dwarf2_cu *cu)
9121 struct die_reader_specs reader_specs;
9122 int read_abbrevs = 0;
9123 struct cleanup *back_to = NULL;
9124 struct die_info *die;
9126 if (cu->dwarf2_abbrevs == NULL)
9128 dwarf2_read_abbrevs (cu->objfile->obfd, cu);
9129 back_to = make_cleanup (dwarf2_free_abbrev_table, cu);
9133 gdb_assert (cu->die_hash == NULL);
9135 = htab_create_alloc_ex (cu->header.length / 12,
9139 &cu->comp_unit_obstack,
9140 hashtab_obstack_allocate,
9141 dummy_obstack_deallocate);
9143 init_cu_die_reader (&reader_specs, cu);
9145 die = read_die_and_children (&reader_specs, info_ptr, &info_ptr, NULL);
9148 do_cleanups (back_to);
9153 /* Main entry point for reading a DIE and all children.
9154 Read the DIE and dump it if requested. */
9156 static struct die_info *
9157 read_die_and_children (const struct die_reader_specs *reader,
9159 gdb_byte **new_info_ptr,
9160 struct die_info *parent)
9162 struct die_info *result = read_die_and_children_1 (reader, info_ptr,
9163 new_info_ptr, parent);
9165 if (dwarf2_die_debug)
9167 fprintf_unfiltered (gdb_stdlog,
9168 "\nRead die from %s of %s:\n",
9169 (reader->cu->per_cu->debug_type_section
9172 reader->abfd->filename);
9173 dump_die (result, dwarf2_die_debug);
9179 /* Read a single die and all its descendents. Set the die's sibling
9180 field to NULL; set other fields in the die correctly, and set all
9181 of the descendents' fields correctly. Set *NEW_INFO_PTR to the
9182 location of the info_ptr after reading all of those dies. PARENT
9183 is the parent of the die in question. */
9185 static struct die_info *
9186 read_die_and_children_1 (const struct die_reader_specs *reader,
9188 gdb_byte **new_info_ptr,
9189 struct die_info *parent)
9191 struct die_info *die;
9195 cur_ptr = read_full_die (reader, &die, info_ptr, &has_children);
9198 *new_info_ptr = cur_ptr;
9201 store_in_ref_table (die, reader->cu);
9204 die->child = read_die_and_siblings (reader, cur_ptr, new_info_ptr, die);
9208 *new_info_ptr = cur_ptr;
9211 die->sibling = NULL;
9212 die->parent = parent;
9216 /* Read a die, all of its descendents, and all of its siblings; set
9217 all of the fields of all of the dies correctly. Arguments are as
9218 in read_die_and_children. */
9220 static struct die_info *
9221 read_die_and_siblings (const struct die_reader_specs *reader,
9223 gdb_byte **new_info_ptr,
9224 struct die_info *parent)
9226 struct die_info *first_die, *last_sibling;
9230 first_die = last_sibling = NULL;
9234 struct die_info *die
9235 = read_die_and_children_1 (reader, cur_ptr, &cur_ptr, parent);
9239 *new_info_ptr = cur_ptr;
9246 last_sibling->sibling = die;
9252 /* Read the die from the .debug_info section buffer. Set DIEP to
9253 point to a newly allocated die with its information, except for its
9254 child, sibling, and parent fields. Set HAS_CHILDREN to tell
9255 whether the die has children or not. */
9258 read_full_die (const struct die_reader_specs *reader,
9259 struct die_info **diep, gdb_byte *info_ptr,
9262 unsigned int abbrev_number, bytes_read, i, offset;
9263 struct abbrev_info *abbrev;
9264 struct die_info *die;
9265 struct dwarf2_cu *cu = reader->cu;
9266 bfd *abfd = reader->abfd;
9268 offset = info_ptr - reader->buffer;
9269 abbrev_number = read_unsigned_leb128 (abfd, info_ptr, &bytes_read);
9270 info_ptr += bytes_read;
9278 abbrev = dwarf2_lookup_abbrev (abbrev_number, cu);
9280 error (_("Dwarf Error: could not find abbrev number %d [in module %s]"),
9282 bfd_get_filename (abfd));
9284 die = dwarf_alloc_die (cu, abbrev->num_attrs);
9285 die->offset = offset;
9286 die->tag = abbrev->tag;
9287 die->abbrev = abbrev_number;
9289 die->num_attrs = abbrev->num_attrs;
9291 for (i = 0; i < abbrev->num_attrs; ++i)
9292 info_ptr = read_attribute (&die->attrs[i], &abbrev->attrs[i],
9293 abfd, info_ptr, cu);
9296 *has_children = abbrev->has_children;
9300 /* In DWARF version 2, the description of the debugging information is
9301 stored in a separate .debug_abbrev section. Before we read any
9302 dies from a section we read in all abbreviations and install them
9303 in a hash table. This function also sets flags in CU describing
9304 the data found in the abbrev table. */
9307 dwarf2_read_abbrevs (bfd *abfd, struct dwarf2_cu *cu)
9309 struct comp_unit_head *cu_header = &cu->header;
9310 gdb_byte *abbrev_ptr;
9311 struct abbrev_info *cur_abbrev;
9312 unsigned int abbrev_number, bytes_read, abbrev_name;
9313 unsigned int abbrev_form, hash_number;
9314 struct attr_abbrev *cur_attrs;
9315 unsigned int allocated_attrs;
9317 /* Initialize dwarf2 abbrevs. */
9318 obstack_init (&cu->abbrev_obstack);
9319 cu->dwarf2_abbrevs = obstack_alloc (&cu->abbrev_obstack,
9321 * sizeof (struct abbrev_info *)));
9322 memset (cu->dwarf2_abbrevs, 0,
9323 ABBREV_HASH_SIZE * sizeof (struct abbrev_info *));
9325 dwarf2_read_section (dwarf2_per_objfile->objfile,
9326 &dwarf2_per_objfile->abbrev);
9327 abbrev_ptr = dwarf2_per_objfile->abbrev.buffer + cu_header->abbrev_offset;
9328 abbrev_number = read_unsigned_leb128 (abfd, abbrev_ptr, &bytes_read);
9329 abbrev_ptr += bytes_read;
9331 allocated_attrs = ATTR_ALLOC_CHUNK;
9332 cur_attrs = xmalloc (allocated_attrs * sizeof (struct attr_abbrev));
9334 /* Loop until we reach an abbrev number of 0. */
9335 while (abbrev_number)
9337 cur_abbrev = dwarf_alloc_abbrev (cu);
9339 /* read in abbrev header */
9340 cur_abbrev->number = abbrev_number;
9341 cur_abbrev->tag = read_unsigned_leb128 (abfd, abbrev_ptr, &bytes_read);
9342 abbrev_ptr += bytes_read;
9343 cur_abbrev->has_children = read_1_byte (abfd, abbrev_ptr);
9346 if (cur_abbrev->tag == DW_TAG_namespace)
9347 cu->has_namespace_info = 1;
9349 /* now read in declarations */
9350 abbrev_name = read_unsigned_leb128 (abfd, abbrev_ptr, &bytes_read);
9351 abbrev_ptr += bytes_read;
9352 abbrev_form = read_unsigned_leb128 (abfd, abbrev_ptr, &bytes_read);
9353 abbrev_ptr += bytes_read;
9356 if (cur_abbrev->num_attrs == allocated_attrs)
9358 allocated_attrs += ATTR_ALLOC_CHUNK;
9360 = xrealloc (cur_attrs, (allocated_attrs
9361 * sizeof (struct attr_abbrev)));
9364 /* Record whether this compilation unit might have
9365 inter-compilation-unit references. If we don't know what form
9366 this attribute will have, then it might potentially be a
9367 DW_FORM_ref_addr, so we conservatively expect inter-CU
9370 if (abbrev_form == DW_FORM_ref_addr
9371 || abbrev_form == DW_FORM_indirect)
9372 cu->has_form_ref_addr = 1;
9374 cur_attrs[cur_abbrev->num_attrs].name = abbrev_name;
9375 cur_attrs[cur_abbrev->num_attrs++].form = abbrev_form;
9376 abbrev_name = read_unsigned_leb128 (abfd, abbrev_ptr, &bytes_read);
9377 abbrev_ptr += bytes_read;
9378 abbrev_form = read_unsigned_leb128 (abfd, abbrev_ptr, &bytes_read);
9379 abbrev_ptr += bytes_read;
9382 cur_abbrev->attrs = obstack_alloc (&cu->abbrev_obstack,
9383 (cur_abbrev->num_attrs
9384 * sizeof (struct attr_abbrev)));
9385 memcpy (cur_abbrev->attrs, cur_attrs,
9386 cur_abbrev->num_attrs * sizeof (struct attr_abbrev));
9388 hash_number = abbrev_number % ABBREV_HASH_SIZE;
9389 cur_abbrev->next = cu->dwarf2_abbrevs[hash_number];
9390 cu->dwarf2_abbrevs[hash_number] = cur_abbrev;
9392 /* Get next abbreviation.
9393 Under Irix6 the abbreviations for a compilation unit are not
9394 always properly terminated with an abbrev number of 0.
9395 Exit loop if we encounter an abbreviation which we have
9396 already read (which means we are about to read the abbreviations
9397 for the next compile unit) or if the end of the abbreviation
9398 table is reached. */
9399 if ((unsigned int) (abbrev_ptr - dwarf2_per_objfile->abbrev.buffer)
9400 >= dwarf2_per_objfile->abbrev.size)
9402 abbrev_number = read_unsigned_leb128 (abfd, abbrev_ptr, &bytes_read);
9403 abbrev_ptr += bytes_read;
9404 if (dwarf2_lookup_abbrev (abbrev_number, cu) != NULL)
9411 /* Release the memory used by the abbrev table for a compilation unit. */
9414 dwarf2_free_abbrev_table (void *ptr_to_cu)
9416 struct dwarf2_cu *cu = ptr_to_cu;
9418 obstack_free (&cu->abbrev_obstack, NULL);
9419 cu->dwarf2_abbrevs = NULL;
9422 /* Lookup an abbrev_info structure in the abbrev hash table. */
9424 static struct abbrev_info *
9425 dwarf2_lookup_abbrev (unsigned int number, struct dwarf2_cu *cu)
9427 unsigned int hash_number;
9428 struct abbrev_info *abbrev;
9430 hash_number = number % ABBREV_HASH_SIZE;
9431 abbrev = cu->dwarf2_abbrevs[hash_number];
9435 if (abbrev->number == number)
9438 abbrev = abbrev->next;
9443 /* Returns nonzero if TAG represents a type that we might generate a partial
9447 is_type_tag_for_partial (int tag)
9452 /* Some types that would be reasonable to generate partial symbols for,
9453 that we don't at present. */
9454 case DW_TAG_array_type:
9455 case DW_TAG_file_type:
9456 case DW_TAG_ptr_to_member_type:
9457 case DW_TAG_set_type:
9458 case DW_TAG_string_type:
9459 case DW_TAG_subroutine_type:
9461 case DW_TAG_base_type:
9462 case DW_TAG_class_type:
9463 case DW_TAG_interface_type:
9464 case DW_TAG_enumeration_type:
9465 case DW_TAG_structure_type:
9466 case DW_TAG_subrange_type:
9467 case DW_TAG_typedef:
9468 case DW_TAG_union_type:
9475 /* Load all DIEs that are interesting for partial symbols into memory. */
9477 static struct partial_die_info *
9478 load_partial_dies (bfd *abfd, gdb_byte *buffer, gdb_byte *info_ptr,
9479 int building_psymtab, struct dwarf2_cu *cu)
9481 struct partial_die_info *part_die;
9482 struct partial_die_info *parent_die, *last_die, *first_die = NULL;
9483 struct abbrev_info *abbrev;
9484 unsigned int bytes_read;
9485 unsigned int load_all = 0;
9487 int nesting_level = 1;
9492 if (cu->per_cu && cu->per_cu->load_all_dies)
9496 = htab_create_alloc_ex (cu->header.length / 12,
9500 &cu->comp_unit_obstack,
9501 hashtab_obstack_allocate,
9502 dummy_obstack_deallocate);
9504 part_die = obstack_alloc (&cu->comp_unit_obstack,
9505 sizeof (struct partial_die_info));
9509 abbrev = peek_die_abbrev (info_ptr, &bytes_read, cu);
9511 /* A NULL abbrev means the end of a series of children. */
9514 if (--nesting_level == 0)
9516 /* PART_DIE was probably the last thing allocated on the
9517 comp_unit_obstack, so we could call obstack_free
9518 here. We don't do that because the waste is small,
9519 and will be cleaned up when we're done with this
9520 compilation unit. This way, we're also more robust
9521 against other users of the comp_unit_obstack. */
9524 info_ptr += bytes_read;
9525 last_die = parent_die;
9526 parent_die = parent_die->die_parent;
9530 /* Check for template arguments. We never save these; if
9531 they're seen, we just mark the parent, and go on our way. */
9532 if (parent_die != NULL
9533 && cu->language == language_cplus
9534 && (abbrev->tag == DW_TAG_template_type_param
9535 || abbrev->tag == DW_TAG_template_value_param))
9537 parent_die->has_template_arguments = 1;
9541 /* We don't need a partial DIE for the template argument. */
9542 info_ptr = skip_one_die (buffer, info_ptr + bytes_read, abbrev,
9548 /* We only recurse into subprograms looking for template arguments.
9549 Skip their other children. */
9551 && cu->language == language_cplus
9552 && parent_die != NULL
9553 && parent_die->tag == DW_TAG_subprogram)
9555 info_ptr = skip_one_die (buffer, info_ptr + bytes_read, abbrev, cu);
9559 /* Check whether this DIE is interesting enough to save. Normally
9560 we would not be interested in members here, but there may be
9561 later variables referencing them via DW_AT_specification (for
9564 && !is_type_tag_for_partial (abbrev->tag)
9565 && abbrev->tag != DW_TAG_constant
9566 && abbrev->tag != DW_TAG_enumerator
9567 && abbrev->tag != DW_TAG_subprogram
9568 && abbrev->tag != DW_TAG_lexical_block
9569 && abbrev->tag != DW_TAG_variable
9570 && abbrev->tag != DW_TAG_namespace
9571 && abbrev->tag != DW_TAG_module
9572 && abbrev->tag != DW_TAG_member)
9574 /* Otherwise we skip to the next sibling, if any. */
9575 info_ptr = skip_one_die (buffer, info_ptr + bytes_read, abbrev, cu);
9579 info_ptr = read_partial_die (part_die, abbrev, bytes_read, abfd,
9580 buffer, info_ptr, cu);
9582 /* This two-pass algorithm for processing partial symbols has a
9583 high cost in cache pressure. Thus, handle some simple cases
9584 here which cover the majority of C partial symbols. DIEs
9585 which neither have specification tags in them, nor could have
9586 specification tags elsewhere pointing at them, can simply be
9587 processed and discarded.
9589 This segment is also optional; scan_partial_symbols and
9590 add_partial_symbol will handle these DIEs if we chain
9591 them in normally. When compilers which do not emit large
9592 quantities of duplicate debug information are more common,
9593 this code can probably be removed. */
9595 /* Any complete simple types at the top level (pretty much all
9596 of them, for a language without namespaces), can be processed
9598 if (parent_die == NULL
9599 && part_die->has_specification == 0
9600 && part_die->is_declaration == 0
9601 && ((part_die->tag == DW_TAG_typedef && !part_die->has_children)
9602 || part_die->tag == DW_TAG_base_type
9603 || part_die->tag == DW_TAG_subrange_type))
9605 if (building_psymtab && part_die->name != NULL)
9606 add_psymbol_to_list (part_die->name, strlen (part_die->name), 0,
9607 VAR_DOMAIN, LOC_TYPEDEF,
9608 &cu->objfile->static_psymbols,
9609 0, (CORE_ADDR) 0, cu->language, cu->objfile);
9610 info_ptr = locate_pdi_sibling (part_die, buffer, info_ptr, abfd, cu);
9614 /* The exception for DW_TAG_typedef with has_children above is
9615 a workaround of GCC PR debug/47510. In the case of this complaint
9616 type_name_no_tag_or_error will error on such types later.
9618 GDB skipped children of DW_TAG_typedef by the shortcut above and then
9619 it could not find the child DIEs referenced later, this is checked
9620 above. In correct DWARF DW_TAG_typedef should have no children. */
9622 if (part_die->tag == DW_TAG_typedef && part_die->has_children)
9623 complaint (&symfile_complaints,
9624 _("DW_TAG_typedef has childen - GCC PR debug/47510 bug "
9625 "- DIE at 0x%x [in module %s]"),
9626 part_die->offset, cu->objfile->name);
9628 /* If we're at the second level, and we're an enumerator, and
9629 our parent has no specification (meaning possibly lives in a
9630 namespace elsewhere), then we can add the partial symbol now
9631 instead of queueing it. */
9632 if (part_die->tag == DW_TAG_enumerator
9633 && parent_die != NULL
9634 && parent_die->die_parent == NULL
9635 && parent_die->tag == DW_TAG_enumeration_type
9636 && parent_die->has_specification == 0)
9638 if (part_die->name == NULL)
9639 complaint (&symfile_complaints,
9640 _("malformed enumerator DIE ignored"));
9641 else if (building_psymtab)
9642 add_psymbol_to_list (part_die->name, strlen (part_die->name), 0,
9643 VAR_DOMAIN, LOC_CONST,
9644 (cu->language == language_cplus
9645 || cu->language == language_java)
9646 ? &cu->objfile->global_psymbols
9647 : &cu->objfile->static_psymbols,
9648 0, (CORE_ADDR) 0, cu->language, cu->objfile);
9650 info_ptr = locate_pdi_sibling (part_die, buffer, info_ptr, abfd, cu);
9654 /* We'll save this DIE so link it in. */
9655 part_die->die_parent = parent_die;
9656 part_die->die_sibling = NULL;
9657 part_die->die_child = NULL;
9659 if (last_die && last_die == parent_die)
9660 last_die->die_child = part_die;
9662 last_die->die_sibling = part_die;
9664 last_die = part_die;
9666 if (first_die == NULL)
9667 first_die = part_die;
9669 /* Maybe add the DIE to the hash table. Not all DIEs that we
9670 find interesting need to be in the hash table, because we
9671 also have the parent/sibling/child chains; only those that we
9672 might refer to by offset later during partial symbol reading.
9674 For now this means things that might have be the target of a
9675 DW_AT_specification, DW_AT_abstract_origin, or
9676 DW_AT_extension. DW_AT_extension will refer only to
9677 namespaces; DW_AT_abstract_origin refers to functions (and
9678 many things under the function DIE, but we do not recurse
9679 into function DIEs during partial symbol reading) and
9680 possibly variables as well; DW_AT_specification refers to
9681 declarations. Declarations ought to have the DW_AT_declaration
9682 flag. It happens that GCC forgets to put it in sometimes, but
9683 only for functions, not for types.
9685 Adding more things than necessary to the hash table is harmless
9686 except for the performance cost. Adding too few will result in
9687 wasted time in find_partial_die, when we reread the compilation
9688 unit with load_all_dies set. */
9691 || abbrev->tag == DW_TAG_constant
9692 || abbrev->tag == DW_TAG_subprogram
9693 || abbrev->tag == DW_TAG_variable
9694 || abbrev->tag == DW_TAG_namespace
9695 || part_die->is_declaration)
9699 slot = htab_find_slot_with_hash (cu->partial_dies, part_die,
9700 part_die->offset, INSERT);
9704 part_die = obstack_alloc (&cu->comp_unit_obstack,
9705 sizeof (struct partial_die_info));
9707 /* For some DIEs we want to follow their children (if any). For C
9708 we have no reason to follow the children of structures; for other
9709 languages we have to, so that we can get at method physnames
9710 to infer fully qualified class names, for DW_AT_specification,
9711 and for C++ template arguments. For C++, we also look one level
9712 inside functions to find template arguments (if the name of the
9713 function does not already contain the template arguments).
9715 For Ada, we need to scan the children of subprograms and lexical
9716 blocks as well because Ada allows the definition of nested
9717 entities that could be interesting for the debugger, such as
9718 nested subprograms for instance. */
9719 if (last_die->has_children
9721 || last_die->tag == DW_TAG_namespace
9722 || last_die->tag == DW_TAG_module
9723 || last_die->tag == DW_TAG_enumeration_type
9724 || (cu->language == language_cplus
9725 && last_die->tag == DW_TAG_subprogram
9726 && (last_die->name == NULL
9727 || strchr (last_die->name, '<') == NULL))
9728 || (cu->language != language_c
9729 && (last_die->tag == DW_TAG_class_type
9730 || last_die->tag == DW_TAG_interface_type
9731 || last_die->tag == DW_TAG_structure_type
9732 || last_die->tag == DW_TAG_union_type))
9733 || (cu->language == language_ada
9734 && (last_die->tag == DW_TAG_subprogram
9735 || last_die->tag == DW_TAG_lexical_block))))
9738 parent_die = last_die;
9742 /* Otherwise we skip to the next sibling, if any. */
9743 info_ptr = locate_pdi_sibling (last_die, buffer, info_ptr, abfd, cu);
9745 /* Back to the top, do it again. */
9749 /* Read a minimal amount of information into the minimal die structure. */
9752 read_partial_die (struct partial_die_info *part_die,
9753 struct abbrev_info *abbrev,
9754 unsigned int abbrev_len, bfd *abfd,
9755 gdb_byte *buffer, gdb_byte *info_ptr,
9756 struct dwarf2_cu *cu)
9759 struct attribute attr;
9760 int has_low_pc_attr = 0;
9761 int has_high_pc_attr = 0;
9763 memset (part_die, 0, sizeof (struct partial_die_info));
9765 part_die->offset = info_ptr - buffer;
9767 info_ptr += abbrev_len;
9772 part_die->tag = abbrev->tag;
9773 part_die->has_children = abbrev->has_children;
9775 for (i = 0; i < abbrev->num_attrs; ++i)
9777 info_ptr = read_attribute (&attr, &abbrev->attrs[i], abfd, info_ptr, cu);
9779 /* Store the data if it is of an attribute we want to keep in a
9780 partial symbol table. */
9784 switch (part_die->tag)
9786 case DW_TAG_compile_unit:
9787 case DW_TAG_type_unit:
9788 /* Compilation units have a DW_AT_name that is a filename, not
9789 a source language identifier. */
9790 case DW_TAG_enumeration_type:
9791 case DW_TAG_enumerator:
9792 /* These tags always have simple identifiers already; no need
9793 to canonicalize them. */
9794 part_die->name = DW_STRING (&attr);
9798 = dwarf2_canonicalize_name (DW_STRING (&attr), cu,
9799 &cu->objfile->objfile_obstack);
9803 case DW_AT_linkage_name:
9804 case DW_AT_MIPS_linkage_name:
9805 /* Note that both forms of linkage name might appear. We
9806 assume they will be the same, and we only store the last
9808 if (cu->language == language_ada)
9809 part_die->name = DW_STRING (&attr);
9810 part_die->linkage_name = DW_STRING (&attr);
9813 has_low_pc_attr = 1;
9814 part_die->lowpc = DW_ADDR (&attr);
9817 has_high_pc_attr = 1;
9818 part_die->highpc = DW_ADDR (&attr);
9820 case DW_AT_location:
9821 /* Support the .debug_loc offsets. */
9822 if (attr_form_is_block (&attr))
9824 part_die->locdesc = DW_BLOCK (&attr);
9826 else if (attr_form_is_section_offset (&attr))
9828 dwarf2_complex_location_expr_complaint ();
9832 dwarf2_invalid_attrib_class_complaint ("DW_AT_location",
9833 "partial symbol information");
9836 case DW_AT_external:
9837 part_die->is_external = DW_UNSND (&attr);
9839 case DW_AT_declaration:
9840 part_die->is_declaration = DW_UNSND (&attr);
9843 part_die->has_type = 1;
9845 case DW_AT_abstract_origin:
9846 case DW_AT_specification:
9847 case DW_AT_extension:
9848 part_die->has_specification = 1;
9849 part_die->spec_offset = dwarf2_get_ref_die_offset (&attr);
9852 /* Ignore absolute siblings, they might point outside of
9853 the current compile unit. */
9854 if (attr.form == DW_FORM_ref_addr)
9855 complaint (&symfile_complaints,
9856 _("ignoring absolute DW_AT_sibling"));
9858 part_die->sibling = buffer + dwarf2_get_ref_die_offset (&attr);
9860 case DW_AT_byte_size:
9861 part_die->has_byte_size = 1;
9863 case DW_AT_calling_convention:
9864 /* DWARF doesn't provide a way to identify a program's source-level
9865 entry point. DW_AT_calling_convention attributes are only meant
9866 to describe functions' calling conventions.
9868 However, because it's a necessary piece of information in
9869 Fortran, and because DW_CC_program is the only piece of debugging
9870 information whose definition refers to a 'main program' at all,
9871 several compilers have begun marking Fortran main programs with
9872 DW_CC_program --- even when those functions use the standard
9873 calling conventions.
9875 So until DWARF specifies a way to provide this information and
9876 compilers pick up the new representation, we'll support this
9878 if (DW_UNSND (&attr) == DW_CC_program
9879 && cu->language == language_fortran)
9881 set_main_name (part_die->name);
9883 /* As this DIE has a static linkage the name would be difficult
9884 to look up later. */
9885 language_of_main = language_fortran;
9893 if (has_low_pc_attr && has_high_pc_attr)
9895 /* When using the GNU linker, .gnu.linkonce. sections are used to
9896 eliminate duplicate copies of functions and vtables and such.
9897 The linker will arbitrarily choose one and discard the others.
9898 The AT_*_pc values for such functions refer to local labels in
9899 these sections. If the section from that file was discarded, the
9900 labels are not in the output, so the relocs get a value of 0.
9901 If this is a discarded function, mark the pc bounds as invalid,
9902 so that GDB will ignore it. */
9903 if (part_die->lowpc == 0 && !dwarf2_per_objfile->has_section_at_zero)
9905 struct gdbarch *gdbarch = get_objfile_arch (cu->objfile);
9907 complaint (&symfile_complaints,
9908 _("DW_AT_low_pc %s is zero "
9909 "for DIE at 0x%x [in module %s]"),
9910 paddress (gdbarch, part_die->lowpc),
9911 part_die->offset, cu->objfile->name);
9913 /* dwarf2_get_pc_bounds has also the strict low < high requirement. */
9914 else if (part_die->lowpc >= part_die->highpc)
9916 struct gdbarch *gdbarch = get_objfile_arch (cu->objfile);
9918 complaint (&symfile_complaints,
9919 _("DW_AT_low_pc %s is not < DW_AT_high_pc %s "
9920 "for DIE at 0x%x [in module %s]"),
9921 paddress (gdbarch, part_die->lowpc),
9922 paddress (gdbarch, part_die->highpc),
9923 part_die->offset, cu->objfile->name);
9926 part_die->has_pc_info = 1;
9932 /* Find a cached partial DIE at OFFSET in CU. */
9934 static struct partial_die_info *
9935 find_partial_die_in_comp_unit (unsigned int offset, struct dwarf2_cu *cu)
9937 struct partial_die_info *lookup_die = NULL;
9938 struct partial_die_info part_die;
9940 part_die.offset = offset;
9941 lookup_die = htab_find_with_hash (cu->partial_dies, &part_die, offset);
9946 /* Find a partial DIE at OFFSET, which may or may not be in CU,
9947 except in the case of .debug_types DIEs which do not reference
9948 outside their CU (they do however referencing other types via
9949 DW_FORM_ref_sig8). */
9951 static struct partial_die_info *
9952 find_partial_die (unsigned int offset, struct dwarf2_cu *cu)
9954 struct dwarf2_per_cu_data *per_cu = NULL;
9955 struct partial_die_info *pd = NULL;
9957 if (cu->per_cu->debug_type_section)
9959 pd = find_partial_die_in_comp_unit (offset, cu);
9965 if (offset_in_cu_p (&cu->header, offset))
9967 pd = find_partial_die_in_comp_unit (offset, cu);
9972 per_cu = dwarf2_find_containing_comp_unit (offset, cu->objfile);
9974 if (per_cu->cu == NULL || per_cu->cu->partial_dies == NULL)
9975 load_partial_comp_unit (per_cu, cu->objfile);
9977 per_cu->cu->last_used = 0;
9978 pd = find_partial_die_in_comp_unit (offset, per_cu->cu);
9980 if (pd == NULL && per_cu->load_all_dies == 0)
9982 struct cleanup *back_to;
9983 struct partial_die_info comp_unit_die;
9984 struct abbrev_info *abbrev;
9985 unsigned int bytes_read;
9988 per_cu->load_all_dies = 1;
9990 /* Re-read the DIEs. */
9991 back_to = make_cleanup (null_cleanup, 0);
9992 if (per_cu->cu->dwarf2_abbrevs == NULL)
9994 dwarf2_read_abbrevs (per_cu->cu->objfile->obfd, per_cu->cu);
9995 make_cleanup (dwarf2_free_abbrev_table, per_cu->cu);
9997 info_ptr = (dwarf2_per_objfile->info.buffer
9998 + per_cu->cu->header.offset
9999 + per_cu->cu->header.first_die_offset);
10000 abbrev = peek_die_abbrev (info_ptr, &bytes_read, per_cu->cu);
10001 info_ptr = read_partial_die (&comp_unit_die, abbrev, bytes_read,
10002 per_cu->cu->objfile->obfd,
10003 dwarf2_per_objfile->info.buffer, info_ptr,
10005 if (comp_unit_die.has_children)
10006 load_partial_dies (per_cu->cu->objfile->obfd,
10007 dwarf2_per_objfile->info.buffer, info_ptr,
10009 do_cleanups (back_to);
10011 pd = find_partial_die_in_comp_unit (offset, per_cu->cu);
10017 internal_error (__FILE__, __LINE__,
10018 _("could not find partial DIE 0x%x "
10019 "in cache [from module %s]\n"),
10020 offset, bfd_get_filename (cu->objfile->obfd));
10024 /* See if we can figure out if the class lives in a namespace. We do
10025 this by looking for a member function; its demangled name will
10026 contain namespace info, if there is any. */
10029 guess_partial_die_structure_name (struct partial_die_info *struct_pdi,
10030 struct dwarf2_cu *cu)
10032 /* NOTE: carlton/2003-10-07: Getting the info this way changes
10033 what template types look like, because the demangler
10034 frequently doesn't give the same name as the debug info. We
10035 could fix this by only using the demangled name to get the
10036 prefix (but see comment in read_structure_type). */
10038 struct partial_die_info *real_pdi;
10039 struct partial_die_info *child_pdi;
10041 /* If this DIE (this DIE's specification, if any) has a parent, then
10042 we should not do this. We'll prepend the parent's fully qualified
10043 name when we create the partial symbol. */
10045 real_pdi = struct_pdi;
10046 while (real_pdi->has_specification)
10047 real_pdi = find_partial_die (real_pdi->spec_offset, cu);
10049 if (real_pdi->die_parent != NULL)
10052 for (child_pdi = struct_pdi->die_child;
10054 child_pdi = child_pdi->die_sibling)
10056 if (child_pdi->tag == DW_TAG_subprogram
10057 && child_pdi->linkage_name != NULL)
10059 char *actual_class_name
10060 = language_class_name_from_physname (cu->language_defn,
10061 child_pdi->linkage_name);
10062 if (actual_class_name != NULL)
10065 = obsavestring (actual_class_name,
10066 strlen (actual_class_name),
10067 &cu->objfile->objfile_obstack);
10068 xfree (actual_class_name);
10075 /* Adjust PART_DIE before generating a symbol for it. This function
10076 may set the is_external flag or change the DIE's name. */
10079 fixup_partial_die (struct partial_die_info *part_die,
10080 struct dwarf2_cu *cu)
10082 /* Once we've fixed up a die, there's no point in doing so again.
10083 This also avoids a memory leak if we were to call
10084 guess_partial_die_structure_name multiple times. */
10085 if (part_die->fixup_called)
10088 /* If we found a reference attribute and the DIE has no name, try
10089 to find a name in the referred to DIE. */
10091 if (part_die->name == NULL && part_die->has_specification)
10093 struct partial_die_info *spec_die;
10095 spec_die = find_partial_die (part_die->spec_offset, cu);
10097 fixup_partial_die (spec_die, cu);
10099 if (spec_die->name)
10101 part_die->name = spec_die->name;
10103 /* Copy DW_AT_external attribute if it is set. */
10104 if (spec_die->is_external)
10105 part_die->is_external = spec_die->is_external;
10109 /* Set default names for some unnamed DIEs. */
10111 if (part_die->name == NULL && part_die->tag == DW_TAG_namespace)
10112 part_die->name = CP_ANONYMOUS_NAMESPACE_STR;
10114 /* If there is no parent die to provide a namespace, and there are
10115 children, see if we can determine the namespace from their linkage
10117 NOTE: We need to do this even if cu->has_namespace_info != 0.
10118 gcc-4.5 -gdwarf-4 can drop the enclosing namespace. */
10119 if (cu->language == language_cplus
10120 && !VEC_empty (dwarf2_section_info_def, dwarf2_per_objfile->types)
10121 && part_die->die_parent == NULL
10122 && part_die->has_children
10123 && (part_die->tag == DW_TAG_class_type
10124 || part_die->tag == DW_TAG_structure_type
10125 || part_die->tag == DW_TAG_union_type))
10126 guess_partial_die_structure_name (part_die, cu);
10128 /* GCC might emit a nameless struct or union that has a linkage
10129 name. See http://gcc.gnu.org/bugzilla/show_bug.cgi?id=47510. */
10130 if (part_die->name == NULL
10131 && (part_die->tag == DW_TAG_class_type
10132 || part_die->tag == DW_TAG_interface_type
10133 || part_die->tag == DW_TAG_structure_type
10134 || part_die->tag == DW_TAG_union_type)
10135 && part_die->linkage_name != NULL)
10139 demangled = cplus_demangle (part_die->linkage_name, DMGL_TYPES);
10144 /* Strip any leading namespaces/classes, keep only the base name.
10145 DW_AT_name for named DIEs does not contain the prefixes. */
10146 base = strrchr (demangled, ':');
10147 if (base && base > demangled && base[-1] == ':')
10152 part_die->name = obsavestring (base, strlen (base),
10153 &cu->objfile->objfile_obstack);
10158 part_die->fixup_called = 1;
10161 /* Read an attribute value described by an attribute form. */
10164 read_attribute_value (struct attribute *attr, unsigned form,
10165 bfd *abfd, gdb_byte *info_ptr,
10166 struct dwarf2_cu *cu)
10168 struct comp_unit_head *cu_header = &cu->header;
10169 unsigned int bytes_read;
10170 struct dwarf_block *blk;
10175 case DW_FORM_ref_addr:
10176 if (cu->header.version == 2)
10177 DW_ADDR (attr) = read_address (abfd, info_ptr, cu, &bytes_read);
10179 DW_ADDR (attr) = read_offset (abfd, info_ptr,
10180 &cu->header, &bytes_read);
10181 info_ptr += bytes_read;
10184 DW_ADDR (attr) = read_address (abfd, info_ptr, cu, &bytes_read);
10185 info_ptr += bytes_read;
10187 case DW_FORM_block2:
10188 blk = dwarf_alloc_block (cu);
10189 blk->size = read_2_bytes (abfd, info_ptr);
10191 blk->data = read_n_bytes (abfd, info_ptr, blk->size);
10192 info_ptr += blk->size;
10193 DW_BLOCK (attr) = blk;
10195 case DW_FORM_block4:
10196 blk = dwarf_alloc_block (cu);
10197 blk->size = read_4_bytes (abfd, info_ptr);
10199 blk->data = read_n_bytes (abfd, info_ptr, blk->size);
10200 info_ptr += blk->size;
10201 DW_BLOCK (attr) = blk;
10203 case DW_FORM_data2:
10204 DW_UNSND (attr) = read_2_bytes (abfd, info_ptr);
10207 case DW_FORM_data4:
10208 DW_UNSND (attr) = read_4_bytes (abfd, info_ptr);
10211 case DW_FORM_data8:
10212 DW_UNSND (attr) = read_8_bytes (abfd, info_ptr);
10215 case DW_FORM_sec_offset:
10216 DW_UNSND (attr) = read_offset (abfd, info_ptr, &cu->header, &bytes_read);
10217 info_ptr += bytes_read;
10219 case DW_FORM_string:
10220 DW_STRING (attr) = read_direct_string (abfd, info_ptr, &bytes_read);
10221 DW_STRING_IS_CANONICAL (attr) = 0;
10222 info_ptr += bytes_read;
10225 DW_STRING (attr) = read_indirect_string (abfd, info_ptr, cu_header,
10227 DW_STRING_IS_CANONICAL (attr) = 0;
10228 info_ptr += bytes_read;
10230 case DW_FORM_exprloc:
10231 case DW_FORM_block:
10232 blk = dwarf_alloc_block (cu);
10233 blk->size = read_unsigned_leb128 (abfd, info_ptr, &bytes_read);
10234 info_ptr += bytes_read;
10235 blk->data = read_n_bytes (abfd, info_ptr, blk->size);
10236 info_ptr += blk->size;
10237 DW_BLOCK (attr) = blk;
10239 case DW_FORM_block1:
10240 blk = dwarf_alloc_block (cu);
10241 blk->size = read_1_byte (abfd, info_ptr);
10243 blk->data = read_n_bytes (abfd, info_ptr, blk->size);
10244 info_ptr += blk->size;
10245 DW_BLOCK (attr) = blk;
10247 case DW_FORM_data1:
10248 DW_UNSND (attr) = read_1_byte (abfd, info_ptr);
10252 DW_UNSND (attr) = read_1_byte (abfd, info_ptr);
10255 case DW_FORM_flag_present:
10256 DW_UNSND (attr) = 1;
10258 case DW_FORM_sdata:
10259 DW_SND (attr) = read_signed_leb128 (abfd, info_ptr, &bytes_read);
10260 info_ptr += bytes_read;
10262 case DW_FORM_udata:
10263 DW_UNSND (attr) = read_unsigned_leb128 (abfd, info_ptr, &bytes_read);
10264 info_ptr += bytes_read;
10267 DW_ADDR (attr) = cu->header.offset + read_1_byte (abfd, info_ptr);
10271 DW_ADDR (attr) = cu->header.offset + read_2_bytes (abfd, info_ptr);
10275 DW_ADDR (attr) = cu->header.offset + read_4_bytes (abfd, info_ptr);
10279 DW_ADDR (attr) = cu->header.offset + read_8_bytes (abfd, info_ptr);
10282 case DW_FORM_ref_sig8:
10283 /* Convert the signature to something we can record in DW_UNSND
10285 NOTE: This is NULL if the type wasn't found. */
10286 DW_SIGNATURED_TYPE (attr) =
10287 lookup_signatured_type (cu->objfile, read_8_bytes (abfd, info_ptr));
10290 case DW_FORM_ref_udata:
10291 DW_ADDR (attr) = (cu->header.offset
10292 + read_unsigned_leb128 (abfd, info_ptr, &bytes_read));
10293 info_ptr += bytes_read;
10295 case DW_FORM_indirect:
10296 form = read_unsigned_leb128 (abfd, info_ptr, &bytes_read);
10297 info_ptr += bytes_read;
10298 info_ptr = read_attribute_value (attr, form, abfd, info_ptr, cu);
10301 error (_("Dwarf Error: Cannot handle %s in DWARF reader [in module %s]"),
10302 dwarf_form_name (form),
10303 bfd_get_filename (abfd));
10306 /* We have seen instances where the compiler tried to emit a byte
10307 size attribute of -1 which ended up being encoded as an unsigned
10308 0xffffffff. Although 0xffffffff is technically a valid size value,
10309 an object of this size seems pretty unlikely so we can relatively
10310 safely treat these cases as if the size attribute was invalid and
10311 treat them as zero by default. */
10312 if (attr->name == DW_AT_byte_size
10313 && form == DW_FORM_data4
10314 && DW_UNSND (attr) >= 0xffffffff)
10317 (&symfile_complaints,
10318 _("Suspicious DW_AT_byte_size value treated as zero instead of %s"),
10319 hex_string (DW_UNSND (attr)));
10320 DW_UNSND (attr) = 0;
10326 /* Read an attribute described by an abbreviated attribute. */
10329 read_attribute (struct attribute *attr, struct attr_abbrev *abbrev,
10330 bfd *abfd, gdb_byte *info_ptr, struct dwarf2_cu *cu)
10332 attr->name = abbrev->name;
10333 return read_attribute_value (attr, abbrev->form, abfd, info_ptr, cu);
10336 /* Read dwarf information from a buffer. */
10338 static unsigned int
10339 read_1_byte (bfd *abfd, gdb_byte *buf)
10341 return bfd_get_8 (abfd, buf);
10345 read_1_signed_byte (bfd *abfd, gdb_byte *buf)
10347 return bfd_get_signed_8 (abfd, buf);
10350 static unsigned int
10351 read_2_bytes (bfd *abfd, gdb_byte *buf)
10353 return bfd_get_16 (abfd, buf);
10357 read_2_signed_bytes (bfd *abfd, gdb_byte *buf)
10359 return bfd_get_signed_16 (abfd, buf);
10362 static unsigned int
10363 read_4_bytes (bfd *abfd, gdb_byte *buf)
10365 return bfd_get_32 (abfd, buf);
10369 read_4_signed_bytes (bfd *abfd, gdb_byte *buf)
10371 return bfd_get_signed_32 (abfd, buf);
10375 read_8_bytes (bfd *abfd, gdb_byte *buf)
10377 return bfd_get_64 (abfd, buf);
10381 read_address (bfd *abfd, gdb_byte *buf, struct dwarf2_cu *cu,
10382 unsigned int *bytes_read)
10384 struct comp_unit_head *cu_header = &cu->header;
10385 CORE_ADDR retval = 0;
10387 if (cu_header->signed_addr_p)
10389 switch (cu_header->addr_size)
10392 retval = bfd_get_signed_16 (abfd, buf);
10395 retval = bfd_get_signed_32 (abfd, buf);
10398 retval = bfd_get_signed_64 (abfd, buf);
10401 internal_error (__FILE__, __LINE__,
10402 _("read_address: bad switch, signed [in module %s]"),
10403 bfd_get_filename (abfd));
10408 switch (cu_header->addr_size)
10411 retval = bfd_get_16 (abfd, buf);
10414 retval = bfd_get_32 (abfd, buf);
10417 retval = bfd_get_64 (abfd, buf);
10420 internal_error (__FILE__, __LINE__,
10421 _("read_address: bad switch, "
10422 "unsigned [in module %s]"),
10423 bfd_get_filename (abfd));
10427 *bytes_read = cu_header->addr_size;
10431 /* Read the initial length from a section. The (draft) DWARF 3
10432 specification allows the initial length to take up either 4 bytes
10433 or 12 bytes. If the first 4 bytes are 0xffffffff, then the next 8
10434 bytes describe the length and all offsets will be 8 bytes in length
10437 An older, non-standard 64-bit format is also handled by this
10438 function. The older format in question stores the initial length
10439 as an 8-byte quantity without an escape value. Lengths greater
10440 than 2^32 aren't very common which means that the initial 4 bytes
10441 is almost always zero. Since a length value of zero doesn't make
10442 sense for the 32-bit format, this initial zero can be considered to
10443 be an escape value which indicates the presence of the older 64-bit
10444 format. As written, the code can't detect (old format) lengths
10445 greater than 4GB. If it becomes necessary to handle lengths
10446 somewhat larger than 4GB, we could allow other small values (such
10447 as the non-sensical values of 1, 2, and 3) to also be used as
10448 escape values indicating the presence of the old format.
10450 The value returned via bytes_read should be used to increment the
10451 relevant pointer after calling read_initial_length().
10453 [ Note: read_initial_length() and read_offset() are based on the
10454 document entitled "DWARF Debugging Information Format", revision
10455 3, draft 8, dated November 19, 2001. This document was obtained
10458 http://reality.sgiweb.org/davea/dwarf3-draft8-011125.pdf
10460 This document is only a draft and is subject to change. (So beware.)
10462 Details regarding the older, non-standard 64-bit format were
10463 determined empirically by examining 64-bit ELF files produced by
10464 the SGI toolchain on an IRIX 6.5 machine.
10466 - Kevin, July 16, 2002
10470 read_initial_length (bfd *abfd, gdb_byte *buf, unsigned int *bytes_read)
10472 LONGEST length = bfd_get_32 (abfd, buf);
10474 if (length == 0xffffffff)
10476 length = bfd_get_64 (abfd, buf + 4);
10479 else if (length == 0)
10481 /* Handle the (non-standard) 64-bit DWARF2 format used by IRIX. */
10482 length = bfd_get_64 (abfd, buf);
10493 /* Cover function for read_initial_length.
10494 Returns the length of the object at BUF, and stores the size of the
10495 initial length in *BYTES_READ and stores the size that offsets will be in
10497 If the initial length size is not equivalent to that specified in
10498 CU_HEADER then issue a complaint.
10499 This is useful when reading non-comp-unit headers. */
10502 read_checked_initial_length_and_offset (bfd *abfd, gdb_byte *buf,
10503 const struct comp_unit_head *cu_header,
10504 unsigned int *bytes_read,
10505 unsigned int *offset_size)
10507 LONGEST length = read_initial_length (abfd, buf, bytes_read);
10509 gdb_assert (cu_header->initial_length_size == 4
10510 || cu_header->initial_length_size == 8
10511 || cu_header->initial_length_size == 12);
10513 if (cu_header->initial_length_size != *bytes_read)
10514 complaint (&symfile_complaints,
10515 _("intermixed 32-bit and 64-bit DWARF sections"));
10517 *offset_size = (*bytes_read == 4) ? 4 : 8;
10521 /* Read an offset from the data stream. The size of the offset is
10522 given by cu_header->offset_size. */
10525 read_offset (bfd *abfd, gdb_byte *buf, const struct comp_unit_head *cu_header,
10526 unsigned int *bytes_read)
10528 LONGEST offset = read_offset_1 (abfd, buf, cu_header->offset_size);
10530 *bytes_read = cu_header->offset_size;
10534 /* Read an offset from the data stream. */
10537 read_offset_1 (bfd *abfd, gdb_byte *buf, unsigned int offset_size)
10539 LONGEST retval = 0;
10541 switch (offset_size)
10544 retval = bfd_get_32 (abfd, buf);
10547 retval = bfd_get_64 (abfd, buf);
10550 internal_error (__FILE__, __LINE__,
10551 _("read_offset_1: bad switch [in module %s]"),
10552 bfd_get_filename (abfd));
10559 read_n_bytes (bfd *abfd, gdb_byte *buf, unsigned int size)
10561 /* If the size of a host char is 8 bits, we can return a pointer
10562 to the buffer, otherwise we have to copy the data to a buffer
10563 allocated on the temporary obstack. */
10564 gdb_assert (HOST_CHAR_BIT == 8);
10569 read_direct_string (bfd *abfd, gdb_byte *buf, unsigned int *bytes_read_ptr)
10571 /* If the size of a host char is 8 bits, we can return a pointer
10572 to the string, otherwise we have to copy the string to a buffer
10573 allocated on the temporary obstack. */
10574 gdb_assert (HOST_CHAR_BIT == 8);
10577 *bytes_read_ptr = 1;
10580 *bytes_read_ptr = strlen ((char *) buf) + 1;
10581 return (char *) buf;
10585 read_indirect_string_at_offset (bfd *abfd, LONGEST str_offset)
10587 dwarf2_read_section (dwarf2_per_objfile->objfile, &dwarf2_per_objfile->str);
10588 if (dwarf2_per_objfile->str.buffer == NULL)
10589 error (_("DW_FORM_strp used without .debug_str section [in module %s]"),
10590 bfd_get_filename (abfd));
10591 if (str_offset >= dwarf2_per_objfile->str.size)
10592 error (_("DW_FORM_strp pointing outside of "
10593 ".debug_str section [in module %s]"),
10594 bfd_get_filename (abfd));
10595 gdb_assert (HOST_CHAR_BIT == 8);
10596 if (dwarf2_per_objfile->str.buffer[str_offset] == '\0')
10598 return (char *) (dwarf2_per_objfile->str.buffer + str_offset);
10602 read_indirect_string (bfd *abfd, gdb_byte *buf,
10603 const struct comp_unit_head *cu_header,
10604 unsigned int *bytes_read_ptr)
10606 LONGEST str_offset = read_offset (abfd, buf, cu_header, bytes_read_ptr);
10608 return read_indirect_string_at_offset (abfd, str_offset);
10611 static unsigned long
10612 read_unsigned_leb128 (bfd *abfd, gdb_byte *buf, unsigned int *bytes_read_ptr)
10614 unsigned long result;
10615 unsigned int num_read;
10617 unsigned char byte;
10625 byte = bfd_get_8 (abfd, buf);
10628 result |= ((unsigned long)(byte & 127) << shift);
10629 if ((byte & 128) == 0)
10635 *bytes_read_ptr = num_read;
10640 read_signed_leb128 (bfd *abfd, gdb_byte *buf, unsigned int *bytes_read_ptr)
10643 int i, shift, num_read;
10644 unsigned char byte;
10652 byte = bfd_get_8 (abfd, buf);
10655 result |= ((long)(byte & 127) << shift);
10657 if ((byte & 128) == 0)
10662 if ((shift < 8 * sizeof (result)) && (byte & 0x40))
10663 result |= -(((long)1) << shift);
10664 *bytes_read_ptr = num_read;
10668 /* Return a pointer to just past the end of an LEB128 number in BUF. */
10671 skip_leb128 (bfd *abfd, gdb_byte *buf)
10677 byte = bfd_get_8 (abfd, buf);
10679 if ((byte & 128) == 0)
10685 set_cu_language (unsigned int lang, struct dwarf2_cu *cu)
10692 cu->language = language_c;
10694 case DW_LANG_C_plus_plus:
10695 cu->language = language_cplus;
10698 cu->language = language_d;
10700 case DW_LANG_Fortran77:
10701 case DW_LANG_Fortran90:
10702 case DW_LANG_Fortran95:
10703 cu->language = language_fortran;
10705 case DW_LANG_Mips_Assembler:
10706 cu->language = language_asm;
10709 cu->language = language_java;
10711 case DW_LANG_Ada83:
10712 case DW_LANG_Ada95:
10713 cu->language = language_ada;
10715 case DW_LANG_Modula2:
10716 cu->language = language_m2;
10718 case DW_LANG_Pascal83:
10719 cu->language = language_pascal;
10722 cu->language = language_objc;
10724 case DW_LANG_Cobol74:
10725 case DW_LANG_Cobol85:
10727 cu->language = language_minimal;
10730 cu->language_defn = language_def (cu->language);
10733 /* Return the named attribute or NULL if not there. */
10735 static struct attribute *
10736 dwarf2_attr (struct die_info *die, unsigned int name, struct dwarf2_cu *cu)
10739 struct attribute *spec = NULL;
10741 for (i = 0; i < die->num_attrs; ++i)
10743 if (die->attrs[i].name == name)
10744 return &die->attrs[i];
10745 if (die->attrs[i].name == DW_AT_specification
10746 || die->attrs[i].name == DW_AT_abstract_origin)
10747 spec = &die->attrs[i];
10752 die = follow_die_ref (die, spec, &cu);
10753 return dwarf2_attr (die, name, cu);
10759 /* Return the named attribute or NULL if not there,
10760 but do not follow DW_AT_specification, etc.
10761 This is for use in contexts where we're reading .debug_types dies.
10762 Following DW_AT_specification, DW_AT_abstract_origin will take us
10763 back up the chain, and we want to go down. */
10765 static struct attribute *
10766 dwarf2_attr_no_follow (struct die_info *die, unsigned int name,
10767 struct dwarf2_cu *cu)
10771 for (i = 0; i < die->num_attrs; ++i)
10772 if (die->attrs[i].name == name)
10773 return &die->attrs[i];
10778 /* Return non-zero iff the attribute NAME is defined for the given DIE,
10779 and holds a non-zero value. This function should only be used for
10780 DW_FORM_flag or DW_FORM_flag_present attributes. */
10783 dwarf2_flag_true_p (struct die_info *die, unsigned name, struct dwarf2_cu *cu)
10785 struct attribute *attr = dwarf2_attr (die, name, cu);
10787 return (attr && DW_UNSND (attr));
10791 die_is_declaration (struct die_info *die, struct dwarf2_cu *cu)
10793 /* A DIE is a declaration if it has a DW_AT_declaration attribute
10794 which value is non-zero. However, we have to be careful with
10795 DIEs having a DW_AT_specification attribute, because dwarf2_attr()
10796 (via dwarf2_flag_true_p) follows this attribute. So we may
10797 end up accidently finding a declaration attribute that belongs
10798 to a different DIE referenced by the specification attribute,
10799 even though the given DIE does not have a declaration attribute. */
10800 return (dwarf2_flag_true_p (die, DW_AT_declaration, cu)
10801 && dwarf2_attr (die, DW_AT_specification, cu) == NULL);
10804 /* Return the die giving the specification for DIE, if there is
10805 one. *SPEC_CU is the CU containing DIE on input, and the CU
10806 containing the return value on output. If there is no
10807 specification, but there is an abstract origin, that is
10810 static struct die_info *
10811 die_specification (struct die_info *die, struct dwarf2_cu **spec_cu)
10813 struct attribute *spec_attr = dwarf2_attr (die, DW_AT_specification,
10816 if (spec_attr == NULL)
10817 spec_attr = dwarf2_attr (die, DW_AT_abstract_origin, *spec_cu);
10819 if (spec_attr == NULL)
10822 return follow_die_ref (die, spec_attr, spec_cu);
10825 /* Free the line_header structure *LH, and any arrays and strings it
10827 NOTE: This is also used as a "cleanup" function. */
10830 free_line_header (struct line_header *lh)
10832 if (lh->standard_opcode_lengths)
10833 xfree (lh->standard_opcode_lengths);
10835 /* Remember that all the lh->file_names[i].name pointers are
10836 pointers into debug_line_buffer, and don't need to be freed. */
10837 if (lh->file_names)
10838 xfree (lh->file_names);
10840 /* Similarly for the include directory names. */
10841 if (lh->include_dirs)
10842 xfree (lh->include_dirs);
10847 /* Add an entry to LH's include directory table. */
10850 add_include_dir (struct line_header *lh, char *include_dir)
10852 /* Grow the array if necessary. */
10853 if (lh->include_dirs_size == 0)
10855 lh->include_dirs_size = 1; /* for testing */
10856 lh->include_dirs = xmalloc (lh->include_dirs_size
10857 * sizeof (*lh->include_dirs));
10859 else if (lh->num_include_dirs >= lh->include_dirs_size)
10861 lh->include_dirs_size *= 2;
10862 lh->include_dirs = xrealloc (lh->include_dirs,
10863 (lh->include_dirs_size
10864 * sizeof (*lh->include_dirs)));
10867 lh->include_dirs[lh->num_include_dirs++] = include_dir;
10870 /* Add an entry to LH's file name table. */
10873 add_file_name (struct line_header *lh,
10875 unsigned int dir_index,
10876 unsigned int mod_time,
10877 unsigned int length)
10879 struct file_entry *fe;
10881 /* Grow the array if necessary. */
10882 if (lh->file_names_size == 0)
10884 lh->file_names_size = 1; /* for testing */
10885 lh->file_names = xmalloc (lh->file_names_size
10886 * sizeof (*lh->file_names));
10888 else if (lh->num_file_names >= lh->file_names_size)
10890 lh->file_names_size *= 2;
10891 lh->file_names = xrealloc (lh->file_names,
10892 (lh->file_names_size
10893 * sizeof (*lh->file_names)));
10896 fe = &lh->file_names[lh->num_file_names++];
10898 fe->dir_index = dir_index;
10899 fe->mod_time = mod_time;
10900 fe->length = length;
10901 fe->included_p = 0;
10905 /* Read the statement program header starting at OFFSET in
10906 .debug_line, according to the endianness of ABFD. Return a pointer
10907 to a struct line_header, allocated using xmalloc.
10909 NOTE: the strings in the include directory and file name tables of
10910 the returned object point into debug_line_buffer, and must not be
10913 static struct line_header *
10914 dwarf_decode_line_header (unsigned int offset, bfd *abfd,
10915 struct dwarf2_cu *cu)
10917 struct cleanup *back_to;
10918 struct line_header *lh;
10919 gdb_byte *line_ptr;
10920 unsigned int bytes_read, offset_size;
10922 char *cur_dir, *cur_file;
10924 dwarf2_read_section (dwarf2_per_objfile->objfile, &dwarf2_per_objfile->line);
10925 if (dwarf2_per_objfile->line.buffer == NULL)
10927 complaint (&symfile_complaints, _("missing .debug_line section"));
10931 /* Make sure that at least there's room for the total_length field.
10932 That could be 12 bytes long, but we're just going to fudge that. */
10933 if (offset + 4 >= dwarf2_per_objfile->line.size)
10935 dwarf2_statement_list_fits_in_line_number_section_complaint ();
10939 lh = xmalloc (sizeof (*lh));
10940 memset (lh, 0, sizeof (*lh));
10941 back_to = make_cleanup ((make_cleanup_ftype *) free_line_header,
10944 line_ptr = dwarf2_per_objfile->line.buffer + offset;
10946 /* Read in the header. */
10948 read_checked_initial_length_and_offset (abfd, line_ptr, &cu->header,
10949 &bytes_read, &offset_size);
10950 line_ptr += bytes_read;
10951 if (line_ptr + lh->total_length > (dwarf2_per_objfile->line.buffer
10952 + dwarf2_per_objfile->line.size))
10954 dwarf2_statement_list_fits_in_line_number_section_complaint ();
10957 lh->statement_program_end = line_ptr + lh->total_length;
10958 lh->version = read_2_bytes (abfd, line_ptr);
10960 lh->header_length = read_offset_1 (abfd, line_ptr, offset_size);
10961 line_ptr += offset_size;
10962 lh->minimum_instruction_length = read_1_byte (abfd, line_ptr);
10964 if (lh->version >= 4)
10966 lh->maximum_ops_per_instruction = read_1_byte (abfd, line_ptr);
10970 lh->maximum_ops_per_instruction = 1;
10972 if (lh->maximum_ops_per_instruction == 0)
10974 lh->maximum_ops_per_instruction = 1;
10975 complaint (&symfile_complaints,
10976 _("invalid maximum_ops_per_instruction "
10977 "in `.debug_line' section"));
10980 lh->default_is_stmt = read_1_byte (abfd, line_ptr);
10982 lh->line_base = read_1_signed_byte (abfd, line_ptr);
10984 lh->line_range = read_1_byte (abfd, line_ptr);
10986 lh->opcode_base = read_1_byte (abfd, line_ptr);
10988 lh->standard_opcode_lengths
10989 = xmalloc (lh->opcode_base * sizeof (lh->standard_opcode_lengths[0]));
10991 lh->standard_opcode_lengths[0] = 1; /* This should never be used anyway. */
10992 for (i = 1; i < lh->opcode_base; ++i)
10994 lh->standard_opcode_lengths[i] = read_1_byte (abfd, line_ptr);
10998 /* Read directory table. */
10999 while ((cur_dir = read_direct_string (abfd, line_ptr, &bytes_read)) != NULL)
11001 line_ptr += bytes_read;
11002 add_include_dir (lh, cur_dir);
11004 line_ptr += bytes_read;
11006 /* Read file name table. */
11007 while ((cur_file = read_direct_string (abfd, line_ptr, &bytes_read)) != NULL)
11009 unsigned int dir_index, mod_time, length;
11011 line_ptr += bytes_read;
11012 dir_index = read_unsigned_leb128 (abfd, line_ptr, &bytes_read);
11013 line_ptr += bytes_read;
11014 mod_time = read_unsigned_leb128 (abfd, line_ptr, &bytes_read);
11015 line_ptr += bytes_read;
11016 length = read_unsigned_leb128 (abfd, line_ptr, &bytes_read);
11017 line_ptr += bytes_read;
11019 add_file_name (lh, cur_file, dir_index, mod_time, length);
11021 line_ptr += bytes_read;
11022 lh->statement_program_start = line_ptr;
11024 if (line_ptr > (dwarf2_per_objfile->line.buffer
11025 + dwarf2_per_objfile->line.size))
11026 complaint (&symfile_complaints,
11027 _("line number info header doesn't "
11028 "fit in `.debug_line' section"));
11030 discard_cleanups (back_to);
11034 /* This function exists to work around a bug in certain compilers
11035 (particularly GCC 2.95), in which the first line number marker of a
11036 function does not show up until after the prologue, right before
11037 the second line number marker. This function shifts ADDRESS down
11038 to the beginning of the function if necessary, and is called on
11039 addresses passed to record_line. */
11042 check_cu_functions (CORE_ADDR address, struct dwarf2_cu *cu)
11044 struct function_range *fn;
11046 /* Find the function_range containing address. */
11050 if (!cu->cached_fn)
11051 cu->cached_fn = cu->first_fn;
11053 fn = cu->cached_fn;
11055 if (fn->lowpc <= address && fn->highpc > address)
11061 while (fn && fn != cu->cached_fn)
11062 if (fn->lowpc <= address && fn->highpc > address)
11072 if (address != fn->lowpc)
11073 complaint (&symfile_complaints,
11074 _("misplaced first line number at 0x%lx for '%s'"),
11075 (unsigned long) address, fn->name);
11080 /* Subroutine of dwarf_decode_lines to simplify it.
11081 Return the file name of the psymtab for included file FILE_INDEX
11082 in line header LH of PST.
11083 COMP_DIR is the compilation directory (DW_AT_comp_dir) or NULL if unknown.
11084 If space for the result is malloc'd, it will be freed by a cleanup.
11085 Returns NULL if FILE_INDEX should be ignored, i.e., it is pst->filename. */
11088 psymtab_include_file_name (const struct line_header *lh, int file_index,
11089 const struct partial_symtab *pst,
11090 const char *comp_dir)
11092 const struct file_entry fe = lh->file_names [file_index];
11093 char *include_name = fe.name;
11094 char *include_name_to_compare = include_name;
11095 char *dir_name = NULL;
11096 const char *pst_filename;
11097 char *copied_name = NULL;
11101 dir_name = lh->include_dirs[fe.dir_index - 1];
11103 if (!IS_ABSOLUTE_PATH (include_name)
11104 && (dir_name != NULL || comp_dir != NULL))
11106 /* Avoid creating a duplicate psymtab for PST.
11107 We do this by comparing INCLUDE_NAME and PST_FILENAME.
11108 Before we do the comparison, however, we need to account
11109 for DIR_NAME and COMP_DIR.
11110 First prepend dir_name (if non-NULL). If we still don't
11111 have an absolute path prepend comp_dir (if non-NULL).
11112 However, the directory we record in the include-file's
11113 psymtab does not contain COMP_DIR (to match the
11114 corresponding symtab(s)).
11119 bash$ gcc -g ./hello.c
11120 include_name = "hello.c"
11122 DW_AT_comp_dir = comp_dir = "/tmp"
11123 DW_AT_name = "./hello.c" */
11125 if (dir_name != NULL)
11127 include_name = concat (dir_name, SLASH_STRING,
11128 include_name, (char *)NULL);
11129 include_name_to_compare = include_name;
11130 make_cleanup (xfree, include_name);
11132 if (!IS_ABSOLUTE_PATH (include_name) && comp_dir != NULL)
11134 include_name_to_compare = concat (comp_dir, SLASH_STRING,
11135 include_name, (char *)NULL);
11139 pst_filename = pst->filename;
11140 if (!IS_ABSOLUTE_PATH (pst_filename) && pst->dirname != NULL)
11142 copied_name = concat (pst->dirname, SLASH_STRING,
11143 pst_filename, (char *)NULL);
11144 pst_filename = copied_name;
11147 file_is_pst = FILENAME_CMP (include_name_to_compare, pst_filename) == 0;
11149 if (include_name_to_compare != include_name)
11150 xfree (include_name_to_compare);
11151 if (copied_name != NULL)
11152 xfree (copied_name);
11156 return include_name;
11159 /* Ignore this record_line request. */
11162 noop_record_line (struct subfile *subfile, int line, CORE_ADDR pc)
11167 /* Decode the Line Number Program (LNP) for the given line_header
11168 structure and CU. The actual information extracted and the type
11169 of structures created from the LNP depends on the value of PST.
11171 1. If PST is NULL, then this procedure uses the data from the program
11172 to create all necessary symbol tables, and their linetables.
11174 2. If PST is not NULL, this procedure reads the program to determine
11175 the list of files included by the unit represented by PST, and
11176 builds all the associated partial symbol tables.
11178 COMP_DIR is the compilation directory (DW_AT_comp_dir) or NULL if unknown.
11179 It is used for relative paths in the line table.
11180 NOTE: When processing partial symtabs (pst != NULL),
11181 comp_dir == pst->dirname.
11183 NOTE: It is important that psymtabs have the same file name (via strcmp)
11184 as the corresponding symtab. Since COMP_DIR is not used in the name of the
11185 symtab we don't use it in the name of the psymtabs we create.
11186 E.g. expand_line_sal requires this when finding psymtabs to expand.
11187 A good testcase for this is mb-inline.exp. */
11190 dwarf_decode_lines (struct line_header *lh, const char *comp_dir, bfd *abfd,
11191 struct dwarf2_cu *cu, struct partial_symtab *pst)
11193 gdb_byte *line_ptr, *extended_end;
11194 gdb_byte *line_end;
11195 unsigned int bytes_read, extended_len;
11196 unsigned char op_code, extended_op, adj_opcode;
11197 CORE_ADDR baseaddr;
11198 struct objfile *objfile = cu->objfile;
11199 struct gdbarch *gdbarch = get_objfile_arch (objfile);
11200 const int decode_for_pst_p = (pst != NULL);
11201 struct subfile *last_subfile = NULL, *first_subfile = current_subfile;
11202 void (*p_record_line) (struct subfile *subfile, int line, CORE_ADDR pc)
11205 baseaddr = ANOFFSET (objfile->section_offsets, SECT_OFF_TEXT (objfile));
11207 line_ptr = lh->statement_program_start;
11208 line_end = lh->statement_program_end;
11210 /* Read the statement sequences until there's nothing left. */
11211 while (line_ptr < line_end)
11213 /* state machine registers */
11214 CORE_ADDR address = 0;
11215 unsigned int file = 1;
11216 unsigned int line = 1;
11217 unsigned int column = 0;
11218 int is_stmt = lh->default_is_stmt;
11219 int basic_block = 0;
11220 int end_sequence = 0;
11222 unsigned char op_index = 0;
11224 if (!decode_for_pst_p && lh->num_file_names >= file)
11226 /* Start a subfile for the current file of the state machine. */
11227 /* lh->include_dirs and lh->file_names are 0-based, but the
11228 directory and file name numbers in the statement program
11230 struct file_entry *fe = &lh->file_names[file - 1];
11234 dir = lh->include_dirs[fe->dir_index - 1];
11236 dwarf2_start_subfile (fe->name, dir, comp_dir);
11239 /* Decode the table. */
11240 while (!end_sequence)
11242 op_code = read_1_byte (abfd, line_ptr);
11244 if (line_ptr > line_end)
11246 dwarf2_debug_line_missing_end_sequence_complaint ();
11250 if (op_code >= lh->opcode_base)
11252 /* Special operand. */
11253 adj_opcode = op_code - lh->opcode_base;
11254 address += (((op_index + (adj_opcode / lh->line_range))
11255 / lh->maximum_ops_per_instruction)
11256 * lh->minimum_instruction_length);
11257 op_index = ((op_index + (adj_opcode / lh->line_range))
11258 % lh->maximum_ops_per_instruction);
11259 line += lh->line_base + (adj_opcode % lh->line_range);
11260 if (lh->num_file_names < file || file == 0)
11261 dwarf2_debug_line_missing_file_complaint ();
11262 /* For now we ignore lines not starting on an
11263 instruction boundary. */
11264 else if (op_index == 0)
11266 lh->file_names[file - 1].included_p = 1;
11267 if (!decode_for_pst_p && is_stmt)
11269 if (last_subfile != current_subfile)
11271 addr = gdbarch_addr_bits_remove (gdbarch, address);
11273 (*p_record_line) (last_subfile, 0, addr);
11274 last_subfile = current_subfile;
11276 /* Append row to matrix using current values. */
11277 addr = check_cu_functions (address, cu);
11278 addr = gdbarch_addr_bits_remove (gdbarch, addr);
11279 (*p_record_line) (current_subfile, line, addr);
11284 else switch (op_code)
11286 case DW_LNS_extended_op:
11287 extended_len = read_unsigned_leb128 (abfd, line_ptr,
11289 line_ptr += bytes_read;
11290 extended_end = line_ptr + extended_len;
11291 extended_op = read_1_byte (abfd, line_ptr);
11293 switch (extended_op)
11295 case DW_LNE_end_sequence:
11296 p_record_line = record_line;
11299 case DW_LNE_set_address:
11300 address = read_address (abfd, line_ptr, cu, &bytes_read);
11302 if (address == 0 && !dwarf2_per_objfile->has_section_at_zero)
11304 /* This line table is for a function which has been
11305 GCd by the linker. Ignore it. PR gdb/12528 */
11308 = line_ptr - dwarf2_per_objfile->line.buffer;
11310 complaint (&symfile_complaints,
11311 _(".debug_line address at offset 0x%lx is 0 "
11313 line_offset, cu->objfile->name);
11314 p_record_line = noop_record_line;
11318 line_ptr += bytes_read;
11319 address += baseaddr;
11321 case DW_LNE_define_file:
11324 unsigned int dir_index, mod_time, length;
11326 cur_file = read_direct_string (abfd, line_ptr,
11328 line_ptr += bytes_read;
11330 read_unsigned_leb128 (abfd, line_ptr, &bytes_read);
11331 line_ptr += bytes_read;
11333 read_unsigned_leb128 (abfd, line_ptr, &bytes_read);
11334 line_ptr += bytes_read;
11336 read_unsigned_leb128 (abfd, line_ptr, &bytes_read);
11337 line_ptr += bytes_read;
11338 add_file_name (lh, cur_file, dir_index, mod_time, length);
11341 case DW_LNE_set_discriminator:
11342 /* The discriminator is not interesting to the debugger;
11344 line_ptr = extended_end;
11347 complaint (&symfile_complaints,
11348 _("mangled .debug_line section"));
11351 /* Make sure that we parsed the extended op correctly. If e.g.
11352 we expected a different address size than the producer used,
11353 we may have read the wrong number of bytes. */
11354 if (line_ptr != extended_end)
11356 complaint (&symfile_complaints,
11357 _("mangled .debug_line section"));
11362 if (lh->num_file_names < file || file == 0)
11363 dwarf2_debug_line_missing_file_complaint ();
11366 lh->file_names[file - 1].included_p = 1;
11367 if (!decode_for_pst_p && is_stmt)
11369 if (last_subfile != current_subfile)
11371 addr = gdbarch_addr_bits_remove (gdbarch, address);
11373 (*p_record_line) (last_subfile, 0, addr);
11374 last_subfile = current_subfile;
11376 addr = check_cu_functions (address, cu);
11377 addr = gdbarch_addr_bits_remove (gdbarch, addr);
11378 (*p_record_line) (current_subfile, line, addr);
11383 case DW_LNS_advance_pc:
11386 = read_unsigned_leb128 (abfd, line_ptr, &bytes_read);
11388 address += (((op_index + adjust)
11389 / lh->maximum_ops_per_instruction)
11390 * lh->minimum_instruction_length);
11391 op_index = ((op_index + adjust)
11392 % lh->maximum_ops_per_instruction);
11393 line_ptr += bytes_read;
11396 case DW_LNS_advance_line:
11397 line += read_signed_leb128 (abfd, line_ptr, &bytes_read);
11398 line_ptr += bytes_read;
11400 case DW_LNS_set_file:
11402 /* The arrays lh->include_dirs and lh->file_names are
11403 0-based, but the directory and file name numbers in
11404 the statement program are 1-based. */
11405 struct file_entry *fe;
11408 file = read_unsigned_leb128 (abfd, line_ptr, &bytes_read);
11409 line_ptr += bytes_read;
11410 if (lh->num_file_names < file || file == 0)
11411 dwarf2_debug_line_missing_file_complaint ();
11414 fe = &lh->file_names[file - 1];
11416 dir = lh->include_dirs[fe->dir_index - 1];
11417 if (!decode_for_pst_p)
11419 last_subfile = current_subfile;
11420 dwarf2_start_subfile (fe->name, dir, comp_dir);
11425 case DW_LNS_set_column:
11426 column = read_unsigned_leb128 (abfd, line_ptr, &bytes_read);
11427 line_ptr += bytes_read;
11429 case DW_LNS_negate_stmt:
11430 is_stmt = (!is_stmt);
11432 case DW_LNS_set_basic_block:
11435 /* Add to the address register of the state machine the
11436 address increment value corresponding to special opcode
11437 255. I.e., this value is scaled by the minimum
11438 instruction length since special opcode 255 would have
11439 scaled the increment. */
11440 case DW_LNS_const_add_pc:
11442 CORE_ADDR adjust = (255 - lh->opcode_base) / lh->line_range;
11444 address += (((op_index + adjust)
11445 / lh->maximum_ops_per_instruction)
11446 * lh->minimum_instruction_length);
11447 op_index = ((op_index + adjust)
11448 % lh->maximum_ops_per_instruction);
11451 case DW_LNS_fixed_advance_pc:
11452 address += read_2_bytes (abfd, line_ptr);
11458 /* Unknown standard opcode, ignore it. */
11461 for (i = 0; i < lh->standard_opcode_lengths[op_code]; i++)
11463 (void) read_unsigned_leb128 (abfd, line_ptr, &bytes_read);
11464 line_ptr += bytes_read;
11469 if (lh->num_file_names < file || file == 0)
11470 dwarf2_debug_line_missing_file_complaint ();
11473 lh->file_names[file - 1].included_p = 1;
11474 if (!decode_for_pst_p)
11476 addr = gdbarch_addr_bits_remove (gdbarch, address);
11477 (*p_record_line) (current_subfile, 0, addr);
11482 if (decode_for_pst_p)
11486 /* Now that we're done scanning the Line Header Program, we can
11487 create the psymtab of each included file. */
11488 for (file_index = 0; file_index < lh->num_file_names; file_index++)
11489 if (lh->file_names[file_index].included_p == 1)
11491 char *include_name =
11492 psymtab_include_file_name (lh, file_index, pst, comp_dir);
11493 if (include_name != NULL)
11494 dwarf2_create_include_psymtab (include_name, pst, objfile);
11499 /* Make sure a symtab is created for every file, even files
11500 which contain only variables (i.e. no code with associated
11504 struct file_entry *fe;
11506 for (i = 0; i < lh->num_file_names; i++)
11510 fe = &lh->file_names[i];
11512 dir = lh->include_dirs[fe->dir_index - 1];
11513 dwarf2_start_subfile (fe->name, dir, comp_dir);
11515 /* Skip the main file; we don't need it, and it must be
11516 allocated last, so that it will show up before the
11517 non-primary symtabs in the objfile's symtab list. */
11518 if (current_subfile == first_subfile)
11521 if (current_subfile->symtab == NULL)
11522 current_subfile->symtab = allocate_symtab (current_subfile->name,
11524 fe->symtab = current_subfile->symtab;
11529 /* Start a subfile for DWARF. FILENAME is the name of the file and
11530 DIRNAME the name of the source directory which contains FILENAME
11531 or NULL if not known. COMP_DIR is the compilation directory for the
11532 linetable's compilation unit or NULL if not known.
11533 This routine tries to keep line numbers from identical absolute and
11534 relative file names in a common subfile.
11536 Using the `list' example from the GDB testsuite, which resides in
11537 /srcdir and compiling it with Irix6.2 cc in /compdir using a filename
11538 of /srcdir/list0.c yields the following debugging information for list0.c:
11540 DW_AT_name: /srcdir/list0.c
11541 DW_AT_comp_dir: /compdir
11542 files.files[0].name: list0.h
11543 files.files[0].dir: /srcdir
11544 files.files[1].name: list0.c
11545 files.files[1].dir: /srcdir
11547 The line number information for list0.c has to end up in a single
11548 subfile, so that `break /srcdir/list0.c:1' works as expected.
11549 start_subfile will ensure that this happens provided that we pass the
11550 concatenation of files.files[1].dir and files.files[1].name as the
11554 dwarf2_start_subfile (char *filename, const char *dirname,
11555 const char *comp_dir)
11559 /* While reading the DIEs, we call start_symtab(DW_AT_name, DW_AT_comp_dir).
11560 `start_symtab' will always pass the contents of DW_AT_comp_dir as
11561 second argument to start_subfile. To be consistent, we do the
11562 same here. In order not to lose the line information directory,
11563 we concatenate it to the filename when it makes sense.
11564 Note that the Dwarf3 standard says (speaking of filenames in line
11565 information): ``The directory index is ignored for file names
11566 that represent full path names''. Thus ignoring dirname in the
11567 `else' branch below isn't an issue. */
11569 if (!IS_ABSOLUTE_PATH (filename) && dirname != NULL)
11570 fullname = concat (dirname, SLASH_STRING, filename, (char *)NULL);
11572 fullname = filename;
11574 start_subfile (fullname, comp_dir);
11576 if (fullname != filename)
11581 var_decode_location (struct attribute *attr, struct symbol *sym,
11582 struct dwarf2_cu *cu)
11584 struct objfile *objfile = cu->objfile;
11585 struct comp_unit_head *cu_header = &cu->header;
11587 /* NOTE drow/2003-01-30: There used to be a comment and some special
11588 code here to turn a symbol with DW_AT_external and a
11589 SYMBOL_VALUE_ADDRESS of 0 into a LOC_UNRESOLVED symbol. This was
11590 necessary for platforms (maybe Alpha, certainly PowerPC GNU/Linux
11591 with some versions of binutils) where shared libraries could have
11592 relocations against symbols in their debug information - the
11593 minimal symbol would have the right address, but the debug info
11594 would not. It's no longer necessary, because we will explicitly
11595 apply relocations when we read in the debug information now. */
11597 /* A DW_AT_location attribute with no contents indicates that a
11598 variable has been optimized away. */
11599 if (attr_form_is_block (attr) && DW_BLOCK (attr)->size == 0)
11601 SYMBOL_CLASS (sym) = LOC_OPTIMIZED_OUT;
11605 /* Handle one degenerate form of location expression specially, to
11606 preserve GDB's previous behavior when section offsets are
11607 specified. If this is just a DW_OP_addr then mark this symbol
11610 if (attr_form_is_block (attr)
11611 && DW_BLOCK (attr)->size == 1 + cu_header->addr_size
11612 && DW_BLOCK (attr)->data[0] == DW_OP_addr)
11614 unsigned int dummy;
11616 SYMBOL_VALUE_ADDRESS (sym) =
11617 read_address (objfile->obfd, DW_BLOCK (attr)->data + 1, cu, &dummy);
11618 SYMBOL_CLASS (sym) = LOC_STATIC;
11619 fixup_symbol_section (sym, objfile);
11620 SYMBOL_VALUE_ADDRESS (sym) += ANOFFSET (objfile->section_offsets,
11621 SYMBOL_SECTION (sym));
11625 /* NOTE drow/2002-01-30: It might be worthwhile to have a static
11626 expression evaluator, and use LOC_COMPUTED only when necessary
11627 (i.e. when the value of a register or memory location is
11628 referenced, or a thread-local block, etc.). Then again, it might
11629 not be worthwhile. I'm assuming that it isn't unless performance
11630 or memory numbers show me otherwise. */
11632 dwarf2_symbol_mark_computed (attr, sym, cu);
11633 SYMBOL_CLASS (sym) = LOC_COMPUTED;
11635 if (SYMBOL_COMPUTED_OPS (sym) == &dwarf2_loclist_funcs)
11636 cu->has_loclist = 1;
11639 /* Given a pointer to a DWARF information entry, figure out if we need
11640 to make a symbol table entry for it, and if so, create a new entry
11641 and return a pointer to it.
11642 If TYPE is NULL, determine symbol type from the die, otherwise
11643 used the passed type.
11644 If SPACE is not NULL, use it to hold the new symbol. If it is
11645 NULL, allocate a new symbol on the objfile's obstack. */
11647 static struct symbol *
11648 new_symbol_full (struct die_info *die, struct type *type, struct dwarf2_cu *cu,
11649 struct symbol *space)
11651 struct objfile *objfile = cu->objfile;
11652 struct symbol *sym = NULL;
11654 struct attribute *attr = NULL;
11655 struct attribute *attr2 = NULL;
11656 CORE_ADDR baseaddr;
11657 struct pending **list_to_add = NULL;
11659 int inlined_func = (die->tag == DW_TAG_inlined_subroutine);
11661 baseaddr = ANOFFSET (objfile->section_offsets, SECT_OFF_TEXT (objfile));
11663 name = dwarf2_name (die, cu);
11666 const char *linkagename;
11667 int suppress_add = 0;
11672 sym = OBSTACK_ZALLOC (&objfile->objfile_obstack, struct symbol);
11673 OBJSTAT (objfile, n_syms++);
11675 /* Cache this symbol's name and the name's demangled form (if any). */
11676 SYMBOL_SET_LANGUAGE (sym, cu->language);
11677 linkagename = dwarf2_physname (name, die, cu);
11678 SYMBOL_SET_NAMES (sym, linkagename, strlen (linkagename), 0, objfile);
11680 /* Fortran does not have mangling standard and the mangling does differ
11681 between gfortran, iFort etc. */
11682 if (cu->language == language_fortran
11683 && symbol_get_demangled_name (&(sym->ginfo)) == NULL)
11684 symbol_set_demangled_name (&(sym->ginfo),
11685 (char *) dwarf2_full_name (name, die, cu),
11688 /* Default assumptions.
11689 Use the passed type or decode it from the die. */
11690 SYMBOL_DOMAIN (sym) = VAR_DOMAIN;
11691 SYMBOL_CLASS (sym) = LOC_OPTIMIZED_OUT;
11693 SYMBOL_TYPE (sym) = type;
11695 SYMBOL_TYPE (sym) = die_type (die, cu);
11696 attr = dwarf2_attr (die,
11697 inlined_func ? DW_AT_call_line : DW_AT_decl_line,
11701 SYMBOL_LINE (sym) = DW_UNSND (attr);
11704 attr = dwarf2_attr (die,
11705 inlined_func ? DW_AT_call_file : DW_AT_decl_file,
11709 int file_index = DW_UNSND (attr);
11711 if (cu->line_header == NULL
11712 || file_index > cu->line_header->num_file_names)
11713 complaint (&symfile_complaints,
11714 _("file index out of range"));
11715 else if (file_index > 0)
11717 struct file_entry *fe;
11719 fe = &cu->line_header->file_names[file_index - 1];
11720 SYMBOL_SYMTAB (sym) = fe->symtab;
11727 attr = dwarf2_attr (die, DW_AT_low_pc, cu);
11730 SYMBOL_VALUE_ADDRESS (sym) = DW_ADDR (attr) + baseaddr;
11732 SYMBOL_TYPE (sym) = objfile_type (objfile)->builtin_core_addr;
11733 SYMBOL_DOMAIN (sym) = LABEL_DOMAIN;
11734 SYMBOL_CLASS (sym) = LOC_LABEL;
11735 add_symbol_to_list (sym, cu->list_in_scope);
11737 case DW_TAG_subprogram:
11738 /* SYMBOL_BLOCK_VALUE (sym) will be filled in later by
11740 SYMBOL_CLASS (sym) = LOC_BLOCK;
11741 attr2 = dwarf2_attr (die, DW_AT_external, cu);
11742 if ((attr2 && (DW_UNSND (attr2) != 0))
11743 || cu->language == language_ada)
11745 /* Subprograms marked external are stored as a global symbol.
11746 Ada subprograms, whether marked external or not, are always
11747 stored as a global symbol, because we want to be able to
11748 access them globally. For instance, we want to be able
11749 to break on a nested subprogram without having to
11750 specify the context. */
11751 list_to_add = &global_symbols;
11755 list_to_add = cu->list_in_scope;
11758 case DW_TAG_inlined_subroutine:
11759 /* SYMBOL_BLOCK_VALUE (sym) will be filled in later by
11761 SYMBOL_CLASS (sym) = LOC_BLOCK;
11762 SYMBOL_INLINED (sym) = 1;
11763 /* Do not add the symbol to any lists. It will be found via
11764 BLOCK_FUNCTION from the blockvector. */
11766 case DW_TAG_template_value_param:
11768 /* Fall through. */
11769 case DW_TAG_constant:
11770 case DW_TAG_variable:
11771 case DW_TAG_member:
11772 /* Compilation with minimal debug info may result in
11773 variables with missing type entries. Change the
11774 misleading `void' type to something sensible. */
11775 if (TYPE_CODE (SYMBOL_TYPE (sym)) == TYPE_CODE_VOID)
11777 = objfile_type (objfile)->nodebug_data_symbol;
11779 attr = dwarf2_attr (die, DW_AT_const_value, cu);
11780 /* In the case of DW_TAG_member, we should only be called for
11781 static const members. */
11782 if (die->tag == DW_TAG_member)
11784 /* dwarf2_add_field uses die_is_declaration,
11785 so we do the same. */
11786 gdb_assert (die_is_declaration (die, cu));
11791 dwarf2_const_value (attr, sym, cu);
11792 attr2 = dwarf2_attr (die, DW_AT_external, cu);
11795 if (attr2 && (DW_UNSND (attr2) != 0))
11796 list_to_add = &global_symbols;
11798 list_to_add = cu->list_in_scope;
11802 attr = dwarf2_attr (die, DW_AT_location, cu);
11805 var_decode_location (attr, sym, cu);
11806 attr2 = dwarf2_attr (die, DW_AT_external, cu);
11807 if (SYMBOL_CLASS (sym) == LOC_STATIC
11808 && SYMBOL_VALUE_ADDRESS (sym) == 0
11809 && !dwarf2_per_objfile->has_section_at_zero)
11811 /* When a static variable is eliminated by the linker,
11812 the corresponding debug information is not stripped
11813 out, but the variable address is set to null;
11814 do not add such variables into symbol table. */
11816 else if (attr2 && (DW_UNSND (attr2) != 0))
11818 /* Workaround gfortran PR debug/40040 - it uses
11819 DW_AT_location for variables in -fPIC libraries which may
11820 get overriden by other libraries/executable and get
11821 a different address. Resolve it by the minimal symbol
11822 which may come from inferior's executable using copy
11823 relocation. Make this workaround only for gfortran as for
11824 other compilers GDB cannot guess the minimal symbol
11825 Fortran mangling kind. */
11826 if (cu->language == language_fortran && die->parent
11827 && die->parent->tag == DW_TAG_module
11829 && strncmp (cu->producer, "GNU Fortran ", 12) == 0)
11830 SYMBOL_CLASS (sym) = LOC_UNRESOLVED;
11832 /* A variable with DW_AT_external is never static,
11833 but it may be block-scoped. */
11834 list_to_add = (cu->list_in_scope == &file_symbols
11835 ? &global_symbols : cu->list_in_scope);
11838 list_to_add = cu->list_in_scope;
11842 /* We do not know the address of this symbol.
11843 If it is an external symbol and we have type information
11844 for it, enter the symbol as a LOC_UNRESOLVED symbol.
11845 The address of the variable will then be determined from
11846 the minimal symbol table whenever the variable is
11848 attr2 = dwarf2_attr (die, DW_AT_external, cu);
11849 if (attr2 && (DW_UNSND (attr2) != 0)
11850 && dwarf2_attr (die, DW_AT_type, cu) != NULL)
11852 /* A variable with DW_AT_external is never static, but it
11853 may be block-scoped. */
11854 list_to_add = (cu->list_in_scope == &file_symbols
11855 ? &global_symbols : cu->list_in_scope);
11857 SYMBOL_CLASS (sym) = LOC_UNRESOLVED;
11859 else if (!die_is_declaration (die, cu))
11861 /* Use the default LOC_OPTIMIZED_OUT class. */
11862 gdb_assert (SYMBOL_CLASS (sym) == LOC_OPTIMIZED_OUT);
11864 list_to_add = cu->list_in_scope;
11868 case DW_TAG_formal_parameter:
11869 /* If we are inside a function, mark this as an argument. If
11870 not, we might be looking at an argument to an inlined function
11871 when we do not have enough information to show inlined frames;
11872 pretend it's a local variable in that case so that the user can
11874 if (context_stack_depth > 0
11875 && context_stack[context_stack_depth - 1].name != NULL)
11876 SYMBOL_IS_ARGUMENT (sym) = 1;
11877 attr = dwarf2_attr (die, DW_AT_location, cu);
11880 var_decode_location (attr, sym, cu);
11882 attr = dwarf2_attr (die, DW_AT_const_value, cu);
11885 dwarf2_const_value (attr, sym, cu);
11888 list_to_add = cu->list_in_scope;
11890 case DW_TAG_unspecified_parameters:
11891 /* From varargs functions; gdb doesn't seem to have any
11892 interest in this information, so just ignore it for now.
11895 case DW_TAG_template_type_param:
11897 /* Fall through. */
11898 case DW_TAG_class_type:
11899 case DW_TAG_interface_type:
11900 case DW_TAG_structure_type:
11901 case DW_TAG_union_type:
11902 case DW_TAG_set_type:
11903 case DW_TAG_enumeration_type:
11904 SYMBOL_CLASS (sym) = LOC_TYPEDEF;
11905 SYMBOL_DOMAIN (sym) = STRUCT_DOMAIN;
11908 /* NOTE: carlton/2003-11-10: C++ and Java class symbols shouldn't
11909 really ever be static objects: otherwise, if you try
11910 to, say, break of a class's method and you're in a file
11911 which doesn't mention that class, it won't work unless
11912 the check for all static symbols in lookup_symbol_aux
11913 saves you. See the OtherFileClass tests in
11914 gdb.c++/namespace.exp. */
11918 list_to_add = (cu->list_in_scope == &file_symbols
11919 && (cu->language == language_cplus
11920 || cu->language == language_java)
11921 ? &global_symbols : cu->list_in_scope);
11923 /* The semantics of C++ state that "struct foo {
11924 ... }" also defines a typedef for "foo". A Java
11925 class declaration also defines a typedef for the
11927 if (cu->language == language_cplus
11928 || cu->language == language_java
11929 || cu->language == language_ada)
11931 /* The symbol's name is already allocated along
11932 with this objfile, so we don't need to
11933 duplicate it for the type. */
11934 if (TYPE_NAME (SYMBOL_TYPE (sym)) == 0)
11935 TYPE_NAME (SYMBOL_TYPE (sym)) = SYMBOL_SEARCH_NAME (sym);
11940 case DW_TAG_typedef:
11941 SYMBOL_CLASS (sym) = LOC_TYPEDEF;
11942 SYMBOL_DOMAIN (sym) = VAR_DOMAIN;
11943 list_to_add = cu->list_in_scope;
11945 case DW_TAG_base_type:
11946 case DW_TAG_subrange_type:
11947 SYMBOL_CLASS (sym) = LOC_TYPEDEF;
11948 SYMBOL_DOMAIN (sym) = VAR_DOMAIN;
11949 list_to_add = cu->list_in_scope;
11951 case DW_TAG_enumerator:
11952 attr = dwarf2_attr (die, DW_AT_const_value, cu);
11955 dwarf2_const_value (attr, sym, cu);
11958 /* NOTE: carlton/2003-11-10: See comment above in the
11959 DW_TAG_class_type, etc. block. */
11961 list_to_add = (cu->list_in_scope == &file_symbols
11962 && (cu->language == language_cplus
11963 || cu->language == language_java)
11964 ? &global_symbols : cu->list_in_scope);
11967 case DW_TAG_namespace:
11968 SYMBOL_CLASS (sym) = LOC_TYPEDEF;
11969 list_to_add = &global_symbols;
11972 /* Not a tag we recognize. Hopefully we aren't processing
11973 trash data, but since we must specifically ignore things
11974 we don't recognize, there is nothing else we should do at
11976 complaint (&symfile_complaints, _("unsupported tag: '%s'"),
11977 dwarf_tag_name (die->tag));
11983 sym->hash_next = objfile->template_symbols;
11984 objfile->template_symbols = sym;
11985 list_to_add = NULL;
11988 if (list_to_add != NULL)
11989 add_symbol_to_list (sym, list_to_add);
11991 /* For the benefit of old versions of GCC, check for anonymous
11992 namespaces based on the demangled name. */
11993 if (!processing_has_namespace_info
11994 && cu->language == language_cplus)
11995 cp_scan_for_anonymous_namespaces (sym);
12000 /* A wrapper for new_symbol_full that always allocates a new symbol. */
12002 static struct symbol *
12003 new_symbol (struct die_info *die, struct type *type, struct dwarf2_cu *cu)
12005 return new_symbol_full (die, type, cu, NULL);
12008 /* Given an attr with a DW_FORM_dataN value in host byte order,
12009 zero-extend it as appropriate for the symbol's type. The DWARF
12010 standard (v4) is not entirely clear about the meaning of using
12011 DW_FORM_dataN for a constant with a signed type, where the type is
12012 wider than the data. The conclusion of a discussion on the DWARF
12013 list was that this is unspecified. We choose to always zero-extend
12014 because that is the interpretation long in use by GCC. */
12017 dwarf2_const_value_data (struct attribute *attr, struct type *type,
12018 const char *name, struct obstack *obstack,
12019 struct dwarf2_cu *cu, long *value, int bits)
12021 struct objfile *objfile = cu->objfile;
12022 enum bfd_endian byte_order = bfd_big_endian (objfile->obfd) ?
12023 BFD_ENDIAN_BIG : BFD_ENDIAN_LITTLE;
12024 LONGEST l = DW_UNSND (attr);
12026 if (bits < sizeof (*value) * 8)
12028 l &= ((LONGEST) 1 << bits) - 1;
12031 else if (bits == sizeof (*value) * 8)
12035 gdb_byte *bytes = obstack_alloc (obstack, bits / 8);
12036 store_unsigned_integer (bytes, bits / 8, byte_order, l);
12043 /* Read a constant value from an attribute. Either set *VALUE, or if
12044 the value does not fit in *VALUE, set *BYTES - either already
12045 allocated on the objfile obstack, or newly allocated on OBSTACK,
12046 or, set *BATON, if we translated the constant to a location
12050 dwarf2_const_value_attr (struct attribute *attr, struct type *type,
12051 const char *name, struct obstack *obstack,
12052 struct dwarf2_cu *cu,
12053 long *value, gdb_byte **bytes,
12054 struct dwarf2_locexpr_baton **baton)
12056 struct objfile *objfile = cu->objfile;
12057 struct comp_unit_head *cu_header = &cu->header;
12058 struct dwarf_block *blk;
12059 enum bfd_endian byte_order = (bfd_big_endian (objfile->obfd) ?
12060 BFD_ENDIAN_BIG : BFD_ENDIAN_LITTLE);
12066 switch (attr->form)
12072 if (TYPE_LENGTH (type) != cu_header->addr_size)
12073 dwarf2_const_value_length_mismatch_complaint (name,
12074 cu_header->addr_size,
12075 TYPE_LENGTH (type));
12076 /* Symbols of this form are reasonably rare, so we just
12077 piggyback on the existing location code rather than writing
12078 a new implementation of symbol_computed_ops. */
12079 *baton = obstack_alloc (&objfile->objfile_obstack,
12080 sizeof (struct dwarf2_locexpr_baton));
12081 (*baton)->per_cu = cu->per_cu;
12082 gdb_assert ((*baton)->per_cu);
12084 (*baton)->size = 2 + cu_header->addr_size;
12085 data = obstack_alloc (&objfile->objfile_obstack, (*baton)->size);
12086 (*baton)->data = data;
12088 data[0] = DW_OP_addr;
12089 store_unsigned_integer (&data[1], cu_header->addr_size,
12090 byte_order, DW_ADDR (attr));
12091 data[cu_header->addr_size + 1] = DW_OP_stack_value;
12094 case DW_FORM_string:
12096 /* DW_STRING is already allocated on the objfile obstack, point
12098 *bytes = (gdb_byte *) DW_STRING (attr);
12100 case DW_FORM_block1:
12101 case DW_FORM_block2:
12102 case DW_FORM_block4:
12103 case DW_FORM_block:
12104 case DW_FORM_exprloc:
12105 blk = DW_BLOCK (attr);
12106 if (TYPE_LENGTH (type) != blk->size)
12107 dwarf2_const_value_length_mismatch_complaint (name, blk->size,
12108 TYPE_LENGTH (type));
12109 *bytes = blk->data;
12112 /* The DW_AT_const_value attributes are supposed to carry the
12113 symbol's value "represented as it would be on the target
12114 architecture." By the time we get here, it's already been
12115 converted to host endianness, so we just need to sign- or
12116 zero-extend it as appropriate. */
12117 case DW_FORM_data1:
12118 *bytes = dwarf2_const_value_data (attr, type, name,
12119 obstack, cu, value, 8);
12121 case DW_FORM_data2:
12122 *bytes = dwarf2_const_value_data (attr, type, name,
12123 obstack, cu, value, 16);
12125 case DW_FORM_data4:
12126 *bytes = dwarf2_const_value_data (attr, type, name,
12127 obstack, cu, value, 32);
12129 case DW_FORM_data8:
12130 *bytes = dwarf2_const_value_data (attr, type, name,
12131 obstack, cu, value, 64);
12134 case DW_FORM_sdata:
12135 *value = DW_SND (attr);
12138 case DW_FORM_udata:
12139 *value = DW_UNSND (attr);
12143 complaint (&symfile_complaints,
12144 _("unsupported const value attribute form: '%s'"),
12145 dwarf_form_name (attr->form));
12152 /* Copy constant value from an attribute to a symbol. */
12155 dwarf2_const_value (struct attribute *attr, struct symbol *sym,
12156 struct dwarf2_cu *cu)
12158 struct objfile *objfile = cu->objfile;
12159 struct comp_unit_head *cu_header = &cu->header;
12162 struct dwarf2_locexpr_baton *baton;
12164 dwarf2_const_value_attr (attr, SYMBOL_TYPE (sym),
12165 SYMBOL_PRINT_NAME (sym),
12166 &objfile->objfile_obstack, cu,
12167 &value, &bytes, &baton);
12171 SYMBOL_COMPUTED_OPS (sym) = &dwarf2_locexpr_funcs;
12172 SYMBOL_LOCATION_BATON (sym) = baton;
12173 SYMBOL_CLASS (sym) = LOC_COMPUTED;
12175 else if (bytes != NULL)
12177 SYMBOL_VALUE_BYTES (sym) = bytes;
12178 SYMBOL_CLASS (sym) = LOC_CONST_BYTES;
12182 SYMBOL_VALUE (sym) = value;
12183 SYMBOL_CLASS (sym) = LOC_CONST;
12187 /* Return the type of the die in question using its DW_AT_type attribute. */
12189 static struct type *
12190 die_type (struct die_info *die, struct dwarf2_cu *cu)
12192 struct attribute *type_attr;
12194 type_attr = dwarf2_attr (die, DW_AT_type, cu);
12197 /* A missing DW_AT_type represents a void type. */
12198 return objfile_type (cu->objfile)->builtin_void;
12201 return lookup_die_type (die, type_attr, cu);
12204 /* True iff CU's producer generates GNAT Ada auxiliary information
12205 that allows to find parallel types through that information instead
12206 of having to do expensive parallel lookups by type name. */
12209 need_gnat_info (struct dwarf2_cu *cu)
12211 /* FIXME: brobecker/2010-10-12: As of now, only the AdaCore version
12212 of GNAT produces this auxiliary information, without any indication
12213 that it is produced. Part of enhancing the FSF version of GNAT
12214 to produce that information will be to put in place an indicator
12215 that we can use in order to determine whether the descriptive type
12216 info is available or not. One suggestion that has been made is
12217 to use a new attribute, attached to the CU die. For now, assume
12218 that the descriptive type info is not available. */
12222 /* Return the auxiliary type of the die in question using its
12223 DW_AT_GNAT_descriptive_type attribute. Returns NULL if the
12224 attribute is not present. */
12226 static struct type *
12227 die_descriptive_type (struct die_info *die, struct dwarf2_cu *cu)
12229 struct attribute *type_attr;
12231 type_attr = dwarf2_attr (die, DW_AT_GNAT_descriptive_type, cu);
12235 return lookup_die_type (die, type_attr, cu);
12238 /* If DIE has a descriptive_type attribute, then set the TYPE's
12239 descriptive type accordingly. */
12242 set_descriptive_type (struct type *type, struct die_info *die,
12243 struct dwarf2_cu *cu)
12245 struct type *descriptive_type = die_descriptive_type (die, cu);
12247 if (descriptive_type)
12249 ALLOCATE_GNAT_AUX_TYPE (type);
12250 TYPE_DESCRIPTIVE_TYPE (type) = descriptive_type;
12254 /* Return the containing type of the die in question using its
12255 DW_AT_containing_type attribute. */
12257 static struct type *
12258 die_containing_type (struct die_info *die, struct dwarf2_cu *cu)
12260 struct attribute *type_attr;
12262 type_attr = dwarf2_attr (die, DW_AT_containing_type, cu);
12264 error (_("Dwarf Error: Problem turning containing type into gdb type "
12265 "[in module %s]"), cu->objfile->name);
12267 return lookup_die_type (die, type_attr, cu);
12270 /* Look up the type of DIE in CU using its type attribute ATTR.
12271 If there is no type substitute an error marker. */
12273 static struct type *
12274 lookup_die_type (struct die_info *die, struct attribute *attr,
12275 struct dwarf2_cu *cu)
12277 struct type *this_type;
12279 /* First see if we have it cached. */
12281 if (is_ref_attr (attr))
12283 unsigned int offset = dwarf2_get_ref_die_offset (attr);
12285 this_type = get_die_type_at_offset (offset, cu->per_cu);
12287 else if (attr->form == DW_FORM_ref_sig8)
12289 struct signatured_type *sig_type = DW_SIGNATURED_TYPE (attr);
12290 struct dwarf2_cu *sig_cu;
12291 unsigned int offset;
12293 /* sig_type will be NULL if the signatured type is missing from
12295 if (sig_type == NULL)
12296 error (_("Dwarf Error: Cannot find signatured DIE referenced from DIE "
12297 "at 0x%x [in module %s]"),
12298 die->offset, cu->objfile->name);
12300 gdb_assert (sig_type->per_cu.debug_type_section);
12301 offset = sig_type->per_cu.offset + sig_type->type_offset;
12302 this_type = get_die_type_at_offset (offset, &sig_type->per_cu);
12306 dump_die_for_error (die);
12307 error (_("Dwarf Error: Bad type attribute %s [in module %s]"),
12308 dwarf_attr_name (attr->name), cu->objfile->name);
12311 /* If not cached we need to read it in. */
12313 if (this_type == NULL)
12315 struct die_info *type_die;
12316 struct dwarf2_cu *type_cu = cu;
12318 type_die = follow_die_ref_or_sig (die, attr, &type_cu);
12319 /* If the type is cached, we should have found it above. */
12320 gdb_assert (get_die_type (type_die, type_cu) == NULL);
12321 this_type = read_type_die_1 (type_die, type_cu);
12324 /* If we still don't have a type use an error marker. */
12326 if (this_type == NULL)
12328 char *message, *saved;
12330 /* read_type_die already issued a complaint. */
12331 message = xstrprintf (_("<unknown type in %s, CU 0x%x, DIE 0x%x>"),
12335 saved = obstack_copy0 (&cu->objfile->objfile_obstack,
12336 message, strlen (message));
12339 this_type = init_type (TYPE_CODE_ERROR, 0, 0, saved, cu->objfile);
12345 /* Return the type in DIE, CU.
12346 Returns NULL for invalid types.
12348 This first does a lookup in the appropriate type_hash table,
12349 and only reads the die in if necessary.
12351 NOTE: This can be called when reading in partial or full symbols. */
12353 static struct type *
12354 read_type_die (struct die_info *die, struct dwarf2_cu *cu)
12356 struct type *this_type;
12358 this_type = get_die_type (die, cu);
12362 return read_type_die_1 (die, cu);
12365 /* Read the type in DIE, CU.
12366 Returns NULL for invalid types. */
12368 static struct type *
12369 read_type_die_1 (struct die_info *die, struct dwarf2_cu *cu)
12371 struct type *this_type = NULL;
12375 case DW_TAG_class_type:
12376 case DW_TAG_interface_type:
12377 case DW_TAG_structure_type:
12378 case DW_TAG_union_type:
12379 this_type = read_structure_type (die, cu);
12381 case DW_TAG_enumeration_type:
12382 this_type = read_enumeration_type (die, cu);
12384 case DW_TAG_subprogram:
12385 case DW_TAG_subroutine_type:
12386 case DW_TAG_inlined_subroutine:
12387 this_type = read_subroutine_type (die, cu);
12389 case DW_TAG_array_type:
12390 this_type = read_array_type (die, cu);
12392 case DW_TAG_set_type:
12393 this_type = read_set_type (die, cu);
12395 case DW_TAG_pointer_type:
12396 this_type = read_tag_pointer_type (die, cu);
12398 case DW_TAG_ptr_to_member_type:
12399 this_type = read_tag_ptr_to_member_type (die, cu);
12401 case DW_TAG_reference_type:
12402 this_type = read_tag_reference_type (die, cu);
12404 case DW_TAG_const_type:
12405 this_type = read_tag_const_type (die, cu);
12407 case DW_TAG_volatile_type:
12408 this_type = read_tag_volatile_type (die, cu);
12410 case DW_TAG_string_type:
12411 this_type = read_tag_string_type (die, cu);
12413 case DW_TAG_typedef:
12414 this_type = read_typedef (die, cu);
12416 case DW_TAG_subrange_type:
12417 this_type = read_subrange_type (die, cu);
12419 case DW_TAG_base_type:
12420 this_type = read_base_type (die, cu);
12422 case DW_TAG_unspecified_type:
12423 this_type = read_unspecified_type (die, cu);
12425 case DW_TAG_namespace:
12426 this_type = read_namespace_type (die, cu);
12428 case DW_TAG_module:
12429 this_type = read_module_type (die, cu);
12432 complaint (&symfile_complaints,
12433 _("unexpected tag in read_type_die: '%s'"),
12434 dwarf_tag_name (die->tag));
12441 /* See if we can figure out if the class lives in a namespace. We do
12442 this by looking for a member function; its demangled name will
12443 contain namespace info, if there is any.
12444 Return the computed name or NULL.
12445 Space for the result is allocated on the objfile's obstack.
12446 This is the full-die version of guess_partial_die_structure_name.
12447 In this case we know DIE has no useful parent. */
12450 guess_full_die_structure_name (struct die_info *die, struct dwarf2_cu *cu)
12452 struct die_info *spec_die;
12453 struct dwarf2_cu *spec_cu;
12454 struct die_info *child;
12457 spec_die = die_specification (die, &spec_cu);
12458 if (spec_die != NULL)
12464 for (child = die->child;
12466 child = child->sibling)
12468 if (child->tag == DW_TAG_subprogram)
12470 struct attribute *attr;
12472 attr = dwarf2_attr (child, DW_AT_linkage_name, cu);
12474 attr = dwarf2_attr (child, DW_AT_MIPS_linkage_name, cu);
12478 = language_class_name_from_physname (cu->language_defn,
12482 if (actual_name != NULL)
12484 char *die_name = dwarf2_name (die, cu);
12486 if (die_name != NULL
12487 && strcmp (die_name, actual_name) != 0)
12489 /* Strip off the class name from the full name.
12490 We want the prefix. */
12491 int die_name_len = strlen (die_name);
12492 int actual_name_len = strlen (actual_name);
12494 /* Test for '::' as a sanity check. */
12495 if (actual_name_len > die_name_len + 2
12496 && actual_name[actual_name_len
12497 - die_name_len - 1] == ':')
12499 obsavestring (actual_name,
12500 actual_name_len - die_name_len - 2,
12501 &cu->objfile->objfile_obstack);
12504 xfree (actual_name);
12513 /* GCC might emit a nameless typedef that has a linkage name. Determine the
12514 prefix part in such case. See
12515 http://gcc.gnu.org/bugzilla/show_bug.cgi?id=47510. */
12518 anonymous_struct_prefix (struct die_info *die, struct dwarf2_cu *cu)
12520 struct attribute *attr;
12523 if (die->tag != DW_TAG_class_type && die->tag != DW_TAG_interface_type
12524 && die->tag != DW_TAG_structure_type && die->tag != DW_TAG_union_type)
12527 attr = dwarf2_attr (die, DW_AT_name, cu);
12528 if (attr != NULL && DW_STRING (attr) != NULL)
12531 attr = dwarf2_attr (die, DW_AT_linkage_name, cu);
12533 attr = dwarf2_attr (die, DW_AT_MIPS_linkage_name, cu);
12534 if (attr == NULL || DW_STRING (attr) == NULL)
12537 /* dwarf2_name had to be already called. */
12538 gdb_assert (DW_STRING_IS_CANONICAL (attr));
12540 /* Strip the base name, keep any leading namespaces/classes. */
12541 base = strrchr (DW_STRING (attr), ':');
12542 if (base == NULL || base == DW_STRING (attr) || base[-1] != ':')
12545 return obsavestring (DW_STRING (attr), &base[-1] - DW_STRING (attr),
12546 &cu->objfile->objfile_obstack);
12549 /* Return the name of the namespace/class that DIE is defined within,
12550 or "" if we can't tell. The caller should not xfree the result.
12552 For example, if we're within the method foo() in the following
12562 then determine_prefix on foo's die will return "N::C". */
12565 determine_prefix (struct die_info *die, struct dwarf2_cu *cu)
12567 struct die_info *parent, *spec_die;
12568 struct dwarf2_cu *spec_cu;
12569 struct type *parent_type;
12572 if (cu->language != language_cplus && cu->language != language_java
12573 && cu->language != language_fortran)
12576 retval = anonymous_struct_prefix (die, cu);
12580 /* We have to be careful in the presence of DW_AT_specification.
12581 For example, with GCC 3.4, given the code
12585 // Definition of N::foo.
12589 then we'll have a tree of DIEs like this:
12591 1: DW_TAG_compile_unit
12592 2: DW_TAG_namespace // N
12593 3: DW_TAG_subprogram // declaration of N::foo
12594 4: DW_TAG_subprogram // definition of N::foo
12595 DW_AT_specification // refers to die #3
12597 Thus, when processing die #4, we have to pretend that we're in
12598 the context of its DW_AT_specification, namely the contex of die
12601 spec_die = die_specification (die, &spec_cu);
12602 if (spec_die == NULL)
12603 parent = die->parent;
12606 parent = spec_die->parent;
12610 if (parent == NULL)
12612 else if (parent->building_fullname)
12615 const char *parent_name;
12617 /* It has been seen on RealView 2.2 built binaries,
12618 DW_TAG_template_type_param types actually _defined_ as
12619 children of the parent class:
12622 template class <class Enum> Class{};
12623 Class<enum E> class_e;
12625 1: DW_TAG_class_type (Class)
12626 2: DW_TAG_enumeration_type (E)
12627 3: DW_TAG_enumerator (enum1:0)
12628 3: DW_TAG_enumerator (enum2:1)
12630 2: DW_TAG_template_type_param
12631 DW_AT_type DW_FORM_ref_udata (E)
12633 Besides being broken debug info, it can put GDB into an
12634 infinite loop. Consider:
12636 When we're building the full name for Class<E>, we'll start
12637 at Class, and go look over its template type parameters,
12638 finding E. We'll then try to build the full name of E, and
12639 reach here. We're now trying to build the full name of E,
12640 and look over the parent DIE for containing scope. In the
12641 broken case, if we followed the parent DIE of E, we'd again
12642 find Class, and once again go look at its template type
12643 arguments, etc., etc. Simply don't consider such parent die
12644 as source-level parent of this die (it can't be, the language
12645 doesn't allow it), and break the loop here. */
12646 name = dwarf2_name (die, cu);
12647 parent_name = dwarf2_name (parent, cu);
12648 complaint (&symfile_complaints,
12649 _("template param type '%s' defined within parent '%s'"),
12650 name ? name : "<unknown>",
12651 parent_name ? parent_name : "<unknown>");
12655 switch (parent->tag)
12657 case DW_TAG_namespace:
12658 parent_type = read_type_die (parent, cu);
12659 /* GCC 4.0 and 4.1 had a bug (PR c++/28460) where they generated bogus
12660 DW_TAG_namespace DIEs with a name of "::" for the global namespace.
12661 Work around this problem here. */
12662 if (cu->language == language_cplus
12663 && strcmp (TYPE_TAG_NAME (parent_type), "::") == 0)
12665 /* We give a name to even anonymous namespaces. */
12666 return TYPE_TAG_NAME (parent_type);
12667 case DW_TAG_class_type:
12668 case DW_TAG_interface_type:
12669 case DW_TAG_structure_type:
12670 case DW_TAG_union_type:
12671 case DW_TAG_module:
12672 parent_type = read_type_die (parent, cu);
12673 if (TYPE_TAG_NAME (parent_type) != NULL)
12674 return TYPE_TAG_NAME (parent_type);
12676 /* An anonymous structure is only allowed non-static data
12677 members; no typedefs, no member functions, et cetera.
12678 So it does not need a prefix. */
12680 case DW_TAG_compile_unit:
12681 /* gcc-4.5 -gdwarf-4 can drop the enclosing namespace. Cope. */
12682 if (cu->language == language_cplus
12683 && !VEC_empty (dwarf2_section_info_def, dwarf2_per_objfile->types)
12684 && die->child != NULL
12685 && (die->tag == DW_TAG_class_type
12686 || die->tag == DW_TAG_structure_type
12687 || die->tag == DW_TAG_union_type))
12689 char *name = guess_full_die_structure_name (die, cu);
12695 return determine_prefix (parent, cu);
12699 /* Return a newly-allocated string formed by concatenating PREFIX and SUFFIX
12700 with appropriate separator. If PREFIX or SUFFIX is NULL or empty, then
12701 simply copy the SUFFIX or PREFIX, respectively. If OBS is non-null, perform
12702 an obconcat, otherwise allocate storage for the result. The CU argument is
12703 used to determine the language and hence, the appropriate separator. */
12705 #define MAX_SEP_LEN 7 /* strlen ("__") + strlen ("_MOD_") */
12708 typename_concat (struct obstack *obs, const char *prefix, const char *suffix,
12709 int physname, struct dwarf2_cu *cu)
12711 const char *lead = "";
12714 if (suffix == NULL || suffix[0] == '\0'
12715 || prefix == NULL || prefix[0] == '\0')
12717 else if (cu->language == language_java)
12719 else if (cu->language == language_fortran && physname)
12721 /* This is gfortran specific mangling. Normally DW_AT_linkage_name or
12722 DW_AT_MIPS_linkage_name is preferred and used instead. */
12730 if (prefix == NULL)
12732 if (suffix == NULL)
12738 = xmalloc (strlen (prefix) + MAX_SEP_LEN + strlen (suffix) + 1);
12740 strcpy (retval, lead);
12741 strcat (retval, prefix);
12742 strcat (retval, sep);
12743 strcat (retval, suffix);
12748 /* We have an obstack. */
12749 return obconcat (obs, lead, prefix, sep, suffix, (char *) NULL);
12753 /* Return sibling of die, NULL if no sibling. */
12755 static struct die_info *
12756 sibling_die (struct die_info *die)
12758 return die->sibling;
12761 /* Get name of a die, return NULL if not found. */
12764 dwarf2_canonicalize_name (char *name, struct dwarf2_cu *cu,
12765 struct obstack *obstack)
12767 if (name && cu->language == language_cplus)
12769 char *canon_name = cp_canonicalize_string (name);
12771 if (canon_name != NULL)
12773 if (strcmp (canon_name, name) != 0)
12774 name = obsavestring (canon_name, strlen (canon_name),
12776 xfree (canon_name);
12783 /* Get name of a die, return NULL if not found. */
12786 dwarf2_name (struct die_info *die, struct dwarf2_cu *cu)
12788 struct attribute *attr;
12790 attr = dwarf2_attr (die, DW_AT_name, cu);
12791 if ((!attr || !DW_STRING (attr))
12792 && die->tag != DW_TAG_class_type
12793 && die->tag != DW_TAG_interface_type
12794 && die->tag != DW_TAG_structure_type
12795 && die->tag != DW_TAG_union_type)
12800 case DW_TAG_compile_unit:
12801 /* Compilation units have a DW_AT_name that is a filename, not
12802 a source language identifier. */
12803 case DW_TAG_enumeration_type:
12804 case DW_TAG_enumerator:
12805 /* These tags always have simple identifiers already; no need
12806 to canonicalize them. */
12807 return DW_STRING (attr);
12809 case DW_TAG_subprogram:
12810 /* Java constructors will all be named "<init>", so return
12811 the class name when we see this special case. */
12812 if (cu->language == language_java
12813 && DW_STRING (attr) != NULL
12814 && strcmp (DW_STRING (attr), "<init>") == 0)
12816 struct dwarf2_cu *spec_cu = cu;
12817 struct die_info *spec_die;
12819 /* GCJ will output '<init>' for Java constructor names.
12820 For this special case, return the name of the parent class. */
12822 /* GCJ may output suprogram DIEs with AT_specification set.
12823 If so, use the name of the specified DIE. */
12824 spec_die = die_specification (die, &spec_cu);
12825 if (spec_die != NULL)
12826 return dwarf2_name (spec_die, spec_cu);
12831 if (die->tag == DW_TAG_class_type)
12832 return dwarf2_name (die, cu);
12834 while (die->tag != DW_TAG_compile_unit);
12838 case DW_TAG_class_type:
12839 case DW_TAG_interface_type:
12840 case DW_TAG_structure_type:
12841 case DW_TAG_union_type:
12842 /* Some GCC versions emit spurious DW_AT_name attributes for unnamed
12843 structures or unions. These were of the form "._%d" in GCC 4.1,
12844 or simply "<anonymous struct>" or "<anonymous union>" in GCC 4.3
12845 and GCC 4.4. We work around this problem by ignoring these. */
12846 if (attr && DW_STRING (attr)
12847 && (strncmp (DW_STRING (attr), "._", 2) == 0
12848 || strncmp (DW_STRING (attr), "<anonymous", 10) == 0))
12851 /* GCC might emit a nameless typedef that has a linkage name. See
12852 http://gcc.gnu.org/bugzilla/show_bug.cgi?id=47510. */
12853 if (!attr || DW_STRING (attr) == NULL)
12855 char *demangled = NULL;
12857 attr = dwarf2_attr (die, DW_AT_linkage_name, cu);
12859 attr = dwarf2_attr (die, DW_AT_MIPS_linkage_name, cu);
12861 if (attr == NULL || DW_STRING (attr) == NULL)
12864 /* Avoid demangling DW_STRING (attr) the second time on a second
12865 call for the same DIE. */
12866 if (!DW_STRING_IS_CANONICAL (attr))
12867 demangled = cplus_demangle (DW_STRING (attr), DMGL_TYPES);
12873 /* FIXME: we already did this for the partial symbol... */
12874 DW_STRING (attr) = obsavestring (demangled, strlen (demangled),
12875 &cu->objfile->objfile_obstack);
12876 DW_STRING_IS_CANONICAL (attr) = 1;
12879 /* Strip any leading namespaces/classes, keep only the base name.
12880 DW_AT_name for named DIEs does not contain the prefixes. */
12881 base = strrchr (DW_STRING (attr), ':');
12882 if (base && base > DW_STRING (attr) && base[-1] == ':')
12885 return DW_STRING (attr);
12894 if (!DW_STRING_IS_CANONICAL (attr))
12897 = dwarf2_canonicalize_name (DW_STRING (attr), cu,
12898 &cu->objfile->objfile_obstack);
12899 DW_STRING_IS_CANONICAL (attr) = 1;
12901 return DW_STRING (attr);
12904 /* Return the die that this die in an extension of, or NULL if there
12905 is none. *EXT_CU is the CU containing DIE on input, and the CU
12906 containing the return value on output. */
12908 static struct die_info *
12909 dwarf2_extension (struct die_info *die, struct dwarf2_cu **ext_cu)
12911 struct attribute *attr;
12913 attr = dwarf2_attr (die, DW_AT_extension, *ext_cu);
12917 return follow_die_ref (die, attr, ext_cu);
12920 /* Convert a DIE tag into its string name. */
12923 dwarf_tag_name (unsigned tag)
12927 case DW_TAG_padding:
12928 return "DW_TAG_padding";
12929 case DW_TAG_array_type:
12930 return "DW_TAG_array_type";
12931 case DW_TAG_class_type:
12932 return "DW_TAG_class_type";
12933 case DW_TAG_entry_point:
12934 return "DW_TAG_entry_point";
12935 case DW_TAG_enumeration_type:
12936 return "DW_TAG_enumeration_type";
12937 case DW_TAG_formal_parameter:
12938 return "DW_TAG_formal_parameter";
12939 case DW_TAG_imported_declaration:
12940 return "DW_TAG_imported_declaration";
12942 return "DW_TAG_label";
12943 case DW_TAG_lexical_block:
12944 return "DW_TAG_lexical_block";
12945 case DW_TAG_member:
12946 return "DW_TAG_member";
12947 case DW_TAG_pointer_type:
12948 return "DW_TAG_pointer_type";
12949 case DW_TAG_reference_type:
12950 return "DW_TAG_reference_type";
12951 case DW_TAG_compile_unit:
12952 return "DW_TAG_compile_unit";
12953 case DW_TAG_string_type:
12954 return "DW_TAG_string_type";
12955 case DW_TAG_structure_type:
12956 return "DW_TAG_structure_type";
12957 case DW_TAG_subroutine_type:
12958 return "DW_TAG_subroutine_type";
12959 case DW_TAG_typedef:
12960 return "DW_TAG_typedef";
12961 case DW_TAG_union_type:
12962 return "DW_TAG_union_type";
12963 case DW_TAG_unspecified_parameters:
12964 return "DW_TAG_unspecified_parameters";
12965 case DW_TAG_variant:
12966 return "DW_TAG_variant";
12967 case DW_TAG_common_block:
12968 return "DW_TAG_common_block";
12969 case DW_TAG_common_inclusion:
12970 return "DW_TAG_common_inclusion";
12971 case DW_TAG_inheritance:
12972 return "DW_TAG_inheritance";
12973 case DW_TAG_inlined_subroutine:
12974 return "DW_TAG_inlined_subroutine";
12975 case DW_TAG_module:
12976 return "DW_TAG_module";
12977 case DW_TAG_ptr_to_member_type:
12978 return "DW_TAG_ptr_to_member_type";
12979 case DW_TAG_set_type:
12980 return "DW_TAG_set_type";
12981 case DW_TAG_subrange_type:
12982 return "DW_TAG_subrange_type";
12983 case DW_TAG_with_stmt:
12984 return "DW_TAG_with_stmt";
12985 case DW_TAG_access_declaration:
12986 return "DW_TAG_access_declaration";
12987 case DW_TAG_base_type:
12988 return "DW_TAG_base_type";
12989 case DW_TAG_catch_block:
12990 return "DW_TAG_catch_block";
12991 case DW_TAG_const_type:
12992 return "DW_TAG_const_type";
12993 case DW_TAG_constant:
12994 return "DW_TAG_constant";
12995 case DW_TAG_enumerator:
12996 return "DW_TAG_enumerator";
12997 case DW_TAG_file_type:
12998 return "DW_TAG_file_type";
12999 case DW_TAG_friend:
13000 return "DW_TAG_friend";
13001 case DW_TAG_namelist:
13002 return "DW_TAG_namelist";
13003 case DW_TAG_namelist_item:
13004 return "DW_TAG_namelist_item";
13005 case DW_TAG_packed_type:
13006 return "DW_TAG_packed_type";
13007 case DW_TAG_subprogram:
13008 return "DW_TAG_subprogram";
13009 case DW_TAG_template_type_param:
13010 return "DW_TAG_template_type_param";
13011 case DW_TAG_template_value_param:
13012 return "DW_TAG_template_value_param";
13013 case DW_TAG_thrown_type:
13014 return "DW_TAG_thrown_type";
13015 case DW_TAG_try_block:
13016 return "DW_TAG_try_block";
13017 case DW_TAG_variant_part:
13018 return "DW_TAG_variant_part";
13019 case DW_TAG_variable:
13020 return "DW_TAG_variable";
13021 case DW_TAG_volatile_type:
13022 return "DW_TAG_volatile_type";
13023 case DW_TAG_dwarf_procedure:
13024 return "DW_TAG_dwarf_procedure";
13025 case DW_TAG_restrict_type:
13026 return "DW_TAG_restrict_type";
13027 case DW_TAG_interface_type:
13028 return "DW_TAG_interface_type";
13029 case DW_TAG_namespace:
13030 return "DW_TAG_namespace";
13031 case DW_TAG_imported_module:
13032 return "DW_TAG_imported_module";
13033 case DW_TAG_unspecified_type:
13034 return "DW_TAG_unspecified_type";
13035 case DW_TAG_partial_unit:
13036 return "DW_TAG_partial_unit";
13037 case DW_TAG_imported_unit:
13038 return "DW_TAG_imported_unit";
13039 case DW_TAG_condition:
13040 return "DW_TAG_condition";
13041 case DW_TAG_shared_type:
13042 return "DW_TAG_shared_type";
13043 case DW_TAG_type_unit:
13044 return "DW_TAG_type_unit";
13045 case DW_TAG_MIPS_loop:
13046 return "DW_TAG_MIPS_loop";
13047 case DW_TAG_HP_array_descriptor:
13048 return "DW_TAG_HP_array_descriptor";
13049 case DW_TAG_format_label:
13050 return "DW_TAG_format_label";
13051 case DW_TAG_function_template:
13052 return "DW_TAG_function_template";
13053 case DW_TAG_class_template:
13054 return "DW_TAG_class_template";
13055 case DW_TAG_GNU_BINCL:
13056 return "DW_TAG_GNU_BINCL";
13057 case DW_TAG_GNU_EINCL:
13058 return "DW_TAG_GNU_EINCL";
13059 case DW_TAG_upc_shared_type:
13060 return "DW_TAG_upc_shared_type";
13061 case DW_TAG_upc_strict_type:
13062 return "DW_TAG_upc_strict_type";
13063 case DW_TAG_upc_relaxed_type:
13064 return "DW_TAG_upc_relaxed_type";
13065 case DW_TAG_PGI_kanji_type:
13066 return "DW_TAG_PGI_kanji_type";
13067 case DW_TAG_PGI_interface_block:
13068 return "DW_TAG_PGI_interface_block";
13069 case DW_TAG_GNU_call_site:
13070 return "DW_TAG_GNU_call_site";
13072 return "DW_TAG_<unknown>";
13076 /* Convert a DWARF attribute code into its string name. */
13079 dwarf_attr_name (unsigned attr)
13083 case DW_AT_sibling:
13084 return "DW_AT_sibling";
13085 case DW_AT_location:
13086 return "DW_AT_location";
13088 return "DW_AT_name";
13089 case DW_AT_ordering:
13090 return "DW_AT_ordering";
13091 case DW_AT_subscr_data:
13092 return "DW_AT_subscr_data";
13093 case DW_AT_byte_size:
13094 return "DW_AT_byte_size";
13095 case DW_AT_bit_offset:
13096 return "DW_AT_bit_offset";
13097 case DW_AT_bit_size:
13098 return "DW_AT_bit_size";
13099 case DW_AT_element_list:
13100 return "DW_AT_element_list";
13101 case DW_AT_stmt_list:
13102 return "DW_AT_stmt_list";
13104 return "DW_AT_low_pc";
13105 case DW_AT_high_pc:
13106 return "DW_AT_high_pc";
13107 case DW_AT_language:
13108 return "DW_AT_language";
13110 return "DW_AT_member";
13112 return "DW_AT_discr";
13113 case DW_AT_discr_value:
13114 return "DW_AT_discr_value";
13115 case DW_AT_visibility:
13116 return "DW_AT_visibility";
13118 return "DW_AT_import";
13119 case DW_AT_string_length:
13120 return "DW_AT_string_length";
13121 case DW_AT_common_reference:
13122 return "DW_AT_common_reference";
13123 case DW_AT_comp_dir:
13124 return "DW_AT_comp_dir";
13125 case DW_AT_const_value:
13126 return "DW_AT_const_value";
13127 case DW_AT_containing_type:
13128 return "DW_AT_containing_type";
13129 case DW_AT_default_value:
13130 return "DW_AT_default_value";
13132 return "DW_AT_inline";
13133 case DW_AT_is_optional:
13134 return "DW_AT_is_optional";
13135 case DW_AT_lower_bound:
13136 return "DW_AT_lower_bound";
13137 case DW_AT_producer:
13138 return "DW_AT_producer";
13139 case DW_AT_prototyped:
13140 return "DW_AT_prototyped";
13141 case DW_AT_return_addr:
13142 return "DW_AT_return_addr";
13143 case DW_AT_start_scope:
13144 return "DW_AT_start_scope";
13145 case DW_AT_bit_stride:
13146 return "DW_AT_bit_stride";
13147 case DW_AT_upper_bound:
13148 return "DW_AT_upper_bound";
13149 case DW_AT_abstract_origin:
13150 return "DW_AT_abstract_origin";
13151 case DW_AT_accessibility:
13152 return "DW_AT_accessibility";
13153 case DW_AT_address_class:
13154 return "DW_AT_address_class";
13155 case DW_AT_artificial:
13156 return "DW_AT_artificial";
13157 case DW_AT_base_types:
13158 return "DW_AT_base_types";
13159 case DW_AT_calling_convention:
13160 return "DW_AT_calling_convention";
13162 return "DW_AT_count";
13163 case DW_AT_data_member_location:
13164 return "DW_AT_data_member_location";
13165 case DW_AT_decl_column:
13166 return "DW_AT_decl_column";
13167 case DW_AT_decl_file:
13168 return "DW_AT_decl_file";
13169 case DW_AT_decl_line:
13170 return "DW_AT_decl_line";
13171 case DW_AT_declaration:
13172 return "DW_AT_declaration";
13173 case DW_AT_discr_list:
13174 return "DW_AT_discr_list";
13175 case DW_AT_encoding:
13176 return "DW_AT_encoding";
13177 case DW_AT_external:
13178 return "DW_AT_external";
13179 case DW_AT_frame_base:
13180 return "DW_AT_frame_base";
13182 return "DW_AT_friend";
13183 case DW_AT_identifier_case:
13184 return "DW_AT_identifier_case";
13185 case DW_AT_macro_info:
13186 return "DW_AT_macro_info";
13187 case DW_AT_namelist_items:
13188 return "DW_AT_namelist_items";
13189 case DW_AT_priority:
13190 return "DW_AT_priority";
13191 case DW_AT_segment:
13192 return "DW_AT_segment";
13193 case DW_AT_specification:
13194 return "DW_AT_specification";
13195 case DW_AT_static_link:
13196 return "DW_AT_static_link";
13198 return "DW_AT_type";
13199 case DW_AT_use_location:
13200 return "DW_AT_use_location";
13201 case DW_AT_variable_parameter:
13202 return "DW_AT_variable_parameter";
13203 case DW_AT_virtuality:
13204 return "DW_AT_virtuality";
13205 case DW_AT_vtable_elem_location:
13206 return "DW_AT_vtable_elem_location";
13207 /* DWARF 3 values. */
13208 case DW_AT_allocated:
13209 return "DW_AT_allocated";
13210 case DW_AT_associated:
13211 return "DW_AT_associated";
13212 case DW_AT_data_location:
13213 return "DW_AT_data_location";
13214 case DW_AT_byte_stride:
13215 return "DW_AT_byte_stride";
13216 case DW_AT_entry_pc:
13217 return "DW_AT_entry_pc";
13218 case DW_AT_use_UTF8:
13219 return "DW_AT_use_UTF8";
13220 case DW_AT_extension:
13221 return "DW_AT_extension";
13223 return "DW_AT_ranges";
13224 case DW_AT_trampoline:
13225 return "DW_AT_trampoline";
13226 case DW_AT_call_column:
13227 return "DW_AT_call_column";
13228 case DW_AT_call_file:
13229 return "DW_AT_call_file";
13230 case DW_AT_call_line:
13231 return "DW_AT_call_line";
13232 case DW_AT_description:
13233 return "DW_AT_description";
13234 case DW_AT_binary_scale:
13235 return "DW_AT_binary_scale";
13236 case DW_AT_decimal_scale:
13237 return "DW_AT_decimal_scale";
13239 return "DW_AT_small";
13240 case DW_AT_decimal_sign:
13241 return "DW_AT_decimal_sign";
13242 case DW_AT_digit_count:
13243 return "DW_AT_digit_count";
13244 case DW_AT_picture_string:
13245 return "DW_AT_picture_string";
13246 case DW_AT_mutable:
13247 return "DW_AT_mutable";
13248 case DW_AT_threads_scaled:
13249 return "DW_AT_threads_scaled";
13250 case DW_AT_explicit:
13251 return "DW_AT_explicit";
13252 case DW_AT_object_pointer:
13253 return "DW_AT_object_pointer";
13254 case DW_AT_endianity:
13255 return "DW_AT_endianity";
13256 case DW_AT_elemental:
13257 return "DW_AT_elemental";
13259 return "DW_AT_pure";
13260 case DW_AT_recursive:
13261 return "DW_AT_recursive";
13262 /* DWARF 4 values. */
13263 case DW_AT_signature:
13264 return "DW_AT_signature";
13265 case DW_AT_linkage_name:
13266 return "DW_AT_linkage_name";
13267 /* SGI/MIPS extensions. */
13268 #ifdef MIPS /* collides with DW_AT_HP_block_index */
13269 case DW_AT_MIPS_fde:
13270 return "DW_AT_MIPS_fde";
13272 case DW_AT_MIPS_loop_begin:
13273 return "DW_AT_MIPS_loop_begin";
13274 case DW_AT_MIPS_tail_loop_begin:
13275 return "DW_AT_MIPS_tail_loop_begin";
13276 case DW_AT_MIPS_epilog_begin:
13277 return "DW_AT_MIPS_epilog_begin";
13278 case DW_AT_MIPS_loop_unroll_factor:
13279 return "DW_AT_MIPS_loop_unroll_factor";
13280 case DW_AT_MIPS_software_pipeline_depth:
13281 return "DW_AT_MIPS_software_pipeline_depth";
13282 case DW_AT_MIPS_linkage_name:
13283 return "DW_AT_MIPS_linkage_name";
13284 case DW_AT_MIPS_stride:
13285 return "DW_AT_MIPS_stride";
13286 case DW_AT_MIPS_abstract_name:
13287 return "DW_AT_MIPS_abstract_name";
13288 case DW_AT_MIPS_clone_origin:
13289 return "DW_AT_MIPS_clone_origin";
13290 case DW_AT_MIPS_has_inlines:
13291 return "DW_AT_MIPS_has_inlines";
13292 /* HP extensions. */
13293 #ifndef MIPS /* collides with DW_AT_MIPS_fde */
13294 case DW_AT_HP_block_index:
13295 return "DW_AT_HP_block_index";
13297 case DW_AT_HP_unmodifiable:
13298 return "DW_AT_HP_unmodifiable";
13299 case DW_AT_HP_actuals_stmt_list:
13300 return "DW_AT_HP_actuals_stmt_list";
13301 case DW_AT_HP_proc_per_section:
13302 return "DW_AT_HP_proc_per_section";
13303 case DW_AT_HP_raw_data_ptr:
13304 return "DW_AT_HP_raw_data_ptr";
13305 case DW_AT_HP_pass_by_reference:
13306 return "DW_AT_HP_pass_by_reference";
13307 case DW_AT_HP_opt_level:
13308 return "DW_AT_HP_opt_level";
13309 case DW_AT_HP_prof_version_id:
13310 return "DW_AT_HP_prof_version_id";
13311 case DW_AT_HP_opt_flags:
13312 return "DW_AT_HP_opt_flags";
13313 case DW_AT_HP_cold_region_low_pc:
13314 return "DW_AT_HP_cold_region_low_pc";
13315 case DW_AT_HP_cold_region_high_pc:
13316 return "DW_AT_HP_cold_region_high_pc";
13317 case DW_AT_HP_all_variables_modifiable:
13318 return "DW_AT_HP_all_variables_modifiable";
13319 case DW_AT_HP_linkage_name:
13320 return "DW_AT_HP_linkage_name";
13321 case DW_AT_HP_prof_flags:
13322 return "DW_AT_HP_prof_flags";
13323 /* GNU extensions. */
13324 case DW_AT_sf_names:
13325 return "DW_AT_sf_names";
13326 case DW_AT_src_info:
13327 return "DW_AT_src_info";
13328 case DW_AT_mac_info:
13329 return "DW_AT_mac_info";
13330 case DW_AT_src_coords:
13331 return "DW_AT_src_coords";
13332 case DW_AT_body_begin:
13333 return "DW_AT_body_begin";
13334 case DW_AT_body_end:
13335 return "DW_AT_body_end";
13336 case DW_AT_GNU_vector:
13337 return "DW_AT_GNU_vector";
13338 case DW_AT_GNU_odr_signature:
13339 return "DW_AT_GNU_odr_signature";
13340 /* VMS extensions. */
13341 case DW_AT_VMS_rtnbeg_pd_address:
13342 return "DW_AT_VMS_rtnbeg_pd_address";
13343 /* UPC extension. */
13344 case DW_AT_upc_threads_scaled:
13345 return "DW_AT_upc_threads_scaled";
13346 /* PGI (STMicroelectronics) extensions. */
13347 case DW_AT_PGI_lbase:
13348 return "DW_AT_PGI_lbase";
13349 case DW_AT_PGI_soffset:
13350 return "DW_AT_PGI_soffset";
13351 case DW_AT_PGI_lstride:
13352 return "DW_AT_PGI_lstride";
13354 return "DW_AT_<unknown>";
13358 /* Convert a DWARF value form code into its string name. */
13361 dwarf_form_name (unsigned form)
13366 return "DW_FORM_addr";
13367 case DW_FORM_block2:
13368 return "DW_FORM_block2";
13369 case DW_FORM_block4:
13370 return "DW_FORM_block4";
13371 case DW_FORM_data2:
13372 return "DW_FORM_data2";
13373 case DW_FORM_data4:
13374 return "DW_FORM_data4";
13375 case DW_FORM_data8:
13376 return "DW_FORM_data8";
13377 case DW_FORM_string:
13378 return "DW_FORM_string";
13379 case DW_FORM_block:
13380 return "DW_FORM_block";
13381 case DW_FORM_block1:
13382 return "DW_FORM_block1";
13383 case DW_FORM_data1:
13384 return "DW_FORM_data1";
13386 return "DW_FORM_flag";
13387 case DW_FORM_sdata:
13388 return "DW_FORM_sdata";
13390 return "DW_FORM_strp";
13391 case DW_FORM_udata:
13392 return "DW_FORM_udata";
13393 case DW_FORM_ref_addr:
13394 return "DW_FORM_ref_addr";
13396 return "DW_FORM_ref1";
13398 return "DW_FORM_ref2";
13400 return "DW_FORM_ref4";
13402 return "DW_FORM_ref8";
13403 case DW_FORM_ref_udata:
13404 return "DW_FORM_ref_udata";
13405 case DW_FORM_indirect:
13406 return "DW_FORM_indirect";
13407 case DW_FORM_sec_offset:
13408 return "DW_FORM_sec_offset";
13409 case DW_FORM_exprloc:
13410 return "DW_FORM_exprloc";
13411 case DW_FORM_flag_present:
13412 return "DW_FORM_flag_present";
13413 case DW_FORM_ref_sig8:
13414 return "DW_FORM_ref_sig8";
13416 return "DW_FORM_<unknown>";
13420 /* Convert a DWARF stack opcode into its string name. */
13423 dwarf_stack_op_name (unsigned op)
13428 return "DW_OP_addr";
13430 return "DW_OP_deref";
13431 case DW_OP_const1u:
13432 return "DW_OP_const1u";
13433 case DW_OP_const1s:
13434 return "DW_OP_const1s";
13435 case DW_OP_const2u:
13436 return "DW_OP_const2u";
13437 case DW_OP_const2s:
13438 return "DW_OP_const2s";
13439 case DW_OP_const4u:
13440 return "DW_OP_const4u";
13441 case DW_OP_const4s:
13442 return "DW_OP_const4s";
13443 case DW_OP_const8u:
13444 return "DW_OP_const8u";
13445 case DW_OP_const8s:
13446 return "DW_OP_const8s";
13448 return "DW_OP_constu";
13450 return "DW_OP_consts";
13452 return "DW_OP_dup";
13454 return "DW_OP_drop";
13456 return "DW_OP_over";
13458 return "DW_OP_pick";
13460 return "DW_OP_swap";
13462 return "DW_OP_rot";
13464 return "DW_OP_xderef";
13466 return "DW_OP_abs";
13468 return "DW_OP_and";
13470 return "DW_OP_div";
13472 return "DW_OP_minus";
13474 return "DW_OP_mod";
13476 return "DW_OP_mul";
13478 return "DW_OP_neg";
13480 return "DW_OP_not";
13484 return "DW_OP_plus";
13485 case DW_OP_plus_uconst:
13486 return "DW_OP_plus_uconst";
13488 return "DW_OP_shl";
13490 return "DW_OP_shr";
13492 return "DW_OP_shra";
13494 return "DW_OP_xor";
13496 return "DW_OP_bra";
13510 return "DW_OP_skip";
13512 return "DW_OP_lit0";
13514 return "DW_OP_lit1";
13516 return "DW_OP_lit2";
13518 return "DW_OP_lit3";
13520 return "DW_OP_lit4";
13522 return "DW_OP_lit5";
13524 return "DW_OP_lit6";
13526 return "DW_OP_lit7";
13528 return "DW_OP_lit8";
13530 return "DW_OP_lit9";
13532 return "DW_OP_lit10";
13534 return "DW_OP_lit11";
13536 return "DW_OP_lit12";
13538 return "DW_OP_lit13";
13540 return "DW_OP_lit14";
13542 return "DW_OP_lit15";
13544 return "DW_OP_lit16";
13546 return "DW_OP_lit17";
13548 return "DW_OP_lit18";
13550 return "DW_OP_lit19";
13552 return "DW_OP_lit20";
13554 return "DW_OP_lit21";
13556 return "DW_OP_lit22";
13558 return "DW_OP_lit23";
13560 return "DW_OP_lit24";
13562 return "DW_OP_lit25";
13564 return "DW_OP_lit26";
13566 return "DW_OP_lit27";
13568 return "DW_OP_lit28";
13570 return "DW_OP_lit29";
13572 return "DW_OP_lit30";
13574 return "DW_OP_lit31";
13576 return "DW_OP_reg0";
13578 return "DW_OP_reg1";
13580 return "DW_OP_reg2";
13582 return "DW_OP_reg3";
13584 return "DW_OP_reg4";
13586 return "DW_OP_reg5";
13588 return "DW_OP_reg6";
13590 return "DW_OP_reg7";
13592 return "DW_OP_reg8";
13594 return "DW_OP_reg9";
13596 return "DW_OP_reg10";
13598 return "DW_OP_reg11";
13600 return "DW_OP_reg12";
13602 return "DW_OP_reg13";
13604 return "DW_OP_reg14";
13606 return "DW_OP_reg15";
13608 return "DW_OP_reg16";
13610 return "DW_OP_reg17";
13612 return "DW_OP_reg18";
13614 return "DW_OP_reg19";
13616 return "DW_OP_reg20";
13618 return "DW_OP_reg21";
13620 return "DW_OP_reg22";
13622 return "DW_OP_reg23";
13624 return "DW_OP_reg24";
13626 return "DW_OP_reg25";
13628 return "DW_OP_reg26";
13630 return "DW_OP_reg27";
13632 return "DW_OP_reg28";
13634 return "DW_OP_reg29";
13636 return "DW_OP_reg30";
13638 return "DW_OP_reg31";
13640 return "DW_OP_breg0";
13642 return "DW_OP_breg1";
13644 return "DW_OP_breg2";
13646 return "DW_OP_breg3";
13648 return "DW_OP_breg4";
13650 return "DW_OP_breg5";
13652 return "DW_OP_breg6";
13654 return "DW_OP_breg7";
13656 return "DW_OP_breg8";
13658 return "DW_OP_breg9";
13660 return "DW_OP_breg10";
13662 return "DW_OP_breg11";
13664 return "DW_OP_breg12";
13666 return "DW_OP_breg13";
13668 return "DW_OP_breg14";
13670 return "DW_OP_breg15";
13672 return "DW_OP_breg16";
13674 return "DW_OP_breg17";
13676 return "DW_OP_breg18";
13678 return "DW_OP_breg19";
13680 return "DW_OP_breg20";
13682 return "DW_OP_breg21";
13684 return "DW_OP_breg22";
13686 return "DW_OP_breg23";
13688 return "DW_OP_breg24";
13690 return "DW_OP_breg25";
13692 return "DW_OP_breg26";
13694 return "DW_OP_breg27";
13696 return "DW_OP_breg28";
13698 return "DW_OP_breg29";
13700 return "DW_OP_breg30";
13702 return "DW_OP_breg31";
13704 return "DW_OP_regx";
13706 return "DW_OP_fbreg";
13708 return "DW_OP_bregx";
13710 return "DW_OP_piece";
13711 case DW_OP_deref_size:
13712 return "DW_OP_deref_size";
13713 case DW_OP_xderef_size:
13714 return "DW_OP_xderef_size";
13716 return "DW_OP_nop";
13717 /* DWARF 3 extensions. */
13718 case DW_OP_push_object_address:
13719 return "DW_OP_push_object_address";
13721 return "DW_OP_call2";
13723 return "DW_OP_call4";
13724 case DW_OP_call_ref:
13725 return "DW_OP_call_ref";
13726 case DW_OP_form_tls_address:
13727 return "DW_OP_form_tls_address";
13728 case DW_OP_call_frame_cfa:
13729 return "DW_OP_call_frame_cfa";
13730 case DW_OP_bit_piece:
13731 return "DW_OP_bit_piece";
13732 /* DWARF 4 extensions. */
13733 case DW_OP_implicit_value:
13734 return "DW_OP_implicit_value";
13735 case DW_OP_stack_value:
13736 return "DW_OP_stack_value";
13737 /* GNU extensions. */
13738 case DW_OP_GNU_push_tls_address:
13739 return "DW_OP_GNU_push_tls_address";
13740 case DW_OP_GNU_uninit:
13741 return "DW_OP_GNU_uninit";
13742 case DW_OP_GNU_implicit_pointer:
13743 return "DW_OP_GNU_implicit_pointer";
13744 case DW_OP_GNU_entry_value:
13745 return "DW_OP_GNU_entry_value";
13746 case DW_OP_GNU_const_type:
13747 return "DW_OP_GNU_const_type";
13748 case DW_OP_GNU_regval_type:
13749 return "DW_OP_GNU_regval_type";
13750 case DW_OP_GNU_deref_type:
13751 return "DW_OP_GNU_deref_type";
13752 case DW_OP_GNU_convert:
13753 return "DW_OP_GNU_convert";
13754 case DW_OP_GNU_reinterpret:
13755 return "DW_OP_GNU_reinterpret";
13762 dwarf_bool_name (unsigned mybool)
13770 /* Convert a DWARF type code into its string name. */
13773 dwarf_type_encoding_name (unsigned enc)
13778 return "DW_ATE_void";
13779 case DW_ATE_address:
13780 return "DW_ATE_address";
13781 case DW_ATE_boolean:
13782 return "DW_ATE_boolean";
13783 case DW_ATE_complex_float:
13784 return "DW_ATE_complex_float";
13786 return "DW_ATE_float";
13787 case DW_ATE_signed:
13788 return "DW_ATE_signed";
13789 case DW_ATE_signed_char:
13790 return "DW_ATE_signed_char";
13791 case DW_ATE_unsigned:
13792 return "DW_ATE_unsigned";
13793 case DW_ATE_unsigned_char:
13794 return "DW_ATE_unsigned_char";
13796 case DW_ATE_imaginary_float:
13797 return "DW_ATE_imaginary_float";
13798 case DW_ATE_packed_decimal:
13799 return "DW_ATE_packed_decimal";
13800 case DW_ATE_numeric_string:
13801 return "DW_ATE_numeric_string";
13802 case DW_ATE_edited:
13803 return "DW_ATE_edited";
13804 case DW_ATE_signed_fixed:
13805 return "DW_ATE_signed_fixed";
13806 case DW_ATE_unsigned_fixed:
13807 return "DW_ATE_unsigned_fixed";
13808 case DW_ATE_decimal_float:
13809 return "DW_ATE_decimal_float";
13812 return "DW_ATE_UTF";
13813 /* HP extensions. */
13814 case DW_ATE_HP_float80:
13815 return "DW_ATE_HP_float80";
13816 case DW_ATE_HP_complex_float80:
13817 return "DW_ATE_HP_complex_float80";
13818 case DW_ATE_HP_float128:
13819 return "DW_ATE_HP_float128";
13820 case DW_ATE_HP_complex_float128:
13821 return "DW_ATE_HP_complex_float128";
13822 case DW_ATE_HP_floathpintel:
13823 return "DW_ATE_HP_floathpintel";
13824 case DW_ATE_HP_imaginary_float80:
13825 return "DW_ATE_HP_imaginary_float80";
13826 case DW_ATE_HP_imaginary_float128:
13827 return "DW_ATE_HP_imaginary_float128";
13829 return "DW_ATE_<unknown>";
13833 /* Convert a DWARF call frame info operation to its string name. */
13837 dwarf_cfi_name (unsigned cfi_opc)
13841 case DW_CFA_advance_loc:
13842 return "DW_CFA_advance_loc";
13843 case DW_CFA_offset:
13844 return "DW_CFA_offset";
13845 case DW_CFA_restore:
13846 return "DW_CFA_restore";
13848 return "DW_CFA_nop";
13849 case DW_CFA_set_loc:
13850 return "DW_CFA_set_loc";
13851 case DW_CFA_advance_loc1:
13852 return "DW_CFA_advance_loc1";
13853 case DW_CFA_advance_loc2:
13854 return "DW_CFA_advance_loc2";
13855 case DW_CFA_advance_loc4:
13856 return "DW_CFA_advance_loc4";
13857 case DW_CFA_offset_extended:
13858 return "DW_CFA_offset_extended";
13859 case DW_CFA_restore_extended:
13860 return "DW_CFA_restore_extended";
13861 case DW_CFA_undefined:
13862 return "DW_CFA_undefined";
13863 case DW_CFA_same_value:
13864 return "DW_CFA_same_value";
13865 case DW_CFA_register:
13866 return "DW_CFA_register";
13867 case DW_CFA_remember_state:
13868 return "DW_CFA_remember_state";
13869 case DW_CFA_restore_state:
13870 return "DW_CFA_restore_state";
13871 case DW_CFA_def_cfa:
13872 return "DW_CFA_def_cfa";
13873 case DW_CFA_def_cfa_register:
13874 return "DW_CFA_def_cfa_register";
13875 case DW_CFA_def_cfa_offset:
13876 return "DW_CFA_def_cfa_offset";
13878 case DW_CFA_def_cfa_expression:
13879 return "DW_CFA_def_cfa_expression";
13880 case DW_CFA_expression:
13881 return "DW_CFA_expression";
13882 case DW_CFA_offset_extended_sf:
13883 return "DW_CFA_offset_extended_sf";
13884 case DW_CFA_def_cfa_sf:
13885 return "DW_CFA_def_cfa_sf";
13886 case DW_CFA_def_cfa_offset_sf:
13887 return "DW_CFA_def_cfa_offset_sf";
13888 case DW_CFA_val_offset:
13889 return "DW_CFA_val_offset";
13890 case DW_CFA_val_offset_sf:
13891 return "DW_CFA_val_offset_sf";
13892 case DW_CFA_val_expression:
13893 return "DW_CFA_val_expression";
13894 /* SGI/MIPS specific. */
13895 case DW_CFA_MIPS_advance_loc8:
13896 return "DW_CFA_MIPS_advance_loc8";
13897 /* GNU extensions. */
13898 case DW_CFA_GNU_window_save:
13899 return "DW_CFA_GNU_window_save";
13900 case DW_CFA_GNU_args_size:
13901 return "DW_CFA_GNU_args_size";
13902 case DW_CFA_GNU_negative_offset_extended:
13903 return "DW_CFA_GNU_negative_offset_extended";
13905 return "DW_CFA_<unknown>";
13911 dump_die_shallow (struct ui_file *f, int indent, struct die_info *die)
13915 print_spaces (indent, f);
13916 fprintf_unfiltered (f, "Die: %s (abbrev %d, offset 0x%x)\n",
13917 dwarf_tag_name (die->tag), die->abbrev, die->offset);
13919 if (die->parent != NULL)
13921 print_spaces (indent, f);
13922 fprintf_unfiltered (f, " parent at offset: 0x%x\n",
13923 die->parent->offset);
13926 print_spaces (indent, f);
13927 fprintf_unfiltered (f, " has children: %s\n",
13928 dwarf_bool_name (die->child != NULL));
13930 print_spaces (indent, f);
13931 fprintf_unfiltered (f, " attributes:\n");
13933 for (i = 0; i < die->num_attrs; ++i)
13935 print_spaces (indent, f);
13936 fprintf_unfiltered (f, " %s (%s) ",
13937 dwarf_attr_name (die->attrs[i].name),
13938 dwarf_form_name (die->attrs[i].form));
13940 switch (die->attrs[i].form)
13942 case DW_FORM_ref_addr:
13944 fprintf_unfiltered (f, "address: ");
13945 fputs_filtered (hex_string (DW_ADDR (&die->attrs[i])), f);
13947 case DW_FORM_block2:
13948 case DW_FORM_block4:
13949 case DW_FORM_block:
13950 case DW_FORM_block1:
13951 fprintf_unfiltered (f, "block: size %d",
13952 DW_BLOCK (&die->attrs[i])->size);
13954 case DW_FORM_exprloc:
13955 fprintf_unfiltered (f, "expression: size %u",
13956 DW_BLOCK (&die->attrs[i])->size);
13961 fprintf_unfiltered (f, "constant ref: 0x%lx (adjusted)",
13962 (long) (DW_ADDR (&die->attrs[i])));
13964 case DW_FORM_data1:
13965 case DW_FORM_data2:
13966 case DW_FORM_data4:
13967 case DW_FORM_data8:
13968 case DW_FORM_udata:
13969 case DW_FORM_sdata:
13970 fprintf_unfiltered (f, "constant: %s",
13971 pulongest (DW_UNSND (&die->attrs[i])));
13973 case DW_FORM_sec_offset:
13974 fprintf_unfiltered (f, "section offset: %s",
13975 pulongest (DW_UNSND (&die->attrs[i])));
13977 case DW_FORM_ref_sig8:
13978 if (DW_SIGNATURED_TYPE (&die->attrs[i]) != NULL)
13979 fprintf_unfiltered (f, "signatured type, offset: 0x%x",
13980 DW_SIGNATURED_TYPE (&die->attrs[i])->per_cu.offset);
13982 fprintf_unfiltered (f, "signatured type, offset: unknown");
13984 case DW_FORM_string:
13986 fprintf_unfiltered (f, "string: \"%s\" (%s canonicalized)",
13987 DW_STRING (&die->attrs[i])
13988 ? DW_STRING (&die->attrs[i]) : "",
13989 DW_STRING_IS_CANONICAL (&die->attrs[i]) ? "is" : "not");
13992 if (DW_UNSND (&die->attrs[i]))
13993 fprintf_unfiltered (f, "flag: TRUE");
13995 fprintf_unfiltered (f, "flag: FALSE");
13997 case DW_FORM_flag_present:
13998 fprintf_unfiltered (f, "flag: TRUE");
14000 case DW_FORM_indirect:
14001 /* The reader will have reduced the indirect form to
14002 the "base form" so this form should not occur. */
14003 fprintf_unfiltered (f,
14004 "unexpected attribute form: DW_FORM_indirect");
14007 fprintf_unfiltered (f, "unsupported attribute form: %d.",
14008 die->attrs[i].form);
14011 fprintf_unfiltered (f, "\n");
14016 dump_die_for_error (struct die_info *die)
14018 dump_die_shallow (gdb_stderr, 0, die);
14022 dump_die_1 (struct ui_file *f, int level, int max_level, struct die_info *die)
14024 int indent = level * 4;
14026 gdb_assert (die != NULL);
14028 if (level >= max_level)
14031 dump_die_shallow (f, indent, die);
14033 if (die->child != NULL)
14035 print_spaces (indent, f);
14036 fprintf_unfiltered (f, " Children:");
14037 if (level + 1 < max_level)
14039 fprintf_unfiltered (f, "\n");
14040 dump_die_1 (f, level + 1, max_level, die->child);
14044 fprintf_unfiltered (f,
14045 " [not printed, max nesting level reached]\n");
14049 if (die->sibling != NULL && level > 0)
14051 dump_die_1 (f, level, max_level, die->sibling);
14055 /* This is called from the pdie macro in gdbinit.in.
14056 It's not static so gcc will keep a copy callable from gdb. */
14059 dump_die (struct die_info *die, int max_level)
14061 dump_die_1 (gdb_stdlog, 0, max_level, die);
14065 store_in_ref_table (struct die_info *die, struct dwarf2_cu *cu)
14069 slot = htab_find_slot_with_hash (cu->die_hash, die, die->offset, INSERT);
14075 is_ref_attr (struct attribute *attr)
14077 switch (attr->form)
14079 case DW_FORM_ref_addr:
14084 case DW_FORM_ref_udata:
14091 static unsigned int
14092 dwarf2_get_ref_die_offset (struct attribute *attr)
14094 if (is_ref_attr (attr))
14095 return DW_ADDR (attr);
14097 complaint (&symfile_complaints,
14098 _("unsupported die ref attribute form: '%s'"),
14099 dwarf_form_name (attr->form));
14103 /* Return the constant value held by ATTR. Return DEFAULT_VALUE if
14104 * the value held by the attribute is not constant. */
14107 dwarf2_get_attr_constant_value (struct attribute *attr, int default_value)
14109 if (attr->form == DW_FORM_sdata)
14110 return DW_SND (attr);
14111 else if (attr->form == DW_FORM_udata
14112 || attr->form == DW_FORM_data1
14113 || attr->form == DW_FORM_data2
14114 || attr->form == DW_FORM_data4
14115 || attr->form == DW_FORM_data8)
14116 return DW_UNSND (attr);
14119 complaint (&symfile_complaints,
14120 _("Attribute value is not a constant (%s)"),
14121 dwarf_form_name (attr->form));
14122 return default_value;
14126 /* THIS_CU has a reference to PER_CU. If necessary, load the new compilation
14127 unit and add it to our queue.
14128 The result is non-zero if PER_CU was queued, otherwise the result is zero
14129 meaning either PER_CU is already queued or it is already loaded. */
14132 maybe_queue_comp_unit (struct dwarf2_cu *this_cu,
14133 struct dwarf2_per_cu_data *per_cu)
14135 /* We may arrive here during partial symbol reading, if we need full
14136 DIEs to process an unusual case (e.g. template arguments). Do
14137 not queue PER_CU, just tell our caller to load its DIEs. */
14138 if (dwarf2_per_objfile->reading_partial_symbols)
14140 if (per_cu->cu == NULL || per_cu->cu->dies == NULL)
14145 /* Mark the dependence relation so that we don't flush PER_CU
14147 dwarf2_add_dependence (this_cu, per_cu);
14149 /* If it's already on the queue, we have nothing to do. */
14150 if (per_cu->queued)
14153 /* If the compilation unit is already loaded, just mark it as
14155 if (per_cu->cu != NULL)
14157 per_cu->cu->last_used = 0;
14161 /* Add it to the queue. */
14162 queue_comp_unit (per_cu, this_cu->objfile);
14167 /* Follow reference or signature attribute ATTR of SRC_DIE.
14168 On entry *REF_CU is the CU of SRC_DIE.
14169 On exit *REF_CU is the CU of the result. */
14171 static struct die_info *
14172 follow_die_ref_or_sig (struct die_info *src_die, struct attribute *attr,
14173 struct dwarf2_cu **ref_cu)
14175 struct die_info *die;
14177 if (is_ref_attr (attr))
14178 die = follow_die_ref (src_die, attr, ref_cu);
14179 else if (attr->form == DW_FORM_ref_sig8)
14180 die = follow_die_sig (src_die, attr, ref_cu);
14183 dump_die_for_error (src_die);
14184 error (_("Dwarf Error: Expected reference attribute [in module %s]"),
14185 (*ref_cu)->objfile->name);
14191 /* Follow reference OFFSET.
14192 On entry *REF_CU is the CU of the source die referencing OFFSET.
14193 On exit *REF_CU is the CU of the result.
14194 Returns NULL if OFFSET is invalid. */
14196 static struct die_info *
14197 follow_die_offset (unsigned int offset, struct dwarf2_cu **ref_cu)
14199 struct die_info temp_die;
14200 struct dwarf2_cu *target_cu, *cu = *ref_cu;
14202 gdb_assert (cu->per_cu != NULL);
14206 if (cu->per_cu->debug_type_section)
14208 /* .debug_types CUs cannot reference anything outside their CU.
14209 If they need to, they have to reference a signatured type via
14210 DW_FORM_ref_sig8. */
14211 if (! offset_in_cu_p (&cu->header, offset))
14214 else if (! offset_in_cu_p (&cu->header, offset))
14216 struct dwarf2_per_cu_data *per_cu;
14218 per_cu = dwarf2_find_containing_comp_unit (offset, cu->objfile);
14220 /* If necessary, add it to the queue and load its DIEs. */
14221 if (maybe_queue_comp_unit (cu, per_cu))
14222 load_full_comp_unit (per_cu, cu->objfile);
14224 target_cu = per_cu->cu;
14226 else if (cu->dies == NULL)
14228 /* We're loading full DIEs during partial symbol reading. */
14229 gdb_assert (dwarf2_per_objfile->reading_partial_symbols);
14230 load_full_comp_unit (cu->per_cu, cu->objfile);
14233 *ref_cu = target_cu;
14234 temp_die.offset = offset;
14235 return htab_find_with_hash (target_cu->die_hash, &temp_die, offset);
14238 /* Follow reference attribute ATTR of SRC_DIE.
14239 On entry *REF_CU is the CU of SRC_DIE.
14240 On exit *REF_CU is the CU of the result. */
14242 static struct die_info *
14243 follow_die_ref (struct die_info *src_die, struct attribute *attr,
14244 struct dwarf2_cu **ref_cu)
14246 unsigned int offset = dwarf2_get_ref_die_offset (attr);
14247 struct dwarf2_cu *cu = *ref_cu;
14248 struct die_info *die;
14250 die = follow_die_offset (offset, ref_cu);
14252 error (_("Dwarf Error: Cannot find DIE at 0x%x referenced from DIE "
14253 "at 0x%x [in module %s]"),
14254 offset, src_die->offset, cu->objfile->name);
14259 /* Return DWARF block referenced by DW_AT_location of DIE at OFFSET at PER_CU.
14260 Returned value is intended for DW_OP_call*. Returned
14261 dwarf2_locexpr_baton->data has lifetime of PER_CU->OBJFILE. */
14263 struct dwarf2_locexpr_baton
14264 dwarf2_fetch_die_location_block (unsigned int offset,
14265 struct dwarf2_per_cu_data *per_cu,
14266 CORE_ADDR (*get_frame_pc) (void *baton),
14269 struct dwarf2_cu *cu;
14270 struct die_info *die;
14271 struct attribute *attr;
14272 struct dwarf2_locexpr_baton retval;
14274 dw2_setup (per_cu->objfile);
14276 if (per_cu->cu == NULL)
14280 die = follow_die_offset (offset, &cu);
14282 error (_("Dwarf Error: Cannot find DIE at 0x%x referenced in module %s"),
14283 offset, per_cu->cu->objfile->name);
14285 attr = dwarf2_attr (die, DW_AT_location, cu);
14288 /* DWARF: "If there is no such attribute, then there is no effect.".
14289 DATA is ignored if SIZE is 0. */
14291 retval.data = NULL;
14294 else if (attr_form_is_section_offset (attr))
14296 struct dwarf2_loclist_baton loclist_baton;
14297 CORE_ADDR pc = (*get_frame_pc) (baton);
14300 fill_in_loclist_baton (cu, &loclist_baton, attr);
14302 retval.data = dwarf2_find_location_expression (&loclist_baton,
14304 retval.size = size;
14308 if (!attr_form_is_block (attr))
14309 error (_("Dwarf Error: DIE at 0x%x referenced in module %s "
14310 "is neither DW_FORM_block* nor DW_FORM_exprloc"),
14311 offset, per_cu->cu->objfile->name);
14313 retval.data = DW_BLOCK (attr)->data;
14314 retval.size = DW_BLOCK (attr)->size;
14316 retval.per_cu = cu->per_cu;
14318 age_cached_comp_units ();
14323 /* Return the type of the DIE at DIE_OFFSET in the CU named by
14327 dwarf2_get_die_type (unsigned int die_offset,
14328 struct dwarf2_per_cu_data *per_cu)
14330 dw2_setup (per_cu->objfile);
14331 return get_die_type_at_offset (die_offset, per_cu);
14334 /* Follow the signature attribute ATTR in SRC_DIE.
14335 On entry *REF_CU is the CU of SRC_DIE.
14336 On exit *REF_CU is the CU of the result. */
14338 static struct die_info *
14339 follow_die_sig (struct die_info *src_die, struct attribute *attr,
14340 struct dwarf2_cu **ref_cu)
14342 struct objfile *objfile = (*ref_cu)->objfile;
14343 struct die_info temp_die;
14344 struct signatured_type *sig_type = DW_SIGNATURED_TYPE (attr);
14345 struct dwarf2_cu *sig_cu;
14346 struct die_info *die;
14348 /* sig_type will be NULL if the signatured type is missing from
14350 if (sig_type == NULL)
14351 error (_("Dwarf Error: Cannot find signatured DIE referenced from DIE "
14352 "at 0x%x [in module %s]"),
14353 src_die->offset, objfile->name);
14355 /* If necessary, add it to the queue and load its DIEs. */
14357 if (maybe_queue_comp_unit (*ref_cu, &sig_type->per_cu))
14358 read_signatured_type (objfile, sig_type);
14360 gdb_assert (sig_type->per_cu.cu != NULL);
14362 sig_cu = sig_type->per_cu.cu;
14363 temp_die.offset = sig_cu->header.offset + sig_type->type_offset;
14364 die = htab_find_with_hash (sig_cu->die_hash, &temp_die, temp_die.offset);
14371 error (_("Dwarf Error: Cannot find signatured DIE at 0x%x referenced "
14372 "from DIE at 0x%x [in module %s]"),
14373 sig_type->type_offset, src_die->offset, objfile->name);
14376 /* Given an offset of a signatured type, return its signatured_type. */
14378 static struct signatured_type *
14379 lookup_signatured_type_at_offset (struct objfile *objfile,
14380 struct dwarf2_section_info *section,
14381 unsigned int offset)
14383 gdb_byte *info_ptr = section->buffer + offset;
14384 unsigned int length, initial_length_size;
14385 unsigned int sig_offset;
14386 struct signatured_type find_entry, *type_sig;
14388 length = read_initial_length (objfile->obfd, info_ptr, &initial_length_size);
14389 sig_offset = (initial_length_size
14391 + (initial_length_size == 4 ? 4 : 8) /*debug_abbrev_offset*/
14392 + 1 /*address_size*/);
14393 find_entry.signature = bfd_get_64 (objfile->obfd, info_ptr + sig_offset);
14394 type_sig = htab_find (dwarf2_per_objfile->signatured_types, &find_entry);
14396 /* This is only used to lookup previously recorded types.
14397 If we didn't find it, it's our bug. */
14398 gdb_assert (type_sig != NULL);
14399 gdb_assert (offset == type_sig->per_cu.offset);
14404 /* Read in signatured type at OFFSET and build its CU and die(s). */
14407 read_signatured_type_at_offset (struct objfile *objfile,
14408 struct dwarf2_section_info *sect,
14409 unsigned int offset)
14411 struct signatured_type *type_sig;
14413 dwarf2_read_section (objfile, sect);
14415 /* We have the section offset, but we need the signature to do the
14416 hash table lookup. */
14417 type_sig = lookup_signatured_type_at_offset (objfile, sect, offset);
14419 gdb_assert (type_sig->per_cu.cu == NULL);
14421 read_signatured_type (objfile, type_sig);
14423 gdb_assert (type_sig->per_cu.cu != NULL);
14426 /* Read in a signatured type and build its CU and DIEs. */
14429 read_signatured_type (struct objfile *objfile,
14430 struct signatured_type *type_sig)
14432 gdb_byte *types_ptr;
14433 struct die_reader_specs reader_specs;
14434 struct dwarf2_cu *cu;
14435 ULONGEST signature;
14436 struct cleanup *back_to, *free_cu_cleanup;
14437 struct dwarf2_section_info *section = type_sig->per_cu.debug_type_section;
14439 dwarf2_read_section (objfile, section);
14440 types_ptr = section->buffer + type_sig->per_cu.offset;
14442 gdb_assert (type_sig->per_cu.cu == NULL);
14444 cu = xmalloc (sizeof (*cu));
14445 init_one_comp_unit (cu, objfile);
14447 type_sig->per_cu.cu = cu;
14448 cu->per_cu = &type_sig->per_cu;
14450 /* If an error occurs while loading, release our storage. */
14451 free_cu_cleanup = make_cleanup (free_one_comp_unit, cu);
14453 types_ptr = read_type_comp_unit_head (&cu->header, section, &signature,
14454 types_ptr, objfile->obfd);
14455 gdb_assert (signature == type_sig->signature);
14458 = htab_create_alloc_ex (cu->header.length / 12,
14462 &cu->comp_unit_obstack,
14463 hashtab_obstack_allocate,
14464 dummy_obstack_deallocate);
14466 dwarf2_read_abbrevs (cu->objfile->obfd, cu);
14467 back_to = make_cleanup (dwarf2_free_abbrev_table, cu);
14469 init_cu_die_reader (&reader_specs, cu);
14471 cu->dies = read_die_and_children (&reader_specs, types_ptr, &types_ptr,
14474 /* We try not to read any attributes in this function, because not
14475 all objfiles needed for references have been loaded yet, and symbol
14476 table processing isn't initialized. But we have to set the CU language,
14477 or we won't be able to build types correctly. */
14478 prepare_one_comp_unit (cu, cu->dies);
14480 do_cleanups (back_to);
14482 /* We've successfully allocated this compilation unit. Let our caller
14483 clean it up when finished with it. */
14484 discard_cleanups (free_cu_cleanup);
14486 type_sig->per_cu.cu->read_in_chain = dwarf2_per_objfile->read_in_chain;
14487 dwarf2_per_objfile->read_in_chain = &type_sig->per_cu;
14490 /* Decode simple location descriptions.
14491 Given a pointer to a dwarf block that defines a location, compute
14492 the location and return the value.
14494 NOTE drow/2003-11-18: This function is called in two situations
14495 now: for the address of static or global variables (partial symbols
14496 only) and for offsets into structures which are expected to be
14497 (more or less) constant. The partial symbol case should go away,
14498 and only the constant case should remain. That will let this
14499 function complain more accurately. A few special modes are allowed
14500 without complaint for global variables (for instance, global
14501 register values and thread-local values).
14503 A location description containing no operations indicates that the
14504 object is optimized out. The return value is 0 for that case.
14505 FIXME drow/2003-11-16: No callers check for this case any more; soon all
14506 callers will only want a very basic result and this can become a
14509 Note that stack[0] is unused except as a default error return. */
14512 decode_locdesc (struct dwarf_block *blk, struct dwarf2_cu *cu)
14514 struct objfile *objfile = cu->objfile;
14516 int size = blk->size;
14517 gdb_byte *data = blk->data;
14518 CORE_ADDR stack[64];
14520 unsigned int bytes_read, unsnd;
14526 stack[++stacki] = 0;
14565 stack[++stacki] = op - DW_OP_lit0;
14600 stack[++stacki] = op - DW_OP_reg0;
14602 dwarf2_complex_location_expr_complaint ();
14606 unsnd = read_unsigned_leb128 (NULL, (data + i), &bytes_read);
14608 stack[++stacki] = unsnd;
14610 dwarf2_complex_location_expr_complaint ();
14614 stack[++stacki] = read_address (objfile->obfd, &data[i],
14619 case DW_OP_const1u:
14620 stack[++stacki] = read_1_byte (objfile->obfd, &data[i]);
14624 case DW_OP_const1s:
14625 stack[++stacki] = read_1_signed_byte (objfile->obfd, &data[i]);
14629 case DW_OP_const2u:
14630 stack[++stacki] = read_2_bytes (objfile->obfd, &data[i]);
14634 case DW_OP_const2s:
14635 stack[++stacki] = read_2_signed_bytes (objfile->obfd, &data[i]);
14639 case DW_OP_const4u:
14640 stack[++stacki] = read_4_bytes (objfile->obfd, &data[i]);
14644 case DW_OP_const4s:
14645 stack[++stacki] = read_4_signed_bytes (objfile->obfd, &data[i]);
14650 stack[++stacki] = read_unsigned_leb128 (NULL, (data + i),
14656 stack[++stacki] = read_signed_leb128 (NULL, (data + i), &bytes_read);
14661 stack[stacki + 1] = stack[stacki];
14666 stack[stacki - 1] += stack[stacki];
14670 case DW_OP_plus_uconst:
14671 stack[stacki] += read_unsigned_leb128 (NULL, (data + i),
14677 stack[stacki - 1] -= stack[stacki];
14682 /* If we're not the last op, then we definitely can't encode
14683 this using GDB's address_class enum. This is valid for partial
14684 global symbols, although the variable's address will be bogus
14687 dwarf2_complex_location_expr_complaint ();
14690 case DW_OP_GNU_push_tls_address:
14691 /* The top of the stack has the offset from the beginning
14692 of the thread control block at which the variable is located. */
14693 /* Nothing should follow this operator, so the top of stack would
14695 /* This is valid for partial global symbols, but the variable's
14696 address will be bogus in the psymtab. */
14698 dwarf2_complex_location_expr_complaint ();
14701 case DW_OP_GNU_uninit:
14706 const char *name = dwarf_stack_op_name (op);
14709 complaint (&symfile_complaints, _("unsupported stack op: '%s'"),
14712 complaint (&symfile_complaints, _("unsupported stack op: '%02x'"),
14716 return (stack[stacki]);
14719 /* Enforce maximum stack depth of SIZE-1 to avoid writing
14720 outside of the allocated space. Also enforce minimum>0. */
14721 if (stacki >= ARRAY_SIZE (stack) - 1)
14723 complaint (&symfile_complaints,
14724 _("location description stack overflow"));
14730 complaint (&symfile_complaints,
14731 _("location description stack underflow"));
14735 return (stack[stacki]);
14738 /* memory allocation interface */
14740 static struct dwarf_block *
14741 dwarf_alloc_block (struct dwarf2_cu *cu)
14743 struct dwarf_block *blk;
14745 blk = (struct dwarf_block *)
14746 obstack_alloc (&cu->comp_unit_obstack, sizeof (struct dwarf_block));
14750 static struct abbrev_info *
14751 dwarf_alloc_abbrev (struct dwarf2_cu *cu)
14753 struct abbrev_info *abbrev;
14755 abbrev = (struct abbrev_info *)
14756 obstack_alloc (&cu->abbrev_obstack, sizeof (struct abbrev_info));
14757 memset (abbrev, 0, sizeof (struct abbrev_info));
14761 static struct die_info *
14762 dwarf_alloc_die (struct dwarf2_cu *cu, int num_attrs)
14764 struct die_info *die;
14765 size_t size = sizeof (struct die_info);
14768 size += (num_attrs - 1) * sizeof (struct attribute);
14770 die = (struct die_info *) obstack_alloc (&cu->comp_unit_obstack, size);
14771 memset (die, 0, sizeof (struct die_info));
14776 /* Macro support. */
14778 /* Return the full name of file number I in *LH's file name table.
14779 Use COMP_DIR as the name of the current directory of the
14780 compilation. The result is allocated using xmalloc; the caller is
14781 responsible for freeing it. */
14783 file_full_name (int file, struct line_header *lh, const char *comp_dir)
14785 /* Is the file number a valid index into the line header's file name
14786 table? Remember that file numbers start with one, not zero. */
14787 if (1 <= file && file <= lh->num_file_names)
14789 struct file_entry *fe = &lh->file_names[file - 1];
14791 if (IS_ABSOLUTE_PATH (fe->name))
14792 return xstrdup (fe->name);
14800 dir = lh->include_dirs[fe->dir_index - 1];
14806 dir_len = strlen (dir);
14807 full_name = xmalloc (dir_len + 1 + strlen (fe->name) + 1);
14808 strcpy (full_name, dir);
14809 full_name[dir_len] = '/';
14810 strcpy (full_name + dir_len + 1, fe->name);
14814 return xstrdup (fe->name);
14819 /* The compiler produced a bogus file number. We can at least
14820 record the macro definitions made in the file, even if we
14821 won't be able to find the file by name. */
14822 char fake_name[80];
14824 sprintf (fake_name, "<bad macro file number %d>", file);
14826 complaint (&symfile_complaints,
14827 _("bad file number in macro information (%d)"),
14830 return xstrdup (fake_name);
14835 static struct macro_source_file *
14836 macro_start_file (int file, int line,
14837 struct macro_source_file *current_file,
14838 const char *comp_dir,
14839 struct line_header *lh, struct objfile *objfile)
14841 /* The full name of this source file. */
14842 char *full_name = file_full_name (file, lh, comp_dir);
14844 /* We don't create a macro table for this compilation unit
14845 at all until we actually get a filename. */
14846 if (! pending_macros)
14847 pending_macros = new_macro_table (&objfile->objfile_obstack,
14848 objfile->macro_cache);
14850 if (! current_file)
14851 /* If we have no current file, then this must be the start_file
14852 directive for the compilation unit's main source file. */
14853 current_file = macro_set_main (pending_macros, full_name);
14855 current_file = macro_include (current_file, line, full_name);
14859 return current_file;
14863 /* Copy the LEN characters at BUF to a xmalloc'ed block of memory,
14864 followed by a null byte. */
14866 copy_string (const char *buf, int len)
14868 char *s = xmalloc (len + 1);
14870 memcpy (s, buf, len);
14876 static const char *
14877 consume_improper_spaces (const char *p, const char *body)
14881 complaint (&symfile_complaints,
14882 _("macro definition contains spaces "
14883 "in formal argument list:\n`%s'"),
14895 parse_macro_definition (struct macro_source_file *file, int line,
14900 /* The body string takes one of two forms. For object-like macro
14901 definitions, it should be:
14903 <macro name> " " <definition>
14905 For function-like macro definitions, it should be:
14907 <macro name> "() " <definition>
14909 <macro name> "(" <arg name> ( "," <arg name> ) * ") " <definition>
14911 Spaces may appear only where explicitly indicated, and in the
14914 The Dwarf 2 spec says that an object-like macro's name is always
14915 followed by a space, but versions of GCC around March 2002 omit
14916 the space when the macro's definition is the empty string.
14918 The Dwarf 2 spec says that there should be no spaces between the
14919 formal arguments in a function-like macro's formal argument list,
14920 but versions of GCC around March 2002 include spaces after the
14924 /* Find the extent of the macro name. The macro name is terminated
14925 by either a space or null character (for an object-like macro) or
14926 an opening paren (for a function-like macro). */
14927 for (p = body; *p; p++)
14928 if (*p == ' ' || *p == '(')
14931 if (*p == ' ' || *p == '\0')
14933 /* It's an object-like macro. */
14934 int name_len = p - body;
14935 char *name = copy_string (body, name_len);
14936 const char *replacement;
14939 replacement = body + name_len + 1;
14942 dwarf2_macro_malformed_definition_complaint (body);
14943 replacement = body + name_len;
14946 macro_define_object (file, line, name, replacement);
14950 else if (*p == '(')
14952 /* It's a function-like macro. */
14953 char *name = copy_string (body, p - body);
14956 char **argv = xmalloc (argv_size * sizeof (*argv));
14960 p = consume_improper_spaces (p, body);
14962 /* Parse the formal argument list. */
14963 while (*p && *p != ')')
14965 /* Find the extent of the current argument name. */
14966 const char *arg_start = p;
14968 while (*p && *p != ',' && *p != ')' && *p != ' ')
14971 if (! *p || p == arg_start)
14972 dwarf2_macro_malformed_definition_complaint (body);
14975 /* Make sure argv has room for the new argument. */
14976 if (argc >= argv_size)
14979 argv = xrealloc (argv, argv_size * sizeof (*argv));
14982 argv[argc++] = copy_string (arg_start, p - arg_start);
14985 p = consume_improper_spaces (p, body);
14987 /* Consume the comma, if present. */
14992 p = consume_improper_spaces (p, body);
15001 /* Perfectly formed definition, no complaints. */
15002 macro_define_function (file, line, name,
15003 argc, (const char **) argv,
15005 else if (*p == '\0')
15007 /* Complain, but do define it. */
15008 dwarf2_macro_malformed_definition_complaint (body);
15009 macro_define_function (file, line, name,
15010 argc, (const char **) argv,
15014 /* Just complain. */
15015 dwarf2_macro_malformed_definition_complaint (body);
15018 /* Just complain. */
15019 dwarf2_macro_malformed_definition_complaint (body);
15025 for (i = 0; i < argc; i++)
15031 dwarf2_macro_malformed_definition_complaint (body);
15034 /* Skip some bytes from BYTES according to the form given in FORM.
15035 Returns the new pointer. */
15038 skip_form_bytes (bfd *abfd, gdb_byte *bytes,
15039 enum dwarf_form form,
15040 unsigned int offset_size,
15041 struct dwarf2_section_info *section)
15043 unsigned int bytes_read;
15047 case DW_FORM_data1:
15052 case DW_FORM_data2:
15056 case DW_FORM_data4:
15060 case DW_FORM_data8:
15064 case DW_FORM_string:
15065 read_direct_string (abfd, bytes, &bytes_read);
15066 bytes += bytes_read;
15069 case DW_FORM_sec_offset:
15071 bytes += offset_size;
15074 case DW_FORM_block:
15075 bytes += read_unsigned_leb128 (abfd, bytes, &bytes_read);
15076 bytes += bytes_read;
15079 case DW_FORM_block1:
15080 bytes += 1 + read_1_byte (abfd, bytes);
15082 case DW_FORM_block2:
15083 bytes += 2 + read_2_bytes (abfd, bytes);
15085 case DW_FORM_block4:
15086 bytes += 4 + read_4_bytes (abfd, bytes);
15089 case DW_FORM_sdata:
15090 case DW_FORM_udata:
15091 bytes = skip_leb128 (abfd, bytes);
15097 complaint (&symfile_complaints,
15098 _("invalid form 0x%x in `%s'"),
15100 section->asection->name);
15108 /* A helper for dwarf_decode_macros that handles skipping an unknown
15109 opcode. Returns an updated pointer to the macro data buffer; or,
15110 on error, issues a complaint and returns NULL. */
15113 skip_unknown_opcode (unsigned int opcode,
15114 gdb_byte **opcode_definitions,
15117 unsigned int offset_size,
15118 struct dwarf2_section_info *section)
15120 unsigned int bytes_read, i;
15124 if (opcode_definitions[opcode] == NULL)
15126 complaint (&symfile_complaints,
15127 _("unrecognized DW_MACFINO opcode 0x%x"),
15132 defn = opcode_definitions[opcode];
15133 arg = read_unsigned_leb128 (abfd, defn, &bytes_read);
15134 defn += bytes_read;
15136 for (i = 0; i < arg; ++i)
15138 mac_ptr = skip_form_bytes (abfd, mac_ptr, defn[i], offset_size, section);
15139 if (mac_ptr == NULL)
15141 /* skip_form_bytes already issued the complaint. */
15149 /* A helper function which parses the header of a macro section.
15150 If the macro section is the extended (for now called "GNU") type,
15151 then this updates *OFFSET_SIZE. Returns a pointer to just after
15152 the header, or issues a complaint and returns NULL on error. */
15155 dwarf_parse_macro_header (gdb_byte **opcode_definitions,
15158 unsigned int *offset_size,
15159 int section_is_gnu)
15161 memset (opcode_definitions, 0, 256 * sizeof (gdb_byte *));
15163 if (section_is_gnu)
15165 unsigned int version, flags;
15167 version = read_2_bytes (abfd, mac_ptr);
15170 complaint (&symfile_complaints,
15171 _("unrecognized version `%d' in .debug_macro section"),
15177 flags = read_1_byte (abfd, mac_ptr);
15179 *offset_size = (flags & 1) ? 8 : 4;
15181 if ((flags & 2) != 0)
15182 /* We don't need the line table offset. */
15183 mac_ptr += *offset_size;
15185 /* Vendor opcode descriptions. */
15186 if ((flags & 4) != 0)
15188 unsigned int i, count;
15190 count = read_1_byte (abfd, mac_ptr);
15192 for (i = 0; i < count; ++i)
15194 unsigned int opcode, bytes_read;
15197 opcode = read_1_byte (abfd, mac_ptr);
15199 opcode_definitions[opcode] = mac_ptr;
15200 arg = read_unsigned_leb128 (abfd, mac_ptr, &bytes_read);
15201 mac_ptr += bytes_read;
15210 /* A helper for dwarf_decode_macros that handles the GNU extensions,
15211 including DW_GNU_MACINFO_transparent_include. */
15214 dwarf_decode_macro_bytes (bfd *abfd, gdb_byte *mac_ptr, gdb_byte *mac_end,
15215 struct macro_source_file *current_file,
15216 struct line_header *lh, char *comp_dir,
15217 struct dwarf2_section_info *section,
15218 int section_is_gnu,
15219 unsigned int offset_size,
15220 struct objfile *objfile)
15222 enum dwarf_macro_record_type macinfo_type;
15223 int at_commandline;
15224 gdb_byte *opcode_definitions[256];
15226 mac_ptr = dwarf_parse_macro_header (opcode_definitions, abfd, mac_ptr,
15227 &offset_size, section_is_gnu);
15228 if (mac_ptr == NULL)
15230 /* We already issued a complaint. */
15234 /* Determines if GDB is still before first DW_MACINFO_start_file. If true
15235 GDB is still reading the definitions from command line. First
15236 DW_MACINFO_start_file will need to be ignored as it was already executed
15237 to create CURRENT_FILE for the main source holding also the command line
15238 definitions. On first met DW_MACINFO_start_file this flag is reset to
15239 normally execute all the remaining DW_MACINFO_start_file macinfos. */
15241 at_commandline = 1;
15245 /* Do we at least have room for a macinfo type byte? */
15246 if (mac_ptr >= mac_end)
15248 dwarf2_macros_too_long_complaint (section);
15252 macinfo_type = read_1_byte (abfd, mac_ptr);
15255 /* Note that we rely on the fact that the corresponding GNU and
15256 DWARF constants are the same. */
15257 switch (macinfo_type)
15259 /* A zero macinfo type indicates the end of the macro
15264 case DW_MACRO_GNU_define:
15265 case DW_MACRO_GNU_undef:
15266 case DW_MACRO_GNU_define_indirect:
15267 case DW_MACRO_GNU_undef_indirect:
15269 unsigned int bytes_read;
15274 line = read_unsigned_leb128 (abfd, mac_ptr, &bytes_read);
15275 mac_ptr += bytes_read;
15277 if (macinfo_type == DW_MACRO_GNU_define
15278 || macinfo_type == DW_MACRO_GNU_undef)
15280 body = read_direct_string (abfd, mac_ptr, &bytes_read);
15281 mac_ptr += bytes_read;
15285 LONGEST str_offset;
15287 str_offset = read_offset_1 (abfd, mac_ptr, offset_size);
15288 mac_ptr += offset_size;
15290 body = read_indirect_string_at_offset (abfd, str_offset);
15293 is_define = (macinfo_type == DW_MACRO_GNU_define
15294 || macinfo_type == DW_MACRO_GNU_define_indirect);
15295 if (! current_file)
15297 /* DWARF violation as no main source is present. */
15298 complaint (&symfile_complaints,
15299 _("debug info with no main source gives macro %s "
15301 is_define ? _("definition") : _("undefinition"),
15305 if ((line == 0 && !at_commandline)
15306 || (line != 0 && at_commandline))
15307 complaint (&symfile_complaints,
15308 _("debug info gives %s macro %s with %s line %d: %s"),
15309 at_commandline ? _("command-line") : _("in-file"),
15310 is_define ? _("definition") : _("undefinition"),
15311 line == 0 ? _("zero") : _("non-zero"), line, body);
15314 parse_macro_definition (current_file, line, body);
15317 gdb_assert (macinfo_type == DW_MACRO_GNU_undef
15318 || macinfo_type == DW_MACRO_GNU_undef_indirect);
15319 macro_undef (current_file, line, body);
15324 case DW_MACRO_GNU_start_file:
15326 unsigned int bytes_read;
15329 line = read_unsigned_leb128 (abfd, mac_ptr, &bytes_read);
15330 mac_ptr += bytes_read;
15331 file = read_unsigned_leb128 (abfd, mac_ptr, &bytes_read);
15332 mac_ptr += bytes_read;
15334 if ((line == 0 && !at_commandline)
15335 || (line != 0 && at_commandline))
15336 complaint (&symfile_complaints,
15337 _("debug info gives source %d included "
15338 "from %s at %s line %d"),
15339 file, at_commandline ? _("command-line") : _("file"),
15340 line == 0 ? _("zero") : _("non-zero"), line);
15342 if (at_commandline)
15344 /* This DW_MACRO_GNU_start_file was executed in the
15346 at_commandline = 0;
15349 current_file = macro_start_file (file, line,
15350 current_file, comp_dir,
15355 case DW_MACRO_GNU_end_file:
15356 if (! current_file)
15357 complaint (&symfile_complaints,
15358 _("macro debug info has an unmatched "
15359 "`close_file' directive"));
15362 current_file = current_file->included_by;
15363 if (! current_file)
15365 enum dwarf_macro_record_type next_type;
15367 /* GCC circa March 2002 doesn't produce the zero
15368 type byte marking the end of the compilation
15369 unit. Complain if it's not there, but exit no
15372 /* Do we at least have room for a macinfo type byte? */
15373 if (mac_ptr >= mac_end)
15375 dwarf2_macros_too_long_complaint (section);
15379 /* We don't increment mac_ptr here, so this is just
15381 next_type = read_1_byte (abfd, mac_ptr);
15382 if (next_type != 0)
15383 complaint (&symfile_complaints,
15384 _("no terminating 0-type entry for "
15385 "macros in `.debug_macinfo' section"));
15392 case DW_MACRO_GNU_transparent_include:
15396 offset = read_offset_1 (abfd, mac_ptr, offset_size);
15397 mac_ptr += offset_size;
15399 dwarf_decode_macro_bytes (abfd,
15400 section->buffer + offset,
15401 mac_end, current_file,
15403 section, section_is_gnu,
15404 offset_size, objfile);
15408 case DW_MACINFO_vendor_ext:
15409 if (!section_is_gnu)
15411 unsigned int bytes_read;
15414 constant = read_unsigned_leb128 (abfd, mac_ptr, &bytes_read);
15415 mac_ptr += bytes_read;
15416 read_direct_string (abfd, mac_ptr, &bytes_read);
15417 mac_ptr += bytes_read;
15419 /* We don't recognize any vendor extensions. */
15425 mac_ptr = skip_unknown_opcode (macinfo_type, opcode_definitions,
15426 mac_ptr, abfd, offset_size,
15428 if (mac_ptr == NULL)
15432 } while (macinfo_type != 0);
15436 dwarf_decode_macros (struct line_header *lh, unsigned int offset,
15437 char *comp_dir, bfd *abfd,
15438 struct dwarf2_cu *cu,
15439 struct dwarf2_section_info *section,
15440 int section_is_gnu)
15442 gdb_byte *mac_ptr, *mac_end;
15443 struct macro_source_file *current_file = 0;
15444 enum dwarf_macro_record_type macinfo_type;
15445 unsigned int offset_size = cu->header.offset_size;
15446 gdb_byte *opcode_definitions[256];
15448 dwarf2_read_section (dwarf2_per_objfile->objfile, section);
15449 if (section->buffer == NULL)
15451 complaint (&symfile_complaints, _("missing %s section"),
15452 section->asection->name);
15456 /* First pass: Find the name of the base filename.
15457 This filename is needed in order to process all macros whose definition
15458 (or undefinition) comes from the command line. These macros are defined
15459 before the first DW_MACINFO_start_file entry, and yet still need to be
15460 associated to the base file.
15462 To determine the base file name, we scan the macro definitions until we
15463 reach the first DW_MACINFO_start_file entry. We then initialize
15464 CURRENT_FILE accordingly so that any macro definition found before the
15465 first DW_MACINFO_start_file can still be associated to the base file. */
15467 mac_ptr = section->buffer + offset;
15468 mac_end = section->buffer + section->size;
15470 mac_ptr = dwarf_parse_macro_header (opcode_definitions, abfd, mac_ptr,
15471 &offset_size, section_is_gnu);
15472 if (mac_ptr == NULL)
15474 /* We already issued a complaint. */
15480 /* Do we at least have room for a macinfo type byte? */
15481 if (mac_ptr >= mac_end)
15483 /* Complaint is printed during the second pass as GDB will probably
15484 stop the first pass earlier upon finding
15485 DW_MACINFO_start_file. */
15489 macinfo_type = read_1_byte (abfd, mac_ptr);
15492 /* Note that we rely on the fact that the corresponding GNU and
15493 DWARF constants are the same. */
15494 switch (macinfo_type)
15496 /* A zero macinfo type indicates the end of the macro
15501 case DW_MACRO_GNU_define:
15502 case DW_MACRO_GNU_undef:
15503 /* Only skip the data by MAC_PTR. */
15505 unsigned int bytes_read;
15507 read_unsigned_leb128 (abfd, mac_ptr, &bytes_read);
15508 mac_ptr += bytes_read;
15509 read_direct_string (abfd, mac_ptr, &bytes_read);
15510 mac_ptr += bytes_read;
15514 case DW_MACRO_GNU_start_file:
15516 unsigned int bytes_read;
15519 line = read_unsigned_leb128 (abfd, mac_ptr, &bytes_read);
15520 mac_ptr += bytes_read;
15521 file = read_unsigned_leb128 (abfd, mac_ptr, &bytes_read);
15522 mac_ptr += bytes_read;
15524 current_file = macro_start_file (file, line, current_file,
15525 comp_dir, lh, cu->objfile);
15529 case DW_MACRO_GNU_end_file:
15530 /* No data to skip by MAC_PTR. */
15533 case DW_MACRO_GNU_define_indirect:
15534 case DW_MACRO_GNU_undef_indirect:
15536 unsigned int bytes_read;
15538 read_unsigned_leb128 (abfd, mac_ptr, &bytes_read);
15539 mac_ptr += bytes_read;
15540 mac_ptr += offset_size;
15544 case DW_MACRO_GNU_transparent_include:
15545 /* Note that, according to the spec, a transparent include
15546 chain cannot call DW_MACRO_GNU_start_file. So, we can just
15547 skip this opcode. */
15548 mac_ptr += offset_size;
15551 case DW_MACINFO_vendor_ext:
15552 /* Only skip the data by MAC_PTR. */
15553 if (!section_is_gnu)
15555 unsigned int bytes_read;
15557 read_unsigned_leb128 (abfd, mac_ptr, &bytes_read);
15558 mac_ptr += bytes_read;
15559 read_direct_string (abfd, mac_ptr, &bytes_read);
15560 mac_ptr += bytes_read;
15565 mac_ptr = skip_unknown_opcode (macinfo_type, opcode_definitions,
15566 mac_ptr, abfd, offset_size,
15568 if (mac_ptr == NULL)
15572 } while (macinfo_type != 0 && current_file == NULL);
15574 /* Second pass: Process all entries.
15576 Use the AT_COMMAND_LINE flag to determine whether we are still processing
15577 command-line macro definitions/undefinitions. This flag is unset when we
15578 reach the first DW_MACINFO_start_file entry. */
15580 dwarf_decode_macro_bytes (abfd, section->buffer + offset, mac_end,
15581 current_file, lh, comp_dir, section, section_is_gnu,
15582 offset_size, cu->objfile);
15585 /* Check if the attribute's form is a DW_FORM_block*
15586 if so return true else false. */
15588 attr_form_is_block (struct attribute *attr)
15590 return (attr == NULL ? 0 :
15591 attr->form == DW_FORM_block1
15592 || attr->form == DW_FORM_block2
15593 || attr->form == DW_FORM_block4
15594 || attr->form == DW_FORM_block
15595 || attr->form == DW_FORM_exprloc);
15598 /* Return non-zero if ATTR's value is a section offset --- classes
15599 lineptr, loclistptr, macptr or rangelistptr --- or zero, otherwise.
15600 You may use DW_UNSND (attr) to retrieve such offsets.
15602 Section 7.5.4, "Attribute Encodings", explains that no attribute
15603 may have a value that belongs to more than one of these classes; it
15604 would be ambiguous if we did, because we use the same forms for all
15607 attr_form_is_section_offset (struct attribute *attr)
15609 return (attr->form == DW_FORM_data4
15610 || attr->form == DW_FORM_data8
15611 || attr->form == DW_FORM_sec_offset);
15615 /* Return non-zero if ATTR's value falls in the 'constant' class, or
15616 zero otherwise. When this function returns true, you can apply
15617 dwarf2_get_attr_constant_value to it.
15619 However, note that for some attributes you must check
15620 attr_form_is_section_offset before using this test. DW_FORM_data4
15621 and DW_FORM_data8 are members of both the constant class, and of
15622 the classes that contain offsets into other debug sections
15623 (lineptr, loclistptr, macptr or rangelistptr). The DWARF spec says
15624 that, if an attribute's can be either a constant or one of the
15625 section offset classes, DW_FORM_data4 and DW_FORM_data8 should be
15626 taken as section offsets, not constants. */
15628 attr_form_is_constant (struct attribute *attr)
15630 switch (attr->form)
15632 case DW_FORM_sdata:
15633 case DW_FORM_udata:
15634 case DW_FORM_data1:
15635 case DW_FORM_data2:
15636 case DW_FORM_data4:
15637 case DW_FORM_data8:
15644 /* A helper function that fills in a dwarf2_loclist_baton. */
15647 fill_in_loclist_baton (struct dwarf2_cu *cu,
15648 struct dwarf2_loclist_baton *baton,
15649 struct attribute *attr)
15651 dwarf2_read_section (dwarf2_per_objfile->objfile,
15652 &dwarf2_per_objfile->loc);
15654 baton->per_cu = cu->per_cu;
15655 gdb_assert (baton->per_cu);
15656 /* We don't know how long the location list is, but make sure we
15657 don't run off the edge of the section. */
15658 baton->size = dwarf2_per_objfile->loc.size - DW_UNSND (attr);
15659 baton->data = dwarf2_per_objfile->loc.buffer + DW_UNSND (attr);
15660 baton->base_address = cu->base_address;
15664 dwarf2_symbol_mark_computed (struct attribute *attr, struct symbol *sym,
15665 struct dwarf2_cu *cu)
15667 if (attr_form_is_section_offset (attr)
15668 /* ".debug_loc" may not exist at all, or the offset may be outside
15669 the section. If so, fall through to the complaint in the
15671 && DW_UNSND (attr) < dwarf2_section_size (dwarf2_per_objfile->objfile,
15672 &dwarf2_per_objfile->loc))
15674 struct dwarf2_loclist_baton *baton;
15676 baton = obstack_alloc (&cu->objfile->objfile_obstack,
15677 sizeof (struct dwarf2_loclist_baton));
15679 fill_in_loclist_baton (cu, baton, attr);
15681 if (cu->base_known == 0)
15682 complaint (&symfile_complaints,
15683 _("Location list used without "
15684 "specifying the CU base address."));
15686 SYMBOL_COMPUTED_OPS (sym) = &dwarf2_loclist_funcs;
15687 SYMBOL_LOCATION_BATON (sym) = baton;
15691 struct dwarf2_locexpr_baton *baton;
15693 baton = obstack_alloc (&cu->objfile->objfile_obstack,
15694 sizeof (struct dwarf2_locexpr_baton));
15695 baton->per_cu = cu->per_cu;
15696 gdb_assert (baton->per_cu);
15698 if (attr_form_is_block (attr))
15700 /* Note that we're just copying the block's data pointer
15701 here, not the actual data. We're still pointing into the
15702 info_buffer for SYM's objfile; right now we never release
15703 that buffer, but when we do clean up properly this may
15705 baton->size = DW_BLOCK (attr)->size;
15706 baton->data = DW_BLOCK (attr)->data;
15710 dwarf2_invalid_attrib_class_complaint ("location description",
15711 SYMBOL_NATURAL_NAME (sym));
15715 SYMBOL_COMPUTED_OPS (sym) = &dwarf2_locexpr_funcs;
15716 SYMBOL_LOCATION_BATON (sym) = baton;
15720 /* Return the OBJFILE associated with the compilation unit CU. If CU
15721 came from a separate debuginfo file, then the master objfile is
15725 dwarf2_per_cu_objfile (struct dwarf2_per_cu_data *per_cu)
15727 struct objfile *objfile = per_cu->objfile;
15729 /* Return the master objfile, so that we can report and look up the
15730 correct file containing this variable. */
15731 if (objfile->separate_debug_objfile_backlink)
15732 objfile = objfile->separate_debug_objfile_backlink;
15737 /* Return comp_unit_head for PER_CU, either already available in PER_CU->CU
15738 (CU_HEADERP is unused in such case) or prepare a temporary copy at
15739 CU_HEADERP first. */
15741 static const struct comp_unit_head *
15742 per_cu_header_read_in (struct comp_unit_head *cu_headerp,
15743 struct dwarf2_per_cu_data *per_cu)
15745 struct objfile *objfile;
15746 struct dwarf2_per_objfile *per_objfile;
15747 gdb_byte *info_ptr;
15750 return &per_cu->cu->header;
15752 objfile = per_cu->objfile;
15753 per_objfile = objfile_data (objfile, dwarf2_objfile_data_key);
15754 info_ptr = per_objfile->info.buffer + per_cu->offset;
15756 memset (cu_headerp, 0, sizeof (*cu_headerp));
15757 read_comp_unit_head (cu_headerp, info_ptr, objfile->obfd);
15762 /* Return the address size given in the compilation unit header for CU. */
15765 dwarf2_per_cu_addr_size (struct dwarf2_per_cu_data *per_cu)
15767 struct comp_unit_head cu_header_local;
15768 const struct comp_unit_head *cu_headerp;
15770 cu_headerp = per_cu_header_read_in (&cu_header_local, per_cu);
15772 return cu_headerp->addr_size;
15775 /* Return the offset size given in the compilation unit header for CU. */
15778 dwarf2_per_cu_offset_size (struct dwarf2_per_cu_data *per_cu)
15780 struct comp_unit_head cu_header_local;
15781 const struct comp_unit_head *cu_headerp;
15783 cu_headerp = per_cu_header_read_in (&cu_header_local, per_cu);
15785 return cu_headerp->offset_size;
15788 /* See its dwarf2loc.h declaration. */
15791 dwarf2_per_cu_ref_addr_size (struct dwarf2_per_cu_data *per_cu)
15793 struct comp_unit_head cu_header_local;
15794 const struct comp_unit_head *cu_headerp;
15796 cu_headerp = per_cu_header_read_in (&cu_header_local, per_cu);
15798 if (cu_headerp->version == 2)
15799 return cu_headerp->addr_size;
15801 return cu_headerp->offset_size;
15804 /* Return the text offset of the CU. The returned offset comes from
15805 this CU's objfile. If this objfile came from a separate debuginfo
15806 file, then the offset may be different from the corresponding
15807 offset in the parent objfile. */
15810 dwarf2_per_cu_text_offset (struct dwarf2_per_cu_data *per_cu)
15812 struct objfile *objfile = per_cu->objfile;
15814 return ANOFFSET (objfile->section_offsets, SECT_OFF_TEXT (objfile));
15817 /* Locate the .debug_info compilation unit from CU's objfile which contains
15818 the DIE at OFFSET. Raises an error on failure. */
15820 static struct dwarf2_per_cu_data *
15821 dwarf2_find_containing_comp_unit (unsigned int offset,
15822 struct objfile *objfile)
15824 struct dwarf2_per_cu_data *this_cu;
15828 high = dwarf2_per_objfile->n_comp_units - 1;
15831 int mid = low + (high - low) / 2;
15833 if (dwarf2_per_objfile->all_comp_units[mid]->offset >= offset)
15838 gdb_assert (low == high);
15839 if (dwarf2_per_objfile->all_comp_units[low]->offset > offset)
15842 error (_("Dwarf Error: could not find partial DIE containing "
15843 "offset 0x%lx [in module %s]"),
15844 (long) offset, bfd_get_filename (objfile->obfd));
15846 gdb_assert (dwarf2_per_objfile->all_comp_units[low-1]->offset <= offset);
15847 return dwarf2_per_objfile->all_comp_units[low-1];
15851 this_cu = dwarf2_per_objfile->all_comp_units[low];
15852 if (low == dwarf2_per_objfile->n_comp_units - 1
15853 && offset >= this_cu->offset + this_cu->length)
15854 error (_("invalid dwarf2 offset %u"), offset);
15855 gdb_assert (offset < this_cu->offset + this_cu->length);
15860 /* Locate the compilation unit from OBJFILE which is located at exactly
15861 OFFSET. Raises an error on failure. */
15863 static struct dwarf2_per_cu_data *
15864 dwarf2_find_comp_unit (unsigned int offset, struct objfile *objfile)
15866 struct dwarf2_per_cu_data *this_cu;
15868 this_cu = dwarf2_find_containing_comp_unit (offset, objfile);
15869 if (this_cu->offset != offset)
15870 error (_("no compilation unit with offset %u."), offset);
15874 /* Initialize dwarf2_cu CU for OBJFILE in a pre-allocated space. */
15877 init_one_comp_unit (struct dwarf2_cu *cu, struct objfile *objfile)
15879 memset (cu, 0, sizeof (*cu));
15880 cu->objfile = objfile;
15881 obstack_init (&cu->comp_unit_obstack);
15884 /* Initialize basic fields of dwarf_cu CU according to DIE COMP_UNIT_DIE. */
15887 prepare_one_comp_unit (struct dwarf2_cu *cu, struct die_info *comp_unit_die)
15889 struct attribute *attr;
15891 /* Set the language we're debugging. */
15892 attr = dwarf2_attr (comp_unit_die, DW_AT_language, cu);
15894 set_cu_language (DW_UNSND (attr), cu);
15897 cu->language = language_minimal;
15898 cu->language_defn = language_def (cu->language);
15902 /* Release one cached compilation unit, CU. We unlink it from the tree
15903 of compilation units, but we don't remove it from the read_in_chain;
15904 the caller is responsible for that.
15905 NOTE: DATA is a void * because this function is also used as a
15906 cleanup routine. */
15909 free_one_comp_unit (void *data)
15911 struct dwarf2_cu *cu = data;
15913 if (cu->per_cu != NULL)
15914 cu->per_cu->cu = NULL;
15917 obstack_free (&cu->comp_unit_obstack, NULL);
15922 /* This cleanup function is passed the address of a dwarf2_cu on the stack
15923 when we're finished with it. We can't free the pointer itself, but be
15924 sure to unlink it from the cache. Also release any associated storage
15925 and perform cache maintenance.
15927 Only used during partial symbol parsing. */
15930 free_stack_comp_unit (void *data)
15932 struct dwarf2_cu *cu = data;
15934 obstack_free (&cu->comp_unit_obstack, NULL);
15935 cu->partial_dies = NULL;
15937 if (cu->per_cu != NULL)
15939 /* This compilation unit is on the stack in our caller, so we
15940 should not xfree it. Just unlink it. */
15941 cu->per_cu->cu = NULL;
15944 /* If we had a per-cu pointer, then we may have other compilation
15945 units loaded, so age them now. */
15946 age_cached_comp_units ();
15950 /* Free all cached compilation units. */
15953 free_cached_comp_units (void *data)
15955 struct dwarf2_per_cu_data *per_cu, **last_chain;
15957 per_cu = dwarf2_per_objfile->read_in_chain;
15958 last_chain = &dwarf2_per_objfile->read_in_chain;
15959 while (per_cu != NULL)
15961 struct dwarf2_per_cu_data *next_cu;
15963 next_cu = per_cu->cu->read_in_chain;
15965 free_one_comp_unit (per_cu->cu);
15966 *last_chain = next_cu;
15972 /* Increase the age counter on each cached compilation unit, and free
15973 any that are too old. */
15976 age_cached_comp_units (void)
15978 struct dwarf2_per_cu_data *per_cu, **last_chain;
15980 dwarf2_clear_marks (dwarf2_per_objfile->read_in_chain);
15981 per_cu = dwarf2_per_objfile->read_in_chain;
15982 while (per_cu != NULL)
15984 per_cu->cu->last_used ++;
15985 if (per_cu->cu->last_used <= dwarf2_max_cache_age)
15986 dwarf2_mark (per_cu->cu);
15987 per_cu = per_cu->cu->read_in_chain;
15990 per_cu = dwarf2_per_objfile->read_in_chain;
15991 last_chain = &dwarf2_per_objfile->read_in_chain;
15992 while (per_cu != NULL)
15994 struct dwarf2_per_cu_data *next_cu;
15996 next_cu = per_cu->cu->read_in_chain;
15998 if (!per_cu->cu->mark)
16000 free_one_comp_unit (per_cu->cu);
16001 *last_chain = next_cu;
16004 last_chain = &per_cu->cu->read_in_chain;
16010 /* Remove a single compilation unit from the cache. */
16013 free_one_cached_comp_unit (void *target_cu)
16015 struct dwarf2_per_cu_data *per_cu, **last_chain;
16017 per_cu = dwarf2_per_objfile->read_in_chain;
16018 last_chain = &dwarf2_per_objfile->read_in_chain;
16019 while (per_cu != NULL)
16021 struct dwarf2_per_cu_data *next_cu;
16023 next_cu = per_cu->cu->read_in_chain;
16025 if (per_cu->cu == target_cu)
16027 free_one_comp_unit (per_cu->cu);
16028 *last_chain = next_cu;
16032 last_chain = &per_cu->cu->read_in_chain;
16038 /* Release all extra memory associated with OBJFILE. */
16041 dwarf2_free_objfile (struct objfile *objfile)
16043 dwarf2_per_objfile = objfile_data (objfile, dwarf2_objfile_data_key);
16045 if (dwarf2_per_objfile == NULL)
16048 /* Cached DIE trees use xmalloc and the comp_unit_obstack. */
16049 free_cached_comp_units (NULL);
16051 if (dwarf2_per_objfile->quick_file_names_table)
16052 htab_delete (dwarf2_per_objfile->quick_file_names_table);
16054 /* Everything else should be on the objfile obstack. */
16057 /* A pair of DIE offset and GDB type pointer. We store these
16058 in a hash table separate from the DIEs, and preserve them
16059 when the DIEs are flushed out of cache. */
16061 struct dwarf2_offset_and_type
16063 unsigned int offset;
16067 /* Hash function for a dwarf2_offset_and_type. */
16070 offset_and_type_hash (const void *item)
16072 const struct dwarf2_offset_and_type *ofs = item;
16074 return ofs->offset;
16077 /* Equality function for a dwarf2_offset_and_type. */
16080 offset_and_type_eq (const void *item_lhs, const void *item_rhs)
16082 const struct dwarf2_offset_and_type *ofs_lhs = item_lhs;
16083 const struct dwarf2_offset_and_type *ofs_rhs = item_rhs;
16085 return ofs_lhs->offset == ofs_rhs->offset;
16088 /* Set the type associated with DIE to TYPE. Save it in CU's hash
16089 table if necessary. For convenience, return TYPE.
16091 The DIEs reading must have careful ordering to:
16092 * Not cause infite loops trying to read in DIEs as a prerequisite for
16093 reading current DIE.
16094 * Not trying to dereference contents of still incompletely read in types
16095 while reading in other DIEs.
16096 * Enable referencing still incompletely read in types just by a pointer to
16097 the type without accessing its fields.
16099 Therefore caller should follow these rules:
16100 * Try to fetch any prerequisite types we may need to build this DIE type
16101 before building the type and calling set_die_type.
16102 * After building type call set_die_type for current DIE as soon as
16103 possible before fetching more types to complete the current type.
16104 * Make the type as complete as possible before fetching more types. */
16106 static struct type *
16107 set_die_type (struct die_info *die, struct type *type, struct dwarf2_cu *cu)
16109 struct dwarf2_offset_and_type **slot, ofs;
16110 struct objfile *objfile = cu->objfile;
16111 htab_t *type_hash_ptr;
16113 /* For Ada types, make sure that the gnat-specific data is always
16114 initialized (if not already set). There are a few types where
16115 we should not be doing so, because the type-specific area is
16116 already used to hold some other piece of info (eg: TYPE_CODE_FLT
16117 where the type-specific area is used to store the floatformat).
16118 But this is not a problem, because the gnat-specific information
16119 is actually not needed for these types. */
16120 if (need_gnat_info (cu)
16121 && TYPE_CODE (type) != TYPE_CODE_FUNC
16122 && TYPE_CODE (type) != TYPE_CODE_FLT
16123 && !HAVE_GNAT_AUX_INFO (type))
16124 INIT_GNAT_SPECIFIC (type);
16126 if (cu->per_cu->debug_type_section)
16127 type_hash_ptr = &dwarf2_per_objfile->debug_types_type_hash;
16129 type_hash_ptr = &dwarf2_per_objfile->debug_info_type_hash;
16131 if (*type_hash_ptr == NULL)
16134 = htab_create_alloc_ex (127,
16135 offset_and_type_hash,
16136 offset_and_type_eq,
16138 &objfile->objfile_obstack,
16139 hashtab_obstack_allocate,
16140 dummy_obstack_deallocate);
16143 ofs.offset = die->offset;
16145 slot = (struct dwarf2_offset_and_type **)
16146 htab_find_slot_with_hash (*type_hash_ptr, &ofs, ofs.offset, INSERT);
16148 complaint (&symfile_complaints,
16149 _("A problem internal to GDB: DIE 0x%x has type already set"),
16151 *slot = obstack_alloc (&objfile->objfile_obstack, sizeof (**slot));
16156 /* Look up the type for the die at DIE_OFFSET in the appropriate type_hash
16157 table, or return NULL if the die does not have a saved type. */
16159 static struct type *
16160 get_die_type_at_offset (unsigned int offset,
16161 struct dwarf2_per_cu_data *per_cu)
16163 struct dwarf2_offset_and_type *slot, ofs;
16166 if (per_cu->debug_type_section)
16167 type_hash = dwarf2_per_objfile->debug_types_type_hash;
16169 type_hash = dwarf2_per_objfile->debug_info_type_hash;
16170 if (type_hash == NULL)
16173 ofs.offset = offset;
16174 slot = htab_find_with_hash (type_hash, &ofs, ofs.offset);
16181 /* Look up the type for DIE in the appropriate type_hash table,
16182 or return NULL if DIE does not have a saved type. */
16184 static struct type *
16185 get_die_type (struct die_info *die, struct dwarf2_cu *cu)
16187 return get_die_type_at_offset (die->offset, cu->per_cu);
16190 /* Add a dependence relationship from CU to REF_PER_CU. */
16193 dwarf2_add_dependence (struct dwarf2_cu *cu,
16194 struct dwarf2_per_cu_data *ref_per_cu)
16198 if (cu->dependencies == NULL)
16200 = htab_create_alloc_ex (5, htab_hash_pointer, htab_eq_pointer,
16201 NULL, &cu->comp_unit_obstack,
16202 hashtab_obstack_allocate,
16203 dummy_obstack_deallocate);
16205 slot = htab_find_slot (cu->dependencies, ref_per_cu, INSERT);
16207 *slot = ref_per_cu;
16210 /* Subroutine of dwarf2_mark to pass to htab_traverse.
16211 Set the mark field in every compilation unit in the
16212 cache that we must keep because we are keeping CU. */
16215 dwarf2_mark_helper (void **slot, void *data)
16217 struct dwarf2_per_cu_data *per_cu;
16219 per_cu = (struct dwarf2_per_cu_data *) *slot;
16221 /* cu->dependencies references may not yet have been ever read if QUIT aborts
16222 reading of the chain. As such dependencies remain valid it is not much
16223 useful to track and undo them during QUIT cleanups. */
16224 if (per_cu->cu == NULL)
16227 if (per_cu->cu->mark)
16229 per_cu->cu->mark = 1;
16231 if (per_cu->cu->dependencies != NULL)
16232 htab_traverse (per_cu->cu->dependencies, dwarf2_mark_helper, NULL);
16237 /* Set the mark field in CU and in every other compilation unit in the
16238 cache that we must keep because we are keeping CU. */
16241 dwarf2_mark (struct dwarf2_cu *cu)
16246 if (cu->dependencies != NULL)
16247 htab_traverse (cu->dependencies, dwarf2_mark_helper, NULL);
16251 dwarf2_clear_marks (struct dwarf2_per_cu_data *per_cu)
16255 per_cu->cu->mark = 0;
16256 per_cu = per_cu->cu->read_in_chain;
16260 /* Trivial hash function for partial_die_info: the hash value of a DIE
16261 is its offset in .debug_info for this objfile. */
16264 partial_die_hash (const void *item)
16266 const struct partial_die_info *part_die = item;
16268 return part_die->offset;
16271 /* Trivial comparison function for partial_die_info structures: two DIEs
16272 are equal if they have the same offset. */
16275 partial_die_eq (const void *item_lhs, const void *item_rhs)
16277 const struct partial_die_info *part_die_lhs = item_lhs;
16278 const struct partial_die_info *part_die_rhs = item_rhs;
16280 return part_die_lhs->offset == part_die_rhs->offset;
16283 static struct cmd_list_element *set_dwarf2_cmdlist;
16284 static struct cmd_list_element *show_dwarf2_cmdlist;
16287 set_dwarf2_cmd (char *args, int from_tty)
16289 help_list (set_dwarf2_cmdlist, "maintenance set dwarf2 ", -1, gdb_stdout);
16293 show_dwarf2_cmd (char *args, int from_tty)
16295 cmd_show_list (show_dwarf2_cmdlist, from_tty, "");
16298 /* If section described by INFO was mmapped, munmap it now. */
16301 munmap_section_buffer (struct dwarf2_section_info *info)
16303 if (info->map_addr != NULL)
16308 res = munmap (info->map_addr, info->map_len);
16309 gdb_assert (res == 0);
16311 /* Without HAVE_MMAP, we should never be here to begin with. */
16312 gdb_assert_not_reached ("no mmap support");
16317 /* munmap debug sections for OBJFILE, if necessary. */
16320 dwarf2_per_objfile_free (struct objfile *objfile, void *d)
16322 struct dwarf2_per_objfile *data = d;
16324 struct dwarf2_section_info *section;
16326 /* This is sorted according to the order they're defined in to make it easier
16327 to keep in sync. */
16328 munmap_section_buffer (&data->info);
16329 munmap_section_buffer (&data->abbrev);
16330 munmap_section_buffer (&data->line);
16331 munmap_section_buffer (&data->loc);
16332 munmap_section_buffer (&data->macinfo);
16333 munmap_section_buffer (&data->macro);
16334 munmap_section_buffer (&data->str);
16335 munmap_section_buffer (&data->ranges);
16336 munmap_section_buffer (&data->frame);
16337 munmap_section_buffer (&data->eh_frame);
16338 munmap_section_buffer (&data->gdb_index);
16341 VEC_iterate (dwarf2_section_info_def, data->types, ix, section);
16343 munmap_section_buffer (section);
16345 VEC_free (dwarf2_section_info_def, data->types);
16349 /* The "save gdb-index" command. */
16351 /* The contents of the hash table we create when building the string
16353 struct strtab_entry
16355 offset_type offset;
16359 /* Hash function for a strtab_entry.
16361 Function is used only during write_hash_table so no index format backward
16362 compatibility is needed. */
16365 hash_strtab_entry (const void *e)
16367 const struct strtab_entry *entry = e;
16368 return mapped_index_string_hash (INT_MAX, entry->str);
16371 /* Equality function for a strtab_entry. */
16374 eq_strtab_entry (const void *a, const void *b)
16376 const struct strtab_entry *ea = a;
16377 const struct strtab_entry *eb = b;
16378 return !strcmp (ea->str, eb->str);
16381 /* Create a strtab_entry hash table. */
16384 create_strtab (void)
16386 return htab_create_alloc (100, hash_strtab_entry, eq_strtab_entry,
16387 xfree, xcalloc, xfree);
16390 /* Add a string to the constant pool. Return the string's offset in
16394 add_string (htab_t table, struct obstack *cpool, const char *str)
16397 struct strtab_entry entry;
16398 struct strtab_entry *result;
16401 slot = htab_find_slot (table, &entry, INSERT);
16406 result = XNEW (struct strtab_entry);
16407 result->offset = obstack_object_size (cpool);
16409 obstack_grow_str0 (cpool, str);
16412 return result->offset;
16415 /* An entry in the symbol table. */
16416 struct symtab_index_entry
16418 /* The name of the symbol. */
16420 /* The offset of the name in the constant pool. */
16421 offset_type index_offset;
16422 /* A sorted vector of the indices of all the CUs that hold an object
16424 VEC (offset_type) *cu_indices;
16427 /* The symbol table. This is a power-of-2-sized hash table. */
16428 struct mapped_symtab
16430 offset_type n_elements;
16432 struct symtab_index_entry **data;
16435 /* Hash function for a symtab_index_entry. */
16438 hash_symtab_entry (const void *e)
16440 const struct symtab_index_entry *entry = e;
16441 return iterative_hash (VEC_address (offset_type, entry->cu_indices),
16442 sizeof (offset_type) * VEC_length (offset_type,
16443 entry->cu_indices),
16447 /* Equality function for a symtab_index_entry. */
16450 eq_symtab_entry (const void *a, const void *b)
16452 const struct symtab_index_entry *ea = a;
16453 const struct symtab_index_entry *eb = b;
16454 int len = VEC_length (offset_type, ea->cu_indices);
16455 if (len != VEC_length (offset_type, eb->cu_indices))
16457 return !memcmp (VEC_address (offset_type, ea->cu_indices),
16458 VEC_address (offset_type, eb->cu_indices),
16459 sizeof (offset_type) * len);
16462 /* Destroy a symtab_index_entry. */
16465 delete_symtab_entry (void *p)
16467 struct symtab_index_entry *entry = p;
16468 VEC_free (offset_type, entry->cu_indices);
16472 /* Create a hash table holding symtab_index_entry objects. */
16475 create_symbol_hash_table (void)
16477 return htab_create_alloc (100, hash_symtab_entry, eq_symtab_entry,
16478 delete_symtab_entry, xcalloc, xfree);
16481 /* Create a new mapped symtab object. */
16483 static struct mapped_symtab *
16484 create_mapped_symtab (void)
16486 struct mapped_symtab *symtab = XNEW (struct mapped_symtab);
16487 symtab->n_elements = 0;
16488 symtab->size = 1024;
16489 symtab->data = XCNEWVEC (struct symtab_index_entry *, symtab->size);
16493 /* Destroy a mapped_symtab. */
16496 cleanup_mapped_symtab (void *p)
16498 struct mapped_symtab *symtab = p;
16499 /* The contents of the array are freed when the other hash table is
16501 xfree (symtab->data);
16505 /* Find a slot in SYMTAB for the symbol NAME. Returns a pointer to
16508 Function is used only during write_hash_table so no index format backward
16509 compatibility is needed. */
16511 static struct symtab_index_entry **
16512 find_slot (struct mapped_symtab *symtab, const char *name)
16514 offset_type index, step, hash = mapped_index_string_hash (INT_MAX, name);
16516 index = hash & (symtab->size - 1);
16517 step = ((hash * 17) & (symtab->size - 1)) | 1;
16521 if (!symtab->data[index] || !strcmp (name, symtab->data[index]->name))
16522 return &symtab->data[index];
16523 index = (index + step) & (symtab->size - 1);
16527 /* Expand SYMTAB's hash table. */
16530 hash_expand (struct mapped_symtab *symtab)
16532 offset_type old_size = symtab->size;
16534 struct symtab_index_entry **old_entries = symtab->data;
16537 symtab->data = XCNEWVEC (struct symtab_index_entry *, symtab->size);
16539 for (i = 0; i < old_size; ++i)
16541 if (old_entries[i])
16543 struct symtab_index_entry **slot = find_slot (symtab,
16544 old_entries[i]->name);
16545 *slot = old_entries[i];
16549 xfree (old_entries);
16552 /* Add an entry to SYMTAB. NAME is the name of the symbol. CU_INDEX
16553 is the index of the CU in which the symbol appears. */
16556 add_index_entry (struct mapped_symtab *symtab, const char *name,
16557 offset_type cu_index)
16559 struct symtab_index_entry **slot;
16561 ++symtab->n_elements;
16562 if (4 * symtab->n_elements / 3 >= symtab->size)
16563 hash_expand (symtab);
16565 slot = find_slot (symtab, name);
16568 *slot = XNEW (struct symtab_index_entry);
16569 (*slot)->name = name;
16570 (*slot)->cu_indices = NULL;
16572 /* Don't push an index twice. Due to how we add entries we only
16573 have to check the last one. */
16574 if (VEC_empty (offset_type, (*slot)->cu_indices)
16575 || VEC_last (offset_type, (*slot)->cu_indices) != cu_index)
16576 VEC_safe_push (offset_type, (*slot)->cu_indices, cu_index);
16579 /* Add a vector of indices to the constant pool. */
16582 add_indices_to_cpool (htab_t symbol_hash_table, struct obstack *cpool,
16583 struct symtab_index_entry *entry)
16587 slot = htab_find_slot (symbol_hash_table, entry, INSERT);
16590 offset_type len = VEC_length (offset_type, entry->cu_indices);
16591 offset_type val = MAYBE_SWAP (len);
16596 entry->index_offset = obstack_object_size (cpool);
16598 obstack_grow (cpool, &val, sizeof (val));
16600 VEC_iterate (offset_type, entry->cu_indices, i, iter);
16603 val = MAYBE_SWAP (iter);
16604 obstack_grow (cpool, &val, sizeof (val));
16609 struct symtab_index_entry *old_entry = *slot;
16610 entry->index_offset = old_entry->index_offset;
16613 return entry->index_offset;
16616 /* Write the mapped hash table SYMTAB to the obstack OUTPUT, with
16617 constant pool entries going into the obstack CPOOL. */
16620 write_hash_table (struct mapped_symtab *symtab,
16621 struct obstack *output, struct obstack *cpool)
16624 htab_t symbol_hash_table;
16627 symbol_hash_table = create_symbol_hash_table ();
16628 str_table = create_strtab ();
16630 /* We add all the index vectors to the constant pool first, to
16631 ensure alignment is ok. */
16632 for (i = 0; i < symtab->size; ++i)
16634 if (symtab->data[i])
16635 add_indices_to_cpool (symbol_hash_table, cpool, symtab->data[i]);
16638 /* Now write out the hash table. */
16639 for (i = 0; i < symtab->size; ++i)
16641 offset_type str_off, vec_off;
16643 if (symtab->data[i])
16645 str_off = add_string (str_table, cpool, symtab->data[i]->name);
16646 vec_off = symtab->data[i]->index_offset;
16650 /* While 0 is a valid constant pool index, it is not valid
16651 to have 0 for both offsets. */
16656 str_off = MAYBE_SWAP (str_off);
16657 vec_off = MAYBE_SWAP (vec_off);
16659 obstack_grow (output, &str_off, sizeof (str_off));
16660 obstack_grow (output, &vec_off, sizeof (vec_off));
16663 htab_delete (str_table);
16664 htab_delete (symbol_hash_table);
16667 /* Struct to map psymtab to CU index in the index file. */
16668 struct psymtab_cu_index_map
16670 struct partial_symtab *psymtab;
16671 unsigned int cu_index;
16675 hash_psymtab_cu_index (const void *item)
16677 const struct psymtab_cu_index_map *map = item;
16679 return htab_hash_pointer (map->psymtab);
16683 eq_psymtab_cu_index (const void *item_lhs, const void *item_rhs)
16685 const struct psymtab_cu_index_map *lhs = item_lhs;
16686 const struct psymtab_cu_index_map *rhs = item_rhs;
16688 return lhs->psymtab == rhs->psymtab;
16691 /* Helper struct for building the address table. */
16692 struct addrmap_index_data
16694 struct objfile *objfile;
16695 struct obstack *addr_obstack;
16696 htab_t cu_index_htab;
16698 /* Non-zero if the previous_* fields are valid.
16699 We can't write an entry until we see the next entry (since it is only then
16700 that we know the end of the entry). */
16701 int previous_valid;
16702 /* Index of the CU in the table of all CUs in the index file. */
16703 unsigned int previous_cu_index;
16704 /* Start address of the CU. */
16705 CORE_ADDR previous_cu_start;
16708 /* Write an address entry to OBSTACK. */
16711 add_address_entry (struct objfile *objfile, struct obstack *obstack,
16712 CORE_ADDR start, CORE_ADDR end, unsigned int cu_index)
16714 offset_type cu_index_to_write;
16716 CORE_ADDR baseaddr;
16718 baseaddr = ANOFFSET (objfile->section_offsets, SECT_OFF_TEXT (objfile));
16720 store_unsigned_integer (addr, 8, BFD_ENDIAN_LITTLE, start - baseaddr);
16721 obstack_grow (obstack, addr, 8);
16722 store_unsigned_integer (addr, 8, BFD_ENDIAN_LITTLE, end - baseaddr);
16723 obstack_grow (obstack, addr, 8);
16724 cu_index_to_write = MAYBE_SWAP (cu_index);
16725 obstack_grow (obstack, &cu_index_to_write, sizeof (offset_type));
16728 /* Worker function for traversing an addrmap to build the address table. */
16731 add_address_entry_worker (void *datap, CORE_ADDR start_addr, void *obj)
16733 struct addrmap_index_data *data = datap;
16734 struct partial_symtab *pst = obj;
16735 offset_type cu_index;
16738 if (data->previous_valid)
16739 add_address_entry (data->objfile, data->addr_obstack,
16740 data->previous_cu_start, start_addr,
16741 data->previous_cu_index);
16743 data->previous_cu_start = start_addr;
16746 struct psymtab_cu_index_map find_map, *map;
16747 find_map.psymtab = pst;
16748 map = htab_find (data->cu_index_htab, &find_map);
16749 gdb_assert (map != NULL);
16750 data->previous_cu_index = map->cu_index;
16751 data->previous_valid = 1;
16754 data->previous_valid = 0;
16759 /* Write OBJFILE's address map to OBSTACK.
16760 CU_INDEX_HTAB is used to map addrmap entries to their CU indices
16761 in the index file. */
16764 write_address_map (struct objfile *objfile, struct obstack *obstack,
16765 htab_t cu_index_htab)
16767 struct addrmap_index_data addrmap_index_data;
16769 /* When writing the address table, we have to cope with the fact that
16770 the addrmap iterator only provides the start of a region; we have to
16771 wait until the next invocation to get the start of the next region. */
16773 addrmap_index_data.objfile = objfile;
16774 addrmap_index_data.addr_obstack = obstack;
16775 addrmap_index_data.cu_index_htab = cu_index_htab;
16776 addrmap_index_data.previous_valid = 0;
16778 addrmap_foreach (objfile->psymtabs_addrmap, add_address_entry_worker,
16779 &addrmap_index_data);
16781 /* It's highly unlikely the last entry (end address = 0xff...ff)
16782 is valid, but we should still handle it.
16783 The end address is recorded as the start of the next region, but that
16784 doesn't work here. To cope we pass 0xff...ff, this is a rare situation
16786 if (addrmap_index_data.previous_valid)
16787 add_address_entry (objfile, obstack,
16788 addrmap_index_data.previous_cu_start, (CORE_ADDR) -1,
16789 addrmap_index_data.previous_cu_index);
16792 /* Add a list of partial symbols to SYMTAB. */
16795 write_psymbols (struct mapped_symtab *symtab,
16797 struct partial_symbol **psymp,
16799 offset_type cu_index,
16802 for (; count-- > 0; ++psymp)
16804 void **slot, *lookup;
16806 if (SYMBOL_LANGUAGE (*psymp) == language_ada)
16807 error (_("Ada is not currently supported by the index"));
16809 /* We only want to add a given psymbol once. However, we also
16810 want to account for whether it is global or static. So, we
16811 may add it twice, using slightly different values. */
16814 uintptr_t val = 1 | (uintptr_t) *psymp;
16816 lookup = (void *) val;
16821 /* Only add a given psymbol once. */
16822 slot = htab_find_slot (psyms_seen, lookup, INSERT);
16826 add_index_entry (symtab, SYMBOL_NATURAL_NAME (*psymp), cu_index);
16831 /* Write the contents of an ("unfinished") obstack to FILE. Throw an
16832 exception if there is an error. */
16835 write_obstack (FILE *file, struct obstack *obstack)
16837 if (fwrite (obstack_base (obstack), 1, obstack_object_size (obstack),
16839 != obstack_object_size (obstack))
16840 error (_("couldn't data write to file"));
16843 /* Unlink a file if the argument is not NULL. */
16846 unlink_if_set (void *p)
16848 char **filename = p;
16850 unlink (*filename);
16853 /* A helper struct used when iterating over debug_types. */
16854 struct signatured_type_index_data
16856 struct objfile *objfile;
16857 struct mapped_symtab *symtab;
16858 struct obstack *types_list;
16863 /* A helper function that writes a single signatured_type to an
16867 write_one_signatured_type (void **slot, void *d)
16869 struct signatured_type_index_data *info = d;
16870 struct signatured_type *entry = (struct signatured_type *) *slot;
16871 struct dwarf2_per_cu_data *per_cu = &entry->per_cu;
16872 struct partial_symtab *psymtab = per_cu->v.psymtab;
16875 write_psymbols (info->symtab,
16877 info->objfile->global_psymbols.list
16878 + psymtab->globals_offset,
16879 psymtab->n_global_syms, info->cu_index,
16881 write_psymbols (info->symtab,
16883 info->objfile->static_psymbols.list
16884 + psymtab->statics_offset,
16885 psymtab->n_static_syms, info->cu_index,
16888 store_unsigned_integer (val, 8, BFD_ENDIAN_LITTLE, entry->per_cu.offset);
16889 obstack_grow (info->types_list, val, 8);
16890 store_unsigned_integer (val, 8, BFD_ENDIAN_LITTLE, entry->type_offset);
16891 obstack_grow (info->types_list, val, 8);
16892 store_unsigned_integer (val, 8, BFD_ENDIAN_LITTLE, entry->signature);
16893 obstack_grow (info->types_list, val, 8);
16900 /* Create an index file for OBJFILE in the directory DIR. */
16903 write_psymtabs_to_index (struct objfile *objfile, const char *dir)
16905 struct cleanup *cleanup;
16906 char *filename, *cleanup_filename;
16907 struct obstack contents, addr_obstack, constant_pool, symtab_obstack;
16908 struct obstack cu_list, types_cu_list;
16911 struct mapped_symtab *symtab;
16912 offset_type val, size_of_contents, total_len;
16916 htab_t cu_index_htab;
16917 struct psymtab_cu_index_map *psymtab_cu_index_map;
16919 if (!objfile->psymtabs || !objfile->psymtabs_addrmap)
16922 if (dwarf2_per_objfile->using_index)
16923 error (_("Cannot use an index to create the index"));
16925 if (VEC_length (dwarf2_section_info_def, dwarf2_per_objfile->types) > 1)
16926 error (_("Cannot make an index when the file has multiple .debug_types sections"));
16928 if (stat (objfile->name, &st) < 0)
16929 perror_with_name (objfile->name);
16931 filename = concat (dir, SLASH_STRING, lbasename (objfile->name),
16932 INDEX_SUFFIX, (char *) NULL);
16933 cleanup = make_cleanup (xfree, filename);
16935 out_file = fopen (filename, "wb");
16937 error (_("Can't open `%s' for writing"), filename);
16939 cleanup_filename = filename;
16940 make_cleanup (unlink_if_set, &cleanup_filename);
16942 symtab = create_mapped_symtab ();
16943 make_cleanup (cleanup_mapped_symtab, symtab);
16945 obstack_init (&addr_obstack);
16946 make_cleanup_obstack_free (&addr_obstack);
16948 obstack_init (&cu_list);
16949 make_cleanup_obstack_free (&cu_list);
16951 obstack_init (&types_cu_list);
16952 make_cleanup_obstack_free (&types_cu_list);
16954 psyms_seen = htab_create_alloc (100, htab_hash_pointer, htab_eq_pointer,
16955 NULL, xcalloc, xfree);
16956 make_cleanup_htab_delete (psyms_seen);
16958 /* While we're scanning CU's create a table that maps a psymtab pointer
16959 (which is what addrmap records) to its index (which is what is recorded
16960 in the index file). This will later be needed to write the address
16962 cu_index_htab = htab_create_alloc (100,
16963 hash_psymtab_cu_index,
16964 eq_psymtab_cu_index,
16965 NULL, xcalloc, xfree);
16966 make_cleanup_htab_delete (cu_index_htab);
16967 psymtab_cu_index_map = (struct psymtab_cu_index_map *)
16968 xmalloc (sizeof (struct psymtab_cu_index_map)
16969 * dwarf2_per_objfile->n_comp_units);
16970 make_cleanup (xfree, psymtab_cu_index_map);
16972 /* The CU list is already sorted, so we don't need to do additional
16973 work here. Also, the debug_types entries do not appear in
16974 all_comp_units, but only in their own hash table. */
16975 for (i = 0; i < dwarf2_per_objfile->n_comp_units; ++i)
16977 struct dwarf2_per_cu_data *per_cu
16978 = dwarf2_per_objfile->all_comp_units[i];
16979 struct partial_symtab *psymtab = per_cu->v.psymtab;
16981 struct psymtab_cu_index_map *map;
16984 write_psymbols (symtab,
16986 objfile->global_psymbols.list + psymtab->globals_offset,
16987 psymtab->n_global_syms, i,
16989 write_psymbols (symtab,
16991 objfile->static_psymbols.list + psymtab->statics_offset,
16992 psymtab->n_static_syms, i,
16995 map = &psymtab_cu_index_map[i];
16996 map->psymtab = psymtab;
16998 slot = htab_find_slot (cu_index_htab, map, INSERT);
16999 gdb_assert (slot != NULL);
17000 gdb_assert (*slot == NULL);
17003 store_unsigned_integer (val, 8, BFD_ENDIAN_LITTLE, per_cu->offset);
17004 obstack_grow (&cu_list, val, 8);
17005 store_unsigned_integer (val, 8, BFD_ENDIAN_LITTLE, per_cu->length);
17006 obstack_grow (&cu_list, val, 8);
17009 /* Dump the address map. */
17010 write_address_map (objfile, &addr_obstack, cu_index_htab);
17012 /* Write out the .debug_type entries, if any. */
17013 if (dwarf2_per_objfile->signatured_types)
17015 struct signatured_type_index_data sig_data;
17017 sig_data.objfile = objfile;
17018 sig_data.symtab = symtab;
17019 sig_data.types_list = &types_cu_list;
17020 sig_data.psyms_seen = psyms_seen;
17021 sig_data.cu_index = dwarf2_per_objfile->n_comp_units;
17022 htab_traverse_noresize (dwarf2_per_objfile->signatured_types,
17023 write_one_signatured_type, &sig_data);
17026 obstack_init (&constant_pool);
17027 make_cleanup_obstack_free (&constant_pool);
17028 obstack_init (&symtab_obstack);
17029 make_cleanup_obstack_free (&symtab_obstack);
17030 write_hash_table (symtab, &symtab_obstack, &constant_pool);
17032 obstack_init (&contents);
17033 make_cleanup_obstack_free (&contents);
17034 size_of_contents = 6 * sizeof (offset_type);
17035 total_len = size_of_contents;
17037 /* The version number. */
17038 val = MAYBE_SWAP (5);
17039 obstack_grow (&contents, &val, sizeof (val));
17041 /* The offset of the CU list from the start of the file. */
17042 val = MAYBE_SWAP (total_len);
17043 obstack_grow (&contents, &val, sizeof (val));
17044 total_len += obstack_object_size (&cu_list);
17046 /* The offset of the types CU list from the start of the file. */
17047 val = MAYBE_SWAP (total_len);
17048 obstack_grow (&contents, &val, sizeof (val));
17049 total_len += obstack_object_size (&types_cu_list);
17051 /* The offset of the address table from the start of the file. */
17052 val = MAYBE_SWAP (total_len);
17053 obstack_grow (&contents, &val, sizeof (val));
17054 total_len += obstack_object_size (&addr_obstack);
17056 /* The offset of the symbol table from the start of the file. */
17057 val = MAYBE_SWAP (total_len);
17058 obstack_grow (&contents, &val, sizeof (val));
17059 total_len += obstack_object_size (&symtab_obstack);
17061 /* The offset of the constant pool from the start of the file. */
17062 val = MAYBE_SWAP (total_len);
17063 obstack_grow (&contents, &val, sizeof (val));
17064 total_len += obstack_object_size (&constant_pool);
17066 gdb_assert (obstack_object_size (&contents) == size_of_contents);
17068 write_obstack (out_file, &contents);
17069 write_obstack (out_file, &cu_list);
17070 write_obstack (out_file, &types_cu_list);
17071 write_obstack (out_file, &addr_obstack);
17072 write_obstack (out_file, &symtab_obstack);
17073 write_obstack (out_file, &constant_pool);
17077 /* We want to keep the file, so we set cleanup_filename to NULL
17078 here. See unlink_if_set. */
17079 cleanup_filename = NULL;
17081 do_cleanups (cleanup);
17084 /* Implementation of the `save gdb-index' command.
17086 Note that the file format used by this command is documented in the
17087 GDB manual. Any changes here must be documented there. */
17090 save_gdb_index_command (char *arg, int from_tty)
17092 struct objfile *objfile;
17095 error (_("usage: save gdb-index DIRECTORY"));
17097 ALL_OBJFILES (objfile)
17101 /* If the objfile does not correspond to an actual file, skip it. */
17102 if (stat (objfile->name, &st) < 0)
17105 dwarf2_per_objfile = objfile_data (objfile, dwarf2_objfile_data_key);
17106 if (dwarf2_per_objfile)
17108 volatile struct gdb_exception except;
17110 TRY_CATCH (except, RETURN_MASK_ERROR)
17112 write_psymtabs_to_index (objfile, arg);
17114 if (except.reason < 0)
17115 exception_fprintf (gdb_stderr, except,
17116 _("Error while writing index for `%s': "),
17124 int dwarf2_always_disassemble;
17127 show_dwarf2_always_disassemble (struct ui_file *file, int from_tty,
17128 struct cmd_list_element *c, const char *value)
17130 fprintf_filtered (file,
17131 _("Whether to always disassemble "
17132 "DWARF expressions is %s.\n"),
17137 show_check_physname (struct ui_file *file, int from_tty,
17138 struct cmd_list_element *c, const char *value)
17140 fprintf_filtered (file,
17141 _("Whether to check \"physname\" is %s.\n"),
17145 void _initialize_dwarf2_read (void);
17148 _initialize_dwarf2_read (void)
17150 struct cmd_list_element *c;
17152 dwarf2_objfile_data_key
17153 = register_objfile_data_with_cleanup (NULL, dwarf2_per_objfile_free);
17155 add_prefix_cmd ("dwarf2", class_maintenance, set_dwarf2_cmd, _("\
17156 Set DWARF 2 specific variables.\n\
17157 Configure DWARF 2 variables such as the cache size"),
17158 &set_dwarf2_cmdlist, "maintenance set dwarf2 ",
17159 0/*allow-unknown*/, &maintenance_set_cmdlist);
17161 add_prefix_cmd ("dwarf2", class_maintenance, show_dwarf2_cmd, _("\
17162 Show DWARF 2 specific variables\n\
17163 Show DWARF 2 variables such as the cache size"),
17164 &show_dwarf2_cmdlist, "maintenance show dwarf2 ",
17165 0/*allow-unknown*/, &maintenance_show_cmdlist);
17167 add_setshow_zinteger_cmd ("max-cache-age", class_obscure,
17168 &dwarf2_max_cache_age, _("\
17169 Set the upper bound on the age of cached dwarf2 compilation units."), _("\
17170 Show the upper bound on the age of cached dwarf2 compilation units."), _("\
17171 A higher limit means that cached compilation units will be stored\n\
17172 in memory longer, and more total memory will be used. Zero disables\n\
17173 caching, which can slow down startup."),
17175 show_dwarf2_max_cache_age,
17176 &set_dwarf2_cmdlist,
17177 &show_dwarf2_cmdlist);
17179 add_setshow_boolean_cmd ("always-disassemble", class_obscure,
17180 &dwarf2_always_disassemble, _("\
17181 Set whether `info address' always disassembles DWARF expressions."), _("\
17182 Show whether `info address' always disassembles DWARF expressions."), _("\
17183 When enabled, DWARF expressions are always printed in an assembly-like\n\
17184 syntax. When disabled, expressions will be printed in a more\n\
17185 conversational style, when possible."),
17187 show_dwarf2_always_disassemble,
17188 &set_dwarf2_cmdlist,
17189 &show_dwarf2_cmdlist);
17191 add_setshow_zinteger_cmd ("dwarf2-die", no_class, &dwarf2_die_debug, _("\
17192 Set debugging of the dwarf2 DIE reader."), _("\
17193 Show debugging of the dwarf2 DIE reader."), _("\
17194 When enabled (non-zero), DIEs are dumped after they are read in.\n\
17195 The value is the maximum depth to print."),
17198 &setdebuglist, &showdebuglist);
17200 add_setshow_boolean_cmd ("check-physname", no_class, &check_physname, _("\
17201 Set cross-checking of \"physname\" code against demangler."), _("\
17202 Show cross-checking of \"physname\" code against demangler."), _("\
17203 When enabled, GDB's internal \"physname\" code is checked against\n\
17205 NULL, show_check_physname,
17206 &setdebuglist, &showdebuglist);
17208 c = add_cmd ("gdb-index", class_files, save_gdb_index_command,
17210 Save a gdb-index file.\n\
17211 Usage: save gdb-index DIRECTORY"),
17213 set_cmd_completer (c, filename_completer);