1 /* DWARF 2 debugging format support for GDB.
3 Copyright (C) 1994-2014 Free Software Foundation, Inc.
5 Adapted by Gary Funck (gary@intrepid.com), Intrepid Technology,
6 Inc. with support from Florida State University (under contract
7 with the Ada Joint Program Office), and Silicon Graphics, Inc.
8 Initial contribution by Brent Benson, Harris Computer Systems, Inc.,
9 based on Fred Fish's (Cygnus Support) implementation of DWARF 1
12 This file is part of GDB.
14 This program is free software; you can redistribute it and/or modify
15 it under the terms of the GNU General Public License as published by
16 the Free Software Foundation; either version 3 of the License, or
17 (at your option) any later version.
19 This program is distributed in the hope that it will be useful,
20 but WITHOUT ANY WARRANTY; without even the implied warranty of
21 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
22 GNU General Public License for more details.
24 You should have received a copy of the GNU General Public License
25 along with this program. If not, see <http://www.gnu.org/licenses/>. */
27 /* FIXME: Various die-reading functions need to be more careful with
28 reading off the end of the section.
29 E.g., load_partial_dies, read_partial_die. */
40 #include "gdb-demangle.h"
41 #include "expression.h"
42 #include "filenames.h" /* for DOSish file names */
45 #include "complaints.h"
47 #include "dwarf2expr.h"
48 #include "dwarf2loc.h"
49 #include "cp-support.h"
55 #include "typeprint.h"
58 #include "exceptions.h"
60 #include "completer.h"
65 #include "gdbcore.h" /* for gnutarget */
66 #include "gdb/gdb-index.h"
71 #include "filestuff.h"
76 #include "gdb_assert.h"
77 #include <sys/types.h>
79 typedef struct symbol *symbolp;
82 /* When == 1, print basic high level tracing messages.
83 When > 1, be more verbose.
84 This is in contrast to the low level DIE reading of dwarf2_die_debug. */
85 static unsigned int dwarf2_read_debug = 0;
87 /* When non-zero, dump DIEs after they are read in. */
88 static unsigned int dwarf2_die_debug = 0;
90 /* When non-zero, cross-check physname against demangler. */
91 static int check_physname = 0;
93 /* When non-zero, do not reject deprecated .gdb_index sections. */
94 static int use_deprecated_index_sections = 0;
96 static const struct objfile_data *dwarf2_objfile_data_key;
98 /* The "aclass" indices for various kinds of computed DWARF symbols. */
100 static int dwarf2_locexpr_index;
101 static int dwarf2_loclist_index;
102 static int dwarf2_locexpr_block_index;
103 static int dwarf2_loclist_block_index;
105 /* A descriptor for dwarf sections.
107 S.ASECTION, SIZE are typically initialized when the objfile is first
108 scanned. BUFFER, READIN are filled in later when the section is read.
109 If the section contained compressed data then SIZE is updated to record
110 the uncompressed size of the section.
112 DWP file format V2 introduces a wrinkle that is easiest to handle by
113 creating the concept of virtual sections contained within a real section.
114 In DWP V2 the sections of the input DWO files are concatenated together
115 into one section, but section offsets are kept relative to the original
117 If this is a virtual dwp-v2 section, S.CONTAINING_SECTION is a backlink to
118 the real section this "virtual" section is contained in, and BUFFER,SIZE
119 describe the virtual section. */
121 struct dwarf2_section_info
125 /* If this is a real section, the bfd section. */
127 /* If this is a virtual section, pointer to the containing ("real")
129 struct dwarf2_section_info *containing_section;
131 /* Pointer to section data, only valid if readin. */
132 const gdb_byte *buffer;
133 /* The size of the section, real or virtual. */
135 /* If this is a virtual section, the offset in the real section.
136 Only valid if is_virtual. */
137 bfd_size_type virtual_offset;
138 /* True if we have tried to read this section. */
140 /* True if this is a virtual section, False otherwise.
141 This specifies which of s.asection and s.containing_section to use. */
145 typedef struct dwarf2_section_info dwarf2_section_info_def;
146 DEF_VEC_O (dwarf2_section_info_def);
148 /* All offsets in the index are of this type. It must be
149 architecture-independent. */
150 typedef uint32_t offset_type;
152 DEF_VEC_I (offset_type);
154 /* Ensure only legit values are used. */
155 #define DW2_GDB_INDEX_SYMBOL_STATIC_SET_VALUE(cu_index, value) \
157 gdb_assert ((unsigned int) (value) <= 1); \
158 GDB_INDEX_SYMBOL_STATIC_SET_VALUE((cu_index), (value)); \
161 /* Ensure only legit values are used. */
162 #define DW2_GDB_INDEX_SYMBOL_KIND_SET_VALUE(cu_index, value) \
164 gdb_assert ((value) >= GDB_INDEX_SYMBOL_KIND_TYPE \
165 && (value) <= GDB_INDEX_SYMBOL_KIND_OTHER); \
166 GDB_INDEX_SYMBOL_KIND_SET_VALUE((cu_index), (value)); \
169 /* Ensure we don't use more than the alloted nuber of bits for the CU. */
170 #define DW2_GDB_INDEX_CU_SET_VALUE(cu_index, value) \
172 gdb_assert (((value) & ~GDB_INDEX_CU_MASK) == 0); \
173 GDB_INDEX_CU_SET_VALUE((cu_index), (value)); \
176 /* A description of the mapped index. The file format is described in
177 a comment by the code that writes the index. */
180 /* Index data format version. */
183 /* The total length of the buffer. */
186 /* A pointer to the address table data. */
187 const gdb_byte *address_table;
189 /* Size of the address table data in bytes. */
190 offset_type address_table_size;
192 /* The symbol table, implemented as a hash table. */
193 const offset_type *symbol_table;
195 /* Size in slots, each slot is 2 offset_types. */
196 offset_type symbol_table_slots;
198 /* A pointer to the constant pool. */
199 const char *constant_pool;
202 typedef struct dwarf2_per_cu_data *dwarf2_per_cu_ptr;
203 DEF_VEC_P (dwarf2_per_cu_ptr);
205 /* Collection of data recorded per objfile.
206 This hangs off of dwarf2_objfile_data_key. */
208 struct dwarf2_per_objfile
210 struct dwarf2_section_info info;
211 struct dwarf2_section_info abbrev;
212 struct dwarf2_section_info line;
213 struct dwarf2_section_info loc;
214 struct dwarf2_section_info macinfo;
215 struct dwarf2_section_info macro;
216 struct dwarf2_section_info str;
217 struct dwarf2_section_info ranges;
218 struct dwarf2_section_info addr;
219 struct dwarf2_section_info frame;
220 struct dwarf2_section_info eh_frame;
221 struct dwarf2_section_info gdb_index;
223 VEC (dwarf2_section_info_def) *types;
226 struct objfile *objfile;
228 /* Table of all the compilation units. This is used to locate
229 the target compilation unit of a particular reference. */
230 struct dwarf2_per_cu_data **all_comp_units;
232 /* The number of compilation units in ALL_COMP_UNITS. */
235 /* The number of .debug_types-related CUs. */
238 /* The .debug_types-related CUs (TUs).
239 This is stored in malloc space because we may realloc it. */
240 struct signatured_type **all_type_units;
242 /* The number of entries in all_type_unit_groups. */
243 int n_type_unit_groups;
245 /* Table of type unit groups.
246 This exists to make it easy to iterate over all CUs and TU groups. */
247 struct type_unit_group **all_type_unit_groups;
249 /* Table of struct type_unit_group objects.
250 The hash key is the DW_AT_stmt_list value. */
251 htab_t type_unit_groups;
253 /* A table mapping .debug_types signatures to its signatured_type entry.
254 This is NULL if the .debug_types section hasn't been read in yet. */
255 htab_t signatured_types;
257 /* Type unit statistics, to see how well the scaling improvements
261 int nr_uniq_abbrev_tables;
263 int nr_symtab_sharers;
264 int nr_stmt_less_type_units;
267 /* A chain of compilation units that are currently read in, so that
268 they can be freed later. */
269 struct dwarf2_per_cu_data *read_in_chain;
271 /* A table mapping DW_AT_dwo_name values to struct dwo_file objects.
272 This is NULL if the table hasn't been allocated yet. */
275 /* Non-zero if we've check for whether there is a DWP file. */
278 /* The DWP file if there is one, or NULL. */
279 struct dwp_file *dwp_file;
281 /* The shared '.dwz' file, if one exists. This is used when the
282 original data was compressed using 'dwz -m'. */
283 struct dwz_file *dwz_file;
285 /* A flag indicating wether this objfile has a section loaded at a
287 int has_section_at_zero;
289 /* True if we are using the mapped index,
290 or we are faking it for OBJF_READNOW's sake. */
291 unsigned char using_index;
293 /* The mapped index, or NULL if .gdb_index is missing or not being used. */
294 struct mapped_index *index_table;
296 /* When using index_table, this keeps track of all quick_file_names entries.
297 TUs typically share line table entries with a CU, so we maintain a
298 separate table of all line table entries to support the sharing.
299 Note that while there can be way more TUs than CUs, we've already
300 sorted all the TUs into "type unit groups", grouped by their
301 DW_AT_stmt_list value. Therefore the only sharing done here is with a
302 CU and its associated TU group if there is one. */
303 htab_t quick_file_names_table;
305 /* Set during partial symbol reading, to prevent queueing of full
307 int reading_partial_symbols;
309 /* Table mapping type DIEs to their struct type *.
310 This is NULL if not allocated yet.
311 The mapping is done via (CU/TU + DIE offset) -> type. */
312 htab_t die_type_hash;
314 /* The CUs we recently read. */
315 VEC (dwarf2_per_cu_ptr) *just_read_cus;
318 static struct dwarf2_per_objfile *dwarf2_per_objfile;
320 /* Default names of the debugging sections. */
322 /* Note that if the debugging section has been compressed, it might
323 have a name like .zdebug_info. */
325 static const struct dwarf2_debug_sections dwarf2_elf_names =
327 { ".debug_info", ".zdebug_info" },
328 { ".debug_abbrev", ".zdebug_abbrev" },
329 { ".debug_line", ".zdebug_line" },
330 { ".debug_loc", ".zdebug_loc" },
331 { ".debug_macinfo", ".zdebug_macinfo" },
332 { ".debug_macro", ".zdebug_macro" },
333 { ".debug_str", ".zdebug_str" },
334 { ".debug_ranges", ".zdebug_ranges" },
335 { ".debug_types", ".zdebug_types" },
336 { ".debug_addr", ".zdebug_addr" },
337 { ".debug_frame", ".zdebug_frame" },
338 { ".eh_frame", NULL },
339 { ".gdb_index", ".zgdb_index" },
343 /* List of DWO/DWP sections. */
345 static const struct dwop_section_names
347 struct dwarf2_section_names abbrev_dwo;
348 struct dwarf2_section_names info_dwo;
349 struct dwarf2_section_names line_dwo;
350 struct dwarf2_section_names loc_dwo;
351 struct dwarf2_section_names macinfo_dwo;
352 struct dwarf2_section_names macro_dwo;
353 struct dwarf2_section_names str_dwo;
354 struct dwarf2_section_names str_offsets_dwo;
355 struct dwarf2_section_names types_dwo;
356 struct dwarf2_section_names cu_index;
357 struct dwarf2_section_names tu_index;
361 { ".debug_abbrev.dwo", ".zdebug_abbrev.dwo" },
362 { ".debug_info.dwo", ".zdebug_info.dwo" },
363 { ".debug_line.dwo", ".zdebug_line.dwo" },
364 { ".debug_loc.dwo", ".zdebug_loc.dwo" },
365 { ".debug_macinfo.dwo", ".zdebug_macinfo.dwo" },
366 { ".debug_macro.dwo", ".zdebug_macro.dwo" },
367 { ".debug_str.dwo", ".zdebug_str.dwo" },
368 { ".debug_str_offsets.dwo", ".zdebug_str_offsets.dwo" },
369 { ".debug_types.dwo", ".zdebug_types.dwo" },
370 { ".debug_cu_index", ".zdebug_cu_index" },
371 { ".debug_tu_index", ".zdebug_tu_index" },
374 /* local data types */
376 /* The data in a compilation unit header, after target2host
377 translation, looks like this. */
378 struct comp_unit_head
382 unsigned char addr_size;
383 unsigned char signed_addr_p;
384 sect_offset abbrev_offset;
386 /* Size of file offsets; either 4 or 8. */
387 unsigned int offset_size;
389 /* Size of the length field; either 4 or 12. */
390 unsigned int initial_length_size;
392 /* Offset to the first byte of this compilation unit header in the
393 .debug_info section, for resolving relative reference dies. */
396 /* Offset to first die in this cu from the start of the cu.
397 This will be the first byte following the compilation unit header. */
398 cu_offset first_die_offset;
401 /* Type used for delaying computation of method physnames.
402 See comments for compute_delayed_physnames. */
403 struct delayed_method_info
405 /* The type to which the method is attached, i.e., its parent class. */
408 /* The index of the method in the type's function fieldlists. */
411 /* The index of the method in the fieldlist. */
414 /* The name of the DIE. */
417 /* The DIE associated with this method. */
418 struct die_info *die;
421 typedef struct delayed_method_info delayed_method_info;
422 DEF_VEC_O (delayed_method_info);
424 /* Internal state when decoding a particular compilation unit. */
427 /* The objfile containing this compilation unit. */
428 struct objfile *objfile;
430 /* The header of the compilation unit. */
431 struct comp_unit_head header;
433 /* Base address of this compilation unit. */
434 CORE_ADDR base_address;
436 /* Non-zero if base_address has been set. */
439 /* The language we are debugging. */
440 enum language language;
441 const struct language_defn *language_defn;
443 const char *producer;
445 /* The generic symbol table building routines have separate lists for
446 file scope symbols and all all other scopes (local scopes). So
447 we need to select the right one to pass to add_symbol_to_list().
448 We do it by keeping a pointer to the correct list in list_in_scope.
450 FIXME: The original dwarf code just treated the file scope as the
451 first local scope, and all other local scopes as nested local
452 scopes, and worked fine. Check to see if we really need to
453 distinguish these in buildsym.c. */
454 struct pending **list_in_scope;
456 /* The abbrev table for this CU.
457 Normally this points to the abbrev table in the objfile.
458 But if DWO_UNIT is non-NULL this is the abbrev table in the DWO file. */
459 struct abbrev_table *abbrev_table;
461 /* Hash table holding all the loaded partial DIEs
462 with partial_die->offset.SECT_OFF as hash. */
465 /* Storage for things with the same lifetime as this read-in compilation
466 unit, including partial DIEs. */
467 struct obstack comp_unit_obstack;
469 /* When multiple dwarf2_cu structures are living in memory, this field
470 chains them all together, so that they can be released efficiently.
471 We will probably also want a generation counter so that most-recently-used
472 compilation units are cached... */
473 struct dwarf2_per_cu_data *read_in_chain;
475 /* Backlink to our per_cu entry. */
476 struct dwarf2_per_cu_data *per_cu;
478 /* How many compilation units ago was this CU last referenced? */
481 /* A hash table of DIE cu_offset for following references with
482 die_info->offset.sect_off as hash. */
485 /* Full DIEs if read in. */
486 struct die_info *dies;
488 /* A set of pointers to dwarf2_per_cu_data objects for compilation
489 units referenced by this one. Only set during full symbol processing;
490 partial symbol tables do not have dependencies. */
493 /* Header data from the line table, during full symbol processing. */
494 struct line_header *line_header;
496 /* A list of methods which need to have physnames computed
497 after all type information has been read. */
498 VEC (delayed_method_info) *method_list;
500 /* To be copied to symtab->call_site_htab. */
501 htab_t call_site_htab;
503 /* Non-NULL if this CU came from a DWO file.
504 There is an invariant here that is important to remember:
505 Except for attributes copied from the top level DIE in the "main"
506 (or "stub") file in preparation for reading the DWO file
507 (e.g., DW_AT_GNU_addr_base), we KISS: there is only *one* CU.
508 Either there isn't a DWO file (in which case this is NULL and the point
509 is moot), or there is and either we're not going to read it (in which
510 case this is NULL) or there is and we are reading it (in which case this
512 struct dwo_unit *dwo_unit;
514 /* The DW_AT_addr_base attribute if present, zero otherwise
515 (zero is a valid value though).
516 Note this value comes from the stub CU/TU's DIE. */
519 /* The DW_AT_ranges_base attribute if present, zero otherwise
520 (zero is a valid value though).
521 Note this value comes from the stub CU/TU's DIE.
522 Also note that the value is zero in the non-DWO case so this value can
523 be used without needing to know whether DWO files are in use or not.
524 N.B. This does not apply to DW_AT_ranges appearing in
525 DW_TAG_compile_unit dies. This is a bit of a wart, consider if ever
526 DW_AT_ranges appeared in the DW_TAG_compile_unit of DWO DIEs: then
527 DW_AT_ranges_base *would* have to be applied, and we'd have to care
528 whether the DW_AT_ranges attribute came from the skeleton or DWO. */
529 ULONGEST ranges_base;
531 /* Mark used when releasing cached dies. */
532 unsigned int mark : 1;
534 /* This CU references .debug_loc. See the symtab->locations_valid field.
535 This test is imperfect as there may exist optimized debug code not using
536 any location list and still facing inlining issues if handled as
537 unoptimized code. For a future better test see GCC PR other/32998. */
538 unsigned int has_loclist : 1;
540 /* These cache the results for producer_is_* fields. CHECKED_PRODUCER is set
541 if all the producer_is_* fields are valid. This information is cached
542 because profiling CU expansion showed excessive time spent in
543 producer_is_gxx_lt_4_6. */
544 unsigned int checked_producer : 1;
545 unsigned int producer_is_gxx_lt_4_6 : 1;
546 unsigned int producer_is_gcc_lt_4_3 : 1;
547 unsigned int producer_is_icc : 1;
549 /* When set, the file that we're processing is known to have
550 debugging info for C++ namespaces. GCC 3.3.x did not produce
551 this information, but later versions do. */
553 unsigned int processing_has_namespace_info : 1;
556 /* Persistent data held for a compilation unit, even when not
557 processing it. We put a pointer to this structure in the
558 read_symtab_private field of the psymtab. */
560 struct dwarf2_per_cu_data
562 /* The start offset and length of this compilation unit.
563 NOTE: Unlike comp_unit_head.length, this length includes
565 If the DIE refers to a DWO file, this is always of the original die,
570 /* Flag indicating this compilation unit will be read in before
571 any of the current compilation units are processed. */
572 unsigned int queued : 1;
574 /* This flag will be set when reading partial DIEs if we need to load
575 absolutely all DIEs for this compilation unit, instead of just the ones
576 we think are interesting. It gets set if we look for a DIE in the
577 hash table and don't find it. */
578 unsigned int load_all_dies : 1;
580 /* Non-zero if this CU is from .debug_types.
581 Struct dwarf2_per_cu_data is contained in struct signatured_type iff
583 unsigned int is_debug_types : 1;
585 /* Non-zero if this CU is from the .dwz file. */
586 unsigned int is_dwz : 1;
588 /* Non-zero if reading a TU directly from a DWO file, bypassing the stub.
589 This flag is only valid if is_debug_types is true.
590 We can't read a CU directly from a DWO file: There are required
591 attributes in the stub. */
592 unsigned int reading_dwo_directly : 1;
594 /* Non-zero if the TU has been read.
595 This is used to assist the "Stay in DWO Optimization" for Fission:
596 When reading a DWO, it's faster to read TUs from the DWO instead of
597 fetching them from random other DWOs (due to comdat folding).
598 If the TU has already been read, the optimization is unnecessary
599 (and unwise - we don't want to change where gdb thinks the TU lives
601 This flag is only valid if is_debug_types is true. */
602 unsigned int tu_read : 1;
604 /* The section this CU/TU lives in.
605 If the DIE refers to a DWO file, this is always the original die,
607 struct dwarf2_section_info *section;
609 /* Set to non-NULL iff this CU is currently loaded. When it gets freed out
610 of the CU cache it gets reset to NULL again. */
611 struct dwarf2_cu *cu;
613 /* The corresponding objfile.
614 Normally we can get the objfile from dwarf2_per_objfile.
615 However we can enter this file with just a "per_cu" handle. */
616 struct objfile *objfile;
618 /* When using partial symbol tables, the 'psymtab' field is active.
619 Otherwise the 'quick' field is active. */
622 /* The partial symbol table associated with this compilation unit,
623 or NULL for unread partial units. */
624 struct partial_symtab *psymtab;
626 /* Data needed by the "quick" functions. */
627 struct dwarf2_per_cu_quick_data *quick;
630 /* The CUs we import using DW_TAG_imported_unit. This is filled in
631 while reading psymtabs, used to compute the psymtab dependencies,
632 and then cleared. Then it is filled in again while reading full
633 symbols, and only deleted when the objfile is destroyed.
635 This is also used to work around a difference between the way gold
636 generates .gdb_index version <=7 and the way gdb does. Arguably this
637 is a gold bug. For symbols coming from TUs, gold records in the index
638 the CU that includes the TU instead of the TU itself. This breaks
639 dw2_lookup_symbol: It assumes that if the index says symbol X lives
640 in CU/TU Y, then one need only expand Y and a subsequent lookup in Y
641 will find X. Alas TUs live in their own symtab, so after expanding CU Y
642 we need to look in TU Z to find X. Fortunately, this is akin to
643 DW_TAG_imported_unit, so we just use the same mechanism: For
644 .gdb_index version <=7 this also records the TUs that the CU referred
645 to. Concurrently with this change gdb was modified to emit version 8
646 indices so we only pay a price for gold generated indices.
647 http://sourceware.org/bugzilla/show_bug.cgi?id=15021. */
648 VEC (dwarf2_per_cu_ptr) *imported_symtabs;
651 /* Entry in the signatured_types hash table. */
653 struct signatured_type
655 /* The "per_cu" object of this type.
656 This struct is used iff per_cu.is_debug_types.
657 N.B.: This is the first member so that it's easy to convert pointers
659 struct dwarf2_per_cu_data per_cu;
661 /* The type's signature. */
664 /* Offset in the TU of the type's DIE, as read from the TU header.
665 If this TU is a DWO stub and the definition lives in a DWO file
666 (specified by DW_AT_GNU_dwo_name), this value is unusable. */
667 cu_offset type_offset_in_tu;
669 /* Offset in the section of the type's DIE.
670 If the definition lives in a DWO file, this is the offset in the
671 .debug_types.dwo section.
672 The value is zero until the actual value is known.
673 Zero is otherwise not a valid section offset. */
674 sect_offset type_offset_in_section;
676 /* Type units are grouped by their DW_AT_stmt_list entry so that they
677 can share them. This points to the containing symtab. */
678 struct type_unit_group *type_unit_group;
681 The first time we encounter this type we fully read it in and install it
682 in the symbol tables. Subsequent times we only need the type. */
685 /* Containing DWO unit.
686 This field is valid iff per_cu.reading_dwo_directly. */
687 struct dwo_unit *dwo_unit;
690 typedef struct signatured_type *sig_type_ptr;
691 DEF_VEC_P (sig_type_ptr);
693 /* A struct that can be used as a hash key for tables based on DW_AT_stmt_list.
694 This includes type_unit_group and quick_file_names. */
696 struct stmt_list_hash
698 /* The DWO unit this table is from or NULL if there is none. */
699 struct dwo_unit *dwo_unit;
701 /* Offset in .debug_line or .debug_line.dwo. */
702 sect_offset line_offset;
705 /* Each element of dwarf2_per_objfile->type_unit_groups is a pointer to
706 an object of this type. */
708 struct type_unit_group
710 /* dwarf2read.c's main "handle" on a TU symtab.
711 To simplify things we create an artificial CU that "includes" all the
712 type units using this stmt_list so that the rest of the code still has
713 a "per_cu" handle on the symtab.
714 This PER_CU is recognized by having no section. */
715 #define IS_TYPE_UNIT_GROUP(per_cu) ((per_cu)->section == NULL)
716 struct dwarf2_per_cu_data per_cu;
718 /* The TUs that share this DW_AT_stmt_list entry.
719 This is added to while parsing type units to build partial symtabs,
720 and is deleted afterwards and not used again. */
721 VEC (sig_type_ptr) *tus;
723 /* The primary symtab.
724 Type units in a group needn't all be defined in the same source file,
725 so we create an essentially anonymous symtab as the primary symtab. */
726 struct symtab *primary_symtab;
728 /* The data used to construct the hash key. */
729 struct stmt_list_hash hash;
731 /* The number of symtabs from the line header.
732 The value here must match line_header.num_file_names. */
733 unsigned int num_symtabs;
735 /* The symbol tables for this TU (obtained from the files listed in
737 WARNING: The order of entries here must match the order of entries
738 in the line header. After the first TU using this type_unit_group, the
739 line header for the subsequent TUs is recreated from this. This is done
740 because we need to use the same symtabs for each TU using the same
741 DW_AT_stmt_list value. Also note that symtabs may be repeated here,
742 there's no guarantee the line header doesn't have duplicate entries. */
743 struct symtab **symtabs;
746 /* These sections are what may appear in a (real or virtual) DWO file. */
750 struct dwarf2_section_info abbrev;
751 struct dwarf2_section_info line;
752 struct dwarf2_section_info loc;
753 struct dwarf2_section_info macinfo;
754 struct dwarf2_section_info macro;
755 struct dwarf2_section_info str;
756 struct dwarf2_section_info str_offsets;
757 /* In the case of a virtual DWO file, these two are unused. */
758 struct dwarf2_section_info info;
759 VEC (dwarf2_section_info_def) *types;
762 /* CUs/TUs in DWP/DWO files. */
766 /* Backlink to the containing struct dwo_file. */
767 struct dwo_file *dwo_file;
769 /* The "id" that distinguishes this CU/TU.
770 .debug_info calls this "dwo_id", .debug_types calls this "signature".
771 Since signatures came first, we stick with it for consistency. */
774 /* The section this CU/TU lives in, in the DWO file. */
775 struct dwarf2_section_info *section;
777 /* Same as dwarf2_per_cu_data:{offset,length} but in the DWO section. */
781 /* For types, offset in the type's DIE of the type defined by this TU. */
782 cu_offset type_offset_in_tu;
785 /* include/dwarf2.h defines the DWP section codes.
786 It defines a max value but it doesn't define a min value, which we
787 use for error checking, so provide one. */
789 enum dwp_v2_section_ids
794 /* Data for one DWO file.
796 This includes virtual DWO files (a virtual DWO file is a DWO file as it
797 appears in a DWP file). DWP files don't really have DWO files per se -
798 comdat folding of types "loses" the DWO file they came from, and from
799 a high level view DWP files appear to contain a mass of random types.
800 However, to maintain consistency with the non-DWP case we pretend DWP
801 files contain virtual DWO files, and we assign each TU with one virtual
802 DWO file (generally based on the line and abbrev section offsets -
803 a heuristic that seems to work in practice). */
807 /* The DW_AT_GNU_dwo_name attribute.
808 For virtual DWO files the name is constructed from the section offsets
809 of abbrev,line,loc,str_offsets so that we combine virtual DWO files
810 from related CU+TUs. */
811 const char *dwo_name;
813 /* The DW_AT_comp_dir attribute. */
814 const char *comp_dir;
816 /* The bfd, when the file is open. Otherwise this is NULL.
817 This is unused(NULL) for virtual DWO files where we use dwp_file.dbfd. */
820 /* The sections that make up this DWO file.
821 Remember that for virtual DWO files in DWP V2, these are virtual
822 sections (for lack of a better name). */
823 struct dwo_sections sections;
825 /* The CU in the file.
826 We only support one because having more than one requires hacking the
827 dwo_name of each to match, which is highly unlikely to happen.
828 Doing this means all TUs can share comp_dir: We also assume that
829 DW_AT_comp_dir across all TUs in a DWO file will be identical. */
832 /* Table of TUs in the file.
833 Each element is a struct dwo_unit. */
837 /* These sections are what may appear in a DWP file. */
841 /* These are used by both DWP version 1 and 2. */
842 struct dwarf2_section_info str;
843 struct dwarf2_section_info cu_index;
844 struct dwarf2_section_info tu_index;
846 /* These are only used by DWP version 2 files.
847 In DWP version 1 the .debug_info.dwo, .debug_types.dwo, and other
848 sections are referenced by section number, and are not recorded here.
849 In DWP version 2 there is at most one copy of all these sections, each
850 section being (effectively) comprised of the concatenation of all of the
851 individual sections that exist in the version 1 format.
852 To keep the code simple we treat each of these concatenated pieces as a
853 section itself (a virtual section?). */
854 struct dwarf2_section_info abbrev;
855 struct dwarf2_section_info info;
856 struct dwarf2_section_info line;
857 struct dwarf2_section_info loc;
858 struct dwarf2_section_info macinfo;
859 struct dwarf2_section_info macro;
860 struct dwarf2_section_info str_offsets;
861 struct dwarf2_section_info types;
864 /* These sections are what may appear in a virtual DWO file in DWP version 1.
865 A virtual DWO file is a DWO file as it appears in a DWP file. */
867 struct virtual_v1_dwo_sections
869 struct dwarf2_section_info abbrev;
870 struct dwarf2_section_info line;
871 struct dwarf2_section_info loc;
872 struct dwarf2_section_info macinfo;
873 struct dwarf2_section_info macro;
874 struct dwarf2_section_info str_offsets;
875 /* Each DWP hash table entry records one CU or one TU.
876 That is recorded here, and copied to dwo_unit.section. */
877 struct dwarf2_section_info info_or_types;
880 /* Similar to virtual_v1_dwo_sections, but for DWP version 2.
881 In version 2, the sections of the DWO files are concatenated together
882 and stored in one section of that name. Thus each ELF section contains
883 several "virtual" sections. */
885 struct virtual_v2_dwo_sections
887 bfd_size_type abbrev_offset;
888 bfd_size_type abbrev_size;
890 bfd_size_type line_offset;
891 bfd_size_type line_size;
893 bfd_size_type loc_offset;
894 bfd_size_type loc_size;
896 bfd_size_type macinfo_offset;
897 bfd_size_type macinfo_size;
899 bfd_size_type macro_offset;
900 bfd_size_type macro_size;
902 bfd_size_type str_offsets_offset;
903 bfd_size_type str_offsets_size;
905 /* Each DWP hash table entry records one CU or one TU.
906 That is recorded here, and copied to dwo_unit.section. */
907 bfd_size_type info_or_types_offset;
908 bfd_size_type info_or_types_size;
911 /* Contents of DWP hash tables. */
913 struct dwp_hash_table
915 uint32_t version, nr_columns;
916 uint32_t nr_units, nr_slots;
917 const gdb_byte *hash_table, *unit_table;
922 const gdb_byte *indices;
926 /* This is indexed by column number and gives the id of the section
928 #define MAX_NR_V2_DWO_SECTIONS \
929 (1 /* .debug_info or .debug_types */ \
930 + 1 /* .debug_abbrev */ \
931 + 1 /* .debug_line */ \
932 + 1 /* .debug_loc */ \
933 + 1 /* .debug_str_offsets */ \
934 + 1 /* .debug_macro or .debug_macinfo */)
935 int section_ids[MAX_NR_V2_DWO_SECTIONS];
936 const gdb_byte *offsets;
937 const gdb_byte *sizes;
942 /* Data for one DWP file. */
946 /* Name of the file. */
949 /* File format version. */
955 /* Section info for this file. */
956 struct dwp_sections sections;
958 /* Table of CUs in the file. */
959 const struct dwp_hash_table *cus;
961 /* Table of TUs in the file. */
962 const struct dwp_hash_table *tus;
964 /* Tables of loaded CUs/TUs. Each entry is a struct dwo_unit *. */
968 /* Table to map ELF section numbers to their sections.
969 This is only needed for the DWP V1 file format. */
970 unsigned int num_sections;
971 asection **elf_sections;
974 /* This represents a '.dwz' file. */
978 /* A dwz file can only contain a few sections. */
979 struct dwarf2_section_info abbrev;
980 struct dwarf2_section_info info;
981 struct dwarf2_section_info str;
982 struct dwarf2_section_info line;
983 struct dwarf2_section_info macro;
984 struct dwarf2_section_info gdb_index;
990 /* Struct used to pass misc. parameters to read_die_and_children, et
991 al. which are used for both .debug_info and .debug_types dies.
992 All parameters here are unchanging for the life of the call. This
993 struct exists to abstract away the constant parameters of die reading. */
995 struct die_reader_specs
997 /* The bfd of die_section. */
1000 /* The CU of the DIE we are parsing. */
1001 struct dwarf2_cu *cu;
1003 /* Non-NULL if reading a DWO file (including one packaged into a DWP). */
1004 struct dwo_file *dwo_file;
1006 /* The section the die comes from.
1007 This is either .debug_info or .debug_types, or the .dwo variants. */
1008 struct dwarf2_section_info *die_section;
1010 /* die_section->buffer. */
1011 const gdb_byte *buffer;
1013 /* The end of the buffer. */
1014 const gdb_byte *buffer_end;
1016 /* The value of the DW_AT_comp_dir attribute. */
1017 const char *comp_dir;
1020 /* Type of function passed to init_cutu_and_read_dies, et.al. */
1021 typedef void (die_reader_func_ftype) (const struct die_reader_specs *reader,
1022 const gdb_byte *info_ptr,
1023 struct die_info *comp_unit_die,
1027 /* The line number information for a compilation unit (found in the
1028 .debug_line section) begins with a "statement program header",
1029 which contains the following information. */
1032 unsigned int total_length;
1033 unsigned short version;
1034 unsigned int header_length;
1035 unsigned char minimum_instruction_length;
1036 unsigned char maximum_ops_per_instruction;
1037 unsigned char default_is_stmt;
1039 unsigned char line_range;
1040 unsigned char opcode_base;
1042 /* standard_opcode_lengths[i] is the number of operands for the
1043 standard opcode whose value is i. This means that
1044 standard_opcode_lengths[0] is unused, and the last meaningful
1045 element is standard_opcode_lengths[opcode_base - 1]. */
1046 unsigned char *standard_opcode_lengths;
1048 /* The include_directories table. NOTE! These strings are not
1049 allocated with xmalloc; instead, they are pointers into
1050 debug_line_buffer. If you try to free them, `free' will get
1052 unsigned int num_include_dirs, include_dirs_size;
1053 const char **include_dirs;
1055 /* The file_names table. NOTE! These strings are not allocated
1056 with xmalloc; instead, they are pointers into debug_line_buffer.
1057 Don't try to free them directly. */
1058 unsigned int num_file_names, file_names_size;
1062 unsigned int dir_index;
1063 unsigned int mod_time;
1064 unsigned int length;
1065 int included_p; /* Non-zero if referenced by the Line Number Program. */
1066 struct symtab *symtab; /* The associated symbol table, if any. */
1069 /* The start and end of the statement program following this
1070 header. These point into dwarf2_per_objfile->line_buffer. */
1071 const gdb_byte *statement_program_start, *statement_program_end;
1074 /* When we construct a partial symbol table entry we only
1075 need this much information. */
1076 struct partial_die_info
1078 /* Offset of this DIE. */
1081 /* DWARF-2 tag for this DIE. */
1082 ENUM_BITFIELD(dwarf_tag) tag : 16;
1084 /* Assorted flags describing the data found in this DIE. */
1085 unsigned int has_children : 1;
1086 unsigned int is_external : 1;
1087 unsigned int is_declaration : 1;
1088 unsigned int has_type : 1;
1089 unsigned int has_specification : 1;
1090 unsigned int has_pc_info : 1;
1091 unsigned int may_be_inlined : 1;
1093 /* Flag set if the SCOPE field of this structure has been
1095 unsigned int scope_set : 1;
1097 /* Flag set if the DIE has a byte_size attribute. */
1098 unsigned int has_byte_size : 1;
1100 /* Flag set if any of the DIE's children are template arguments. */
1101 unsigned int has_template_arguments : 1;
1103 /* Flag set if fixup_partial_die has been called on this die. */
1104 unsigned int fixup_called : 1;
1106 /* Flag set if DW_TAG_imported_unit uses DW_FORM_GNU_ref_alt. */
1107 unsigned int is_dwz : 1;
1109 /* Flag set if spec_offset uses DW_FORM_GNU_ref_alt. */
1110 unsigned int spec_is_dwz : 1;
1112 /* The name of this DIE. Normally the value of DW_AT_name, but
1113 sometimes a default name for unnamed DIEs. */
1116 /* The linkage name, if present. */
1117 const char *linkage_name;
1119 /* The scope to prepend to our children. This is generally
1120 allocated on the comp_unit_obstack, so will disappear
1121 when this compilation unit leaves the cache. */
1124 /* Some data associated with the partial DIE. The tag determines
1125 which field is live. */
1128 /* The location description associated with this DIE, if any. */
1129 struct dwarf_block *locdesc;
1130 /* The offset of an import, for DW_TAG_imported_unit. */
1134 /* If HAS_PC_INFO, the PC range associated with this DIE. */
1138 /* Pointer into the info_buffer (or types_buffer) pointing at the target of
1139 DW_AT_sibling, if any. */
1140 /* NOTE: This member isn't strictly necessary, read_partial_die could
1141 return DW_AT_sibling values to its caller load_partial_dies. */
1142 const gdb_byte *sibling;
1144 /* If HAS_SPECIFICATION, the offset of the DIE referred to by
1145 DW_AT_specification (or DW_AT_abstract_origin or
1146 DW_AT_extension). */
1147 sect_offset spec_offset;
1149 /* Pointers to this DIE's parent, first child, and next sibling,
1151 struct partial_die_info *die_parent, *die_child, *die_sibling;
1154 /* This data structure holds the information of an abbrev. */
1157 unsigned int number; /* number identifying abbrev */
1158 enum dwarf_tag tag; /* dwarf tag */
1159 unsigned short has_children; /* boolean */
1160 unsigned short num_attrs; /* number of attributes */
1161 struct attr_abbrev *attrs; /* an array of attribute descriptions */
1162 struct abbrev_info *next; /* next in chain */
1167 ENUM_BITFIELD(dwarf_attribute) name : 16;
1168 ENUM_BITFIELD(dwarf_form) form : 16;
1171 /* Size of abbrev_table.abbrev_hash_table. */
1172 #define ABBREV_HASH_SIZE 121
1174 /* Top level data structure to contain an abbreviation table. */
1178 /* Where the abbrev table came from.
1179 This is used as a sanity check when the table is used. */
1182 /* Storage for the abbrev table. */
1183 struct obstack abbrev_obstack;
1185 /* Hash table of abbrevs.
1186 This is an array of size ABBREV_HASH_SIZE allocated in abbrev_obstack.
1187 It could be statically allocated, but the previous code didn't so we
1189 struct abbrev_info **abbrevs;
1192 /* Attributes have a name and a value. */
1195 ENUM_BITFIELD(dwarf_attribute) name : 16;
1196 ENUM_BITFIELD(dwarf_form) form : 15;
1198 /* Has DW_STRING already been updated by dwarf2_canonicalize_name? This
1199 field should be in u.str (existing only for DW_STRING) but it is kept
1200 here for better struct attribute alignment. */
1201 unsigned int string_is_canonical : 1;
1206 struct dwarf_block *blk;
1215 /* This data structure holds a complete die structure. */
1218 /* DWARF-2 tag for this DIE. */
1219 ENUM_BITFIELD(dwarf_tag) tag : 16;
1221 /* Number of attributes */
1222 unsigned char num_attrs;
1224 /* True if we're presently building the full type name for the
1225 type derived from this DIE. */
1226 unsigned char building_fullname : 1;
1229 unsigned int abbrev;
1231 /* Offset in .debug_info or .debug_types section. */
1234 /* The dies in a compilation unit form an n-ary tree. PARENT
1235 points to this die's parent; CHILD points to the first child of
1236 this node; and all the children of a given node are chained
1237 together via their SIBLING fields. */
1238 struct die_info *child; /* Its first child, if any. */
1239 struct die_info *sibling; /* Its next sibling, if any. */
1240 struct die_info *parent; /* Its parent, if any. */
1242 /* An array of attributes, with NUM_ATTRS elements. There may be
1243 zero, but it's not common and zero-sized arrays are not
1244 sufficiently portable C. */
1245 struct attribute attrs[1];
1248 /* Get at parts of an attribute structure. */
1250 #define DW_STRING(attr) ((attr)->u.str)
1251 #define DW_STRING_IS_CANONICAL(attr) ((attr)->string_is_canonical)
1252 #define DW_UNSND(attr) ((attr)->u.unsnd)
1253 #define DW_BLOCK(attr) ((attr)->u.blk)
1254 #define DW_SND(attr) ((attr)->u.snd)
1255 #define DW_ADDR(attr) ((attr)->u.addr)
1256 #define DW_SIGNATURE(attr) ((attr)->u.signature)
1258 /* Blocks are a bunch of untyped bytes. */
1263 /* Valid only if SIZE is not zero. */
1264 const gdb_byte *data;
1267 #ifndef ATTR_ALLOC_CHUNK
1268 #define ATTR_ALLOC_CHUNK 4
1271 /* Allocate fields for structs, unions and enums in this size. */
1272 #ifndef DW_FIELD_ALLOC_CHUNK
1273 #define DW_FIELD_ALLOC_CHUNK 4
1276 /* FIXME: We might want to set this from BFD via bfd_arch_bits_per_byte,
1277 but this would require a corresponding change in unpack_field_as_long
1279 static int bits_per_byte = 8;
1281 /* The routines that read and process dies for a C struct or C++ class
1282 pass lists of data member fields and lists of member function fields
1283 in an instance of a field_info structure, as defined below. */
1286 /* List of data member and baseclasses fields. */
1289 struct nextfield *next;
1294 *fields, *baseclasses;
1296 /* Number of fields (including baseclasses). */
1299 /* Number of baseclasses. */
1302 /* Set if the accesibility of one of the fields is not public. */
1303 int non_public_fields;
1305 /* Member function fields array, entries are allocated in the order they
1306 are encountered in the object file. */
1309 struct nextfnfield *next;
1310 struct fn_field fnfield;
1314 /* Member function fieldlist array, contains name of possibly overloaded
1315 member function, number of overloaded member functions and a pointer
1316 to the head of the member function field chain. */
1321 struct nextfnfield *head;
1325 /* Number of entries in the fnfieldlists array. */
1328 /* typedefs defined inside this class. TYPEDEF_FIELD_LIST contains head of
1329 a NULL terminated list of TYPEDEF_FIELD_LIST_COUNT elements. */
1330 struct typedef_field_list
1332 struct typedef_field field;
1333 struct typedef_field_list *next;
1335 *typedef_field_list;
1336 unsigned typedef_field_list_count;
1339 /* One item on the queue of compilation units to read in full symbols
1341 struct dwarf2_queue_item
1343 struct dwarf2_per_cu_data *per_cu;
1344 enum language pretend_language;
1345 struct dwarf2_queue_item *next;
1348 /* The current queue. */
1349 static struct dwarf2_queue_item *dwarf2_queue, *dwarf2_queue_tail;
1351 /* Loaded secondary compilation units are kept in memory until they
1352 have not been referenced for the processing of this many
1353 compilation units. Set this to zero to disable caching. Cache
1354 sizes of up to at least twenty will improve startup time for
1355 typical inter-CU-reference binaries, at an obvious memory cost. */
1356 static int dwarf2_max_cache_age = 5;
1358 show_dwarf2_max_cache_age (struct ui_file *file, int from_tty,
1359 struct cmd_list_element *c, const char *value)
1361 fprintf_filtered (file, _("The upper bound on the age of cached "
1362 "dwarf2 compilation units is %s.\n"),
1366 /* local function prototypes */
1368 static const char *get_section_name (const struct dwarf2_section_info *);
1370 static const char *get_section_file_name (const struct dwarf2_section_info *);
1372 static void dwarf2_locate_sections (bfd *, asection *, void *);
1374 static void dwarf2_find_base_address (struct die_info *die,
1375 struct dwarf2_cu *cu);
1377 static struct partial_symtab *create_partial_symtab
1378 (struct dwarf2_per_cu_data *per_cu, const char *name);
1380 static void dwarf2_build_psymtabs_hard (struct objfile *);
1382 static void scan_partial_symbols (struct partial_die_info *,
1383 CORE_ADDR *, CORE_ADDR *,
1384 int, struct dwarf2_cu *);
1386 static void add_partial_symbol (struct partial_die_info *,
1387 struct dwarf2_cu *);
1389 static void add_partial_namespace (struct partial_die_info *pdi,
1390 CORE_ADDR *lowpc, CORE_ADDR *highpc,
1391 int need_pc, struct dwarf2_cu *cu);
1393 static void add_partial_module (struct partial_die_info *pdi, CORE_ADDR *lowpc,
1394 CORE_ADDR *highpc, int need_pc,
1395 struct dwarf2_cu *cu);
1397 static void add_partial_enumeration (struct partial_die_info *enum_pdi,
1398 struct dwarf2_cu *cu);
1400 static void add_partial_subprogram (struct partial_die_info *pdi,
1401 CORE_ADDR *lowpc, CORE_ADDR *highpc,
1402 int need_pc, struct dwarf2_cu *cu);
1404 static void dwarf2_read_symtab (struct partial_symtab *,
1407 static void psymtab_to_symtab_1 (struct partial_symtab *);
1409 static struct abbrev_info *abbrev_table_lookup_abbrev
1410 (const struct abbrev_table *, unsigned int);
1412 static struct abbrev_table *abbrev_table_read_table
1413 (struct dwarf2_section_info *, sect_offset);
1415 static void abbrev_table_free (struct abbrev_table *);
1417 static void abbrev_table_free_cleanup (void *);
1419 static void dwarf2_read_abbrevs (struct dwarf2_cu *,
1420 struct dwarf2_section_info *);
1422 static void dwarf2_free_abbrev_table (void *);
1424 static unsigned int peek_abbrev_code (bfd *, const gdb_byte *);
1426 static struct partial_die_info *load_partial_dies
1427 (const struct die_reader_specs *, const gdb_byte *, int);
1429 static const gdb_byte *read_partial_die (const struct die_reader_specs *,
1430 struct partial_die_info *,
1431 struct abbrev_info *,
1435 static struct partial_die_info *find_partial_die (sect_offset, int,
1436 struct dwarf2_cu *);
1438 static void fixup_partial_die (struct partial_die_info *,
1439 struct dwarf2_cu *);
1441 static const gdb_byte *read_attribute (const struct die_reader_specs *,
1442 struct attribute *, struct attr_abbrev *,
1445 static unsigned int read_1_byte (bfd *, const gdb_byte *);
1447 static int read_1_signed_byte (bfd *, const gdb_byte *);
1449 static unsigned int read_2_bytes (bfd *, const gdb_byte *);
1451 static unsigned int read_4_bytes (bfd *, const gdb_byte *);
1453 static ULONGEST read_8_bytes (bfd *, const gdb_byte *);
1455 static CORE_ADDR read_address (bfd *, const gdb_byte *ptr, struct dwarf2_cu *,
1458 static LONGEST read_initial_length (bfd *, const gdb_byte *, unsigned int *);
1460 static LONGEST read_checked_initial_length_and_offset
1461 (bfd *, const gdb_byte *, const struct comp_unit_head *,
1462 unsigned int *, unsigned int *);
1464 static LONGEST read_offset (bfd *, const gdb_byte *,
1465 const struct comp_unit_head *,
1468 static LONGEST read_offset_1 (bfd *, const gdb_byte *, unsigned int);
1470 static sect_offset read_abbrev_offset (struct dwarf2_section_info *,
1473 static const gdb_byte *read_n_bytes (bfd *, const gdb_byte *, unsigned int);
1475 static const char *read_direct_string (bfd *, const gdb_byte *, unsigned int *);
1477 static const char *read_indirect_string (bfd *, const gdb_byte *,
1478 const struct comp_unit_head *,
1481 static const char *read_indirect_string_from_dwz (struct dwz_file *, LONGEST);
1483 static ULONGEST read_unsigned_leb128 (bfd *, const gdb_byte *, unsigned int *);
1485 static LONGEST read_signed_leb128 (bfd *, const gdb_byte *, unsigned int *);
1487 static CORE_ADDR read_addr_index_from_leb128 (struct dwarf2_cu *,
1491 static const char *read_str_index (const struct die_reader_specs *reader,
1492 struct dwarf2_cu *cu, ULONGEST str_index);
1494 static void set_cu_language (unsigned int, struct dwarf2_cu *);
1496 static struct attribute *dwarf2_attr (struct die_info *, unsigned int,
1497 struct dwarf2_cu *);
1499 static struct attribute *dwarf2_attr_no_follow (struct die_info *,
1502 static int dwarf2_flag_true_p (struct die_info *die, unsigned name,
1503 struct dwarf2_cu *cu);
1505 static int die_is_declaration (struct die_info *, struct dwarf2_cu *cu);
1507 static struct die_info *die_specification (struct die_info *die,
1508 struct dwarf2_cu **);
1510 static void free_line_header (struct line_header *lh);
1512 static struct line_header *dwarf_decode_line_header (unsigned int offset,
1513 struct dwarf2_cu *cu);
1515 static void dwarf_decode_lines (struct line_header *, const char *,
1516 struct dwarf2_cu *, struct partial_symtab *,
1519 static void dwarf2_start_subfile (const char *, const char *, const char *);
1521 static void dwarf2_start_symtab (struct dwarf2_cu *,
1522 const char *, const char *, CORE_ADDR);
1524 static struct symbol *new_symbol (struct die_info *, struct type *,
1525 struct dwarf2_cu *);
1527 static struct symbol *new_symbol_full (struct die_info *, struct type *,
1528 struct dwarf2_cu *, struct symbol *);
1530 static void dwarf2_const_value (const struct attribute *, struct symbol *,
1531 struct dwarf2_cu *);
1533 static void dwarf2_const_value_attr (const struct attribute *attr,
1536 struct obstack *obstack,
1537 struct dwarf2_cu *cu, LONGEST *value,
1538 const gdb_byte **bytes,
1539 struct dwarf2_locexpr_baton **baton);
1541 static struct type *die_type (struct die_info *, struct dwarf2_cu *);
1543 static int need_gnat_info (struct dwarf2_cu *);
1545 static struct type *die_descriptive_type (struct die_info *,
1546 struct dwarf2_cu *);
1548 static void set_descriptive_type (struct type *, struct die_info *,
1549 struct dwarf2_cu *);
1551 static struct type *die_containing_type (struct die_info *,
1552 struct dwarf2_cu *);
1554 static struct type *lookup_die_type (struct die_info *, const struct attribute *,
1555 struct dwarf2_cu *);
1557 static struct type *read_type_die (struct die_info *, struct dwarf2_cu *);
1559 static struct type *read_type_die_1 (struct die_info *, struct dwarf2_cu *);
1561 static const char *determine_prefix (struct die_info *die, struct dwarf2_cu *);
1563 static char *typename_concat (struct obstack *obs, const char *prefix,
1564 const char *suffix, int physname,
1565 struct dwarf2_cu *cu);
1567 static void read_file_scope (struct die_info *, struct dwarf2_cu *);
1569 static void read_type_unit_scope (struct die_info *, struct dwarf2_cu *);
1571 static void read_func_scope (struct die_info *, struct dwarf2_cu *);
1573 static void read_lexical_block_scope (struct die_info *, struct dwarf2_cu *);
1575 static void read_call_site_scope (struct die_info *die, struct dwarf2_cu *cu);
1577 static int dwarf2_ranges_read (unsigned, CORE_ADDR *, CORE_ADDR *,
1578 struct dwarf2_cu *, struct partial_symtab *);
1580 static int dwarf2_get_pc_bounds (struct die_info *,
1581 CORE_ADDR *, CORE_ADDR *, struct dwarf2_cu *,
1582 struct partial_symtab *);
1584 static void get_scope_pc_bounds (struct die_info *,
1585 CORE_ADDR *, CORE_ADDR *,
1586 struct dwarf2_cu *);
1588 static void dwarf2_record_block_ranges (struct die_info *, struct block *,
1589 CORE_ADDR, struct dwarf2_cu *);
1591 static void dwarf2_add_field (struct field_info *, struct die_info *,
1592 struct dwarf2_cu *);
1594 static void dwarf2_attach_fields_to_type (struct field_info *,
1595 struct type *, struct dwarf2_cu *);
1597 static void dwarf2_add_member_fn (struct field_info *,
1598 struct die_info *, struct type *,
1599 struct dwarf2_cu *);
1601 static void dwarf2_attach_fn_fields_to_type (struct field_info *,
1603 struct dwarf2_cu *);
1605 static void process_structure_scope (struct die_info *, struct dwarf2_cu *);
1607 static void read_common_block (struct die_info *, struct dwarf2_cu *);
1609 static void read_namespace (struct die_info *die, struct dwarf2_cu *);
1611 static void read_module (struct die_info *die, struct dwarf2_cu *cu);
1613 static void read_import_statement (struct die_info *die, struct dwarf2_cu *);
1615 static int read_namespace_alias (struct die_info *die, struct dwarf2_cu *cu);
1617 static struct type *read_module_type (struct die_info *die,
1618 struct dwarf2_cu *cu);
1620 static const char *namespace_name (struct die_info *die,
1621 int *is_anonymous, struct dwarf2_cu *);
1623 static void process_enumeration_scope (struct die_info *, struct dwarf2_cu *);
1625 static CORE_ADDR decode_locdesc (struct dwarf_block *, struct dwarf2_cu *);
1627 static enum dwarf_array_dim_ordering read_array_order (struct die_info *,
1628 struct dwarf2_cu *);
1630 static struct die_info *read_die_and_siblings_1
1631 (const struct die_reader_specs *, const gdb_byte *, const gdb_byte **,
1634 static struct die_info *read_die_and_siblings (const struct die_reader_specs *,
1635 const gdb_byte *info_ptr,
1636 const gdb_byte **new_info_ptr,
1637 struct die_info *parent);
1639 static const gdb_byte *read_full_die_1 (const struct die_reader_specs *,
1640 struct die_info **, const gdb_byte *,
1643 static const gdb_byte *read_full_die (const struct die_reader_specs *,
1644 struct die_info **, const gdb_byte *,
1647 static void process_die (struct die_info *, struct dwarf2_cu *);
1649 static const char *dwarf2_canonicalize_name (const char *, struct dwarf2_cu *,
1652 static const char *dwarf2_name (struct die_info *die, struct dwarf2_cu *);
1654 static const char *dwarf2_full_name (const char *name,
1655 struct die_info *die,
1656 struct dwarf2_cu *cu);
1658 static const char *dwarf2_physname (const char *name, struct die_info *die,
1659 struct dwarf2_cu *cu);
1661 static struct die_info *dwarf2_extension (struct die_info *die,
1662 struct dwarf2_cu **);
1664 static const char *dwarf_tag_name (unsigned int);
1666 static const char *dwarf_attr_name (unsigned int);
1668 static const char *dwarf_form_name (unsigned int);
1670 static char *dwarf_bool_name (unsigned int);
1672 static const char *dwarf_type_encoding_name (unsigned int);
1674 static struct die_info *sibling_die (struct die_info *);
1676 static void dump_die_shallow (struct ui_file *, int indent, struct die_info *);
1678 static void dump_die_for_error (struct die_info *);
1680 static void dump_die_1 (struct ui_file *, int level, int max_level,
1683 /*static*/ void dump_die (struct die_info *, int max_level);
1685 static void store_in_ref_table (struct die_info *,
1686 struct dwarf2_cu *);
1688 static sect_offset dwarf2_get_ref_die_offset (const struct attribute *);
1690 static LONGEST dwarf2_get_attr_constant_value (const struct attribute *, int);
1692 static struct die_info *follow_die_ref_or_sig (struct die_info *,
1693 const struct attribute *,
1694 struct dwarf2_cu **);
1696 static struct die_info *follow_die_ref (struct die_info *,
1697 const struct attribute *,
1698 struct dwarf2_cu **);
1700 static struct die_info *follow_die_sig (struct die_info *,
1701 const struct attribute *,
1702 struct dwarf2_cu **);
1704 static struct type *get_signatured_type (struct die_info *, ULONGEST,
1705 struct dwarf2_cu *);
1707 static struct type *get_DW_AT_signature_type (struct die_info *,
1708 const struct attribute *,
1709 struct dwarf2_cu *);
1711 static void load_full_type_unit (struct dwarf2_per_cu_data *per_cu);
1713 static void read_signatured_type (struct signatured_type *);
1715 static struct type_unit_group *get_type_unit_group
1716 (struct dwarf2_cu *, const struct attribute *);
1718 static void build_type_unit_groups (die_reader_func_ftype *, void *);
1720 /* memory allocation interface */
1722 static struct dwarf_block *dwarf_alloc_block (struct dwarf2_cu *);
1724 static struct die_info *dwarf_alloc_die (struct dwarf2_cu *, int);
1726 static void dwarf_decode_macros (struct dwarf2_cu *, unsigned int,
1729 static int attr_form_is_block (const struct attribute *);
1731 static int attr_form_is_section_offset (const struct attribute *);
1733 static int attr_form_is_constant (const struct attribute *);
1735 static int attr_form_is_ref (const struct attribute *);
1737 static void fill_in_loclist_baton (struct dwarf2_cu *cu,
1738 struct dwarf2_loclist_baton *baton,
1739 const struct attribute *attr);
1741 static void dwarf2_symbol_mark_computed (const struct attribute *attr,
1743 struct dwarf2_cu *cu,
1746 static const gdb_byte *skip_one_die (const struct die_reader_specs *reader,
1747 const gdb_byte *info_ptr,
1748 struct abbrev_info *abbrev);
1750 static void free_stack_comp_unit (void *);
1752 static hashval_t partial_die_hash (const void *item);
1754 static int partial_die_eq (const void *item_lhs, const void *item_rhs);
1756 static struct dwarf2_per_cu_data *dwarf2_find_containing_comp_unit
1757 (sect_offset offset, unsigned int offset_in_dwz, struct objfile *objfile);
1759 static void init_one_comp_unit (struct dwarf2_cu *cu,
1760 struct dwarf2_per_cu_data *per_cu);
1762 static void prepare_one_comp_unit (struct dwarf2_cu *cu,
1763 struct die_info *comp_unit_die,
1764 enum language pretend_language);
1766 static void free_heap_comp_unit (void *);
1768 static void free_cached_comp_units (void *);
1770 static void age_cached_comp_units (void);
1772 static void free_one_cached_comp_unit (struct dwarf2_per_cu_data *);
1774 static struct type *set_die_type (struct die_info *, struct type *,
1775 struct dwarf2_cu *);
1777 static void create_all_comp_units (struct objfile *);
1779 static int create_all_type_units (struct objfile *);
1781 static void load_full_comp_unit (struct dwarf2_per_cu_data *,
1784 static void process_full_comp_unit (struct dwarf2_per_cu_data *,
1787 static void process_full_type_unit (struct dwarf2_per_cu_data *,
1790 static void dwarf2_add_dependence (struct dwarf2_cu *,
1791 struct dwarf2_per_cu_data *);
1793 static void dwarf2_mark (struct dwarf2_cu *);
1795 static void dwarf2_clear_marks (struct dwarf2_per_cu_data *);
1797 static struct type *get_die_type_at_offset (sect_offset,
1798 struct dwarf2_per_cu_data *);
1800 static struct type *get_die_type (struct die_info *die, struct dwarf2_cu *cu);
1802 static void dwarf2_release_queue (void *dummy);
1804 static void queue_comp_unit (struct dwarf2_per_cu_data *per_cu,
1805 enum language pretend_language);
1807 static void process_queue (void);
1809 static void find_file_and_directory (struct die_info *die,
1810 struct dwarf2_cu *cu,
1811 const char **name, const char **comp_dir);
1813 static char *file_full_name (int file, struct line_header *lh,
1814 const char *comp_dir);
1816 static const gdb_byte *read_and_check_comp_unit_head
1817 (struct comp_unit_head *header,
1818 struct dwarf2_section_info *section,
1819 struct dwarf2_section_info *abbrev_section, const gdb_byte *info_ptr,
1820 int is_debug_types_section);
1822 static void init_cutu_and_read_dies
1823 (struct dwarf2_per_cu_data *this_cu, struct abbrev_table *abbrev_table,
1824 int use_existing_cu, int keep,
1825 die_reader_func_ftype *die_reader_func, void *data);
1827 static void init_cutu_and_read_dies_simple
1828 (struct dwarf2_per_cu_data *this_cu,
1829 die_reader_func_ftype *die_reader_func, void *data);
1831 static htab_t allocate_signatured_type_table (struct objfile *objfile);
1833 static htab_t allocate_dwo_unit_table (struct objfile *objfile);
1835 static struct dwo_unit *lookup_dwo_unit_in_dwp
1836 (struct dwp_file *dwp_file, const char *comp_dir,
1837 ULONGEST signature, int is_debug_types);
1839 static struct dwp_file *get_dwp_file (void);
1841 static struct dwo_unit *lookup_dwo_comp_unit
1842 (struct dwarf2_per_cu_data *, const char *, const char *, ULONGEST);
1844 static struct dwo_unit *lookup_dwo_type_unit
1845 (struct signatured_type *, const char *, const char *);
1847 static void queue_and_load_all_dwo_tus (struct dwarf2_per_cu_data *);
1849 static void free_dwo_file_cleanup (void *);
1851 static void process_cu_includes (void);
1853 static void check_producer (struct dwarf2_cu *cu);
1855 /* Various complaints about symbol reading that don't abort the process. */
1858 dwarf2_statement_list_fits_in_line_number_section_complaint (void)
1860 complaint (&symfile_complaints,
1861 _("statement list doesn't fit in .debug_line section"));
1865 dwarf2_debug_line_missing_file_complaint (void)
1867 complaint (&symfile_complaints,
1868 _(".debug_line section has line data without a file"));
1872 dwarf2_debug_line_missing_end_sequence_complaint (void)
1874 complaint (&symfile_complaints,
1875 _(".debug_line section has line "
1876 "program sequence without an end"));
1880 dwarf2_complex_location_expr_complaint (void)
1882 complaint (&symfile_complaints, _("location expression too complex"));
1886 dwarf2_const_value_length_mismatch_complaint (const char *arg1, int arg2,
1889 complaint (&symfile_complaints,
1890 _("const value length mismatch for '%s', got %d, expected %d"),
1895 dwarf2_section_buffer_overflow_complaint (struct dwarf2_section_info *section)
1897 complaint (&symfile_complaints,
1898 _("debug info runs off end of %s section"
1900 get_section_name (section),
1901 get_section_file_name (section));
1905 dwarf2_macro_malformed_definition_complaint (const char *arg1)
1907 complaint (&symfile_complaints,
1908 _("macro debug info contains a "
1909 "malformed macro definition:\n`%s'"),
1914 dwarf2_invalid_attrib_class_complaint (const char *arg1, const char *arg2)
1916 complaint (&symfile_complaints,
1917 _("invalid attribute class or form for '%s' in '%s'"),
1923 /* Convert VALUE between big- and little-endian. */
1925 byte_swap (offset_type value)
1929 result = (value & 0xff) << 24;
1930 result |= (value & 0xff00) << 8;
1931 result |= (value & 0xff0000) >> 8;
1932 result |= (value & 0xff000000) >> 24;
1936 #define MAYBE_SWAP(V) byte_swap (V)
1939 #define MAYBE_SWAP(V) (V)
1940 #endif /* WORDS_BIGENDIAN */
1942 /* The suffix for an index file. */
1943 #define INDEX_SUFFIX ".gdb-index"
1945 /* Try to locate the sections we need for DWARF 2 debugging
1946 information and return true if we have enough to do something.
1947 NAMES points to the dwarf2 section names, or is NULL if the standard
1948 ELF names are used. */
1951 dwarf2_has_info (struct objfile *objfile,
1952 const struct dwarf2_debug_sections *names)
1954 dwarf2_per_objfile = objfile_data (objfile, dwarf2_objfile_data_key);
1955 if (!dwarf2_per_objfile)
1957 /* Initialize per-objfile state. */
1958 struct dwarf2_per_objfile *data
1959 = obstack_alloc (&objfile->objfile_obstack, sizeof (*data));
1961 memset (data, 0, sizeof (*data));
1962 set_objfile_data (objfile, dwarf2_objfile_data_key, data);
1963 dwarf2_per_objfile = data;
1965 bfd_map_over_sections (objfile->obfd, dwarf2_locate_sections,
1967 dwarf2_per_objfile->objfile = objfile;
1969 return (!dwarf2_per_objfile->info.is_virtual
1970 && dwarf2_per_objfile->info.s.asection != NULL
1971 && !dwarf2_per_objfile->abbrev.is_virtual
1972 && dwarf2_per_objfile->abbrev.s.asection != NULL);
1975 /* Return the containing section of virtual section SECTION. */
1977 static struct dwarf2_section_info *
1978 get_containing_section (const struct dwarf2_section_info *section)
1980 gdb_assert (section->is_virtual);
1981 return section->s.containing_section;
1984 /* Return the bfd owner of SECTION. */
1987 get_section_bfd_owner (const struct dwarf2_section_info *section)
1989 if (section->is_virtual)
1991 section = get_containing_section (section);
1992 gdb_assert (!section->is_virtual);
1994 return section->s.asection->owner;
1997 /* Return the bfd section of SECTION.
1998 Returns NULL if the section is not present. */
2001 get_section_bfd_section (const struct dwarf2_section_info *section)
2003 if (section->is_virtual)
2005 section = get_containing_section (section);
2006 gdb_assert (!section->is_virtual);
2008 return section->s.asection;
2011 /* Return the name of SECTION. */
2014 get_section_name (const struct dwarf2_section_info *section)
2016 asection *sectp = get_section_bfd_section (section);
2018 gdb_assert (sectp != NULL);
2019 return bfd_section_name (get_section_bfd_owner (section), sectp);
2022 /* Return the name of the file SECTION is in. */
2025 get_section_file_name (const struct dwarf2_section_info *section)
2027 bfd *abfd = get_section_bfd_owner (section);
2029 return bfd_get_filename (abfd);
2032 /* Return the id of SECTION.
2033 Returns 0 if SECTION doesn't exist. */
2036 get_section_id (const struct dwarf2_section_info *section)
2038 asection *sectp = get_section_bfd_section (section);
2045 /* Return the flags of SECTION.
2046 SECTION (or containing section if this is a virtual section) must exist. */
2049 get_section_flags (const struct dwarf2_section_info *section)
2051 asection *sectp = get_section_bfd_section (section);
2053 gdb_assert (sectp != NULL);
2054 return bfd_get_section_flags (sectp->owner, sectp);
2057 /* When loading sections, we look either for uncompressed section or for
2058 compressed section names. */
2061 section_is_p (const char *section_name,
2062 const struct dwarf2_section_names *names)
2064 if (names->normal != NULL
2065 && strcmp (section_name, names->normal) == 0)
2067 if (names->compressed != NULL
2068 && strcmp (section_name, names->compressed) == 0)
2073 /* This function is mapped across the sections and remembers the
2074 offset and size of each of the debugging sections we are interested
2078 dwarf2_locate_sections (bfd *abfd, asection *sectp, void *vnames)
2080 const struct dwarf2_debug_sections *names;
2081 flagword aflag = bfd_get_section_flags (abfd, sectp);
2084 names = &dwarf2_elf_names;
2086 names = (const struct dwarf2_debug_sections *) vnames;
2088 if ((aflag & SEC_HAS_CONTENTS) == 0)
2091 else if (section_is_p (sectp->name, &names->info))
2093 dwarf2_per_objfile->info.s.asection = sectp;
2094 dwarf2_per_objfile->info.size = bfd_get_section_size (sectp);
2096 else if (section_is_p (sectp->name, &names->abbrev))
2098 dwarf2_per_objfile->abbrev.s.asection = sectp;
2099 dwarf2_per_objfile->abbrev.size = bfd_get_section_size (sectp);
2101 else if (section_is_p (sectp->name, &names->line))
2103 dwarf2_per_objfile->line.s.asection = sectp;
2104 dwarf2_per_objfile->line.size = bfd_get_section_size (sectp);
2106 else if (section_is_p (sectp->name, &names->loc))
2108 dwarf2_per_objfile->loc.s.asection = sectp;
2109 dwarf2_per_objfile->loc.size = bfd_get_section_size (sectp);
2111 else if (section_is_p (sectp->name, &names->macinfo))
2113 dwarf2_per_objfile->macinfo.s.asection = sectp;
2114 dwarf2_per_objfile->macinfo.size = bfd_get_section_size (sectp);
2116 else if (section_is_p (sectp->name, &names->macro))
2118 dwarf2_per_objfile->macro.s.asection = sectp;
2119 dwarf2_per_objfile->macro.size = bfd_get_section_size (sectp);
2121 else if (section_is_p (sectp->name, &names->str))
2123 dwarf2_per_objfile->str.s.asection = sectp;
2124 dwarf2_per_objfile->str.size = bfd_get_section_size (sectp);
2126 else if (section_is_p (sectp->name, &names->addr))
2128 dwarf2_per_objfile->addr.s.asection = sectp;
2129 dwarf2_per_objfile->addr.size = bfd_get_section_size (sectp);
2131 else if (section_is_p (sectp->name, &names->frame))
2133 dwarf2_per_objfile->frame.s.asection = sectp;
2134 dwarf2_per_objfile->frame.size = bfd_get_section_size (sectp);
2136 else if (section_is_p (sectp->name, &names->eh_frame))
2138 dwarf2_per_objfile->eh_frame.s.asection = sectp;
2139 dwarf2_per_objfile->eh_frame.size = bfd_get_section_size (sectp);
2141 else if (section_is_p (sectp->name, &names->ranges))
2143 dwarf2_per_objfile->ranges.s.asection = sectp;
2144 dwarf2_per_objfile->ranges.size = bfd_get_section_size (sectp);
2146 else if (section_is_p (sectp->name, &names->types))
2148 struct dwarf2_section_info type_section;
2150 memset (&type_section, 0, sizeof (type_section));
2151 type_section.s.asection = sectp;
2152 type_section.size = bfd_get_section_size (sectp);
2154 VEC_safe_push (dwarf2_section_info_def, dwarf2_per_objfile->types,
2157 else if (section_is_p (sectp->name, &names->gdb_index))
2159 dwarf2_per_objfile->gdb_index.s.asection = sectp;
2160 dwarf2_per_objfile->gdb_index.size = bfd_get_section_size (sectp);
2163 if ((bfd_get_section_flags (abfd, sectp) & SEC_LOAD)
2164 && bfd_section_vma (abfd, sectp) == 0)
2165 dwarf2_per_objfile->has_section_at_zero = 1;
2168 /* A helper function that decides whether a section is empty,
2172 dwarf2_section_empty_p (const struct dwarf2_section_info *section)
2174 if (section->is_virtual)
2175 return section->size == 0;
2176 return section->s.asection == NULL || section->size == 0;
2179 /* Read the contents of the section INFO.
2180 OBJFILE is the main object file, but not necessarily the file where
2181 the section comes from. E.g., for DWO files the bfd of INFO is the bfd
2183 If the section is compressed, uncompress it before returning. */
2186 dwarf2_read_section (struct objfile *objfile, struct dwarf2_section_info *info)
2190 gdb_byte *buf, *retbuf;
2194 info->buffer = NULL;
2197 if (dwarf2_section_empty_p (info))
2200 sectp = get_section_bfd_section (info);
2202 /* If this is a virtual section we need to read in the real one first. */
2203 if (info->is_virtual)
2205 struct dwarf2_section_info *containing_section =
2206 get_containing_section (info);
2208 gdb_assert (sectp != NULL);
2209 if ((sectp->flags & SEC_RELOC) != 0)
2211 error (_("Dwarf Error: DWP format V2 with relocations is not"
2212 " supported in section %s [in module %s]"),
2213 get_section_name (info), get_section_file_name (info));
2215 dwarf2_read_section (objfile, containing_section);
2216 /* Other code should have already caught virtual sections that don't
2218 gdb_assert (info->virtual_offset + info->size
2219 <= containing_section->size);
2220 /* If the real section is empty or there was a problem reading the
2221 section we shouldn't get here. */
2222 gdb_assert (containing_section->buffer != NULL);
2223 info->buffer = containing_section->buffer + info->virtual_offset;
2227 /* If the section has relocations, we must read it ourselves.
2228 Otherwise we attach it to the BFD. */
2229 if ((sectp->flags & SEC_RELOC) == 0)
2231 info->buffer = gdb_bfd_map_section (sectp, &info->size);
2235 buf = obstack_alloc (&objfile->objfile_obstack, info->size);
2238 /* When debugging .o files, we may need to apply relocations; see
2239 http://sourceware.org/ml/gdb-patches/2002-04/msg00136.html .
2240 We never compress sections in .o files, so we only need to
2241 try this when the section is not compressed. */
2242 retbuf = symfile_relocate_debug_section (objfile, sectp, buf);
2245 info->buffer = retbuf;
2249 abfd = get_section_bfd_owner (info);
2250 gdb_assert (abfd != NULL);
2252 if (bfd_seek (abfd, sectp->filepos, SEEK_SET) != 0
2253 || bfd_bread (buf, info->size, abfd) != info->size)
2255 error (_("Dwarf Error: Can't read DWARF data"
2256 " in section %s [in module %s]"),
2257 bfd_section_name (abfd, sectp), bfd_get_filename (abfd));
2261 /* A helper function that returns the size of a section in a safe way.
2262 If you are positive that the section has been read before using the
2263 size, then it is safe to refer to the dwarf2_section_info object's
2264 "size" field directly. In other cases, you must call this
2265 function, because for compressed sections the size field is not set
2266 correctly until the section has been read. */
2268 static bfd_size_type
2269 dwarf2_section_size (struct objfile *objfile,
2270 struct dwarf2_section_info *info)
2273 dwarf2_read_section (objfile, info);
2277 /* Fill in SECTP, BUFP and SIZEP with section info, given OBJFILE and
2281 dwarf2_get_section_info (struct objfile *objfile,
2282 enum dwarf2_section_enum sect,
2283 asection **sectp, const gdb_byte **bufp,
2284 bfd_size_type *sizep)
2286 struct dwarf2_per_objfile *data
2287 = objfile_data (objfile, dwarf2_objfile_data_key);
2288 struct dwarf2_section_info *info;
2290 /* We may see an objfile without any DWARF, in which case we just
2301 case DWARF2_DEBUG_FRAME:
2302 info = &data->frame;
2304 case DWARF2_EH_FRAME:
2305 info = &data->eh_frame;
2308 gdb_assert_not_reached ("unexpected section");
2311 dwarf2_read_section (objfile, info);
2313 *sectp = get_section_bfd_section (info);
2314 *bufp = info->buffer;
2315 *sizep = info->size;
2318 /* A helper function to find the sections for a .dwz file. */
2321 locate_dwz_sections (bfd *abfd, asection *sectp, void *arg)
2323 struct dwz_file *dwz_file = arg;
2325 /* Note that we only support the standard ELF names, because .dwz
2326 is ELF-only (at the time of writing). */
2327 if (section_is_p (sectp->name, &dwarf2_elf_names.abbrev))
2329 dwz_file->abbrev.s.asection = sectp;
2330 dwz_file->abbrev.size = bfd_get_section_size (sectp);
2332 else if (section_is_p (sectp->name, &dwarf2_elf_names.info))
2334 dwz_file->info.s.asection = sectp;
2335 dwz_file->info.size = bfd_get_section_size (sectp);
2337 else if (section_is_p (sectp->name, &dwarf2_elf_names.str))
2339 dwz_file->str.s.asection = sectp;
2340 dwz_file->str.size = bfd_get_section_size (sectp);
2342 else if (section_is_p (sectp->name, &dwarf2_elf_names.line))
2344 dwz_file->line.s.asection = sectp;
2345 dwz_file->line.size = bfd_get_section_size (sectp);
2347 else if (section_is_p (sectp->name, &dwarf2_elf_names.macro))
2349 dwz_file->macro.s.asection = sectp;
2350 dwz_file->macro.size = bfd_get_section_size (sectp);
2352 else if (section_is_p (sectp->name, &dwarf2_elf_names.gdb_index))
2354 dwz_file->gdb_index.s.asection = sectp;
2355 dwz_file->gdb_index.size = bfd_get_section_size (sectp);
2359 /* Open the separate '.dwz' debug file, if needed. Return NULL if
2360 there is no .gnu_debugaltlink section in the file. Error if there
2361 is such a section but the file cannot be found. */
2363 static struct dwz_file *
2364 dwarf2_get_dwz_file (void)
2368 struct cleanup *cleanup;
2369 const char *filename;
2370 struct dwz_file *result;
2371 bfd_size_type buildid_len_arg;
2375 if (dwarf2_per_objfile->dwz_file != NULL)
2376 return dwarf2_per_objfile->dwz_file;
2378 bfd_set_error (bfd_error_no_error);
2379 data = bfd_get_alt_debug_link_info (dwarf2_per_objfile->objfile->obfd,
2380 &buildid_len_arg, &buildid);
2383 if (bfd_get_error () == bfd_error_no_error)
2385 error (_("could not read '.gnu_debugaltlink' section: %s"),
2386 bfd_errmsg (bfd_get_error ()));
2388 cleanup = make_cleanup (xfree, data);
2389 make_cleanup (xfree, buildid);
2391 buildid_len = (size_t) buildid_len_arg;
2393 filename = (const char *) data;
2394 if (!IS_ABSOLUTE_PATH (filename))
2396 char *abs = gdb_realpath (objfile_name (dwarf2_per_objfile->objfile));
2399 make_cleanup (xfree, abs);
2400 abs = ldirname (abs);
2401 make_cleanup (xfree, abs);
2403 rel = concat (abs, SLASH_STRING, filename, (char *) NULL);
2404 make_cleanup (xfree, rel);
2408 /* First try the file name given in the section. If that doesn't
2409 work, try to use the build-id instead. */
2410 dwz_bfd = gdb_bfd_open (filename, gnutarget, -1);
2411 if (dwz_bfd != NULL)
2413 if (!build_id_verify (dwz_bfd, buildid_len, buildid))
2415 gdb_bfd_unref (dwz_bfd);
2420 if (dwz_bfd == NULL)
2421 dwz_bfd = build_id_to_debug_bfd (buildid_len, buildid);
2423 if (dwz_bfd == NULL)
2424 error (_("could not find '.gnu_debugaltlink' file for %s"),
2425 objfile_name (dwarf2_per_objfile->objfile));
2427 result = OBSTACK_ZALLOC (&dwarf2_per_objfile->objfile->objfile_obstack,
2429 result->dwz_bfd = dwz_bfd;
2431 bfd_map_over_sections (dwz_bfd, locate_dwz_sections, result);
2433 do_cleanups (cleanup);
2435 dwarf2_per_objfile->dwz_file = result;
2439 /* DWARF quick_symbols_functions support. */
2441 /* TUs can share .debug_line entries, and there can be a lot more TUs than
2442 unique line tables, so we maintain a separate table of all .debug_line
2443 derived entries to support the sharing.
2444 All the quick functions need is the list of file names. We discard the
2445 line_header when we're done and don't need to record it here. */
2446 struct quick_file_names
2448 /* The data used to construct the hash key. */
2449 struct stmt_list_hash hash;
2451 /* The number of entries in file_names, real_names. */
2452 unsigned int num_file_names;
2454 /* The file names from the line table, after being run through
2456 const char **file_names;
2458 /* The file names from the line table after being run through
2459 gdb_realpath. These are computed lazily. */
2460 const char **real_names;
2463 /* When using the index (and thus not using psymtabs), each CU has an
2464 object of this type. This is used to hold information needed by
2465 the various "quick" methods. */
2466 struct dwarf2_per_cu_quick_data
2468 /* The file table. This can be NULL if there was no file table
2469 or it's currently not read in.
2470 NOTE: This points into dwarf2_per_objfile->quick_file_names_table. */
2471 struct quick_file_names *file_names;
2473 /* The corresponding symbol table. This is NULL if symbols for this
2474 CU have not yet been read. */
2475 struct symtab *symtab;
2477 /* A temporary mark bit used when iterating over all CUs in
2478 expand_symtabs_matching. */
2479 unsigned int mark : 1;
2481 /* True if we've tried to read the file table and found there isn't one.
2482 There will be no point in trying to read it again next time. */
2483 unsigned int no_file_data : 1;
2486 /* Utility hash function for a stmt_list_hash. */
2489 hash_stmt_list_entry (const struct stmt_list_hash *stmt_list_hash)
2493 if (stmt_list_hash->dwo_unit != NULL)
2494 v += (uintptr_t) stmt_list_hash->dwo_unit->dwo_file;
2495 v += stmt_list_hash->line_offset.sect_off;
2499 /* Utility equality function for a stmt_list_hash. */
2502 eq_stmt_list_entry (const struct stmt_list_hash *lhs,
2503 const struct stmt_list_hash *rhs)
2505 if ((lhs->dwo_unit != NULL) != (rhs->dwo_unit != NULL))
2507 if (lhs->dwo_unit != NULL
2508 && lhs->dwo_unit->dwo_file != rhs->dwo_unit->dwo_file)
2511 return lhs->line_offset.sect_off == rhs->line_offset.sect_off;
2514 /* Hash function for a quick_file_names. */
2517 hash_file_name_entry (const void *e)
2519 const struct quick_file_names *file_data = e;
2521 return hash_stmt_list_entry (&file_data->hash);
2524 /* Equality function for a quick_file_names. */
2527 eq_file_name_entry (const void *a, const void *b)
2529 const struct quick_file_names *ea = a;
2530 const struct quick_file_names *eb = b;
2532 return eq_stmt_list_entry (&ea->hash, &eb->hash);
2535 /* Delete function for a quick_file_names. */
2538 delete_file_name_entry (void *e)
2540 struct quick_file_names *file_data = e;
2543 for (i = 0; i < file_data->num_file_names; ++i)
2545 xfree ((void*) file_data->file_names[i]);
2546 if (file_data->real_names)
2547 xfree ((void*) file_data->real_names[i]);
2550 /* The space for the struct itself lives on objfile_obstack,
2551 so we don't free it here. */
2554 /* Create a quick_file_names hash table. */
2557 create_quick_file_names_table (unsigned int nr_initial_entries)
2559 return htab_create_alloc (nr_initial_entries,
2560 hash_file_name_entry, eq_file_name_entry,
2561 delete_file_name_entry, xcalloc, xfree);
2564 /* Read in PER_CU->CU. This function is unrelated to symtabs, symtab would
2565 have to be created afterwards. You should call age_cached_comp_units after
2566 processing PER_CU->CU. dw2_setup must have been already called. */
2569 load_cu (struct dwarf2_per_cu_data *per_cu)
2571 if (per_cu->is_debug_types)
2572 load_full_type_unit (per_cu);
2574 load_full_comp_unit (per_cu, language_minimal);
2576 gdb_assert (per_cu->cu != NULL);
2578 dwarf2_find_base_address (per_cu->cu->dies, per_cu->cu);
2581 /* Read in the symbols for PER_CU. */
2584 dw2_do_instantiate_symtab (struct dwarf2_per_cu_data *per_cu)
2586 struct cleanup *back_to;
2588 /* Skip type_unit_groups, reading the type units they contain
2589 is handled elsewhere. */
2590 if (IS_TYPE_UNIT_GROUP (per_cu))
2593 back_to = make_cleanup (dwarf2_release_queue, NULL);
2595 if (dwarf2_per_objfile->using_index
2596 ? per_cu->v.quick->symtab == NULL
2597 : (per_cu->v.psymtab == NULL || !per_cu->v.psymtab->readin))
2599 queue_comp_unit (per_cu, language_minimal);
2602 /* If we just loaded a CU from a DWO, and we're working with an index
2603 that may badly handle TUs, load all the TUs in that DWO as well.
2604 http://sourceware.org/bugzilla/show_bug.cgi?id=15021 */
2605 if (!per_cu->is_debug_types
2606 && per_cu->cu->dwo_unit != NULL
2607 && dwarf2_per_objfile->index_table != NULL
2608 && dwarf2_per_objfile->index_table->version <= 7
2609 /* DWP files aren't supported yet. */
2610 && get_dwp_file () == NULL)
2611 queue_and_load_all_dwo_tus (per_cu);
2616 /* Age the cache, releasing compilation units that have not
2617 been used recently. */
2618 age_cached_comp_units ();
2620 do_cleanups (back_to);
2623 /* Ensure that the symbols for PER_CU have been read in. OBJFILE is
2624 the objfile from which this CU came. Returns the resulting symbol
2627 static struct symtab *
2628 dw2_instantiate_symtab (struct dwarf2_per_cu_data *per_cu)
2630 gdb_assert (dwarf2_per_objfile->using_index);
2631 if (!per_cu->v.quick->symtab)
2633 struct cleanup *back_to = make_cleanup (free_cached_comp_units, NULL);
2634 increment_reading_symtab ();
2635 dw2_do_instantiate_symtab (per_cu);
2636 process_cu_includes ();
2637 do_cleanups (back_to);
2639 return per_cu->v.quick->symtab;
2642 /* Return the CU given its index.
2644 This is intended for loops like:
2646 for (i = 0; i < (dwarf2_per_objfile->n_comp_units
2647 + dwarf2_per_objfile->n_type_units); ++i)
2649 struct dwarf2_per_cu_data *per_cu = dw2_get_cu (i);
2655 static struct dwarf2_per_cu_data *
2656 dw2_get_cu (int index)
2658 if (index >= dwarf2_per_objfile->n_comp_units)
2660 index -= dwarf2_per_objfile->n_comp_units;
2661 gdb_assert (index < dwarf2_per_objfile->n_type_units);
2662 return &dwarf2_per_objfile->all_type_units[index]->per_cu;
2665 return dwarf2_per_objfile->all_comp_units[index];
2668 /* Return the primary CU given its index.
2669 The difference between this function and dw2_get_cu is in the handling
2670 of type units (TUs). Here we return the type_unit_group object.
2672 This is intended for loops like:
2674 for (i = 0; i < (dwarf2_per_objfile->n_comp_units
2675 + dwarf2_per_objfile->n_type_unit_groups); ++i)
2677 struct dwarf2_per_cu_data *per_cu = dw2_get_primary_cu (i);
2683 static struct dwarf2_per_cu_data *
2684 dw2_get_primary_cu (int index)
2686 if (index >= dwarf2_per_objfile->n_comp_units)
2688 index -= dwarf2_per_objfile->n_comp_units;
2689 gdb_assert (index < dwarf2_per_objfile->n_type_unit_groups);
2690 return &dwarf2_per_objfile->all_type_unit_groups[index]->per_cu;
2693 return dwarf2_per_objfile->all_comp_units[index];
2696 /* A helper for create_cus_from_index that handles a given list of
2700 create_cus_from_index_list (struct objfile *objfile,
2701 const gdb_byte *cu_list, offset_type n_elements,
2702 struct dwarf2_section_info *section,
2708 for (i = 0; i < n_elements; i += 2)
2710 struct dwarf2_per_cu_data *the_cu;
2711 ULONGEST offset, length;
2713 gdb_static_assert (sizeof (ULONGEST) >= 8);
2714 offset = extract_unsigned_integer (cu_list, 8, BFD_ENDIAN_LITTLE);
2715 length = extract_unsigned_integer (cu_list + 8, 8, BFD_ENDIAN_LITTLE);
2718 the_cu = OBSTACK_ZALLOC (&objfile->objfile_obstack,
2719 struct dwarf2_per_cu_data);
2720 the_cu->offset.sect_off = offset;
2721 the_cu->length = length;
2722 the_cu->objfile = objfile;
2723 the_cu->section = section;
2724 the_cu->v.quick = OBSTACK_ZALLOC (&objfile->objfile_obstack,
2725 struct dwarf2_per_cu_quick_data);
2726 the_cu->is_dwz = is_dwz;
2727 dwarf2_per_objfile->all_comp_units[base_offset + i / 2] = the_cu;
2731 /* Read the CU list from the mapped index, and use it to create all
2732 the CU objects for this objfile. */
2735 create_cus_from_index (struct objfile *objfile,
2736 const gdb_byte *cu_list, offset_type cu_list_elements,
2737 const gdb_byte *dwz_list, offset_type dwz_elements)
2739 struct dwz_file *dwz;
2741 dwarf2_per_objfile->n_comp_units = (cu_list_elements + dwz_elements) / 2;
2742 dwarf2_per_objfile->all_comp_units
2743 = obstack_alloc (&objfile->objfile_obstack,
2744 dwarf2_per_objfile->n_comp_units
2745 * sizeof (struct dwarf2_per_cu_data *));
2747 create_cus_from_index_list (objfile, cu_list, cu_list_elements,
2748 &dwarf2_per_objfile->info, 0, 0);
2750 if (dwz_elements == 0)
2753 dwz = dwarf2_get_dwz_file ();
2754 create_cus_from_index_list (objfile, dwz_list, dwz_elements, &dwz->info, 1,
2755 cu_list_elements / 2);
2758 /* Create the signatured type hash table from the index. */
2761 create_signatured_type_table_from_index (struct objfile *objfile,
2762 struct dwarf2_section_info *section,
2763 const gdb_byte *bytes,
2764 offset_type elements)
2767 htab_t sig_types_hash;
2769 dwarf2_per_objfile->n_type_units = elements / 3;
2770 dwarf2_per_objfile->all_type_units
2771 = xmalloc (dwarf2_per_objfile->n_type_units
2772 * sizeof (struct signatured_type *));
2774 sig_types_hash = allocate_signatured_type_table (objfile);
2776 for (i = 0; i < elements; i += 3)
2778 struct signatured_type *sig_type;
2779 ULONGEST offset, type_offset_in_tu, signature;
2782 gdb_static_assert (sizeof (ULONGEST) >= 8);
2783 offset = extract_unsigned_integer (bytes, 8, BFD_ENDIAN_LITTLE);
2784 type_offset_in_tu = extract_unsigned_integer (bytes + 8, 8,
2786 signature = extract_unsigned_integer (bytes + 16, 8, BFD_ENDIAN_LITTLE);
2789 sig_type = OBSTACK_ZALLOC (&objfile->objfile_obstack,
2790 struct signatured_type);
2791 sig_type->signature = signature;
2792 sig_type->type_offset_in_tu.cu_off = type_offset_in_tu;
2793 sig_type->per_cu.is_debug_types = 1;
2794 sig_type->per_cu.section = section;
2795 sig_type->per_cu.offset.sect_off = offset;
2796 sig_type->per_cu.objfile = objfile;
2797 sig_type->per_cu.v.quick
2798 = OBSTACK_ZALLOC (&objfile->objfile_obstack,
2799 struct dwarf2_per_cu_quick_data);
2801 slot = htab_find_slot (sig_types_hash, sig_type, INSERT);
2804 dwarf2_per_objfile->all_type_units[i / 3] = sig_type;
2807 dwarf2_per_objfile->signatured_types = sig_types_hash;
2810 /* Read the address map data from the mapped index, and use it to
2811 populate the objfile's psymtabs_addrmap. */
2814 create_addrmap_from_index (struct objfile *objfile, struct mapped_index *index)
2816 const gdb_byte *iter, *end;
2817 struct obstack temp_obstack;
2818 struct addrmap *mutable_map;
2819 struct cleanup *cleanup;
2822 obstack_init (&temp_obstack);
2823 cleanup = make_cleanup_obstack_free (&temp_obstack);
2824 mutable_map = addrmap_create_mutable (&temp_obstack);
2826 iter = index->address_table;
2827 end = iter + index->address_table_size;
2829 baseaddr = ANOFFSET (objfile->section_offsets, SECT_OFF_TEXT (objfile));
2833 ULONGEST hi, lo, cu_index;
2834 lo = extract_unsigned_integer (iter, 8, BFD_ENDIAN_LITTLE);
2836 hi = extract_unsigned_integer (iter, 8, BFD_ENDIAN_LITTLE);
2838 cu_index = extract_unsigned_integer (iter, 4, BFD_ENDIAN_LITTLE);
2843 complaint (&symfile_complaints,
2844 _(".gdb_index address table has invalid range (%s - %s)"),
2845 hex_string (lo), hex_string (hi));
2849 if (cu_index >= dwarf2_per_objfile->n_comp_units)
2851 complaint (&symfile_complaints,
2852 _(".gdb_index address table has invalid CU number %u"),
2853 (unsigned) cu_index);
2857 addrmap_set_empty (mutable_map, lo + baseaddr, hi + baseaddr - 1,
2858 dw2_get_cu (cu_index));
2861 objfile->psymtabs_addrmap = addrmap_create_fixed (mutable_map,
2862 &objfile->objfile_obstack);
2863 do_cleanups (cleanup);
2866 /* The hash function for strings in the mapped index. This is the same as
2867 SYMBOL_HASH_NEXT, but we keep a separate copy to maintain control over the
2868 implementation. This is necessary because the hash function is tied to the
2869 format of the mapped index file. The hash values do not have to match with
2872 Use INT_MAX for INDEX_VERSION if you generate the current index format. */
2875 mapped_index_string_hash (int index_version, const void *p)
2877 const unsigned char *str = (const unsigned char *) p;
2881 while ((c = *str++) != 0)
2883 if (index_version >= 5)
2885 r = r * 67 + c - 113;
2891 /* Find a slot in the mapped index INDEX for the object named NAME.
2892 If NAME is found, set *VEC_OUT to point to the CU vector in the
2893 constant pool and return 1. If NAME cannot be found, return 0. */
2896 find_slot_in_mapped_hash (struct mapped_index *index, const char *name,
2897 offset_type **vec_out)
2899 struct cleanup *back_to = make_cleanup (null_cleanup, 0);
2901 offset_type slot, step;
2902 int (*cmp) (const char *, const char *);
2904 if (current_language->la_language == language_cplus
2905 || current_language->la_language == language_java
2906 || current_language->la_language == language_fortran)
2908 /* NAME is already canonical. Drop any qualifiers as .gdb_index does
2910 const char *paren = strchr (name, '(');
2916 dup = xmalloc (paren - name + 1);
2917 memcpy (dup, name, paren - name);
2918 dup[paren - name] = 0;
2920 make_cleanup (xfree, dup);
2925 /* Index version 4 did not support case insensitive searches. But the
2926 indices for case insensitive languages are built in lowercase, therefore
2927 simulate our NAME being searched is also lowercased. */
2928 hash = mapped_index_string_hash ((index->version == 4
2929 && case_sensitivity == case_sensitive_off
2930 ? 5 : index->version),
2933 slot = hash & (index->symbol_table_slots - 1);
2934 step = ((hash * 17) & (index->symbol_table_slots - 1)) | 1;
2935 cmp = (case_sensitivity == case_sensitive_on ? strcmp : strcasecmp);
2939 /* Convert a slot number to an offset into the table. */
2940 offset_type i = 2 * slot;
2942 if (index->symbol_table[i] == 0 && index->symbol_table[i + 1] == 0)
2944 do_cleanups (back_to);
2948 str = index->constant_pool + MAYBE_SWAP (index->symbol_table[i]);
2949 if (!cmp (name, str))
2951 *vec_out = (offset_type *) (index->constant_pool
2952 + MAYBE_SWAP (index->symbol_table[i + 1]));
2953 do_cleanups (back_to);
2957 slot = (slot + step) & (index->symbol_table_slots - 1);
2961 /* A helper function that reads the .gdb_index from SECTION and fills
2962 in MAP. FILENAME is the name of the file containing the section;
2963 it is used for error reporting. DEPRECATED_OK is nonzero if it is
2964 ok to use deprecated sections.
2966 CU_LIST, CU_LIST_ELEMENTS, TYPES_LIST, and TYPES_LIST_ELEMENTS are
2967 out parameters that are filled in with information about the CU and
2968 TU lists in the section.
2970 Returns 1 if all went well, 0 otherwise. */
2973 read_index_from_section (struct objfile *objfile,
2974 const char *filename,
2976 struct dwarf2_section_info *section,
2977 struct mapped_index *map,
2978 const gdb_byte **cu_list,
2979 offset_type *cu_list_elements,
2980 const gdb_byte **types_list,
2981 offset_type *types_list_elements)
2983 const gdb_byte *addr;
2984 offset_type version;
2985 offset_type *metadata;
2988 if (dwarf2_section_empty_p (section))
2991 /* Older elfutils strip versions could keep the section in the main
2992 executable while splitting it for the separate debug info file. */
2993 if ((get_section_flags (section) & SEC_HAS_CONTENTS) == 0)
2996 dwarf2_read_section (objfile, section);
2998 addr = section->buffer;
2999 /* Version check. */
3000 version = MAYBE_SWAP (*(offset_type *) addr);
3001 /* Versions earlier than 3 emitted every copy of a psymbol. This
3002 causes the index to behave very poorly for certain requests. Version 3
3003 contained incomplete addrmap. So, it seems better to just ignore such
3007 static int warning_printed = 0;
3008 if (!warning_printed)
3010 warning (_("Skipping obsolete .gdb_index section in %s."),
3012 warning_printed = 1;
3016 /* Index version 4 uses a different hash function than index version
3019 Versions earlier than 6 did not emit psymbols for inlined
3020 functions. Using these files will cause GDB not to be able to
3021 set breakpoints on inlined functions by name, so we ignore these
3022 indices unless the user has done
3023 "set use-deprecated-index-sections on". */
3024 if (version < 6 && !deprecated_ok)
3026 static int warning_printed = 0;
3027 if (!warning_printed)
3030 Skipping deprecated .gdb_index section in %s.\n\
3031 Do \"set use-deprecated-index-sections on\" before the file is read\n\
3032 to use the section anyway."),
3034 warning_printed = 1;
3038 /* Version 7 indices generated by gold refer to the CU for a symbol instead
3039 of the TU (for symbols coming from TUs),
3040 http://sourceware.org/bugzilla/show_bug.cgi?id=15021.
3041 Plus gold-generated indices can have duplicate entries for global symbols,
3042 http://sourceware.org/bugzilla/show_bug.cgi?id=15646.
3043 These are just performance bugs, and we can't distinguish gdb-generated
3044 indices from gold-generated ones, so issue no warning here. */
3046 /* Indexes with higher version than the one supported by GDB may be no
3047 longer backward compatible. */
3051 map->version = version;
3052 map->total_size = section->size;
3054 metadata = (offset_type *) (addr + sizeof (offset_type));
3057 *cu_list = addr + MAYBE_SWAP (metadata[i]);
3058 *cu_list_elements = ((MAYBE_SWAP (metadata[i + 1]) - MAYBE_SWAP (metadata[i]))
3062 *types_list = addr + MAYBE_SWAP (metadata[i]);
3063 *types_list_elements = ((MAYBE_SWAP (metadata[i + 1])
3064 - MAYBE_SWAP (metadata[i]))
3068 map->address_table = addr + MAYBE_SWAP (metadata[i]);
3069 map->address_table_size = (MAYBE_SWAP (metadata[i + 1])
3070 - MAYBE_SWAP (metadata[i]));
3073 map->symbol_table = (offset_type *) (addr + MAYBE_SWAP (metadata[i]));
3074 map->symbol_table_slots = ((MAYBE_SWAP (metadata[i + 1])
3075 - MAYBE_SWAP (metadata[i]))
3076 / (2 * sizeof (offset_type)));
3079 map->constant_pool = (char *) (addr + MAYBE_SWAP (metadata[i]));
3085 /* Read the index file. If everything went ok, initialize the "quick"
3086 elements of all the CUs and return 1. Otherwise, return 0. */
3089 dwarf2_read_index (struct objfile *objfile)
3091 struct mapped_index local_map, *map;
3092 const gdb_byte *cu_list, *types_list, *dwz_list = NULL;
3093 offset_type cu_list_elements, types_list_elements, dwz_list_elements = 0;
3094 struct dwz_file *dwz;
3096 if (!read_index_from_section (objfile, objfile_name (objfile),
3097 use_deprecated_index_sections,
3098 &dwarf2_per_objfile->gdb_index, &local_map,
3099 &cu_list, &cu_list_elements,
3100 &types_list, &types_list_elements))
3103 /* Don't use the index if it's empty. */
3104 if (local_map.symbol_table_slots == 0)
3107 /* If there is a .dwz file, read it so we can get its CU list as
3109 dwz = dwarf2_get_dwz_file ();
3112 struct mapped_index dwz_map;
3113 const gdb_byte *dwz_types_ignore;
3114 offset_type dwz_types_elements_ignore;
3116 if (!read_index_from_section (objfile, bfd_get_filename (dwz->dwz_bfd),
3118 &dwz->gdb_index, &dwz_map,
3119 &dwz_list, &dwz_list_elements,
3121 &dwz_types_elements_ignore))
3123 warning (_("could not read '.gdb_index' section from %s; skipping"),
3124 bfd_get_filename (dwz->dwz_bfd));
3129 create_cus_from_index (objfile, cu_list, cu_list_elements, dwz_list,
3132 if (types_list_elements)
3134 struct dwarf2_section_info *section;
3136 /* We can only handle a single .debug_types when we have an
3138 if (VEC_length (dwarf2_section_info_def, dwarf2_per_objfile->types) != 1)
3141 section = VEC_index (dwarf2_section_info_def,
3142 dwarf2_per_objfile->types, 0);
3144 create_signatured_type_table_from_index (objfile, section, types_list,
3145 types_list_elements);
3148 create_addrmap_from_index (objfile, &local_map);
3150 map = obstack_alloc (&objfile->objfile_obstack, sizeof (struct mapped_index));
3153 dwarf2_per_objfile->index_table = map;
3154 dwarf2_per_objfile->using_index = 1;
3155 dwarf2_per_objfile->quick_file_names_table =
3156 create_quick_file_names_table (dwarf2_per_objfile->n_comp_units);
3161 /* A helper for the "quick" functions which sets the global
3162 dwarf2_per_objfile according to OBJFILE. */
3165 dw2_setup (struct objfile *objfile)
3167 dwarf2_per_objfile = objfile_data (objfile, dwarf2_objfile_data_key);
3168 gdb_assert (dwarf2_per_objfile);
3171 /* die_reader_func for dw2_get_file_names. */
3174 dw2_get_file_names_reader (const struct die_reader_specs *reader,
3175 const gdb_byte *info_ptr,
3176 struct die_info *comp_unit_die,
3180 struct dwarf2_cu *cu = reader->cu;
3181 struct dwarf2_per_cu_data *this_cu = cu->per_cu;
3182 struct objfile *objfile = dwarf2_per_objfile->objfile;
3183 struct dwarf2_per_cu_data *lh_cu;
3184 struct line_header *lh;
3185 struct attribute *attr;
3187 const char *name, *comp_dir;
3189 struct quick_file_names *qfn;
3190 unsigned int line_offset;
3192 gdb_assert (! this_cu->is_debug_types);
3194 /* Our callers never want to match partial units -- instead they
3195 will match the enclosing full CU. */
3196 if (comp_unit_die->tag == DW_TAG_partial_unit)
3198 this_cu->v.quick->no_file_data = 1;
3207 attr = dwarf2_attr (comp_unit_die, DW_AT_stmt_list, cu);
3210 struct quick_file_names find_entry;
3212 line_offset = DW_UNSND (attr);
3214 /* We may have already read in this line header (TU line header sharing).
3215 If we have we're done. */
3216 find_entry.hash.dwo_unit = cu->dwo_unit;
3217 find_entry.hash.line_offset.sect_off = line_offset;
3218 slot = htab_find_slot (dwarf2_per_objfile->quick_file_names_table,
3219 &find_entry, INSERT);
3222 lh_cu->v.quick->file_names = *slot;
3226 lh = dwarf_decode_line_header (line_offset, cu);
3230 lh_cu->v.quick->no_file_data = 1;
3234 qfn = obstack_alloc (&objfile->objfile_obstack, sizeof (*qfn));
3235 qfn->hash.dwo_unit = cu->dwo_unit;
3236 qfn->hash.line_offset.sect_off = line_offset;
3237 gdb_assert (slot != NULL);
3240 find_file_and_directory (comp_unit_die, cu, &name, &comp_dir);
3242 qfn->num_file_names = lh->num_file_names;
3243 qfn->file_names = obstack_alloc (&objfile->objfile_obstack,
3244 lh->num_file_names * sizeof (char *));
3245 for (i = 0; i < lh->num_file_names; ++i)
3246 qfn->file_names[i] = file_full_name (i + 1, lh, comp_dir);
3247 qfn->real_names = NULL;
3249 free_line_header (lh);
3251 lh_cu->v.quick->file_names = qfn;
3254 /* A helper for the "quick" functions which attempts to read the line
3255 table for THIS_CU. */
3257 static struct quick_file_names *
3258 dw2_get_file_names (struct dwarf2_per_cu_data *this_cu)
3260 /* This should never be called for TUs. */
3261 gdb_assert (! this_cu->is_debug_types);
3262 /* Nor type unit groups. */
3263 gdb_assert (! IS_TYPE_UNIT_GROUP (this_cu));
3265 if (this_cu->v.quick->file_names != NULL)
3266 return this_cu->v.quick->file_names;
3267 /* If we know there is no line data, no point in looking again. */
3268 if (this_cu->v.quick->no_file_data)
3271 init_cutu_and_read_dies_simple (this_cu, dw2_get_file_names_reader, NULL);
3273 if (this_cu->v.quick->no_file_data)
3275 return this_cu->v.quick->file_names;
3278 /* A helper for the "quick" functions which computes and caches the
3279 real path for a given file name from the line table. */
3282 dw2_get_real_path (struct objfile *objfile,
3283 struct quick_file_names *qfn, int index)
3285 if (qfn->real_names == NULL)
3286 qfn->real_names = OBSTACK_CALLOC (&objfile->objfile_obstack,
3287 qfn->num_file_names, char *);
3289 if (qfn->real_names[index] == NULL)
3290 qfn->real_names[index] = gdb_realpath (qfn->file_names[index]);
3292 return qfn->real_names[index];
3295 static struct symtab *
3296 dw2_find_last_source_symtab (struct objfile *objfile)
3300 dw2_setup (objfile);
3301 index = dwarf2_per_objfile->n_comp_units - 1;
3302 return dw2_instantiate_symtab (dw2_get_cu (index));
3305 /* Traversal function for dw2_forget_cached_source_info. */
3308 dw2_free_cached_file_names (void **slot, void *info)
3310 struct quick_file_names *file_data = (struct quick_file_names *) *slot;
3312 if (file_data->real_names)
3316 for (i = 0; i < file_data->num_file_names; ++i)
3318 xfree ((void*) file_data->real_names[i]);
3319 file_data->real_names[i] = NULL;
3327 dw2_forget_cached_source_info (struct objfile *objfile)
3329 dw2_setup (objfile);
3331 htab_traverse_noresize (dwarf2_per_objfile->quick_file_names_table,
3332 dw2_free_cached_file_names, NULL);
3335 /* Helper function for dw2_map_symtabs_matching_filename that expands
3336 the symtabs and calls the iterator. */
3339 dw2_map_expand_apply (struct objfile *objfile,
3340 struct dwarf2_per_cu_data *per_cu,
3341 const char *name, const char *real_path,
3342 int (*callback) (struct symtab *, void *),
3345 struct symtab *last_made = objfile->symtabs;
3347 /* Don't visit already-expanded CUs. */
3348 if (per_cu->v.quick->symtab)
3351 /* This may expand more than one symtab, and we want to iterate over
3353 dw2_instantiate_symtab (per_cu);
3355 return iterate_over_some_symtabs (name, real_path, callback, data,
3356 objfile->symtabs, last_made);
3359 /* Implementation of the map_symtabs_matching_filename method. */
3362 dw2_map_symtabs_matching_filename (struct objfile *objfile, const char *name,
3363 const char *real_path,
3364 int (*callback) (struct symtab *, void *),
3368 const char *name_basename = lbasename (name);
3370 dw2_setup (objfile);
3372 /* The rule is CUs specify all the files, including those used by
3373 any TU, so there's no need to scan TUs here. */
3375 for (i = 0; i < dwarf2_per_objfile->n_comp_units; ++i)
3378 struct dwarf2_per_cu_data *per_cu = dw2_get_primary_cu (i);
3379 struct quick_file_names *file_data;
3381 /* We only need to look at symtabs not already expanded. */
3382 if (per_cu->v.quick->symtab)
3385 file_data = dw2_get_file_names (per_cu);
3386 if (file_data == NULL)
3389 for (j = 0; j < file_data->num_file_names; ++j)
3391 const char *this_name = file_data->file_names[j];
3392 const char *this_real_name;
3394 if (compare_filenames_for_search (this_name, name))
3396 if (dw2_map_expand_apply (objfile, per_cu, name, real_path,
3402 /* Before we invoke realpath, which can get expensive when many
3403 files are involved, do a quick comparison of the basenames. */
3404 if (! basenames_may_differ
3405 && FILENAME_CMP (lbasename (this_name), name_basename) != 0)
3408 this_real_name = dw2_get_real_path (objfile, file_data, j);
3409 if (compare_filenames_for_search (this_real_name, name))
3411 if (dw2_map_expand_apply (objfile, per_cu, name, real_path,
3417 if (real_path != NULL)
3419 gdb_assert (IS_ABSOLUTE_PATH (real_path));
3420 gdb_assert (IS_ABSOLUTE_PATH (name));
3421 if (this_real_name != NULL
3422 && FILENAME_CMP (real_path, this_real_name) == 0)
3424 if (dw2_map_expand_apply (objfile, per_cu, name, real_path,
3436 /* Struct used to manage iterating over all CUs looking for a symbol. */
3438 struct dw2_symtab_iterator
3440 /* The internalized form of .gdb_index. */
3441 struct mapped_index *index;
3442 /* If non-zero, only look for symbols that match BLOCK_INDEX. */
3443 int want_specific_block;
3444 /* One of GLOBAL_BLOCK or STATIC_BLOCK.
3445 Unused if !WANT_SPECIFIC_BLOCK. */
3447 /* The kind of symbol we're looking for. */
3449 /* The list of CUs from the index entry of the symbol,
3450 or NULL if not found. */
3452 /* The next element in VEC to look at. */
3454 /* The number of elements in VEC, or zero if there is no match. */
3456 /* Have we seen a global version of the symbol?
3457 If so we can ignore all further global instances.
3458 This is to work around gold/15646, inefficient gold-generated
3463 /* Initialize the index symtab iterator ITER.
3464 If WANT_SPECIFIC_BLOCK is non-zero, only look for symbols
3465 in block BLOCK_INDEX. Otherwise BLOCK_INDEX is ignored. */
3468 dw2_symtab_iter_init (struct dw2_symtab_iterator *iter,
3469 struct mapped_index *index,
3470 int want_specific_block,
3475 iter->index = index;
3476 iter->want_specific_block = want_specific_block;
3477 iter->block_index = block_index;
3478 iter->domain = domain;
3480 iter->global_seen = 0;
3482 if (find_slot_in_mapped_hash (index, name, &iter->vec))
3483 iter->length = MAYBE_SWAP (*iter->vec);
3491 /* Return the next matching CU or NULL if there are no more. */
3493 static struct dwarf2_per_cu_data *
3494 dw2_symtab_iter_next (struct dw2_symtab_iterator *iter)
3496 for ( ; iter->next < iter->length; ++iter->next)
3498 offset_type cu_index_and_attrs =
3499 MAYBE_SWAP (iter->vec[iter->next + 1]);
3500 offset_type cu_index = GDB_INDEX_CU_VALUE (cu_index_and_attrs);
3501 struct dwarf2_per_cu_data *per_cu;
3502 int want_static = iter->block_index != GLOBAL_BLOCK;
3503 /* This value is only valid for index versions >= 7. */
3504 int is_static = GDB_INDEX_SYMBOL_STATIC_VALUE (cu_index_and_attrs);
3505 gdb_index_symbol_kind symbol_kind =
3506 GDB_INDEX_SYMBOL_KIND_VALUE (cu_index_and_attrs);
3507 /* Only check the symbol attributes if they're present.
3508 Indices prior to version 7 don't record them,
3509 and indices >= 7 may elide them for certain symbols
3510 (gold does this). */
3512 (iter->index->version >= 7
3513 && symbol_kind != GDB_INDEX_SYMBOL_KIND_NONE);
3515 /* Don't crash on bad data. */
3516 if (cu_index >= (dwarf2_per_objfile->n_comp_units
3517 + dwarf2_per_objfile->n_type_units))
3519 complaint (&symfile_complaints,
3520 _(".gdb_index entry has bad CU index"
3522 objfile_name (dwarf2_per_objfile->objfile));
3526 per_cu = dw2_get_cu (cu_index);
3528 /* Skip if already read in. */
3529 if (per_cu->v.quick->symtab)
3532 /* Check static vs global. */
3535 if (iter->want_specific_block
3536 && want_static != is_static)
3538 /* Work around gold/15646. */
3539 if (!is_static && iter->global_seen)
3542 iter->global_seen = 1;
3545 /* Only check the symbol's kind if it has one. */
3548 switch (iter->domain)
3551 if (symbol_kind != GDB_INDEX_SYMBOL_KIND_VARIABLE
3552 && symbol_kind != GDB_INDEX_SYMBOL_KIND_FUNCTION
3553 /* Some types are also in VAR_DOMAIN. */
3554 && symbol_kind != GDB_INDEX_SYMBOL_KIND_TYPE)
3558 if (symbol_kind != GDB_INDEX_SYMBOL_KIND_TYPE)
3562 if (symbol_kind != GDB_INDEX_SYMBOL_KIND_OTHER)
3577 static struct symtab *
3578 dw2_lookup_symbol (struct objfile *objfile, int block_index,
3579 const char *name, domain_enum domain)
3581 struct symtab *stab_best = NULL;
3582 struct mapped_index *index;
3584 dw2_setup (objfile);
3586 index = dwarf2_per_objfile->index_table;
3588 /* index is NULL if OBJF_READNOW. */
3591 struct dw2_symtab_iterator iter;
3592 struct dwarf2_per_cu_data *per_cu;
3594 dw2_symtab_iter_init (&iter, index, 1, block_index, domain, name);
3596 while ((per_cu = dw2_symtab_iter_next (&iter)) != NULL)
3598 struct symbol *sym = NULL;
3599 struct symtab *stab = dw2_instantiate_symtab (per_cu);
3601 /* Some caution must be observed with overloaded functions
3602 and methods, since the index will not contain any overload
3603 information (but NAME might contain it). */
3606 struct blockvector *bv = BLOCKVECTOR (stab);
3607 struct block *block = BLOCKVECTOR_BLOCK (bv, block_index);
3609 sym = lookup_block_symbol (block, name, domain);
3612 if (sym && strcmp_iw (SYMBOL_SEARCH_NAME (sym), name) == 0)
3614 if (!TYPE_IS_OPAQUE (SYMBOL_TYPE (sym)))
3620 /* Keep looking through other CUs. */
3628 dw2_print_stats (struct objfile *objfile)
3630 int i, total, count;
3632 dw2_setup (objfile);
3633 total = dwarf2_per_objfile->n_comp_units + dwarf2_per_objfile->n_type_units;
3635 for (i = 0; i < total; ++i)
3637 struct dwarf2_per_cu_data *per_cu = dw2_get_cu (i);
3639 if (!per_cu->v.quick->symtab)
3642 printf_filtered (_(" Number of read CUs: %d\n"), total - count);
3643 printf_filtered (_(" Number of unread CUs: %d\n"), count);
3646 /* This dumps minimal information about the index.
3647 It is called via "mt print objfiles".
3648 One use is to verify .gdb_index has been loaded by the
3649 gdb.dwarf2/gdb-index.exp testcase. */
3652 dw2_dump (struct objfile *objfile)
3654 dw2_setup (objfile);
3655 gdb_assert (dwarf2_per_objfile->using_index);
3656 printf_filtered (".gdb_index:");
3657 if (dwarf2_per_objfile->index_table != NULL)
3659 printf_filtered (" version %d\n",
3660 dwarf2_per_objfile->index_table->version);
3663 printf_filtered (" faked for \"readnow\"\n");
3664 printf_filtered ("\n");
3668 dw2_relocate (struct objfile *objfile,
3669 const struct section_offsets *new_offsets,
3670 const struct section_offsets *delta)
3672 /* There's nothing to relocate here. */
3676 dw2_expand_symtabs_for_function (struct objfile *objfile,
3677 const char *func_name)
3679 struct mapped_index *index;
3681 dw2_setup (objfile);
3683 index = dwarf2_per_objfile->index_table;
3685 /* index is NULL if OBJF_READNOW. */
3688 struct dw2_symtab_iterator iter;
3689 struct dwarf2_per_cu_data *per_cu;
3691 /* Note: It doesn't matter what we pass for block_index here. */
3692 dw2_symtab_iter_init (&iter, index, 0, GLOBAL_BLOCK, VAR_DOMAIN,
3695 while ((per_cu = dw2_symtab_iter_next (&iter)) != NULL)
3696 dw2_instantiate_symtab (per_cu);
3701 dw2_expand_all_symtabs (struct objfile *objfile)
3705 dw2_setup (objfile);
3707 for (i = 0; i < (dwarf2_per_objfile->n_comp_units
3708 + dwarf2_per_objfile->n_type_units); ++i)
3710 struct dwarf2_per_cu_data *per_cu = dw2_get_cu (i);
3712 dw2_instantiate_symtab (per_cu);
3717 dw2_expand_symtabs_with_fullname (struct objfile *objfile,
3718 const char *fullname)
3722 dw2_setup (objfile);
3724 /* We don't need to consider type units here.
3725 This is only called for examining code, e.g. expand_line_sal.
3726 There can be an order of magnitude (or more) more type units
3727 than comp units, and we avoid them if we can. */
3729 for (i = 0; i < dwarf2_per_objfile->n_comp_units; ++i)
3732 struct dwarf2_per_cu_data *per_cu = dw2_get_cu (i);
3733 struct quick_file_names *file_data;
3735 /* We only need to look at symtabs not already expanded. */
3736 if (per_cu->v.quick->symtab)
3739 file_data = dw2_get_file_names (per_cu);
3740 if (file_data == NULL)
3743 for (j = 0; j < file_data->num_file_names; ++j)
3745 const char *this_fullname = file_data->file_names[j];
3747 if (filename_cmp (this_fullname, fullname) == 0)
3749 dw2_instantiate_symtab (per_cu);
3757 dw2_map_matching_symbols (struct objfile *objfile,
3758 const char * name, domain_enum namespace,
3760 int (*callback) (struct block *,
3761 struct symbol *, void *),
3762 void *data, symbol_compare_ftype *match,
3763 symbol_compare_ftype *ordered_compare)
3765 /* Currently unimplemented; used for Ada. The function can be called if the
3766 current language is Ada for a non-Ada objfile using GNU index. As Ada
3767 does not look for non-Ada symbols this function should just return. */
3771 dw2_expand_symtabs_matching
3772 (struct objfile *objfile,
3773 int (*file_matcher) (const char *, void *, int basenames),
3774 int (*name_matcher) (const char *, void *),
3775 enum search_domain kind,
3780 struct mapped_index *index;
3782 dw2_setup (objfile);
3784 /* index_table is NULL if OBJF_READNOW. */
3785 if (!dwarf2_per_objfile->index_table)
3787 index = dwarf2_per_objfile->index_table;
3789 if (file_matcher != NULL)
3791 struct cleanup *cleanup;
3792 htab_t visited_found, visited_not_found;
3794 visited_found = htab_create_alloc (10,
3795 htab_hash_pointer, htab_eq_pointer,
3796 NULL, xcalloc, xfree);
3797 cleanup = make_cleanup_htab_delete (visited_found);
3798 visited_not_found = htab_create_alloc (10,
3799 htab_hash_pointer, htab_eq_pointer,
3800 NULL, xcalloc, xfree);
3801 make_cleanup_htab_delete (visited_not_found);
3803 /* The rule is CUs specify all the files, including those used by
3804 any TU, so there's no need to scan TUs here. */
3806 for (i = 0; i < dwarf2_per_objfile->n_comp_units; ++i)
3809 struct dwarf2_per_cu_data *per_cu = dw2_get_primary_cu (i);
3810 struct quick_file_names *file_data;
3813 per_cu->v.quick->mark = 0;
3815 /* We only need to look at symtabs not already expanded. */
3816 if (per_cu->v.quick->symtab)
3819 file_data = dw2_get_file_names (per_cu);
3820 if (file_data == NULL)
3823 if (htab_find (visited_not_found, file_data) != NULL)
3825 else if (htab_find (visited_found, file_data) != NULL)
3827 per_cu->v.quick->mark = 1;
3831 for (j = 0; j < file_data->num_file_names; ++j)
3833 const char *this_real_name;
3835 if (file_matcher (file_data->file_names[j], data, 0))
3837 per_cu->v.quick->mark = 1;
3841 /* Before we invoke realpath, which can get expensive when many
3842 files are involved, do a quick comparison of the basenames. */
3843 if (!basenames_may_differ
3844 && !file_matcher (lbasename (file_data->file_names[j]),
3848 this_real_name = dw2_get_real_path (objfile, file_data, j);
3849 if (file_matcher (this_real_name, data, 0))
3851 per_cu->v.quick->mark = 1;
3856 slot = htab_find_slot (per_cu->v.quick->mark
3858 : visited_not_found,
3863 do_cleanups (cleanup);
3866 for (iter = 0; iter < index->symbol_table_slots; ++iter)
3868 offset_type idx = 2 * iter;
3870 offset_type *vec, vec_len, vec_idx;
3871 int global_seen = 0;
3873 if (index->symbol_table[idx] == 0 && index->symbol_table[idx + 1] == 0)
3876 name = index->constant_pool + MAYBE_SWAP (index->symbol_table[idx]);
3878 if (! (*name_matcher) (name, data))
3881 /* The name was matched, now expand corresponding CUs that were
3883 vec = (offset_type *) (index->constant_pool
3884 + MAYBE_SWAP (index->symbol_table[idx + 1]));
3885 vec_len = MAYBE_SWAP (vec[0]);
3886 for (vec_idx = 0; vec_idx < vec_len; ++vec_idx)
3888 struct dwarf2_per_cu_data *per_cu;
3889 offset_type cu_index_and_attrs = MAYBE_SWAP (vec[vec_idx + 1]);
3890 /* This value is only valid for index versions >= 7. */
3891 int is_static = GDB_INDEX_SYMBOL_STATIC_VALUE (cu_index_and_attrs);
3892 gdb_index_symbol_kind symbol_kind =
3893 GDB_INDEX_SYMBOL_KIND_VALUE (cu_index_and_attrs);
3894 int cu_index = GDB_INDEX_CU_VALUE (cu_index_and_attrs);
3895 /* Only check the symbol attributes if they're present.
3896 Indices prior to version 7 don't record them,
3897 and indices >= 7 may elide them for certain symbols
3898 (gold does this). */
3900 (index->version >= 7
3901 && symbol_kind != GDB_INDEX_SYMBOL_KIND_NONE);
3903 /* Work around gold/15646. */
3906 if (!is_static && global_seen)
3912 /* Only check the symbol's kind if it has one. */
3917 case VARIABLES_DOMAIN:
3918 if (symbol_kind != GDB_INDEX_SYMBOL_KIND_VARIABLE)
3921 case FUNCTIONS_DOMAIN:
3922 if (symbol_kind != GDB_INDEX_SYMBOL_KIND_FUNCTION)
3926 if (symbol_kind != GDB_INDEX_SYMBOL_KIND_TYPE)
3934 /* Don't crash on bad data. */
3935 if (cu_index >= (dwarf2_per_objfile->n_comp_units
3936 + dwarf2_per_objfile->n_type_units))
3938 complaint (&symfile_complaints,
3939 _(".gdb_index entry has bad CU index"
3940 " [in module %s]"), objfile_name (objfile));
3944 per_cu = dw2_get_cu (cu_index);
3945 if (file_matcher == NULL || per_cu->v.quick->mark)
3946 dw2_instantiate_symtab (per_cu);
3951 /* A helper for dw2_find_pc_sect_symtab which finds the most specific
3954 static struct symtab *
3955 recursively_find_pc_sect_symtab (struct symtab *symtab, CORE_ADDR pc)
3959 if (BLOCKVECTOR (symtab) != NULL
3960 && blockvector_contains_pc (BLOCKVECTOR (symtab), pc))
3963 if (symtab->includes == NULL)
3966 for (i = 0; symtab->includes[i]; ++i)
3968 struct symtab *s = symtab->includes[i];
3970 s = recursively_find_pc_sect_symtab (s, pc);
3978 static struct symtab *
3979 dw2_find_pc_sect_symtab (struct objfile *objfile,
3980 struct minimal_symbol *msymbol,
3982 struct obj_section *section,
3985 struct dwarf2_per_cu_data *data;
3986 struct symtab *result;
3988 dw2_setup (objfile);
3990 if (!objfile->psymtabs_addrmap)
3993 data = addrmap_find (objfile->psymtabs_addrmap, pc);
3997 if (warn_if_readin && data->v.quick->symtab)
3998 warning (_("(Internal error: pc %s in read in CU, but not in symtab.)"),
3999 paddress (get_objfile_arch (objfile), pc));
4001 result = recursively_find_pc_sect_symtab (dw2_instantiate_symtab (data), pc);
4002 gdb_assert (result != NULL);
4007 dw2_map_symbol_filenames (struct objfile *objfile, symbol_filename_ftype *fun,
4008 void *data, int need_fullname)
4011 struct cleanup *cleanup;
4012 htab_t visited = htab_create_alloc (10, htab_hash_pointer, htab_eq_pointer,
4013 NULL, xcalloc, xfree);
4015 cleanup = make_cleanup_htab_delete (visited);
4016 dw2_setup (objfile);
4018 /* The rule is CUs specify all the files, including those used by
4019 any TU, so there's no need to scan TUs here.
4020 We can ignore file names coming from already-expanded CUs. */
4022 for (i = 0; i < dwarf2_per_objfile->n_comp_units; ++i)
4024 struct dwarf2_per_cu_data *per_cu = dw2_get_cu (i);
4026 if (per_cu->v.quick->symtab)
4028 void **slot = htab_find_slot (visited, per_cu->v.quick->file_names,
4031 *slot = per_cu->v.quick->file_names;
4035 for (i = 0; i < dwarf2_per_objfile->n_comp_units; ++i)
4038 struct dwarf2_per_cu_data *per_cu = dw2_get_primary_cu (i);
4039 struct quick_file_names *file_data;
4042 /* We only need to look at symtabs not already expanded. */
4043 if (per_cu->v.quick->symtab)
4046 file_data = dw2_get_file_names (per_cu);
4047 if (file_data == NULL)
4050 slot = htab_find_slot (visited, file_data, INSERT);
4053 /* Already visited. */
4058 for (j = 0; j < file_data->num_file_names; ++j)
4060 const char *this_real_name;
4063 this_real_name = dw2_get_real_path (objfile, file_data, j);
4065 this_real_name = NULL;
4066 (*fun) (file_data->file_names[j], this_real_name, data);
4070 do_cleanups (cleanup);
4074 dw2_has_symbols (struct objfile *objfile)
4079 const struct quick_symbol_functions dwarf2_gdb_index_functions =
4082 dw2_find_last_source_symtab,
4083 dw2_forget_cached_source_info,
4084 dw2_map_symtabs_matching_filename,
4089 dw2_expand_symtabs_for_function,
4090 dw2_expand_all_symtabs,
4091 dw2_expand_symtabs_with_fullname,
4092 dw2_map_matching_symbols,
4093 dw2_expand_symtabs_matching,
4094 dw2_find_pc_sect_symtab,
4095 dw2_map_symbol_filenames
4098 /* Initialize for reading DWARF for this objfile. Return 0 if this
4099 file will use psymtabs, or 1 if using the GNU index. */
4102 dwarf2_initialize_objfile (struct objfile *objfile)
4104 /* If we're about to read full symbols, don't bother with the
4105 indices. In this case we also don't care if some other debug
4106 format is making psymtabs, because they are all about to be
4108 if ((objfile->flags & OBJF_READNOW))
4112 dwarf2_per_objfile->using_index = 1;
4113 create_all_comp_units (objfile);
4114 create_all_type_units (objfile);
4115 dwarf2_per_objfile->quick_file_names_table =
4116 create_quick_file_names_table (dwarf2_per_objfile->n_comp_units);
4118 for (i = 0; i < (dwarf2_per_objfile->n_comp_units
4119 + dwarf2_per_objfile->n_type_units); ++i)
4121 struct dwarf2_per_cu_data *per_cu = dw2_get_cu (i);
4123 per_cu->v.quick = OBSTACK_ZALLOC (&objfile->objfile_obstack,
4124 struct dwarf2_per_cu_quick_data);
4127 /* Return 1 so that gdb sees the "quick" functions. However,
4128 these functions will be no-ops because we will have expanded
4133 if (dwarf2_read_index (objfile))
4141 /* Build a partial symbol table. */
4144 dwarf2_build_psymtabs (struct objfile *objfile)
4146 volatile struct gdb_exception except;
4148 if (objfile->global_psymbols.size == 0 && objfile->static_psymbols.size == 0)
4150 init_psymbol_list (objfile, 1024);
4153 TRY_CATCH (except, RETURN_MASK_ERROR)
4155 /* This isn't really ideal: all the data we allocate on the
4156 objfile's obstack is still uselessly kept around. However,
4157 freeing it seems unsafe. */
4158 struct cleanup *cleanups = make_cleanup_discard_psymtabs (objfile);
4160 dwarf2_build_psymtabs_hard (objfile);
4161 discard_cleanups (cleanups);
4163 if (except.reason < 0)
4164 exception_print (gdb_stderr, except);
4167 /* Return the total length of the CU described by HEADER. */
4170 get_cu_length (const struct comp_unit_head *header)
4172 return header->initial_length_size + header->length;
4175 /* Return TRUE if OFFSET is within CU_HEADER. */
4178 offset_in_cu_p (const struct comp_unit_head *cu_header, sect_offset offset)
4180 sect_offset bottom = { cu_header->offset.sect_off };
4181 sect_offset top = { cu_header->offset.sect_off + get_cu_length (cu_header) };
4183 return (offset.sect_off >= bottom.sect_off && offset.sect_off < top.sect_off);
4186 /* Find the base address of the compilation unit for range lists and
4187 location lists. It will normally be specified by DW_AT_low_pc.
4188 In DWARF-3 draft 4, the base address could be overridden by
4189 DW_AT_entry_pc. It's been removed, but GCC still uses this for
4190 compilation units with discontinuous ranges. */
4193 dwarf2_find_base_address (struct die_info *die, struct dwarf2_cu *cu)
4195 struct attribute *attr;
4198 cu->base_address = 0;
4200 attr = dwarf2_attr (die, DW_AT_entry_pc, cu);
4203 cu->base_address = DW_ADDR (attr);
4208 attr = dwarf2_attr (die, DW_AT_low_pc, cu);
4211 cu->base_address = DW_ADDR (attr);
4217 /* Read in the comp unit header information from the debug_info at info_ptr.
4218 NOTE: This leaves members offset, first_die_offset to be filled in
4221 static const gdb_byte *
4222 read_comp_unit_head (struct comp_unit_head *cu_header,
4223 const gdb_byte *info_ptr, bfd *abfd)
4226 unsigned int bytes_read;
4228 cu_header->length = read_initial_length (abfd, info_ptr, &bytes_read);
4229 cu_header->initial_length_size = bytes_read;
4230 cu_header->offset_size = (bytes_read == 4) ? 4 : 8;
4231 info_ptr += bytes_read;
4232 cu_header->version = read_2_bytes (abfd, info_ptr);
4234 cu_header->abbrev_offset.sect_off = read_offset (abfd, info_ptr, cu_header,
4236 info_ptr += bytes_read;
4237 cu_header->addr_size = read_1_byte (abfd, info_ptr);
4239 signed_addr = bfd_get_sign_extend_vma (abfd);
4240 if (signed_addr < 0)
4241 internal_error (__FILE__, __LINE__,
4242 _("read_comp_unit_head: dwarf from non elf file"));
4243 cu_header->signed_addr_p = signed_addr;
4248 /* Helper function that returns the proper abbrev section for
4251 static struct dwarf2_section_info *
4252 get_abbrev_section_for_cu (struct dwarf2_per_cu_data *this_cu)
4254 struct dwarf2_section_info *abbrev;
4256 if (this_cu->is_dwz)
4257 abbrev = &dwarf2_get_dwz_file ()->abbrev;
4259 abbrev = &dwarf2_per_objfile->abbrev;
4264 /* Subroutine of read_and_check_comp_unit_head and
4265 read_and_check_type_unit_head to simplify them.
4266 Perform various error checking on the header. */
4269 error_check_comp_unit_head (struct comp_unit_head *header,
4270 struct dwarf2_section_info *section,
4271 struct dwarf2_section_info *abbrev_section)
4273 bfd *abfd = get_section_bfd_owner (section);
4274 const char *filename = get_section_file_name (section);
4276 if (header->version != 2 && header->version != 3 && header->version != 4)
4277 error (_("Dwarf Error: wrong version in compilation unit header "
4278 "(is %d, should be 2, 3, or 4) [in module %s]"), header->version,
4281 if (header->abbrev_offset.sect_off
4282 >= dwarf2_section_size (dwarf2_per_objfile->objfile, abbrev_section))
4283 error (_("Dwarf Error: bad offset (0x%lx) in compilation unit header "
4284 "(offset 0x%lx + 6) [in module %s]"),
4285 (long) header->abbrev_offset.sect_off, (long) header->offset.sect_off,
4288 /* Cast to unsigned long to use 64-bit arithmetic when possible to
4289 avoid potential 32-bit overflow. */
4290 if (((unsigned long) header->offset.sect_off + get_cu_length (header))
4292 error (_("Dwarf Error: bad length (0x%lx) in compilation unit header "
4293 "(offset 0x%lx + 0) [in module %s]"),
4294 (long) header->length, (long) header->offset.sect_off,
4298 /* Read in a CU/TU header and perform some basic error checking.
4299 The contents of the header are stored in HEADER.
4300 The result is a pointer to the start of the first DIE. */
4302 static const gdb_byte *
4303 read_and_check_comp_unit_head (struct comp_unit_head *header,
4304 struct dwarf2_section_info *section,
4305 struct dwarf2_section_info *abbrev_section,
4306 const gdb_byte *info_ptr,
4307 int is_debug_types_section)
4309 const gdb_byte *beg_of_comp_unit = info_ptr;
4310 bfd *abfd = get_section_bfd_owner (section);
4312 header->offset.sect_off = beg_of_comp_unit - section->buffer;
4314 info_ptr = read_comp_unit_head (header, info_ptr, abfd);
4316 /* If we're reading a type unit, skip over the signature and
4317 type_offset fields. */
4318 if (is_debug_types_section)
4319 info_ptr += 8 /*signature*/ + header->offset_size;
4321 header->first_die_offset.cu_off = info_ptr - beg_of_comp_unit;
4323 error_check_comp_unit_head (header, section, abbrev_section);
4328 /* Read in the types comp unit header information from .debug_types entry at
4329 types_ptr. The result is a pointer to one past the end of the header. */
4331 static const gdb_byte *
4332 read_and_check_type_unit_head (struct comp_unit_head *header,
4333 struct dwarf2_section_info *section,
4334 struct dwarf2_section_info *abbrev_section,
4335 const gdb_byte *info_ptr,
4336 ULONGEST *signature,
4337 cu_offset *type_offset_in_tu)
4339 const gdb_byte *beg_of_comp_unit = info_ptr;
4340 bfd *abfd = get_section_bfd_owner (section);
4342 header->offset.sect_off = beg_of_comp_unit - section->buffer;
4344 info_ptr = read_comp_unit_head (header, info_ptr, abfd);
4346 /* If we're reading a type unit, skip over the signature and
4347 type_offset fields. */
4348 if (signature != NULL)
4349 *signature = read_8_bytes (abfd, info_ptr);
4351 if (type_offset_in_tu != NULL)
4352 type_offset_in_tu->cu_off = read_offset_1 (abfd, info_ptr,
4353 header->offset_size);
4354 info_ptr += header->offset_size;
4356 header->first_die_offset.cu_off = info_ptr - beg_of_comp_unit;
4358 error_check_comp_unit_head (header, section, abbrev_section);
4363 /* Fetch the abbreviation table offset from a comp or type unit header. */
4366 read_abbrev_offset (struct dwarf2_section_info *section,
4369 bfd *abfd = get_section_bfd_owner (section);
4370 const gdb_byte *info_ptr;
4371 unsigned int length, initial_length_size, offset_size;
4372 sect_offset abbrev_offset;
4374 dwarf2_read_section (dwarf2_per_objfile->objfile, section);
4375 info_ptr = section->buffer + offset.sect_off;
4376 length = read_initial_length (abfd, info_ptr, &initial_length_size);
4377 offset_size = initial_length_size == 4 ? 4 : 8;
4378 info_ptr += initial_length_size + 2 /*version*/;
4379 abbrev_offset.sect_off = read_offset_1 (abfd, info_ptr, offset_size);
4380 return abbrev_offset;
4383 /* Allocate a new partial symtab for file named NAME and mark this new
4384 partial symtab as being an include of PST. */
4387 dwarf2_create_include_psymtab (const char *name, struct partial_symtab *pst,
4388 struct objfile *objfile)
4390 struct partial_symtab *subpst = allocate_psymtab (name, objfile);
4392 if (!IS_ABSOLUTE_PATH (subpst->filename))
4394 /* It shares objfile->objfile_obstack. */
4395 subpst->dirname = pst->dirname;
4398 subpst->section_offsets = pst->section_offsets;
4399 subpst->textlow = 0;
4400 subpst->texthigh = 0;
4402 subpst->dependencies = (struct partial_symtab **)
4403 obstack_alloc (&objfile->objfile_obstack,
4404 sizeof (struct partial_symtab *));
4405 subpst->dependencies[0] = pst;
4406 subpst->number_of_dependencies = 1;
4408 subpst->globals_offset = 0;
4409 subpst->n_global_syms = 0;
4410 subpst->statics_offset = 0;
4411 subpst->n_static_syms = 0;
4412 subpst->symtab = NULL;
4413 subpst->read_symtab = pst->read_symtab;
4416 /* No private part is necessary for include psymtabs. This property
4417 can be used to differentiate between such include psymtabs and
4418 the regular ones. */
4419 subpst->read_symtab_private = NULL;
4422 /* Read the Line Number Program data and extract the list of files
4423 included by the source file represented by PST. Build an include
4424 partial symtab for each of these included files. */
4427 dwarf2_build_include_psymtabs (struct dwarf2_cu *cu,
4428 struct die_info *die,
4429 struct partial_symtab *pst)
4431 struct line_header *lh = NULL;
4432 struct attribute *attr;
4434 attr = dwarf2_attr (die, DW_AT_stmt_list, cu);
4436 lh = dwarf_decode_line_header (DW_UNSND (attr), cu);
4438 return; /* No linetable, so no includes. */
4440 /* NOTE: pst->dirname is DW_AT_comp_dir (if present). */
4441 dwarf_decode_lines (lh, pst->dirname, cu, pst, 1);
4443 free_line_header (lh);
4447 hash_signatured_type (const void *item)
4449 const struct signatured_type *sig_type = item;
4451 /* This drops the top 32 bits of the signature, but is ok for a hash. */
4452 return sig_type->signature;
4456 eq_signatured_type (const void *item_lhs, const void *item_rhs)
4458 const struct signatured_type *lhs = item_lhs;
4459 const struct signatured_type *rhs = item_rhs;
4461 return lhs->signature == rhs->signature;
4464 /* Allocate a hash table for signatured types. */
4467 allocate_signatured_type_table (struct objfile *objfile)
4469 return htab_create_alloc_ex (41,
4470 hash_signatured_type,
4473 &objfile->objfile_obstack,
4474 hashtab_obstack_allocate,
4475 dummy_obstack_deallocate);
4478 /* A helper function to add a signatured type CU to a table. */
4481 add_signatured_type_cu_to_table (void **slot, void *datum)
4483 struct signatured_type *sigt = *slot;
4484 struct signatured_type ***datap = datum;
4492 /* Create the hash table of all entries in the .debug_types
4493 (or .debug_types.dwo) section(s).
4494 If reading a DWO file, then DWO_FILE is a pointer to the DWO file object,
4495 otherwise it is NULL.
4497 The result is a pointer to the hash table or NULL if there are no types.
4499 Note: This function processes DWO files only, not DWP files. */
4502 create_debug_types_hash_table (struct dwo_file *dwo_file,
4503 VEC (dwarf2_section_info_def) *types)
4505 struct objfile *objfile = dwarf2_per_objfile->objfile;
4506 htab_t types_htab = NULL;
4508 struct dwarf2_section_info *section;
4509 struct dwarf2_section_info *abbrev_section;
4511 if (VEC_empty (dwarf2_section_info_def, types))
4514 abbrev_section = (dwo_file != NULL
4515 ? &dwo_file->sections.abbrev
4516 : &dwarf2_per_objfile->abbrev);
4518 if (dwarf2_read_debug)
4519 fprintf_unfiltered (gdb_stdlog, "Reading .debug_types%s for %s:\n",
4520 dwo_file ? ".dwo" : "",
4521 get_section_file_name (abbrev_section));
4524 VEC_iterate (dwarf2_section_info_def, types, ix, section);
4528 const gdb_byte *info_ptr, *end_ptr;
4530 dwarf2_read_section (objfile, section);
4531 info_ptr = section->buffer;
4533 if (info_ptr == NULL)
4536 /* We can't set abfd until now because the section may be empty or
4537 not present, in which case the bfd is unknown. */
4538 abfd = get_section_bfd_owner (section);
4540 /* We don't use init_cutu_and_read_dies_simple, or some such, here
4541 because we don't need to read any dies: the signature is in the
4544 end_ptr = info_ptr + section->size;
4545 while (info_ptr < end_ptr)
4548 cu_offset type_offset_in_tu;
4550 struct signatured_type *sig_type;
4551 struct dwo_unit *dwo_tu;
4553 const gdb_byte *ptr = info_ptr;
4554 struct comp_unit_head header;
4555 unsigned int length;
4557 offset.sect_off = ptr - section->buffer;
4559 /* We need to read the type's signature in order to build the hash
4560 table, but we don't need anything else just yet. */
4562 ptr = read_and_check_type_unit_head (&header, section,
4563 abbrev_section, ptr,
4564 &signature, &type_offset_in_tu);
4566 length = get_cu_length (&header);
4568 /* Skip dummy type units. */
4569 if (ptr >= info_ptr + length
4570 || peek_abbrev_code (abfd, ptr) == 0)
4576 if (types_htab == NULL)
4579 types_htab = allocate_dwo_unit_table (objfile);
4581 types_htab = allocate_signatured_type_table (objfile);
4587 dwo_tu = OBSTACK_ZALLOC (&objfile->objfile_obstack,
4589 dwo_tu->dwo_file = dwo_file;
4590 dwo_tu->signature = signature;
4591 dwo_tu->type_offset_in_tu = type_offset_in_tu;
4592 dwo_tu->section = section;
4593 dwo_tu->offset = offset;
4594 dwo_tu->length = length;
4598 /* N.B.: type_offset is not usable if this type uses a DWO file.
4599 The real type_offset is in the DWO file. */
4601 sig_type = OBSTACK_ZALLOC (&objfile->objfile_obstack,
4602 struct signatured_type);
4603 sig_type->signature = signature;
4604 sig_type->type_offset_in_tu = type_offset_in_tu;
4605 sig_type->per_cu.objfile = objfile;
4606 sig_type->per_cu.is_debug_types = 1;
4607 sig_type->per_cu.section = section;
4608 sig_type->per_cu.offset = offset;
4609 sig_type->per_cu.length = length;
4612 slot = htab_find_slot (types_htab,
4613 dwo_file ? (void*) dwo_tu : (void *) sig_type,
4615 gdb_assert (slot != NULL);
4618 sect_offset dup_offset;
4622 const struct dwo_unit *dup_tu = *slot;
4624 dup_offset = dup_tu->offset;
4628 const struct signatured_type *dup_tu = *slot;
4630 dup_offset = dup_tu->per_cu.offset;
4633 complaint (&symfile_complaints,
4634 _("debug type entry at offset 0x%x is duplicate to"
4635 " the entry at offset 0x%x, signature %s"),
4636 offset.sect_off, dup_offset.sect_off,
4637 hex_string (signature));
4639 *slot = dwo_file ? (void *) dwo_tu : (void *) sig_type;
4641 if (dwarf2_read_debug > 1)
4642 fprintf_unfiltered (gdb_stdlog, " offset 0x%x, signature %s\n",
4644 hex_string (signature));
4653 /* Create the hash table of all entries in the .debug_types section,
4654 and initialize all_type_units.
4655 The result is zero if there is an error (e.g. missing .debug_types section),
4656 otherwise non-zero. */
4659 create_all_type_units (struct objfile *objfile)
4662 struct signatured_type **iter;
4664 types_htab = create_debug_types_hash_table (NULL, dwarf2_per_objfile->types);
4665 if (types_htab == NULL)
4667 dwarf2_per_objfile->signatured_types = NULL;
4671 dwarf2_per_objfile->signatured_types = types_htab;
4673 dwarf2_per_objfile->n_type_units = htab_elements (types_htab);
4674 dwarf2_per_objfile->all_type_units
4675 = xmalloc (dwarf2_per_objfile->n_type_units
4676 * sizeof (struct signatured_type *));
4677 iter = &dwarf2_per_objfile->all_type_units[0];
4678 htab_traverse_noresize (types_htab, add_signatured_type_cu_to_table, &iter);
4679 gdb_assert (iter - &dwarf2_per_objfile->all_type_units[0]
4680 == dwarf2_per_objfile->n_type_units);
4685 /* Subroutine of lookup_dwo_signatured_type and lookup_dwp_signatured_type.
4686 Fill in SIG_ENTRY with DWO_ENTRY. */
4689 fill_in_sig_entry_from_dwo_entry (struct objfile *objfile,
4690 struct signatured_type *sig_entry,
4691 struct dwo_unit *dwo_entry)
4693 /* Make sure we're not clobbering something we don't expect to. */
4694 gdb_assert (! sig_entry->per_cu.queued);
4695 gdb_assert (sig_entry->per_cu.cu == NULL);
4696 gdb_assert (sig_entry->per_cu.v.quick != NULL);
4697 gdb_assert (sig_entry->per_cu.v.quick->symtab == NULL);
4698 gdb_assert (sig_entry->signature == dwo_entry->signature);
4699 gdb_assert (sig_entry->type_offset_in_section.sect_off == 0);
4700 gdb_assert (sig_entry->type_unit_group == NULL);
4701 gdb_assert (sig_entry->dwo_unit == NULL);
4703 sig_entry->per_cu.section = dwo_entry->section;
4704 sig_entry->per_cu.offset = dwo_entry->offset;
4705 sig_entry->per_cu.length = dwo_entry->length;
4706 sig_entry->per_cu.reading_dwo_directly = 1;
4707 sig_entry->per_cu.objfile = objfile;
4708 sig_entry->type_offset_in_tu = dwo_entry->type_offset_in_tu;
4709 sig_entry->dwo_unit = dwo_entry;
4712 /* Subroutine of lookup_signatured_type.
4713 If we haven't read the TU yet, create the signatured_type data structure
4714 for a TU to be read in directly from a DWO file, bypassing the stub.
4715 This is the "Stay in DWO Optimization": When there is no DWP file and we're
4716 using .gdb_index, then when reading a CU we want to stay in the DWO file
4717 containing that CU. Otherwise we could end up reading several other DWO
4718 files (due to comdat folding) to process the transitive closure of all the
4719 mentioned TUs, and that can be slow. The current DWO file will have every
4720 type signature that it needs.
4721 We only do this for .gdb_index because in the psymtab case we already have
4722 to read all the DWOs to build the type unit groups. */
4724 static struct signatured_type *
4725 lookup_dwo_signatured_type (struct dwarf2_cu *cu, ULONGEST sig)
4727 struct objfile *objfile = dwarf2_per_objfile->objfile;
4728 struct dwo_file *dwo_file;
4729 struct dwo_unit find_dwo_entry, *dwo_entry;
4730 struct signatured_type find_sig_entry, *sig_entry;
4732 gdb_assert (cu->dwo_unit && dwarf2_per_objfile->using_index);
4734 /* Note: cu->dwo_unit is the dwo_unit that references this TU, not the
4735 dwo_unit of the TU itself. */
4736 dwo_file = cu->dwo_unit->dwo_file;
4738 /* We only ever need to read in one copy of a signatured type.
4739 Just use the global signatured_types array. If this is the first time
4740 we're reading this type, replace the recorded data from .gdb_index with
4743 if (dwarf2_per_objfile->signatured_types == NULL)
4745 find_sig_entry.signature = sig;
4746 sig_entry = htab_find (dwarf2_per_objfile->signatured_types, &find_sig_entry);
4747 if (sig_entry == NULL)
4750 /* We can get here with the TU already read, *or* in the process of being
4751 read. Don't reassign it if that's the case. Also note that if the TU is
4752 already being read, it may not have come from a DWO, the program may be
4753 a mix of Fission-compiled code and non-Fission-compiled code. */
4754 /* Have we already tried to read this TU? */
4755 if (sig_entry->per_cu.tu_read)
4758 /* Ok, this is the first time we're reading this TU. */
4759 if (dwo_file->tus == NULL)
4761 find_dwo_entry.signature = sig;
4762 dwo_entry = htab_find (dwo_file->tus, &find_dwo_entry);
4763 if (dwo_entry == NULL)
4766 fill_in_sig_entry_from_dwo_entry (objfile, sig_entry, dwo_entry);
4767 sig_entry->per_cu.tu_read = 1;
4771 /* Subroutine of lookup_dwp_signatured_type.
4772 Add an entry for signature SIG to dwarf2_per_objfile->signatured_types. */
4774 static struct signatured_type *
4775 add_type_unit (ULONGEST sig)
4777 struct objfile *objfile = dwarf2_per_objfile->objfile;
4778 int n_type_units = dwarf2_per_objfile->n_type_units;
4779 struct signatured_type *sig_type;
4783 dwarf2_per_objfile->all_type_units =
4784 xrealloc (dwarf2_per_objfile->all_type_units,
4785 n_type_units * sizeof (struct signatured_type *));
4786 dwarf2_per_objfile->n_type_units = n_type_units;
4787 sig_type = OBSTACK_ZALLOC (&objfile->objfile_obstack,
4788 struct signatured_type);
4789 dwarf2_per_objfile->all_type_units[n_type_units - 1] = sig_type;
4790 sig_type->signature = sig;
4791 sig_type->per_cu.is_debug_types = 1;
4792 sig_type->per_cu.v.quick =
4793 OBSTACK_ZALLOC (&objfile->objfile_obstack,
4794 struct dwarf2_per_cu_quick_data);
4795 slot = htab_find_slot (dwarf2_per_objfile->signatured_types,
4797 gdb_assert (*slot == NULL);
4799 /* The rest of sig_type must be filled in by the caller. */
4803 /* Subroutine of lookup_signatured_type.
4804 Look up the type for signature SIG, and if we can't find SIG in .gdb_index
4805 then try the DWP file.
4806 Normally this "can't happen", but if there's a bug in signature
4807 generation and/or the DWP file is built incorrectly, it can happen.
4808 Using the type directly from the DWP file means we don't have the stub
4809 which has some useful attributes (e.g., DW_AT_comp_dir), but they're
4810 not critical. [Eventually the stub may go away for type units anyway.] */
4812 static struct signatured_type *
4813 lookup_dwp_signatured_type (struct dwarf2_cu *cu, ULONGEST sig)
4815 struct objfile *objfile = dwarf2_per_objfile->objfile;
4816 struct dwp_file *dwp_file = get_dwp_file ();
4817 struct dwo_unit *dwo_entry;
4818 struct signatured_type find_sig_entry, *sig_entry;
4820 gdb_assert (cu->dwo_unit && dwarf2_per_objfile->using_index);
4821 gdb_assert (dwp_file != NULL);
4823 if (dwarf2_per_objfile->signatured_types != NULL)
4825 find_sig_entry.signature = sig;
4826 sig_entry = htab_find (dwarf2_per_objfile->signatured_types,
4828 if (sig_entry != NULL)
4832 /* This is the "shouldn't happen" case.
4833 Try the DWP file and hope for the best. */
4834 if (dwp_file->tus == NULL)
4836 dwo_entry = lookup_dwo_unit_in_dwp (dwp_file, NULL,
4837 sig, 1 /* is_debug_types */);
4838 if (dwo_entry == NULL)
4841 sig_entry = add_type_unit (sig);
4842 fill_in_sig_entry_from_dwo_entry (objfile, sig_entry, dwo_entry);
4844 /* The caller will signal a complaint if we return NULL.
4845 Here we don't return NULL but we still want to complain. */
4846 complaint (&symfile_complaints,
4847 _("Bad type signature %s referenced by %s at 0x%x,"
4848 " coping by using copy in DWP [in module %s]"),
4850 cu->per_cu->is_debug_types ? "TU" : "CU",
4851 cu->per_cu->offset.sect_off,
4852 objfile_name (objfile));
4857 /* Lookup a signature based type for DW_FORM_ref_sig8.
4858 Returns NULL if signature SIG is not present in the table.
4859 It is up to the caller to complain about this. */
4861 static struct signatured_type *
4862 lookup_signatured_type (struct dwarf2_cu *cu, ULONGEST sig)
4865 && dwarf2_per_objfile->using_index)
4867 /* We're in a DWO/DWP file, and we're using .gdb_index.
4868 These cases require special processing. */
4869 if (get_dwp_file () == NULL)
4870 return lookup_dwo_signatured_type (cu, sig);
4872 return lookup_dwp_signatured_type (cu, sig);
4876 struct signatured_type find_entry, *entry;
4878 if (dwarf2_per_objfile->signatured_types == NULL)
4880 find_entry.signature = sig;
4881 entry = htab_find (dwarf2_per_objfile->signatured_types, &find_entry);
4886 /* Low level DIE reading support. */
4888 /* Initialize a die_reader_specs struct from a dwarf2_cu struct. */
4891 init_cu_die_reader (struct die_reader_specs *reader,
4892 struct dwarf2_cu *cu,
4893 struct dwarf2_section_info *section,
4894 struct dwo_file *dwo_file)
4896 gdb_assert (section->readin && section->buffer != NULL);
4897 reader->abfd = get_section_bfd_owner (section);
4899 reader->dwo_file = dwo_file;
4900 reader->die_section = section;
4901 reader->buffer = section->buffer;
4902 reader->buffer_end = section->buffer + section->size;
4903 reader->comp_dir = NULL;
4906 /* Subroutine of init_cutu_and_read_dies to simplify it.
4907 Read in the rest of a CU/TU top level DIE from DWO_UNIT.
4908 There's just a lot of work to do, and init_cutu_and_read_dies is big enough
4911 STUB_COMP_UNIT_DIE is for the stub DIE, we copy over certain attributes
4912 from it to the DIE in the DWO. If NULL we are skipping the stub.
4913 STUB_COMP_DIR is similar to STUB_COMP_UNIT_DIE: When reading a TU directly
4914 from the DWO file, bypassing the stub, it contains the DW_AT_comp_dir
4915 attribute of the referencing CU. Exactly one of STUB_COMP_UNIT_DIE and
4916 COMP_DIR must be non-NULL.
4917 *RESULT_READER,*RESULT_INFO_PTR,*RESULT_COMP_UNIT_DIE,*RESULT_HAS_CHILDREN
4918 are filled in with the info of the DIE from the DWO file.
4919 ABBREV_TABLE_PROVIDED is non-zero if the caller of init_cutu_and_read_dies
4920 provided an abbrev table to use.
4921 The result is non-zero if a valid (non-dummy) DIE was found. */
4924 read_cutu_die_from_dwo (struct dwarf2_per_cu_data *this_cu,
4925 struct dwo_unit *dwo_unit,
4926 int abbrev_table_provided,
4927 struct die_info *stub_comp_unit_die,
4928 const char *stub_comp_dir,
4929 struct die_reader_specs *result_reader,
4930 const gdb_byte **result_info_ptr,
4931 struct die_info **result_comp_unit_die,
4932 int *result_has_children)
4934 struct objfile *objfile = dwarf2_per_objfile->objfile;
4935 struct dwarf2_cu *cu = this_cu->cu;
4936 struct dwarf2_section_info *section;
4938 const gdb_byte *begin_info_ptr, *info_ptr;
4939 const char *comp_dir_string;
4940 ULONGEST signature; /* Or dwo_id. */
4941 struct attribute *comp_dir, *stmt_list, *low_pc, *high_pc, *ranges;
4942 int i,num_extra_attrs;
4943 struct dwarf2_section_info *dwo_abbrev_section;
4944 struct attribute *attr;
4945 struct attribute comp_dir_attr;
4946 struct die_info *comp_unit_die;
4948 /* Both can't be provided. */
4949 gdb_assert (! (stub_comp_unit_die && stub_comp_dir));
4951 /* These attributes aren't processed until later:
4952 DW_AT_stmt_list, DW_AT_low_pc, DW_AT_high_pc, DW_AT_ranges.
4953 However, the attribute is found in the stub which we won't have later.
4954 In order to not impose this complication on the rest of the code,
4955 we read them here and copy them to the DWO CU/TU die. */
4963 if (stub_comp_unit_die != NULL)
4965 /* For TUs in DWO files, the DW_AT_stmt_list attribute lives in the
4967 if (! this_cu->is_debug_types)
4968 stmt_list = dwarf2_attr (stub_comp_unit_die, DW_AT_stmt_list, cu);
4969 low_pc = dwarf2_attr (stub_comp_unit_die, DW_AT_low_pc, cu);
4970 high_pc = dwarf2_attr (stub_comp_unit_die, DW_AT_high_pc, cu);
4971 ranges = dwarf2_attr (stub_comp_unit_die, DW_AT_ranges, cu);
4972 comp_dir = dwarf2_attr (stub_comp_unit_die, DW_AT_comp_dir, cu);
4974 /* There should be a DW_AT_addr_base attribute here (if needed).
4975 We need the value before we can process DW_FORM_GNU_addr_index. */
4977 attr = dwarf2_attr (stub_comp_unit_die, DW_AT_GNU_addr_base, cu);
4979 cu->addr_base = DW_UNSND (attr);
4981 /* There should be a DW_AT_ranges_base attribute here (if needed).
4982 We need the value before we can process DW_AT_ranges. */
4983 cu->ranges_base = 0;
4984 attr = dwarf2_attr (stub_comp_unit_die, DW_AT_GNU_ranges_base, cu);
4986 cu->ranges_base = DW_UNSND (attr);
4988 else if (stub_comp_dir != NULL)
4990 /* Reconstruct the comp_dir attribute to simplify the code below. */
4991 comp_dir = (struct attribute *)
4992 obstack_alloc (&cu->comp_unit_obstack, sizeof (*comp_dir));
4993 comp_dir->name = DW_AT_comp_dir;
4994 comp_dir->form = DW_FORM_string;
4995 DW_STRING_IS_CANONICAL (comp_dir) = 0;
4996 DW_STRING (comp_dir) = stub_comp_dir;
4999 /* Set up for reading the DWO CU/TU. */
5000 cu->dwo_unit = dwo_unit;
5001 section = dwo_unit->section;
5002 dwarf2_read_section (objfile, section);
5003 abfd = get_section_bfd_owner (section);
5004 begin_info_ptr = info_ptr = section->buffer + dwo_unit->offset.sect_off;
5005 dwo_abbrev_section = &dwo_unit->dwo_file->sections.abbrev;
5006 init_cu_die_reader (result_reader, cu, section, dwo_unit->dwo_file);
5008 if (this_cu->is_debug_types)
5010 ULONGEST header_signature;
5011 cu_offset type_offset_in_tu;
5012 struct signatured_type *sig_type = (struct signatured_type *) this_cu;
5014 info_ptr = read_and_check_type_unit_head (&cu->header, section,
5018 &type_offset_in_tu);
5019 /* This is not an assert because it can be caused by bad debug info. */
5020 if (sig_type->signature != header_signature)
5022 error (_("Dwarf Error: signature mismatch %s vs %s while reading"
5023 " TU at offset 0x%x [in module %s]"),
5024 hex_string (sig_type->signature),
5025 hex_string (header_signature),
5026 dwo_unit->offset.sect_off,
5027 bfd_get_filename (abfd));
5029 gdb_assert (dwo_unit->offset.sect_off == cu->header.offset.sect_off);
5030 /* For DWOs coming from DWP files, we don't know the CU length
5031 nor the type's offset in the TU until now. */
5032 dwo_unit->length = get_cu_length (&cu->header);
5033 dwo_unit->type_offset_in_tu = type_offset_in_tu;
5035 /* Establish the type offset that can be used to lookup the type.
5036 For DWO files, we don't know it until now. */
5037 sig_type->type_offset_in_section.sect_off =
5038 dwo_unit->offset.sect_off + dwo_unit->type_offset_in_tu.cu_off;
5042 info_ptr = read_and_check_comp_unit_head (&cu->header, section,
5045 gdb_assert (dwo_unit->offset.sect_off == cu->header.offset.sect_off);
5046 /* For DWOs coming from DWP files, we don't know the CU length
5048 dwo_unit->length = get_cu_length (&cu->header);
5051 /* Replace the CU's original abbrev table with the DWO's.
5052 Reminder: We can't read the abbrev table until we've read the header. */
5053 if (abbrev_table_provided)
5055 /* Don't free the provided abbrev table, the caller of
5056 init_cutu_and_read_dies owns it. */
5057 dwarf2_read_abbrevs (cu, dwo_abbrev_section);
5058 /* Ensure the DWO abbrev table gets freed. */
5059 make_cleanup (dwarf2_free_abbrev_table, cu);
5063 dwarf2_free_abbrev_table (cu);
5064 dwarf2_read_abbrevs (cu, dwo_abbrev_section);
5065 /* Leave any existing abbrev table cleanup as is. */
5068 /* Read in the die, but leave space to copy over the attributes
5069 from the stub. This has the benefit of simplifying the rest of
5070 the code - all the work to maintain the illusion of a single
5071 DW_TAG_{compile,type}_unit DIE is done here. */
5072 num_extra_attrs = ((stmt_list != NULL)
5076 + (comp_dir != NULL));
5077 info_ptr = read_full_die_1 (result_reader, result_comp_unit_die, info_ptr,
5078 result_has_children, num_extra_attrs);
5080 /* Copy over the attributes from the stub to the DIE we just read in. */
5081 comp_unit_die = *result_comp_unit_die;
5082 i = comp_unit_die->num_attrs;
5083 if (stmt_list != NULL)
5084 comp_unit_die->attrs[i++] = *stmt_list;
5086 comp_unit_die->attrs[i++] = *low_pc;
5087 if (high_pc != NULL)
5088 comp_unit_die->attrs[i++] = *high_pc;
5090 comp_unit_die->attrs[i++] = *ranges;
5091 if (comp_dir != NULL)
5092 comp_unit_die->attrs[i++] = *comp_dir;
5093 comp_unit_die->num_attrs += num_extra_attrs;
5095 if (dwarf2_die_debug)
5097 fprintf_unfiltered (gdb_stdlog,
5098 "Read die from %s@0x%x of %s:\n",
5099 get_section_name (section),
5100 (unsigned) (begin_info_ptr - section->buffer),
5101 bfd_get_filename (abfd));
5102 dump_die (comp_unit_die, dwarf2_die_debug);
5105 /* Save the comp_dir attribute. If there is no DWP file then we'll read
5106 TUs by skipping the stub and going directly to the entry in the DWO file.
5107 However, skipping the stub means we won't get DW_AT_comp_dir, so we have
5108 to get it via circuitous means. Blech. */
5109 if (comp_dir != NULL)
5110 result_reader->comp_dir = DW_STRING (comp_dir);
5112 /* Skip dummy compilation units. */
5113 if (info_ptr >= begin_info_ptr + dwo_unit->length
5114 || peek_abbrev_code (abfd, info_ptr) == 0)
5117 *result_info_ptr = info_ptr;
5121 /* Subroutine of init_cutu_and_read_dies to simplify it.
5122 Look up the DWO unit specified by COMP_UNIT_DIE of THIS_CU.
5123 Returns NULL if the specified DWO unit cannot be found. */
5125 static struct dwo_unit *
5126 lookup_dwo_unit (struct dwarf2_per_cu_data *this_cu,
5127 struct die_info *comp_unit_die)
5129 struct dwarf2_cu *cu = this_cu->cu;
5130 struct attribute *attr;
5132 struct dwo_unit *dwo_unit;
5133 const char *comp_dir, *dwo_name;
5135 gdb_assert (cu != NULL);
5137 /* Yeah, we look dwo_name up again, but it simplifies the code. */
5138 attr = dwarf2_attr (comp_unit_die, DW_AT_GNU_dwo_name, cu);
5139 gdb_assert (attr != NULL);
5140 dwo_name = DW_STRING (attr);
5142 attr = dwarf2_attr (comp_unit_die, DW_AT_comp_dir, cu);
5144 comp_dir = DW_STRING (attr);
5146 if (this_cu->is_debug_types)
5148 struct signatured_type *sig_type;
5150 /* Since this_cu is the first member of struct signatured_type,
5151 we can go from a pointer to one to a pointer to the other. */
5152 sig_type = (struct signatured_type *) this_cu;
5153 signature = sig_type->signature;
5154 dwo_unit = lookup_dwo_type_unit (sig_type, dwo_name, comp_dir);
5158 struct attribute *attr;
5160 attr = dwarf2_attr (comp_unit_die, DW_AT_GNU_dwo_id, cu);
5162 error (_("Dwarf Error: missing dwo_id for dwo_name %s"
5164 dwo_name, objfile_name (this_cu->objfile));
5165 signature = DW_UNSND (attr);
5166 dwo_unit = lookup_dwo_comp_unit (this_cu, dwo_name, comp_dir,
5173 /* Subroutine of init_cutu_and_read_dies to simplify it.
5174 Read a TU directly from a DWO file, bypassing the stub. */
5177 init_tu_and_read_dwo_dies (struct dwarf2_per_cu_data *this_cu, int keep,
5178 die_reader_func_ftype *die_reader_func,
5181 struct dwarf2_cu *cu;
5182 struct signatured_type *sig_type;
5183 struct cleanup *cleanups, *free_cu_cleanup;
5184 struct die_reader_specs reader;
5185 const gdb_byte *info_ptr;
5186 struct die_info *comp_unit_die;
5189 /* Verify we can do the following downcast, and that we have the
5191 gdb_assert (this_cu->is_debug_types && this_cu->reading_dwo_directly);
5192 sig_type = (struct signatured_type *) this_cu;
5193 gdb_assert (sig_type->dwo_unit != NULL);
5195 cleanups = make_cleanup (null_cleanup, NULL);
5197 gdb_assert (this_cu->cu == NULL);
5198 cu = xmalloc (sizeof (*cu));
5199 init_one_comp_unit (cu, this_cu);
5200 /* If an error occurs while loading, release our storage. */
5201 free_cu_cleanup = make_cleanup (free_heap_comp_unit, cu);
5203 if (read_cutu_die_from_dwo (this_cu, sig_type->dwo_unit,
5204 0 /* abbrev_table_provided */,
5205 NULL /* stub_comp_unit_die */,
5206 sig_type->dwo_unit->dwo_file->comp_dir,
5208 &comp_unit_die, &has_children) == 0)
5211 do_cleanups (cleanups);
5215 /* All the "real" work is done here. */
5216 die_reader_func (&reader, info_ptr, comp_unit_die, has_children, data);
5218 /* This duplicates some code in init_cutu_and_read_dies,
5219 but the alternative is making the latter more complex.
5220 This function is only for the special case of using DWO files directly:
5221 no point in overly complicating the general case just to handle this. */
5224 /* We've successfully allocated this compilation unit. Let our
5225 caller clean it up when finished with it. */
5226 discard_cleanups (free_cu_cleanup);
5228 /* We can only discard free_cu_cleanup and all subsequent cleanups.
5229 So we have to manually free the abbrev table. */
5230 dwarf2_free_abbrev_table (cu);
5232 /* Link this CU into read_in_chain. */
5233 this_cu->cu->read_in_chain = dwarf2_per_objfile->read_in_chain;
5234 dwarf2_per_objfile->read_in_chain = this_cu;
5237 do_cleanups (free_cu_cleanup);
5239 do_cleanups (cleanups);
5242 /* Initialize a CU (or TU) and read its DIEs.
5243 If the CU defers to a DWO file, read the DWO file as well.
5245 ABBREV_TABLE, if non-NULL, is the abbreviation table to use.
5246 Otherwise the table specified in the comp unit header is read in and used.
5247 This is an optimization for when we already have the abbrev table.
5249 If USE_EXISTING_CU is non-zero, and THIS_CU->cu is non-NULL, then use it.
5250 Otherwise, a new CU is allocated with xmalloc.
5252 If KEEP is non-zero, then if we allocated a dwarf2_cu we add it to
5253 read_in_chain. Otherwise the dwarf2_cu data is freed at the end.
5255 WARNING: If THIS_CU is a "dummy CU" (used as filler by the incremental
5256 linker) then DIE_READER_FUNC will not get called. */
5259 init_cutu_and_read_dies (struct dwarf2_per_cu_data *this_cu,
5260 struct abbrev_table *abbrev_table,
5261 int use_existing_cu, int keep,
5262 die_reader_func_ftype *die_reader_func,
5265 struct objfile *objfile = dwarf2_per_objfile->objfile;
5266 struct dwarf2_section_info *section = this_cu->section;
5267 bfd *abfd = get_section_bfd_owner (section);
5268 struct dwarf2_cu *cu;
5269 const gdb_byte *begin_info_ptr, *info_ptr;
5270 struct die_reader_specs reader;
5271 struct die_info *comp_unit_die;
5273 struct attribute *attr;
5274 struct cleanup *cleanups, *free_cu_cleanup = NULL;
5275 struct signatured_type *sig_type = NULL;
5276 struct dwarf2_section_info *abbrev_section;
5277 /* Non-zero if CU currently points to a DWO file and we need to
5278 reread it. When this happens we need to reread the skeleton die
5279 before we can reread the DWO file (this only applies to CUs, not TUs). */
5280 int rereading_dwo_cu = 0;
5282 if (dwarf2_die_debug)
5283 fprintf_unfiltered (gdb_stdlog, "Reading %s unit at offset 0x%x\n",
5284 this_cu->is_debug_types ? "type" : "comp",
5285 this_cu->offset.sect_off);
5287 if (use_existing_cu)
5290 /* If we're reading a TU directly from a DWO file, including a virtual DWO
5291 file (instead of going through the stub), short-circuit all of this. */
5292 if (this_cu->reading_dwo_directly)
5294 /* Narrow down the scope of possibilities to have to understand. */
5295 gdb_assert (this_cu->is_debug_types);
5296 gdb_assert (abbrev_table == NULL);
5297 gdb_assert (!use_existing_cu);
5298 init_tu_and_read_dwo_dies (this_cu, keep, die_reader_func, data);
5302 cleanups = make_cleanup (null_cleanup, NULL);
5304 /* This is cheap if the section is already read in. */
5305 dwarf2_read_section (objfile, section);
5307 begin_info_ptr = info_ptr = section->buffer + this_cu->offset.sect_off;
5309 abbrev_section = get_abbrev_section_for_cu (this_cu);
5311 if (use_existing_cu && this_cu->cu != NULL)
5315 /* If this CU is from a DWO file we need to start over, we need to
5316 refetch the attributes from the skeleton CU.
5317 This could be optimized by retrieving those attributes from when we
5318 were here the first time: the previous comp_unit_die was stored in
5319 comp_unit_obstack. But there's no data yet that we need this
5321 if (cu->dwo_unit != NULL)
5322 rereading_dwo_cu = 1;
5326 /* If !use_existing_cu, this_cu->cu must be NULL. */
5327 gdb_assert (this_cu->cu == NULL);
5329 cu = xmalloc (sizeof (*cu));
5330 init_one_comp_unit (cu, this_cu);
5332 /* If an error occurs while loading, release our storage. */
5333 free_cu_cleanup = make_cleanup (free_heap_comp_unit, cu);
5336 /* Get the header. */
5337 if (cu->header.first_die_offset.cu_off != 0 && ! rereading_dwo_cu)
5339 /* We already have the header, there's no need to read it in again. */
5340 info_ptr += cu->header.first_die_offset.cu_off;
5344 if (this_cu->is_debug_types)
5347 cu_offset type_offset_in_tu;
5349 info_ptr = read_and_check_type_unit_head (&cu->header, section,
5350 abbrev_section, info_ptr,
5352 &type_offset_in_tu);
5354 /* Since per_cu is the first member of struct signatured_type,
5355 we can go from a pointer to one to a pointer to the other. */
5356 sig_type = (struct signatured_type *) this_cu;
5357 gdb_assert (sig_type->signature == signature);
5358 gdb_assert (sig_type->type_offset_in_tu.cu_off
5359 == type_offset_in_tu.cu_off);
5360 gdb_assert (this_cu->offset.sect_off == cu->header.offset.sect_off);
5362 /* LENGTH has not been set yet for type units if we're
5363 using .gdb_index. */
5364 this_cu->length = get_cu_length (&cu->header);
5366 /* Establish the type offset that can be used to lookup the type. */
5367 sig_type->type_offset_in_section.sect_off =
5368 this_cu->offset.sect_off + sig_type->type_offset_in_tu.cu_off;
5372 info_ptr = read_and_check_comp_unit_head (&cu->header, section,
5376 gdb_assert (this_cu->offset.sect_off == cu->header.offset.sect_off);
5377 gdb_assert (this_cu->length == get_cu_length (&cu->header));
5381 /* Skip dummy compilation units. */
5382 if (info_ptr >= begin_info_ptr + this_cu->length
5383 || peek_abbrev_code (abfd, info_ptr) == 0)
5385 do_cleanups (cleanups);
5389 /* If we don't have them yet, read the abbrevs for this compilation unit.
5390 And if we need to read them now, make sure they're freed when we're
5391 done. Note that it's important that if the CU had an abbrev table
5392 on entry we don't free it when we're done: Somewhere up the call stack
5393 it may be in use. */
5394 if (abbrev_table != NULL)
5396 gdb_assert (cu->abbrev_table == NULL);
5397 gdb_assert (cu->header.abbrev_offset.sect_off
5398 == abbrev_table->offset.sect_off);
5399 cu->abbrev_table = abbrev_table;
5401 else if (cu->abbrev_table == NULL)
5403 dwarf2_read_abbrevs (cu, abbrev_section);
5404 make_cleanup (dwarf2_free_abbrev_table, cu);
5406 else if (rereading_dwo_cu)
5408 dwarf2_free_abbrev_table (cu);
5409 dwarf2_read_abbrevs (cu, abbrev_section);
5412 /* Read the top level CU/TU die. */
5413 init_cu_die_reader (&reader, cu, section, NULL);
5414 info_ptr = read_full_die (&reader, &comp_unit_die, info_ptr, &has_children);
5416 /* If we are in a DWO stub, process it and then read in the "real" CU/TU
5418 Note that if USE_EXISTING_OK != 0, and THIS_CU->cu already contains a
5419 DWO CU, that this test will fail (the attribute will not be present). */
5420 attr = dwarf2_attr (comp_unit_die, DW_AT_GNU_dwo_name, cu);
5423 struct dwo_unit *dwo_unit;
5424 struct die_info *dwo_comp_unit_die;
5428 complaint (&symfile_complaints,
5429 _("compilation unit with DW_AT_GNU_dwo_name"
5430 " has children (offset 0x%x) [in module %s]"),
5431 this_cu->offset.sect_off, bfd_get_filename (abfd));
5433 dwo_unit = lookup_dwo_unit (this_cu, comp_unit_die);
5434 if (dwo_unit != NULL)
5436 if (read_cutu_die_from_dwo (this_cu, dwo_unit,
5437 abbrev_table != NULL,
5438 comp_unit_die, NULL,
5440 &dwo_comp_unit_die, &has_children) == 0)
5443 do_cleanups (cleanups);
5446 comp_unit_die = dwo_comp_unit_die;
5450 /* Yikes, we couldn't find the rest of the DIE, we only have
5451 the stub. A complaint has already been logged. There's
5452 not much more we can do except pass on the stub DIE to
5453 die_reader_func. We don't want to throw an error on bad
5458 /* All of the above is setup for this call. Yikes. */
5459 die_reader_func (&reader, info_ptr, comp_unit_die, has_children, data);
5461 /* Done, clean up. */
5462 if (free_cu_cleanup != NULL)
5466 /* We've successfully allocated this compilation unit. Let our
5467 caller clean it up when finished with it. */
5468 discard_cleanups (free_cu_cleanup);
5470 /* We can only discard free_cu_cleanup and all subsequent cleanups.
5471 So we have to manually free the abbrev table. */
5472 dwarf2_free_abbrev_table (cu);
5474 /* Link this CU into read_in_chain. */
5475 this_cu->cu->read_in_chain = dwarf2_per_objfile->read_in_chain;
5476 dwarf2_per_objfile->read_in_chain = this_cu;
5479 do_cleanups (free_cu_cleanup);
5482 do_cleanups (cleanups);
5485 /* Read CU/TU THIS_CU in section SECTION,
5486 but do not follow DW_AT_GNU_dwo_name if present.
5487 DWOP_FILE, if non-NULL, is the DWO/DWP file to read (the caller is assumed
5488 to have already done the lookup to find the DWO/DWP file).
5490 The caller is required to fill in THIS_CU->section, THIS_CU->offset, and
5491 THIS_CU->is_debug_types, but nothing else.
5493 We fill in THIS_CU->length.
5495 WARNING: If THIS_CU is a "dummy CU" (used as filler by the incremental
5496 linker) then DIE_READER_FUNC will not get called.
5498 THIS_CU->cu is always freed when done.
5499 This is done in order to not leave THIS_CU->cu in a state where we have
5500 to care whether it refers to the "main" CU or the DWO CU. */
5503 init_cutu_and_read_dies_no_follow (struct dwarf2_per_cu_data *this_cu,
5504 struct dwarf2_section_info *abbrev_section,
5505 struct dwo_file *dwo_file,
5506 die_reader_func_ftype *die_reader_func,
5509 struct objfile *objfile = dwarf2_per_objfile->objfile;
5510 struct dwarf2_section_info *section = this_cu->section;
5511 bfd *abfd = get_section_bfd_owner (section);
5512 struct dwarf2_cu cu;
5513 const gdb_byte *begin_info_ptr, *info_ptr;
5514 struct die_reader_specs reader;
5515 struct cleanup *cleanups;
5516 struct die_info *comp_unit_die;
5519 if (dwarf2_die_debug)
5520 fprintf_unfiltered (gdb_stdlog, "Reading %s unit at offset 0x%x\n",
5521 this_cu->is_debug_types ? "type" : "comp",
5522 this_cu->offset.sect_off);
5524 gdb_assert (this_cu->cu == NULL);
5526 /* This is cheap if the section is already read in. */
5527 dwarf2_read_section (objfile, section);
5529 init_one_comp_unit (&cu, this_cu);
5531 cleanups = make_cleanup (free_stack_comp_unit, &cu);
5533 begin_info_ptr = info_ptr = section->buffer + this_cu->offset.sect_off;
5534 info_ptr = read_and_check_comp_unit_head (&cu.header, section,
5535 abbrev_section, info_ptr,
5536 this_cu->is_debug_types);
5538 this_cu->length = get_cu_length (&cu.header);
5540 /* Skip dummy compilation units. */
5541 if (info_ptr >= begin_info_ptr + this_cu->length
5542 || peek_abbrev_code (abfd, info_ptr) == 0)
5544 do_cleanups (cleanups);
5548 dwarf2_read_abbrevs (&cu, abbrev_section);
5549 make_cleanup (dwarf2_free_abbrev_table, &cu);
5551 init_cu_die_reader (&reader, &cu, section, dwo_file);
5552 info_ptr = read_full_die (&reader, &comp_unit_die, info_ptr, &has_children);
5554 die_reader_func (&reader, info_ptr, comp_unit_die, has_children, data);
5556 do_cleanups (cleanups);
5559 /* Read a CU/TU, except that this does not look for DW_AT_GNU_dwo_name and
5560 does not lookup the specified DWO file.
5561 This cannot be used to read DWO files.
5563 THIS_CU->cu is always freed when done.
5564 This is done in order to not leave THIS_CU->cu in a state where we have
5565 to care whether it refers to the "main" CU or the DWO CU.
5566 We can revisit this if the data shows there's a performance issue. */
5569 init_cutu_and_read_dies_simple (struct dwarf2_per_cu_data *this_cu,
5570 die_reader_func_ftype *die_reader_func,
5573 init_cutu_and_read_dies_no_follow (this_cu,
5574 get_abbrev_section_for_cu (this_cu),
5576 die_reader_func, data);
5579 /* Type Unit Groups.
5581 Type Unit Groups are a way to collapse the set of all TUs (type units) into
5582 a more manageable set. The grouping is done by DW_AT_stmt_list entry
5583 so that all types coming from the same compilation (.o file) are grouped
5584 together. A future step could be to put the types in the same symtab as
5585 the CU the types ultimately came from. */
5588 hash_type_unit_group (const void *item)
5590 const struct type_unit_group *tu_group = item;
5592 return hash_stmt_list_entry (&tu_group->hash);
5596 eq_type_unit_group (const void *item_lhs, const void *item_rhs)
5598 const struct type_unit_group *lhs = item_lhs;
5599 const struct type_unit_group *rhs = item_rhs;
5601 return eq_stmt_list_entry (&lhs->hash, &rhs->hash);
5604 /* Allocate a hash table for type unit groups. */
5607 allocate_type_unit_groups_table (void)
5609 return htab_create_alloc_ex (3,
5610 hash_type_unit_group,
5613 &dwarf2_per_objfile->objfile->objfile_obstack,
5614 hashtab_obstack_allocate,
5615 dummy_obstack_deallocate);
5618 /* Type units that don't have DW_AT_stmt_list are grouped into their own
5619 partial symtabs. We combine several TUs per psymtab to not let the size
5620 of any one psymtab grow too big. */
5621 #define NO_STMT_LIST_TYPE_UNIT_PSYMTAB (1 << 31)
5622 #define NO_STMT_LIST_TYPE_UNIT_PSYMTAB_SIZE 10
5624 /* Helper routine for get_type_unit_group.
5625 Create the type_unit_group object used to hold one or more TUs. */
5627 static struct type_unit_group *
5628 create_type_unit_group (struct dwarf2_cu *cu, sect_offset line_offset_struct)
5630 struct objfile *objfile = dwarf2_per_objfile->objfile;
5631 struct dwarf2_per_cu_data *per_cu;
5632 struct type_unit_group *tu_group;
5634 tu_group = OBSTACK_ZALLOC (&objfile->objfile_obstack,
5635 struct type_unit_group);
5636 per_cu = &tu_group->per_cu;
5637 per_cu->objfile = objfile;
5639 if (dwarf2_per_objfile->using_index)
5641 per_cu->v.quick = OBSTACK_ZALLOC (&objfile->objfile_obstack,
5642 struct dwarf2_per_cu_quick_data);
5646 unsigned int line_offset = line_offset_struct.sect_off;
5647 struct partial_symtab *pst;
5650 /* Give the symtab a useful name for debug purposes. */
5651 if ((line_offset & NO_STMT_LIST_TYPE_UNIT_PSYMTAB) != 0)
5652 name = xstrprintf ("<type_units_%d>",
5653 (line_offset & ~NO_STMT_LIST_TYPE_UNIT_PSYMTAB));
5655 name = xstrprintf ("<type_units_at_0x%x>", line_offset);
5657 pst = create_partial_symtab (per_cu, name);
5663 tu_group->hash.dwo_unit = cu->dwo_unit;
5664 tu_group->hash.line_offset = line_offset_struct;
5669 /* Look up the type_unit_group for type unit CU, and create it if necessary.
5670 STMT_LIST is a DW_AT_stmt_list attribute. */
5672 static struct type_unit_group *
5673 get_type_unit_group (struct dwarf2_cu *cu, const struct attribute *stmt_list)
5675 struct tu_stats *tu_stats = &dwarf2_per_objfile->tu_stats;
5676 struct type_unit_group *tu_group;
5678 unsigned int line_offset;
5679 struct type_unit_group type_unit_group_for_lookup;
5681 if (dwarf2_per_objfile->type_unit_groups == NULL)
5683 dwarf2_per_objfile->type_unit_groups =
5684 allocate_type_unit_groups_table ();
5687 /* Do we need to create a new group, or can we use an existing one? */
5691 line_offset = DW_UNSND (stmt_list);
5692 ++tu_stats->nr_symtab_sharers;
5696 /* Ugh, no stmt_list. Rare, but we have to handle it.
5697 We can do various things here like create one group per TU or
5698 spread them over multiple groups to split up the expansion work.
5699 To avoid worst case scenarios (too many groups or too large groups)
5700 we, umm, group them in bunches. */
5701 line_offset = (NO_STMT_LIST_TYPE_UNIT_PSYMTAB
5702 | (tu_stats->nr_stmt_less_type_units
5703 / NO_STMT_LIST_TYPE_UNIT_PSYMTAB_SIZE));
5704 ++tu_stats->nr_stmt_less_type_units;
5707 type_unit_group_for_lookup.hash.dwo_unit = cu->dwo_unit;
5708 type_unit_group_for_lookup.hash.line_offset.sect_off = line_offset;
5709 slot = htab_find_slot (dwarf2_per_objfile->type_unit_groups,
5710 &type_unit_group_for_lookup, INSERT);
5714 gdb_assert (tu_group != NULL);
5718 sect_offset line_offset_struct;
5720 line_offset_struct.sect_off = line_offset;
5721 tu_group = create_type_unit_group (cu, line_offset_struct);
5723 ++tu_stats->nr_symtabs;
5729 /* Struct used to sort TUs by their abbreviation table offset. */
5731 struct tu_abbrev_offset
5733 struct signatured_type *sig_type;
5734 sect_offset abbrev_offset;
5737 /* Helper routine for build_type_unit_groups, passed to qsort. */
5740 sort_tu_by_abbrev_offset (const void *ap, const void *bp)
5742 const struct tu_abbrev_offset * const *a = ap;
5743 const struct tu_abbrev_offset * const *b = bp;
5744 unsigned int aoff = (*a)->abbrev_offset.sect_off;
5745 unsigned int boff = (*b)->abbrev_offset.sect_off;
5747 return (aoff > boff) - (aoff < boff);
5750 /* A helper function to add a type_unit_group to a table. */
5753 add_type_unit_group_to_table (void **slot, void *datum)
5755 struct type_unit_group *tu_group = *slot;
5756 struct type_unit_group ***datap = datum;
5764 /* Efficiently read all the type units, calling init_cutu_and_read_dies on
5765 each one passing FUNC,DATA.
5767 The efficiency is because we sort TUs by the abbrev table they use and
5768 only read each abbrev table once. In one program there are 200K TUs
5769 sharing 8K abbrev tables.
5771 The main purpose of this function is to support building the
5772 dwarf2_per_objfile->type_unit_groups table.
5773 TUs typically share the DW_AT_stmt_list of the CU they came from, so we
5774 can collapse the search space by grouping them by stmt_list.
5775 The savings can be significant, in the same program from above the 200K TUs
5776 share 8K stmt_list tables.
5778 FUNC is expected to call get_type_unit_group, which will create the
5779 struct type_unit_group if necessary and add it to
5780 dwarf2_per_objfile->type_unit_groups. */
5783 build_type_unit_groups (die_reader_func_ftype *func, void *data)
5785 struct objfile *objfile = dwarf2_per_objfile->objfile;
5786 struct tu_stats *tu_stats = &dwarf2_per_objfile->tu_stats;
5787 struct cleanup *cleanups;
5788 struct abbrev_table *abbrev_table;
5789 sect_offset abbrev_offset;
5790 struct tu_abbrev_offset *sorted_by_abbrev;
5791 struct type_unit_group **iter;
5794 /* It's up to the caller to not call us multiple times. */
5795 gdb_assert (dwarf2_per_objfile->type_unit_groups == NULL);
5797 if (dwarf2_per_objfile->n_type_units == 0)
5800 /* TUs typically share abbrev tables, and there can be way more TUs than
5801 abbrev tables. Sort by abbrev table to reduce the number of times we
5802 read each abbrev table in.
5803 Alternatives are to punt or to maintain a cache of abbrev tables.
5804 This is simpler and efficient enough for now.
5806 Later we group TUs by their DW_AT_stmt_list value (as this defines the
5807 symtab to use). Typically TUs with the same abbrev offset have the same
5808 stmt_list value too so in practice this should work well.
5810 The basic algorithm here is:
5812 sort TUs by abbrev table
5813 for each TU with same abbrev table:
5814 read abbrev table if first user
5815 read TU top level DIE
5816 [IWBN if DWO skeletons had DW_AT_stmt_list]
5819 if (dwarf2_read_debug)
5820 fprintf_unfiltered (gdb_stdlog, "Building type unit groups ...\n");
5822 /* Sort in a separate table to maintain the order of all_type_units
5823 for .gdb_index: TU indices directly index all_type_units. */
5824 sorted_by_abbrev = XNEWVEC (struct tu_abbrev_offset,
5825 dwarf2_per_objfile->n_type_units);
5826 for (i = 0; i < dwarf2_per_objfile->n_type_units; ++i)
5828 struct signatured_type *sig_type = dwarf2_per_objfile->all_type_units[i];
5830 sorted_by_abbrev[i].sig_type = sig_type;
5831 sorted_by_abbrev[i].abbrev_offset =
5832 read_abbrev_offset (sig_type->per_cu.section,
5833 sig_type->per_cu.offset);
5835 cleanups = make_cleanup (xfree, sorted_by_abbrev);
5836 qsort (sorted_by_abbrev, dwarf2_per_objfile->n_type_units,
5837 sizeof (struct tu_abbrev_offset), sort_tu_by_abbrev_offset);
5839 /* Note: In the .gdb_index case, get_type_unit_group may have already been
5840 called any number of times, so we don't reset tu_stats here. */
5842 abbrev_offset.sect_off = ~(unsigned) 0;
5843 abbrev_table = NULL;
5844 make_cleanup (abbrev_table_free_cleanup, &abbrev_table);
5846 for (i = 0; i < dwarf2_per_objfile->n_type_units; ++i)
5848 const struct tu_abbrev_offset *tu = &sorted_by_abbrev[i];
5850 /* Switch to the next abbrev table if necessary. */
5851 if (abbrev_table == NULL
5852 || tu->abbrev_offset.sect_off != abbrev_offset.sect_off)
5854 if (abbrev_table != NULL)
5856 abbrev_table_free (abbrev_table);
5857 /* Reset to NULL in case abbrev_table_read_table throws
5858 an error: abbrev_table_free_cleanup will get called. */
5859 abbrev_table = NULL;
5861 abbrev_offset = tu->abbrev_offset;
5863 abbrev_table_read_table (&dwarf2_per_objfile->abbrev,
5865 ++tu_stats->nr_uniq_abbrev_tables;
5868 init_cutu_and_read_dies (&tu->sig_type->per_cu, abbrev_table, 0, 0,
5872 /* type_unit_groups can be NULL if there is an error in the debug info.
5873 Just create an empty table so the rest of gdb doesn't have to watch
5874 for this error case. */
5875 if (dwarf2_per_objfile->type_unit_groups == NULL)
5877 dwarf2_per_objfile->type_unit_groups =
5878 allocate_type_unit_groups_table ();
5879 dwarf2_per_objfile->n_type_unit_groups = 0;
5882 /* Create a vector of pointers to primary type units to make it easy to
5883 iterate over them and CUs. See dw2_get_primary_cu. */
5884 dwarf2_per_objfile->n_type_unit_groups =
5885 htab_elements (dwarf2_per_objfile->type_unit_groups);
5886 dwarf2_per_objfile->all_type_unit_groups =
5887 obstack_alloc (&objfile->objfile_obstack,
5888 dwarf2_per_objfile->n_type_unit_groups
5889 * sizeof (struct type_unit_group *));
5890 iter = &dwarf2_per_objfile->all_type_unit_groups[0];
5891 htab_traverse_noresize (dwarf2_per_objfile->type_unit_groups,
5892 add_type_unit_group_to_table, &iter);
5893 gdb_assert (iter - &dwarf2_per_objfile->all_type_unit_groups[0]
5894 == dwarf2_per_objfile->n_type_unit_groups);
5896 do_cleanups (cleanups);
5898 if (dwarf2_read_debug)
5900 fprintf_unfiltered (gdb_stdlog, "Done building type unit groups:\n");
5901 fprintf_unfiltered (gdb_stdlog, " %d TUs\n",
5902 dwarf2_per_objfile->n_type_units);
5903 fprintf_unfiltered (gdb_stdlog, " %d uniq abbrev tables\n",
5904 tu_stats->nr_uniq_abbrev_tables);
5905 fprintf_unfiltered (gdb_stdlog, " %d symtabs from stmt_list entries\n",
5906 tu_stats->nr_symtabs);
5907 fprintf_unfiltered (gdb_stdlog, " %d symtab sharers\n",
5908 tu_stats->nr_symtab_sharers);
5909 fprintf_unfiltered (gdb_stdlog, " %d type units without a stmt_list\n",
5910 tu_stats->nr_stmt_less_type_units);
5914 /* Partial symbol tables. */
5916 /* Create a psymtab named NAME and assign it to PER_CU.
5918 The caller must fill in the following details:
5919 dirname, textlow, texthigh. */
5921 static struct partial_symtab *
5922 create_partial_symtab (struct dwarf2_per_cu_data *per_cu, const char *name)
5924 struct objfile *objfile = per_cu->objfile;
5925 struct partial_symtab *pst;
5927 pst = start_psymtab_common (objfile, objfile->section_offsets,
5929 objfile->global_psymbols.next,
5930 objfile->static_psymbols.next);
5932 pst->psymtabs_addrmap_supported = 1;
5934 /* This is the glue that links PST into GDB's symbol API. */
5935 pst->read_symtab_private = per_cu;
5936 pst->read_symtab = dwarf2_read_symtab;
5937 per_cu->v.psymtab = pst;
5942 /* The DATA object passed to process_psymtab_comp_unit_reader has this
5945 struct process_psymtab_comp_unit_data
5947 /* True if we are reading a DW_TAG_partial_unit. */
5949 int want_partial_unit;
5951 /* The "pretend" language that is used if the CU doesn't declare a
5954 enum language pretend_language;
5957 /* die_reader_func for process_psymtab_comp_unit. */
5960 process_psymtab_comp_unit_reader (const struct die_reader_specs *reader,
5961 const gdb_byte *info_ptr,
5962 struct die_info *comp_unit_die,
5966 struct dwarf2_cu *cu = reader->cu;
5967 struct objfile *objfile = cu->objfile;
5968 struct dwarf2_per_cu_data *per_cu = cu->per_cu;
5969 struct attribute *attr;
5971 CORE_ADDR best_lowpc = 0, best_highpc = 0;
5972 struct partial_symtab *pst;
5974 const char *filename;
5975 struct process_psymtab_comp_unit_data *info = data;
5977 if (comp_unit_die->tag == DW_TAG_partial_unit && !info->want_partial_unit)
5980 gdb_assert (! per_cu->is_debug_types);
5982 prepare_one_comp_unit (cu, comp_unit_die, info->pretend_language);
5984 cu->list_in_scope = &file_symbols;
5986 /* Allocate a new partial symbol table structure. */
5987 attr = dwarf2_attr (comp_unit_die, DW_AT_name, cu);
5988 if (attr == NULL || !DW_STRING (attr))
5991 filename = DW_STRING (attr);
5993 pst = create_partial_symtab (per_cu, filename);
5995 /* This must be done before calling dwarf2_build_include_psymtabs. */
5996 attr = dwarf2_attr (comp_unit_die, DW_AT_comp_dir, cu);
5998 pst->dirname = DW_STRING (attr);
6000 baseaddr = ANOFFSET (objfile->section_offsets, SECT_OFF_TEXT (objfile));
6002 dwarf2_find_base_address (comp_unit_die, cu);
6004 /* Possibly set the default values of LOWPC and HIGHPC from
6006 has_pc_info = dwarf2_get_pc_bounds (comp_unit_die, &best_lowpc,
6007 &best_highpc, cu, pst);
6008 if (has_pc_info == 1 && best_lowpc < best_highpc)
6009 /* Store the contiguous range if it is not empty; it can be empty for
6010 CUs with no code. */
6011 addrmap_set_empty (objfile->psymtabs_addrmap,
6012 best_lowpc + baseaddr,
6013 best_highpc + baseaddr - 1, pst);
6015 /* Check if comp unit has_children.
6016 If so, read the rest of the partial symbols from this comp unit.
6017 If not, there's no more debug_info for this comp unit. */
6020 struct partial_die_info *first_die;
6021 CORE_ADDR lowpc, highpc;
6023 lowpc = ((CORE_ADDR) -1);
6024 highpc = ((CORE_ADDR) 0);
6026 first_die = load_partial_dies (reader, info_ptr, 1);
6028 scan_partial_symbols (first_die, &lowpc, &highpc,
6031 /* If we didn't find a lowpc, set it to highpc to avoid
6032 complaints from `maint check'. */
6033 if (lowpc == ((CORE_ADDR) -1))
6036 /* If the compilation unit didn't have an explicit address range,
6037 then use the information extracted from its child dies. */
6041 best_highpc = highpc;
6044 pst->textlow = best_lowpc + baseaddr;
6045 pst->texthigh = best_highpc + baseaddr;
6047 pst->n_global_syms = objfile->global_psymbols.next -
6048 (objfile->global_psymbols.list + pst->globals_offset);
6049 pst->n_static_syms = objfile->static_psymbols.next -
6050 (objfile->static_psymbols.list + pst->statics_offset);
6051 sort_pst_symbols (objfile, pst);
6053 if (!VEC_empty (dwarf2_per_cu_ptr, cu->per_cu->imported_symtabs))
6056 int len = VEC_length (dwarf2_per_cu_ptr, cu->per_cu->imported_symtabs);
6057 struct dwarf2_per_cu_data *iter;
6059 /* Fill in 'dependencies' here; we fill in 'users' in a
6061 pst->number_of_dependencies = len;
6062 pst->dependencies = obstack_alloc (&objfile->objfile_obstack,
6063 len * sizeof (struct symtab *));
6065 VEC_iterate (dwarf2_per_cu_ptr, cu->per_cu->imported_symtabs,
6068 pst->dependencies[i] = iter->v.psymtab;
6070 VEC_free (dwarf2_per_cu_ptr, cu->per_cu->imported_symtabs);
6073 /* Get the list of files included in the current compilation unit,
6074 and build a psymtab for each of them. */
6075 dwarf2_build_include_psymtabs (cu, comp_unit_die, pst);
6077 if (dwarf2_read_debug)
6079 struct gdbarch *gdbarch = get_objfile_arch (objfile);
6081 fprintf_unfiltered (gdb_stdlog,
6082 "Psymtab for %s unit @0x%x: %s - %s"
6083 ", %d global, %d static syms\n",
6084 per_cu->is_debug_types ? "type" : "comp",
6085 per_cu->offset.sect_off,
6086 paddress (gdbarch, pst->textlow),
6087 paddress (gdbarch, pst->texthigh),
6088 pst->n_global_syms, pst->n_static_syms);
6092 /* Subroutine of dwarf2_build_psymtabs_hard to simplify it.
6093 Process compilation unit THIS_CU for a psymtab. */
6096 process_psymtab_comp_unit (struct dwarf2_per_cu_data *this_cu,
6097 int want_partial_unit,
6098 enum language pretend_language)
6100 struct process_psymtab_comp_unit_data info;
6102 /* If this compilation unit was already read in, free the
6103 cached copy in order to read it in again. This is
6104 necessary because we skipped some symbols when we first
6105 read in the compilation unit (see load_partial_dies).
6106 This problem could be avoided, but the benefit is unclear. */
6107 if (this_cu->cu != NULL)
6108 free_one_cached_comp_unit (this_cu);
6110 gdb_assert (! this_cu->is_debug_types);
6111 info.want_partial_unit = want_partial_unit;
6112 info.pretend_language = pretend_language;
6113 init_cutu_and_read_dies (this_cu, NULL, 0, 0,
6114 process_psymtab_comp_unit_reader,
6117 /* Age out any secondary CUs. */
6118 age_cached_comp_units ();
6121 /* Reader function for build_type_psymtabs. */
6124 build_type_psymtabs_reader (const struct die_reader_specs *reader,
6125 const gdb_byte *info_ptr,
6126 struct die_info *type_unit_die,
6130 struct objfile *objfile = dwarf2_per_objfile->objfile;
6131 struct dwarf2_cu *cu = reader->cu;
6132 struct dwarf2_per_cu_data *per_cu = cu->per_cu;
6133 struct signatured_type *sig_type;
6134 struct type_unit_group *tu_group;
6135 struct attribute *attr;
6136 struct partial_die_info *first_die;
6137 CORE_ADDR lowpc, highpc;
6138 struct partial_symtab *pst;
6140 gdb_assert (data == NULL);
6141 gdb_assert (per_cu->is_debug_types);
6142 sig_type = (struct signatured_type *) per_cu;
6147 attr = dwarf2_attr_no_follow (type_unit_die, DW_AT_stmt_list);
6148 tu_group = get_type_unit_group (cu, attr);
6150 VEC_safe_push (sig_type_ptr, tu_group->tus, sig_type);
6152 prepare_one_comp_unit (cu, type_unit_die, language_minimal);
6153 cu->list_in_scope = &file_symbols;
6154 pst = create_partial_symtab (per_cu, "");
6157 first_die = load_partial_dies (reader, info_ptr, 1);
6159 lowpc = (CORE_ADDR) -1;
6160 highpc = (CORE_ADDR) 0;
6161 scan_partial_symbols (first_die, &lowpc, &highpc, 0, cu);
6163 pst->n_global_syms = objfile->global_psymbols.next -
6164 (objfile->global_psymbols.list + pst->globals_offset);
6165 pst->n_static_syms = objfile->static_psymbols.next -
6166 (objfile->static_psymbols.list + pst->statics_offset);
6167 sort_pst_symbols (objfile, pst);
6170 /* Traversal function for build_type_psymtabs. */
6173 build_type_psymtab_dependencies (void **slot, void *info)
6175 struct objfile *objfile = dwarf2_per_objfile->objfile;
6176 struct type_unit_group *tu_group = (struct type_unit_group *) *slot;
6177 struct dwarf2_per_cu_data *per_cu = &tu_group->per_cu;
6178 struct partial_symtab *pst = per_cu->v.psymtab;
6179 int len = VEC_length (sig_type_ptr, tu_group->tus);
6180 struct signatured_type *iter;
6183 gdb_assert (len > 0);
6184 gdb_assert (IS_TYPE_UNIT_GROUP (per_cu));
6186 pst->number_of_dependencies = len;
6187 pst->dependencies = obstack_alloc (&objfile->objfile_obstack,
6188 len * sizeof (struct psymtab *));
6190 VEC_iterate (sig_type_ptr, tu_group->tus, i, iter);
6193 gdb_assert (iter->per_cu.is_debug_types);
6194 pst->dependencies[i] = iter->per_cu.v.psymtab;
6195 iter->type_unit_group = tu_group;
6198 VEC_free (sig_type_ptr, tu_group->tus);
6203 /* Subroutine of dwarf2_build_psymtabs_hard to simplify it.
6204 Build partial symbol tables for the .debug_types comp-units. */
6207 build_type_psymtabs (struct objfile *objfile)
6209 if (! create_all_type_units (objfile))
6212 build_type_unit_groups (build_type_psymtabs_reader, NULL);
6214 /* Now that all TUs have been processed we can fill in the dependencies. */
6215 htab_traverse_noresize (dwarf2_per_objfile->type_unit_groups,
6216 build_type_psymtab_dependencies, NULL);
6219 /* A cleanup function that clears objfile's psymtabs_addrmap field. */
6222 psymtabs_addrmap_cleanup (void *o)
6224 struct objfile *objfile = o;
6226 objfile->psymtabs_addrmap = NULL;
6229 /* Compute the 'user' field for each psymtab in OBJFILE. */
6232 set_partial_user (struct objfile *objfile)
6236 for (i = 0; i < dwarf2_per_objfile->n_comp_units; ++i)
6238 struct dwarf2_per_cu_data *per_cu = dw2_get_cu (i);
6239 struct partial_symtab *pst = per_cu->v.psymtab;
6245 for (j = 0; j < pst->number_of_dependencies; ++j)
6247 /* Set the 'user' field only if it is not already set. */
6248 if (pst->dependencies[j]->user == NULL)
6249 pst->dependencies[j]->user = pst;
6254 /* Build the partial symbol table by doing a quick pass through the
6255 .debug_info and .debug_abbrev sections. */
6258 dwarf2_build_psymtabs_hard (struct objfile *objfile)
6260 struct cleanup *back_to, *addrmap_cleanup;
6261 struct obstack temp_obstack;
6264 if (dwarf2_read_debug)
6266 fprintf_unfiltered (gdb_stdlog, "Building psymtabs of objfile %s ...\n",
6267 objfile_name (objfile));
6270 dwarf2_per_objfile->reading_partial_symbols = 1;
6272 dwarf2_read_section (objfile, &dwarf2_per_objfile->info);
6274 /* Any cached compilation units will be linked by the per-objfile
6275 read_in_chain. Make sure to free them when we're done. */
6276 back_to = make_cleanup (free_cached_comp_units, NULL);
6278 build_type_psymtabs (objfile);
6280 create_all_comp_units (objfile);
6282 /* Create a temporary address map on a temporary obstack. We later
6283 copy this to the final obstack. */
6284 obstack_init (&temp_obstack);
6285 make_cleanup_obstack_free (&temp_obstack);
6286 objfile->psymtabs_addrmap = addrmap_create_mutable (&temp_obstack);
6287 addrmap_cleanup = make_cleanup (psymtabs_addrmap_cleanup, objfile);
6289 for (i = 0; i < dwarf2_per_objfile->n_comp_units; ++i)
6291 struct dwarf2_per_cu_data *per_cu = dw2_get_cu (i);
6293 process_psymtab_comp_unit (per_cu, 0, language_minimal);
6296 set_partial_user (objfile);
6298 objfile->psymtabs_addrmap = addrmap_create_fixed (objfile->psymtabs_addrmap,
6299 &objfile->objfile_obstack);
6300 discard_cleanups (addrmap_cleanup);
6302 do_cleanups (back_to);
6304 if (dwarf2_read_debug)
6305 fprintf_unfiltered (gdb_stdlog, "Done building psymtabs of %s\n",
6306 objfile_name (objfile));
6309 /* die_reader_func for load_partial_comp_unit. */
6312 load_partial_comp_unit_reader (const struct die_reader_specs *reader,
6313 const gdb_byte *info_ptr,
6314 struct die_info *comp_unit_die,
6318 struct dwarf2_cu *cu = reader->cu;
6320 prepare_one_comp_unit (cu, comp_unit_die, language_minimal);
6322 /* Check if comp unit has_children.
6323 If so, read the rest of the partial symbols from this comp unit.
6324 If not, there's no more debug_info for this comp unit. */
6326 load_partial_dies (reader, info_ptr, 0);
6329 /* Load the partial DIEs for a secondary CU into memory.
6330 This is also used when rereading a primary CU with load_all_dies. */
6333 load_partial_comp_unit (struct dwarf2_per_cu_data *this_cu)
6335 init_cutu_and_read_dies (this_cu, NULL, 1, 1,
6336 load_partial_comp_unit_reader, NULL);
6340 read_comp_units_from_section (struct objfile *objfile,
6341 struct dwarf2_section_info *section,
6342 unsigned int is_dwz,
6345 struct dwarf2_per_cu_data ***all_comp_units)
6347 const gdb_byte *info_ptr;
6348 bfd *abfd = get_section_bfd_owner (section);
6350 if (dwarf2_read_debug)
6351 fprintf_unfiltered (gdb_stdlog, "Reading %s for %s\n",
6352 get_section_name (section),
6353 get_section_file_name (section));
6355 dwarf2_read_section (objfile, section);
6357 info_ptr = section->buffer;
6359 while (info_ptr < section->buffer + section->size)
6361 unsigned int length, initial_length_size;
6362 struct dwarf2_per_cu_data *this_cu;
6365 offset.sect_off = info_ptr - section->buffer;
6367 /* Read just enough information to find out where the next
6368 compilation unit is. */
6369 length = read_initial_length (abfd, info_ptr, &initial_length_size);
6371 /* Save the compilation unit for later lookup. */
6372 this_cu = obstack_alloc (&objfile->objfile_obstack,
6373 sizeof (struct dwarf2_per_cu_data));
6374 memset (this_cu, 0, sizeof (*this_cu));
6375 this_cu->offset = offset;
6376 this_cu->length = length + initial_length_size;
6377 this_cu->is_dwz = is_dwz;
6378 this_cu->objfile = objfile;
6379 this_cu->section = section;
6381 if (*n_comp_units == *n_allocated)
6384 *all_comp_units = xrealloc (*all_comp_units,
6386 * sizeof (struct dwarf2_per_cu_data *));
6388 (*all_comp_units)[*n_comp_units] = this_cu;
6391 info_ptr = info_ptr + this_cu->length;
6395 /* Create a list of all compilation units in OBJFILE.
6396 This is only done for -readnow and building partial symtabs. */
6399 create_all_comp_units (struct objfile *objfile)
6403 struct dwarf2_per_cu_data **all_comp_units;
6404 struct dwz_file *dwz;
6408 all_comp_units = xmalloc (n_allocated
6409 * sizeof (struct dwarf2_per_cu_data *));
6411 read_comp_units_from_section (objfile, &dwarf2_per_objfile->info, 0,
6412 &n_allocated, &n_comp_units, &all_comp_units);
6414 dwz = dwarf2_get_dwz_file ();
6416 read_comp_units_from_section (objfile, &dwz->info, 1,
6417 &n_allocated, &n_comp_units,
6420 dwarf2_per_objfile->all_comp_units
6421 = obstack_alloc (&objfile->objfile_obstack,
6422 n_comp_units * sizeof (struct dwarf2_per_cu_data *));
6423 memcpy (dwarf2_per_objfile->all_comp_units, all_comp_units,
6424 n_comp_units * sizeof (struct dwarf2_per_cu_data *));
6425 xfree (all_comp_units);
6426 dwarf2_per_objfile->n_comp_units = n_comp_units;
6429 /* Process all loaded DIEs for compilation unit CU, starting at
6430 FIRST_DIE. The caller should pass NEED_PC == 1 if the compilation
6431 unit DIE did not have PC info (DW_AT_low_pc and DW_AT_high_pc, or
6432 DW_AT_ranges). If NEED_PC is set, then this function will set
6433 *LOWPC and *HIGHPC to the lowest and highest PC values found in CU
6434 and record the covered ranges in the addrmap. */
6437 scan_partial_symbols (struct partial_die_info *first_die, CORE_ADDR *lowpc,
6438 CORE_ADDR *highpc, int need_pc, struct dwarf2_cu *cu)
6440 struct partial_die_info *pdi;
6442 /* Now, march along the PDI's, descending into ones which have
6443 interesting children but skipping the children of the other ones,
6444 until we reach the end of the compilation unit. */
6450 fixup_partial_die (pdi, cu);
6452 /* Anonymous namespaces or modules have no name but have interesting
6453 children, so we need to look at them. Ditto for anonymous
6456 if (pdi->name != NULL || pdi->tag == DW_TAG_namespace
6457 || pdi->tag == DW_TAG_module || pdi->tag == DW_TAG_enumeration_type
6458 || pdi->tag == DW_TAG_imported_unit)
6462 case DW_TAG_subprogram:
6463 add_partial_subprogram (pdi, lowpc, highpc, need_pc, cu);
6465 case DW_TAG_constant:
6466 case DW_TAG_variable:
6467 case DW_TAG_typedef:
6468 case DW_TAG_union_type:
6469 if (!pdi->is_declaration)
6471 add_partial_symbol (pdi, cu);
6474 case DW_TAG_class_type:
6475 case DW_TAG_interface_type:
6476 case DW_TAG_structure_type:
6477 if (!pdi->is_declaration)
6479 add_partial_symbol (pdi, cu);
6482 case DW_TAG_enumeration_type:
6483 if (!pdi->is_declaration)
6484 add_partial_enumeration (pdi, cu);
6486 case DW_TAG_base_type:
6487 case DW_TAG_subrange_type:
6488 /* File scope base type definitions are added to the partial
6490 add_partial_symbol (pdi, cu);
6492 case DW_TAG_namespace:
6493 add_partial_namespace (pdi, lowpc, highpc, need_pc, cu);
6496 add_partial_module (pdi, lowpc, highpc, need_pc, cu);
6498 case DW_TAG_imported_unit:
6500 struct dwarf2_per_cu_data *per_cu;
6502 /* For now we don't handle imported units in type units. */
6503 if (cu->per_cu->is_debug_types)
6505 error (_("Dwarf Error: DW_TAG_imported_unit is not"
6506 " supported in type units [in module %s]"),
6507 objfile_name (cu->objfile));
6510 per_cu = dwarf2_find_containing_comp_unit (pdi->d.offset,
6514 /* Go read the partial unit, if needed. */
6515 if (per_cu->v.psymtab == NULL)
6516 process_psymtab_comp_unit (per_cu, 1, cu->language);
6518 VEC_safe_push (dwarf2_per_cu_ptr,
6519 cu->per_cu->imported_symtabs, per_cu);
6522 case DW_TAG_imported_declaration:
6523 add_partial_symbol (pdi, cu);
6530 /* If the die has a sibling, skip to the sibling. */
6532 pdi = pdi->die_sibling;
6536 /* Functions used to compute the fully scoped name of a partial DIE.
6538 Normally, this is simple. For C++, the parent DIE's fully scoped
6539 name is concatenated with "::" and the partial DIE's name. For
6540 Java, the same thing occurs except that "." is used instead of "::".
6541 Enumerators are an exception; they use the scope of their parent
6542 enumeration type, i.e. the name of the enumeration type is not
6543 prepended to the enumerator.
6545 There are two complexities. One is DW_AT_specification; in this
6546 case "parent" means the parent of the target of the specification,
6547 instead of the direct parent of the DIE. The other is compilers
6548 which do not emit DW_TAG_namespace; in this case we try to guess
6549 the fully qualified name of structure types from their members'
6550 linkage names. This must be done using the DIE's children rather
6551 than the children of any DW_AT_specification target. We only need
6552 to do this for structures at the top level, i.e. if the target of
6553 any DW_AT_specification (if any; otherwise the DIE itself) does not
6556 /* Compute the scope prefix associated with PDI's parent, in
6557 compilation unit CU. The result will be allocated on CU's
6558 comp_unit_obstack, or a copy of the already allocated PDI->NAME
6559 field. NULL is returned if no prefix is necessary. */
6561 partial_die_parent_scope (struct partial_die_info *pdi,
6562 struct dwarf2_cu *cu)
6564 const char *grandparent_scope;
6565 struct partial_die_info *parent, *real_pdi;
6567 /* We need to look at our parent DIE; if we have a DW_AT_specification,
6568 then this means the parent of the specification DIE. */
6571 while (real_pdi->has_specification)
6572 real_pdi = find_partial_die (real_pdi->spec_offset,
6573 real_pdi->spec_is_dwz, cu);
6575 parent = real_pdi->die_parent;
6579 if (parent->scope_set)
6580 return parent->scope;
6582 fixup_partial_die (parent, cu);
6584 grandparent_scope = partial_die_parent_scope (parent, cu);
6586 /* GCC 4.0 and 4.1 had a bug (PR c++/28460) where they generated bogus
6587 DW_TAG_namespace DIEs with a name of "::" for the global namespace.
6588 Work around this problem here. */
6589 if (cu->language == language_cplus
6590 && parent->tag == DW_TAG_namespace
6591 && strcmp (parent->name, "::") == 0
6592 && grandparent_scope == NULL)
6594 parent->scope = NULL;
6595 parent->scope_set = 1;
6599 if (pdi->tag == DW_TAG_enumerator)
6600 /* Enumerators should not get the name of the enumeration as a prefix. */
6601 parent->scope = grandparent_scope;
6602 else if (parent->tag == DW_TAG_namespace
6603 || parent->tag == DW_TAG_module
6604 || parent->tag == DW_TAG_structure_type
6605 || parent->tag == DW_TAG_class_type
6606 || parent->tag == DW_TAG_interface_type
6607 || parent->tag == DW_TAG_union_type
6608 || parent->tag == DW_TAG_enumeration_type)
6610 if (grandparent_scope == NULL)
6611 parent->scope = parent->name;
6613 parent->scope = typename_concat (&cu->comp_unit_obstack,
6615 parent->name, 0, cu);
6619 /* FIXME drow/2004-04-01: What should we be doing with
6620 function-local names? For partial symbols, we should probably be
6622 complaint (&symfile_complaints,
6623 _("unhandled containing DIE tag %d for DIE at %d"),
6624 parent->tag, pdi->offset.sect_off);
6625 parent->scope = grandparent_scope;
6628 parent->scope_set = 1;
6629 return parent->scope;
6632 /* Return the fully scoped name associated with PDI, from compilation unit
6633 CU. The result will be allocated with malloc. */
6636 partial_die_full_name (struct partial_die_info *pdi,
6637 struct dwarf2_cu *cu)
6639 const char *parent_scope;
6641 /* If this is a template instantiation, we can not work out the
6642 template arguments from partial DIEs. So, unfortunately, we have
6643 to go through the full DIEs. At least any work we do building
6644 types here will be reused if full symbols are loaded later. */
6645 if (pdi->has_template_arguments)
6647 fixup_partial_die (pdi, cu);
6649 if (pdi->name != NULL && strchr (pdi->name, '<') == NULL)
6651 struct die_info *die;
6652 struct attribute attr;
6653 struct dwarf2_cu *ref_cu = cu;
6655 /* DW_FORM_ref_addr is using section offset. */
6657 attr.form = DW_FORM_ref_addr;
6658 attr.u.unsnd = pdi->offset.sect_off;
6659 die = follow_die_ref (NULL, &attr, &ref_cu);
6661 return xstrdup (dwarf2_full_name (NULL, die, ref_cu));
6665 parent_scope = partial_die_parent_scope (pdi, cu);
6666 if (parent_scope == NULL)
6669 return typename_concat (NULL, parent_scope, pdi->name, 0, cu);
6673 add_partial_symbol (struct partial_die_info *pdi, struct dwarf2_cu *cu)
6675 struct objfile *objfile = cu->objfile;
6677 const char *actual_name = NULL;
6679 char *built_actual_name;
6681 baseaddr = ANOFFSET (objfile->section_offsets, SECT_OFF_TEXT (objfile));
6683 built_actual_name = partial_die_full_name (pdi, cu);
6684 if (built_actual_name != NULL)
6685 actual_name = built_actual_name;
6687 if (actual_name == NULL)
6688 actual_name = pdi->name;
6692 case DW_TAG_subprogram:
6693 if (pdi->is_external || cu->language == language_ada)
6695 /* brobecker/2007-12-26: Normally, only "external" DIEs are part
6696 of the global scope. But in Ada, we want to be able to access
6697 nested procedures globally. So all Ada subprograms are stored
6698 in the global scope. */
6699 /* prim_record_minimal_symbol (actual_name, pdi->lowpc + baseaddr,
6700 mst_text, objfile); */
6701 add_psymbol_to_list (actual_name, strlen (actual_name),
6702 built_actual_name != NULL,
6703 VAR_DOMAIN, LOC_BLOCK,
6704 &objfile->global_psymbols,
6705 0, pdi->lowpc + baseaddr,
6706 cu->language, objfile);
6710 /* prim_record_minimal_symbol (actual_name, pdi->lowpc + baseaddr,
6711 mst_file_text, objfile); */
6712 add_psymbol_to_list (actual_name, strlen (actual_name),
6713 built_actual_name != NULL,
6714 VAR_DOMAIN, LOC_BLOCK,
6715 &objfile->static_psymbols,
6716 0, pdi->lowpc + baseaddr,
6717 cu->language, objfile);
6720 case DW_TAG_constant:
6722 struct psymbol_allocation_list *list;
6724 if (pdi->is_external)
6725 list = &objfile->global_psymbols;
6727 list = &objfile->static_psymbols;
6728 add_psymbol_to_list (actual_name, strlen (actual_name),
6729 built_actual_name != NULL, VAR_DOMAIN, LOC_STATIC,
6730 list, 0, 0, cu->language, objfile);
6733 case DW_TAG_variable:
6735 addr = decode_locdesc (pdi->d.locdesc, cu);
6739 && !dwarf2_per_objfile->has_section_at_zero)
6741 /* A global or static variable may also have been stripped
6742 out by the linker if unused, in which case its address
6743 will be nullified; do not add such variables into partial
6744 symbol table then. */
6746 else if (pdi->is_external)
6749 Don't enter into the minimal symbol tables as there is
6750 a minimal symbol table entry from the ELF symbols already.
6751 Enter into partial symbol table if it has a location
6752 descriptor or a type.
6753 If the location descriptor is missing, new_symbol will create
6754 a LOC_UNRESOLVED symbol, the address of the variable will then
6755 be determined from the minimal symbol table whenever the variable
6757 The address for the partial symbol table entry is not
6758 used by GDB, but it comes in handy for debugging partial symbol
6761 if (pdi->d.locdesc || pdi->has_type)
6762 add_psymbol_to_list (actual_name, strlen (actual_name),
6763 built_actual_name != NULL,
6764 VAR_DOMAIN, LOC_STATIC,
6765 &objfile->global_psymbols,
6767 cu->language, objfile);
6771 /* Static Variable. Skip symbols without location descriptors. */
6772 if (pdi->d.locdesc == NULL)
6774 xfree (built_actual_name);
6777 /* prim_record_minimal_symbol (actual_name, addr + baseaddr,
6778 mst_file_data, objfile); */
6779 add_psymbol_to_list (actual_name, strlen (actual_name),
6780 built_actual_name != NULL,
6781 VAR_DOMAIN, LOC_STATIC,
6782 &objfile->static_psymbols,
6784 cu->language, objfile);
6787 case DW_TAG_typedef:
6788 case DW_TAG_base_type:
6789 case DW_TAG_subrange_type:
6790 add_psymbol_to_list (actual_name, strlen (actual_name),
6791 built_actual_name != NULL,
6792 VAR_DOMAIN, LOC_TYPEDEF,
6793 &objfile->static_psymbols,
6794 0, (CORE_ADDR) 0, cu->language, objfile);
6796 case DW_TAG_imported_declaration:
6797 case DW_TAG_namespace:
6798 add_psymbol_to_list (actual_name, strlen (actual_name),
6799 built_actual_name != NULL,
6800 VAR_DOMAIN, LOC_TYPEDEF,
6801 &objfile->global_psymbols,
6802 0, (CORE_ADDR) 0, cu->language, objfile);
6805 add_psymbol_to_list (actual_name, strlen (actual_name),
6806 built_actual_name != NULL,
6807 MODULE_DOMAIN, LOC_TYPEDEF,
6808 &objfile->global_psymbols,
6809 0, (CORE_ADDR) 0, cu->language, objfile);
6811 case DW_TAG_class_type:
6812 case DW_TAG_interface_type:
6813 case DW_TAG_structure_type:
6814 case DW_TAG_union_type:
6815 case DW_TAG_enumeration_type:
6816 /* Skip external references. The DWARF standard says in the section
6817 about "Structure, Union, and Class Type Entries": "An incomplete
6818 structure, union or class type is represented by a structure,
6819 union or class entry that does not have a byte size attribute
6820 and that has a DW_AT_declaration attribute." */
6821 if (!pdi->has_byte_size && pdi->is_declaration)
6823 xfree (built_actual_name);
6827 /* NOTE: carlton/2003-10-07: See comment in new_symbol about
6828 static vs. global. */
6829 add_psymbol_to_list (actual_name, strlen (actual_name),
6830 built_actual_name != NULL,
6831 STRUCT_DOMAIN, LOC_TYPEDEF,
6832 (cu->language == language_cplus
6833 || cu->language == language_java)
6834 ? &objfile->global_psymbols
6835 : &objfile->static_psymbols,
6836 0, (CORE_ADDR) 0, cu->language, objfile);
6839 case DW_TAG_enumerator:
6840 add_psymbol_to_list (actual_name, strlen (actual_name),
6841 built_actual_name != NULL,
6842 VAR_DOMAIN, LOC_CONST,
6843 (cu->language == language_cplus
6844 || cu->language == language_java)
6845 ? &objfile->global_psymbols
6846 : &objfile->static_psymbols,
6847 0, (CORE_ADDR) 0, cu->language, objfile);
6853 xfree (built_actual_name);
6856 /* Read a partial die corresponding to a namespace; also, add a symbol
6857 corresponding to that namespace to the symbol table. NAMESPACE is
6858 the name of the enclosing namespace. */
6861 add_partial_namespace (struct partial_die_info *pdi,
6862 CORE_ADDR *lowpc, CORE_ADDR *highpc,
6863 int need_pc, struct dwarf2_cu *cu)
6865 /* Add a symbol for the namespace. */
6867 add_partial_symbol (pdi, cu);
6869 /* Now scan partial symbols in that namespace. */
6871 if (pdi->has_children)
6872 scan_partial_symbols (pdi->die_child, lowpc, highpc, need_pc, cu);
6875 /* Read a partial die corresponding to a Fortran module. */
6878 add_partial_module (struct partial_die_info *pdi, CORE_ADDR *lowpc,
6879 CORE_ADDR *highpc, int need_pc, struct dwarf2_cu *cu)
6881 /* Add a symbol for the namespace. */
6883 add_partial_symbol (pdi, cu);
6885 /* Now scan partial symbols in that module. */
6887 if (pdi->has_children)
6888 scan_partial_symbols (pdi->die_child, lowpc, highpc, need_pc, cu);
6891 /* Read a partial die corresponding to a subprogram and create a partial
6892 symbol for that subprogram. When the CU language allows it, this
6893 routine also defines a partial symbol for each nested subprogram
6894 that this subprogram contains.
6896 DIE my also be a lexical block, in which case we simply search
6897 recursively for suprograms defined inside that lexical block.
6898 Again, this is only performed when the CU language allows this
6899 type of definitions. */
6902 add_partial_subprogram (struct partial_die_info *pdi,
6903 CORE_ADDR *lowpc, CORE_ADDR *highpc,
6904 int need_pc, struct dwarf2_cu *cu)
6906 if (pdi->tag == DW_TAG_subprogram)
6908 if (pdi->has_pc_info)
6910 if (pdi->lowpc < *lowpc)
6911 *lowpc = pdi->lowpc;
6912 if (pdi->highpc > *highpc)
6913 *highpc = pdi->highpc;
6917 struct objfile *objfile = cu->objfile;
6919 baseaddr = ANOFFSET (objfile->section_offsets,
6920 SECT_OFF_TEXT (objfile));
6921 addrmap_set_empty (objfile->psymtabs_addrmap,
6922 pdi->lowpc + baseaddr,
6923 pdi->highpc - 1 + baseaddr,
6924 cu->per_cu->v.psymtab);
6928 if (pdi->has_pc_info || (!pdi->is_external && pdi->may_be_inlined))
6930 if (!pdi->is_declaration)
6931 /* Ignore subprogram DIEs that do not have a name, they are
6932 illegal. Do not emit a complaint at this point, we will
6933 do so when we convert this psymtab into a symtab. */
6935 add_partial_symbol (pdi, cu);
6939 if (! pdi->has_children)
6942 if (cu->language == language_ada)
6944 pdi = pdi->die_child;
6947 fixup_partial_die (pdi, cu);
6948 if (pdi->tag == DW_TAG_subprogram
6949 || pdi->tag == DW_TAG_lexical_block)
6950 add_partial_subprogram (pdi, lowpc, highpc, need_pc, cu);
6951 pdi = pdi->die_sibling;
6956 /* Read a partial die corresponding to an enumeration type. */
6959 add_partial_enumeration (struct partial_die_info *enum_pdi,
6960 struct dwarf2_cu *cu)
6962 struct partial_die_info *pdi;
6964 if (enum_pdi->name != NULL)
6965 add_partial_symbol (enum_pdi, cu);
6967 pdi = enum_pdi->die_child;
6970 if (pdi->tag != DW_TAG_enumerator || pdi->name == NULL)
6971 complaint (&symfile_complaints, _("malformed enumerator DIE ignored"));
6973 add_partial_symbol (pdi, cu);
6974 pdi = pdi->die_sibling;
6978 /* Return the initial uleb128 in the die at INFO_PTR. */
6981 peek_abbrev_code (bfd *abfd, const gdb_byte *info_ptr)
6983 unsigned int bytes_read;
6985 return read_unsigned_leb128 (abfd, info_ptr, &bytes_read);
6988 /* Read the initial uleb128 in the die at INFO_PTR in compilation unit CU.
6989 Return the corresponding abbrev, or NULL if the number is zero (indicating
6990 an empty DIE). In either case *BYTES_READ will be set to the length of
6991 the initial number. */
6993 static struct abbrev_info *
6994 peek_die_abbrev (const gdb_byte *info_ptr, unsigned int *bytes_read,
6995 struct dwarf2_cu *cu)
6997 bfd *abfd = cu->objfile->obfd;
6998 unsigned int abbrev_number;
6999 struct abbrev_info *abbrev;
7001 abbrev_number = read_unsigned_leb128 (abfd, info_ptr, bytes_read);
7003 if (abbrev_number == 0)
7006 abbrev = abbrev_table_lookup_abbrev (cu->abbrev_table, abbrev_number);
7009 error (_("Dwarf Error: Could not find abbrev number %d [in module %s]"),
7010 abbrev_number, bfd_get_filename (abfd));
7016 /* Scan the debug information for CU starting at INFO_PTR in buffer BUFFER.
7017 Returns a pointer to the end of a series of DIEs, terminated by an empty
7018 DIE. Any children of the skipped DIEs will also be skipped. */
7020 static const gdb_byte *
7021 skip_children (const struct die_reader_specs *reader, const gdb_byte *info_ptr)
7023 struct dwarf2_cu *cu = reader->cu;
7024 struct abbrev_info *abbrev;
7025 unsigned int bytes_read;
7029 abbrev = peek_die_abbrev (info_ptr, &bytes_read, cu);
7031 return info_ptr + bytes_read;
7033 info_ptr = skip_one_die (reader, info_ptr + bytes_read, abbrev);
7037 /* Scan the debug information for CU starting at INFO_PTR in buffer BUFFER.
7038 INFO_PTR should point just after the initial uleb128 of a DIE, and the
7039 abbrev corresponding to that skipped uleb128 should be passed in
7040 ABBREV. Returns a pointer to this DIE's sibling, skipping any
7043 static const gdb_byte *
7044 skip_one_die (const struct die_reader_specs *reader, const gdb_byte *info_ptr,
7045 struct abbrev_info *abbrev)
7047 unsigned int bytes_read;
7048 struct attribute attr;
7049 bfd *abfd = reader->abfd;
7050 struct dwarf2_cu *cu = reader->cu;
7051 const gdb_byte *buffer = reader->buffer;
7052 const gdb_byte *buffer_end = reader->buffer_end;
7053 const gdb_byte *start_info_ptr = info_ptr;
7054 unsigned int form, i;
7056 for (i = 0; i < abbrev->num_attrs; i++)
7058 /* The only abbrev we care about is DW_AT_sibling. */
7059 if (abbrev->attrs[i].name == DW_AT_sibling)
7061 read_attribute (reader, &attr, &abbrev->attrs[i], info_ptr);
7062 if (attr.form == DW_FORM_ref_addr)
7063 complaint (&symfile_complaints,
7064 _("ignoring absolute DW_AT_sibling"));
7067 unsigned int off = dwarf2_get_ref_die_offset (&attr).sect_off;
7068 const gdb_byte *sibling_ptr = buffer + off;
7070 if (sibling_ptr < info_ptr)
7071 complaint (&symfile_complaints,
7072 _("DW_AT_sibling points backwards"));
7078 /* If it isn't DW_AT_sibling, skip this attribute. */
7079 form = abbrev->attrs[i].form;
7083 case DW_FORM_ref_addr:
7084 /* In DWARF 2, DW_FORM_ref_addr is address sized; in DWARF 3
7085 and later it is offset sized. */
7086 if (cu->header.version == 2)
7087 info_ptr += cu->header.addr_size;
7089 info_ptr += cu->header.offset_size;
7091 case DW_FORM_GNU_ref_alt:
7092 info_ptr += cu->header.offset_size;
7095 info_ptr += cu->header.addr_size;
7102 case DW_FORM_flag_present:
7114 case DW_FORM_ref_sig8:
7117 case DW_FORM_string:
7118 read_direct_string (abfd, info_ptr, &bytes_read);
7119 info_ptr += bytes_read;
7121 case DW_FORM_sec_offset:
7123 case DW_FORM_GNU_strp_alt:
7124 info_ptr += cu->header.offset_size;
7126 case DW_FORM_exprloc:
7128 info_ptr += read_unsigned_leb128 (abfd, info_ptr, &bytes_read);
7129 info_ptr += bytes_read;
7131 case DW_FORM_block1:
7132 info_ptr += 1 + read_1_byte (abfd, info_ptr);
7134 case DW_FORM_block2:
7135 info_ptr += 2 + read_2_bytes (abfd, info_ptr);
7137 case DW_FORM_block4:
7138 info_ptr += 4 + read_4_bytes (abfd, info_ptr);
7142 case DW_FORM_ref_udata:
7143 case DW_FORM_GNU_addr_index:
7144 case DW_FORM_GNU_str_index:
7145 info_ptr = safe_skip_leb128 (info_ptr, buffer_end);
7147 case DW_FORM_indirect:
7148 form = read_unsigned_leb128 (abfd, info_ptr, &bytes_read);
7149 info_ptr += bytes_read;
7150 /* We need to continue parsing from here, so just go back to
7152 goto skip_attribute;
7155 error (_("Dwarf Error: Cannot handle %s "
7156 "in DWARF reader [in module %s]"),
7157 dwarf_form_name (form),
7158 bfd_get_filename (abfd));
7162 if (abbrev->has_children)
7163 return skip_children (reader, info_ptr);
7168 /* Locate ORIG_PDI's sibling.
7169 INFO_PTR should point to the start of the next DIE after ORIG_PDI. */
7171 static const gdb_byte *
7172 locate_pdi_sibling (const struct die_reader_specs *reader,
7173 struct partial_die_info *orig_pdi,
7174 const gdb_byte *info_ptr)
7176 /* Do we know the sibling already? */
7178 if (orig_pdi->sibling)
7179 return orig_pdi->sibling;
7181 /* Are there any children to deal with? */
7183 if (!orig_pdi->has_children)
7186 /* Skip the children the long way. */
7188 return skip_children (reader, info_ptr);
7191 /* Expand this partial symbol table into a full symbol table. SELF is
7195 dwarf2_read_symtab (struct partial_symtab *self,
7196 struct objfile *objfile)
7200 warning (_("bug: psymtab for %s is already read in."),
7207 printf_filtered (_("Reading in symbols for %s..."),
7209 gdb_flush (gdb_stdout);
7212 /* Restore our global data. */
7213 dwarf2_per_objfile = objfile_data (objfile, dwarf2_objfile_data_key);
7215 /* If this psymtab is constructed from a debug-only objfile, the
7216 has_section_at_zero flag will not necessarily be correct. We
7217 can get the correct value for this flag by looking at the data
7218 associated with the (presumably stripped) associated objfile. */
7219 if (objfile->separate_debug_objfile_backlink)
7221 struct dwarf2_per_objfile *dpo_backlink
7222 = objfile_data (objfile->separate_debug_objfile_backlink,
7223 dwarf2_objfile_data_key);
7225 dwarf2_per_objfile->has_section_at_zero
7226 = dpo_backlink->has_section_at_zero;
7229 dwarf2_per_objfile->reading_partial_symbols = 0;
7231 psymtab_to_symtab_1 (self);
7233 /* Finish up the debug error message. */
7235 printf_filtered (_("done.\n"));
7238 process_cu_includes ();
7241 /* Reading in full CUs. */
7243 /* Add PER_CU to the queue. */
7246 queue_comp_unit (struct dwarf2_per_cu_data *per_cu,
7247 enum language pretend_language)
7249 struct dwarf2_queue_item *item;
7252 item = xmalloc (sizeof (*item));
7253 item->per_cu = per_cu;
7254 item->pretend_language = pretend_language;
7257 if (dwarf2_queue == NULL)
7258 dwarf2_queue = item;
7260 dwarf2_queue_tail->next = item;
7262 dwarf2_queue_tail = item;
7265 /* If PER_CU is not yet queued, add it to the queue.
7266 If DEPENDENT_CU is non-NULL, it has a reference to PER_CU so add a
7268 The result is non-zero if PER_CU was queued, otherwise the result is zero
7269 meaning either PER_CU is already queued or it is already loaded.
7271 N.B. There is an invariant here that if a CU is queued then it is loaded.
7272 The caller is required to load PER_CU if we return non-zero. */
7275 maybe_queue_comp_unit (struct dwarf2_cu *dependent_cu,
7276 struct dwarf2_per_cu_data *per_cu,
7277 enum language pretend_language)
7279 /* We may arrive here during partial symbol reading, if we need full
7280 DIEs to process an unusual case (e.g. template arguments). Do
7281 not queue PER_CU, just tell our caller to load its DIEs. */
7282 if (dwarf2_per_objfile->reading_partial_symbols)
7284 if (per_cu->cu == NULL || per_cu->cu->dies == NULL)
7289 /* Mark the dependence relation so that we don't flush PER_CU
7291 if (dependent_cu != NULL)
7292 dwarf2_add_dependence (dependent_cu, per_cu);
7294 /* If it's already on the queue, we have nothing to do. */
7298 /* If the compilation unit is already loaded, just mark it as
7300 if (per_cu->cu != NULL)
7302 per_cu->cu->last_used = 0;
7306 /* Add it to the queue. */
7307 queue_comp_unit (per_cu, pretend_language);
7312 /* Process the queue. */
7315 process_queue (void)
7317 struct dwarf2_queue_item *item, *next_item;
7319 if (dwarf2_read_debug)
7321 fprintf_unfiltered (gdb_stdlog,
7322 "Expanding one or more symtabs of objfile %s ...\n",
7323 objfile_name (dwarf2_per_objfile->objfile));
7326 /* The queue starts out with one item, but following a DIE reference
7327 may load a new CU, adding it to the end of the queue. */
7328 for (item = dwarf2_queue; item != NULL; dwarf2_queue = item = next_item)
7330 if (dwarf2_per_objfile->using_index
7331 ? !item->per_cu->v.quick->symtab
7332 : (item->per_cu->v.psymtab && !item->per_cu->v.psymtab->readin))
7334 struct dwarf2_per_cu_data *per_cu = item->per_cu;
7335 unsigned int debug_print_threshold;
7338 if (per_cu->is_debug_types)
7340 struct signatured_type *sig_type =
7341 (struct signatured_type *) per_cu;
7343 sprintf (buf, "TU %s at offset 0x%x",
7344 hex_string (sig_type->signature),
7345 per_cu->offset.sect_off);
7346 /* There can be 100s of TUs.
7347 Only print them in verbose mode. */
7348 debug_print_threshold = 2;
7352 sprintf (buf, "CU at offset 0x%x", per_cu->offset.sect_off);
7353 debug_print_threshold = 1;
7356 if (dwarf2_read_debug >= debug_print_threshold)
7357 fprintf_unfiltered (gdb_stdlog, "Expanding symtab of %s\n", buf);
7359 if (per_cu->is_debug_types)
7360 process_full_type_unit (per_cu, item->pretend_language);
7362 process_full_comp_unit (per_cu, item->pretend_language);
7364 if (dwarf2_read_debug >= debug_print_threshold)
7365 fprintf_unfiltered (gdb_stdlog, "Done expanding %s\n", buf);
7368 item->per_cu->queued = 0;
7369 next_item = item->next;
7373 dwarf2_queue_tail = NULL;
7375 if (dwarf2_read_debug)
7377 fprintf_unfiltered (gdb_stdlog, "Done expanding symtabs of %s.\n",
7378 objfile_name (dwarf2_per_objfile->objfile));
7382 /* Free all allocated queue entries. This function only releases anything if
7383 an error was thrown; if the queue was processed then it would have been
7384 freed as we went along. */
7387 dwarf2_release_queue (void *dummy)
7389 struct dwarf2_queue_item *item, *last;
7391 item = dwarf2_queue;
7394 /* Anything still marked queued is likely to be in an
7395 inconsistent state, so discard it. */
7396 if (item->per_cu->queued)
7398 if (item->per_cu->cu != NULL)
7399 free_one_cached_comp_unit (item->per_cu);
7400 item->per_cu->queued = 0;
7408 dwarf2_queue = dwarf2_queue_tail = NULL;
7411 /* Read in full symbols for PST, and anything it depends on. */
7414 psymtab_to_symtab_1 (struct partial_symtab *pst)
7416 struct dwarf2_per_cu_data *per_cu;
7422 for (i = 0; i < pst->number_of_dependencies; i++)
7423 if (!pst->dependencies[i]->readin
7424 && pst->dependencies[i]->user == NULL)
7426 /* Inform about additional files that need to be read in. */
7429 /* FIXME: i18n: Need to make this a single string. */
7430 fputs_filtered (" ", gdb_stdout);
7432 fputs_filtered ("and ", gdb_stdout);
7434 printf_filtered ("%s...", pst->dependencies[i]->filename);
7435 wrap_here (""); /* Flush output. */
7436 gdb_flush (gdb_stdout);
7438 psymtab_to_symtab_1 (pst->dependencies[i]);
7441 per_cu = pst->read_symtab_private;
7445 /* It's an include file, no symbols to read for it.
7446 Everything is in the parent symtab. */
7451 dw2_do_instantiate_symtab (per_cu);
7454 /* Trivial hash function for die_info: the hash value of a DIE
7455 is its offset in .debug_info for this objfile. */
7458 die_hash (const void *item)
7460 const struct die_info *die = item;
7462 return die->offset.sect_off;
7465 /* Trivial comparison function for die_info structures: two DIEs
7466 are equal if they have the same offset. */
7469 die_eq (const void *item_lhs, const void *item_rhs)
7471 const struct die_info *die_lhs = item_lhs;
7472 const struct die_info *die_rhs = item_rhs;
7474 return die_lhs->offset.sect_off == die_rhs->offset.sect_off;
7477 /* die_reader_func for load_full_comp_unit.
7478 This is identical to read_signatured_type_reader,
7479 but is kept separate for now. */
7482 load_full_comp_unit_reader (const struct die_reader_specs *reader,
7483 const gdb_byte *info_ptr,
7484 struct die_info *comp_unit_die,
7488 struct dwarf2_cu *cu = reader->cu;
7489 enum language *language_ptr = data;
7491 gdb_assert (cu->die_hash == NULL);
7493 htab_create_alloc_ex (cu->header.length / 12,
7497 &cu->comp_unit_obstack,
7498 hashtab_obstack_allocate,
7499 dummy_obstack_deallocate);
7502 comp_unit_die->child = read_die_and_siblings (reader, info_ptr,
7503 &info_ptr, comp_unit_die);
7504 cu->dies = comp_unit_die;
7505 /* comp_unit_die is not stored in die_hash, no need. */
7507 /* We try not to read any attributes in this function, because not
7508 all CUs needed for references have been loaded yet, and symbol
7509 table processing isn't initialized. But we have to set the CU language,
7510 or we won't be able to build types correctly.
7511 Similarly, if we do not read the producer, we can not apply
7512 producer-specific interpretation. */
7513 prepare_one_comp_unit (cu, cu->dies, *language_ptr);
7516 /* Load the DIEs associated with PER_CU into memory. */
7519 load_full_comp_unit (struct dwarf2_per_cu_data *this_cu,
7520 enum language pretend_language)
7522 gdb_assert (! this_cu->is_debug_types);
7524 init_cutu_and_read_dies (this_cu, NULL, 1, 1,
7525 load_full_comp_unit_reader, &pretend_language);
7528 /* Add a DIE to the delayed physname list. */
7531 add_to_method_list (struct type *type, int fnfield_index, int index,
7532 const char *name, struct die_info *die,
7533 struct dwarf2_cu *cu)
7535 struct delayed_method_info mi;
7537 mi.fnfield_index = fnfield_index;
7541 VEC_safe_push (delayed_method_info, cu->method_list, &mi);
7544 /* A cleanup for freeing the delayed method list. */
7547 free_delayed_list (void *ptr)
7549 struct dwarf2_cu *cu = (struct dwarf2_cu *) ptr;
7550 if (cu->method_list != NULL)
7552 VEC_free (delayed_method_info, cu->method_list);
7553 cu->method_list = NULL;
7557 /* Compute the physnames of any methods on the CU's method list.
7559 The computation of method physnames is delayed in order to avoid the
7560 (bad) condition that one of the method's formal parameters is of an as yet
7564 compute_delayed_physnames (struct dwarf2_cu *cu)
7567 struct delayed_method_info *mi;
7568 for (i = 0; VEC_iterate (delayed_method_info, cu->method_list, i, mi) ; ++i)
7570 const char *physname;
7571 struct fn_fieldlist *fn_flp
7572 = &TYPE_FN_FIELDLIST (mi->type, mi->fnfield_index);
7573 physname = dwarf2_physname (mi->name, mi->die, cu);
7574 fn_flp->fn_fields[mi->index].physname = physname ? physname : "";
7578 /* Go objects should be embedded in a DW_TAG_module DIE,
7579 and it's not clear if/how imported objects will appear.
7580 To keep Go support simple until that's worked out,
7581 go back through what we've read and create something usable.
7582 We could do this while processing each DIE, and feels kinda cleaner,
7583 but that way is more invasive.
7584 This is to, for example, allow the user to type "p var" or "b main"
7585 without having to specify the package name, and allow lookups
7586 of module.object to work in contexts that use the expression
7590 fixup_go_packaging (struct dwarf2_cu *cu)
7592 char *package_name = NULL;
7593 struct pending *list;
7596 for (list = global_symbols; list != NULL; list = list->next)
7598 for (i = 0; i < list->nsyms; ++i)
7600 struct symbol *sym = list->symbol[i];
7602 if (SYMBOL_LANGUAGE (sym) == language_go
7603 && SYMBOL_CLASS (sym) == LOC_BLOCK)
7605 char *this_package_name = go_symbol_package_name (sym);
7607 if (this_package_name == NULL)
7609 if (package_name == NULL)
7610 package_name = this_package_name;
7613 if (strcmp (package_name, this_package_name) != 0)
7614 complaint (&symfile_complaints,
7615 _("Symtab %s has objects from two different Go packages: %s and %s"),
7616 (SYMBOL_SYMTAB (sym)
7617 ? symtab_to_filename_for_display (SYMBOL_SYMTAB (sym))
7618 : objfile_name (cu->objfile)),
7619 this_package_name, package_name);
7620 xfree (this_package_name);
7626 if (package_name != NULL)
7628 struct objfile *objfile = cu->objfile;
7629 const char *saved_package_name = obstack_copy0 (&objfile->objfile_obstack,
7631 strlen (package_name));
7632 struct type *type = init_type (TYPE_CODE_MODULE, 0, 0,
7633 saved_package_name, objfile);
7636 TYPE_TAG_NAME (type) = TYPE_NAME (type);
7638 sym = allocate_symbol (objfile);
7639 SYMBOL_SET_LANGUAGE (sym, language_go, &objfile->objfile_obstack);
7640 SYMBOL_SET_NAMES (sym, saved_package_name,
7641 strlen (saved_package_name), 0, objfile);
7642 /* This is not VAR_DOMAIN because we want a way to ensure a lookup of,
7643 e.g., "main" finds the "main" module and not C's main(). */
7644 SYMBOL_DOMAIN (sym) = STRUCT_DOMAIN;
7645 SYMBOL_ACLASS_INDEX (sym) = LOC_TYPEDEF;
7646 SYMBOL_TYPE (sym) = type;
7648 add_symbol_to_list (sym, &global_symbols);
7650 xfree (package_name);
7654 /* Return the symtab for PER_CU. This works properly regardless of
7655 whether we're using the index or psymtabs. */
7657 static struct symtab *
7658 get_symtab (struct dwarf2_per_cu_data *per_cu)
7660 return (dwarf2_per_objfile->using_index
7661 ? per_cu->v.quick->symtab
7662 : per_cu->v.psymtab->symtab);
7665 /* A helper function for computing the list of all symbol tables
7666 included by PER_CU. */
7669 recursively_compute_inclusions (VEC (symtab_ptr) **result,
7670 htab_t all_children, htab_t all_type_symtabs,
7671 struct dwarf2_per_cu_data *per_cu,
7672 struct symtab *immediate_parent)
7676 struct symtab *symtab;
7677 struct dwarf2_per_cu_data *iter;
7679 slot = htab_find_slot (all_children, per_cu, INSERT);
7682 /* This inclusion and its children have been processed. */
7687 /* Only add a CU if it has a symbol table. */
7688 symtab = get_symtab (per_cu);
7691 /* If this is a type unit only add its symbol table if we haven't
7692 seen it yet (type unit per_cu's can share symtabs). */
7693 if (per_cu->is_debug_types)
7695 slot = htab_find_slot (all_type_symtabs, symtab, INSERT);
7699 VEC_safe_push (symtab_ptr, *result, symtab);
7700 if (symtab->user == NULL)
7701 symtab->user = immediate_parent;
7706 VEC_safe_push (symtab_ptr, *result, symtab);
7707 if (symtab->user == NULL)
7708 symtab->user = immediate_parent;
7713 VEC_iterate (dwarf2_per_cu_ptr, per_cu->imported_symtabs, ix, iter);
7716 recursively_compute_inclusions (result, all_children,
7717 all_type_symtabs, iter, symtab);
7721 /* Compute the symtab 'includes' fields for the symtab related to
7725 compute_symtab_includes (struct dwarf2_per_cu_data *per_cu)
7727 gdb_assert (! per_cu->is_debug_types);
7729 if (!VEC_empty (dwarf2_per_cu_ptr, per_cu->imported_symtabs))
7732 struct dwarf2_per_cu_data *per_cu_iter;
7733 struct symtab *symtab_iter;
7734 VEC (symtab_ptr) *result_symtabs = NULL;
7735 htab_t all_children, all_type_symtabs;
7736 struct symtab *symtab = get_symtab (per_cu);
7738 /* If we don't have a symtab, we can just skip this case. */
7742 all_children = htab_create_alloc (1, htab_hash_pointer, htab_eq_pointer,
7743 NULL, xcalloc, xfree);
7744 all_type_symtabs = htab_create_alloc (1, htab_hash_pointer, htab_eq_pointer,
7745 NULL, xcalloc, xfree);
7748 VEC_iterate (dwarf2_per_cu_ptr, per_cu->imported_symtabs,
7752 recursively_compute_inclusions (&result_symtabs, all_children,
7753 all_type_symtabs, per_cu_iter,
7757 /* Now we have a transitive closure of all the included symtabs. */
7758 len = VEC_length (symtab_ptr, result_symtabs);
7760 = obstack_alloc (&dwarf2_per_objfile->objfile->objfile_obstack,
7761 (len + 1) * sizeof (struct symtab *));
7763 VEC_iterate (symtab_ptr, result_symtabs, ix, symtab_iter);
7765 symtab->includes[ix] = symtab_iter;
7766 symtab->includes[len] = NULL;
7768 VEC_free (symtab_ptr, result_symtabs);
7769 htab_delete (all_children);
7770 htab_delete (all_type_symtabs);
7774 /* Compute the 'includes' field for the symtabs of all the CUs we just
7778 process_cu_includes (void)
7781 struct dwarf2_per_cu_data *iter;
7784 VEC_iterate (dwarf2_per_cu_ptr, dwarf2_per_objfile->just_read_cus,
7788 if (! iter->is_debug_types)
7789 compute_symtab_includes (iter);
7792 VEC_free (dwarf2_per_cu_ptr, dwarf2_per_objfile->just_read_cus);
7795 /* Generate full symbol information for PER_CU, whose DIEs have
7796 already been loaded into memory. */
7799 process_full_comp_unit (struct dwarf2_per_cu_data *per_cu,
7800 enum language pretend_language)
7802 struct dwarf2_cu *cu = per_cu->cu;
7803 struct objfile *objfile = per_cu->objfile;
7804 CORE_ADDR lowpc, highpc;
7805 struct symtab *symtab;
7806 struct cleanup *back_to, *delayed_list_cleanup;
7808 struct block *static_block;
7810 baseaddr = ANOFFSET (objfile->section_offsets, SECT_OFF_TEXT (objfile));
7813 back_to = make_cleanup (really_free_pendings, NULL);
7814 delayed_list_cleanup = make_cleanup (free_delayed_list, cu);
7816 cu->list_in_scope = &file_symbols;
7818 cu->language = pretend_language;
7819 cu->language_defn = language_def (cu->language);
7821 /* Do line number decoding in read_file_scope () */
7822 process_die (cu->dies, cu);
7824 /* For now fudge the Go package. */
7825 if (cu->language == language_go)
7826 fixup_go_packaging (cu);
7828 /* Now that we have processed all the DIEs in the CU, all the types
7829 should be complete, and it should now be safe to compute all of the
7831 compute_delayed_physnames (cu);
7832 do_cleanups (delayed_list_cleanup);
7834 /* Some compilers don't define a DW_AT_high_pc attribute for the
7835 compilation unit. If the DW_AT_high_pc is missing, synthesize
7836 it, by scanning the DIE's below the compilation unit. */
7837 get_scope_pc_bounds (cu->dies, &lowpc, &highpc, cu);
7840 = end_symtab_get_static_block (highpc + baseaddr, objfile, 0, 1);
7842 /* If the comp unit has DW_AT_ranges, it may have discontiguous ranges.
7843 Also, DW_AT_ranges may record ranges not belonging to any child DIEs
7844 (such as virtual method tables). Record the ranges in STATIC_BLOCK's
7845 addrmap to help ensure it has an accurate map of pc values belonging to
7847 dwarf2_record_block_ranges (cu->dies, static_block, baseaddr, cu);
7849 symtab = end_symtab_from_static_block (static_block, objfile,
7850 SECT_OFF_TEXT (objfile), 0);
7854 int gcc_4_minor = producer_is_gcc_ge_4 (cu->producer);
7856 /* Set symtab language to language from DW_AT_language. If the
7857 compilation is from a C file generated by language preprocessors, do
7858 not set the language if it was already deduced by start_subfile. */
7859 if (!(cu->language == language_c && symtab->language != language_c))
7860 symtab->language = cu->language;
7862 /* GCC-4.0 has started to support -fvar-tracking. GCC-3.x still can
7863 produce DW_AT_location with location lists but it can be possibly
7864 invalid without -fvar-tracking. Still up to GCC-4.4.x incl. 4.4.0
7865 there were bugs in prologue debug info, fixed later in GCC-4.5
7866 by "unwind info for epilogues" patch (which is not directly related).
7868 For -gdwarf-4 type units LOCATIONS_VALID indication is fortunately not
7869 needed, it would be wrong due to missing DW_AT_producer there.
7871 Still one can confuse GDB by using non-standard GCC compilation
7872 options - this waits on GCC PR other/32998 (-frecord-gcc-switches).
7874 if (cu->has_loclist && gcc_4_minor >= 5)
7875 symtab->locations_valid = 1;
7877 if (gcc_4_minor >= 5)
7878 symtab->epilogue_unwind_valid = 1;
7880 symtab->call_site_htab = cu->call_site_htab;
7883 if (dwarf2_per_objfile->using_index)
7884 per_cu->v.quick->symtab = symtab;
7887 struct partial_symtab *pst = per_cu->v.psymtab;
7888 pst->symtab = symtab;
7892 /* Push it for inclusion processing later. */
7893 VEC_safe_push (dwarf2_per_cu_ptr, dwarf2_per_objfile->just_read_cus, per_cu);
7895 do_cleanups (back_to);
7898 /* Generate full symbol information for type unit PER_CU, whose DIEs have
7899 already been loaded into memory. */
7902 process_full_type_unit (struct dwarf2_per_cu_data *per_cu,
7903 enum language pretend_language)
7905 struct dwarf2_cu *cu = per_cu->cu;
7906 struct objfile *objfile = per_cu->objfile;
7907 struct symtab *symtab;
7908 struct cleanup *back_to, *delayed_list_cleanup;
7909 struct signatured_type *sig_type;
7911 gdb_assert (per_cu->is_debug_types);
7912 sig_type = (struct signatured_type *) per_cu;
7915 back_to = make_cleanup (really_free_pendings, NULL);
7916 delayed_list_cleanup = make_cleanup (free_delayed_list, cu);
7918 cu->list_in_scope = &file_symbols;
7920 cu->language = pretend_language;
7921 cu->language_defn = language_def (cu->language);
7923 /* The symbol tables are set up in read_type_unit_scope. */
7924 process_die (cu->dies, cu);
7926 /* For now fudge the Go package. */
7927 if (cu->language == language_go)
7928 fixup_go_packaging (cu);
7930 /* Now that we have processed all the DIEs in the CU, all the types
7931 should be complete, and it should now be safe to compute all of the
7933 compute_delayed_physnames (cu);
7934 do_cleanups (delayed_list_cleanup);
7936 /* TUs share symbol tables.
7937 If this is the first TU to use this symtab, complete the construction
7938 of it with end_expandable_symtab. Otherwise, complete the addition of
7939 this TU's symbols to the existing symtab. */
7940 if (sig_type->type_unit_group->primary_symtab == NULL)
7942 symtab = end_expandable_symtab (0, objfile, SECT_OFF_TEXT (objfile));
7943 sig_type->type_unit_group->primary_symtab = symtab;
7947 /* Set symtab language to language from DW_AT_language. If the
7948 compilation is from a C file generated by language preprocessors,
7949 do not set the language if it was already deduced by
7951 if (!(cu->language == language_c && symtab->language != language_c))
7952 symtab->language = cu->language;
7957 augment_type_symtab (objfile,
7958 sig_type->type_unit_group->primary_symtab);
7959 symtab = sig_type->type_unit_group->primary_symtab;
7962 if (dwarf2_per_objfile->using_index)
7963 per_cu->v.quick->symtab = symtab;
7966 struct partial_symtab *pst = per_cu->v.psymtab;
7967 pst->symtab = symtab;
7971 do_cleanups (back_to);
7974 /* Process an imported unit DIE. */
7977 process_imported_unit_die (struct die_info *die, struct dwarf2_cu *cu)
7979 struct attribute *attr;
7981 /* For now we don't handle imported units in type units. */
7982 if (cu->per_cu->is_debug_types)
7984 error (_("Dwarf Error: DW_TAG_imported_unit is not"
7985 " supported in type units [in module %s]"),
7986 objfile_name (cu->objfile));
7989 attr = dwarf2_attr (die, DW_AT_import, cu);
7992 struct dwarf2_per_cu_data *per_cu;
7993 struct symtab *imported_symtab;
7997 offset = dwarf2_get_ref_die_offset (attr);
7998 is_dwz = (attr->form == DW_FORM_GNU_ref_alt || cu->per_cu->is_dwz);
7999 per_cu = dwarf2_find_containing_comp_unit (offset, is_dwz, cu->objfile);
8001 /* If necessary, add it to the queue and load its DIEs. */
8002 if (maybe_queue_comp_unit (cu, per_cu, cu->language))
8003 load_full_comp_unit (per_cu, cu->language);
8005 VEC_safe_push (dwarf2_per_cu_ptr, cu->per_cu->imported_symtabs,
8010 /* Process a die and its children. */
8013 process_die (struct die_info *die, struct dwarf2_cu *cu)
8017 case DW_TAG_padding:
8019 case DW_TAG_compile_unit:
8020 case DW_TAG_partial_unit:
8021 read_file_scope (die, cu);
8023 case DW_TAG_type_unit:
8024 read_type_unit_scope (die, cu);
8026 case DW_TAG_subprogram:
8027 case DW_TAG_inlined_subroutine:
8028 read_func_scope (die, cu);
8030 case DW_TAG_lexical_block:
8031 case DW_TAG_try_block:
8032 case DW_TAG_catch_block:
8033 read_lexical_block_scope (die, cu);
8035 case DW_TAG_GNU_call_site:
8036 read_call_site_scope (die, cu);
8038 case DW_TAG_class_type:
8039 case DW_TAG_interface_type:
8040 case DW_TAG_structure_type:
8041 case DW_TAG_union_type:
8042 process_structure_scope (die, cu);
8044 case DW_TAG_enumeration_type:
8045 process_enumeration_scope (die, cu);
8048 /* These dies have a type, but processing them does not create
8049 a symbol or recurse to process the children. Therefore we can
8050 read them on-demand through read_type_die. */
8051 case DW_TAG_subroutine_type:
8052 case DW_TAG_set_type:
8053 case DW_TAG_array_type:
8054 case DW_TAG_pointer_type:
8055 case DW_TAG_ptr_to_member_type:
8056 case DW_TAG_reference_type:
8057 case DW_TAG_string_type:
8060 case DW_TAG_base_type:
8061 case DW_TAG_subrange_type:
8062 case DW_TAG_typedef:
8063 /* Add a typedef symbol for the type definition, if it has a
8065 new_symbol (die, read_type_die (die, cu), cu);
8067 case DW_TAG_common_block:
8068 read_common_block (die, cu);
8070 case DW_TAG_common_inclusion:
8072 case DW_TAG_namespace:
8073 cu->processing_has_namespace_info = 1;
8074 read_namespace (die, cu);
8077 cu->processing_has_namespace_info = 1;
8078 read_module (die, cu);
8080 case DW_TAG_imported_declaration:
8081 cu->processing_has_namespace_info = 1;
8082 if (read_namespace_alias (die, cu))
8084 /* The declaration is not a global namespace alias: fall through. */
8085 case DW_TAG_imported_module:
8086 cu->processing_has_namespace_info = 1;
8087 if (die->child != NULL && (die->tag == DW_TAG_imported_declaration
8088 || cu->language != language_fortran))
8089 complaint (&symfile_complaints, _("Tag '%s' has unexpected children"),
8090 dwarf_tag_name (die->tag));
8091 read_import_statement (die, cu);
8094 case DW_TAG_imported_unit:
8095 process_imported_unit_die (die, cu);
8099 new_symbol (die, NULL, cu);
8104 /* DWARF name computation. */
8106 /* A helper function for dwarf2_compute_name which determines whether DIE
8107 needs to have the name of the scope prepended to the name listed in the
8111 die_needs_namespace (struct die_info *die, struct dwarf2_cu *cu)
8113 struct attribute *attr;
8117 case DW_TAG_namespace:
8118 case DW_TAG_typedef:
8119 case DW_TAG_class_type:
8120 case DW_TAG_interface_type:
8121 case DW_TAG_structure_type:
8122 case DW_TAG_union_type:
8123 case DW_TAG_enumeration_type:
8124 case DW_TAG_enumerator:
8125 case DW_TAG_subprogram:
8127 case DW_TAG_imported_declaration:
8130 case DW_TAG_variable:
8131 case DW_TAG_constant:
8132 /* We only need to prefix "globally" visible variables. These include
8133 any variable marked with DW_AT_external or any variable that
8134 lives in a namespace. [Variables in anonymous namespaces
8135 require prefixing, but they are not DW_AT_external.] */
8137 if (dwarf2_attr (die, DW_AT_specification, cu))
8139 struct dwarf2_cu *spec_cu = cu;
8141 return die_needs_namespace (die_specification (die, &spec_cu),
8145 attr = dwarf2_attr (die, DW_AT_external, cu);
8146 if (attr == NULL && die->parent->tag != DW_TAG_namespace
8147 && die->parent->tag != DW_TAG_module)
8149 /* A variable in a lexical block of some kind does not need a
8150 namespace, even though in C++ such variables may be external
8151 and have a mangled name. */
8152 if (die->parent->tag == DW_TAG_lexical_block
8153 || die->parent->tag == DW_TAG_try_block
8154 || die->parent->tag == DW_TAG_catch_block
8155 || die->parent->tag == DW_TAG_subprogram)
8164 /* Retrieve the last character from a mem_file. */
8167 do_ui_file_peek_last (void *object, const char *buffer, long length)
8169 char *last_char_p = (char *) object;
8172 *last_char_p = buffer[length - 1];
8175 /* Compute the fully qualified name of DIE in CU. If PHYSNAME is nonzero,
8176 compute the physname for the object, which include a method's:
8177 - formal parameters (C++/Java),
8178 - receiver type (Go),
8179 - return type (Java).
8181 The term "physname" is a bit confusing.
8182 For C++, for example, it is the demangled name.
8183 For Go, for example, it's the mangled name.
8185 For Ada, return the DIE's linkage name rather than the fully qualified
8186 name. PHYSNAME is ignored..
8188 The result is allocated on the objfile_obstack and canonicalized. */
8191 dwarf2_compute_name (const char *name,
8192 struct die_info *die, struct dwarf2_cu *cu,
8195 struct objfile *objfile = cu->objfile;
8198 name = dwarf2_name (die, cu);
8200 /* For Fortran GDB prefers DW_AT_*linkage_name if present but otherwise
8201 compute it by typename_concat inside GDB. */
8202 if (cu->language == language_ada
8203 || (cu->language == language_fortran && physname))
8205 /* For Ada unit, we prefer the linkage name over the name, as
8206 the former contains the exported name, which the user expects
8207 to be able to reference. Ideally, we want the user to be able
8208 to reference this entity using either natural or linkage name,
8209 but we haven't started looking at this enhancement yet. */
8210 struct attribute *attr;
8212 attr = dwarf2_attr (die, DW_AT_linkage_name, cu);
8214 attr = dwarf2_attr (die, DW_AT_MIPS_linkage_name, cu);
8215 if (attr && DW_STRING (attr))
8216 return DW_STRING (attr);
8219 /* These are the only languages we know how to qualify names in. */
8221 && (cu->language == language_cplus || cu->language == language_java
8222 || cu->language == language_fortran))
8224 if (die_needs_namespace (die, cu))
8228 struct ui_file *buf;
8230 prefix = determine_prefix (die, cu);
8231 buf = mem_fileopen ();
8232 if (*prefix != '\0')
8234 char *prefixed_name = typename_concat (NULL, prefix, name,
8237 fputs_unfiltered (prefixed_name, buf);
8238 xfree (prefixed_name);
8241 fputs_unfiltered (name, buf);
8243 /* Template parameters may be specified in the DIE's DW_AT_name, or
8244 as children with DW_TAG_template_type_param or
8245 DW_TAG_value_type_param. If the latter, add them to the name
8246 here. If the name already has template parameters, then
8247 skip this step; some versions of GCC emit both, and
8248 it is more efficient to use the pre-computed name.
8250 Something to keep in mind about this process: it is very
8251 unlikely, or in some cases downright impossible, to produce
8252 something that will match the mangled name of a function.
8253 If the definition of the function has the same debug info,
8254 we should be able to match up with it anyway. But fallbacks
8255 using the minimal symbol, for instance to find a method
8256 implemented in a stripped copy of libstdc++, will not work.
8257 If we do not have debug info for the definition, we will have to
8258 match them up some other way.
8260 When we do name matching there is a related problem with function
8261 templates; two instantiated function templates are allowed to
8262 differ only by their return types, which we do not add here. */
8264 if (cu->language == language_cplus && strchr (name, '<') == NULL)
8266 struct attribute *attr;
8267 struct die_info *child;
8270 die->building_fullname = 1;
8272 for (child = die->child; child != NULL; child = child->sibling)
8276 const gdb_byte *bytes;
8277 struct dwarf2_locexpr_baton *baton;
8280 if (child->tag != DW_TAG_template_type_param
8281 && child->tag != DW_TAG_template_value_param)
8286 fputs_unfiltered ("<", buf);
8290 fputs_unfiltered (", ", buf);
8292 attr = dwarf2_attr (child, DW_AT_type, cu);
8295 complaint (&symfile_complaints,
8296 _("template parameter missing DW_AT_type"));
8297 fputs_unfiltered ("UNKNOWN_TYPE", buf);
8300 type = die_type (child, cu);
8302 if (child->tag == DW_TAG_template_type_param)
8304 c_print_type (type, "", buf, -1, 0, &type_print_raw_options);
8308 attr = dwarf2_attr (child, DW_AT_const_value, cu);
8311 complaint (&symfile_complaints,
8312 _("template parameter missing "
8313 "DW_AT_const_value"));
8314 fputs_unfiltered ("UNKNOWN_VALUE", buf);
8318 dwarf2_const_value_attr (attr, type, name,
8319 &cu->comp_unit_obstack, cu,
8320 &value, &bytes, &baton);
8322 if (TYPE_NOSIGN (type))
8323 /* GDB prints characters as NUMBER 'CHAR'. If that's
8324 changed, this can use value_print instead. */
8325 c_printchar (value, type, buf);
8328 struct value_print_options opts;
8331 v = dwarf2_evaluate_loc_desc (type, NULL,
8335 else if (bytes != NULL)
8337 v = allocate_value (type);
8338 memcpy (value_contents_writeable (v), bytes,
8339 TYPE_LENGTH (type));
8342 v = value_from_longest (type, value);
8344 /* Specify decimal so that we do not depend on
8346 get_formatted_print_options (&opts, 'd');
8348 value_print (v, buf, &opts);
8354 die->building_fullname = 0;
8358 /* Close the argument list, with a space if necessary
8359 (nested templates). */
8360 char last_char = '\0';
8361 ui_file_put (buf, do_ui_file_peek_last, &last_char);
8362 if (last_char == '>')
8363 fputs_unfiltered (" >", buf);
8365 fputs_unfiltered (">", buf);
8369 /* For Java and C++ methods, append formal parameter type
8370 information, if PHYSNAME. */
8372 if (physname && die->tag == DW_TAG_subprogram
8373 && (cu->language == language_cplus
8374 || cu->language == language_java))
8376 struct type *type = read_type_die (die, cu);
8378 c_type_print_args (type, buf, 1, cu->language,
8379 &type_print_raw_options);
8381 if (cu->language == language_java)
8383 /* For java, we must append the return type to method
8385 if (die->tag == DW_TAG_subprogram)
8386 java_print_type (TYPE_TARGET_TYPE (type), "", buf,
8387 0, 0, &type_print_raw_options);
8389 else if (cu->language == language_cplus)
8391 /* Assume that an artificial first parameter is
8392 "this", but do not crash if it is not. RealView
8393 marks unnamed (and thus unused) parameters as
8394 artificial; there is no way to differentiate
8396 if (TYPE_NFIELDS (type) > 0
8397 && TYPE_FIELD_ARTIFICIAL (type, 0)
8398 && TYPE_CODE (TYPE_FIELD_TYPE (type, 0)) == TYPE_CODE_PTR
8399 && TYPE_CONST (TYPE_TARGET_TYPE (TYPE_FIELD_TYPE (type,
8401 fputs_unfiltered (" const", buf);
8405 name = ui_file_obsavestring (buf, &objfile->objfile_obstack,
8407 ui_file_delete (buf);
8409 if (cu->language == language_cplus)
8412 = dwarf2_canonicalize_name (name, cu,
8413 &objfile->objfile_obstack);
8424 /* Return the fully qualified name of DIE, based on its DW_AT_name.
8425 If scope qualifiers are appropriate they will be added. The result
8426 will be allocated on the objfile_obstack, or NULL if the DIE does
8427 not have a name. NAME may either be from a previous call to
8428 dwarf2_name or NULL.
8430 The output string will be canonicalized (if C++/Java). */
8433 dwarf2_full_name (const char *name, struct die_info *die, struct dwarf2_cu *cu)
8435 return dwarf2_compute_name (name, die, cu, 0);
8438 /* Construct a physname for the given DIE in CU. NAME may either be
8439 from a previous call to dwarf2_name or NULL. The result will be
8440 allocated on the objfile_objstack or NULL if the DIE does not have a
8443 The output string will be canonicalized (if C++/Java). */
8446 dwarf2_physname (const char *name, struct die_info *die, struct dwarf2_cu *cu)
8448 struct objfile *objfile = cu->objfile;
8449 struct attribute *attr;
8450 const char *retval, *mangled = NULL, *canon = NULL;
8451 struct cleanup *back_to;
8454 /* In this case dwarf2_compute_name is just a shortcut not building anything
8456 if (!die_needs_namespace (die, cu))
8457 return dwarf2_compute_name (name, die, cu, 1);
8459 back_to = make_cleanup (null_cleanup, NULL);
8461 attr = dwarf2_attr (die, DW_AT_linkage_name, cu);
8463 attr = dwarf2_attr (die, DW_AT_MIPS_linkage_name, cu);
8465 /* DW_AT_linkage_name is missing in some cases - depend on what GDB
8467 if (attr && DW_STRING (attr))
8471 mangled = DW_STRING (attr);
8473 /* Use DMGL_RET_DROP for C++ template functions to suppress their return
8474 type. It is easier for GDB users to search for such functions as
8475 `name(params)' than `long name(params)'. In such case the minimal
8476 symbol names do not match the full symbol names but for template
8477 functions there is never a need to look up their definition from their
8478 declaration so the only disadvantage remains the minimal symbol
8479 variant `long name(params)' does not have the proper inferior type.
8482 if (cu->language == language_go)
8484 /* This is a lie, but we already lie to the caller new_symbol_full.
8485 new_symbol_full assumes we return the mangled name.
8486 This just undoes that lie until things are cleaned up. */
8491 demangled = gdb_demangle (mangled,
8492 (DMGL_PARAMS | DMGL_ANSI
8493 | (cu->language == language_java
8494 ? DMGL_JAVA | DMGL_RET_POSTFIX
8499 make_cleanup (xfree, demangled);
8509 if (canon == NULL || check_physname)
8511 const char *physname = dwarf2_compute_name (name, die, cu, 1);
8513 if (canon != NULL && strcmp (physname, canon) != 0)
8515 /* It may not mean a bug in GDB. The compiler could also
8516 compute DW_AT_linkage_name incorrectly. But in such case
8517 GDB would need to be bug-to-bug compatible. */
8519 complaint (&symfile_complaints,
8520 _("Computed physname <%s> does not match demangled <%s> "
8521 "(from linkage <%s>) - DIE at 0x%x [in module %s]"),
8522 physname, canon, mangled, die->offset.sect_off,
8523 objfile_name (objfile));
8525 /* Prefer DW_AT_linkage_name (in the CANON form) - when it
8526 is available here - over computed PHYSNAME. It is safer
8527 against both buggy GDB and buggy compilers. */
8541 retval = obstack_copy0 (&objfile->objfile_obstack, retval, strlen (retval));
8543 do_cleanups (back_to);
8547 /* Inspect DIE in CU for a namespace alias. If one exists, record
8548 a new symbol for it.
8550 Returns 1 if a namespace alias was recorded, 0 otherwise. */
8553 read_namespace_alias (struct die_info *die, struct dwarf2_cu *cu)
8555 struct attribute *attr;
8557 /* If the die does not have a name, this is not a namespace
8559 attr = dwarf2_attr (die, DW_AT_name, cu);
8563 struct die_info *d = die;
8564 struct dwarf2_cu *imported_cu = cu;
8566 /* If the compiler has nested DW_AT_imported_declaration DIEs,
8567 keep inspecting DIEs until we hit the underlying import. */
8568 #define MAX_NESTED_IMPORTED_DECLARATIONS 100
8569 for (num = 0; num < MAX_NESTED_IMPORTED_DECLARATIONS; ++num)
8571 attr = dwarf2_attr (d, DW_AT_import, cu);
8575 d = follow_die_ref (d, attr, &imported_cu);
8576 if (d->tag != DW_TAG_imported_declaration)
8580 if (num == MAX_NESTED_IMPORTED_DECLARATIONS)
8582 complaint (&symfile_complaints,
8583 _("DIE at 0x%x has too many recursively imported "
8584 "declarations"), d->offset.sect_off);
8591 sect_offset offset = dwarf2_get_ref_die_offset (attr);
8593 type = get_die_type_at_offset (offset, cu->per_cu);
8594 if (type != NULL && TYPE_CODE (type) == TYPE_CODE_NAMESPACE)
8596 /* This declaration is a global namespace alias. Add
8597 a symbol for it whose type is the aliased namespace. */
8598 new_symbol (die, type, cu);
8607 /* Read the import statement specified by the given die and record it. */
8610 read_import_statement (struct die_info *die, struct dwarf2_cu *cu)
8612 struct objfile *objfile = cu->objfile;
8613 struct attribute *import_attr;
8614 struct die_info *imported_die, *child_die;
8615 struct dwarf2_cu *imported_cu;
8616 const char *imported_name;
8617 const char *imported_name_prefix;
8618 const char *canonical_name;
8619 const char *import_alias;
8620 const char *imported_declaration = NULL;
8621 const char *import_prefix;
8622 VEC (const_char_ptr) *excludes = NULL;
8623 struct cleanup *cleanups;
8625 import_attr = dwarf2_attr (die, DW_AT_import, cu);
8626 if (import_attr == NULL)
8628 complaint (&symfile_complaints, _("Tag '%s' has no DW_AT_import"),
8629 dwarf_tag_name (die->tag));
8634 imported_die = follow_die_ref_or_sig (die, import_attr, &imported_cu);
8635 imported_name = dwarf2_name (imported_die, imported_cu);
8636 if (imported_name == NULL)
8638 /* GCC bug: https://bugzilla.redhat.com/show_bug.cgi?id=506524
8640 The import in the following code:
8654 <2><51>: Abbrev Number: 3 (DW_TAG_imported_declaration)
8655 <52> DW_AT_decl_file : 1
8656 <53> DW_AT_decl_line : 6
8657 <54> DW_AT_import : <0x75>
8658 <2><58>: Abbrev Number: 4 (DW_TAG_typedef)
8660 <5b> DW_AT_decl_file : 1
8661 <5c> DW_AT_decl_line : 2
8662 <5d> DW_AT_type : <0x6e>
8664 <1><75>: Abbrev Number: 7 (DW_TAG_base_type)
8665 <76> DW_AT_byte_size : 4
8666 <77> DW_AT_encoding : 5 (signed)
8668 imports the wrong die ( 0x75 instead of 0x58 ).
8669 This case will be ignored until the gcc bug is fixed. */
8673 /* Figure out the local name after import. */
8674 import_alias = dwarf2_name (die, cu);
8676 /* Figure out where the statement is being imported to. */
8677 import_prefix = determine_prefix (die, cu);
8679 /* Figure out what the scope of the imported die is and prepend it
8680 to the name of the imported die. */
8681 imported_name_prefix = determine_prefix (imported_die, imported_cu);
8683 if (imported_die->tag != DW_TAG_namespace
8684 && imported_die->tag != DW_TAG_module)
8686 imported_declaration = imported_name;
8687 canonical_name = imported_name_prefix;
8689 else if (strlen (imported_name_prefix) > 0)
8690 canonical_name = obconcat (&objfile->objfile_obstack,
8691 imported_name_prefix, "::", imported_name,
8694 canonical_name = imported_name;
8696 cleanups = make_cleanup (VEC_cleanup (const_char_ptr), &excludes);
8698 if (die->tag == DW_TAG_imported_module && cu->language == language_fortran)
8699 for (child_die = die->child; child_die && child_die->tag;
8700 child_die = sibling_die (child_die))
8702 /* DWARF-4: A Fortran use statement with a “rename list” may be
8703 represented by an imported module entry with an import attribute
8704 referring to the module and owned entries corresponding to those
8705 entities that are renamed as part of being imported. */
8707 if (child_die->tag != DW_TAG_imported_declaration)
8709 complaint (&symfile_complaints,
8710 _("child DW_TAG_imported_declaration expected "
8711 "- DIE at 0x%x [in module %s]"),
8712 child_die->offset.sect_off, objfile_name (objfile));
8716 import_attr = dwarf2_attr (child_die, DW_AT_import, cu);
8717 if (import_attr == NULL)
8719 complaint (&symfile_complaints, _("Tag '%s' has no DW_AT_import"),
8720 dwarf_tag_name (child_die->tag));
8725 imported_die = follow_die_ref_or_sig (child_die, import_attr,
8727 imported_name = dwarf2_name (imported_die, imported_cu);
8728 if (imported_name == NULL)
8730 complaint (&symfile_complaints,
8731 _("child DW_TAG_imported_declaration has unknown "
8732 "imported name - DIE at 0x%x [in module %s]"),
8733 child_die->offset.sect_off, objfile_name (objfile));
8737 VEC_safe_push (const_char_ptr, excludes, imported_name);
8739 process_die (child_die, cu);
8742 cp_add_using_directive (import_prefix,
8745 imported_declaration,
8748 &objfile->objfile_obstack);
8750 do_cleanups (cleanups);
8753 /* Cleanup function for handle_DW_AT_stmt_list. */
8756 free_cu_line_header (void *arg)
8758 struct dwarf2_cu *cu = arg;
8760 free_line_header (cu->line_header);
8761 cu->line_header = NULL;
8764 /* Check for possibly missing DW_AT_comp_dir with relative .debug_line
8765 directory paths. GCC SVN r127613 (new option -fdebug-prefix-map) fixed
8766 this, it was first present in GCC release 4.3.0. */
8769 producer_is_gcc_lt_4_3 (struct dwarf2_cu *cu)
8771 if (!cu->checked_producer)
8772 check_producer (cu);
8774 return cu->producer_is_gcc_lt_4_3;
8778 find_file_and_directory (struct die_info *die, struct dwarf2_cu *cu,
8779 const char **name, const char **comp_dir)
8781 struct attribute *attr;
8786 /* Find the filename. Do not use dwarf2_name here, since the filename
8787 is not a source language identifier. */
8788 attr = dwarf2_attr (die, DW_AT_name, cu);
8791 *name = DW_STRING (attr);
8794 attr = dwarf2_attr (die, DW_AT_comp_dir, cu);
8796 *comp_dir = DW_STRING (attr);
8797 else if (producer_is_gcc_lt_4_3 (cu) && *name != NULL
8798 && IS_ABSOLUTE_PATH (*name))
8800 char *d = ldirname (*name);
8804 make_cleanup (xfree, d);
8806 if (*comp_dir != NULL)
8808 /* Irix 6.2 native cc prepends <machine>.: to the compilation
8809 directory, get rid of it. */
8810 char *cp = strchr (*comp_dir, ':');
8812 if (cp && cp != *comp_dir && cp[-1] == '.' && cp[1] == '/')
8817 *name = "<unknown>";
8820 /* Handle DW_AT_stmt_list for a compilation unit.
8821 DIE is the DW_TAG_compile_unit die for CU.
8822 COMP_DIR is the compilation directory.
8823 WANT_LINE_INFO is non-zero if the pc/line-number mapping is needed. */
8826 handle_DW_AT_stmt_list (struct die_info *die, struct dwarf2_cu *cu,
8827 const char *comp_dir) /* ARI: editCase function */
8829 struct attribute *attr;
8831 gdb_assert (! cu->per_cu->is_debug_types);
8833 attr = dwarf2_attr (die, DW_AT_stmt_list, cu);
8836 unsigned int line_offset = DW_UNSND (attr);
8837 struct line_header *line_header
8838 = dwarf_decode_line_header (line_offset, cu);
8842 cu->line_header = line_header;
8843 make_cleanup (free_cu_line_header, cu);
8844 dwarf_decode_lines (line_header, comp_dir, cu, NULL, 1);
8849 /* Process DW_TAG_compile_unit or DW_TAG_partial_unit. */
8852 read_file_scope (struct die_info *die, struct dwarf2_cu *cu)
8854 struct objfile *objfile = dwarf2_per_objfile->objfile;
8855 struct cleanup *back_to = make_cleanup (null_cleanup, 0);
8856 CORE_ADDR lowpc = ((CORE_ADDR) -1);
8857 CORE_ADDR highpc = ((CORE_ADDR) 0);
8858 struct attribute *attr;
8859 const char *name = NULL;
8860 const char *comp_dir = NULL;
8861 struct die_info *child_die;
8862 bfd *abfd = objfile->obfd;
8865 baseaddr = ANOFFSET (objfile->section_offsets, SECT_OFF_TEXT (objfile));
8867 get_scope_pc_bounds (die, &lowpc, &highpc, cu);
8869 /* If we didn't find a lowpc, set it to highpc to avoid complaints
8870 from finish_block. */
8871 if (lowpc == ((CORE_ADDR) -1))
8876 find_file_and_directory (die, cu, &name, &comp_dir);
8878 prepare_one_comp_unit (cu, die, cu->language);
8880 /* The XLCL doesn't generate DW_LANG_OpenCL because this attribute is not
8881 standardised yet. As a workaround for the language detection we fall
8882 back to the DW_AT_producer string. */
8883 if (cu->producer && strstr (cu->producer, "IBM XL C for OpenCL") != NULL)
8884 cu->language = language_opencl;
8886 /* Similar hack for Go. */
8887 if (cu->producer && strstr (cu->producer, "GNU Go ") != NULL)
8888 set_cu_language (DW_LANG_Go, cu);
8890 dwarf2_start_symtab (cu, name, comp_dir, lowpc);
8892 /* Decode line number information if present. We do this before
8893 processing child DIEs, so that the line header table is available
8894 for DW_AT_decl_file. */
8895 handle_DW_AT_stmt_list (die, cu, comp_dir);
8897 /* Process all dies in compilation unit. */
8898 if (die->child != NULL)
8900 child_die = die->child;
8901 while (child_die && child_die->tag)
8903 process_die (child_die, cu);
8904 child_die = sibling_die (child_die);
8908 /* Decode macro information, if present. Dwarf 2 macro information
8909 refers to information in the line number info statement program
8910 header, so we can only read it if we've read the header
8912 attr = dwarf2_attr (die, DW_AT_GNU_macros, cu);
8913 if (attr && cu->line_header)
8915 if (dwarf2_attr (die, DW_AT_macro_info, cu))
8916 complaint (&symfile_complaints,
8917 _("CU refers to both DW_AT_GNU_macros and DW_AT_macro_info"));
8919 dwarf_decode_macros (cu, DW_UNSND (attr), comp_dir, 1);
8923 attr = dwarf2_attr (die, DW_AT_macro_info, cu);
8924 if (attr && cu->line_header)
8926 unsigned int macro_offset = DW_UNSND (attr);
8928 dwarf_decode_macros (cu, macro_offset, comp_dir, 0);
8932 do_cleanups (back_to);
8935 /* TU version of handle_DW_AT_stmt_list for read_type_unit_scope.
8936 Create the set of symtabs used by this TU, or if this TU is sharing
8937 symtabs with another TU and the symtabs have already been created
8938 then restore those symtabs in the line header.
8939 We don't need the pc/line-number mapping for type units. */
8942 setup_type_unit_groups (struct die_info *die, struct dwarf2_cu *cu)
8944 struct objfile *objfile = dwarf2_per_objfile->objfile;
8945 struct dwarf2_per_cu_data *per_cu = cu->per_cu;
8946 struct type_unit_group *tu_group;
8948 struct line_header *lh;
8949 struct attribute *attr;
8950 unsigned int i, line_offset;
8951 struct signatured_type *sig_type;
8953 gdb_assert (per_cu->is_debug_types);
8954 sig_type = (struct signatured_type *) per_cu;
8956 attr = dwarf2_attr (die, DW_AT_stmt_list, cu);
8958 /* If we're using .gdb_index (includes -readnow) then
8959 per_cu->type_unit_group may not have been set up yet. */
8960 if (sig_type->type_unit_group == NULL)
8961 sig_type->type_unit_group = get_type_unit_group (cu, attr);
8962 tu_group = sig_type->type_unit_group;
8964 /* If we've already processed this stmt_list there's no real need to
8965 do it again, we could fake it and just recreate the part we need
8966 (file name,index -> symtab mapping). If data shows this optimization
8967 is useful we can do it then. */
8968 first_time = tu_group->primary_symtab == NULL;
8970 /* We have to handle the case of both a missing DW_AT_stmt_list or bad
8975 line_offset = DW_UNSND (attr);
8976 lh = dwarf_decode_line_header (line_offset, cu);
8981 dwarf2_start_symtab (cu, "", NULL, 0);
8984 gdb_assert (tu_group->symtabs == NULL);
8987 /* Note: The primary symtab will get allocated at the end. */
8991 cu->line_header = lh;
8992 make_cleanup (free_cu_line_header, cu);
8996 dwarf2_start_symtab (cu, "", NULL, 0);
8998 tu_group->num_symtabs = lh->num_file_names;
8999 tu_group->symtabs = XNEWVEC (struct symtab *, lh->num_file_names);
9001 for (i = 0; i < lh->num_file_names; ++i)
9003 const char *dir = NULL;
9004 struct file_entry *fe = &lh->file_names[i];
9007 dir = lh->include_dirs[fe->dir_index - 1];
9008 dwarf2_start_subfile (fe->name, dir, NULL);
9010 /* Note: We don't have to watch for the main subfile here, type units
9011 don't have DW_AT_name. */
9013 if (current_subfile->symtab == NULL)
9015 /* NOTE: start_subfile will recognize when it's been passed
9016 a file it has already seen. So we can't assume there's a
9017 simple mapping from lh->file_names to subfiles,
9018 lh->file_names may contain dups. */
9019 current_subfile->symtab = allocate_symtab (current_subfile->name,
9023 fe->symtab = current_subfile->symtab;
9024 tu_group->symtabs[i] = fe->symtab;
9031 for (i = 0; i < lh->num_file_names; ++i)
9033 struct file_entry *fe = &lh->file_names[i];
9035 fe->symtab = tu_group->symtabs[i];
9039 /* The main symtab is allocated last. Type units don't have DW_AT_name
9040 so they don't have a "real" (so to speak) symtab anyway.
9041 There is later code that will assign the main symtab to all symbols
9042 that don't have one. We need to handle the case of a symbol with a
9043 missing symtab (DW_AT_decl_file) anyway. */
9046 /* Process DW_TAG_type_unit.
9047 For TUs we want to skip the first top level sibling if it's not the
9048 actual type being defined by this TU. In this case the first top
9049 level sibling is there to provide context only. */
9052 read_type_unit_scope (struct die_info *die, struct dwarf2_cu *cu)
9054 struct die_info *child_die;
9056 prepare_one_comp_unit (cu, die, language_minimal);
9058 /* Initialize (or reinitialize) the machinery for building symtabs.
9059 We do this before processing child DIEs, so that the line header table
9060 is available for DW_AT_decl_file. */
9061 setup_type_unit_groups (die, cu);
9063 if (die->child != NULL)
9065 child_die = die->child;
9066 while (child_die && child_die->tag)
9068 process_die (child_die, cu);
9069 child_die = sibling_die (child_die);
9076 http://gcc.gnu.org/wiki/DebugFission
9077 http://gcc.gnu.org/wiki/DebugFissionDWP
9079 To simplify handling of both DWO files ("object" files with the DWARF info)
9080 and DWP files (a file with the DWOs packaged up into one file), we treat
9081 DWP files as having a collection of virtual DWO files. */
9084 hash_dwo_file (const void *item)
9086 const struct dwo_file *dwo_file = item;
9089 hash = htab_hash_string (dwo_file->dwo_name);
9090 if (dwo_file->comp_dir != NULL)
9091 hash += htab_hash_string (dwo_file->comp_dir);
9096 eq_dwo_file (const void *item_lhs, const void *item_rhs)
9098 const struct dwo_file *lhs = item_lhs;
9099 const struct dwo_file *rhs = item_rhs;
9101 if (strcmp (lhs->dwo_name, rhs->dwo_name) != 0)
9103 if (lhs->comp_dir == NULL || rhs->comp_dir == NULL)
9104 return lhs->comp_dir == rhs->comp_dir;
9105 return strcmp (lhs->comp_dir, rhs->comp_dir) == 0;
9108 /* Allocate a hash table for DWO files. */
9111 allocate_dwo_file_hash_table (void)
9113 struct objfile *objfile = dwarf2_per_objfile->objfile;
9115 return htab_create_alloc_ex (41,
9119 &objfile->objfile_obstack,
9120 hashtab_obstack_allocate,
9121 dummy_obstack_deallocate);
9124 /* Lookup DWO file DWO_NAME. */
9127 lookup_dwo_file_slot (const char *dwo_name, const char *comp_dir)
9129 struct dwo_file find_entry;
9132 if (dwarf2_per_objfile->dwo_files == NULL)
9133 dwarf2_per_objfile->dwo_files = allocate_dwo_file_hash_table ();
9135 memset (&find_entry, 0, sizeof (find_entry));
9136 find_entry.dwo_name = dwo_name;
9137 find_entry.comp_dir = comp_dir;
9138 slot = htab_find_slot (dwarf2_per_objfile->dwo_files, &find_entry, INSERT);
9144 hash_dwo_unit (const void *item)
9146 const struct dwo_unit *dwo_unit = item;
9148 /* This drops the top 32 bits of the id, but is ok for a hash. */
9149 return dwo_unit->signature;
9153 eq_dwo_unit (const void *item_lhs, const void *item_rhs)
9155 const struct dwo_unit *lhs = item_lhs;
9156 const struct dwo_unit *rhs = item_rhs;
9158 /* The signature is assumed to be unique within the DWO file.
9159 So while object file CU dwo_id's always have the value zero,
9160 that's OK, assuming each object file DWO file has only one CU,
9161 and that's the rule for now. */
9162 return lhs->signature == rhs->signature;
9165 /* Allocate a hash table for DWO CUs,TUs.
9166 There is one of these tables for each of CUs,TUs for each DWO file. */
9169 allocate_dwo_unit_table (struct objfile *objfile)
9171 /* Start out with a pretty small number.
9172 Generally DWO files contain only one CU and maybe some TUs. */
9173 return htab_create_alloc_ex (3,
9177 &objfile->objfile_obstack,
9178 hashtab_obstack_allocate,
9179 dummy_obstack_deallocate);
9182 /* Structure used to pass data to create_dwo_debug_info_hash_table_reader. */
9184 struct create_dwo_cu_data
9186 struct dwo_file *dwo_file;
9187 struct dwo_unit dwo_unit;
9190 /* die_reader_func for create_dwo_cu. */
9193 create_dwo_cu_reader (const struct die_reader_specs *reader,
9194 const gdb_byte *info_ptr,
9195 struct die_info *comp_unit_die,
9199 struct dwarf2_cu *cu = reader->cu;
9200 struct objfile *objfile = dwarf2_per_objfile->objfile;
9201 sect_offset offset = cu->per_cu->offset;
9202 struct dwarf2_section_info *section = cu->per_cu->section;
9203 struct create_dwo_cu_data *data = datap;
9204 struct dwo_file *dwo_file = data->dwo_file;
9205 struct dwo_unit *dwo_unit = &data->dwo_unit;
9206 struct attribute *attr;
9208 attr = dwarf2_attr (comp_unit_die, DW_AT_GNU_dwo_id, cu);
9211 complaint (&symfile_complaints,
9212 _("Dwarf Error: debug entry at offset 0x%x is missing"
9213 " its dwo_id [in module %s]"),
9214 offset.sect_off, dwo_file->dwo_name);
9218 dwo_unit->dwo_file = dwo_file;
9219 dwo_unit->signature = DW_UNSND (attr);
9220 dwo_unit->section = section;
9221 dwo_unit->offset = offset;
9222 dwo_unit->length = cu->per_cu->length;
9224 if (dwarf2_read_debug)
9225 fprintf_unfiltered (gdb_stdlog, " offset 0x%x, dwo_id %s\n",
9226 offset.sect_off, hex_string (dwo_unit->signature));
9229 /* Create the dwo_unit for the lone CU in DWO_FILE.
9230 Note: This function processes DWO files only, not DWP files. */
9232 static struct dwo_unit *
9233 create_dwo_cu (struct dwo_file *dwo_file)
9235 struct objfile *objfile = dwarf2_per_objfile->objfile;
9236 struct dwarf2_section_info *section = &dwo_file->sections.info;
9239 const gdb_byte *info_ptr, *end_ptr;
9240 struct create_dwo_cu_data create_dwo_cu_data;
9241 struct dwo_unit *dwo_unit;
9243 dwarf2_read_section (objfile, section);
9244 info_ptr = section->buffer;
9246 if (info_ptr == NULL)
9249 /* We can't set abfd until now because the section may be empty or
9250 not present, in which case section->asection will be NULL. */
9251 abfd = get_section_bfd_owner (section);
9253 if (dwarf2_read_debug)
9255 fprintf_unfiltered (gdb_stdlog, "Reading %s for %s:\n",
9256 get_section_name (section),
9257 get_section_file_name (section));
9260 create_dwo_cu_data.dwo_file = dwo_file;
9263 end_ptr = info_ptr + section->size;
9264 while (info_ptr < end_ptr)
9266 struct dwarf2_per_cu_data per_cu;
9268 memset (&create_dwo_cu_data.dwo_unit, 0,
9269 sizeof (create_dwo_cu_data.dwo_unit));
9270 memset (&per_cu, 0, sizeof (per_cu));
9271 per_cu.objfile = objfile;
9272 per_cu.is_debug_types = 0;
9273 per_cu.offset.sect_off = info_ptr - section->buffer;
9274 per_cu.section = section;
9276 init_cutu_and_read_dies_no_follow (&per_cu,
9277 &dwo_file->sections.abbrev,
9279 create_dwo_cu_reader,
9280 &create_dwo_cu_data);
9282 if (create_dwo_cu_data.dwo_unit.dwo_file != NULL)
9284 /* If we've already found one, complain. We only support one
9285 because having more than one requires hacking the dwo_name of
9286 each to match, which is highly unlikely to happen. */
9287 if (dwo_unit != NULL)
9289 complaint (&symfile_complaints,
9290 _("Multiple CUs in DWO file %s [in module %s]"),
9291 dwo_file->dwo_name, objfile_name (objfile));
9295 dwo_unit = OBSTACK_ZALLOC (&objfile->objfile_obstack, struct dwo_unit);
9296 *dwo_unit = create_dwo_cu_data.dwo_unit;
9299 info_ptr += per_cu.length;
9305 /* DWP file .debug_{cu,tu}_index section format:
9306 [ref: http://gcc.gnu.org/wiki/DebugFissionDWP]
9310 Both index sections have the same format, and serve to map a 64-bit
9311 signature to a set of section numbers. Each section begins with a header,
9312 followed by a hash table of 64-bit signatures, a parallel table of 32-bit
9313 indexes, and a pool of 32-bit section numbers. The index sections will be
9314 aligned at 8-byte boundaries in the file.
9316 The index section header consists of:
9318 V, 32 bit version number
9320 N, 32 bit number of compilation units or type units in the index
9321 M, 32 bit number of slots in the hash table
9323 Numbers are recorded using the byte order of the application binary.
9325 The hash table begins at offset 16 in the section, and consists of an array
9326 of M 64-bit slots. Each slot contains a 64-bit signature (using the byte
9327 order of the application binary). Unused slots in the hash table are 0.
9328 (We rely on the extreme unlikeliness of a signature being exactly 0.)
9330 The parallel table begins immediately after the hash table
9331 (at offset 16 + 8 * M from the beginning of the section), and consists of an
9332 array of 32-bit indexes (using the byte order of the application binary),
9333 corresponding 1-1 with slots in the hash table. Each entry in the parallel
9334 table contains a 32-bit index into the pool of section numbers. For unused
9335 hash table slots, the corresponding entry in the parallel table will be 0.
9337 The pool of section numbers begins immediately following the hash table
9338 (at offset 16 + 12 * M from the beginning of the section). The pool of
9339 section numbers consists of an array of 32-bit words (using the byte order
9340 of the application binary). Each item in the array is indexed starting
9341 from 0. The hash table entry provides the index of the first section
9342 number in the set. Additional section numbers in the set follow, and the
9343 set is terminated by a 0 entry (section number 0 is not used in ELF).
9345 In each set of section numbers, the .debug_info.dwo or .debug_types.dwo
9346 section must be the first entry in the set, and the .debug_abbrev.dwo must
9347 be the second entry. Other members of the set may follow in any order.
9353 DWP Version 2 combines all the .debug_info, etc. sections into one,
9354 and the entries in the index tables are now offsets into these sections.
9355 CU offsets begin at 0. TU offsets begin at the size of the .debug_info
9358 Index Section Contents:
9360 Hash Table of Signatures dwp_hash_table.hash_table
9361 Parallel Table of Indices dwp_hash_table.unit_table
9362 Table of Section Offsets dwp_hash_table.v2.{section_ids,offsets}
9363 Table of Section Sizes dwp_hash_table.v2.sizes
9365 The index section header consists of:
9367 V, 32 bit version number
9368 L, 32 bit number of columns in the table of section offsets
9369 N, 32 bit number of compilation units or type units in the index
9370 M, 32 bit number of slots in the hash table
9372 Numbers are recorded using the byte order of the application binary.
9374 The hash table has the same format as version 1.
9375 The parallel table of indices has the same format as version 1,
9376 except that the entries are origin-1 indices into the table of sections
9377 offsets and the table of section sizes.
9379 The table of offsets begins immediately following the parallel table
9380 (at offset 16 + 12 * M from the beginning of the section). The table is
9381 a two-dimensional array of 32-bit words (using the byte order of the
9382 application binary), with L columns and N+1 rows, in row-major order.
9383 Each row in the array is indexed starting from 0. The first row provides
9384 a key to the remaining rows: each column in this row provides an identifier
9385 for a debug section, and the offsets in the same column of subsequent rows
9386 refer to that section. The section identifiers are:
9388 DW_SECT_INFO 1 .debug_info.dwo
9389 DW_SECT_TYPES 2 .debug_types.dwo
9390 DW_SECT_ABBREV 3 .debug_abbrev.dwo
9391 DW_SECT_LINE 4 .debug_line.dwo
9392 DW_SECT_LOC 5 .debug_loc.dwo
9393 DW_SECT_STR_OFFSETS 6 .debug_str_offsets.dwo
9394 DW_SECT_MACINFO 7 .debug_macinfo.dwo
9395 DW_SECT_MACRO 8 .debug_macro.dwo
9397 The offsets provided by the CU and TU index sections are the base offsets
9398 for the contributions made by each CU or TU to the corresponding section
9399 in the package file. Each CU and TU header contains an abbrev_offset
9400 field, used to find the abbreviations table for that CU or TU within the
9401 contribution to the .debug_abbrev.dwo section for that CU or TU, and should
9402 be interpreted as relative to the base offset given in the index section.
9403 Likewise, offsets into .debug_line.dwo from DW_AT_stmt_list attributes
9404 should be interpreted as relative to the base offset for .debug_line.dwo,
9405 and offsets into other debug sections obtained from DWARF attributes should
9406 also be interpreted as relative to the corresponding base offset.
9408 The table of sizes begins immediately following the table of offsets.
9409 Like the table of offsets, it is a two-dimensional array of 32-bit words,
9410 with L columns and N rows, in row-major order. Each row in the array is
9411 indexed starting from 1 (row 0 is shared by the two tables).
9415 Hash table lookup is handled the same in version 1 and 2:
9417 We assume that N and M will not exceed 2^32 - 1.
9418 The size of the hash table, M, must be 2^k such that 2^k > 3*N/2.
9420 Given a 64-bit compilation unit signature or a type signature S, an entry
9421 in the hash table is located as follows:
9423 1) Calculate a primary hash H = S & MASK(k), where MASK(k) is a mask with
9424 the low-order k bits all set to 1.
9426 2) Calculate a secondary hash H' = (((S >> 32) & MASK(k)) | 1).
9428 3) If the hash table entry at index H matches the signature, use that
9429 entry. If the hash table entry at index H is unused (all zeroes),
9430 terminate the search: the signature is not present in the table.
9432 4) Let H = (H + H') modulo M. Repeat at Step 3.
9434 Because M > N and H' and M are relatively prime, the search is guaranteed
9435 to stop at an unused slot or find the match. */
9437 /* Create a hash table to map DWO IDs to their CU/TU entry in
9438 .debug_{info,types}.dwo in DWP_FILE.
9439 Returns NULL if there isn't one.
9440 Note: This function processes DWP files only, not DWO files. */
9442 static struct dwp_hash_table *
9443 create_dwp_hash_table (struct dwp_file *dwp_file, int is_debug_types)
9445 struct objfile *objfile = dwarf2_per_objfile->objfile;
9446 bfd *dbfd = dwp_file->dbfd;
9447 const gdb_byte *index_ptr, *index_end;
9448 struct dwarf2_section_info *index;
9449 uint32_t version, nr_columns, nr_units, nr_slots;
9450 struct dwp_hash_table *htab;
9453 index = &dwp_file->sections.tu_index;
9455 index = &dwp_file->sections.cu_index;
9457 if (dwarf2_section_empty_p (index))
9459 dwarf2_read_section (objfile, index);
9461 index_ptr = index->buffer;
9462 index_end = index_ptr + index->size;
9464 version = read_4_bytes (dbfd, index_ptr);
9467 nr_columns = read_4_bytes (dbfd, index_ptr);
9471 nr_units = read_4_bytes (dbfd, index_ptr);
9473 nr_slots = read_4_bytes (dbfd, index_ptr);
9476 if (version != 1 && version != 2)
9478 error (_("Dwarf Error: unsupported DWP file version (%s)"
9480 pulongest (version), dwp_file->name);
9482 if (nr_slots != (nr_slots & -nr_slots))
9484 error (_("Dwarf Error: number of slots in DWP hash table (%s)"
9485 " is not power of 2 [in module %s]"),
9486 pulongest (nr_slots), dwp_file->name);
9489 htab = OBSTACK_ZALLOC (&objfile->objfile_obstack, struct dwp_hash_table);
9490 htab->version = version;
9491 htab->nr_columns = nr_columns;
9492 htab->nr_units = nr_units;
9493 htab->nr_slots = nr_slots;
9494 htab->hash_table = index_ptr;
9495 htab->unit_table = htab->hash_table + sizeof (uint64_t) * nr_slots;
9497 /* Exit early if the table is empty. */
9498 if (nr_slots == 0 || nr_units == 0
9499 || (version == 2 && nr_columns == 0))
9501 /* All must be zero. */
9502 if (nr_slots != 0 || nr_units != 0
9503 || (version == 2 && nr_columns != 0))
9505 complaint (&symfile_complaints,
9506 _("Empty DWP but nr_slots,nr_units,nr_columns not"
9507 " all zero [in modules %s]"),
9515 htab->section_pool.v1.indices =
9516 htab->unit_table + sizeof (uint32_t) * nr_slots;
9517 /* It's harder to decide whether the section is too small in v1.
9518 V1 is deprecated anyway so we punt. */
9522 const gdb_byte *ids_ptr = htab->unit_table + sizeof (uint32_t) * nr_slots;
9523 int *ids = htab->section_pool.v2.section_ids;
9524 /* Reverse map for error checking. */
9525 int ids_seen[DW_SECT_MAX + 1];
9530 error (_("Dwarf Error: bad DWP hash table, too few columns"
9531 " in section table [in module %s]"),
9534 if (nr_columns > MAX_NR_V2_DWO_SECTIONS)
9536 error (_("Dwarf Error: bad DWP hash table, too many columns"
9537 " in section table [in module %s]"),
9540 memset (ids, 255, (DW_SECT_MAX + 1) * sizeof (int32_t));
9541 memset (ids_seen, 255, (DW_SECT_MAX + 1) * sizeof (int32_t));
9542 for (i = 0; i < nr_columns; ++i)
9544 int id = read_4_bytes (dbfd, ids_ptr + i * sizeof (uint32_t));
9546 if (id < DW_SECT_MIN || id > DW_SECT_MAX)
9548 error (_("Dwarf Error: bad DWP hash table, bad section id %d"
9549 " in section table [in module %s]"),
9550 id, dwp_file->name);
9552 if (ids_seen[id] != -1)
9554 error (_("Dwarf Error: bad DWP hash table, duplicate section"
9555 " id %d in section table [in module %s]"),
9556 id, dwp_file->name);
9561 /* Must have exactly one info or types section. */
9562 if (((ids_seen[DW_SECT_INFO] != -1)
9563 + (ids_seen[DW_SECT_TYPES] != -1))
9566 error (_("Dwarf Error: bad DWP hash table, missing/duplicate"
9567 " DWO info/types section [in module %s]"),
9570 /* Must have an abbrev section. */
9571 if (ids_seen[DW_SECT_ABBREV] == -1)
9573 error (_("Dwarf Error: bad DWP hash table, missing DWO abbrev"
9574 " section [in module %s]"),
9577 htab->section_pool.v2.offsets = ids_ptr + sizeof (uint32_t) * nr_columns;
9578 htab->section_pool.v2.sizes =
9579 htab->section_pool.v2.offsets + (sizeof (uint32_t)
9580 * nr_units * nr_columns);
9581 if ((htab->section_pool.v2.sizes + (sizeof (uint32_t)
9582 * nr_units * nr_columns))
9585 error (_("Dwarf Error: DWP index section is corrupt (too small)"
9594 /* Update SECTIONS with the data from SECTP.
9596 This function is like the other "locate" section routines that are
9597 passed to bfd_map_over_sections, but in this context the sections to
9598 read comes from the DWP V1 hash table, not the full ELF section table.
9600 The result is non-zero for success, or zero if an error was found. */
9603 locate_v1_virtual_dwo_sections (asection *sectp,
9604 struct virtual_v1_dwo_sections *sections)
9606 const struct dwop_section_names *names = &dwop_section_names;
9608 if (section_is_p (sectp->name, &names->abbrev_dwo))
9610 /* There can be only one. */
9611 if (sections->abbrev.s.asection != NULL)
9613 sections->abbrev.s.asection = sectp;
9614 sections->abbrev.size = bfd_get_section_size (sectp);
9616 else if (section_is_p (sectp->name, &names->info_dwo)
9617 || section_is_p (sectp->name, &names->types_dwo))
9619 /* There can be only one. */
9620 if (sections->info_or_types.s.asection != NULL)
9622 sections->info_or_types.s.asection = sectp;
9623 sections->info_or_types.size = bfd_get_section_size (sectp);
9625 else if (section_is_p (sectp->name, &names->line_dwo))
9627 /* There can be only one. */
9628 if (sections->line.s.asection != NULL)
9630 sections->line.s.asection = sectp;
9631 sections->line.size = bfd_get_section_size (sectp);
9633 else if (section_is_p (sectp->name, &names->loc_dwo))
9635 /* There can be only one. */
9636 if (sections->loc.s.asection != NULL)
9638 sections->loc.s.asection = sectp;
9639 sections->loc.size = bfd_get_section_size (sectp);
9641 else if (section_is_p (sectp->name, &names->macinfo_dwo))
9643 /* There can be only one. */
9644 if (sections->macinfo.s.asection != NULL)
9646 sections->macinfo.s.asection = sectp;
9647 sections->macinfo.size = bfd_get_section_size (sectp);
9649 else if (section_is_p (sectp->name, &names->macro_dwo))
9651 /* There can be only one. */
9652 if (sections->macro.s.asection != NULL)
9654 sections->macro.s.asection = sectp;
9655 sections->macro.size = bfd_get_section_size (sectp);
9657 else if (section_is_p (sectp->name, &names->str_offsets_dwo))
9659 /* There can be only one. */
9660 if (sections->str_offsets.s.asection != NULL)
9662 sections->str_offsets.s.asection = sectp;
9663 sections->str_offsets.size = bfd_get_section_size (sectp);
9667 /* No other kind of section is valid. */
9674 /* Create a dwo_unit object for the DWO unit with signature SIGNATURE.
9675 UNIT_INDEX is the index of the DWO unit in the DWP hash table.
9676 COMP_DIR is the DW_AT_comp_dir attribute of the referencing CU.
9677 This is for DWP version 1 files. */
9679 static struct dwo_unit *
9680 create_dwo_unit_in_dwp_v1 (struct dwp_file *dwp_file,
9681 uint32_t unit_index,
9682 const char *comp_dir,
9683 ULONGEST signature, int is_debug_types)
9685 struct objfile *objfile = dwarf2_per_objfile->objfile;
9686 const struct dwp_hash_table *dwp_htab =
9687 is_debug_types ? dwp_file->tus : dwp_file->cus;
9688 bfd *dbfd = dwp_file->dbfd;
9689 const char *kind = is_debug_types ? "TU" : "CU";
9690 struct dwo_file *dwo_file;
9691 struct dwo_unit *dwo_unit;
9692 struct virtual_v1_dwo_sections sections;
9693 void **dwo_file_slot;
9694 char *virtual_dwo_name;
9695 struct dwarf2_section_info *cutu;
9696 struct cleanup *cleanups;
9699 gdb_assert (dwp_file->version == 1);
9701 if (dwarf2_read_debug)
9703 fprintf_unfiltered (gdb_stdlog, "Reading %s %s/%s in DWP V1 file: %s\n",
9705 pulongest (unit_index), hex_string (signature),
9709 /* Fetch the sections of this DWO unit.
9710 Put a limit on the number of sections we look for so that bad data
9711 doesn't cause us to loop forever. */
9713 #define MAX_NR_V1_DWO_SECTIONS \
9714 (1 /* .debug_info or .debug_types */ \
9715 + 1 /* .debug_abbrev */ \
9716 + 1 /* .debug_line */ \
9717 + 1 /* .debug_loc */ \
9718 + 1 /* .debug_str_offsets */ \
9719 + 1 /* .debug_macro or .debug_macinfo */ \
9720 + 1 /* trailing zero */)
9722 memset (§ions, 0, sizeof (sections));
9723 cleanups = make_cleanup (null_cleanup, 0);
9725 for (i = 0; i < MAX_NR_V1_DWO_SECTIONS; ++i)
9728 uint32_t section_nr =
9730 dwp_htab->section_pool.v1.indices
9731 + (unit_index + i) * sizeof (uint32_t));
9733 if (section_nr == 0)
9735 if (section_nr >= dwp_file->num_sections)
9737 error (_("Dwarf Error: bad DWP hash table, section number too large"
9742 sectp = dwp_file->elf_sections[section_nr];
9743 if (! locate_v1_virtual_dwo_sections (sectp, §ions))
9745 error (_("Dwarf Error: bad DWP hash table, invalid section found"
9752 || dwarf2_section_empty_p (§ions.info_or_types)
9753 || dwarf2_section_empty_p (§ions.abbrev))
9755 error (_("Dwarf Error: bad DWP hash table, missing DWO sections"
9759 if (i == MAX_NR_V1_DWO_SECTIONS)
9761 error (_("Dwarf Error: bad DWP hash table, too many DWO sections"
9766 /* It's easier for the rest of the code if we fake a struct dwo_file and
9767 have dwo_unit "live" in that. At least for now.
9769 The DWP file can be made up of a random collection of CUs and TUs.
9770 However, for each CU + set of TUs that came from the same original DWO
9771 file, we can combine them back into a virtual DWO file to save space
9772 (fewer struct dwo_file objects to allocate). Remember that for really
9773 large apps there can be on the order of 8K CUs and 200K TUs, or more. */
9776 xstrprintf ("virtual-dwo/%d-%d-%d-%d",
9777 get_section_id (§ions.abbrev),
9778 get_section_id (§ions.line),
9779 get_section_id (§ions.loc),
9780 get_section_id (§ions.str_offsets));
9781 make_cleanup (xfree, virtual_dwo_name);
9782 /* Can we use an existing virtual DWO file? */
9783 dwo_file_slot = lookup_dwo_file_slot (virtual_dwo_name, comp_dir);
9784 /* Create one if necessary. */
9785 if (*dwo_file_slot == NULL)
9787 if (dwarf2_read_debug)
9789 fprintf_unfiltered (gdb_stdlog, "Creating virtual DWO: %s\n",
9792 dwo_file = OBSTACK_ZALLOC (&objfile->objfile_obstack, struct dwo_file);
9793 dwo_file->dwo_name = obstack_copy0 (&objfile->objfile_obstack,
9795 strlen (virtual_dwo_name));
9796 dwo_file->comp_dir = comp_dir;
9797 dwo_file->sections.abbrev = sections.abbrev;
9798 dwo_file->sections.line = sections.line;
9799 dwo_file->sections.loc = sections.loc;
9800 dwo_file->sections.macinfo = sections.macinfo;
9801 dwo_file->sections.macro = sections.macro;
9802 dwo_file->sections.str_offsets = sections.str_offsets;
9803 /* The "str" section is global to the entire DWP file. */
9804 dwo_file->sections.str = dwp_file->sections.str;
9805 /* The info or types section is assigned below to dwo_unit,
9806 there's no need to record it in dwo_file.
9807 Also, we can't simply record type sections in dwo_file because
9808 we record a pointer into the vector in dwo_unit. As we collect more
9809 types we'll grow the vector and eventually have to reallocate space
9810 for it, invalidating all copies of pointers into the previous
9812 *dwo_file_slot = dwo_file;
9816 if (dwarf2_read_debug)
9818 fprintf_unfiltered (gdb_stdlog, "Using existing virtual DWO: %s\n",
9821 dwo_file = *dwo_file_slot;
9823 do_cleanups (cleanups);
9825 dwo_unit = OBSTACK_ZALLOC (&objfile->objfile_obstack, struct dwo_unit);
9826 dwo_unit->dwo_file = dwo_file;
9827 dwo_unit->signature = signature;
9828 dwo_unit->section = obstack_alloc (&objfile->objfile_obstack,
9829 sizeof (struct dwarf2_section_info));
9830 *dwo_unit->section = sections.info_or_types;
9831 /* dwo_unit->{offset,length,type_offset_in_tu} are set later. */
9836 /* Subroutine of create_dwo_unit_in_dwp_v2 to simplify it.
9837 Given a pointer to the containing section SECTION, and OFFSET,SIZE of the
9838 piece within that section used by a TU/CU, return a virtual section
9839 of just that piece. */
9841 static struct dwarf2_section_info
9842 create_dwp_v2_section (struct dwarf2_section_info *section,
9843 bfd_size_type offset, bfd_size_type size)
9845 struct dwarf2_section_info result;
9848 gdb_assert (section != NULL);
9849 gdb_assert (!section->is_virtual);
9851 memset (&result, 0, sizeof (result));
9852 result.s.containing_section = section;
9853 result.is_virtual = 1;
9858 sectp = get_section_bfd_section (section);
9860 /* Flag an error if the piece denoted by OFFSET,SIZE is outside the
9861 bounds of the real section. This is a pretty-rare event, so just
9862 flag an error (easier) instead of a warning and trying to cope. */
9864 || offset + size > bfd_get_section_size (sectp))
9866 bfd *abfd = sectp->owner;
9868 error (_("Dwarf Error: Bad DWP V2 section info, doesn't fit"
9869 " in section %s [in module %s]"),
9870 sectp ? bfd_section_name (abfd, sectp) : "<unknown>",
9871 objfile_name (dwarf2_per_objfile->objfile));
9874 result.virtual_offset = offset;
9879 /* Create a dwo_unit object for the DWO unit with signature SIGNATURE.
9880 UNIT_INDEX is the index of the DWO unit in the DWP hash table.
9881 COMP_DIR is the DW_AT_comp_dir attribute of the referencing CU.
9882 This is for DWP version 2 files. */
9884 static struct dwo_unit *
9885 create_dwo_unit_in_dwp_v2 (struct dwp_file *dwp_file,
9886 uint32_t unit_index,
9887 const char *comp_dir,
9888 ULONGEST signature, int is_debug_types)
9890 struct objfile *objfile = dwarf2_per_objfile->objfile;
9891 const struct dwp_hash_table *dwp_htab =
9892 is_debug_types ? dwp_file->tus : dwp_file->cus;
9893 bfd *dbfd = dwp_file->dbfd;
9894 const char *kind = is_debug_types ? "TU" : "CU";
9895 struct dwo_file *dwo_file;
9896 struct dwo_unit *dwo_unit;
9897 struct virtual_v2_dwo_sections sections;
9898 void **dwo_file_slot;
9899 char *virtual_dwo_name;
9900 struct dwarf2_section_info *cutu;
9901 struct cleanup *cleanups;
9904 gdb_assert (dwp_file->version == 2);
9906 if (dwarf2_read_debug)
9908 fprintf_unfiltered (gdb_stdlog, "Reading %s %s/%s in DWP V2 file: %s\n",
9910 pulongest (unit_index), hex_string (signature),
9914 /* Fetch the section offsets of this DWO unit. */
9916 memset (§ions, 0, sizeof (sections));
9917 cleanups = make_cleanup (null_cleanup, 0);
9919 for (i = 0; i < dwp_htab->nr_columns; ++i)
9921 uint32_t offset = read_4_bytes (dbfd,
9922 dwp_htab->section_pool.v2.offsets
9923 + (((unit_index - 1) * dwp_htab->nr_columns
9925 * sizeof (uint32_t)));
9926 uint32_t size = read_4_bytes (dbfd,
9927 dwp_htab->section_pool.v2.sizes
9928 + (((unit_index - 1) * dwp_htab->nr_columns
9930 * sizeof (uint32_t)));
9932 switch (dwp_htab->section_pool.v2.section_ids[i])
9936 sections.info_or_types_offset = offset;
9937 sections.info_or_types_size = size;
9939 case DW_SECT_ABBREV:
9940 sections.abbrev_offset = offset;
9941 sections.abbrev_size = size;
9944 sections.line_offset = offset;
9945 sections.line_size = size;
9948 sections.loc_offset = offset;
9949 sections.loc_size = size;
9951 case DW_SECT_STR_OFFSETS:
9952 sections.str_offsets_offset = offset;
9953 sections.str_offsets_size = size;
9955 case DW_SECT_MACINFO:
9956 sections.macinfo_offset = offset;
9957 sections.macinfo_size = size;
9960 sections.macro_offset = offset;
9961 sections.macro_size = size;
9966 /* It's easier for the rest of the code if we fake a struct dwo_file and
9967 have dwo_unit "live" in that. At least for now.
9969 The DWP file can be made up of a random collection of CUs and TUs.
9970 However, for each CU + set of TUs that came from the same original DWO
9971 file, we can combine them back into a virtual DWO file to save space
9972 (fewer struct dwo_file objects to allocate). Remember that for really
9973 large apps there can be on the order of 8K CUs and 200K TUs, or more. */
9976 xstrprintf ("virtual-dwo/%ld-%ld-%ld-%ld",
9977 (long) (sections.abbrev_size ? sections.abbrev_offset : 0),
9978 (long) (sections.line_size ? sections.line_offset : 0),
9979 (long) (sections.loc_size ? sections.loc_offset : 0),
9980 (long) (sections.str_offsets_size
9981 ? sections.str_offsets_offset : 0));
9982 make_cleanup (xfree, virtual_dwo_name);
9983 /* Can we use an existing virtual DWO file? */
9984 dwo_file_slot = lookup_dwo_file_slot (virtual_dwo_name, comp_dir);
9985 /* Create one if necessary. */
9986 if (*dwo_file_slot == NULL)
9988 if (dwarf2_read_debug)
9990 fprintf_unfiltered (gdb_stdlog, "Creating virtual DWO: %s\n",
9993 dwo_file = OBSTACK_ZALLOC (&objfile->objfile_obstack, struct dwo_file);
9994 dwo_file->dwo_name = obstack_copy0 (&objfile->objfile_obstack,
9996 strlen (virtual_dwo_name));
9997 dwo_file->comp_dir = comp_dir;
9998 dwo_file->sections.abbrev =
9999 create_dwp_v2_section (&dwp_file->sections.abbrev,
10000 sections.abbrev_offset, sections.abbrev_size);
10001 dwo_file->sections.line =
10002 create_dwp_v2_section (&dwp_file->sections.line,
10003 sections.line_offset, sections.line_size);
10004 dwo_file->sections.loc =
10005 create_dwp_v2_section (&dwp_file->sections.loc,
10006 sections.loc_offset, sections.loc_size);
10007 dwo_file->sections.macinfo =
10008 create_dwp_v2_section (&dwp_file->sections.macinfo,
10009 sections.macinfo_offset, sections.macinfo_size);
10010 dwo_file->sections.macro =
10011 create_dwp_v2_section (&dwp_file->sections.macro,
10012 sections.macro_offset, sections.macro_size);
10013 dwo_file->sections.str_offsets =
10014 create_dwp_v2_section (&dwp_file->sections.str_offsets,
10015 sections.str_offsets_offset,
10016 sections.str_offsets_size);
10017 /* The "str" section is global to the entire DWP file. */
10018 dwo_file->sections.str = dwp_file->sections.str;
10019 /* The info or types section is assigned below to dwo_unit,
10020 there's no need to record it in dwo_file.
10021 Also, we can't simply record type sections in dwo_file because
10022 we record a pointer into the vector in dwo_unit. As we collect more
10023 types we'll grow the vector and eventually have to reallocate space
10024 for it, invalidating all copies of pointers into the previous
10026 *dwo_file_slot = dwo_file;
10030 if (dwarf2_read_debug)
10032 fprintf_unfiltered (gdb_stdlog, "Using existing virtual DWO: %s\n",
10035 dwo_file = *dwo_file_slot;
10037 do_cleanups (cleanups);
10039 dwo_unit = OBSTACK_ZALLOC (&objfile->objfile_obstack, struct dwo_unit);
10040 dwo_unit->dwo_file = dwo_file;
10041 dwo_unit->signature = signature;
10042 dwo_unit->section = obstack_alloc (&objfile->objfile_obstack,
10043 sizeof (struct dwarf2_section_info));
10044 *dwo_unit->section = create_dwp_v2_section (is_debug_types
10045 ? &dwp_file->sections.types
10046 : &dwp_file->sections.info,
10047 sections.info_or_types_offset,
10048 sections.info_or_types_size);
10049 /* dwo_unit->{offset,length,type_offset_in_tu} are set later. */
10054 /* Lookup the DWO unit with SIGNATURE in DWP_FILE.
10055 Returns NULL if the signature isn't found. */
10057 static struct dwo_unit *
10058 lookup_dwo_unit_in_dwp (struct dwp_file *dwp_file, const char *comp_dir,
10059 ULONGEST signature, int is_debug_types)
10061 const struct dwp_hash_table *dwp_htab =
10062 is_debug_types ? dwp_file->tus : dwp_file->cus;
10063 bfd *dbfd = dwp_file->dbfd;
10064 uint32_t mask = dwp_htab->nr_slots - 1;
10065 uint32_t hash = signature & mask;
10066 uint32_t hash2 = ((signature >> 32) & mask) | 1;
10069 struct dwo_unit find_dwo_cu, *dwo_cu;
10071 memset (&find_dwo_cu, 0, sizeof (find_dwo_cu));
10072 find_dwo_cu.signature = signature;
10073 slot = htab_find_slot (is_debug_types
10074 ? dwp_file->loaded_tus
10075 : dwp_file->loaded_cus,
10076 &find_dwo_cu, INSERT);
10081 /* Use a for loop so that we don't loop forever on bad debug info. */
10082 for (i = 0; i < dwp_htab->nr_slots; ++i)
10084 ULONGEST signature_in_table;
10086 signature_in_table =
10087 read_8_bytes (dbfd, dwp_htab->hash_table + hash * sizeof (uint64_t));
10088 if (signature_in_table == signature)
10090 uint32_t unit_index =
10091 read_4_bytes (dbfd,
10092 dwp_htab->unit_table + hash * sizeof (uint32_t));
10094 if (dwp_file->version == 1)
10096 *slot = create_dwo_unit_in_dwp_v1 (dwp_file, unit_index,
10097 comp_dir, signature,
10102 *slot = create_dwo_unit_in_dwp_v2 (dwp_file, unit_index,
10103 comp_dir, signature,
10108 if (signature_in_table == 0)
10110 hash = (hash + hash2) & mask;
10113 error (_("Dwarf Error: bad DWP hash table, lookup didn't terminate"
10114 " [in module %s]"),
10118 /* Subroutine of open_dwo_file,open_dwp_file to simplify them.
10119 Open the file specified by FILE_NAME and hand it off to BFD for
10120 preliminary analysis. Return a newly initialized bfd *, which
10121 includes a canonicalized copy of FILE_NAME.
10122 If IS_DWP is TRUE, we're opening a DWP file, otherwise a DWO file.
10123 SEARCH_CWD is true if the current directory is to be searched.
10124 It will be searched before debug-file-directory.
10125 If unable to find/open the file, return NULL.
10126 NOTE: This function is derived from symfile_bfd_open. */
10129 try_open_dwop_file (const char *file_name, int is_dwp, int search_cwd)
10133 char *absolute_name;
10134 /* Blech. OPF_TRY_CWD_FIRST also disables searching the path list if
10135 FILE_NAME contains a '/'. So we can't use it. Instead prepend "."
10136 to debug_file_directory. */
10138 static const char dirname_separator_string[] = { DIRNAME_SEPARATOR, '\0' };
10142 if (*debug_file_directory != '\0')
10143 search_path = concat (".", dirname_separator_string,
10144 debug_file_directory, NULL);
10146 search_path = xstrdup (".");
10149 search_path = xstrdup (debug_file_directory);
10151 flags = OPF_RETURN_REALPATH;
10153 flags |= OPF_SEARCH_IN_PATH;
10154 desc = openp (search_path, flags, file_name,
10155 O_RDONLY | O_BINARY, &absolute_name);
10156 xfree (search_path);
10160 sym_bfd = gdb_bfd_open (absolute_name, gnutarget, desc);
10161 xfree (absolute_name);
10162 if (sym_bfd == NULL)
10164 bfd_set_cacheable (sym_bfd, 1);
10166 if (!bfd_check_format (sym_bfd, bfd_object))
10168 gdb_bfd_unref (sym_bfd); /* This also closes desc. */
10175 /* Try to open DWO file FILE_NAME.
10176 COMP_DIR is the DW_AT_comp_dir attribute.
10177 The result is the bfd handle of the file.
10178 If there is a problem finding or opening the file, return NULL.
10179 Upon success, the canonicalized path of the file is stored in the bfd,
10180 same as symfile_bfd_open. */
10183 open_dwo_file (const char *file_name, const char *comp_dir)
10187 if (IS_ABSOLUTE_PATH (file_name))
10188 return try_open_dwop_file (file_name, 0 /*is_dwp*/, 0 /*search_cwd*/);
10190 /* Before trying the search path, try DWO_NAME in COMP_DIR. */
10192 if (comp_dir != NULL)
10194 char *path_to_try = concat (comp_dir, SLASH_STRING, file_name, NULL);
10196 /* NOTE: If comp_dir is a relative path, this will also try the
10197 search path, which seems useful. */
10198 abfd = try_open_dwop_file (path_to_try, 0 /*is_dwp*/, 1 /*search_cwd*/);
10199 xfree (path_to_try);
10204 /* That didn't work, try debug-file-directory, which, despite its name,
10205 is a list of paths. */
10207 if (*debug_file_directory == '\0')
10210 return try_open_dwop_file (file_name, 0 /*is_dwp*/, 1 /*search_cwd*/);
10213 /* This function is mapped across the sections and remembers the offset and
10214 size of each of the DWO debugging sections we are interested in. */
10217 dwarf2_locate_dwo_sections (bfd *abfd, asection *sectp, void *dwo_sections_ptr)
10219 struct dwo_sections *dwo_sections = dwo_sections_ptr;
10220 const struct dwop_section_names *names = &dwop_section_names;
10222 if (section_is_p (sectp->name, &names->abbrev_dwo))
10224 dwo_sections->abbrev.s.asection = sectp;
10225 dwo_sections->abbrev.size = bfd_get_section_size (sectp);
10227 else if (section_is_p (sectp->name, &names->info_dwo))
10229 dwo_sections->info.s.asection = sectp;
10230 dwo_sections->info.size = bfd_get_section_size (sectp);
10232 else if (section_is_p (sectp->name, &names->line_dwo))
10234 dwo_sections->line.s.asection = sectp;
10235 dwo_sections->line.size = bfd_get_section_size (sectp);
10237 else if (section_is_p (sectp->name, &names->loc_dwo))
10239 dwo_sections->loc.s.asection = sectp;
10240 dwo_sections->loc.size = bfd_get_section_size (sectp);
10242 else if (section_is_p (sectp->name, &names->macinfo_dwo))
10244 dwo_sections->macinfo.s.asection = sectp;
10245 dwo_sections->macinfo.size = bfd_get_section_size (sectp);
10247 else if (section_is_p (sectp->name, &names->macro_dwo))
10249 dwo_sections->macro.s.asection = sectp;
10250 dwo_sections->macro.size = bfd_get_section_size (sectp);
10252 else if (section_is_p (sectp->name, &names->str_dwo))
10254 dwo_sections->str.s.asection = sectp;
10255 dwo_sections->str.size = bfd_get_section_size (sectp);
10257 else if (section_is_p (sectp->name, &names->str_offsets_dwo))
10259 dwo_sections->str_offsets.s.asection = sectp;
10260 dwo_sections->str_offsets.size = bfd_get_section_size (sectp);
10262 else if (section_is_p (sectp->name, &names->types_dwo))
10264 struct dwarf2_section_info type_section;
10266 memset (&type_section, 0, sizeof (type_section));
10267 type_section.s.asection = sectp;
10268 type_section.size = bfd_get_section_size (sectp);
10269 VEC_safe_push (dwarf2_section_info_def, dwo_sections->types,
10274 /* Initialize the use of the DWO file specified by DWO_NAME and referenced
10275 by PER_CU. This is for the non-DWP case.
10276 The result is NULL if DWO_NAME can't be found. */
10278 static struct dwo_file *
10279 open_and_init_dwo_file (struct dwarf2_per_cu_data *per_cu,
10280 const char *dwo_name, const char *comp_dir)
10282 struct objfile *objfile = dwarf2_per_objfile->objfile;
10283 struct dwo_file *dwo_file;
10285 struct cleanup *cleanups;
10287 dbfd = open_dwo_file (dwo_name, comp_dir);
10290 if (dwarf2_read_debug)
10291 fprintf_unfiltered (gdb_stdlog, "DWO file not found: %s\n", dwo_name);
10294 dwo_file = OBSTACK_ZALLOC (&objfile->objfile_obstack, struct dwo_file);
10295 dwo_file->dwo_name = dwo_name;
10296 dwo_file->comp_dir = comp_dir;
10297 dwo_file->dbfd = dbfd;
10299 cleanups = make_cleanup (free_dwo_file_cleanup, dwo_file);
10301 bfd_map_over_sections (dbfd, dwarf2_locate_dwo_sections, &dwo_file->sections);
10303 dwo_file->cu = create_dwo_cu (dwo_file);
10305 dwo_file->tus = create_debug_types_hash_table (dwo_file,
10306 dwo_file->sections.types);
10308 discard_cleanups (cleanups);
10310 if (dwarf2_read_debug)
10311 fprintf_unfiltered (gdb_stdlog, "DWO file found: %s\n", dwo_name);
10316 /* This function is mapped across the sections and remembers the offset and
10317 size of each of the DWP debugging sections common to version 1 and 2 that
10318 we are interested in. */
10321 dwarf2_locate_common_dwp_sections (bfd *abfd, asection *sectp,
10322 void *dwp_file_ptr)
10324 struct dwp_file *dwp_file = dwp_file_ptr;
10325 const struct dwop_section_names *names = &dwop_section_names;
10326 unsigned int elf_section_nr = elf_section_data (sectp)->this_idx;
10328 /* Record the ELF section number for later lookup: this is what the
10329 .debug_cu_index,.debug_tu_index tables use in DWP V1. */
10330 gdb_assert (elf_section_nr < dwp_file->num_sections);
10331 dwp_file->elf_sections[elf_section_nr] = sectp;
10333 /* Look for specific sections that we need. */
10334 if (section_is_p (sectp->name, &names->str_dwo))
10336 dwp_file->sections.str.s.asection = sectp;
10337 dwp_file->sections.str.size = bfd_get_section_size (sectp);
10339 else if (section_is_p (sectp->name, &names->cu_index))
10341 dwp_file->sections.cu_index.s.asection = sectp;
10342 dwp_file->sections.cu_index.size = bfd_get_section_size (sectp);
10344 else if (section_is_p (sectp->name, &names->tu_index))
10346 dwp_file->sections.tu_index.s.asection = sectp;
10347 dwp_file->sections.tu_index.size = bfd_get_section_size (sectp);
10351 /* This function is mapped across the sections and remembers the offset and
10352 size of each of the DWP version 2 debugging sections that we are interested
10353 in. This is split into a separate function because we don't know if we
10354 have version 1 or 2 until we parse the cu_index/tu_index sections. */
10357 dwarf2_locate_v2_dwp_sections (bfd *abfd, asection *sectp, void *dwp_file_ptr)
10359 struct dwp_file *dwp_file = dwp_file_ptr;
10360 const struct dwop_section_names *names = &dwop_section_names;
10361 unsigned int elf_section_nr = elf_section_data (sectp)->this_idx;
10363 /* Record the ELF section number for later lookup: this is what the
10364 .debug_cu_index,.debug_tu_index tables use in DWP V1. */
10365 gdb_assert (elf_section_nr < dwp_file->num_sections);
10366 dwp_file->elf_sections[elf_section_nr] = sectp;
10368 /* Look for specific sections that we need. */
10369 if (section_is_p (sectp->name, &names->abbrev_dwo))
10371 dwp_file->sections.abbrev.s.asection = sectp;
10372 dwp_file->sections.abbrev.size = bfd_get_section_size (sectp);
10374 else if (section_is_p (sectp->name, &names->info_dwo))
10376 dwp_file->sections.info.s.asection = sectp;
10377 dwp_file->sections.info.size = bfd_get_section_size (sectp);
10379 else if (section_is_p (sectp->name, &names->line_dwo))
10381 dwp_file->sections.line.s.asection = sectp;
10382 dwp_file->sections.line.size = bfd_get_section_size (sectp);
10384 else if (section_is_p (sectp->name, &names->loc_dwo))
10386 dwp_file->sections.loc.s.asection = sectp;
10387 dwp_file->sections.loc.size = bfd_get_section_size (sectp);
10389 else if (section_is_p (sectp->name, &names->macinfo_dwo))
10391 dwp_file->sections.macinfo.s.asection = sectp;
10392 dwp_file->sections.macinfo.size = bfd_get_section_size (sectp);
10394 else if (section_is_p (sectp->name, &names->macro_dwo))
10396 dwp_file->sections.macro.s.asection = sectp;
10397 dwp_file->sections.macro.size = bfd_get_section_size (sectp);
10399 else if (section_is_p (sectp->name, &names->str_offsets_dwo))
10401 dwp_file->sections.str_offsets.s.asection = sectp;
10402 dwp_file->sections.str_offsets.size = bfd_get_section_size (sectp);
10404 else if (section_is_p (sectp->name, &names->types_dwo))
10406 dwp_file->sections.types.s.asection = sectp;
10407 dwp_file->sections.types.size = bfd_get_section_size (sectp);
10411 /* Hash function for dwp_file loaded CUs/TUs. */
10414 hash_dwp_loaded_cutus (const void *item)
10416 const struct dwo_unit *dwo_unit = item;
10418 /* This drops the top 32 bits of the signature, but is ok for a hash. */
10419 return dwo_unit->signature;
10422 /* Equality function for dwp_file loaded CUs/TUs. */
10425 eq_dwp_loaded_cutus (const void *a, const void *b)
10427 const struct dwo_unit *dua = a;
10428 const struct dwo_unit *dub = b;
10430 return dua->signature == dub->signature;
10433 /* Allocate a hash table for dwp_file loaded CUs/TUs. */
10436 allocate_dwp_loaded_cutus_table (struct objfile *objfile)
10438 return htab_create_alloc_ex (3,
10439 hash_dwp_loaded_cutus,
10440 eq_dwp_loaded_cutus,
10442 &objfile->objfile_obstack,
10443 hashtab_obstack_allocate,
10444 dummy_obstack_deallocate);
10447 /* Try to open DWP file FILE_NAME.
10448 The result is the bfd handle of the file.
10449 If there is a problem finding or opening the file, return NULL.
10450 Upon success, the canonicalized path of the file is stored in the bfd,
10451 same as symfile_bfd_open. */
10454 open_dwp_file (const char *file_name)
10458 abfd = try_open_dwop_file (file_name, 1 /*is_dwp*/, 1 /*search_cwd*/);
10462 /* Work around upstream bug 15652.
10463 http://sourceware.org/bugzilla/show_bug.cgi?id=15652
10464 [Whether that's a "bug" is debatable, but it is getting in our way.]
10465 We have no real idea where the dwp file is, because gdb's realpath-ing
10466 of the executable's path may have discarded the needed info.
10467 [IWBN if the dwp file name was recorded in the executable, akin to
10468 .gnu_debuglink, but that doesn't exist yet.]
10469 Strip the directory from FILE_NAME and search again. */
10470 if (*debug_file_directory != '\0')
10472 /* Don't implicitly search the current directory here.
10473 If the user wants to search "." to handle this case,
10474 it must be added to debug-file-directory. */
10475 return try_open_dwop_file (lbasename (file_name), 1 /*is_dwp*/,
10482 /* Initialize the use of the DWP file for the current objfile.
10483 By convention the name of the DWP file is ${objfile}.dwp.
10484 The result is NULL if it can't be found. */
10486 static struct dwp_file *
10487 open_and_init_dwp_file (void)
10489 struct objfile *objfile = dwarf2_per_objfile->objfile;
10490 struct dwp_file *dwp_file;
10493 struct cleanup *cleanups;
10495 /* Try to find first .dwp for the binary file before any symbolic links
10497 dwp_name = xstrprintf ("%s.dwp", objfile->original_name);
10498 cleanups = make_cleanup (xfree, dwp_name);
10500 dbfd = open_dwp_file (dwp_name);
10502 && strcmp (objfile->original_name, objfile_name (objfile)) != 0)
10504 /* Try to find .dwp for the binary file after gdb_realpath resolving. */
10505 dwp_name = xstrprintf ("%s.dwp", objfile_name (objfile));
10506 make_cleanup (xfree, dwp_name);
10507 dbfd = open_dwp_file (dwp_name);
10512 if (dwarf2_read_debug)
10513 fprintf_unfiltered (gdb_stdlog, "DWP file not found: %s\n", dwp_name);
10514 do_cleanups (cleanups);
10517 dwp_file = OBSTACK_ZALLOC (&objfile->objfile_obstack, struct dwp_file);
10518 dwp_file->name = bfd_get_filename (dbfd);
10519 dwp_file->dbfd = dbfd;
10520 do_cleanups (cleanups);
10522 /* +1: section 0 is unused */
10523 dwp_file->num_sections = bfd_count_sections (dbfd) + 1;
10524 dwp_file->elf_sections =
10525 OBSTACK_CALLOC (&objfile->objfile_obstack,
10526 dwp_file->num_sections, asection *);
10528 bfd_map_over_sections (dbfd, dwarf2_locate_common_dwp_sections, dwp_file);
10530 dwp_file->cus = create_dwp_hash_table (dwp_file, 0);
10532 dwp_file->tus = create_dwp_hash_table (dwp_file, 1);
10534 /* The DWP file version is stored in the hash table. Oh well. */
10535 if (dwp_file->cus->version != dwp_file->tus->version)
10537 /* Technically speaking, we should try to limp along, but this is
10539 error (_("Dwarf Error: DWP file CU version %d doesn't match"
10540 " TU version %d [in DWP file %s]"),
10541 dwp_file->cus->version, dwp_file->tus->version, dwp_name);
10543 dwp_file->version = dwp_file->cus->version;
10545 if (dwp_file->version == 2)
10546 bfd_map_over_sections (dbfd, dwarf2_locate_v2_dwp_sections, dwp_file);
10548 dwp_file->loaded_cus = allocate_dwp_loaded_cutus_table (objfile);
10549 dwp_file->loaded_tus = allocate_dwp_loaded_cutus_table (objfile);
10551 if (dwarf2_read_debug)
10553 fprintf_unfiltered (gdb_stdlog, "DWP file found: %s\n", dwp_file->name);
10554 fprintf_unfiltered (gdb_stdlog,
10555 " %s CUs, %s TUs\n",
10556 pulongest (dwp_file->cus ? dwp_file->cus->nr_units : 0),
10557 pulongest (dwp_file->tus ? dwp_file->tus->nr_units : 0));
10563 /* Wrapper around open_and_init_dwp_file, only open it once. */
10565 static struct dwp_file *
10566 get_dwp_file (void)
10568 if (! dwarf2_per_objfile->dwp_checked)
10570 dwarf2_per_objfile->dwp_file = open_and_init_dwp_file ();
10571 dwarf2_per_objfile->dwp_checked = 1;
10573 return dwarf2_per_objfile->dwp_file;
10576 /* Subroutine of lookup_dwo_comp_unit, lookup_dwo_type_unit.
10577 Look up the CU/TU with signature SIGNATURE, either in DWO file DWO_NAME
10578 or in the DWP file for the objfile, referenced by THIS_UNIT.
10579 If non-NULL, comp_dir is the DW_AT_comp_dir attribute.
10580 IS_DEBUG_TYPES is non-zero if reading a TU, otherwise read a CU.
10582 This is called, for example, when wanting to read a variable with a
10583 complex location. Therefore we don't want to do file i/o for every call.
10584 Therefore we don't want to look for a DWO file on every call.
10585 Therefore we first see if we've already seen SIGNATURE in a DWP file,
10586 then we check if we've already seen DWO_NAME, and only THEN do we check
10589 The result is a pointer to the dwo_unit object or NULL if we didn't find it
10590 (dwo_id mismatch or couldn't find the DWO/DWP file). */
10592 static struct dwo_unit *
10593 lookup_dwo_cutu (struct dwarf2_per_cu_data *this_unit,
10594 const char *dwo_name, const char *comp_dir,
10595 ULONGEST signature, int is_debug_types)
10597 struct objfile *objfile = dwarf2_per_objfile->objfile;
10598 const char *kind = is_debug_types ? "TU" : "CU";
10599 void **dwo_file_slot;
10600 struct dwo_file *dwo_file;
10601 struct dwp_file *dwp_file;
10603 /* First see if there's a DWP file.
10604 If we have a DWP file but didn't find the DWO inside it, don't
10605 look for the original DWO file. It makes gdb behave differently
10606 depending on whether one is debugging in the build tree. */
10608 dwp_file = get_dwp_file ();
10609 if (dwp_file != NULL)
10611 const struct dwp_hash_table *dwp_htab =
10612 is_debug_types ? dwp_file->tus : dwp_file->cus;
10614 if (dwp_htab != NULL)
10616 struct dwo_unit *dwo_cutu =
10617 lookup_dwo_unit_in_dwp (dwp_file, comp_dir,
10618 signature, is_debug_types);
10620 if (dwo_cutu != NULL)
10622 if (dwarf2_read_debug)
10624 fprintf_unfiltered (gdb_stdlog,
10625 "Virtual DWO %s %s found: @%s\n",
10626 kind, hex_string (signature),
10627 host_address_to_string (dwo_cutu));
10635 /* No DWP file, look for the DWO file. */
10637 dwo_file_slot = lookup_dwo_file_slot (dwo_name, comp_dir);
10638 if (*dwo_file_slot == NULL)
10640 /* Read in the file and build a table of the CUs/TUs it contains. */
10641 *dwo_file_slot = open_and_init_dwo_file (this_unit, dwo_name, comp_dir);
10643 /* NOTE: This will be NULL if unable to open the file. */
10644 dwo_file = *dwo_file_slot;
10646 if (dwo_file != NULL)
10648 struct dwo_unit *dwo_cutu = NULL;
10650 if (is_debug_types && dwo_file->tus)
10652 struct dwo_unit find_dwo_cutu;
10654 memset (&find_dwo_cutu, 0, sizeof (find_dwo_cutu));
10655 find_dwo_cutu.signature = signature;
10656 dwo_cutu = htab_find (dwo_file->tus, &find_dwo_cutu);
10658 else if (!is_debug_types && dwo_file->cu)
10660 if (signature == dwo_file->cu->signature)
10661 dwo_cutu = dwo_file->cu;
10664 if (dwo_cutu != NULL)
10666 if (dwarf2_read_debug)
10668 fprintf_unfiltered (gdb_stdlog, "DWO %s %s(%s) found: @%s\n",
10669 kind, dwo_name, hex_string (signature),
10670 host_address_to_string (dwo_cutu));
10677 /* We didn't find it. This could mean a dwo_id mismatch, or
10678 someone deleted the DWO/DWP file, or the search path isn't set up
10679 correctly to find the file. */
10681 if (dwarf2_read_debug)
10683 fprintf_unfiltered (gdb_stdlog, "DWO %s %s(%s) not found\n",
10684 kind, dwo_name, hex_string (signature));
10687 /* This is a warning and not a complaint because it can be caused by
10688 pilot error (e.g., user accidentally deleting the DWO). */
10690 /* Print the name of the DWP file if we looked there, helps the user
10691 better diagnose the problem. */
10692 char *dwp_text = NULL;
10693 struct cleanup *cleanups;
10695 if (dwp_file != NULL)
10696 dwp_text = xstrprintf (" [in DWP file %s]", lbasename (dwp_file->name));
10697 cleanups = make_cleanup (xfree, dwp_text);
10699 warning (_("Could not find DWO %s %s(%s)%s referenced by %s at offset 0x%x"
10700 " [in module %s]"),
10701 kind, dwo_name, hex_string (signature),
10702 dwp_text != NULL ? dwp_text : "",
10703 this_unit->is_debug_types ? "TU" : "CU",
10704 this_unit->offset.sect_off, objfile_name (objfile));
10706 do_cleanups (cleanups);
10711 /* Lookup the DWO CU DWO_NAME/SIGNATURE referenced from THIS_CU.
10712 See lookup_dwo_cutu_unit for details. */
10714 static struct dwo_unit *
10715 lookup_dwo_comp_unit (struct dwarf2_per_cu_data *this_cu,
10716 const char *dwo_name, const char *comp_dir,
10717 ULONGEST signature)
10719 return lookup_dwo_cutu (this_cu, dwo_name, comp_dir, signature, 0);
10722 /* Lookup the DWO TU DWO_NAME/SIGNATURE referenced from THIS_TU.
10723 See lookup_dwo_cutu_unit for details. */
10725 static struct dwo_unit *
10726 lookup_dwo_type_unit (struct signatured_type *this_tu,
10727 const char *dwo_name, const char *comp_dir)
10729 return lookup_dwo_cutu (&this_tu->per_cu, dwo_name, comp_dir, this_tu->signature, 1);
10732 /* Traversal function for queue_and_load_all_dwo_tus. */
10735 queue_and_load_dwo_tu (void **slot, void *info)
10737 struct dwo_unit *dwo_unit = (struct dwo_unit *) *slot;
10738 struct dwarf2_per_cu_data *per_cu = (struct dwarf2_per_cu_data *) info;
10739 ULONGEST signature = dwo_unit->signature;
10740 struct signatured_type *sig_type =
10741 lookup_dwo_signatured_type (per_cu->cu, signature);
10743 if (sig_type != NULL)
10745 struct dwarf2_per_cu_data *sig_cu = &sig_type->per_cu;
10747 /* We pass NULL for DEPENDENT_CU because we don't yet know if there's
10748 a real dependency of PER_CU on SIG_TYPE. That is detected later
10749 while processing PER_CU. */
10750 if (maybe_queue_comp_unit (NULL, sig_cu, per_cu->cu->language))
10751 load_full_type_unit (sig_cu);
10752 VEC_safe_push (dwarf2_per_cu_ptr, per_cu->imported_symtabs, sig_cu);
10758 /* Queue all TUs contained in the DWO of PER_CU to be read in.
10759 The DWO may have the only definition of the type, though it may not be
10760 referenced anywhere in PER_CU. Thus we have to load *all* its TUs.
10761 http://sourceware.org/bugzilla/show_bug.cgi?id=15021 */
10764 queue_and_load_all_dwo_tus (struct dwarf2_per_cu_data *per_cu)
10766 struct dwo_unit *dwo_unit;
10767 struct dwo_file *dwo_file;
10769 gdb_assert (!per_cu->is_debug_types);
10770 gdb_assert (get_dwp_file () == NULL);
10771 gdb_assert (per_cu->cu != NULL);
10773 dwo_unit = per_cu->cu->dwo_unit;
10774 gdb_assert (dwo_unit != NULL);
10776 dwo_file = dwo_unit->dwo_file;
10777 if (dwo_file->tus != NULL)
10778 htab_traverse_noresize (dwo_file->tus, queue_and_load_dwo_tu, per_cu);
10781 /* Free all resources associated with DWO_FILE.
10782 Close the DWO file and munmap the sections.
10783 All memory should be on the objfile obstack. */
10786 free_dwo_file (struct dwo_file *dwo_file, struct objfile *objfile)
10789 struct dwarf2_section_info *section;
10791 /* Note: dbfd is NULL for virtual DWO files. */
10792 gdb_bfd_unref (dwo_file->dbfd);
10794 VEC_free (dwarf2_section_info_def, dwo_file->sections.types);
10797 /* Wrapper for free_dwo_file for use in cleanups. */
10800 free_dwo_file_cleanup (void *arg)
10802 struct dwo_file *dwo_file = (struct dwo_file *) arg;
10803 struct objfile *objfile = dwarf2_per_objfile->objfile;
10805 free_dwo_file (dwo_file, objfile);
10808 /* Traversal function for free_dwo_files. */
10811 free_dwo_file_from_slot (void **slot, void *info)
10813 struct dwo_file *dwo_file = (struct dwo_file *) *slot;
10814 struct objfile *objfile = (struct objfile *) info;
10816 free_dwo_file (dwo_file, objfile);
10821 /* Free all resources associated with DWO_FILES. */
10824 free_dwo_files (htab_t dwo_files, struct objfile *objfile)
10826 htab_traverse_noresize (dwo_files, free_dwo_file_from_slot, objfile);
10829 /* Read in various DIEs. */
10831 /* qsort helper for inherit_abstract_dies. */
10834 unsigned_int_compar (const void *ap, const void *bp)
10836 unsigned int a = *(unsigned int *) ap;
10837 unsigned int b = *(unsigned int *) bp;
10839 return (a > b) - (b > a);
10842 /* DW_AT_abstract_origin inherits whole DIEs (not just their attributes).
10843 Inherit only the children of the DW_AT_abstract_origin DIE not being
10844 already referenced by DW_AT_abstract_origin from the children of the
10848 inherit_abstract_dies (struct die_info *die, struct dwarf2_cu *cu)
10850 struct die_info *child_die;
10851 unsigned die_children_count;
10852 /* CU offsets which were referenced by children of the current DIE. */
10853 sect_offset *offsets;
10854 sect_offset *offsets_end, *offsetp;
10855 /* Parent of DIE - referenced by DW_AT_abstract_origin. */
10856 struct die_info *origin_die;
10857 /* Iterator of the ORIGIN_DIE children. */
10858 struct die_info *origin_child_die;
10859 struct cleanup *cleanups;
10860 struct attribute *attr;
10861 struct dwarf2_cu *origin_cu;
10862 struct pending **origin_previous_list_in_scope;
10864 attr = dwarf2_attr (die, DW_AT_abstract_origin, cu);
10868 /* Note that following die references may follow to a die in a
10872 origin_die = follow_die_ref (die, attr, &origin_cu);
10874 /* We're inheriting ORIGIN's children into the scope we'd put DIE's
10876 origin_previous_list_in_scope = origin_cu->list_in_scope;
10877 origin_cu->list_in_scope = cu->list_in_scope;
10879 if (die->tag != origin_die->tag
10880 && !(die->tag == DW_TAG_inlined_subroutine
10881 && origin_die->tag == DW_TAG_subprogram))
10882 complaint (&symfile_complaints,
10883 _("DIE 0x%x and its abstract origin 0x%x have different tags"),
10884 die->offset.sect_off, origin_die->offset.sect_off);
10886 child_die = die->child;
10887 die_children_count = 0;
10888 while (child_die && child_die->tag)
10890 child_die = sibling_die (child_die);
10891 die_children_count++;
10893 offsets = xmalloc (sizeof (*offsets) * die_children_count);
10894 cleanups = make_cleanup (xfree, offsets);
10896 offsets_end = offsets;
10897 child_die = die->child;
10898 while (child_die && child_die->tag)
10900 /* For each CHILD_DIE, find the corresponding child of
10901 ORIGIN_DIE. If there is more than one layer of
10902 DW_AT_abstract_origin, follow them all; there shouldn't be,
10903 but GCC versions at least through 4.4 generate this (GCC PR
10905 struct die_info *child_origin_die = child_die;
10906 struct dwarf2_cu *child_origin_cu = cu;
10910 attr = dwarf2_attr (child_origin_die, DW_AT_abstract_origin,
10914 child_origin_die = follow_die_ref (child_origin_die, attr,
10918 /* According to DWARF3 3.3.8.2 #3 new entries without their abstract
10919 counterpart may exist. */
10920 if (child_origin_die != child_die)
10922 if (child_die->tag != child_origin_die->tag
10923 && !(child_die->tag == DW_TAG_inlined_subroutine
10924 && child_origin_die->tag == DW_TAG_subprogram))
10925 complaint (&symfile_complaints,
10926 _("Child DIE 0x%x and its abstract origin 0x%x have "
10927 "different tags"), child_die->offset.sect_off,
10928 child_origin_die->offset.sect_off);
10929 if (child_origin_die->parent != origin_die)
10930 complaint (&symfile_complaints,
10931 _("Child DIE 0x%x and its abstract origin 0x%x have "
10932 "different parents"), child_die->offset.sect_off,
10933 child_origin_die->offset.sect_off);
10935 *offsets_end++ = child_origin_die->offset;
10937 child_die = sibling_die (child_die);
10939 qsort (offsets, offsets_end - offsets, sizeof (*offsets),
10940 unsigned_int_compar);
10941 for (offsetp = offsets + 1; offsetp < offsets_end; offsetp++)
10942 if (offsetp[-1].sect_off == offsetp->sect_off)
10943 complaint (&symfile_complaints,
10944 _("Multiple children of DIE 0x%x refer "
10945 "to DIE 0x%x as their abstract origin"),
10946 die->offset.sect_off, offsetp->sect_off);
10949 origin_child_die = origin_die->child;
10950 while (origin_child_die && origin_child_die->tag)
10952 /* Is ORIGIN_CHILD_DIE referenced by any of the DIE children? */
10953 while (offsetp < offsets_end
10954 && offsetp->sect_off < origin_child_die->offset.sect_off)
10956 if (offsetp >= offsets_end
10957 || offsetp->sect_off > origin_child_die->offset.sect_off)
10959 /* Found that ORIGIN_CHILD_DIE is really not referenced. */
10960 process_die (origin_child_die, origin_cu);
10962 origin_child_die = sibling_die (origin_child_die);
10964 origin_cu->list_in_scope = origin_previous_list_in_scope;
10966 do_cleanups (cleanups);
10970 read_func_scope (struct die_info *die, struct dwarf2_cu *cu)
10972 struct objfile *objfile = cu->objfile;
10973 struct context_stack *new;
10976 struct die_info *child_die;
10977 struct attribute *attr, *call_line, *call_file;
10979 CORE_ADDR baseaddr;
10980 struct block *block;
10981 int inlined_func = (die->tag == DW_TAG_inlined_subroutine);
10982 VEC (symbolp) *template_args = NULL;
10983 struct template_symbol *templ_func = NULL;
10987 /* If we do not have call site information, we can't show the
10988 caller of this inlined function. That's too confusing, so
10989 only use the scope for local variables. */
10990 call_line = dwarf2_attr (die, DW_AT_call_line, cu);
10991 call_file = dwarf2_attr (die, DW_AT_call_file, cu);
10992 if (call_line == NULL || call_file == NULL)
10994 read_lexical_block_scope (die, cu);
10999 baseaddr = ANOFFSET (objfile->section_offsets, SECT_OFF_TEXT (objfile));
11001 name = dwarf2_name (die, cu);
11003 /* Ignore functions with missing or empty names. These are actually
11004 illegal according to the DWARF standard. */
11007 complaint (&symfile_complaints,
11008 _("missing name for subprogram DIE at %d"),
11009 die->offset.sect_off);
11013 /* Ignore functions with missing or invalid low and high pc attributes. */
11014 if (!dwarf2_get_pc_bounds (die, &lowpc, &highpc, cu, NULL))
11016 attr = dwarf2_attr (die, DW_AT_external, cu);
11017 if (!attr || !DW_UNSND (attr))
11018 complaint (&symfile_complaints,
11019 _("cannot get low and high bounds "
11020 "for subprogram DIE at %d"),
11021 die->offset.sect_off);
11026 highpc += baseaddr;
11028 /* If we have any template arguments, then we must allocate a
11029 different sort of symbol. */
11030 for (child_die = die->child; child_die; child_die = sibling_die (child_die))
11032 if (child_die->tag == DW_TAG_template_type_param
11033 || child_die->tag == DW_TAG_template_value_param)
11035 templ_func = allocate_template_symbol (objfile);
11036 templ_func->base.is_cplus_template_function = 1;
11041 new = push_context (0, lowpc);
11042 new->name = new_symbol_full (die, read_type_die (die, cu), cu,
11043 (struct symbol *) templ_func);
11045 /* If there is a location expression for DW_AT_frame_base, record
11047 attr = dwarf2_attr (die, DW_AT_frame_base, cu);
11049 dwarf2_symbol_mark_computed (attr, new->name, cu, 1);
11051 cu->list_in_scope = &local_symbols;
11053 if (die->child != NULL)
11055 child_die = die->child;
11056 while (child_die && child_die->tag)
11058 if (child_die->tag == DW_TAG_template_type_param
11059 || child_die->tag == DW_TAG_template_value_param)
11061 struct symbol *arg = new_symbol (child_die, NULL, cu);
11064 VEC_safe_push (symbolp, template_args, arg);
11067 process_die (child_die, cu);
11068 child_die = sibling_die (child_die);
11072 inherit_abstract_dies (die, cu);
11074 /* If we have a DW_AT_specification, we might need to import using
11075 directives from the context of the specification DIE. See the
11076 comment in determine_prefix. */
11077 if (cu->language == language_cplus
11078 && dwarf2_attr (die, DW_AT_specification, cu))
11080 struct dwarf2_cu *spec_cu = cu;
11081 struct die_info *spec_die = die_specification (die, &spec_cu);
11085 child_die = spec_die->child;
11086 while (child_die && child_die->tag)
11088 if (child_die->tag == DW_TAG_imported_module)
11089 process_die (child_die, spec_cu);
11090 child_die = sibling_die (child_die);
11093 /* In some cases, GCC generates specification DIEs that
11094 themselves contain DW_AT_specification attributes. */
11095 spec_die = die_specification (spec_die, &spec_cu);
11099 new = pop_context ();
11100 /* Make a block for the local symbols within. */
11101 block = finish_block (new->name, &local_symbols, new->old_blocks,
11102 lowpc, highpc, objfile);
11104 /* For C++, set the block's scope. */
11105 if ((cu->language == language_cplus || cu->language == language_fortran)
11106 && cu->processing_has_namespace_info)
11107 block_set_scope (block, determine_prefix (die, cu),
11108 &objfile->objfile_obstack);
11110 /* If we have address ranges, record them. */
11111 dwarf2_record_block_ranges (die, block, baseaddr, cu);
11113 /* Attach template arguments to function. */
11114 if (! VEC_empty (symbolp, template_args))
11116 gdb_assert (templ_func != NULL);
11118 templ_func->n_template_arguments = VEC_length (symbolp, template_args);
11119 templ_func->template_arguments
11120 = obstack_alloc (&objfile->objfile_obstack,
11121 (templ_func->n_template_arguments
11122 * sizeof (struct symbol *)));
11123 memcpy (templ_func->template_arguments,
11124 VEC_address (symbolp, template_args),
11125 (templ_func->n_template_arguments * sizeof (struct symbol *)));
11126 VEC_free (symbolp, template_args);
11129 /* In C++, we can have functions nested inside functions (e.g., when
11130 a function declares a class that has methods). This means that
11131 when we finish processing a function scope, we may need to go
11132 back to building a containing block's symbol lists. */
11133 local_symbols = new->locals;
11134 using_directives = new->using_directives;
11136 /* If we've finished processing a top-level function, subsequent
11137 symbols go in the file symbol list. */
11138 if (outermost_context_p ())
11139 cu->list_in_scope = &file_symbols;
11142 /* Process all the DIES contained within a lexical block scope. Start
11143 a new scope, process the dies, and then close the scope. */
11146 read_lexical_block_scope (struct die_info *die, struct dwarf2_cu *cu)
11148 struct objfile *objfile = cu->objfile;
11149 struct context_stack *new;
11150 CORE_ADDR lowpc, highpc;
11151 struct die_info *child_die;
11152 CORE_ADDR baseaddr;
11154 baseaddr = ANOFFSET (objfile->section_offsets, SECT_OFF_TEXT (objfile));
11156 /* Ignore blocks with missing or invalid low and high pc attributes. */
11157 /* ??? Perhaps consider discontiguous blocks defined by DW_AT_ranges
11158 as multiple lexical blocks? Handling children in a sane way would
11159 be nasty. Might be easier to properly extend generic blocks to
11160 describe ranges. */
11161 if (!dwarf2_get_pc_bounds (die, &lowpc, &highpc, cu, NULL))
11164 highpc += baseaddr;
11166 push_context (0, lowpc);
11167 if (die->child != NULL)
11169 child_die = die->child;
11170 while (child_die && child_die->tag)
11172 process_die (child_die, cu);
11173 child_die = sibling_die (child_die);
11176 new = pop_context ();
11178 if (local_symbols != NULL || using_directives != NULL)
11180 struct block *block
11181 = finish_block (0, &local_symbols, new->old_blocks, new->start_addr,
11184 /* Note that recording ranges after traversing children, as we
11185 do here, means that recording a parent's ranges entails
11186 walking across all its children's ranges as they appear in
11187 the address map, which is quadratic behavior.
11189 It would be nicer to record the parent's ranges before
11190 traversing its children, simply overriding whatever you find
11191 there. But since we don't even decide whether to create a
11192 block until after we've traversed its children, that's hard
11194 dwarf2_record_block_ranges (die, block, baseaddr, cu);
11196 local_symbols = new->locals;
11197 using_directives = new->using_directives;
11200 /* Read in DW_TAG_GNU_call_site and insert it to CU->call_site_htab. */
11203 read_call_site_scope (struct die_info *die, struct dwarf2_cu *cu)
11205 struct objfile *objfile = cu->objfile;
11206 struct gdbarch *gdbarch = get_objfile_arch (objfile);
11207 CORE_ADDR pc, baseaddr;
11208 struct attribute *attr;
11209 struct call_site *call_site, call_site_local;
11212 struct die_info *child_die;
11214 baseaddr = ANOFFSET (objfile->section_offsets, SECT_OFF_TEXT (objfile));
11216 attr = dwarf2_attr (die, DW_AT_low_pc, cu);
11219 complaint (&symfile_complaints,
11220 _("missing DW_AT_low_pc for DW_TAG_GNU_call_site "
11221 "DIE 0x%x [in module %s]"),
11222 die->offset.sect_off, objfile_name (objfile));
11225 pc = DW_ADDR (attr) + baseaddr;
11227 if (cu->call_site_htab == NULL)
11228 cu->call_site_htab = htab_create_alloc_ex (16, core_addr_hash, core_addr_eq,
11229 NULL, &objfile->objfile_obstack,
11230 hashtab_obstack_allocate, NULL);
11231 call_site_local.pc = pc;
11232 slot = htab_find_slot (cu->call_site_htab, &call_site_local, INSERT);
11235 complaint (&symfile_complaints,
11236 _("Duplicate PC %s for DW_TAG_GNU_call_site "
11237 "DIE 0x%x [in module %s]"),
11238 paddress (gdbarch, pc), die->offset.sect_off,
11239 objfile_name (objfile));
11243 /* Count parameters at the caller. */
11246 for (child_die = die->child; child_die && child_die->tag;
11247 child_die = sibling_die (child_die))
11249 if (child_die->tag != DW_TAG_GNU_call_site_parameter)
11251 complaint (&symfile_complaints,
11252 _("Tag %d is not DW_TAG_GNU_call_site_parameter in "
11253 "DW_TAG_GNU_call_site child DIE 0x%x [in module %s]"),
11254 child_die->tag, child_die->offset.sect_off,
11255 objfile_name (objfile));
11262 call_site = obstack_alloc (&objfile->objfile_obstack,
11263 (sizeof (*call_site)
11264 + (sizeof (*call_site->parameter)
11265 * (nparams - 1))));
11267 memset (call_site, 0, sizeof (*call_site) - sizeof (*call_site->parameter));
11268 call_site->pc = pc;
11270 if (dwarf2_flag_true_p (die, DW_AT_GNU_tail_call, cu))
11272 struct die_info *func_die;
11274 /* Skip also over DW_TAG_inlined_subroutine. */
11275 for (func_die = die->parent;
11276 func_die && func_die->tag != DW_TAG_subprogram
11277 && func_die->tag != DW_TAG_subroutine_type;
11278 func_die = func_die->parent);
11280 /* DW_AT_GNU_all_call_sites is a superset
11281 of DW_AT_GNU_all_tail_call_sites. */
11283 && !dwarf2_flag_true_p (func_die, DW_AT_GNU_all_call_sites, cu)
11284 && !dwarf2_flag_true_p (func_die, DW_AT_GNU_all_tail_call_sites, cu))
11286 /* TYPE_TAIL_CALL_LIST is not interesting in functions where it is
11287 not complete. But keep CALL_SITE for look ups via call_site_htab,
11288 both the initial caller containing the real return address PC and
11289 the final callee containing the current PC of a chain of tail
11290 calls do not need to have the tail call list complete. But any
11291 function candidate for a virtual tail call frame searched via
11292 TYPE_TAIL_CALL_LIST must have the tail call list complete to be
11293 determined unambiguously. */
11297 struct type *func_type = NULL;
11300 func_type = get_die_type (func_die, cu);
11301 if (func_type != NULL)
11303 gdb_assert (TYPE_CODE (func_type) == TYPE_CODE_FUNC);
11305 /* Enlist this call site to the function. */
11306 call_site->tail_call_next = TYPE_TAIL_CALL_LIST (func_type);
11307 TYPE_TAIL_CALL_LIST (func_type) = call_site;
11310 complaint (&symfile_complaints,
11311 _("Cannot find function owning DW_TAG_GNU_call_site "
11312 "DIE 0x%x [in module %s]"),
11313 die->offset.sect_off, objfile_name (objfile));
11317 attr = dwarf2_attr (die, DW_AT_GNU_call_site_target, cu);
11319 attr = dwarf2_attr (die, DW_AT_abstract_origin, cu);
11320 SET_FIELD_DWARF_BLOCK (call_site->target, NULL);
11321 if (!attr || (attr_form_is_block (attr) && DW_BLOCK (attr)->size == 0))
11322 /* Keep NULL DWARF_BLOCK. */;
11323 else if (attr_form_is_block (attr))
11325 struct dwarf2_locexpr_baton *dlbaton;
11327 dlbaton = obstack_alloc (&objfile->objfile_obstack, sizeof (*dlbaton));
11328 dlbaton->data = DW_BLOCK (attr)->data;
11329 dlbaton->size = DW_BLOCK (attr)->size;
11330 dlbaton->per_cu = cu->per_cu;
11332 SET_FIELD_DWARF_BLOCK (call_site->target, dlbaton);
11334 else if (attr_form_is_ref (attr))
11336 struct dwarf2_cu *target_cu = cu;
11337 struct die_info *target_die;
11339 target_die = follow_die_ref (die, attr, &target_cu);
11340 gdb_assert (target_cu->objfile == objfile);
11341 if (die_is_declaration (target_die, target_cu))
11343 const char *target_physname = NULL;
11344 struct attribute *target_attr;
11346 /* Prefer the mangled name; otherwise compute the demangled one. */
11347 target_attr = dwarf2_attr (target_die, DW_AT_linkage_name, target_cu);
11348 if (target_attr == NULL)
11349 target_attr = dwarf2_attr (target_die, DW_AT_MIPS_linkage_name,
11351 if (target_attr != NULL && DW_STRING (target_attr) != NULL)
11352 target_physname = DW_STRING (target_attr);
11354 target_physname = dwarf2_physname (NULL, target_die, target_cu);
11355 if (target_physname == NULL)
11356 complaint (&symfile_complaints,
11357 _("DW_AT_GNU_call_site_target target DIE has invalid "
11358 "physname, for referencing DIE 0x%x [in module %s]"),
11359 die->offset.sect_off, objfile_name (objfile));
11361 SET_FIELD_PHYSNAME (call_site->target, target_physname);
11367 /* DW_AT_entry_pc should be preferred. */
11368 if (!dwarf2_get_pc_bounds (target_die, &lowpc, NULL, target_cu, NULL))
11369 complaint (&symfile_complaints,
11370 _("DW_AT_GNU_call_site_target target DIE has invalid "
11371 "low pc, for referencing DIE 0x%x [in module %s]"),
11372 die->offset.sect_off, objfile_name (objfile));
11374 SET_FIELD_PHYSADDR (call_site->target, lowpc + baseaddr);
11378 complaint (&symfile_complaints,
11379 _("DW_TAG_GNU_call_site DW_AT_GNU_call_site_target is neither "
11380 "block nor reference, for DIE 0x%x [in module %s]"),
11381 die->offset.sect_off, objfile_name (objfile));
11383 call_site->per_cu = cu->per_cu;
11385 for (child_die = die->child;
11386 child_die && child_die->tag;
11387 child_die = sibling_die (child_die))
11389 struct call_site_parameter *parameter;
11390 struct attribute *loc, *origin;
11392 if (child_die->tag != DW_TAG_GNU_call_site_parameter)
11394 /* Already printed the complaint above. */
11398 gdb_assert (call_site->parameter_count < nparams);
11399 parameter = &call_site->parameter[call_site->parameter_count];
11401 /* DW_AT_location specifies the register number or DW_AT_abstract_origin
11402 specifies DW_TAG_formal_parameter. Value of the data assumed for the
11403 register is contained in DW_AT_GNU_call_site_value. */
11405 loc = dwarf2_attr (child_die, DW_AT_location, cu);
11406 origin = dwarf2_attr (child_die, DW_AT_abstract_origin, cu);
11407 if (loc == NULL && origin != NULL && attr_form_is_ref (origin))
11409 sect_offset offset;
11411 parameter->kind = CALL_SITE_PARAMETER_PARAM_OFFSET;
11412 offset = dwarf2_get_ref_die_offset (origin);
11413 if (!offset_in_cu_p (&cu->header, offset))
11415 /* As DW_OP_GNU_parameter_ref uses CU-relative offset this
11416 binding can be done only inside one CU. Such referenced DIE
11417 therefore cannot be even moved to DW_TAG_partial_unit. */
11418 complaint (&symfile_complaints,
11419 _("DW_AT_abstract_origin offset is not in CU for "
11420 "DW_TAG_GNU_call_site child DIE 0x%x "
11422 child_die->offset.sect_off, objfile_name (objfile));
11425 parameter->u.param_offset.cu_off = (offset.sect_off
11426 - cu->header.offset.sect_off);
11428 else if (loc == NULL || origin != NULL || !attr_form_is_block (loc))
11430 complaint (&symfile_complaints,
11431 _("No DW_FORM_block* DW_AT_location for "
11432 "DW_TAG_GNU_call_site child DIE 0x%x [in module %s]"),
11433 child_die->offset.sect_off, objfile_name (objfile));
11438 parameter->u.dwarf_reg = dwarf_block_to_dwarf_reg
11439 (DW_BLOCK (loc)->data, &DW_BLOCK (loc)->data[DW_BLOCK (loc)->size]);
11440 if (parameter->u.dwarf_reg != -1)
11441 parameter->kind = CALL_SITE_PARAMETER_DWARF_REG;
11442 else if (dwarf_block_to_sp_offset (gdbarch, DW_BLOCK (loc)->data,
11443 &DW_BLOCK (loc)->data[DW_BLOCK (loc)->size],
11444 ¶meter->u.fb_offset))
11445 parameter->kind = CALL_SITE_PARAMETER_FB_OFFSET;
11448 complaint (&symfile_complaints,
11449 _("Only single DW_OP_reg or DW_OP_fbreg is supported "
11450 "for DW_FORM_block* DW_AT_location is supported for "
11451 "DW_TAG_GNU_call_site child DIE 0x%x "
11453 child_die->offset.sect_off, objfile_name (objfile));
11458 attr = dwarf2_attr (child_die, DW_AT_GNU_call_site_value, cu);
11459 if (!attr_form_is_block (attr))
11461 complaint (&symfile_complaints,
11462 _("No DW_FORM_block* DW_AT_GNU_call_site_value for "
11463 "DW_TAG_GNU_call_site child DIE 0x%x [in module %s]"),
11464 child_die->offset.sect_off, objfile_name (objfile));
11467 parameter->value = DW_BLOCK (attr)->data;
11468 parameter->value_size = DW_BLOCK (attr)->size;
11470 /* Parameters are not pre-cleared by memset above. */
11471 parameter->data_value = NULL;
11472 parameter->data_value_size = 0;
11473 call_site->parameter_count++;
11475 attr = dwarf2_attr (child_die, DW_AT_GNU_call_site_data_value, cu);
11478 if (!attr_form_is_block (attr))
11479 complaint (&symfile_complaints,
11480 _("No DW_FORM_block* DW_AT_GNU_call_site_data_value for "
11481 "DW_TAG_GNU_call_site child DIE 0x%x [in module %s]"),
11482 child_die->offset.sect_off, objfile_name (objfile));
11485 parameter->data_value = DW_BLOCK (attr)->data;
11486 parameter->data_value_size = DW_BLOCK (attr)->size;
11492 /* Get low and high pc attributes from DW_AT_ranges attribute value OFFSET.
11493 Return 1 if the attributes are present and valid, otherwise, return 0.
11494 If RANGES_PST is not NULL we should setup `objfile->psymtabs_addrmap'. */
11497 dwarf2_ranges_read (unsigned offset, CORE_ADDR *low_return,
11498 CORE_ADDR *high_return, struct dwarf2_cu *cu,
11499 struct partial_symtab *ranges_pst)
11501 struct objfile *objfile = cu->objfile;
11502 struct comp_unit_head *cu_header = &cu->header;
11503 bfd *obfd = objfile->obfd;
11504 unsigned int addr_size = cu_header->addr_size;
11505 CORE_ADDR mask = ~(~(CORE_ADDR)1 << (addr_size * 8 - 1));
11506 /* Base address selection entry. */
11509 unsigned int dummy;
11510 const gdb_byte *buffer;
11514 CORE_ADDR high = 0;
11515 CORE_ADDR baseaddr;
11517 found_base = cu->base_known;
11518 base = cu->base_address;
11520 dwarf2_read_section (objfile, &dwarf2_per_objfile->ranges);
11521 if (offset >= dwarf2_per_objfile->ranges.size)
11523 complaint (&symfile_complaints,
11524 _("Offset %d out of bounds for DW_AT_ranges attribute"),
11528 buffer = dwarf2_per_objfile->ranges.buffer + offset;
11530 /* Read in the largest possible address. */
11531 marker = read_address (obfd, buffer, cu, &dummy);
11532 if ((marker & mask) == mask)
11534 /* If we found the largest possible address, then
11535 read the base address. */
11536 base = read_address (obfd, buffer + addr_size, cu, &dummy);
11537 buffer += 2 * addr_size;
11538 offset += 2 * addr_size;
11544 baseaddr = ANOFFSET (objfile->section_offsets, SECT_OFF_TEXT (objfile));
11548 CORE_ADDR range_beginning, range_end;
11550 range_beginning = read_address (obfd, buffer, cu, &dummy);
11551 buffer += addr_size;
11552 range_end = read_address (obfd, buffer, cu, &dummy);
11553 buffer += addr_size;
11554 offset += 2 * addr_size;
11556 /* An end of list marker is a pair of zero addresses. */
11557 if (range_beginning == 0 && range_end == 0)
11558 /* Found the end of list entry. */
11561 /* Each base address selection entry is a pair of 2 values.
11562 The first is the largest possible address, the second is
11563 the base address. Check for a base address here. */
11564 if ((range_beginning & mask) == mask)
11566 /* If we found the largest possible address, then
11567 read the base address. */
11568 base = read_address (obfd, buffer + addr_size, cu, &dummy);
11575 /* We have no valid base address for the ranges
11577 complaint (&symfile_complaints,
11578 _("Invalid .debug_ranges data (no base address)"));
11582 if (range_beginning > range_end)
11584 /* Inverted range entries are invalid. */
11585 complaint (&symfile_complaints,
11586 _("Invalid .debug_ranges data (inverted range)"));
11590 /* Empty range entries have no effect. */
11591 if (range_beginning == range_end)
11594 range_beginning += base;
11597 /* A not-uncommon case of bad debug info.
11598 Don't pollute the addrmap with bad data. */
11599 if (range_beginning + baseaddr == 0
11600 && !dwarf2_per_objfile->has_section_at_zero)
11602 complaint (&symfile_complaints,
11603 _(".debug_ranges entry has start address of zero"
11604 " [in module %s]"), objfile_name (objfile));
11608 if (ranges_pst != NULL)
11609 addrmap_set_empty (objfile->psymtabs_addrmap,
11610 range_beginning + baseaddr,
11611 range_end - 1 + baseaddr,
11614 /* FIXME: This is recording everything as a low-high
11615 segment of consecutive addresses. We should have a
11616 data structure for discontiguous block ranges
11620 low = range_beginning;
11626 if (range_beginning < low)
11627 low = range_beginning;
11628 if (range_end > high)
11634 /* If the first entry is an end-of-list marker, the range
11635 describes an empty scope, i.e. no instructions. */
11641 *high_return = high;
11645 /* Get low and high pc attributes from a die. Return 1 if the attributes
11646 are present and valid, otherwise, return 0. Return -1 if the range is
11647 discontinuous, i.e. derived from DW_AT_ranges information. */
11650 dwarf2_get_pc_bounds (struct die_info *die, CORE_ADDR *lowpc,
11651 CORE_ADDR *highpc, struct dwarf2_cu *cu,
11652 struct partial_symtab *pst)
11654 struct attribute *attr;
11655 struct attribute *attr_high;
11657 CORE_ADDR high = 0;
11660 attr_high = dwarf2_attr (die, DW_AT_high_pc, cu);
11663 attr = dwarf2_attr (die, DW_AT_low_pc, cu);
11666 low = DW_ADDR (attr);
11667 if (attr_high->form == DW_FORM_addr
11668 || attr_high->form == DW_FORM_GNU_addr_index)
11669 high = DW_ADDR (attr_high);
11671 high = low + DW_UNSND (attr_high);
11674 /* Found high w/o low attribute. */
11677 /* Found consecutive range of addresses. */
11682 attr = dwarf2_attr (die, DW_AT_ranges, cu);
11685 /* DW_AT_ranges_base does not apply to DIEs from the DWO skeleton.
11686 We take advantage of the fact that DW_AT_ranges does not appear
11687 in DW_TAG_compile_unit of DWO files. */
11688 int need_ranges_base = die->tag != DW_TAG_compile_unit;
11689 unsigned int ranges_offset = (DW_UNSND (attr)
11690 + (need_ranges_base
11694 /* Value of the DW_AT_ranges attribute is the offset in the
11695 .debug_ranges section. */
11696 if (!dwarf2_ranges_read (ranges_offset, &low, &high, cu, pst))
11698 /* Found discontinuous range of addresses. */
11703 /* read_partial_die has also the strict LOW < HIGH requirement. */
11707 /* When using the GNU linker, .gnu.linkonce. sections are used to
11708 eliminate duplicate copies of functions and vtables and such.
11709 The linker will arbitrarily choose one and discard the others.
11710 The AT_*_pc values for such functions refer to local labels in
11711 these sections. If the section from that file was discarded, the
11712 labels are not in the output, so the relocs get a value of 0.
11713 If this is a discarded function, mark the pc bounds as invalid,
11714 so that GDB will ignore it. */
11715 if (low == 0 && !dwarf2_per_objfile->has_section_at_zero)
11724 /* Assuming that DIE represents a subprogram DIE or a lexical block, get
11725 its low and high PC addresses. Do nothing if these addresses could not
11726 be determined. Otherwise, set LOWPC to the low address if it is smaller,
11727 and HIGHPC to the high address if greater than HIGHPC. */
11730 dwarf2_get_subprogram_pc_bounds (struct die_info *die,
11731 CORE_ADDR *lowpc, CORE_ADDR *highpc,
11732 struct dwarf2_cu *cu)
11734 CORE_ADDR low, high;
11735 struct die_info *child = die->child;
11737 if (dwarf2_get_pc_bounds (die, &low, &high, cu, NULL))
11739 *lowpc = min (*lowpc, low);
11740 *highpc = max (*highpc, high);
11743 /* If the language does not allow nested subprograms (either inside
11744 subprograms or lexical blocks), we're done. */
11745 if (cu->language != language_ada)
11748 /* Check all the children of the given DIE. If it contains nested
11749 subprograms, then check their pc bounds. Likewise, we need to
11750 check lexical blocks as well, as they may also contain subprogram
11752 while (child && child->tag)
11754 if (child->tag == DW_TAG_subprogram
11755 || child->tag == DW_TAG_lexical_block)
11756 dwarf2_get_subprogram_pc_bounds (child, lowpc, highpc, cu);
11757 child = sibling_die (child);
11761 /* Get the low and high pc's represented by the scope DIE, and store
11762 them in *LOWPC and *HIGHPC. If the correct values can't be
11763 determined, set *LOWPC to -1 and *HIGHPC to 0. */
11766 get_scope_pc_bounds (struct die_info *die,
11767 CORE_ADDR *lowpc, CORE_ADDR *highpc,
11768 struct dwarf2_cu *cu)
11770 CORE_ADDR best_low = (CORE_ADDR) -1;
11771 CORE_ADDR best_high = (CORE_ADDR) 0;
11772 CORE_ADDR current_low, current_high;
11774 if (dwarf2_get_pc_bounds (die, ¤t_low, ¤t_high, cu, NULL))
11776 best_low = current_low;
11777 best_high = current_high;
11781 struct die_info *child = die->child;
11783 while (child && child->tag)
11785 switch (child->tag) {
11786 case DW_TAG_subprogram:
11787 dwarf2_get_subprogram_pc_bounds (child, &best_low, &best_high, cu);
11789 case DW_TAG_namespace:
11790 case DW_TAG_module:
11791 /* FIXME: carlton/2004-01-16: Should we do this for
11792 DW_TAG_class_type/DW_TAG_structure_type, too? I think
11793 that current GCC's always emit the DIEs corresponding
11794 to definitions of methods of classes as children of a
11795 DW_TAG_compile_unit or DW_TAG_namespace (as opposed to
11796 the DIEs giving the declarations, which could be
11797 anywhere). But I don't see any reason why the
11798 standards says that they have to be there. */
11799 get_scope_pc_bounds (child, ¤t_low, ¤t_high, cu);
11801 if (current_low != ((CORE_ADDR) -1))
11803 best_low = min (best_low, current_low);
11804 best_high = max (best_high, current_high);
11812 child = sibling_die (child);
11817 *highpc = best_high;
11820 /* Record the address ranges for BLOCK, offset by BASEADDR, as given
11824 dwarf2_record_block_ranges (struct die_info *die, struct block *block,
11825 CORE_ADDR baseaddr, struct dwarf2_cu *cu)
11827 struct objfile *objfile = cu->objfile;
11828 struct attribute *attr;
11829 struct attribute *attr_high;
11831 attr_high = dwarf2_attr (die, DW_AT_high_pc, cu);
11834 attr = dwarf2_attr (die, DW_AT_low_pc, cu);
11837 CORE_ADDR low = DW_ADDR (attr);
11839 if (attr_high->form == DW_FORM_addr
11840 || attr_high->form == DW_FORM_GNU_addr_index)
11841 high = DW_ADDR (attr_high);
11843 high = low + DW_UNSND (attr_high);
11845 record_block_range (block, baseaddr + low, baseaddr + high - 1);
11849 attr = dwarf2_attr (die, DW_AT_ranges, cu);
11852 bfd *obfd = objfile->obfd;
11853 /* DW_AT_ranges_base does not apply to DIEs from the DWO skeleton.
11854 We take advantage of the fact that DW_AT_ranges does not appear
11855 in DW_TAG_compile_unit of DWO files. */
11856 int need_ranges_base = die->tag != DW_TAG_compile_unit;
11858 /* The value of the DW_AT_ranges attribute is the offset of the
11859 address range list in the .debug_ranges section. */
11860 unsigned long offset = (DW_UNSND (attr)
11861 + (need_ranges_base ? cu->ranges_base : 0));
11862 const gdb_byte *buffer;
11864 /* For some target architectures, but not others, the
11865 read_address function sign-extends the addresses it returns.
11866 To recognize base address selection entries, we need a
11868 unsigned int addr_size = cu->header.addr_size;
11869 CORE_ADDR base_select_mask = ~(~(CORE_ADDR)1 << (addr_size * 8 - 1));
11871 /* The base address, to which the next pair is relative. Note
11872 that this 'base' is a DWARF concept: most entries in a range
11873 list are relative, to reduce the number of relocs against the
11874 debugging information. This is separate from this function's
11875 'baseaddr' argument, which GDB uses to relocate debugging
11876 information from a shared library based on the address at
11877 which the library was loaded. */
11878 CORE_ADDR base = cu->base_address;
11879 int base_known = cu->base_known;
11881 dwarf2_read_section (objfile, &dwarf2_per_objfile->ranges);
11882 if (offset >= dwarf2_per_objfile->ranges.size)
11884 complaint (&symfile_complaints,
11885 _("Offset %lu out of bounds for DW_AT_ranges attribute"),
11889 buffer = dwarf2_per_objfile->ranges.buffer + offset;
11893 unsigned int bytes_read;
11894 CORE_ADDR start, end;
11896 start = read_address (obfd, buffer, cu, &bytes_read);
11897 buffer += bytes_read;
11898 end = read_address (obfd, buffer, cu, &bytes_read);
11899 buffer += bytes_read;
11901 /* Did we find the end of the range list? */
11902 if (start == 0 && end == 0)
11905 /* Did we find a base address selection entry? */
11906 else if ((start & base_select_mask) == base_select_mask)
11912 /* We found an ordinary address range. */
11917 complaint (&symfile_complaints,
11918 _("Invalid .debug_ranges data "
11919 "(no base address)"));
11925 /* Inverted range entries are invalid. */
11926 complaint (&symfile_complaints,
11927 _("Invalid .debug_ranges data "
11928 "(inverted range)"));
11932 /* Empty range entries have no effect. */
11936 start += base + baseaddr;
11937 end += base + baseaddr;
11939 /* A not-uncommon case of bad debug info.
11940 Don't pollute the addrmap with bad data. */
11941 if (start == 0 && !dwarf2_per_objfile->has_section_at_zero)
11943 complaint (&symfile_complaints,
11944 _(".debug_ranges entry has start address of zero"
11945 " [in module %s]"), objfile_name (objfile));
11949 record_block_range (block, start, end - 1);
11955 /* Check whether the producer field indicates either of GCC < 4.6, or the
11956 Intel C/C++ compiler, and cache the result in CU. */
11959 check_producer (struct dwarf2_cu *cu)
11962 int major, minor, release;
11964 if (cu->producer == NULL)
11966 /* For unknown compilers expect their behavior is DWARF version
11969 GCC started to support .debug_types sections by -gdwarf-4 since
11970 gcc-4.5.x. As the .debug_types sections are missing DW_AT_producer
11971 for their space efficiency GDB cannot workaround gcc-4.5.x -gdwarf-4
11972 combination. gcc-4.5.x -gdwarf-4 binaries have DW_AT_accessibility
11973 interpreted incorrectly by GDB now - GCC PR debug/48229. */
11975 else if (strncmp (cu->producer, "GNU ", strlen ("GNU ")) == 0)
11977 /* Skip any identifier after "GNU " - such as "C++" or "Java". */
11979 cs = &cu->producer[strlen ("GNU ")];
11980 while (*cs && !isdigit (*cs))
11982 if (sscanf (cs, "%d.%d.%d", &major, &minor, &release) != 3)
11984 /* Not recognized as GCC. */
11988 cu->producer_is_gxx_lt_4_6 = major < 4 || (major == 4 && minor < 6);
11989 cu->producer_is_gcc_lt_4_3 = major < 4 || (major == 4 && minor < 3);
11992 else if (strncmp (cu->producer, "Intel(R) C", strlen ("Intel(R) C")) == 0)
11993 cu->producer_is_icc = 1;
11996 /* For other non-GCC compilers, expect their behavior is DWARF version
12000 cu->checked_producer = 1;
12003 /* Check for GCC PR debug/45124 fix which is not present in any G++ version up
12004 to 4.5.any while it is present already in G++ 4.6.0 - the PR has been fixed
12005 during 4.6.0 experimental. */
12008 producer_is_gxx_lt_4_6 (struct dwarf2_cu *cu)
12010 if (!cu->checked_producer)
12011 check_producer (cu);
12013 return cu->producer_is_gxx_lt_4_6;
12016 /* Return the default accessibility type if it is not overriden by
12017 DW_AT_accessibility. */
12019 static enum dwarf_access_attribute
12020 dwarf2_default_access_attribute (struct die_info *die, struct dwarf2_cu *cu)
12022 if (cu->header.version < 3 || producer_is_gxx_lt_4_6 (cu))
12024 /* The default DWARF 2 accessibility for members is public, the default
12025 accessibility for inheritance is private. */
12027 if (die->tag != DW_TAG_inheritance)
12028 return DW_ACCESS_public;
12030 return DW_ACCESS_private;
12034 /* DWARF 3+ defines the default accessibility a different way. The same
12035 rules apply now for DW_TAG_inheritance as for the members and it only
12036 depends on the container kind. */
12038 if (die->parent->tag == DW_TAG_class_type)
12039 return DW_ACCESS_private;
12041 return DW_ACCESS_public;
12045 /* Look for DW_AT_data_member_location. Set *OFFSET to the byte
12046 offset. If the attribute was not found return 0, otherwise return
12047 1. If it was found but could not properly be handled, set *OFFSET
12051 handle_data_member_location (struct die_info *die, struct dwarf2_cu *cu,
12054 struct attribute *attr;
12056 attr = dwarf2_attr (die, DW_AT_data_member_location, cu);
12061 /* Note that we do not check for a section offset first here.
12062 This is because DW_AT_data_member_location is new in DWARF 4,
12063 so if we see it, we can assume that a constant form is really
12064 a constant and not a section offset. */
12065 if (attr_form_is_constant (attr))
12066 *offset = dwarf2_get_attr_constant_value (attr, 0);
12067 else if (attr_form_is_section_offset (attr))
12068 dwarf2_complex_location_expr_complaint ();
12069 else if (attr_form_is_block (attr))
12070 *offset = decode_locdesc (DW_BLOCK (attr), cu);
12072 dwarf2_complex_location_expr_complaint ();
12080 /* Add an aggregate field to the field list. */
12083 dwarf2_add_field (struct field_info *fip, struct die_info *die,
12084 struct dwarf2_cu *cu)
12086 struct objfile *objfile = cu->objfile;
12087 struct gdbarch *gdbarch = get_objfile_arch (objfile);
12088 struct nextfield *new_field;
12089 struct attribute *attr;
12091 const char *fieldname = "";
12093 /* Allocate a new field list entry and link it in. */
12094 new_field = (struct nextfield *) xmalloc (sizeof (struct nextfield));
12095 make_cleanup (xfree, new_field);
12096 memset (new_field, 0, sizeof (struct nextfield));
12098 if (die->tag == DW_TAG_inheritance)
12100 new_field->next = fip->baseclasses;
12101 fip->baseclasses = new_field;
12105 new_field->next = fip->fields;
12106 fip->fields = new_field;
12110 attr = dwarf2_attr (die, DW_AT_accessibility, cu);
12112 new_field->accessibility = DW_UNSND (attr);
12114 new_field->accessibility = dwarf2_default_access_attribute (die, cu);
12115 if (new_field->accessibility != DW_ACCESS_public)
12116 fip->non_public_fields = 1;
12118 attr = dwarf2_attr (die, DW_AT_virtuality, cu);
12120 new_field->virtuality = DW_UNSND (attr);
12122 new_field->virtuality = DW_VIRTUALITY_none;
12124 fp = &new_field->field;
12126 if (die->tag == DW_TAG_member && ! die_is_declaration (die, cu))
12130 /* Data member other than a C++ static data member. */
12132 /* Get type of field. */
12133 fp->type = die_type (die, cu);
12135 SET_FIELD_BITPOS (*fp, 0);
12137 /* Get bit size of field (zero if none). */
12138 attr = dwarf2_attr (die, DW_AT_bit_size, cu);
12141 FIELD_BITSIZE (*fp) = DW_UNSND (attr);
12145 FIELD_BITSIZE (*fp) = 0;
12148 /* Get bit offset of field. */
12149 if (handle_data_member_location (die, cu, &offset))
12150 SET_FIELD_BITPOS (*fp, offset * bits_per_byte);
12151 attr = dwarf2_attr (die, DW_AT_bit_offset, cu);
12154 if (gdbarch_bits_big_endian (gdbarch))
12156 /* For big endian bits, the DW_AT_bit_offset gives the
12157 additional bit offset from the MSB of the containing
12158 anonymous object to the MSB of the field. We don't
12159 have to do anything special since we don't need to
12160 know the size of the anonymous object. */
12161 SET_FIELD_BITPOS (*fp, FIELD_BITPOS (*fp) + DW_UNSND (attr));
12165 /* For little endian bits, compute the bit offset to the
12166 MSB of the anonymous object, subtract off the number of
12167 bits from the MSB of the field to the MSB of the
12168 object, and then subtract off the number of bits of
12169 the field itself. The result is the bit offset of
12170 the LSB of the field. */
12171 int anonymous_size;
12172 int bit_offset = DW_UNSND (attr);
12174 attr = dwarf2_attr (die, DW_AT_byte_size, cu);
12177 /* The size of the anonymous object containing
12178 the bit field is explicit, so use the
12179 indicated size (in bytes). */
12180 anonymous_size = DW_UNSND (attr);
12184 /* The size of the anonymous object containing
12185 the bit field must be inferred from the type
12186 attribute of the data member containing the
12188 anonymous_size = TYPE_LENGTH (fp->type);
12190 SET_FIELD_BITPOS (*fp,
12191 (FIELD_BITPOS (*fp)
12192 + anonymous_size * bits_per_byte
12193 - bit_offset - FIELD_BITSIZE (*fp)));
12197 /* Get name of field. */
12198 fieldname = dwarf2_name (die, cu);
12199 if (fieldname == NULL)
12202 /* The name is already allocated along with this objfile, so we don't
12203 need to duplicate it for the type. */
12204 fp->name = fieldname;
12206 /* Change accessibility for artificial fields (e.g. virtual table
12207 pointer or virtual base class pointer) to private. */
12208 if (dwarf2_attr (die, DW_AT_artificial, cu))
12210 FIELD_ARTIFICIAL (*fp) = 1;
12211 new_field->accessibility = DW_ACCESS_private;
12212 fip->non_public_fields = 1;
12215 else if (die->tag == DW_TAG_member || die->tag == DW_TAG_variable)
12217 /* C++ static member. */
12219 /* NOTE: carlton/2002-11-05: It should be a DW_TAG_member that
12220 is a declaration, but all versions of G++ as of this writing
12221 (so through at least 3.2.1) incorrectly generate
12222 DW_TAG_variable tags. */
12224 const char *physname;
12226 /* Get name of field. */
12227 fieldname = dwarf2_name (die, cu);
12228 if (fieldname == NULL)
12231 attr = dwarf2_attr (die, DW_AT_const_value, cu);
12233 /* Only create a symbol if this is an external value.
12234 new_symbol checks this and puts the value in the global symbol
12235 table, which we want. If it is not external, new_symbol
12236 will try to put the value in cu->list_in_scope which is wrong. */
12237 && dwarf2_flag_true_p (die, DW_AT_external, cu))
12239 /* A static const member, not much different than an enum as far as
12240 we're concerned, except that we can support more types. */
12241 new_symbol (die, NULL, cu);
12244 /* Get physical name. */
12245 physname = dwarf2_physname (fieldname, die, cu);
12247 /* The name is already allocated along with this objfile, so we don't
12248 need to duplicate it for the type. */
12249 SET_FIELD_PHYSNAME (*fp, physname ? physname : "");
12250 FIELD_TYPE (*fp) = die_type (die, cu);
12251 FIELD_NAME (*fp) = fieldname;
12253 else if (die->tag == DW_TAG_inheritance)
12257 /* C++ base class field. */
12258 if (handle_data_member_location (die, cu, &offset))
12259 SET_FIELD_BITPOS (*fp, offset * bits_per_byte);
12260 FIELD_BITSIZE (*fp) = 0;
12261 FIELD_TYPE (*fp) = die_type (die, cu);
12262 FIELD_NAME (*fp) = type_name_no_tag (fp->type);
12263 fip->nbaseclasses++;
12267 /* Add a typedef defined in the scope of the FIP's class. */
12270 dwarf2_add_typedef (struct field_info *fip, struct die_info *die,
12271 struct dwarf2_cu *cu)
12273 struct objfile *objfile = cu->objfile;
12274 struct typedef_field_list *new_field;
12275 struct attribute *attr;
12276 struct typedef_field *fp;
12277 char *fieldname = "";
12279 /* Allocate a new field list entry and link it in. */
12280 new_field = xzalloc (sizeof (*new_field));
12281 make_cleanup (xfree, new_field);
12283 gdb_assert (die->tag == DW_TAG_typedef);
12285 fp = &new_field->field;
12287 /* Get name of field. */
12288 fp->name = dwarf2_name (die, cu);
12289 if (fp->name == NULL)
12292 fp->type = read_type_die (die, cu);
12294 new_field->next = fip->typedef_field_list;
12295 fip->typedef_field_list = new_field;
12296 fip->typedef_field_list_count++;
12299 /* Create the vector of fields, and attach it to the type. */
12302 dwarf2_attach_fields_to_type (struct field_info *fip, struct type *type,
12303 struct dwarf2_cu *cu)
12305 int nfields = fip->nfields;
12307 /* Record the field count, allocate space for the array of fields,
12308 and create blank accessibility bitfields if necessary. */
12309 TYPE_NFIELDS (type) = nfields;
12310 TYPE_FIELDS (type) = (struct field *)
12311 TYPE_ALLOC (type, sizeof (struct field) * nfields);
12312 memset (TYPE_FIELDS (type), 0, sizeof (struct field) * nfields);
12314 if (fip->non_public_fields && cu->language != language_ada)
12316 ALLOCATE_CPLUS_STRUCT_TYPE (type);
12318 TYPE_FIELD_PRIVATE_BITS (type) =
12319 (B_TYPE *) TYPE_ALLOC (type, B_BYTES (nfields));
12320 B_CLRALL (TYPE_FIELD_PRIVATE_BITS (type), nfields);
12322 TYPE_FIELD_PROTECTED_BITS (type) =
12323 (B_TYPE *) TYPE_ALLOC (type, B_BYTES (nfields));
12324 B_CLRALL (TYPE_FIELD_PROTECTED_BITS (type), nfields);
12326 TYPE_FIELD_IGNORE_BITS (type) =
12327 (B_TYPE *) TYPE_ALLOC (type, B_BYTES (nfields));
12328 B_CLRALL (TYPE_FIELD_IGNORE_BITS (type), nfields);
12331 /* If the type has baseclasses, allocate and clear a bit vector for
12332 TYPE_FIELD_VIRTUAL_BITS. */
12333 if (fip->nbaseclasses && cu->language != language_ada)
12335 int num_bytes = B_BYTES (fip->nbaseclasses);
12336 unsigned char *pointer;
12338 ALLOCATE_CPLUS_STRUCT_TYPE (type);
12339 pointer = TYPE_ALLOC (type, num_bytes);
12340 TYPE_FIELD_VIRTUAL_BITS (type) = pointer;
12341 B_CLRALL (TYPE_FIELD_VIRTUAL_BITS (type), fip->nbaseclasses);
12342 TYPE_N_BASECLASSES (type) = fip->nbaseclasses;
12345 /* Copy the saved-up fields into the field vector. Start from the head of
12346 the list, adding to the tail of the field array, so that they end up in
12347 the same order in the array in which they were added to the list. */
12348 while (nfields-- > 0)
12350 struct nextfield *fieldp;
12354 fieldp = fip->fields;
12355 fip->fields = fieldp->next;
12359 fieldp = fip->baseclasses;
12360 fip->baseclasses = fieldp->next;
12363 TYPE_FIELD (type, nfields) = fieldp->field;
12364 switch (fieldp->accessibility)
12366 case DW_ACCESS_private:
12367 if (cu->language != language_ada)
12368 SET_TYPE_FIELD_PRIVATE (type, nfields);
12371 case DW_ACCESS_protected:
12372 if (cu->language != language_ada)
12373 SET_TYPE_FIELD_PROTECTED (type, nfields);
12376 case DW_ACCESS_public:
12380 /* Unknown accessibility. Complain and treat it as public. */
12382 complaint (&symfile_complaints, _("unsupported accessibility %d"),
12383 fieldp->accessibility);
12387 if (nfields < fip->nbaseclasses)
12389 switch (fieldp->virtuality)
12391 case DW_VIRTUALITY_virtual:
12392 case DW_VIRTUALITY_pure_virtual:
12393 if (cu->language == language_ada)
12394 error (_("unexpected virtuality in component of Ada type"));
12395 SET_TYPE_FIELD_VIRTUAL (type, nfields);
12402 /* Return true if this member function is a constructor, false
12406 dwarf2_is_constructor (struct die_info *die, struct dwarf2_cu *cu)
12408 const char *fieldname;
12409 const char *typename;
12412 if (die->parent == NULL)
12415 if (die->parent->tag != DW_TAG_structure_type
12416 && die->parent->tag != DW_TAG_union_type
12417 && die->parent->tag != DW_TAG_class_type)
12420 fieldname = dwarf2_name (die, cu);
12421 typename = dwarf2_name (die->parent, cu);
12422 if (fieldname == NULL || typename == NULL)
12425 len = strlen (fieldname);
12426 return (strncmp (fieldname, typename, len) == 0
12427 && (typename[len] == '\0' || typename[len] == '<'));
12430 /* Add a member function to the proper fieldlist. */
12433 dwarf2_add_member_fn (struct field_info *fip, struct die_info *die,
12434 struct type *type, struct dwarf2_cu *cu)
12436 struct objfile *objfile = cu->objfile;
12437 struct attribute *attr;
12438 struct fnfieldlist *flp;
12440 struct fn_field *fnp;
12441 const char *fieldname;
12442 struct nextfnfield *new_fnfield;
12443 struct type *this_type;
12444 enum dwarf_access_attribute accessibility;
12446 if (cu->language == language_ada)
12447 error (_("unexpected member function in Ada type"));
12449 /* Get name of member function. */
12450 fieldname = dwarf2_name (die, cu);
12451 if (fieldname == NULL)
12454 /* Look up member function name in fieldlist. */
12455 for (i = 0; i < fip->nfnfields; i++)
12457 if (strcmp (fip->fnfieldlists[i].name, fieldname) == 0)
12461 /* Create new list element if necessary. */
12462 if (i < fip->nfnfields)
12463 flp = &fip->fnfieldlists[i];
12466 if ((fip->nfnfields % DW_FIELD_ALLOC_CHUNK) == 0)
12468 fip->fnfieldlists = (struct fnfieldlist *)
12469 xrealloc (fip->fnfieldlists,
12470 (fip->nfnfields + DW_FIELD_ALLOC_CHUNK)
12471 * sizeof (struct fnfieldlist));
12472 if (fip->nfnfields == 0)
12473 make_cleanup (free_current_contents, &fip->fnfieldlists);
12475 flp = &fip->fnfieldlists[fip->nfnfields];
12476 flp->name = fieldname;
12479 i = fip->nfnfields++;
12482 /* Create a new member function field and chain it to the field list
12484 new_fnfield = (struct nextfnfield *) xmalloc (sizeof (struct nextfnfield));
12485 make_cleanup (xfree, new_fnfield);
12486 memset (new_fnfield, 0, sizeof (struct nextfnfield));
12487 new_fnfield->next = flp->head;
12488 flp->head = new_fnfield;
12491 /* Fill in the member function field info. */
12492 fnp = &new_fnfield->fnfield;
12494 /* Delay processing of the physname until later. */
12495 if (cu->language == language_cplus || cu->language == language_java)
12497 add_to_method_list (type, i, flp->length - 1, fieldname,
12502 const char *physname = dwarf2_physname (fieldname, die, cu);
12503 fnp->physname = physname ? physname : "";
12506 fnp->type = alloc_type (objfile);
12507 this_type = read_type_die (die, cu);
12508 if (this_type && TYPE_CODE (this_type) == TYPE_CODE_FUNC)
12510 int nparams = TYPE_NFIELDS (this_type);
12512 /* TYPE is the domain of this method, and THIS_TYPE is the type
12513 of the method itself (TYPE_CODE_METHOD). */
12514 smash_to_method_type (fnp->type, type,
12515 TYPE_TARGET_TYPE (this_type),
12516 TYPE_FIELDS (this_type),
12517 TYPE_NFIELDS (this_type),
12518 TYPE_VARARGS (this_type));
12520 /* Handle static member functions.
12521 Dwarf2 has no clean way to discern C++ static and non-static
12522 member functions. G++ helps GDB by marking the first
12523 parameter for non-static member functions (which is the this
12524 pointer) as artificial. We obtain this information from
12525 read_subroutine_type via TYPE_FIELD_ARTIFICIAL. */
12526 if (nparams == 0 || TYPE_FIELD_ARTIFICIAL (this_type, 0) == 0)
12527 fnp->voffset = VOFFSET_STATIC;
12530 complaint (&symfile_complaints, _("member function type missing for '%s'"),
12531 dwarf2_full_name (fieldname, die, cu));
12533 /* Get fcontext from DW_AT_containing_type if present. */
12534 if (dwarf2_attr (die, DW_AT_containing_type, cu) != NULL)
12535 fnp->fcontext = die_containing_type (die, cu);
12537 /* dwarf2 doesn't have stubbed physical names, so the setting of is_const and
12538 is_volatile is irrelevant, as it is needed by gdb_mangle_name only. */
12540 /* Get accessibility. */
12541 attr = dwarf2_attr (die, DW_AT_accessibility, cu);
12543 accessibility = DW_UNSND (attr);
12545 accessibility = dwarf2_default_access_attribute (die, cu);
12546 switch (accessibility)
12548 case DW_ACCESS_private:
12549 fnp->is_private = 1;
12551 case DW_ACCESS_protected:
12552 fnp->is_protected = 1;
12556 /* Check for artificial methods. */
12557 attr = dwarf2_attr (die, DW_AT_artificial, cu);
12558 if (attr && DW_UNSND (attr) != 0)
12559 fnp->is_artificial = 1;
12561 fnp->is_constructor = dwarf2_is_constructor (die, cu);
12563 /* Get index in virtual function table if it is a virtual member
12564 function. For older versions of GCC, this is an offset in the
12565 appropriate virtual table, as specified by DW_AT_containing_type.
12566 For everyone else, it is an expression to be evaluated relative
12567 to the object address. */
12569 attr = dwarf2_attr (die, DW_AT_vtable_elem_location, cu);
12572 if (attr_form_is_block (attr) && DW_BLOCK (attr)->size > 0)
12574 if (DW_BLOCK (attr)->data[0] == DW_OP_constu)
12576 /* Old-style GCC. */
12577 fnp->voffset = decode_locdesc (DW_BLOCK (attr), cu) + 2;
12579 else if (DW_BLOCK (attr)->data[0] == DW_OP_deref
12580 || (DW_BLOCK (attr)->size > 1
12581 && DW_BLOCK (attr)->data[0] == DW_OP_deref_size
12582 && DW_BLOCK (attr)->data[1] == cu->header.addr_size))
12584 struct dwarf_block blk;
12587 offset = (DW_BLOCK (attr)->data[0] == DW_OP_deref
12589 blk.size = DW_BLOCK (attr)->size - offset;
12590 blk.data = DW_BLOCK (attr)->data + offset;
12591 fnp->voffset = decode_locdesc (DW_BLOCK (attr), cu);
12592 if ((fnp->voffset % cu->header.addr_size) != 0)
12593 dwarf2_complex_location_expr_complaint ();
12595 fnp->voffset /= cu->header.addr_size;
12599 dwarf2_complex_location_expr_complaint ();
12601 if (!fnp->fcontext)
12602 fnp->fcontext = TYPE_TARGET_TYPE (TYPE_FIELD_TYPE (this_type, 0));
12604 else if (attr_form_is_section_offset (attr))
12606 dwarf2_complex_location_expr_complaint ();
12610 dwarf2_invalid_attrib_class_complaint ("DW_AT_vtable_elem_location",
12616 attr = dwarf2_attr (die, DW_AT_virtuality, cu);
12617 if (attr && DW_UNSND (attr))
12619 /* GCC does this, as of 2008-08-25; PR debug/37237. */
12620 complaint (&symfile_complaints,
12621 _("Member function \"%s\" (offset %d) is virtual "
12622 "but the vtable offset is not specified"),
12623 fieldname, die->offset.sect_off);
12624 ALLOCATE_CPLUS_STRUCT_TYPE (type);
12625 TYPE_CPLUS_DYNAMIC (type) = 1;
12630 /* Create the vector of member function fields, and attach it to the type. */
12633 dwarf2_attach_fn_fields_to_type (struct field_info *fip, struct type *type,
12634 struct dwarf2_cu *cu)
12636 struct fnfieldlist *flp;
12639 if (cu->language == language_ada)
12640 error (_("unexpected member functions in Ada type"));
12642 ALLOCATE_CPLUS_STRUCT_TYPE (type);
12643 TYPE_FN_FIELDLISTS (type) = (struct fn_fieldlist *)
12644 TYPE_ALLOC (type, sizeof (struct fn_fieldlist) * fip->nfnfields);
12646 for (i = 0, flp = fip->fnfieldlists; i < fip->nfnfields; i++, flp++)
12648 struct nextfnfield *nfp = flp->head;
12649 struct fn_fieldlist *fn_flp = &TYPE_FN_FIELDLIST (type, i);
12652 TYPE_FN_FIELDLIST_NAME (type, i) = flp->name;
12653 TYPE_FN_FIELDLIST_LENGTH (type, i) = flp->length;
12654 fn_flp->fn_fields = (struct fn_field *)
12655 TYPE_ALLOC (type, sizeof (struct fn_field) * flp->length);
12656 for (k = flp->length; (k--, nfp); nfp = nfp->next)
12657 fn_flp->fn_fields[k] = nfp->fnfield;
12660 TYPE_NFN_FIELDS (type) = fip->nfnfields;
12663 /* Returns non-zero if NAME is the name of a vtable member in CU's
12664 language, zero otherwise. */
12666 is_vtable_name (const char *name, struct dwarf2_cu *cu)
12668 static const char vptr[] = "_vptr";
12669 static const char vtable[] = "vtable";
12671 /* Look for the C++ and Java forms of the vtable. */
12672 if ((cu->language == language_java
12673 && strncmp (name, vtable, sizeof (vtable) - 1) == 0)
12674 || (strncmp (name, vptr, sizeof (vptr) - 1) == 0
12675 && is_cplus_marker (name[sizeof (vptr) - 1])))
12681 /* GCC outputs unnamed structures that are really pointers to member
12682 functions, with the ABI-specified layout. If TYPE describes
12683 such a structure, smash it into a member function type.
12685 GCC shouldn't do this; it should just output pointer to member DIEs.
12686 This is GCC PR debug/28767. */
12689 quirk_gcc_member_function_pointer (struct type *type, struct objfile *objfile)
12691 struct type *pfn_type, *domain_type, *new_type;
12693 /* Check for a structure with no name and two children. */
12694 if (TYPE_CODE (type) != TYPE_CODE_STRUCT || TYPE_NFIELDS (type) != 2)
12697 /* Check for __pfn and __delta members. */
12698 if (TYPE_FIELD_NAME (type, 0) == NULL
12699 || strcmp (TYPE_FIELD_NAME (type, 0), "__pfn") != 0
12700 || TYPE_FIELD_NAME (type, 1) == NULL
12701 || strcmp (TYPE_FIELD_NAME (type, 1), "__delta") != 0)
12704 /* Find the type of the method. */
12705 pfn_type = TYPE_FIELD_TYPE (type, 0);
12706 if (pfn_type == NULL
12707 || TYPE_CODE (pfn_type) != TYPE_CODE_PTR
12708 || TYPE_CODE (TYPE_TARGET_TYPE (pfn_type)) != TYPE_CODE_FUNC)
12711 /* Look for the "this" argument. */
12712 pfn_type = TYPE_TARGET_TYPE (pfn_type);
12713 if (TYPE_NFIELDS (pfn_type) == 0
12714 /* || TYPE_FIELD_TYPE (pfn_type, 0) == NULL */
12715 || TYPE_CODE (TYPE_FIELD_TYPE (pfn_type, 0)) != TYPE_CODE_PTR)
12718 domain_type = TYPE_TARGET_TYPE (TYPE_FIELD_TYPE (pfn_type, 0));
12719 new_type = alloc_type (objfile);
12720 smash_to_method_type (new_type, domain_type, TYPE_TARGET_TYPE (pfn_type),
12721 TYPE_FIELDS (pfn_type), TYPE_NFIELDS (pfn_type),
12722 TYPE_VARARGS (pfn_type));
12723 smash_to_methodptr_type (type, new_type);
12726 /* Return non-zero if the CU's PRODUCER string matches the Intel C/C++ compiler
12730 producer_is_icc (struct dwarf2_cu *cu)
12732 if (!cu->checked_producer)
12733 check_producer (cu);
12735 return cu->producer_is_icc;
12738 /* Called when we find the DIE that starts a structure or union scope
12739 (definition) to create a type for the structure or union. Fill in
12740 the type's name and general properties; the members will not be
12741 processed until process_structure_scope.
12743 NOTE: we need to call these functions regardless of whether or not the
12744 DIE has a DW_AT_name attribute, since it might be an anonymous
12745 structure or union. This gets the type entered into our set of
12746 user defined types.
12748 However, if the structure is incomplete (an opaque struct/union)
12749 then suppress creating a symbol table entry for it since gdb only
12750 wants to find the one with the complete definition. Note that if
12751 it is complete, we just call new_symbol, which does it's own
12752 checking about whether the struct/union is anonymous or not (and
12753 suppresses creating a symbol table entry itself). */
12755 static struct type *
12756 read_structure_type (struct die_info *die, struct dwarf2_cu *cu)
12758 struct objfile *objfile = cu->objfile;
12760 struct attribute *attr;
12763 /* If the definition of this type lives in .debug_types, read that type.
12764 Don't follow DW_AT_specification though, that will take us back up
12765 the chain and we want to go down. */
12766 attr = dwarf2_attr_no_follow (die, DW_AT_signature);
12769 type = get_DW_AT_signature_type (die, attr, cu);
12771 /* The type's CU may not be the same as CU.
12772 Ensure TYPE is recorded with CU in die_type_hash. */
12773 return set_die_type (die, type, cu);
12776 type = alloc_type (objfile);
12777 INIT_CPLUS_SPECIFIC (type);
12779 name = dwarf2_name (die, cu);
12782 if (cu->language == language_cplus
12783 || cu->language == language_java)
12785 const char *full_name = dwarf2_full_name (name, die, cu);
12787 /* dwarf2_full_name might have already finished building the DIE's
12788 type. If so, there is no need to continue. */
12789 if (get_die_type (die, cu) != NULL)
12790 return get_die_type (die, cu);
12792 TYPE_TAG_NAME (type) = full_name;
12793 if (die->tag == DW_TAG_structure_type
12794 || die->tag == DW_TAG_class_type)
12795 TYPE_NAME (type) = TYPE_TAG_NAME (type);
12799 /* The name is already allocated along with this objfile, so
12800 we don't need to duplicate it for the type. */
12801 TYPE_TAG_NAME (type) = name;
12802 if (die->tag == DW_TAG_class_type)
12803 TYPE_NAME (type) = TYPE_TAG_NAME (type);
12807 if (die->tag == DW_TAG_structure_type)
12809 TYPE_CODE (type) = TYPE_CODE_STRUCT;
12811 else if (die->tag == DW_TAG_union_type)
12813 TYPE_CODE (type) = TYPE_CODE_UNION;
12817 TYPE_CODE (type) = TYPE_CODE_CLASS;
12820 if (cu->language == language_cplus && die->tag == DW_TAG_class_type)
12821 TYPE_DECLARED_CLASS (type) = 1;
12823 attr = dwarf2_attr (die, DW_AT_byte_size, cu);
12826 TYPE_LENGTH (type) = DW_UNSND (attr);
12830 TYPE_LENGTH (type) = 0;
12833 if (producer_is_icc (cu))
12835 /* ICC does not output the required DW_AT_declaration
12836 on incomplete types, but gives them a size of zero. */
12839 TYPE_STUB_SUPPORTED (type) = 1;
12841 if (die_is_declaration (die, cu))
12842 TYPE_STUB (type) = 1;
12843 else if (attr == NULL && die->child == NULL
12844 && producer_is_realview (cu->producer))
12845 /* RealView does not output the required DW_AT_declaration
12846 on incomplete types. */
12847 TYPE_STUB (type) = 1;
12849 /* We need to add the type field to the die immediately so we don't
12850 infinitely recurse when dealing with pointers to the structure
12851 type within the structure itself. */
12852 set_die_type (die, type, cu);
12854 /* set_die_type should be already done. */
12855 set_descriptive_type (type, die, cu);
12860 /* Finish creating a structure or union type, including filling in
12861 its members and creating a symbol for it. */
12864 process_structure_scope (struct die_info *die, struct dwarf2_cu *cu)
12866 struct objfile *objfile = cu->objfile;
12867 struct die_info *child_die = die->child;
12870 type = get_die_type (die, cu);
12872 type = read_structure_type (die, cu);
12874 if (die->child != NULL && ! die_is_declaration (die, cu))
12876 struct field_info fi;
12877 struct die_info *child_die;
12878 VEC (symbolp) *template_args = NULL;
12879 struct cleanup *back_to = make_cleanup (null_cleanup, 0);
12881 memset (&fi, 0, sizeof (struct field_info));
12883 child_die = die->child;
12885 while (child_die && child_die->tag)
12887 if (child_die->tag == DW_TAG_member
12888 || child_die->tag == DW_TAG_variable)
12890 /* NOTE: carlton/2002-11-05: A C++ static data member
12891 should be a DW_TAG_member that is a declaration, but
12892 all versions of G++ as of this writing (so through at
12893 least 3.2.1) incorrectly generate DW_TAG_variable
12894 tags for them instead. */
12895 dwarf2_add_field (&fi, child_die, cu);
12897 else if (child_die->tag == DW_TAG_subprogram)
12899 /* C++ member function. */
12900 dwarf2_add_member_fn (&fi, child_die, type, cu);
12902 else if (child_die->tag == DW_TAG_inheritance)
12904 /* C++ base class field. */
12905 dwarf2_add_field (&fi, child_die, cu);
12907 else if (child_die->tag == DW_TAG_typedef)
12908 dwarf2_add_typedef (&fi, child_die, cu);
12909 else if (child_die->tag == DW_TAG_template_type_param
12910 || child_die->tag == DW_TAG_template_value_param)
12912 struct symbol *arg = new_symbol (child_die, NULL, cu);
12915 VEC_safe_push (symbolp, template_args, arg);
12918 child_die = sibling_die (child_die);
12921 /* Attach template arguments to type. */
12922 if (! VEC_empty (symbolp, template_args))
12924 ALLOCATE_CPLUS_STRUCT_TYPE (type);
12925 TYPE_N_TEMPLATE_ARGUMENTS (type)
12926 = VEC_length (symbolp, template_args);
12927 TYPE_TEMPLATE_ARGUMENTS (type)
12928 = obstack_alloc (&objfile->objfile_obstack,
12929 (TYPE_N_TEMPLATE_ARGUMENTS (type)
12930 * sizeof (struct symbol *)));
12931 memcpy (TYPE_TEMPLATE_ARGUMENTS (type),
12932 VEC_address (symbolp, template_args),
12933 (TYPE_N_TEMPLATE_ARGUMENTS (type)
12934 * sizeof (struct symbol *)));
12935 VEC_free (symbolp, template_args);
12938 /* Attach fields and member functions to the type. */
12940 dwarf2_attach_fields_to_type (&fi, type, cu);
12943 dwarf2_attach_fn_fields_to_type (&fi, type, cu);
12945 /* Get the type which refers to the base class (possibly this
12946 class itself) which contains the vtable pointer for the current
12947 class from the DW_AT_containing_type attribute. This use of
12948 DW_AT_containing_type is a GNU extension. */
12950 if (dwarf2_attr (die, DW_AT_containing_type, cu) != NULL)
12952 struct type *t = die_containing_type (die, cu);
12954 TYPE_VPTR_BASETYPE (type) = t;
12959 /* Our own class provides vtbl ptr. */
12960 for (i = TYPE_NFIELDS (t) - 1;
12961 i >= TYPE_N_BASECLASSES (t);
12964 const char *fieldname = TYPE_FIELD_NAME (t, i);
12966 if (is_vtable_name (fieldname, cu))
12968 TYPE_VPTR_FIELDNO (type) = i;
12973 /* Complain if virtual function table field not found. */
12974 if (i < TYPE_N_BASECLASSES (t))
12975 complaint (&symfile_complaints,
12976 _("virtual function table pointer "
12977 "not found when defining class '%s'"),
12978 TYPE_TAG_NAME (type) ? TYPE_TAG_NAME (type) :
12983 TYPE_VPTR_FIELDNO (type) = TYPE_VPTR_FIELDNO (t);
12986 else if (cu->producer
12987 && strncmp (cu->producer,
12988 "IBM(R) XL C/C++ Advanced Edition", 32) == 0)
12990 /* The IBM XLC compiler does not provide direct indication
12991 of the containing type, but the vtable pointer is
12992 always named __vfp. */
12996 for (i = TYPE_NFIELDS (type) - 1;
12997 i >= TYPE_N_BASECLASSES (type);
13000 if (strcmp (TYPE_FIELD_NAME (type, i), "__vfp") == 0)
13002 TYPE_VPTR_FIELDNO (type) = i;
13003 TYPE_VPTR_BASETYPE (type) = type;
13010 /* Copy fi.typedef_field_list linked list elements content into the
13011 allocated array TYPE_TYPEDEF_FIELD_ARRAY (type). */
13012 if (fi.typedef_field_list)
13014 int i = fi.typedef_field_list_count;
13016 ALLOCATE_CPLUS_STRUCT_TYPE (type);
13017 TYPE_TYPEDEF_FIELD_ARRAY (type)
13018 = TYPE_ALLOC (type, sizeof (TYPE_TYPEDEF_FIELD (type, 0)) * i);
13019 TYPE_TYPEDEF_FIELD_COUNT (type) = i;
13021 /* Reverse the list order to keep the debug info elements order. */
13024 struct typedef_field *dest, *src;
13026 dest = &TYPE_TYPEDEF_FIELD (type, i);
13027 src = &fi.typedef_field_list->field;
13028 fi.typedef_field_list = fi.typedef_field_list->next;
13033 do_cleanups (back_to);
13035 if (HAVE_CPLUS_STRUCT (type))
13036 TYPE_CPLUS_REALLY_JAVA (type) = cu->language == language_java;
13039 quirk_gcc_member_function_pointer (type, objfile);
13041 /* NOTE: carlton/2004-03-16: GCC 3.4 (or at least one of its
13042 snapshots) has been known to create a die giving a declaration
13043 for a class that has, as a child, a die giving a definition for a
13044 nested class. So we have to process our children even if the
13045 current die is a declaration. Normally, of course, a declaration
13046 won't have any children at all. */
13048 while (child_die != NULL && child_die->tag)
13050 if (child_die->tag == DW_TAG_member
13051 || child_die->tag == DW_TAG_variable
13052 || child_die->tag == DW_TAG_inheritance
13053 || child_die->tag == DW_TAG_template_value_param
13054 || child_die->tag == DW_TAG_template_type_param)
13059 process_die (child_die, cu);
13061 child_die = sibling_die (child_die);
13064 /* Do not consider external references. According to the DWARF standard,
13065 these DIEs are identified by the fact that they have no byte_size
13066 attribute, and a declaration attribute. */
13067 if (dwarf2_attr (die, DW_AT_byte_size, cu) != NULL
13068 || !die_is_declaration (die, cu))
13069 new_symbol (die, type, cu);
13072 /* Given a DW_AT_enumeration_type die, set its type. We do not
13073 complete the type's fields yet, or create any symbols. */
13075 static struct type *
13076 read_enumeration_type (struct die_info *die, struct dwarf2_cu *cu)
13078 struct objfile *objfile = cu->objfile;
13080 struct attribute *attr;
13083 /* If the definition of this type lives in .debug_types, read that type.
13084 Don't follow DW_AT_specification though, that will take us back up
13085 the chain and we want to go down. */
13086 attr = dwarf2_attr_no_follow (die, DW_AT_signature);
13089 type = get_DW_AT_signature_type (die, attr, cu);
13091 /* The type's CU may not be the same as CU.
13092 Ensure TYPE is recorded with CU in die_type_hash. */
13093 return set_die_type (die, type, cu);
13096 type = alloc_type (objfile);
13098 TYPE_CODE (type) = TYPE_CODE_ENUM;
13099 name = dwarf2_full_name (NULL, die, cu);
13101 TYPE_TAG_NAME (type) = name;
13103 attr = dwarf2_attr (die, DW_AT_byte_size, cu);
13106 TYPE_LENGTH (type) = DW_UNSND (attr);
13110 TYPE_LENGTH (type) = 0;
13113 /* The enumeration DIE can be incomplete. In Ada, any type can be
13114 declared as private in the package spec, and then defined only
13115 inside the package body. Such types are known as Taft Amendment
13116 Types. When another package uses such a type, an incomplete DIE
13117 may be generated by the compiler. */
13118 if (die_is_declaration (die, cu))
13119 TYPE_STUB (type) = 1;
13121 return set_die_type (die, type, cu);
13124 /* Given a pointer to a die which begins an enumeration, process all
13125 the dies that define the members of the enumeration, and create the
13126 symbol for the enumeration type.
13128 NOTE: We reverse the order of the element list. */
13131 process_enumeration_scope (struct die_info *die, struct dwarf2_cu *cu)
13133 struct type *this_type;
13135 this_type = get_die_type (die, cu);
13136 if (this_type == NULL)
13137 this_type = read_enumeration_type (die, cu);
13139 if (die->child != NULL)
13141 struct die_info *child_die;
13142 struct symbol *sym;
13143 struct field *fields = NULL;
13144 int num_fields = 0;
13145 int unsigned_enum = 1;
13150 child_die = die->child;
13151 while (child_die && child_die->tag)
13153 if (child_die->tag != DW_TAG_enumerator)
13155 process_die (child_die, cu);
13159 name = dwarf2_name (child_die, cu);
13162 sym = new_symbol (child_die, this_type, cu);
13163 if (SYMBOL_VALUE (sym) < 0)
13168 else if ((mask & SYMBOL_VALUE (sym)) != 0)
13171 mask |= SYMBOL_VALUE (sym);
13173 if ((num_fields % DW_FIELD_ALLOC_CHUNK) == 0)
13175 fields = (struct field *)
13177 (num_fields + DW_FIELD_ALLOC_CHUNK)
13178 * sizeof (struct field));
13181 FIELD_NAME (fields[num_fields]) = SYMBOL_LINKAGE_NAME (sym);
13182 FIELD_TYPE (fields[num_fields]) = NULL;
13183 SET_FIELD_ENUMVAL (fields[num_fields], SYMBOL_VALUE (sym));
13184 FIELD_BITSIZE (fields[num_fields]) = 0;
13190 child_die = sibling_die (child_die);
13195 TYPE_NFIELDS (this_type) = num_fields;
13196 TYPE_FIELDS (this_type) = (struct field *)
13197 TYPE_ALLOC (this_type, sizeof (struct field) * num_fields);
13198 memcpy (TYPE_FIELDS (this_type), fields,
13199 sizeof (struct field) * num_fields);
13203 TYPE_UNSIGNED (this_type) = 1;
13205 TYPE_FLAG_ENUM (this_type) = 1;
13208 /* If we are reading an enum from a .debug_types unit, and the enum
13209 is a declaration, and the enum is not the signatured type in the
13210 unit, then we do not want to add a symbol for it. Adding a
13211 symbol would in some cases obscure the true definition of the
13212 enum, giving users an incomplete type when the definition is
13213 actually available. Note that we do not want to do this for all
13214 enums which are just declarations, because C++0x allows forward
13215 enum declarations. */
13216 if (cu->per_cu->is_debug_types
13217 && die_is_declaration (die, cu))
13219 struct signatured_type *sig_type;
13221 sig_type = (struct signatured_type *) cu->per_cu;
13222 gdb_assert (sig_type->type_offset_in_section.sect_off != 0);
13223 if (sig_type->type_offset_in_section.sect_off != die->offset.sect_off)
13227 new_symbol (die, this_type, cu);
13230 /* Extract all information from a DW_TAG_array_type DIE and put it in
13231 the DIE's type field. For now, this only handles one dimensional
13234 static struct type *
13235 read_array_type (struct die_info *die, struct dwarf2_cu *cu)
13237 struct objfile *objfile = cu->objfile;
13238 struct die_info *child_die;
13240 struct type *element_type, *range_type, *index_type;
13241 struct type **range_types = NULL;
13242 struct attribute *attr;
13244 struct cleanup *back_to;
13247 element_type = die_type (die, cu);
13249 /* The die_type call above may have already set the type for this DIE. */
13250 type = get_die_type (die, cu);
13254 /* Irix 6.2 native cc creates array types without children for
13255 arrays with unspecified length. */
13256 if (die->child == NULL)
13258 index_type = objfile_type (objfile)->builtin_int;
13259 range_type = create_range_type (NULL, index_type, 0, -1);
13260 type = create_array_type (NULL, element_type, range_type);
13261 return set_die_type (die, type, cu);
13264 back_to = make_cleanup (null_cleanup, NULL);
13265 child_die = die->child;
13266 while (child_die && child_die->tag)
13268 if (child_die->tag == DW_TAG_subrange_type)
13270 struct type *child_type = read_type_die (child_die, cu);
13272 if (child_type != NULL)
13274 /* The range type was succesfully read. Save it for the
13275 array type creation. */
13276 if ((ndim % DW_FIELD_ALLOC_CHUNK) == 0)
13278 range_types = (struct type **)
13279 xrealloc (range_types, (ndim + DW_FIELD_ALLOC_CHUNK)
13280 * sizeof (struct type *));
13282 make_cleanup (free_current_contents, &range_types);
13284 range_types[ndim++] = child_type;
13287 child_die = sibling_die (child_die);
13290 /* Dwarf2 dimensions are output from left to right, create the
13291 necessary array types in backwards order. */
13293 type = element_type;
13295 if (read_array_order (die, cu) == DW_ORD_col_major)
13300 type = create_array_type (NULL, type, range_types[i++]);
13305 type = create_array_type (NULL, type, range_types[ndim]);
13308 /* Understand Dwarf2 support for vector types (like they occur on
13309 the PowerPC w/ AltiVec). Gcc just adds another attribute to the
13310 array type. This is not part of the Dwarf2/3 standard yet, but a
13311 custom vendor extension. The main difference between a regular
13312 array and the vector variant is that vectors are passed by value
13314 attr = dwarf2_attr (die, DW_AT_GNU_vector, cu);
13316 make_vector_type (type);
13318 /* The DIE may have DW_AT_byte_size set. For example an OpenCL
13319 implementation may choose to implement triple vectors using this
13321 attr = dwarf2_attr (die, DW_AT_byte_size, cu);
13324 if (DW_UNSND (attr) >= TYPE_LENGTH (type))
13325 TYPE_LENGTH (type) = DW_UNSND (attr);
13327 complaint (&symfile_complaints,
13328 _("DW_AT_byte_size for array type smaller "
13329 "than the total size of elements"));
13332 name = dwarf2_name (die, cu);
13334 TYPE_NAME (type) = name;
13336 /* Install the type in the die. */
13337 set_die_type (die, type, cu);
13339 /* set_die_type should be already done. */
13340 set_descriptive_type (type, die, cu);
13342 do_cleanups (back_to);
13347 static enum dwarf_array_dim_ordering
13348 read_array_order (struct die_info *die, struct dwarf2_cu *cu)
13350 struct attribute *attr;
13352 attr = dwarf2_attr (die, DW_AT_ordering, cu);
13354 if (attr) return DW_SND (attr);
13356 /* GNU F77 is a special case, as at 08/2004 array type info is the
13357 opposite order to the dwarf2 specification, but data is still
13358 laid out as per normal fortran.
13360 FIXME: dsl/2004-8-20: If G77 is ever fixed, this will also need
13361 version checking. */
13363 if (cu->language == language_fortran
13364 && cu->producer && strstr (cu->producer, "GNU F77"))
13366 return DW_ORD_row_major;
13369 switch (cu->language_defn->la_array_ordering)
13371 case array_column_major:
13372 return DW_ORD_col_major;
13373 case array_row_major:
13375 return DW_ORD_row_major;
13379 /* Extract all information from a DW_TAG_set_type DIE and put it in
13380 the DIE's type field. */
13382 static struct type *
13383 read_set_type (struct die_info *die, struct dwarf2_cu *cu)
13385 struct type *domain_type, *set_type;
13386 struct attribute *attr;
13388 domain_type = die_type (die, cu);
13390 /* The die_type call above may have already set the type for this DIE. */
13391 set_type = get_die_type (die, cu);
13395 set_type = create_set_type (NULL, domain_type);
13397 attr = dwarf2_attr (die, DW_AT_byte_size, cu);
13399 TYPE_LENGTH (set_type) = DW_UNSND (attr);
13401 return set_die_type (die, set_type, cu);
13404 /* A helper for read_common_block that creates a locexpr baton.
13405 SYM is the symbol which we are marking as computed.
13406 COMMON_DIE is the DIE for the common block.
13407 COMMON_LOC is the location expression attribute for the common
13409 MEMBER_LOC is the location expression attribute for the particular
13410 member of the common block that we are processing.
13411 CU is the CU from which the above come. */
13414 mark_common_block_symbol_computed (struct symbol *sym,
13415 struct die_info *common_die,
13416 struct attribute *common_loc,
13417 struct attribute *member_loc,
13418 struct dwarf2_cu *cu)
13420 struct objfile *objfile = dwarf2_per_objfile->objfile;
13421 struct dwarf2_locexpr_baton *baton;
13423 unsigned int cu_off;
13424 enum bfd_endian byte_order = gdbarch_byte_order (get_objfile_arch (objfile));
13425 LONGEST offset = 0;
13427 gdb_assert (common_loc && member_loc);
13428 gdb_assert (attr_form_is_block (common_loc));
13429 gdb_assert (attr_form_is_block (member_loc)
13430 || attr_form_is_constant (member_loc));
13432 baton = obstack_alloc (&objfile->objfile_obstack,
13433 sizeof (struct dwarf2_locexpr_baton));
13434 baton->per_cu = cu->per_cu;
13435 gdb_assert (baton->per_cu);
13437 baton->size = 5 /* DW_OP_call4 */ + 1 /* DW_OP_plus */;
13439 if (attr_form_is_constant (member_loc))
13441 offset = dwarf2_get_attr_constant_value (member_loc, 0);
13442 baton->size += 1 /* DW_OP_addr */ + cu->header.addr_size;
13445 baton->size += DW_BLOCK (member_loc)->size;
13447 ptr = obstack_alloc (&objfile->objfile_obstack, baton->size);
13450 *ptr++ = DW_OP_call4;
13451 cu_off = common_die->offset.sect_off - cu->per_cu->offset.sect_off;
13452 store_unsigned_integer (ptr, 4, byte_order, cu_off);
13455 if (attr_form_is_constant (member_loc))
13457 *ptr++ = DW_OP_addr;
13458 store_unsigned_integer (ptr, cu->header.addr_size, byte_order, offset);
13459 ptr += cu->header.addr_size;
13463 /* We have to copy the data here, because DW_OP_call4 will only
13464 use a DW_AT_location attribute. */
13465 memcpy (ptr, DW_BLOCK (member_loc)->data, DW_BLOCK (member_loc)->size);
13466 ptr += DW_BLOCK (member_loc)->size;
13469 *ptr++ = DW_OP_plus;
13470 gdb_assert (ptr - baton->data == baton->size);
13472 SYMBOL_LOCATION_BATON (sym) = baton;
13473 SYMBOL_ACLASS_INDEX (sym) = dwarf2_locexpr_index;
13476 /* Create appropriate locally-scoped variables for all the
13477 DW_TAG_common_block entries. Also create a struct common_block
13478 listing all such variables for `info common'. COMMON_BLOCK_DOMAIN
13479 is used to sepate the common blocks name namespace from regular
13483 read_common_block (struct die_info *die, struct dwarf2_cu *cu)
13485 struct attribute *attr;
13487 attr = dwarf2_attr (die, DW_AT_location, cu);
13490 /* Support the .debug_loc offsets. */
13491 if (attr_form_is_block (attr))
13495 else if (attr_form_is_section_offset (attr))
13497 dwarf2_complex_location_expr_complaint ();
13502 dwarf2_invalid_attrib_class_complaint ("DW_AT_location",
13503 "common block member");
13508 if (die->child != NULL)
13510 struct objfile *objfile = cu->objfile;
13511 struct die_info *child_die;
13512 size_t n_entries = 0, size;
13513 struct common_block *common_block;
13514 struct symbol *sym;
13516 for (child_die = die->child;
13517 child_die && child_die->tag;
13518 child_die = sibling_die (child_die))
13521 size = (sizeof (struct common_block)
13522 + (n_entries - 1) * sizeof (struct symbol *));
13523 common_block = obstack_alloc (&objfile->objfile_obstack, size);
13524 memset (common_block->contents, 0, n_entries * sizeof (struct symbol *));
13525 common_block->n_entries = 0;
13527 for (child_die = die->child;
13528 child_die && child_die->tag;
13529 child_die = sibling_die (child_die))
13531 /* Create the symbol in the DW_TAG_common_block block in the current
13533 sym = new_symbol (child_die, NULL, cu);
13536 struct attribute *member_loc;
13538 common_block->contents[common_block->n_entries++] = sym;
13540 member_loc = dwarf2_attr (child_die, DW_AT_data_member_location,
13544 /* GDB has handled this for a long time, but it is
13545 not specified by DWARF. It seems to have been
13546 emitted by gfortran at least as recently as:
13547 http://gcc.gnu.org/bugzilla/show_bug.cgi?id=23057. */
13548 complaint (&symfile_complaints,
13549 _("Variable in common block has "
13550 "DW_AT_data_member_location "
13551 "- DIE at 0x%x [in module %s]"),
13552 child_die->offset.sect_off,
13553 objfile_name (cu->objfile));
13555 if (attr_form_is_section_offset (member_loc))
13556 dwarf2_complex_location_expr_complaint ();
13557 else if (attr_form_is_constant (member_loc)
13558 || attr_form_is_block (member_loc))
13561 mark_common_block_symbol_computed (sym, die, attr,
13565 dwarf2_complex_location_expr_complaint ();
13570 sym = new_symbol (die, objfile_type (objfile)->builtin_void, cu);
13571 SYMBOL_VALUE_COMMON_BLOCK (sym) = common_block;
13575 /* Create a type for a C++ namespace. */
13577 static struct type *
13578 read_namespace_type (struct die_info *die, struct dwarf2_cu *cu)
13580 struct objfile *objfile = cu->objfile;
13581 const char *previous_prefix, *name;
13585 /* For extensions, reuse the type of the original namespace. */
13586 if (dwarf2_attr (die, DW_AT_extension, cu) != NULL)
13588 struct die_info *ext_die;
13589 struct dwarf2_cu *ext_cu = cu;
13591 ext_die = dwarf2_extension (die, &ext_cu);
13592 type = read_type_die (ext_die, ext_cu);
13594 /* EXT_CU may not be the same as CU.
13595 Ensure TYPE is recorded with CU in die_type_hash. */
13596 return set_die_type (die, type, cu);
13599 name = namespace_name (die, &is_anonymous, cu);
13601 /* Now build the name of the current namespace. */
13603 previous_prefix = determine_prefix (die, cu);
13604 if (previous_prefix[0] != '\0')
13605 name = typename_concat (&objfile->objfile_obstack,
13606 previous_prefix, name, 0, cu);
13608 /* Create the type. */
13609 type = init_type (TYPE_CODE_NAMESPACE, 0, 0, NULL,
13611 TYPE_NAME (type) = name;
13612 TYPE_TAG_NAME (type) = TYPE_NAME (type);
13614 return set_die_type (die, type, cu);
13617 /* Read a C++ namespace. */
13620 read_namespace (struct die_info *die, struct dwarf2_cu *cu)
13622 struct objfile *objfile = cu->objfile;
13625 /* Add a symbol associated to this if we haven't seen the namespace
13626 before. Also, add a using directive if it's an anonymous
13629 if (dwarf2_attr (die, DW_AT_extension, cu) == NULL)
13633 type = read_type_die (die, cu);
13634 new_symbol (die, type, cu);
13636 namespace_name (die, &is_anonymous, cu);
13639 const char *previous_prefix = determine_prefix (die, cu);
13641 cp_add_using_directive (previous_prefix, TYPE_NAME (type), NULL,
13642 NULL, NULL, 0, &objfile->objfile_obstack);
13646 if (die->child != NULL)
13648 struct die_info *child_die = die->child;
13650 while (child_die && child_die->tag)
13652 process_die (child_die, cu);
13653 child_die = sibling_die (child_die);
13658 /* Read a Fortran module as type. This DIE can be only a declaration used for
13659 imported module. Still we need that type as local Fortran "use ... only"
13660 declaration imports depend on the created type in determine_prefix. */
13662 static struct type *
13663 read_module_type (struct die_info *die, struct dwarf2_cu *cu)
13665 struct objfile *objfile = cu->objfile;
13666 const char *module_name;
13669 module_name = dwarf2_name (die, cu);
13671 complaint (&symfile_complaints,
13672 _("DW_TAG_module has no name, offset 0x%x"),
13673 die->offset.sect_off);
13674 type = init_type (TYPE_CODE_MODULE, 0, 0, module_name, objfile);
13676 /* determine_prefix uses TYPE_TAG_NAME. */
13677 TYPE_TAG_NAME (type) = TYPE_NAME (type);
13679 return set_die_type (die, type, cu);
13682 /* Read a Fortran module. */
13685 read_module (struct die_info *die, struct dwarf2_cu *cu)
13687 struct die_info *child_die = die->child;
13690 type = read_type_die (die, cu);
13691 new_symbol (die, type, cu);
13693 while (child_die && child_die->tag)
13695 process_die (child_die, cu);
13696 child_die = sibling_die (child_die);
13700 /* Return the name of the namespace represented by DIE. Set
13701 *IS_ANONYMOUS to tell whether or not the namespace is an anonymous
13704 static const char *
13705 namespace_name (struct die_info *die, int *is_anonymous, struct dwarf2_cu *cu)
13707 struct die_info *current_die;
13708 const char *name = NULL;
13710 /* Loop through the extensions until we find a name. */
13712 for (current_die = die;
13713 current_die != NULL;
13714 current_die = dwarf2_extension (die, &cu))
13716 name = dwarf2_name (current_die, cu);
13721 /* Is it an anonymous namespace? */
13723 *is_anonymous = (name == NULL);
13725 name = CP_ANONYMOUS_NAMESPACE_STR;
13730 /* Extract all information from a DW_TAG_pointer_type DIE and add to
13731 the user defined type vector. */
13733 static struct type *
13734 read_tag_pointer_type (struct die_info *die, struct dwarf2_cu *cu)
13736 struct gdbarch *gdbarch = get_objfile_arch (cu->objfile);
13737 struct comp_unit_head *cu_header = &cu->header;
13739 struct attribute *attr_byte_size;
13740 struct attribute *attr_address_class;
13741 int byte_size, addr_class;
13742 struct type *target_type;
13744 target_type = die_type (die, cu);
13746 /* The die_type call above may have already set the type for this DIE. */
13747 type = get_die_type (die, cu);
13751 type = lookup_pointer_type (target_type);
13753 attr_byte_size = dwarf2_attr (die, DW_AT_byte_size, cu);
13754 if (attr_byte_size)
13755 byte_size = DW_UNSND (attr_byte_size);
13757 byte_size = cu_header->addr_size;
13759 attr_address_class = dwarf2_attr (die, DW_AT_address_class, cu);
13760 if (attr_address_class)
13761 addr_class = DW_UNSND (attr_address_class);
13763 addr_class = DW_ADDR_none;
13765 /* If the pointer size or address class is different than the
13766 default, create a type variant marked as such and set the
13767 length accordingly. */
13768 if (TYPE_LENGTH (type) != byte_size || addr_class != DW_ADDR_none)
13770 if (gdbarch_address_class_type_flags_p (gdbarch))
13774 type_flags = gdbarch_address_class_type_flags
13775 (gdbarch, byte_size, addr_class);
13776 gdb_assert ((type_flags & ~TYPE_INSTANCE_FLAG_ADDRESS_CLASS_ALL)
13778 type = make_type_with_address_space (type, type_flags);
13780 else if (TYPE_LENGTH (type) != byte_size)
13782 complaint (&symfile_complaints,
13783 _("invalid pointer size %d"), byte_size);
13787 /* Should we also complain about unhandled address classes? */
13791 TYPE_LENGTH (type) = byte_size;
13792 return set_die_type (die, type, cu);
13795 /* Extract all information from a DW_TAG_ptr_to_member_type DIE and add to
13796 the user defined type vector. */
13798 static struct type *
13799 read_tag_ptr_to_member_type (struct die_info *die, struct dwarf2_cu *cu)
13802 struct type *to_type;
13803 struct type *domain;
13805 to_type = die_type (die, cu);
13806 domain = die_containing_type (die, cu);
13808 /* The calls above may have already set the type for this DIE. */
13809 type = get_die_type (die, cu);
13813 if (TYPE_CODE (check_typedef (to_type)) == TYPE_CODE_METHOD)
13814 type = lookup_methodptr_type (to_type);
13815 else if (TYPE_CODE (check_typedef (to_type)) == TYPE_CODE_FUNC)
13817 struct type *new_type = alloc_type (cu->objfile);
13819 smash_to_method_type (new_type, domain, TYPE_TARGET_TYPE (to_type),
13820 TYPE_FIELDS (to_type), TYPE_NFIELDS (to_type),
13821 TYPE_VARARGS (to_type));
13822 type = lookup_methodptr_type (new_type);
13825 type = lookup_memberptr_type (to_type, domain);
13827 return set_die_type (die, type, cu);
13830 /* Extract all information from a DW_TAG_reference_type DIE and add to
13831 the user defined type vector. */
13833 static struct type *
13834 read_tag_reference_type (struct die_info *die, struct dwarf2_cu *cu)
13836 struct comp_unit_head *cu_header = &cu->header;
13837 struct type *type, *target_type;
13838 struct attribute *attr;
13840 target_type = die_type (die, cu);
13842 /* The die_type call above may have already set the type for this DIE. */
13843 type = get_die_type (die, cu);
13847 type = lookup_reference_type (target_type);
13848 attr = dwarf2_attr (die, DW_AT_byte_size, cu);
13851 TYPE_LENGTH (type) = DW_UNSND (attr);
13855 TYPE_LENGTH (type) = cu_header->addr_size;
13857 return set_die_type (die, type, cu);
13860 static struct type *
13861 read_tag_const_type (struct die_info *die, struct dwarf2_cu *cu)
13863 struct type *base_type, *cv_type;
13865 base_type = die_type (die, cu);
13867 /* The die_type call above may have already set the type for this DIE. */
13868 cv_type = get_die_type (die, cu);
13872 /* In case the const qualifier is applied to an array type, the element type
13873 is so qualified, not the array type (section 6.7.3 of C99). */
13874 if (TYPE_CODE (base_type) == TYPE_CODE_ARRAY)
13876 struct type *el_type, *inner_array;
13878 base_type = copy_type (base_type);
13879 inner_array = base_type;
13881 while (TYPE_CODE (TYPE_TARGET_TYPE (inner_array)) == TYPE_CODE_ARRAY)
13883 TYPE_TARGET_TYPE (inner_array) =
13884 copy_type (TYPE_TARGET_TYPE (inner_array));
13885 inner_array = TYPE_TARGET_TYPE (inner_array);
13888 el_type = TYPE_TARGET_TYPE (inner_array);
13889 TYPE_TARGET_TYPE (inner_array) =
13890 make_cv_type (1, TYPE_VOLATILE (el_type), el_type, NULL);
13892 return set_die_type (die, base_type, cu);
13895 cv_type = make_cv_type (1, TYPE_VOLATILE (base_type), base_type, 0);
13896 return set_die_type (die, cv_type, cu);
13899 static struct type *
13900 read_tag_volatile_type (struct die_info *die, struct dwarf2_cu *cu)
13902 struct type *base_type, *cv_type;
13904 base_type = die_type (die, cu);
13906 /* The die_type call above may have already set the type for this DIE. */
13907 cv_type = get_die_type (die, cu);
13911 cv_type = make_cv_type (TYPE_CONST (base_type), 1, base_type, 0);
13912 return set_die_type (die, cv_type, cu);
13915 /* Handle DW_TAG_restrict_type. */
13917 static struct type *
13918 read_tag_restrict_type (struct die_info *die, struct dwarf2_cu *cu)
13920 struct type *base_type, *cv_type;
13922 base_type = die_type (die, cu);
13924 /* The die_type call above may have already set the type for this DIE. */
13925 cv_type = get_die_type (die, cu);
13929 cv_type = make_restrict_type (base_type);
13930 return set_die_type (die, cv_type, cu);
13933 /* Extract all information from a DW_TAG_string_type DIE and add to
13934 the user defined type vector. It isn't really a user defined type,
13935 but it behaves like one, with other DIE's using an AT_user_def_type
13936 attribute to reference it. */
13938 static struct type *
13939 read_tag_string_type (struct die_info *die, struct dwarf2_cu *cu)
13941 struct objfile *objfile = cu->objfile;
13942 struct gdbarch *gdbarch = get_objfile_arch (objfile);
13943 struct type *type, *range_type, *index_type, *char_type;
13944 struct attribute *attr;
13945 unsigned int length;
13947 attr = dwarf2_attr (die, DW_AT_string_length, cu);
13950 length = DW_UNSND (attr);
13954 /* Check for the DW_AT_byte_size attribute. */
13955 attr = dwarf2_attr (die, DW_AT_byte_size, cu);
13958 length = DW_UNSND (attr);
13966 index_type = objfile_type (objfile)->builtin_int;
13967 range_type = create_range_type (NULL, index_type, 1, length);
13968 char_type = language_string_char_type (cu->language_defn, gdbarch);
13969 type = create_string_type (NULL, char_type, range_type);
13971 return set_die_type (die, type, cu);
13974 /* Assuming that DIE corresponds to a function, returns nonzero
13975 if the function is prototyped. */
13978 prototyped_function_p (struct die_info *die, struct dwarf2_cu *cu)
13980 struct attribute *attr;
13982 attr = dwarf2_attr (die, DW_AT_prototyped, cu);
13983 if (attr && (DW_UNSND (attr) != 0))
13986 /* The DWARF standard implies that the DW_AT_prototyped attribute
13987 is only meaninful for C, but the concept also extends to other
13988 languages that allow unprototyped functions (Eg: Objective C).
13989 For all other languages, assume that functions are always
13991 if (cu->language != language_c
13992 && cu->language != language_objc
13993 && cu->language != language_opencl)
13996 /* RealView does not emit DW_AT_prototyped. We can not distinguish
13997 prototyped and unprototyped functions; default to prototyped,
13998 since that is more common in modern code (and RealView warns
13999 about unprototyped functions). */
14000 if (producer_is_realview (cu->producer))
14006 /* Handle DIES due to C code like:
14010 int (*funcp)(int a, long l);
14014 ('funcp' generates a DW_TAG_subroutine_type DIE). */
14016 static struct type *
14017 read_subroutine_type (struct die_info *die, struct dwarf2_cu *cu)
14019 struct objfile *objfile = cu->objfile;
14020 struct type *type; /* Type that this function returns. */
14021 struct type *ftype; /* Function that returns above type. */
14022 struct attribute *attr;
14024 type = die_type (die, cu);
14026 /* The die_type call above may have already set the type for this DIE. */
14027 ftype = get_die_type (die, cu);
14031 ftype = lookup_function_type (type);
14033 if (prototyped_function_p (die, cu))
14034 TYPE_PROTOTYPED (ftype) = 1;
14036 /* Store the calling convention in the type if it's available in
14037 the subroutine die. Otherwise set the calling convention to
14038 the default value DW_CC_normal. */
14039 attr = dwarf2_attr (die, DW_AT_calling_convention, cu);
14041 TYPE_CALLING_CONVENTION (ftype) = DW_UNSND (attr);
14042 else if (cu->producer && strstr (cu->producer, "IBM XL C for OpenCL"))
14043 TYPE_CALLING_CONVENTION (ftype) = DW_CC_GDB_IBM_OpenCL;
14045 TYPE_CALLING_CONVENTION (ftype) = DW_CC_normal;
14047 /* We need to add the subroutine type to the die immediately so
14048 we don't infinitely recurse when dealing with parameters
14049 declared as the same subroutine type. */
14050 set_die_type (die, ftype, cu);
14052 if (die->child != NULL)
14054 struct type *void_type = objfile_type (objfile)->builtin_void;
14055 struct die_info *child_die;
14056 int nparams, iparams;
14058 /* Count the number of parameters.
14059 FIXME: GDB currently ignores vararg functions, but knows about
14060 vararg member functions. */
14062 child_die = die->child;
14063 while (child_die && child_die->tag)
14065 if (child_die->tag == DW_TAG_formal_parameter)
14067 else if (child_die->tag == DW_TAG_unspecified_parameters)
14068 TYPE_VARARGS (ftype) = 1;
14069 child_die = sibling_die (child_die);
14072 /* Allocate storage for parameters and fill them in. */
14073 TYPE_NFIELDS (ftype) = nparams;
14074 TYPE_FIELDS (ftype) = (struct field *)
14075 TYPE_ZALLOC (ftype, nparams * sizeof (struct field));
14077 /* TYPE_FIELD_TYPE must never be NULL. Pre-fill the array to ensure it
14078 even if we error out during the parameters reading below. */
14079 for (iparams = 0; iparams < nparams; iparams++)
14080 TYPE_FIELD_TYPE (ftype, iparams) = void_type;
14083 child_die = die->child;
14084 while (child_die && child_die->tag)
14086 if (child_die->tag == DW_TAG_formal_parameter)
14088 struct type *arg_type;
14090 /* DWARF version 2 has no clean way to discern C++
14091 static and non-static member functions. G++ helps
14092 GDB by marking the first parameter for non-static
14093 member functions (which is the this pointer) as
14094 artificial. We pass this information to
14095 dwarf2_add_member_fn via TYPE_FIELD_ARTIFICIAL.
14097 DWARF version 3 added DW_AT_object_pointer, which GCC
14098 4.5 does not yet generate. */
14099 attr = dwarf2_attr (child_die, DW_AT_artificial, cu);
14101 TYPE_FIELD_ARTIFICIAL (ftype, iparams) = DW_UNSND (attr);
14104 TYPE_FIELD_ARTIFICIAL (ftype, iparams) = 0;
14106 /* GCC/43521: In java, the formal parameter
14107 "this" is sometimes not marked with DW_AT_artificial. */
14108 if (cu->language == language_java)
14110 const char *name = dwarf2_name (child_die, cu);
14112 if (name && !strcmp (name, "this"))
14113 TYPE_FIELD_ARTIFICIAL (ftype, iparams) = 1;
14116 arg_type = die_type (child_die, cu);
14118 /* RealView does not mark THIS as const, which the testsuite
14119 expects. GCC marks THIS as const in method definitions,
14120 but not in the class specifications (GCC PR 43053). */
14121 if (cu->language == language_cplus && !TYPE_CONST (arg_type)
14122 && TYPE_FIELD_ARTIFICIAL (ftype, iparams))
14125 struct dwarf2_cu *arg_cu = cu;
14126 const char *name = dwarf2_name (child_die, cu);
14128 attr = dwarf2_attr (die, DW_AT_object_pointer, cu);
14131 /* If the compiler emits this, use it. */
14132 if (follow_die_ref (die, attr, &arg_cu) == child_die)
14135 else if (name && strcmp (name, "this") == 0)
14136 /* Function definitions will have the argument names. */
14138 else if (name == NULL && iparams == 0)
14139 /* Declarations may not have the names, so like
14140 elsewhere in GDB, assume an artificial first
14141 argument is "this". */
14145 arg_type = make_cv_type (1, TYPE_VOLATILE (arg_type),
14149 TYPE_FIELD_TYPE (ftype, iparams) = arg_type;
14152 child_die = sibling_die (child_die);
14159 static struct type *
14160 read_typedef (struct die_info *die, struct dwarf2_cu *cu)
14162 struct objfile *objfile = cu->objfile;
14163 const char *name = NULL;
14164 struct type *this_type, *target_type;
14166 name = dwarf2_full_name (NULL, die, cu);
14167 this_type = init_type (TYPE_CODE_TYPEDEF, 0,
14168 TYPE_FLAG_TARGET_STUB, NULL, objfile);
14169 TYPE_NAME (this_type) = name;
14170 set_die_type (die, this_type, cu);
14171 target_type = die_type (die, cu);
14172 if (target_type != this_type)
14173 TYPE_TARGET_TYPE (this_type) = target_type;
14176 /* Self-referential typedefs are, it seems, not allowed by the DWARF
14177 spec and cause infinite loops in GDB. */
14178 complaint (&symfile_complaints,
14179 _("Self-referential DW_TAG_typedef "
14180 "- DIE at 0x%x [in module %s]"),
14181 die->offset.sect_off, objfile_name (objfile));
14182 TYPE_TARGET_TYPE (this_type) = NULL;
14187 /* Find a representation of a given base type and install
14188 it in the TYPE field of the die. */
14190 static struct type *
14191 read_base_type (struct die_info *die, struct dwarf2_cu *cu)
14193 struct objfile *objfile = cu->objfile;
14195 struct attribute *attr;
14196 int encoding = 0, size = 0;
14198 enum type_code code = TYPE_CODE_INT;
14199 int type_flags = 0;
14200 struct type *target_type = NULL;
14202 attr = dwarf2_attr (die, DW_AT_encoding, cu);
14205 encoding = DW_UNSND (attr);
14207 attr = dwarf2_attr (die, DW_AT_byte_size, cu);
14210 size = DW_UNSND (attr);
14212 name = dwarf2_name (die, cu);
14215 complaint (&symfile_complaints,
14216 _("DW_AT_name missing from DW_TAG_base_type"));
14221 case DW_ATE_address:
14222 /* Turn DW_ATE_address into a void * pointer. */
14223 code = TYPE_CODE_PTR;
14224 type_flags |= TYPE_FLAG_UNSIGNED;
14225 target_type = init_type (TYPE_CODE_VOID, 1, 0, NULL, objfile);
14227 case DW_ATE_boolean:
14228 code = TYPE_CODE_BOOL;
14229 type_flags |= TYPE_FLAG_UNSIGNED;
14231 case DW_ATE_complex_float:
14232 code = TYPE_CODE_COMPLEX;
14233 target_type = init_type (TYPE_CODE_FLT, size / 2, 0, NULL, objfile);
14235 case DW_ATE_decimal_float:
14236 code = TYPE_CODE_DECFLOAT;
14239 code = TYPE_CODE_FLT;
14241 case DW_ATE_signed:
14243 case DW_ATE_unsigned:
14244 type_flags |= TYPE_FLAG_UNSIGNED;
14245 if (cu->language == language_fortran
14247 && strncmp (name, "character(", sizeof ("character(") - 1) == 0)
14248 code = TYPE_CODE_CHAR;
14250 case DW_ATE_signed_char:
14251 if (cu->language == language_ada || cu->language == language_m2
14252 || cu->language == language_pascal
14253 || cu->language == language_fortran)
14254 code = TYPE_CODE_CHAR;
14256 case DW_ATE_unsigned_char:
14257 if (cu->language == language_ada || cu->language == language_m2
14258 || cu->language == language_pascal
14259 || cu->language == language_fortran)
14260 code = TYPE_CODE_CHAR;
14261 type_flags |= TYPE_FLAG_UNSIGNED;
14264 /* We just treat this as an integer and then recognize the
14265 type by name elsewhere. */
14269 complaint (&symfile_complaints, _("unsupported DW_AT_encoding: '%s'"),
14270 dwarf_type_encoding_name (encoding));
14274 type = init_type (code, size, type_flags, NULL, objfile);
14275 TYPE_NAME (type) = name;
14276 TYPE_TARGET_TYPE (type) = target_type;
14278 if (name && strcmp (name, "char") == 0)
14279 TYPE_NOSIGN (type) = 1;
14281 return set_die_type (die, type, cu);
14284 /* Read the given DW_AT_subrange DIE. */
14286 static struct type *
14287 read_subrange_type (struct die_info *die, struct dwarf2_cu *cu)
14289 struct type *base_type, *orig_base_type;
14290 struct type *range_type;
14291 struct attribute *attr;
14293 int low_default_is_valid;
14295 LONGEST negative_mask;
14297 orig_base_type = die_type (die, cu);
14298 /* If ORIG_BASE_TYPE is a typedef, it will not be TYPE_UNSIGNED,
14299 whereas the real type might be. So, we use ORIG_BASE_TYPE when
14300 creating the range type, but we use the result of check_typedef
14301 when examining properties of the type. */
14302 base_type = check_typedef (orig_base_type);
14304 /* The die_type call above may have already set the type for this DIE. */
14305 range_type = get_die_type (die, cu);
14309 /* Set LOW_DEFAULT_IS_VALID if current language and DWARF version allow
14310 omitting DW_AT_lower_bound. */
14311 switch (cu->language)
14314 case language_cplus:
14316 low_default_is_valid = 1;
14318 case language_fortran:
14320 low_default_is_valid = 1;
14323 case language_java:
14324 case language_objc:
14326 low_default_is_valid = (cu->header.version >= 4);
14330 case language_pascal:
14332 low_default_is_valid = (cu->header.version >= 4);
14336 low_default_is_valid = 0;
14340 /* FIXME: For variable sized arrays either of these could be
14341 a variable rather than a constant value. We'll allow it,
14342 but we don't know how to handle it. */
14343 attr = dwarf2_attr (die, DW_AT_lower_bound, cu);
14345 low = dwarf2_get_attr_constant_value (attr, low);
14346 else if (!low_default_is_valid)
14347 complaint (&symfile_complaints, _("Missing DW_AT_lower_bound "
14348 "- DIE at 0x%x [in module %s]"),
14349 die->offset.sect_off, objfile_name (cu->objfile));
14351 attr = dwarf2_attr (die, DW_AT_upper_bound, cu);
14354 if (attr_form_is_block (attr) || attr_form_is_ref (attr))
14356 /* GCC encodes arrays with unspecified or dynamic length
14357 with a DW_FORM_block1 attribute or a reference attribute.
14358 FIXME: GDB does not yet know how to handle dynamic
14359 arrays properly, treat them as arrays with unspecified
14362 FIXME: jimb/2003-09-22: GDB does not really know
14363 how to handle arrays of unspecified length
14364 either; we just represent them as zero-length
14365 arrays. Choose an appropriate upper bound given
14366 the lower bound we've computed above. */
14370 high = dwarf2_get_attr_constant_value (attr, 1);
14374 attr = dwarf2_attr (die, DW_AT_count, cu);
14377 int count = dwarf2_get_attr_constant_value (attr, 1);
14378 high = low + count - 1;
14382 /* Unspecified array length. */
14387 /* Dwarf-2 specifications explicitly allows to create subrange types
14388 without specifying a base type.
14389 In that case, the base type must be set to the type of
14390 the lower bound, upper bound or count, in that order, if any of these
14391 three attributes references an object that has a type.
14392 If no base type is found, the Dwarf-2 specifications say that
14393 a signed integer type of size equal to the size of an address should
14395 For the following C code: `extern char gdb_int [];'
14396 GCC produces an empty range DIE.
14397 FIXME: muller/2010-05-28: Possible references to object for low bound,
14398 high bound or count are not yet handled by this code. */
14399 if (TYPE_CODE (base_type) == TYPE_CODE_VOID)
14401 struct objfile *objfile = cu->objfile;
14402 struct gdbarch *gdbarch = get_objfile_arch (objfile);
14403 int addr_size = gdbarch_addr_bit (gdbarch) /8;
14404 struct type *int_type = objfile_type (objfile)->builtin_int;
14406 /* Test "int", "long int", and "long long int" objfile types,
14407 and select the first one having a size above or equal to the
14408 architecture address size. */
14409 if (int_type && TYPE_LENGTH (int_type) >= addr_size)
14410 base_type = int_type;
14413 int_type = objfile_type (objfile)->builtin_long;
14414 if (int_type && TYPE_LENGTH (int_type) >= addr_size)
14415 base_type = int_type;
14418 int_type = objfile_type (objfile)->builtin_long_long;
14419 if (int_type && TYPE_LENGTH (int_type) >= addr_size)
14420 base_type = int_type;
14426 (LONGEST) -1 << (TYPE_LENGTH (base_type) * TARGET_CHAR_BIT - 1);
14427 if (!TYPE_UNSIGNED (base_type) && (low & negative_mask))
14428 low |= negative_mask;
14429 if (!TYPE_UNSIGNED (base_type) && (high & negative_mask))
14430 high |= negative_mask;
14432 range_type = create_range_type (NULL, orig_base_type, low, high);
14434 /* Mark arrays with dynamic length at least as an array of unspecified
14435 length. GDB could check the boundary but before it gets implemented at
14436 least allow accessing the array elements. */
14437 if (attr && attr_form_is_block (attr))
14438 TYPE_HIGH_BOUND_UNDEFINED (range_type) = 1;
14440 /* Ada expects an empty array on no boundary attributes. */
14441 if (attr == NULL && cu->language != language_ada)
14442 TYPE_HIGH_BOUND_UNDEFINED (range_type) = 1;
14444 name = dwarf2_name (die, cu);
14446 TYPE_NAME (range_type) = name;
14448 attr = dwarf2_attr (die, DW_AT_byte_size, cu);
14450 TYPE_LENGTH (range_type) = DW_UNSND (attr);
14452 set_die_type (die, range_type, cu);
14454 /* set_die_type should be already done. */
14455 set_descriptive_type (range_type, die, cu);
14460 static struct type *
14461 read_unspecified_type (struct die_info *die, struct dwarf2_cu *cu)
14465 /* For now, we only support the C meaning of an unspecified type: void. */
14467 type = init_type (TYPE_CODE_VOID, 0, 0, NULL, cu->objfile);
14468 TYPE_NAME (type) = dwarf2_name (die, cu);
14470 return set_die_type (die, type, cu);
14473 /* Read a single die and all its descendents. Set the die's sibling
14474 field to NULL; set other fields in the die correctly, and set all
14475 of the descendents' fields correctly. Set *NEW_INFO_PTR to the
14476 location of the info_ptr after reading all of those dies. PARENT
14477 is the parent of the die in question. */
14479 static struct die_info *
14480 read_die_and_children (const struct die_reader_specs *reader,
14481 const gdb_byte *info_ptr,
14482 const gdb_byte **new_info_ptr,
14483 struct die_info *parent)
14485 struct die_info *die;
14486 const gdb_byte *cur_ptr;
14489 cur_ptr = read_full_die_1 (reader, &die, info_ptr, &has_children, 0);
14492 *new_info_ptr = cur_ptr;
14495 store_in_ref_table (die, reader->cu);
14498 die->child = read_die_and_siblings_1 (reader, cur_ptr, new_info_ptr, die);
14502 *new_info_ptr = cur_ptr;
14505 die->sibling = NULL;
14506 die->parent = parent;
14510 /* Read a die, all of its descendents, and all of its siblings; set
14511 all of the fields of all of the dies correctly. Arguments are as
14512 in read_die_and_children. */
14514 static struct die_info *
14515 read_die_and_siblings_1 (const struct die_reader_specs *reader,
14516 const gdb_byte *info_ptr,
14517 const gdb_byte **new_info_ptr,
14518 struct die_info *parent)
14520 struct die_info *first_die, *last_sibling;
14521 const gdb_byte *cur_ptr;
14523 cur_ptr = info_ptr;
14524 first_die = last_sibling = NULL;
14528 struct die_info *die
14529 = read_die_and_children (reader, cur_ptr, &cur_ptr, parent);
14533 *new_info_ptr = cur_ptr;
14540 last_sibling->sibling = die;
14542 last_sibling = die;
14546 /* Read a die, all of its descendents, and all of its siblings; set
14547 all of the fields of all of the dies correctly. Arguments are as
14548 in read_die_and_children.
14549 This the main entry point for reading a DIE and all its children. */
14551 static struct die_info *
14552 read_die_and_siblings (const struct die_reader_specs *reader,
14553 const gdb_byte *info_ptr,
14554 const gdb_byte **new_info_ptr,
14555 struct die_info *parent)
14557 struct die_info *die = read_die_and_siblings_1 (reader, info_ptr,
14558 new_info_ptr, parent);
14560 if (dwarf2_die_debug)
14562 fprintf_unfiltered (gdb_stdlog,
14563 "Read die from %s@0x%x of %s:\n",
14564 get_section_name (reader->die_section),
14565 (unsigned) (info_ptr - reader->die_section->buffer),
14566 bfd_get_filename (reader->abfd));
14567 dump_die (die, dwarf2_die_debug);
14573 /* Read a die and all its attributes, leave space for NUM_EXTRA_ATTRS
14575 The caller is responsible for filling in the extra attributes
14576 and updating (*DIEP)->num_attrs.
14577 Set DIEP to point to a newly allocated die with its information,
14578 except for its child, sibling, and parent fields.
14579 Set HAS_CHILDREN to tell whether the die has children or not. */
14581 static const gdb_byte *
14582 read_full_die_1 (const struct die_reader_specs *reader,
14583 struct die_info **diep, const gdb_byte *info_ptr,
14584 int *has_children, int num_extra_attrs)
14586 unsigned int abbrev_number, bytes_read, i;
14587 sect_offset offset;
14588 struct abbrev_info *abbrev;
14589 struct die_info *die;
14590 struct dwarf2_cu *cu = reader->cu;
14591 bfd *abfd = reader->abfd;
14593 offset.sect_off = info_ptr - reader->buffer;
14594 abbrev_number = read_unsigned_leb128 (abfd, info_ptr, &bytes_read);
14595 info_ptr += bytes_read;
14596 if (!abbrev_number)
14603 abbrev = abbrev_table_lookup_abbrev (cu->abbrev_table, abbrev_number);
14605 error (_("Dwarf Error: could not find abbrev number %d [in module %s]"),
14607 bfd_get_filename (abfd));
14609 die = dwarf_alloc_die (cu, abbrev->num_attrs + num_extra_attrs);
14610 die->offset = offset;
14611 die->tag = abbrev->tag;
14612 die->abbrev = abbrev_number;
14614 /* Make the result usable.
14615 The caller needs to update num_attrs after adding the extra
14617 die->num_attrs = abbrev->num_attrs;
14619 for (i = 0; i < abbrev->num_attrs; ++i)
14620 info_ptr = read_attribute (reader, &die->attrs[i], &abbrev->attrs[i],
14624 *has_children = abbrev->has_children;
14628 /* Read a die and all its attributes.
14629 Set DIEP to point to a newly allocated die with its information,
14630 except for its child, sibling, and parent fields.
14631 Set HAS_CHILDREN to tell whether the die has children or not. */
14633 static const gdb_byte *
14634 read_full_die (const struct die_reader_specs *reader,
14635 struct die_info **diep, const gdb_byte *info_ptr,
14638 const gdb_byte *result;
14640 result = read_full_die_1 (reader, diep, info_ptr, has_children, 0);
14642 if (dwarf2_die_debug)
14644 fprintf_unfiltered (gdb_stdlog,
14645 "Read die from %s@0x%x of %s:\n",
14646 get_section_name (reader->die_section),
14647 (unsigned) (info_ptr - reader->die_section->buffer),
14648 bfd_get_filename (reader->abfd));
14649 dump_die (*diep, dwarf2_die_debug);
14655 /* Abbreviation tables.
14657 In DWARF version 2, the description of the debugging information is
14658 stored in a separate .debug_abbrev section. Before we read any
14659 dies from a section we read in all abbreviations and install them
14660 in a hash table. */
14662 /* Allocate space for a struct abbrev_info object in ABBREV_TABLE. */
14664 static struct abbrev_info *
14665 abbrev_table_alloc_abbrev (struct abbrev_table *abbrev_table)
14667 struct abbrev_info *abbrev;
14669 abbrev = (struct abbrev_info *)
14670 obstack_alloc (&abbrev_table->abbrev_obstack, sizeof (struct abbrev_info));
14671 memset (abbrev, 0, sizeof (struct abbrev_info));
14675 /* Add an abbreviation to the table. */
14678 abbrev_table_add_abbrev (struct abbrev_table *abbrev_table,
14679 unsigned int abbrev_number,
14680 struct abbrev_info *abbrev)
14682 unsigned int hash_number;
14684 hash_number = abbrev_number % ABBREV_HASH_SIZE;
14685 abbrev->next = abbrev_table->abbrevs[hash_number];
14686 abbrev_table->abbrevs[hash_number] = abbrev;
14689 /* Look up an abbrev in the table.
14690 Returns NULL if the abbrev is not found. */
14692 static struct abbrev_info *
14693 abbrev_table_lookup_abbrev (const struct abbrev_table *abbrev_table,
14694 unsigned int abbrev_number)
14696 unsigned int hash_number;
14697 struct abbrev_info *abbrev;
14699 hash_number = abbrev_number % ABBREV_HASH_SIZE;
14700 abbrev = abbrev_table->abbrevs[hash_number];
14704 if (abbrev->number == abbrev_number)
14706 abbrev = abbrev->next;
14711 /* Read in an abbrev table. */
14713 static struct abbrev_table *
14714 abbrev_table_read_table (struct dwarf2_section_info *section,
14715 sect_offset offset)
14717 struct objfile *objfile = dwarf2_per_objfile->objfile;
14718 bfd *abfd = get_section_bfd_owner (section);
14719 struct abbrev_table *abbrev_table;
14720 const gdb_byte *abbrev_ptr;
14721 struct abbrev_info *cur_abbrev;
14722 unsigned int abbrev_number, bytes_read, abbrev_name;
14723 unsigned int abbrev_form;
14724 struct attr_abbrev *cur_attrs;
14725 unsigned int allocated_attrs;
14727 abbrev_table = XNEW (struct abbrev_table);
14728 abbrev_table->offset = offset;
14729 obstack_init (&abbrev_table->abbrev_obstack);
14730 abbrev_table->abbrevs = obstack_alloc (&abbrev_table->abbrev_obstack,
14732 * sizeof (struct abbrev_info *)));
14733 memset (abbrev_table->abbrevs, 0,
14734 ABBREV_HASH_SIZE * sizeof (struct abbrev_info *));
14736 dwarf2_read_section (objfile, section);
14737 abbrev_ptr = section->buffer + offset.sect_off;
14738 abbrev_number = read_unsigned_leb128 (abfd, abbrev_ptr, &bytes_read);
14739 abbrev_ptr += bytes_read;
14741 allocated_attrs = ATTR_ALLOC_CHUNK;
14742 cur_attrs = xmalloc (allocated_attrs * sizeof (struct attr_abbrev));
14744 /* Loop until we reach an abbrev number of 0. */
14745 while (abbrev_number)
14747 cur_abbrev = abbrev_table_alloc_abbrev (abbrev_table);
14749 /* read in abbrev header */
14750 cur_abbrev->number = abbrev_number;
14751 cur_abbrev->tag = read_unsigned_leb128 (abfd, abbrev_ptr, &bytes_read);
14752 abbrev_ptr += bytes_read;
14753 cur_abbrev->has_children = read_1_byte (abfd, abbrev_ptr);
14756 /* now read in declarations */
14757 abbrev_name = read_unsigned_leb128 (abfd, abbrev_ptr, &bytes_read);
14758 abbrev_ptr += bytes_read;
14759 abbrev_form = read_unsigned_leb128 (abfd, abbrev_ptr, &bytes_read);
14760 abbrev_ptr += bytes_read;
14761 while (abbrev_name)
14763 if (cur_abbrev->num_attrs == allocated_attrs)
14765 allocated_attrs += ATTR_ALLOC_CHUNK;
14767 = xrealloc (cur_attrs, (allocated_attrs
14768 * sizeof (struct attr_abbrev)));
14771 cur_attrs[cur_abbrev->num_attrs].name = abbrev_name;
14772 cur_attrs[cur_abbrev->num_attrs++].form = abbrev_form;
14773 abbrev_name = read_unsigned_leb128 (abfd, abbrev_ptr, &bytes_read);
14774 abbrev_ptr += bytes_read;
14775 abbrev_form = read_unsigned_leb128 (abfd, abbrev_ptr, &bytes_read);
14776 abbrev_ptr += bytes_read;
14779 cur_abbrev->attrs = obstack_alloc (&abbrev_table->abbrev_obstack,
14780 (cur_abbrev->num_attrs
14781 * sizeof (struct attr_abbrev)));
14782 memcpy (cur_abbrev->attrs, cur_attrs,
14783 cur_abbrev->num_attrs * sizeof (struct attr_abbrev));
14785 abbrev_table_add_abbrev (abbrev_table, abbrev_number, cur_abbrev);
14787 /* Get next abbreviation.
14788 Under Irix6 the abbreviations for a compilation unit are not
14789 always properly terminated with an abbrev number of 0.
14790 Exit loop if we encounter an abbreviation which we have
14791 already read (which means we are about to read the abbreviations
14792 for the next compile unit) or if the end of the abbreviation
14793 table is reached. */
14794 if ((unsigned int) (abbrev_ptr - section->buffer) >= section->size)
14796 abbrev_number = read_unsigned_leb128 (abfd, abbrev_ptr, &bytes_read);
14797 abbrev_ptr += bytes_read;
14798 if (abbrev_table_lookup_abbrev (abbrev_table, abbrev_number) != NULL)
14803 return abbrev_table;
14806 /* Free the resources held by ABBREV_TABLE. */
14809 abbrev_table_free (struct abbrev_table *abbrev_table)
14811 obstack_free (&abbrev_table->abbrev_obstack, NULL);
14812 xfree (abbrev_table);
14815 /* Same as abbrev_table_free but as a cleanup.
14816 We pass in a pointer to the pointer to the table so that we can
14817 set the pointer to NULL when we're done. It also simplifies
14818 build_type_unit_groups. */
14821 abbrev_table_free_cleanup (void *table_ptr)
14823 struct abbrev_table **abbrev_table_ptr = table_ptr;
14825 if (*abbrev_table_ptr != NULL)
14826 abbrev_table_free (*abbrev_table_ptr);
14827 *abbrev_table_ptr = NULL;
14830 /* Read the abbrev table for CU from ABBREV_SECTION. */
14833 dwarf2_read_abbrevs (struct dwarf2_cu *cu,
14834 struct dwarf2_section_info *abbrev_section)
14837 abbrev_table_read_table (abbrev_section, cu->header.abbrev_offset);
14840 /* Release the memory used by the abbrev table for a compilation unit. */
14843 dwarf2_free_abbrev_table (void *ptr_to_cu)
14845 struct dwarf2_cu *cu = ptr_to_cu;
14847 if (cu->abbrev_table != NULL)
14848 abbrev_table_free (cu->abbrev_table);
14849 /* Set this to NULL so that we SEGV if we try to read it later,
14850 and also because free_comp_unit verifies this is NULL. */
14851 cu->abbrev_table = NULL;
14854 /* Returns nonzero if TAG represents a type that we might generate a partial
14858 is_type_tag_for_partial (int tag)
14863 /* Some types that would be reasonable to generate partial symbols for,
14864 that we don't at present. */
14865 case DW_TAG_array_type:
14866 case DW_TAG_file_type:
14867 case DW_TAG_ptr_to_member_type:
14868 case DW_TAG_set_type:
14869 case DW_TAG_string_type:
14870 case DW_TAG_subroutine_type:
14872 case DW_TAG_base_type:
14873 case DW_TAG_class_type:
14874 case DW_TAG_interface_type:
14875 case DW_TAG_enumeration_type:
14876 case DW_TAG_structure_type:
14877 case DW_TAG_subrange_type:
14878 case DW_TAG_typedef:
14879 case DW_TAG_union_type:
14886 /* Load all DIEs that are interesting for partial symbols into memory. */
14888 static struct partial_die_info *
14889 load_partial_dies (const struct die_reader_specs *reader,
14890 const gdb_byte *info_ptr, int building_psymtab)
14892 struct dwarf2_cu *cu = reader->cu;
14893 struct objfile *objfile = cu->objfile;
14894 struct partial_die_info *part_die;
14895 struct partial_die_info *parent_die, *last_die, *first_die = NULL;
14896 struct abbrev_info *abbrev;
14897 unsigned int bytes_read;
14898 unsigned int load_all = 0;
14899 int nesting_level = 1;
14904 gdb_assert (cu->per_cu != NULL);
14905 if (cu->per_cu->load_all_dies)
14909 = htab_create_alloc_ex (cu->header.length / 12,
14913 &cu->comp_unit_obstack,
14914 hashtab_obstack_allocate,
14915 dummy_obstack_deallocate);
14917 part_die = obstack_alloc (&cu->comp_unit_obstack,
14918 sizeof (struct partial_die_info));
14922 abbrev = peek_die_abbrev (info_ptr, &bytes_read, cu);
14924 /* A NULL abbrev means the end of a series of children. */
14925 if (abbrev == NULL)
14927 if (--nesting_level == 0)
14929 /* PART_DIE was probably the last thing allocated on the
14930 comp_unit_obstack, so we could call obstack_free
14931 here. We don't do that because the waste is small,
14932 and will be cleaned up when we're done with this
14933 compilation unit. This way, we're also more robust
14934 against other users of the comp_unit_obstack. */
14937 info_ptr += bytes_read;
14938 last_die = parent_die;
14939 parent_die = parent_die->die_parent;
14943 /* Check for template arguments. We never save these; if
14944 they're seen, we just mark the parent, and go on our way. */
14945 if (parent_die != NULL
14946 && cu->language == language_cplus
14947 && (abbrev->tag == DW_TAG_template_type_param
14948 || abbrev->tag == DW_TAG_template_value_param))
14950 parent_die->has_template_arguments = 1;
14954 /* We don't need a partial DIE for the template argument. */
14955 info_ptr = skip_one_die (reader, info_ptr + bytes_read, abbrev);
14960 /* We only recurse into c++ subprograms looking for template arguments.
14961 Skip their other children. */
14963 && cu->language == language_cplus
14964 && parent_die != NULL
14965 && parent_die->tag == DW_TAG_subprogram)
14967 info_ptr = skip_one_die (reader, info_ptr + bytes_read, abbrev);
14971 /* Check whether this DIE is interesting enough to save. Normally
14972 we would not be interested in members here, but there may be
14973 later variables referencing them via DW_AT_specification (for
14974 static members). */
14976 && !is_type_tag_for_partial (abbrev->tag)
14977 && abbrev->tag != DW_TAG_constant
14978 && abbrev->tag != DW_TAG_enumerator
14979 && abbrev->tag != DW_TAG_subprogram
14980 && abbrev->tag != DW_TAG_lexical_block
14981 && abbrev->tag != DW_TAG_variable
14982 && abbrev->tag != DW_TAG_namespace
14983 && abbrev->tag != DW_TAG_module
14984 && abbrev->tag != DW_TAG_member
14985 && abbrev->tag != DW_TAG_imported_unit
14986 && abbrev->tag != DW_TAG_imported_declaration)
14988 /* Otherwise we skip to the next sibling, if any. */
14989 info_ptr = skip_one_die (reader, info_ptr + bytes_read, abbrev);
14993 info_ptr = read_partial_die (reader, part_die, abbrev, bytes_read,
14996 /* This two-pass algorithm for processing partial symbols has a
14997 high cost in cache pressure. Thus, handle some simple cases
14998 here which cover the majority of C partial symbols. DIEs
14999 which neither have specification tags in them, nor could have
15000 specification tags elsewhere pointing at them, can simply be
15001 processed and discarded.
15003 This segment is also optional; scan_partial_symbols and
15004 add_partial_symbol will handle these DIEs if we chain
15005 them in normally. When compilers which do not emit large
15006 quantities of duplicate debug information are more common,
15007 this code can probably be removed. */
15009 /* Any complete simple types at the top level (pretty much all
15010 of them, for a language without namespaces), can be processed
15012 if (parent_die == NULL
15013 && part_die->has_specification == 0
15014 && part_die->is_declaration == 0
15015 && ((part_die->tag == DW_TAG_typedef && !part_die->has_children)
15016 || part_die->tag == DW_TAG_base_type
15017 || part_die->tag == DW_TAG_subrange_type))
15019 if (building_psymtab && part_die->name != NULL)
15020 add_psymbol_to_list (part_die->name, strlen (part_die->name), 0,
15021 VAR_DOMAIN, LOC_TYPEDEF,
15022 &objfile->static_psymbols,
15023 0, (CORE_ADDR) 0, cu->language, objfile);
15024 info_ptr = locate_pdi_sibling (reader, part_die, info_ptr);
15028 /* The exception for DW_TAG_typedef with has_children above is
15029 a workaround of GCC PR debug/47510. In the case of this complaint
15030 type_name_no_tag_or_error will error on such types later.
15032 GDB skipped children of DW_TAG_typedef by the shortcut above and then
15033 it could not find the child DIEs referenced later, this is checked
15034 above. In correct DWARF DW_TAG_typedef should have no children. */
15036 if (part_die->tag == DW_TAG_typedef && part_die->has_children)
15037 complaint (&symfile_complaints,
15038 _("DW_TAG_typedef has childen - GCC PR debug/47510 bug "
15039 "- DIE at 0x%x [in module %s]"),
15040 part_die->offset.sect_off, objfile_name (objfile));
15042 /* If we're at the second level, and we're an enumerator, and
15043 our parent has no specification (meaning possibly lives in a
15044 namespace elsewhere), then we can add the partial symbol now
15045 instead of queueing it. */
15046 if (part_die->tag == DW_TAG_enumerator
15047 && parent_die != NULL
15048 && parent_die->die_parent == NULL
15049 && parent_die->tag == DW_TAG_enumeration_type
15050 && parent_die->has_specification == 0)
15052 if (part_die->name == NULL)
15053 complaint (&symfile_complaints,
15054 _("malformed enumerator DIE ignored"));
15055 else if (building_psymtab)
15056 add_psymbol_to_list (part_die->name, strlen (part_die->name), 0,
15057 VAR_DOMAIN, LOC_CONST,
15058 (cu->language == language_cplus
15059 || cu->language == language_java)
15060 ? &objfile->global_psymbols
15061 : &objfile->static_psymbols,
15062 0, (CORE_ADDR) 0, cu->language, objfile);
15064 info_ptr = locate_pdi_sibling (reader, part_die, info_ptr);
15068 /* We'll save this DIE so link it in. */
15069 part_die->die_parent = parent_die;
15070 part_die->die_sibling = NULL;
15071 part_die->die_child = NULL;
15073 if (last_die && last_die == parent_die)
15074 last_die->die_child = part_die;
15076 last_die->die_sibling = part_die;
15078 last_die = part_die;
15080 if (first_die == NULL)
15081 first_die = part_die;
15083 /* Maybe add the DIE to the hash table. Not all DIEs that we
15084 find interesting need to be in the hash table, because we
15085 also have the parent/sibling/child chains; only those that we
15086 might refer to by offset later during partial symbol reading.
15088 For now this means things that might have be the target of a
15089 DW_AT_specification, DW_AT_abstract_origin, or
15090 DW_AT_extension. DW_AT_extension will refer only to
15091 namespaces; DW_AT_abstract_origin refers to functions (and
15092 many things under the function DIE, but we do not recurse
15093 into function DIEs during partial symbol reading) and
15094 possibly variables as well; DW_AT_specification refers to
15095 declarations. Declarations ought to have the DW_AT_declaration
15096 flag. It happens that GCC forgets to put it in sometimes, but
15097 only for functions, not for types.
15099 Adding more things than necessary to the hash table is harmless
15100 except for the performance cost. Adding too few will result in
15101 wasted time in find_partial_die, when we reread the compilation
15102 unit with load_all_dies set. */
15105 || abbrev->tag == DW_TAG_constant
15106 || abbrev->tag == DW_TAG_subprogram
15107 || abbrev->tag == DW_TAG_variable
15108 || abbrev->tag == DW_TAG_namespace
15109 || part_die->is_declaration)
15113 slot = htab_find_slot_with_hash (cu->partial_dies, part_die,
15114 part_die->offset.sect_off, INSERT);
15118 part_die = obstack_alloc (&cu->comp_unit_obstack,
15119 sizeof (struct partial_die_info));
15121 /* For some DIEs we want to follow their children (if any). For C
15122 we have no reason to follow the children of structures; for other
15123 languages we have to, so that we can get at method physnames
15124 to infer fully qualified class names, for DW_AT_specification,
15125 and for C++ template arguments. For C++, we also look one level
15126 inside functions to find template arguments (if the name of the
15127 function does not already contain the template arguments).
15129 For Ada, we need to scan the children of subprograms and lexical
15130 blocks as well because Ada allows the definition of nested
15131 entities that could be interesting for the debugger, such as
15132 nested subprograms for instance. */
15133 if (last_die->has_children
15135 || last_die->tag == DW_TAG_namespace
15136 || last_die->tag == DW_TAG_module
15137 || last_die->tag == DW_TAG_enumeration_type
15138 || (cu->language == language_cplus
15139 && last_die->tag == DW_TAG_subprogram
15140 && (last_die->name == NULL
15141 || strchr (last_die->name, '<') == NULL))
15142 || (cu->language != language_c
15143 && (last_die->tag == DW_TAG_class_type
15144 || last_die->tag == DW_TAG_interface_type
15145 || last_die->tag == DW_TAG_structure_type
15146 || last_die->tag == DW_TAG_union_type))
15147 || (cu->language == language_ada
15148 && (last_die->tag == DW_TAG_subprogram
15149 || last_die->tag == DW_TAG_lexical_block))))
15152 parent_die = last_die;
15156 /* Otherwise we skip to the next sibling, if any. */
15157 info_ptr = locate_pdi_sibling (reader, last_die, info_ptr);
15159 /* Back to the top, do it again. */
15163 /* Read a minimal amount of information into the minimal die structure. */
15165 static const gdb_byte *
15166 read_partial_die (const struct die_reader_specs *reader,
15167 struct partial_die_info *part_die,
15168 struct abbrev_info *abbrev, unsigned int abbrev_len,
15169 const gdb_byte *info_ptr)
15171 struct dwarf2_cu *cu = reader->cu;
15172 struct objfile *objfile = cu->objfile;
15173 const gdb_byte *buffer = reader->buffer;
15175 struct attribute attr;
15176 int has_low_pc_attr = 0;
15177 int has_high_pc_attr = 0;
15178 int high_pc_relative = 0;
15180 memset (part_die, 0, sizeof (struct partial_die_info));
15182 part_die->offset.sect_off = info_ptr - buffer;
15184 info_ptr += abbrev_len;
15186 if (abbrev == NULL)
15189 part_die->tag = abbrev->tag;
15190 part_die->has_children = abbrev->has_children;
15192 for (i = 0; i < abbrev->num_attrs; ++i)
15194 info_ptr = read_attribute (reader, &attr, &abbrev->attrs[i], info_ptr);
15196 /* Store the data if it is of an attribute we want to keep in a
15197 partial symbol table. */
15201 switch (part_die->tag)
15203 case DW_TAG_compile_unit:
15204 case DW_TAG_partial_unit:
15205 case DW_TAG_type_unit:
15206 /* Compilation units have a DW_AT_name that is a filename, not
15207 a source language identifier. */
15208 case DW_TAG_enumeration_type:
15209 case DW_TAG_enumerator:
15210 /* These tags always have simple identifiers already; no need
15211 to canonicalize them. */
15212 part_die->name = DW_STRING (&attr);
15216 = dwarf2_canonicalize_name (DW_STRING (&attr), cu,
15217 &objfile->objfile_obstack);
15221 case DW_AT_linkage_name:
15222 case DW_AT_MIPS_linkage_name:
15223 /* Note that both forms of linkage name might appear. We
15224 assume they will be the same, and we only store the last
15226 if (cu->language == language_ada)
15227 part_die->name = DW_STRING (&attr);
15228 part_die->linkage_name = DW_STRING (&attr);
15231 has_low_pc_attr = 1;
15232 part_die->lowpc = DW_ADDR (&attr);
15234 case DW_AT_high_pc:
15235 has_high_pc_attr = 1;
15236 if (attr.form == DW_FORM_addr
15237 || attr.form == DW_FORM_GNU_addr_index)
15238 part_die->highpc = DW_ADDR (&attr);
15241 high_pc_relative = 1;
15242 part_die->highpc = DW_UNSND (&attr);
15245 case DW_AT_location:
15246 /* Support the .debug_loc offsets. */
15247 if (attr_form_is_block (&attr))
15249 part_die->d.locdesc = DW_BLOCK (&attr);
15251 else if (attr_form_is_section_offset (&attr))
15253 dwarf2_complex_location_expr_complaint ();
15257 dwarf2_invalid_attrib_class_complaint ("DW_AT_location",
15258 "partial symbol information");
15261 case DW_AT_external:
15262 part_die->is_external = DW_UNSND (&attr);
15264 case DW_AT_declaration:
15265 part_die->is_declaration = DW_UNSND (&attr);
15268 part_die->has_type = 1;
15270 case DW_AT_abstract_origin:
15271 case DW_AT_specification:
15272 case DW_AT_extension:
15273 part_die->has_specification = 1;
15274 part_die->spec_offset = dwarf2_get_ref_die_offset (&attr);
15275 part_die->spec_is_dwz = (attr.form == DW_FORM_GNU_ref_alt
15276 || cu->per_cu->is_dwz);
15278 case DW_AT_sibling:
15279 /* Ignore absolute siblings, they might point outside of
15280 the current compile unit. */
15281 if (attr.form == DW_FORM_ref_addr)
15282 complaint (&symfile_complaints,
15283 _("ignoring absolute DW_AT_sibling"));
15286 unsigned int off = dwarf2_get_ref_die_offset (&attr).sect_off;
15287 const gdb_byte *sibling_ptr = buffer + off;
15289 if (sibling_ptr < info_ptr)
15290 complaint (&symfile_complaints,
15291 _("DW_AT_sibling points backwards"));
15293 part_die->sibling = sibling_ptr;
15296 case DW_AT_byte_size:
15297 part_die->has_byte_size = 1;
15299 case DW_AT_calling_convention:
15300 /* DWARF doesn't provide a way to identify a program's source-level
15301 entry point. DW_AT_calling_convention attributes are only meant
15302 to describe functions' calling conventions.
15304 However, because it's a necessary piece of information in
15305 Fortran, and because DW_CC_program is the only piece of debugging
15306 information whose definition refers to a 'main program' at all,
15307 several compilers have begun marking Fortran main programs with
15308 DW_CC_program --- even when those functions use the standard
15309 calling conventions.
15311 So until DWARF specifies a way to provide this information and
15312 compilers pick up the new representation, we'll support this
15314 if (DW_UNSND (&attr) == DW_CC_program
15315 && cu->language == language_fortran)
15317 set_main_name (part_die->name);
15319 /* As this DIE has a static linkage the name would be difficult
15320 to look up later. */
15321 language_of_main = language_fortran;
15325 if (DW_UNSND (&attr) == DW_INL_inlined
15326 || DW_UNSND (&attr) == DW_INL_declared_inlined)
15327 part_die->may_be_inlined = 1;
15331 if (part_die->tag == DW_TAG_imported_unit)
15333 part_die->d.offset = dwarf2_get_ref_die_offset (&attr);
15334 part_die->is_dwz = (attr.form == DW_FORM_GNU_ref_alt
15335 || cu->per_cu->is_dwz);
15344 if (high_pc_relative)
15345 part_die->highpc += part_die->lowpc;
15347 if (has_low_pc_attr && has_high_pc_attr)
15349 /* When using the GNU linker, .gnu.linkonce. sections are used to
15350 eliminate duplicate copies of functions and vtables and such.
15351 The linker will arbitrarily choose one and discard the others.
15352 The AT_*_pc values for such functions refer to local labels in
15353 these sections. If the section from that file was discarded, the
15354 labels are not in the output, so the relocs get a value of 0.
15355 If this is a discarded function, mark the pc bounds as invalid,
15356 so that GDB will ignore it. */
15357 if (part_die->lowpc == 0 && !dwarf2_per_objfile->has_section_at_zero)
15359 struct gdbarch *gdbarch = get_objfile_arch (objfile);
15361 complaint (&symfile_complaints,
15362 _("DW_AT_low_pc %s is zero "
15363 "for DIE at 0x%x [in module %s]"),
15364 paddress (gdbarch, part_die->lowpc),
15365 part_die->offset.sect_off, objfile_name (objfile));
15367 /* dwarf2_get_pc_bounds has also the strict low < high requirement. */
15368 else if (part_die->lowpc >= part_die->highpc)
15370 struct gdbarch *gdbarch = get_objfile_arch (objfile);
15372 complaint (&symfile_complaints,
15373 _("DW_AT_low_pc %s is not < DW_AT_high_pc %s "
15374 "for DIE at 0x%x [in module %s]"),
15375 paddress (gdbarch, part_die->lowpc),
15376 paddress (gdbarch, part_die->highpc),
15377 part_die->offset.sect_off, objfile_name (objfile));
15380 part_die->has_pc_info = 1;
15386 /* Find a cached partial DIE at OFFSET in CU. */
15388 static struct partial_die_info *
15389 find_partial_die_in_comp_unit (sect_offset offset, struct dwarf2_cu *cu)
15391 struct partial_die_info *lookup_die = NULL;
15392 struct partial_die_info part_die;
15394 part_die.offset = offset;
15395 lookup_die = htab_find_with_hash (cu->partial_dies, &part_die,
15401 /* Find a partial DIE at OFFSET, which may or may not be in CU,
15402 except in the case of .debug_types DIEs which do not reference
15403 outside their CU (they do however referencing other types via
15404 DW_FORM_ref_sig8). */
15406 static struct partial_die_info *
15407 find_partial_die (sect_offset offset, int offset_in_dwz, struct dwarf2_cu *cu)
15409 struct objfile *objfile = cu->objfile;
15410 struct dwarf2_per_cu_data *per_cu = NULL;
15411 struct partial_die_info *pd = NULL;
15413 if (offset_in_dwz == cu->per_cu->is_dwz
15414 && offset_in_cu_p (&cu->header, offset))
15416 pd = find_partial_die_in_comp_unit (offset, cu);
15419 /* We missed recording what we needed.
15420 Load all dies and try again. */
15421 per_cu = cu->per_cu;
15425 /* TUs don't reference other CUs/TUs (except via type signatures). */
15426 if (cu->per_cu->is_debug_types)
15428 error (_("Dwarf Error: Type Unit at offset 0x%lx contains"
15429 " external reference to offset 0x%lx [in module %s].\n"),
15430 (long) cu->header.offset.sect_off, (long) offset.sect_off,
15431 bfd_get_filename (objfile->obfd));
15433 per_cu = dwarf2_find_containing_comp_unit (offset, offset_in_dwz,
15436 if (per_cu->cu == NULL || per_cu->cu->partial_dies == NULL)
15437 load_partial_comp_unit (per_cu);
15439 per_cu->cu->last_used = 0;
15440 pd = find_partial_die_in_comp_unit (offset, per_cu->cu);
15443 /* If we didn't find it, and not all dies have been loaded,
15444 load them all and try again. */
15446 if (pd == NULL && per_cu->load_all_dies == 0)
15448 per_cu->load_all_dies = 1;
15450 /* This is nasty. When we reread the DIEs, somewhere up the call chain
15451 THIS_CU->cu may already be in use. So we can't just free it and
15452 replace its DIEs with the ones we read in. Instead, we leave those
15453 DIEs alone (which can still be in use, e.g. in scan_partial_symbols),
15454 and clobber THIS_CU->cu->partial_dies with the hash table for the new
15456 load_partial_comp_unit (per_cu);
15458 pd = find_partial_die_in_comp_unit (offset, per_cu->cu);
15462 internal_error (__FILE__, __LINE__,
15463 _("could not find partial DIE 0x%x "
15464 "in cache [from module %s]\n"),
15465 offset.sect_off, bfd_get_filename (objfile->obfd));
15469 /* See if we can figure out if the class lives in a namespace. We do
15470 this by looking for a member function; its demangled name will
15471 contain namespace info, if there is any. */
15474 guess_partial_die_structure_name (struct partial_die_info *struct_pdi,
15475 struct dwarf2_cu *cu)
15477 /* NOTE: carlton/2003-10-07: Getting the info this way changes
15478 what template types look like, because the demangler
15479 frequently doesn't give the same name as the debug info. We
15480 could fix this by only using the demangled name to get the
15481 prefix (but see comment in read_structure_type). */
15483 struct partial_die_info *real_pdi;
15484 struct partial_die_info *child_pdi;
15486 /* If this DIE (this DIE's specification, if any) has a parent, then
15487 we should not do this. We'll prepend the parent's fully qualified
15488 name when we create the partial symbol. */
15490 real_pdi = struct_pdi;
15491 while (real_pdi->has_specification)
15492 real_pdi = find_partial_die (real_pdi->spec_offset,
15493 real_pdi->spec_is_dwz, cu);
15495 if (real_pdi->die_parent != NULL)
15498 for (child_pdi = struct_pdi->die_child;
15500 child_pdi = child_pdi->die_sibling)
15502 if (child_pdi->tag == DW_TAG_subprogram
15503 && child_pdi->linkage_name != NULL)
15505 char *actual_class_name
15506 = language_class_name_from_physname (cu->language_defn,
15507 child_pdi->linkage_name);
15508 if (actual_class_name != NULL)
15511 = obstack_copy0 (&cu->objfile->objfile_obstack,
15513 strlen (actual_class_name));
15514 xfree (actual_class_name);
15521 /* Adjust PART_DIE before generating a symbol for it. This function
15522 may set the is_external flag or change the DIE's name. */
15525 fixup_partial_die (struct partial_die_info *part_die,
15526 struct dwarf2_cu *cu)
15528 /* Once we've fixed up a die, there's no point in doing so again.
15529 This also avoids a memory leak if we were to call
15530 guess_partial_die_structure_name multiple times. */
15531 if (part_die->fixup_called)
15534 /* If we found a reference attribute and the DIE has no name, try
15535 to find a name in the referred to DIE. */
15537 if (part_die->name == NULL && part_die->has_specification)
15539 struct partial_die_info *spec_die;
15541 spec_die = find_partial_die (part_die->spec_offset,
15542 part_die->spec_is_dwz, cu);
15544 fixup_partial_die (spec_die, cu);
15546 if (spec_die->name)
15548 part_die->name = spec_die->name;
15550 /* Copy DW_AT_external attribute if it is set. */
15551 if (spec_die->is_external)
15552 part_die->is_external = spec_die->is_external;
15556 /* Set default names for some unnamed DIEs. */
15558 if (part_die->name == NULL && part_die->tag == DW_TAG_namespace)
15559 part_die->name = CP_ANONYMOUS_NAMESPACE_STR;
15561 /* If there is no parent die to provide a namespace, and there are
15562 children, see if we can determine the namespace from their linkage
15564 if (cu->language == language_cplus
15565 && !VEC_empty (dwarf2_section_info_def, dwarf2_per_objfile->types)
15566 && part_die->die_parent == NULL
15567 && part_die->has_children
15568 && (part_die->tag == DW_TAG_class_type
15569 || part_die->tag == DW_TAG_structure_type
15570 || part_die->tag == DW_TAG_union_type))
15571 guess_partial_die_structure_name (part_die, cu);
15573 /* GCC might emit a nameless struct or union that has a linkage
15574 name. See http://gcc.gnu.org/bugzilla/show_bug.cgi?id=47510. */
15575 if (part_die->name == NULL
15576 && (part_die->tag == DW_TAG_class_type
15577 || part_die->tag == DW_TAG_interface_type
15578 || part_die->tag == DW_TAG_structure_type
15579 || part_die->tag == DW_TAG_union_type)
15580 && part_die->linkage_name != NULL)
15584 demangled = gdb_demangle (part_die->linkage_name, DMGL_TYPES);
15589 /* Strip any leading namespaces/classes, keep only the base name.
15590 DW_AT_name for named DIEs does not contain the prefixes. */
15591 base = strrchr (demangled, ':');
15592 if (base && base > demangled && base[-1] == ':')
15597 part_die->name = obstack_copy0 (&cu->objfile->objfile_obstack,
15598 base, strlen (base));
15603 part_die->fixup_called = 1;
15606 /* Read an attribute value described by an attribute form. */
15608 static const gdb_byte *
15609 read_attribute_value (const struct die_reader_specs *reader,
15610 struct attribute *attr, unsigned form,
15611 const gdb_byte *info_ptr)
15613 struct dwarf2_cu *cu = reader->cu;
15614 bfd *abfd = reader->abfd;
15615 struct comp_unit_head *cu_header = &cu->header;
15616 unsigned int bytes_read;
15617 struct dwarf_block *blk;
15622 case DW_FORM_ref_addr:
15623 if (cu->header.version == 2)
15624 DW_UNSND (attr) = read_address (abfd, info_ptr, cu, &bytes_read);
15626 DW_UNSND (attr) = read_offset (abfd, info_ptr,
15627 &cu->header, &bytes_read);
15628 info_ptr += bytes_read;
15630 case DW_FORM_GNU_ref_alt:
15631 DW_UNSND (attr) = read_offset (abfd, info_ptr, &cu->header, &bytes_read);
15632 info_ptr += bytes_read;
15635 DW_ADDR (attr) = read_address (abfd, info_ptr, cu, &bytes_read);
15636 info_ptr += bytes_read;
15638 case DW_FORM_block2:
15639 blk = dwarf_alloc_block (cu);
15640 blk->size = read_2_bytes (abfd, info_ptr);
15642 blk->data = read_n_bytes (abfd, info_ptr, blk->size);
15643 info_ptr += blk->size;
15644 DW_BLOCK (attr) = blk;
15646 case DW_FORM_block4:
15647 blk = dwarf_alloc_block (cu);
15648 blk->size = read_4_bytes (abfd, info_ptr);
15650 blk->data = read_n_bytes (abfd, info_ptr, blk->size);
15651 info_ptr += blk->size;
15652 DW_BLOCK (attr) = blk;
15654 case DW_FORM_data2:
15655 DW_UNSND (attr) = read_2_bytes (abfd, info_ptr);
15658 case DW_FORM_data4:
15659 DW_UNSND (attr) = read_4_bytes (abfd, info_ptr);
15662 case DW_FORM_data8:
15663 DW_UNSND (attr) = read_8_bytes (abfd, info_ptr);
15666 case DW_FORM_sec_offset:
15667 DW_UNSND (attr) = read_offset (abfd, info_ptr, &cu->header, &bytes_read);
15668 info_ptr += bytes_read;
15670 case DW_FORM_string:
15671 DW_STRING (attr) = read_direct_string (abfd, info_ptr, &bytes_read);
15672 DW_STRING_IS_CANONICAL (attr) = 0;
15673 info_ptr += bytes_read;
15676 if (!cu->per_cu->is_dwz)
15678 DW_STRING (attr) = read_indirect_string (abfd, info_ptr, cu_header,
15680 DW_STRING_IS_CANONICAL (attr) = 0;
15681 info_ptr += bytes_read;
15685 case DW_FORM_GNU_strp_alt:
15687 struct dwz_file *dwz = dwarf2_get_dwz_file ();
15688 LONGEST str_offset = read_offset (abfd, info_ptr, cu_header,
15691 DW_STRING (attr) = read_indirect_string_from_dwz (dwz, str_offset);
15692 DW_STRING_IS_CANONICAL (attr) = 0;
15693 info_ptr += bytes_read;
15696 case DW_FORM_exprloc:
15697 case DW_FORM_block:
15698 blk = dwarf_alloc_block (cu);
15699 blk->size = read_unsigned_leb128 (abfd, info_ptr, &bytes_read);
15700 info_ptr += bytes_read;
15701 blk->data = read_n_bytes (abfd, info_ptr, blk->size);
15702 info_ptr += blk->size;
15703 DW_BLOCK (attr) = blk;
15705 case DW_FORM_block1:
15706 blk = dwarf_alloc_block (cu);
15707 blk->size = read_1_byte (abfd, info_ptr);
15709 blk->data = read_n_bytes (abfd, info_ptr, blk->size);
15710 info_ptr += blk->size;
15711 DW_BLOCK (attr) = blk;
15713 case DW_FORM_data1:
15714 DW_UNSND (attr) = read_1_byte (abfd, info_ptr);
15718 DW_UNSND (attr) = read_1_byte (abfd, info_ptr);
15721 case DW_FORM_flag_present:
15722 DW_UNSND (attr) = 1;
15724 case DW_FORM_sdata:
15725 DW_SND (attr) = read_signed_leb128 (abfd, info_ptr, &bytes_read);
15726 info_ptr += bytes_read;
15728 case DW_FORM_udata:
15729 DW_UNSND (attr) = read_unsigned_leb128 (abfd, info_ptr, &bytes_read);
15730 info_ptr += bytes_read;
15733 DW_UNSND (attr) = (cu->header.offset.sect_off
15734 + read_1_byte (abfd, info_ptr));
15738 DW_UNSND (attr) = (cu->header.offset.sect_off
15739 + read_2_bytes (abfd, info_ptr));
15743 DW_UNSND (attr) = (cu->header.offset.sect_off
15744 + read_4_bytes (abfd, info_ptr));
15748 DW_UNSND (attr) = (cu->header.offset.sect_off
15749 + read_8_bytes (abfd, info_ptr));
15752 case DW_FORM_ref_sig8:
15753 DW_SIGNATURE (attr) = read_8_bytes (abfd, info_ptr);
15756 case DW_FORM_ref_udata:
15757 DW_UNSND (attr) = (cu->header.offset.sect_off
15758 + read_unsigned_leb128 (abfd, info_ptr, &bytes_read));
15759 info_ptr += bytes_read;
15761 case DW_FORM_indirect:
15762 form = read_unsigned_leb128 (abfd, info_ptr, &bytes_read);
15763 info_ptr += bytes_read;
15764 info_ptr = read_attribute_value (reader, attr, form, info_ptr);
15766 case DW_FORM_GNU_addr_index:
15767 if (reader->dwo_file == NULL)
15769 /* For now flag a hard error.
15770 Later we can turn this into a complaint. */
15771 error (_("Dwarf Error: %s found in non-DWO CU [in module %s]"),
15772 dwarf_form_name (form),
15773 bfd_get_filename (abfd));
15775 DW_ADDR (attr) = read_addr_index_from_leb128 (cu, info_ptr, &bytes_read);
15776 info_ptr += bytes_read;
15778 case DW_FORM_GNU_str_index:
15779 if (reader->dwo_file == NULL)
15781 /* For now flag a hard error.
15782 Later we can turn this into a complaint if warranted. */
15783 error (_("Dwarf Error: %s found in non-DWO CU [in module %s]"),
15784 dwarf_form_name (form),
15785 bfd_get_filename (abfd));
15788 ULONGEST str_index =
15789 read_unsigned_leb128 (abfd, info_ptr, &bytes_read);
15791 DW_STRING (attr) = read_str_index (reader, cu, str_index);
15792 DW_STRING_IS_CANONICAL (attr) = 0;
15793 info_ptr += bytes_read;
15797 error (_("Dwarf Error: Cannot handle %s in DWARF reader [in module %s]"),
15798 dwarf_form_name (form),
15799 bfd_get_filename (abfd));
15803 if (cu->per_cu->is_dwz && attr_form_is_ref (attr))
15804 attr->form = DW_FORM_GNU_ref_alt;
15806 /* We have seen instances where the compiler tried to emit a byte
15807 size attribute of -1 which ended up being encoded as an unsigned
15808 0xffffffff. Although 0xffffffff is technically a valid size value,
15809 an object of this size seems pretty unlikely so we can relatively
15810 safely treat these cases as if the size attribute was invalid and
15811 treat them as zero by default. */
15812 if (attr->name == DW_AT_byte_size
15813 && form == DW_FORM_data4
15814 && DW_UNSND (attr) >= 0xffffffff)
15817 (&symfile_complaints,
15818 _("Suspicious DW_AT_byte_size value treated as zero instead of %s"),
15819 hex_string (DW_UNSND (attr)));
15820 DW_UNSND (attr) = 0;
15826 /* Read an attribute described by an abbreviated attribute. */
15828 static const gdb_byte *
15829 read_attribute (const struct die_reader_specs *reader,
15830 struct attribute *attr, struct attr_abbrev *abbrev,
15831 const gdb_byte *info_ptr)
15833 attr->name = abbrev->name;
15834 return read_attribute_value (reader, attr, abbrev->form, info_ptr);
15837 /* Read dwarf information from a buffer. */
15839 static unsigned int
15840 read_1_byte (bfd *abfd, const gdb_byte *buf)
15842 return bfd_get_8 (abfd, buf);
15846 read_1_signed_byte (bfd *abfd, const gdb_byte *buf)
15848 return bfd_get_signed_8 (abfd, buf);
15851 static unsigned int
15852 read_2_bytes (bfd *abfd, const gdb_byte *buf)
15854 return bfd_get_16 (abfd, buf);
15858 read_2_signed_bytes (bfd *abfd, const gdb_byte *buf)
15860 return bfd_get_signed_16 (abfd, buf);
15863 static unsigned int
15864 read_4_bytes (bfd *abfd, const gdb_byte *buf)
15866 return bfd_get_32 (abfd, buf);
15870 read_4_signed_bytes (bfd *abfd, const gdb_byte *buf)
15872 return bfd_get_signed_32 (abfd, buf);
15876 read_8_bytes (bfd *abfd, const gdb_byte *buf)
15878 return bfd_get_64 (abfd, buf);
15882 read_address (bfd *abfd, const gdb_byte *buf, struct dwarf2_cu *cu,
15883 unsigned int *bytes_read)
15885 struct comp_unit_head *cu_header = &cu->header;
15886 CORE_ADDR retval = 0;
15888 if (cu_header->signed_addr_p)
15890 switch (cu_header->addr_size)
15893 retval = bfd_get_signed_16 (abfd, buf);
15896 retval = bfd_get_signed_32 (abfd, buf);
15899 retval = bfd_get_signed_64 (abfd, buf);
15902 internal_error (__FILE__, __LINE__,
15903 _("read_address: bad switch, signed [in module %s]"),
15904 bfd_get_filename (abfd));
15909 switch (cu_header->addr_size)
15912 retval = bfd_get_16 (abfd, buf);
15915 retval = bfd_get_32 (abfd, buf);
15918 retval = bfd_get_64 (abfd, buf);
15921 internal_error (__FILE__, __LINE__,
15922 _("read_address: bad switch, "
15923 "unsigned [in module %s]"),
15924 bfd_get_filename (abfd));
15928 *bytes_read = cu_header->addr_size;
15932 /* Read the initial length from a section. The (draft) DWARF 3
15933 specification allows the initial length to take up either 4 bytes
15934 or 12 bytes. If the first 4 bytes are 0xffffffff, then the next 8
15935 bytes describe the length and all offsets will be 8 bytes in length
15938 An older, non-standard 64-bit format is also handled by this
15939 function. The older format in question stores the initial length
15940 as an 8-byte quantity without an escape value. Lengths greater
15941 than 2^32 aren't very common which means that the initial 4 bytes
15942 is almost always zero. Since a length value of zero doesn't make
15943 sense for the 32-bit format, this initial zero can be considered to
15944 be an escape value which indicates the presence of the older 64-bit
15945 format. As written, the code can't detect (old format) lengths
15946 greater than 4GB. If it becomes necessary to handle lengths
15947 somewhat larger than 4GB, we could allow other small values (such
15948 as the non-sensical values of 1, 2, and 3) to also be used as
15949 escape values indicating the presence of the old format.
15951 The value returned via bytes_read should be used to increment the
15952 relevant pointer after calling read_initial_length().
15954 [ Note: read_initial_length() and read_offset() are based on the
15955 document entitled "DWARF Debugging Information Format", revision
15956 3, draft 8, dated November 19, 2001. This document was obtained
15959 http://reality.sgiweb.org/davea/dwarf3-draft8-011125.pdf
15961 This document is only a draft and is subject to change. (So beware.)
15963 Details regarding the older, non-standard 64-bit format were
15964 determined empirically by examining 64-bit ELF files produced by
15965 the SGI toolchain on an IRIX 6.5 machine.
15967 - Kevin, July 16, 2002
15971 read_initial_length (bfd *abfd, const gdb_byte *buf, unsigned int *bytes_read)
15973 LONGEST length = bfd_get_32 (abfd, buf);
15975 if (length == 0xffffffff)
15977 length = bfd_get_64 (abfd, buf + 4);
15980 else if (length == 0)
15982 /* Handle the (non-standard) 64-bit DWARF2 format used by IRIX. */
15983 length = bfd_get_64 (abfd, buf);
15994 /* Cover function for read_initial_length.
15995 Returns the length of the object at BUF, and stores the size of the
15996 initial length in *BYTES_READ and stores the size that offsets will be in
15998 If the initial length size is not equivalent to that specified in
15999 CU_HEADER then issue a complaint.
16000 This is useful when reading non-comp-unit headers. */
16003 read_checked_initial_length_and_offset (bfd *abfd, const gdb_byte *buf,
16004 const struct comp_unit_head *cu_header,
16005 unsigned int *bytes_read,
16006 unsigned int *offset_size)
16008 LONGEST length = read_initial_length (abfd, buf, bytes_read);
16010 gdb_assert (cu_header->initial_length_size == 4
16011 || cu_header->initial_length_size == 8
16012 || cu_header->initial_length_size == 12);
16014 if (cu_header->initial_length_size != *bytes_read)
16015 complaint (&symfile_complaints,
16016 _("intermixed 32-bit and 64-bit DWARF sections"));
16018 *offset_size = (*bytes_read == 4) ? 4 : 8;
16022 /* Read an offset from the data stream. The size of the offset is
16023 given by cu_header->offset_size. */
16026 read_offset (bfd *abfd, const gdb_byte *buf,
16027 const struct comp_unit_head *cu_header,
16028 unsigned int *bytes_read)
16030 LONGEST offset = read_offset_1 (abfd, buf, cu_header->offset_size);
16032 *bytes_read = cu_header->offset_size;
16036 /* Read an offset from the data stream. */
16039 read_offset_1 (bfd *abfd, const gdb_byte *buf, unsigned int offset_size)
16041 LONGEST retval = 0;
16043 switch (offset_size)
16046 retval = bfd_get_32 (abfd, buf);
16049 retval = bfd_get_64 (abfd, buf);
16052 internal_error (__FILE__, __LINE__,
16053 _("read_offset_1: bad switch [in module %s]"),
16054 bfd_get_filename (abfd));
16060 static const gdb_byte *
16061 read_n_bytes (bfd *abfd, const gdb_byte *buf, unsigned int size)
16063 /* If the size of a host char is 8 bits, we can return a pointer
16064 to the buffer, otherwise we have to copy the data to a buffer
16065 allocated on the temporary obstack. */
16066 gdb_assert (HOST_CHAR_BIT == 8);
16070 static const char *
16071 read_direct_string (bfd *abfd, const gdb_byte *buf,
16072 unsigned int *bytes_read_ptr)
16074 /* If the size of a host char is 8 bits, we can return a pointer
16075 to the string, otherwise we have to copy the string to a buffer
16076 allocated on the temporary obstack. */
16077 gdb_assert (HOST_CHAR_BIT == 8);
16080 *bytes_read_ptr = 1;
16083 *bytes_read_ptr = strlen ((const char *) buf) + 1;
16084 return (const char *) buf;
16087 static const char *
16088 read_indirect_string_at_offset (bfd *abfd, LONGEST str_offset)
16090 dwarf2_read_section (dwarf2_per_objfile->objfile, &dwarf2_per_objfile->str);
16091 if (dwarf2_per_objfile->str.buffer == NULL)
16092 error (_("DW_FORM_strp used without .debug_str section [in module %s]"),
16093 bfd_get_filename (abfd));
16094 if (str_offset >= dwarf2_per_objfile->str.size)
16095 error (_("DW_FORM_strp pointing outside of "
16096 ".debug_str section [in module %s]"),
16097 bfd_get_filename (abfd));
16098 gdb_assert (HOST_CHAR_BIT == 8);
16099 if (dwarf2_per_objfile->str.buffer[str_offset] == '\0')
16101 return (const char *) (dwarf2_per_objfile->str.buffer + str_offset);
16104 /* Read a string at offset STR_OFFSET in the .debug_str section from
16105 the .dwz file DWZ. Throw an error if the offset is too large. If
16106 the string consists of a single NUL byte, return NULL; otherwise
16107 return a pointer to the string. */
16109 static const char *
16110 read_indirect_string_from_dwz (struct dwz_file *dwz, LONGEST str_offset)
16112 dwarf2_read_section (dwarf2_per_objfile->objfile, &dwz->str);
16114 if (dwz->str.buffer == NULL)
16115 error (_("DW_FORM_GNU_strp_alt used without .debug_str "
16116 "section [in module %s]"),
16117 bfd_get_filename (dwz->dwz_bfd));
16118 if (str_offset >= dwz->str.size)
16119 error (_("DW_FORM_GNU_strp_alt pointing outside of "
16120 ".debug_str section [in module %s]"),
16121 bfd_get_filename (dwz->dwz_bfd));
16122 gdb_assert (HOST_CHAR_BIT == 8);
16123 if (dwz->str.buffer[str_offset] == '\0')
16125 return (const char *) (dwz->str.buffer + str_offset);
16128 static const char *
16129 read_indirect_string (bfd *abfd, const gdb_byte *buf,
16130 const struct comp_unit_head *cu_header,
16131 unsigned int *bytes_read_ptr)
16133 LONGEST str_offset = read_offset (abfd, buf, cu_header, bytes_read_ptr);
16135 return read_indirect_string_at_offset (abfd, str_offset);
16139 read_unsigned_leb128 (bfd *abfd, const gdb_byte *buf,
16140 unsigned int *bytes_read_ptr)
16143 unsigned int num_read;
16145 unsigned char byte;
16153 byte = bfd_get_8 (abfd, buf);
16156 result |= ((ULONGEST) (byte & 127) << shift);
16157 if ((byte & 128) == 0)
16163 *bytes_read_ptr = num_read;
16168 read_signed_leb128 (bfd *abfd, const gdb_byte *buf,
16169 unsigned int *bytes_read_ptr)
16172 int i, shift, num_read;
16173 unsigned char byte;
16181 byte = bfd_get_8 (abfd, buf);
16184 result |= ((LONGEST) (byte & 127) << shift);
16186 if ((byte & 128) == 0)
16191 if ((shift < 8 * sizeof (result)) && (byte & 0x40))
16192 result |= -(((LONGEST) 1) << shift);
16193 *bytes_read_ptr = num_read;
16197 /* Given index ADDR_INDEX in .debug_addr, fetch the value.
16198 ADDR_BASE is the DW_AT_GNU_addr_base attribute or zero.
16199 ADDR_SIZE is the size of addresses from the CU header. */
16202 read_addr_index_1 (unsigned int addr_index, ULONGEST addr_base, int addr_size)
16204 struct objfile *objfile = dwarf2_per_objfile->objfile;
16205 bfd *abfd = objfile->obfd;
16206 const gdb_byte *info_ptr;
16208 dwarf2_read_section (objfile, &dwarf2_per_objfile->addr);
16209 if (dwarf2_per_objfile->addr.buffer == NULL)
16210 error (_("DW_FORM_addr_index used without .debug_addr section [in module %s]"),
16211 objfile_name (objfile));
16212 if (addr_base + addr_index * addr_size >= dwarf2_per_objfile->addr.size)
16213 error (_("DW_FORM_addr_index pointing outside of "
16214 ".debug_addr section [in module %s]"),
16215 objfile_name (objfile));
16216 info_ptr = (dwarf2_per_objfile->addr.buffer
16217 + addr_base + addr_index * addr_size);
16218 if (addr_size == 4)
16219 return bfd_get_32 (abfd, info_ptr);
16221 return bfd_get_64 (abfd, info_ptr);
16224 /* Given index ADDR_INDEX in .debug_addr, fetch the value. */
16227 read_addr_index (struct dwarf2_cu *cu, unsigned int addr_index)
16229 return read_addr_index_1 (addr_index, cu->addr_base, cu->header.addr_size);
16232 /* Given a pointer to an leb128 value, fetch the value from .debug_addr. */
16235 read_addr_index_from_leb128 (struct dwarf2_cu *cu, const gdb_byte *info_ptr,
16236 unsigned int *bytes_read)
16238 bfd *abfd = cu->objfile->obfd;
16239 unsigned int addr_index = read_unsigned_leb128 (abfd, info_ptr, bytes_read);
16241 return read_addr_index (cu, addr_index);
16244 /* Data structure to pass results from dwarf2_read_addr_index_reader
16245 back to dwarf2_read_addr_index. */
16247 struct dwarf2_read_addr_index_data
16249 ULONGEST addr_base;
16253 /* die_reader_func for dwarf2_read_addr_index. */
16256 dwarf2_read_addr_index_reader (const struct die_reader_specs *reader,
16257 const gdb_byte *info_ptr,
16258 struct die_info *comp_unit_die,
16262 struct dwarf2_cu *cu = reader->cu;
16263 struct dwarf2_read_addr_index_data *aidata =
16264 (struct dwarf2_read_addr_index_data *) data;
16266 aidata->addr_base = cu->addr_base;
16267 aidata->addr_size = cu->header.addr_size;
16270 /* Given an index in .debug_addr, fetch the value.
16271 NOTE: This can be called during dwarf expression evaluation,
16272 long after the debug information has been read, and thus per_cu->cu
16273 may no longer exist. */
16276 dwarf2_read_addr_index (struct dwarf2_per_cu_data *per_cu,
16277 unsigned int addr_index)
16279 struct objfile *objfile = per_cu->objfile;
16280 struct dwarf2_cu *cu = per_cu->cu;
16281 ULONGEST addr_base;
16284 /* This is intended to be called from outside this file. */
16285 dw2_setup (objfile);
16287 /* We need addr_base and addr_size.
16288 If we don't have PER_CU->cu, we have to get it.
16289 Nasty, but the alternative is storing the needed info in PER_CU,
16290 which at this point doesn't seem justified: it's not clear how frequently
16291 it would get used and it would increase the size of every PER_CU.
16292 Entry points like dwarf2_per_cu_addr_size do a similar thing
16293 so we're not in uncharted territory here.
16294 Alas we need to be a bit more complicated as addr_base is contained
16297 We don't need to read the entire CU(/TU).
16298 We just need the header and top level die.
16300 IWBN to use the aging mechanism to let us lazily later discard the CU.
16301 For now we skip this optimization. */
16305 addr_base = cu->addr_base;
16306 addr_size = cu->header.addr_size;
16310 struct dwarf2_read_addr_index_data aidata;
16312 /* Note: We can't use init_cutu_and_read_dies_simple here,
16313 we need addr_base. */
16314 init_cutu_and_read_dies (per_cu, NULL, 0, 0,
16315 dwarf2_read_addr_index_reader, &aidata);
16316 addr_base = aidata.addr_base;
16317 addr_size = aidata.addr_size;
16320 return read_addr_index_1 (addr_index, addr_base, addr_size);
16323 /* Given a DW_FORM_GNU_str_index, fetch the string.
16324 This is only used by the Fission support. */
16326 static const char *
16327 read_str_index (const struct die_reader_specs *reader,
16328 struct dwarf2_cu *cu, ULONGEST str_index)
16330 struct objfile *objfile = dwarf2_per_objfile->objfile;
16331 const char *dwo_name = objfile_name (objfile);
16332 bfd *abfd = objfile->obfd;
16333 struct dwarf2_section_info *str_section = &reader->dwo_file->sections.str;
16334 struct dwarf2_section_info *str_offsets_section =
16335 &reader->dwo_file->sections.str_offsets;
16336 const gdb_byte *info_ptr;
16337 ULONGEST str_offset;
16338 static const char form_name[] = "DW_FORM_GNU_str_index";
16340 dwarf2_read_section (objfile, str_section);
16341 dwarf2_read_section (objfile, str_offsets_section);
16342 if (str_section->buffer == NULL)
16343 error (_("%s used without .debug_str.dwo section"
16344 " in CU at offset 0x%lx [in module %s]"),
16345 form_name, (long) cu->header.offset.sect_off, dwo_name);
16346 if (str_offsets_section->buffer == NULL)
16347 error (_("%s used without .debug_str_offsets.dwo section"
16348 " in CU at offset 0x%lx [in module %s]"),
16349 form_name, (long) cu->header.offset.sect_off, dwo_name);
16350 if (str_index * cu->header.offset_size >= str_offsets_section->size)
16351 error (_("%s pointing outside of .debug_str_offsets.dwo"
16352 " section in CU at offset 0x%lx [in module %s]"),
16353 form_name, (long) cu->header.offset.sect_off, dwo_name);
16354 info_ptr = (str_offsets_section->buffer
16355 + str_index * cu->header.offset_size);
16356 if (cu->header.offset_size == 4)
16357 str_offset = bfd_get_32 (abfd, info_ptr);
16359 str_offset = bfd_get_64 (abfd, info_ptr);
16360 if (str_offset >= str_section->size)
16361 error (_("Offset from %s pointing outside of"
16362 " .debug_str.dwo section in CU at offset 0x%lx [in module %s]"),
16363 form_name, (long) cu->header.offset.sect_off, dwo_name);
16364 return (const char *) (str_section->buffer + str_offset);
16367 /* Return the length of an LEB128 number in BUF. */
16370 leb128_size (const gdb_byte *buf)
16372 const gdb_byte *begin = buf;
16378 if ((byte & 128) == 0)
16379 return buf - begin;
16384 set_cu_language (unsigned int lang, struct dwarf2_cu *cu)
16392 cu->language = language_c;
16394 case DW_LANG_C_plus_plus:
16395 cu->language = language_cplus;
16398 cu->language = language_d;
16400 case DW_LANG_Fortran77:
16401 case DW_LANG_Fortran90:
16402 case DW_LANG_Fortran95:
16403 cu->language = language_fortran;
16406 cu->language = language_go;
16408 case DW_LANG_Mips_Assembler:
16409 cu->language = language_asm;
16412 cu->language = language_java;
16414 case DW_LANG_Ada83:
16415 case DW_LANG_Ada95:
16416 cu->language = language_ada;
16418 case DW_LANG_Modula2:
16419 cu->language = language_m2;
16421 case DW_LANG_Pascal83:
16422 cu->language = language_pascal;
16425 cu->language = language_objc;
16427 case DW_LANG_Cobol74:
16428 case DW_LANG_Cobol85:
16430 cu->language = language_minimal;
16433 cu->language_defn = language_def (cu->language);
16436 /* Return the named attribute or NULL if not there. */
16438 static struct attribute *
16439 dwarf2_attr (struct die_info *die, unsigned int name, struct dwarf2_cu *cu)
16444 struct attribute *spec = NULL;
16446 for (i = 0; i < die->num_attrs; ++i)
16448 if (die->attrs[i].name == name)
16449 return &die->attrs[i];
16450 if (die->attrs[i].name == DW_AT_specification
16451 || die->attrs[i].name == DW_AT_abstract_origin)
16452 spec = &die->attrs[i];
16458 die = follow_die_ref (die, spec, &cu);
16464 /* Return the named attribute or NULL if not there,
16465 but do not follow DW_AT_specification, etc.
16466 This is for use in contexts where we're reading .debug_types dies.
16467 Following DW_AT_specification, DW_AT_abstract_origin will take us
16468 back up the chain, and we want to go down. */
16470 static struct attribute *
16471 dwarf2_attr_no_follow (struct die_info *die, unsigned int name)
16475 for (i = 0; i < die->num_attrs; ++i)
16476 if (die->attrs[i].name == name)
16477 return &die->attrs[i];
16482 /* Return non-zero iff the attribute NAME is defined for the given DIE,
16483 and holds a non-zero value. This function should only be used for
16484 DW_FORM_flag or DW_FORM_flag_present attributes. */
16487 dwarf2_flag_true_p (struct die_info *die, unsigned name, struct dwarf2_cu *cu)
16489 struct attribute *attr = dwarf2_attr (die, name, cu);
16491 return (attr && DW_UNSND (attr));
16495 die_is_declaration (struct die_info *die, struct dwarf2_cu *cu)
16497 /* A DIE is a declaration if it has a DW_AT_declaration attribute
16498 which value is non-zero. However, we have to be careful with
16499 DIEs having a DW_AT_specification attribute, because dwarf2_attr()
16500 (via dwarf2_flag_true_p) follows this attribute. So we may
16501 end up accidently finding a declaration attribute that belongs
16502 to a different DIE referenced by the specification attribute,
16503 even though the given DIE does not have a declaration attribute. */
16504 return (dwarf2_flag_true_p (die, DW_AT_declaration, cu)
16505 && dwarf2_attr (die, DW_AT_specification, cu) == NULL);
16508 /* Return the die giving the specification for DIE, if there is
16509 one. *SPEC_CU is the CU containing DIE on input, and the CU
16510 containing the return value on output. If there is no
16511 specification, but there is an abstract origin, that is
16514 static struct die_info *
16515 die_specification (struct die_info *die, struct dwarf2_cu **spec_cu)
16517 struct attribute *spec_attr = dwarf2_attr (die, DW_AT_specification,
16520 if (spec_attr == NULL)
16521 spec_attr = dwarf2_attr (die, DW_AT_abstract_origin, *spec_cu);
16523 if (spec_attr == NULL)
16526 return follow_die_ref (die, spec_attr, spec_cu);
16529 /* Free the line_header structure *LH, and any arrays and strings it
16531 NOTE: This is also used as a "cleanup" function. */
16534 free_line_header (struct line_header *lh)
16536 if (lh->standard_opcode_lengths)
16537 xfree (lh->standard_opcode_lengths);
16539 /* Remember that all the lh->file_names[i].name pointers are
16540 pointers into debug_line_buffer, and don't need to be freed. */
16541 if (lh->file_names)
16542 xfree (lh->file_names);
16544 /* Similarly for the include directory names. */
16545 if (lh->include_dirs)
16546 xfree (lh->include_dirs);
16551 /* Add an entry to LH's include directory table. */
16554 add_include_dir (struct line_header *lh, const char *include_dir)
16556 /* Grow the array if necessary. */
16557 if (lh->include_dirs_size == 0)
16559 lh->include_dirs_size = 1; /* for testing */
16560 lh->include_dirs = xmalloc (lh->include_dirs_size
16561 * sizeof (*lh->include_dirs));
16563 else if (lh->num_include_dirs >= lh->include_dirs_size)
16565 lh->include_dirs_size *= 2;
16566 lh->include_dirs = xrealloc (lh->include_dirs,
16567 (lh->include_dirs_size
16568 * sizeof (*lh->include_dirs)));
16571 lh->include_dirs[lh->num_include_dirs++] = include_dir;
16574 /* Add an entry to LH's file name table. */
16577 add_file_name (struct line_header *lh,
16579 unsigned int dir_index,
16580 unsigned int mod_time,
16581 unsigned int length)
16583 struct file_entry *fe;
16585 /* Grow the array if necessary. */
16586 if (lh->file_names_size == 0)
16588 lh->file_names_size = 1; /* for testing */
16589 lh->file_names = xmalloc (lh->file_names_size
16590 * sizeof (*lh->file_names));
16592 else if (lh->num_file_names >= lh->file_names_size)
16594 lh->file_names_size *= 2;
16595 lh->file_names = xrealloc (lh->file_names,
16596 (lh->file_names_size
16597 * sizeof (*lh->file_names)));
16600 fe = &lh->file_names[lh->num_file_names++];
16602 fe->dir_index = dir_index;
16603 fe->mod_time = mod_time;
16604 fe->length = length;
16605 fe->included_p = 0;
16609 /* A convenience function to find the proper .debug_line section for a
16612 static struct dwarf2_section_info *
16613 get_debug_line_section (struct dwarf2_cu *cu)
16615 struct dwarf2_section_info *section;
16617 /* For TUs in DWO files, the DW_AT_stmt_list attribute lives in the
16619 if (cu->dwo_unit && cu->per_cu->is_debug_types)
16620 section = &cu->dwo_unit->dwo_file->sections.line;
16621 else if (cu->per_cu->is_dwz)
16623 struct dwz_file *dwz = dwarf2_get_dwz_file ();
16625 section = &dwz->line;
16628 section = &dwarf2_per_objfile->line;
16633 /* Read the statement program header starting at OFFSET in
16634 .debug_line, or .debug_line.dwo. Return a pointer
16635 to a struct line_header, allocated using xmalloc.
16637 NOTE: the strings in the include directory and file name tables of
16638 the returned object point into the dwarf line section buffer,
16639 and must not be freed. */
16641 static struct line_header *
16642 dwarf_decode_line_header (unsigned int offset, struct dwarf2_cu *cu)
16644 struct cleanup *back_to;
16645 struct line_header *lh;
16646 const gdb_byte *line_ptr;
16647 unsigned int bytes_read, offset_size;
16649 const char *cur_dir, *cur_file;
16650 struct dwarf2_section_info *section;
16653 section = get_debug_line_section (cu);
16654 dwarf2_read_section (dwarf2_per_objfile->objfile, section);
16655 if (section->buffer == NULL)
16657 if (cu->dwo_unit && cu->per_cu->is_debug_types)
16658 complaint (&symfile_complaints, _("missing .debug_line.dwo section"));
16660 complaint (&symfile_complaints, _("missing .debug_line section"));
16664 /* We can't do this until we know the section is non-empty.
16665 Only then do we know we have such a section. */
16666 abfd = get_section_bfd_owner (section);
16668 /* Make sure that at least there's room for the total_length field.
16669 That could be 12 bytes long, but we're just going to fudge that. */
16670 if (offset + 4 >= section->size)
16672 dwarf2_statement_list_fits_in_line_number_section_complaint ();
16676 lh = xmalloc (sizeof (*lh));
16677 memset (lh, 0, sizeof (*lh));
16678 back_to = make_cleanup ((make_cleanup_ftype *) free_line_header,
16681 line_ptr = section->buffer + offset;
16683 /* Read in the header. */
16685 read_checked_initial_length_and_offset (abfd, line_ptr, &cu->header,
16686 &bytes_read, &offset_size);
16687 line_ptr += bytes_read;
16688 if (line_ptr + lh->total_length > (section->buffer + section->size))
16690 dwarf2_statement_list_fits_in_line_number_section_complaint ();
16691 do_cleanups (back_to);
16694 lh->statement_program_end = line_ptr + lh->total_length;
16695 lh->version = read_2_bytes (abfd, line_ptr);
16697 lh->header_length = read_offset_1 (abfd, line_ptr, offset_size);
16698 line_ptr += offset_size;
16699 lh->minimum_instruction_length = read_1_byte (abfd, line_ptr);
16701 if (lh->version >= 4)
16703 lh->maximum_ops_per_instruction = read_1_byte (abfd, line_ptr);
16707 lh->maximum_ops_per_instruction = 1;
16709 if (lh->maximum_ops_per_instruction == 0)
16711 lh->maximum_ops_per_instruction = 1;
16712 complaint (&symfile_complaints,
16713 _("invalid maximum_ops_per_instruction "
16714 "in `.debug_line' section"));
16717 lh->default_is_stmt = read_1_byte (abfd, line_ptr);
16719 lh->line_base = read_1_signed_byte (abfd, line_ptr);
16721 lh->line_range = read_1_byte (abfd, line_ptr);
16723 lh->opcode_base = read_1_byte (abfd, line_ptr);
16725 lh->standard_opcode_lengths
16726 = xmalloc (lh->opcode_base * sizeof (lh->standard_opcode_lengths[0]));
16728 lh->standard_opcode_lengths[0] = 1; /* This should never be used anyway. */
16729 for (i = 1; i < lh->opcode_base; ++i)
16731 lh->standard_opcode_lengths[i] = read_1_byte (abfd, line_ptr);
16735 /* Read directory table. */
16736 while ((cur_dir = read_direct_string (abfd, line_ptr, &bytes_read)) != NULL)
16738 line_ptr += bytes_read;
16739 add_include_dir (lh, cur_dir);
16741 line_ptr += bytes_read;
16743 /* Read file name table. */
16744 while ((cur_file = read_direct_string (abfd, line_ptr, &bytes_read)) != NULL)
16746 unsigned int dir_index, mod_time, length;
16748 line_ptr += bytes_read;
16749 dir_index = read_unsigned_leb128 (abfd, line_ptr, &bytes_read);
16750 line_ptr += bytes_read;
16751 mod_time = read_unsigned_leb128 (abfd, line_ptr, &bytes_read);
16752 line_ptr += bytes_read;
16753 length = read_unsigned_leb128 (abfd, line_ptr, &bytes_read);
16754 line_ptr += bytes_read;
16756 add_file_name (lh, cur_file, dir_index, mod_time, length);
16758 line_ptr += bytes_read;
16759 lh->statement_program_start = line_ptr;
16761 if (line_ptr > (section->buffer + section->size))
16762 complaint (&symfile_complaints,
16763 _("line number info header doesn't "
16764 "fit in `.debug_line' section"));
16766 discard_cleanups (back_to);
16770 /* Subroutine of dwarf_decode_lines to simplify it.
16771 Return the file name of the psymtab for included file FILE_INDEX
16772 in line header LH of PST.
16773 COMP_DIR is the compilation directory (DW_AT_comp_dir) or NULL if unknown.
16774 If space for the result is malloc'd, it will be freed by a cleanup.
16775 Returns NULL if FILE_INDEX should be ignored, i.e., it is pst->filename.
16777 The function creates dangling cleanup registration. */
16779 static const char *
16780 psymtab_include_file_name (const struct line_header *lh, int file_index,
16781 const struct partial_symtab *pst,
16782 const char *comp_dir)
16784 const struct file_entry fe = lh->file_names [file_index];
16785 const char *include_name = fe.name;
16786 const char *include_name_to_compare = include_name;
16787 const char *dir_name = NULL;
16788 const char *pst_filename;
16789 char *copied_name = NULL;
16793 dir_name = lh->include_dirs[fe.dir_index - 1];
16795 if (!IS_ABSOLUTE_PATH (include_name)
16796 && (dir_name != NULL || comp_dir != NULL))
16798 /* Avoid creating a duplicate psymtab for PST.
16799 We do this by comparing INCLUDE_NAME and PST_FILENAME.
16800 Before we do the comparison, however, we need to account
16801 for DIR_NAME and COMP_DIR.
16802 First prepend dir_name (if non-NULL). If we still don't
16803 have an absolute path prepend comp_dir (if non-NULL).
16804 However, the directory we record in the include-file's
16805 psymtab does not contain COMP_DIR (to match the
16806 corresponding symtab(s)).
16811 bash$ gcc -g ./hello.c
16812 include_name = "hello.c"
16814 DW_AT_comp_dir = comp_dir = "/tmp"
16815 DW_AT_name = "./hello.c" */
16817 if (dir_name != NULL)
16819 char *tem = concat (dir_name, SLASH_STRING,
16820 include_name, (char *)NULL);
16822 make_cleanup (xfree, tem);
16823 include_name = tem;
16824 include_name_to_compare = include_name;
16826 if (!IS_ABSOLUTE_PATH (include_name) && comp_dir != NULL)
16828 char *tem = concat (comp_dir, SLASH_STRING,
16829 include_name, (char *)NULL);
16831 make_cleanup (xfree, tem);
16832 include_name_to_compare = tem;
16836 pst_filename = pst->filename;
16837 if (!IS_ABSOLUTE_PATH (pst_filename) && pst->dirname != NULL)
16839 copied_name = concat (pst->dirname, SLASH_STRING,
16840 pst_filename, (char *)NULL);
16841 pst_filename = copied_name;
16844 file_is_pst = FILENAME_CMP (include_name_to_compare, pst_filename) == 0;
16846 if (copied_name != NULL)
16847 xfree (copied_name);
16851 return include_name;
16854 /* Ignore this record_line request. */
16857 noop_record_line (struct subfile *subfile, int line, CORE_ADDR pc)
16862 /* Subroutine of dwarf_decode_lines to simplify it.
16863 Process the line number information in LH. */
16866 dwarf_decode_lines_1 (struct line_header *lh, const char *comp_dir,
16867 struct dwarf2_cu *cu, struct partial_symtab *pst)
16869 const gdb_byte *line_ptr, *extended_end;
16870 const gdb_byte *line_end;
16871 unsigned int bytes_read, extended_len;
16872 unsigned char op_code, extended_op, adj_opcode;
16873 CORE_ADDR baseaddr;
16874 struct objfile *objfile = cu->objfile;
16875 bfd *abfd = objfile->obfd;
16876 struct gdbarch *gdbarch = get_objfile_arch (objfile);
16877 const int decode_for_pst_p = (pst != NULL);
16878 struct subfile *last_subfile = NULL;
16879 void (*p_record_line) (struct subfile *subfile, int line, CORE_ADDR pc)
16882 baseaddr = ANOFFSET (objfile->section_offsets, SECT_OFF_TEXT (objfile));
16884 line_ptr = lh->statement_program_start;
16885 line_end = lh->statement_program_end;
16887 /* Read the statement sequences until there's nothing left. */
16888 while (line_ptr < line_end)
16890 /* state machine registers */
16891 CORE_ADDR address = 0;
16892 unsigned int file = 1;
16893 unsigned int line = 1;
16894 unsigned int column = 0;
16895 int is_stmt = lh->default_is_stmt;
16896 int basic_block = 0;
16897 int end_sequence = 0;
16899 unsigned char op_index = 0;
16901 if (!decode_for_pst_p && lh->num_file_names >= file)
16903 /* Start a subfile for the current file of the state machine. */
16904 /* lh->include_dirs and lh->file_names are 0-based, but the
16905 directory and file name numbers in the statement program
16907 struct file_entry *fe = &lh->file_names[file - 1];
16908 const char *dir = NULL;
16911 dir = lh->include_dirs[fe->dir_index - 1];
16913 dwarf2_start_subfile (fe->name, dir, comp_dir);
16916 /* Decode the table. */
16917 while (!end_sequence)
16919 op_code = read_1_byte (abfd, line_ptr);
16921 if (line_ptr > line_end)
16923 dwarf2_debug_line_missing_end_sequence_complaint ();
16927 if (op_code >= lh->opcode_base)
16929 /* Special operand. */
16930 adj_opcode = op_code - lh->opcode_base;
16931 address += (((op_index + (adj_opcode / lh->line_range))
16932 / lh->maximum_ops_per_instruction)
16933 * lh->minimum_instruction_length);
16934 op_index = ((op_index + (adj_opcode / lh->line_range))
16935 % lh->maximum_ops_per_instruction);
16936 line += lh->line_base + (adj_opcode % lh->line_range);
16937 if (lh->num_file_names < file || file == 0)
16938 dwarf2_debug_line_missing_file_complaint ();
16939 /* For now we ignore lines not starting on an
16940 instruction boundary. */
16941 else if (op_index == 0)
16943 lh->file_names[file - 1].included_p = 1;
16944 if (!decode_for_pst_p && is_stmt)
16946 if (last_subfile != current_subfile)
16948 addr = gdbarch_addr_bits_remove (gdbarch, address);
16950 (*p_record_line) (last_subfile, 0, addr);
16951 last_subfile = current_subfile;
16953 /* Append row to matrix using current values. */
16954 addr = gdbarch_addr_bits_remove (gdbarch, address);
16955 (*p_record_line) (current_subfile, line, addr);
16960 else switch (op_code)
16962 case DW_LNS_extended_op:
16963 extended_len = read_unsigned_leb128 (abfd, line_ptr,
16965 line_ptr += bytes_read;
16966 extended_end = line_ptr + extended_len;
16967 extended_op = read_1_byte (abfd, line_ptr);
16969 switch (extended_op)
16971 case DW_LNE_end_sequence:
16972 p_record_line = record_line;
16975 case DW_LNE_set_address:
16976 address = read_address (abfd, line_ptr, cu, &bytes_read);
16978 if (address == 0 && !dwarf2_per_objfile->has_section_at_zero)
16980 /* This line table is for a function which has been
16981 GCd by the linker. Ignore it. PR gdb/12528 */
16984 = line_ptr - get_debug_line_section (cu)->buffer;
16986 complaint (&symfile_complaints,
16987 _(".debug_line address at offset 0x%lx is 0 "
16989 line_offset, objfile_name (objfile));
16990 p_record_line = noop_record_line;
16994 line_ptr += bytes_read;
16995 address += baseaddr;
16997 case DW_LNE_define_file:
16999 const char *cur_file;
17000 unsigned int dir_index, mod_time, length;
17002 cur_file = read_direct_string (abfd, line_ptr,
17004 line_ptr += bytes_read;
17006 read_unsigned_leb128 (abfd, line_ptr, &bytes_read);
17007 line_ptr += bytes_read;
17009 read_unsigned_leb128 (abfd, line_ptr, &bytes_read);
17010 line_ptr += bytes_read;
17012 read_unsigned_leb128 (abfd, line_ptr, &bytes_read);
17013 line_ptr += bytes_read;
17014 add_file_name (lh, cur_file, dir_index, mod_time, length);
17017 case DW_LNE_set_discriminator:
17018 /* The discriminator is not interesting to the debugger;
17020 line_ptr = extended_end;
17023 complaint (&symfile_complaints,
17024 _("mangled .debug_line section"));
17027 /* Make sure that we parsed the extended op correctly. If e.g.
17028 we expected a different address size than the producer used,
17029 we may have read the wrong number of bytes. */
17030 if (line_ptr != extended_end)
17032 complaint (&symfile_complaints,
17033 _("mangled .debug_line section"));
17038 if (lh->num_file_names < file || file == 0)
17039 dwarf2_debug_line_missing_file_complaint ();
17042 lh->file_names[file - 1].included_p = 1;
17043 if (!decode_for_pst_p && is_stmt)
17045 if (last_subfile != current_subfile)
17047 addr = gdbarch_addr_bits_remove (gdbarch, address);
17049 (*p_record_line) (last_subfile, 0, addr);
17050 last_subfile = current_subfile;
17052 addr = gdbarch_addr_bits_remove (gdbarch, address);
17053 (*p_record_line) (current_subfile, line, addr);
17058 case DW_LNS_advance_pc:
17061 = read_unsigned_leb128 (abfd, line_ptr, &bytes_read);
17063 address += (((op_index + adjust)
17064 / lh->maximum_ops_per_instruction)
17065 * lh->minimum_instruction_length);
17066 op_index = ((op_index + adjust)
17067 % lh->maximum_ops_per_instruction);
17068 line_ptr += bytes_read;
17071 case DW_LNS_advance_line:
17072 line += read_signed_leb128 (abfd, line_ptr, &bytes_read);
17073 line_ptr += bytes_read;
17075 case DW_LNS_set_file:
17077 /* The arrays lh->include_dirs and lh->file_names are
17078 0-based, but the directory and file name numbers in
17079 the statement program are 1-based. */
17080 struct file_entry *fe;
17081 const char *dir = NULL;
17083 file = read_unsigned_leb128 (abfd, line_ptr, &bytes_read);
17084 line_ptr += bytes_read;
17085 if (lh->num_file_names < file || file == 0)
17086 dwarf2_debug_line_missing_file_complaint ();
17089 fe = &lh->file_names[file - 1];
17091 dir = lh->include_dirs[fe->dir_index - 1];
17092 if (!decode_for_pst_p)
17094 last_subfile = current_subfile;
17095 dwarf2_start_subfile (fe->name, dir, comp_dir);
17100 case DW_LNS_set_column:
17101 column = read_unsigned_leb128 (abfd, line_ptr, &bytes_read);
17102 line_ptr += bytes_read;
17104 case DW_LNS_negate_stmt:
17105 is_stmt = (!is_stmt);
17107 case DW_LNS_set_basic_block:
17110 /* Add to the address register of the state machine the
17111 address increment value corresponding to special opcode
17112 255. I.e., this value is scaled by the minimum
17113 instruction length since special opcode 255 would have
17114 scaled the increment. */
17115 case DW_LNS_const_add_pc:
17117 CORE_ADDR adjust = (255 - lh->opcode_base) / lh->line_range;
17119 address += (((op_index + adjust)
17120 / lh->maximum_ops_per_instruction)
17121 * lh->minimum_instruction_length);
17122 op_index = ((op_index + adjust)
17123 % lh->maximum_ops_per_instruction);
17126 case DW_LNS_fixed_advance_pc:
17127 address += read_2_bytes (abfd, line_ptr);
17133 /* Unknown standard opcode, ignore it. */
17136 for (i = 0; i < lh->standard_opcode_lengths[op_code]; i++)
17138 (void) read_unsigned_leb128 (abfd, line_ptr, &bytes_read);
17139 line_ptr += bytes_read;
17144 if (lh->num_file_names < file || file == 0)
17145 dwarf2_debug_line_missing_file_complaint ();
17148 lh->file_names[file - 1].included_p = 1;
17149 if (!decode_for_pst_p)
17151 addr = gdbarch_addr_bits_remove (gdbarch, address);
17152 (*p_record_line) (current_subfile, 0, addr);
17158 /* Decode the Line Number Program (LNP) for the given line_header
17159 structure and CU. The actual information extracted and the type
17160 of structures created from the LNP depends on the value of PST.
17162 1. If PST is NULL, then this procedure uses the data from the program
17163 to create all necessary symbol tables, and their linetables.
17165 2. If PST is not NULL, this procedure reads the program to determine
17166 the list of files included by the unit represented by PST, and
17167 builds all the associated partial symbol tables.
17169 COMP_DIR is the compilation directory (DW_AT_comp_dir) or NULL if unknown.
17170 It is used for relative paths in the line table.
17171 NOTE: When processing partial symtabs (pst != NULL),
17172 comp_dir == pst->dirname.
17174 NOTE: It is important that psymtabs have the same file name (via strcmp)
17175 as the corresponding symtab. Since COMP_DIR is not used in the name of the
17176 symtab we don't use it in the name of the psymtabs we create.
17177 E.g. expand_line_sal requires this when finding psymtabs to expand.
17178 A good testcase for this is mb-inline.exp. */
17181 dwarf_decode_lines (struct line_header *lh, const char *comp_dir,
17182 struct dwarf2_cu *cu, struct partial_symtab *pst,
17183 int want_line_info)
17185 struct objfile *objfile = cu->objfile;
17186 const int decode_for_pst_p = (pst != NULL);
17187 struct subfile *first_subfile = current_subfile;
17189 if (want_line_info)
17190 dwarf_decode_lines_1 (lh, comp_dir, cu, pst);
17192 if (decode_for_pst_p)
17196 /* Now that we're done scanning the Line Header Program, we can
17197 create the psymtab of each included file. */
17198 for (file_index = 0; file_index < lh->num_file_names; file_index++)
17199 if (lh->file_names[file_index].included_p == 1)
17201 const char *include_name =
17202 psymtab_include_file_name (lh, file_index, pst, comp_dir);
17203 if (include_name != NULL)
17204 dwarf2_create_include_psymtab (include_name, pst, objfile);
17209 /* Make sure a symtab is created for every file, even files
17210 which contain only variables (i.e. no code with associated
17214 for (i = 0; i < lh->num_file_names; i++)
17216 const char *dir = NULL;
17217 struct file_entry *fe;
17219 fe = &lh->file_names[i];
17221 dir = lh->include_dirs[fe->dir_index - 1];
17222 dwarf2_start_subfile (fe->name, dir, comp_dir);
17224 /* Skip the main file; we don't need it, and it must be
17225 allocated last, so that it will show up before the
17226 non-primary symtabs in the objfile's symtab list. */
17227 if (current_subfile == first_subfile)
17230 if (current_subfile->symtab == NULL)
17231 current_subfile->symtab = allocate_symtab (current_subfile->name,
17233 fe->symtab = current_subfile->symtab;
17238 /* Start a subfile for DWARF. FILENAME is the name of the file and
17239 DIRNAME the name of the source directory which contains FILENAME
17240 or NULL if not known. COMP_DIR is the compilation directory for the
17241 linetable's compilation unit or NULL if not known.
17242 This routine tries to keep line numbers from identical absolute and
17243 relative file names in a common subfile.
17245 Using the `list' example from the GDB testsuite, which resides in
17246 /srcdir and compiling it with Irix6.2 cc in /compdir using a filename
17247 of /srcdir/list0.c yields the following debugging information for list0.c:
17249 DW_AT_name: /srcdir/list0.c
17250 DW_AT_comp_dir: /compdir
17251 files.files[0].name: list0.h
17252 files.files[0].dir: /srcdir
17253 files.files[1].name: list0.c
17254 files.files[1].dir: /srcdir
17256 The line number information for list0.c has to end up in a single
17257 subfile, so that `break /srcdir/list0.c:1' works as expected.
17258 start_subfile will ensure that this happens provided that we pass the
17259 concatenation of files.files[1].dir and files.files[1].name as the
17263 dwarf2_start_subfile (const char *filename, const char *dirname,
17264 const char *comp_dir)
17268 /* While reading the DIEs, we call start_symtab(DW_AT_name, DW_AT_comp_dir).
17269 `start_symtab' will always pass the contents of DW_AT_comp_dir as
17270 second argument to start_subfile. To be consistent, we do the
17271 same here. In order not to lose the line information directory,
17272 we concatenate it to the filename when it makes sense.
17273 Note that the Dwarf3 standard says (speaking of filenames in line
17274 information): ``The directory index is ignored for file names
17275 that represent full path names''. Thus ignoring dirname in the
17276 `else' branch below isn't an issue. */
17278 if (!IS_ABSOLUTE_PATH (filename) && dirname != NULL)
17280 copy = concat (dirname, SLASH_STRING, filename, (char *)NULL);
17284 start_subfile (filename, comp_dir);
17290 /* Start a symtab for DWARF.
17291 NAME, COMP_DIR, LOW_PC are passed to start_symtab. */
17294 dwarf2_start_symtab (struct dwarf2_cu *cu,
17295 const char *name, const char *comp_dir, CORE_ADDR low_pc)
17297 start_symtab (name, comp_dir, low_pc);
17298 record_debugformat ("DWARF 2");
17299 record_producer (cu->producer);
17301 /* We assume that we're processing GCC output. */
17302 processing_gcc_compilation = 2;
17304 cu->processing_has_namespace_info = 0;
17308 var_decode_location (struct attribute *attr, struct symbol *sym,
17309 struct dwarf2_cu *cu)
17311 struct objfile *objfile = cu->objfile;
17312 struct comp_unit_head *cu_header = &cu->header;
17314 /* NOTE drow/2003-01-30: There used to be a comment and some special
17315 code here to turn a symbol with DW_AT_external and a
17316 SYMBOL_VALUE_ADDRESS of 0 into a LOC_UNRESOLVED symbol. This was
17317 necessary for platforms (maybe Alpha, certainly PowerPC GNU/Linux
17318 with some versions of binutils) where shared libraries could have
17319 relocations against symbols in their debug information - the
17320 minimal symbol would have the right address, but the debug info
17321 would not. It's no longer necessary, because we will explicitly
17322 apply relocations when we read in the debug information now. */
17324 /* A DW_AT_location attribute with no contents indicates that a
17325 variable has been optimized away. */
17326 if (attr_form_is_block (attr) && DW_BLOCK (attr)->size == 0)
17328 SYMBOL_ACLASS_INDEX (sym) = LOC_OPTIMIZED_OUT;
17332 /* Handle one degenerate form of location expression specially, to
17333 preserve GDB's previous behavior when section offsets are
17334 specified. If this is just a DW_OP_addr or DW_OP_GNU_addr_index
17335 then mark this symbol as LOC_STATIC. */
17337 if (attr_form_is_block (attr)
17338 && ((DW_BLOCK (attr)->data[0] == DW_OP_addr
17339 && DW_BLOCK (attr)->size == 1 + cu_header->addr_size)
17340 || (DW_BLOCK (attr)->data[0] == DW_OP_GNU_addr_index
17341 && (DW_BLOCK (attr)->size
17342 == 1 + leb128_size (&DW_BLOCK (attr)->data[1])))))
17344 unsigned int dummy;
17346 if (DW_BLOCK (attr)->data[0] == DW_OP_addr)
17347 SYMBOL_VALUE_ADDRESS (sym) =
17348 read_address (objfile->obfd, DW_BLOCK (attr)->data + 1, cu, &dummy);
17350 SYMBOL_VALUE_ADDRESS (sym) =
17351 read_addr_index_from_leb128 (cu, DW_BLOCK (attr)->data + 1, &dummy);
17352 SYMBOL_ACLASS_INDEX (sym) = LOC_STATIC;
17353 fixup_symbol_section (sym, objfile);
17354 SYMBOL_VALUE_ADDRESS (sym) += ANOFFSET (objfile->section_offsets,
17355 SYMBOL_SECTION (sym));
17359 /* NOTE drow/2002-01-30: It might be worthwhile to have a static
17360 expression evaluator, and use LOC_COMPUTED only when necessary
17361 (i.e. when the value of a register or memory location is
17362 referenced, or a thread-local block, etc.). Then again, it might
17363 not be worthwhile. I'm assuming that it isn't unless performance
17364 or memory numbers show me otherwise. */
17366 dwarf2_symbol_mark_computed (attr, sym, cu, 0);
17368 if (SYMBOL_COMPUTED_OPS (sym)->location_has_loclist)
17369 cu->has_loclist = 1;
17372 /* Given a pointer to a DWARF information entry, figure out if we need
17373 to make a symbol table entry for it, and if so, create a new entry
17374 and return a pointer to it.
17375 If TYPE is NULL, determine symbol type from the die, otherwise
17376 used the passed type.
17377 If SPACE is not NULL, use it to hold the new symbol. If it is
17378 NULL, allocate a new symbol on the objfile's obstack. */
17380 static struct symbol *
17381 new_symbol_full (struct die_info *die, struct type *type, struct dwarf2_cu *cu,
17382 struct symbol *space)
17384 struct objfile *objfile = cu->objfile;
17385 struct symbol *sym = NULL;
17387 struct attribute *attr = NULL;
17388 struct attribute *attr2 = NULL;
17389 CORE_ADDR baseaddr;
17390 struct pending **list_to_add = NULL;
17392 int inlined_func = (die->tag == DW_TAG_inlined_subroutine);
17394 baseaddr = ANOFFSET (objfile->section_offsets, SECT_OFF_TEXT (objfile));
17396 name = dwarf2_name (die, cu);
17399 const char *linkagename;
17400 int suppress_add = 0;
17405 sym = allocate_symbol (objfile);
17406 OBJSTAT (objfile, n_syms++);
17408 /* Cache this symbol's name and the name's demangled form (if any). */
17409 SYMBOL_SET_LANGUAGE (sym, cu->language, &objfile->objfile_obstack);
17410 linkagename = dwarf2_physname (name, die, cu);
17411 SYMBOL_SET_NAMES (sym, linkagename, strlen (linkagename), 0, objfile);
17413 /* Fortran does not have mangling standard and the mangling does differ
17414 between gfortran, iFort etc. */
17415 if (cu->language == language_fortran
17416 && symbol_get_demangled_name (&(sym->ginfo)) == NULL)
17417 symbol_set_demangled_name (&(sym->ginfo),
17418 dwarf2_full_name (name, die, cu),
17421 /* Default assumptions.
17422 Use the passed type or decode it from the die. */
17423 SYMBOL_DOMAIN (sym) = VAR_DOMAIN;
17424 SYMBOL_ACLASS_INDEX (sym) = LOC_OPTIMIZED_OUT;
17426 SYMBOL_TYPE (sym) = type;
17428 SYMBOL_TYPE (sym) = die_type (die, cu);
17429 attr = dwarf2_attr (die,
17430 inlined_func ? DW_AT_call_line : DW_AT_decl_line,
17434 SYMBOL_LINE (sym) = DW_UNSND (attr);
17437 attr = dwarf2_attr (die,
17438 inlined_func ? DW_AT_call_file : DW_AT_decl_file,
17442 int file_index = DW_UNSND (attr);
17444 if (cu->line_header == NULL
17445 || file_index > cu->line_header->num_file_names)
17446 complaint (&symfile_complaints,
17447 _("file index out of range"));
17448 else if (file_index > 0)
17450 struct file_entry *fe;
17452 fe = &cu->line_header->file_names[file_index - 1];
17453 SYMBOL_SYMTAB (sym) = fe->symtab;
17460 attr = dwarf2_attr (die, DW_AT_low_pc, cu);
17463 SYMBOL_VALUE_ADDRESS (sym) = DW_ADDR (attr) + baseaddr;
17465 SYMBOL_TYPE (sym) = objfile_type (objfile)->builtin_core_addr;
17466 SYMBOL_DOMAIN (sym) = LABEL_DOMAIN;
17467 SYMBOL_ACLASS_INDEX (sym) = LOC_LABEL;
17468 add_symbol_to_list (sym, cu->list_in_scope);
17470 case DW_TAG_subprogram:
17471 /* SYMBOL_BLOCK_VALUE (sym) will be filled in later by
17473 SYMBOL_ACLASS_INDEX (sym) = LOC_BLOCK;
17474 attr2 = dwarf2_attr (die, DW_AT_external, cu);
17475 if ((attr2 && (DW_UNSND (attr2) != 0))
17476 || cu->language == language_ada)
17478 /* Subprograms marked external are stored as a global symbol.
17479 Ada subprograms, whether marked external or not, are always
17480 stored as a global symbol, because we want to be able to
17481 access them globally. For instance, we want to be able
17482 to break on a nested subprogram without having to
17483 specify the context. */
17484 list_to_add = &global_symbols;
17488 list_to_add = cu->list_in_scope;
17491 case DW_TAG_inlined_subroutine:
17492 /* SYMBOL_BLOCK_VALUE (sym) will be filled in later by
17494 SYMBOL_ACLASS_INDEX (sym) = LOC_BLOCK;
17495 SYMBOL_INLINED (sym) = 1;
17496 list_to_add = cu->list_in_scope;
17498 case DW_TAG_template_value_param:
17500 /* Fall through. */
17501 case DW_TAG_constant:
17502 case DW_TAG_variable:
17503 case DW_TAG_member:
17504 /* Compilation with minimal debug info may result in
17505 variables with missing type entries. Change the
17506 misleading `void' type to something sensible. */
17507 if (TYPE_CODE (SYMBOL_TYPE (sym)) == TYPE_CODE_VOID)
17509 = objfile_type (objfile)->nodebug_data_symbol;
17511 attr = dwarf2_attr (die, DW_AT_const_value, cu);
17512 /* In the case of DW_TAG_member, we should only be called for
17513 static const members. */
17514 if (die->tag == DW_TAG_member)
17516 /* dwarf2_add_field uses die_is_declaration,
17517 so we do the same. */
17518 gdb_assert (die_is_declaration (die, cu));
17523 dwarf2_const_value (attr, sym, cu);
17524 attr2 = dwarf2_attr (die, DW_AT_external, cu);
17527 if (attr2 && (DW_UNSND (attr2) != 0))
17528 list_to_add = &global_symbols;
17530 list_to_add = cu->list_in_scope;
17534 attr = dwarf2_attr (die, DW_AT_location, cu);
17537 var_decode_location (attr, sym, cu);
17538 attr2 = dwarf2_attr (die, DW_AT_external, cu);
17540 /* Fortran explicitly imports any global symbols to the local
17541 scope by DW_TAG_common_block. */
17542 if (cu->language == language_fortran && die->parent
17543 && die->parent->tag == DW_TAG_common_block)
17546 if (SYMBOL_CLASS (sym) == LOC_STATIC
17547 && SYMBOL_VALUE_ADDRESS (sym) == 0
17548 && !dwarf2_per_objfile->has_section_at_zero)
17550 /* When a static variable is eliminated by the linker,
17551 the corresponding debug information is not stripped
17552 out, but the variable address is set to null;
17553 do not add such variables into symbol table. */
17555 else if (attr2 && (DW_UNSND (attr2) != 0))
17557 /* Workaround gfortran PR debug/40040 - it uses
17558 DW_AT_location for variables in -fPIC libraries which may
17559 get overriden by other libraries/executable and get
17560 a different address. Resolve it by the minimal symbol
17561 which may come from inferior's executable using copy
17562 relocation. Make this workaround only for gfortran as for
17563 other compilers GDB cannot guess the minimal symbol
17564 Fortran mangling kind. */
17565 if (cu->language == language_fortran && die->parent
17566 && die->parent->tag == DW_TAG_module
17568 && strncmp (cu->producer, "GNU Fortran ", 12) == 0)
17569 SYMBOL_ACLASS_INDEX (sym) = LOC_UNRESOLVED;
17571 /* A variable with DW_AT_external is never static,
17572 but it may be block-scoped. */
17573 list_to_add = (cu->list_in_scope == &file_symbols
17574 ? &global_symbols : cu->list_in_scope);
17577 list_to_add = cu->list_in_scope;
17581 /* We do not know the address of this symbol.
17582 If it is an external symbol and we have type information
17583 for it, enter the symbol as a LOC_UNRESOLVED symbol.
17584 The address of the variable will then be determined from
17585 the minimal symbol table whenever the variable is
17587 attr2 = dwarf2_attr (die, DW_AT_external, cu);
17589 /* Fortran explicitly imports any global symbols to the local
17590 scope by DW_TAG_common_block. */
17591 if (cu->language == language_fortran && die->parent
17592 && die->parent->tag == DW_TAG_common_block)
17594 /* SYMBOL_CLASS doesn't matter here because
17595 read_common_block is going to reset it. */
17597 list_to_add = cu->list_in_scope;
17599 else if (attr2 && (DW_UNSND (attr2) != 0)
17600 && dwarf2_attr (die, DW_AT_type, cu) != NULL)
17602 /* A variable with DW_AT_external is never static, but it
17603 may be block-scoped. */
17604 list_to_add = (cu->list_in_scope == &file_symbols
17605 ? &global_symbols : cu->list_in_scope);
17607 SYMBOL_ACLASS_INDEX (sym) = LOC_UNRESOLVED;
17609 else if (!die_is_declaration (die, cu))
17611 /* Use the default LOC_OPTIMIZED_OUT class. */
17612 gdb_assert (SYMBOL_CLASS (sym) == LOC_OPTIMIZED_OUT);
17614 list_to_add = cu->list_in_scope;
17618 case DW_TAG_formal_parameter:
17619 /* If we are inside a function, mark this as an argument. If
17620 not, we might be looking at an argument to an inlined function
17621 when we do not have enough information to show inlined frames;
17622 pretend it's a local variable in that case so that the user can
17624 if (context_stack_depth > 0
17625 && context_stack[context_stack_depth - 1].name != NULL)
17626 SYMBOL_IS_ARGUMENT (sym) = 1;
17627 attr = dwarf2_attr (die, DW_AT_location, cu);
17630 var_decode_location (attr, sym, cu);
17632 attr = dwarf2_attr (die, DW_AT_const_value, cu);
17635 dwarf2_const_value (attr, sym, cu);
17638 list_to_add = cu->list_in_scope;
17640 case DW_TAG_unspecified_parameters:
17641 /* From varargs functions; gdb doesn't seem to have any
17642 interest in this information, so just ignore it for now.
17645 case DW_TAG_template_type_param:
17647 /* Fall through. */
17648 case DW_TAG_class_type:
17649 case DW_TAG_interface_type:
17650 case DW_TAG_structure_type:
17651 case DW_TAG_union_type:
17652 case DW_TAG_set_type:
17653 case DW_TAG_enumeration_type:
17654 SYMBOL_ACLASS_INDEX (sym) = LOC_TYPEDEF;
17655 SYMBOL_DOMAIN (sym) = STRUCT_DOMAIN;
17658 /* NOTE: carlton/2003-11-10: C++ and Java class symbols shouldn't
17659 really ever be static objects: otherwise, if you try
17660 to, say, break of a class's method and you're in a file
17661 which doesn't mention that class, it won't work unless
17662 the check for all static symbols in lookup_symbol_aux
17663 saves you. See the OtherFileClass tests in
17664 gdb.c++/namespace.exp. */
17668 list_to_add = (cu->list_in_scope == &file_symbols
17669 && (cu->language == language_cplus
17670 || cu->language == language_java)
17671 ? &global_symbols : cu->list_in_scope);
17673 /* The semantics of C++ state that "struct foo {
17674 ... }" also defines a typedef for "foo". A Java
17675 class declaration also defines a typedef for the
17677 if (cu->language == language_cplus
17678 || cu->language == language_java
17679 || cu->language == language_ada)
17681 /* The symbol's name is already allocated along
17682 with this objfile, so we don't need to
17683 duplicate it for the type. */
17684 if (TYPE_NAME (SYMBOL_TYPE (sym)) == 0)
17685 TYPE_NAME (SYMBOL_TYPE (sym)) = SYMBOL_SEARCH_NAME (sym);
17690 case DW_TAG_typedef:
17691 SYMBOL_ACLASS_INDEX (sym) = LOC_TYPEDEF;
17692 SYMBOL_DOMAIN (sym) = VAR_DOMAIN;
17693 list_to_add = cu->list_in_scope;
17695 case DW_TAG_base_type:
17696 case DW_TAG_subrange_type:
17697 SYMBOL_ACLASS_INDEX (sym) = LOC_TYPEDEF;
17698 SYMBOL_DOMAIN (sym) = VAR_DOMAIN;
17699 list_to_add = cu->list_in_scope;
17701 case DW_TAG_enumerator:
17702 attr = dwarf2_attr (die, DW_AT_const_value, cu);
17705 dwarf2_const_value (attr, sym, cu);
17708 /* NOTE: carlton/2003-11-10: See comment above in the
17709 DW_TAG_class_type, etc. block. */
17711 list_to_add = (cu->list_in_scope == &file_symbols
17712 && (cu->language == language_cplus
17713 || cu->language == language_java)
17714 ? &global_symbols : cu->list_in_scope);
17717 case DW_TAG_imported_declaration:
17718 case DW_TAG_namespace:
17719 SYMBOL_ACLASS_INDEX (sym) = LOC_TYPEDEF;
17720 list_to_add = &global_symbols;
17722 case DW_TAG_module:
17723 SYMBOL_ACLASS_INDEX (sym) = LOC_TYPEDEF;
17724 SYMBOL_DOMAIN (sym) = MODULE_DOMAIN;
17725 list_to_add = &global_symbols;
17727 case DW_TAG_common_block:
17728 SYMBOL_ACLASS_INDEX (sym) = LOC_COMMON_BLOCK;
17729 SYMBOL_DOMAIN (sym) = COMMON_BLOCK_DOMAIN;
17730 add_symbol_to_list (sym, cu->list_in_scope);
17733 /* Not a tag we recognize. Hopefully we aren't processing
17734 trash data, but since we must specifically ignore things
17735 we don't recognize, there is nothing else we should do at
17737 complaint (&symfile_complaints, _("unsupported tag: '%s'"),
17738 dwarf_tag_name (die->tag));
17744 sym->hash_next = objfile->template_symbols;
17745 objfile->template_symbols = sym;
17746 list_to_add = NULL;
17749 if (list_to_add != NULL)
17750 add_symbol_to_list (sym, list_to_add);
17752 /* For the benefit of old versions of GCC, check for anonymous
17753 namespaces based on the demangled name. */
17754 if (!cu->processing_has_namespace_info
17755 && cu->language == language_cplus)
17756 cp_scan_for_anonymous_namespaces (sym, objfile);
17761 /* A wrapper for new_symbol_full that always allocates a new symbol. */
17763 static struct symbol *
17764 new_symbol (struct die_info *die, struct type *type, struct dwarf2_cu *cu)
17766 return new_symbol_full (die, type, cu, NULL);
17769 /* Given an attr with a DW_FORM_dataN value in host byte order,
17770 zero-extend it as appropriate for the symbol's type. The DWARF
17771 standard (v4) is not entirely clear about the meaning of using
17772 DW_FORM_dataN for a constant with a signed type, where the type is
17773 wider than the data. The conclusion of a discussion on the DWARF
17774 list was that this is unspecified. We choose to always zero-extend
17775 because that is the interpretation long in use by GCC. */
17778 dwarf2_const_value_data (const struct attribute *attr, struct obstack *obstack,
17779 struct dwarf2_cu *cu, LONGEST *value, int bits)
17781 struct objfile *objfile = cu->objfile;
17782 enum bfd_endian byte_order = bfd_big_endian (objfile->obfd) ?
17783 BFD_ENDIAN_BIG : BFD_ENDIAN_LITTLE;
17784 LONGEST l = DW_UNSND (attr);
17786 if (bits < sizeof (*value) * 8)
17788 l &= ((LONGEST) 1 << bits) - 1;
17791 else if (bits == sizeof (*value) * 8)
17795 gdb_byte *bytes = obstack_alloc (obstack, bits / 8);
17796 store_unsigned_integer (bytes, bits / 8, byte_order, l);
17803 /* Read a constant value from an attribute. Either set *VALUE, or if
17804 the value does not fit in *VALUE, set *BYTES - either already
17805 allocated on the objfile obstack, or newly allocated on OBSTACK,
17806 or, set *BATON, if we translated the constant to a location
17810 dwarf2_const_value_attr (const struct attribute *attr, struct type *type,
17811 const char *name, struct obstack *obstack,
17812 struct dwarf2_cu *cu,
17813 LONGEST *value, const gdb_byte **bytes,
17814 struct dwarf2_locexpr_baton **baton)
17816 struct objfile *objfile = cu->objfile;
17817 struct comp_unit_head *cu_header = &cu->header;
17818 struct dwarf_block *blk;
17819 enum bfd_endian byte_order = (bfd_big_endian (objfile->obfd) ?
17820 BFD_ENDIAN_BIG : BFD_ENDIAN_LITTLE);
17826 switch (attr->form)
17829 case DW_FORM_GNU_addr_index:
17833 if (TYPE_LENGTH (type) != cu_header->addr_size)
17834 dwarf2_const_value_length_mismatch_complaint (name,
17835 cu_header->addr_size,
17836 TYPE_LENGTH (type));
17837 /* Symbols of this form are reasonably rare, so we just
17838 piggyback on the existing location code rather than writing
17839 a new implementation of symbol_computed_ops. */
17840 *baton = obstack_alloc (obstack, sizeof (struct dwarf2_locexpr_baton));
17841 (*baton)->per_cu = cu->per_cu;
17842 gdb_assert ((*baton)->per_cu);
17844 (*baton)->size = 2 + cu_header->addr_size;
17845 data = obstack_alloc (obstack, (*baton)->size);
17846 (*baton)->data = data;
17848 data[0] = DW_OP_addr;
17849 store_unsigned_integer (&data[1], cu_header->addr_size,
17850 byte_order, DW_ADDR (attr));
17851 data[cu_header->addr_size + 1] = DW_OP_stack_value;
17854 case DW_FORM_string:
17856 case DW_FORM_GNU_str_index:
17857 case DW_FORM_GNU_strp_alt:
17858 /* DW_STRING is already allocated on the objfile obstack, point
17860 *bytes = (const gdb_byte *) DW_STRING (attr);
17862 case DW_FORM_block1:
17863 case DW_FORM_block2:
17864 case DW_FORM_block4:
17865 case DW_FORM_block:
17866 case DW_FORM_exprloc:
17867 blk = DW_BLOCK (attr);
17868 if (TYPE_LENGTH (type) != blk->size)
17869 dwarf2_const_value_length_mismatch_complaint (name, blk->size,
17870 TYPE_LENGTH (type));
17871 *bytes = blk->data;
17874 /* The DW_AT_const_value attributes are supposed to carry the
17875 symbol's value "represented as it would be on the target
17876 architecture." By the time we get here, it's already been
17877 converted to host endianness, so we just need to sign- or
17878 zero-extend it as appropriate. */
17879 case DW_FORM_data1:
17880 *bytes = dwarf2_const_value_data (attr, obstack, cu, value, 8);
17882 case DW_FORM_data2:
17883 *bytes = dwarf2_const_value_data (attr, obstack, cu, value, 16);
17885 case DW_FORM_data4:
17886 *bytes = dwarf2_const_value_data (attr, obstack, cu, value, 32);
17888 case DW_FORM_data8:
17889 *bytes = dwarf2_const_value_data (attr, obstack, cu, value, 64);
17892 case DW_FORM_sdata:
17893 *value = DW_SND (attr);
17896 case DW_FORM_udata:
17897 *value = DW_UNSND (attr);
17901 complaint (&symfile_complaints,
17902 _("unsupported const value attribute form: '%s'"),
17903 dwarf_form_name (attr->form));
17910 /* Copy constant value from an attribute to a symbol. */
17913 dwarf2_const_value (const struct attribute *attr, struct symbol *sym,
17914 struct dwarf2_cu *cu)
17916 struct objfile *objfile = cu->objfile;
17917 struct comp_unit_head *cu_header = &cu->header;
17919 const gdb_byte *bytes;
17920 struct dwarf2_locexpr_baton *baton;
17922 dwarf2_const_value_attr (attr, SYMBOL_TYPE (sym),
17923 SYMBOL_PRINT_NAME (sym),
17924 &objfile->objfile_obstack, cu,
17925 &value, &bytes, &baton);
17929 SYMBOL_LOCATION_BATON (sym) = baton;
17930 SYMBOL_ACLASS_INDEX (sym) = dwarf2_locexpr_index;
17932 else if (bytes != NULL)
17934 SYMBOL_VALUE_BYTES (sym) = bytes;
17935 SYMBOL_ACLASS_INDEX (sym) = LOC_CONST_BYTES;
17939 SYMBOL_VALUE (sym) = value;
17940 SYMBOL_ACLASS_INDEX (sym) = LOC_CONST;
17944 /* Return the type of the die in question using its DW_AT_type attribute. */
17946 static struct type *
17947 die_type (struct die_info *die, struct dwarf2_cu *cu)
17949 struct attribute *type_attr;
17951 type_attr = dwarf2_attr (die, DW_AT_type, cu);
17954 /* A missing DW_AT_type represents a void type. */
17955 return objfile_type (cu->objfile)->builtin_void;
17958 return lookup_die_type (die, type_attr, cu);
17961 /* True iff CU's producer generates GNAT Ada auxiliary information
17962 that allows to find parallel types through that information instead
17963 of having to do expensive parallel lookups by type name. */
17966 need_gnat_info (struct dwarf2_cu *cu)
17968 /* FIXME: brobecker/2010-10-12: As of now, only the AdaCore version
17969 of GNAT produces this auxiliary information, without any indication
17970 that it is produced. Part of enhancing the FSF version of GNAT
17971 to produce that information will be to put in place an indicator
17972 that we can use in order to determine whether the descriptive type
17973 info is available or not. One suggestion that has been made is
17974 to use a new attribute, attached to the CU die. For now, assume
17975 that the descriptive type info is not available. */
17979 /* Return the auxiliary type of the die in question using its
17980 DW_AT_GNAT_descriptive_type attribute. Returns NULL if the
17981 attribute is not present. */
17983 static struct type *
17984 die_descriptive_type (struct die_info *die, struct dwarf2_cu *cu)
17986 struct attribute *type_attr;
17988 type_attr = dwarf2_attr (die, DW_AT_GNAT_descriptive_type, cu);
17992 return lookup_die_type (die, type_attr, cu);
17995 /* If DIE has a descriptive_type attribute, then set the TYPE's
17996 descriptive type accordingly. */
17999 set_descriptive_type (struct type *type, struct die_info *die,
18000 struct dwarf2_cu *cu)
18002 struct type *descriptive_type = die_descriptive_type (die, cu);
18004 if (descriptive_type)
18006 ALLOCATE_GNAT_AUX_TYPE (type);
18007 TYPE_DESCRIPTIVE_TYPE (type) = descriptive_type;
18011 /* Return the containing type of the die in question using its
18012 DW_AT_containing_type attribute. */
18014 static struct type *
18015 die_containing_type (struct die_info *die, struct dwarf2_cu *cu)
18017 struct attribute *type_attr;
18019 type_attr = dwarf2_attr (die, DW_AT_containing_type, cu);
18021 error (_("Dwarf Error: Problem turning containing type into gdb type "
18022 "[in module %s]"), objfile_name (cu->objfile));
18024 return lookup_die_type (die, type_attr, cu);
18027 /* Return an error marker type to use for the ill formed type in DIE/CU. */
18029 static struct type *
18030 build_error_marker_type (struct dwarf2_cu *cu, struct die_info *die)
18032 struct objfile *objfile = dwarf2_per_objfile->objfile;
18033 char *message, *saved;
18035 message = xstrprintf (_("<unknown type in %s, CU 0x%x, DIE 0x%x>"),
18036 objfile_name (objfile),
18037 cu->header.offset.sect_off,
18038 die->offset.sect_off);
18039 saved = obstack_copy0 (&objfile->objfile_obstack,
18040 message, strlen (message));
18043 return init_type (TYPE_CODE_ERROR, 0, 0, saved, objfile);
18046 /* Look up the type of DIE in CU using its type attribute ATTR.
18047 ATTR must be one of: DW_AT_type, DW_AT_GNAT_descriptive_type,
18048 DW_AT_containing_type.
18049 If there is no type substitute an error marker. */
18051 static struct type *
18052 lookup_die_type (struct die_info *die, const struct attribute *attr,
18053 struct dwarf2_cu *cu)
18055 struct objfile *objfile = cu->objfile;
18056 struct type *this_type;
18058 gdb_assert (attr->name == DW_AT_type
18059 || attr->name == DW_AT_GNAT_descriptive_type
18060 || attr->name == DW_AT_containing_type);
18062 /* First see if we have it cached. */
18064 if (attr->form == DW_FORM_GNU_ref_alt)
18066 struct dwarf2_per_cu_data *per_cu;
18067 sect_offset offset = dwarf2_get_ref_die_offset (attr);
18069 per_cu = dwarf2_find_containing_comp_unit (offset, 1, cu->objfile);
18070 this_type = get_die_type_at_offset (offset, per_cu);
18072 else if (attr_form_is_ref (attr))
18074 sect_offset offset = dwarf2_get_ref_die_offset (attr);
18076 this_type = get_die_type_at_offset (offset, cu->per_cu);
18078 else if (attr->form == DW_FORM_ref_sig8)
18080 ULONGEST signature = DW_SIGNATURE (attr);
18082 return get_signatured_type (die, signature, cu);
18086 complaint (&symfile_complaints,
18087 _("Dwarf Error: Bad type attribute %s in DIE"
18088 " at 0x%x [in module %s]"),
18089 dwarf_attr_name (attr->name), die->offset.sect_off,
18090 objfile_name (objfile));
18091 return build_error_marker_type (cu, die);
18094 /* If not cached we need to read it in. */
18096 if (this_type == NULL)
18098 struct die_info *type_die = NULL;
18099 struct dwarf2_cu *type_cu = cu;
18101 if (attr_form_is_ref (attr))
18102 type_die = follow_die_ref (die, attr, &type_cu);
18103 if (type_die == NULL)
18104 return build_error_marker_type (cu, die);
18105 /* If we find the type now, it's probably because the type came
18106 from an inter-CU reference and the type's CU got expanded before
18108 this_type = read_type_die (type_die, type_cu);
18111 /* If we still don't have a type use an error marker. */
18113 if (this_type == NULL)
18114 return build_error_marker_type (cu, die);
18119 /* Return the type in DIE, CU.
18120 Returns NULL for invalid types.
18122 This first does a lookup in die_type_hash,
18123 and only reads the die in if necessary.
18125 NOTE: This can be called when reading in partial or full symbols. */
18127 static struct type *
18128 read_type_die (struct die_info *die, struct dwarf2_cu *cu)
18130 struct type *this_type;
18132 this_type = get_die_type (die, cu);
18136 return read_type_die_1 (die, cu);
18139 /* Read the type in DIE, CU.
18140 Returns NULL for invalid types. */
18142 static struct type *
18143 read_type_die_1 (struct die_info *die, struct dwarf2_cu *cu)
18145 struct type *this_type = NULL;
18149 case DW_TAG_class_type:
18150 case DW_TAG_interface_type:
18151 case DW_TAG_structure_type:
18152 case DW_TAG_union_type:
18153 this_type = read_structure_type (die, cu);
18155 case DW_TAG_enumeration_type:
18156 this_type = read_enumeration_type (die, cu);
18158 case DW_TAG_subprogram:
18159 case DW_TAG_subroutine_type:
18160 case DW_TAG_inlined_subroutine:
18161 this_type = read_subroutine_type (die, cu);
18163 case DW_TAG_array_type:
18164 this_type = read_array_type (die, cu);
18166 case DW_TAG_set_type:
18167 this_type = read_set_type (die, cu);
18169 case DW_TAG_pointer_type:
18170 this_type = read_tag_pointer_type (die, cu);
18172 case DW_TAG_ptr_to_member_type:
18173 this_type = read_tag_ptr_to_member_type (die, cu);
18175 case DW_TAG_reference_type:
18176 this_type = read_tag_reference_type (die, cu);
18178 case DW_TAG_const_type:
18179 this_type = read_tag_const_type (die, cu);
18181 case DW_TAG_volatile_type:
18182 this_type = read_tag_volatile_type (die, cu);
18184 case DW_TAG_restrict_type:
18185 this_type = read_tag_restrict_type (die, cu);
18187 case DW_TAG_string_type:
18188 this_type = read_tag_string_type (die, cu);
18190 case DW_TAG_typedef:
18191 this_type = read_typedef (die, cu);
18193 case DW_TAG_subrange_type:
18194 this_type = read_subrange_type (die, cu);
18196 case DW_TAG_base_type:
18197 this_type = read_base_type (die, cu);
18199 case DW_TAG_unspecified_type:
18200 this_type = read_unspecified_type (die, cu);
18202 case DW_TAG_namespace:
18203 this_type = read_namespace_type (die, cu);
18205 case DW_TAG_module:
18206 this_type = read_module_type (die, cu);
18209 complaint (&symfile_complaints,
18210 _("unexpected tag in read_type_die: '%s'"),
18211 dwarf_tag_name (die->tag));
18218 /* See if we can figure out if the class lives in a namespace. We do
18219 this by looking for a member function; its demangled name will
18220 contain namespace info, if there is any.
18221 Return the computed name or NULL.
18222 Space for the result is allocated on the objfile's obstack.
18223 This is the full-die version of guess_partial_die_structure_name.
18224 In this case we know DIE has no useful parent. */
18227 guess_full_die_structure_name (struct die_info *die, struct dwarf2_cu *cu)
18229 struct die_info *spec_die;
18230 struct dwarf2_cu *spec_cu;
18231 struct die_info *child;
18234 spec_die = die_specification (die, &spec_cu);
18235 if (spec_die != NULL)
18241 for (child = die->child;
18243 child = child->sibling)
18245 if (child->tag == DW_TAG_subprogram)
18247 struct attribute *attr;
18249 attr = dwarf2_attr (child, DW_AT_linkage_name, cu);
18251 attr = dwarf2_attr (child, DW_AT_MIPS_linkage_name, cu);
18255 = language_class_name_from_physname (cu->language_defn,
18259 if (actual_name != NULL)
18261 const char *die_name = dwarf2_name (die, cu);
18263 if (die_name != NULL
18264 && strcmp (die_name, actual_name) != 0)
18266 /* Strip off the class name from the full name.
18267 We want the prefix. */
18268 int die_name_len = strlen (die_name);
18269 int actual_name_len = strlen (actual_name);
18271 /* Test for '::' as a sanity check. */
18272 if (actual_name_len > die_name_len + 2
18273 && actual_name[actual_name_len
18274 - die_name_len - 1] == ':')
18276 obstack_copy0 (&cu->objfile->objfile_obstack,
18278 actual_name_len - die_name_len - 2);
18281 xfree (actual_name);
18290 /* GCC might emit a nameless typedef that has a linkage name. Determine the
18291 prefix part in such case. See
18292 http://gcc.gnu.org/bugzilla/show_bug.cgi?id=47510. */
18295 anonymous_struct_prefix (struct die_info *die, struct dwarf2_cu *cu)
18297 struct attribute *attr;
18300 if (die->tag != DW_TAG_class_type && die->tag != DW_TAG_interface_type
18301 && die->tag != DW_TAG_structure_type && die->tag != DW_TAG_union_type)
18304 attr = dwarf2_attr (die, DW_AT_name, cu);
18305 if (attr != NULL && DW_STRING (attr) != NULL)
18308 attr = dwarf2_attr (die, DW_AT_linkage_name, cu);
18310 attr = dwarf2_attr (die, DW_AT_MIPS_linkage_name, cu);
18311 if (attr == NULL || DW_STRING (attr) == NULL)
18314 /* dwarf2_name had to be already called. */
18315 gdb_assert (DW_STRING_IS_CANONICAL (attr));
18317 /* Strip the base name, keep any leading namespaces/classes. */
18318 base = strrchr (DW_STRING (attr), ':');
18319 if (base == NULL || base == DW_STRING (attr) || base[-1] != ':')
18322 return obstack_copy0 (&cu->objfile->objfile_obstack,
18323 DW_STRING (attr), &base[-1] - DW_STRING (attr));
18326 /* Return the name of the namespace/class that DIE is defined within,
18327 or "" if we can't tell. The caller should not xfree the result.
18329 For example, if we're within the method foo() in the following
18339 then determine_prefix on foo's die will return "N::C". */
18341 static const char *
18342 determine_prefix (struct die_info *die, struct dwarf2_cu *cu)
18344 struct die_info *parent, *spec_die;
18345 struct dwarf2_cu *spec_cu;
18346 struct type *parent_type;
18349 if (cu->language != language_cplus && cu->language != language_java
18350 && cu->language != language_fortran)
18353 retval = anonymous_struct_prefix (die, cu);
18357 /* We have to be careful in the presence of DW_AT_specification.
18358 For example, with GCC 3.4, given the code
18362 // Definition of N::foo.
18366 then we'll have a tree of DIEs like this:
18368 1: DW_TAG_compile_unit
18369 2: DW_TAG_namespace // N
18370 3: DW_TAG_subprogram // declaration of N::foo
18371 4: DW_TAG_subprogram // definition of N::foo
18372 DW_AT_specification // refers to die #3
18374 Thus, when processing die #4, we have to pretend that we're in
18375 the context of its DW_AT_specification, namely the contex of die
18378 spec_die = die_specification (die, &spec_cu);
18379 if (spec_die == NULL)
18380 parent = die->parent;
18383 parent = spec_die->parent;
18387 if (parent == NULL)
18389 else if (parent->building_fullname)
18392 const char *parent_name;
18394 /* It has been seen on RealView 2.2 built binaries,
18395 DW_TAG_template_type_param types actually _defined_ as
18396 children of the parent class:
18399 template class <class Enum> Class{};
18400 Class<enum E> class_e;
18402 1: DW_TAG_class_type (Class)
18403 2: DW_TAG_enumeration_type (E)
18404 3: DW_TAG_enumerator (enum1:0)
18405 3: DW_TAG_enumerator (enum2:1)
18407 2: DW_TAG_template_type_param
18408 DW_AT_type DW_FORM_ref_udata (E)
18410 Besides being broken debug info, it can put GDB into an
18411 infinite loop. Consider:
18413 When we're building the full name for Class<E>, we'll start
18414 at Class, and go look over its template type parameters,
18415 finding E. We'll then try to build the full name of E, and
18416 reach here. We're now trying to build the full name of E,
18417 and look over the parent DIE for containing scope. In the
18418 broken case, if we followed the parent DIE of E, we'd again
18419 find Class, and once again go look at its template type
18420 arguments, etc., etc. Simply don't consider such parent die
18421 as source-level parent of this die (it can't be, the language
18422 doesn't allow it), and break the loop here. */
18423 name = dwarf2_name (die, cu);
18424 parent_name = dwarf2_name (parent, cu);
18425 complaint (&symfile_complaints,
18426 _("template param type '%s' defined within parent '%s'"),
18427 name ? name : "<unknown>",
18428 parent_name ? parent_name : "<unknown>");
18432 switch (parent->tag)
18434 case DW_TAG_namespace:
18435 parent_type = read_type_die (parent, cu);
18436 /* GCC 4.0 and 4.1 had a bug (PR c++/28460) where they generated bogus
18437 DW_TAG_namespace DIEs with a name of "::" for the global namespace.
18438 Work around this problem here. */
18439 if (cu->language == language_cplus
18440 && strcmp (TYPE_TAG_NAME (parent_type), "::") == 0)
18442 /* We give a name to even anonymous namespaces. */
18443 return TYPE_TAG_NAME (parent_type);
18444 case DW_TAG_class_type:
18445 case DW_TAG_interface_type:
18446 case DW_TAG_structure_type:
18447 case DW_TAG_union_type:
18448 case DW_TAG_module:
18449 parent_type = read_type_die (parent, cu);
18450 if (TYPE_TAG_NAME (parent_type) != NULL)
18451 return TYPE_TAG_NAME (parent_type);
18453 /* An anonymous structure is only allowed non-static data
18454 members; no typedefs, no member functions, et cetera.
18455 So it does not need a prefix. */
18457 case DW_TAG_compile_unit:
18458 case DW_TAG_partial_unit:
18459 /* gcc-4.5 -gdwarf-4 can drop the enclosing namespace. Cope. */
18460 if (cu->language == language_cplus
18461 && !VEC_empty (dwarf2_section_info_def, dwarf2_per_objfile->types)
18462 && die->child != NULL
18463 && (die->tag == DW_TAG_class_type
18464 || die->tag == DW_TAG_structure_type
18465 || die->tag == DW_TAG_union_type))
18467 char *name = guess_full_die_structure_name (die, cu);
18473 return determine_prefix (parent, cu);
18477 /* Return a newly-allocated string formed by concatenating PREFIX and SUFFIX
18478 with appropriate separator. If PREFIX or SUFFIX is NULL or empty, then
18479 simply copy the SUFFIX or PREFIX, respectively. If OBS is non-null, perform
18480 an obconcat, otherwise allocate storage for the result. The CU argument is
18481 used to determine the language and hence, the appropriate separator. */
18483 #define MAX_SEP_LEN 7 /* strlen ("__") + strlen ("_MOD_") */
18486 typename_concat (struct obstack *obs, const char *prefix, const char *suffix,
18487 int physname, struct dwarf2_cu *cu)
18489 const char *lead = "";
18492 if (suffix == NULL || suffix[0] == '\0'
18493 || prefix == NULL || prefix[0] == '\0')
18495 else if (cu->language == language_java)
18497 else if (cu->language == language_fortran && physname)
18499 /* This is gfortran specific mangling. Normally DW_AT_linkage_name or
18500 DW_AT_MIPS_linkage_name is preferred and used instead. */
18508 if (prefix == NULL)
18510 if (suffix == NULL)
18516 = xmalloc (strlen (prefix) + MAX_SEP_LEN + strlen (suffix) + 1);
18518 strcpy (retval, lead);
18519 strcat (retval, prefix);
18520 strcat (retval, sep);
18521 strcat (retval, suffix);
18526 /* We have an obstack. */
18527 return obconcat (obs, lead, prefix, sep, suffix, (char *) NULL);
18531 /* Return sibling of die, NULL if no sibling. */
18533 static struct die_info *
18534 sibling_die (struct die_info *die)
18536 return die->sibling;
18539 /* Get name of a die, return NULL if not found. */
18541 static const char *
18542 dwarf2_canonicalize_name (const char *name, struct dwarf2_cu *cu,
18543 struct obstack *obstack)
18545 if (name && cu->language == language_cplus)
18547 char *canon_name = cp_canonicalize_string (name);
18549 if (canon_name != NULL)
18551 if (strcmp (canon_name, name) != 0)
18552 name = obstack_copy0 (obstack, canon_name, strlen (canon_name));
18553 xfree (canon_name);
18560 /* Get name of a die, return NULL if not found. */
18562 static const char *
18563 dwarf2_name (struct die_info *die, struct dwarf2_cu *cu)
18565 struct attribute *attr;
18567 attr = dwarf2_attr (die, DW_AT_name, cu);
18568 if ((!attr || !DW_STRING (attr))
18569 && die->tag != DW_TAG_class_type
18570 && die->tag != DW_TAG_interface_type
18571 && die->tag != DW_TAG_structure_type
18572 && die->tag != DW_TAG_union_type)
18577 case DW_TAG_compile_unit:
18578 case DW_TAG_partial_unit:
18579 /* Compilation units have a DW_AT_name that is a filename, not
18580 a source language identifier. */
18581 case DW_TAG_enumeration_type:
18582 case DW_TAG_enumerator:
18583 /* These tags always have simple identifiers already; no need
18584 to canonicalize them. */
18585 return DW_STRING (attr);
18587 case DW_TAG_subprogram:
18588 /* Java constructors will all be named "<init>", so return
18589 the class name when we see this special case. */
18590 if (cu->language == language_java
18591 && DW_STRING (attr) != NULL
18592 && strcmp (DW_STRING (attr), "<init>") == 0)
18594 struct dwarf2_cu *spec_cu = cu;
18595 struct die_info *spec_die;
18597 /* GCJ will output '<init>' for Java constructor names.
18598 For this special case, return the name of the parent class. */
18600 /* GCJ may output suprogram DIEs with AT_specification set.
18601 If so, use the name of the specified DIE. */
18602 spec_die = die_specification (die, &spec_cu);
18603 if (spec_die != NULL)
18604 return dwarf2_name (spec_die, spec_cu);
18609 if (die->tag == DW_TAG_class_type)
18610 return dwarf2_name (die, cu);
18612 while (die->tag != DW_TAG_compile_unit
18613 && die->tag != DW_TAG_partial_unit);
18617 case DW_TAG_class_type:
18618 case DW_TAG_interface_type:
18619 case DW_TAG_structure_type:
18620 case DW_TAG_union_type:
18621 /* Some GCC versions emit spurious DW_AT_name attributes for unnamed
18622 structures or unions. These were of the form "._%d" in GCC 4.1,
18623 or simply "<anonymous struct>" or "<anonymous union>" in GCC 4.3
18624 and GCC 4.4. We work around this problem by ignoring these. */
18625 if (attr && DW_STRING (attr)
18626 && (strncmp (DW_STRING (attr), "._", 2) == 0
18627 || strncmp (DW_STRING (attr), "<anonymous", 10) == 0))
18630 /* GCC might emit a nameless typedef that has a linkage name. See
18631 http://gcc.gnu.org/bugzilla/show_bug.cgi?id=47510. */
18632 if (!attr || DW_STRING (attr) == NULL)
18634 char *demangled = NULL;
18636 attr = dwarf2_attr (die, DW_AT_linkage_name, cu);
18638 attr = dwarf2_attr (die, DW_AT_MIPS_linkage_name, cu);
18640 if (attr == NULL || DW_STRING (attr) == NULL)
18643 /* Avoid demangling DW_STRING (attr) the second time on a second
18644 call for the same DIE. */
18645 if (!DW_STRING_IS_CANONICAL (attr))
18646 demangled = gdb_demangle (DW_STRING (attr), DMGL_TYPES);
18652 /* FIXME: we already did this for the partial symbol... */
18653 DW_STRING (attr) = obstack_copy0 (&cu->objfile->objfile_obstack,
18654 demangled, strlen (demangled));
18655 DW_STRING_IS_CANONICAL (attr) = 1;
18658 /* Strip any leading namespaces/classes, keep only the base name.
18659 DW_AT_name for named DIEs does not contain the prefixes. */
18660 base = strrchr (DW_STRING (attr), ':');
18661 if (base && base > DW_STRING (attr) && base[-1] == ':')
18664 return DW_STRING (attr);
18673 if (!DW_STRING_IS_CANONICAL (attr))
18676 = dwarf2_canonicalize_name (DW_STRING (attr), cu,
18677 &cu->objfile->objfile_obstack);
18678 DW_STRING_IS_CANONICAL (attr) = 1;
18680 return DW_STRING (attr);
18683 /* Return the die that this die in an extension of, or NULL if there
18684 is none. *EXT_CU is the CU containing DIE on input, and the CU
18685 containing the return value on output. */
18687 static struct die_info *
18688 dwarf2_extension (struct die_info *die, struct dwarf2_cu **ext_cu)
18690 struct attribute *attr;
18692 attr = dwarf2_attr (die, DW_AT_extension, *ext_cu);
18696 return follow_die_ref (die, attr, ext_cu);
18699 /* Convert a DIE tag into its string name. */
18701 static const char *
18702 dwarf_tag_name (unsigned tag)
18704 const char *name = get_DW_TAG_name (tag);
18707 return "DW_TAG_<unknown>";
18712 /* Convert a DWARF attribute code into its string name. */
18714 static const char *
18715 dwarf_attr_name (unsigned attr)
18719 #ifdef MIPS /* collides with DW_AT_HP_block_index */
18720 if (attr == DW_AT_MIPS_fde)
18721 return "DW_AT_MIPS_fde";
18723 if (attr == DW_AT_HP_block_index)
18724 return "DW_AT_HP_block_index";
18727 name = get_DW_AT_name (attr);
18730 return "DW_AT_<unknown>";
18735 /* Convert a DWARF value form code into its string name. */
18737 static const char *
18738 dwarf_form_name (unsigned form)
18740 const char *name = get_DW_FORM_name (form);
18743 return "DW_FORM_<unknown>";
18749 dwarf_bool_name (unsigned mybool)
18757 /* Convert a DWARF type code into its string name. */
18759 static const char *
18760 dwarf_type_encoding_name (unsigned enc)
18762 const char *name = get_DW_ATE_name (enc);
18765 return "DW_ATE_<unknown>";
18771 dump_die_shallow (struct ui_file *f, int indent, struct die_info *die)
18775 print_spaces (indent, f);
18776 fprintf_unfiltered (f, "Die: %s (abbrev %d, offset 0x%x)\n",
18777 dwarf_tag_name (die->tag), die->abbrev, die->offset.sect_off);
18779 if (die->parent != NULL)
18781 print_spaces (indent, f);
18782 fprintf_unfiltered (f, " parent at offset: 0x%x\n",
18783 die->parent->offset.sect_off);
18786 print_spaces (indent, f);
18787 fprintf_unfiltered (f, " has children: %s\n",
18788 dwarf_bool_name (die->child != NULL));
18790 print_spaces (indent, f);
18791 fprintf_unfiltered (f, " attributes:\n");
18793 for (i = 0; i < die->num_attrs; ++i)
18795 print_spaces (indent, f);
18796 fprintf_unfiltered (f, " %s (%s) ",
18797 dwarf_attr_name (die->attrs[i].name),
18798 dwarf_form_name (die->attrs[i].form));
18800 switch (die->attrs[i].form)
18803 case DW_FORM_GNU_addr_index:
18804 fprintf_unfiltered (f, "address: ");
18805 fputs_filtered (hex_string (DW_ADDR (&die->attrs[i])), f);
18807 case DW_FORM_block2:
18808 case DW_FORM_block4:
18809 case DW_FORM_block:
18810 case DW_FORM_block1:
18811 fprintf_unfiltered (f, "block: size %s",
18812 pulongest (DW_BLOCK (&die->attrs[i])->size));
18814 case DW_FORM_exprloc:
18815 fprintf_unfiltered (f, "expression: size %s",
18816 pulongest (DW_BLOCK (&die->attrs[i])->size));
18818 case DW_FORM_ref_addr:
18819 fprintf_unfiltered (f, "ref address: ");
18820 fputs_filtered (hex_string (DW_UNSND (&die->attrs[i])), f);
18822 case DW_FORM_GNU_ref_alt:
18823 fprintf_unfiltered (f, "alt ref address: ");
18824 fputs_filtered (hex_string (DW_UNSND (&die->attrs[i])), f);
18830 case DW_FORM_ref_udata:
18831 fprintf_unfiltered (f, "constant ref: 0x%lx (adjusted)",
18832 (long) (DW_UNSND (&die->attrs[i])));
18834 case DW_FORM_data1:
18835 case DW_FORM_data2:
18836 case DW_FORM_data4:
18837 case DW_FORM_data8:
18838 case DW_FORM_udata:
18839 case DW_FORM_sdata:
18840 fprintf_unfiltered (f, "constant: %s",
18841 pulongest (DW_UNSND (&die->attrs[i])));
18843 case DW_FORM_sec_offset:
18844 fprintf_unfiltered (f, "section offset: %s",
18845 pulongest (DW_UNSND (&die->attrs[i])));
18847 case DW_FORM_ref_sig8:
18848 fprintf_unfiltered (f, "signature: %s",
18849 hex_string (DW_SIGNATURE (&die->attrs[i])));
18851 case DW_FORM_string:
18853 case DW_FORM_GNU_str_index:
18854 case DW_FORM_GNU_strp_alt:
18855 fprintf_unfiltered (f, "string: \"%s\" (%s canonicalized)",
18856 DW_STRING (&die->attrs[i])
18857 ? DW_STRING (&die->attrs[i]) : "",
18858 DW_STRING_IS_CANONICAL (&die->attrs[i]) ? "is" : "not");
18861 if (DW_UNSND (&die->attrs[i]))
18862 fprintf_unfiltered (f, "flag: TRUE");
18864 fprintf_unfiltered (f, "flag: FALSE");
18866 case DW_FORM_flag_present:
18867 fprintf_unfiltered (f, "flag: TRUE");
18869 case DW_FORM_indirect:
18870 /* The reader will have reduced the indirect form to
18871 the "base form" so this form should not occur. */
18872 fprintf_unfiltered (f,
18873 "unexpected attribute form: DW_FORM_indirect");
18876 fprintf_unfiltered (f, "unsupported attribute form: %d.",
18877 die->attrs[i].form);
18880 fprintf_unfiltered (f, "\n");
18885 dump_die_for_error (struct die_info *die)
18887 dump_die_shallow (gdb_stderr, 0, die);
18891 dump_die_1 (struct ui_file *f, int level, int max_level, struct die_info *die)
18893 int indent = level * 4;
18895 gdb_assert (die != NULL);
18897 if (level >= max_level)
18900 dump_die_shallow (f, indent, die);
18902 if (die->child != NULL)
18904 print_spaces (indent, f);
18905 fprintf_unfiltered (f, " Children:");
18906 if (level + 1 < max_level)
18908 fprintf_unfiltered (f, "\n");
18909 dump_die_1 (f, level + 1, max_level, die->child);
18913 fprintf_unfiltered (f,
18914 " [not printed, max nesting level reached]\n");
18918 if (die->sibling != NULL && level > 0)
18920 dump_die_1 (f, level, max_level, die->sibling);
18924 /* This is called from the pdie macro in gdbinit.in.
18925 It's not static so gcc will keep a copy callable from gdb. */
18928 dump_die (struct die_info *die, int max_level)
18930 dump_die_1 (gdb_stdlog, 0, max_level, die);
18934 store_in_ref_table (struct die_info *die, struct dwarf2_cu *cu)
18938 slot = htab_find_slot_with_hash (cu->die_hash, die, die->offset.sect_off,
18944 /* Return DIE offset of ATTR. Return 0 with complaint if ATTR is not of the
18948 dwarf2_get_ref_die_offset (const struct attribute *attr)
18950 sect_offset retval = { DW_UNSND (attr) };
18952 if (attr_form_is_ref (attr))
18955 retval.sect_off = 0;
18956 complaint (&symfile_complaints,
18957 _("unsupported die ref attribute form: '%s'"),
18958 dwarf_form_name (attr->form));
18962 /* Return the constant value held by ATTR. Return DEFAULT_VALUE if
18963 * the value held by the attribute is not constant. */
18966 dwarf2_get_attr_constant_value (const struct attribute *attr, int default_value)
18968 if (attr->form == DW_FORM_sdata)
18969 return DW_SND (attr);
18970 else if (attr->form == DW_FORM_udata
18971 || attr->form == DW_FORM_data1
18972 || attr->form == DW_FORM_data2
18973 || attr->form == DW_FORM_data4
18974 || attr->form == DW_FORM_data8)
18975 return DW_UNSND (attr);
18978 complaint (&symfile_complaints,
18979 _("Attribute value is not a constant (%s)"),
18980 dwarf_form_name (attr->form));
18981 return default_value;
18985 /* Follow reference or signature attribute ATTR of SRC_DIE.
18986 On entry *REF_CU is the CU of SRC_DIE.
18987 On exit *REF_CU is the CU of the result. */
18989 static struct die_info *
18990 follow_die_ref_or_sig (struct die_info *src_die, const struct attribute *attr,
18991 struct dwarf2_cu **ref_cu)
18993 struct die_info *die;
18995 if (attr_form_is_ref (attr))
18996 die = follow_die_ref (src_die, attr, ref_cu);
18997 else if (attr->form == DW_FORM_ref_sig8)
18998 die = follow_die_sig (src_die, attr, ref_cu);
19001 dump_die_for_error (src_die);
19002 error (_("Dwarf Error: Expected reference attribute [in module %s]"),
19003 objfile_name ((*ref_cu)->objfile));
19009 /* Follow reference OFFSET.
19010 On entry *REF_CU is the CU of the source die referencing OFFSET.
19011 On exit *REF_CU is the CU of the result.
19012 Returns NULL if OFFSET is invalid. */
19014 static struct die_info *
19015 follow_die_offset (sect_offset offset, int offset_in_dwz,
19016 struct dwarf2_cu **ref_cu)
19018 struct die_info temp_die;
19019 struct dwarf2_cu *target_cu, *cu = *ref_cu;
19021 gdb_assert (cu->per_cu != NULL);
19025 if (cu->per_cu->is_debug_types)
19027 /* .debug_types CUs cannot reference anything outside their CU.
19028 If they need to, they have to reference a signatured type via
19029 DW_FORM_ref_sig8. */
19030 if (! offset_in_cu_p (&cu->header, offset))
19033 else if (offset_in_dwz != cu->per_cu->is_dwz
19034 || ! offset_in_cu_p (&cu->header, offset))
19036 struct dwarf2_per_cu_data *per_cu;
19038 per_cu = dwarf2_find_containing_comp_unit (offset, offset_in_dwz,
19041 /* If necessary, add it to the queue and load its DIEs. */
19042 if (maybe_queue_comp_unit (cu, per_cu, cu->language))
19043 load_full_comp_unit (per_cu, cu->language);
19045 target_cu = per_cu->cu;
19047 else if (cu->dies == NULL)
19049 /* We're loading full DIEs during partial symbol reading. */
19050 gdb_assert (dwarf2_per_objfile->reading_partial_symbols);
19051 load_full_comp_unit (cu->per_cu, language_minimal);
19054 *ref_cu = target_cu;
19055 temp_die.offset = offset;
19056 return htab_find_with_hash (target_cu->die_hash, &temp_die, offset.sect_off);
19059 /* Follow reference attribute ATTR of SRC_DIE.
19060 On entry *REF_CU is the CU of SRC_DIE.
19061 On exit *REF_CU is the CU of the result. */
19063 static struct die_info *
19064 follow_die_ref (struct die_info *src_die, const struct attribute *attr,
19065 struct dwarf2_cu **ref_cu)
19067 sect_offset offset = dwarf2_get_ref_die_offset (attr);
19068 struct dwarf2_cu *cu = *ref_cu;
19069 struct die_info *die;
19071 die = follow_die_offset (offset,
19072 (attr->form == DW_FORM_GNU_ref_alt
19073 || cu->per_cu->is_dwz),
19076 error (_("Dwarf Error: Cannot find DIE at 0x%x referenced from DIE "
19077 "at 0x%x [in module %s]"),
19078 offset.sect_off, src_die->offset.sect_off,
19079 objfile_name (cu->objfile));
19084 /* Return DWARF block referenced by DW_AT_location of DIE at OFFSET at PER_CU.
19085 Returned value is intended for DW_OP_call*. Returned
19086 dwarf2_locexpr_baton->data has lifetime of PER_CU->OBJFILE. */
19088 struct dwarf2_locexpr_baton
19089 dwarf2_fetch_die_loc_sect_off (sect_offset offset,
19090 struct dwarf2_per_cu_data *per_cu,
19091 CORE_ADDR (*get_frame_pc) (void *baton),
19094 struct dwarf2_cu *cu;
19095 struct die_info *die;
19096 struct attribute *attr;
19097 struct dwarf2_locexpr_baton retval;
19099 dw2_setup (per_cu->objfile);
19101 if (per_cu->cu == NULL)
19105 die = follow_die_offset (offset, per_cu->is_dwz, &cu);
19107 error (_("Dwarf Error: Cannot find DIE at 0x%x referenced in module %s"),
19108 offset.sect_off, objfile_name (per_cu->objfile));
19110 attr = dwarf2_attr (die, DW_AT_location, cu);
19113 /* DWARF: "If there is no such attribute, then there is no effect.".
19114 DATA is ignored if SIZE is 0. */
19116 retval.data = NULL;
19119 else if (attr_form_is_section_offset (attr))
19121 struct dwarf2_loclist_baton loclist_baton;
19122 CORE_ADDR pc = (*get_frame_pc) (baton);
19125 fill_in_loclist_baton (cu, &loclist_baton, attr);
19127 retval.data = dwarf2_find_location_expression (&loclist_baton,
19129 retval.size = size;
19133 if (!attr_form_is_block (attr))
19134 error (_("Dwarf Error: DIE at 0x%x referenced in module %s "
19135 "is neither DW_FORM_block* nor DW_FORM_exprloc"),
19136 offset.sect_off, objfile_name (per_cu->objfile));
19138 retval.data = DW_BLOCK (attr)->data;
19139 retval.size = DW_BLOCK (attr)->size;
19141 retval.per_cu = cu->per_cu;
19143 age_cached_comp_units ();
19148 /* Like dwarf2_fetch_die_loc_sect_off, but take a CU
19151 struct dwarf2_locexpr_baton
19152 dwarf2_fetch_die_loc_cu_off (cu_offset offset_in_cu,
19153 struct dwarf2_per_cu_data *per_cu,
19154 CORE_ADDR (*get_frame_pc) (void *baton),
19157 sect_offset offset = { per_cu->offset.sect_off + offset_in_cu.cu_off };
19159 return dwarf2_fetch_die_loc_sect_off (offset, per_cu, get_frame_pc, baton);
19162 /* Write a constant of a given type as target-ordered bytes into
19165 static const gdb_byte *
19166 write_constant_as_bytes (struct obstack *obstack,
19167 enum bfd_endian byte_order,
19174 *len = TYPE_LENGTH (type);
19175 result = obstack_alloc (obstack, *len);
19176 store_unsigned_integer (result, *len, byte_order, value);
19181 /* If the DIE at OFFSET in PER_CU has a DW_AT_const_value, return a
19182 pointer to the constant bytes and set LEN to the length of the
19183 data. If memory is needed, allocate it on OBSTACK. If the DIE
19184 does not have a DW_AT_const_value, return NULL. */
19187 dwarf2_fetch_constant_bytes (sect_offset offset,
19188 struct dwarf2_per_cu_data *per_cu,
19189 struct obstack *obstack,
19192 struct dwarf2_cu *cu;
19193 struct die_info *die;
19194 struct attribute *attr;
19195 const gdb_byte *result = NULL;
19198 enum bfd_endian byte_order;
19200 dw2_setup (per_cu->objfile);
19202 if (per_cu->cu == NULL)
19206 die = follow_die_offset (offset, per_cu->is_dwz, &cu);
19208 error (_("Dwarf Error: Cannot find DIE at 0x%x referenced in module %s"),
19209 offset.sect_off, objfile_name (per_cu->objfile));
19212 attr = dwarf2_attr (die, DW_AT_const_value, cu);
19216 byte_order = (bfd_big_endian (per_cu->objfile->obfd)
19217 ? BFD_ENDIAN_BIG : BFD_ENDIAN_LITTLE);
19219 switch (attr->form)
19222 case DW_FORM_GNU_addr_index:
19226 *len = cu->header.addr_size;
19227 tem = obstack_alloc (obstack, *len);
19228 store_unsigned_integer (tem, *len, byte_order, DW_ADDR (attr));
19232 case DW_FORM_string:
19234 case DW_FORM_GNU_str_index:
19235 case DW_FORM_GNU_strp_alt:
19236 /* DW_STRING is already allocated on the objfile obstack, point
19238 result = (const gdb_byte *) DW_STRING (attr);
19239 *len = strlen (DW_STRING (attr));
19241 case DW_FORM_block1:
19242 case DW_FORM_block2:
19243 case DW_FORM_block4:
19244 case DW_FORM_block:
19245 case DW_FORM_exprloc:
19246 result = DW_BLOCK (attr)->data;
19247 *len = DW_BLOCK (attr)->size;
19250 /* The DW_AT_const_value attributes are supposed to carry the
19251 symbol's value "represented as it would be on the target
19252 architecture." By the time we get here, it's already been
19253 converted to host endianness, so we just need to sign- or
19254 zero-extend it as appropriate. */
19255 case DW_FORM_data1:
19256 type = die_type (die, cu);
19257 result = dwarf2_const_value_data (attr, obstack, cu, &value, 8);
19258 if (result == NULL)
19259 result = write_constant_as_bytes (obstack, byte_order,
19262 case DW_FORM_data2:
19263 type = die_type (die, cu);
19264 result = dwarf2_const_value_data (attr, obstack, cu, &value, 16);
19265 if (result == NULL)
19266 result = write_constant_as_bytes (obstack, byte_order,
19269 case DW_FORM_data4:
19270 type = die_type (die, cu);
19271 result = dwarf2_const_value_data (attr, obstack, cu, &value, 32);
19272 if (result == NULL)
19273 result = write_constant_as_bytes (obstack, byte_order,
19276 case DW_FORM_data8:
19277 type = die_type (die, cu);
19278 result = dwarf2_const_value_data (attr, obstack, cu, &value, 64);
19279 if (result == NULL)
19280 result = write_constant_as_bytes (obstack, byte_order,
19284 case DW_FORM_sdata:
19285 type = die_type (die, cu);
19286 result = write_constant_as_bytes (obstack, byte_order,
19287 type, DW_SND (attr), len);
19290 case DW_FORM_udata:
19291 type = die_type (die, cu);
19292 result = write_constant_as_bytes (obstack, byte_order,
19293 type, DW_UNSND (attr), len);
19297 complaint (&symfile_complaints,
19298 _("unsupported const value attribute form: '%s'"),
19299 dwarf_form_name (attr->form));
19306 /* Return the type of the DIE at DIE_OFFSET in the CU named by
19310 dwarf2_get_die_type (cu_offset die_offset,
19311 struct dwarf2_per_cu_data *per_cu)
19313 sect_offset die_offset_sect;
19315 dw2_setup (per_cu->objfile);
19317 die_offset_sect.sect_off = per_cu->offset.sect_off + die_offset.cu_off;
19318 return get_die_type_at_offset (die_offset_sect, per_cu);
19321 /* Follow type unit SIG_TYPE referenced by SRC_DIE.
19322 On entry *REF_CU is the CU of SRC_DIE.
19323 On exit *REF_CU is the CU of the result.
19324 Returns NULL if the referenced DIE isn't found. */
19326 static struct die_info *
19327 follow_die_sig_1 (struct die_info *src_die, struct signatured_type *sig_type,
19328 struct dwarf2_cu **ref_cu)
19330 struct objfile *objfile = (*ref_cu)->objfile;
19331 struct die_info temp_die;
19332 struct dwarf2_cu *sig_cu;
19333 struct die_info *die;
19335 /* While it might be nice to assert sig_type->type == NULL here,
19336 we can get here for DW_AT_imported_declaration where we need
19337 the DIE not the type. */
19339 /* If necessary, add it to the queue and load its DIEs. */
19341 if (maybe_queue_comp_unit (*ref_cu, &sig_type->per_cu, language_minimal))
19342 read_signatured_type (sig_type);
19344 sig_cu = sig_type->per_cu.cu;
19345 gdb_assert (sig_cu != NULL);
19346 gdb_assert (sig_type->type_offset_in_section.sect_off != 0);
19347 temp_die.offset = sig_type->type_offset_in_section;
19348 die = htab_find_with_hash (sig_cu->die_hash, &temp_die,
19349 temp_die.offset.sect_off);
19352 /* For .gdb_index version 7 keep track of included TUs.
19353 http://sourceware.org/bugzilla/show_bug.cgi?id=15021. */
19354 if (dwarf2_per_objfile->index_table != NULL
19355 && dwarf2_per_objfile->index_table->version <= 7)
19357 VEC_safe_push (dwarf2_per_cu_ptr,
19358 (*ref_cu)->per_cu->imported_symtabs,
19369 /* Follow signatured type referenced by ATTR in SRC_DIE.
19370 On entry *REF_CU is the CU of SRC_DIE.
19371 On exit *REF_CU is the CU of the result.
19372 The result is the DIE of the type.
19373 If the referenced type cannot be found an error is thrown. */
19375 static struct die_info *
19376 follow_die_sig (struct die_info *src_die, const struct attribute *attr,
19377 struct dwarf2_cu **ref_cu)
19379 ULONGEST signature = DW_SIGNATURE (attr);
19380 struct signatured_type *sig_type;
19381 struct die_info *die;
19383 gdb_assert (attr->form == DW_FORM_ref_sig8);
19385 sig_type = lookup_signatured_type (*ref_cu, signature);
19386 /* sig_type will be NULL if the signatured type is missing from
19388 if (sig_type == NULL)
19390 error (_("Dwarf Error: Cannot find signatured DIE %s referenced"
19391 " from DIE at 0x%x [in module %s]"),
19392 hex_string (signature), src_die->offset.sect_off,
19393 objfile_name ((*ref_cu)->objfile));
19396 die = follow_die_sig_1 (src_die, sig_type, ref_cu);
19399 dump_die_for_error (src_die);
19400 error (_("Dwarf Error: Problem reading signatured DIE %s referenced"
19401 " from DIE at 0x%x [in module %s]"),
19402 hex_string (signature), src_die->offset.sect_off,
19403 objfile_name ((*ref_cu)->objfile));
19409 /* Get the type specified by SIGNATURE referenced in DIE/CU,
19410 reading in and processing the type unit if necessary. */
19412 static struct type *
19413 get_signatured_type (struct die_info *die, ULONGEST signature,
19414 struct dwarf2_cu *cu)
19416 struct signatured_type *sig_type;
19417 struct dwarf2_cu *type_cu;
19418 struct die_info *type_die;
19421 sig_type = lookup_signatured_type (cu, signature);
19422 /* sig_type will be NULL if the signatured type is missing from
19424 if (sig_type == NULL)
19426 complaint (&symfile_complaints,
19427 _("Dwarf Error: Cannot find signatured DIE %s referenced"
19428 " from DIE at 0x%x [in module %s]"),
19429 hex_string (signature), die->offset.sect_off,
19430 objfile_name (dwarf2_per_objfile->objfile));
19431 return build_error_marker_type (cu, die);
19434 /* If we already know the type we're done. */
19435 if (sig_type->type != NULL)
19436 return sig_type->type;
19439 type_die = follow_die_sig_1 (die, sig_type, &type_cu);
19440 if (type_die != NULL)
19442 /* N.B. We need to call get_die_type to ensure only one type for this DIE
19443 is created. This is important, for example, because for c++ classes
19444 we need TYPE_NAME set which is only done by new_symbol. Blech. */
19445 type = read_type_die (type_die, type_cu);
19448 complaint (&symfile_complaints,
19449 _("Dwarf Error: Cannot build signatured type %s"
19450 " referenced from DIE at 0x%x [in module %s]"),
19451 hex_string (signature), die->offset.sect_off,
19452 objfile_name (dwarf2_per_objfile->objfile));
19453 type = build_error_marker_type (cu, die);
19458 complaint (&symfile_complaints,
19459 _("Dwarf Error: Problem reading signatured DIE %s referenced"
19460 " from DIE at 0x%x [in module %s]"),
19461 hex_string (signature), die->offset.sect_off,
19462 objfile_name (dwarf2_per_objfile->objfile));
19463 type = build_error_marker_type (cu, die);
19465 sig_type->type = type;
19470 /* Get the type specified by the DW_AT_signature ATTR in DIE/CU,
19471 reading in and processing the type unit if necessary. */
19473 static struct type *
19474 get_DW_AT_signature_type (struct die_info *die, const struct attribute *attr,
19475 struct dwarf2_cu *cu) /* ARI: editCase function */
19477 /* Yes, DW_AT_signature can use a non-ref_sig8 reference. */
19478 if (attr_form_is_ref (attr))
19480 struct dwarf2_cu *type_cu = cu;
19481 struct die_info *type_die = follow_die_ref (die, attr, &type_cu);
19483 return read_type_die (type_die, type_cu);
19485 else if (attr->form == DW_FORM_ref_sig8)
19487 return get_signatured_type (die, DW_SIGNATURE (attr), cu);
19491 complaint (&symfile_complaints,
19492 _("Dwarf Error: DW_AT_signature has bad form %s in DIE"
19493 " at 0x%x [in module %s]"),
19494 dwarf_form_name (attr->form), die->offset.sect_off,
19495 objfile_name (dwarf2_per_objfile->objfile));
19496 return build_error_marker_type (cu, die);
19500 /* Load the DIEs associated with type unit PER_CU into memory. */
19503 load_full_type_unit (struct dwarf2_per_cu_data *per_cu)
19505 struct signatured_type *sig_type;
19507 /* Caller is responsible for ensuring type_unit_groups don't get here. */
19508 gdb_assert (! IS_TYPE_UNIT_GROUP (per_cu));
19510 /* We have the per_cu, but we need the signatured_type.
19511 Fortunately this is an easy translation. */
19512 gdb_assert (per_cu->is_debug_types);
19513 sig_type = (struct signatured_type *) per_cu;
19515 gdb_assert (per_cu->cu == NULL);
19517 read_signatured_type (sig_type);
19519 gdb_assert (per_cu->cu != NULL);
19522 /* die_reader_func for read_signatured_type.
19523 This is identical to load_full_comp_unit_reader,
19524 but is kept separate for now. */
19527 read_signatured_type_reader (const struct die_reader_specs *reader,
19528 const gdb_byte *info_ptr,
19529 struct die_info *comp_unit_die,
19533 struct dwarf2_cu *cu = reader->cu;
19535 gdb_assert (cu->die_hash == NULL);
19537 htab_create_alloc_ex (cu->header.length / 12,
19541 &cu->comp_unit_obstack,
19542 hashtab_obstack_allocate,
19543 dummy_obstack_deallocate);
19546 comp_unit_die->child = read_die_and_siblings (reader, info_ptr,
19547 &info_ptr, comp_unit_die);
19548 cu->dies = comp_unit_die;
19549 /* comp_unit_die is not stored in die_hash, no need. */
19551 /* We try not to read any attributes in this function, because not
19552 all CUs needed for references have been loaded yet, and symbol
19553 table processing isn't initialized. But we have to set the CU language,
19554 or we won't be able to build types correctly.
19555 Similarly, if we do not read the producer, we can not apply
19556 producer-specific interpretation. */
19557 prepare_one_comp_unit (cu, cu->dies, language_minimal);
19560 /* Read in a signatured type and build its CU and DIEs.
19561 If the type is a stub for the real type in a DWO file,
19562 read in the real type from the DWO file as well. */
19565 read_signatured_type (struct signatured_type *sig_type)
19567 struct dwarf2_per_cu_data *per_cu = &sig_type->per_cu;
19569 gdb_assert (per_cu->is_debug_types);
19570 gdb_assert (per_cu->cu == NULL);
19572 init_cutu_and_read_dies (per_cu, NULL, 0, 1,
19573 read_signatured_type_reader, NULL);
19574 sig_type->per_cu.tu_read = 1;
19577 /* Decode simple location descriptions.
19578 Given a pointer to a dwarf block that defines a location, compute
19579 the location and return the value.
19581 NOTE drow/2003-11-18: This function is called in two situations
19582 now: for the address of static or global variables (partial symbols
19583 only) and for offsets into structures which are expected to be
19584 (more or less) constant. The partial symbol case should go away,
19585 and only the constant case should remain. That will let this
19586 function complain more accurately. A few special modes are allowed
19587 without complaint for global variables (for instance, global
19588 register values and thread-local values).
19590 A location description containing no operations indicates that the
19591 object is optimized out. The return value is 0 for that case.
19592 FIXME drow/2003-11-16: No callers check for this case any more; soon all
19593 callers will only want a very basic result and this can become a
19596 Note that stack[0] is unused except as a default error return. */
19599 decode_locdesc (struct dwarf_block *blk, struct dwarf2_cu *cu)
19601 struct objfile *objfile = cu->objfile;
19603 size_t size = blk->size;
19604 const gdb_byte *data = blk->data;
19605 CORE_ADDR stack[64];
19607 unsigned int bytes_read, unsnd;
19613 stack[++stacki] = 0;
19652 stack[++stacki] = op - DW_OP_lit0;
19687 stack[++stacki] = op - DW_OP_reg0;
19689 dwarf2_complex_location_expr_complaint ();
19693 unsnd = read_unsigned_leb128 (NULL, (data + i), &bytes_read);
19695 stack[++stacki] = unsnd;
19697 dwarf2_complex_location_expr_complaint ();
19701 stack[++stacki] = read_address (objfile->obfd, &data[i],
19706 case DW_OP_const1u:
19707 stack[++stacki] = read_1_byte (objfile->obfd, &data[i]);
19711 case DW_OP_const1s:
19712 stack[++stacki] = read_1_signed_byte (objfile->obfd, &data[i]);
19716 case DW_OP_const2u:
19717 stack[++stacki] = read_2_bytes (objfile->obfd, &data[i]);
19721 case DW_OP_const2s:
19722 stack[++stacki] = read_2_signed_bytes (objfile->obfd, &data[i]);
19726 case DW_OP_const4u:
19727 stack[++stacki] = read_4_bytes (objfile->obfd, &data[i]);
19731 case DW_OP_const4s:
19732 stack[++stacki] = read_4_signed_bytes (objfile->obfd, &data[i]);
19736 case DW_OP_const8u:
19737 stack[++stacki] = read_8_bytes (objfile->obfd, &data[i]);
19742 stack[++stacki] = read_unsigned_leb128 (NULL, (data + i),
19748 stack[++stacki] = read_signed_leb128 (NULL, (data + i), &bytes_read);
19753 stack[stacki + 1] = stack[stacki];
19758 stack[stacki - 1] += stack[stacki];
19762 case DW_OP_plus_uconst:
19763 stack[stacki] += read_unsigned_leb128 (NULL, (data + i),
19769 stack[stacki - 1] -= stack[stacki];
19774 /* If we're not the last op, then we definitely can't encode
19775 this using GDB's address_class enum. This is valid for partial
19776 global symbols, although the variable's address will be bogus
19779 dwarf2_complex_location_expr_complaint ();
19782 case DW_OP_GNU_push_tls_address:
19783 /* The top of the stack has the offset from the beginning
19784 of the thread control block at which the variable is located. */
19785 /* Nothing should follow this operator, so the top of stack would
19787 /* This is valid for partial global symbols, but the variable's
19788 address will be bogus in the psymtab. Make it always at least
19789 non-zero to not look as a variable garbage collected by linker
19790 which have DW_OP_addr 0. */
19792 dwarf2_complex_location_expr_complaint ();
19796 case DW_OP_GNU_uninit:
19799 case DW_OP_GNU_addr_index:
19800 case DW_OP_GNU_const_index:
19801 stack[++stacki] = read_addr_index_from_leb128 (cu, &data[i],
19808 const char *name = get_DW_OP_name (op);
19811 complaint (&symfile_complaints, _("unsupported stack op: '%s'"),
19814 complaint (&symfile_complaints, _("unsupported stack op: '%02x'"),
19818 return (stack[stacki]);
19821 /* Enforce maximum stack depth of SIZE-1 to avoid writing
19822 outside of the allocated space. Also enforce minimum>0. */
19823 if (stacki >= ARRAY_SIZE (stack) - 1)
19825 complaint (&symfile_complaints,
19826 _("location description stack overflow"));
19832 complaint (&symfile_complaints,
19833 _("location description stack underflow"));
19837 return (stack[stacki]);
19840 /* memory allocation interface */
19842 static struct dwarf_block *
19843 dwarf_alloc_block (struct dwarf2_cu *cu)
19845 struct dwarf_block *blk;
19847 blk = (struct dwarf_block *)
19848 obstack_alloc (&cu->comp_unit_obstack, sizeof (struct dwarf_block));
19852 static struct die_info *
19853 dwarf_alloc_die (struct dwarf2_cu *cu, int num_attrs)
19855 struct die_info *die;
19856 size_t size = sizeof (struct die_info);
19859 size += (num_attrs - 1) * sizeof (struct attribute);
19861 die = (struct die_info *) obstack_alloc (&cu->comp_unit_obstack, size);
19862 memset (die, 0, sizeof (struct die_info));
19867 /* Macro support. */
19869 /* Return file name relative to the compilation directory of file number I in
19870 *LH's file name table. The result is allocated using xmalloc; the caller is
19871 responsible for freeing it. */
19874 file_file_name (int file, struct line_header *lh)
19876 /* Is the file number a valid index into the line header's file name
19877 table? Remember that file numbers start with one, not zero. */
19878 if (1 <= file && file <= lh->num_file_names)
19880 struct file_entry *fe = &lh->file_names[file - 1];
19882 if (IS_ABSOLUTE_PATH (fe->name) || fe->dir_index == 0)
19883 return xstrdup (fe->name);
19884 return concat (lh->include_dirs[fe->dir_index - 1], SLASH_STRING,
19889 /* The compiler produced a bogus file number. We can at least
19890 record the macro definitions made in the file, even if we
19891 won't be able to find the file by name. */
19892 char fake_name[80];
19894 xsnprintf (fake_name, sizeof (fake_name),
19895 "<bad macro file number %d>", file);
19897 complaint (&symfile_complaints,
19898 _("bad file number in macro information (%d)"),
19901 return xstrdup (fake_name);
19905 /* Return the full name of file number I in *LH's file name table.
19906 Use COMP_DIR as the name of the current directory of the
19907 compilation. The result is allocated using xmalloc; the caller is
19908 responsible for freeing it. */
19910 file_full_name (int file, struct line_header *lh, const char *comp_dir)
19912 /* Is the file number a valid index into the line header's file name
19913 table? Remember that file numbers start with one, not zero. */
19914 if (1 <= file && file <= lh->num_file_names)
19916 char *relative = file_file_name (file, lh);
19918 if (IS_ABSOLUTE_PATH (relative) || comp_dir == NULL)
19920 return reconcat (relative, comp_dir, SLASH_STRING, relative, NULL);
19923 return file_file_name (file, lh);
19927 static struct macro_source_file *
19928 macro_start_file (int file, int line,
19929 struct macro_source_file *current_file,
19930 const char *comp_dir,
19931 struct line_header *lh, struct objfile *objfile)
19933 /* File name relative to the compilation directory of this source file. */
19934 char *file_name = file_file_name (file, lh);
19936 if (! current_file)
19938 /* Note: We don't create a macro table for this compilation unit
19939 at all until we actually get a filename. */
19940 struct macro_table *macro_table = get_macro_table (objfile, comp_dir);
19942 /* If we have no current file, then this must be the start_file
19943 directive for the compilation unit's main source file. */
19944 current_file = macro_set_main (macro_table, file_name);
19945 macro_define_special (macro_table);
19948 current_file = macro_include (current_file, line, file_name);
19952 return current_file;
19956 /* Copy the LEN characters at BUF to a xmalloc'ed block of memory,
19957 followed by a null byte. */
19959 copy_string (const char *buf, int len)
19961 char *s = xmalloc (len + 1);
19963 memcpy (s, buf, len);
19969 static const char *
19970 consume_improper_spaces (const char *p, const char *body)
19974 complaint (&symfile_complaints,
19975 _("macro definition contains spaces "
19976 "in formal argument list:\n`%s'"),
19988 parse_macro_definition (struct macro_source_file *file, int line,
19993 /* The body string takes one of two forms. For object-like macro
19994 definitions, it should be:
19996 <macro name> " " <definition>
19998 For function-like macro definitions, it should be:
20000 <macro name> "() " <definition>
20002 <macro name> "(" <arg name> ( "," <arg name> ) * ") " <definition>
20004 Spaces may appear only where explicitly indicated, and in the
20007 The Dwarf 2 spec says that an object-like macro's name is always
20008 followed by a space, but versions of GCC around March 2002 omit
20009 the space when the macro's definition is the empty string.
20011 The Dwarf 2 spec says that there should be no spaces between the
20012 formal arguments in a function-like macro's formal argument list,
20013 but versions of GCC around March 2002 include spaces after the
20017 /* Find the extent of the macro name. The macro name is terminated
20018 by either a space or null character (for an object-like macro) or
20019 an opening paren (for a function-like macro). */
20020 for (p = body; *p; p++)
20021 if (*p == ' ' || *p == '(')
20024 if (*p == ' ' || *p == '\0')
20026 /* It's an object-like macro. */
20027 int name_len = p - body;
20028 char *name = copy_string (body, name_len);
20029 const char *replacement;
20032 replacement = body + name_len + 1;
20035 dwarf2_macro_malformed_definition_complaint (body);
20036 replacement = body + name_len;
20039 macro_define_object (file, line, name, replacement);
20043 else if (*p == '(')
20045 /* It's a function-like macro. */
20046 char *name = copy_string (body, p - body);
20049 char **argv = xmalloc (argv_size * sizeof (*argv));
20053 p = consume_improper_spaces (p, body);
20055 /* Parse the formal argument list. */
20056 while (*p && *p != ')')
20058 /* Find the extent of the current argument name. */
20059 const char *arg_start = p;
20061 while (*p && *p != ',' && *p != ')' && *p != ' ')
20064 if (! *p || p == arg_start)
20065 dwarf2_macro_malformed_definition_complaint (body);
20068 /* Make sure argv has room for the new argument. */
20069 if (argc >= argv_size)
20072 argv = xrealloc (argv, argv_size * sizeof (*argv));
20075 argv[argc++] = copy_string (arg_start, p - arg_start);
20078 p = consume_improper_spaces (p, body);
20080 /* Consume the comma, if present. */
20085 p = consume_improper_spaces (p, body);
20094 /* Perfectly formed definition, no complaints. */
20095 macro_define_function (file, line, name,
20096 argc, (const char **) argv,
20098 else if (*p == '\0')
20100 /* Complain, but do define it. */
20101 dwarf2_macro_malformed_definition_complaint (body);
20102 macro_define_function (file, line, name,
20103 argc, (const char **) argv,
20107 /* Just complain. */
20108 dwarf2_macro_malformed_definition_complaint (body);
20111 /* Just complain. */
20112 dwarf2_macro_malformed_definition_complaint (body);
20118 for (i = 0; i < argc; i++)
20124 dwarf2_macro_malformed_definition_complaint (body);
20127 /* Skip some bytes from BYTES according to the form given in FORM.
20128 Returns the new pointer. */
20130 static const gdb_byte *
20131 skip_form_bytes (bfd *abfd, const gdb_byte *bytes, const gdb_byte *buffer_end,
20132 enum dwarf_form form,
20133 unsigned int offset_size,
20134 struct dwarf2_section_info *section)
20136 unsigned int bytes_read;
20140 case DW_FORM_data1:
20145 case DW_FORM_data2:
20149 case DW_FORM_data4:
20153 case DW_FORM_data8:
20157 case DW_FORM_string:
20158 read_direct_string (abfd, bytes, &bytes_read);
20159 bytes += bytes_read;
20162 case DW_FORM_sec_offset:
20164 case DW_FORM_GNU_strp_alt:
20165 bytes += offset_size;
20168 case DW_FORM_block:
20169 bytes += read_unsigned_leb128 (abfd, bytes, &bytes_read);
20170 bytes += bytes_read;
20173 case DW_FORM_block1:
20174 bytes += 1 + read_1_byte (abfd, bytes);
20176 case DW_FORM_block2:
20177 bytes += 2 + read_2_bytes (abfd, bytes);
20179 case DW_FORM_block4:
20180 bytes += 4 + read_4_bytes (abfd, bytes);
20183 case DW_FORM_sdata:
20184 case DW_FORM_udata:
20185 case DW_FORM_GNU_addr_index:
20186 case DW_FORM_GNU_str_index:
20187 bytes = gdb_skip_leb128 (bytes, buffer_end);
20190 dwarf2_section_buffer_overflow_complaint (section);
20198 complaint (&symfile_complaints,
20199 _("invalid form 0x%x in `%s'"),
20200 form, get_section_name (section));
20208 /* A helper for dwarf_decode_macros that handles skipping an unknown
20209 opcode. Returns an updated pointer to the macro data buffer; or,
20210 on error, issues a complaint and returns NULL. */
20212 static const gdb_byte *
20213 skip_unknown_opcode (unsigned int opcode,
20214 const gdb_byte **opcode_definitions,
20215 const gdb_byte *mac_ptr, const gdb_byte *mac_end,
20217 unsigned int offset_size,
20218 struct dwarf2_section_info *section)
20220 unsigned int bytes_read, i;
20222 const gdb_byte *defn;
20224 if (opcode_definitions[opcode] == NULL)
20226 complaint (&symfile_complaints,
20227 _("unrecognized DW_MACFINO opcode 0x%x"),
20232 defn = opcode_definitions[opcode];
20233 arg = read_unsigned_leb128 (abfd, defn, &bytes_read);
20234 defn += bytes_read;
20236 for (i = 0; i < arg; ++i)
20238 mac_ptr = skip_form_bytes (abfd, mac_ptr, mac_end, defn[i], offset_size,
20240 if (mac_ptr == NULL)
20242 /* skip_form_bytes already issued the complaint. */
20250 /* A helper function which parses the header of a macro section.
20251 If the macro section is the extended (for now called "GNU") type,
20252 then this updates *OFFSET_SIZE. Returns a pointer to just after
20253 the header, or issues a complaint and returns NULL on error. */
20255 static const gdb_byte *
20256 dwarf_parse_macro_header (const gdb_byte **opcode_definitions,
20258 const gdb_byte *mac_ptr,
20259 unsigned int *offset_size,
20260 int section_is_gnu)
20262 memset (opcode_definitions, 0, 256 * sizeof (gdb_byte *));
20264 if (section_is_gnu)
20266 unsigned int version, flags;
20268 version = read_2_bytes (abfd, mac_ptr);
20271 complaint (&symfile_complaints,
20272 _("unrecognized version `%d' in .debug_macro section"),
20278 flags = read_1_byte (abfd, mac_ptr);
20280 *offset_size = (flags & 1) ? 8 : 4;
20282 if ((flags & 2) != 0)
20283 /* We don't need the line table offset. */
20284 mac_ptr += *offset_size;
20286 /* Vendor opcode descriptions. */
20287 if ((flags & 4) != 0)
20289 unsigned int i, count;
20291 count = read_1_byte (abfd, mac_ptr);
20293 for (i = 0; i < count; ++i)
20295 unsigned int opcode, bytes_read;
20298 opcode = read_1_byte (abfd, mac_ptr);
20300 opcode_definitions[opcode] = mac_ptr;
20301 arg = read_unsigned_leb128 (abfd, mac_ptr, &bytes_read);
20302 mac_ptr += bytes_read;
20311 /* A helper for dwarf_decode_macros that handles the GNU extensions,
20312 including DW_MACRO_GNU_transparent_include. */
20315 dwarf_decode_macro_bytes (bfd *abfd,
20316 const gdb_byte *mac_ptr, const gdb_byte *mac_end,
20317 struct macro_source_file *current_file,
20318 struct line_header *lh, const char *comp_dir,
20319 struct dwarf2_section_info *section,
20320 int section_is_gnu, int section_is_dwz,
20321 unsigned int offset_size,
20322 struct objfile *objfile,
20323 htab_t include_hash)
20325 enum dwarf_macro_record_type macinfo_type;
20326 int at_commandline;
20327 const gdb_byte *opcode_definitions[256];
20329 mac_ptr = dwarf_parse_macro_header (opcode_definitions, abfd, mac_ptr,
20330 &offset_size, section_is_gnu);
20331 if (mac_ptr == NULL)
20333 /* We already issued a complaint. */
20337 /* Determines if GDB is still before first DW_MACINFO_start_file. If true
20338 GDB is still reading the definitions from command line. First
20339 DW_MACINFO_start_file will need to be ignored as it was already executed
20340 to create CURRENT_FILE for the main source holding also the command line
20341 definitions. On first met DW_MACINFO_start_file this flag is reset to
20342 normally execute all the remaining DW_MACINFO_start_file macinfos. */
20344 at_commandline = 1;
20348 /* Do we at least have room for a macinfo type byte? */
20349 if (mac_ptr >= mac_end)
20351 dwarf2_section_buffer_overflow_complaint (section);
20355 macinfo_type = read_1_byte (abfd, mac_ptr);
20358 /* Note that we rely on the fact that the corresponding GNU and
20359 DWARF constants are the same. */
20360 switch (macinfo_type)
20362 /* A zero macinfo type indicates the end of the macro
20367 case DW_MACRO_GNU_define:
20368 case DW_MACRO_GNU_undef:
20369 case DW_MACRO_GNU_define_indirect:
20370 case DW_MACRO_GNU_undef_indirect:
20371 case DW_MACRO_GNU_define_indirect_alt:
20372 case DW_MACRO_GNU_undef_indirect_alt:
20374 unsigned int bytes_read;
20379 line = read_unsigned_leb128 (abfd, mac_ptr, &bytes_read);
20380 mac_ptr += bytes_read;
20382 if (macinfo_type == DW_MACRO_GNU_define
20383 || macinfo_type == DW_MACRO_GNU_undef)
20385 body = read_direct_string (abfd, mac_ptr, &bytes_read);
20386 mac_ptr += bytes_read;
20390 LONGEST str_offset;
20392 str_offset = read_offset_1 (abfd, mac_ptr, offset_size);
20393 mac_ptr += offset_size;
20395 if (macinfo_type == DW_MACRO_GNU_define_indirect_alt
20396 || macinfo_type == DW_MACRO_GNU_undef_indirect_alt
20399 struct dwz_file *dwz = dwarf2_get_dwz_file ();
20401 body = read_indirect_string_from_dwz (dwz, str_offset);
20404 body = read_indirect_string_at_offset (abfd, str_offset);
20407 is_define = (macinfo_type == DW_MACRO_GNU_define
20408 || macinfo_type == DW_MACRO_GNU_define_indirect
20409 || macinfo_type == DW_MACRO_GNU_define_indirect_alt);
20410 if (! current_file)
20412 /* DWARF violation as no main source is present. */
20413 complaint (&symfile_complaints,
20414 _("debug info with no main source gives macro %s "
20416 is_define ? _("definition") : _("undefinition"),
20420 if ((line == 0 && !at_commandline)
20421 || (line != 0 && at_commandline))
20422 complaint (&symfile_complaints,
20423 _("debug info gives %s macro %s with %s line %d: %s"),
20424 at_commandline ? _("command-line") : _("in-file"),
20425 is_define ? _("definition") : _("undefinition"),
20426 line == 0 ? _("zero") : _("non-zero"), line, body);
20429 parse_macro_definition (current_file, line, body);
20432 gdb_assert (macinfo_type == DW_MACRO_GNU_undef
20433 || macinfo_type == DW_MACRO_GNU_undef_indirect
20434 || macinfo_type == DW_MACRO_GNU_undef_indirect_alt);
20435 macro_undef (current_file, line, body);
20440 case DW_MACRO_GNU_start_file:
20442 unsigned int bytes_read;
20445 line = read_unsigned_leb128 (abfd, mac_ptr, &bytes_read);
20446 mac_ptr += bytes_read;
20447 file = read_unsigned_leb128 (abfd, mac_ptr, &bytes_read);
20448 mac_ptr += bytes_read;
20450 if ((line == 0 && !at_commandline)
20451 || (line != 0 && at_commandline))
20452 complaint (&symfile_complaints,
20453 _("debug info gives source %d included "
20454 "from %s at %s line %d"),
20455 file, at_commandline ? _("command-line") : _("file"),
20456 line == 0 ? _("zero") : _("non-zero"), line);
20458 if (at_commandline)
20460 /* This DW_MACRO_GNU_start_file was executed in the
20462 at_commandline = 0;
20465 current_file = macro_start_file (file, line,
20466 current_file, comp_dir,
20471 case DW_MACRO_GNU_end_file:
20472 if (! current_file)
20473 complaint (&symfile_complaints,
20474 _("macro debug info has an unmatched "
20475 "`close_file' directive"));
20478 current_file = current_file->included_by;
20479 if (! current_file)
20481 enum dwarf_macro_record_type next_type;
20483 /* GCC circa March 2002 doesn't produce the zero
20484 type byte marking the end of the compilation
20485 unit. Complain if it's not there, but exit no
20488 /* Do we at least have room for a macinfo type byte? */
20489 if (mac_ptr >= mac_end)
20491 dwarf2_section_buffer_overflow_complaint (section);
20495 /* We don't increment mac_ptr here, so this is just
20497 next_type = read_1_byte (abfd, mac_ptr);
20498 if (next_type != 0)
20499 complaint (&symfile_complaints,
20500 _("no terminating 0-type entry for "
20501 "macros in `.debug_macinfo' section"));
20508 case DW_MACRO_GNU_transparent_include:
20509 case DW_MACRO_GNU_transparent_include_alt:
20513 bfd *include_bfd = abfd;
20514 struct dwarf2_section_info *include_section = section;
20515 struct dwarf2_section_info alt_section;
20516 const gdb_byte *include_mac_end = mac_end;
20517 int is_dwz = section_is_dwz;
20518 const gdb_byte *new_mac_ptr;
20520 offset = read_offset_1 (abfd, mac_ptr, offset_size);
20521 mac_ptr += offset_size;
20523 if (macinfo_type == DW_MACRO_GNU_transparent_include_alt)
20525 struct dwz_file *dwz = dwarf2_get_dwz_file ();
20527 dwarf2_read_section (dwarf2_per_objfile->objfile,
20530 include_section = &dwz->macro;
20531 include_bfd = get_section_bfd_owner (include_section);
20532 include_mac_end = dwz->macro.buffer + dwz->macro.size;
20536 new_mac_ptr = include_section->buffer + offset;
20537 slot = htab_find_slot (include_hash, new_mac_ptr, INSERT);
20541 /* This has actually happened; see
20542 http://sourceware.org/bugzilla/show_bug.cgi?id=13568. */
20543 complaint (&symfile_complaints,
20544 _("recursive DW_MACRO_GNU_transparent_include in "
20545 ".debug_macro section"));
20549 *slot = (void *) new_mac_ptr;
20551 dwarf_decode_macro_bytes (include_bfd, new_mac_ptr,
20552 include_mac_end, current_file,
20554 section, section_is_gnu, is_dwz,
20555 offset_size, objfile, include_hash);
20557 htab_remove_elt (include_hash, (void *) new_mac_ptr);
20562 case DW_MACINFO_vendor_ext:
20563 if (!section_is_gnu)
20565 unsigned int bytes_read;
20568 constant = read_unsigned_leb128 (abfd, mac_ptr, &bytes_read);
20569 mac_ptr += bytes_read;
20570 read_direct_string (abfd, mac_ptr, &bytes_read);
20571 mac_ptr += bytes_read;
20573 /* We don't recognize any vendor extensions. */
20579 mac_ptr = skip_unknown_opcode (macinfo_type, opcode_definitions,
20580 mac_ptr, mac_end, abfd, offset_size,
20582 if (mac_ptr == NULL)
20586 } while (macinfo_type != 0);
20590 dwarf_decode_macros (struct dwarf2_cu *cu, unsigned int offset,
20591 const char *comp_dir, int section_is_gnu)
20593 struct objfile *objfile = dwarf2_per_objfile->objfile;
20594 struct line_header *lh = cu->line_header;
20596 const gdb_byte *mac_ptr, *mac_end;
20597 struct macro_source_file *current_file = 0;
20598 enum dwarf_macro_record_type macinfo_type;
20599 unsigned int offset_size = cu->header.offset_size;
20600 const gdb_byte *opcode_definitions[256];
20601 struct cleanup *cleanup;
20602 htab_t include_hash;
20604 struct dwarf2_section_info *section;
20605 const char *section_name;
20607 if (cu->dwo_unit != NULL)
20609 if (section_is_gnu)
20611 section = &cu->dwo_unit->dwo_file->sections.macro;
20612 section_name = ".debug_macro.dwo";
20616 section = &cu->dwo_unit->dwo_file->sections.macinfo;
20617 section_name = ".debug_macinfo.dwo";
20622 if (section_is_gnu)
20624 section = &dwarf2_per_objfile->macro;
20625 section_name = ".debug_macro";
20629 section = &dwarf2_per_objfile->macinfo;
20630 section_name = ".debug_macinfo";
20634 dwarf2_read_section (objfile, section);
20635 if (section->buffer == NULL)
20637 complaint (&symfile_complaints, _("missing %s section"), section_name);
20640 abfd = get_section_bfd_owner (section);
20642 /* First pass: Find the name of the base filename.
20643 This filename is needed in order to process all macros whose definition
20644 (or undefinition) comes from the command line. These macros are defined
20645 before the first DW_MACINFO_start_file entry, and yet still need to be
20646 associated to the base file.
20648 To determine the base file name, we scan the macro definitions until we
20649 reach the first DW_MACINFO_start_file entry. We then initialize
20650 CURRENT_FILE accordingly so that any macro definition found before the
20651 first DW_MACINFO_start_file can still be associated to the base file. */
20653 mac_ptr = section->buffer + offset;
20654 mac_end = section->buffer + section->size;
20656 mac_ptr = dwarf_parse_macro_header (opcode_definitions, abfd, mac_ptr,
20657 &offset_size, section_is_gnu);
20658 if (mac_ptr == NULL)
20660 /* We already issued a complaint. */
20666 /* Do we at least have room for a macinfo type byte? */
20667 if (mac_ptr >= mac_end)
20669 /* Complaint is printed during the second pass as GDB will probably
20670 stop the first pass earlier upon finding
20671 DW_MACINFO_start_file. */
20675 macinfo_type = read_1_byte (abfd, mac_ptr);
20678 /* Note that we rely on the fact that the corresponding GNU and
20679 DWARF constants are the same. */
20680 switch (macinfo_type)
20682 /* A zero macinfo type indicates the end of the macro
20687 case DW_MACRO_GNU_define:
20688 case DW_MACRO_GNU_undef:
20689 /* Only skip the data by MAC_PTR. */
20691 unsigned int bytes_read;
20693 read_unsigned_leb128 (abfd, mac_ptr, &bytes_read);
20694 mac_ptr += bytes_read;
20695 read_direct_string (abfd, mac_ptr, &bytes_read);
20696 mac_ptr += bytes_read;
20700 case DW_MACRO_GNU_start_file:
20702 unsigned int bytes_read;
20705 line = read_unsigned_leb128 (abfd, mac_ptr, &bytes_read);
20706 mac_ptr += bytes_read;
20707 file = read_unsigned_leb128 (abfd, mac_ptr, &bytes_read);
20708 mac_ptr += bytes_read;
20710 current_file = macro_start_file (file, line, current_file,
20711 comp_dir, lh, objfile);
20715 case DW_MACRO_GNU_end_file:
20716 /* No data to skip by MAC_PTR. */
20719 case DW_MACRO_GNU_define_indirect:
20720 case DW_MACRO_GNU_undef_indirect:
20721 case DW_MACRO_GNU_define_indirect_alt:
20722 case DW_MACRO_GNU_undef_indirect_alt:
20724 unsigned int bytes_read;
20726 read_unsigned_leb128 (abfd, mac_ptr, &bytes_read);
20727 mac_ptr += bytes_read;
20728 mac_ptr += offset_size;
20732 case DW_MACRO_GNU_transparent_include:
20733 case DW_MACRO_GNU_transparent_include_alt:
20734 /* Note that, according to the spec, a transparent include
20735 chain cannot call DW_MACRO_GNU_start_file. So, we can just
20736 skip this opcode. */
20737 mac_ptr += offset_size;
20740 case DW_MACINFO_vendor_ext:
20741 /* Only skip the data by MAC_PTR. */
20742 if (!section_is_gnu)
20744 unsigned int bytes_read;
20746 read_unsigned_leb128 (abfd, mac_ptr, &bytes_read);
20747 mac_ptr += bytes_read;
20748 read_direct_string (abfd, mac_ptr, &bytes_read);
20749 mac_ptr += bytes_read;
20754 mac_ptr = skip_unknown_opcode (macinfo_type, opcode_definitions,
20755 mac_ptr, mac_end, abfd, offset_size,
20757 if (mac_ptr == NULL)
20761 } while (macinfo_type != 0 && current_file == NULL);
20763 /* Second pass: Process all entries.
20765 Use the AT_COMMAND_LINE flag to determine whether we are still processing
20766 command-line macro definitions/undefinitions. This flag is unset when we
20767 reach the first DW_MACINFO_start_file entry. */
20769 include_hash = htab_create_alloc (1, htab_hash_pointer, htab_eq_pointer,
20770 NULL, xcalloc, xfree);
20771 cleanup = make_cleanup_htab_delete (include_hash);
20772 mac_ptr = section->buffer + offset;
20773 slot = htab_find_slot (include_hash, mac_ptr, INSERT);
20774 *slot = (void *) mac_ptr;
20775 dwarf_decode_macro_bytes (abfd, mac_ptr, mac_end,
20776 current_file, lh, comp_dir, section,
20778 offset_size, objfile, include_hash);
20779 do_cleanups (cleanup);
20782 /* Check if the attribute's form is a DW_FORM_block*
20783 if so return true else false. */
20786 attr_form_is_block (const struct attribute *attr)
20788 return (attr == NULL ? 0 :
20789 attr->form == DW_FORM_block1
20790 || attr->form == DW_FORM_block2
20791 || attr->form == DW_FORM_block4
20792 || attr->form == DW_FORM_block
20793 || attr->form == DW_FORM_exprloc);
20796 /* Return non-zero if ATTR's value is a section offset --- classes
20797 lineptr, loclistptr, macptr or rangelistptr --- or zero, otherwise.
20798 You may use DW_UNSND (attr) to retrieve such offsets.
20800 Section 7.5.4, "Attribute Encodings", explains that no attribute
20801 may have a value that belongs to more than one of these classes; it
20802 would be ambiguous if we did, because we use the same forms for all
20806 attr_form_is_section_offset (const struct attribute *attr)
20808 return (attr->form == DW_FORM_data4
20809 || attr->form == DW_FORM_data8
20810 || attr->form == DW_FORM_sec_offset);
20813 /* Return non-zero if ATTR's value falls in the 'constant' class, or
20814 zero otherwise. When this function returns true, you can apply
20815 dwarf2_get_attr_constant_value to it.
20817 However, note that for some attributes you must check
20818 attr_form_is_section_offset before using this test. DW_FORM_data4
20819 and DW_FORM_data8 are members of both the constant class, and of
20820 the classes that contain offsets into other debug sections
20821 (lineptr, loclistptr, macptr or rangelistptr). The DWARF spec says
20822 that, if an attribute's can be either a constant or one of the
20823 section offset classes, DW_FORM_data4 and DW_FORM_data8 should be
20824 taken as section offsets, not constants. */
20827 attr_form_is_constant (const struct attribute *attr)
20829 switch (attr->form)
20831 case DW_FORM_sdata:
20832 case DW_FORM_udata:
20833 case DW_FORM_data1:
20834 case DW_FORM_data2:
20835 case DW_FORM_data4:
20836 case DW_FORM_data8:
20844 /* DW_ADDR is always stored already as sect_offset; despite for the forms
20845 besides DW_FORM_ref_addr it is stored as cu_offset in the DWARF file. */
20848 attr_form_is_ref (const struct attribute *attr)
20850 switch (attr->form)
20852 case DW_FORM_ref_addr:
20857 case DW_FORM_ref_udata:
20858 case DW_FORM_GNU_ref_alt:
20865 /* Return the .debug_loc section to use for CU.
20866 For DWO files use .debug_loc.dwo. */
20868 static struct dwarf2_section_info *
20869 cu_debug_loc_section (struct dwarf2_cu *cu)
20872 return &cu->dwo_unit->dwo_file->sections.loc;
20873 return &dwarf2_per_objfile->loc;
20876 /* A helper function that fills in a dwarf2_loclist_baton. */
20879 fill_in_loclist_baton (struct dwarf2_cu *cu,
20880 struct dwarf2_loclist_baton *baton,
20881 const struct attribute *attr)
20883 struct dwarf2_section_info *section = cu_debug_loc_section (cu);
20885 dwarf2_read_section (dwarf2_per_objfile->objfile, section);
20887 baton->per_cu = cu->per_cu;
20888 gdb_assert (baton->per_cu);
20889 /* We don't know how long the location list is, but make sure we
20890 don't run off the edge of the section. */
20891 baton->size = section->size - DW_UNSND (attr);
20892 baton->data = section->buffer + DW_UNSND (attr);
20893 baton->base_address = cu->base_address;
20894 baton->from_dwo = cu->dwo_unit != NULL;
20898 dwarf2_symbol_mark_computed (const struct attribute *attr, struct symbol *sym,
20899 struct dwarf2_cu *cu, int is_block)
20901 struct objfile *objfile = dwarf2_per_objfile->objfile;
20902 struct dwarf2_section_info *section = cu_debug_loc_section (cu);
20904 if (attr_form_is_section_offset (attr)
20905 /* .debug_loc{,.dwo} may not exist at all, or the offset may be outside
20906 the section. If so, fall through to the complaint in the
20908 && DW_UNSND (attr) < dwarf2_section_size (objfile, section))
20910 struct dwarf2_loclist_baton *baton;
20912 baton = obstack_alloc (&objfile->objfile_obstack,
20913 sizeof (struct dwarf2_loclist_baton));
20915 fill_in_loclist_baton (cu, baton, attr);
20917 if (cu->base_known == 0)
20918 complaint (&symfile_complaints,
20919 _("Location list used without "
20920 "specifying the CU base address."));
20922 SYMBOL_ACLASS_INDEX (sym) = (is_block
20923 ? dwarf2_loclist_block_index
20924 : dwarf2_loclist_index);
20925 SYMBOL_LOCATION_BATON (sym) = baton;
20929 struct dwarf2_locexpr_baton *baton;
20931 baton = obstack_alloc (&objfile->objfile_obstack,
20932 sizeof (struct dwarf2_locexpr_baton));
20933 baton->per_cu = cu->per_cu;
20934 gdb_assert (baton->per_cu);
20936 if (attr_form_is_block (attr))
20938 /* Note that we're just copying the block's data pointer
20939 here, not the actual data. We're still pointing into the
20940 info_buffer for SYM's objfile; right now we never release
20941 that buffer, but when we do clean up properly this may
20943 baton->size = DW_BLOCK (attr)->size;
20944 baton->data = DW_BLOCK (attr)->data;
20948 dwarf2_invalid_attrib_class_complaint ("location description",
20949 SYMBOL_NATURAL_NAME (sym));
20953 SYMBOL_ACLASS_INDEX (sym) = (is_block
20954 ? dwarf2_locexpr_block_index
20955 : dwarf2_locexpr_index);
20956 SYMBOL_LOCATION_BATON (sym) = baton;
20960 /* Return the OBJFILE associated with the compilation unit CU. If CU
20961 came from a separate debuginfo file, then the master objfile is
20965 dwarf2_per_cu_objfile (struct dwarf2_per_cu_data *per_cu)
20967 struct objfile *objfile = per_cu->objfile;
20969 /* Return the master objfile, so that we can report and look up the
20970 correct file containing this variable. */
20971 if (objfile->separate_debug_objfile_backlink)
20972 objfile = objfile->separate_debug_objfile_backlink;
20977 /* Return comp_unit_head for PER_CU, either already available in PER_CU->CU
20978 (CU_HEADERP is unused in such case) or prepare a temporary copy at
20979 CU_HEADERP first. */
20981 static const struct comp_unit_head *
20982 per_cu_header_read_in (struct comp_unit_head *cu_headerp,
20983 struct dwarf2_per_cu_data *per_cu)
20985 const gdb_byte *info_ptr;
20988 return &per_cu->cu->header;
20990 info_ptr = per_cu->section->buffer + per_cu->offset.sect_off;
20992 memset (cu_headerp, 0, sizeof (*cu_headerp));
20993 read_comp_unit_head (cu_headerp, info_ptr, per_cu->objfile->obfd);
20998 /* Return the address size given in the compilation unit header for CU. */
21001 dwarf2_per_cu_addr_size (struct dwarf2_per_cu_data *per_cu)
21003 struct comp_unit_head cu_header_local;
21004 const struct comp_unit_head *cu_headerp;
21006 cu_headerp = per_cu_header_read_in (&cu_header_local, per_cu);
21008 return cu_headerp->addr_size;
21011 /* Return the offset size given in the compilation unit header for CU. */
21014 dwarf2_per_cu_offset_size (struct dwarf2_per_cu_data *per_cu)
21016 struct comp_unit_head cu_header_local;
21017 const struct comp_unit_head *cu_headerp;
21019 cu_headerp = per_cu_header_read_in (&cu_header_local, per_cu);
21021 return cu_headerp->offset_size;
21024 /* See its dwarf2loc.h declaration. */
21027 dwarf2_per_cu_ref_addr_size (struct dwarf2_per_cu_data *per_cu)
21029 struct comp_unit_head cu_header_local;
21030 const struct comp_unit_head *cu_headerp;
21032 cu_headerp = per_cu_header_read_in (&cu_header_local, per_cu);
21034 if (cu_headerp->version == 2)
21035 return cu_headerp->addr_size;
21037 return cu_headerp->offset_size;
21040 /* Return the text offset of the CU. The returned offset comes from
21041 this CU's objfile. If this objfile came from a separate debuginfo
21042 file, then the offset may be different from the corresponding
21043 offset in the parent objfile. */
21046 dwarf2_per_cu_text_offset (struct dwarf2_per_cu_data *per_cu)
21048 struct objfile *objfile = per_cu->objfile;
21050 return ANOFFSET (objfile->section_offsets, SECT_OFF_TEXT (objfile));
21053 /* Locate the .debug_info compilation unit from CU's objfile which contains
21054 the DIE at OFFSET. Raises an error on failure. */
21056 static struct dwarf2_per_cu_data *
21057 dwarf2_find_containing_comp_unit (sect_offset offset,
21058 unsigned int offset_in_dwz,
21059 struct objfile *objfile)
21061 struct dwarf2_per_cu_data *this_cu;
21063 const sect_offset *cu_off;
21066 high = dwarf2_per_objfile->n_comp_units - 1;
21069 struct dwarf2_per_cu_data *mid_cu;
21070 int mid = low + (high - low) / 2;
21072 mid_cu = dwarf2_per_objfile->all_comp_units[mid];
21073 cu_off = &mid_cu->offset;
21074 if (mid_cu->is_dwz > offset_in_dwz
21075 || (mid_cu->is_dwz == offset_in_dwz
21076 && cu_off->sect_off >= offset.sect_off))
21081 gdb_assert (low == high);
21082 this_cu = dwarf2_per_objfile->all_comp_units[low];
21083 cu_off = &this_cu->offset;
21084 if (this_cu->is_dwz != offset_in_dwz || cu_off->sect_off > offset.sect_off)
21086 if (low == 0 || this_cu->is_dwz != offset_in_dwz)
21087 error (_("Dwarf Error: could not find partial DIE containing "
21088 "offset 0x%lx [in module %s]"),
21089 (long) offset.sect_off, bfd_get_filename (objfile->obfd));
21091 gdb_assert (dwarf2_per_objfile->all_comp_units[low-1]->offset.sect_off
21092 <= offset.sect_off);
21093 return dwarf2_per_objfile->all_comp_units[low-1];
21097 this_cu = dwarf2_per_objfile->all_comp_units[low];
21098 if (low == dwarf2_per_objfile->n_comp_units - 1
21099 && offset.sect_off >= this_cu->offset.sect_off + this_cu->length)
21100 error (_("invalid dwarf2 offset %u"), offset.sect_off);
21101 gdb_assert (offset.sect_off < this_cu->offset.sect_off + this_cu->length);
21106 /* Initialize dwarf2_cu CU, owned by PER_CU. */
21109 init_one_comp_unit (struct dwarf2_cu *cu, struct dwarf2_per_cu_data *per_cu)
21111 memset (cu, 0, sizeof (*cu));
21113 cu->per_cu = per_cu;
21114 cu->objfile = per_cu->objfile;
21115 obstack_init (&cu->comp_unit_obstack);
21118 /* Initialize basic fields of dwarf_cu CU according to DIE COMP_UNIT_DIE. */
21121 prepare_one_comp_unit (struct dwarf2_cu *cu, struct die_info *comp_unit_die,
21122 enum language pretend_language)
21124 struct attribute *attr;
21126 /* Set the language we're debugging. */
21127 attr = dwarf2_attr (comp_unit_die, DW_AT_language, cu);
21129 set_cu_language (DW_UNSND (attr), cu);
21132 cu->language = pretend_language;
21133 cu->language_defn = language_def (cu->language);
21136 attr = dwarf2_attr (comp_unit_die, DW_AT_producer, cu);
21138 cu->producer = DW_STRING (attr);
21141 /* Release one cached compilation unit, CU. We unlink it from the tree
21142 of compilation units, but we don't remove it from the read_in_chain;
21143 the caller is responsible for that.
21144 NOTE: DATA is a void * because this function is also used as a
21145 cleanup routine. */
21148 free_heap_comp_unit (void *data)
21150 struct dwarf2_cu *cu = data;
21152 gdb_assert (cu->per_cu != NULL);
21153 cu->per_cu->cu = NULL;
21156 obstack_free (&cu->comp_unit_obstack, NULL);
21161 /* This cleanup function is passed the address of a dwarf2_cu on the stack
21162 when we're finished with it. We can't free the pointer itself, but be
21163 sure to unlink it from the cache. Also release any associated storage. */
21166 free_stack_comp_unit (void *data)
21168 struct dwarf2_cu *cu = data;
21170 gdb_assert (cu->per_cu != NULL);
21171 cu->per_cu->cu = NULL;
21174 obstack_free (&cu->comp_unit_obstack, NULL);
21175 cu->partial_dies = NULL;
21178 /* Free all cached compilation units. */
21181 free_cached_comp_units (void *data)
21183 struct dwarf2_per_cu_data *per_cu, **last_chain;
21185 per_cu = dwarf2_per_objfile->read_in_chain;
21186 last_chain = &dwarf2_per_objfile->read_in_chain;
21187 while (per_cu != NULL)
21189 struct dwarf2_per_cu_data *next_cu;
21191 next_cu = per_cu->cu->read_in_chain;
21193 free_heap_comp_unit (per_cu->cu);
21194 *last_chain = next_cu;
21200 /* Increase the age counter on each cached compilation unit, and free
21201 any that are too old. */
21204 age_cached_comp_units (void)
21206 struct dwarf2_per_cu_data *per_cu, **last_chain;
21208 dwarf2_clear_marks (dwarf2_per_objfile->read_in_chain);
21209 per_cu = dwarf2_per_objfile->read_in_chain;
21210 while (per_cu != NULL)
21212 per_cu->cu->last_used ++;
21213 if (per_cu->cu->last_used <= dwarf2_max_cache_age)
21214 dwarf2_mark (per_cu->cu);
21215 per_cu = per_cu->cu->read_in_chain;
21218 per_cu = dwarf2_per_objfile->read_in_chain;
21219 last_chain = &dwarf2_per_objfile->read_in_chain;
21220 while (per_cu != NULL)
21222 struct dwarf2_per_cu_data *next_cu;
21224 next_cu = per_cu->cu->read_in_chain;
21226 if (!per_cu->cu->mark)
21228 free_heap_comp_unit (per_cu->cu);
21229 *last_chain = next_cu;
21232 last_chain = &per_cu->cu->read_in_chain;
21238 /* Remove a single compilation unit from the cache. */
21241 free_one_cached_comp_unit (struct dwarf2_per_cu_data *target_per_cu)
21243 struct dwarf2_per_cu_data *per_cu, **last_chain;
21245 per_cu = dwarf2_per_objfile->read_in_chain;
21246 last_chain = &dwarf2_per_objfile->read_in_chain;
21247 while (per_cu != NULL)
21249 struct dwarf2_per_cu_data *next_cu;
21251 next_cu = per_cu->cu->read_in_chain;
21253 if (per_cu == target_per_cu)
21255 free_heap_comp_unit (per_cu->cu);
21257 *last_chain = next_cu;
21261 last_chain = &per_cu->cu->read_in_chain;
21267 /* Release all extra memory associated with OBJFILE. */
21270 dwarf2_free_objfile (struct objfile *objfile)
21272 dwarf2_per_objfile = objfile_data (objfile, dwarf2_objfile_data_key);
21274 if (dwarf2_per_objfile == NULL)
21277 /* Cached DIE trees use xmalloc and the comp_unit_obstack. */
21278 free_cached_comp_units (NULL);
21280 if (dwarf2_per_objfile->quick_file_names_table)
21281 htab_delete (dwarf2_per_objfile->quick_file_names_table);
21283 /* Everything else should be on the objfile obstack. */
21286 /* A set of CU "per_cu" pointer, DIE offset, and GDB type pointer.
21287 We store these in a hash table separate from the DIEs, and preserve them
21288 when the DIEs are flushed out of cache.
21290 The CU "per_cu" pointer is needed because offset alone is not enough to
21291 uniquely identify the type. A file may have multiple .debug_types sections,
21292 or the type may come from a DWO file. Furthermore, while it's more logical
21293 to use per_cu->section+offset, with Fission the section with the data is in
21294 the DWO file but we don't know that section at the point we need it.
21295 We have to use something in dwarf2_per_cu_data (or the pointer to it)
21296 because we can enter the lookup routine, get_die_type_at_offset, from
21297 outside this file, and thus won't necessarily have PER_CU->cu.
21298 Fortunately, PER_CU is stable for the life of the objfile. */
21300 struct dwarf2_per_cu_offset_and_type
21302 const struct dwarf2_per_cu_data *per_cu;
21303 sect_offset offset;
21307 /* Hash function for a dwarf2_per_cu_offset_and_type. */
21310 per_cu_offset_and_type_hash (const void *item)
21312 const struct dwarf2_per_cu_offset_and_type *ofs = item;
21314 return (uintptr_t) ofs->per_cu + ofs->offset.sect_off;
21317 /* Equality function for a dwarf2_per_cu_offset_and_type. */
21320 per_cu_offset_and_type_eq (const void *item_lhs, const void *item_rhs)
21322 const struct dwarf2_per_cu_offset_and_type *ofs_lhs = item_lhs;
21323 const struct dwarf2_per_cu_offset_and_type *ofs_rhs = item_rhs;
21325 return (ofs_lhs->per_cu == ofs_rhs->per_cu
21326 && ofs_lhs->offset.sect_off == ofs_rhs->offset.sect_off);
21329 /* Set the type associated with DIE to TYPE. Save it in CU's hash
21330 table if necessary. For convenience, return TYPE.
21332 The DIEs reading must have careful ordering to:
21333 * Not cause infite loops trying to read in DIEs as a prerequisite for
21334 reading current DIE.
21335 * Not trying to dereference contents of still incompletely read in types
21336 while reading in other DIEs.
21337 * Enable referencing still incompletely read in types just by a pointer to
21338 the type without accessing its fields.
21340 Therefore caller should follow these rules:
21341 * Try to fetch any prerequisite types we may need to build this DIE type
21342 before building the type and calling set_die_type.
21343 * After building type call set_die_type for current DIE as soon as
21344 possible before fetching more types to complete the current type.
21345 * Make the type as complete as possible before fetching more types. */
21347 static struct type *
21348 set_die_type (struct die_info *die, struct type *type, struct dwarf2_cu *cu)
21350 struct dwarf2_per_cu_offset_and_type **slot, ofs;
21351 struct objfile *objfile = cu->objfile;
21353 /* For Ada types, make sure that the gnat-specific data is always
21354 initialized (if not already set). There are a few types where
21355 we should not be doing so, because the type-specific area is
21356 already used to hold some other piece of info (eg: TYPE_CODE_FLT
21357 where the type-specific area is used to store the floatformat).
21358 But this is not a problem, because the gnat-specific information
21359 is actually not needed for these types. */
21360 if (need_gnat_info (cu)
21361 && TYPE_CODE (type) != TYPE_CODE_FUNC
21362 && TYPE_CODE (type) != TYPE_CODE_FLT
21363 && !HAVE_GNAT_AUX_INFO (type))
21364 INIT_GNAT_SPECIFIC (type);
21366 if (dwarf2_per_objfile->die_type_hash == NULL)
21368 dwarf2_per_objfile->die_type_hash =
21369 htab_create_alloc_ex (127,
21370 per_cu_offset_and_type_hash,
21371 per_cu_offset_and_type_eq,
21373 &objfile->objfile_obstack,
21374 hashtab_obstack_allocate,
21375 dummy_obstack_deallocate);
21378 ofs.per_cu = cu->per_cu;
21379 ofs.offset = die->offset;
21381 slot = (struct dwarf2_per_cu_offset_and_type **)
21382 htab_find_slot (dwarf2_per_objfile->die_type_hash, &ofs, INSERT);
21384 complaint (&symfile_complaints,
21385 _("A problem internal to GDB: DIE 0x%x has type already set"),
21386 die->offset.sect_off);
21387 *slot = obstack_alloc (&objfile->objfile_obstack, sizeof (**slot));
21392 /* Look up the type for the die at OFFSET in PER_CU in die_type_hash,
21393 or return NULL if the die does not have a saved type. */
21395 static struct type *
21396 get_die_type_at_offset (sect_offset offset,
21397 struct dwarf2_per_cu_data *per_cu)
21399 struct dwarf2_per_cu_offset_and_type *slot, ofs;
21401 if (dwarf2_per_objfile->die_type_hash == NULL)
21404 ofs.per_cu = per_cu;
21405 ofs.offset = offset;
21406 slot = htab_find (dwarf2_per_objfile->die_type_hash, &ofs);
21413 /* Look up the type for DIE in CU in die_type_hash,
21414 or return NULL if DIE does not have a saved type. */
21416 static struct type *
21417 get_die_type (struct die_info *die, struct dwarf2_cu *cu)
21419 return get_die_type_at_offset (die->offset, cu->per_cu);
21422 /* Add a dependence relationship from CU to REF_PER_CU. */
21425 dwarf2_add_dependence (struct dwarf2_cu *cu,
21426 struct dwarf2_per_cu_data *ref_per_cu)
21430 if (cu->dependencies == NULL)
21432 = htab_create_alloc_ex (5, htab_hash_pointer, htab_eq_pointer,
21433 NULL, &cu->comp_unit_obstack,
21434 hashtab_obstack_allocate,
21435 dummy_obstack_deallocate);
21437 slot = htab_find_slot (cu->dependencies, ref_per_cu, INSERT);
21439 *slot = ref_per_cu;
21442 /* Subroutine of dwarf2_mark to pass to htab_traverse.
21443 Set the mark field in every compilation unit in the
21444 cache that we must keep because we are keeping CU. */
21447 dwarf2_mark_helper (void **slot, void *data)
21449 struct dwarf2_per_cu_data *per_cu;
21451 per_cu = (struct dwarf2_per_cu_data *) *slot;
21453 /* cu->dependencies references may not yet have been ever read if QUIT aborts
21454 reading of the chain. As such dependencies remain valid it is not much
21455 useful to track and undo them during QUIT cleanups. */
21456 if (per_cu->cu == NULL)
21459 if (per_cu->cu->mark)
21461 per_cu->cu->mark = 1;
21463 if (per_cu->cu->dependencies != NULL)
21464 htab_traverse (per_cu->cu->dependencies, dwarf2_mark_helper, NULL);
21469 /* Set the mark field in CU and in every other compilation unit in the
21470 cache that we must keep because we are keeping CU. */
21473 dwarf2_mark (struct dwarf2_cu *cu)
21478 if (cu->dependencies != NULL)
21479 htab_traverse (cu->dependencies, dwarf2_mark_helper, NULL);
21483 dwarf2_clear_marks (struct dwarf2_per_cu_data *per_cu)
21487 per_cu->cu->mark = 0;
21488 per_cu = per_cu->cu->read_in_chain;
21492 /* Trivial hash function for partial_die_info: the hash value of a DIE
21493 is its offset in .debug_info for this objfile. */
21496 partial_die_hash (const void *item)
21498 const struct partial_die_info *part_die = item;
21500 return part_die->offset.sect_off;
21503 /* Trivial comparison function for partial_die_info structures: two DIEs
21504 are equal if they have the same offset. */
21507 partial_die_eq (const void *item_lhs, const void *item_rhs)
21509 const struct partial_die_info *part_die_lhs = item_lhs;
21510 const struct partial_die_info *part_die_rhs = item_rhs;
21512 return part_die_lhs->offset.sect_off == part_die_rhs->offset.sect_off;
21515 static struct cmd_list_element *set_dwarf2_cmdlist;
21516 static struct cmd_list_element *show_dwarf2_cmdlist;
21519 set_dwarf2_cmd (char *args, int from_tty)
21521 help_list (set_dwarf2_cmdlist, "maintenance set dwarf2 ", -1, gdb_stdout);
21525 show_dwarf2_cmd (char *args, int from_tty)
21527 cmd_show_list (show_dwarf2_cmdlist, from_tty, "");
21530 /* Free data associated with OBJFILE, if necessary. */
21533 dwarf2_per_objfile_free (struct objfile *objfile, void *d)
21535 struct dwarf2_per_objfile *data = d;
21538 /* Make sure we don't accidentally use dwarf2_per_objfile while
21540 dwarf2_per_objfile = NULL;
21542 for (ix = 0; ix < data->n_comp_units; ++ix)
21543 VEC_free (dwarf2_per_cu_ptr, data->all_comp_units[ix]->imported_symtabs);
21545 for (ix = 0; ix < data->n_type_units; ++ix)
21546 VEC_free (dwarf2_per_cu_ptr,
21547 data->all_type_units[ix]->per_cu.imported_symtabs);
21548 xfree (data->all_type_units);
21550 VEC_free (dwarf2_section_info_def, data->types);
21552 if (data->dwo_files)
21553 free_dwo_files (data->dwo_files, objfile);
21554 if (data->dwp_file)
21555 gdb_bfd_unref (data->dwp_file->dbfd);
21557 if (data->dwz_file && data->dwz_file->dwz_bfd)
21558 gdb_bfd_unref (data->dwz_file->dwz_bfd);
21562 /* The "save gdb-index" command. */
21564 /* The contents of the hash table we create when building the string
21566 struct strtab_entry
21568 offset_type offset;
21572 /* Hash function for a strtab_entry.
21574 Function is used only during write_hash_table so no index format backward
21575 compatibility is needed. */
21578 hash_strtab_entry (const void *e)
21580 const struct strtab_entry *entry = e;
21581 return mapped_index_string_hash (INT_MAX, entry->str);
21584 /* Equality function for a strtab_entry. */
21587 eq_strtab_entry (const void *a, const void *b)
21589 const struct strtab_entry *ea = a;
21590 const struct strtab_entry *eb = b;
21591 return !strcmp (ea->str, eb->str);
21594 /* Create a strtab_entry hash table. */
21597 create_strtab (void)
21599 return htab_create_alloc (100, hash_strtab_entry, eq_strtab_entry,
21600 xfree, xcalloc, xfree);
21603 /* Add a string to the constant pool. Return the string's offset in
21607 add_string (htab_t table, struct obstack *cpool, const char *str)
21610 struct strtab_entry entry;
21611 struct strtab_entry *result;
21614 slot = htab_find_slot (table, &entry, INSERT);
21619 result = XNEW (struct strtab_entry);
21620 result->offset = obstack_object_size (cpool);
21622 obstack_grow_str0 (cpool, str);
21625 return result->offset;
21628 /* An entry in the symbol table. */
21629 struct symtab_index_entry
21631 /* The name of the symbol. */
21633 /* The offset of the name in the constant pool. */
21634 offset_type index_offset;
21635 /* A sorted vector of the indices of all the CUs that hold an object
21637 VEC (offset_type) *cu_indices;
21640 /* The symbol table. This is a power-of-2-sized hash table. */
21641 struct mapped_symtab
21643 offset_type n_elements;
21645 struct symtab_index_entry **data;
21648 /* Hash function for a symtab_index_entry. */
21651 hash_symtab_entry (const void *e)
21653 const struct symtab_index_entry *entry = e;
21654 return iterative_hash (VEC_address (offset_type, entry->cu_indices),
21655 sizeof (offset_type) * VEC_length (offset_type,
21656 entry->cu_indices),
21660 /* Equality function for a symtab_index_entry. */
21663 eq_symtab_entry (const void *a, const void *b)
21665 const struct symtab_index_entry *ea = a;
21666 const struct symtab_index_entry *eb = b;
21667 int len = VEC_length (offset_type, ea->cu_indices);
21668 if (len != VEC_length (offset_type, eb->cu_indices))
21670 return !memcmp (VEC_address (offset_type, ea->cu_indices),
21671 VEC_address (offset_type, eb->cu_indices),
21672 sizeof (offset_type) * len);
21675 /* Destroy a symtab_index_entry. */
21678 delete_symtab_entry (void *p)
21680 struct symtab_index_entry *entry = p;
21681 VEC_free (offset_type, entry->cu_indices);
21685 /* Create a hash table holding symtab_index_entry objects. */
21688 create_symbol_hash_table (void)
21690 return htab_create_alloc (100, hash_symtab_entry, eq_symtab_entry,
21691 delete_symtab_entry, xcalloc, xfree);
21694 /* Create a new mapped symtab object. */
21696 static struct mapped_symtab *
21697 create_mapped_symtab (void)
21699 struct mapped_symtab *symtab = XNEW (struct mapped_symtab);
21700 symtab->n_elements = 0;
21701 symtab->size = 1024;
21702 symtab->data = XCNEWVEC (struct symtab_index_entry *, symtab->size);
21706 /* Destroy a mapped_symtab. */
21709 cleanup_mapped_symtab (void *p)
21711 struct mapped_symtab *symtab = p;
21712 /* The contents of the array are freed when the other hash table is
21714 xfree (symtab->data);
21718 /* Find a slot in SYMTAB for the symbol NAME. Returns a pointer to
21721 Function is used only during write_hash_table so no index format backward
21722 compatibility is needed. */
21724 static struct symtab_index_entry **
21725 find_slot (struct mapped_symtab *symtab, const char *name)
21727 offset_type index, step, hash = mapped_index_string_hash (INT_MAX, name);
21729 index = hash & (symtab->size - 1);
21730 step = ((hash * 17) & (symtab->size - 1)) | 1;
21734 if (!symtab->data[index] || !strcmp (name, symtab->data[index]->name))
21735 return &symtab->data[index];
21736 index = (index + step) & (symtab->size - 1);
21740 /* Expand SYMTAB's hash table. */
21743 hash_expand (struct mapped_symtab *symtab)
21745 offset_type old_size = symtab->size;
21747 struct symtab_index_entry **old_entries = symtab->data;
21750 symtab->data = XCNEWVEC (struct symtab_index_entry *, symtab->size);
21752 for (i = 0; i < old_size; ++i)
21754 if (old_entries[i])
21756 struct symtab_index_entry **slot = find_slot (symtab,
21757 old_entries[i]->name);
21758 *slot = old_entries[i];
21762 xfree (old_entries);
21765 /* Add an entry to SYMTAB. NAME is the name of the symbol.
21766 CU_INDEX is the index of the CU in which the symbol appears.
21767 IS_STATIC is one if the symbol is static, otherwise zero (global). */
21770 add_index_entry (struct mapped_symtab *symtab, const char *name,
21771 int is_static, gdb_index_symbol_kind kind,
21772 offset_type cu_index)
21774 struct symtab_index_entry **slot;
21775 offset_type cu_index_and_attrs;
21777 ++symtab->n_elements;
21778 if (4 * symtab->n_elements / 3 >= symtab->size)
21779 hash_expand (symtab);
21781 slot = find_slot (symtab, name);
21784 *slot = XNEW (struct symtab_index_entry);
21785 (*slot)->name = name;
21786 /* index_offset is set later. */
21787 (*slot)->cu_indices = NULL;
21790 cu_index_and_attrs = 0;
21791 DW2_GDB_INDEX_CU_SET_VALUE (cu_index_and_attrs, cu_index);
21792 DW2_GDB_INDEX_SYMBOL_STATIC_SET_VALUE (cu_index_and_attrs, is_static);
21793 DW2_GDB_INDEX_SYMBOL_KIND_SET_VALUE (cu_index_and_attrs, kind);
21795 /* We don't want to record an index value twice as we want to avoid the
21797 We process all global symbols and then all static symbols
21798 (which would allow us to avoid the duplication by only having to check
21799 the last entry pushed), but a symbol could have multiple kinds in one CU.
21800 To keep things simple we don't worry about the duplication here and
21801 sort and uniqufy the list after we've processed all symbols. */
21802 VEC_safe_push (offset_type, (*slot)->cu_indices, cu_index_and_attrs);
21805 /* qsort helper routine for uniquify_cu_indices. */
21808 offset_type_compare (const void *ap, const void *bp)
21810 offset_type a = *(offset_type *) ap;
21811 offset_type b = *(offset_type *) bp;
21813 return (a > b) - (b > a);
21816 /* Sort and remove duplicates of all symbols' cu_indices lists. */
21819 uniquify_cu_indices (struct mapped_symtab *symtab)
21823 for (i = 0; i < symtab->size; ++i)
21825 struct symtab_index_entry *entry = symtab->data[i];
21828 && entry->cu_indices != NULL)
21830 unsigned int next_to_insert, next_to_check;
21831 offset_type last_value;
21833 qsort (VEC_address (offset_type, entry->cu_indices),
21834 VEC_length (offset_type, entry->cu_indices),
21835 sizeof (offset_type), offset_type_compare);
21837 last_value = VEC_index (offset_type, entry->cu_indices, 0);
21838 next_to_insert = 1;
21839 for (next_to_check = 1;
21840 next_to_check < VEC_length (offset_type, entry->cu_indices);
21843 if (VEC_index (offset_type, entry->cu_indices, next_to_check)
21846 last_value = VEC_index (offset_type, entry->cu_indices,
21848 VEC_replace (offset_type, entry->cu_indices, next_to_insert,
21853 VEC_truncate (offset_type, entry->cu_indices, next_to_insert);
21858 /* Add a vector of indices to the constant pool. */
21861 add_indices_to_cpool (htab_t symbol_hash_table, struct obstack *cpool,
21862 struct symtab_index_entry *entry)
21866 slot = htab_find_slot (symbol_hash_table, entry, INSERT);
21869 offset_type len = VEC_length (offset_type, entry->cu_indices);
21870 offset_type val = MAYBE_SWAP (len);
21875 entry->index_offset = obstack_object_size (cpool);
21877 obstack_grow (cpool, &val, sizeof (val));
21879 VEC_iterate (offset_type, entry->cu_indices, i, iter);
21882 val = MAYBE_SWAP (iter);
21883 obstack_grow (cpool, &val, sizeof (val));
21888 struct symtab_index_entry *old_entry = *slot;
21889 entry->index_offset = old_entry->index_offset;
21892 return entry->index_offset;
21895 /* Write the mapped hash table SYMTAB to the obstack OUTPUT, with
21896 constant pool entries going into the obstack CPOOL. */
21899 write_hash_table (struct mapped_symtab *symtab,
21900 struct obstack *output, struct obstack *cpool)
21903 htab_t symbol_hash_table;
21906 symbol_hash_table = create_symbol_hash_table ();
21907 str_table = create_strtab ();
21909 /* We add all the index vectors to the constant pool first, to
21910 ensure alignment is ok. */
21911 for (i = 0; i < symtab->size; ++i)
21913 if (symtab->data[i])
21914 add_indices_to_cpool (symbol_hash_table, cpool, symtab->data[i]);
21917 /* Now write out the hash table. */
21918 for (i = 0; i < symtab->size; ++i)
21920 offset_type str_off, vec_off;
21922 if (symtab->data[i])
21924 str_off = add_string (str_table, cpool, symtab->data[i]->name);
21925 vec_off = symtab->data[i]->index_offset;
21929 /* While 0 is a valid constant pool index, it is not valid
21930 to have 0 for both offsets. */
21935 str_off = MAYBE_SWAP (str_off);
21936 vec_off = MAYBE_SWAP (vec_off);
21938 obstack_grow (output, &str_off, sizeof (str_off));
21939 obstack_grow (output, &vec_off, sizeof (vec_off));
21942 htab_delete (str_table);
21943 htab_delete (symbol_hash_table);
21946 /* Struct to map psymtab to CU index in the index file. */
21947 struct psymtab_cu_index_map
21949 struct partial_symtab *psymtab;
21950 unsigned int cu_index;
21954 hash_psymtab_cu_index (const void *item)
21956 const struct psymtab_cu_index_map *map = item;
21958 return htab_hash_pointer (map->psymtab);
21962 eq_psymtab_cu_index (const void *item_lhs, const void *item_rhs)
21964 const struct psymtab_cu_index_map *lhs = item_lhs;
21965 const struct psymtab_cu_index_map *rhs = item_rhs;
21967 return lhs->psymtab == rhs->psymtab;
21970 /* Helper struct for building the address table. */
21971 struct addrmap_index_data
21973 struct objfile *objfile;
21974 struct obstack *addr_obstack;
21975 htab_t cu_index_htab;
21977 /* Non-zero if the previous_* fields are valid.
21978 We can't write an entry until we see the next entry (since it is only then
21979 that we know the end of the entry). */
21980 int previous_valid;
21981 /* Index of the CU in the table of all CUs in the index file. */
21982 unsigned int previous_cu_index;
21983 /* Start address of the CU. */
21984 CORE_ADDR previous_cu_start;
21987 /* Write an address entry to OBSTACK. */
21990 add_address_entry (struct objfile *objfile, struct obstack *obstack,
21991 CORE_ADDR start, CORE_ADDR end, unsigned int cu_index)
21993 offset_type cu_index_to_write;
21995 CORE_ADDR baseaddr;
21997 baseaddr = ANOFFSET (objfile->section_offsets, SECT_OFF_TEXT (objfile));
21999 store_unsigned_integer (addr, 8, BFD_ENDIAN_LITTLE, start - baseaddr);
22000 obstack_grow (obstack, addr, 8);
22001 store_unsigned_integer (addr, 8, BFD_ENDIAN_LITTLE, end - baseaddr);
22002 obstack_grow (obstack, addr, 8);
22003 cu_index_to_write = MAYBE_SWAP (cu_index);
22004 obstack_grow (obstack, &cu_index_to_write, sizeof (offset_type));
22007 /* Worker function for traversing an addrmap to build the address table. */
22010 add_address_entry_worker (void *datap, CORE_ADDR start_addr, void *obj)
22012 struct addrmap_index_data *data = datap;
22013 struct partial_symtab *pst = obj;
22015 if (data->previous_valid)
22016 add_address_entry (data->objfile, data->addr_obstack,
22017 data->previous_cu_start, start_addr,
22018 data->previous_cu_index);
22020 data->previous_cu_start = start_addr;
22023 struct psymtab_cu_index_map find_map, *map;
22024 find_map.psymtab = pst;
22025 map = htab_find (data->cu_index_htab, &find_map);
22026 gdb_assert (map != NULL);
22027 data->previous_cu_index = map->cu_index;
22028 data->previous_valid = 1;
22031 data->previous_valid = 0;
22036 /* Write OBJFILE's address map to OBSTACK.
22037 CU_INDEX_HTAB is used to map addrmap entries to their CU indices
22038 in the index file. */
22041 write_address_map (struct objfile *objfile, struct obstack *obstack,
22042 htab_t cu_index_htab)
22044 struct addrmap_index_data addrmap_index_data;
22046 /* When writing the address table, we have to cope with the fact that
22047 the addrmap iterator only provides the start of a region; we have to
22048 wait until the next invocation to get the start of the next region. */
22050 addrmap_index_data.objfile = objfile;
22051 addrmap_index_data.addr_obstack = obstack;
22052 addrmap_index_data.cu_index_htab = cu_index_htab;
22053 addrmap_index_data.previous_valid = 0;
22055 addrmap_foreach (objfile->psymtabs_addrmap, add_address_entry_worker,
22056 &addrmap_index_data);
22058 /* It's highly unlikely the last entry (end address = 0xff...ff)
22059 is valid, but we should still handle it.
22060 The end address is recorded as the start of the next region, but that
22061 doesn't work here. To cope we pass 0xff...ff, this is a rare situation
22063 if (addrmap_index_data.previous_valid)
22064 add_address_entry (objfile, obstack,
22065 addrmap_index_data.previous_cu_start, (CORE_ADDR) -1,
22066 addrmap_index_data.previous_cu_index);
22069 /* Return the symbol kind of PSYM. */
22071 static gdb_index_symbol_kind
22072 symbol_kind (struct partial_symbol *psym)
22074 domain_enum domain = PSYMBOL_DOMAIN (psym);
22075 enum address_class aclass = PSYMBOL_CLASS (psym);
22083 return GDB_INDEX_SYMBOL_KIND_FUNCTION;
22085 return GDB_INDEX_SYMBOL_KIND_TYPE;
22087 case LOC_CONST_BYTES:
22088 case LOC_OPTIMIZED_OUT:
22090 return GDB_INDEX_SYMBOL_KIND_VARIABLE;
22092 /* Note: It's currently impossible to recognize psyms as enum values
22093 short of reading the type info. For now punt. */
22094 return GDB_INDEX_SYMBOL_KIND_VARIABLE;
22096 /* There are other LOC_FOO values that one might want to classify
22097 as variables, but dwarf2read.c doesn't currently use them. */
22098 return GDB_INDEX_SYMBOL_KIND_OTHER;
22100 case STRUCT_DOMAIN:
22101 return GDB_INDEX_SYMBOL_KIND_TYPE;
22103 return GDB_INDEX_SYMBOL_KIND_OTHER;
22107 /* Add a list of partial symbols to SYMTAB. */
22110 write_psymbols (struct mapped_symtab *symtab,
22112 struct partial_symbol **psymp,
22114 offset_type cu_index,
22117 for (; count-- > 0; ++psymp)
22119 struct partial_symbol *psym = *psymp;
22122 if (SYMBOL_LANGUAGE (psym) == language_ada)
22123 error (_("Ada is not currently supported by the index"));
22125 /* Only add a given psymbol once. */
22126 slot = htab_find_slot (psyms_seen, psym, INSERT);
22129 gdb_index_symbol_kind kind = symbol_kind (psym);
22132 add_index_entry (symtab, SYMBOL_SEARCH_NAME (psym),
22133 is_static, kind, cu_index);
22138 /* Write the contents of an ("unfinished") obstack to FILE. Throw an
22139 exception if there is an error. */
22142 write_obstack (FILE *file, struct obstack *obstack)
22144 if (fwrite (obstack_base (obstack), 1, obstack_object_size (obstack),
22146 != obstack_object_size (obstack))
22147 error (_("couldn't data write to file"));
22150 /* Unlink a file if the argument is not NULL. */
22153 unlink_if_set (void *p)
22155 char **filename = p;
22157 unlink (*filename);
22160 /* A helper struct used when iterating over debug_types. */
22161 struct signatured_type_index_data
22163 struct objfile *objfile;
22164 struct mapped_symtab *symtab;
22165 struct obstack *types_list;
22170 /* A helper function that writes a single signatured_type to an
22174 write_one_signatured_type (void **slot, void *d)
22176 struct signatured_type_index_data *info = d;
22177 struct signatured_type *entry = (struct signatured_type *) *slot;
22178 struct partial_symtab *psymtab = entry->per_cu.v.psymtab;
22181 write_psymbols (info->symtab,
22183 info->objfile->global_psymbols.list
22184 + psymtab->globals_offset,
22185 psymtab->n_global_syms, info->cu_index,
22187 write_psymbols (info->symtab,
22189 info->objfile->static_psymbols.list
22190 + psymtab->statics_offset,
22191 psymtab->n_static_syms, info->cu_index,
22194 store_unsigned_integer (val, 8, BFD_ENDIAN_LITTLE,
22195 entry->per_cu.offset.sect_off);
22196 obstack_grow (info->types_list, val, 8);
22197 store_unsigned_integer (val, 8, BFD_ENDIAN_LITTLE,
22198 entry->type_offset_in_tu.cu_off);
22199 obstack_grow (info->types_list, val, 8);
22200 store_unsigned_integer (val, 8, BFD_ENDIAN_LITTLE, entry->signature);
22201 obstack_grow (info->types_list, val, 8);
22208 /* Recurse into all "included" dependencies and write their symbols as
22209 if they appeared in this psymtab. */
22212 recursively_write_psymbols (struct objfile *objfile,
22213 struct partial_symtab *psymtab,
22214 struct mapped_symtab *symtab,
22216 offset_type cu_index)
22220 for (i = 0; i < psymtab->number_of_dependencies; ++i)
22221 if (psymtab->dependencies[i]->user != NULL)
22222 recursively_write_psymbols (objfile, psymtab->dependencies[i],
22223 symtab, psyms_seen, cu_index);
22225 write_psymbols (symtab,
22227 objfile->global_psymbols.list + psymtab->globals_offset,
22228 psymtab->n_global_syms, cu_index,
22230 write_psymbols (symtab,
22232 objfile->static_psymbols.list + psymtab->statics_offset,
22233 psymtab->n_static_syms, cu_index,
22237 /* Create an index file for OBJFILE in the directory DIR. */
22240 write_psymtabs_to_index (struct objfile *objfile, const char *dir)
22242 struct cleanup *cleanup;
22243 char *filename, *cleanup_filename;
22244 struct obstack contents, addr_obstack, constant_pool, symtab_obstack;
22245 struct obstack cu_list, types_cu_list;
22248 struct mapped_symtab *symtab;
22249 offset_type val, size_of_contents, total_len;
22252 htab_t cu_index_htab;
22253 struct psymtab_cu_index_map *psymtab_cu_index_map;
22255 if (dwarf2_per_objfile->using_index)
22256 error (_("Cannot use an index to create the index"));
22258 if (VEC_length (dwarf2_section_info_def, dwarf2_per_objfile->types) > 1)
22259 error (_("Cannot make an index when the file has multiple .debug_types sections"));
22261 if (!objfile->psymtabs || !objfile->psymtabs_addrmap)
22264 if (stat (objfile_name (objfile), &st) < 0)
22265 perror_with_name (objfile_name (objfile));
22267 filename = concat (dir, SLASH_STRING, lbasename (objfile_name (objfile)),
22268 INDEX_SUFFIX, (char *) NULL);
22269 cleanup = make_cleanup (xfree, filename);
22271 out_file = gdb_fopen_cloexec (filename, "wb");
22273 error (_("Can't open `%s' for writing"), filename);
22275 cleanup_filename = filename;
22276 make_cleanup (unlink_if_set, &cleanup_filename);
22278 symtab = create_mapped_symtab ();
22279 make_cleanup (cleanup_mapped_symtab, symtab);
22281 obstack_init (&addr_obstack);
22282 make_cleanup_obstack_free (&addr_obstack);
22284 obstack_init (&cu_list);
22285 make_cleanup_obstack_free (&cu_list);
22287 obstack_init (&types_cu_list);
22288 make_cleanup_obstack_free (&types_cu_list);
22290 psyms_seen = htab_create_alloc (100, htab_hash_pointer, htab_eq_pointer,
22291 NULL, xcalloc, xfree);
22292 make_cleanup_htab_delete (psyms_seen);
22294 /* While we're scanning CU's create a table that maps a psymtab pointer
22295 (which is what addrmap records) to its index (which is what is recorded
22296 in the index file). This will later be needed to write the address
22298 cu_index_htab = htab_create_alloc (100,
22299 hash_psymtab_cu_index,
22300 eq_psymtab_cu_index,
22301 NULL, xcalloc, xfree);
22302 make_cleanup_htab_delete (cu_index_htab);
22303 psymtab_cu_index_map = (struct psymtab_cu_index_map *)
22304 xmalloc (sizeof (struct psymtab_cu_index_map)
22305 * dwarf2_per_objfile->n_comp_units);
22306 make_cleanup (xfree, psymtab_cu_index_map);
22308 /* The CU list is already sorted, so we don't need to do additional
22309 work here. Also, the debug_types entries do not appear in
22310 all_comp_units, but only in their own hash table. */
22311 for (i = 0; i < dwarf2_per_objfile->n_comp_units; ++i)
22313 struct dwarf2_per_cu_data *per_cu
22314 = dwarf2_per_objfile->all_comp_units[i];
22315 struct partial_symtab *psymtab = per_cu->v.psymtab;
22317 struct psymtab_cu_index_map *map;
22320 /* CU of a shared file from 'dwz -m' may be unused by this main file.
22321 It may be referenced from a local scope but in such case it does not
22322 need to be present in .gdb_index. */
22323 if (psymtab == NULL)
22326 if (psymtab->user == NULL)
22327 recursively_write_psymbols (objfile, psymtab, symtab, psyms_seen, i);
22329 map = &psymtab_cu_index_map[i];
22330 map->psymtab = psymtab;
22332 slot = htab_find_slot (cu_index_htab, map, INSERT);
22333 gdb_assert (slot != NULL);
22334 gdb_assert (*slot == NULL);
22337 store_unsigned_integer (val, 8, BFD_ENDIAN_LITTLE,
22338 per_cu->offset.sect_off);
22339 obstack_grow (&cu_list, val, 8);
22340 store_unsigned_integer (val, 8, BFD_ENDIAN_LITTLE, per_cu->length);
22341 obstack_grow (&cu_list, val, 8);
22344 /* Dump the address map. */
22345 write_address_map (objfile, &addr_obstack, cu_index_htab);
22347 /* Write out the .debug_type entries, if any. */
22348 if (dwarf2_per_objfile->signatured_types)
22350 struct signatured_type_index_data sig_data;
22352 sig_data.objfile = objfile;
22353 sig_data.symtab = symtab;
22354 sig_data.types_list = &types_cu_list;
22355 sig_data.psyms_seen = psyms_seen;
22356 sig_data.cu_index = dwarf2_per_objfile->n_comp_units;
22357 htab_traverse_noresize (dwarf2_per_objfile->signatured_types,
22358 write_one_signatured_type, &sig_data);
22361 /* Now that we've processed all symbols we can shrink their cu_indices
22363 uniquify_cu_indices (symtab);
22365 obstack_init (&constant_pool);
22366 make_cleanup_obstack_free (&constant_pool);
22367 obstack_init (&symtab_obstack);
22368 make_cleanup_obstack_free (&symtab_obstack);
22369 write_hash_table (symtab, &symtab_obstack, &constant_pool);
22371 obstack_init (&contents);
22372 make_cleanup_obstack_free (&contents);
22373 size_of_contents = 6 * sizeof (offset_type);
22374 total_len = size_of_contents;
22376 /* The version number. */
22377 val = MAYBE_SWAP (8);
22378 obstack_grow (&contents, &val, sizeof (val));
22380 /* The offset of the CU list from the start of the file. */
22381 val = MAYBE_SWAP (total_len);
22382 obstack_grow (&contents, &val, sizeof (val));
22383 total_len += obstack_object_size (&cu_list);
22385 /* The offset of the types CU list from the start of the file. */
22386 val = MAYBE_SWAP (total_len);
22387 obstack_grow (&contents, &val, sizeof (val));
22388 total_len += obstack_object_size (&types_cu_list);
22390 /* The offset of the address table from the start of the file. */
22391 val = MAYBE_SWAP (total_len);
22392 obstack_grow (&contents, &val, sizeof (val));
22393 total_len += obstack_object_size (&addr_obstack);
22395 /* The offset of the symbol table from the start of the file. */
22396 val = MAYBE_SWAP (total_len);
22397 obstack_grow (&contents, &val, sizeof (val));
22398 total_len += obstack_object_size (&symtab_obstack);
22400 /* The offset of the constant pool from the start of the file. */
22401 val = MAYBE_SWAP (total_len);
22402 obstack_grow (&contents, &val, sizeof (val));
22403 total_len += obstack_object_size (&constant_pool);
22405 gdb_assert (obstack_object_size (&contents) == size_of_contents);
22407 write_obstack (out_file, &contents);
22408 write_obstack (out_file, &cu_list);
22409 write_obstack (out_file, &types_cu_list);
22410 write_obstack (out_file, &addr_obstack);
22411 write_obstack (out_file, &symtab_obstack);
22412 write_obstack (out_file, &constant_pool);
22416 /* We want to keep the file, so we set cleanup_filename to NULL
22417 here. See unlink_if_set. */
22418 cleanup_filename = NULL;
22420 do_cleanups (cleanup);
22423 /* Implementation of the `save gdb-index' command.
22425 Note that the file format used by this command is documented in the
22426 GDB manual. Any changes here must be documented there. */
22429 save_gdb_index_command (char *arg, int from_tty)
22431 struct objfile *objfile;
22434 error (_("usage: save gdb-index DIRECTORY"));
22436 ALL_OBJFILES (objfile)
22440 /* If the objfile does not correspond to an actual file, skip it. */
22441 if (stat (objfile_name (objfile), &st) < 0)
22444 dwarf2_per_objfile = objfile_data (objfile, dwarf2_objfile_data_key);
22445 if (dwarf2_per_objfile)
22447 volatile struct gdb_exception except;
22449 TRY_CATCH (except, RETURN_MASK_ERROR)
22451 write_psymtabs_to_index (objfile, arg);
22453 if (except.reason < 0)
22454 exception_fprintf (gdb_stderr, except,
22455 _("Error while writing index for `%s': "),
22456 objfile_name (objfile));
22463 int dwarf2_always_disassemble;
22466 show_dwarf2_always_disassemble (struct ui_file *file, int from_tty,
22467 struct cmd_list_element *c, const char *value)
22469 fprintf_filtered (file,
22470 _("Whether to always disassemble "
22471 "DWARF expressions is %s.\n"),
22476 show_check_physname (struct ui_file *file, int from_tty,
22477 struct cmd_list_element *c, const char *value)
22479 fprintf_filtered (file,
22480 _("Whether to check \"physname\" is %s.\n"),
22484 void _initialize_dwarf2_read (void);
22487 _initialize_dwarf2_read (void)
22489 struct cmd_list_element *c;
22491 dwarf2_objfile_data_key
22492 = register_objfile_data_with_cleanup (NULL, dwarf2_per_objfile_free);
22494 add_prefix_cmd ("dwarf2", class_maintenance, set_dwarf2_cmd, _("\
22495 Set DWARF 2 specific variables.\n\
22496 Configure DWARF 2 variables such as the cache size"),
22497 &set_dwarf2_cmdlist, "maintenance set dwarf2 ",
22498 0/*allow-unknown*/, &maintenance_set_cmdlist);
22500 add_prefix_cmd ("dwarf2", class_maintenance, show_dwarf2_cmd, _("\
22501 Show DWARF 2 specific variables\n\
22502 Show DWARF 2 variables such as the cache size"),
22503 &show_dwarf2_cmdlist, "maintenance show dwarf2 ",
22504 0/*allow-unknown*/, &maintenance_show_cmdlist);
22506 add_setshow_zinteger_cmd ("max-cache-age", class_obscure,
22507 &dwarf2_max_cache_age, _("\
22508 Set the upper bound on the age of cached dwarf2 compilation units."), _("\
22509 Show the upper bound on the age of cached dwarf2 compilation units."), _("\
22510 A higher limit means that cached compilation units will be stored\n\
22511 in memory longer, and more total memory will be used. Zero disables\n\
22512 caching, which can slow down startup."),
22514 show_dwarf2_max_cache_age,
22515 &set_dwarf2_cmdlist,
22516 &show_dwarf2_cmdlist);
22518 add_setshow_boolean_cmd ("always-disassemble", class_obscure,
22519 &dwarf2_always_disassemble, _("\
22520 Set whether `info address' always disassembles DWARF expressions."), _("\
22521 Show whether `info address' always disassembles DWARF expressions."), _("\
22522 When enabled, DWARF expressions are always printed in an assembly-like\n\
22523 syntax. When disabled, expressions will be printed in a more\n\
22524 conversational style, when possible."),
22526 show_dwarf2_always_disassemble,
22527 &set_dwarf2_cmdlist,
22528 &show_dwarf2_cmdlist);
22530 add_setshow_zuinteger_cmd ("dwarf2-read", no_class, &dwarf2_read_debug, _("\
22531 Set debugging of the dwarf2 reader."), _("\
22532 Show debugging of the dwarf2 reader."), _("\
22533 When enabled (non-zero), debugging messages are printed during dwarf2\n\
22534 reading and symtab expansion. A value of 1 (one) provides basic\n\
22535 information. A value greater than 1 provides more verbose information."),
22538 &setdebuglist, &showdebuglist);
22540 add_setshow_zuinteger_cmd ("dwarf2-die", no_class, &dwarf2_die_debug, _("\
22541 Set debugging of the dwarf2 DIE reader."), _("\
22542 Show debugging of the dwarf2 DIE reader."), _("\
22543 When enabled (non-zero), DIEs are dumped after they are read in.\n\
22544 The value is the maximum depth to print."),
22547 &setdebuglist, &showdebuglist);
22549 add_setshow_boolean_cmd ("check-physname", no_class, &check_physname, _("\
22550 Set cross-checking of \"physname\" code against demangler."), _("\
22551 Show cross-checking of \"physname\" code against demangler."), _("\
22552 When enabled, GDB's internal \"physname\" code is checked against\n\
22554 NULL, show_check_physname,
22555 &setdebuglist, &showdebuglist);
22557 add_setshow_boolean_cmd ("use-deprecated-index-sections",
22558 no_class, &use_deprecated_index_sections, _("\
22559 Set whether to use deprecated gdb_index sections."), _("\
22560 Show whether to use deprecated gdb_index sections."), _("\
22561 When enabled, deprecated .gdb_index sections are used anyway.\n\
22562 Normally they are ignored either because of a missing feature or\n\
22563 performance issue.\n\
22564 Warning: This option must be enabled before gdb reads the file."),
22567 &setlist, &showlist);
22569 c = add_cmd ("gdb-index", class_files, save_gdb_index_command,
22571 Save a gdb-index file.\n\
22572 Usage: save gdb-index DIRECTORY"),
22574 set_cmd_completer (c, filename_completer);
22576 dwarf2_locexpr_index = register_symbol_computed_impl (LOC_COMPUTED,
22577 &dwarf2_locexpr_funcs);
22578 dwarf2_loclist_index = register_symbol_computed_impl (LOC_COMPUTED,
22579 &dwarf2_loclist_funcs);
22581 dwarf2_locexpr_block_index = register_symbol_block_impl (LOC_BLOCK,
22582 &dwarf2_block_frame_base_locexpr_funcs);
22583 dwarf2_loclist_block_index = register_symbol_block_impl (LOC_BLOCK,
22584 &dwarf2_block_frame_base_loclist_funcs);