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"
59 #include "completer.h"
64 #include "gdbcore.h" /* for gnutarget */
65 #include "gdb/gdb-index.h"
70 #include "filestuff.h"
74 #include <sys/types.h>
76 typedef struct symbol *symbolp;
79 /* When == 1, print basic high level tracing messages.
80 When > 1, be more verbose.
81 This is in contrast to the low level DIE reading of dwarf2_die_debug. */
82 static unsigned int dwarf2_read_debug = 0;
84 /* When non-zero, dump DIEs after they are read in. */
85 static unsigned int dwarf2_die_debug = 0;
87 /* When non-zero, cross-check physname against demangler. */
88 static int check_physname = 0;
90 /* When non-zero, do not reject deprecated .gdb_index sections. */
91 static int use_deprecated_index_sections = 0;
93 static const struct objfile_data *dwarf2_objfile_data_key;
95 /* The "aclass" indices for various kinds of computed DWARF symbols. */
97 static int dwarf2_locexpr_index;
98 static int dwarf2_loclist_index;
99 static int dwarf2_locexpr_block_index;
100 static int dwarf2_loclist_block_index;
102 /* A descriptor for dwarf sections.
104 S.ASECTION, SIZE are typically initialized when the objfile is first
105 scanned. BUFFER, READIN are filled in later when the section is read.
106 If the section contained compressed data then SIZE is updated to record
107 the uncompressed size of the section.
109 DWP file format V2 introduces a wrinkle that is easiest to handle by
110 creating the concept of virtual sections contained within a real section.
111 In DWP V2 the sections of the input DWO files are concatenated together
112 into one section, but section offsets are kept relative to the original
114 If this is a virtual dwp-v2 section, S.CONTAINING_SECTION is a backlink to
115 the real section this "virtual" section is contained in, and BUFFER,SIZE
116 describe the virtual section. */
118 struct dwarf2_section_info
122 /* If this is a real section, the bfd section. */
124 /* If this is a virtual section, pointer to the containing ("real")
126 struct dwarf2_section_info *containing_section;
128 /* Pointer to section data, only valid if readin. */
129 const gdb_byte *buffer;
130 /* The size of the section, real or virtual. */
132 /* If this is a virtual section, the offset in the real section.
133 Only valid if is_virtual. */
134 bfd_size_type virtual_offset;
135 /* True if we have tried to read this section. */
137 /* True if this is a virtual section, False otherwise.
138 This specifies which of s.asection and s.containing_section to use. */
142 typedef struct dwarf2_section_info dwarf2_section_info_def;
143 DEF_VEC_O (dwarf2_section_info_def);
145 /* All offsets in the index are of this type. It must be
146 architecture-independent. */
147 typedef uint32_t offset_type;
149 DEF_VEC_I (offset_type);
151 /* Ensure only legit values are used. */
152 #define DW2_GDB_INDEX_SYMBOL_STATIC_SET_VALUE(cu_index, value) \
154 gdb_assert ((unsigned int) (value) <= 1); \
155 GDB_INDEX_SYMBOL_STATIC_SET_VALUE((cu_index), (value)); \
158 /* Ensure only legit values are used. */
159 #define DW2_GDB_INDEX_SYMBOL_KIND_SET_VALUE(cu_index, value) \
161 gdb_assert ((value) >= GDB_INDEX_SYMBOL_KIND_TYPE \
162 && (value) <= GDB_INDEX_SYMBOL_KIND_OTHER); \
163 GDB_INDEX_SYMBOL_KIND_SET_VALUE((cu_index), (value)); \
166 /* Ensure we don't use more than the alloted nuber of bits for the CU. */
167 #define DW2_GDB_INDEX_CU_SET_VALUE(cu_index, value) \
169 gdb_assert (((value) & ~GDB_INDEX_CU_MASK) == 0); \
170 GDB_INDEX_CU_SET_VALUE((cu_index), (value)); \
173 /* A description of the mapped index. The file format is described in
174 a comment by the code that writes the index. */
177 /* Index data format version. */
180 /* The total length of the buffer. */
183 /* A pointer to the address table data. */
184 const gdb_byte *address_table;
186 /* Size of the address table data in bytes. */
187 offset_type address_table_size;
189 /* The symbol table, implemented as a hash table. */
190 const offset_type *symbol_table;
192 /* Size in slots, each slot is 2 offset_types. */
193 offset_type symbol_table_slots;
195 /* A pointer to the constant pool. */
196 const char *constant_pool;
199 typedef struct dwarf2_per_cu_data *dwarf2_per_cu_ptr;
200 DEF_VEC_P (dwarf2_per_cu_ptr);
202 /* Collection of data recorded per objfile.
203 This hangs off of dwarf2_objfile_data_key. */
205 struct dwarf2_per_objfile
207 struct dwarf2_section_info info;
208 struct dwarf2_section_info abbrev;
209 struct dwarf2_section_info line;
210 struct dwarf2_section_info loc;
211 struct dwarf2_section_info macinfo;
212 struct dwarf2_section_info macro;
213 struct dwarf2_section_info str;
214 struct dwarf2_section_info ranges;
215 struct dwarf2_section_info addr;
216 struct dwarf2_section_info frame;
217 struct dwarf2_section_info eh_frame;
218 struct dwarf2_section_info gdb_index;
220 VEC (dwarf2_section_info_def) *types;
223 struct objfile *objfile;
225 /* Table of all the compilation units. This is used to locate
226 the target compilation unit of a particular reference. */
227 struct dwarf2_per_cu_data **all_comp_units;
229 /* The number of compilation units in ALL_COMP_UNITS. */
232 /* The number of .debug_types-related CUs. */
235 /* The number of elements allocated in all_type_units.
236 If there are skeleton-less TUs, we add them to all_type_units lazily. */
237 int n_allocated_type_units;
239 /* The .debug_types-related CUs (TUs).
240 This is stored in malloc space because we may realloc it. */
241 struct signatured_type **all_type_units;
243 /* Table of struct type_unit_group objects.
244 The hash key is the DW_AT_stmt_list value. */
245 htab_t type_unit_groups;
247 /* A table mapping .debug_types signatures to its signatured_type entry.
248 This is NULL if the .debug_types section hasn't been read in yet. */
249 htab_t signatured_types;
251 /* Type unit statistics, to see how well the scaling improvements
255 int nr_uniq_abbrev_tables;
257 int nr_symtab_sharers;
258 int nr_stmt_less_type_units;
259 int nr_all_type_units_reallocs;
262 /* A chain of compilation units that are currently read in, so that
263 they can be freed later. */
264 struct dwarf2_per_cu_data *read_in_chain;
266 /* A table mapping DW_AT_dwo_name values to struct dwo_file objects.
267 This is NULL if the table hasn't been allocated yet. */
270 /* Non-zero if we've check for whether there is a DWP file. */
273 /* The DWP file if there is one, or NULL. */
274 struct dwp_file *dwp_file;
276 /* The shared '.dwz' file, if one exists. This is used when the
277 original data was compressed using 'dwz -m'. */
278 struct dwz_file *dwz_file;
280 /* A flag indicating wether this objfile has a section loaded at a
282 int has_section_at_zero;
284 /* True if we are using the mapped index,
285 or we are faking it for OBJF_READNOW's sake. */
286 unsigned char using_index;
288 /* The mapped index, or NULL if .gdb_index is missing or not being used. */
289 struct mapped_index *index_table;
291 /* When using index_table, this keeps track of all quick_file_names entries.
292 TUs typically share line table entries with a CU, so we maintain a
293 separate table of all line table entries to support the sharing.
294 Note that while there can be way more TUs than CUs, we've already
295 sorted all the TUs into "type unit groups", grouped by their
296 DW_AT_stmt_list value. Therefore the only sharing done here is with a
297 CU and its associated TU group if there is one. */
298 htab_t quick_file_names_table;
300 /* Set during partial symbol reading, to prevent queueing of full
302 int reading_partial_symbols;
304 /* Table mapping type DIEs to their struct type *.
305 This is NULL if not allocated yet.
306 The mapping is done via (CU/TU + DIE offset) -> type. */
307 htab_t die_type_hash;
309 /* The CUs we recently read. */
310 VEC (dwarf2_per_cu_ptr) *just_read_cus;
313 static struct dwarf2_per_objfile *dwarf2_per_objfile;
315 /* Default names of the debugging sections. */
317 /* Note that if the debugging section has been compressed, it might
318 have a name like .zdebug_info. */
320 static const struct dwarf2_debug_sections dwarf2_elf_names =
322 { ".debug_info", ".zdebug_info" },
323 { ".debug_abbrev", ".zdebug_abbrev" },
324 { ".debug_line", ".zdebug_line" },
325 { ".debug_loc", ".zdebug_loc" },
326 { ".debug_macinfo", ".zdebug_macinfo" },
327 { ".debug_macro", ".zdebug_macro" },
328 { ".debug_str", ".zdebug_str" },
329 { ".debug_ranges", ".zdebug_ranges" },
330 { ".debug_types", ".zdebug_types" },
331 { ".debug_addr", ".zdebug_addr" },
332 { ".debug_frame", ".zdebug_frame" },
333 { ".eh_frame", NULL },
334 { ".gdb_index", ".zgdb_index" },
338 /* List of DWO/DWP sections. */
340 static const struct dwop_section_names
342 struct dwarf2_section_names abbrev_dwo;
343 struct dwarf2_section_names info_dwo;
344 struct dwarf2_section_names line_dwo;
345 struct dwarf2_section_names loc_dwo;
346 struct dwarf2_section_names macinfo_dwo;
347 struct dwarf2_section_names macro_dwo;
348 struct dwarf2_section_names str_dwo;
349 struct dwarf2_section_names str_offsets_dwo;
350 struct dwarf2_section_names types_dwo;
351 struct dwarf2_section_names cu_index;
352 struct dwarf2_section_names tu_index;
356 { ".debug_abbrev.dwo", ".zdebug_abbrev.dwo" },
357 { ".debug_info.dwo", ".zdebug_info.dwo" },
358 { ".debug_line.dwo", ".zdebug_line.dwo" },
359 { ".debug_loc.dwo", ".zdebug_loc.dwo" },
360 { ".debug_macinfo.dwo", ".zdebug_macinfo.dwo" },
361 { ".debug_macro.dwo", ".zdebug_macro.dwo" },
362 { ".debug_str.dwo", ".zdebug_str.dwo" },
363 { ".debug_str_offsets.dwo", ".zdebug_str_offsets.dwo" },
364 { ".debug_types.dwo", ".zdebug_types.dwo" },
365 { ".debug_cu_index", ".zdebug_cu_index" },
366 { ".debug_tu_index", ".zdebug_tu_index" },
369 /* local data types */
371 /* The data in a compilation unit header, after target2host
372 translation, looks like this. */
373 struct comp_unit_head
377 unsigned char addr_size;
378 unsigned char signed_addr_p;
379 sect_offset abbrev_offset;
381 /* Size of file offsets; either 4 or 8. */
382 unsigned int offset_size;
384 /* Size of the length field; either 4 or 12. */
385 unsigned int initial_length_size;
387 /* Offset to the first byte of this compilation unit header in the
388 .debug_info section, for resolving relative reference dies. */
391 /* Offset to first die in this cu from the start of the cu.
392 This will be the first byte following the compilation unit header. */
393 cu_offset first_die_offset;
396 /* Type used for delaying computation of method physnames.
397 See comments for compute_delayed_physnames. */
398 struct delayed_method_info
400 /* The type to which the method is attached, i.e., its parent class. */
403 /* The index of the method in the type's function fieldlists. */
406 /* The index of the method in the fieldlist. */
409 /* The name of the DIE. */
412 /* The DIE associated with this method. */
413 struct die_info *die;
416 typedef struct delayed_method_info delayed_method_info;
417 DEF_VEC_O (delayed_method_info);
419 /* Internal state when decoding a particular compilation unit. */
422 /* The objfile containing this compilation unit. */
423 struct objfile *objfile;
425 /* The header of the compilation unit. */
426 struct comp_unit_head header;
428 /* Base address of this compilation unit. */
429 CORE_ADDR base_address;
431 /* Non-zero if base_address has been set. */
434 /* The language we are debugging. */
435 enum language language;
436 const struct language_defn *language_defn;
438 const char *producer;
440 /* The generic symbol table building routines have separate lists for
441 file scope symbols and all all other scopes (local scopes). So
442 we need to select the right one to pass to add_symbol_to_list().
443 We do it by keeping a pointer to the correct list in list_in_scope.
445 FIXME: The original dwarf code just treated the file scope as the
446 first local scope, and all other local scopes as nested local
447 scopes, and worked fine. Check to see if we really need to
448 distinguish these in buildsym.c. */
449 struct pending **list_in_scope;
451 /* The abbrev table for this CU.
452 Normally this points to the abbrev table in the objfile.
453 But if DWO_UNIT is non-NULL this is the abbrev table in the DWO file. */
454 struct abbrev_table *abbrev_table;
456 /* Hash table holding all the loaded partial DIEs
457 with partial_die->offset.SECT_OFF as hash. */
460 /* Storage for things with the same lifetime as this read-in compilation
461 unit, including partial DIEs. */
462 struct obstack comp_unit_obstack;
464 /* When multiple dwarf2_cu structures are living in memory, this field
465 chains them all together, so that they can be released efficiently.
466 We will probably also want a generation counter so that most-recently-used
467 compilation units are cached... */
468 struct dwarf2_per_cu_data *read_in_chain;
470 /* Backlink to our per_cu entry. */
471 struct dwarf2_per_cu_data *per_cu;
473 /* How many compilation units ago was this CU last referenced? */
476 /* A hash table of DIE cu_offset for following references with
477 die_info->offset.sect_off as hash. */
480 /* Full DIEs if read in. */
481 struct die_info *dies;
483 /* A set of pointers to dwarf2_per_cu_data objects for compilation
484 units referenced by this one. Only set during full symbol processing;
485 partial symbol tables do not have dependencies. */
488 /* Header data from the line table, during full symbol processing. */
489 struct line_header *line_header;
491 /* A list of methods which need to have physnames computed
492 after all type information has been read. */
493 VEC (delayed_method_info) *method_list;
495 /* To be copied to symtab->call_site_htab. */
496 htab_t call_site_htab;
498 /* Non-NULL if this CU came from a DWO file.
499 There is an invariant here that is important to remember:
500 Except for attributes copied from the top level DIE in the "main"
501 (or "stub") file in preparation for reading the DWO file
502 (e.g., DW_AT_GNU_addr_base), we KISS: there is only *one* CU.
503 Either there isn't a DWO file (in which case this is NULL and the point
504 is moot), or there is and either we're not going to read it (in which
505 case this is NULL) or there is and we are reading it (in which case this
507 struct dwo_unit *dwo_unit;
509 /* The DW_AT_addr_base attribute if present, zero otherwise
510 (zero is a valid value though).
511 Note this value comes from the Fission stub CU/TU's DIE. */
514 /* The DW_AT_ranges_base attribute if present, zero otherwise
515 (zero is a valid value though).
516 Note this value comes from the Fission stub CU/TU's DIE.
517 Also note that the value is zero in the non-DWO case so this value can
518 be used without needing to know whether DWO files are in use or not.
519 N.B. This does not apply to DW_AT_ranges appearing in
520 DW_TAG_compile_unit dies. This is a bit of a wart, consider if ever
521 DW_AT_ranges appeared in the DW_TAG_compile_unit of DWO DIEs: then
522 DW_AT_ranges_base *would* have to be applied, and we'd have to care
523 whether the DW_AT_ranges attribute came from the skeleton or DWO. */
524 ULONGEST ranges_base;
526 /* Mark used when releasing cached dies. */
527 unsigned int mark : 1;
529 /* This CU references .debug_loc. See the symtab->locations_valid field.
530 This test is imperfect as there may exist optimized debug code not using
531 any location list and still facing inlining issues if handled as
532 unoptimized code. For a future better test see GCC PR other/32998. */
533 unsigned int has_loclist : 1;
535 /* These cache the results for producer_is_* fields. CHECKED_PRODUCER is set
536 if all the producer_is_* fields are valid. This information is cached
537 because profiling CU expansion showed excessive time spent in
538 producer_is_gxx_lt_4_6. */
539 unsigned int checked_producer : 1;
540 unsigned int producer_is_gxx_lt_4_6 : 1;
541 unsigned int producer_is_gcc_lt_4_3 : 1;
542 unsigned int producer_is_icc : 1;
544 /* When set, the file that we're processing is known to have
545 debugging info for C++ namespaces. GCC 3.3.x did not produce
546 this information, but later versions do. */
548 unsigned int processing_has_namespace_info : 1;
551 /* Persistent data held for a compilation unit, even when not
552 processing it. We put a pointer to this structure in the
553 read_symtab_private field of the psymtab. */
555 struct dwarf2_per_cu_data
557 /* The start offset and length of this compilation unit.
558 NOTE: Unlike comp_unit_head.length, this length includes
560 If the DIE refers to a DWO file, this is always of the original die,
565 /* Flag indicating this compilation unit will be read in before
566 any of the current compilation units are processed. */
567 unsigned int queued : 1;
569 /* This flag will be set when reading partial DIEs if we need to load
570 absolutely all DIEs for this compilation unit, instead of just the ones
571 we think are interesting. It gets set if we look for a DIE in the
572 hash table and don't find it. */
573 unsigned int load_all_dies : 1;
575 /* Non-zero if this CU is from .debug_types.
576 Struct dwarf2_per_cu_data is contained in struct signatured_type iff
578 unsigned int is_debug_types : 1;
580 /* Non-zero if this CU is from the .dwz file. */
581 unsigned int is_dwz : 1;
583 /* Non-zero if reading a TU directly from a DWO file, bypassing the stub.
584 This flag is only valid if is_debug_types is true.
585 We can't read a CU directly from a DWO file: There are required
586 attributes in the stub. */
587 unsigned int reading_dwo_directly : 1;
589 /* Non-zero if the TU has been read.
590 This is used to assist the "Stay in DWO Optimization" for Fission:
591 When reading a DWO, it's faster to read TUs from the DWO instead of
592 fetching them from random other DWOs (due to comdat folding).
593 If the TU has already been read, the optimization is unnecessary
594 (and unwise - we don't want to change where gdb thinks the TU lives
596 This flag is only valid if is_debug_types is true. */
597 unsigned int tu_read : 1;
599 /* The section this CU/TU lives in.
600 If the DIE refers to a DWO file, this is always the original die,
602 struct dwarf2_section_info *section;
604 /* Set to non-NULL iff this CU is currently loaded. When it gets freed out
605 of the CU cache it gets reset to NULL again. */
606 struct dwarf2_cu *cu;
608 /* The corresponding objfile.
609 Normally we can get the objfile from dwarf2_per_objfile.
610 However we can enter this file with just a "per_cu" handle. */
611 struct objfile *objfile;
613 /* When dwarf2_per_objfile->using_index is true, the 'quick' field
614 is active. Otherwise, the 'psymtab' field is active. */
617 /* The partial symbol table associated with this compilation unit,
618 or NULL for unread partial units. */
619 struct partial_symtab *psymtab;
621 /* Data needed by the "quick" functions. */
622 struct dwarf2_per_cu_quick_data *quick;
625 /* The CUs we import using DW_TAG_imported_unit. This is filled in
626 while reading psymtabs, used to compute the psymtab dependencies,
627 and then cleared. Then it is filled in again while reading full
628 symbols, and only deleted when the objfile is destroyed.
630 This is also used to work around a difference between the way gold
631 generates .gdb_index version <=7 and the way gdb does. Arguably this
632 is a gold bug. For symbols coming from TUs, gold records in the index
633 the CU that includes the TU instead of the TU itself. This breaks
634 dw2_lookup_symbol: It assumes that if the index says symbol X lives
635 in CU/TU Y, then one need only expand Y and a subsequent lookup in Y
636 will find X. Alas TUs live in their own symtab, so after expanding CU Y
637 we need to look in TU Z to find X. Fortunately, this is akin to
638 DW_TAG_imported_unit, so we just use the same mechanism: For
639 .gdb_index version <=7 this also records the TUs that the CU referred
640 to. Concurrently with this change gdb was modified to emit version 8
641 indices so we only pay a price for gold generated indices.
642 http://sourceware.org/bugzilla/show_bug.cgi?id=15021. */
643 VEC (dwarf2_per_cu_ptr) *imported_symtabs;
646 /* Entry in the signatured_types hash table. */
648 struct signatured_type
650 /* The "per_cu" object of this type.
651 This struct is used iff per_cu.is_debug_types.
652 N.B.: This is the first member so that it's easy to convert pointers
654 struct dwarf2_per_cu_data per_cu;
656 /* The type's signature. */
659 /* Offset in the TU of the type's DIE, as read from the TU header.
660 If this TU is a DWO stub and the definition lives in a DWO file
661 (specified by DW_AT_GNU_dwo_name), this value is unusable. */
662 cu_offset type_offset_in_tu;
664 /* Offset in the section of the type's DIE.
665 If the definition lives in a DWO file, this is the offset in the
666 .debug_types.dwo section.
667 The value is zero until the actual value is known.
668 Zero is otherwise not a valid section offset. */
669 sect_offset type_offset_in_section;
671 /* Type units are grouped by their DW_AT_stmt_list entry so that they
672 can share them. This points to the containing symtab. */
673 struct type_unit_group *type_unit_group;
676 The first time we encounter this type we fully read it in and install it
677 in the symbol tables. Subsequent times we only need the type. */
680 /* Containing DWO unit.
681 This field is valid iff per_cu.reading_dwo_directly. */
682 struct dwo_unit *dwo_unit;
685 typedef struct signatured_type *sig_type_ptr;
686 DEF_VEC_P (sig_type_ptr);
688 /* A struct that can be used as a hash key for tables based on DW_AT_stmt_list.
689 This includes type_unit_group and quick_file_names. */
691 struct stmt_list_hash
693 /* The DWO unit this table is from or NULL if there is none. */
694 struct dwo_unit *dwo_unit;
696 /* Offset in .debug_line or .debug_line.dwo. */
697 sect_offset line_offset;
700 /* Each element of dwarf2_per_objfile->type_unit_groups is a pointer to
701 an object of this type. */
703 struct type_unit_group
705 /* dwarf2read.c's main "handle" on a TU symtab.
706 To simplify things we create an artificial CU that "includes" all the
707 type units using this stmt_list so that the rest of the code still has
708 a "per_cu" handle on the symtab.
709 This PER_CU is recognized by having no section. */
710 #define IS_TYPE_UNIT_GROUP(per_cu) ((per_cu)->section == NULL)
711 struct dwarf2_per_cu_data per_cu;
713 /* The TUs that share this DW_AT_stmt_list entry.
714 This is added to while parsing type units to build partial symtabs,
715 and is deleted afterwards and not used again. */
716 VEC (sig_type_ptr) *tus;
718 /* The primary symtab.
719 Type units in a group needn't all be defined in the same source file,
720 so we create an essentially anonymous symtab as the primary symtab. */
721 struct symtab *primary_symtab;
723 /* The data used to construct the hash key. */
724 struct stmt_list_hash hash;
726 /* The number of symtabs from the line header.
727 The value here must match line_header.num_file_names. */
728 unsigned int num_symtabs;
730 /* The symbol tables for this TU (obtained from the files listed in
732 WARNING: The order of entries here must match the order of entries
733 in the line header. After the first TU using this type_unit_group, the
734 line header for the subsequent TUs is recreated from this. This is done
735 because we need to use the same symtabs for each TU using the same
736 DW_AT_stmt_list value. Also note that symtabs may be repeated here,
737 there's no guarantee the line header doesn't have duplicate entries. */
738 struct symtab **symtabs;
741 /* These sections are what may appear in a (real or virtual) DWO file. */
745 struct dwarf2_section_info abbrev;
746 struct dwarf2_section_info line;
747 struct dwarf2_section_info loc;
748 struct dwarf2_section_info macinfo;
749 struct dwarf2_section_info macro;
750 struct dwarf2_section_info str;
751 struct dwarf2_section_info str_offsets;
752 /* In the case of a virtual DWO file, these two are unused. */
753 struct dwarf2_section_info info;
754 VEC (dwarf2_section_info_def) *types;
757 /* CUs/TUs in DWP/DWO files. */
761 /* Backlink to the containing struct dwo_file. */
762 struct dwo_file *dwo_file;
764 /* The "id" that distinguishes this CU/TU.
765 .debug_info calls this "dwo_id", .debug_types calls this "signature".
766 Since signatures came first, we stick with it for consistency. */
769 /* The section this CU/TU lives in, in the DWO file. */
770 struct dwarf2_section_info *section;
772 /* Same as dwarf2_per_cu_data:{offset,length} but in the DWO section. */
776 /* For types, offset in the type's DIE of the type defined by this TU. */
777 cu_offset type_offset_in_tu;
780 /* include/dwarf2.h defines the DWP section codes.
781 It defines a max value but it doesn't define a min value, which we
782 use for error checking, so provide one. */
784 enum dwp_v2_section_ids
789 /* Data for one DWO file.
791 This includes virtual DWO files (a virtual DWO file is a DWO file as it
792 appears in a DWP file). DWP files don't really have DWO files per se -
793 comdat folding of types "loses" the DWO file they came from, and from
794 a high level view DWP files appear to contain a mass of random types.
795 However, to maintain consistency with the non-DWP case we pretend DWP
796 files contain virtual DWO files, and we assign each TU with one virtual
797 DWO file (generally based on the line and abbrev section offsets -
798 a heuristic that seems to work in practice). */
802 /* The DW_AT_GNU_dwo_name attribute.
803 For virtual DWO files the name is constructed from the section offsets
804 of abbrev,line,loc,str_offsets so that we combine virtual DWO files
805 from related CU+TUs. */
806 const char *dwo_name;
808 /* The DW_AT_comp_dir attribute. */
809 const char *comp_dir;
811 /* The bfd, when the file is open. Otherwise this is NULL.
812 This is unused(NULL) for virtual DWO files where we use dwp_file.dbfd. */
815 /* The sections that make up this DWO file.
816 Remember that for virtual DWO files in DWP V2, these are virtual
817 sections (for lack of a better name). */
818 struct dwo_sections sections;
820 /* The CU in the file.
821 We only support one because having more than one requires hacking the
822 dwo_name of each to match, which is highly unlikely to happen.
823 Doing this means all TUs can share comp_dir: We also assume that
824 DW_AT_comp_dir across all TUs in a DWO file will be identical. */
827 /* Table of TUs in the file.
828 Each element is a struct dwo_unit. */
832 /* These sections are what may appear in a DWP file. */
836 /* These are used by both DWP version 1 and 2. */
837 struct dwarf2_section_info str;
838 struct dwarf2_section_info cu_index;
839 struct dwarf2_section_info tu_index;
841 /* These are only used by DWP version 2 files.
842 In DWP version 1 the .debug_info.dwo, .debug_types.dwo, and other
843 sections are referenced by section number, and are not recorded here.
844 In DWP version 2 there is at most one copy of all these sections, each
845 section being (effectively) comprised of the concatenation of all of the
846 individual sections that exist in the version 1 format.
847 To keep the code simple we treat each of these concatenated pieces as a
848 section itself (a virtual section?). */
849 struct dwarf2_section_info abbrev;
850 struct dwarf2_section_info info;
851 struct dwarf2_section_info line;
852 struct dwarf2_section_info loc;
853 struct dwarf2_section_info macinfo;
854 struct dwarf2_section_info macro;
855 struct dwarf2_section_info str_offsets;
856 struct dwarf2_section_info types;
859 /* These sections are what may appear in a virtual DWO file in DWP version 1.
860 A virtual DWO file is a DWO file as it appears in a DWP file. */
862 struct virtual_v1_dwo_sections
864 struct dwarf2_section_info abbrev;
865 struct dwarf2_section_info line;
866 struct dwarf2_section_info loc;
867 struct dwarf2_section_info macinfo;
868 struct dwarf2_section_info macro;
869 struct dwarf2_section_info str_offsets;
870 /* Each DWP hash table entry records one CU or one TU.
871 That is recorded here, and copied to dwo_unit.section. */
872 struct dwarf2_section_info info_or_types;
875 /* Similar to virtual_v1_dwo_sections, but for DWP version 2.
876 In version 2, the sections of the DWO files are concatenated together
877 and stored in one section of that name. Thus each ELF section contains
878 several "virtual" sections. */
880 struct virtual_v2_dwo_sections
882 bfd_size_type abbrev_offset;
883 bfd_size_type abbrev_size;
885 bfd_size_type line_offset;
886 bfd_size_type line_size;
888 bfd_size_type loc_offset;
889 bfd_size_type loc_size;
891 bfd_size_type macinfo_offset;
892 bfd_size_type macinfo_size;
894 bfd_size_type macro_offset;
895 bfd_size_type macro_size;
897 bfd_size_type str_offsets_offset;
898 bfd_size_type str_offsets_size;
900 /* Each DWP hash table entry records one CU or one TU.
901 That is recorded here, and copied to dwo_unit.section. */
902 bfd_size_type info_or_types_offset;
903 bfd_size_type info_or_types_size;
906 /* Contents of DWP hash tables. */
908 struct dwp_hash_table
910 uint32_t version, nr_columns;
911 uint32_t nr_units, nr_slots;
912 const gdb_byte *hash_table, *unit_table;
917 const gdb_byte *indices;
921 /* This is indexed by column number and gives the id of the section
923 #define MAX_NR_V2_DWO_SECTIONS \
924 (1 /* .debug_info or .debug_types */ \
925 + 1 /* .debug_abbrev */ \
926 + 1 /* .debug_line */ \
927 + 1 /* .debug_loc */ \
928 + 1 /* .debug_str_offsets */ \
929 + 1 /* .debug_macro or .debug_macinfo */)
930 int section_ids[MAX_NR_V2_DWO_SECTIONS];
931 const gdb_byte *offsets;
932 const gdb_byte *sizes;
937 /* Data for one DWP file. */
941 /* Name of the file. */
944 /* File format version. */
950 /* Section info for this file. */
951 struct dwp_sections sections;
953 /* Table of CUs in the file. */
954 const struct dwp_hash_table *cus;
956 /* Table of TUs in the file. */
957 const struct dwp_hash_table *tus;
959 /* Tables of loaded CUs/TUs. Each entry is a struct dwo_unit *. */
963 /* Table to map ELF section numbers to their sections.
964 This is only needed for the DWP V1 file format. */
965 unsigned int num_sections;
966 asection **elf_sections;
969 /* This represents a '.dwz' file. */
973 /* A dwz file can only contain a few sections. */
974 struct dwarf2_section_info abbrev;
975 struct dwarf2_section_info info;
976 struct dwarf2_section_info str;
977 struct dwarf2_section_info line;
978 struct dwarf2_section_info macro;
979 struct dwarf2_section_info gdb_index;
985 /* Struct used to pass misc. parameters to read_die_and_children, et
986 al. which are used for both .debug_info and .debug_types dies.
987 All parameters here are unchanging for the life of the call. This
988 struct exists to abstract away the constant parameters of die reading. */
990 struct die_reader_specs
992 /* The bfd of die_section. */
995 /* The CU of the DIE we are parsing. */
996 struct dwarf2_cu *cu;
998 /* Non-NULL if reading a DWO file (including one packaged into a DWP). */
999 struct dwo_file *dwo_file;
1001 /* The section the die comes from.
1002 This is either .debug_info or .debug_types, or the .dwo variants. */
1003 struct dwarf2_section_info *die_section;
1005 /* die_section->buffer. */
1006 const gdb_byte *buffer;
1008 /* The end of the buffer. */
1009 const gdb_byte *buffer_end;
1011 /* The value of the DW_AT_comp_dir attribute. */
1012 const char *comp_dir;
1015 /* Type of function passed to init_cutu_and_read_dies, et.al. */
1016 typedef void (die_reader_func_ftype) (const struct die_reader_specs *reader,
1017 const gdb_byte *info_ptr,
1018 struct die_info *comp_unit_die,
1022 /* The line number information for a compilation unit (found in the
1023 .debug_line section) begins with a "statement program header",
1024 which contains the following information. */
1027 unsigned int total_length;
1028 unsigned short version;
1029 unsigned int header_length;
1030 unsigned char minimum_instruction_length;
1031 unsigned char maximum_ops_per_instruction;
1032 unsigned char default_is_stmt;
1034 unsigned char line_range;
1035 unsigned char opcode_base;
1037 /* standard_opcode_lengths[i] is the number of operands for the
1038 standard opcode whose value is i. This means that
1039 standard_opcode_lengths[0] is unused, and the last meaningful
1040 element is standard_opcode_lengths[opcode_base - 1]. */
1041 unsigned char *standard_opcode_lengths;
1043 /* The include_directories table. NOTE! These strings are not
1044 allocated with xmalloc; instead, they are pointers into
1045 debug_line_buffer. If you try to free them, `free' will get
1047 unsigned int num_include_dirs, include_dirs_size;
1048 const char **include_dirs;
1050 /* The file_names table. NOTE! These strings are not allocated
1051 with xmalloc; instead, they are pointers into debug_line_buffer.
1052 Don't try to free them directly. */
1053 unsigned int num_file_names, file_names_size;
1057 unsigned int dir_index;
1058 unsigned int mod_time;
1059 unsigned int length;
1060 int included_p; /* Non-zero if referenced by the Line Number Program. */
1061 struct symtab *symtab; /* The associated symbol table, if any. */
1064 /* The start and end of the statement program following this
1065 header. These point into dwarf2_per_objfile->line_buffer. */
1066 const gdb_byte *statement_program_start, *statement_program_end;
1069 /* When we construct a partial symbol table entry we only
1070 need this much information. */
1071 struct partial_die_info
1073 /* Offset of this DIE. */
1076 /* DWARF-2 tag for this DIE. */
1077 ENUM_BITFIELD(dwarf_tag) tag : 16;
1079 /* Assorted flags describing the data found in this DIE. */
1080 unsigned int has_children : 1;
1081 unsigned int is_external : 1;
1082 unsigned int is_declaration : 1;
1083 unsigned int has_type : 1;
1084 unsigned int has_specification : 1;
1085 unsigned int has_pc_info : 1;
1086 unsigned int may_be_inlined : 1;
1088 /* Flag set if the SCOPE field of this structure has been
1090 unsigned int scope_set : 1;
1092 /* Flag set if the DIE has a byte_size attribute. */
1093 unsigned int has_byte_size : 1;
1095 /* Flag set if any of the DIE's children are template arguments. */
1096 unsigned int has_template_arguments : 1;
1098 /* Flag set if fixup_partial_die has been called on this die. */
1099 unsigned int fixup_called : 1;
1101 /* Flag set if DW_TAG_imported_unit uses DW_FORM_GNU_ref_alt. */
1102 unsigned int is_dwz : 1;
1104 /* Flag set if spec_offset uses DW_FORM_GNU_ref_alt. */
1105 unsigned int spec_is_dwz : 1;
1107 /* The name of this DIE. Normally the value of DW_AT_name, but
1108 sometimes a default name for unnamed DIEs. */
1111 /* The linkage name, if present. */
1112 const char *linkage_name;
1114 /* The scope to prepend to our children. This is generally
1115 allocated on the comp_unit_obstack, so will disappear
1116 when this compilation unit leaves the cache. */
1119 /* Some data associated with the partial DIE. The tag determines
1120 which field is live. */
1123 /* The location description associated with this DIE, if any. */
1124 struct dwarf_block *locdesc;
1125 /* The offset of an import, for DW_TAG_imported_unit. */
1129 /* If HAS_PC_INFO, the PC range associated with this DIE. */
1133 /* Pointer into the info_buffer (or types_buffer) pointing at the target of
1134 DW_AT_sibling, if any. */
1135 /* NOTE: This member isn't strictly necessary, read_partial_die could
1136 return DW_AT_sibling values to its caller load_partial_dies. */
1137 const gdb_byte *sibling;
1139 /* If HAS_SPECIFICATION, the offset of the DIE referred to by
1140 DW_AT_specification (or DW_AT_abstract_origin or
1141 DW_AT_extension). */
1142 sect_offset spec_offset;
1144 /* Pointers to this DIE's parent, first child, and next sibling,
1146 struct partial_die_info *die_parent, *die_child, *die_sibling;
1149 /* This data structure holds the information of an abbrev. */
1152 unsigned int number; /* number identifying abbrev */
1153 enum dwarf_tag tag; /* dwarf tag */
1154 unsigned short has_children; /* boolean */
1155 unsigned short num_attrs; /* number of attributes */
1156 struct attr_abbrev *attrs; /* an array of attribute descriptions */
1157 struct abbrev_info *next; /* next in chain */
1162 ENUM_BITFIELD(dwarf_attribute) name : 16;
1163 ENUM_BITFIELD(dwarf_form) form : 16;
1166 /* Size of abbrev_table.abbrev_hash_table. */
1167 #define ABBREV_HASH_SIZE 121
1169 /* Top level data structure to contain an abbreviation table. */
1173 /* Where the abbrev table came from.
1174 This is used as a sanity check when the table is used. */
1177 /* Storage for the abbrev table. */
1178 struct obstack abbrev_obstack;
1180 /* Hash table of abbrevs.
1181 This is an array of size ABBREV_HASH_SIZE allocated in abbrev_obstack.
1182 It could be statically allocated, but the previous code didn't so we
1184 struct abbrev_info **abbrevs;
1187 /* Attributes have a name and a value. */
1190 ENUM_BITFIELD(dwarf_attribute) name : 16;
1191 ENUM_BITFIELD(dwarf_form) form : 15;
1193 /* Has DW_STRING already been updated by dwarf2_canonicalize_name? This
1194 field should be in u.str (existing only for DW_STRING) but it is kept
1195 here for better struct attribute alignment. */
1196 unsigned int string_is_canonical : 1;
1201 struct dwarf_block *blk;
1210 /* This data structure holds a complete die structure. */
1213 /* DWARF-2 tag for this DIE. */
1214 ENUM_BITFIELD(dwarf_tag) tag : 16;
1216 /* Number of attributes */
1217 unsigned char num_attrs;
1219 /* True if we're presently building the full type name for the
1220 type derived from this DIE. */
1221 unsigned char building_fullname : 1;
1223 /* True if this die is in process. PR 16581. */
1224 unsigned char in_process : 1;
1227 unsigned int abbrev;
1229 /* Offset in .debug_info or .debug_types section. */
1232 /* The dies in a compilation unit form an n-ary tree. PARENT
1233 points to this die's parent; CHILD points to the first child of
1234 this node; and all the children of a given node are chained
1235 together via their SIBLING fields. */
1236 struct die_info *child; /* Its first child, if any. */
1237 struct die_info *sibling; /* Its next sibling, if any. */
1238 struct die_info *parent; /* Its parent, if any. */
1240 /* An array of attributes, with NUM_ATTRS elements. There may be
1241 zero, but it's not common and zero-sized arrays are not
1242 sufficiently portable C. */
1243 struct attribute attrs[1];
1246 /* Get at parts of an attribute structure. */
1248 #define DW_STRING(attr) ((attr)->u.str)
1249 #define DW_STRING_IS_CANONICAL(attr) ((attr)->string_is_canonical)
1250 #define DW_UNSND(attr) ((attr)->u.unsnd)
1251 #define DW_BLOCK(attr) ((attr)->u.blk)
1252 #define DW_SND(attr) ((attr)->u.snd)
1253 #define DW_ADDR(attr) ((attr)->u.addr)
1254 #define DW_SIGNATURE(attr) ((attr)->u.signature)
1256 /* Blocks are a bunch of untyped bytes. */
1261 /* Valid only if SIZE is not zero. */
1262 const gdb_byte *data;
1265 #ifndef ATTR_ALLOC_CHUNK
1266 #define ATTR_ALLOC_CHUNK 4
1269 /* Allocate fields for structs, unions and enums in this size. */
1270 #ifndef DW_FIELD_ALLOC_CHUNK
1271 #define DW_FIELD_ALLOC_CHUNK 4
1274 /* FIXME: We might want to set this from BFD via bfd_arch_bits_per_byte,
1275 but this would require a corresponding change in unpack_field_as_long
1277 static int bits_per_byte = 8;
1279 /* The routines that read and process dies for a C struct or C++ class
1280 pass lists of data member fields and lists of member function fields
1281 in an instance of a field_info structure, as defined below. */
1284 /* List of data member and baseclasses fields. */
1287 struct nextfield *next;
1292 *fields, *baseclasses;
1294 /* Number of fields (including baseclasses). */
1297 /* Number of baseclasses. */
1300 /* Set if the accesibility of one of the fields is not public. */
1301 int non_public_fields;
1303 /* Member function fields array, entries are allocated in the order they
1304 are encountered in the object file. */
1307 struct nextfnfield *next;
1308 struct fn_field fnfield;
1312 /* Member function fieldlist array, contains name of possibly overloaded
1313 member function, number of overloaded member functions and a pointer
1314 to the head of the member function field chain. */
1319 struct nextfnfield *head;
1323 /* Number of entries in the fnfieldlists array. */
1326 /* typedefs defined inside this class. TYPEDEF_FIELD_LIST contains head of
1327 a NULL terminated list of TYPEDEF_FIELD_LIST_COUNT elements. */
1328 struct typedef_field_list
1330 struct typedef_field field;
1331 struct typedef_field_list *next;
1333 *typedef_field_list;
1334 unsigned typedef_field_list_count;
1337 /* One item on the queue of compilation units to read in full symbols
1339 struct dwarf2_queue_item
1341 struct dwarf2_per_cu_data *per_cu;
1342 enum language pretend_language;
1343 struct dwarf2_queue_item *next;
1346 /* The current queue. */
1347 static struct dwarf2_queue_item *dwarf2_queue, *dwarf2_queue_tail;
1349 /* Loaded secondary compilation units are kept in memory until they
1350 have not been referenced for the processing of this many
1351 compilation units. Set this to zero to disable caching. Cache
1352 sizes of up to at least twenty will improve startup time for
1353 typical inter-CU-reference binaries, at an obvious memory cost. */
1354 static int dwarf2_max_cache_age = 5;
1356 show_dwarf2_max_cache_age (struct ui_file *file, int from_tty,
1357 struct cmd_list_element *c, const char *value)
1359 fprintf_filtered (file, _("The upper bound on the age of cached "
1360 "dwarf2 compilation units is %s.\n"),
1364 /* local function prototypes */
1366 static const char *get_section_name (const struct dwarf2_section_info *);
1368 static const char *get_section_file_name (const struct dwarf2_section_info *);
1370 static void dwarf2_locate_sections (bfd *, asection *, void *);
1372 static void dwarf2_find_base_address (struct die_info *die,
1373 struct dwarf2_cu *cu);
1375 static struct partial_symtab *create_partial_symtab
1376 (struct dwarf2_per_cu_data *per_cu, const char *name);
1378 static void dwarf2_build_psymtabs_hard (struct objfile *);
1380 static void scan_partial_symbols (struct partial_die_info *,
1381 CORE_ADDR *, CORE_ADDR *,
1382 int, struct dwarf2_cu *);
1384 static void add_partial_symbol (struct partial_die_info *,
1385 struct dwarf2_cu *);
1387 static void add_partial_namespace (struct partial_die_info *pdi,
1388 CORE_ADDR *lowpc, CORE_ADDR *highpc,
1389 int set_addrmap, struct dwarf2_cu *cu);
1391 static void add_partial_module (struct partial_die_info *pdi, CORE_ADDR *lowpc,
1392 CORE_ADDR *highpc, int set_addrmap,
1393 struct dwarf2_cu *cu);
1395 static void add_partial_enumeration (struct partial_die_info *enum_pdi,
1396 struct dwarf2_cu *cu);
1398 static void add_partial_subprogram (struct partial_die_info *pdi,
1399 CORE_ADDR *lowpc, CORE_ADDR *highpc,
1400 int need_pc, struct dwarf2_cu *cu);
1402 static void dwarf2_read_symtab (struct partial_symtab *,
1405 static void psymtab_to_symtab_1 (struct partial_symtab *);
1407 static struct abbrev_info *abbrev_table_lookup_abbrev
1408 (const struct abbrev_table *, unsigned int);
1410 static struct abbrev_table *abbrev_table_read_table
1411 (struct dwarf2_section_info *, sect_offset);
1413 static void abbrev_table_free (struct abbrev_table *);
1415 static void abbrev_table_free_cleanup (void *);
1417 static void dwarf2_read_abbrevs (struct dwarf2_cu *,
1418 struct dwarf2_section_info *);
1420 static void dwarf2_free_abbrev_table (void *);
1422 static unsigned int peek_abbrev_code (bfd *, const gdb_byte *);
1424 static struct partial_die_info *load_partial_dies
1425 (const struct die_reader_specs *, const gdb_byte *, int);
1427 static const gdb_byte *read_partial_die (const struct die_reader_specs *,
1428 struct partial_die_info *,
1429 struct abbrev_info *,
1433 static struct partial_die_info *find_partial_die (sect_offset, int,
1434 struct dwarf2_cu *);
1436 static void fixup_partial_die (struct partial_die_info *,
1437 struct dwarf2_cu *);
1439 static const gdb_byte *read_attribute (const struct die_reader_specs *,
1440 struct attribute *, struct attr_abbrev *,
1443 static unsigned int read_1_byte (bfd *, const gdb_byte *);
1445 static int read_1_signed_byte (bfd *, const gdb_byte *);
1447 static unsigned int read_2_bytes (bfd *, const gdb_byte *);
1449 static unsigned int read_4_bytes (bfd *, const gdb_byte *);
1451 static ULONGEST read_8_bytes (bfd *, const gdb_byte *);
1453 static CORE_ADDR read_address (bfd *, const gdb_byte *ptr, struct dwarf2_cu *,
1456 static LONGEST read_initial_length (bfd *, const gdb_byte *, unsigned int *);
1458 static LONGEST read_checked_initial_length_and_offset
1459 (bfd *, const gdb_byte *, const struct comp_unit_head *,
1460 unsigned int *, unsigned int *);
1462 static LONGEST read_offset (bfd *, const gdb_byte *,
1463 const struct comp_unit_head *,
1466 static LONGEST read_offset_1 (bfd *, const gdb_byte *, unsigned int);
1468 static sect_offset read_abbrev_offset (struct dwarf2_section_info *,
1471 static const gdb_byte *read_n_bytes (bfd *, const gdb_byte *, unsigned int);
1473 static const char *read_direct_string (bfd *, const gdb_byte *, unsigned int *);
1475 static const char *read_indirect_string (bfd *, const gdb_byte *,
1476 const struct comp_unit_head *,
1479 static const char *read_indirect_string_from_dwz (struct dwz_file *, LONGEST);
1481 static ULONGEST read_unsigned_leb128 (bfd *, const gdb_byte *, unsigned int *);
1483 static LONGEST read_signed_leb128 (bfd *, const gdb_byte *, unsigned int *);
1485 static CORE_ADDR read_addr_index_from_leb128 (struct dwarf2_cu *,
1489 static const char *read_str_index (const struct die_reader_specs *reader,
1490 ULONGEST str_index);
1492 static void set_cu_language (unsigned int, struct dwarf2_cu *);
1494 static struct attribute *dwarf2_attr (struct die_info *, unsigned int,
1495 struct dwarf2_cu *);
1497 static struct attribute *dwarf2_attr_no_follow (struct die_info *,
1500 static int dwarf2_flag_true_p (struct die_info *die, unsigned name,
1501 struct dwarf2_cu *cu);
1503 static int die_is_declaration (struct die_info *, struct dwarf2_cu *cu);
1505 static struct die_info *die_specification (struct die_info *die,
1506 struct dwarf2_cu **);
1508 static void free_line_header (struct line_header *lh);
1510 static struct line_header *dwarf_decode_line_header (unsigned int offset,
1511 struct dwarf2_cu *cu);
1513 static void dwarf_decode_lines (struct line_header *, const char *,
1514 struct dwarf2_cu *, struct partial_symtab *,
1517 static void dwarf2_start_subfile (const char *, const char *, const char *);
1519 static void dwarf2_start_symtab (struct dwarf2_cu *,
1520 const char *, const char *, CORE_ADDR);
1522 static struct symbol *new_symbol (struct die_info *, struct type *,
1523 struct dwarf2_cu *);
1525 static struct symbol *new_symbol_full (struct die_info *, struct type *,
1526 struct dwarf2_cu *, struct symbol *);
1528 static void dwarf2_const_value (const struct attribute *, struct symbol *,
1529 struct dwarf2_cu *);
1531 static void dwarf2_const_value_attr (const struct attribute *attr,
1534 struct obstack *obstack,
1535 struct dwarf2_cu *cu, LONGEST *value,
1536 const gdb_byte **bytes,
1537 struct dwarf2_locexpr_baton **baton);
1539 static struct type *die_type (struct die_info *, struct dwarf2_cu *);
1541 static int need_gnat_info (struct dwarf2_cu *);
1543 static struct type *die_descriptive_type (struct die_info *,
1544 struct dwarf2_cu *);
1546 static void set_descriptive_type (struct type *, struct die_info *,
1547 struct dwarf2_cu *);
1549 static struct type *die_containing_type (struct die_info *,
1550 struct dwarf2_cu *);
1552 static struct type *lookup_die_type (struct die_info *, const struct attribute *,
1553 struct dwarf2_cu *);
1555 static struct type *read_type_die (struct die_info *, struct dwarf2_cu *);
1557 static struct type *read_type_die_1 (struct die_info *, struct dwarf2_cu *);
1559 static const char *determine_prefix (struct die_info *die, struct dwarf2_cu *);
1561 static char *typename_concat (struct obstack *obs, const char *prefix,
1562 const char *suffix, int physname,
1563 struct dwarf2_cu *cu);
1565 static void read_file_scope (struct die_info *, struct dwarf2_cu *);
1567 static void read_type_unit_scope (struct die_info *, struct dwarf2_cu *);
1569 static void read_func_scope (struct die_info *, struct dwarf2_cu *);
1571 static void read_lexical_block_scope (struct die_info *, struct dwarf2_cu *);
1573 static void read_call_site_scope (struct die_info *die, struct dwarf2_cu *cu);
1575 static int dwarf2_ranges_read (unsigned, CORE_ADDR *, CORE_ADDR *,
1576 struct dwarf2_cu *, struct partial_symtab *);
1578 static int dwarf2_get_pc_bounds (struct die_info *,
1579 CORE_ADDR *, CORE_ADDR *, struct dwarf2_cu *,
1580 struct partial_symtab *);
1582 static void get_scope_pc_bounds (struct die_info *,
1583 CORE_ADDR *, CORE_ADDR *,
1584 struct dwarf2_cu *);
1586 static void dwarf2_record_block_ranges (struct die_info *, struct block *,
1587 CORE_ADDR, struct dwarf2_cu *);
1589 static void dwarf2_add_field (struct field_info *, struct die_info *,
1590 struct dwarf2_cu *);
1592 static void dwarf2_attach_fields_to_type (struct field_info *,
1593 struct type *, struct dwarf2_cu *);
1595 static void dwarf2_add_member_fn (struct field_info *,
1596 struct die_info *, struct type *,
1597 struct dwarf2_cu *);
1599 static void dwarf2_attach_fn_fields_to_type (struct field_info *,
1601 struct dwarf2_cu *);
1603 static void process_structure_scope (struct die_info *, struct dwarf2_cu *);
1605 static void read_common_block (struct die_info *, struct dwarf2_cu *);
1607 static void read_namespace (struct die_info *die, struct dwarf2_cu *);
1609 static void read_module (struct die_info *die, struct dwarf2_cu *cu);
1611 static void read_import_statement (struct die_info *die, struct dwarf2_cu *);
1613 static int read_namespace_alias (struct die_info *die, struct dwarf2_cu *cu);
1615 static struct type *read_module_type (struct die_info *die,
1616 struct dwarf2_cu *cu);
1618 static const char *namespace_name (struct die_info *die,
1619 int *is_anonymous, struct dwarf2_cu *);
1621 static void process_enumeration_scope (struct die_info *, struct dwarf2_cu *);
1623 static CORE_ADDR decode_locdesc (struct dwarf_block *, struct dwarf2_cu *);
1625 static enum dwarf_array_dim_ordering read_array_order (struct die_info *,
1626 struct dwarf2_cu *);
1628 static struct die_info *read_die_and_siblings_1
1629 (const struct die_reader_specs *, const gdb_byte *, const gdb_byte **,
1632 static struct die_info *read_die_and_siblings (const struct die_reader_specs *,
1633 const gdb_byte *info_ptr,
1634 const gdb_byte **new_info_ptr,
1635 struct die_info *parent);
1637 static const gdb_byte *read_full_die_1 (const struct die_reader_specs *,
1638 struct die_info **, const gdb_byte *,
1641 static const gdb_byte *read_full_die (const struct die_reader_specs *,
1642 struct die_info **, const gdb_byte *,
1645 static void process_die (struct die_info *, struct dwarf2_cu *);
1647 static const char *dwarf2_canonicalize_name (const char *, struct dwarf2_cu *,
1650 static const char *dwarf2_name (struct die_info *die, struct dwarf2_cu *);
1652 static const char *dwarf2_full_name (const char *name,
1653 struct die_info *die,
1654 struct dwarf2_cu *cu);
1656 static const char *dwarf2_physname (const char *name, struct die_info *die,
1657 struct dwarf2_cu *cu);
1659 static struct die_info *dwarf2_extension (struct die_info *die,
1660 struct dwarf2_cu **);
1662 static const char *dwarf_tag_name (unsigned int);
1664 static const char *dwarf_attr_name (unsigned int);
1666 static const char *dwarf_form_name (unsigned int);
1668 static char *dwarf_bool_name (unsigned int);
1670 static const char *dwarf_type_encoding_name (unsigned int);
1672 static struct die_info *sibling_die (struct die_info *);
1674 static void dump_die_shallow (struct ui_file *, int indent, struct die_info *);
1676 static void dump_die_for_error (struct die_info *);
1678 static void dump_die_1 (struct ui_file *, int level, int max_level,
1681 /*static*/ void dump_die (struct die_info *, int max_level);
1683 static void store_in_ref_table (struct die_info *,
1684 struct dwarf2_cu *);
1686 static sect_offset dwarf2_get_ref_die_offset (const struct attribute *);
1688 static LONGEST dwarf2_get_attr_constant_value (const struct attribute *, int);
1690 static struct die_info *follow_die_ref_or_sig (struct die_info *,
1691 const struct attribute *,
1692 struct dwarf2_cu **);
1694 static struct die_info *follow_die_ref (struct die_info *,
1695 const struct attribute *,
1696 struct dwarf2_cu **);
1698 static struct die_info *follow_die_sig (struct die_info *,
1699 const struct attribute *,
1700 struct dwarf2_cu **);
1702 static struct type *get_signatured_type (struct die_info *, ULONGEST,
1703 struct dwarf2_cu *);
1705 static struct type *get_DW_AT_signature_type (struct die_info *,
1706 const struct attribute *,
1707 struct dwarf2_cu *);
1709 static void load_full_type_unit (struct dwarf2_per_cu_data *per_cu);
1711 static void read_signatured_type (struct signatured_type *);
1713 /* memory allocation interface */
1715 static struct dwarf_block *dwarf_alloc_block (struct dwarf2_cu *);
1717 static struct die_info *dwarf_alloc_die (struct dwarf2_cu *, int);
1719 static void dwarf_decode_macros (struct dwarf2_cu *, unsigned int,
1722 static int attr_form_is_block (const struct attribute *);
1724 static int attr_form_is_section_offset (const struct attribute *);
1726 static int attr_form_is_constant (const struct attribute *);
1728 static int attr_form_is_ref (const struct attribute *);
1730 static void fill_in_loclist_baton (struct dwarf2_cu *cu,
1731 struct dwarf2_loclist_baton *baton,
1732 const struct attribute *attr);
1734 static void dwarf2_symbol_mark_computed (const struct attribute *attr,
1736 struct dwarf2_cu *cu,
1739 static const gdb_byte *skip_one_die (const struct die_reader_specs *reader,
1740 const gdb_byte *info_ptr,
1741 struct abbrev_info *abbrev);
1743 static void free_stack_comp_unit (void *);
1745 static hashval_t partial_die_hash (const void *item);
1747 static int partial_die_eq (const void *item_lhs, const void *item_rhs);
1749 static struct dwarf2_per_cu_data *dwarf2_find_containing_comp_unit
1750 (sect_offset offset, unsigned int offset_in_dwz, struct objfile *objfile);
1752 static void init_one_comp_unit (struct dwarf2_cu *cu,
1753 struct dwarf2_per_cu_data *per_cu);
1755 static void prepare_one_comp_unit (struct dwarf2_cu *cu,
1756 struct die_info *comp_unit_die,
1757 enum language pretend_language);
1759 static void free_heap_comp_unit (void *);
1761 static void free_cached_comp_units (void *);
1763 static void age_cached_comp_units (void);
1765 static void free_one_cached_comp_unit (struct dwarf2_per_cu_data *);
1767 static struct type *set_die_type (struct die_info *, struct type *,
1768 struct dwarf2_cu *);
1770 static void create_all_comp_units (struct objfile *);
1772 static int create_all_type_units (struct objfile *);
1774 static void load_full_comp_unit (struct dwarf2_per_cu_data *,
1777 static void process_full_comp_unit (struct dwarf2_per_cu_data *,
1780 static void process_full_type_unit (struct dwarf2_per_cu_data *,
1783 static void dwarf2_add_dependence (struct dwarf2_cu *,
1784 struct dwarf2_per_cu_data *);
1786 static void dwarf2_mark (struct dwarf2_cu *);
1788 static void dwarf2_clear_marks (struct dwarf2_per_cu_data *);
1790 static struct type *get_die_type_at_offset (sect_offset,
1791 struct dwarf2_per_cu_data *);
1793 static struct type *get_die_type (struct die_info *die, struct dwarf2_cu *cu);
1795 static void dwarf2_release_queue (void *dummy);
1797 static void queue_comp_unit (struct dwarf2_per_cu_data *per_cu,
1798 enum language pretend_language);
1800 static void process_queue (void);
1802 static void find_file_and_directory (struct die_info *die,
1803 struct dwarf2_cu *cu,
1804 const char **name, const char **comp_dir);
1806 static char *file_full_name (int file, struct line_header *lh,
1807 const char *comp_dir);
1809 static const gdb_byte *read_and_check_comp_unit_head
1810 (struct comp_unit_head *header,
1811 struct dwarf2_section_info *section,
1812 struct dwarf2_section_info *abbrev_section, const gdb_byte *info_ptr,
1813 int is_debug_types_section);
1815 static void init_cutu_and_read_dies
1816 (struct dwarf2_per_cu_data *this_cu, struct abbrev_table *abbrev_table,
1817 int use_existing_cu, int keep,
1818 die_reader_func_ftype *die_reader_func, void *data);
1820 static void init_cutu_and_read_dies_simple
1821 (struct dwarf2_per_cu_data *this_cu,
1822 die_reader_func_ftype *die_reader_func, void *data);
1824 static htab_t allocate_signatured_type_table (struct objfile *objfile);
1826 static htab_t allocate_dwo_unit_table (struct objfile *objfile);
1828 static struct dwo_unit *lookup_dwo_unit_in_dwp
1829 (struct dwp_file *dwp_file, const char *comp_dir,
1830 ULONGEST signature, int is_debug_types);
1832 static struct dwp_file *get_dwp_file (void);
1834 static struct dwo_unit *lookup_dwo_comp_unit
1835 (struct dwarf2_per_cu_data *, const char *, const char *, ULONGEST);
1837 static struct dwo_unit *lookup_dwo_type_unit
1838 (struct signatured_type *, const char *, const char *);
1840 static void queue_and_load_all_dwo_tus (struct dwarf2_per_cu_data *);
1842 static void free_dwo_file_cleanup (void *);
1844 static void process_cu_includes (void);
1846 static void check_producer (struct dwarf2_cu *cu);
1848 /* Various complaints about symbol reading that don't abort the process. */
1851 dwarf2_statement_list_fits_in_line_number_section_complaint (void)
1853 complaint (&symfile_complaints,
1854 _("statement list doesn't fit in .debug_line section"));
1858 dwarf2_debug_line_missing_file_complaint (void)
1860 complaint (&symfile_complaints,
1861 _(".debug_line section has line data without a file"));
1865 dwarf2_debug_line_missing_end_sequence_complaint (void)
1867 complaint (&symfile_complaints,
1868 _(".debug_line section has line "
1869 "program sequence without an end"));
1873 dwarf2_complex_location_expr_complaint (void)
1875 complaint (&symfile_complaints, _("location expression too complex"));
1879 dwarf2_const_value_length_mismatch_complaint (const char *arg1, int arg2,
1882 complaint (&symfile_complaints,
1883 _("const value length mismatch for '%s', got %d, expected %d"),
1888 dwarf2_section_buffer_overflow_complaint (struct dwarf2_section_info *section)
1890 complaint (&symfile_complaints,
1891 _("debug info runs off end of %s section"
1893 get_section_name (section),
1894 get_section_file_name (section));
1898 dwarf2_macro_malformed_definition_complaint (const char *arg1)
1900 complaint (&symfile_complaints,
1901 _("macro debug info contains a "
1902 "malformed macro definition:\n`%s'"),
1907 dwarf2_invalid_attrib_class_complaint (const char *arg1, const char *arg2)
1909 complaint (&symfile_complaints,
1910 _("invalid attribute class or form for '%s' in '%s'"),
1916 /* Convert VALUE between big- and little-endian. */
1918 byte_swap (offset_type value)
1922 result = (value & 0xff) << 24;
1923 result |= (value & 0xff00) << 8;
1924 result |= (value & 0xff0000) >> 8;
1925 result |= (value & 0xff000000) >> 24;
1929 #define MAYBE_SWAP(V) byte_swap (V)
1932 #define MAYBE_SWAP(V) (V)
1933 #endif /* WORDS_BIGENDIAN */
1935 /* Read the given attribute value as an address, taking the attribute's
1936 form into account. */
1939 attr_value_as_address (struct attribute *attr)
1943 if (attr->form != DW_FORM_addr && attr->form != DW_FORM_GNU_addr_index)
1945 /* Aside from a few clearly defined exceptions, attributes that
1946 contain an address must always be in DW_FORM_addr form.
1947 Unfortunately, some compilers happen to be violating this
1948 requirement by encoding addresses using other forms, such
1949 as DW_FORM_data4 for example. For those broken compilers,
1950 we try to do our best, without any guarantee of success,
1951 to interpret the address correctly. It would also be nice
1952 to generate a complaint, but that would require us to maintain
1953 a list of legitimate cases where a non-address form is allowed,
1954 as well as update callers to pass in at least the CU's DWARF
1955 version. This is more overhead than what we're willing to
1956 expand for a pretty rare case. */
1957 addr = DW_UNSND (attr);
1960 addr = DW_ADDR (attr);
1965 /* The suffix for an index file. */
1966 #define INDEX_SUFFIX ".gdb-index"
1968 /* Try to locate the sections we need for DWARF 2 debugging
1969 information and return true if we have enough to do something.
1970 NAMES points to the dwarf2 section names, or is NULL if the standard
1971 ELF names are used. */
1974 dwarf2_has_info (struct objfile *objfile,
1975 const struct dwarf2_debug_sections *names)
1977 dwarf2_per_objfile = objfile_data (objfile, dwarf2_objfile_data_key);
1978 if (!dwarf2_per_objfile)
1980 /* Initialize per-objfile state. */
1981 struct dwarf2_per_objfile *data
1982 = obstack_alloc (&objfile->objfile_obstack, sizeof (*data));
1984 memset (data, 0, sizeof (*data));
1985 set_objfile_data (objfile, dwarf2_objfile_data_key, data);
1986 dwarf2_per_objfile = data;
1988 bfd_map_over_sections (objfile->obfd, dwarf2_locate_sections,
1990 dwarf2_per_objfile->objfile = objfile;
1992 return (!dwarf2_per_objfile->info.is_virtual
1993 && dwarf2_per_objfile->info.s.asection != NULL
1994 && !dwarf2_per_objfile->abbrev.is_virtual
1995 && dwarf2_per_objfile->abbrev.s.asection != NULL);
1998 /* Return the containing section of virtual section SECTION. */
2000 static struct dwarf2_section_info *
2001 get_containing_section (const struct dwarf2_section_info *section)
2003 gdb_assert (section->is_virtual);
2004 return section->s.containing_section;
2007 /* Return the bfd owner of SECTION. */
2010 get_section_bfd_owner (const struct dwarf2_section_info *section)
2012 if (section->is_virtual)
2014 section = get_containing_section (section);
2015 gdb_assert (!section->is_virtual);
2017 return section->s.asection->owner;
2020 /* Return the bfd section of SECTION.
2021 Returns NULL if the section is not present. */
2024 get_section_bfd_section (const struct dwarf2_section_info *section)
2026 if (section->is_virtual)
2028 section = get_containing_section (section);
2029 gdb_assert (!section->is_virtual);
2031 return section->s.asection;
2034 /* Return the name of SECTION. */
2037 get_section_name (const struct dwarf2_section_info *section)
2039 asection *sectp = get_section_bfd_section (section);
2041 gdb_assert (sectp != NULL);
2042 return bfd_section_name (get_section_bfd_owner (section), sectp);
2045 /* Return the name of the file SECTION is in. */
2048 get_section_file_name (const struct dwarf2_section_info *section)
2050 bfd *abfd = get_section_bfd_owner (section);
2052 return bfd_get_filename (abfd);
2055 /* Return the id of SECTION.
2056 Returns 0 if SECTION doesn't exist. */
2059 get_section_id (const struct dwarf2_section_info *section)
2061 asection *sectp = get_section_bfd_section (section);
2068 /* Return the flags of SECTION.
2069 SECTION (or containing section if this is a virtual section) must exist. */
2072 get_section_flags (const struct dwarf2_section_info *section)
2074 asection *sectp = get_section_bfd_section (section);
2076 gdb_assert (sectp != NULL);
2077 return bfd_get_section_flags (sectp->owner, sectp);
2080 /* When loading sections, we look either for uncompressed section or for
2081 compressed section names. */
2084 section_is_p (const char *section_name,
2085 const struct dwarf2_section_names *names)
2087 if (names->normal != NULL
2088 && strcmp (section_name, names->normal) == 0)
2090 if (names->compressed != NULL
2091 && strcmp (section_name, names->compressed) == 0)
2096 /* This function is mapped across the sections and remembers the
2097 offset and size of each of the debugging sections we are interested
2101 dwarf2_locate_sections (bfd *abfd, asection *sectp, void *vnames)
2103 const struct dwarf2_debug_sections *names;
2104 flagword aflag = bfd_get_section_flags (abfd, sectp);
2107 names = &dwarf2_elf_names;
2109 names = (const struct dwarf2_debug_sections *) vnames;
2111 if ((aflag & SEC_HAS_CONTENTS) == 0)
2114 else if (section_is_p (sectp->name, &names->info))
2116 dwarf2_per_objfile->info.s.asection = sectp;
2117 dwarf2_per_objfile->info.size = bfd_get_section_size (sectp);
2119 else if (section_is_p (sectp->name, &names->abbrev))
2121 dwarf2_per_objfile->abbrev.s.asection = sectp;
2122 dwarf2_per_objfile->abbrev.size = bfd_get_section_size (sectp);
2124 else if (section_is_p (sectp->name, &names->line))
2126 dwarf2_per_objfile->line.s.asection = sectp;
2127 dwarf2_per_objfile->line.size = bfd_get_section_size (sectp);
2129 else if (section_is_p (sectp->name, &names->loc))
2131 dwarf2_per_objfile->loc.s.asection = sectp;
2132 dwarf2_per_objfile->loc.size = bfd_get_section_size (sectp);
2134 else if (section_is_p (sectp->name, &names->macinfo))
2136 dwarf2_per_objfile->macinfo.s.asection = sectp;
2137 dwarf2_per_objfile->macinfo.size = bfd_get_section_size (sectp);
2139 else if (section_is_p (sectp->name, &names->macro))
2141 dwarf2_per_objfile->macro.s.asection = sectp;
2142 dwarf2_per_objfile->macro.size = bfd_get_section_size (sectp);
2144 else if (section_is_p (sectp->name, &names->str))
2146 dwarf2_per_objfile->str.s.asection = sectp;
2147 dwarf2_per_objfile->str.size = bfd_get_section_size (sectp);
2149 else if (section_is_p (sectp->name, &names->addr))
2151 dwarf2_per_objfile->addr.s.asection = sectp;
2152 dwarf2_per_objfile->addr.size = bfd_get_section_size (sectp);
2154 else if (section_is_p (sectp->name, &names->frame))
2156 dwarf2_per_objfile->frame.s.asection = sectp;
2157 dwarf2_per_objfile->frame.size = bfd_get_section_size (sectp);
2159 else if (section_is_p (sectp->name, &names->eh_frame))
2161 dwarf2_per_objfile->eh_frame.s.asection = sectp;
2162 dwarf2_per_objfile->eh_frame.size = bfd_get_section_size (sectp);
2164 else if (section_is_p (sectp->name, &names->ranges))
2166 dwarf2_per_objfile->ranges.s.asection = sectp;
2167 dwarf2_per_objfile->ranges.size = bfd_get_section_size (sectp);
2169 else if (section_is_p (sectp->name, &names->types))
2171 struct dwarf2_section_info type_section;
2173 memset (&type_section, 0, sizeof (type_section));
2174 type_section.s.asection = sectp;
2175 type_section.size = bfd_get_section_size (sectp);
2177 VEC_safe_push (dwarf2_section_info_def, dwarf2_per_objfile->types,
2180 else if (section_is_p (sectp->name, &names->gdb_index))
2182 dwarf2_per_objfile->gdb_index.s.asection = sectp;
2183 dwarf2_per_objfile->gdb_index.size = bfd_get_section_size (sectp);
2186 if ((bfd_get_section_flags (abfd, sectp) & SEC_LOAD)
2187 && bfd_section_vma (abfd, sectp) == 0)
2188 dwarf2_per_objfile->has_section_at_zero = 1;
2191 /* A helper function that decides whether a section is empty,
2195 dwarf2_section_empty_p (const struct dwarf2_section_info *section)
2197 if (section->is_virtual)
2198 return section->size == 0;
2199 return section->s.asection == NULL || section->size == 0;
2202 /* Read the contents of the section INFO.
2203 OBJFILE is the main object file, but not necessarily the file where
2204 the section comes from. E.g., for DWO files the bfd of INFO is the bfd
2206 If the section is compressed, uncompress it before returning. */
2209 dwarf2_read_section (struct objfile *objfile, struct dwarf2_section_info *info)
2213 gdb_byte *buf, *retbuf;
2217 info->buffer = NULL;
2220 if (dwarf2_section_empty_p (info))
2223 sectp = get_section_bfd_section (info);
2225 /* If this is a virtual section we need to read in the real one first. */
2226 if (info->is_virtual)
2228 struct dwarf2_section_info *containing_section =
2229 get_containing_section (info);
2231 gdb_assert (sectp != NULL);
2232 if ((sectp->flags & SEC_RELOC) != 0)
2234 error (_("Dwarf Error: DWP format V2 with relocations is not"
2235 " supported in section %s [in module %s]"),
2236 get_section_name (info), get_section_file_name (info));
2238 dwarf2_read_section (objfile, containing_section);
2239 /* Other code should have already caught virtual sections that don't
2241 gdb_assert (info->virtual_offset + info->size
2242 <= containing_section->size);
2243 /* If the real section is empty or there was a problem reading the
2244 section we shouldn't get here. */
2245 gdb_assert (containing_section->buffer != NULL);
2246 info->buffer = containing_section->buffer + info->virtual_offset;
2250 /* If the section has relocations, we must read it ourselves.
2251 Otherwise we attach it to the BFD. */
2252 if ((sectp->flags & SEC_RELOC) == 0)
2254 info->buffer = gdb_bfd_map_section (sectp, &info->size);
2258 buf = obstack_alloc (&objfile->objfile_obstack, info->size);
2261 /* When debugging .o files, we may need to apply relocations; see
2262 http://sourceware.org/ml/gdb-patches/2002-04/msg00136.html .
2263 We never compress sections in .o files, so we only need to
2264 try this when the section is not compressed. */
2265 retbuf = symfile_relocate_debug_section (objfile, sectp, buf);
2268 info->buffer = retbuf;
2272 abfd = get_section_bfd_owner (info);
2273 gdb_assert (abfd != NULL);
2275 if (bfd_seek (abfd, sectp->filepos, SEEK_SET) != 0
2276 || bfd_bread (buf, info->size, abfd) != info->size)
2278 error (_("Dwarf Error: Can't read DWARF data"
2279 " in section %s [in module %s]"),
2280 bfd_section_name (abfd, sectp), bfd_get_filename (abfd));
2284 /* A helper function that returns the size of a section in a safe way.
2285 If you are positive that the section has been read before using the
2286 size, then it is safe to refer to the dwarf2_section_info object's
2287 "size" field directly. In other cases, you must call this
2288 function, because for compressed sections the size field is not set
2289 correctly until the section has been read. */
2291 static bfd_size_type
2292 dwarf2_section_size (struct objfile *objfile,
2293 struct dwarf2_section_info *info)
2296 dwarf2_read_section (objfile, info);
2300 /* Fill in SECTP, BUFP and SIZEP with section info, given OBJFILE and
2304 dwarf2_get_section_info (struct objfile *objfile,
2305 enum dwarf2_section_enum sect,
2306 asection **sectp, const gdb_byte **bufp,
2307 bfd_size_type *sizep)
2309 struct dwarf2_per_objfile *data
2310 = objfile_data (objfile, dwarf2_objfile_data_key);
2311 struct dwarf2_section_info *info;
2313 /* We may see an objfile without any DWARF, in which case we just
2324 case DWARF2_DEBUG_FRAME:
2325 info = &data->frame;
2327 case DWARF2_EH_FRAME:
2328 info = &data->eh_frame;
2331 gdb_assert_not_reached ("unexpected section");
2334 dwarf2_read_section (objfile, info);
2336 *sectp = get_section_bfd_section (info);
2337 *bufp = info->buffer;
2338 *sizep = info->size;
2341 /* A helper function to find the sections for a .dwz file. */
2344 locate_dwz_sections (bfd *abfd, asection *sectp, void *arg)
2346 struct dwz_file *dwz_file = arg;
2348 /* Note that we only support the standard ELF names, because .dwz
2349 is ELF-only (at the time of writing). */
2350 if (section_is_p (sectp->name, &dwarf2_elf_names.abbrev))
2352 dwz_file->abbrev.s.asection = sectp;
2353 dwz_file->abbrev.size = bfd_get_section_size (sectp);
2355 else if (section_is_p (sectp->name, &dwarf2_elf_names.info))
2357 dwz_file->info.s.asection = sectp;
2358 dwz_file->info.size = bfd_get_section_size (sectp);
2360 else if (section_is_p (sectp->name, &dwarf2_elf_names.str))
2362 dwz_file->str.s.asection = sectp;
2363 dwz_file->str.size = bfd_get_section_size (sectp);
2365 else if (section_is_p (sectp->name, &dwarf2_elf_names.line))
2367 dwz_file->line.s.asection = sectp;
2368 dwz_file->line.size = bfd_get_section_size (sectp);
2370 else if (section_is_p (sectp->name, &dwarf2_elf_names.macro))
2372 dwz_file->macro.s.asection = sectp;
2373 dwz_file->macro.size = bfd_get_section_size (sectp);
2375 else if (section_is_p (sectp->name, &dwarf2_elf_names.gdb_index))
2377 dwz_file->gdb_index.s.asection = sectp;
2378 dwz_file->gdb_index.size = bfd_get_section_size (sectp);
2382 /* Open the separate '.dwz' debug file, if needed. Return NULL if
2383 there is no .gnu_debugaltlink section in the file. Error if there
2384 is such a section but the file cannot be found. */
2386 static struct dwz_file *
2387 dwarf2_get_dwz_file (void)
2391 struct cleanup *cleanup;
2392 const char *filename;
2393 struct dwz_file *result;
2394 bfd_size_type buildid_len_arg;
2398 if (dwarf2_per_objfile->dwz_file != NULL)
2399 return dwarf2_per_objfile->dwz_file;
2401 bfd_set_error (bfd_error_no_error);
2402 data = bfd_get_alt_debug_link_info (dwarf2_per_objfile->objfile->obfd,
2403 &buildid_len_arg, &buildid);
2406 if (bfd_get_error () == bfd_error_no_error)
2408 error (_("could not read '.gnu_debugaltlink' section: %s"),
2409 bfd_errmsg (bfd_get_error ()));
2411 cleanup = make_cleanup (xfree, data);
2412 make_cleanup (xfree, buildid);
2414 buildid_len = (size_t) buildid_len_arg;
2416 filename = (const char *) data;
2417 if (!IS_ABSOLUTE_PATH (filename))
2419 char *abs = gdb_realpath (objfile_name (dwarf2_per_objfile->objfile));
2422 make_cleanup (xfree, abs);
2423 abs = ldirname (abs);
2424 make_cleanup (xfree, abs);
2426 rel = concat (abs, SLASH_STRING, filename, (char *) NULL);
2427 make_cleanup (xfree, rel);
2431 /* First try the file name given in the section. If that doesn't
2432 work, try to use the build-id instead. */
2433 dwz_bfd = gdb_bfd_open (filename, gnutarget, -1);
2434 if (dwz_bfd != NULL)
2436 if (!build_id_verify (dwz_bfd, buildid_len, buildid))
2438 gdb_bfd_unref (dwz_bfd);
2443 if (dwz_bfd == NULL)
2444 dwz_bfd = build_id_to_debug_bfd (buildid_len, buildid);
2446 if (dwz_bfd == NULL)
2447 error (_("could not find '.gnu_debugaltlink' file for %s"),
2448 objfile_name (dwarf2_per_objfile->objfile));
2450 result = OBSTACK_ZALLOC (&dwarf2_per_objfile->objfile->objfile_obstack,
2452 result->dwz_bfd = dwz_bfd;
2454 bfd_map_over_sections (dwz_bfd, locate_dwz_sections, result);
2456 do_cleanups (cleanup);
2458 gdb_bfd_record_inclusion (dwarf2_per_objfile->objfile->obfd, dwz_bfd);
2459 dwarf2_per_objfile->dwz_file = result;
2463 /* DWARF quick_symbols_functions support. */
2465 /* TUs can share .debug_line entries, and there can be a lot more TUs than
2466 unique line tables, so we maintain a separate table of all .debug_line
2467 derived entries to support the sharing.
2468 All the quick functions need is the list of file names. We discard the
2469 line_header when we're done and don't need to record it here. */
2470 struct quick_file_names
2472 /* The data used to construct the hash key. */
2473 struct stmt_list_hash hash;
2475 /* The number of entries in file_names, real_names. */
2476 unsigned int num_file_names;
2478 /* The file names from the line table, after being run through
2480 const char **file_names;
2482 /* The file names from the line table after being run through
2483 gdb_realpath. These are computed lazily. */
2484 const char **real_names;
2487 /* When using the index (and thus not using psymtabs), each CU has an
2488 object of this type. This is used to hold information needed by
2489 the various "quick" methods. */
2490 struct dwarf2_per_cu_quick_data
2492 /* The file table. This can be NULL if there was no file table
2493 or it's currently not read in.
2494 NOTE: This points into dwarf2_per_objfile->quick_file_names_table. */
2495 struct quick_file_names *file_names;
2497 /* The corresponding symbol table. This is NULL if symbols for this
2498 CU have not yet been read. */
2499 struct symtab *symtab;
2501 /* A temporary mark bit used when iterating over all CUs in
2502 expand_symtabs_matching. */
2503 unsigned int mark : 1;
2505 /* True if we've tried to read the file table and found there isn't one.
2506 There will be no point in trying to read it again next time. */
2507 unsigned int no_file_data : 1;
2510 /* Utility hash function for a stmt_list_hash. */
2513 hash_stmt_list_entry (const struct stmt_list_hash *stmt_list_hash)
2517 if (stmt_list_hash->dwo_unit != NULL)
2518 v += (uintptr_t) stmt_list_hash->dwo_unit->dwo_file;
2519 v += stmt_list_hash->line_offset.sect_off;
2523 /* Utility equality function for a stmt_list_hash. */
2526 eq_stmt_list_entry (const struct stmt_list_hash *lhs,
2527 const struct stmt_list_hash *rhs)
2529 if ((lhs->dwo_unit != NULL) != (rhs->dwo_unit != NULL))
2531 if (lhs->dwo_unit != NULL
2532 && lhs->dwo_unit->dwo_file != rhs->dwo_unit->dwo_file)
2535 return lhs->line_offset.sect_off == rhs->line_offset.sect_off;
2538 /* Hash function for a quick_file_names. */
2541 hash_file_name_entry (const void *e)
2543 const struct quick_file_names *file_data = e;
2545 return hash_stmt_list_entry (&file_data->hash);
2548 /* Equality function for a quick_file_names. */
2551 eq_file_name_entry (const void *a, const void *b)
2553 const struct quick_file_names *ea = a;
2554 const struct quick_file_names *eb = b;
2556 return eq_stmt_list_entry (&ea->hash, &eb->hash);
2559 /* Delete function for a quick_file_names. */
2562 delete_file_name_entry (void *e)
2564 struct quick_file_names *file_data = e;
2567 for (i = 0; i < file_data->num_file_names; ++i)
2569 xfree ((void*) file_data->file_names[i]);
2570 if (file_data->real_names)
2571 xfree ((void*) file_data->real_names[i]);
2574 /* The space for the struct itself lives on objfile_obstack,
2575 so we don't free it here. */
2578 /* Create a quick_file_names hash table. */
2581 create_quick_file_names_table (unsigned int nr_initial_entries)
2583 return htab_create_alloc (nr_initial_entries,
2584 hash_file_name_entry, eq_file_name_entry,
2585 delete_file_name_entry, xcalloc, xfree);
2588 /* Read in PER_CU->CU. This function is unrelated to symtabs, symtab would
2589 have to be created afterwards. You should call age_cached_comp_units after
2590 processing PER_CU->CU. dw2_setup must have been already called. */
2593 load_cu (struct dwarf2_per_cu_data *per_cu)
2595 if (per_cu->is_debug_types)
2596 load_full_type_unit (per_cu);
2598 load_full_comp_unit (per_cu, language_minimal);
2600 gdb_assert (per_cu->cu != NULL);
2602 dwarf2_find_base_address (per_cu->cu->dies, per_cu->cu);
2605 /* Read in the symbols for PER_CU. */
2608 dw2_do_instantiate_symtab (struct dwarf2_per_cu_data *per_cu)
2610 struct cleanup *back_to;
2612 /* Skip type_unit_groups, reading the type units they contain
2613 is handled elsewhere. */
2614 if (IS_TYPE_UNIT_GROUP (per_cu))
2617 back_to = make_cleanup (dwarf2_release_queue, NULL);
2619 if (dwarf2_per_objfile->using_index
2620 ? per_cu->v.quick->symtab == NULL
2621 : (per_cu->v.psymtab == NULL || !per_cu->v.psymtab->readin))
2623 queue_comp_unit (per_cu, language_minimal);
2626 /* If we just loaded a CU from a DWO, and we're working with an index
2627 that may badly handle TUs, load all the TUs in that DWO as well.
2628 http://sourceware.org/bugzilla/show_bug.cgi?id=15021 */
2629 if (!per_cu->is_debug_types
2630 && per_cu->cu->dwo_unit != NULL
2631 && dwarf2_per_objfile->index_table != NULL
2632 && dwarf2_per_objfile->index_table->version <= 7
2633 /* DWP files aren't supported yet. */
2634 && get_dwp_file () == NULL)
2635 queue_and_load_all_dwo_tus (per_cu);
2640 /* Age the cache, releasing compilation units that have not
2641 been used recently. */
2642 age_cached_comp_units ();
2644 do_cleanups (back_to);
2647 /* Ensure that the symbols for PER_CU have been read in. OBJFILE is
2648 the objfile from which this CU came. Returns the resulting symbol
2651 static struct symtab *
2652 dw2_instantiate_symtab (struct dwarf2_per_cu_data *per_cu)
2654 gdb_assert (dwarf2_per_objfile->using_index);
2655 if (!per_cu->v.quick->symtab)
2657 struct cleanup *back_to = make_cleanup (free_cached_comp_units, NULL);
2658 increment_reading_symtab ();
2659 dw2_do_instantiate_symtab (per_cu);
2660 process_cu_includes ();
2661 do_cleanups (back_to);
2663 return per_cu->v.quick->symtab;
2666 /* Return the CU/TU given its index.
2668 This is intended for loops like:
2670 for (i = 0; i < (dwarf2_per_objfile->n_comp_units
2671 + dwarf2_per_objfile->n_type_units); ++i)
2673 struct dwarf2_per_cu_data *per_cu = dw2_get_cutu (i);
2679 static struct dwarf2_per_cu_data *
2680 dw2_get_cutu (int index)
2682 if (index >= dwarf2_per_objfile->n_comp_units)
2684 index -= dwarf2_per_objfile->n_comp_units;
2685 gdb_assert (index < dwarf2_per_objfile->n_type_units);
2686 return &dwarf2_per_objfile->all_type_units[index]->per_cu;
2689 return dwarf2_per_objfile->all_comp_units[index];
2692 /* Return the CU given its index.
2693 This differs from dw2_get_cutu in that it's for when you know INDEX
2696 static struct dwarf2_per_cu_data *
2697 dw2_get_cu (int index)
2699 gdb_assert (index >= 0 && index < dwarf2_per_objfile->n_comp_units);
2701 return dwarf2_per_objfile->all_comp_units[index];
2704 /* A helper for create_cus_from_index that handles a given list of
2708 create_cus_from_index_list (struct objfile *objfile,
2709 const gdb_byte *cu_list, offset_type n_elements,
2710 struct dwarf2_section_info *section,
2716 for (i = 0; i < n_elements; i += 2)
2718 struct dwarf2_per_cu_data *the_cu;
2719 ULONGEST offset, length;
2721 gdb_static_assert (sizeof (ULONGEST) >= 8);
2722 offset = extract_unsigned_integer (cu_list, 8, BFD_ENDIAN_LITTLE);
2723 length = extract_unsigned_integer (cu_list + 8, 8, BFD_ENDIAN_LITTLE);
2726 the_cu = OBSTACK_ZALLOC (&objfile->objfile_obstack,
2727 struct dwarf2_per_cu_data);
2728 the_cu->offset.sect_off = offset;
2729 the_cu->length = length;
2730 the_cu->objfile = objfile;
2731 the_cu->section = section;
2732 the_cu->v.quick = OBSTACK_ZALLOC (&objfile->objfile_obstack,
2733 struct dwarf2_per_cu_quick_data);
2734 the_cu->is_dwz = is_dwz;
2735 dwarf2_per_objfile->all_comp_units[base_offset + i / 2] = the_cu;
2739 /* Read the CU list from the mapped index, and use it to create all
2740 the CU objects for this objfile. */
2743 create_cus_from_index (struct objfile *objfile,
2744 const gdb_byte *cu_list, offset_type cu_list_elements,
2745 const gdb_byte *dwz_list, offset_type dwz_elements)
2747 struct dwz_file *dwz;
2749 dwarf2_per_objfile->n_comp_units = (cu_list_elements + dwz_elements) / 2;
2750 dwarf2_per_objfile->all_comp_units
2751 = obstack_alloc (&objfile->objfile_obstack,
2752 dwarf2_per_objfile->n_comp_units
2753 * sizeof (struct dwarf2_per_cu_data *));
2755 create_cus_from_index_list (objfile, cu_list, cu_list_elements,
2756 &dwarf2_per_objfile->info, 0, 0);
2758 if (dwz_elements == 0)
2761 dwz = dwarf2_get_dwz_file ();
2762 create_cus_from_index_list (objfile, dwz_list, dwz_elements, &dwz->info, 1,
2763 cu_list_elements / 2);
2766 /* Create the signatured type hash table from the index. */
2769 create_signatured_type_table_from_index (struct objfile *objfile,
2770 struct dwarf2_section_info *section,
2771 const gdb_byte *bytes,
2772 offset_type elements)
2775 htab_t sig_types_hash;
2777 dwarf2_per_objfile->n_type_units
2778 = dwarf2_per_objfile->n_allocated_type_units
2780 dwarf2_per_objfile->all_type_units
2781 = xmalloc (dwarf2_per_objfile->n_type_units
2782 * sizeof (struct signatured_type *));
2784 sig_types_hash = allocate_signatured_type_table (objfile);
2786 for (i = 0; i < elements; i += 3)
2788 struct signatured_type *sig_type;
2789 ULONGEST offset, type_offset_in_tu, signature;
2792 gdb_static_assert (sizeof (ULONGEST) >= 8);
2793 offset = extract_unsigned_integer (bytes, 8, BFD_ENDIAN_LITTLE);
2794 type_offset_in_tu = extract_unsigned_integer (bytes + 8, 8,
2796 signature = extract_unsigned_integer (bytes + 16, 8, BFD_ENDIAN_LITTLE);
2799 sig_type = OBSTACK_ZALLOC (&objfile->objfile_obstack,
2800 struct signatured_type);
2801 sig_type->signature = signature;
2802 sig_type->type_offset_in_tu.cu_off = type_offset_in_tu;
2803 sig_type->per_cu.is_debug_types = 1;
2804 sig_type->per_cu.section = section;
2805 sig_type->per_cu.offset.sect_off = offset;
2806 sig_type->per_cu.objfile = objfile;
2807 sig_type->per_cu.v.quick
2808 = OBSTACK_ZALLOC (&objfile->objfile_obstack,
2809 struct dwarf2_per_cu_quick_data);
2811 slot = htab_find_slot (sig_types_hash, sig_type, INSERT);
2814 dwarf2_per_objfile->all_type_units[i / 3] = sig_type;
2817 dwarf2_per_objfile->signatured_types = sig_types_hash;
2820 /* Read the address map data from the mapped index, and use it to
2821 populate the objfile's psymtabs_addrmap. */
2824 create_addrmap_from_index (struct objfile *objfile, struct mapped_index *index)
2826 const gdb_byte *iter, *end;
2827 struct obstack temp_obstack;
2828 struct addrmap *mutable_map;
2829 struct cleanup *cleanup;
2832 obstack_init (&temp_obstack);
2833 cleanup = make_cleanup_obstack_free (&temp_obstack);
2834 mutable_map = addrmap_create_mutable (&temp_obstack);
2836 iter = index->address_table;
2837 end = iter + index->address_table_size;
2839 baseaddr = ANOFFSET (objfile->section_offsets, SECT_OFF_TEXT (objfile));
2843 ULONGEST hi, lo, cu_index;
2844 lo = extract_unsigned_integer (iter, 8, BFD_ENDIAN_LITTLE);
2846 hi = extract_unsigned_integer (iter, 8, BFD_ENDIAN_LITTLE);
2848 cu_index = extract_unsigned_integer (iter, 4, BFD_ENDIAN_LITTLE);
2853 complaint (&symfile_complaints,
2854 _(".gdb_index address table has invalid range (%s - %s)"),
2855 hex_string (lo), hex_string (hi));
2859 if (cu_index >= dwarf2_per_objfile->n_comp_units)
2861 complaint (&symfile_complaints,
2862 _(".gdb_index address table has invalid CU number %u"),
2863 (unsigned) cu_index);
2867 addrmap_set_empty (mutable_map, lo + baseaddr, hi + baseaddr - 1,
2868 dw2_get_cutu (cu_index));
2871 objfile->psymtabs_addrmap = addrmap_create_fixed (mutable_map,
2872 &objfile->objfile_obstack);
2873 do_cleanups (cleanup);
2876 /* The hash function for strings in the mapped index. This is the same as
2877 SYMBOL_HASH_NEXT, but we keep a separate copy to maintain control over the
2878 implementation. This is necessary because the hash function is tied to the
2879 format of the mapped index file. The hash values do not have to match with
2882 Use INT_MAX for INDEX_VERSION if you generate the current index format. */
2885 mapped_index_string_hash (int index_version, const void *p)
2887 const unsigned char *str = (const unsigned char *) p;
2891 while ((c = *str++) != 0)
2893 if (index_version >= 5)
2895 r = r * 67 + c - 113;
2901 /* Find a slot in the mapped index INDEX for the object named NAME.
2902 If NAME is found, set *VEC_OUT to point to the CU vector in the
2903 constant pool and return 1. If NAME cannot be found, return 0. */
2906 find_slot_in_mapped_hash (struct mapped_index *index, const char *name,
2907 offset_type **vec_out)
2909 struct cleanup *back_to = make_cleanup (null_cleanup, 0);
2911 offset_type slot, step;
2912 int (*cmp) (const char *, const char *);
2914 if (current_language->la_language == language_cplus
2915 || current_language->la_language == language_java
2916 || current_language->la_language == language_fortran)
2918 /* NAME is already canonical. Drop any qualifiers as .gdb_index does
2920 const char *paren = strchr (name, '(');
2926 dup = xmalloc (paren - name + 1);
2927 memcpy (dup, name, paren - name);
2928 dup[paren - name] = 0;
2930 make_cleanup (xfree, dup);
2935 /* Index version 4 did not support case insensitive searches. But the
2936 indices for case insensitive languages are built in lowercase, therefore
2937 simulate our NAME being searched is also lowercased. */
2938 hash = mapped_index_string_hash ((index->version == 4
2939 && case_sensitivity == case_sensitive_off
2940 ? 5 : index->version),
2943 slot = hash & (index->symbol_table_slots - 1);
2944 step = ((hash * 17) & (index->symbol_table_slots - 1)) | 1;
2945 cmp = (case_sensitivity == case_sensitive_on ? strcmp : strcasecmp);
2949 /* Convert a slot number to an offset into the table. */
2950 offset_type i = 2 * slot;
2952 if (index->symbol_table[i] == 0 && index->symbol_table[i + 1] == 0)
2954 do_cleanups (back_to);
2958 str = index->constant_pool + MAYBE_SWAP (index->symbol_table[i]);
2959 if (!cmp (name, str))
2961 *vec_out = (offset_type *) (index->constant_pool
2962 + MAYBE_SWAP (index->symbol_table[i + 1]));
2963 do_cleanups (back_to);
2967 slot = (slot + step) & (index->symbol_table_slots - 1);
2971 /* A helper function that reads the .gdb_index from SECTION and fills
2972 in MAP. FILENAME is the name of the file containing the section;
2973 it is used for error reporting. DEPRECATED_OK is nonzero if it is
2974 ok to use deprecated sections.
2976 CU_LIST, CU_LIST_ELEMENTS, TYPES_LIST, and TYPES_LIST_ELEMENTS are
2977 out parameters that are filled in with information about the CU and
2978 TU lists in the section.
2980 Returns 1 if all went well, 0 otherwise. */
2983 read_index_from_section (struct objfile *objfile,
2984 const char *filename,
2986 struct dwarf2_section_info *section,
2987 struct mapped_index *map,
2988 const gdb_byte **cu_list,
2989 offset_type *cu_list_elements,
2990 const gdb_byte **types_list,
2991 offset_type *types_list_elements)
2993 const gdb_byte *addr;
2994 offset_type version;
2995 offset_type *metadata;
2998 if (dwarf2_section_empty_p (section))
3001 /* Older elfutils strip versions could keep the section in the main
3002 executable while splitting it for the separate debug info file. */
3003 if ((get_section_flags (section) & SEC_HAS_CONTENTS) == 0)
3006 dwarf2_read_section (objfile, section);
3008 addr = section->buffer;
3009 /* Version check. */
3010 version = MAYBE_SWAP (*(offset_type *) addr);
3011 /* Versions earlier than 3 emitted every copy of a psymbol. This
3012 causes the index to behave very poorly for certain requests. Version 3
3013 contained incomplete addrmap. So, it seems better to just ignore such
3017 static int warning_printed = 0;
3018 if (!warning_printed)
3020 warning (_("Skipping obsolete .gdb_index section in %s."),
3022 warning_printed = 1;
3026 /* Index version 4 uses a different hash function than index version
3029 Versions earlier than 6 did not emit psymbols for inlined
3030 functions. Using these files will cause GDB not to be able to
3031 set breakpoints on inlined functions by name, so we ignore these
3032 indices unless the user has done
3033 "set use-deprecated-index-sections on". */
3034 if (version < 6 && !deprecated_ok)
3036 static int warning_printed = 0;
3037 if (!warning_printed)
3040 Skipping deprecated .gdb_index section in %s.\n\
3041 Do \"set use-deprecated-index-sections on\" before the file is read\n\
3042 to use the section anyway."),
3044 warning_printed = 1;
3048 /* Version 7 indices generated by gold refer to the CU for a symbol instead
3049 of the TU (for symbols coming from TUs),
3050 http://sourceware.org/bugzilla/show_bug.cgi?id=15021.
3051 Plus gold-generated indices can have duplicate entries for global symbols,
3052 http://sourceware.org/bugzilla/show_bug.cgi?id=15646.
3053 These are just performance bugs, and we can't distinguish gdb-generated
3054 indices from gold-generated ones, so issue no warning here. */
3056 /* Indexes with higher version than the one supported by GDB may be no
3057 longer backward compatible. */
3061 map->version = version;
3062 map->total_size = section->size;
3064 metadata = (offset_type *) (addr + sizeof (offset_type));
3067 *cu_list = addr + MAYBE_SWAP (metadata[i]);
3068 *cu_list_elements = ((MAYBE_SWAP (metadata[i + 1]) - MAYBE_SWAP (metadata[i]))
3072 *types_list = addr + MAYBE_SWAP (metadata[i]);
3073 *types_list_elements = ((MAYBE_SWAP (metadata[i + 1])
3074 - MAYBE_SWAP (metadata[i]))
3078 map->address_table = addr + MAYBE_SWAP (metadata[i]);
3079 map->address_table_size = (MAYBE_SWAP (metadata[i + 1])
3080 - MAYBE_SWAP (metadata[i]));
3083 map->symbol_table = (offset_type *) (addr + MAYBE_SWAP (metadata[i]));
3084 map->symbol_table_slots = ((MAYBE_SWAP (metadata[i + 1])
3085 - MAYBE_SWAP (metadata[i]))
3086 / (2 * sizeof (offset_type)));
3089 map->constant_pool = (char *) (addr + MAYBE_SWAP (metadata[i]));
3095 /* Read the index file. If everything went ok, initialize the "quick"
3096 elements of all the CUs and return 1. Otherwise, return 0. */
3099 dwarf2_read_index (struct objfile *objfile)
3101 struct mapped_index local_map, *map;
3102 const gdb_byte *cu_list, *types_list, *dwz_list = NULL;
3103 offset_type cu_list_elements, types_list_elements, dwz_list_elements = 0;
3104 struct dwz_file *dwz;
3106 if (!read_index_from_section (objfile, objfile_name (objfile),
3107 use_deprecated_index_sections,
3108 &dwarf2_per_objfile->gdb_index, &local_map,
3109 &cu_list, &cu_list_elements,
3110 &types_list, &types_list_elements))
3113 /* Don't use the index if it's empty. */
3114 if (local_map.symbol_table_slots == 0)
3117 /* If there is a .dwz file, read it so we can get its CU list as
3119 dwz = dwarf2_get_dwz_file ();
3122 struct mapped_index dwz_map;
3123 const gdb_byte *dwz_types_ignore;
3124 offset_type dwz_types_elements_ignore;
3126 if (!read_index_from_section (objfile, bfd_get_filename (dwz->dwz_bfd),
3128 &dwz->gdb_index, &dwz_map,
3129 &dwz_list, &dwz_list_elements,
3131 &dwz_types_elements_ignore))
3133 warning (_("could not read '.gdb_index' section from %s; skipping"),
3134 bfd_get_filename (dwz->dwz_bfd));
3139 create_cus_from_index (objfile, cu_list, cu_list_elements, dwz_list,
3142 if (types_list_elements)
3144 struct dwarf2_section_info *section;
3146 /* We can only handle a single .debug_types when we have an
3148 if (VEC_length (dwarf2_section_info_def, dwarf2_per_objfile->types) != 1)
3151 section = VEC_index (dwarf2_section_info_def,
3152 dwarf2_per_objfile->types, 0);
3154 create_signatured_type_table_from_index (objfile, section, types_list,
3155 types_list_elements);
3158 create_addrmap_from_index (objfile, &local_map);
3160 map = obstack_alloc (&objfile->objfile_obstack, sizeof (struct mapped_index));
3163 dwarf2_per_objfile->index_table = map;
3164 dwarf2_per_objfile->using_index = 1;
3165 dwarf2_per_objfile->quick_file_names_table =
3166 create_quick_file_names_table (dwarf2_per_objfile->n_comp_units);
3171 /* A helper for the "quick" functions which sets the global
3172 dwarf2_per_objfile according to OBJFILE. */
3175 dw2_setup (struct objfile *objfile)
3177 dwarf2_per_objfile = objfile_data (objfile, dwarf2_objfile_data_key);
3178 gdb_assert (dwarf2_per_objfile);
3181 /* die_reader_func for dw2_get_file_names. */
3184 dw2_get_file_names_reader (const struct die_reader_specs *reader,
3185 const gdb_byte *info_ptr,
3186 struct die_info *comp_unit_die,
3190 struct dwarf2_cu *cu = reader->cu;
3191 struct dwarf2_per_cu_data *this_cu = cu->per_cu;
3192 struct objfile *objfile = dwarf2_per_objfile->objfile;
3193 struct dwarf2_per_cu_data *lh_cu;
3194 struct line_header *lh;
3195 struct attribute *attr;
3197 const char *name, *comp_dir;
3199 struct quick_file_names *qfn;
3200 unsigned int line_offset;
3202 gdb_assert (! this_cu->is_debug_types);
3204 /* Our callers never want to match partial units -- instead they
3205 will match the enclosing full CU. */
3206 if (comp_unit_die->tag == DW_TAG_partial_unit)
3208 this_cu->v.quick->no_file_data = 1;
3217 attr = dwarf2_attr (comp_unit_die, DW_AT_stmt_list, cu);
3220 struct quick_file_names find_entry;
3222 line_offset = DW_UNSND (attr);
3224 /* We may have already read in this line header (TU line header sharing).
3225 If we have we're done. */
3226 find_entry.hash.dwo_unit = cu->dwo_unit;
3227 find_entry.hash.line_offset.sect_off = line_offset;
3228 slot = htab_find_slot (dwarf2_per_objfile->quick_file_names_table,
3229 &find_entry, INSERT);
3232 lh_cu->v.quick->file_names = *slot;
3236 lh = dwarf_decode_line_header (line_offset, cu);
3240 lh_cu->v.quick->no_file_data = 1;
3244 qfn = obstack_alloc (&objfile->objfile_obstack, sizeof (*qfn));
3245 qfn->hash.dwo_unit = cu->dwo_unit;
3246 qfn->hash.line_offset.sect_off = line_offset;
3247 gdb_assert (slot != NULL);
3250 find_file_and_directory (comp_unit_die, cu, &name, &comp_dir);
3252 qfn->num_file_names = lh->num_file_names;
3253 qfn->file_names = obstack_alloc (&objfile->objfile_obstack,
3254 lh->num_file_names * sizeof (char *));
3255 for (i = 0; i < lh->num_file_names; ++i)
3256 qfn->file_names[i] = file_full_name (i + 1, lh, comp_dir);
3257 qfn->real_names = NULL;
3259 free_line_header (lh);
3261 lh_cu->v.quick->file_names = qfn;
3264 /* A helper for the "quick" functions which attempts to read the line
3265 table for THIS_CU. */
3267 static struct quick_file_names *
3268 dw2_get_file_names (struct dwarf2_per_cu_data *this_cu)
3270 /* This should never be called for TUs. */
3271 gdb_assert (! this_cu->is_debug_types);
3272 /* Nor type unit groups. */
3273 gdb_assert (! IS_TYPE_UNIT_GROUP (this_cu));
3275 if (this_cu->v.quick->file_names != NULL)
3276 return this_cu->v.quick->file_names;
3277 /* If we know there is no line data, no point in looking again. */
3278 if (this_cu->v.quick->no_file_data)
3281 init_cutu_and_read_dies_simple (this_cu, dw2_get_file_names_reader, NULL);
3283 if (this_cu->v.quick->no_file_data)
3285 return this_cu->v.quick->file_names;
3288 /* A helper for the "quick" functions which computes and caches the
3289 real path for a given file name from the line table. */
3292 dw2_get_real_path (struct objfile *objfile,
3293 struct quick_file_names *qfn, int index)
3295 if (qfn->real_names == NULL)
3296 qfn->real_names = OBSTACK_CALLOC (&objfile->objfile_obstack,
3297 qfn->num_file_names, const char *);
3299 if (qfn->real_names[index] == NULL)
3300 qfn->real_names[index] = gdb_realpath (qfn->file_names[index]);
3302 return qfn->real_names[index];
3305 static struct symtab *
3306 dw2_find_last_source_symtab (struct objfile *objfile)
3310 dw2_setup (objfile);
3311 index = dwarf2_per_objfile->n_comp_units - 1;
3312 return dw2_instantiate_symtab (dw2_get_cutu (index));
3315 /* Traversal function for dw2_forget_cached_source_info. */
3318 dw2_free_cached_file_names (void **slot, void *info)
3320 struct quick_file_names *file_data = (struct quick_file_names *) *slot;
3322 if (file_data->real_names)
3326 for (i = 0; i < file_data->num_file_names; ++i)
3328 xfree ((void*) file_data->real_names[i]);
3329 file_data->real_names[i] = NULL;
3337 dw2_forget_cached_source_info (struct objfile *objfile)
3339 dw2_setup (objfile);
3341 htab_traverse_noresize (dwarf2_per_objfile->quick_file_names_table,
3342 dw2_free_cached_file_names, NULL);
3345 /* Helper function for dw2_map_symtabs_matching_filename that expands
3346 the symtabs and calls the iterator. */
3349 dw2_map_expand_apply (struct objfile *objfile,
3350 struct dwarf2_per_cu_data *per_cu,
3351 const char *name, const char *real_path,
3352 int (*callback) (struct symtab *, void *),
3355 struct symtab *last_made = objfile->symtabs;
3357 /* Don't visit already-expanded CUs. */
3358 if (per_cu->v.quick->symtab)
3361 /* This may expand more than one symtab, and we want to iterate over
3363 dw2_instantiate_symtab (per_cu);
3365 return iterate_over_some_symtabs (name, real_path, callback, data,
3366 objfile->symtabs, last_made);
3369 /* Implementation of the map_symtabs_matching_filename method. */
3372 dw2_map_symtabs_matching_filename (struct objfile *objfile, const char *name,
3373 const char *real_path,
3374 int (*callback) (struct symtab *, void *),
3378 const char *name_basename = lbasename (name);
3380 dw2_setup (objfile);
3382 /* The rule is CUs specify all the files, including those used by
3383 any TU, so there's no need to scan TUs here. */
3385 for (i = 0; i < dwarf2_per_objfile->n_comp_units; ++i)
3388 struct dwarf2_per_cu_data *per_cu = dw2_get_cu (i);
3389 struct quick_file_names *file_data;
3391 /* We only need to look at symtabs not already expanded. */
3392 if (per_cu->v.quick->symtab)
3395 file_data = dw2_get_file_names (per_cu);
3396 if (file_data == NULL)
3399 for (j = 0; j < file_data->num_file_names; ++j)
3401 const char *this_name = file_data->file_names[j];
3402 const char *this_real_name;
3404 if (compare_filenames_for_search (this_name, name))
3406 if (dw2_map_expand_apply (objfile, per_cu, name, real_path,
3412 /* Before we invoke realpath, which can get expensive when many
3413 files are involved, do a quick comparison of the basenames. */
3414 if (! basenames_may_differ
3415 && FILENAME_CMP (lbasename (this_name), name_basename) != 0)
3418 this_real_name = dw2_get_real_path (objfile, file_data, j);
3419 if (compare_filenames_for_search (this_real_name, name))
3421 if (dw2_map_expand_apply (objfile, per_cu, name, real_path,
3427 if (real_path != NULL)
3429 gdb_assert (IS_ABSOLUTE_PATH (real_path));
3430 gdb_assert (IS_ABSOLUTE_PATH (name));
3431 if (this_real_name != NULL
3432 && FILENAME_CMP (real_path, this_real_name) == 0)
3434 if (dw2_map_expand_apply (objfile, per_cu, name, real_path,
3446 /* Struct used to manage iterating over all CUs looking for a symbol. */
3448 struct dw2_symtab_iterator
3450 /* The internalized form of .gdb_index. */
3451 struct mapped_index *index;
3452 /* If non-zero, only look for symbols that match BLOCK_INDEX. */
3453 int want_specific_block;
3454 /* One of GLOBAL_BLOCK or STATIC_BLOCK.
3455 Unused if !WANT_SPECIFIC_BLOCK. */
3457 /* The kind of symbol we're looking for. */
3459 /* The list of CUs from the index entry of the symbol,
3460 or NULL if not found. */
3462 /* The next element in VEC to look at. */
3464 /* The number of elements in VEC, or zero if there is no match. */
3466 /* Have we seen a global version of the symbol?
3467 If so we can ignore all further global instances.
3468 This is to work around gold/15646, inefficient gold-generated
3473 /* Initialize the index symtab iterator ITER.
3474 If WANT_SPECIFIC_BLOCK is non-zero, only look for symbols
3475 in block BLOCK_INDEX. Otherwise BLOCK_INDEX is ignored. */
3478 dw2_symtab_iter_init (struct dw2_symtab_iterator *iter,
3479 struct mapped_index *index,
3480 int want_specific_block,
3485 iter->index = index;
3486 iter->want_specific_block = want_specific_block;
3487 iter->block_index = block_index;
3488 iter->domain = domain;
3490 iter->global_seen = 0;
3492 if (find_slot_in_mapped_hash (index, name, &iter->vec))
3493 iter->length = MAYBE_SWAP (*iter->vec);
3501 /* Return the next matching CU or NULL if there are no more. */
3503 static struct dwarf2_per_cu_data *
3504 dw2_symtab_iter_next (struct dw2_symtab_iterator *iter)
3506 for ( ; iter->next < iter->length; ++iter->next)
3508 offset_type cu_index_and_attrs =
3509 MAYBE_SWAP (iter->vec[iter->next + 1]);
3510 offset_type cu_index = GDB_INDEX_CU_VALUE (cu_index_and_attrs);
3511 struct dwarf2_per_cu_data *per_cu;
3512 int want_static = iter->block_index != GLOBAL_BLOCK;
3513 /* This value is only valid for index versions >= 7. */
3514 int is_static = GDB_INDEX_SYMBOL_STATIC_VALUE (cu_index_and_attrs);
3515 gdb_index_symbol_kind symbol_kind =
3516 GDB_INDEX_SYMBOL_KIND_VALUE (cu_index_and_attrs);
3517 /* Only check the symbol attributes if they're present.
3518 Indices prior to version 7 don't record them,
3519 and indices >= 7 may elide them for certain symbols
3520 (gold does this). */
3522 (iter->index->version >= 7
3523 && symbol_kind != GDB_INDEX_SYMBOL_KIND_NONE);
3525 /* Don't crash on bad data. */
3526 if (cu_index >= (dwarf2_per_objfile->n_comp_units
3527 + dwarf2_per_objfile->n_type_units))
3529 complaint (&symfile_complaints,
3530 _(".gdb_index entry has bad CU index"
3532 objfile_name (dwarf2_per_objfile->objfile));
3536 per_cu = dw2_get_cutu (cu_index);
3538 /* Skip if already read in. */
3539 if (per_cu->v.quick->symtab)
3542 /* Check static vs global. */
3545 if (iter->want_specific_block
3546 && want_static != is_static)
3548 /* Work around gold/15646. */
3549 if (!is_static && iter->global_seen)
3552 iter->global_seen = 1;
3555 /* Only check the symbol's kind if it has one. */
3558 switch (iter->domain)
3561 if (symbol_kind != GDB_INDEX_SYMBOL_KIND_VARIABLE
3562 && symbol_kind != GDB_INDEX_SYMBOL_KIND_FUNCTION
3563 /* Some types are also in VAR_DOMAIN. */
3564 && symbol_kind != GDB_INDEX_SYMBOL_KIND_TYPE)
3568 if (symbol_kind != GDB_INDEX_SYMBOL_KIND_TYPE)
3572 if (symbol_kind != GDB_INDEX_SYMBOL_KIND_OTHER)
3587 static struct symtab *
3588 dw2_lookup_symbol (struct objfile *objfile, int block_index,
3589 const char *name, domain_enum domain)
3591 struct symtab *stab_best = NULL;
3592 struct mapped_index *index;
3594 dw2_setup (objfile);
3596 index = dwarf2_per_objfile->index_table;
3598 /* index is NULL if OBJF_READNOW. */
3601 struct dw2_symtab_iterator iter;
3602 struct dwarf2_per_cu_data *per_cu;
3604 dw2_symtab_iter_init (&iter, index, 1, block_index, domain, name);
3606 while ((per_cu = dw2_symtab_iter_next (&iter)) != NULL)
3608 struct symbol *sym = NULL;
3609 struct symtab *stab = dw2_instantiate_symtab (per_cu);
3611 /* Some caution must be observed with overloaded functions
3612 and methods, since the index will not contain any overload
3613 information (but NAME might contain it). */
3616 const struct blockvector *bv = BLOCKVECTOR (stab);
3617 struct block *block = BLOCKVECTOR_BLOCK (bv, block_index);
3619 sym = lookup_block_symbol (block, name, domain);
3622 if (sym && strcmp_iw (SYMBOL_SEARCH_NAME (sym), name) == 0)
3624 if (!TYPE_IS_OPAQUE (SYMBOL_TYPE (sym)))
3630 /* Keep looking through other CUs. */
3638 dw2_print_stats (struct objfile *objfile)
3640 int i, total, count;
3642 dw2_setup (objfile);
3643 total = dwarf2_per_objfile->n_comp_units + dwarf2_per_objfile->n_type_units;
3645 for (i = 0; i < total; ++i)
3647 struct dwarf2_per_cu_data *per_cu = dw2_get_cutu (i);
3649 if (!per_cu->v.quick->symtab)
3652 printf_filtered (_(" Number of read CUs: %d\n"), total - count);
3653 printf_filtered (_(" Number of unread CUs: %d\n"), count);
3656 /* This dumps minimal information about the index.
3657 It is called via "mt print objfiles".
3658 One use is to verify .gdb_index has been loaded by the
3659 gdb.dwarf2/gdb-index.exp testcase. */
3662 dw2_dump (struct objfile *objfile)
3664 dw2_setup (objfile);
3665 gdb_assert (dwarf2_per_objfile->using_index);
3666 printf_filtered (".gdb_index:");
3667 if (dwarf2_per_objfile->index_table != NULL)
3669 printf_filtered (" version %d\n",
3670 dwarf2_per_objfile->index_table->version);
3673 printf_filtered (" faked for \"readnow\"\n");
3674 printf_filtered ("\n");
3678 dw2_relocate (struct objfile *objfile,
3679 const struct section_offsets *new_offsets,
3680 const struct section_offsets *delta)
3682 /* There's nothing to relocate here. */
3686 dw2_expand_symtabs_for_function (struct objfile *objfile,
3687 const char *func_name)
3689 struct mapped_index *index;
3691 dw2_setup (objfile);
3693 index = dwarf2_per_objfile->index_table;
3695 /* index is NULL if OBJF_READNOW. */
3698 struct dw2_symtab_iterator iter;
3699 struct dwarf2_per_cu_data *per_cu;
3701 /* Note: It doesn't matter what we pass for block_index here. */
3702 dw2_symtab_iter_init (&iter, index, 0, GLOBAL_BLOCK, VAR_DOMAIN,
3705 while ((per_cu = dw2_symtab_iter_next (&iter)) != NULL)
3706 dw2_instantiate_symtab (per_cu);
3711 dw2_expand_all_symtabs (struct objfile *objfile)
3715 dw2_setup (objfile);
3717 for (i = 0; i < (dwarf2_per_objfile->n_comp_units
3718 + dwarf2_per_objfile->n_type_units); ++i)
3720 struct dwarf2_per_cu_data *per_cu = dw2_get_cutu (i);
3722 dw2_instantiate_symtab (per_cu);
3727 dw2_expand_symtabs_with_fullname (struct objfile *objfile,
3728 const char *fullname)
3732 dw2_setup (objfile);
3734 /* We don't need to consider type units here.
3735 This is only called for examining code, e.g. expand_line_sal.
3736 There can be an order of magnitude (or more) more type units
3737 than comp units, and we avoid them if we can. */
3739 for (i = 0; i < dwarf2_per_objfile->n_comp_units; ++i)
3742 struct dwarf2_per_cu_data *per_cu = dw2_get_cutu (i);
3743 struct quick_file_names *file_data;
3745 /* We only need to look at symtabs not already expanded. */
3746 if (per_cu->v.quick->symtab)
3749 file_data = dw2_get_file_names (per_cu);
3750 if (file_data == NULL)
3753 for (j = 0; j < file_data->num_file_names; ++j)
3755 const char *this_fullname = file_data->file_names[j];
3757 if (filename_cmp (this_fullname, fullname) == 0)
3759 dw2_instantiate_symtab (per_cu);
3767 dw2_map_matching_symbols (struct objfile *objfile,
3768 const char * name, domain_enum namespace,
3770 int (*callback) (struct block *,
3771 struct symbol *, void *),
3772 void *data, symbol_compare_ftype *match,
3773 symbol_compare_ftype *ordered_compare)
3775 /* Currently unimplemented; used for Ada. The function can be called if the
3776 current language is Ada for a non-Ada objfile using GNU index. As Ada
3777 does not look for non-Ada symbols this function should just return. */
3781 dw2_expand_symtabs_matching
3782 (struct objfile *objfile,
3783 expand_symtabs_file_matcher_ftype *file_matcher,
3784 expand_symtabs_symbol_matcher_ftype *symbol_matcher,
3785 enum search_domain kind,
3790 struct mapped_index *index;
3792 dw2_setup (objfile);
3794 /* index_table is NULL if OBJF_READNOW. */
3795 if (!dwarf2_per_objfile->index_table)
3797 index = dwarf2_per_objfile->index_table;
3799 if (file_matcher != NULL)
3801 struct cleanup *cleanup;
3802 htab_t visited_found, visited_not_found;
3804 visited_found = htab_create_alloc (10,
3805 htab_hash_pointer, htab_eq_pointer,
3806 NULL, xcalloc, xfree);
3807 cleanup = make_cleanup_htab_delete (visited_found);
3808 visited_not_found = htab_create_alloc (10,
3809 htab_hash_pointer, htab_eq_pointer,
3810 NULL, xcalloc, xfree);
3811 make_cleanup_htab_delete (visited_not_found);
3813 /* The rule is CUs specify all the files, including those used by
3814 any TU, so there's no need to scan TUs here. */
3816 for (i = 0; i < dwarf2_per_objfile->n_comp_units; ++i)
3819 struct dwarf2_per_cu_data *per_cu = dw2_get_cu (i);
3820 struct quick_file_names *file_data;
3823 per_cu->v.quick->mark = 0;
3825 /* We only need to look at symtabs not already expanded. */
3826 if (per_cu->v.quick->symtab)
3829 file_data = dw2_get_file_names (per_cu);
3830 if (file_data == NULL)
3833 if (htab_find (visited_not_found, file_data) != NULL)
3835 else if (htab_find (visited_found, file_data) != NULL)
3837 per_cu->v.quick->mark = 1;
3841 for (j = 0; j < file_data->num_file_names; ++j)
3843 const char *this_real_name;
3845 if (file_matcher (file_data->file_names[j], data, 0))
3847 per_cu->v.quick->mark = 1;
3851 /* Before we invoke realpath, which can get expensive when many
3852 files are involved, do a quick comparison of the basenames. */
3853 if (!basenames_may_differ
3854 && !file_matcher (lbasename (file_data->file_names[j]),
3858 this_real_name = dw2_get_real_path (objfile, file_data, j);
3859 if (file_matcher (this_real_name, data, 0))
3861 per_cu->v.quick->mark = 1;
3866 slot = htab_find_slot (per_cu->v.quick->mark
3868 : visited_not_found,
3873 do_cleanups (cleanup);
3876 for (iter = 0; iter < index->symbol_table_slots; ++iter)
3878 offset_type idx = 2 * iter;
3880 offset_type *vec, vec_len, vec_idx;
3881 int global_seen = 0;
3883 if (index->symbol_table[idx] == 0 && index->symbol_table[idx + 1] == 0)
3886 name = index->constant_pool + MAYBE_SWAP (index->symbol_table[idx]);
3888 if (! (*symbol_matcher) (name, data))
3891 /* The name was matched, now expand corresponding CUs that were
3893 vec = (offset_type *) (index->constant_pool
3894 + MAYBE_SWAP (index->symbol_table[idx + 1]));
3895 vec_len = MAYBE_SWAP (vec[0]);
3896 for (vec_idx = 0; vec_idx < vec_len; ++vec_idx)
3898 struct dwarf2_per_cu_data *per_cu;
3899 offset_type cu_index_and_attrs = MAYBE_SWAP (vec[vec_idx + 1]);
3900 /* This value is only valid for index versions >= 7. */
3901 int is_static = GDB_INDEX_SYMBOL_STATIC_VALUE (cu_index_and_attrs);
3902 gdb_index_symbol_kind symbol_kind =
3903 GDB_INDEX_SYMBOL_KIND_VALUE (cu_index_and_attrs);
3904 int cu_index = GDB_INDEX_CU_VALUE (cu_index_and_attrs);
3905 /* Only check the symbol attributes if they're present.
3906 Indices prior to version 7 don't record them,
3907 and indices >= 7 may elide them for certain symbols
3908 (gold does this). */
3910 (index->version >= 7
3911 && symbol_kind != GDB_INDEX_SYMBOL_KIND_NONE);
3913 /* Work around gold/15646. */
3916 if (!is_static && global_seen)
3922 /* Only check the symbol's kind if it has one. */
3927 case VARIABLES_DOMAIN:
3928 if (symbol_kind != GDB_INDEX_SYMBOL_KIND_VARIABLE)
3931 case FUNCTIONS_DOMAIN:
3932 if (symbol_kind != GDB_INDEX_SYMBOL_KIND_FUNCTION)
3936 if (symbol_kind != GDB_INDEX_SYMBOL_KIND_TYPE)
3944 /* Don't crash on bad data. */
3945 if (cu_index >= (dwarf2_per_objfile->n_comp_units
3946 + dwarf2_per_objfile->n_type_units))
3948 complaint (&symfile_complaints,
3949 _(".gdb_index entry has bad CU index"
3950 " [in module %s]"), objfile_name (objfile));
3954 per_cu = dw2_get_cutu (cu_index);
3955 if (file_matcher == NULL || per_cu->v.quick->mark)
3956 dw2_instantiate_symtab (per_cu);
3961 /* A helper for dw2_find_pc_sect_symtab which finds the most specific
3964 static struct symtab *
3965 recursively_find_pc_sect_symtab (struct symtab *symtab, CORE_ADDR pc)
3969 if (BLOCKVECTOR (symtab) != NULL
3970 && blockvector_contains_pc (BLOCKVECTOR (symtab), pc))
3973 if (symtab->includes == NULL)
3976 for (i = 0; symtab->includes[i]; ++i)
3978 struct symtab *s = symtab->includes[i];
3980 s = recursively_find_pc_sect_symtab (s, pc);
3988 static struct symtab *
3989 dw2_find_pc_sect_symtab (struct objfile *objfile,
3990 struct bound_minimal_symbol msymbol,
3992 struct obj_section *section,
3995 struct dwarf2_per_cu_data *data;
3996 struct symtab *result;
3998 dw2_setup (objfile);
4000 if (!objfile->psymtabs_addrmap)
4003 data = addrmap_find (objfile->psymtabs_addrmap, pc);
4007 if (warn_if_readin && data->v.quick->symtab)
4008 warning (_("(Internal error: pc %s in read in CU, but not in symtab.)"),
4009 paddress (get_objfile_arch (objfile), pc));
4011 result = recursively_find_pc_sect_symtab (dw2_instantiate_symtab (data), pc);
4012 gdb_assert (result != NULL);
4017 dw2_map_symbol_filenames (struct objfile *objfile, symbol_filename_ftype *fun,
4018 void *data, int need_fullname)
4021 struct cleanup *cleanup;
4022 htab_t visited = htab_create_alloc (10, htab_hash_pointer, htab_eq_pointer,
4023 NULL, xcalloc, xfree);
4025 cleanup = make_cleanup_htab_delete (visited);
4026 dw2_setup (objfile);
4028 /* The rule is CUs specify all the files, including those used by
4029 any TU, so there's no need to scan TUs here.
4030 We can ignore file names coming from already-expanded CUs. */
4032 for (i = 0; i < dwarf2_per_objfile->n_comp_units; ++i)
4034 struct dwarf2_per_cu_data *per_cu = dw2_get_cutu (i);
4036 if (per_cu->v.quick->symtab)
4038 void **slot = htab_find_slot (visited, per_cu->v.quick->file_names,
4041 *slot = per_cu->v.quick->file_names;
4045 for (i = 0; i < dwarf2_per_objfile->n_comp_units; ++i)
4048 struct dwarf2_per_cu_data *per_cu = dw2_get_cu (i);
4049 struct quick_file_names *file_data;
4052 /* We only need to look at symtabs not already expanded. */
4053 if (per_cu->v.quick->symtab)
4056 file_data = dw2_get_file_names (per_cu);
4057 if (file_data == NULL)
4060 slot = htab_find_slot (visited, file_data, INSERT);
4063 /* Already visited. */
4068 for (j = 0; j < file_data->num_file_names; ++j)
4070 const char *this_real_name;
4073 this_real_name = dw2_get_real_path (objfile, file_data, j);
4075 this_real_name = NULL;
4076 (*fun) (file_data->file_names[j], this_real_name, data);
4080 do_cleanups (cleanup);
4084 dw2_has_symbols (struct objfile *objfile)
4089 const struct quick_symbol_functions dwarf2_gdb_index_functions =
4092 dw2_find_last_source_symtab,
4093 dw2_forget_cached_source_info,
4094 dw2_map_symtabs_matching_filename,
4099 dw2_expand_symtabs_for_function,
4100 dw2_expand_all_symtabs,
4101 dw2_expand_symtabs_with_fullname,
4102 dw2_map_matching_symbols,
4103 dw2_expand_symtabs_matching,
4104 dw2_find_pc_sect_symtab,
4105 dw2_map_symbol_filenames
4108 /* Initialize for reading DWARF for this objfile. Return 0 if this
4109 file will use psymtabs, or 1 if using the GNU index. */
4112 dwarf2_initialize_objfile (struct objfile *objfile)
4114 /* If we're about to read full symbols, don't bother with the
4115 indices. In this case we also don't care if some other debug
4116 format is making psymtabs, because they are all about to be
4118 if ((objfile->flags & OBJF_READNOW))
4122 dwarf2_per_objfile->using_index = 1;
4123 create_all_comp_units (objfile);
4124 create_all_type_units (objfile);
4125 dwarf2_per_objfile->quick_file_names_table =
4126 create_quick_file_names_table (dwarf2_per_objfile->n_comp_units);
4128 for (i = 0; i < (dwarf2_per_objfile->n_comp_units
4129 + dwarf2_per_objfile->n_type_units); ++i)
4131 struct dwarf2_per_cu_data *per_cu = dw2_get_cutu (i);
4133 per_cu->v.quick = OBSTACK_ZALLOC (&objfile->objfile_obstack,
4134 struct dwarf2_per_cu_quick_data);
4137 /* Return 1 so that gdb sees the "quick" functions. However,
4138 these functions will be no-ops because we will have expanded
4143 if (dwarf2_read_index (objfile))
4151 /* Build a partial symbol table. */
4154 dwarf2_build_psymtabs (struct objfile *objfile)
4156 volatile struct gdb_exception except;
4158 if (objfile->global_psymbols.size == 0 && objfile->static_psymbols.size == 0)
4160 init_psymbol_list (objfile, 1024);
4163 TRY_CATCH (except, RETURN_MASK_ERROR)
4165 /* This isn't really ideal: all the data we allocate on the
4166 objfile's obstack is still uselessly kept around. However,
4167 freeing it seems unsafe. */
4168 struct cleanup *cleanups = make_cleanup_discard_psymtabs (objfile);
4170 dwarf2_build_psymtabs_hard (objfile);
4171 discard_cleanups (cleanups);
4173 if (except.reason < 0)
4174 exception_print (gdb_stderr, except);
4177 /* Return the total length of the CU described by HEADER. */
4180 get_cu_length (const struct comp_unit_head *header)
4182 return header->initial_length_size + header->length;
4185 /* Return TRUE if OFFSET is within CU_HEADER. */
4188 offset_in_cu_p (const struct comp_unit_head *cu_header, sect_offset offset)
4190 sect_offset bottom = { cu_header->offset.sect_off };
4191 sect_offset top = { cu_header->offset.sect_off + get_cu_length (cu_header) };
4193 return (offset.sect_off >= bottom.sect_off && offset.sect_off < top.sect_off);
4196 /* Find the base address of the compilation unit for range lists and
4197 location lists. It will normally be specified by DW_AT_low_pc.
4198 In DWARF-3 draft 4, the base address could be overridden by
4199 DW_AT_entry_pc. It's been removed, but GCC still uses this for
4200 compilation units with discontinuous ranges. */
4203 dwarf2_find_base_address (struct die_info *die, struct dwarf2_cu *cu)
4205 struct attribute *attr;
4208 cu->base_address = 0;
4210 attr = dwarf2_attr (die, DW_AT_entry_pc, cu);
4213 cu->base_address = attr_value_as_address (attr);
4218 attr = dwarf2_attr (die, DW_AT_low_pc, cu);
4221 cu->base_address = attr_value_as_address (attr);
4227 /* Read in the comp unit header information from the debug_info at info_ptr.
4228 NOTE: This leaves members offset, first_die_offset to be filled in
4231 static const gdb_byte *
4232 read_comp_unit_head (struct comp_unit_head *cu_header,
4233 const gdb_byte *info_ptr, bfd *abfd)
4236 unsigned int bytes_read;
4238 cu_header->length = read_initial_length (abfd, info_ptr, &bytes_read);
4239 cu_header->initial_length_size = bytes_read;
4240 cu_header->offset_size = (bytes_read == 4) ? 4 : 8;
4241 info_ptr += bytes_read;
4242 cu_header->version = read_2_bytes (abfd, info_ptr);
4244 cu_header->abbrev_offset.sect_off = read_offset (abfd, info_ptr, cu_header,
4246 info_ptr += bytes_read;
4247 cu_header->addr_size = read_1_byte (abfd, info_ptr);
4249 signed_addr = bfd_get_sign_extend_vma (abfd);
4250 if (signed_addr < 0)
4251 internal_error (__FILE__, __LINE__,
4252 _("read_comp_unit_head: dwarf from non elf file"));
4253 cu_header->signed_addr_p = signed_addr;
4258 /* Helper function that returns the proper abbrev section for
4261 static struct dwarf2_section_info *
4262 get_abbrev_section_for_cu (struct dwarf2_per_cu_data *this_cu)
4264 struct dwarf2_section_info *abbrev;
4266 if (this_cu->is_dwz)
4267 abbrev = &dwarf2_get_dwz_file ()->abbrev;
4269 abbrev = &dwarf2_per_objfile->abbrev;
4274 /* Subroutine of read_and_check_comp_unit_head and
4275 read_and_check_type_unit_head to simplify them.
4276 Perform various error checking on the header. */
4279 error_check_comp_unit_head (struct comp_unit_head *header,
4280 struct dwarf2_section_info *section,
4281 struct dwarf2_section_info *abbrev_section)
4283 bfd *abfd = get_section_bfd_owner (section);
4284 const char *filename = get_section_file_name (section);
4286 if (header->version != 2 && header->version != 3 && header->version != 4)
4287 error (_("Dwarf Error: wrong version in compilation unit header "
4288 "(is %d, should be 2, 3, or 4) [in module %s]"), header->version,
4291 if (header->abbrev_offset.sect_off
4292 >= dwarf2_section_size (dwarf2_per_objfile->objfile, abbrev_section))
4293 error (_("Dwarf Error: bad offset (0x%lx) in compilation unit header "
4294 "(offset 0x%lx + 6) [in module %s]"),
4295 (long) header->abbrev_offset.sect_off, (long) header->offset.sect_off,
4298 /* Cast to unsigned long to use 64-bit arithmetic when possible to
4299 avoid potential 32-bit overflow. */
4300 if (((unsigned long) header->offset.sect_off + get_cu_length (header))
4302 error (_("Dwarf Error: bad length (0x%lx) in compilation unit header "
4303 "(offset 0x%lx + 0) [in module %s]"),
4304 (long) header->length, (long) header->offset.sect_off,
4308 /* Read in a CU/TU header and perform some basic error checking.
4309 The contents of the header are stored in HEADER.
4310 The result is a pointer to the start of the first DIE. */
4312 static const gdb_byte *
4313 read_and_check_comp_unit_head (struct comp_unit_head *header,
4314 struct dwarf2_section_info *section,
4315 struct dwarf2_section_info *abbrev_section,
4316 const gdb_byte *info_ptr,
4317 int is_debug_types_section)
4319 const gdb_byte *beg_of_comp_unit = info_ptr;
4320 bfd *abfd = get_section_bfd_owner (section);
4322 header->offset.sect_off = beg_of_comp_unit - section->buffer;
4324 info_ptr = read_comp_unit_head (header, info_ptr, abfd);
4326 /* If we're reading a type unit, skip over the signature and
4327 type_offset fields. */
4328 if (is_debug_types_section)
4329 info_ptr += 8 /*signature*/ + header->offset_size;
4331 header->first_die_offset.cu_off = info_ptr - beg_of_comp_unit;
4333 error_check_comp_unit_head (header, section, abbrev_section);
4338 /* Read in the types comp unit header information from .debug_types entry at
4339 types_ptr. The result is a pointer to one past the end of the header. */
4341 static const gdb_byte *
4342 read_and_check_type_unit_head (struct comp_unit_head *header,
4343 struct dwarf2_section_info *section,
4344 struct dwarf2_section_info *abbrev_section,
4345 const gdb_byte *info_ptr,
4346 ULONGEST *signature,
4347 cu_offset *type_offset_in_tu)
4349 const gdb_byte *beg_of_comp_unit = info_ptr;
4350 bfd *abfd = get_section_bfd_owner (section);
4352 header->offset.sect_off = beg_of_comp_unit - section->buffer;
4354 info_ptr = read_comp_unit_head (header, info_ptr, abfd);
4356 /* If we're reading a type unit, skip over the signature and
4357 type_offset fields. */
4358 if (signature != NULL)
4359 *signature = read_8_bytes (abfd, info_ptr);
4361 if (type_offset_in_tu != NULL)
4362 type_offset_in_tu->cu_off = read_offset_1 (abfd, info_ptr,
4363 header->offset_size);
4364 info_ptr += header->offset_size;
4366 header->first_die_offset.cu_off = info_ptr - beg_of_comp_unit;
4368 error_check_comp_unit_head (header, section, abbrev_section);
4373 /* Fetch the abbreviation table offset from a comp or type unit header. */
4376 read_abbrev_offset (struct dwarf2_section_info *section,
4379 bfd *abfd = get_section_bfd_owner (section);
4380 const gdb_byte *info_ptr;
4381 unsigned int length, initial_length_size, offset_size;
4382 sect_offset abbrev_offset;
4384 dwarf2_read_section (dwarf2_per_objfile->objfile, section);
4385 info_ptr = section->buffer + offset.sect_off;
4386 length = read_initial_length (abfd, info_ptr, &initial_length_size);
4387 offset_size = initial_length_size == 4 ? 4 : 8;
4388 info_ptr += initial_length_size + 2 /*version*/;
4389 abbrev_offset.sect_off = read_offset_1 (abfd, info_ptr, offset_size);
4390 return abbrev_offset;
4393 /* Allocate a new partial symtab for file named NAME and mark this new
4394 partial symtab as being an include of PST. */
4397 dwarf2_create_include_psymtab (const char *name, struct partial_symtab *pst,
4398 struct objfile *objfile)
4400 struct partial_symtab *subpst = allocate_psymtab (name, objfile);
4402 if (!IS_ABSOLUTE_PATH (subpst->filename))
4404 /* It shares objfile->objfile_obstack. */
4405 subpst->dirname = pst->dirname;
4408 subpst->section_offsets = pst->section_offsets;
4409 subpst->textlow = 0;
4410 subpst->texthigh = 0;
4412 subpst->dependencies = (struct partial_symtab **)
4413 obstack_alloc (&objfile->objfile_obstack,
4414 sizeof (struct partial_symtab *));
4415 subpst->dependencies[0] = pst;
4416 subpst->number_of_dependencies = 1;
4418 subpst->globals_offset = 0;
4419 subpst->n_global_syms = 0;
4420 subpst->statics_offset = 0;
4421 subpst->n_static_syms = 0;
4422 subpst->symtab = NULL;
4423 subpst->read_symtab = pst->read_symtab;
4426 /* No private part is necessary for include psymtabs. This property
4427 can be used to differentiate between such include psymtabs and
4428 the regular ones. */
4429 subpst->read_symtab_private = NULL;
4432 /* Read the Line Number Program data and extract the list of files
4433 included by the source file represented by PST. Build an include
4434 partial symtab for each of these included files. */
4437 dwarf2_build_include_psymtabs (struct dwarf2_cu *cu,
4438 struct die_info *die,
4439 struct partial_symtab *pst)
4441 struct line_header *lh = NULL;
4442 struct attribute *attr;
4444 attr = dwarf2_attr (die, DW_AT_stmt_list, cu);
4446 lh = dwarf_decode_line_header (DW_UNSND (attr), cu);
4448 return; /* No linetable, so no includes. */
4450 /* NOTE: pst->dirname is DW_AT_comp_dir (if present). */
4451 dwarf_decode_lines (lh, pst->dirname, cu, pst, pst->textlow);
4453 free_line_header (lh);
4457 hash_signatured_type (const void *item)
4459 const struct signatured_type *sig_type = item;
4461 /* This drops the top 32 bits of the signature, but is ok for a hash. */
4462 return sig_type->signature;
4466 eq_signatured_type (const void *item_lhs, const void *item_rhs)
4468 const struct signatured_type *lhs = item_lhs;
4469 const struct signatured_type *rhs = item_rhs;
4471 return lhs->signature == rhs->signature;
4474 /* Allocate a hash table for signatured types. */
4477 allocate_signatured_type_table (struct objfile *objfile)
4479 return htab_create_alloc_ex (41,
4480 hash_signatured_type,
4483 &objfile->objfile_obstack,
4484 hashtab_obstack_allocate,
4485 dummy_obstack_deallocate);
4488 /* A helper function to add a signatured type CU to a table. */
4491 add_signatured_type_cu_to_table (void **slot, void *datum)
4493 struct signatured_type *sigt = *slot;
4494 struct signatured_type ***datap = datum;
4502 /* Create the hash table of all entries in the .debug_types
4503 (or .debug_types.dwo) section(s).
4504 If reading a DWO file, then DWO_FILE is a pointer to the DWO file object,
4505 otherwise it is NULL.
4507 The result is a pointer to the hash table or NULL if there are no types.
4509 Note: This function processes DWO files only, not DWP files. */
4512 create_debug_types_hash_table (struct dwo_file *dwo_file,
4513 VEC (dwarf2_section_info_def) *types)
4515 struct objfile *objfile = dwarf2_per_objfile->objfile;
4516 htab_t types_htab = NULL;
4518 struct dwarf2_section_info *section;
4519 struct dwarf2_section_info *abbrev_section;
4521 if (VEC_empty (dwarf2_section_info_def, types))
4524 abbrev_section = (dwo_file != NULL
4525 ? &dwo_file->sections.abbrev
4526 : &dwarf2_per_objfile->abbrev);
4528 if (dwarf2_read_debug)
4529 fprintf_unfiltered (gdb_stdlog, "Reading .debug_types%s for %s:\n",
4530 dwo_file ? ".dwo" : "",
4531 get_section_file_name (abbrev_section));
4534 VEC_iterate (dwarf2_section_info_def, types, ix, section);
4538 const gdb_byte *info_ptr, *end_ptr;
4540 dwarf2_read_section (objfile, section);
4541 info_ptr = section->buffer;
4543 if (info_ptr == NULL)
4546 /* We can't set abfd until now because the section may be empty or
4547 not present, in which case the bfd is unknown. */
4548 abfd = get_section_bfd_owner (section);
4550 /* We don't use init_cutu_and_read_dies_simple, or some such, here
4551 because we don't need to read any dies: the signature is in the
4554 end_ptr = info_ptr + section->size;
4555 while (info_ptr < end_ptr)
4558 cu_offset type_offset_in_tu;
4560 struct signatured_type *sig_type;
4561 struct dwo_unit *dwo_tu;
4563 const gdb_byte *ptr = info_ptr;
4564 struct comp_unit_head header;
4565 unsigned int length;
4567 offset.sect_off = ptr - section->buffer;
4569 /* We need to read the type's signature in order to build the hash
4570 table, but we don't need anything else just yet. */
4572 ptr = read_and_check_type_unit_head (&header, section,
4573 abbrev_section, ptr,
4574 &signature, &type_offset_in_tu);
4576 length = get_cu_length (&header);
4578 /* Skip dummy type units. */
4579 if (ptr >= info_ptr + length
4580 || peek_abbrev_code (abfd, ptr) == 0)
4586 if (types_htab == NULL)
4589 types_htab = allocate_dwo_unit_table (objfile);
4591 types_htab = allocate_signatured_type_table (objfile);
4597 dwo_tu = OBSTACK_ZALLOC (&objfile->objfile_obstack,
4599 dwo_tu->dwo_file = dwo_file;
4600 dwo_tu->signature = signature;
4601 dwo_tu->type_offset_in_tu = type_offset_in_tu;
4602 dwo_tu->section = section;
4603 dwo_tu->offset = offset;
4604 dwo_tu->length = length;
4608 /* N.B.: type_offset is not usable if this type uses a DWO file.
4609 The real type_offset is in the DWO file. */
4611 sig_type = OBSTACK_ZALLOC (&objfile->objfile_obstack,
4612 struct signatured_type);
4613 sig_type->signature = signature;
4614 sig_type->type_offset_in_tu = type_offset_in_tu;
4615 sig_type->per_cu.objfile = objfile;
4616 sig_type->per_cu.is_debug_types = 1;
4617 sig_type->per_cu.section = section;
4618 sig_type->per_cu.offset = offset;
4619 sig_type->per_cu.length = length;
4622 slot = htab_find_slot (types_htab,
4623 dwo_file ? (void*) dwo_tu : (void *) sig_type,
4625 gdb_assert (slot != NULL);
4628 sect_offset dup_offset;
4632 const struct dwo_unit *dup_tu = *slot;
4634 dup_offset = dup_tu->offset;
4638 const struct signatured_type *dup_tu = *slot;
4640 dup_offset = dup_tu->per_cu.offset;
4643 complaint (&symfile_complaints,
4644 _("debug type entry at offset 0x%x is duplicate to"
4645 " the entry at offset 0x%x, signature %s"),
4646 offset.sect_off, dup_offset.sect_off,
4647 hex_string (signature));
4649 *slot = dwo_file ? (void *) dwo_tu : (void *) sig_type;
4651 if (dwarf2_read_debug > 1)
4652 fprintf_unfiltered (gdb_stdlog, " offset 0x%x, signature %s\n",
4654 hex_string (signature));
4663 /* Create the hash table of all entries in the .debug_types section,
4664 and initialize all_type_units.
4665 The result is zero if there is an error (e.g. missing .debug_types section),
4666 otherwise non-zero. */
4669 create_all_type_units (struct objfile *objfile)
4672 struct signatured_type **iter;
4674 types_htab = create_debug_types_hash_table (NULL, dwarf2_per_objfile->types);
4675 if (types_htab == NULL)
4677 dwarf2_per_objfile->signatured_types = NULL;
4681 dwarf2_per_objfile->signatured_types = types_htab;
4683 dwarf2_per_objfile->n_type_units
4684 = dwarf2_per_objfile->n_allocated_type_units
4685 = htab_elements (types_htab);
4686 dwarf2_per_objfile->all_type_units
4687 = xmalloc (dwarf2_per_objfile->n_type_units
4688 * sizeof (struct signatured_type *));
4689 iter = &dwarf2_per_objfile->all_type_units[0];
4690 htab_traverse_noresize (types_htab, add_signatured_type_cu_to_table, &iter);
4691 gdb_assert (iter - &dwarf2_per_objfile->all_type_units[0]
4692 == dwarf2_per_objfile->n_type_units);
4697 /* Add an entry for signature SIG to dwarf2_per_objfile->signatured_types.
4698 If SLOT is non-NULL, it is the entry to use in the hash table.
4699 Otherwise we find one. */
4701 static struct signatured_type *
4702 add_type_unit (ULONGEST sig, void **slot)
4704 struct objfile *objfile = dwarf2_per_objfile->objfile;
4705 int n_type_units = dwarf2_per_objfile->n_type_units;
4706 struct signatured_type *sig_type;
4708 gdb_assert (n_type_units <= dwarf2_per_objfile->n_allocated_type_units);
4710 if (n_type_units > dwarf2_per_objfile->n_allocated_type_units)
4712 if (dwarf2_per_objfile->n_allocated_type_units == 0)
4713 dwarf2_per_objfile->n_allocated_type_units = 1;
4714 dwarf2_per_objfile->n_allocated_type_units *= 2;
4715 dwarf2_per_objfile->all_type_units
4716 = xrealloc (dwarf2_per_objfile->all_type_units,
4717 dwarf2_per_objfile->n_allocated_type_units
4718 * sizeof (struct signatured_type *));
4719 ++dwarf2_per_objfile->tu_stats.nr_all_type_units_reallocs;
4721 dwarf2_per_objfile->n_type_units = n_type_units;
4723 sig_type = OBSTACK_ZALLOC (&objfile->objfile_obstack,
4724 struct signatured_type);
4725 dwarf2_per_objfile->all_type_units[n_type_units - 1] = sig_type;
4726 sig_type->signature = sig;
4727 sig_type->per_cu.is_debug_types = 1;
4728 if (dwarf2_per_objfile->using_index)
4730 sig_type->per_cu.v.quick =
4731 OBSTACK_ZALLOC (&objfile->objfile_obstack,
4732 struct dwarf2_per_cu_quick_data);
4737 slot = htab_find_slot (dwarf2_per_objfile->signatured_types,
4740 gdb_assert (*slot == NULL);
4742 /* The rest of sig_type must be filled in by the caller. */
4746 /* Subroutine of lookup_dwo_signatured_type and lookup_dwp_signatured_type.
4747 Fill in SIG_ENTRY with DWO_ENTRY. */
4750 fill_in_sig_entry_from_dwo_entry (struct objfile *objfile,
4751 struct signatured_type *sig_entry,
4752 struct dwo_unit *dwo_entry)
4754 /* Make sure we're not clobbering something we don't expect to. */
4755 gdb_assert (! sig_entry->per_cu.queued);
4756 gdb_assert (sig_entry->per_cu.cu == NULL);
4757 if (dwarf2_per_objfile->using_index)
4759 gdb_assert (sig_entry->per_cu.v.quick != NULL);
4760 gdb_assert (sig_entry->per_cu.v.quick->symtab == NULL);
4763 gdb_assert (sig_entry->per_cu.v.psymtab == NULL);
4764 gdb_assert (sig_entry->signature == dwo_entry->signature);
4765 gdb_assert (sig_entry->type_offset_in_section.sect_off == 0);
4766 gdb_assert (sig_entry->type_unit_group == NULL);
4767 gdb_assert (sig_entry->dwo_unit == NULL);
4769 sig_entry->per_cu.section = dwo_entry->section;
4770 sig_entry->per_cu.offset = dwo_entry->offset;
4771 sig_entry->per_cu.length = dwo_entry->length;
4772 sig_entry->per_cu.reading_dwo_directly = 1;
4773 sig_entry->per_cu.objfile = objfile;
4774 sig_entry->type_offset_in_tu = dwo_entry->type_offset_in_tu;
4775 sig_entry->dwo_unit = dwo_entry;
4778 /* Subroutine of lookup_signatured_type.
4779 If we haven't read the TU yet, create the signatured_type data structure
4780 for a TU to be read in directly from a DWO file, bypassing the stub.
4781 This is the "Stay in DWO Optimization": When there is no DWP file and we're
4782 using .gdb_index, then when reading a CU we want to stay in the DWO file
4783 containing that CU. Otherwise we could end up reading several other DWO
4784 files (due to comdat folding) to process the transitive closure of all the
4785 mentioned TUs, and that can be slow. The current DWO file will have every
4786 type signature that it needs.
4787 We only do this for .gdb_index because in the psymtab case we already have
4788 to read all the DWOs to build the type unit groups. */
4790 static struct signatured_type *
4791 lookup_dwo_signatured_type (struct dwarf2_cu *cu, ULONGEST sig)
4793 struct objfile *objfile = dwarf2_per_objfile->objfile;
4794 struct dwo_file *dwo_file;
4795 struct dwo_unit find_dwo_entry, *dwo_entry;
4796 struct signatured_type find_sig_entry, *sig_entry;
4799 gdb_assert (cu->dwo_unit && dwarf2_per_objfile->using_index);
4801 /* If TU skeletons have been removed then we may not have read in any
4803 if (dwarf2_per_objfile->signatured_types == NULL)
4805 dwarf2_per_objfile->signatured_types
4806 = allocate_signatured_type_table (objfile);
4809 /* We only ever need to read in one copy of a signatured type.
4810 Use the global signatured_types array to do our own comdat-folding
4811 of types. If this is the first time we're reading this TU, and
4812 the TU has an entry in .gdb_index, replace the recorded data from
4813 .gdb_index with this TU. */
4815 find_sig_entry.signature = sig;
4816 slot = htab_find_slot (dwarf2_per_objfile->signatured_types,
4817 &find_sig_entry, INSERT);
4820 /* We can get here with the TU already read, *or* in the process of being
4821 read. Don't reassign the global entry to point to this DWO if that's
4822 the case. Also note that if the TU is already being read, it may not
4823 have come from a DWO, the program may be a mix of Fission-compiled
4824 code and non-Fission-compiled code. */
4826 /* Have we already tried to read this TU?
4827 Note: sig_entry can be NULL if the skeleton TU was removed (thus it
4828 needn't exist in the global table yet). */
4829 if (sig_entry != NULL && sig_entry->per_cu.tu_read)
4832 /* Note: cu->dwo_unit is the dwo_unit that references this TU, not the
4833 dwo_unit of the TU itself. */
4834 dwo_file = cu->dwo_unit->dwo_file;
4836 /* Ok, this is the first time we're reading this TU. */
4837 if (dwo_file->tus == NULL)
4839 find_dwo_entry.signature = sig;
4840 dwo_entry = htab_find (dwo_file->tus, &find_dwo_entry);
4841 if (dwo_entry == NULL)
4844 /* If the global table doesn't have an entry for this TU, add one. */
4845 if (sig_entry == NULL)
4846 sig_entry = add_type_unit (sig, slot);
4848 fill_in_sig_entry_from_dwo_entry (objfile, sig_entry, dwo_entry);
4849 sig_entry->per_cu.tu_read = 1;
4853 /* Subroutine of lookup_signatured_type.
4854 Look up the type for signature SIG, and if we can't find SIG in .gdb_index
4855 then try the DWP file. If the TU stub (skeleton) has been removed then
4856 it won't be in .gdb_index. */
4858 static struct signatured_type *
4859 lookup_dwp_signatured_type (struct dwarf2_cu *cu, ULONGEST sig)
4861 struct objfile *objfile = dwarf2_per_objfile->objfile;
4862 struct dwp_file *dwp_file = get_dwp_file ();
4863 struct dwo_unit *dwo_entry;
4864 struct signatured_type find_sig_entry, *sig_entry;
4867 gdb_assert (cu->dwo_unit && dwarf2_per_objfile->using_index);
4868 gdb_assert (dwp_file != NULL);
4870 /* If TU skeletons have been removed then we may not have read in any
4872 if (dwarf2_per_objfile->signatured_types == NULL)
4874 dwarf2_per_objfile->signatured_types
4875 = allocate_signatured_type_table (objfile);
4878 find_sig_entry.signature = sig;
4879 slot = htab_find_slot (dwarf2_per_objfile->signatured_types,
4880 &find_sig_entry, INSERT);
4883 /* Have we already tried to read this TU?
4884 Note: sig_entry can be NULL if the skeleton TU was removed (thus it
4885 needn't exist in the global table yet). */
4886 if (sig_entry != NULL)
4889 if (dwp_file->tus == NULL)
4891 dwo_entry = lookup_dwo_unit_in_dwp (dwp_file, NULL,
4892 sig, 1 /* is_debug_types */);
4893 if (dwo_entry == NULL)
4896 sig_entry = add_type_unit (sig, slot);
4897 fill_in_sig_entry_from_dwo_entry (objfile, sig_entry, dwo_entry);
4902 /* Lookup a signature based type for DW_FORM_ref_sig8.
4903 Returns NULL if signature SIG is not present in the table.
4904 It is up to the caller to complain about this. */
4906 static struct signatured_type *
4907 lookup_signatured_type (struct dwarf2_cu *cu, ULONGEST sig)
4910 && dwarf2_per_objfile->using_index)
4912 /* We're in a DWO/DWP file, and we're using .gdb_index.
4913 These cases require special processing. */
4914 if (get_dwp_file () == NULL)
4915 return lookup_dwo_signatured_type (cu, sig);
4917 return lookup_dwp_signatured_type (cu, sig);
4921 struct signatured_type find_entry, *entry;
4923 if (dwarf2_per_objfile->signatured_types == NULL)
4925 find_entry.signature = sig;
4926 entry = htab_find (dwarf2_per_objfile->signatured_types, &find_entry);
4931 /* Low level DIE reading support. */
4933 /* Initialize a die_reader_specs struct from a dwarf2_cu struct. */
4936 init_cu_die_reader (struct die_reader_specs *reader,
4937 struct dwarf2_cu *cu,
4938 struct dwarf2_section_info *section,
4939 struct dwo_file *dwo_file)
4941 gdb_assert (section->readin && section->buffer != NULL);
4942 reader->abfd = get_section_bfd_owner (section);
4944 reader->dwo_file = dwo_file;
4945 reader->die_section = section;
4946 reader->buffer = section->buffer;
4947 reader->buffer_end = section->buffer + section->size;
4948 reader->comp_dir = NULL;
4951 /* Subroutine of init_cutu_and_read_dies to simplify it.
4952 Read in the rest of a CU/TU top level DIE from DWO_UNIT.
4953 There's just a lot of work to do, and init_cutu_and_read_dies is big enough
4956 STUB_COMP_UNIT_DIE is for the stub DIE, we copy over certain attributes
4957 from it to the DIE in the DWO. If NULL we are skipping the stub.
4958 STUB_COMP_DIR is similar to STUB_COMP_UNIT_DIE: When reading a TU directly
4959 from the DWO file, bypassing the stub, it contains the DW_AT_comp_dir
4960 attribute of the referencing CU. At most one of STUB_COMP_UNIT_DIE and
4961 STUB_COMP_DIR may be non-NULL.
4962 *RESULT_READER,*RESULT_INFO_PTR,*RESULT_COMP_UNIT_DIE,*RESULT_HAS_CHILDREN
4963 are filled in with the info of the DIE from the DWO file.
4964 ABBREV_TABLE_PROVIDED is non-zero if the caller of init_cutu_and_read_dies
4965 provided an abbrev table to use.
4966 The result is non-zero if a valid (non-dummy) DIE was found. */
4969 read_cutu_die_from_dwo (struct dwarf2_per_cu_data *this_cu,
4970 struct dwo_unit *dwo_unit,
4971 int abbrev_table_provided,
4972 struct die_info *stub_comp_unit_die,
4973 const char *stub_comp_dir,
4974 struct die_reader_specs *result_reader,
4975 const gdb_byte **result_info_ptr,
4976 struct die_info **result_comp_unit_die,
4977 int *result_has_children)
4979 struct objfile *objfile = dwarf2_per_objfile->objfile;
4980 struct dwarf2_cu *cu = this_cu->cu;
4981 struct dwarf2_section_info *section;
4983 const gdb_byte *begin_info_ptr, *info_ptr;
4984 ULONGEST signature; /* Or dwo_id. */
4985 struct attribute *comp_dir, *stmt_list, *low_pc, *high_pc, *ranges;
4986 int i,num_extra_attrs;
4987 struct dwarf2_section_info *dwo_abbrev_section;
4988 struct attribute *attr;
4989 struct die_info *comp_unit_die;
4991 /* At most one of these may be provided. */
4992 gdb_assert ((stub_comp_unit_die != NULL) + (stub_comp_dir != NULL) <= 1);
4994 /* These attributes aren't processed until later:
4995 DW_AT_stmt_list, DW_AT_low_pc, DW_AT_high_pc, DW_AT_ranges.
4996 DW_AT_comp_dir is used now, to find the DWO file, but it is also
4997 referenced later. However, these attributes are found in the stub
4998 which we won't have later. In order to not impose this complication
4999 on the rest of the code, we read them here and copy them to the
5008 if (stub_comp_unit_die != NULL)
5010 /* For TUs in DWO files, the DW_AT_stmt_list attribute lives in the
5012 if (! this_cu->is_debug_types)
5013 stmt_list = dwarf2_attr (stub_comp_unit_die, DW_AT_stmt_list, cu);
5014 low_pc = dwarf2_attr (stub_comp_unit_die, DW_AT_low_pc, cu);
5015 high_pc = dwarf2_attr (stub_comp_unit_die, DW_AT_high_pc, cu);
5016 ranges = dwarf2_attr (stub_comp_unit_die, DW_AT_ranges, cu);
5017 comp_dir = dwarf2_attr (stub_comp_unit_die, DW_AT_comp_dir, cu);
5019 /* There should be a DW_AT_addr_base attribute here (if needed).
5020 We need the value before we can process DW_FORM_GNU_addr_index. */
5022 attr = dwarf2_attr (stub_comp_unit_die, DW_AT_GNU_addr_base, cu);
5024 cu->addr_base = DW_UNSND (attr);
5026 /* There should be a DW_AT_ranges_base attribute here (if needed).
5027 We need the value before we can process DW_AT_ranges. */
5028 cu->ranges_base = 0;
5029 attr = dwarf2_attr (stub_comp_unit_die, DW_AT_GNU_ranges_base, cu);
5031 cu->ranges_base = DW_UNSND (attr);
5033 else if (stub_comp_dir != NULL)
5035 /* Reconstruct the comp_dir attribute to simplify the code below. */
5036 comp_dir = (struct attribute *)
5037 obstack_alloc (&cu->comp_unit_obstack, sizeof (*comp_dir));
5038 comp_dir->name = DW_AT_comp_dir;
5039 comp_dir->form = DW_FORM_string;
5040 DW_STRING_IS_CANONICAL (comp_dir) = 0;
5041 DW_STRING (comp_dir) = stub_comp_dir;
5044 /* Set up for reading the DWO CU/TU. */
5045 cu->dwo_unit = dwo_unit;
5046 section = dwo_unit->section;
5047 dwarf2_read_section (objfile, section);
5048 abfd = get_section_bfd_owner (section);
5049 begin_info_ptr = info_ptr = section->buffer + dwo_unit->offset.sect_off;
5050 dwo_abbrev_section = &dwo_unit->dwo_file->sections.abbrev;
5051 init_cu_die_reader (result_reader, cu, section, dwo_unit->dwo_file);
5053 if (this_cu->is_debug_types)
5055 ULONGEST header_signature;
5056 cu_offset type_offset_in_tu;
5057 struct signatured_type *sig_type = (struct signatured_type *) this_cu;
5059 info_ptr = read_and_check_type_unit_head (&cu->header, section,
5063 &type_offset_in_tu);
5064 /* This is not an assert because it can be caused by bad debug info. */
5065 if (sig_type->signature != header_signature)
5067 error (_("Dwarf Error: signature mismatch %s vs %s while reading"
5068 " TU at offset 0x%x [in module %s]"),
5069 hex_string (sig_type->signature),
5070 hex_string (header_signature),
5071 dwo_unit->offset.sect_off,
5072 bfd_get_filename (abfd));
5074 gdb_assert (dwo_unit->offset.sect_off == cu->header.offset.sect_off);
5075 /* For DWOs coming from DWP files, we don't know the CU length
5076 nor the type's offset in the TU until now. */
5077 dwo_unit->length = get_cu_length (&cu->header);
5078 dwo_unit->type_offset_in_tu = type_offset_in_tu;
5080 /* Establish the type offset that can be used to lookup the type.
5081 For DWO files, we don't know it until now. */
5082 sig_type->type_offset_in_section.sect_off =
5083 dwo_unit->offset.sect_off + dwo_unit->type_offset_in_tu.cu_off;
5087 info_ptr = read_and_check_comp_unit_head (&cu->header, section,
5090 gdb_assert (dwo_unit->offset.sect_off == cu->header.offset.sect_off);
5091 /* For DWOs coming from DWP files, we don't know the CU length
5093 dwo_unit->length = get_cu_length (&cu->header);
5096 /* Replace the CU's original abbrev table with the DWO's.
5097 Reminder: We can't read the abbrev table until we've read the header. */
5098 if (abbrev_table_provided)
5100 /* Don't free the provided abbrev table, the caller of
5101 init_cutu_and_read_dies owns it. */
5102 dwarf2_read_abbrevs (cu, dwo_abbrev_section);
5103 /* Ensure the DWO abbrev table gets freed. */
5104 make_cleanup (dwarf2_free_abbrev_table, cu);
5108 dwarf2_free_abbrev_table (cu);
5109 dwarf2_read_abbrevs (cu, dwo_abbrev_section);
5110 /* Leave any existing abbrev table cleanup as is. */
5113 /* Read in the die, but leave space to copy over the attributes
5114 from the stub. This has the benefit of simplifying the rest of
5115 the code - all the work to maintain the illusion of a single
5116 DW_TAG_{compile,type}_unit DIE is done here. */
5117 num_extra_attrs = ((stmt_list != NULL)
5121 + (comp_dir != NULL));
5122 info_ptr = read_full_die_1 (result_reader, result_comp_unit_die, info_ptr,
5123 result_has_children, num_extra_attrs);
5125 /* Copy over the attributes from the stub to the DIE we just read in. */
5126 comp_unit_die = *result_comp_unit_die;
5127 i = comp_unit_die->num_attrs;
5128 if (stmt_list != NULL)
5129 comp_unit_die->attrs[i++] = *stmt_list;
5131 comp_unit_die->attrs[i++] = *low_pc;
5132 if (high_pc != NULL)
5133 comp_unit_die->attrs[i++] = *high_pc;
5135 comp_unit_die->attrs[i++] = *ranges;
5136 if (comp_dir != NULL)
5137 comp_unit_die->attrs[i++] = *comp_dir;
5138 comp_unit_die->num_attrs += num_extra_attrs;
5140 if (dwarf2_die_debug)
5142 fprintf_unfiltered (gdb_stdlog,
5143 "Read die from %s@0x%x of %s:\n",
5144 get_section_name (section),
5145 (unsigned) (begin_info_ptr - section->buffer),
5146 bfd_get_filename (abfd));
5147 dump_die (comp_unit_die, dwarf2_die_debug);
5150 /* Save the comp_dir attribute. If there is no DWP file then we'll read
5151 TUs by skipping the stub and going directly to the entry in the DWO file.
5152 However, skipping the stub means we won't get DW_AT_comp_dir, so we have
5153 to get it via circuitous means. Blech. */
5154 if (comp_dir != NULL)
5155 result_reader->comp_dir = DW_STRING (comp_dir);
5157 /* Skip dummy compilation units. */
5158 if (info_ptr >= begin_info_ptr + dwo_unit->length
5159 || peek_abbrev_code (abfd, info_ptr) == 0)
5162 *result_info_ptr = info_ptr;
5166 /* Subroutine of init_cutu_and_read_dies to simplify it.
5167 Look up the DWO unit specified by COMP_UNIT_DIE of THIS_CU.
5168 Returns NULL if the specified DWO unit cannot be found. */
5170 static struct dwo_unit *
5171 lookup_dwo_unit (struct dwarf2_per_cu_data *this_cu,
5172 struct die_info *comp_unit_die)
5174 struct dwarf2_cu *cu = this_cu->cu;
5175 struct attribute *attr;
5177 struct dwo_unit *dwo_unit;
5178 const char *comp_dir, *dwo_name;
5180 gdb_assert (cu != NULL);
5182 /* Yeah, we look dwo_name up again, but it simplifies the code. */
5183 attr = dwarf2_attr (comp_unit_die, DW_AT_GNU_dwo_name, cu);
5184 gdb_assert (attr != NULL);
5185 dwo_name = DW_STRING (attr);
5187 attr = dwarf2_attr (comp_unit_die, DW_AT_comp_dir, cu);
5189 comp_dir = DW_STRING (attr);
5191 if (this_cu->is_debug_types)
5193 struct signatured_type *sig_type;
5195 /* Since this_cu is the first member of struct signatured_type,
5196 we can go from a pointer to one to a pointer to the other. */
5197 sig_type = (struct signatured_type *) this_cu;
5198 signature = sig_type->signature;
5199 dwo_unit = lookup_dwo_type_unit (sig_type, dwo_name, comp_dir);
5203 struct attribute *attr;
5205 attr = dwarf2_attr (comp_unit_die, DW_AT_GNU_dwo_id, cu);
5207 error (_("Dwarf Error: missing dwo_id for dwo_name %s"
5209 dwo_name, objfile_name (this_cu->objfile));
5210 signature = DW_UNSND (attr);
5211 dwo_unit = lookup_dwo_comp_unit (this_cu, dwo_name, comp_dir,
5218 /* Subroutine of init_cutu_and_read_dies to simplify it.
5219 See it for a description of the parameters.
5220 Read a TU directly from a DWO file, bypassing the stub.
5222 Note: This function could be a little bit simpler if we shared cleanups
5223 with our caller, init_cutu_and_read_dies. That's generally a fragile thing
5224 to do, so we keep this function self-contained. Or we could move this
5225 into our caller, but it's complex enough already. */
5228 init_tu_and_read_dwo_dies (struct dwarf2_per_cu_data *this_cu,
5229 int use_existing_cu, int keep,
5230 die_reader_func_ftype *die_reader_func,
5233 struct dwarf2_cu *cu;
5234 struct signatured_type *sig_type;
5235 struct cleanup *cleanups, *free_cu_cleanup = NULL;
5236 struct die_reader_specs reader;
5237 const gdb_byte *info_ptr;
5238 struct die_info *comp_unit_die;
5241 /* Verify we can do the following downcast, and that we have the
5243 gdb_assert (this_cu->is_debug_types && this_cu->reading_dwo_directly);
5244 sig_type = (struct signatured_type *) this_cu;
5245 gdb_assert (sig_type->dwo_unit != NULL);
5247 cleanups = make_cleanup (null_cleanup, NULL);
5249 if (use_existing_cu && this_cu->cu != NULL)
5251 gdb_assert (this_cu->cu->dwo_unit == sig_type->dwo_unit);
5253 /* There's no need to do the rereading_dwo_cu handling that
5254 init_cutu_and_read_dies does since we don't read the stub. */
5258 /* If !use_existing_cu, this_cu->cu must be NULL. */
5259 gdb_assert (this_cu->cu == NULL);
5260 cu = xmalloc (sizeof (*cu));
5261 init_one_comp_unit (cu, this_cu);
5262 /* If an error occurs while loading, release our storage. */
5263 free_cu_cleanup = make_cleanup (free_heap_comp_unit, cu);
5266 /* A future optimization, if needed, would be to use an existing
5267 abbrev table. When reading DWOs with skeletonless TUs, all the TUs
5268 could share abbrev tables. */
5270 if (read_cutu_die_from_dwo (this_cu, sig_type->dwo_unit,
5271 0 /* abbrev_table_provided */,
5272 NULL /* stub_comp_unit_die */,
5273 sig_type->dwo_unit->dwo_file->comp_dir,
5275 &comp_unit_die, &has_children) == 0)
5278 do_cleanups (cleanups);
5282 /* All the "real" work is done here. */
5283 die_reader_func (&reader, info_ptr, comp_unit_die, has_children, data);
5285 /* This duplicates the code in init_cutu_and_read_dies,
5286 but the alternative is making the latter more complex.
5287 This function is only for the special case of using DWO files directly:
5288 no point in overly complicating the general case just to handle this. */
5289 if (free_cu_cleanup != NULL)
5293 /* We've successfully allocated this compilation unit. Let our
5294 caller clean it up when finished with it. */
5295 discard_cleanups (free_cu_cleanup);
5297 /* We can only discard free_cu_cleanup and all subsequent cleanups.
5298 So we have to manually free the abbrev table. */
5299 dwarf2_free_abbrev_table (cu);
5301 /* Link this CU into read_in_chain. */
5302 this_cu->cu->read_in_chain = dwarf2_per_objfile->read_in_chain;
5303 dwarf2_per_objfile->read_in_chain = this_cu;
5306 do_cleanups (free_cu_cleanup);
5309 do_cleanups (cleanups);
5312 /* Initialize a CU (or TU) and read its DIEs.
5313 If the CU defers to a DWO file, read the DWO file as well.
5315 ABBREV_TABLE, if non-NULL, is the abbreviation table to use.
5316 Otherwise the table specified in the comp unit header is read in and used.
5317 This is an optimization for when we already have the abbrev table.
5319 If USE_EXISTING_CU is non-zero, and THIS_CU->cu is non-NULL, then use it.
5320 Otherwise, a new CU is allocated with xmalloc.
5322 If KEEP is non-zero, then if we allocated a dwarf2_cu we add it to
5323 read_in_chain. Otherwise the dwarf2_cu data is freed at the end.
5325 WARNING: If THIS_CU is a "dummy CU" (used as filler by the incremental
5326 linker) then DIE_READER_FUNC will not get called. */
5329 init_cutu_and_read_dies (struct dwarf2_per_cu_data *this_cu,
5330 struct abbrev_table *abbrev_table,
5331 int use_existing_cu, int keep,
5332 die_reader_func_ftype *die_reader_func,
5335 struct objfile *objfile = dwarf2_per_objfile->objfile;
5336 struct dwarf2_section_info *section = this_cu->section;
5337 bfd *abfd = get_section_bfd_owner (section);
5338 struct dwarf2_cu *cu;
5339 const gdb_byte *begin_info_ptr, *info_ptr;
5340 struct die_reader_specs reader;
5341 struct die_info *comp_unit_die;
5343 struct attribute *attr;
5344 struct cleanup *cleanups, *free_cu_cleanup = NULL;
5345 struct signatured_type *sig_type = NULL;
5346 struct dwarf2_section_info *abbrev_section;
5347 /* Non-zero if CU currently points to a DWO file and we need to
5348 reread it. When this happens we need to reread the skeleton die
5349 before we can reread the DWO file (this only applies to CUs, not TUs). */
5350 int rereading_dwo_cu = 0;
5352 if (dwarf2_die_debug)
5353 fprintf_unfiltered (gdb_stdlog, "Reading %s unit at offset 0x%x\n",
5354 this_cu->is_debug_types ? "type" : "comp",
5355 this_cu->offset.sect_off);
5357 if (use_existing_cu)
5360 /* If we're reading a TU directly from a DWO file, including a virtual DWO
5361 file (instead of going through the stub), short-circuit all of this. */
5362 if (this_cu->reading_dwo_directly)
5364 /* Narrow down the scope of possibilities to have to understand. */
5365 gdb_assert (this_cu->is_debug_types);
5366 gdb_assert (abbrev_table == NULL);
5367 init_tu_and_read_dwo_dies (this_cu, use_existing_cu, keep,
5368 die_reader_func, data);
5372 cleanups = make_cleanup (null_cleanup, NULL);
5374 /* This is cheap if the section is already read in. */
5375 dwarf2_read_section (objfile, section);
5377 begin_info_ptr = info_ptr = section->buffer + this_cu->offset.sect_off;
5379 abbrev_section = get_abbrev_section_for_cu (this_cu);
5381 if (use_existing_cu && this_cu->cu != NULL)
5384 /* If this CU is from a DWO file we need to start over, we need to
5385 refetch the attributes from the skeleton CU.
5386 This could be optimized by retrieving those attributes from when we
5387 were here the first time: the previous comp_unit_die was stored in
5388 comp_unit_obstack. But there's no data yet that we need this
5390 if (cu->dwo_unit != NULL)
5391 rereading_dwo_cu = 1;
5395 /* If !use_existing_cu, this_cu->cu must be NULL. */
5396 gdb_assert (this_cu->cu == NULL);
5397 cu = xmalloc (sizeof (*cu));
5398 init_one_comp_unit (cu, this_cu);
5399 /* If an error occurs while loading, release our storage. */
5400 free_cu_cleanup = make_cleanup (free_heap_comp_unit, cu);
5403 /* Get the header. */
5404 if (cu->header.first_die_offset.cu_off != 0 && ! rereading_dwo_cu)
5406 /* We already have the header, there's no need to read it in again. */
5407 info_ptr += cu->header.first_die_offset.cu_off;
5411 if (this_cu->is_debug_types)
5414 cu_offset type_offset_in_tu;
5416 info_ptr = read_and_check_type_unit_head (&cu->header, section,
5417 abbrev_section, info_ptr,
5419 &type_offset_in_tu);
5421 /* Since per_cu is the first member of struct signatured_type,
5422 we can go from a pointer to one to a pointer to the other. */
5423 sig_type = (struct signatured_type *) this_cu;
5424 gdb_assert (sig_type->signature == signature);
5425 gdb_assert (sig_type->type_offset_in_tu.cu_off
5426 == type_offset_in_tu.cu_off);
5427 gdb_assert (this_cu->offset.sect_off == cu->header.offset.sect_off);
5429 /* LENGTH has not been set yet for type units if we're
5430 using .gdb_index. */
5431 this_cu->length = get_cu_length (&cu->header);
5433 /* Establish the type offset that can be used to lookup the type. */
5434 sig_type->type_offset_in_section.sect_off =
5435 this_cu->offset.sect_off + sig_type->type_offset_in_tu.cu_off;
5439 info_ptr = read_and_check_comp_unit_head (&cu->header, section,
5443 gdb_assert (this_cu->offset.sect_off == cu->header.offset.sect_off);
5444 gdb_assert (this_cu->length == get_cu_length (&cu->header));
5448 /* Skip dummy compilation units. */
5449 if (info_ptr >= begin_info_ptr + this_cu->length
5450 || peek_abbrev_code (abfd, info_ptr) == 0)
5452 do_cleanups (cleanups);
5456 /* If we don't have them yet, read the abbrevs for this compilation unit.
5457 And if we need to read them now, make sure they're freed when we're
5458 done. Note that it's important that if the CU had an abbrev table
5459 on entry we don't free it when we're done: Somewhere up the call stack
5460 it may be in use. */
5461 if (abbrev_table != NULL)
5463 gdb_assert (cu->abbrev_table == NULL);
5464 gdb_assert (cu->header.abbrev_offset.sect_off
5465 == abbrev_table->offset.sect_off);
5466 cu->abbrev_table = abbrev_table;
5468 else if (cu->abbrev_table == NULL)
5470 dwarf2_read_abbrevs (cu, abbrev_section);
5471 make_cleanup (dwarf2_free_abbrev_table, cu);
5473 else if (rereading_dwo_cu)
5475 dwarf2_free_abbrev_table (cu);
5476 dwarf2_read_abbrevs (cu, abbrev_section);
5479 /* Read the top level CU/TU die. */
5480 init_cu_die_reader (&reader, cu, section, NULL);
5481 info_ptr = read_full_die (&reader, &comp_unit_die, info_ptr, &has_children);
5483 /* If we are in a DWO stub, process it and then read in the "real" CU/TU
5485 Note that if USE_EXISTING_OK != 0, and THIS_CU->cu already contains a
5486 DWO CU, that this test will fail (the attribute will not be present). */
5487 attr = dwarf2_attr (comp_unit_die, DW_AT_GNU_dwo_name, cu);
5490 struct dwo_unit *dwo_unit;
5491 struct die_info *dwo_comp_unit_die;
5495 complaint (&symfile_complaints,
5496 _("compilation unit with DW_AT_GNU_dwo_name"
5497 " has children (offset 0x%x) [in module %s]"),
5498 this_cu->offset.sect_off, bfd_get_filename (abfd));
5500 dwo_unit = lookup_dwo_unit (this_cu, comp_unit_die);
5501 if (dwo_unit != NULL)
5503 if (read_cutu_die_from_dwo (this_cu, dwo_unit,
5504 abbrev_table != NULL,
5505 comp_unit_die, NULL,
5507 &dwo_comp_unit_die, &has_children) == 0)
5510 do_cleanups (cleanups);
5513 comp_unit_die = dwo_comp_unit_die;
5517 /* Yikes, we couldn't find the rest of the DIE, we only have
5518 the stub. A complaint has already been logged. There's
5519 not much more we can do except pass on the stub DIE to
5520 die_reader_func. We don't want to throw an error on bad
5525 /* All of the above is setup for this call. Yikes. */
5526 die_reader_func (&reader, info_ptr, comp_unit_die, has_children, data);
5528 /* Done, clean up. */
5529 if (free_cu_cleanup != NULL)
5533 /* We've successfully allocated this compilation unit. Let our
5534 caller clean it up when finished with it. */
5535 discard_cleanups (free_cu_cleanup);
5537 /* We can only discard free_cu_cleanup and all subsequent cleanups.
5538 So we have to manually free the abbrev table. */
5539 dwarf2_free_abbrev_table (cu);
5541 /* Link this CU into read_in_chain. */
5542 this_cu->cu->read_in_chain = dwarf2_per_objfile->read_in_chain;
5543 dwarf2_per_objfile->read_in_chain = this_cu;
5546 do_cleanups (free_cu_cleanup);
5549 do_cleanups (cleanups);
5552 /* Read CU/TU THIS_CU but do not follow DW_AT_GNU_dwo_name if present.
5553 DWO_FILE, if non-NULL, is the DWO file to read (the caller is assumed
5554 to have already done the lookup to find the DWO file).
5556 The caller is required to fill in THIS_CU->section, THIS_CU->offset, and
5557 THIS_CU->is_debug_types, but nothing else.
5559 We fill in THIS_CU->length.
5561 WARNING: If THIS_CU is a "dummy CU" (used as filler by the incremental
5562 linker) then DIE_READER_FUNC will not get called.
5564 THIS_CU->cu is always freed when done.
5565 This is done in order to not leave THIS_CU->cu in a state where we have
5566 to care whether it refers to the "main" CU or the DWO CU. */
5569 init_cutu_and_read_dies_no_follow (struct dwarf2_per_cu_data *this_cu,
5570 struct dwo_file *dwo_file,
5571 die_reader_func_ftype *die_reader_func,
5574 struct objfile *objfile = dwarf2_per_objfile->objfile;
5575 struct dwarf2_section_info *section = this_cu->section;
5576 bfd *abfd = get_section_bfd_owner (section);
5577 struct dwarf2_section_info *abbrev_section;
5578 struct dwarf2_cu cu;
5579 const gdb_byte *begin_info_ptr, *info_ptr;
5580 struct die_reader_specs reader;
5581 struct cleanup *cleanups;
5582 struct die_info *comp_unit_die;
5585 if (dwarf2_die_debug)
5586 fprintf_unfiltered (gdb_stdlog, "Reading %s unit at offset 0x%x\n",
5587 this_cu->is_debug_types ? "type" : "comp",
5588 this_cu->offset.sect_off);
5590 gdb_assert (this_cu->cu == NULL);
5592 abbrev_section = (dwo_file != NULL
5593 ? &dwo_file->sections.abbrev
5594 : get_abbrev_section_for_cu (this_cu));
5596 /* This is cheap if the section is already read in. */
5597 dwarf2_read_section (objfile, section);
5599 init_one_comp_unit (&cu, this_cu);
5601 cleanups = make_cleanup (free_stack_comp_unit, &cu);
5603 begin_info_ptr = info_ptr = section->buffer + this_cu->offset.sect_off;
5604 info_ptr = read_and_check_comp_unit_head (&cu.header, section,
5605 abbrev_section, info_ptr,
5606 this_cu->is_debug_types);
5608 this_cu->length = get_cu_length (&cu.header);
5610 /* Skip dummy compilation units. */
5611 if (info_ptr >= begin_info_ptr + this_cu->length
5612 || peek_abbrev_code (abfd, info_ptr) == 0)
5614 do_cleanups (cleanups);
5618 dwarf2_read_abbrevs (&cu, abbrev_section);
5619 make_cleanup (dwarf2_free_abbrev_table, &cu);
5621 init_cu_die_reader (&reader, &cu, section, dwo_file);
5622 info_ptr = read_full_die (&reader, &comp_unit_die, info_ptr, &has_children);
5624 die_reader_func (&reader, info_ptr, comp_unit_die, has_children, data);
5626 do_cleanups (cleanups);
5629 /* Read a CU/TU, except that this does not look for DW_AT_GNU_dwo_name and
5630 does not lookup the specified DWO file.
5631 This cannot be used to read DWO files.
5633 THIS_CU->cu is always freed when done.
5634 This is done in order to not leave THIS_CU->cu in a state where we have
5635 to care whether it refers to the "main" CU or the DWO CU.
5636 We can revisit this if the data shows there's a performance issue. */
5639 init_cutu_and_read_dies_simple (struct dwarf2_per_cu_data *this_cu,
5640 die_reader_func_ftype *die_reader_func,
5643 init_cutu_and_read_dies_no_follow (this_cu, NULL, die_reader_func, data);
5646 /* Type Unit Groups.
5648 Type Unit Groups are a way to collapse the set of all TUs (type units) into
5649 a more manageable set. The grouping is done by DW_AT_stmt_list entry
5650 so that all types coming from the same compilation (.o file) are grouped
5651 together. A future step could be to put the types in the same symtab as
5652 the CU the types ultimately came from. */
5655 hash_type_unit_group (const void *item)
5657 const struct type_unit_group *tu_group = item;
5659 return hash_stmt_list_entry (&tu_group->hash);
5663 eq_type_unit_group (const void *item_lhs, const void *item_rhs)
5665 const struct type_unit_group *lhs = item_lhs;
5666 const struct type_unit_group *rhs = item_rhs;
5668 return eq_stmt_list_entry (&lhs->hash, &rhs->hash);
5671 /* Allocate a hash table for type unit groups. */
5674 allocate_type_unit_groups_table (void)
5676 return htab_create_alloc_ex (3,
5677 hash_type_unit_group,
5680 &dwarf2_per_objfile->objfile->objfile_obstack,
5681 hashtab_obstack_allocate,
5682 dummy_obstack_deallocate);
5685 /* Type units that don't have DW_AT_stmt_list are grouped into their own
5686 partial symtabs. We combine several TUs per psymtab to not let the size
5687 of any one psymtab grow too big. */
5688 #define NO_STMT_LIST_TYPE_UNIT_PSYMTAB (1 << 31)
5689 #define NO_STMT_LIST_TYPE_UNIT_PSYMTAB_SIZE 10
5691 /* Helper routine for get_type_unit_group.
5692 Create the type_unit_group object used to hold one or more TUs. */
5694 static struct type_unit_group *
5695 create_type_unit_group (struct dwarf2_cu *cu, sect_offset line_offset_struct)
5697 struct objfile *objfile = dwarf2_per_objfile->objfile;
5698 struct dwarf2_per_cu_data *per_cu;
5699 struct type_unit_group *tu_group;
5701 tu_group = OBSTACK_ZALLOC (&objfile->objfile_obstack,
5702 struct type_unit_group);
5703 per_cu = &tu_group->per_cu;
5704 per_cu->objfile = objfile;
5706 if (dwarf2_per_objfile->using_index)
5708 per_cu->v.quick = OBSTACK_ZALLOC (&objfile->objfile_obstack,
5709 struct dwarf2_per_cu_quick_data);
5713 unsigned int line_offset = line_offset_struct.sect_off;
5714 struct partial_symtab *pst;
5717 /* Give the symtab a useful name for debug purposes. */
5718 if ((line_offset & NO_STMT_LIST_TYPE_UNIT_PSYMTAB) != 0)
5719 name = xstrprintf ("<type_units_%d>",
5720 (line_offset & ~NO_STMT_LIST_TYPE_UNIT_PSYMTAB));
5722 name = xstrprintf ("<type_units_at_0x%x>", line_offset);
5724 pst = create_partial_symtab (per_cu, name);
5730 tu_group->hash.dwo_unit = cu->dwo_unit;
5731 tu_group->hash.line_offset = line_offset_struct;
5736 /* Look up the type_unit_group for type unit CU, and create it if necessary.
5737 STMT_LIST is a DW_AT_stmt_list attribute. */
5739 static struct type_unit_group *
5740 get_type_unit_group (struct dwarf2_cu *cu, const struct attribute *stmt_list)
5742 struct tu_stats *tu_stats = &dwarf2_per_objfile->tu_stats;
5743 struct type_unit_group *tu_group;
5745 unsigned int line_offset;
5746 struct type_unit_group type_unit_group_for_lookup;
5748 if (dwarf2_per_objfile->type_unit_groups == NULL)
5750 dwarf2_per_objfile->type_unit_groups =
5751 allocate_type_unit_groups_table ();
5754 /* Do we need to create a new group, or can we use an existing one? */
5758 line_offset = DW_UNSND (stmt_list);
5759 ++tu_stats->nr_symtab_sharers;
5763 /* Ugh, no stmt_list. Rare, but we have to handle it.
5764 We can do various things here like create one group per TU or
5765 spread them over multiple groups to split up the expansion work.
5766 To avoid worst case scenarios (too many groups or too large groups)
5767 we, umm, group them in bunches. */
5768 line_offset = (NO_STMT_LIST_TYPE_UNIT_PSYMTAB
5769 | (tu_stats->nr_stmt_less_type_units
5770 / NO_STMT_LIST_TYPE_UNIT_PSYMTAB_SIZE));
5771 ++tu_stats->nr_stmt_less_type_units;
5774 type_unit_group_for_lookup.hash.dwo_unit = cu->dwo_unit;
5775 type_unit_group_for_lookup.hash.line_offset.sect_off = line_offset;
5776 slot = htab_find_slot (dwarf2_per_objfile->type_unit_groups,
5777 &type_unit_group_for_lookup, INSERT);
5781 gdb_assert (tu_group != NULL);
5785 sect_offset line_offset_struct;
5787 line_offset_struct.sect_off = line_offset;
5788 tu_group = create_type_unit_group (cu, line_offset_struct);
5790 ++tu_stats->nr_symtabs;
5796 /* Partial symbol tables. */
5798 /* Create a psymtab named NAME and assign it to PER_CU.
5800 The caller must fill in the following details:
5801 dirname, textlow, texthigh. */
5803 static struct partial_symtab *
5804 create_partial_symtab (struct dwarf2_per_cu_data *per_cu, const char *name)
5806 struct objfile *objfile = per_cu->objfile;
5807 struct partial_symtab *pst;
5809 pst = start_psymtab_common (objfile, objfile->section_offsets,
5811 objfile->global_psymbols.next,
5812 objfile->static_psymbols.next);
5814 pst->psymtabs_addrmap_supported = 1;
5816 /* This is the glue that links PST into GDB's symbol API. */
5817 pst->read_symtab_private = per_cu;
5818 pst->read_symtab = dwarf2_read_symtab;
5819 per_cu->v.psymtab = pst;
5824 /* The DATA object passed to process_psymtab_comp_unit_reader has this
5827 struct process_psymtab_comp_unit_data
5829 /* True if we are reading a DW_TAG_partial_unit. */
5831 int want_partial_unit;
5833 /* The "pretend" language that is used if the CU doesn't declare a
5836 enum language pretend_language;
5839 /* die_reader_func for process_psymtab_comp_unit. */
5842 process_psymtab_comp_unit_reader (const struct die_reader_specs *reader,
5843 const gdb_byte *info_ptr,
5844 struct die_info *comp_unit_die,
5848 struct dwarf2_cu *cu = reader->cu;
5849 struct objfile *objfile = cu->objfile;
5850 struct dwarf2_per_cu_data *per_cu = cu->per_cu;
5851 struct attribute *attr;
5853 CORE_ADDR best_lowpc = 0, best_highpc = 0;
5854 struct partial_symtab *pst;
5856 const char *filename;
5857 struct process_psymtab_comp_unit_data *info = data;
5859 if (comp_unit_die->tag == DW_TAG_partial_unit && !info->want_partial_unit)
5862 gdb_assert (! per_cu->is_debug_types);
5864 prepare_one_comp_unit (cu, comp_unit_die, info->pretend_language);
5866 cu->list_in_scope = &file_symbols;
5868 /* Allocate a new partial symbol table structure. */
5869 attr = dwarf2_attr (comp_unit_die, DW_AT_name, cu);
5870 if (attr == NULL || !DW_STRING (attr))
5873 filename = DW_STRING (attr);
5875 pst = create_partial_symtab (per_cu, filename);
5877 /* This must be done before calling dwarf2_build_include_psymtabs. */
5878 attr = dwarf2_attr (comp_unit_die, DW_AT_comp_dir, cu);
5880 pst->dirname = DW_STRING (attr);
5882 baseaddr = ANOFFSET (objfile->section_offsets, SECT_OFF_TEXT (objfile));
5884 dwarf2_find_base_address (comp_unit_die, cu);
5886 /* Possibly set the default values of LOWPC and HIGHPC from
5888 has_pc_info = dwarf2_get_pc_bounds (comp_unit_die, &best_lowpc,
5889 &best_highpc, cu, pst);
5890 if (has_pc_info == 1 && best_lowpc < best_highpc)
5891 /* Store the contiguous range if it is not empty; it can be empty for
5892 CUs with no code. */
5893 addrmap_set_empty (objfile->psymtabs_addrmap,
5894 best_lowpc + baseaddr,
5895 best_highpc + baseaddr - 1, pst);
5897 /* Check if comp unit has_children.
5898 If so, read the rest of the partial symbols from this comp unit.
5899 If not, there's no more debug_info for this comp unit. */
5902 struct partial_die_info *first_die;
5903 CORE_ADDR lowpc, highpc;
5905 lowpc = ((CORE_ADDR) -1);
5906 highpc = ((CORE_ADDR) 0);
5908 first_die = load_partial_dies (reader, info_ptr, 1);
5910 scan_partial_symbols (first_die, &lowpc, &highpc,
5913 /* If we didn't find a lowpc, set it to highpc to avoid
5914 complaints from `maint check'. */
5915 if (lowpc == ((CORE_ADDR) -1))
5918 /* If the compilation unit didn't have an explicit address range,
5919 then use the information extracted from its child dies. */
5923 best_highpc = highpc;
5926 pst->textlow = best_lowpc + baseaddr;
5927 pst->texthigh = best_highpc + baseaddr;
5929 pst->n_global_syms = objfile->global_psymbols.next -
5930 (objfile->global_psymbols.list + pst->globals_offset);
5931 pst->n_static_syms = objfile->static_psymbols.next -
5932 (objfile->static_psymbols.list + pst->statics_offset);
5933 sort_pst_symbols (objfile, pst);
5935 if (!VEC_empty (dwarf2_per_cu_ptr, cu->per_cu->imported_symtabs))
5938 int len = VEC_length (dwarf2_per_cu_ptr, cu->per_cu->imported_symtabs);
5939 struct dwarf2_per_cu_data *iter;
5941 /* Fill in 'dependencies' here; we fill in 'users' in a
5943 pst->number_of_dependencies = len;
5944 pst->dependencies = obstack_alloc (&objfile->objfile_obstack,
5945 len * sizeof (struct symtab *));
5947 VEC_iterate (dwarf2_per_cu_ptr, cu->per_cu->imported_symtabs,
5950 pst->dependencies[i] = iter->v.psymtab;
5952 VEC_free (dwarf2_per_cu_ptr, cu->per_cu->imported_symtabs);
5955 /* Get the list of files included in the current compilation unit,
5956 and build a psymtab for each of them. */
5957 dwarf2_build_include_psymtabs (cu, comp_unit_die, pst);
5959 if (dwarf2_read_debug)
5961 struct gdbarch *gdbarch = get_objfile_arch (objfile);
5963 fprintf_unfiltered (gdb_stdlog,
5964 "Psymtab for %s unit @0x%x: %s - %s"
5965 ", %d global, %d static syms\n",
5966 per_cu->is_debug_types ? "type" : "comp",
5967 per_cu->offset.sect_off,
5968 paddress (gdbarch, pst->textlow),
5969 paddress (gdbarch, pst->texthigh),
5970 pst->n_global_syms, pst->n_static_syms);
5974 /* Subroutine of dwarf2_build_psymtabs_hard to simplify it.
5975 Process compilation unit THIS_CU for a psymtab. */
5978 process_psymtab_comp_unit (struct dwarf2_per_cu_data *this_cu,
5979 int want_partial_unit,
5980 enum language pretend_language)
5982 struct process_psymtab_comp_unit_data info;
5984 /* If this compilation unit was already read in, free the
5985 cached copy in order to read it in again. This is
5986 necessary because we skipped some symbols when we first
5987 read in the compilation unit (see load_partial_dies).
5988 This problem could be avoided, but the benefit is unclear. */
5989 if (this_cu->cu != NULL)
5990 free_one_cached_comp_unit (this_cu);
5992 gdb_assert (! this_cu->is_debug_types);
5993 info.want_partial_unit = want_partial_unit;
5994 info.pretend_language = pretend_language;
5995 init_cutu_and_read_dies (this_cu, NULL, 0, 0,
5996 process_psymtab_comp_unit_reader,
5999 /* Age out any secondary CUs. */
6000 age_cached_comp_units ();
6003 /* Reader function for build_type_psymtabs. */
6006 build_type_psymtabs_reader (const struct die_reader_specs *reader,
6007 const gdb_byte *info_ptr,
6008 struct die_info *type_unit_die,
6012 struct objfile *objfile = dwarf2_per_objfile->objfile;
6013 struct dwarf2_cu *cu = reader->cu;
6014 struct dwarf2_per_cu_data *per_cu = cu->per_cu;
6015 struct signatured_type *sig_type;
6016 struct type_unit_group *tu_group;
6017 struct attribute *attr;
6018 struct partial_die_info *first_die;
6019 CORE_ADDR lowpc, highpc;
6020 struct partial_symtab *pst;
6022 gdb_assert (data == NULL);
6023 gdb_assert (per_cu->is_debug_types);
6024 sig_type = (struct signatured_type *) per_cu;
6029 attr = dwarf2_attr_no_follow (type_unit_die, DW_AT_stmt_list);
6030 tu_group = get_type_unit_group (cu, attr);
6032 VEC_safe_push (sig_type_ptr, tu_group->tus, sig_type);
6034 prepare_one_comp_unit (cu, type_unit_die, language_minimal);
6035 cu->list_in_scope = &file_symbols;
6036 pst = create_partial_symtab (per_cu, "");
6039 first_die = load_partial_dies (reader, info_ptr, 1);
6041 lowpc = (CORE_ADDR) -1;
6042 highpc = (CORE_ADDR) 0;
6043 scan_partial_symbols (first_die, &lowpc, &highpc, 0, cu);
6045 pst->n_global_syms = objfile->global_psymbols.next -
6046 (objfile->global_psymbols.list + pst->globals_offset);
6047 pst->n_static_syms = objfile->static_psymbols.next -
6048 (objfile->static_psymbols.list + pst->statics_offset);
6049 sort_pst_symbols (objfile, pst);
6052 /* Struct used to sort TUs by their abbreviation table offset. */
6054 struct tu_abbrev_offset
6056 struct signatured_type *sig_type;
6057 sect_offset abbrev_offset;
6060 /* Helper routine for build_type_psymtabs_1, passed to qsort. */
6063 sort_tu_by_abbrev_offset (const void *ap, const void *bp)
6065 const struct tu_abbrev_offset * const *a = ap;
6066 const struct tu_abbrev_offset * const *b = bp;
6067 unsigned int aoff = (*a)->abbrev_offset.sect_off;
6068 unsigned int boff = (*b)->abbrev_offset.sect_off;
6070 return (aoff > boff) - (aoff < boff);
6073 /* Efficiently read all the type units.
6074 This does the bulk of the work for build_type_psymtabs.
6076 The efficiency is because we sort TUs by the abbrev table they use and
6077 only read each abbrev table once. In one program there are 200K TUs
6078 sharing 8K abbrev tables.
6080 The main purpose of this function is to support building the
6081 dwarf2_per_objfile->type_unit_groups table.
6082 TUs typically share the DW_AT_stmt_list of the CU they came from, so we
6083 can collapse the search space by grouping them by stmt_list.
6084 The savings can be significant, in the same program from above the 200K TUs
6085 share 8K stmt_list tables.
6087 FUNC is expected to call get_type_unit_group, which will create the
6088 struct type_unit_group if necessary and add it to
6089 dwarf2_per_objfile->type_unit_groups. */
6092 build_type_psymtabs_1 (void)
6094 struct objfile *objfile = dwarf2_per_objfile->objfile;
6095 struct tu_stats *tu_stats = &dwarf2_per_objfile->tu_stats;
6096 struct cleanup *cleanups;
6097 struct abbrev_table *abbrev_table;
6098 sect_offset abbrev_offset;
6099 struct tu_abbrev_offset *sorted_by_abbrev;
6100 struct type_unit_group **iter;
6103 /* It's up to the caller to not call us multiple times. */
6104 gdb_assert (dwarf2_per_objfile->type_unit_groups == NULL);
6106 if (dwarf2_per_objfile->n_type_units == 0)
6109 /* TUs typically share abbrev tables, and there can be way more TUs than
6110 abbrev tables. Sort by abbrev table to reduce the number of times we
6111 read each abbrev table in.
6112 Alternatives are to punt or to maintain a cache of abbrev tables.
6113 This is simpler and efficient enough for now.
6115 Later we group TUs by their DW_AT_stmt_list value (as this defines the
6116 symtab to use). Typically TUs with the same abbrev offset have the same
6117 stmt_list value too so in practice this should work well.
6119 The basic algorithm here is:
6121 sort TUs by abbrev table
6122 for each TU with same abbrev table:
6123 read abbrev table if first user
6124 read TU top level DIE
6125 [IWBN if DWO skeletons had DW_AT_stmt_list]
6128 if (dwarf2_read_debug)
6129 fprintf_unfiltered (gdb_stdlog, "Building type unit groups ...\n");
6131 /* Sort in a separate table to maintain the order of all_type_units
6132 for .gdb_index: TU indices directly index all_type_units. */
6133 sorted_by_abbrev = XNEWVEC (struct tu_abbrev_offset,
6134 dwarf2_per_objfile->n_type_units);
6135 for (i = 0; i < dwarf2_per_objfile->n_type_units; ++i)
6137 struct signatured_type *sig_type = dwarf2_per_objfile->all_type_units[i];
6139 sorted_by_abbrev[i].sig_type = sig_type;
6140 sorted_by_abbrev[i].abbrev_offset =
6141 read_abbrev_offset (sig_type->per_cu.section,
6142 sig_type->per_cu.offset);
6144 cleanups = make_cleanup (xfree, sorted_by_abbrev);
6145 qsort (sorted_by_abbrev, dwarf2_per_objfile->n_type_units,
6146 sizeof (struct tu_abbrev_offset), sort_tu_by_abbrev_offset);
6148 abbrev_offset.sect_off = ~(unsigned) 0;
6149 abbrev_table = NULL;
6150 make_cleanup (abbrev_table_free_cleanup, &abbrev_table);
6152 for (i = 0; i < dwarf2_per_objfile->n_type_units; ++i)
6154 const struct tu_abbrev_offset *tu = &sorted_by_abbrev[i];
6156 /* Switch to the next abbrev table if necessary. */
6157 if (abbrev_table == NULL
6158 || tu->abbrev_offset.sect_off != abbrev_offset.sect_off)
6160 if (abbrev_table != NULL)
6162 abbrev_table_free (abbrev_table);
6163 /* Reset to NULL in case abbrev_table_read_table throws
6164 an error: abbrev_table_free_cleanup will get called. */
6165 abbrev_table = NULL;
6167 abbrev_offset = tu->abbrev_offset;
6169 abbrev_table_read_table (&dwarf2_per_objfile->abbrev,
6171 ++tu_stats->nr_uniq_abbrev_tables;
6174 init_cutu_and_read_dies (&tu->sig_type->per_cu, abbrev_table, 0, 0,
6175 build_type_psymtabs_reader, NULL);
6178 do_cleanups (cleanups);
6181 /* Print collected type unit statistics. */
6184 print_tu_stats (void)
6186 struct tu_stats *tu_stats = &dwarf2_per_objfile->tu_stats;
6188 fprintf_unfiltered (gdb_stdlog, "Type unit statistics:\n");
6189 fprintf_unfiltered (gdb_stdlog, " %d TUs\n",
6190 dwarf2_per_objfile->n_type_units);
6191 fprintf_unfiltered (gdb_stdlog, " %d uniq abbrev tables\n",
6192 tu_stats->nr_uniq_abbrev_tables);
6193 fprintf_unfiltered (gdb_stdlog, " %d symtabs from stmt_list entries\n",
6194 tu_stats->nr_symtabs);
6195 fprintf_unfiltered (gdb_stdlog, " %d symtab sharers\n",
6196 tu_stats->nr_symtab_sharers);
6197 fprintf_unfiltered (gdb_stdlog, " %d type units without a stmt_list\n",
6198 tu_stats->nr_stmt_less_type_units);
6199 fprintf_unfiltered (gdb_stdlog, " %d all_type_units reallocs\n",
6200 tu_stats->nr_all_type_units_reallocs);
6203 /* Traversal function for build_type_psymtabs. */
6206 build_type_psymtab_dependencies (void **slot, void *info)
6208 struct objfile *objfile = dwarf2_per_objfile->objfile;
6209 struct type_unit_group *tu_group = (struct type_unit_group *) *slot;
6210 struct dwarf2_per_cu_data *per_cu = &tu_group->per_cu;
6211 struct partial_symtab *pst = per_cu->v.psymtab;
6212 int len = VEC_length (sig_type_ptr, tu_group->tus);
6213 struct signatured_type *iter;
6216 gdb_assert (len > 0);
6217 gdb_assert (IS_TYPE_UNIT_GROUP (per_cu));
6219 pst->number_of_dependencies = len;
6220 pst->dependencies = obstack_alloc (&objfile->objfile_obstack,
6221 len * sizeof (struct psymtab *));
6223 VEC_iterate (sig_type_ptr, tu_group->tus, i, iter);
6226 gdb_assert (iter->per_cu.is_debug_types);
6227 pst->dependencies[i] = iter->per_cu.v.psymtab;
6228 iter->type_unit_group = tu_group;
6231 VEC_free (sig_type_ptr, tu_group->tus);
6236 /* Subroutine of dwarf2_build_psymtabs_hard to simplify it.
6237 Build partial symbol tables for the .debug_types comp-units. */
6240 build_type_psymtabs (struct objfile *objfile)
6242 if (! create_all_type_units (objfile))
6245 build_type_psymtabs_1 ();
6248 /* Traversal function for process_skeletonless_type_unit.
6249 Read a TU in a DWO file and build partial symbols for it. */
6252 process_skeletonless_type_unit (void **slot, void *info)
6254 struct dwo_unit *dwo_unit = (struct dwo_unit *) *slot;
6255 struct objfile *objfile = info;
6256 struct signatured_type find_entry, *entry;
6258 /* If this TU doesn't exist in the global table, add it and read it in. */
6260 if (dwarf2_per_objfile->signatured_types == NULL)
6262 dwarf2_per_objfile->signatured_types
6263 = allocate_signatured_type_table (objfile);
6266 find_entry.signature = dwo_unit->signature;
6267 slot = htab_find_slot (dwarf2_per_objfile->signatured_types, &find_entry,
6269 /* If we've already seen this type there's nothing to do. What's happening
6270 is we're doing our own version of comdat-folding here. */
6274 /* This does the job that create_all_type_units would have done for
6276 entry = add_type_unit (dwo_unit->signature, slot);
6277 fill_in_sig_entry_from_dwo_entry (objfile, entry, dwo_unit);
6280 /* This does the job that build_type_psymtabs_1 would have done. */
6281 init_cutu_and_read_dies (&entry->per_cu, NULL, 0, 0,
6282 build_type_psymtabs_reader, NULL);
6287 /* Traversal function for process_skeletonless_type_units. */
6290 process_dwo_file_for_skeletonless_type_units (void **slot, void *info)
6292 struct dwo_file *dwo_file = (struct dwo_file *) *slot;
6294 if (dwo_file->tus != NULL)
6296 htab_traverse_noresize (dwo_file->tus,
6297 process_skeletonless_type_unit, info);
6303 /* Scan all TUs of DWO files, verifying we've processed them.
6304 This is needed in case a TU was emitted without its skeleton.
6305 Note: This can't be done until we know what all the DWO files are. */
6308 process_skeletonless_type_units (struct objfile *objfile)
6310 /* Skeletonless TUs in DWP files without .gdb_index is not supported yet. */
6311 if (get_dwp_file () == NULL
6312 && dwarf2_per_objfile->dwo_files != NULL)
6314 htab_traverse_noresize (dwarf2_per_objfile->dwo_files,
6315 process_dwo_file_for_skeletonless_type_units,
6320 /* A cleanup function that clears objfile's psymtabs_addrmap field. */
6323 psymtabs_addrmap_cleanup (void *o)
6325 struct objfile *objfile = o;
6327 objfile->psymtabs_addrmap = NULL;
6330 /* Compute the 'user' field for each psymtab in OBJFILE. */
6333 set_partial_user (struct objfile *objfile)
6337 for (i = 0; i < dwarf2_per_objfile->n_comp_units; ++i)
6339 struct dwarf2_per_cu_data *per_cu = dw2_get_cutu (i);
6340 struct partial_symtab *pst = per_cu->v.psymtab;
6346 for (j = 0; j < pst->number_of_dependencies; ++j)
6348 /* Set the 'user' field only if it is not already set. */
6349 if (pst->dependencies[j]->user == NULL)
6350 pst->dependencies[j]->user = pst;
6355 /* Build the partial symbol table by doing a quick pass through the
6356 .debug_info and .debug_abbrev sections. */
6359 dwarf2_build_psymtabs_hard (struct objfile *objfile)
6361 struct cleanup *back_to, *addrmap_cleanup;
6362 struct obstack temp_obstack;
6365 if (dwarf2_read_debug)
6367 fprintf_unfiltered (gdb_stdlog, "Building psymtabs of objfile %s ...\n",
6368 objfile_name (objfile));
6371 dwarf2_per_objfile->reading_partial_symbols = 1;
6373 dwarf2_read_section (objfile, &dwarf2_per_objfile->info);
6375 /* Any cached compilation units will be linked by the per-objfile
6376 read_in_chain. Make sure to free them when we're done. */
6377 back_to = make_cleanup (free_cached_comp_units, NULL);
6379 build_type_psymtabs (objfile);
6381 create_all_comp_units (objfile);
6383 /* Create a temporary address map on a temporary obstack. We later
6384 copy this to the final obstack. */
6385 obstack_init (&temp_obstack);
6386 make_cleanup_obstack_free (&temp_obstack);
6387 objfile->psymtabs_addrmap = addrmap_create_mutable (&temp_obstack);
6388 addrmap_cleanup = make_cleanup (psymtabs_addrmap_cleanup, objfile);
6390 for (i = 0; i < dwarf2_per_objfile->n_comp_units; ++i)
6392 struct dwarf2_per_cu_data *per_cu = dw2_get_cutu (i);
6394 process_psymtab_comp_unit (per_cu, 0, language_minimal);
6397 /* This has to wait until we read the CUs, we need the list of DWOs. */
6398 process_skeletonless_type_units (objfile);
6400 /* Now that all TUs have been processed we can fill in the dependencies. */
6401 if (dwarf2_per_objfile->type_unit_groups != NULL)
6403 htab_traverse_noresize (dwarf2_per_objfile->type_unit_groups,
6404 build_type_psymtab_dependencies, NULL);
6407 if (dwarf2_read_debug)
6410 set_partial_user (objfile);
6412 objfile->psymtabs_addrmap = addrmap_create_fixed (objfile->psymtabs_addrmap,
6413 &objfile->objfile_obstack);
6414 discard_cleanups (addrmap_cleanup);
6416 do_cleanups (back_to);
6418 if (dwarf2_read_debug)
6419 fprintf_unfiltered (gdb_stdlog, "Done building psymtabs of %s\n",
6420 objfile_name (objfile));
6423 /* die_reader_func for load_partial_comp_unit. */
6426 load_partial_comp_unit_reader (const struct die_reader_specs *reader,
6427 const gdb_byte *info_ptr,
6428 struct die_info *comp_unit_die,
6432 struct dwarf2_cu *cu = reader->cu;
6434 prepare_one_comp_unit (cu, comp_unit_die, language_minimal);
6436 /* Check if comp unit has_children.
6437 If so, read the rest of the partial symbols from this comp unit.
6438 If not, there's no more debug_info for this comp unit. */
6440 load_partial_dies (reader, info_ptr, 0);
6443 /* Load the partial DIEs for a secondary CU into memory.
6444 This is also used when rereading a primary CU with load_all_dies. */
6447 load_partial_comp_unit (struct dwarf2_per_cu_data *this_cu)
6449 init_cutu_and_read_dies (this_cu, NULL, 1, 1,
6450 load_partial_comp_unit_reader, NULL);
6454 read_comp_units_from_section (struct objfile *objfile,
6455 struct dwarf2_section_info *section,
6456 unsigned int is_dwz,
6459 struct dwarf2_per_cu_data ***all_comp_units)
6461 const gdb_byte *info_ptr;
6462 bfd *abfd = get_section_bfd_owner (section);
6464 if (dwarf2_read_debug)
6465 fprintf_unfiltered (gdb_stdlog, "Reading %s for %s\n",
6466 get_section_name (section),
6467 get_section_file_name (section));
6469 dwarf2_read_section (objfile, section);
6471 info_ptr = section->buffer;
6473 while (info_ptr < section->buffer + section->size)
6475 unsigned int length, initial_length_size;
6476 struct dwarf2_per_cu_data *this_cu;
6479 offset.sect_off = info_ptr - section->buffer;
6481 /* Read just enough information to find out where the next
6482 compilation unit is. */
6483 length = read_initial_length (abfd, info_ptr, &initial_length_size);
6485 /* Save the compilation unit for later lookup. */
6486 this_cu = obstack_alloc (&objfile->objfile_obstack,
6487 sizeof (struct dwarf2_per_cu_data));
6488 memset (this_cu, 0, sizeof (*this_cu));
6489 this_cu->offset = offset;
6490 this_cu->length = length + initial_length_size;
6491 this_cu->is_dwz = is_dwz;
6492 this_cu->objfile = objfile;
6493 this_cu->section = section;
6495 if (*n_comp_units == *n_allocated)
6498 *all_comp_units = xrealloc (*all_comp_units,
6500 * sizeof (struct dwarf2_per_cu_data *));
6502 (*all_comp_units)[*n_comp_units] = this_cu;
6505 info_ptr = info_ptr + this_cu->length;
6509 /* Create a list of all compilation units in OBJFILE.
6510 This is only done for -readnow and building partial symtabs. */
6513 create_all_comp_units (struct objfile *objfile)
6517 struct dwarf2_per_cu_data **all_comp_units;
6518 struct dwz_file *dwz;
6522 all_comp_units = xmalloc (n_allocated
6523 * sizeof (struct dwarf2_per_cu_data *));
6525 read_comp_units_from_section (objfile, &dwarf2_per_objfile->info, 0,
6526 &n_allocated, &n_comp_units, &all_comp_units);
6528 dwz = dwarf2_get_dwz_file ();
6530 read_comp_units_from_section (objfile, &dwz->info, 1,
6531 &n_allocated, &n_comp_units,
6534 dwarf2_per_objfile->all_comp_units
6535 = obstack_alloc (&objfile->objfile_obstack,
6536 n_comp_units * sizeof (struct dwarf2_per_cu_data *));
6537 memcpy (dwarf2_per_objfile->all_comp_units, all_comp_units,
6538 n_comp_units * sizeof (struct dwarf2_per_cu_data *));
6539 xfree (all_comp_units);
6540 dwarf2_per_objfile->n_comp_units = n_comp_units;
6543 /* Process all loaded DIEs for compilation unit CU, starting at
6544 FIRST_DIE. The caller should pass SET_ADDRMAP == 1 if the compilation
6545 unit DIE did not have PC info (DW_AT_low_pc and DW_AT_high_pc, or
6546 DW_AT_ranges). See the comments of add_partial_subprogram on how
6547 SET_ADDRMAP is used and how *LOWPC and *HIGHPC are updated. */
6550 scan_partial_symbols (struct partial_die_info *first_die, CORE_ADDR *lowpc,
6551 CORE_ADDR *highpc, int set_addrmap,
6552 struct dwarf2_cu *cu)
6554 struct partial_die_info *pdi;
6556 /* Now, march along the PDI's, descending into ones which have
6557 interesting children but skipping the children of the other ones,
6558 until we reach the end of the compilation unit. */
6564 fixup_partial_die (pdi, cu);
6566 /* Anonymous namespaces or modules have no name but have interesting
6567 children, so we need to look at them. Ditto for anonymous
6570 if (pdi->name != NULL || pdi->tag == DW_TAG_namespace
6571 || pdi->tag == DW_TAG_module || pdi->tag == DW_TAG_enumeration_type
6572 || pdi->tag == DW_TAG_imported_unit)
6576 case DW_TAG_subprogram:
6577 add_partial_subprogram (pdi, lowpc, highpc, set_addrmap, cu);
6579 case DW_TAG_constant:
6580 case DW_TAG_variable:
6581 case DW_TAG_typedef:
6582 case DW_TAG_union_type:
6583 if (!pdi->is_declaration)
6585 add_partial_symbol (pdi, cu);
6588 case DW_TAG_class_type:
6589 case DW_TAG_interface_type:
6590 case DW_TAG_structure_type:
6591 if (!pdi->is_declaration)
6593 add_partial_symbol (pdi, cu);
6596 case DW_TAG_enumeration_type:
6597 if (!pdi->is_declaration)
6598 add_partial_enumeration (pdi, cu);
6600 case DW_TAG_base_type:
6601 case DW_TAG_subrange_type:
6602 /* File scope base type definitions are added to the partial
6604 add_partial_symbol (pdi, cu);
6606 case DW_TAG_namespace:
6607 add_partial_namespace (pdi, lowpc, highpc, set_addrmap, cu);
6610 add_partial_module (pdi, lowpc, highpc, set_addrmap, cu);
6612 case DW_TAG_imported_unit:
6614 struct dwarf2_per_cu_data *per_cu;
6616 /* For now we don't handle imported units in type units. */
6617 if (cu->per_cu->is_debug_types)
6619 error (_("Dwarf Error: DW_TAG_imported_unit is not"
6620 " supported in type units [in module %s]"),
6621 objfile_name (cu->objfile));
6624 per_cu = dwarf2_find_containing_comp_unit (pdi->d.offset,
6628 /* Go read the partial unit, if needed. */
6629 if (per_cu->v.psymtab == NULL)
6630 process_psymtab_comp_unit (per_cu, 1, cu->language);
6632 VEC_safe_push (dwarf2_per_cu_ptr,
6633 cu->per_cu->imported_symtabs, per_cu);
6636 case DW_TAG_imported_declaration:
6637 add_partial_symbol (pdi, cu);
6644 /* If the die has a sibling, skip to the sibling. */
6646 pdi = pdi->die_sibling;
6650 /* Functions used to compute the fully scoped name of a partial DIE.
6652 Normally, this is simple. For C++, the parent DIE's fully scoped
6653 name is concatenated with "::" and the partial DIE's name. For
6654 Java, the same thing occurs except that "." is used instead of "::".
6655 Enumerators are an exception; they use the scope of their parent
6656 enumeration type, i.e. the name of the enumeration type is not
6657 prepended to the enumerator.
6659 There are two complexities. One is DW_AT_specification; in this
6660 case "parent" means the parent of the target of the specification,
6661 instead of the direct parent of the DIE. The other is compilers
6662 which do not emit DW_TAG_namespace; in this case we try to guess
6663 the fully qualified name of structure types from their members'
6664 linkage names. This must be done using the DIE's children rather
6665 than the children of any DW_AT_specification target. We only need
6666 to do this for structures at the top level, i.e. if the target of
6667 any DW_AT_specification (if any; otherwise the DIE itself) does not
6670 /* Compute the scope prefix associated with PDI's parent, in
6671 compilation unit CU. The result will be allocated on CU's
6672 comp_unit_obstack, or a copy of the already allocated PDI->NAME
6673 field. NULL is returned if no prefix is necessary. */
6675 partial_die_parent_scope (struct partial_die_info *pdi,
6676 struct dwarf2_cu *cu)
6678 const char *grandparent_scope;
6679 struct partial_die_info *parent, *real_pdi;
6681 /* We need to look at our parent DIE; if we have a DW_AT_specification,
6682 then this means the parent of the specification DIE. */
6685 while (real_pdi->has_specification)
6686 real_pdi = find_partial_die (real_pdi->spec_offset,
6687 real_pdi->spec_is_dwz, cu);
6689 parent = real_pdi->die_parent;
6693 if (parent->scope_set)
6694 return parent->scope;
6696 fixup_partial_die (parent, cu);
6698 grandparent_scope = partial_die_parent_scope (parent, cu);
6700 /* GCC 4.0 and 4.1 had a bug (PR c++/28460) where they generated bogus
6701 DW_TAG_namespace DIEs with a name of "::" for the global namespace.
6702 Work around this problem here. */
6703 if (cu->language == language_cplus
6704 && parent->tag == DW_TAG_namespace
6705 && strcmp (parent->name, "::") == 0
6706 && grandparent_scope == NULL)
6708 parent->scope = NULL;
6709 parent->scope_set = 1;
6713 if (pdi->tag == DW_TAG_enumerator)
6714 /* Enumerators should not get the name of the enumeration as a prefix. */
6715 parent->scope = grandparent_scope;
6716 else if (parent->tag == DW_TAG_namespace
6717 || parent->tag == DW_TAG_module
6718 || parent->tag == DW_TAG_structure_type
6719 || parent->tag == DW_TAG_class_type
6720 || parent->tag == DW_TAG_interface_type
6721 || parent->tag == DW_TAG_union_type
6722 || parent->tag == DW_TAG_enumeration_type)
6724 if (grandparent_scope == NULL)
6725 parent->scope = parent->name;
6727 parent->scope = typename_concat (&cu->comp_unit_obstack,
6729 parent->name, 0, cu);
6733 /* FIXME drow/2004-04-01: What should we be doing with
6734 function-local names? For partial symbols, we should probably be
6736 complaint (&symfile_complaints,
6737 _("unhandled containing DIE tag %d for DIE at %d"),
6738 parent->tag, pdi->offset.sect_off);
6739 parent->scope = grandparent_scope;
6742 parent->scope_set = 1;
6743 return parent->scope;
6746 /* Return the fully scoped name associated with PDI, from compilation unit
6747 CU. The result will be allocated with malloc. */
6750 partial_die_full_name (struct partial_die_info *pdi,
6751 struct dwarf2_cu *cu)
6753 const char *parent_scope;
6755 /* If this is a template instantiation, we can not work out the
6756 template arguments from partial DIEs. So, unfortunately, we have
6757 to go through the full DIEs. At least any work we do building
6758 types here will be reused if full symbols are loaded later. */
6759 if (pdi->has_template_arguments)
6761 fixup_partial_die (pdi, cu);
6763 if (pdi->name != NULL && strchr (pdi->name, '<') == NULL)
6765 struct die_info *die;
6766 struct attribute attr;
6767 struct dwarf2_cu *ref_cu = cu;
6769 /* DW_FORM_ref_addr is using section offset. */
6771 attr.form = DW_FORM_ref_addr;
6772 attr.u.unsnd = pdi->offset.sect_off;
6773 die = follow_die_ref (NULL, &attr, &ref_cu);
6775 return xstrdup (dwarf2_full_name (NULL, die, ref_cu));
6779 parent_scope = partial_die_parent_scope (pdi, cu);
6780 if (parent_scope == NULL)
6783 return typename_concat (NULL, parent_scope, pdi->name, 0, cu);
6787 add_partial_symbol (struct partial_die_info *pdi, struct dwarf2_cu *cu)
6789 struct objfile *objfile = cu->objfile;
6791 const char *actual_name = NULL;
6793 char *built_actual_name;
6795 baseaddr = ANOFFSET (objfile->section_offsets, SECT_OFF_TEXT (objfile));
6797 built_actual_name = partial_die_full_name (pdi, cu);
6798 if (built_actual_name != NULL)
6799 actual_name = built_actual_name;
6801 if (actual_name == NULL)
6802 actual_name = pdi->name;
6806 case DW_TAG_subprogram:
6807 if (pdi->is_external || cu->language == language_ada)
6809 /* brobecker/2007-12-26: Normally, only "external" DIEs are part
6810 of the global scope. But in Ada, we want to be able to access
6811 nested procedures globally. So all Ada subprograms are stored
6812 in the global scope. */
6813 /* prim_record_minimal_symbol (actual_name, pdi->lowpc + baseaddr,
6814 mst_text, objfile); */
6815 add_psymbol_to_list (actual_name, strlen (actual_name),
6816 built_actual_name != NULL,
6817 VAR_DOMAIN, LOC_BLOCK,
6818 &objfile->global_psymbols,
6819 0, pdi->lowpc + baseaddr,
6820 cu->language, objfile);
6824 /* prim_record_minimal_symbol (actual_name, pdi->lowpc + baseaddr,
6825 mst_file_text, objfile); */
6826 add_psymbol_to_list (actual_name, strlen (actual_name),
6827 built_actual_name != NULL,
6828 VAR_DOMAIN, LOC_BLOCK,
6829 &objfile->static_psymbols,
6830 0, pdi->lowpc + baseaddr,
6831 cu->language, objfile);
6834 case DW_TAG_constant:
6836 struct psymbol_allocation_list *list;
6838 if (pdi->is_external)
6839 list = &objfile->global_psymbols;
6841 list = &objfile->static_psymbols;
6842 add_psymbol_to_list (actual_name, strlen (actual_name),
6843 built_actual_name != NULL, VAR_DOMAIN, LOC_STATIC,
6844 list, 0, 0, cu->language, objfile);
6847 case DW_TAG_variable:
6849 addr = decode_locdesc (pdi->d.locdesc, cu);
6853 && !dwarf2_per_objfile->has_section_at_zero)
6855 /* A global or static variable may also have been stripped
6856 out by the linker if unused, in which case its address
6857 will be nullified; do not add such variables into partial
6858 symbol table then. */
6860 else if (pdi->is_external)
6863 Don't enter into the minimal symbol tables as there is
6864 a minimal symbol table entry from the ELF symbols already.
6865 Enter into partial symbol table if it has a location
6866 descriptor or a type.
6867 If the location descriptor is missing, new_symbol will create
6868 a LOC_UNRESOLVED symbol, the address of the variable will then
6869 be determined from the minimal symbol table whenever the variable
6871 The address for the partial symbol table entry is not
6872 used by GDB, but it comes in handy for debugging partial symbol
6875 if (pdi->d.locdesc || pdi->has_type)
6876 add_psymbol_to_list (actual_name, strlen (actual_name),
6877 built_actual_name != NULL,
6878 VAR_DOMAIN, LOC_STATIC,
6879 &objfile->global_psymbols,
6881 cu->language, objfile);
6885 /* Static Variable. Skip symbols without location descriptors. */
6886 if (pdi->d.locdesc == NULL)
6888 xfree (built_actual_name);
6891 /* prim_record_minimal_symbol (actual_name, addr + baseaddr,
6892 mst_file_data, objfile); */
6893 add_psymbol_to_list (actual_name, strlen (actual_name),
6894 built_actual_name != NULL,
6895 VAR_DOMAIN, LOC_STATIC,
6896 &objfile->static_psymbols,
6898 cu->language, objfile);
6901 case DW_TAG_typedef:
6902 case DW_TAG_base_type:
6903 case DW_TAG_subrange_type:
6904 add_psymbol_to_list (actual_name, strlen (actual_name),
6905 built_actual_name != NULL,
6906 VAR_DOMAIN, LOC_TYPEDEF,
6907 &objfile->static_psymbols,
6908 0, (CORE_ADDR) 0, cu->language, objfile);
6910 case DW_TAG_imported_declaration:
6911 case DW_TAG_namespace:
6912 add_psymbol_to_list (actual_name, strlen (actual_name),
6913 built_actual_name != NULL,
6914 VAR_DOMAIN, LOC_TYPEDEF,
6915 &objfile->global_psymbols,
6916 0, (CORE_ADDR) 0, cu->language, objfile);
6919 add_psymbol_to_list (actual_name, strlen (actual_name),
6920 built_actual_name != NULL,
6921 MODULE_DOMAIN, LOC_TYPEDEF,
6922 &objfile->global_psymbols,
6923 0, (CORE_ADDR) 0, cu->language, objfile);
6925 case DW_TAG_class_type:
6926 case DW_TAG_interface_type:
6927 case DW_TAG_structure_type:
6928 case DW_TAG_union_type:
6929 case DW_TAG_enumeration_type:
6930 /* Skip external references. The DWARF standard says in the section
6931 about "Structure, Union, and Class Type Entries": "An incomplete
6932 structure, union or class type is represented by a structure,
6933 union or class entry that does not have a byte size attribute
6934 and that has a DW_AT_declaration attribute." */
6935 if (!pdi->has_byte_size && pdi->is_declaration)
6937 xfree (built_actual_name);
6941 /* NOTE: carlton/2003-10-07: See comment in new_symbol about
6942 static vs. global. */
6943 add_psymbol_to_list (actual_name, strlen (actual_name),
6944 built_actual_name != NULL,
6945 STRUCT_DOMAIN, LOC_TYPEDEF,
6946 (cu->language == language_cplus
6947 || cu->language == language_java)
6948 ? &objfile->global_psymbols
6949 : &objfile->static_psymbols,
6950 0, (CORE_ADDR) 0, cu->language, objfile);
6953 case DW_TAG_enumerator:
6954 add_psymbol_to_list (actual_name, strlen (actual_name),
6955 built_actual_name != NULL,
6956 VAR_DOMAIN, LOC_CONST,
6957 (cu->language == language_cplus
6958 || cu->language == language_java)
6959 ? &objfile->global_psymbols
6960 : &objfile->static_psymbols,
6961 0, (CORE_ADDR) 0, cu->language, objfile);
6967 xfree (built_actual_name);
6970 /* Read a partial die corresponding to a namespace; also, add a symbol
6971 corresponding to that namespace to the symbol table. NAMESPACE is
6972 the name of the enclosing namespace. */
6975 add_partial_namespace (struct partial_die_info *pdi,
6976 CORE_ADDR *lowpc, CORE_ADDR *highpc,
6977 int set_addrmap, struct dwarf2_cu *cu)
6979 /* Add a symbol for the namespace. */
6981 add_partial_symbol (pdi, cu);
6983 /* Now scan partial symbols in that namespace. */
6985 if (pdi->has_children)
6986 scan_partial_symbols (pdi->die_child, lowpc, highpc, set_addrmap, cu);
6989 /* Read a partial die corresponding to a Fortran module. */
6992 add_partial_module (struct partial_die_info *pdi, CORE_ADDR *lowpc,
6993 CORE_ADDR *highpc, int set_addrmap, struct dwarf2_cu *cu)
6995 /* Add a symbol for the namespace. */
6997 add_partial_symbol (pdi, cu);
6999 /* Now scan partial symbols in that module. */
7001 if (pdi->has_children)
7002 scan_partial_symbols (pdi->die_child, lowpc, highpc, set_addrmap, cu);
7005 /* Read a partial die corresponding to a subprogram and create a partial
7006 symbol for that subprogram. When the CU language allows it, this
7007 routine also defines a partial symbol for each nested subprogram
7008 that this subprogram contains. If SET_ADDRMAP is true, record the
7009 covered ranges in the addrmap. Set *LOWPC and *HIGHPC to the lowest
7010 and highest PC values found in PDI.
7012 PDI may also be a lexical block, in which case we simply search
7013 recursively for subprograms defined inside that lexical block.
7014 Again, this is only performed when the CU language allows this
7015 type of definitions. */
7018 add_partial_subprogram (struct partial_die_info *pdi,
7019 CORE_ADDR *lowpc, CORE_ADDR *highpc,
7020 int set_addrmap, struct dwarf2_cu *cu)
7022 if (pdi->tag == DW_TAG_subprogram)
7024 if (pdi->has_pc_info)
7026 if (pdi->lowpc < *lowpc)
7027 *lowpc = pdi->lowpc;
7028 if (pdi->highpc > *highpc)
7029 *highpc = pdi->highpc;
7033 struct objfile *objfile = cu->objfile;
7035 baseaddr = ANOFFSET (objfile->section_offsets,
7036 SECT_OFF_TEXT (objfile));
7037 addrmap_set_empty (objfile->psymtabs_addrmap,
7038 pdi->lowpc + baseaddr,
7039 pdi->highpc - 1 + baseaddr,
7040 cu->per_cu->v.psymtab);
7044 if (pdi->has_pc_info || (!pdi->is_external && pdi->may_be_inlined))
7046 if (!pdi->is_declaration)
7047 /* Ignore subprogram DIEs that do not have a name, they are
7048 illegal. Do not emit a complaint at this point, we will
7049 do so when we convert this psymtab into a symtab. */
7051 add_partial_symbol (pdi, cu);
7055 if (! pdi->has_children)
7058 if (cu->language == language_ada)
7060 pdi = pdi->die_child;
7063 fixup_partial_die (pdi, cu);
7064 if (pdi->tag == DW_TAG_subprogram
7065 || pdi->tag == DW_TAG_lexical_block)
7066 add_partial_subprogram (pdi, lowpc, highpc, set_addrmap, cu);
7067 pdi = pdi->die_sibling;
7072 /* Read a partial die corresponding to an enumeration type. */
7075 add_partial_enumeration (struct partial_die_info *enum_pdi,
7076 struct dwarf2_cu *cu)
7078 struct partial_die_info *pdi;
7080 if (enum_pdi->name != NULL)
7081 add_partial_symbol (enum_pdi, cu);
7083 pdi = enum_pdi->die_child;
7086 if (pdi->tag != DW_TAG_enumerator || pdi->name == NULL)
7087 complaint (&symfile_complaints, _("malformed enumerator DIE ignored"));
7089 add_partial_symbol (pdi, cu);
7090 pdi = pdi->die_sibling;
7094 /* Return the initial uleb128 in the die at INFO_PTR. */
7097 peek_abbrev_code (bfd *abfd, const gdb_byte *info_ptr)
7099 unsigned int bytes_read;
7101 return read_unsigned_leb128 (abfd, info_ptr, &bytes_read);
7104 /* Read the initial uleb128 in the die at INFO_PTR in compilation unit CU.
7105 Return the corresponding abbrev, or NULL if the number is zero (indicating
7106 an empty DIE). In either case *BYTES_READ will be set to the length of
7107 the initial number. */
7109 static struct abbrev_info *
7110 peek_die_abbrev (const gdb_byte *info_ptr, unsigned int *bytes_read,
7111 struct dwarf2_cu *cu)
7113 bfd *abfd = cu->objfile->obfd;
7114 unsigned int abbrev_number;
7115 struct abbrev_info *abbrev;
7117 abbrev_number = read_unsigned_leb128 (abfd, info_ptr, bytes_read);
7119 if (abbrev_number == 0)
7122 abbrev = abbrev_table_lookup_abbrev (cu->abbrev_table, abbrev_number);
7125 error (_("Dwarf Error: Could not find abbrev number %d [in module %s]"),
7126 abbrev_number, bfd_get_filename (abfd));
7132 /* Scan the debug information for CU starting at INFO_PTR in buffer BUFFER.
7133 Returns a pointer to the end of a series of DIEs, terminated by an empty
7134 DIE. Any children of the skipped DIEs will also be skipped. */
7136 static const gdb_byte *
7137 skip_children (const struct die_reader_specs *reader, const gdb_byte *info_ptr)
7139 struct dwarf2_cu *cu = reader->cu;
7140 struct abbrev_info *abbrev;
7141 unsigned int bytes_read;
7145 abbrev = peek_die_abbrev (info_ptr, &bytes_read, cu);
7147 return info_ptr + bytes_read;
7149 info_ptr = skip_one_die (reader, info_ptr + bytes_read, abbrev);
7153 /* Scan the debug information for CU starting at INFO_PTR in buffer BUFFER.
7154 INFO_PTR should point just after the initial uleb128 of a DIE, and the
7155 abbrev corresponding to that skipped uleb128 should be passed in
7156 ABBREV. Returns a pointer to this DIE's sibling, skipping any
7159 static const gdb_byte *
7160 skip_one_die (const struct die_reader_specs *reader, const gdb_byte *info_ptr,
7161 struct abbrev_info *abbrev)
7163 unsigned int bytes_read;
7164 struct attribute attr;
7165 bfd *abfd = reader->abfd;
7166 struct dwarf2_cu *cu = reader->cu;
7167 const gdb_byte *buffer = reader->buffer;
7168 const gdb_byte *buffer_end = reader->buffer_end;
7169 const gdb_byte *start_info_ptr = info_ptr;
7170 unsigned int form, i;
7172 for (i = 0; i < abbrev->num_attrs; i++)
7174 /* The only abbrev we care about is DW_AT_sibling. */
7175 if (abbrev->attrs[i].name == DW_AT_sibling)
7177 read_attribute (reader, &attr, &abbrev->attrs[i], info_ptr);
7178 if (attr.form == DW_FORM_ref_addr)
7179 complaint (&symfile_complaints,
7180 _("ignoring absolute DW_AT_sibling"));
7183 unsigned int off = dwarf2_get_ref_die_offset (&attr).sect_off;
7184 const gdb_byte *sibling_ptr = buffer + off;
7186 if (sibling_ptr < info_ptr)
7187 complaint (&symfile_complaints,
7188 _("DW_AT_sibling points backwards"));
7189 else if (sibling_ptr > reader->buffer_end)
7190 dwarf2_section_buffer_overflow_complaint (reader->die_section);
7196 /* If it isn't DW_AT_sibling, skip this attribute. */
7197 form = abbrev->attrs[i].form;
7201 case DW_FORM_ref_addr:
7202 /* In DWARF 2, DW_FORM_ref_addr is address sized; in DWARF 3
7203 and later it is offset sized. */
7204 if (cu->header.version == 2)
7205 info_ptr += cu->header.addr_size;
7207 info_ptr += cu->header.offset_size;
7209 case DW_FORM_GNU_ref_alt:
7210 info_ptr += cu->header.offset_size;
7213 info_ptr += cu->header.addr_size;
7220 case DW_FORM_flag_present:
7232 case DW_FORM_ref_sig8:
7235 case DW_FORM_string:
7236 read_direct_string (abfd, info_ptr, &bytes_read);
7237 info_ptr += bytes_read;
7239 case DW_FORM_sec_offset:
7241 case DW_FORM_GNU_strp_alt:
7242 info_ptr += cu->header.offset_size;
7244 case DW_FORM_exprloc:
7246 info_ptr += read_unsigned_leb128 (abfd, info_ptr, &bytes_read);
7247 info_ptr += bytes_read;
7249 case DW_FORM_block1:
7250 info_ptr += 1 + read_1_byte (abfd, info_ptr);
7252 case DW_FORM_block2:
7253 info_ptr += 2 + read_2_bytes (abfd, info_ptr);
7255 case DW_FORM_block4:
7256 info_ptr += 4 + read_4_bytes (abfd, info_ptr);
7260 case DW_FORM_ref_udata:
7261 case DW_FORM_GNU_addr_index:
7262 case DW_FORM_GNU_str_index:
7263 info_ptr = safe_skip_leb128 (info_ptr, buffer_end);
7265 case DW_FORM_indirect:
7266 form = read_unsigned_leb128 (abfd, info_ptr, &bytes_read);
7267 info_ptr += bytes_read;
7268 /* We need to continue parsing from here, so just go back to
7270 goto skip_attribute;
7273 error (_("Dwarf Error: Cannot handle %s "
7274 "in DWARF reader [in module %s]"),
7275 dwarf_form_name (form),
7276 bfd_get_filename (abfd));
7280 if (abbrev->has_children)
7281 return skip_children (reader, info_ptr);
7286 /* Locate ORIG_PDI's sibling.
7287 INFO_PTR should point to the start of the next DIE after ORIG_PDI. */
7289 static const gdb_byte *
7290 locate_pdi_sibling (const struct die_reader_specs *reader,
7291 struct partial_die_info *orig_pdi,
7292 const gdb_byte *info_ptr)
7294 /* Do we know the sibling already? */
7296 if (orig_pdi->sibling)
7297 return orig_pdi->sibling;
7299 /* Are there any children to deal with? */
7301 if (!orig_pdi->has_children)
7304 /* Skip the children the long way. */
7306 return skip_children (reader, info_ptr);
7309 /* Expand this partial symbol table into a full symbol table. SELF is
7313 dwarf2_read_symtab (struct partial_symtab *self,
7314 struct objfile *objfile)
7318 warning (_("bug: psymtab for %s is already read in."),
7325 printf_filtered (_("Reading in symbols for %s..."),
7327 gdb_flush (gdb_stdout);
7330 /* Restore our global data. */
7331 dwarf2_per_objfile = objfile_data (objfile, dwarf2_objfile_data_key);
7333 /* If this psymtab is constructed from a debug-only objfile, the
7334 has_section_at_zero flag will not necessarily be correct. We
7335 can get the correct value for this flag by looking at the data
7336 associated with the (presumably stripped) associated objfile. */
7337 if (objfile->separate_debug_objfile_backlink)
7339 struct dwarf2_per_objfile *dpo_backlink
7340 = objfile_data (objfile->separate_debug_objfile_backlink,
7341 dwarf2_objfile_data_key);
7343 dwarf2_per_objfile->has_section_at_zero
7344 = dpo_backlink->has_section_at_zero;
7347 dwarf2_per_objfile->reading_partial_symbols = 0;
7349 psymtab_to_symtab_1 (self);
7351 /* Finish up the debug error message. */
7353 printf_filtered (_("done.\n"));
7356 process_cu_includes ();
7359 /* Reading in full CUs. */
7361 /* Add PER_CU to the queue. */
7364 queue_comp_unit (struct dwarf2_per_cu_data *per_cu,
7365 enum language pretend_language)
7367 struct dwarf2_queue_item *item;
7370 item = xmalloc (sizeof (*item));
7371 item->per_cu = per_cu;
7372 item->pretend_language = pretend_language;
7375 if (dwarf2_queue == NULL)
7376 dwarf2_queue = item;
7378 dwarf2_queue_tail->next = item;
7380 dwarf2_queue_tail = item;
7383 /* If PER_CU is not yet queued, add it to the queue.
7384 If DEPENDENT_CU is non-NULL, it has a reference to PER_CU so add a
7386 The result is non-zero if PER_CU was queued, otherwise the result is zero
7387 meaning either PER_CU is already queued or it is already loaded.
7389 N.B. There is an invariant here that if a CU is queued then it is loaded.
7390 The caller is required to load PER_CU if we return non-zero. */
7393 maybe_queue_comp_unit (struct dwarf2_cu *dependent_cu,
7394 struct dwarf2_per_cu_data *per_cu,
7395 enum language pretend_language)
7397 /* We may arrive here during partial symbol reading, if we need full
7398 DIEs to process an unusual case (e.g. template arguments). Do
7399 not queue PER_CU, just tell our caller to load its DIEs. */
7400 if (dwarf2_per_objfile->reading_partial_symbols)
7402 if (per_cu->cu == NULL || per_cu->cu->dies == NULL)
7407 /* Mark the dependence relation so that we don't flush PER_CU
7409 if (dependent_cu != NULL)
7410 dwarf2_add_dependence (dependent_cu, per_cu);
7412 /* If it's already on the queue, we have nothing to do. */
7416 /* If the compilation unit is already loaded, just mark it as
7418 if (per_cu->cu != NULL)
7420 per_cu->cu->last_used = 0;
7424 /* Add it to the queue. */
7425 queue_comp_unit (per_cu, pretend_language);
7430 /* Process the queue. */
7433 process_queue (void)
7435 struct dwarf2_queue_item *item, *next_item;
7437 if (dwarf2_read_debug)
7439 fprintf_unfiltered (gdb_stdlog,
7440 "Expanding one or more symtabs of objfile %s ...\n",
7441 objfile_name (dwarf2_per_objfile->objfile));
7444 /* The queue starts out with one item, but following a DIE reference
7445 may load a new CU, adding it to the end of the queue. */
7446 for (item = dwarf2_queue; item != NULL; dwarf2_queue = item = next_item)
7448 if (dwarf2_per_objfile->using_index
7449 ? !item->per_cu->v.quick->symtab
7450 : (item->per_cu->v.psymtab && !item->per_cu->v.psymtab->readin))
7452 struct dwarf2_per_cu_data *per_cu = item->per_cu;
7453 unsigned int debug_print_threshold;
7456 if (per_cu->is_debug_types)
7458 struct signatured_type *sig_type =
7459 (struct signatured_type *) per_cu;
7461 sprintf (buf, "TU %s at offset 0x%x",
7462 hex_string (sig_type->signature),
7463 per_cu->offset.sect_off);
7464 /* There can be 100s of TUs.
7465 Only print them in verbose mode. */
7466 debug_print_threshold = 2;
7470 sprintf (buf, "CU at offset 0x%x", per_cu->offset.sect_off);
7471 debug_print_threshold = 1;
7474 if (dwarf2_read_debug >= debug_print_threshold)
7475 fprintf_unfiltered (gdb_stdlog, "Expanding symtab of %s\n", buf);
7477 if (per_cu->is_debug_types)
7478 process_full_type_unit (per_cu, item->pretend_language);
7480 process_full_comp_unit (per_cu, item->pretend_language);
7482 if (dwarf2_read_debug >= debug_print_threshold)
7483 fprintf_unfiltered (gdb_stdlog, "Done expanding %s\n", buf);
7486 item->per_cu->queued = 0;
7487 next_item = item->next;
7491 dwarf2_queue_tail = NULL;
7493 if (dwarf2_read_debug)
7495 fprintf_unfiltered (gdb_stdlog, "Done expanding symtabs of %s.\n",
7496 objfile_name (dwarf2_per_objfile->objfile));
7500 /* Free all allocated queue entries. This function only releases anything if
7501 an error was thrown; if the queue was processed then it would have been
7502 freed as we went along. */
7505 dwarf2_release_queue (void *dummy)
7507 struct dwarf2_queue_item *item, *last;
7509 item = dwarf2_queue;
7512 /* Anything still marked queued is likely to be in an
7513 inconsistent state, so discard it. */
7514 if (item->per_cu->queued)
7516 if (item->per_cu->cu != NULL)
7517 free_one_cached_comp_unit (item->per_cu);
7518 item->per_cu->queued = 0;
7526 dwarf2_queue = dwarf2_queue_tail = NULL;
7529 /* Read in full symbols for PST, and anything it depends on. */
7532 psymtab_to_symtab_1 (struct partial_symtab *pst)
7534 struct dwarf2_per_cu_data *per_cu;
7540 for (i = 0; i < pst->number_of_dependencies; i++)
7541 if (!pst->dependencies[i]->readin
7542 && pst->dependencies[i]->user == NULL)
7544 /* Inform about additional files that need to be read in. */
7547 /* FIXME: i18n: Need to make this a single string. */
7548 fputs_filtered (" ", gdb_stdout);
7550 fputs_filtered ("and ", gdb_stdout);
7552 printf_filtered ("%s...", pst->dependencies[i]->filename);
7553 wrap_here (""); /* Flush output. */
7554 gdb_flush (gdb_stdout);
7556 psymtab_to_symtab_1 (pst->dependencies[i]);
7559 per_cu = pst->read_symtab_private;
7563 /* It's an include file, no symbols to read for it.
7564 Everything is in the parent symtab. */
7569 dw2_do_instantiate_symtab (per_cu);
7572 /* Trivial hash function for die_info: the hash value of a DIE
7573 is its offset in .debug_info for this objfile. */
7576 die_hash (const void *item)
7578 const struct die_info *die = item;
7580 return die->offset.sect_off;
7583 /* Trivial comparison function for die_info structures: two DIEs
7584 are equal if they have the same offset. */
7587 die_eq (const void *item_lhs, const void *item_rhs)
7589 const struct die_info *die_lhs = item_lhs;
7590 const struct die_info *die_rhs = item_rhs;
7592 return die_lhs->offset.sect_off == die_rhs->offset.sect_off;
7595 /* die_reader_func for load_full_comp_unit.
7596 This is identical to read_signatured_type_reader,
7597 but is kept separate for now. */
7600 load_full_comp_unit_reader (const struct die_reader_specs *reader,
7601 const gdb_byte *info_ptr,
7602 struct die_info *comp_unit_die,
7606 struct dwarf2_cu *cu = reader->cu;
7607 enum language *language_ptr = data;
7609 gdb_assert (cu->die_hash == NULL);
7611 htab_create_alloc_ex (cu->header.length / 12,
7615 &cu->comp_unit_obstack,
7616 hashtab_obstack_allocate,
7617 dummy_obstack_deallocate);
7620 comp_unit_die->child = read_die_and_siblings (reader, info_ptr,
7621 &info_ptr, comp_unit_die);
7622 cu->dies = comp_unit_die;
7623 /* comp_unit_die is not stored in die_hash, no need. */
7625 /* We try not to read any attributes in this function, because not
7626 all CUs needed for references have been loaded yet, and symbol
7627 table processing isn't initialized. But we have to set the CU language,
7628 or we won't be able to build types correctly.
7629 Similarly, if we do not read the producer, we can not apply
7630 producer-specific interpretation. */
7631 prepare_one_comp_unit (cu, cu->dies, *language_ptr);
7634 /* Load the DIEs associated with PER_CU into memory. */
7637 load_full_comp_unit (struct dwarf2_per_cu_data *this_cu,
7638 enum language pretend_language)
7640 gdb_assert (! this_cu->is_debug_types);
7642 init_cutu_and_read_dies (this_cu, NULL, 1, 1,
7643 load_full_comp_unit_reader, &pretend_language);
7646 /* Add a DIE to the delayed physname list. */
7649 add_to_method_list (struct type *type, int fnfield_index, int index,
7650 const char *name, struct die_info *die,
7651 struct dwarf2_cu *cu)
7653 struct delayed_method_info mi;
7655 mi.fnfield_index = fnfield_index;
7659 VEC_safe_push (delayed_method_info, cu->method_list, &mi);
7662 /* A cleanup for freeing the delayed method list. */
7665 free_delayed_list (void *ptr)
7667 struct dwarf2_cu *cu = (struct dwarf2_cu *) ptr;
7668 if (cu->method_list != NULL)
7670 VEC_free (delayed_method_info, cu->method_list);
7671 cu->method_list = NULL;
7675 /* Compute the physnames of any methods on the CU's method list.
7677 The computation of method physnames is delayed in order to avoid the
7678 (bad) condition that one of the method's formal parameters is of an as yet
7682 compute_delayed_physnames (struct dwarf2_cu *cu)
7685 struct delayed_method_info *mi;
7686 for (i = 0; VEC_iterate (delayed_method_info, cu->method_list, i, mi) ; ++i)
7688 const char *physname;
7689 struct fn_fieldlist *fn_flp
7690 = &TYPE_FN_FIELDLIST (mi->type, mi->fnfield_index);
7691 physname = dwarf2_physname (mi->name, mi->die, cu);
7692 fn_flp->fn_fields[mi->index].physname = physname ? physname : "";
7696 /* Go objects should be embedded in a DW_TAG_module DIE,
7697 and it's not clear if/how imported objects will appear.
7698 To keep Go support simple until that's worked out,
7699 go back through what we've read and create something usable.
7700 We could do this while processing each DIE, and feels kinda cleaner,
7701 but that way is more invasive.
7702 This is to, for example, allow the user to type "p var" or "b main"
7703 without having to specify the package name, and allow lookups
7704 of module.object to work in contexts that use the expression
7708 fixup_go_packaging (struct dwarf2_cu *cu)
7710 char *package_name = NULL;
7711 struct pending *list;
7714 for (list = global_symbols; list != NULL; list = list->next)
7716 for (i = 0; i < list->nsyms; ++i)
7718 struct symbol *sym = list->symbol[i];
7720 if (SYMBOL_LANGUAGE (sym) == language_go
7721 && SYMBOL_CLASS (sym) == LOC_BLOCK)
7723 char *this_package_name = go_symbol_package_name (sym);
7725 if (this_package_name == NULL)
7727 if (package_name == NULL)
7728 package_name = this_package_name;
7731 if (strcmp (package_name, this_package_name) != 0)
7732 complaint (&symfile_complaints,
7733 _("Symtab %s has objects from two different Go packages: %s and %s"),
7734 (SYMBOL_SYMTAB (sym)
7735 ? symtab_to_filename_for_display (SYMBOL_SYMTAB (sym))
7736 : objfile_name (cu->objfile)),
7737 this_package_name, package_name);
7738 xfree (this_package_name);
7744 if (package_name != NULL)
7746 struct objfile *objfile = cu->objfile;
7747 const char *saved_package_name
7748 = obstack_copy0 (&objfile->per_bfd->storage_obstack,
7750 strlen (package_name));
7751 struct type *type = init_type (TYPE_CODE_MODULE, 0, 0,
7752 saved_package_name, objfile);
7755 TYPE_TAG_NAME (type) = TYPE_NAME (type);
7757 sym = allocate_symbol (objfile);
7758 SYMBOL_SET_LANGUAGE (sym, language_go, &objfile->objfile_obstack);
7759 SYMBOL_SET_NAMES (sym, saved_package_name,
7760 strlen (saved_package_name), 0, objfile);
7761 /* This is not VAR_DOMAIN because we want a way to ensure a lookup of,
7762 e.g., "main" finds the "main" module and not C's main(). */
7763 SYMBOL_DOMAIN (sym) = STRUCT_DOMAIN;
7764 SYMBOL_ACLASS_INDEX (sym) = LOC_TYPEDEF;
7765 SYMBOL_TYPE (sym) = type;
7767 add_symbol_to_list (sym, &global_symbols);
7769 xfree (package_name);
7773 /* Return the symtab for PER_CU. This works properly regardless of
7774 whether we're using the index or psymtabs. */
7776 static struct symtab *
7777 get_symtab (struct dwarf2_per_cu_data *per_cu)
7779 return (dwarf2_per_objfile->using_index
7780 ? per_cu->v.quick->symtab
7781 : per_cu->v.psymtab->symtab);
7784 /* A helper function for computing the list of all symbol tables
7785 included by PER_CU. */
7788 recursively_compute_inclusions (VEC (symtab_ptr) **result,
7789 htab_t all_children, htab_t all_type_symtabs,
7790 struct dwarf2_per_cu_data *per_cu,
7791 struct symtab *immediate_parent)
7795 struct symtab *symtab;
7796 struct dwarf2_per_cu_data *iter;
7798 slot = htab_find_slot (all_children, per_cu, INSERT);
7801 /* This inclusion and its children have been processed. */
7806 /* Only add a CU if it has a symbol table. */
7807 symtab = get_symtab (per_cu);
7810 /* If this is a type unit only add its symbol table if we haven't
7811 seen it yet (type unit per_cu's can share symtabs). */
7812 if (per_cu->is_debug_types)
7814 slot = htab_find_slot (all_type_symtabs, symtab, INSERT);
7818 VEC_safe_push (symtab_ptr, *result, symtab);
7819 if (symtab->user == NULL)
7820 symtab->user = immediate_parent;
7825 VEC_safe_push (symtab_ptr, *result, symtab);
7826 if (symtab->user == NULL)
7827 symtab->user = immediate_parent;
7832 VEC_iterate (dwarf2_per_cu_ptr, per_cu->imported_symtabs, ix, iter);
7835 recursively_compute_inclusions (result, all_children,
7836 all_type_symtabs, iter, symtab);
7840 /* Compute the symtab 'includes' fields for the symtab related to
7844 compute_symtab_includes (struct dwarf2_per_cu_data *per_cu)
7846 gdb_assert (! per_cu->is_debug_types);
7848 if (!VEC_empty (dwarf2_per_cu_ptr, per_cu->imported_symtabs))
7851 struct dwarf2_per_cu_data *per_cu_iter;
7852 struct symtab *symtab_iter;
7853 VEC (symtab_ptr) *result_symtabs = NULL;
7854 htab_t all_children, all_type_symtabs;
7855 struct symtab *symtab = get_symtab (per_cu);
7857 /* If we don't have a symtab, we can just skip this case. */
7861 all_children = htab_create_alloc (1, htab_hash_pointer, htab_eq_pointer,
7862 NULL, xcalloc, xfree);
7863 all_type_symtabs = htab_create_alloc (1, htab_hash_pointer, htab_eq_pointer,
7864 NULL, xcalloc, xfree);
7867 VEC_iterate (dwarf2_per_cu_ptr, per_cu->imported_symtabs,
7871 recursively_compute_inclusions (&result_symtabs, all_children,
7872 all_type_symtabs, per_cu_iter,
7876 /* Now we have a transitive closure of all the included symtabs. */
7877 len = VEC_length (symtab_ptr, result_symtabs);
7879 = obstack_alloc (&dwarf2_per_objfile->objfile->objfile_obstack,
7880 (len + 1) * sizeof (struct symtab *));
7882 VEC_iterate (symtab_ptr, result_symtabs, ix, symtab_iter);
7884 symtab->includes[ix] = symtab_iter;
7885 symtab->includes[len] = NULL;
7887 VEC_free (symtab_ptr, result_symtabs);
7888 htab_delete (all_children);
7889 htab_delete (all_type_symtabs);
7893 /* Compute the 'includes' field for the symtabs of all the CUs we just
7897 process_cu_includes (void)
7900 struct dwarf2_per_cu_data *iter;
7903 VEC_iterate (dwarf2_per_cu_ptr, dwarf2_per_objfile->just_read_cus,
7907 if (! iter->is_debug_types)
7908 compute_symtab_includes (iter);
7911 VEC_free (dwarf2_per_cu_ptr, dwarf2_per_objfile->just_read_cus);
7914 /* Generate full symbol information for PER_CU, whose DIEs have
7915 already been loaded into memory. */
7918 process_full_comp_unit (struct dwarf2_per_cu_data *per_cu,
7919 enum language pretend_language)
7921 struct dwarf2_cu *cu = per_cu->cu;
7922 struct objfile *objfile = per_cu->objfile;
7923 CORE_ADDR lowpc, highpc;
7924 struct symtab *symtab;
7925 struct cleanup *back_to, *delayed_list_cleanup;
7927 struct block *static_block;
7929 baseaddr = ANOFFSET (objfile->section_offsets, SECT_OFF_TEXT (objfile));
7932 back_to = make_cleanup (really_free_pendings, NULL);
7933 delayed_list_cleanup = make_cleanup (free_delayed_list, cu);
7935 cu->list_in_scope = &file_symbols;
7937 cu->language = pretend_language;
7938 cu->language_defn = language_def (cu->language);
7940 /* Do line number decoding in read_file_scope () */
7941 process_die (cu->dies, cu);
7943 /* For now fudge the Go package. */
7944 if (cu->language == language_go)
7945 fixup_go_packaging (cu);
7947 /* Now that we have processed all the DIEs in the CU, all the types
7948 should be complete, and it should now be safe to compute all of the
7950 compute_delayed_physnames (cu);
7951 do_cleanups (delayed_list_cleanup);
7953 /* Some compilers don't define a DW_AT_high_pc attribute for the
7954 compilation unit. If the DW_AT_high_pc is missing, synthesize
7955 it, by scanning the DIE's below the compilation unit. */
7956 get_scope_pc_bounds (cu->dies, &lowpc, &highpc, cu);
7959 = end_symtab_get_static_block (highpc + baseaddr, objfile, 0, 1);
7961 /* If the comp unit has DW_AT_ranges, it may have discontiguous ranges.
7962 Also, DW_AT_ranges may record ranges not belonging to any child DIEs
7963 (such as virtual method tables). Record the ranges in STATIC_BLOCK's
7964 addrmap to help ensure it has an accurate map of pc values belonging to
7966 dwarf2_record_block_ranges (cu->dies, static_block, baseaddr, cu);
7968 symtab = end_symtab_from_static_block (static_block, objfile,
7969 SECT_OFF_TEXT (objfile), 0);
7973 int gcc_4_minor = producer_is_gcc_ge_4 (cu->producer);
7975 /* Set symtab language to language from DW_AT_language. If the
7976 compilation is from a C file generated by language preprocessors, do
7977 not set the language if it was already deduced by start_subfile. */
7978 if (!(cu->language == language_c && symtab->language != language_c))
7979 symtab->language = cu->language;
7981 /* GCC-4.0 has started to support -fvar-tracking. GCC-3.x still can
7982 produce DW_AT_location with location lists but it can be possibly
7983 invalid without -fvar-tracking. Still up to GCC-4.4.x incl. 4.4.0
7984 there were bugs in prologue debug info, fixed later in GCC-4.5
7985 by "unwind info for epilogues" patch (which is not directly related).
7987 For -gdwarf-4 type units LOCATIONS_VALID indication is fortunately not
7988 needed, it would be wrong due to missing DW_AT_producer there.
7990 Still one can confuse GDB by using non-standard GCC compilation
7991 options - this waits on GCC PR other/32998 (-frecord-gcc-switches).
7993 if (cu->has_loclist && gcc_4_minor >= 5)
7994 symtab->locations_valid = 1;
7996 if (gcc_4_minor >= 5)
7997 symtab->epilogue_unwind_valid = 1;
7999 symtab->call_site_htab = cu->call_site_htab;
8002 if (dwarf2_per_objfile->using_index)
8003 per_cu->v.quick->symtab = symtab;
8006 struct partial_symtab *pst = per_cu->v.psymtab;
8007 pst->symtab = symtab;
8011 /* Push it for inclusion processing later. */
8012 VEC_safe_push (dwarf2_per_cu_ptr, dwarf2_per_objfile->just_read_cus, per_cu);
8014 do_cleanups (back_to);
8017 /* Generate full symbol information for type unit PER_CU, whose DIEs have
8018 already been loaded into memory. */
8021 process_full_type_unit (struct dwarf2_per_cu_data *per_cu,
8022 enum language pretend_language)
8024 struct dwarf2_cu *cu = per_cu->cu;
8025 struct objfile *objfile = per_cu->objfile;
8026 struct symtab *symtab;
8027 struct cleanup *back_to, *delayed_list_cleanup;
8028 struct signatured_type *sig_type;
8030 gdb_assert (per_cu->is_debug_types);
8031 sig_type = (struct signatured_type *) per_cu;
8034 back_to = make_cleanup (really_free_pendings, NULL);
8035 delayed_list_cleanup = make_cleanup (free_delayed_list, cu);
8037 cu->list_in_scope = &file_symbols;
8039 cu->language = pretend_language;
8040 cu->language_defn = language_def (cu->language);
8042 /* The symbol tables are set up in read_type_unit_scope. */
8043 process_die (cu->dies, cu);
8045 /* For now fudge the Go package. */
8046 if (cu->language == language_go)
8047 fixup_go_packaging (cu);
8049 /* Now that we have processed all the DIEs in the CU, all the types
8050 should be complete, and it should now be safe to compute all of the
8052 compute_delayed_physnames (cu);
8053 do_cleanups (delayed_list_cleanup);
8055 /* TUs share symbol tables.
8056 If this is the first TU to use this symtab, complete the construction
8057 of it with end_expandable_symtab. Otherwise, complete the addition of
8058 this TU's symbols to the existing symtab. */
8059 if (sig_type->type_unit_group->primary_symtab == NULL)
8061 symtab = end_expandable_symtab (0, objfile, SECT_OFF_TEXT (objfile));
8062 sig_type->type_unit_group->primary_symtab = symtab;
8066 /* Set symtab language to language from DW_AT_language. If the
8067 compilation is from a C file generated by language preprocessors,
8068 do not set the language if it was already deduced by
8070 if (!(cu->language == language_c && symtab->language != language_c))
8071 symtab->language = cu->language;
8076 augment_type_symtab (objfile,
8077 sig_type->type_unit_group->primary_symtab);
8078 symtab = sig_type->type_unit_group->primary_symtab;
8081 if (dwarf2_per_objfile->using_index)
8082 per_cu->v.quick->symtab = symtab;
8085 struct partial_symtab *pst = per_cu->v.psymtab;
8086 pst->symtab = symtab;
8090 do_cleanups (back_to);
8093 /* Process an imported unit DIE. */
8096 process_imported_unit_die (struct die_info *die, struct dwarf2_cu *cu)
8098 struct attribute *attr;
8100 /* For now we don't handle imported units in type units. */
8101 if (cu->per_cu->is_debug_types)
8103 error (_("Dwarf Error: DW_TAG_imported_unit is not"
8104 " supported in type units [in module %s]"),
8105 objfile_name (cu->objfile));
8108 attr = dwarf2_attr (die, DW_AT_import, cu);
8111 struct dwarf2_per_cu_data *per_cu;
8112 struct symtab *imported_symtab;
8116 offset = dwarf2_get_ref_die_offset (attr);
8117 is_dwz = (attr->form == DW_FORM_GNU_ref_alt || cu->per_cu->is_dwz);
8118 per_cu = dwarf2_find_containing_comp_unit (offset, is_dwz, cu->objfile);
8120 /* If necessary, add it to the queue and load its DIEs. */
8121 if (maybe_queue_comp_unit (cu, per_cu, cu->language))
8122 load_full_comp_unit (per_cu, cu->language);
8124 VEC_safe_push (dwarf2_per_cu_ptr, cu->per_cu->imported_symtabs,
8129 /* Reset the in_process bit of a die. */
8132 reset_die_in_process (void *arg)
8134 struct die_info *die = arg;
8136 die->in_process = 0;
8139 /* Process a die and its children. */
8142 process_die (struct die_info *die, struct dwarf2_cu *cu)
8144 struct cleanup *in_process;
8146 /* We should only be processing those not already in process. */
8147 gdb_assert (!die->in_process);
8149 die->in_process = 1;
8150 in_process = make_cleanup (reset_die_in_process,die);
8154 case DW_TAG_padding:
8156 case DW_TAG_compile_unit:
8157 case DW_TAG_partial_unit:
8158 read_file_scope (die, cu);
8160 case DW_TAG_type_unit:
8161 read_type_unit_scope (die, cu);
8163 case DW_TAG_subprogram:
8164 case DW_TAG_inlined_subroutine:
8165 read_func_scope (die, cu);
8167 case DW_TAG_lexical_block:
8168 case DW_TAG_try_block:
8169 case DW_TAG_catch_block:
8170 read_lexical_block_scope (die, cu);
8172 case DW_TAG_GNU_call_site:
8173 read_call_site_scope (die, cu);
8175 case DW_TAG_class_type:
8176 case DW_TAG_interface_type:
8177 case DW_TAG_structure_type:
8178 case DW_TAG_union_type:
8179 process_structure_scope (die, cu);
8181 case DW_TAG_enumeration_type:
8182 process_enumeration_scope (die, cu);
8185 /* These dies have a type, but processing them does not create
8186 a symbol or recurse to process the children. Therefore we can
8187 read them on-demand through read_type_die. */
8188 case DW_TAG_subroutine_type:
8189 case DW_TAG_set_type:
8190 case DW_TAG_array_type:
8191 case DW_TAG_pointer_type:
8192 case DW_TAG_ptr_to_member_type:
8193 case DW_TAG_reference_type:
8194 case DW_TAG_string_type:
8197 case DW_TAG_base_type:
8198 case DW_TAG_subrange_type:
8199 case DW_TAG_typedef:
8200 /* Add a typedef symbol for the type definition, if it has a
8202 new_symbol (die, read_type_die (die, cu), cu);
8204 case DW_TAG_common_block:
8205 read_common_block (die, cu);
8207 case DW_TAG_common_inclusion:
8209 case DW_TAG_namespace:
8210 cu->processing_has_namespace_info = 1;
8211 read_namespace (die, cu);
8214 cu->processing_has_namespace_info = 1;
8215 read_module (die, cu);
8217 case DW_TAG_imported_declaration:
8218 cu->processing_has_namespace_info = 1;
8219 if (read_namespace_alias (die, cu))
8221 /* The declaration is not a global namespace alias: fall through. */
8222 case DW_TAG_imported_module:
8223 cu->processing_has_namespace_info = 1;
8224 if (die->child != NULL && (die->tag == DW_TAG_imported_declaration
8225 || cu->language != language_fortran))
8226 complaint (&symfile_complaints, _("Tag '%s' has unexpected children"),
8227 dwarf_tag_name (die->tag));
8228 read_import_statement (die, cu);
8231 case DW_TAG_imported_unit:
8232 process_imported_unit_die (die, cu);
8236 new_symbol (die, NULL, cu);
8240 do_cleanups (in_process);
8243 /* DWARF name computation. */
8245 /* A helper function for dwarf2_compute_name which determines whether DIE
8246 needs to have the name of the scope prepended to the name listed in the
8250 die_needs_namespace (struct die_info *die, struct dwarf2_cu *cu)
8252 struct attribute *attr;
8256 case DW_TAG_namespace:
8257 case DW_TAG_typedef:
8258 case DW_TAG_class_type:
8259 case DW_TAG_interface_type:
8260 case DW_TAG_structure_type:
8261 case DW_TAG_union_type:
8262 case DW_TAG_enumeration_type:
8263 case DW_TAG_enumerator:
8264 case DW_TAG_subprogram:
8266 case DW_TAG_imported_declaration:
8269 case DW_TAG_variable:
8270 case DW_TAG_constant:
8271 /* We only need to prefix "globally" visible variables. These include
8272 any variable marked with DW_AT_external or any variable that
8273 lives in a namespace. [Variables in anonymous namespaces
8274 require prefixing, but they are not DW_AT_external.] */
8276 if (dwarf2_attr (die, DW_AT_specification, cu))
8278 struct dwarf2_cu *spec_cu = cu;
8280 return die_needs_namespace (die_specification (die, &spec_cu),
8284 attr = dwarf2_attr (die, DW_AT_external, cu);
8285 if (attr == NULL && die->parent->tag != DW_TAG_namespace
8286 && die->parent->tag != DW_TAG_module)
8288 /* A variable in a lexical block of some kind does not need a
8289 namespace, even though in C++ such variables may be external
8290 and have a mangled name. */
8291 if (die->parent->tag == DW_TAG_lexical_block
8292 || die->parent->tag == DW_TAG_try_block
8293 || die->parent->tag == DW_TAG_catch_block
8294 || die->parent->tag == DW_TAG_subprogram)
8303 /* Retrieve the last character from a mem_file. */
8306 do_ui_file_peek_last (void *object, const char *buffer, long length)
8308 char *last_char_p = (char *) object;
8311 *last_char_p = buffer[length - 1];
8314 /* Compute the fully qualified name of DIE in CU. If PHYSNAME is nonzero,
8315 compute the physname for the object, which include a method's:
8316 - formal parameters (C++/Java),
8317 - receiver type (Go),
8318 - return type (Java).
8320 The term "physname" is a bit confusing.
8321 For C++, for example, it is the demangled name.
8322 For Go, for example, it's the mangled name.
8324 For Ada, return the DIE's linkage name rather than the fully qualified
8325 name. PHYSNAME is ignored..
8327 The result is allocated on the objfile_obstack and canonicalized. */
8330 dwarf2_compute_name (const char *name,
8331 struct die_info *die, struct dwarf2_cu *cu,
8334 struct objfile *objfile = cu->objfile;
8337 name = dwarf2_name (die, cu);
8339 /* For Fortran GDB prefers DW_AT_*linkage_name if present but otherwise
8340 compute it by typename_concat inside GDB. */
8341 if (cu->language == language_ada
8342 || (cu->language == language_fortran && physname))
8344 /* For Ada unit, we prefer the linkage name over the name, as
8345 the former contains the exported name, which the user expects
8346 to be able to reference. Ideally, we want the user to be able
8347 to reference this entity using either natural or linkage name,
8348 but we haven't started looking at this enhancement yet. */
8349 struct attribute *attr;
8351 attr = dwarf2_attr (die, DW_AT_linkage_name, cu);
8353 attr = dwarf2_attr (die, DW_AT_MIPS_linkage_name, cu);
8354 if (attr && DW_STRING (attr))
8355 return DW_STRING (attr);
8358 /* These are the only languages we know how to qualify names in. */
8360 && (cu->language == language_cplus || cu->language == language_java
8361 || cu->language == language_fortran))
8363 if (die_needs_namespace (die, cu))
8367 struct ui_file *buf;
8368 char *intermediate_name;
8369 const char *canonical_name = NULL;
8371 prefix = determine_prefix (die, cu);
8372 buf = mem_fileopen ();
8373 if (*prefix != '\0')
8375 char *prefixed_name = typename_concat (NULL, prefix, name,
8378 fputs_unfiltered (prefixed_name, buf);
8379 xfree (prefixed_name);
8382 fputs_unfiltered (name, buf);
8384 /* Template parameters may be specified in the DIE's DW_AT_name, or
8385 as children with DW_TAG_template_type_param or
8386 DW_TAG_value_type_param. If the latter, add them to the name
8387 here. If the name already has template parameters, then
8388 skip this step; some versions of GCC emit both, and
8389 it is more efficient to use the pre-computed name.
8391 Something to keep in mind about this process: it is very
8392 unlikely, or in some cases downright impossible, to produce
8393 something that will match the mangled name of a function.
8394 If the definition of the function has the same debug info,
8395 we should be able to match up with it anyway. But fallbacks
8396 using the minimal symbol, for instance to find a method
8397 implemented in a stripped copy of libstdc++, will not work.
8398 If we do not have debug info for the definition, we will have to
8399 match them up some other way.
8401 When we do name matching there is a related problem with function
8402 templates; two instantiated function templates are allowed to
8403 differ only by their return types, which we do not add here. */
8405 if (cu->language == language_cplus && strchr (name, '<') == NULL)
8407 struct attribute *attr;
8408 struct die_info *child;
8411 die->building_fullname = 1;
8413 for (child = die->child; child != NULL; child = child->sibling)
8417 const gdb_byte *bytes;
8418 struct dwarf2_locexpr_baton *baton;
8421 if (child->tag != DW_TAG_template_type_param
8422 && child->tag != DW_TAG_template_value_param)
8427 fputs_unfiltered ("<", buf);
8431 fputs_unfiltered (", ", buf);
8433 attr = dwarf2_attr (child, DW_AT_type, cu);
8436 complaint (&symfile_complaints,
8437 _("template parameter missing DW_AT_type"));
8438 fputs_unfiltered ("UNKNOWN_TYPE", buf);
8441 type = die_type (child, cu);
8443 if (child->tag == DW_TAG_template_type_param)
8445 c_print_type (type, "", buf, -1, 0, &type_print_raw_options);
8449 attr = dwarf2_attr (child, DW_AT_const_value, cu);
8452 complaint (&symfile_complaints,
8453 _("template parameter missing "
8454 "DW_AT_const_value"));
8455 fputs_unfiltered ("UNKNOWN_VALUE", buf);
8459 dwarf2_const_value_attr (attr, type, name,
8460 &cu->comp_unit_obstack, cu,
8461 &value, &bytes, &baton);
8463 if (TYPE_NOSIGN (type))
8464 /* GDB prints characters as NUMBER 'CHAR'. If that's
8465 changed, this can use value_print instead. */
8466 c_printchar (value, type, buf);
8469 struct value_print_options opts;
8472 v = dwarf2_evaluate_loc_desc (type, NULL,
8476 else if (bytes != NULL)
8478 v = allocate_value (type);
8479 memcpy (value_contents_writeable (v), bytes,
8480 TYPE_LENGTH (type));
8483 v = value_from_longest (type, value);
8485 /* Specify decimal so that we do not depend on
8487 get_formatted_print_options (&opts, 'd');
8489 value_print (v, buf, &opts);
8495 die->building_fullname = 0;
8499 /* Close the argument list, with a space if necessary
8500 (nested templates). */
8501 char last_char = '\0';
8502 ui_file_put (buf, do_ui_file_peek_last, &last_char);
8503 if (last_char == '>')
8504 fputs_unfiltered (" >", buf);
8506 fputs_unfiltered (">", buf);
8510 /* For Java and C++ methods, append formal parameter type
8511 information, if PHYSNAME. */
8513 if (physname && die->tag == DW_TAG_subprogram
8514 && (cu->language == language_cplus
8515 || cu->language == language_java))
8517 struct type *type = read_type_die (die, cu);
8519 c_type_print_args (type, buf, 1, cu->language,
8520 &type_print_raw_options);
8522 if (cu->language == language_java)
8524 /* For java, we must append the return type to method
8526 if (die->tag == DW_TAG_subprogram)
8527 java_print_type (TYPE_TARGET_TYPE (type), "", buf,
8528 0, 0, &type_print_raw_options);
8530 else if (cu->language == language_cplus)
8532 /* Assume that an artificial first parameter is
8533 "this", but do not crash if it is not. RealView
8534 marks unnamed (and thus unused) parameters as
8535 artificial; there is no way to differentiate
8537 if (TYPE_NFIELDS (type) > 0
8538 && TYPE_FIELD_ARTIFICIAL (type, 0)
8539 && TYPE_CODE (TYPE_FIELD_TYPE (type, 0)) == TYPE_CODE_PTR
8540 && TYPE_CONST (TYPE_TARGET_TYPE (TYPE_FIELD_TYPE (type,
8542 fputs_unfiltered (" const", buf);
8546 intermediate_name = ui_file_xstrdup (buf, &length);
8547 ui_file_delete (buf);
8549 if (cu->language == language_cplus)
8551 = dwarf2_canonicalize_name (intermediate_name, cu,
8552 &objfile->per_bfd->storage_obstack);
8554 /* If we only computed INTERMEDIATE_NAME, or if
8555 INTERMEDIATE_NAME is already canonical, then we need to
8556 copy it to the appropriate obstack. */
8557 if (canonical_name == NULL || canonical_name == intermediate_name)
8558 name = obstack_copy0 (&objfile->per_bfd->storage_obstack,
8560 strlen (intermediate_name));
8562 name = canonical_name;
8564 xfree (intermediate_name);
8571 /* Return the fully qualified name of DIE, based on its DW_AT_name.
8572 If scope qualifiers are appropriate they will be added. The result
8573 will be allocated on the storage_obstack, or NULL if the DIE does
8574 not have a name. NAME may either be from a previous call to
8575 dwarf2_name or NULL.
8577 The output string will be canonicalized (if C++/Java). */
8580 dwarf2_full_name (const char *name, struct die_info *die, struct dwarf2_cu *cu)
8582 return dwarf2_compute_name (name, die, cu, 0);
8585 /* Construct a physname for the given DIE in CU. NAME may either be
8586 from a previous call to dwarf2_name or NULL. The result will be
8587 allocated on the objfile_objstack or NULL if the DIE does not have a
8590 The output string will be canonicalized (if C++/Java). */
8593 dwarf2_physname (const char *name, struct die_info *die, struct dwarf2_cu *cu)
8595 struct objfile *objfile = cu->objfile;
8596 struct attribute *attr;
8597 const char *retval, *mangled = NULL, *canon = NULL;
8598 struct cleanup *back_to;
8601 /* In this case dwarf2_compute_name is just a shortcut not building anything
8603 if (!die_needs_namespace (die, cu))
8604 return dwarf2_compute_name (name, die, cu, 1);
8606 back_to = make_cleanup (null_cleanup, NULL);
8608 attr = dwarf2_attr (die, DW_AT_linkage_name, cu);
8610 attr = dwarf2_attr (die, DW_AT_MIPS_linkage_name, cu);
8612 /* DW_AT_linkage_name is missing in some cases - depend on what GDB
8614 if (attr && DW_STRING (attr))
8618 mangled = DW_STRING (attr);
8620 /* Use DMGL_RET_DROP for C++ template functions to suppress their return
8621 type. It is easier for GDB users to search for such functions as
8622 `name(params)' than `long name(params)'. In such case the minimal
8623 symbol names do not match the full symbol names but for template
8624 functions there is never a need to look up their definition from their
8625 declaration so the only disadvantage remains the minimal symbol
8626 variant `long name(params)' does not have the proper inferior type.
8629 if (cu->language == language_go)
8631 /* This is a lie, but we already lie to the caller new_symbol_full.
8632 new_symbol_full assumes we return the mangled name.
8633 This just undoes that lie until things are cleaned up. */
8638 demangled = gdb_demangle (mangled,
8639 (DMGL_PARAMS | DMGL_ANSI
8640 | (cu->language == language_java
8641 ? DMGL_JAVA | DMGL_RET_POSTFIX
8646 make_cleanup (xfree, demangled);
8656 if (canon == NULL || check_physname)
8658 const char *physname = dwarf2_compute_name (name, die, cu, 1);
8660 if (canon != NULL && strcmp (physname, canon) != 0)
8662 /* It may not mean a bug in GDB. The compiler could also
8663 compute DW_AT_linkage_name incorrectly. But in such case
8664 GDB would need to be bug-to-bug compatible. */
8666 complaint (&symfile_complaints,
8667 _("Computed physname <%s> does not match demangled <%s> "
8668 "(from linkage <%s>) - DIE at 0x%x [in module %s]"),
8669 physname, canon, mangled, die->offset.sect_off,
8670 objfile_name (objfile));
8672 /* Prefer DW_AT_linkage_name (in the CANON form) - when it
8673 is available here - over computed PHYSNAME. It is safer
8674 against both buggy GDB and buggy compilers. */
8688 retval = obstack_copy0 (&objfile->per_bfd->storage_obstack,
8689 retval, strlen (retval));
8691 do_cleanups (back_to);
8695 /* Inspect DIE in CU for a namespace alias. If one exists, record
8696 a new symbol for it.
8698 Returns 1 if a namespace alias was recorded, 0 otherwise. */
8701 read_namespace_alias (struct die_info *die, struct dwarf2_cu *cu)
8703 struct attribute *attr;
8705 /* If the die does not have a name, this is not a namespace
8707 attr = dwarf2_attr (die, DW_AT_name, cu);
8711 struct die_info *d = die;
8712 struct dwarf2_cu *imported_cu = cu;
8714 /* If the compiler has nested DW_AT_imported_declaration DIEs,
8715 keep inspecting DIEs until we hit the underlying import. */
8716 #define MAX_NESTED_IMPORTED_DECLARATIONS 100
8717 for (num = 0; num < MAX_NESTED_IMPORTED_DECLARATIONS; ++num)
8719 attr = dwarf2_attr (d, DW_AT_import, cu);
8723 d = follow_die_ref (d, attr, &imported_cu);
8724 if (d->tag != DW_TAG_imported_declaration)
8728 if (num == MAX_NESTED_IMPORTED_DECLARATIONS)
8730 complaint (&symfile_complaints,
8731 _("DIE at 0x%x has too many recursively imported "
8732 "declarations"), d->offset.sect_off);
8739 sect_offset offset = dwarf2_get_ref_die_offset (attr);
8741 type = get_die_type_at_offset (offset, cu->per_cu);
8742 if (type != NULL && TYPE_CODE (type) == TYPE_CODE_NAMESPACE)
8744 /* This declaration is a global namespace alias. Add
8745 a symbol for it whose type is the aliased namespace. */
8746 new_symbol (die, type, cu);
8755 /* Read the import statement specified by the given die and record it. */
8758 read_import_statement (struct die_info *die, struct dwarf2_cu *cu)
8760 struct objfile *objfile = cu->objfile;
8761 struct attribute *import_attr;
8762 struct die_info *imported_die, *child_die;
8763 struct dwarf2_cu *imported_cu;
8764 const char *imported_name;
8765 const char *imported_name_prefix;
8766 const char *canonical_name;
8767 const char *import_alias;
8768 const char *imported_declaration = NULL;
8769 const char *import_prefix;
8770 VEC (const_char_ptr) *excludes = NULL;
8771 struct cleanup *cleanups;
8773 import_attr = dwarf2_attr (die, DW_AT_import, cu);
8774 if (import_attr == NULL)
8776 complaint (&symfile_complaints, _("Tag '%s' has no DW_AT_import"),
8777 dwarf_tag_name (die->tag));
8782 imported_die = follow_die_ref_or_sig (die, import_attr, &imported_cu);
8783 imported_name = dwarf2_name (imported_die, imported_cu);
8784 if (imported_name == NULL)
8786 /* GCC bug: https://bugzilla.redhat.com/show_bug.cgi?id=506524
8788 The import in the following code:
8802 <2><51>: Abbrev Number: 3 (DW_TAG_imported_declaration)
8803 <52> DW_AT_decl_file : 1
8804 <53> DW_AT_decl_line : 6
8805 <54> DW_AT_import : <0x75>
8806 <2><58>: Abbrev Number: 4 (DW_TAG_typedef)
8808 <5b> DW_AT_decl_file : 1
8809 <5c> DW_AT_decl_line : 2
8810 <5d> DW_AT_type : <0x6e>
8812 <1><75>: Abbrev Number: 7 (DW_TAG_base_type)
8813 <76> DW_AT_byte_size : 4
8814 <77> DW_AT_encoding : 5 (signed)
8816 imports the wrong die ( 0x75 instead of 0x58 ).
8817 This case will be ignored until the gcc bug is fixed. */
8821 /* Figure out the local name after import. */
8822 import_alias = dwarf2_name (die, cu);
8824 /* Figure out where the statement is being imported to. */
8825 import_prefix = determine_prefix (die, cu);
8827 /* Figure out what the scope of the imported die is and prepend it
8828 to the name of the imported die. */
8829 imported_name_prefix = determine_prefix (imported_die, imported_cu);
8831 if (imported_die->tag != DW_TAG_namespace
8832 && imported_die->tag != DW_TAG_module)
8834 imported_declaration = imported_name;
8835 canonical_name = imported_name_prefix;
8837 else if (strlen (imported_name_prefix) > 0)
8838 canonical_name = obconcat (&objfile->objfile_obstack,
8839 imported_name_prefix, "::", imported_name,
8842 canonical_name = imported_name;
8844 cleanups = make_cleanup (VEC_cleanup (const_char_ptr), &excludes);
8846 if (die->tag == DW_TAG_imported_module && cu->language == language_fortran)
8847 for (child_die = die->child; child_die && child_die->tag;
8848 child_die = sibling_die (child_die))
8850 /* DWARF-4: A Fortran use statement with a “rename list” may be
8851 represented by an imported module entry with an import attribute
8852 referring to the module and owned entries corresponding to those
8853 entities that are renamed as part of being imported. */
8855 if (child_die->tag != DW_TAG_imported_declaration)
8857 complaint (&symfile_complaints,
8858 _("child DW_TAG_imported_declaration expected "
8859 "- DIE at 0x%x [in module %s]"),
8860 child_die->offset.sect_off, objfile_name (objfile));
8864 import_attr = dwarf2_attr (child_die, DW_AT_import, cu);
8865 if (import_attr == NULL)
8867 complaint (&symfile_complaints, _("Tag '%s' has no DW_AT_import"),
8868 dwarf_tag_name (child_die->tag));
8873 imported_die = follow_die_ref_or_sig (child_die, import_attr,
8875 imported_name = dwarf2_name (imported_die, imported_cu);
8876 if (imported_name == NULL)
8878 complaint (&symfile_complaints,
8879 _("child DW_TAG_imported_declaration has unknown "
8880 "imported name - DIE at 0x%x [in module %s]"),
8881 child_die->offset.sect_off, objfile_name (objfile));
8885 VEC_safe_push (const_char_ptr, excludes, imported_name);
8887 process_die (child_die, cu);
8890 cp_add_using_directive (import_prefix,
8893 imported_declaration,
8896 &objfile->objfile_obstack);
8898 do_cleanups (cleanups);
8901 /* Cleanup function for handle_DW_AT_stmt_list. */
8904 free_cu_line_header (void *arg)
8906 struct dwarf2_cu *cu = arg;
8908 free_line_header (cu->line_header);
8909 cu->line_header = NULL;
8912 /* Check for possibly missing DW_AT_comp_dir with relative .debug_line
8913 directory paths. GCC SVN r127613 (new option -fdebug-prefix-map) fixed
8914 this, it was first present in GCC release 4.3.0. */
8917 producer_is_gcc_lt_4_3 (struct dwarf2_cu *cu)
8919 if (!cu->checked_producer)
8920 check_producer (cu);
8922 return cu->producer_is_gcc_lt_4_3;
8926 find_file_and_directory (struct die_info *die, struct dwarf2_cu *cu,
8927 const char **name, const char **comp_dir)
8929 struct attribute *attr;
8934 /* Find the filename. Do not use dwarf2_name here, since the filename
8935 is not a source language identifier. */
8936 attr = dwarf2_attr (die, DW_AT_name, cu);
8939 *name = DW_STRING (attr);
8942 attr = dwarf2_attr (die, DW_AT_comp_dir, cu);
8944 *comp_dir = DW_STRING (attr);
8945 else if (producer_is_gcc_lt_4_3 (cu) && *name != NULL
8946 && IS_ABSOLUTE_PATH (*name))
8948 char *d = ldirname (*name);
8952 make_cleanup (xfree, d);
8954 if (*comp_dir != NULL)
8956 /* Irix 6.2 native cc prepends <machine>.: to the compilation
8957 directory, get rid of it. */
8958 char *cp = strchr (*comp_dir, ':');
8960 if (cp && cp != *comp_dir && cp[-1] == '.' && cp[1] == '/')
8965 *name = "<unknown>";
8968 /* Handle DW_AT_stmt_list for a compilation unit.
8969 DIE is the DW_TAG_compile_unit die for CU.
8970 COMP_DIR is the compilation directory. LOWPC is passed to
8971 dwarf_decode_lines. See dwarf_decode_lines comments about it. */
8974 handle_DW_AT_stmt_list (struct die_info *die, struct dwarf2_cu *cu,
8975 const char *comp_dir, CORE_ADDR lowpc) /* ARI: editCase function */
8977 struct attribute *attr;
8979 gdb_assert (! cu->per_cu->is_debug_types);
8981 attr = dwarf2_attr (die, DW_AT_stmt_list, cu);
8984 unsigned int line_offset = DW_UNSND (attr);
8985 struct line_header *line_header
8986 = dwarf_decode_line_header (line_offset, cu);
8990 cu->line_header = line_header;
8991 make_cleanup (free_cu_line_header, cu);
8992 dwarf_decode_lines (line_header, comp_dir, cu, NULL, lowpc);
8997 /* Process DW_TAG_compile_unit or DW_TAG_partial_unit. */
9000 read_file_scope (struct die_info *die, struct dwarf2_cu *cu)
9002 struct objfile *objfile = dwarf2_per_objfile->objfile;
9003 struct cleanup *back_to = make_cleanup (null_cleanup, 0);
9004 CORE_ADDR lowpc = ((CORE_ADDR) -1);
9005 CORE_ADDR highpc = ((CORE_ADDR) 0);
9006 struct attribute *attr;
9007 const char *name = NULL;
9008 const char *comp_dir = NULL;
9009 struct die_info *child_die;
9010 bfd *abfd = objfile->obfd;
9013 baseaddr = ANOFFSET (objfile->section_offsets, SECT_OFF_TEXT (objfile));
9015 get_scope_pc_bounds (die, &lowpc, &highpc, cu);
9017 /* If we didn't find a lowpc, set it to highpc to avoid complaints
9018 from finish_block. */
9019 if (lowpc == ((CORE_ADDR) -1))
9024 find_file_and_directory (die, cu, &name, &comp_dir);
9026 prepare_one_comp_unit (cu, die, cu->language);
9028 /* The XLCL doesn't generate DW_LANG_OpenCL because this attribute is not
9029 standardised yet. As a workaround for the language detection we fall
9030 back to the DW_AT_producer string. */
9031 if (cu->producer && strstr (cu->producer, "IBM XL C for OpenCL") != NULL)
9032 cu->language = language_opencl;
9034 /* Similar hack for Go. */
9035 if (cu->producer && strstr (cu->producer, "GNU Go ") != NULL)
9036 set_cu_language (DW_LANG_Go, cu);
9038 dwarf2_start_symtab (cu, name, comp_dir, lowpc);
9040 /* Decode line number information if present. We do this before
9041 processing child DIEs, so that the line header table is available
9042 for DW_AT_decl_file. */
9043 handle_DW_AT_stmt_list (die, cu, comp_dir, lowpc);
9045 /* Process all dies in compilation unit. */
9046 if (die->child != NULL)
9048 child_die = die->child;
9049 while (child_die && child_die->tag)
9051 process_die (child_die, cu);
9052 child_die = sibling_die (child_die);
9056 /* Decode macro information, if present. Dwarf 2 macro information
9057 refers to information in the line number info statement program
9058 header, so we can only read it if we've read the header
9060 attr = dwarf2_attr (die, DW_AT_GNU_macros, cu);
9061 if (attr && cu->line_header)
9063 if (dwarf2_attr (die, DW_AT_macro_info, cu))
9064 complaint (&symfile_complaints,
9065 _("CU refers to both DW_AT_GNU_macros and DW_AT_macro_info"));
9067 dwarf_decode_macros (cu, DW_UNSND (attr), comp_dir, 1);
9071 attr = dwarf2_attr (die, DW_AT_macro_info, cu);
9072 if (attr && cu->line_header)
9074 unsigned int macro_offset = DW_UNSND (attr);
9076 dwarf_decode_macros (cu, macro_offset, comp_dir, 0);
9080 do_cleanups (back_to);
9083 /* TU version of handle_DW_AT_stmt_list for read_type_unit_scope.
9084 Create the set of symtabs used by this TU, or if this TU is sharing
9085 symtabs with another TU and the symtabs have already been created
9086 then restore those symtabs in the line header.
9087 We don't need the pc/line-number mapping for type units. */
9090 setup_type_unit_groups (struct die_info *die, struct dwarf2_cu *cu)
9092 struct objfile *objfile = dwarf2_per_objfile->objfile;
9093 struct dwarf2_per_cu_data *per_cu = cu->per_cu;
9094 struct type_unit_group *tu_group;
9096 struct line_header *lh;
9097 struct attribute *attr;
9098 unsigned int i, line_offset;
9099 struct signatured_type *sig_type;
9101 gdb_assert (per_cu->is_debug_types);
9102 sig_type = (struct signatured_type *) per_cu;
9104 attr = dwarf2_attr (die, DW_AT_stmt_list, cu);
9106 /* If we're using .gdb_index (includes -readnow) then
9107 per_cu->type_unit_group may not have been set up yet. */
9108 if (sig_type->type_unit_group == NULL)
9109 sig_type->type_unit_group = get_type_unit_group (cu, attr);
9110 tu_group = sig_type->type_unit_group;
9112 /* If we've already processed this stmt_list there's no real need to
9113 do it again, we could fake it and just recreate the part we need
9114 (file name,index -> symtab mapping). If data shows this optimization
9115 is useful we can do it then. */
9116 first_time = tu_group->primary_symtab == NULL;
9118 /* We have to handle the case of both a missing DW_AT_stmt_list or bad
9123 line_offset = DW_UNSND (attr);
9124 lh = dwarf_decode_line_header (line_offset, cu);
9129 dwarf2_start_symtab (cu, "", NULL, 0);
9132 gdb_assert (tu_group->symtabs == NULL);
9135 /* Note: The primary symtab will get allocated at the end. */
9139 cu->line_header = lh;
9140 make_cleanup (free_cu_line_header, cu);
9144 dwarf2_start_symtab (cu, "", NULL, 0);
9146 tu_group->num_symtabs = lh->num_file_names;
9147 tu_group->symtabs = XNEWVEC (struct symtab *, lh->num_file_names);
9149 for (i = 0; i < lh->num_file_names; ++i)
9151 const char *dir = NULL;
9152 struct file_entry *fe = &lh->file_names[i];
9155 dir = lh->include_dirs[fe->dir_index - 1];
9156 dwarf2_start_subfile (fe->name, dir, NULL);
9158 /* Note: We don't have to watch for the main subfile here, type units
9159 don't have DW_AT_name. */
9161 if (current_subfile->symtab == NULL)
9163 /* NOTE: start_subfile will recognize when it's been passed
9164 a file it has already seen. So we can't assume there's a
9165 simple mapping from lh->file_names to subfiles,
9166 lh->file_names may contain dups. */
9167 current_subfile->symtab = allocate_symtab (current_subfile->name,
9171 fe->symtab = current_subfile->symtab;
9172 tu_group->symtabs[i] = fe->symtab;
9179 for (i = 0; i < lh->num_file_names; ++i)
9181 struct file_entry *fe = &lh->file_names[i];
9183 fe->symtab = tu_group->symtabs[i];
9187 /* The main symtab is allocated last. Type units don't have DW_AT_name
9188 so they don't have a "real" (so to speak) symtab anyway.
9189 There is later code that will assign the main symtab to all symbols
9190 that don't have one. We need to handle the case of a symbol with a
9191 missing symtab (DW_AT_decl_file) anyway. */
9194 /* Process DW_TAG_type_unit.
9195 For TUs we want to skip the first top level sibling if it's not the
9196 actual type being defined by this TU. In this case the first top
9197 level sibling is there to provide context only. */
9200 read_type_unit_scope (struct die_info *die, struct dwarf2_cu *cu)
9202 struct die_info *child_die;
9204 prepare_one_comp_unit (cu, die, language_minimal);
9206 /* Initialize (or reinitialize) the machinery for building symtabs.
9207 We do this before processing child DIEs, so that the line header table
9208 is available for DW_AT_decl_file. */
9209 setup_type_unit_groups (die, cu);
9211 if (die->child != NULL)
9213 child_die = die->child;
9214 while (child_die && child_die->tag)
9216 process_die (child_die, cu);
9217 child_die = sibling_die (child_die);
9224 http://gcc.gnu.org/wiki/DebugFission
9225 http://gcc.gnu.org/wiki/DebugFissionDWP
9227 To simplify handling of both DWO files ("object" files with the DWARF info)
9228 and DWP files (a file with the DWOs packaged up into one file), we treat
9229 DWP files as having a collection of virtual DWO files. */
9232 hash_dwo_file (const void *item)
9234 const struct dwo_file *dwo_file = item;
9237 hash = htab_hash_string (dwo_file->dwo_name);
9238 if (dwo_file->comp_dir != NULL)
9239 hash += htab_hash_string (dwo_file->comp_dir);
9244 eq_dwo_file (const void *item_lhs, const void *item_rhs)
9246 const struct dwo_file *lhs = item_lhs;
9247 const struct dwo_file *rhs = item_rhs;
9249 if (strcmp (lhs->dwo_name, rhs->dwo_name) != 0)
9251 if (lhs->comp_dir == NULL || rhs->comp_dir == NULL)
9252 return lhs->comp_dir == rhs->comp_dir;
9253 return strcmp (lhs->comp_dir, rhs->comp_dir) == 0;
9256 /* Allocate a hash table for DWO files. */
9259 allocate_dwo_file_hash_table (void)
9261 struct objfile *objfile = dwarf2_per_objfile->objfile;
9263 return htab_create_alloc_ex (41,
9267 &objfile->objfile_obstack,
9268 hashtab_obstack_allocate,
9269 dummy_obstack_deallocate);
9272 /* Lookup DWO file DWO_NAME. */
9275 lookup_dwo_file_slot (const char *dwo_name, const char *comp_dir)
9277 struct dwo_file find_entry;
9280 if (dwarf2_per_objfile->dwo_files == NULL)
9281 dwarf2_per_objfile->dwo_files = allocate_dwo_file_hash_table ();
9283 memset (&find_entry, 0, sizeof (find_entry));
9284 find_entry.dwo_name = dwo_name;
9285 find_entry.comp_dir = comp_dir;
9286 slot = htab_find_slot (dwarf2_per_objfile->dwo_files, &find_entry, INSERT);
9292 hash_dwo_unit (const void *item)
9294 const struct dwo_unit *dwo_unit = item;
9296 /* This drops the top 32 bits of the id, but is ok for a hash. */
9297 return dwo_unit->signature;
9301 eq_dwo_unit (const void *item_lhs, const void *item_rhs)
9303 const struct dwo_unit *lhs = item_lhs;
9304 const struct dwo_unit *rhs = item_rhs;
9306 /* The signature is assumed to be unique within the DWO file.
9307 So while object file CU dwo_id's always have the value zero,
9308 that's OK, assuming each object file DWO file has only one CU,
9309 and that's the rule for now. */
9310 return lhs->signature == rhs->signature;
9313 /* Allocate a hash table for DWO CUs,TUs.
9314 There is one of these tables for each of CUs,TUs for each DWO file. */
9317 allocate_dwo_unit_table (struct objfile *objfile)
9319 /* Start out with a pretty small number.
9320 Generally DWO files contain only one CU and maybe some TUs. */
9321 return htab_create_alloc_ex (3,
9325 &objfile->objfile_obstack,
9326 hashtab_obstack_allocate,
9327 dummy_obstack_deallocate);
9330 /* Structure used to pass data to create_dwo_debug_info_hash_table_reader. */
9332 struct create_dwo_cu_data
9334 struct dwo_file *dwo_file;
9335 struct dwo_unit dwo_unit;
9338 /* die_reader_func for create_dwo_cu. */
9341 create_dwo_cu_reader (const struct die_reader_specs *reader,
9342 const gdb_byte *info_ptr,
9343 struct die_info *comp_unit_die,
9347 struct dwarf2_cu *cu = reader->cu;
9348 struct objfile *objfile = dwarf2_per_objfile->objfile;
9349 sect_offset offset = cu->per_cu->offset;
9350 struct dwarf2_section_info *section = cu->per_cu->section;
9351 struct create_dwo_cu_data *data = datap;
9352 struct dwo_file *dwo_file = data->dwo_file;
9353 struct dwo_unit *dwo_unit = &data->dwo_unit;
9354 struct attribute *attr;
9356 attr = dwarf2_attr (comp_unit_die, DW_AT_GNU_dwo_id, cu);
9359 complaint (&symfile_complaints,
9360 _("Dwarf Error: debug entry at offset 0x%x is missing"
9361 " its dwo_id [in module %s]"),
9362 offset.sect_off, dwo_file->dwo_name);
9366 dwo_unit->dwo_file = dwo_file;
9367 dwo_unit->signature = DW_UNSND (attr);
9368 dwo_unit->section = section;
9369 dwo_unit->offset = offset;
9370 dwo_unit->length = cu->per_cu->length;
9372 if (dwarf2_read_debug)
9373 fprintf_unfiltered (gdb_stdlog, " offset 0x%x, dwo_id %s\n",
9374 offset.sect_off, hex_string (dwo_unit->signature));
9377 /* Create the dwo_unit for the lone CU in DWO_FILE.
9378 Note: This function processes DWO files only, not DWP files. */
9380 static struct dwo_unit *
9381 create_dwo_cu (struct dwo_file *dwo_file)
9383 struct objfile *objfile = dwarf2_per_objfile->objfile;
9384 struct dwarf2_section_info *section = &dwo_file->sections.info;
9387 const gdb_byte *info_ptr, *end_ptr;
9388 struct create_dwo_cu_data create_dwo_cu_data;
9389 struct dwo_unit *dwo_unit;
9391 dwarf2_read_section (objfile, section);
9392 info_ptr = section->buffer;
9394 if (info_ptr == NULL)
9397 /* We can't set abfd until now because the section may be empty or
9398 not present, in which case section->asection will be NULL. */
9399 abfd = get_section_bfd_owner (section);
9401 if (dwarf2_read_debug)
9403 fprintf_unfiltered (gdb_stdlog, "Reading %s for %s:\n",
9404 get_section_name (section),
9405 get_section_file_name (section));
9408 create_dwo_cu_data.dwo_file = dwo_file;
9411 end_ptr = info_ptr + section->size;
9412 while (info_ptr < end_ptr)
9414 struct dwarf2_per_cu_data per_cu;
9416 memset (&create_dwo_cu_data.dwo_unit, 0,
9417 sizeof (create_dwo_cu_data.dwo_unit));
9418 memset (&per_cu, 0, sizeof (per_cu));
9419 per_cu.objfile = objfile;
9420 per_cu.is_debug_types = 0;
9421 per_cu.offset.sect_off = info_ptr - section->buffer;
9422 per_cu.section = section;
9424 init_cutu_and_read_dies_no_follow (&per_cu, dwo_file,
9425 create_dwo_cu_reader,
9426 &create_dwo_cu_data);
9428 if (create_dwo_cu_data.dwo_unit.dwo_file != NULL)
9430 /* If we've already found one, complain. We only support one
9431 because having more than one requires hacking the dwo_name of
9432 each to match, which is highly unlikely to happen. */
9433 if (dwo_unit != NULL)
9435 complaint (&symfile_complaints,
9436 _("Multiple CUs in DWO file %s [in module %s]"),
9437 dwo_file->dwo_name, objfile_name (objfile));
9441 dwo_unit = OBSTACK_ZALLOC (&objfile->objfile_obstack, struct dwo_unit);
9442 *dwo_unit = create_dwo_cu_data.dwo_unit;
9445 info_ptr += per_cu.length;
9451 /* DWP file .debug_{cu,tu}_index section format:
9452 [ref: http://gcc.gnu.org/wiki/DebugFissionDWP]
9456 Both index sections have the same format, and serve to map a 64-bit
9457 signature to a set of section numbers. Each section begins with a header,
9458 followed by a hash table of 64-bit signatures, a parallel table of 32-bit
9459 indexes, and a pool of 32-bit section numbers. The index sections will be
9460 aligned at 8-byte boundaries in the file.
9462 The index section header consists of:
9464 V, 32 bit version number
9466 N, 32 bit number of compilation units or type units in the index
9467 M, 32 bit number of slots in the hash table
9469 Numbers are recorded using the byte order of the application binary.
9471 The hash table begins at offset 16 in the section, and consists of an array
9472 of M 64-bit slots. Each slot contains a 64-bit signature (using the byte
9473 order of the application binary). Unused slots in the hash table are 0.
9474 (We rely on the extreme unlikeliness of a signature being exactly 0.)
9476 The parallel table begins immediately after the hash table
9477 (at offset 16 + 8 * M from the beginning of the section), and consists of an
9478 array of 32-bit indexes (using the byte order of the application binary),
9479 corresponding 1-1 with slots in the hash table. Each entry in the parallel
9480 table contains a 32-bit index into the pool of section numbers. For unused
9481 hash table slots, the corresponding entry in the parallel table will be 0.
9483 The pool of section numbers begins immediately following the hash table
9484 (at offset 16 + 12 * M from the beginning of the section). The pool of
9485 section numbers consists of an array of 32-bit words (using the byte order
9486 of the application binary). Each item in the array is indexed starting
9487 from 0. The hash table entry provides the index of the first section
9488 number in the set. Additional section numbers in the set follow, and the
9489 set is terminated by a 0 entry (section number 0 is not used in ELF).
9491 In each set of section numbers, the .debug_info.dwo or .debug_types.dwo
9492 section must be the first entry in the set, and the .debug_abbrev.dwo must
9493 be the second entry. Other members of the set may follow in any order.
9499 DWP Version 2 combines all the .debug_info, etc. sections into one,
9500 and the entries in the index tables are now offsets into these sections.
9501 CU offsets begin at 0. TU offsets begin at the size of the .debug_info
9504 Index Section Contents:
9506 Hash Table of Signatures dwp_hash_table.hash_table
9507 Parallel Table of Indices dwp_hash_table.unit_table
9508 Table of Section Offsets dwp_hash_table.v2.{section_ids,offsets}
9509 Table of Section Sizes dwp_hash_table.v2.sizes
9511 The index section header consists of:
9513 V, 32 bit version number
9514 L, 32 bit number of columns in the table of section offsets
9515 N, 32 bit number of compilation units or type units in the index
9516 M, 32 bit number of slots in the hash table
9518 Numbers are recorded using the byte order of the application binary.
9520 The hash table has the same format as version 1.
9521 The parallel table of indices has the same format as version 1,
9522 except that the entries are origin-1 indices into the table of sections
9523 offsets and the table of section sizes.
9525 The table of offsets begins immediately following the parallel table
9526 (at offset 16 + 12 * M from the beginning of the section). The table is
9527 a two-dimensional array of 32-bit words (using the byte order of the
9528 application binary), with L columns and N+1 rows, in row-major order.
9529 Each row in the array is indexed starting from 0. The first row provides
9530 a key to the remaining rows: each column in this row provides an identifier
9531 for a debug section, and the offsets in the same column of subsequent rows
9532 refer to that section. The section identifiers are:
9534 DW_SECT_INFO 1 .debug_info.dwo
9535 DW_SECT_TYPES 2 .debug_types.dwo
9536 DW_SECT_ABBREV 3 .debug_abbrev.dwo
9537 DW_SECT_LINE 4 .debug_line.dwo
9538 DW_SECT_LOC 5 .debug_loc.dwo
9539 DW_SECT_STR_OFFSETS 6 .debug_str_offsets.dwo
9540 DW_SECT_MACINFO 7 .debug_macinfo.dwo
9541 DW_SECT_MACRO 8 .debug_macro.dwo
9543 The offsets provided by the CU and TU index sections are the base offsets
9544 for the contributions made by each CU or TU to the corresponding section
9545 in the package file. Each CU and TU header contains an abbrev_offset
9546 field, used to find the abbreviations table for that CU or TU within the
9547 contribution to the .debug_abbrev.dwo section for that CU or TU, and should
9548 be interpreted as relative to the base offset given in the index section.
9549 Likewise, offsets into .debug_line.dwo from DW_AT_stmt_list attributes
9550 should be interpreted as relative to the base offset for .debug_line.dwo,
9551 and offsets into other debug sections obtained from DWARF attributes should
9552 also be interpreted as relative to the corresponding base offset.
9554 The table of sizes begins immediately following the table of offsets.
9555 Like the table of offsets, it is a two-dimensional array of 32-bit words,
9556 with L columns and N rows, in row-major order. Each row in the array is
9557 indexed starting from 1 (row 0 is shared by the two tables).
9561 Hash table lookup is handled the same in version 1 and 2:
9563 We assume that N and M will not exceed 2^32 - 1.
9564 The size of the hash table, M, must be 2^k such that 2^k > 3*N/2.
9566 Given a 64-bit compilation unit signature or a type signature S, an entry
9567 in the hash table is located as follows:
9569 1) Calculate a primary hash H = S & MASK(k), where MASK(k) is a mask with
9570 the low-order k bits all set to 1.
9572 2) Calculate a secondary hash H' = (((S >> 32) & MASK(k)) | 1).
9574 3) If the hash table entry at index H matches the signature, use that
9575 entry. If the hash table entry at index H is unused (all zeroes),
9576 terminate the search: the signature is not present in the table.
9578 4) Let H = (H + H') modulo M. Repeat at Step 3.
9580 Because M > N and H' and M are relatively prime, the search is guaranteed
9581 to stop at an unused slot or find the match. */
9583 /* Create a hash table to map DWO IDs to their CU/TU entry in
9584 .debug_{info,types}.dwo in DWP_FILE.
9585 Returns NULL if there isn't one.
9586 Note: This function processes DWP files only, not DWO files. */
9588 static struct dwp_hash_table *
9589 create_dwp_hash_table (struct dwp_file *dwp_file, int is_debug_types)
9591 struct objfile *objfile = dwarf2_per_objfile->objfile;
9592 bfd *dbfd = dwp_file->dbfd;
9593 const gdb_byte *index_ptr, *index_end;
9594 struct dwarf2_section_info *index;
9595 uint32_t version, nr_columns, nr_units, nr_slots;
9596 struct dwp_hash_table *htab;
9599 index = &dwp_file->sections.tu_index;
9601 index = &dwp_file->sections.cu_index;
9603 if (dwarf2_section_empty_p (index))
9605 dwarf2_read_section (objfile, index);
9607 index_ptr = index->buffer;
9608 index_end = index_ptr + index->size;
9610 version = read_4_bytes (dbfd, index_ptr);
9613 nr_columns = read_4_bytes (dbfd, index_ptr);
9617 nr_units = read_4_bytes (dbfd, index_ptr);
9619 nr_slots = read_4_bytes (dbfd, index_ptr);
9622 if (version != 1 && version != 2)
9624 error (_("Dwarf Error: unsupported DWP file version (%s)"
9626 pulongest (version), dwp_file->name);
9628 if (nr_slots != (nr_slots & -nr_slots))
9630 error (_("Dwarf Error: number of slots in DWP hash table (%s)"
9631 " is not power of 2 [in module %s]"),
9632 pulongest (nr_slots), dwp_file->name);
9635 htab = OBSTACK_ZALLOC (&objfile->objfile_obstack, struct dwp_hash_table);
9636 htab->version = version;
9637 htab->nr_columns = nr_columns;
9638 htab->nr_units = nr_units;
9639 htab->nr_slots = nr_slots;
9640 htab->hash_table = index_ptr;
9641 htab->unit_table = htab->hash_table + sizeof (uint64_t) * nr_slots;
9643 /* Exit early if the table is empty. */
9644 if (nr_slots == 0 || nr_units == 0
9645 || (version == 2 && nr_columns == 0))
9647 /* All must be zero. */
9648 if (nr_slots != 0 || nr_units != 0
9649 || (version == 2 && nr_columns != 0))
9651 complaint (&symfile_complaints,
9652 _("Empty DWP but nr_slots,nr_units,nr_columns not"
9653 " all zero [in modules %s]"),
9661 htab->section_pool.v1.indices =
9662 htab->unit_table + sizeof (uint32_t) * nr_slots;
9663 /* It's harder to decide whether the section is too small in v1.
9664 V1 is deprecated anyway so we punt. */
9668 const gdb_byte *ids_ptr = htab->unit_table + sizeof (uint32_t) * nr_slots;
9669 int *ids = htab->section_pool.v2.section_ids;
9670 /* Reverse map for error checking. */
9671 int ids_seen[DW_SECT_MAX + 1];
9676 error (_("Dwarf Error: bad DWP hash table, too few columns"
9677 " in section table [in module %s]"),
9680 if (nr_columns > MAX_NR_V2_DWO_SECTIONS)
9682 error (_("Dwarf Error: bad DWP hash table, too many columns"
9683 " in section table [in module %s]"),
9686 memset (ids, 255, (DW_SECT_MAX + 1) * sizeof (int32_t));
9687 memset (ids_seen, 255, (DW_SECT_MAX + 1) * sizeof (int32_t));
9688 for (i = 0; i < nr_columns; ++i)
9690 int id = read_4_bytes (dbfd, ids_ptr + i * sizeof (uint32_t));
9692 if (id < DW_SECT_MIN || id > DW_SECT_MAX)
9694 error (_("Dwarf Error: bad DWP hash table, bad section id %d"
9695 " in section table [in module %s]"),
9696 id, dwp_file->name);
9698 if (ids_seen[id] != -1)
9700 error (_("Dwarf Error: bad DWP hash table, duplicate section"
9701 " id %d in section table [in module %s]"),
9702 id, dwp_file->name);
9707 /* Must have exactly one info or types section. */
9708 if (((ids_seen[DW_SECT_INFO] != -1)
9709 + (ids_seen[DW_SECT_TYPES] != -1))
9712 error (_("Dwarf Error: bad DWP hash table, missing/duplicate"
9713 " DWO info/types section [in module %s]"),
9716 /* Must have an abbrev section. */
9717 if (ids_seen[DW_SECT_ABBREV] == -1)
9719 error (_("Dwarf Error: bad DWP hash table, missing DWO abbrev"
9720 " section [in module %s]"),
9723 htab->section_pool.v2.offsets = ids_ptr + sizeof (uint32_t) * nr_columns;
9724 htab->section_pool.v2.sizes =
9725 htab->section_pool.v2.offsets + (sizeof (uint32_t)
9726 * nr_units * nr_columns);
9727 if ((htab->section_pool.v2.sizes + (sizeof (uint32_t)
9728 * nr_units * nr_columns))
9731 error (_("Dwarf Error: DWP index section is corrupt (too small)"
9740 /* Update SECTIONS with the data from SECTP.
9742 This function is like the other "locate" section routines that are
9743 passed to bfd_map_over_sections, but in this context the sections to
9744 read comes from the DWP V1 hash table, not the full ELF section table.
9746 The result is non-zero for success, or zero if an error was found. */
9749 locate_v1_virtual_dwo_sections (asection *sectp,
9750 struct virtual_v1_dwo_sections *sections)
9752 const struct dwop_section_names *names = &dwop_section_names;
9754 if (section_is_p (sectp->name, &names->abbrev_dwo))
9756 /* There can be only one. */
9757 if (sections->abbrev.s.asection != NULL)
9759 sections->abbrev.s.asection = sectp;
9760 sections->abbrev.size = bfd_get_section_size (sectp);
9762 else if (section_is_p (sectp->name, &names->info_dwo)
9763 || section_is_p (sectp->name, &names->types_dwo))
9765 /* There can be only one. */
9766 if (sections->info_or_types.s.asection != NULL)
9768 sections->info_or_types.s.asection = sectp;
9769 sections->info_or_types.size = bfd_get_section_size (sectp);
9771 else if (section_is_p (sectp->name, &names->line_dwo))
9773 /* There can be only one. */
9774 if (sections->line.s.asection != NULL)
9776 sections->line.s.asection = sectp;
9777 sections->line.size = bfd_get_section_size (sectp);
9779 else if (section_is_p (sectp->name, &names->loc_dwo))
9781 /* There can be only one. */
9782 if (sections->loc.s.asection != NULL)
9784 sections->loc.s.asection = sectp;
9785 sections->loc.size = bfd_get_section_size (sectp);
9787 else if (section_is_p (sectp->name, &names->macinfo_dwo))
9789 /* There can be only one. */
9790 if (sections->macinfo.s.asection != NULL)
9792 sections->macinfo.s.asection = sectp;
9793 sections->macinfo.size = bfd_get_section_size (sectp);
9795 else if (section_is_p (sectp->name, &names->macro_dwo))
9797 /* There can be only one. */
9798 if (sections->macro.s.asection != NULL)
9800 sections->macro.s.asection = sectp;
9801 sections->macro.size = bfd_get_section_size (sectp);
9803 else if (section_is_p (sectp->name, &names->str_offsets_dwo))
9805 /* There can be only one. */
9806 if (sections->str_offsets.s.asection != NULL)
9808 sections->str_offsets.s.asection = sectp;
9809 sections->str_offsets.size = bfd_get_section_size (sectp);
9813 /* No other kind of section is valid. */
9820 /* Create a dwo_unit object for the DWO unit with signature SIGNATURE.
9821 UNIT_INDEX is the index of the DWO unit in the DWP hash table.
9822 COMP_DIR is the DW_AT_comp_dir attribute of the referencing CU.
9823 This is for DWP version 1 files. */
9825 static struct dwo_unit *
9826 create_dwo_unit_in_dwp_v1 (struct dwp_file *dwp_file,
9827 uint32_t unit_index,
9828 const char *comp_dir,
9829 ULONGEST signature, int is_debug_types)
9831 struct objfile *objfile = dwarf2_per_objfile->objfile;
9832 const struct dwp_hash_table *dwp_htab =
9833 is_debug_types ? dwp_file->tus : dwp_file->cus;
9834 bfd *dbfd = dwp_file->dbfd;
9835 const char *kind = is_debug_types ? "TU" : "CU";
9836 struct dwo_file *dwo_file;
9837 struct dwo_unit *dwo_unit;
9838 struct virtual_v1_dwo_sections sections;
9839 void **dwo_file_slot;
9840 char *virtual_dwo_name;
9841 struct dwarf2_section_info *cutu;
9842 struct cleanup *cleanups;
9845 gdb_assert (dwp_file->version == 1);
9847 if (dwarf2_read_debug)
9849 fprintf_unfiltered (gdb_stdlog, "Reading %s %s/%s in DWP V1 file: %s\n",
9851 pulongest (unit_index), hex_string (signature),
9855 /* Fetch the sections of this DWO unit.
9856 Put a limit on the number of sections we look for so that bad data
9857 doesn't cause us to loop forever. */
9859 #define MAX_NR_V1_DWO_SECTIONS \
9860 (1 /* .debug_info or .debug_types */ \
9861 + 1 /* .debug_abbrev */ \
9862 + 1 /* .debug_line */ \
9863 + 1 /* .debug_loc */ \
9864 + 1 /* .debug_str_offsets */ \
9865 + 1 /* .debug_macro or .debug_macinfo */ \
9866 + 1 /* trailing zero */)
9868 memset (§ions, 0, sizeof (sections));
9869 cleanups = make_cleanup (null_cleanup, 0);
9871 for (i = 0; i < MAX_NR_V1_DWO_SECTIONS; ++i)
9874 uint32_t section_nr =
9876 dwp_htab->section_pool.v1.indices
9877 + (unit_index + i) * sizeof (uint32_t));
9879 if (section_nr == 0)
9881 if (section_nr >= dwp_file->num_sections)
9883 error (_("Dwarf Error: bad DWP hash table, section number too large"
9888 sectp = dwp_file->elf_sections[section_nr];
9889 if (! locate_v1_virtual_dwo_sections (sectp, §ions))
9891 error (_("Dwarf Error: bad DWP hash table, invalid section found"
9898 || dwarf2_section_empty_p (§ions.info_or_types)
9899 || dwarf2_section_empty_p (§ions.abbrev))
9901 error (_("Dwarf Error: bad DWP hash table, missing DWO sections"
9905 if (i == MAX_NR_V1_DWO_SECTIONS)
9907 error (_("Dwarf Error: bad DWP hash table, too many DWO sections"
9912 /* It's easier for the rest of the code if we fake a struct dwo_file and
9913 have dwo_unit "live" in that. At least for now.
9915 The DWP file can be made up of a random collection of CUs and TUs.
9916 However, for each CU + set of TUs that came from the same original DWO
9917 file, we can combine them back into a virtual DWO file to save space
9918 (fewer struct dwo_file objects to allocate). Remember that for really
9919 large apps there can be on the order of 8K CUs and 200K TUs, or more. */
9922 xstrprintf ("virtual-dwo/%d-%d-%d-%d",
9923 get_section_id (§ions.abbrev),
9924 get_section_id (§ions.line),
9925 get_section_id (§ions.loc),
9926 get_section_id (§ions.str_offsets));
9927 make_cleanup (xfree, virtual_dwo_name);
9928 /* Can we use an existing virtual DWO file? */
9929 dwo_file_slot = lookup_dwo_file_slot (virtual_dwo_name, comp_dir);
9930 /* Create one if necessary. */
9931 if (*dwo_file_slot == NULL)
9933 if (dwarf2_read_debug)
9935 fprintf_unfiltered (gdb_stdlog, "Creating virtual DWO: %s\n",
9938 dwo_file = OBSTACK_ZALLOC (&objfile->objfile_obstack, struct dwo_file);
9939 dwo_file->dwo_name = obstack_copy0 (&objfile->objfile_obstack,
9941 strlen (virtual_dwo_name));
9942 dwo_file->comp_dir = comp_dir;
9943 dwo_file->sections.abbrev = sections.abbrev;
9944 dwo_file->sections.line = sections.line;
9945 dwo_file->sections.loc = sections.loc;
9946 dwo_file->sections.macinfo = sections.macinfo;
9947 dwo_file->sections.macro = sections.macro;
9948 dwo_file->sections.str_offsets = sections.str_offsets;
9949 /* The "str" section is global to the entire DWP file. */
9950 dwo_file->sections.str = dwp_file->sections.str;
9951 /* The info or types section is assigned below to dwo_unit,
9952 there's no need to record it in dwo_file.
9953 Also, we can't simply record type sections in dwo_file because
9954 we record a pointer into the vector in dwo_unit. As we collect more
9955 types we'll grow the vector and eventually have to reallocate space
9956 for it, invalidating all copies of pointers into the previous
9958 *dwo_file_slot = dwo_file;
9962 if (dwarf2_read_debug)
9964 fprintf_unfiltered (gdb_stdlog, "Using existing virtual DWO: %s\n",
9967 dwo_file = *dwo_file_slot;
9969 do_cleanups (cleanups);
9971 dwo_unit = OBSTACK_ZALLOC (&objfile->objfile_obstack, struct dwo_unit);
9972 dwo_unit->dwo_file = dwo_file;
9973 dwo_unit->signature = signature;
9974 dwo_unit->section = obstack_alloc (&objfile->objfile_obstack,
9975 sizeof (struct dwarf2_section_info));
9976 *dwo_unit->section = sections.info_or_types;
9977 /* dwo_unit->{offset,length,type_offset_in_tu} are set later. */
9982 /* Subroutine of create_dwo_unit_in_dwp_v2 to simplify it.
9983 Given a pointer to the containing section SECTION, and OFFSET,SIZE of the
9984 piece within that section used by a TU/CU, return a virtual section
9985 of just that piece. */
9987 static struct dwarf2_section_info
9988 create_dwp_v2_section (struct dwarf2_section_info *section,
9989 bfd_size_type offset, bfd_size_type size)
9991 struct dwarf2_section_info result;
9994 gdb_assert (section != NULL);
9995 gdb_assert (!section->is_virtual);
9997 memset (&result, 0, sizeof (result));
9998 result.s.containing_section = section;
9999 result.is_virtual = 1;
10004 sectp = get_section_bfd_section (section);
10006 /* Flag an error if the piece denoted by OFFSET,SIZE is outside the
10007 bounds of the real section. This is a pretty-rare event, so just
10008 flag an error (easier) instead of a warning and trying to cope. */
10010 || offset + size > bfd_get_section_size (sectp))
10012 bfd *abfd = sectp->owner;
10014 error (_("Dwarf Error: Bad DWP V2 section info, doesn't fit"
10015 " in section %s [in module %s]"),
10016 sectp ? bfd_section_name (abfd, sectp) : "<unknown>",
10017 objfile_name (dwarf2_per_objfile->objfile));
10020 result.virtual_offset = offset;
10021 result.size = size;
10025 /* Create a dwo_unit object for the DWO unit with signature SIGNATURE.
10026 UNIT_INDEX is the index of the DWO unit in the DWP hash table.
10027 COMP_DIR is the DW_AT_comp_dir attribute of the referencing CU.
10028 This is for DWP version 2 files. */
10030 static struct dwo_unit *
10031 create_dwo_unit_in_dwp_v2 (struct dwp_file *dwp_file,
10032 uint32_t unit_index,
10033 const char *comp_dir,
10034 ULONGEST signature, int is_debug_types)
10036 struct objfile *objfile = dwarf2_per_objfile->objfile;
10037 const struct dwp_hash_table *dwp_htab =
10038 is_debug_types ? dwp_file->tus : dwp_file->cus;
10039 bfd *dbfd = dwp_file->dbfd;
10040 const char *kind = is_debug_types ? "TU" : "CU";
10041 struct dwo_file *dwo_file;
10042 struct dwo_unit *dwo_unit;
10043 struct virtual_v2_dwo_sections sections;
10044 void **dwo_file_slot;
10045 char *virtual_dwo_name;
10046 struct dwarf2_section_info *cutu;
10047 struct cleanup *cleanups;
10050 gdb_assert (dwp_file->version == 2);
10052 if (dwarf2_read_debug)
10054 fprintf_unfiltered (gdb_stdlog, "Reading %s %s/%s in DWP V2 file: %s\n",
10056 pulongest (unit_index), hex_string (signature),
10060 /* Fetch the section offsets of this DWO unit. */
10062 memset (§ions, 0, sizeof (sections));
10063 cleanups = make_cleanup (null_cleanup, 0);
10065 for (i = 0; i < dwp_htab->nr_columns; ++i)
10067 uint32_t offset = read_4_bytes (dbfd,
10068 dwp_htab->section_pool.v2.offsets
10069 + (((unit_index - 1) * dwp_htab->nr_columns
10071 * sizeof (uint32_t)));
10072 uint32_t size = read_4_bytes (dbfd,
10073 dwp_htab->section_pool.v2.sizes
10074 + (((unit_index - 1) * dwp_htab->nr_columns
10076 * sizeof (uint32_t)));
10078 switch (dwp_htab->section_pool.v2.section_ids[i])
10081 case DW_SECT_TYPES:
10082 sections.info_or_types_offset = offset;
10083 sections.info_or_types_size = size;
10085 case DW_SECT_ABBREV:
10086 sections.abbrev_offset = offset;
10087 sections.abbrev_size = size;
10090 sections.line_offset = offset;
10091 sections.line_size = size;
10094 sections.loc_offset = offset;
10095 sections.loc_size = size;
10097 case DW_SECT_STR_OFFSETS:
10098 sections.str_offsets_offset = offset;
10099 sections.str_offsets_size = size;
10101 case DW_SECT_MACINFO:
10102 sections.macinfo_offset = offset;
10103 sections.macinfo_size = size;
10105 case DW_SECT_MACRO:
10106 sections.macro_offset = offset;
10107 sections.macro_size = size;
10112 /* It's easier for the rest of the code if we fake a struct dwo_file and
10113 have dwo_unit "live" in that. At least for now.
10115 The DWP file can be made up of a random collection of CUs and TUs.
10116 However, for each CU + set of TUs that came from the same original DWO
10117 file, we can combine them back into a virtual DWO file to save space
10118 (fewer struct dwo_file objects to allocate). Remember that for really
10119 large apps there can be on the order of 8K CUs and 200K TUs, or more. */
10122 xstrprintf ("virtual-dwo/%ld-%ld-%ld-%ld",
10123 (long) (sections.abbrev_size ? sections.abbrev_offset : 0),
10124 (long) (sections.line_size ? sections.line_offset : 0),
10125 (long) (sections.loc_size ? sections.loc_offset : 0),
10126 (long) (sections.str_offsets_size
10127 ? sections.str_offsets_offset : 0));
10128 make_cleanup (xfree, virtual_dwo_name);
10129 /* Can we use an existing virtual DWO file? */
10130 dwo_file_slot = lookup_dwo_file_slot (virtual_dwo_name, comp_dir);
10131 /* Create one if necessary. */
10132 if (*dwo_file_slot == NULL)
10134 if (dwarf2_read_debug)
10136 fprintf_unfiltered (gdb_stdlog, "Creating virtual DWO: %s\n",
10139 dwo_file = OBSTACK_ZALLOC (&objfile->objfile_obstack, struct dwo_file);
10140 dwo_file->dwo_name = obstack_copy0 (&objfile->objfile_obstack,
10142 strlen (virtual_dwo_name));
10143 dwo_file->comp_dir = comp_dir;
10144 dwo_file->sections.abbrev =
10145 create_dwp_v2_section (&dwp_file->sections.abbrev,
10146 sections.abbrev_offset, sections.abbrev_size);
10147 dwo_file->sections.line =
10148 create_dwp_v2_section (&dwp_file->sections.line,
10149 sections.line_offset, sections.line_size);
10150 dwo_file->sections.loc =
10151 create_dwp_v2_section (&dwp_file->sections.loc,
10152 sections.loc_offset, sections.loc_size);
10153 dwo_file->sections.macinfo =
10154 create_dwp_v2_section (&dwp_file->sections.macinfo,
10155 sections.macinfo_offset, sections.macinfo_size);
10156 dwo_file->sections.macro =
10157 create_dwp_v2_section (&dwp_file->sections.macro,
10158 sections.macro_offset, sections.macro_size);
10159 dwo_file->sections.str_offsets =
10160 create_dwp_v2_section (&dwp_file->sections.str_offsets,
10161 sections.str_offsets_offset,
10162 sections.str_offsets_size);
10163 /* The "str" section is global to the entire DWP file. */
10164 dwo_file->sections.str = dwp_file->sections.str;
10165 /* The info or types section is assigned below to dwo_unit,
10166 there's no need to record it in dwo_file.
10167 Also, we can't simply record type sections in dwo_file because
10168 we record a pointer into the vector in dwo_unit. As we collect more
10169 types we'll grow the vector and eventually have to reallocate space
10170 for it, invalidating all copies of pointers into the previous
10172 *dwo_file_slot = dwo_file;
10176 if (dwarf2_read_debug)
10178 fprintf_unfiltered (gdb_stdlog, "Using existing virtual DWO: %s\n",
10181 dwo_file = *dwo_file_slot;
10183 do_cleanups (cleanups);
10185 dwo_unit = OBSTACK_ZALLOC (&objfile->objfile_obstack, struct dwo_unit);
10186 dwo_unit->dwo_file = dwo_file;
10187 dwo_unit->signature = signature;
10188 dwo_unit->section = obstack_alloc (&objfile->objfile_obstack,
10189 sizeof (struct dwarf2_section_info));
10190 *dwo_unit->section = create_dwp_v2_section (is_debug_types
10191 ? &dwp_file->sections.types
10192 : &dwp_file->sections.info,
10193 sections.info_or_types_offset,
10194 sections.info_or_types_size);
10195 /* dwo_unit->{offset,length,type_offset_in_tu} are set later. */
10200 /* Lookup the DWO unit with SIGNATURE in DWP_FILE.
10201 Returns NULL if the signature isn't found. */
10203 static struct dwo_unit *
10204 lookup_dwo_unit_in_dwp (struct dwp_file *dwp_file, const char *comp_dir,
10205 ULONGEST signature, int is_debug_types)
10207 const struct dwp_hash_table *dwp_htab =
10208 is_debug_types ? dwp_file->tus : dwp_file->cus;
10209 bfd *dbfd = dwp_file->dbfd;
10210 uint32_t mask = dwp_htab->nr_slots - 1;
10211 uint32_t hash = signature & mask;
10212 uint32_t hash2 = ((signature >> 32) & mask) | 1;
10215 struct dwo_unit find_dwo_cu, *dwo_cu;
10217 memset (&find_dwo_cu, 0, sizeof (find_dwo_cu));
10218 find_dwo_cu.signature = signature;
10219 slot = htab_find_slot (is_debug_types
10220 ? dwp_file->loaded_tus
10221 : dwp_file->loaded_cus,
10222 &find_dwo_cu, INSERT);
10227 /* Use a for loop so that we don't loop forever on bad debug info. */
10228 for (i = 0; i < dwp_htab->nr_slots; ++i)
10230 ULONGEST signature_in_table;
10232 signature_in_table =
10233 read_8_bytes (dbfd, dwp_htab->hash_table + hash * sizeof (uint64_t));
10234 if (signature_in_table == signature)
10236 uint32_t unit_index =
10237 read_4_bytes (dbfd,
10238 dwp_htab->unit_table + hash * sizeof (uint32_t));
10240 if (dwp_file->version == 1)
10242 *slot = create_dwo_unit_in_dwp_v1 (dwp_file, unit_index,
10243 comp_dir, signature,
10248 *slot = create_dwo_unit_in_dwp_v2 (dwp_file, unit_index,
10249 comp_dir, signature,
10254 if (signature_in_table == 0)
10256 hash = (hash + hash2) & mask;
10259 error (_("Dwarf Error: bad DWP hash table, lookup didn't terminate"
10260 " [in module %s]"),
10264 /* Subroutine of open_dwo_file,open_dwp_file to simplify them.
10265 Open the file specified by FILE_NAME and hand it off to BFD for
10266 preliminary analysis. Return a newly initialized bfd *, which
10267 includes a canonicalized copy of FILE_NAME.
10268 If IS_DWP is TRUE, we're opening a DWP file, otherwise a DWO file.
10269 SEARCH_CWD is true if the current directory is to be searched.
10270 It will be searched before debug-file-directory.
10271 If successful, the file is added to the bfd include table of the
10272 objfile's bfd (see gdb_bfd_record_inclusion).
10273 If unable to find/open the file, return NULL.
10274 NOTE: This function is derived from symfile_bfd_open. */
10277 try_open_dwop_file (const char *file_name, int is_dwp, int search_cwd)
10281 char *absolute_name;
10282 /* Blech. OPF_TRY_CWD_FIRST also disables searching the path list if
10283 FILE_NAME contains a '/'. So we can't use it. Instead prepend "."
10284 to debug_file_directory. */
10286 static const char dirname_separator_string[] = { DIRNAME_SEPARATOR, '\0' };
10290 if (*debug_file_directory != '\0')
10291 search_path = concat (".", dirname_separator_string,
10292 debug_file_directory, NULL);
10294 search_path = xstrdup (".");
10297 search_path = xstrdup (debug_file_directory);
10299 flags = OPF_RETURN_REALPATH;
10301 flags |= OPF_SEARCH_IN_PATH;
10302 desc = openp (search_path, flags, file_name,
10303 O_RDONLY | O_BINARY, &absolute_name);
10304 xfree (search_path);
10308 sym_bfd = gdb_bfd_open (absolute_name, gnutarget, desc);
10309 xfree (absolute_name);
10310 if (sym_bfd == NULL)
10312 bfd_set_cacheable (sym_bfd, 1);
10314 if (!bfd_check_format (sym_bfd, bfd_object))
10316 gdb_bfd_unref (sym_bfd); /* This also closes desc. */
10320 /* Success. Record the bfd as having been included by the objfile's bfd.
10321 This is important because things like demangled_names_hash lives in the
10322 objfile's per_bfd space and may have references to things like symbol
10323 names that live in the DWO/DWP file's per_bfd space. PR 16426. */
10324 gdb_bfd_record_inclusion (dwarf2_per_objfile->objfile->obfd, sym_bfd);
10329 /* Try to open DWO file FILE_NAME.
10330 COMP_DIR is the DW_AT_comp_dir attribute.
10331 The result is the bfd handle of the file.
10332 If there is a problem finding or opening the file, return NULL.
10333 Upon success, the canonicalized path of the file is stored in the bfd,
10334 same as symfile_bfd_open. */
10337 open_dwo_file (const char *file_name, const char *comp_dir)
10341 if (IS_ABSOLUTE_PATH (file_name))
10342 return try_open_dwop_file (file_name, 0 /*is_dwp*/, 0 /*search_cwd*/);
10344 /* Before trying the search path, try DWO_NAME in COMP_DIR. */
10346 if (comp_dir != NULL)
10348 char *path_to_try = concat (comp_dir, SLASH_STRING, file_name, NULL);
10350 /* NOTE: If comp_dir is a relative path, this will also try the
10351 search path, which seems useful. */
10352 abfd = try_open_dwop_file (path_to_try, 0 /*is_dwp*/, 1 /*search_cwd*/);
10353 xfree (path_to_try);
10358 /* That didn't work, try debug-file-directory, which, despite its name,
10359 is a list of paths. */
10361 if (*debug_file_directory == '\0')
10364 return try_open_dwop_file (file_name, 0 /*is_dwp*/, 1 /*search_cwd*/);
10367 /* This function is mapped across the sections and remembers the offset and
10368 size of each of the DWO debugging sections we are interested in. */
10371 dwarf2_locate_dwo_sections (bfd *abfd, asection *sectp, void *dwo_sections_ptr)
10373 struct dwo_sections *dwo_sections = dwo_sections_ptr;
10374 const struct dwop_section_names *names = &dwop_section_names;
10376 if (section_is_p (sectp->name, &names->abbrev_dwo))
10378 dwo_sections->abbrev.s.asection = sectp;
10379 dwo_sections->abbrev.size = bfd_get_section_size (sectp);
10381 else if (section_is_p (sectp->name, &names->info_dwo))
10383 dwo_sections->info.s.asection = sectp;
10384 dwo_sections->info.size = bfd_get_section_size (sectp);
10386 else if (section_is_p (sectp->name, &names->line_dwo))
10388 dwo_sections->line.s.asection = sectp;
10389 dwo_sections->line.size = bfd_get_section_size (sectp);
10391 else if (section_is_p (sectp->name, &names->loc_dwo))
10393 dwo_sections->loc.s.asection = sectp;
10394 dwo_sections->loc.size = bfd_get_section_size (sectp);
10396 else if (section_is_p (sectp->name, &names->macinfo_dwo))
10398 dwo_sections->macinfo.s.asection = sectp;
10399 dwo_sections->macinfo.size = bfd_get_section_size (sectp);
10401 else if (section_is_p (sectp->name, &names->macro_dwo))
10403 dwo_sections->macro.s.asection = sectp;
10404 dwo_sections->macro.size = bfd_get_section_size (sectp);
10406 else if (section_is_p (sectp->name, &names->str_dwo))
10408 dwo_sections->str.s.asection = sectp;
10409 dwo_sections->str.size = bfd_get_section_size (sectp);
10411 else if (section_is_p (sectp->name, &names->str_offsets_dwo))
10413 dwo_sections->str_offsets.s.asection = sectp;
10414 dwo_sections->str_offsets.size = bfd_get_section_size (sectp);
10416 else if (section_is_p (sectp->name, &names->types_dwo))
10418 struct dwarf2_section_info type_section;
10420 memset (&type_section, 0, sizeof (type_section));
10421 type_section.s.asection = sectp;
10422 type_section.size = bfd_get_section_size (sectp);
10423 VEC_safe_push (dwarf2_section_info_def, dwo_sections->types,
10428 /* Initialize the use of the DWO file specified by DWO_NAME and referenced
10429 by PER_CU. This is for the non-DWP case.
10430 The result is NULL if DWO_NAME can't be found. */
10432 static struct dwo_file *
10433 open_and_init_dwo_file (struct dwarf2_per_cu_data *per_cu,
10434 const char *dwo_name, const char *comp_dir)
10436 struct objfile *objfile = dwarf2_per_objfile->objfile;
10437 struct dwo_file *dwo_file;
10439 struct cleanup *cleanups;
10441 dbfd = open_dwo_file (dwo_name, comp_dir);
10444 if (dwarf2_read_debug)
10445 fprintf_unfiltered (gdb_stdlog, "DWO file not found: %s\n", dwo_name);
10448 dwo_file = OBSTACK_ZALLOC (&objfile->objfile_obstack, struct dwo_file);
10449 dwo_file->dwo_name = dwo_name;
10450 dwo_file->comp_dir = comp_dir;
10451 dwo_file->dbfd = dbfd;
10453 cleanups = make_cleanup (free_dwo_file_cleanup, dwo_file);
10455 bfd_map_over_sections (dbfd, dwarf2_locate_dwo_sections, &dwo_file->sections);
10457 dwo_file->cu = create_dwo_cu (dwo_file);
10459 dwo_file->tus = create_debug_types_hash_table (dwo_file,
10460 dwo_file->sections.types);
10462 discard_cleanups (cleanups);
10464 if (dwarf2_read_debug)
10465 fprintf_unfiltered (gdb_stdlog, "DWO file found: %s\n", dwo_name);
10470 /* This function is mapped across the sections and remembers the offset and
10471 size of each of the DWP debugging sections common to version 1 and 2 that
10472 we are interested in. */
10475 dwarf2_locate_common_dwp_sections (bfd *abfd, asection *sectp,
10476 void *dwp_file_ptr)
10478 struct dwp_file *dwp_file = dwp_file_ptr;
10479 const struct dwop_section_names *names = &dwop_section_names;
10480 unsigned int elf_section_nr = elf_section_data (sectp)->this_idx;
10482 /* Record the ELF section number for later lookup: this is what the
10483 .debug_cu_index,.debug_tu_index tables use in DWP V1. */
10484 gdb_assert (elf_section_nr < dwp_file->num_sections);
10485 dwp_file->elf_sections[elf_section_nr] = sectp;
10487 /* Look for specific sections that we need. */
10488 if (section_is_p (sectp->name, &names->str_dwo))
10490 dwp_file->sections.str.s.asection = sectp;
10491 dwp_file->sections.str.size = bfd_get_section_size (sectp);
10493 else if (section_is_p (sectp->name, &names->cu_index))
10495 dwp_file->sections.cu_index.s.asection = sectp;
10496 dwp_file->sections.cu_index.size = bfd_get_section_size (sectp);
10498 else if (section_is_p (sectp->name, &names->tu_index))
10500 dwp_file->sections.tu_index.s.asection = sectp;
10501 dwp_file->sections.tu_index.size = bfd_get_section_size (sectp);
10505 /* This function is mapped across the sections and remembers the offset and
10506 size of each of the DWP version 2 debugging sections that we are interested
10507 in. This is split into a separate function because we don't know if we
10508 have version 1 or 2 until we parse the cu_index/tu_index sections. */
10511 dwarf2_locate_v2_dwp_sections (bfd *abfd, asection *sectp, void *dwp_file_ptr)
10513 struct dwp_file *dwp_file = dwp_file_ptr;
10514 const struct dwop_section_names *names = &dwop_section_names;
10515 unsigned int elf_section_nr = elf_section_data (sectp)->this_idx;
10517 /* Record the ELF section number for later lookup: this is what the
10518 .debug_cu_index,.debug_tu_index tables use in DWP V1. */
10519 gdb_assert (elf_section_nr < dwp_file->num_sections);
10520 dwp_file->elf_sections[elf_section_nr] = sectp;
10522 /* Look for specific sections that we need. */
10523 if (section_is_p (sectp->name, &names->abbrev_dwo))
10525 dwp_file->sections.abbrev.s.asection = sectp;
10526 dwp_file->sections.abbrev.size = bfd_get_section_size (sectp);
10528 else if (section_is_p (sectp->name, &names->info_dwo))
10530 dwp_file->sections.info.s.asection = sectp;
10531 dwp_file->sections.info.size = bfd_get_section_size (sectp);
10533 else if (section_is_p (sectp->name, &names->line_dwo))
10535 dwp_file->sections.line.s.asection = sectp;
10536 dwp_file->sections.line.size = bfd_get_section_size (sectp);
10538 else if (section_is_p (sectp->name, &names->loc_dwo))
10540 dwp_file->sections.loc.s.asection = sectp;
10541 dwp_file->sections.loc.size = bfd_get_section_size (sectp);
10543 else if (section_is_p (sectp->name, &names->macinfo_dwo))
10545 dwp_file->sections.macinfo.s.asection = sectp;
10546 dwp_file->sections.macinfo.size = bfd_get_section_size (sectp);
10548 else if (section_is_p (sectp->name, &names->macro_dwo))
10550 dwp_file->sections.macro.s.asection = sectp;
10551 dwp_file->sections.macro.size = bfd_get_section_size (sectp);
10553 else if (section_is_p (sectp->name, &names->str_offsets_dwo))
10555 dwp_file->sections.str_offsets.s.asection = sectp;
10556 dwp_file->sections.str_offsets.size = bfd_get_section_size (sectp);
10558 else if (section_is_p (sectp->name, &names->types_dwo))
10560 dwp_file->sections.types.s.asection = sectp;
10561 dwp_file->sections.types.size = bfd_get_section_size (sectp);
10565 /* Hash function for dwp_file loaded CUs/TUs. */
10568 hash_dwp_loaded_cutus (const void *item)
10570 const struct dwo_unit *dwo_unit = item;
10572 /* This drops the top 32 bits of the signature, but is ok for a hash. */
10573 return dwo_unit->signature;
10576 /* Equality function for dwp_file loaded CUs/TUs. */
10579 eq_dwp_loaded_cutus (const void *a, const void *b)
10581 const struct dwo_unit *dua = a;
10582 const struct dwo_unit *dub = b;
10584 return dua->signature == dub->signature;
10587 /* Allocate a hash table for dwp_file loaded CUs/TUs. */
10590 allocate_dwp_loaded_cutus_table (struct objfile *objfile)
10592 return htab_create_alloc_ex (3,
10593 hash_dwp_loaded_cutus,
10594 eq_dwp_loaded_cutus,
10596 &objfile->objfile_obstack,
10597 hashtab_obstack_allocate,
10598 dummy_obstack_deallocate);
10601 /* Try to open DWP file FILE_NAME.
10602 The result is the bfd handle of the file.
10603 If there is a problem finding or opening the file, return NULL.
10604 Upon success, the canonicalized path of the file is stored in the bfd,
10605 same as symfile_bfd_open. */
10608 open_dwp_file (const char *file_name)
10612 abfd = try_open_dwop_file (file_name, 1 /*is_dwp*/, 1 /*search_cwd*/);
10616 /* Work around upstream bug 15652.
10617 http://sourceware.org/bugzilla/show_bug.cgi?id=15652
10618 [Whether that's a "bug" is debatable, but it is getting in our way.]
10619 We have no real idea where the dwp file is, because gdb's realpath-ing
10620 of the executable's path may have discarded the needed info.
10621 [IWBN if the dwp file name was recorded in the executable, akin to
10622 .gnu_debuglink, but that doesn't exist yet.]
10623 Strip the directory from FILE_NAME and search again. */
10624 if (*debug_file_directory != '\0')
10626 /* Don't implicitly search the current directory here.
10627 If the user wants to search "." to handle this case,
10628 it must be added to debug-file-directory. */
10629 return try_open_dwop_file (lbasename (file_name), 1 /*is_dwp*/,
10636 /* Initialize the use of the DWP file for the current objfile.
10637 By convention the name of the DWP file is ${objfile}.dwp.
10638 The result is NULL if it can't be found. */
10640 static struct dwp_file *
10641 open_and_init_dwp_file (void)
10643 struct objfile *objfile = dwarf2_per_objfile->objfile;
10644 struct dwp_file *dwp_file;
10647 struct cleanup *cleanups;
10649 /* Try to find first .dwp for the binary file before any symbolic links
10651 dwp_name = xstrprintf ("%s.dwp", objfile->original_name);
10652 cleanups = make_cleanup (xfree, dwp_name);
10654 dbfd = open_dwp_file (dwp_name);
10656 && strcmp (objfile->original_name, objfile_name (objfile)) != 0)
10658 /* Try to find .dwp for the binary file after gdb_realpath resolving. */
10659 dwp_name = xstrprintf ("%s.dwp", objfile_name (objfile));
10660 make_cleanup (xfree, dwp_name);
10661 dbfd = open_dwp_file (dwp_name);
10666 if (dwarf2_read_debug)
10667 fprintf_unfiltered (gdb_stdlog, "DWP file not found: %s\n", dwp_name);
10668 do_cleanups (cleanups);
10671 dwp_file = OBSTACK_ZALLOC (&objfile->objfile_obstack, struct dwp_file);
10672 dwp_file->name = bfd_get_filename (dbfd);
10673 dwp_file->dbfd = dbfd;
10674 do_cleanups (cleanups);
10676 /* +1: section 0 is unused */
10677 dwp_file->num_sections = bfd_count_sections (dbfd) + 1;
10678 dwp_file->elf_sections =
10679 OBSTACK_CALLOC (&objfile->objfile_obstack,
10680 dwp_file->num_sections, asection *);
10682 bfd_map_over_sections (dbfd, dwarf2_locate_common_dwp_sections, dwp_file);
10684 dwp_file->cus = create_dwp_hash_table (dwp_file, 0);
10686 dwp_file->tus = create_dwp_hash_table (dwp_file, 1);
10688 /* The DWP file version is stored in the hash table. Oh well. */
10689 if (dwp_file->cus->version != dwp_file->tus->version)
10691 /* Technically speaking, we should try to limp along, but this is
10692 pretty bizarre. We use pulongest here because that's the established
10693 portability solution (e.g, we cannot use %u for uint32_t). */
10694 error (_("Dwarf Error: DWP file CU version %s doesn't match"
10695 " TU version %s [in DWP file %s]"),
10696 pulongest (dwp_file->cus->version),
10697 pulongest (dwp_file->tus->version), dwp_name);
10699 dwp_file->version = dwp_file->cus->version;
10701 if (dwp_file->version == 2)
10702 bfd_map_over_sections (dbfd, dwarf2_locate_v2_dwp_sections, dwp_file);
10704 dwp_file->loaded_cus = allocate_dwp_loaded_cutus_table (objfile);
10705 dwp_file->loaded_tus = allocate_dwp_loaded_cutus_table (objfile);
10707 if (dwarf2_read_debug)
10709 fprintf_unfiltered (gdb_stdlog, "DWP file found: %s\n", dwp_file->name);
10710 fprintf_unfiltered (gdb_stdlog,
10711 " %s CUs, %s TUs\n",
10712 pulongest (dwp_file->cus ? dwp_file->cus->nr_units : 0),
10713 pulongest (dwp_file->tus ? dwp_file->tus->nr_units : 0));
10719 /* Wrapper around open_and_init_dwp_file, only open it once. */
10721 static struct dwp_file *
10722 get_dwp_file (void)
10724 if (! dwarf2_per_objfile->dwp_checked)
10726 dwarf2_per_objfile->dwp_file = open_and_init_dwp_file ();
10727 dwarf2_per_objfile->dwp_checked = 1;
10729 return dwarf2_per_objfile->dwp_file;
10732 /* Subroutine of lookup_dwo_comp_unit, lookup_dwo_type_unit.
10733 Look up the CU/TU with signature SIGNATURE, either in DWO file DWO_NAME
10734 or in the DWP file for the objfile, referenced by THIS_UNIT.
10735 If non-NULL, comp_dir is the DW_AT_comp_dir attribute.
10736 IS_DEBUG_TYPES is non-zero if reading a TU, otherwise read a CU.
10738 This is called, for example, when wanting to read a variable with a
10739 complex location. Therefore we don't want to do file i/o for every call.
10740 Therefore we don't want to look for a DWO file on every call.
10741 Therefore we first see if we've already seen SIGNATURE in a DWP file,
10742 then we check if we've already seen DWO_NAME, and only THEN do we check
10745 The result is a pointer to the dwo_unit object or NULL if we didn't find it
10746 (dwo_id mismatch or couldn't find the DWO/DWP file). */
10748 static struct dwo_unit *
10749 lookup_dwo_cutu (struct dwarf2_per_cu_data *this_unit,
10750 const char *dwo_name, const char *comp_dir,
10751 ULONGEST signature, int is_debug_types)
10753 struct objfile *objfile = dwarf2_per_objfile->objfile;
10754 const char *kind = is_debug_types ? "TU" : "CU";
10755 void **dwo_file_slot;
10756 struct dwo_file *dwo_file;
10757 struct dwp_file *dwp_file;
10759 /* First see if there's a DWP file.
10760 If we have a DWP file but didn't find the DWO inside it, don't
10761 look for the original DWO file. It makes gdb behave differently
10762 depending on whether one is debugging in the build tree. */
10764 dwp_file = get_dwp_file ();
10765 if (dwp_file != NULL)
10767 const struct dwp_hash_table *dwp_htab =
10768 is_debug_types ? dwp_file->tus : dwp_file->cus;
10770 if (dwp_htab != NULL)
10772 struct dwo_unit *dwo_cutu =
10773 lookup_dwo_unit_in_dwp (dwp_file, comp_dir,
10774 signature, is_debug_types);
10776 if (dwo_cutu != NULL)
10778 if (dwarf2_read_debug)
10780 fprintf_unfiltered (gdb_stdlog,
10781 "Virtual DWO %s %s found: @%s\n",
10782 kind, hex_string (signature),
10783 host_address_to_string (dwo_cutu));
10791 /* No DWP file, look for the DWO file. */
10793 dwo_file_slot = lookup_dwo_file_slot (dwo_name, comp_dir);
10794 if (*dwo_file_slot == NULL)
10796 /* Read in the file and build a table of the CUs/TUs it contains. */
10797 *dwo_file_slot = open_and_init_dwo_file (this_unit, dwo_name, comp_dir);
10799 /* NOTE: This will be NULL if unable to open the file. */
10800 dwo_file = *dwo_file_slot;
10802 if (dwo_file != NULL)
10804 struct dwo_unit *dwo_cutu = NULL;
10806 if (is_debug_types && dwo_file->tus)
10808 struct dwo_unit find_dwo_cutu;
10810 memset (&find_dwo_cutu, 0, sizeof (find_dwo_cutu));
10811 find_dwo_cutu.signature = signature;
10812 dwo_cutu = htab_find (dwo_file->tus, &find_dwo_cutu);
10814 else if (!is_debug_types && dwo_file->cu)
10816 if (signature == dwo_file->cu->signature)
10817 dwo_cutu = dwo_file->cu;
10820 if (dwo_cutu != NULL)
10822 if (dwarf2_read_debug)
10824 fprintf_unfiltered (gdb_stdlog, "DWO %s %s(%s) found: @%s\n",
10825 kind, dwo_name, hex_string (signature),
10826 host_address_to_string (dwo_cutu));
10833 /* We didn't find it. This could mean a dwo_id mismatch, or
10834 someone deleted the DWO/DWP file, or the search path isn't set up
10835 correctly to find the file. */
10837 if (dwarf2_read_debug)
10839 fprintf_unfiltered (gdb_stdlog, "DWO %s %s(%s) not found\n",
10840 kind, dwo_name, hex_string (signature));
10843 /* This is a warning and not a complaint because it can be caused by
10844 pilot error (e.g., user accidentally deleting the DWO). */
10846 /* Print the name of the DWP file if we looked there, helps the user
10847 better diagnose the problem. */
10848 char *dwp_text = NULL;
10849 struct cleanup *cleanups;
10851 if (dwp_file != NULL)
10852 dwp_text = xstrprintf (" [in DWP file %s]", lbasename (dwp_file->name));
10853 cleanups = make_cleanup (xfree, dwp_text);
10855 warning (_("Could not find DWO %s %s(%s)%s referenced by %s at offset 0x%x"
10856 " [in module %s]"),
10857 kind, dwo_name, hex_string (signature),
10858 dwp_text != NULL ? dwp_text : "",
10859 this_unit->is_debug_types ? "TU" : "CU",
10860 this_unit->offset.sect_off, objfile_name (objfile));
10862 do_cleanups (cleanups);
10867 /* Lookup the DWO CU DWO_NAME/SIGNATURE referenced from THIS_CU.
10868 See lookup_dwo_cutu_unit for details. */
10870 static struct dwo_unit *
10871 lookup_dwo_comp_unit (struct dwarf2_per_cu_data *this_cu,
10872 const char *dwo_name, const char *comp_dir,
10873 ULONGEST signature)
10875 return lookup_dwo_cutu (this_cu, dwo_name, comp_dir, signature, 0);
10878 /* Lookup the DWO TU DWO_NAME/SIGNATURE referenced from THIS_TU.
10879 See lookup_dwo_cutu_unit for details. */
10881 static struct dwo_unit *
10882 lookup_dwo_type_unit (struct signatured_type *this_tu,
10883 const char *dwo_name, const char *comp_dir)
10885 return lookup_dwo_cutu (&this_tu->per_cu, dwo_name, comp_dir, this_tu->signature, 1);
10888 /* Traversal function for queue_and_load_all_dwo_tus. */
10891 queue_and_load_dwo_tu (void **slot, void *info)
10893 struct dwo_unit *dwo_unit = (struct dwo_unit *) *slot;
10894 struct dwarf2_per_cu_data *per_cu = (struct dwarf2_per_cu_data *) info;
10895 ULONGEST signature = dwo_unit->signature;
10896 struct signatured_type *sig_type =
10897 lookup_dwo_signatured_type (per_cu->cu, signature);
10899 if (sig_type != NULL)
10901 struct dwarf2_per_cu_data *sig_cu = &sig_type->per_cu;
10903 /* We pass NULL for DEPENDENT_CU because we don't yet know if there's
10904 a real dependency of PER_CU on SIG_TYPE. That is detected later
10905 while processing PER_CU. */
10906 if (maybe_queue_comp_unit (NULL, sig_cu, per_cu->cu->language))
10907 load_full_type_unit (sig_cu);
10908 VEC_safe_push (dwarf2_per_cu_ptr, per_cu->imported_symtabs, sig_cu);
10914 /* Queue all TUs contained in the DWO of PER_CU to be read in.
10915 The DWO may have the only definition of the type, though it may not be
10916 referenced anywhere in PER_CU. Thus we have to load *all* its TUs.
10917 http://sourceware.org/bugzilla/show_bug.cgi?id=15021 */
10920 queue_and_load_all_dwo_tus (struct dwarf2_per_cu_data *per_cu)
10922 struct dwo_unit *dwo_unit;
10923 struct dwo_file *dwo_file;
10925 gdb_assert (!per_cu->is_debug_types);
10926 gdb_assert (get_dwp_file () == NULL);
10927 gdb_assert (per_cu->cu != NULL);
10929 dwo_unit = per_cu->cu->dwo_unit;
10930 gdb_assert (dwo_unit != NULL);
10932 dwo_file = dwo_unit->dwo_file;
10933 if (dwo_file->tus != NULL)
10934 htab_traverse_noresize (dwo_file->tus, queue_and_load_dwo_tu, per_cu);
10937 /* Free all resources associated with DWO_FILE.
10938 Close the DWO file and munmap the sections.
10939 All memory should be on the objfile obstack. */
10942 free_dwo_file (struct dwo_file *dwo_file, struct objfile *objfile)
10945 struct dwarf2_section_info *section;
10947 /* Note: dbfd is NULL for virtual DWO files. */
10948 gdb_bfd_unref (dwo_file->dbfd);
10950 VEC_free (dwarf2_section_info_def, dwo_file->sections.types);
10953 /* Wrapper for free_dwo_file for use in cleanups. */
10956 free_dwo_file_cleanup (void *arg)
10958 struct dwo_file *dwo_file = (struct dwo_file *) arg;
10959 struct objfile *objfile = dwarf2_per_objfile->objfile;
10961 free_dwo_file (dwo_file, objfile);
10964 /* Traversal function for free_dwo_files. */
10967 free_dwo_file_from_slot (void **slot, void *info)
10969 struct dwo_file *dwo_file = (struct dwo_file *) *slot;
10970 struct objfile *objfile = (struct objfile *) info;
10972 free_dwo_file (dwo_file, objfile);
10977 /* Free all resources associated with DWO_FILES. */
10980 free_dwo_files (htab_t dwo_files, struct objfile *objfile)
10982 htab_traverse_noresize (dwo_files, free_dwo_file_from_slot, objfile);
10985 /* Read in various DIEs. */
10987 /* qsort helper for inherit_abstract_dies. */
10990 unsigned_int_compar (const void *ap, const void *bp)
10992 unsigned int a = *(unsigned int *) ap;
10993 unsigned int b = *(unsigned int *) bp;
10995 return (a > b) - (b > a);
10998 /* DW_AT_abstract_origin inherits whole DIEs (not just their attributes).
10999 Inherit only the children of the DW_AT_abstract_origin DIE not being
11000 already referenced by DW_AT_abstract_origin from the children of the
11004 inherit_abstract_dies (struct die_info *die, struct dwarf2_cu *cu)
11006 struct die_info *child_die;
11007 unsigned die_children_count;
11008 /* CU offsets which were referenced by children of the current DIE. */
11009 sect_offset *offsets;
11010 sect_offset *offsets_end, *offsetp;
11011 /* Parent of DIE - referenced by DW_AT_abstract_origin. */
11012 struct die_info *origin_die;
11013 /* Iterator of the ORIGIN_DIE children. */
11014 struct die_info *origin_child_die;
11015 struct cleanup *cleanups;
11016 struct attribute *attr;
11017 struct dwarf2_cu *origin_cu;
11018 struct pending **origin_previous_list_in_scope;
11020 attr = dwarf2_attr (die, DW_AT_abstract_origin, cu);
11024 /* Note that following die references may follow to a die in a
11028 origin_die = follow_die_ref (die, attr, &origin_cu);
11030 /* We're inheriting ORIGIN's children into the scope we'd put DIE's
11032 origin_previous_list_in_scope = origin_cu->list_in_scope;
11033 origin_cu->list_in_scope = cu->list_in_scope;
11035 if (die->tag != origin_die->tag
11036 && !(die->tag == DW_TAG_inlined_subroutine
11037 && origin_die->tag == DW_TAG_subprogram))
11038 complaint (&symfile_complaints,
11039 _("DIE 0x%x and its abstract origin 0x%x have different tags"),
11040 die->offset.sect_off, origin_die->offset.sect_off);
11042 child_die = die->child;
11043 die_children_count = 0;
11044 while (child_die && child_die->tag)
11046 child_die = sibling_die (child_die);
11047 die_children_count++;
11049 offsets = xmalloc (sizeof (*offsets) * die_children_count);
11050 cleanups = make_cleanup (xfree, offsets);
11052 offsets_end = offsets;
11053 child_die = die->child;
11054 while (child_die && child_die->tag)
11056 /* For each CHILD_DIE, find the corresponding child of
11057 ORIGIN_DIE. If there is more than one layer of
11058 DW_AT_abstract_origin, follow them all; there shouldn't be,
11059 but GCC versions at least through 4.4 generate this (GCC PR
11061 struct die_info *child_origin_die = child_die;
11062 struct dwarf2_cu *child_origin_cu = cu;
11066 attr = dwarf2_attr (child_origin_die, DW_AT_abstract_origin,
11070 child_origin_die = follow_die_ref (child_origin_die, attr,
11074 /* According to DWARF3 3.3.8.2 #3 new entries without their abstract
11075 counterpart may exist. */
11076 if (child_origin_die != child_die)
11078 if (child_die->tag != child_origin_die->tag
11079 && !(child_die->tag == DW_TAG_inlined_subroutine
11080 && child_origin_die->tag == DW_TAG_subprogram))
11081 complaint (&symfile_complaints,
11082 _("Child DIE 0x%x and its abstract origin 0x%x have "
11083 "different tags"), child_die->offset.sect_off,
11084 child_origin_die->offset.sect_off);
11085 if (child_origin_die->parent != origin_die)
11086 complaint (&symfile_complaints,
11087 _("Child DIE 0x%x and its abstract origin 0x%x have "
11088 "different parents"), child_die->offset.sect_off,
11089 child_origin_die->offset.sect_off);
11091 *offsets_end++ = child_origin_die->offset;
11093 child_die = sibling_die (child_die);
11095 qsort (offsets, offsets_end - offsets, sizeof (*offsets),
11096 unsigned_int_compar);
11097 for (offsetp = offsets + 1; offsetp < offsets_end; offsetp++)
11098 if (offsetp[-1].sect_off == offsetp->sect_off)
11099 complaint (&symfile_complaints,
11100 _("Multiple children of DIE 0x%x refer "
11101 "to DIE 0x%x as their abstract origin"),
11102 die->offset.sect_off, offsetp->sect_off);
11105 origin_child_die = origin_die->child;
11106 while (origin_child_die && origin_child_die->tag)
11108 /* Is ORIGIN_CHILD_DIE referenced by any of the DIE children? */
11109 while (offsetp < offsets_end
11110 && offsetp->sect_off < origin_child_die->offset.sect_off)
11112 if (offsetp >= offsets_end
11113 || offsetp->sect_off > origin_child_die->offset.sect_off)
11115 /* Found that ORIGIN_CHILD_DIE is really not referenced.
11116 Check whether we're already processing ORIGIN_CHILD_DIE.
11117 This can happen with mutually referenced abstract_origins.
11119 if (!origin_child_die->in_process)
11120 process_die (origin_child_die, origin_cu);
11122 origin_child_die = sibling_die (origin_child_die);
11124 origin_cu->list_in_scope = origin_previous_list_in_scope;
11126 do_cleanups (cleanups);
11130 read_func_scope (struct die_info *die, struct dwarf2_cu *cu)
11132 struct objfile *objfile = cu->objfile;
11133 struct context_stack *new;
11136 struct die_info *child_die;
11137 struct attribute *attr, *call_line, *call_file;
11139 CORE_ADDR baseaddr;
11140 struct block *block;
11141 int inlined_func = (die->tag == DW_TAG_inlined_subroutine);
11142 VEC (symbolp) *template_args = NULL;
11143 struct template_symbol *templ_func = NULL;
11147 /* If we do not have call site information, we can't show the
11148 caller of this inlined function. That's too confusing, so
11149 only use the scope for local variables. */
11150 call_line = dwarf2_attr (die, DW_AT_call_line, cu);
11151 call_file = dwarf2_attr (die, DW_AT_call_file, cu);
11152 if (call_line == NULL || call_file == NULL)
11154 read_lexical_block_scope (die, cu);
11159 baseaddr = ANOFFSET (objfile->section_offsets, SECT_OFF_TEXT (objfile));
11161 name = dwarf2_name (die, cu);
11163 /* Ignore functions with missing or empty names. These are actually
11164 illegal according to the DWARF standard. */
11167 complaint (&symfile_complaints,
11168 _("missing name for subprogram DIE at %d"),
11169 die->offset.sect_off);
11173 /* Ignore functions with missing or invalid low and high pc attributes. */
11174 if (!dwarf2_get_pc_bounds (die, &lowpc, &highpc, cu, NULL))
11176 attr = dwarf2_attr (die, DW_AT_external, cu);
11177 if (!attr || !DW_UNSND (attr))
11178 complaint (&symfile_complaints,
11179 _("cannot get low and high bounds "
11180 "for subprogram DIE at %d"),
11181 die->offset.sect_off);
11186 highpc += baseaddr;
11188 /* If we have any template arguments, then we must allocate a
11189 different sort of symbol. */
11190 for (child_die = die->child; child_die; child_die = sibling_die (child_die))
11192 if (child_die->tag == DW_TAG_template_type_param
11193 || child_die->tag == DW_TAG_template_value_param)
11195 templ_func = allocate_template_symbol (objfile);
11196 templ_func->base.is_cplus_template_function = 1;
11201 new = push_context (0, lowpc);
11202 new->name = new_symbol_full (die, read_type_die (die, cu), cu,
11203 (struct symbol *) templ_func);
11205 /* If there is a location expression for DW_AT_frame_base, record
11207 attr = dwarf2_attr (die, DW_AT_frame_base, cu);
11209 dwarf2_symbol_mark_computed (attr, new->name, cu, 1);
11211 cu->list_in_scope = &local_symbols;
11213 if (die->child != NULL)
11215 child_die = die->child;
11216 while (child_die && child_die->tag)
11218 if (child_die->tag == DW_TAG_template_type_param
11219 || child_die->tag == DW_TAG_template_value_param)
11221 struct symbol *arg = new_symbol (child_die, NULL, cu);
11224 VEC_safe_push (symbolp, template_args, arg);
11227 process_die (child_die, cu);
11228 child_die = sibling_die (child_die);
11232 inherit_abstract_dies (die, cu);
11234 /* If we have a DW_AT_specification, we might need to import using
11235 directives from the context of the specification DIE. See the
11236 comment in determine_prefix. */
11237 if (cu->language == language_cplus
11238 && dwarf2_attr (die, DW_AT_specification, cu))
11240 struct dwarf2_cu *spec_cu = cu;
11241 struct die_info *spec_die = die_specification (die, &spec_cu);
11245 child_die = spec_die->child;
11246 while (child_die && child_die->tag)
11248 if (child_die->tag == DW_TAG_imported_module)
11249 process_die (child_die, spec_cu);
11250 child_die = sibling_die (child_die);
11253 /* In some cases, GCC generates specification DIEs that
11254 themselves contain DW_AT_specification attributes. */
11255 spec_die = die_specification (spec_die, &spec_cu);
11259 new = pop_context ();
11260 /* Make a block for the local symbols within. */
11261 block = finish_block (new->name, &local_symbols, new->old_blocks,
11262 lowpc, highpc, objfile);
11264 /* For C++, set the block's scope. */
11265 if ((cu->language == language_cplus || cu->language == language_fortran)
11266 && cu->processing_has_namespace_info)
11267 block_set_scope (block, determine_prefix (die, cu),
11268 &objfile->objfile_obstack);
11270 /* If we have address ranges, record them. */
11271 dwarf2_record_block_ranges (die, block, baseaddr, cu);
11273 /* Attach template arguments to function. */
11274 if (! VEC_empty (symbolp, template_args))
11276 gdb_assert (templ_func != NULL);
11278 templ_func->n_template_arguments = VEC_length (symbolp, template_args);
11279 templ_func->template_arguments
11280 = obstack_alloc (&objfile->objfile_obstack,
11281 (templ_func->n_template_arguments
11282 * sizeof (struct symbol *)));
11283 memcpy (templ_func->template_arguments,
11284 VEC_address (symbolp, template_args),
11285 (templ_func->n_template_arguments * sizeof (struct symbol *)));
11286 VEC_free (symbolp, template_args);
11289 /* In C++, we can have functions nested inside functions (e.g., when
11290 a function declares a class that has methods). This means that
11291 when we finish processing a function scope, we may need to go
11292 back to building a containing block's symbol lists. */
11293 local_symbols = new->locals;
11294 using_directives = new->using_directives;
11296 /* If we've finished processing a top-level function, subsequent
11297 symbols go in the file symbol list. */
11298 if (outermost_context_p ())
11299 cu->list_in_scope = &file_symbols;
11302 /* Process all the DIES contained within a lexical block scope. Start
11303 a new scope, process the dies, and then close the scope. */
11306 read_lexical_block_scope (struct die_info *die, struct dwarf2_cu *cu)
11308 struct objfile *objfile = cu->objfile;
11309 struct context_stack *new;
11310 CORE_ADDR lowpc, highpc;
11311 struct die_info *child_die;
11312 CORE_ADDR baseaddr;
11314 baseaddr = ANOFFSET (objfile->section_offsets, SECT_OFF_TEXT (objfile));
11316 /* Ignore blocks with missing or invalid low and high pc attributes. */
11317 /* ??? Perhaps consider discontiguous blocks defined by DW_AT_ranges
11318 as multiple lexical blocks? Handling children in a sane way would
11319 be nasty. Might be easier to properly extend generic blocks to
11320 describe ranges. */
11321 if (!dwarf2_get_pc_bounds (die, &lowpc, &highpc, cu, NULL))
11324 highpc += baseaddr;
11326 push_context (0, lowpc);
11327 if (die->child != NULL)
11329 child_die = die->child;
11330 while (child_die && child_die->tag)
11332 process_die (child_die, cu);
11333 child_die = sibling_die (child_die);
11336 new = pop_context ();
11338 if (local_symbols != NULL || using_directives != NULL)
11340 struct block *block
11341 = finish_block (0, &local_symbols, new->old_blocks, new->start_addr,
11344 /* Note that recording ranges after traversing children, as we
11345 do here, means that recording a parent's ranges entails
11346 walking across all its children's ranges as they appear in
11347 the address map, which is quadratic behavior.
11349 It would be nicer to record the parent's ranges before
11350 traversing its children, simply overriding whatever you find
11351 there. But since we don't even decide whether to create a
11352 block until after we've traversed its children, that's hard
11354 dwarf2_record_block_ranges (die, block, baseaddr, cu);
11356 local_symbols = new->locals;
11357 using_directives = new->using_directives;
11360 /* Read in DW_TAG_GNU_call_site and insert it to CU->call_site_htab. */
11363 read_call_site_scope (struct die_info *die, struct dwarf2_cu *cu)
11365 struct objfile *objfile = cu->objfile;
11366 struct gdbarch *gdbarch = get_objfile_arch (objfile);
11367 CORE_ADDR pc, baseaddr;
11368 struct attribute *attr;
11369 struct call_site *call_site, call_site_local;
11372 struct die_info *child_die;
11374 baseaddr = ANOFFSET (objfile->section_offsets, SECT_OFF_TEXT (objfile));
11376 attr = dwarf2_attr (die, DW_AT_low_pc, cu);
11379 complaint (&symfile_complaints,
11380 _("missing DW_AT_low_pc for DW_TAG_GNU_call_site "
11381 "DIE 0x%x [in module %s]"),
11382 die->offset.sect_off, objfile_name (objfile));
11385 pc = attr_value_as_address (attr) + baseaddr;
11387 if (cu->call_site_htab == NULL)
11388 cu->call_site_htab = htab_create_alloc_ex (16, core_addr_hash, core_addr_eq,
11389 NULL, &objfile->objfile_obstack,
11390 hashtab_obstack_allocate, NULL);
11391 call_site_local.pc = pc;
11392 slot = htab_find_slot (cu->call_site_htab, &call_site_local, INSERT);
11395 complaint (&symfile_complaints,
11396 _("Duplicate PC %s for DW_TAG_GNU_call_site "
11397 "DIE 0x%x [in module %s]"),
11398 paddress (gdbarch, pc), die->offset.sect_off,
11399 objfile_name (objfile));
11403 /* Count parameters at the caller. */
11406 for (child_die = die->child; child_die && child_die->tag;
11407 child_die = sibling_die (child_die))
11409 if (child_die->tag != DW_TAG_GNU_call_site_parameter)
11411 complaint (&symfile_complaints,
11412 _("Tag %d is not DW_TAG_GNU_call_site_parameter in "
11413 "DW_TAG_GNU_call_site child DIE 0x%x [in module %s]"),
11414 child_die->tag, child_die->offset.sect_off,
11415 objfile_name (objfile));
11422 call_site = obstack_alloc (&objfile->objfile_obstack,
11423 (sizeof (*call_site)
11424 + (sizeof (*call_site->parameter)
11425 * (nparams - 1))));
11427 memset (call_site, 0, sizeof (*call_site) - sizeof (*call_site->parameter));
11428 call_site->pc = pc;
11430 if (dwarf2_flag_true_p (die, DW_AT_GNU_tail_call, cu))
11432 struct die_info *func_die;
11434 /* Skip also over DW_TAG_inlined_subroutine. */
11435 for (func_die = die->parent;
11436 func_die && func_die->tag != DW_TAG_subprogram
11437 && func_die->tag != DW_TAG_subroutine_type;
11438 func_die = func_die->parent);
11440 /* DW_AT_GNU_all_call_sites is a superset
11441 of DW_AT_GNU_all_tail_call_sites. */
11443 && !dwarf2_flag_true_p (func_die, DW_AT_GNU_all_call_sites, cu)
11444 && !dwarf2_flag_true_p (func_die, DW_AT_GNU_all_tail_call_sites, cu))
11446 /* TYPE_TAIL_CALL_LIST is not interesting in functions where it is
11447 not complete. But keep CALL_SITE for look ups via call_site_htab,
11448 both the initial caller containing the real return address PC and
11449 the final callee containing the current PC of a chain of tail
11450 calls do not need to have the tail call list complete. But any
11451 function candidate for a virtual tail call frame searched via
11452 TYPE_TAIL_CALL_LIST must have the tail call list complete to be
11453 determined unambiguously. */
11457 struct type *func_type = NULL;
11460 func_type = get_die_type (func_die, cu);
11461 if (func_type != NULL)
11463 gdb_assert (TYPE_CODE (func_type) == TYPE_CODE_FUNC);
11465 /* Enlist this call site to the function. */
11466 call_site->tail_call_next = TYPE_TAIL_CALL_LIST (func_type);
11467 TYPE_TAIL_CALL_LIST (func_type) = call_site;
11470 complaint (&symfile_complaints,
11471 _("Cannot find function owning DW_TAG_GNU_call_site "
11472 "DIE 0x%x [in module %s]"),
11473 die->offset.sect_off, objfile_name (objfile));
11477 attr = dwarf2_attr (die, DW_AT_GNU_call_site_target, cu);
11479 attr = dwarf2_attr (die, DW_AT_abstract_origin, cu);
11480 SET_FIELD_DWARF_BLOCK (call_site->target, NULL);
11481 if (!attr || (attr_form_is_block (attr) && DW_BLOCK (attr)->size == 0))
11482 /* Keep NULL DWARF_BLOCK. */;
11483 else if (attr_form_is_block (attr))
11485 struct dwarf2_locexpr_baton *dlbaton;
11487 dlbaton = obstack_alloc (&objfile->objfile_obstack, sizeof (*dlbaton));
11488 dlbaton->data = DW_BLOCK (attr)->data;
11489 dlbaton->size = DW_BLOCK (attr)->size;
11490 dlbaton->per_cu = cu->per_cu;
11492 SET_FIELD_DWARF_BLOCK (call_site->target, dlbaton);
11494 else if (attr_form_is_ref (attr))
11496 struct dwarf2_cu *target_cu = cu;
11497 struct die_info *target_die;
11499 target_die = follow_die_ref (die, attr, &target_cu);
11500 gdb_assert (target_cu->objfile == objfile);
11501 if (die_is_declaration (target_die, target_cu))
11503 const char *target_physname = NULL;
11504 struct attribute *target_attr;
11506 /* Prefer the mangled name; otherwise compute the demangled one. */
11507 target_attr = dwarf2_attr (target_die, DW_AT_linkage_name, target_cu);
11508 if (target_attr == NULL)
11509 target_attr = dwarf2_attr (target_die, DW_AT_MIPS_linkage_name,
11511 if (target_attr != NULL && DW_STRING (target_attr) != NULL)
11512 target_physname = DW_STRING (target_attr);
11514 target_physname = dwarf2_physname (NULL, target_die, target_cu);
11515 if (target_physname == NULL)
11516 complaint (&symfile_complaints,
11517 _("DW_AT_GNU_call_site_target target DIE has invalid "
11518 "physname, for referencing DIE 0x%x [in module %s]"),
11519 die->offset.sect_off, objfile_name (objfile));
11521 SET_FIELD_PHYSNAME (call_site->target, target_physname);
11527 /* DW_AT_entry_pc should be preferred. */
11528 if (!dwarf2_get_pc_bounds (target_die, &lowpc, NULL, target_cu, NULL))
11529 complaint (&symfile_complaints,
11530 _("DW_AT_GNU_call_site_target target DIE has invalid "
11531 "low pc, for referencing DIE 0x%x [in module %s]"),
11532 die->offset.sect_off, objfile_name (objfile));
11534 SET_FIELD_PHYSADDR (call_site->target, lowpc + baseaddr);
11538 complaint (&symfile_complaints,
11539 _("DW_TAG_GNU_call_site DW_AT_GNU_call_site_target is neither "
11540 "block nor reference, for DIE 0x%x [in module %s]"),
11541 die->offset.sect_off, objfile_name (objfile));
11543 call_site->per_cu = cu->per_cu;
11545 for (child_die = die->child;
11546 child_die && child_die->tag;
11547 child_die = sibling_die (child_die))
11549 struct call_site_parameter *parameter;
11550 struct attribute *loc, *origin;
11552 if (child_die->tag != DW_TAG_GNU_call_site_parameter)
11554 /* Already printed the complaint above. */
11558 gdb_assert (call_site->parameter_count < nparams);
11559 parameter = &call_site->parameter[call_site->parameter_count];
11561 /* DW_AT_location specifies the register number or DW_AT_abstract_origin
11562 specifies DW_TAG_formal_parameter. Value of the data assumed for the
11563 register is contained in DW_AT_GNU_call_site_value. */
11565 loc = dwarf2_attr (child_die, DW_AT_location, cu);
11566 origin = dwarf2_attr (child_die, DW_AT_abstract_origin, cu);
11567 if (loc == NULL && origin != NULL && attr_form_is_ref (origin))
11569 sect_offset offset;
11571 parameter->kind = CALL_SITE_PARAMETER_PARAM_OFFSET;
11572 offset = dwarf2_get_ref_die_offset (origin);
11573 if (!offset_in_cu_p (&cu->header, offset))
11575 /* As DW_OP_GNU_parameter_ref uses CU-relative offset this
11576 binding can be done only inside one CU. Such referenced DIE
11577 therefore cannot be even moved to DW_TAG_partial_unit. */
11578 complaint (&symfile_complaints,
11579 _("DW_AT_abstract_origin offset is not in CU for "
11580 "DW_TAG_GNU_call_site child DIE 0x%x "
11582 child_die->offset.sect_off, objfile_name (objfile));
11585 parameter->u.param_offset.cu_off = (offset.sect_off
11586 - cu->header.offset.sect_off);
11588 else if (loc == NULL || origin != NULL || !attr_form_is_block (loc))
11590 complaint (&symfile_complaints,
11591 _("No DW_FORM_block* DW_AT_location for "
11592 "DW_TAG_GNU_call_site child DIE 0x%x [in module %s]"),
11593 child_die->offset.sect_off, objfile_name (objfile));
11598 parameter->u.dwarf_reg = dwarf_block_to_dwarf_reg
11599 (DW_BLOCK (loc)->data, &DW_BLOCK (loc)->data[DW_BLOCK (loc)->size]);
11600 if (parameter->u.dwarf_reg != -1)
11601 parameter->kind = CALL_SITE_PARAMETER_DWARF_REG;
11602 else if (dwarf_block_to_sp_offset (gdbarch, DW_BLOCK (loc)->data,
11603 &DW_BLOCK (loc)->data[DW_BLOCK (loc)->size],
11604 ¶meter->u.fb_offset))
11605 parameter->kind = CALL_SITE_PARAMETER_FB_OFFSET;
11608 complaint (&symfile_complaints,
11609 _("Only single DW_OP_reg or DW_OP_fbreg is supported "
11610 "for DW_FORM_block* DW_AT_location is supported for "
11611 "DW_TAG_GNU_call_site child DIE 0x%x "
11613 child_die->offset.sect_off, objfile_name (objfile));
11618 attr = dwarf2_attr (child_die, DW_AT_GNU_call_site_value, cu);
11619 if (!attr_form_is_block (attr))
11621 complaint (&symfile_complaints,
11622 _("No DW_FORM_block* DW_AT_GNU_call_site_value for "
11623 "DW_TAG_GNU_call_site child DIE 0x%x [in module %s]"),
11624 child_die->offset.sect_off, objfile_name (objfile));
11627 parameter->value = DW_BLOCK (attr)->data;
11628 parameter->value_size = DW_BLOCK (attr)->size;
11630 /* Parameters are not pre-cleared by memset above. */
11631 parameter->data_value = NULL;
11632 parameter->data_value_size = 0;
11633 call_site->parameter_count++;
11635 attr = dwarf2_attr (child_die, DW_AT_GNU_call_site_data_value, cu);
11638 if (!attr_form_is_block (attr))
11639 complaint (&symfile_complaints,
11640 _("No DW_FORM_block* DW_AT_GNU_call_site_data_value for "
11641 "DW_TAG_GNU_call_site child DIE 0x%x [in module %s]"),
11642 child_die->offset.sect_off, objfile_name (objfile));
11645 parameter->data_value = DW_BLOCK (attr)->data;
11646 parameter->data_value_size = DW_BLOCK (attr)->size;
11652 /* Get low and high pc attributes from DW_AT_ranges attribute value OFFSET.
11653 Return 1 if the attributes are present and valid, otherwise, return 0.
11654 If RANGES_PST is not NULL we should setup `objfile->psymtabs_addrmap'. */
11657 dwarf2_ranges_read (unsigned offset, CORE_ADDR *low_return,
11658 CORE_ADDR *high_return, struct dwarf2_cu *cu,
11659 struct partial_symtab *ranges_pst)
11661 struct objfile *objfile = cu->objfile;
11662 struct comp_unit_head *cu_header = &cu->header;
11663 bfd *obfd = objfile->obfd;
11664 unsigned int addr_size = cu_header->addr_size;
11665 CORE_ADDR mask = ~(~(CORE_ADDR)1 << (addr_size * 8 - 1));
11666 /* Base address selection entry. */
11669 unsigned int dummy;
11670 const gdb_byte *buffer;
11674 CORE_ADDR high = 0;
11675 CORE_ADDR baseaddr;
11677 found_base = cu->base_known;
11678 base = cu->base_address;
11680 dwarf2_read_section (objfile, &dwarf2_per_objfile->ranges);
11681 if (offset >= dwarf2_per_objfile->ranges.size)
11683 complaint (&symfile_complaints,
11684 _("Offset %d out of bounds for DW_AT_ranges attribute"),
11688 buffer = dwarf2_per_objfile->ranges.buffer + offset;
11690 /* Read in the largest possible address. */
11691 marker = read_address (obfd, buffer, cu, &dummy);
11692 if ((marker & mask) == mask)
11694 /* If we found the largest possible address, then
11695 read the base address. */
11696 base = read_address (obfd, buffer + addr_size, cu, &dummy);
11697 buffer += 2 * addr_size;
11698 offset += 2 * addr_size;
11704 baseaddr = ANOFFSET (objfile->section_offsets, SECT_OFF_TEXT (objfile));
11708 CORE_ADDR range_beginning, range_end;
11710 range_beginning = read_address (obfd, buffer, cu, &dummy);
11711 buffer += addr_size;
11712 range_end = read_address (obfd, buffer, cu, &dummy);
11713 buffer += addr_size;
11714 offset += 2 * addr_size;
11716 /* An end of list marker is a pair of zero addresses. */
11717 if (range_beginning == 0 && range_end == 0)
11718 /* Found the end of list entry. */
11721 /* Each base address selection entry is a pair of 2 values.
11722 The first is the largest possible address, the second is
11723 the base address. Check for a base address here. */
11724 if ((range_beginning & mask) == mask)
11726 /* If we found the largest possible address, then
11727 read the base address. */
11728 base = read_address (obfd, buffer + addr_size, cu, &dummy);
11735 /* We have no valid base address for the ranges
11737 complaint (&symfile_complaints,
11738 _("Invalid .debug_ranges data (no base address)"));
11742 if (range_beginning > range_end)
11744 /* Inverted range entries are invalid. */
11745 complaint (&symfile_complaints,
11746 _("Invalid .debug_ranges data (inverted range)"));
11750 /* Empty range entries have no effect. */
11751 if (range_beginning == range_end)
11754 range_beginning += base;
11757 /* A not-uncommon case of bad debug info.
11758 Don't pollute the addrmap with bad data. */
11759 if (range_beginning + baseaddr == 0
11760 && !dwarf2_per_objfile->has_section_at_zero)
11762 complaint (&symfile_complaints,
11763 _(".debug_ranges entry has start address of zero"
11764 " [in module %s]"), objfile_name (objfile));
11768 if (ranges_pst != NULL)
11769 addrmap_set_empty (objfile->psymtabs_addrmap,
11770 range_beginning + baseaddr,
11771 range_end - 1 + baseaddr,
11774 /* FIXME: This is recording everything as a low-high
11775 segment of consecutive addresses. We should have a
11776 data structure for discontiguous block ranges
11780 low = range_beginning;
11786 if (range_beginning < low)
11787 low = range_beginning;
11788 if (range_end > high)
11794 /* If the first entry is an end-of-list marker, the range
11795 describes an empty scope, i.e. no instructions. */
11801 *high_return = high;
11805 /* Get low and high pc attributes from a die. Return 1 if the attributes
11806 are present and valid, otherwise, return 0. Return -1 if the range is
11807 discontinuous, i.e. derived from DW_AT_ranges information. */
11810 dwarf2_get_pc_bounds (struct die_info *die, CORE_ADDR *lowpc,
11811 CORE_ADDR *highpc, struct dwarf2_cu *cu,
11812 struct partial_symtab *pst)
11814 struct attribute *attr;
11815 struct attribute *attr_high;
11817 CORE_ADDR high = 0;
11820 attr_high = dwarf2_attr (die, DW_AT_high_pc, cu);
11823 attr = dwarf2_attr (die, DW_AT_low_pc, cu);
11826 low = attr_value_as_address (attr);
11827 high = attr_value_as_address (attr_high);
11828 if (cu->header.version >= 4 && attr_form_is_constant (attr_high))
11832 /* Found high w/o low attribute. */
11835 /* Found consecutive range of addresses. */
11840 attr = dwarf2_attr (die, DW_AT_ranges, cu);
11843 /* DW_AT_ranges_base does not apply to DIEs from the DWO skeleton.
11844 We take advantage of the fact that DW_AT_ranges does not appear
11845 in DW_TAG_compile_unit of DWO files. */
11846 int need_ranges_base = die->tag != DW_TAG_compile_unit;
11847 unsigned int ranges_offset = (DW_UNSND (attr)
11848 + (need_ranges_base
11852 /* Value of the DW_AT_ranges attribute is the offset in the
11853 .debug_ranges section. */
11854 if (!dwarf2_ranges_read (ranges_offset, &low, &high, cu, pst))
11856 /* Found discontinuous range of addresses. */
11861 /* read_partial_die has also the strict LOW < HIGH requirement. */
11865 /* When using the GNU linker, .gnu.linkonce. sections are used to
11866 eliminate duplicate copies of functions and vtables and such.
11867 The linker will arbitrarily choose one and discard the others.
11868 The AT_*_pc values for such functions refer to local labels in
11869 these sections. If the section from that file was discarded, the
11870 labels are not in the output, so the relocs get a value of 0.
11871 If this is a discarded function, mark the pc bounds as invalid,
11872 so that GDB will ignore it. */
11873 if (low == 0 && !dwarf2_per_objfile->has_section_at_zero)
11882 /* Assuming that DIE represents a subprogram DIE or a lexical block, get
11883 its low and high PC addresses. Do nothing if these addresses could not
11884 be determined. Otherwise, set LOWPC to the low address if it is smaller,
11885 and HIGHPC to the high address if greater than HIGHPC. */
11888 dwarf2_get_subprogram_pc_bounds (struct die_info *die,
11889 CORE_ADDR *lowpc, CORE_ADDR *highpc,
11890 struct dwarf2_cu *cu)
11892 CORE_ADDR low, high;
11893 struct die_info *child = die->child;
11895 if (dwarf2_get_pc_bounds (die, &low, &high, cu, NULL))
11897 *lowpc = min (*lowpc, low);
11898 *highpc = max (*highpc, high);
11901 /* If the language does not allow nested subprograms (either inside
11902 subprograms or lexical blocks), we're done. */
11903 if (cu->language != language_ada)
11906 /* Check all the children of the given DIE. If it contains nested
11907 subprograms, then check their pc bounds. Likewise, we need to
11908 check lexical blocks as well, as they may also contain subprogram
11910 while (child && child->tag)
11912 if (child->tag == DW_TAG_subprogram
11913 || child->tag == DW_TAG_lexical_block)
11914 dwarf2_get_subprogram_pc_bounds (child, lowpc, highpc, cu);
11915 child = sibling_die (child);
11919 /* Get the low and high pc's represented by the scope DIE, and store
11920 them in *LOWPC and *HIGHPC. If the correct values can't be
11921 determined, set *LOWPC to -1 and *HIGHPC to 0. */
11924 get_scope_pc_bounds (struct die_info *die,
11925 CORE_ADDR *lowpc, CORE_ADDR *highpc,
11926 struct dwarf2_cu *cu)
11928 CORE_ADDR best_low = (CORE_ADDR) -1;
11929 CORE_ADDR best_high = (CORE_ADDR) 0;
11930 CORE_ADDR current_low, current_high;
11932 if (dwarf2_get_pc_bounds (die, ¤t_low, ¤t_high, cu, NULL))
11934 best_low = current_low;
11935 best_high = current_high;
11939 struct die_info *child = die->child;
11941 while (child && child->tag)
11943 switch (child->tag) {
11944 case DW_TAG_subprogram:
11945 dwarf2_get_subprogram_pc_bounds (child, &best_low, &best_high, cu);
11947 case DW_TAG_namespace:
11948 case DW_TAG_module:
11949 /* FIXME: carlton/2004-01-16: Should we do this for
11950 DW_TAG_class_type/DW_TAG_structure_type, too? I think
11951 that current GCC's always emit the DIEs corresponding
11952 to definitions of methods of classes as children of a
11953 DW_TAG_compile_unit or DW_TAG_namespace (as opposed to
11954 the DIEs giving the declarations, which could be
11955 anywhere). But I don't see any reason why the
11956 standards says that they have to be there. */
11957 get_scope_pc_bounds (child, ¤t_low, ¤t_high, cu);
11959 if (current_low != ((CORE_ADDR) -1))
11961 best_low = min (best_low, current_low);
11962 best_high = max (best_high, current_high);
11970 child = sibling_die (child);
11975 *highpc = best_high;
11978 /* Record the address ranges for BLOCK, offset by BASEADDR, as given
11982 dwarf2_record_block_ranges (struct die_info *die, struct block *block,
11983 CORE_ADDR baseaddr, struct dwarf2_cu *cu)
11985 struct objfile *objfile = cu->objfile;
11986 struct attribute *attr;
11987 struct attribute *attr_high;
11989 attr_high = dwarf2_attr (die, DW_AT_high_pc, cu);
11992 attr = dwarf2_attr (die, DW_AT_low_pc, cu);
11995 CORE_ADDR low = attr_value_as_address (attr);
11996 CORE_ADDR high = attr_value_as_address (attr_high);
11998 if (cu->header.version >= 4 && attr_form_is_constant (attr_high))
12001 record_block_range (block, baseaddr + low, baseaddr + high - 1);
12005 attr = dwarf2_attr (die, DW_AT_ranges, cu);
12008 bfd *obfd = objfile->obfd;
12009 /* DW_AT_ranges_base does not apply to DIEs from the DWO skeleton.
12010 We take advantage of the fact that DW_AT_ranges does not appear
12011 in DW_TAG_compile_unit of DWO files. */
12012 int need_ranges_base = die->tag != DW_TAG_compile_unit;
12014 /* The value of the DW_AT_ranges attribute is the offset of the
12015 address range list in the .debug_ranges section. */
12016 unsigned long offset = (DW_UNSND (attr)
12017 + (need_ranges_base ? cu->ranges_base : 0));
12018 const gdb_byte *buffer;
12020 /* For some target architectures, but not others, the
12021 read_address function sign-extends the addresses it returns.
12022 To recognize base address selection entries, we need a
12024 unsigned int addr_size = cu->header.addr_size;
12025 CORE_ADDR base_select_mask = ~(~(CORE_ADDR)1 << (addr_size * 8 - 1));
12027 /* The base address, to which the next pair is relative. Note
12028 that this 'base' is a DWARF concept: most entries in a range
12029 list are relative, to reduce the number of relocs against the
12030 debugging information. This is separate from this function's
12031 'baseaddr' argument, which GDB uses to relocate debugging
12032 information from a shared library based on the address at
12033 which the library was loaded. */
12034 CORE_ADDR base = cu->base_address;
12035 int base_known = cu->base_known;
12037 dwarf2_read_section (objfile, &dwarf2_per_objfile->ranges);
12038 if (offset >= dwarf2_per_objfile->ranges.size)
12040 complaint (&symfile_complaints,
12041 _("Offset %lu out of bounds for DW_AT_ranges attribute"),
12045 buffer = dwarf2_per_objfile->ranges.buffer + offset;
12049 unsigned int bytes_read;
12050 CORE_ADDR start, end;
12052 start = read_address (obfd, buffer, cu, &bytes_read);
12053 buffer += bytes_read;
12054 end = read_address (obfd, buffer, cu, &bytes_read);
12055 buffer += bytes_read;
12057 /* Did we find the end of the range list? */
12058 if (start == 0 && end == 0)
12061 /* Did we find a base address selection entry? */
12062 else if ((start & base_select_mask) == base_select_mask)
12068 /* We found an ordinary address range. */
12073 complaint (&symfile_complaints,
12074 _("Invalid .debug_ranges data "
12075 "(no base address)"));
12081 /* Inverted range entries are invalid. */
12082 complaint (&symfile_complaints,
12083 _("Invalid .debug_ranges data "
12084 "(inverted range)"));
12088 /* Empty range entries have no effect. */
12092 start += base + baseaddr;
12093 end += base + baseaddr;
12095 /* A not-uncommon case of bad debug info.
12096 Don't pollute the addrmap with bad data. */
12097 if (start == 0 && !dwarf2_per_objfile->has_section_at_zero)
12099 complaint (&symfile_complaints,
12100 _(".debug_ranges entry has start address of zero"
12101 " [in module %s]"), objfile_name (objfile));
12105 record_block_range (block, start, end - 1);
12111 /* Check whether the producer field indicates either of GCC < 4.6, or the
12112 Intel C/C++ compiler, and cache the result in CU. */
12115 check_producer (struct dwarf2_cu *cu)
12118 int major, minor, release;
12120 if (cu->producer == NULL)
12122 /* For unknown compilers expect their behavior is DWARF version
12125 GCC started to support .debug_types sections by -gdwarf-4 since
12126 gcc-4.5.x. As the .debug_types sections are missing DW_AT_producer
12127 for their space efficiency GDB cannot workaround gcc-4.5.x -gdwarf-4
12128 combination. gcc-4.5.x -gdwarf-4 binaries have DW_AT_accessibility
12129 interpreted incorrectly by GDB now - GCC PR debug/48229. */
12131 else if (strncmp (cu->producer, "GNU ", strlen ("GNU ")) == 0)
12133 /* Skip any identifier after "GNU " - such as "C++" or "Java". */
12135 cs = &cu->producer[strlen ("GNU ")];
12136 while (*cs && !isdigit (*cs))
12138 if (sscanf (cs, "%d.%d.%d", &major, &minor, &release) != 3)
12140 /* Not recognized as GCC. */
12144 cu->producer_is_gxx_lt_4_6 = major < 4 || (major == 4 && minor < 6);
12145 cu->producer_is_gcc_lt_4_3 = major < 4 || (major == 4 && minor < 3);
12148 else if (strncmp (cu->producer, "Intel(R) C", strlen ("Intel(R) C")) == 0)
12149 cu->producer_is_icc = 1;
12152 /* For other non-GCC compilers, expect their behavior is DWARF version
12156 cu->checked_producer = 1;
12159 /* Check for GCC PR debug/45124 fix which is not present in any G++ version up
12160 to 4.5.any while it is present already in G++ 4.6.0 - the PR has been fixed
12161 during 4.6.0 experimental. */
12164 producer_is_gxx_lt_4_6 (struct dwarf2_cu *cu)
12166 if (!cu->checked_producer)
12167 check_producer (cu);
12169 return cu->producer_is_gxx_lt_4_6;
12172 /* Return the default accessibility type if it is not overriden by
12173 DW_AT_accessibility. */
12175 static enum dwarf_access_attribute
12176 dwarf2_default_access_attribute (struct die_info *die, struct dwarf2_cu *cu)
12178 if (cu->header.version < 3 || producer_is_gxx_lt_4_6 (cu))
12180 /* The default DWARF 2 accessibility for members is public, the default
12181 accessibility for inheritance is private. */
12183 if (die->tag != DW_TAG_inheritance)
12184 return DW_ACCESS_public;
12186 return DW_ACCESS_private;
12190 /* DWARF 3+ defines the default accessibility a different way. The same
12191 rules apply now for DW_TAG_inheritance as for the members and it only
12192 depends on the container kind. */
12194 if (die->parent->tag == DW_TAG_class_type)
12195 return DW_ACCESS_private;
12197 return DW_ACCESS_public;
12201 /* Look for DW_AT_data_member_location. Set *OFFSET to the byte
12202 offset. If the attribute was not found return 0, otherwise return
12203 1. If it was found but could not properly be handled, set *OFFSET
12207 handle_data_member_location (struct die_info *die, struct dwarf2_cu *cu,
12210 struct attribute *attr;
12212 attr = dwarf2_attr (die, DW_AT_data_member_location, cu);
12217 /* Note that we do not check for a section offset first here.
12218 This is because DW_AT_data_member_location is new in DWARF 4,
12219 so if we see it, we can assume that a constant form is really
12220 a constant and not a section offset. */
12221 if (attr_form_is_constant (attr))
12222 *offset = dwarf2_get_attr_constant_value (attr, 0);
12223 else if (attr_form_is_section_offset (attr))
12224 dwarf2_complex_location_expr_complaint ();
12225 else if (attr_form_is_block (attr))
12226 *offset = decode_locdesc (DW_BLOCK (attr), cu);
12228 dwarf2_complex_location_expr_complaint ();
12236 /* Add an aggregate field to the field list. */
12239 dwarf2_add_field (struct field_info *fip, struct die_info *die,
12240 struct dwarf2_cu *cu)
12242 struct objfile *objfile = cu->objfile;
12243 struct gdbarch *gdbarch = get_objfile_arch (objfile);
12244 struct nextfield *new_field;
12245 struct attribute *attr;
12247 const char *fieldname = "";
12249 /* Allocate a new field list entry and link it in. */
12250 new_field = (struct nextfield *) xmalloc (sizeof (struct nextfield));
12251 make_cleanup (xfree, new_field);
12252 memset (new_field, 0, sizeof (struct nextfield));
12254 if (die->tag == DW_TAG_inheritance)
12256 new_field->next = fip->baseclasses;
12257 fip->baseclasses = new_field;
12261 new_field->next = fip->fields;
12262 fip->fields = new_field;
12266 attr = dwarf2_attr (die, DW_AT_accessibility, cu);
12268 new_field->accessibility = DW_UNSND (attr);
12270 new_field->accessibility = dwarf2_default_access_attribute (die, cu);
12271 if (new_field->accessibility != DW_ACCESS_public)
12272 fip->non_public_fields = 1;
12274 attr = dwarf2_attr (die, DW_AT_virtuality, cu);
12276 new_field->virtuality = DW_UNSND (attr);
12278 new_field->virtuality = DW_VIRTUALITY_none;
12280 fp = &new_field->field;
12282 if (die->tag == DW_TAG_member && ! die_is_declaration (die, cu))
12286 /* Data member other than a C++ static data member. */
12288 /* Get type of field. */
12289 fp->type = die_type (die, cu);
12291 SET_FIELD_BITPOS (*fp, 0);
12293 /* Get bit size of field (zero if none). */
12294 attr = dwarf2_attr (die, DW_AT_bit_size, cu);
12297 FIELD_BITSIZE (*fp) = DW_UNSND (attr);
12301 FIELD_BITSIZE (*fp) = 0;
12304 /* Get bit offset of field. */
12305 if (handle_data_member_location (die, cu, &offset))
12306 SET_FIELD_BITPOS (*fp, offset * bits_per_byte);
12307 attr = dwarf2_attr (die, DW_AT_bit_offset, cu);
12310 if (gdbarch_bits_big_endian (gdbarch))
12312 /* For big endian bits, the DW_AT_bit_offset gives the
12313 additional bit offset from the MSB of the containing
12314 anonymous object to the MSB of the field. We don't
12315 have to do anything special since we don't need to
12316 know the size of the anonymous object. */
12317 SET_FIELD_BITPOS (*fp, FIELD_BITPOS (*fp) + DW_UNSND (attr));
12321 /* For little endian bits, compute the bit offset to the
12322 MSB of the anonymous object, subtract off the number of
12323 bits from the MSB of the field to the MSB of the
12324 object, and then subtract off the number of bits of
12325 the field itself. The result is the bit offset of
12326 the LSB of the field. */
12327 int anonymous_size;
12328 int bit_offset = DW_UNSND (attr);
12330 attr = dwarf2_attr (die, DW_AT_byte_size, cu);
12333 /* The size of the anonymous object containing
12334 the bit field is explicit, so use the
12335 indicated size (in bytes). */
12336 anonymous_size = DW_UNSND (attr);
12340 /* The size of the anonymous object containing
12341 the bit field must be inferred from the type
12342 attribute of the data member containing the
12344 anonymous_size = TYPE_LENGTH (fp->type);
12346 SET_FIELD_BITPOS (*fp,
12347 (FIELD_BITPOS (*fp)
12348 + anonymous_size * bits_per_byte
12349 - bit_offset - FIELD_BITSIZE (*fp)));
12353 /* Get name of field. */
12354 fieldname = dwarf2_name (die, cu);
12355 if (fieldname == NULL)
12358 /* The name is already allocated along with this objfile, so we don't
12359 need to duplicate it for the type. */
12360 fp->name = fieldname;
12362 /* Change accessibility for artificial fields (e.g. virtual table
12363 pointer or virtual base class pointer) to private. */
12364 if (dwarf2_attr (die, DW_AT_artificial, cu))
12366 FIELD_ARTIFICIAL (*fp) = 1;
12367 new_field->accessibility = DW_ACCESS_private;
12368 fip->non_public_fields = 1;
12371 else if (die->tag == DW_TAG_member || die->tag == DW_TAG_variable)
12373 /* C++ static member. */
12375 /* NOTE: carlton/2002-11-05: It should be a DW_TAG_member that
12376 is a declaration, but all versions of G++ as of this writing
12377 (so through at least 3.2.1) incorrectly generate
12378 DW_TAG_variable tags. */
12380 const char *physname;
12382 /* Get name of field. */
12383 fieldname = dwarf2_name (die, cu);
12384 if (fieldname == NULL)
12387 attr = dwarf2_attr (die, DW_AT_const_value, cu);
12389 /* Only create a symbol if this is an external value.
12390 new_symbol checks this and puts the value in the global symbol
12391 table, which we want. If it is not external, new_symbol
12392 will try to put the value in cu->list_in_scope which is wrong. */
12393 && dwarf2_flag_true_p (die, DW_AT_external, cu))
12395 /* A static const member, not much different than an enum as far as
12396 we're concerned, except that we can support more types. */
12397 new_symbol (die, NULL, cu);
12400 /* Get physical name. */
12401 physname = dwarf2_physname (fieldname, die, cu);
12403 /* The name is already allocated along with this objfile, so we don't
12404 need to duplicate it for the type. */
12405 SET_FIELD_PHYSNAME (*fp, physname ? physname : "");
12406 FIELD_TYPE (*fp) = die_type (die, cu);
12407 FIELD_NAME (*fp) = fieldname;
12409 else if (die->tag == DW_TAG_inheritance)
12413 /* C++ base class field. */
12414 if (handle_data_member_location (die, cu, &offset))
12415 SET_FIELD_BITPOS (*fp, offset * bits_per_byte);
12416 FIELD_BITSIZE (*fp) = 0;
12417 FIELD_TYPE (*fp) = die_type (die, cu);
12418 FIELD_NAME (*fp) = type_name_no_tag (fp->type);
12419 fip->nbaseclasses++;
12423 /* Add a typedef defined in the scope of the FIP's class. */
12426 dwarf2_add_typedef (struct field_info *fip, struct die_info *die,
12427 struct dwarf2_cu *cu)
12429 struct objfile *objfile = cu->objfile;
12430 struct typedef_field_list *new_field;
12431 struct attribute *attr;
12432 struct typedef_field *fp;
12433 char *fieldname = "";
12435 /* Allocate a new field list entry and link it in. */
12436 new_field = xzalloc (sizeof (*new_field));
12437 make_cleanup (xfree, new_field);
12439 gdb_assert (die->tag == DW_TAG_typedef);
12441 fp = &new_field->field;
12443 /* Get name of field. */
12444 fp->name = dwarf2_name (die, cu);
12445 if (fp->name == NULL)
12448 fp->type = read_type_die (die, cu);
12450 new_field->next = fip->typedef_field_list;
12451 fip->typedef_field_list = new_field;
12452 fip->typedef_field_list_count++;
12455 /* Create the vector of fields, and attach it to the type. */
12458 dwarf2_attach_fields_to_type (struct field_info *fip, struct type *type,
12459 struct dwarf2_cu *cu)
12461 int nfields = fip->nfields;
12463 /* Record the field count, allocate space for the array of fields,
12464 and create blank accessibility bitfields if necessary. */
12465 TYPE_NFIELDS (type) = nfields;
12466 TYPE_FIELDS (type) = (struct field *)
12467 TYPE_ALLOC (type, sizeof (struct field) * nfields);
12468 memset (TYPE_FIELDS (type), 0, sizeof (struct field) * nfields);
12470 if (fip->non_public_fields && cu->language != language_ada)
12472 ALLOCATE_CPLUS_STRUCT_TYPE (type);
12474 TYPE_FIELD_PRIVATE_BITS (type) =
12475 (B_TYPE *) TYPE_ALLOC (type, B_BYTES (nfields));
12476 B_CLRALL (TYPE_FIELD_PRIVATE_BITS (type), nfields);
12478 TYPE_FIELD_PROTECTED_BITS (type) =
12479 (B_TYPE *) TYPE_ALLOC (type, B_BYTES (nfields));
12480 B_CLRALL (TYPE_FIELD_PROTECTED_BITS (type), nfields);
12482 TYPE_FIELD_IGNORE_BITS (type) =
12483 (B_TYPE *) TYPE_ALLOC (type, B_BYTES (nfields));
12484 B_CLRALL (TYPE_FIELD_IGNORE_BITS (type), nfields);
12487 /* If the type has baseclasses, allocate and clear a bit vector for
12488 TYPE_FIELD_VIRTUAL_BITS. */
12489 if (fip->nbaseclasses && cu->language != language_ada)
12491 int num_bytes = B_BYTES (fip->nbaseclasses);
12492 unsigned char *pointer;
12494 ALLOCATE_CPLUS_STRUCT_TYPE (type);
12495 pointer = TYPE_ALLOC (type, num_bytes);
12496 TYPE_FIELD_VIRTUAL_BITS (type) = pointer;
12497 B_CLRALL (TYPE_FIELD_VIRTUAL_BITS (type), fip->nbaseclasses);
12498 TYPE_N_BASECLASSES (type) = fip->nbaseclasses;
12501 /* Copy the saved-up fields into the field vector. Start from the head of
12502 the list, adding to the tail of the field array, so that they end up in
12503 the same order in the array in which they were added to the list. */
12504 while (nfields-- > 0)
12506 struct nextfield *fieldp;
12510 fieldp = fip->fields;
12511 fip->fields = fieldp->next;
12515 fieldp = fip->baseclasses;
12516 fip->baseclasses = fieldp->next;
12519 TYPE_FIELD (type, nfields) = fieldp->field;
12520 switch (fieldp->accessibility)
12522 case DW_ACCESS_private:
12523 if (cu->language != language_ada)
12524 SET_TYPE_FIELD_PRIVATE (type, nfields);
12527 case DW_ACCESS_protected:
12528 if (cu->language != language_ada)
12529 SET_TYPE_FIELD_PROTECTED (type, nfields);
12532 case DW_ACCESS_public:
12536 /* Unknown accessibility. Complain and treat it as public. */
12538 complaint (&symfile_complaints, _("unsupported accessibility %d"),
12539 fieldp->accessibility);
12543 if (nfields < fip->nbaseclasses)
12545 switch (fieldp->virtuality)
12547 case DW_VIRTUALITY_virtual:
12548 case DW_VIRTUALITY_pure_virtual:
12549 if (cu->language == language_ada)
12550 error (_("unexpected virtuality in component of Ada type"));
12551 SET_TYPE_FIELD_VIRTUAL (type, nfields);
12558 /* Return true if this member function is a constructor, false
12562 dwarf2_is_constructor (struct die_info *die, struct dwarf2_cu *cu)
12564 const char *fieldname;
12565 const char *typename;
12568 if (die->parent == NULL)
12571 if (die->parent->tag != DW_TAG_structure_type
12572 && die->parent->tag != DW_TAG_union_type
12573 && die->parent->tag != DW_TAG_class_type)
12576 fieldname = dwarf2_name (die, cu);
12577 typename = dwarf2_name (die->parent, cu);
12578 if (fieldname == NULL || typename == NULL)
12581 len = strlen (fieldname);
12582 return (strncmp (fieldname, typename, len) == 0
12583 && (typename[len] == '\0' || typename[len] == '<'));
12586 /* Add a member function to the proper fieldlist. */
12589 dwarf2_add_member_fn (struct field_info *fip, struct die_info *die,
12590 struct type *type, struct dwarf2_cu *cu)
12592 struct objfile *objfile = cu->objfile;
12593 struct attribute *attr;
12594 struct fnfieldlist *flp;
12596 struct fn_field *fnp;
12597 const char *fieldname;
12598 struct nextfnfield *new_fnfield;
12599 struct type *this_type;
12600 enum dwarf_access_attribute accessibility;
12602 if (cu->language == language_ada)
12603 error (_("unexpected member function in Ada type"));
12605 /* Get name of member function. */
12606 fieldname = dwarf2_name (die, cu);
12607 if (fieldname == NULL)
12610 /* Look up member function name in fieldlist. */
12611 for (i = 0; i < fip->nfnfields; i++)
12613 if (strcmp (fip->fnfieldlists[i].name, fieldname) == 0)
12617 /* Create new list element if necessary. */
12618 if (i < fip->nfnfields)
12619 flp = &fip->fnfieldlists[i];
12622 if ((fip->nfnfields % DW_FIELD_ALLOC_CHUNK) == 0)
12624 fip->fnfieldlists = (struct fnfieldlist *)
12625 xrealloc (fip->fnfieldlists,
12626 (fip->nfnfields + DW_FIELD_ALLOC_CHUNK)
12627 * sizeof (struct fnfieldlist));
12628 if (fip->nfnfields == 0)
12629 make_cleanup (free_current_contents, &fip->fnfieldlists);
12631 flp = &fip->fnfieldlists[fip->nfnfields];
12632 flp->name = fieldname;
12635 i = fip->nfnfields++;
12638 /* Create a new member function field and chain it to the field list
12640 new_fnfield = (struct nextfnfield *) xmalloc (sizeof (struct nextfnfield));
12641 make_cleanup (xfree, new_fnfield);
12642 memset (new_fnfield, 0, sizeof (struct nextfnfield));
12643 new_fnfield->next = flp->head;
12644 flp->head = new_fnfield;
12647 /* Fill in the member function field info. */
12648 fnp = &new_fnfield->fnfield;
12650 /* Delay processing of the physname until later. */
12651 if (cu->language == language_cplus || cu->language == language_java)
12653 add_to_method_list (type, i, flp->length - 1, fieldname,
12658 const char *physname = dwarf2_physname (fieldname, die, cu);
12659 fnp->physname = physname ? physname : "";
12662 fnp->type = alloc_type (objfile);
12663 this_type = read_type_die (die, cu);
12664 if (this_type && TYPE_CODE (this_type) == TYPE_CODE_FUNC)
12666 int nparams = TYPE_NFIELDS (this_type);
12668 /* TYPE is the domain of this method, and THIS_TYPE is the type
12669 of the method itself (TYPE_CODE_METHOD). */
12670 smash_to_method_type (fnp->type, type,
12671 TYPE_TARGET_TYPE (this_type),
12672 TYPE_FIELDS (this_type),
12673 TYPE_NFIELDS (this_type),
12674 TYPE_VARARGS (this_type));
12676 /* Handle static member functions.
12677 Dwarf2 has no clean way to discern C++ static and non-static
12678 member functions. G++ helps GDB by marking the first
12679 parameter for non-static member functions (which is the this
12680 pointer) as artificial. We obtain this information from
12681 read_subroutine_type via TYPE_FIELD_ARTIFICIAL. */
12682 if (nparams == 0 || TYPE_FIELD_ARTIFICIAL (this_type, 0) == 0)
12683 fnp->voffset = VOFFSET_STATIC;
12686 complaint (&symfile_complaints, _("member function type missing for '%s'"),
12687 dwarf2_full_name (fieldname, die, cu));
12689 /* Get fcontext from DW_AT_containing_type if present. */
12690 if (dwarf2_attr (die, DW_AT_containing_type, cu) != NULL)
12691 fnp->fcontext = die_containing_type (die, cu);
12693 /* dwarf2 doesn't have stubbed physical names, so the setting of is_const and
12694 is_volatile is irrelevant, as it is needed by gdb_mangle_name only. */
12696 /* Get accessibility. */
12697 attr = dwarf2_attr (die, DW_AT_accessibility, cu);
12699 accessibility = DW_UNSND (attr);
12701 accessibility = dwarf2_default_access_attribute (die, cu);
12702 switch (accessibility)
12704 case DW_ACCESS_private:
12705 fnp->is_private = 1;
12707 case DW_ACCESS_protected:
12708 fnp->is_protected = 1;
12712 /* Check for artificial methods. */
12713 attr = dwarf2_attr (die, DW_AT_artificial, cu);
12714 if (attr && DW_UNSND (attr) != 0)
12715 fnp->is_artificial = 1;
12717 fnp->is_constructor = dwarf2_is_constructor (die, cu);
12719 /* Get index in virtual function table if it is a virtual member
12720 function. For older versions of GCC, this is an offset in the
12721 appropriate virtual table, as specified by DW_AT_containing_type.
12722 For everyone else, it is an expression to be evaluated relative
12723 to the object address. */
12725 attr = dwarf2_attr (die, DW_AT_vtable_elem_location, cu);
12728 if (attr_form_is_block (attr) && DW_BLOCK (attr)->size > 0)
12730 if (DW_BLOCK (attr)->data[0] == DW_OP_constu)
12732 /* Old-style GCC. */
12733 fnp->voffset = decode_locdesc (DW_BLOCK (attr), cu) + 2;
12735 else if (DW_BLOCK (attr)->data[0] == DW_OP_deref
12736 || (DW_BLOCK (attr)->size > 1
12737 && DW_BLOCK (attr)->data[0] == DW_OP_deref_size
12738 && DW_BLOCK (attr)->data[1] == cu->header.addr_size))
12740 struct dwarf_block blk;
12743 offset = (DW_BLOCK (attr)->data[0] == DW_OP_deref
12745 blk.size = DW_BLOCK (attr)->size - offset;
12746 blk.data = DW_BLOCK (attr)->data + offset;
12747 fnp->voffset = decode_locdesc (DW_BLOCK (attr), cu);
12748 if ((fnp->voffset % cu->header.addr_size) != 0)
12749 dwarf2_complex_location_expr_complaint ();
12751 fnp->voffset /= cu->header.addr_size;
12755 dwarf2_complex_location_expr_complaint ();
12757 if (!fnp->fcontext)
12758 fnp->fcontext = TYPE_TARGET_TYPE (TYPE_FIELD_TYPE (this_type, 0));
12760 else if (attr_form_is_section_offset (attr))
12762 dwarf2_complex_location_expr_complaint ();
12766 dwarf2_invalid_attrib_class_complaint ("DW_AT_vtable_elem_location",
12772 attr = dwarf2_attr (die, DW_AT_virtuality, cu);
12773 if (attr && DW_UNSND (attr))
12775 /* GCC does this, as of 2008-08-25; PR debug/37237. */
12776 complaint (&symfile_complaints,
12777 _("Member function \"%s\" (offset %d) is virtual "
12778 "but the vtable offset is not specified"),
12779 fieldname, die->offset.sect_off);
12780 ALLOCATE_CPLUS_STRUCT_TYPE (type);
12781 TYPE_CPLUS_DYNAMIC (type) = 1;
12786 /* Create the vector of member function fields, and attach it to the type. */
12789 dwarf2_attach_fn_fields_to_type (struct field_info *fip, struct type *type,
12790 struct dwarf2_cu *cu)
12792 struct fnfieldlist *flp;
12795 if (cu->language == language_ada)
12796 error (_("unexpected member functions in Ada type"));
12798 ALLOCATE_CPLUS_STRUCT_TYPE (type);
12799 TYPE_FN_FIELDLISTS (type) = (struct fn_fieldlist *)
12800 TYPE_ALLOC (type, sizeof (struct fn_fieldlist) * fip->nfnfields);
12802 for (i = 0, flp = fip->fnfieldlists; i < fip->nfnfields; i++, flp++)
12804 struct nextfnfield *nfp = flp->head;
12805 struct fn_fieldlist *fn_flp = &TYPE_FN_FIELDLIST (type, i);
12808 TYPE_FN_FIELDLIST_NAME (type, i) = flp->name;
12809 TYPE_FN_FIELDLIST_LENGTH (type, i) = flp->length;
12810 fn_flp->fn_fields = (struct fn_field *)
12811 TYPE_ALLOC (type, sizeof (struct fn_field) * flp->length);
12812 for (k = flp->length; (k--, nfp); nfp = nfp->next)
12813 fn_flp->fn_fields[k] = nfp->fnfield;
12816 TYPE_NFN_FIELDS (type) = fip->nfnfields;
12819 /* Returns non-zero if NAME is the name of a vtable member in CU's
12820 language, zero otherwise. */
12822 is_vtable_name (const char *name, struct dwarf2_cu *cu)
12824 static const char vptr[] = "_vptr";
12825 static const char vtable[] = "vtable";
12827 /* Look for the C++ and Java forms of the vtable. */
12828 if ((cu->language == language_java
12829 && strncmp (name, vtable, sizeof (vtable) - 1) == 0)
12830 || (strncmp (name, vptr, sizeof (vptr) - 1) == 0
12831 && is_cplus_marker (name[sizeof (vptr) - 1])))
12837 /* GCC outputs unnamed structures that are really pointers to member
12838 functions, with the ABI-specified layout. If TYPE describes
12839 such a structure, smash it into a member function type.
12841 GCC shouldn't do this; it should just output pointer to member DIEs.
12842 This is GCC PR debug/28767. */
12845 quirk_gcc_member_function_pointer (struct type *type, struct objfile *objfile)
12847 struct type *pfn_type, *domain_type, *new_type;
12849 /* Check for a structure with no name and two children. */
12850 if (TYPE_CODE (type) != TYPE_CODE_STRUCT || TYPE_NFIELDS (type) != 2)
12853 /* Check for __pfn and __delta members. */
12854 if (TYPE_FIELD_NAME (type, 0) == NULL
12855 || strcmp (TYPE_FIELD_NAME (type, 0), "__pfn") != 0
12856 || TYPE_FIELD_NAME (type, 1) == NULL
12857 || strcmp (TYPE_FIELD_NAME (type, 1), "__delta") != 0)
12860 /* Find the type of the method. */
12861 pfn_type = TYPE_FIELD_TYPE (type, 0);
12862 if (pfn_type == NULL
12863 || TYPE_CODE (pfn_type) != TYPE_CODE_PTR
12864 || TYPE_CODE (TYPE_TARGET_TYPE (pfn_type)) != TYPE_CODE_FUNC)
12867 /* Look for the "this" argument. */
12868 pfn_type = TYPE_TARGET_TYPE (pfn_type);
12869 if (TYPE_NFIELDS (pfn_type) == 0
12870 /* || TYPE_FIELD_TYPE (pfn_type, 0) == NULL */
12871 || TYPE_CODE (TYPE_FIELD_TYPE (pfn_type, 0)) != TYPE_CODE_PTR)
12874 domain_type = TYPE_TARGET_TYPE (TYPE_FIELD_TYPE (pfn_type, 0));
12875 new_type = alloc_type (objfile);
12876 smash_to_method_type (new_type, domain_type, TYPE_TARGET_TYPE (pfn_type),
12877 TYPE_FIELDS (pfn_type), TYPE_NFIELDS (pfn_type),
12878 TYPE_VARARGS (pfn_type));
12879 smash_to_methodptr_type (type, new_type);
12882 /* Return non-zero if the CU's PRODUCER string matches the Intel C/C++ compiler
12886 producer_is_icc (struct dwarf2_cu *cu)
12888 if (!cu->checked_producer)
12889 check_producer (cu);
12891 return cu->producer_is_icc;
12894 /* Called when we find the DIE that starts a structure or union scope
12895 (definition) to create a type for the structure or union. Fill in
12896 the type's name and general properties; the members will not be
12897 processed until process_structure_scope. A symbol table entry for
12898 the type will also not be done until process_structure_scope (assuming
12899 the type has a name).
12901 NOTE: we need to call these functions regardless of whether or not the
12902 DIE has a DW_AT_name attribute, since it might be an anonymous
12903 structure or union. This gets the type entered into our set of
12904 user defined types. */
12906 static struct type *
12907 read_structure_type (struct die_info *die, struct dwarf2_cu *cu)
12909 struct objfile *objfile = cu->objfile;
12911 struct attribute *attr;
12914 /* If the definition of this type lives in .debug_types, read that type.
12915 Don't follow DW_AT_specification though, that will take us back up
12916 the chain and we want to go down. */
12917 attr = dwarf2_attr_no_follow (die, DW_AT_signature);
12920 type = get_DW_AT_signature_type (die, attr, cu);
12922 /* The type's CU may not be the same as CU.
12923 Ensure TYPE is recorded with CU in die_type_hash. */
12924 return set_die_type (die, type, cu);
12927 type = alloc_type (objfile);
12928 INIT_CPLUS_SPECIFIC (type);
12930 name = dwarf2_name (die, cu);
12933 if (cu->language == language_cplus
12934 || cu->language == language_java)
12936 const char *full_name = dwarf2_full_name (name, die, cu);
12938 /* dwarf2_full_name might have already finished building the DIE's
12939 type. If so, there is no need to continue. */
12940 if (get_die_type (die, cu) != NULL)
12941 return get_die_type (die, cu);
12943 TYPE_TAG_NAME (type) = full_name;
12944 if (die->tag == DW_TAG_structure_type
12945 || die->tag == DW_TAG_class_type)
12946 TYPE_NAME (type) = TYPE_TAG_NAME (type);
12950 /* The name is already allocated along with this objfile, so
12951 we don't need to duplicate it for the type. */
12952 TYPE_TAG_NAME (type) = name;
12953 if (die->tag == DW_TAG_class_type)
12954 TYPE_NAME (type) = TYPE_TAG_NAME (type);
12958 if (die->tag == DW_TAG_structure_type)
12960 TYPE_CODE (type) = TYPE_CODE_STRUCT;
12962 else if (die->tag == DW_TAG_union_type)
12964 TYPE_CODE (type) = TYPE_CODE_UNION;
12968 TYPE_CODE (type) = TYPE_CODE_CLASS;
12971 if (cu->language == language_cplus && die->tag == DW_TAG_class_type)
12972 TYPE_DECLARED_CLASS (type) = 1;
12974 attr = dwarf2_attr (die, DW_AT_byte_size, cu);
12977 TYPE_LENGTH (type) = DW_UNSND (attr);
12981 TYPE_LENGTH (type) = 0;
12984 if (producer_is_icc (cu) && (TYPE_LENGTH (type) == 0))
12986 /* ICC does not output the required DW_AT_declaration
12987 on incomplete types, but gives them a size of zero. */
12988 TYPE_STUB (type) = 1;
12991 TYPE_STUB_SUPPORTED (type) = 1;
12993 if (die_is_declaration (die, cu))
12994 TYPE_STUB (type) = 1;
12995 else if (attr == NULL && die->child == NULL
12996 && producer_is_realview (cu->producer))
12997 /* RealView does not output the required DW_AT_declaration
12998 on incomplete types. */
12999 TYPE_STUB (type) = 1;
13001 /* We need to add the type field to the die immediately so we don't
13002 infinitely recurse when dealing with pointers to the structure
13003 type within the structure itself. */
13004 set_die_type (die, type, cu);
13006 /* set_die_type should be already done. */
13007 set_descriptive_type (type, die, cu);
13012 /* Finish creating a structure or union type, including filling in
13013 its members and creating a symbol for it. */
13016 process_structure_scope (struct die_info *die, struct dwarf2_cu *cu)
13018 struct objfile *objfile = cu->objfile;
13019 struct die_info *child_die = die->child;
13022 type = get_die_type (die, cu);
13024 type = read_structure_type (die, cu);
13026 if (die->child != NULL && ! die_is_declaration (die, cu))
13028 struct field_info fi;
13029 struct die_info *child_die;
13030 VEC (symbolp) *template_args = NULL;
13031 struct cleanup *back_to = make_cleanup (null_cleanup, 0);
13033 memset (&fi, 0, sizeof (struct field_info));
13035 child_die = die->child;
13037 while (child_die && child_die->tag)
13039 if (child_die->tag == DW_TAG_member
13040 || child_die->tag == DW_TAG_variable)
13042 /* NOTE: carlton/2002-11-05: A C++ static data member
13043 should be a DW_TAG_member that is a declaration, but
13044 all versions of G++ as of this writing (so through at
13045 least 3.2.1) incorrectly generate DW_TAG_variable
13046 tags for them instead. */
13047 dwarf2_add_field (&fi, child_die, cu);
13049 else if (child_die->tag == DW_TAG_subprogram)
13051 /* C++ member function. */
13052 dwarf2_add_member_fn (&fi, child_die, type, cu);
13054 else if (child_die->tag == DW_TAG_inheritance)
13056 /* C++ base class field. */
13057 dwarf2_add_field (&fi, child_die, cu);
13059 else if (child_die->tag == DW_TAG_typedef)
13060 dwarf2_add_typedef (&fi, child_die, cu);
13061 else if (child_die->tag == DW_TAG_template_type_param
13062 || child_die->tag == DW_TAG_template_value_param)
13064 struct symbol *arg = new_symbol (child_die, NULL, cu);
13067 VEC_safe_push (symbolp, template_args, arg);
13070 child_die = sibling_die (child_die);
13073 /* Attach template arguments to type. */
13074 if (! VEC_empty (symbolp, template_args))
13076 ALLOCATE_CPLUS_STRUCT_TYPE (type);
13077 TYPE_N_TEMPLATE_ARGUMENTS (type)
13078 = VEC_length (symbolp, template_args);
13079 TYPE_TEMPLATE_ARGUMENTS (type)
13080 = obstack_alloc (&objfile->objfile_obstack,
13081 (TYPE_N_TEMPLATE_ARGUMENTS (type)
13082 * sizeof (struct symbol *)));
13083 memcpy (TYPE_TEMPLATE_ARGUMENTS (type),
13084 VEC_address (symbolp, template_args),
13085 (TYPE_N_TEMPLATE_ARGUMENTS (type)
13086 * sizeof (struct symbol *)));
13087 VEC_free (symbolp, template_args);
13090 /* Attach fields and member functions to the type. */
13092 dwarf2_attach_fields_to_type (&fi, type, cu);
13095 dwarf2_attach_fn_fields_to_type (&fi, type, cu);
13097 /* Get the type which refers to the base class (possibly this
13098 class itself) which contains the vtable pointer for the current
13099 class from the DW_AT_containing_type attribute. This use of
13100 DW_AT_containing_type is a GNU extension. */
13102 if (dwarf2_attr (die, DW_AT_containing_type, cu) != NULL)
13104 struct type *t = die_containing_type (die, cu);
13106 TYPE_VPTR_BASETYPE (type) = t;
13111 /* Our own class provides vtbl ptr. */
13112 for (i = TYPE_NFIELDS (t) - 1;
13113 i >= TYPE_N_BASECLASSES (t);
13116 const char *fieldname = TYPE_FIELD_NAME (t, i);
13118 if (is_vtable_name (fieldname, cu))
13120 TYPE_VPTR_FIELDNO (type) = i;
13125 /* Complain if virtual function table field not found. */
13126 if (i < TYPE_N_BASECLASSES (t))
13127 complaint (&symfile_complaints,
13128 _("virtual function table pointer "
13129 "not found when defining class '%s'"),
13130 TYPE_TAG_NAME (type) ? TYPE_TAG_NAME (type) :
13135 TYPE_VPTR_FIELDNO (type) = TYPE_VPTR_FIELDNO (t);
13138 else if (cu->producer
13139 && strncmp (cu->producer,
13140 "IBM(R) XL C/C++ Advanced Edition", 32) == 0)
13142 /* The IBM XLC compiler does not provide direct indication
13143 of the containing type, but the vtable pointer is
13144 always named __vfp. */
13148 for (i = TYPE_NFIELDS (type) - 1;
13149 i >= TYPE_N_BASECLASSES (type);
13152 if (strcmp (TYPE_FIELD_NAME (type, i), "__vfp") == 0)
13154 TYPE_VPTR_FIELDNO (type) = i;
13155 TYPE_VPTR_BASETYPE (type) = type;
13162 /* Copy fi.typedef_field_list linked list elements content into the
13163 allocated array TYPE_TYPEDEF_FIELD_ARRAY (type). */
13164 if (fi.typedef_field_list)
13166 int i = fi.typedef_field_list_count;
13168 ALLOCATE_CPLUS_STRUCT_TYPE (type);
13169 TYPE_TYPEDEF_FIELD_ARRAY (type)
13170 = TYPE_ALLOC (type, sizeof (TYPE_TYPEDEF_FIELD (type, 0)) * i);
13171 TYPE_TYPEDEF_FIELD_COUNT (type) = i;
13173 /* Reverse the list order to keep the debug info elements order. */
13176 struct typedef_field *dest, *src;
13178 dest = &TYPE_TYPEDEF_FIELD (type, i);
13179 src = &fi.typedef_field_list->field;
13180 fi.typedef_field_list = fi.typedef_field_list->next;
13185 do_cleanups (back_to);
13187 if (HAVE_CPLUS_STRUCT (type))
13188 TYPE_CPLUS_REALLY_JAVA (type) = cu->language == language_java;
13191 quirk_gcc_member_function_pointer (type, objfile);
13193 /* NOTE: carlton/2004-03-16: GCC 3.4 (or at least one of its
13194 snapshots) has been known to create a die giving a declaration
13195 for a class that has, as a child, a die giving a definition for a
13196 nested class. So we have to process our children even if the
13197 current die is a declaration. Normally, of course, a declaration
13198 won't have any children at all. */
13200 while (child_die != NULL && child_die->tag)
13202 if (child_die->tag == DW_TAG_member
13203 || child_die->tag == DW_TAG_variable
13204 || child_die->tag == DW_TAG_inheritance
13205 || child_die->tag == DW_TAG_template_value_param
13206 || child_die->tag == DW_TAG_template_type_param)
13211 process_die (child_die, cu);
13213 child_die = sibling_die (child_die);
13216 /* Do not consider external references. According to the DWARF standard,
13217 these DIEs are identified by the fact that they have no byte_size
13218 attribute, and a declaration attribute. */
13219 if (dwarf2_attr (die, DW_AT_byte_size, cu) != NULL
13220 || !die_is_declaration (die, cu))
13221 new_symbol (die, type, cu);
13224 /* Assuming DIE is an enumeration type, and TYPE is its associated type,
13225 update TYPE using some information only available in DIE's children. */
13228 update_enumeration_type_from_children (struct die_info *die,
13230 struct dwarf2_cu *cu)
13232 struct obstack obstack;
13233 struct die_info *child_die = die->child;
13234 int unsigned_enum = 1;
13237 struct cleanup *old_chain;
13239 obstack_init (&obstack);
13240 old_chain = make_cleanup_obstack_free (&obstack);
13242 while (child_die != NULL && child_die->tag)
13244 struct attribute *attr;
13246 const gdb_byte *bytes;
13247 struct dwarf2_locexpr_baton *baton;
13249 if (child_die->tag != DW_TAG_enumerator)
13252 attr = dwarf2_attr (child_die, DW_AT_const_value, cu);
13256 name = dwarf2_name (child_die, cu);
13258 name = "<anonymous enumerator>";
13260 dwarf2_const_value_attr (attr, type, name, &obstack, cu,
13261 &value, &bytes, &baton);
13267 else if ((mask & value) != 0)
13272 /* If we already know that the enum type is neither unsigned, nor
13273 a flag type, no need to look at the rest of the enumerates. */
13274 if (!unsigned_enum && !flag_enum)
13276 child_die = sibling_die (child_die);
13280 TYPE_UNSIGNED (type) = 1;
13282 TYPE_FLAG_ENUM (type) = 1;
13284 do_cleanups (old_chain);
13287 /* Given a DW_AT_enumeration_type die, set its type. We do not
13288 complete the type's fields yet, or create any symbols. */
13290 static struct type *
13291 read_enumeration_type (struct die_info *die, struct dwarf2_cu *cu)
13293 struct objfile *objfile = cu->objfile;
13295 struct attribute *attr;
13298 /* If the definition of this type lives in .debug_types, read that type.
13299 Don't follow DW_AT_specification though, that will take us back up
13300 the chain and we want to go down. */
13301 attr = dwarf2_attr_no_follow (die, DW_AT_signature);
13304 type = get_DW_AT_signature_type (die, attr, cu);
13306 /* The type's CU may not be the same as CU.
13307 Ensure TYPE is recorded with CU in die_type_hash. */
13308 return set_die_type (die, type, cu);
13311 type = alloc_type (objfile);
13313 TYPE_CODE (type) = TYPE_CODE_ENUM;
13314 name = dwarf2_full_name (NULL, die, cu);
13316 TYPE_TAG_NAME (type) = name;
13318 attr = dwarf2_attr (die, DW_AT_type, cu);
13321 struct type *underlying_type = die_type (die, cu);
13323 TYPE_TARGET_TYPE (type) = underlying_type;
13326 attr = dwarf2_attr (die, DW_AT_byte_size, cu);
13329 TYPE_LENGTH (type) = DW_UNSND (attr);
13333 TYPE_LENGTH (type) = 0;
13336 /* The enumeration DIE can be incomplete. In Ada, any type can be
13337 declared as private in the package spec, and then defined only
13338 inside the package body. Such types are known as Taft Amendment
13339 Types. When another package uses such a type, an incomplete DIE
13340 may be generated by the compiler. */
13341 if (die_is_declaration (die, cu))
13342 TYPE_STUB (type) = 1;
13344 /* Finish the creation of this type by using the enum's children.
13345 We must call this even when the underlying type has been provided
13346 so that we can determine if we're looking at a "flag" enum. */
13347 update_enumeration_type_from_children (die, type, cu);
13349 /* If this type has an underlying type that is not a stub, then we
13350 may use its attributes. We always use the "unsigned" attribute
13351 in this situation, because ordinarily we guess whether the type
13352 is unsigned -- but the guess can be wrong and the underlying type
13353 can tell us the reality. However, we defer to a local size
13354 attribute if one exists, because this lets the compiler override
13355 the underlying type if needed. */
13356 if (TYPE_TARGET_TYPE (type) != NULL && !TYPE_STUB (TYPE_TARGET_TYPE (type)))
13358 TYPE_UNSIGNED (type) = TYPE_UNSIGNED (TYPE_TARGET_TYPE (type));
13359 if (TYPE_LENGTH (type) == 0)
13360 TYPE_LENGTH (type) = TYPE_LENGTH (TYPE_TARGET_TYPE (type));
13363 TYPE_DECLARED_CLASS (type) = dwarf2_flag_true_p (die, DW_AT_enum_class, cu);
13365 return set_die_type (die, type, cu);
13368 /* Given a pointer to a die which begins an enumeration, process all
13369 the dies that define the members of the enumeration, and create the
13370 symbol for the enumeration type.
13372 NOTE: We reverse the order of the element list. */
13375 process_enumeration_scope (struct die_info *die, struct dwarf2_cu *cu)
13377 struct type *this_type;
13379 this_type = get_die_type (die, cu);
13380 if (this_type == NULL)
13381 this_type = read_enumeration_type (die, cu);
13383 if (die->child != NULL)
13385 struct die_info *child_die;
13386 struct symbol *sym;
13387 struct field *fields = NULL;
13388 int num_fields = 0;
13391 child_die = die->child;
13392 while (child_die && child_die->tag)
13394 if (child_die->tag != DW_TAG_enumerator)
13396 process_die (child_die, cu);
13400 name = dwarf2_name (child_die, cu);
13403 sym = new_symbol (child_die, this_type, cu);
13405 if ((num_fields % DW_FIELD_ALLOC_CHUNK) == 0)
13407 fields = (struct field *)
13409 (num_fields + DW_FIELD_ALLOC_CHUNK)
13410 * sizeof (struct field));
13413 FIELD_NAME (fields[num_fields]) = SYMBOL_LINKAGE_NAME (sym);
13414 FIELD_TYPE (fields[num_fields]) = NULL;
13415 SET_FIELD_ENUMVAL (fields[num_fields], SYMBOL_VALUE (sym));
13416 FIELD_BITSIZE (fields[num_fields]) = 0;
13422 child_die = sibling_die (child_die);
13427 TYPE_NFIELDS (this_type) = num_fields;
13428 TYPE_FIELDS (this_type) = (struct field *)
13429 TYPE_ALLOC (this_type, sizeof (struct field) * num_fields);
13430 memcpy (TYPE_FIELDS (this_type), fields,
13431 sizeof (struct field) * num_fields);
13436 /* If we are reading an enum from a .debug_types unit, and the enum
13437 is a declaration, and the enum is not the signatured type in the
13438 unit, then we do not want to add a symbol for it. Adding a
13439 symbol would in some cases obscure the true definition of the
13440 enum, giving users an incomplete type when the definition is
13441 actually available. Note that we do not want to do this for all
13442 enums which are just declarations, because C++0x allows forward
13443 enum declarations. */
13444 if (cu->per_cu->is_debug_types
13445 && die_is_declaration (die, cu))
13447 struct signatured_type *sig_type;
13449 sig_type = (struct signatured_type *) cu->per_cu;
13450 gdb_assert (sig_type->type_offset_in_section.sect_off != 0);
13451 if (sig_type->type_offset_in_section.sect_off != die->offset.sect_off)
13455 new_symbol (die, this_type, cu);
13458 /* Extract all information from a DW_TAG_array_type DIE and put it in
13459 the DIE's type field. For now, this only handles one dimensional
13462 static struct type *
13463 read_array_type (struct die_info *die, struct dwarf2_cu *cu)
13465 struct objfile *objfile = cu->objfile;
13466 struct die_info *child_die;
13468 struct type *element_type, *range_type, *index_type;
13469 struct type **range_types = NULL;
13470 struct attribute *attr;
13472 struct cleanup *back_to;
13474 unsigned int bit_stride = 0;
13476 element_type = die_type (die, cu);
13478 /* The die_type call above may have already set the type for this DIE. */
13479 type = get_die_type (die, cu);
13483 attr = dwarf2_attr (die, DW_AT_byte_stride, cu);
13485 bit_stride = DW_UNSND (attr) * 8;
13487 attr = dwarf2_attr (die, DW_AT_bit_stride, cu);
13489 bit_stride = DW_UNSND (attr);
13491 /* Irix 6.2 native cc creates array types without children for
13492 arrays with unspecified length. */
13493 if (die->child == NULL)
13495 index_type = objfile_type (objfile)->builtin_int;
13496 range_type = create_static_range_type (NULL, index_type, 0, -1);
13497 type = create_array_type_with_stride (NULL, element_type, range_type,
13499 return set_die_type (die, type, cu);
13502 back_to = make_cleanup (null_cleanup, NULL);
13503 child_die = die->child;
13504 while (child_die && child_die->tag)
13506 if (child_die->tag == DW_TAG_subrange_type)
13508 struct type *child_type = read_type_die (child_die, cu);
13510 if (child_type != NULL)
13512 /* The range type was succesfully read. Save it for the
13513 array type creation. */
13514 if ((ndim % DW_FIELD_ALLOC_CHUNK) == 0)
13516 range_types = (struct type **)
13517 xrealloc (range_types, (ndim + DW_FIELD_ALLOC_CHUNK)
13518 * sizeof (struct type *));
13520 make_cleanup (free_current_contents, &range_types);
13522 range_types[ndim++] = child_type;
13525 child_die = sibling_die (child_die);
13528 /* Dwarf2 dimensions are output from left to right, create the
13529 necessary array types in backwards order. */
13531 type = element_type;
13533 if (read_array_order (die, cu) == DW_ORD_col_major)
13538 type = create_array_type_with_stride (NULL, type, range_types[i++],
13544 type = create_array_type_with_stride (NULL, type, range_types[ndim],
13548 /* Understand Dwarf2 support for vector types (like they occur on
13549 the PowerPC w/ AltiVec). Gcc just adds another attribute to the
13550 array type. This is not part of the Dwarf2/3 standard yet, but a
13551 custom vendor extension. The main difference between a regular
13552 array and the vector variant is that vectors are passed by value
13554 attr = dwarf2_attr (die, DW_AT_GNU_vector, cu);
13556 make_vector_type (type);
13558 /* The DIE may have DW_AT_byte_size set. For example an OpenCL
13559 implementation may choose to implement triple vectors using this
13561 attr = dwarf2_attr (die, DW_AT_byte_size, cu);
13564 if (DW_UNSND (attr) >= TYPE_LENGTH (type))
13565 TYPE_LENGTH (type) = DW_UNSND (attr);
13567 complaint (&symfile_complaints,
13568 _("DW_AT_byte_size for array type smaller "
13569 "than the total size of elements"));
13572 name = dwarf2_name (die, cu);
13574 TYPE_NAME (type) = name;
13576 /* Install the type in the die. */
13577 set_die_type (die, type, cu);
13579 /* set_die_type should be already done. */
13580 set_descriptive_type (type, die, cu);
13582 do_cleanups (back_to);
13587 static enum dwarf_array_dim_ordering
13588 read_array_order (struct die_info *die, struct dwarf2_cu *cu)
13590 struct attribute *attr;
13592 attr = dwarf2_attr (die, DW_AT_ordering, cu);
13594 if (attr) return DW_SND (attr);
13596 /* GNU F77 is a special case, as at 08/2004 array type info is the
13597 opposite order to the dwarf2 specification, but data is still
13598 laid out as per normal fortran.
13600 FIXME: dsl/2004-8-20: If G77 is ever fixed, this will also need
13601 version checking. */
13603 if (cu->language == language_fortran
13604 && cu->producer && strstr (cu->producer, "GNU F77"))
13606 return DW_ORD_row_major;
13609 switch (cu->language_defn->la_array_ordering)
13611 case array_column_major:
13612 return DW_ORD_col_major;
13613 case array_row_major:
13615 return DW_ORD_row_major;
13619 /* Extract all information from a DW_TAG_set_type DIE and put it in
13620 the DIE's type field. */
13622 static struct type *
13623 read_set_type (struct die_info *die, struct dwarf2_cu *cu)
13625 struct type *domain_type, *set_type;
13626 struct attribute *attr;
13628 domain_type = die_type (die, cu);
13630 /* The die_type call above may have already set the type for this DIE. */
13631 set_type = get_die_type (die, cu);
13635 set_type = create_set_type (NULL, domain_type);
13637 attr = dwarf2_attr (die, DW_AT_byte_size, cu);
13639 TYPE_LENGTH (set_type) = DW_UNSND (attr);
13641 return set_die_type (die, set_type, cu);
13644 /* A helper for read_common_block that creates a locexpr baton.
13645 SYM is the symbol which we are marking as computed.
13646 COMMON_DIE is the DIE for the common block.
13647 COMMON_LOC is the location expression attribute for the common
13649 MEMBER_LOC is the location expression attribute for the particular
13650 member of the common block that we are processing.
13651 CU is the CU from which the above come. */
13654 mark_common_block_symbol_computed (struct symbol *sym,
13655 struct die_info *common_die,
13656 struct attribute *common_loc,
13657 struct attribute *member_loc,
13658 struct dwarf2_cu *cu)
13660 struct objfile *objfile = dwarf2_per_objfile->objfile;
13661 struct dwarf2_locexpr_baton *baton;
13663 unsigned int cu_off;
13664 enum bfd_endian byte_order = gdbarch_byte_order (get_objfile_arch (objfile));
13665 LONGEST offset = 0;
13667 gdb_assert (common_loc && member_loc);
13668 gdb_assert (attr_form_is_block (common_loc));
13669 gdb_assert (attr_form_is_block (member_loc)
13670 || attr_form_is_constant (member_loc));
13672 baton = obstack_alloc (&objfile->objfile_obstack,
13673 sizeof (struct dwarf2_locexpr_baton));
13674 baton->per_cu = cu->per_cu;
13675 gdb_assert (baton->per_cu);
13677 baton->size = 5 /* DW_OP_call4 */ + 1 /* DW_OP_plus */;
13679 if (attr_form_is_constant (member_loc))
13681 offset = dwarf2_get_attr_constant_value (member_loc, 0);
13682 baton->size += 1 /* DW_OP_addr */ + cu->header.addr_size;
13685 baton->size += DW_BLOCK (member_loc)->size;
13687 ptr = obstack_alloc (&objfile->objfile_obstack, baton->size);
13690 *ptr++ = DW_OP_call4;
13691 cu_off = common_die->offset.sect_off - cu->per_cu->offset.sect_off;
13692 store_unsigned_integer (ptr, 4, byte_order, cu_off);
13695 if (attr_form_is_constant (member_loc))
13697 *ptr++ = DW_OP_addr;
13698 store_unsigned_integer (ptr, cu->header.addr_size, byte_order, offset);
13699 ptr += cu->header.addr_size;
13703 /* We have to copy the data here, because DW_OP_call4 will only
13704 use a DW_AT_location attribute. */
13705 memcpy (ptr, DW_BLOCK (member_loc)->data, DW_BLOCK (member_loc)->size);
13706 ptr += DW_BLOCK (member_loc)->size;
13709 *ptr++ = DW_OP_plus;
13710 gdb_assert (ptr - baton->data == baton->size);
13712 SYMBOL_LOCATION_BATON (sym) = baton;
13713 SYMBOL_ACLASS_INDEX (sym) = dwarf2_locexpr_index;
13716 /* Create appropriate locally-scoped variables for all the
13717 DW_TAG_common_block entries. Also create a struct common_block
13718 listing all such variables for `info common'. COMMON_BLOCK_DOMAIN
13719 is used to sepate the common blocks name namespace from regular
13723 read_common_block (struct die_info *die, struct dwarf2_cu *cu)
13725 struct attribute *attr;
13727 attr = dwarf2_attr (die, DW_AT_location, cu);
13730 /* Support the .debug_loc offsets. */
13731 if (attr_form_is_block (attr))
13735 else if (attr_form_is_section_offset (attr))
13737 dwarf2_complex_location_expr_complaint ();
13742 dwarf2_invalid_attrib_class_complaint ("DW_AT_location",
13743 "common block member");
13748 if (die->child != NULL)
13750 struct objfile *objfile = cu->objfile;
13751 struct die_info *child_die;
13752 size_t n_entries = 0, size;
13753 struct common_block *common_block;
13754 struct symbol *sym;
13756 for (child_die = die->child;
13757 child_die && child_die->tag;
13758 child_die = sibling_die (child_die))
13761 size = (sizeof (struct common_block)
13762 + (n_entries - 1) * sizeof (struct symbol *));
13763 common_block = obstack_alloc (&objfile->objfile_obstack, size);
13764 memset (common_block->contents, 0, n_entries * sizeof (struct symbol *));
13765 common_block->n_entries = 0;
13767 for (child_die = die->child;
13768 child_die && child_die->tag;
13769 child_die = sibling_die (child_die))
13771 /* Create the symbol in the DW_TAG_common_block block in the current
13773 sym = new_symbol (child_die, NULL, cu);
13776 struct attribute *member_loc;
13778 common_block->contents[common_block->n_entries++] = sym;
13780 member_loc = dwarf2_attr (child_die, DW_AT_data_member_location,
13784 /* GDB has handled this for a long time, but it is
13785 not specified by DWARF. It seems to have been
13786 emitted by gfortran at least as recently as:
13787 http://gcc.gnu.org/bugzilla/show_bug.cgi?id=23057. */
13788 complaint (&symfile_complaints,
13789 _("Variable in common block has "
13790 "DW_AT_data_member_location "
13791 "- DIE at 0x%x [in module %s]"),
13792 child_die->offset.sect_off,
13793 objfile_name (cu->objfile));
13795 if (attr_form_is_section_offset (member_loc))
13796 dwarf2_complex_location_expr_complaint ();
13797 else if (attr_form_is_constant (member_loc)
13798 || attr_form_is_block (member_loc))
13801 mark_common_block_symbol_computed (sym, die, attr,
13805 dwarf2_complex_location_expr_complaint ();
13810 sym = new_symbol (die, objfile_type (objfile)->builtin_void, cu);
13811 SYMBOL_VALUE_COMMON_BLOCK (sym) = common_block;
13815 /* Create a type for a C++ namespace. */
13817 static struct type *
13818 read_namespace_type (struct die_info *die, struct dwarf2_cu *cu)
13820 struct objfile *objfile = cu->objfile;
13821 const char *previous_prefix, *name;
13825 /* For extensions, reuse the type of the original namespace. */
13826 if (dwarf2_attr (die, DW_AT_extension, cu) != NULL)
13828 struct die_info *ext_die;
13829 struct dwarf2_cu *ext_cu = cu;
13831 ext_die = dwarf2_extension (die, &ext_cu);
13832 type = read_type_die (ext_die, ext_cu);
13834 /* EXT_CU may not be the same as CU.
13835 Ensure TYPE is recorded with CU in die_type_hash. */
13836 return set_die_type (die, type, cu);
13839 name = namespace_name (die, &is_anonymous, cu);
13841 /* Now build the name of the current namespace. */
13843 previous_prefix = determine_prefix (die, cu);
13844 if (previous_prefix[0] != '\0')
13845 name = typename_concat (&objfile->objfile_obstack,
13846 previous_prefix, name, 0, cu);
13848 /* Create the type. */
13849 type = init_type (TYPE_CODE_NAMESPACE, 0, 0, NULL,
13851 TYPE_NAME (type) = name;
13852 TYPE_TAG_NAME (type) = TYPE_NAME (type);
13854 return set_die_type (die, type, cu);
13857 /* Read a C++ namespace. */
13860 read_namespace (struct die_info *die, struct dwarf2_cu *cu)
13862 struct objfile *objfile = cu->objfile;
13865 /* Add a symbol associated to this if we haven't seen the namespace
13866 before. Also, add a using directive if it's an anonymous
13869 if (dwarf2_attr (die, DW_AT_extension, cu) == NULL)
13873 type = read_type_die (die, cu);
13874 new_symbol (die, type, cu);
13876 namespace_name (die, &is_anonymous, cu);
13879 const char *previous_prefix = determine_prefix (die, cu);
13881 cp_add_using_directive (previous_prefix, TYPE_NAME (type), NULL,
13882 NULL, NULL, 0, &objfile->objfile_obstack);
13886 if (die->child != NULL)
13888 struct die_info *child_die = die->child;
13890 while (child_die && child_die->tag)
13892 process_die (child_die, cu);
13893 child_die = sibling_die (child_die);
13898 /* Read a Fortran module as type. This DIE can be only a declaration used for
13899 imported module. Still we need that type as local Fortran "use ... only"
13900 declaration imports depend on the created type in determine_prefix. */
13902 static struct type *
13903 read_module_type (struct die_info *die, struct dwarf2_cu *cu)
13905 struct objfile *objfile = cu->objfile;
13906 const char *module_name;
13909 module_name = dwarf2_name (die, cu);
13911 complaint (&symfile_complaints,
13912 _("DW_TAG_module has no name, offset 0x%x"),
13913 die->offset.sect_off);
13914 type = init_type (TYPE_CODE_MODULE, 0, 0, module_name, objfile);
13916 /* determine_prefix uses TYPE_TAG_NAME. */
13917 TYPE_TAG_NAME (type) = TYPE_NAME (type);
13919 return set_die_type (die, type, cu);
13922 /* Read a Fortran module. */
13925 read_module (struct die_info *die, struct dwarf2_cu *cu)
13927 struct die_info *child_die = die->child;
13930 type = read_type_die (die, cu);
13931 new_symbol (die, type, cu);
13933 while (child_die && child_die->tag)
13935 process_die (child_die, cu);
13936 child_die = sibling_die (child_die);
13940 /* Return the name of the namespace represented by DIE. Set
13941 *IS_ANONYMOUS to tell whether or not the namespace is an anonymous
13944 static const char *
13945 namespace_name (struct die_info *die, int *is_anonymous, struct dwarf2_cu *cu)
13947 struct die_info *current_die;
13948 const char *name = NULL;
13950 /* Loop through the extensions until we find a name. */
13952 for (current_die = die;
13953 current_die != NULL;
13954 current_die = dwarf2_extension (die, &cu))
13956 name = dwarf2_name (current_die, cu);
13961 /* Is it an anonymous namespace? */
13963 *is_anonymous = (name == NULL);
13965 name = CP_ANONYMOUS_NAMESPACE_STR;
13970 /* Extract all information from a DW_TAG_pointer_type DIE and add to
13971 the user defined type vector. */
13973 static struct type *
13974 read_tag_pointer_type (struct die_info *die, struct dwarf2_cu *cu)
13976 struct gdbarch *gdbarch = get_objfile_arch (cu->objfile);
13977 struct comp_unit_head *cu_header = &cu->header;
13979 struct attribute *attr_byte_size;
13980 struct attribute *attr_address_class;
13981 int byte_size, addr_class;
13982 struct type *target_type;
13984 target_type = die_type (die, cu);
13986 /* The die_type call above may have already set the type for this DIE. */
13987 type = get_die_type (die, cu);
13991 type = lookup_pointer_type (target_type);
13993 attr_byte_size = dwarf2_attr (die, DW_AT_byte_size, cu);
13994 if (attr_byte_size)
13995 byte_size = DW_UNSND (attr_byte_size);
13997 byte_size = cu_header->addr_size;
13999 attr_address_class = dwarf2_attr (die, DW_AT_address_class, cu);
14000 if (attr_address_class)
14001 addr_class = DW_UNSND (attr_address_class);
14003 addr_class = DW_ADDR_none;
14005 /* If the pointer size or address class is different than the
14006 default, create a type variant marked as such and set the
14007 length accordingly. */
14008 if (TYPE_LENGTH (type) != byte_size || addr_class != DW_ADDR_none)
14010 if (gdbarch_address_class_type_flags_p (gdbarch))
14014 type_flags = gdbarch_address_class_type_flags
14015 (gdbarch, byte_size, addr_class);
14016 gdb_assert ((type_flags & ~TYPE_INSTANCE_FLAG_ADDRESS_CLASS_ALL)
14018 type = make_type_with_address_space (type, type_flags);
14020 else if (TYPE_LENGTH (type) != byte_size)
14022 complaint (&symfile_complaints,
14023 _("invalid pointer size %d"), byte_size);
14027 /* Should we also complain about unhandled address classes? */
14031 TYPE_LENGTH (type) = byte_size;
14032 return set_die_type (die, type, cu);
14035 /* Extract all information from a DW_TAG_ptr_to_member_type DIE and add to
14036 the user defined type vector. */
14038 static struct type *
14039 read_tag_ptr_to_member_type (struct die_info *die, struct dwarf2_cu *cu)
14042 struct type *to_type;
14043 struct type *domain;
14045 to_type = die_type (die, cu);
14046 domain = die_containing_type (die, cu);
14048 /* The calls above may have already set the type for this DIE. */
14049 type = get_die_type (die, cu);
14053 if (TYPE_CODE (check_typedef (to_type)) == TYPE_CODE_METHOD)
14054 type = lookup_methodptr_type (to_type);
14055 else if (TYPE_CODE (check_typedef (to_type)) == TYPE_CODE_FUNC)
14057 struct type *new_type = alloc_type (cu->objfile);
14059 smash_to_method_type (new_type, domain, TYPE_TARGET_TYPE (to_type),
14060 TYPE_FIELDS (to_type), TYPE_NFIELDS (to_type),
14061 TYPE_VARARGS (to_type));
14062 type = lookup_methodptr_type (new_type);
14065 type = lookup_memberptr_type (to_type, domain);
14067 return set_die_type (die, type, cu);
14070 /* Extract all information from a DW_TAG_reference_type DIE and add to
14071 the user defined type vector. */
14073 static struct type *
14074 read_tag_reference_type (struct die_info *die, struct dwarf2_cu *cu)
14076 struct comp_unit_head *cu_header = &cu->header;
14077 struct type *type, *target_type;
14078 struct attribute *attr;
14080 target_type = die_type (die, cu);
14082 /* The die_type call above may have already set the type for this DIE. */
14083 type = get_die_type (die, cu);
14087 type = lookup_reference_type (target_type);
14088 attr = dwarf2_attr (die, DW_AT_byte_size, cu);
14091 TYPE_LENGTH (type) = DW_UNSND (attr);
14095 TYPE_LENGTH (type) = cu_header->addr_size;
14097 return set_die_type (die, type, cu);
14100 /* Add the given cv-qualifiers to the element type of the array. GCC
14101 outputs DWARF type qualifiers that apply to an array, not the
14102 element type. But GDB relies on the array element type to carry
14103 the cv-qualifiers. This mimics section 6.7.3 of the C99
14106 static struct type *
14107 add_array_cv_type (struct die_info *die, struct dwarf2_cu *cu,
14108 struct type *base_type, int cnst, int voltl)
14110 struct type *el_type, *inner_array;
14112 base_type = copy_type (base_type);
14113 inner_array = base_type;
14115 while (TYPE_CODE (TYPE_TARGET_TYPE (inner_array)) == TYPE_CODE_ARRAY)
14117 TYPE_TARGET_TYPE (inner_array) =
14118 copy_type (TYPE_TARGET_TYPE (inner_array));
14119 inner_array = TYPE_TARGET_TYPE (inner_array);
14122 el_type = TYPE_TARGET_TYPE (inner_array);
14123 cnst |= TYPE_CONST (el_type);
14124 voltl |= TYPE_VOLATILE (el_type);
14125 TYPE_TARGET_TYPE (inner_array) = make_cv_type (cnst, voltl, el_type, NULL);
14127 return set_die_type (die, base_type, cu);
14130 static struct type *
14131 read_tag_const_type (struct die_info *die, struct dwarf2_cu *cu)
14133 struct type *base_type, *cv_type;
14135 base_type = die_type (die, cu);
14137 /* The die_type call above may have already set the type for this DIE. */
14138 cv_type = get_die_type (die, cu);
14142 /* In case the const qualifier is applied to an array type, the element type
14143 is so qualified, not the array type (section 6.7.3 of C99). */
14144 if (TYPE_CODE (base_type) == TYPE_CODE_ARRAY)
14145 return add_array_cv_type (die, cu, base_type, 1, 0);
14147 cv_type = make_cv_type (1, TYPE_VOLATILE (base_type), base_type, 0);
14148 return set_die_type (die, cv_type, cu);
14151 static struct type *
14152 read_tag_volatile_type (struct die_info *die, struct dwarf2_cu *cu)
14154 struct type *base_type, *cv_type;
14156 base_type = die_type (die, cu);
14158 /* The die_type call above may have already set the type for this DIE. */
14159 cv_type = get_die_type (die, cu);
14163 /* In case the volatile qualifier is applied to an array type, the
14164 element type is so qualified, not the array type (section 6.7.3
14166 if (TYPE_CODE (base_type) == TYPE_CODE_ARRAY)
14167 return add_array_cv_type (die, cu, base_type, 0, 1);
14169 cv_type = make_cv_type (TYPE_CONST (base_type), 1, base_type, 0);
14170 return set_die_type (die, cv_type, cu);
14173 /* Handle DW_TAG_restrict_type. */
14175 static struct type *
14176 read_tag_restrict_type (struct die_info *die, struct dwarf2_cu *cu)
14178 struct type *base_type, *cv_type;
14180 base_type = die_type (die, cu);
14182 /* The die_type call above may have already set the type for this DIE. */
14183 cv_type = get_die_type (die, cu);
14187 cv_type = make_restrict_type (base_type);
14188 return set_die_type (die, cv_type, cu);
14191 /* Extract all information from a DW_TAG_string_type DIE and add to
14192 the user defined type vector. It isn't really a user defined type,
14193 but it behaves like one, with other DIE's using an AT_user_def_type
14194 attribute to reference it. */
14196 static struct type *
14197 read_tag_string_type (struct die_info *die, struct dwarf2_cu *cu)
14199 struct objfile *objfile = cu->objfile;
14200 struct gdbarch *gdbarch = get_objfile_arch (objfile);
14201 struct type *type, *range_type, *index_type, *char_type;
14202 struct attribute *attr;
14203 unsigned int length;
14205 attr = dwarf2_attr (die, DW_AT_string_length, cu);
14208 length = DW_UNSND (attr);
14212 /* Check for the DW_AT_byte_size attribute. */
14213 attr = dwarf2_attr (die, DW_AT_byte_size, cu);
14216 length = DW_UNSND (attr);
14224 index_type = objfile_type (objfile)->builtin_int;
14225 range_type = create_static_range_type (NULL, index_type, 1, length);
14226 char_type = language_string_char_type (cu->language_defn, gdbarch);
14227 type = create_string_type (NULL, char_type, range_type);
14229 return set_die_type (die, type, cu);
14232 /* Assuming that DIE corresponds to a function, returns nonzero
14233 if the function is prototyped. */
14236 prototyped_function_p (struct die_info *die, struct dwarf2_cu *cu)
14238 struct attribute *attr;
14240 attr = dwarf2_attr (die, DW_AT_prototyped, cu);
14241 if (attr && (DW_UNSND (attr) != 0))
14244 /* The DWARF standard implies that the DW_AT_prototyped attribute
14245 is only meaninful for C, but the concept also extends to other
14246 languages that allow unprototyped functions (Eg: Objective C).
14247 For all other languages, assume that functions are always
14249 if (cu->language != language_c
14250 && cu->language != language_objc
14251 && cu->language != language_opencl)
14254 /* RealView does not emit DW_AT_prototyped. We can not distinguish
14255 prototyped and unprototyped functions; default to prototyped,
14256 since that is more common in modern code (and RealView warns
14257 about unprototyped functions). */
14258 if (producer_is_realview (cu->producer))
14264 /* Handle DIES due to C code like:
14268 int (*funcp)(int a, long l);
14272 ('funcp' generates a DW_TAG_subroutine_type DIE). */
14274 static struct type *
14275 read_subroutine_type (struct die_info *die, struct dwarf2_cu *cu)
14277 struct objfile *objfile = cu->objfile;
14278 struct type *type; /* Type that this function returns. */
14279 struct type *ftype; /* Function that returns above type. */
14280 struct attribute *attr;
14282 type = die_type (die, cu);
14284 /* The die_type call above may have already set the type for this DIE. */
14285 ftype = get_die_type (die, cu);
14289 ftype = lookup_function_type (type);
14291 if (prototyped_function_p (die, cu))
14292 TYPE_PROTOTYPED (ftype) = 1;
14294 /* Store the calling convention in the type if it's available in
14295 the subroutine die. Otherwise set the calling convention to
14296 the default value DW_CC_normal. */
14297 attr = dwarf2_attr (die, DW_AT_calling_convention, cu);
14299 TYPE_CALLING_CONVENTION (ftype) = DW_UNSND (attr);
14300 else if (cu->producer && strstr (cu->producer, "IBM XL C for OpenCL"))
14301 TYPE_CALLING_CONVENTION (ftype) = DW_CC_GDB_IBM_OpenCL;
14303 TYPE_CALLING_CONVENTION (ftype) = DW_CC_normal;
14305 /* We need to add the subroutine type to the die immediately so
14306 we don't infinitely recurse when dealing with parameters
14307 declared as the same subroutine type. */
14308 set_die_type (die, ftype, cu);
14310 if (die->child != NULL)
14312 struct type *void_type = objfile_type (objfile)->builtin_void;
14313 struct die_info *child_die;
14314 int nparams, iparams;
14316 /* Count the number of parameters.
14317 FIXME: GDB currently ignores vararg functions, but knows about
14318 vararg member functions. */
14320 child_die = die->child;
14321 while (child_die && child_die->tag)
14323 if (child_die->tag == DW_TAG_formal_parameter)
14325 else if (child_die->tag == DW_TAG_unspecified_parameters)
14326 TYPE_VARARGS (ftype) = 1;
14327 child_die = sibling_die (child_die);
14330 /* Allocate storage for parameters and fill them in. */
14331 TYPE_NFIELDS (ftype) = nparams;
14332 TYPE_FIELDS (ftype) = (struct field *)
14333 TYPE_ZALLOC (ftype, nparams * sizeof (struct field));
14335 /* TYPE_FIELD_TYPE must never be NULL. Pre-fill the array to ensure it
14336 even if we error out during the parameters reading below. */
14337 for (iparams = 0; iparams < nparams; iparams++)
14338 TYPE_FIELD_TYPE (ftype, iparams) = void_type;
14341 child_die = die->child;
14342 while (child_die && child_die->tag)
14344 if (child_die->tag == DW_TAG_formal_parameter)
14346 struct type *arg_type;
14348 /* DWARF version 2 has no clean way to discern C++
14349 static and non-static member functions. G++ helps
14350 GDB by marking the first parameter for non-static
14351 member functions (which is the this pointer) as
14352 artificial. We pass this information to
14353 dwarf2_add_member_fn via TYPE_FIELD_ARTIFICIAL.
14355 DWARF version 3 added DW_AT_object_pointer, which GCC
14356 4.5 does not yet generate. */
14357 attr = dwarf2_attr (child_die, DW_AT_artificial, cu);
14359 TYPE_FIELD_ARTIFICIAL (ftype, iparams) = DW_UNSND (attr);
14362 TYPE_FIELD_ARTIFICIAL (ftype, iparams) = 0;
14364 /* GCC/43521: In java, the formal parameter
14365 "this" is sometimes not marked with DW_AT_artificial. */
14366 if (cu->language == language_java)
14368 const char *name = dwarf2_name (child_die, cu);
14370 if (name && !strcmp (name, "this"))
14371 TYPE_FIELD_ARTIFICIAL (ftype, iparams) = 1;
14374 arg_type = die_type (child_die, cu);
14376 /* RealView does not mark THIS as const, which the testsuite
14377 expects. GCC marks THIS as const in method definitions,
14378 but not in the class specifications (GCC PR 43053). */
14379 if (cu->language == language_cplus && !TYPE_CONST (arg_type)
14380 && TYPE_FIELD_ARTIFICIAL (ftype, iparams))
14383 struct dwarf2_cu *arg_cu = cu;
14384 const char *name = dwarf2_name (child_die, cu);
14386 attr = dwarf2_attr (die, DW_AT_object_pointer, cu);
14389 /* If the compiler emits this, use it. */
14390 if (follow_die_ref (die, attr, &arg_cu) == child_die)
14393 else if (name && strcmp (name, "this") == 0)
14394 /* Function definitions will have the argument names. */
14396 else if (name == NULL && iparams == 0)
14397 /* Declarations may not have the names, so like
14398 elsewhere in GDB, assume an artificial first
14399 argument is "this". */
14403 arg_type = make_cv_type (1, TYPE_VOLATILE (arg_type),
14407 TYPE_FIELD_TYPE (ftype, iparams) = arg_type;
14410 child_die = sibling_die (child_die);
14417 static struct type *
14418 read_typedef (struct die_info *die, struct dwarf2_cu *cu)
14420 struct objfile *objfile = cu->objfile;
14421 const char *name = NULL;
14422 struct type *this_type, *target_type;
14424 name = dwarf2_full_name (NULL, die, cu);
14425 this_type = init_type (TYPE_CODE_TYPEDEF, 0,
14426 TYPE_FLAG_TARGET_STUB, NULL, objfile);
14427 TYPE_NAME (this_type) = name;
14428 set_die_type (die, this_type, cu);
14429 target_type = die_type (die, cu);
14430 if (target_type != this_type)
14431 TYPE_TARGET_TYPE (this_type) = target_type;
14434 /* Self-referential typedefs are, it seems, not allowed by the DWARF
14435 spec and cause infinite loops in GDB. */
14436 complaint (&symfile_complaints,
14437 _("Self-referential DW_TAG_typedef "
14438 "- DIE at 0x%x [in module %s]"),
14439 die->offset.sect_off, objfile_name (objfile));
14440 TYPE_TARGET_TYPE (this_type) = NULL;
14445 /* Find a representation of a given base type and install
14446 it in the TYPE field of the die. */
14448 static struct type *
14449 read_base_type (struct die_info *die, struct dwarf2_cu *cu)
14451 struct objfile *objfile = cu->objfile;
14453 struct attribute *attr;
14454 int encoding = 0, size = 0;
14456 enum type_code code = TYPE_CODE_INT;
14457 int type_flags = 0;
14458 struct type *target_type = NULL;
14460 attr = dwarf2_attr (die, DW_AT_encoding, cu);
14463 encoding = DW_UNSND (attr);
14465 attr = dwarf2_attr (die, DW_AT_byte_size, cu);
14468 size = DW_UNSND (attr);
14470 name = dwarf2_name (die, cu);
14473 complaint (&symfile_complaints,
14474 _("DW_AT_name missing from DW_TAG_base_type"));
14479 case DW_ATE_address:
14480 /* Turn DW_ATE_address into a void * pointer. */
14481 code = TYPE_CODE_PTR;
14482 type_flags |= TYPE_FLAG_UNSIGNED;
14483 target_type = init_type (TYPE_CODE_VOID, 1, 0, NULL, objfile);
14485 case DW_ATE_boolean:
14486 code = TYPE_CODE_BOOL;
14487 type_flags |= TYPE_FLAG_UNSIGNED;
14489 case DW_ATE_complex_float:
14490 code = TYPE_CODE_COMPLEX;
14491 target_type = init_type (TYPE_CODE_FLT, size / 2, 0, NULL, objfile);
14493 case DW_ATE_decimal_float:
14494 code = TYPE_CODE_DECFLOAT;
14497 code = TYPE_CODE_FLT;
14499 case DW_ATE_signed:
14501 case DW_ATE_unsigned:
14502 type_flags |= TYPE_FLAG_UNSIGNED;
14503 if (cu->language == language_fortran
14505 && strncmp (name, "character(", sizeof ("character(") - 1) == 0)
14506 code = TYPE_CODE_CHAR;
14508 case DW_ATE_signed_char:
14509 if (cu->language == language_ada || cu->language == language_m2
14510 || cu->language == language_pascal
14511 || cu->language == language_fortran)
14512 code = TYPE_CODE_CHAR;
14514 case DW_ATE_unsigned_char:
14515 if (cu->language == language_ada || cu->language == language_m2
14516 || cu->language == language_pascal
14517 || cu->language == language_fortran)
14518 code = TYPE_CODE_CHAR;
14519 type_flags |= TYPE_FLAG_UNSIGNED;
14522 /* We just treat this as an integer and then recognize the
14523 type by name elsewhere. */
14527 complaint (&symfile_complaints, _("unsupported DW_AT_encoding: '%s'"),
14528 dwarf_type_encoding_name (encoding));
14532 type = init_type (code, size, type_flags, NULL, objfile);
14533 TYPE_NAME (type) = name;
14534 TYPE_TARGET_TYPE (type) = target_type;
14536 if (name && strcmp (name, "char") == 0)
14537 TYPE_NOSIGN (type) = 1;
14539 return set_die_type (die, type, cu);
14542 /* Parse dwarf attribute if it's a block, reference or constant and put the
14543 resulting value of the attribute into struct bound_prop.
14544 Returns 1 if ATTR could be resolved into PROP, 0 otherwise. */
14547 attr_to_dynamic_prop (const struct attribute *attr, struct die_info *die,
14548 struct dwarf2_cu *cu, struct dynamic_prop *prop)
14550 struct dwarf2_property_baton *baton;
14551 struct obstack *obstack = &cu->objfile->objfile_obstack;
14553 if (attr == NULL || prop == NULL)
14556 if (attr_form_is_block (attr))
14558 baton = obstack_alloc (obstack, sizeof (*baton));
14559 baton->referenced_type = NULL;
14560 baton->locexpr.per_cu = cu->per_cu;
14561 baton->locexpr.size = DW_BLOCK (attr)->size;
14562 baton->locexpr.data = DW_BLOCK (attr)->data;
14563 prop->data.baton = baton;
14564 prop->kind = PROP_LOCEXPR;
14565 gdb_assert (prop->data.baton != NULL);
14567 else if (attr_form_is_ref (attr))
14569 struct dwarf2_cu *target_cu = cu;
14570 struct die_info *target_die;
14571 struct attribute *target_attr;
14573 target_die = follow_die_ref (die, attr, &target_cu);
14574 target_attr = dwarf2_attr (target_die, DW_AT_location, target_cu);
14575 if (target_attr == NULL)
14578 if (attr_form_is_section_offset (target_attr))
14580 baton = obstack_alloc (obstack, sizeof (*baton));
14581 baton->referenced_type = die_type (target_die, target_cu);
14582 fill_in_loclist_baton (cu, &baton->loclist, target_attr);
14583 prop->data.baton = baton;
14584 prop->kind = PROP_LOCLIST;
14585 gdb_assert (prop->data.baton != NULL);
14587 else if (attr_form_is_block (target_attr))
14589 baton = obstack_alloc (obstack, sizeof (*baton));
14590 baton->referenced_type = die_type (target_die, target_cu);
14591 baton->locexpr.per_cu = cu->per_cu;
14592 baton->locexpr.size = DW_BLOCK (target_attr)->size;
14593 baton->locexpr.data = DW_BLOCK (target_attr)->data;
14594 prop->data.baton = baton;
14595 prop->kind = PROP_LOCEXPR;
14596 gdb_assert (prop->data.baton != NULL);
14600 dwarf2_invalid_attrib_class_complaint ("DW_AT_location",
14601 "dynamic property");
14605 else if (attr_form_is_constant (attr))
14607 prop->data.const_val = dwarf2_get_attr_constant_value (attr, 0);
14608 prop->kind = PROP_CONST;
14612 dwarf2_invalid_attrib_class_complaint (dwarf_form_name (attr->form),
14613 dwarf2_name (die, cu));
14620 /* Read the given DW_AT_subrange DIE. */
14622 static struct type *
14623 read_subrange_type (struct die_info *die, struct dwarf2_cu *cu)
14625 struct type *base_type, *orig_base_type;
14626 struct type *range_type;
14627 struct attribute *attr;
14628 struct dynamic_prop low, high;
14629 int low_default_is_valid;
14630 int high_bound_is_count = 0;
14632 LONGEST negative_mask;
14634 orig_base_type = die_type (die, cu);
14635 /* If ORIG_BASE_TYPE is a typedef, it will not be TYPE_UNSIGNED,
14636 whereas the real type might be. So, we use ORIG_BASE_TYPE when
14637 creating the range type, but we use the result of check_typedef
14638 when examining properties of the type. */
14639 base_type = check_typedef (orig_base_type);
14641 /* The die_type call above may have already set the type for this DIE. */
14642 range_type = get_die_type (die, cu);
14646 low.kind = PROP_CONST;
14647 high.kind = PROP_CONST;
14648 high.data.const_val = 0;
14650 /* Set LOW_DEFAULT_IS_VALID if current language and DWARF version allow
14651 omitting DW_AT_lower_bound. */
14652 switch (cu->language)
14655 case language_cplus:
14656 low.data.const_val = 0;
14657 low_default_is_valid = 1;
14659 case language_fortran:
14660 low.data.const_val = 1;
14661 low_default_is_valid = 1;
14664 case language_java:
14665 case language_objc:
14666 low.data.const_val = 0;
14667 low_default_is_valid = (cu->header.version >= 4);
14671 case language_pascal:
14672 low.data.const_val = 1;
14673 low_default_is_valid = (cu->header.version >= 4);
14676 low.data.const_val = 0;
14677 low_default_is_valid = 0;
14681 attr = dwarf2_attr (die, DW_AT_lower_bound, cu);
14683 attr_to_dynamic_prop (attr, die, cu, &low);
14684 else if (!low_default_is_valid)
14685 complaint (&symfile_complaints, _("Missing DW_AT_lower_bound "
14686 "- DIE at 0x%x [in module %s]"),
14687 die->offset.sect_off, objfile_name (cu->objfile));
14689 attr = dwarf2_attr (die, DW_AT_upper_bound, cu);
14690 if (!attr_to_dynamic_prop (attr, die, cu, &high))
14692 attr = dwarf2_attr (die, DW_AT_count, cu);
14693 if (attr_to_dynamic_prop (attr, die, cu, &high))
14695 /* If bounds are constant do the final calculation here. */
14696 if (low.kind == PROP_CONST && high.kind == PROP_CONST)
14697 high.data.const_val = low.data.const_val + high.data.const_val - 1;
14699 high_bound_is_count = 1;
14703 /* Dwarf-2 specifications explicitly allows to create subrange types
14704 without specifying a base type.
14705 In that case, the base type must be set to the type of
14706 the lower bound, upper bound or count, in that order, if any of these
14707 three attributes references an object that has a type.
14708 If no base type is found, the Dwarf-2 specifications say that
14709 a signed integer type of size equal to the size of an address should
14711 For the following C code: `extern char gdb_int [];'
14712 GCC produces an empty range DIE.
14713 FIXME: muller/2010-05-28: Possible references to object for low bound,
14714 high bound or count are not yet handled by this code. */
14715 if (TYPE_CODE (base_type) == TYPE_CODE_VOID)
14717 struct objfile *objfile = cu->objfile;
14718 struct gdbarch *gdbarch = get_objfile_arch (objfile);
14719 int addr_size = gdbarch_addr_bit (gdbarch) /8;
14720 struct type *int_type = objfile_type (objfile)->builtin_int;
14722 /* Test "int", "long int", and "long long int" objfile types,
14723 and select the first one having a size above or equal to the
14724 architecture address size. */
14725 if (int_type && TYPE_LENGTH (int_type) >= addr_size)
14726 base_type = int_type;
14729 int_type = objfile_type (objfile)->builtin_long;
14730 if (int_type && TYPE_LENGTH (int_type) >= addr_size)
14731 base_type = int_type;
14734 int_type = objfile_type (objfile)->builtin_long_long;
14735 if (int_type && TYPE_LENGTH (int_type) >= addr_size)
14736 base_type = int_type;
14741 /* Normally, the DWARF producers are expected to use a signed
14742 constant form (Eg. DW_FORM_sdata) to express negative bounds.
14743 But this is unfortunately not always the case, as witnessed
14744 with GCC, for instance, where the ambiguous DW_FORM_dataN form
14745 is used instead. To work around that ambiguity, we treat
14746 the bounds as signed, and thus sign-extend their values, when
14747 the base type is signed. */
14749 (LONGEST) -1 << (TYPE_LENGTH (base_type) * TARGET_CHAR_BIT - 1);
14750 if (low.kind == PROP_CONST
14751 && !TYPE_UNSIGNED (base_type) && (low.data.const_val & negative_mask))
14752 low.data.const_val |= negative_mask;
14753 if (high.kind == PROP_CONST
14754 && !TYPE_UNSIGNED (base_type) && (high.data.const_val & negative_mask))
14755 high.data.const_val |= negative_mask;
14757 range_type = create_range_type (NULL, orig_base_type, &low, &high);
14759 if (high_bound_is_count)
14760 TYPE_RANGE_DATA (range_type)->flag_upper_bound_is_count = 1;
14762 /* Ada expects an empty array on no boundary attributes. */
14763 if (attr == NULL && cu->language != language_ada)
14764 TYPE_HIGH_BOUND_KIND (range_type) = PROP_UNDEFINED;
14766 name = dwarf2_name (die, cu);
14768 TYPE_NAME (range_type) = name;
14770 attr = dwarf2_attr (die, DW_AT_byte_size, cu);
14772 TYPE_LENGTH (range_type) = DW_UNSND (attr);
14774 set_die_type (die, range_type, cu);
14776 /* set_die_type should be already done. */
14777 set_descriptive_type (range_type, die, cu);
14782 static struct type *
14783 read_unspecified_type (struct die_info *die, struct dwarf2_cu *cu)
14787 /* For now, we only support the C meaning of an unspecified type: void. */
14789 type = init_type (TYPE_CODE_VOID, 0, 0, NULL, cu->objfile);
14790 TYPE_NAME (type) = dwarf2_name (die, cu);
14792 return set_die_type (die, type, cu);
14795 /* Read a single die and all its descendents. Set the die's sibling
14796 field to NULL; set other fields in the die correctly, and set all
14797 of the descendents' fields correctly. Set *NEW_INFO_PTR to the
14798 location of the info_ptr after reading all of those dies. PARENT
14799 is the parent of the die in question. */
14801 static struct die_info *
14802 read_die_and_children (const struct die_reader_specs *reader,
14803 const gdb_byte *info_ptr,
14804 const gdb_byte **new_info_ptr,
14805 struct die_info *parent)
14807 struct die_info *die;
14808 const gdb_byte *cur_ptr;
14811 cur_ptr = read_full_die_1 (reader, &die, info_ptr, &has_children, 0);
14814 *new_info_ptr = cur_ptr;
14817 store_in_ref_table (die, reader->cu);
14820 die->child = read_die_and_siblings_1 (reader, cur_ptr, new_info_ptr, die);
14824 *new_info_ptr = cur_ptr;
14827 die->sibling = NULL;
14828 die->parent = parent;
14832 /* Read a die, all of its descendents, and all of its siblings; set
14833 all of the fields of all of the dies correctly. Arguments are as
14834 in read_die_and_children. */
14836 static struct die_info *
14837 read_die_and_siblings_1 (const struct die_reader_specs *reader,
14838 const gdb_byte *info_ptr,
14839 const gdb_byte **new_info_ptr,
14840 struct die_info *parent)
14842 struct die_info *first_die, *last_sibling;
14843 const gdb_byte *cur_ptr;
14845 cur_ptr = info_ptr;
14846 first_die = last_sibling = NULL;
14850 struct die_info *die
14851 = read_die_and_children (reader, cur_ptr, &cur_ptr, parent);
14855 *new_info_ptr = cur_ptr;
14862 last_sibling->sibling = die;
14864 last_sibling = die;
14868 /* Read a die, all of its descendents, and all of its siblings; set
14869 all of the fields of all of the dies correctly. Arguments are as
14870 in read_die_and_children.
14871 This the main entry point for reading a DIE and all its children. */
14873 static struct die_info *
14874 read_die_and_siblings (const struct die_reader_specs *reader,
14875 const gdb_byte *info_ptr,
14876 const gdb_byte **new_info_ptr,
14877 struct die_info *parent)
14879 struct die_info *die = read_die_and_siblings_1 (reader, info_ptr,
14880 new_info_ptr, parent);
14882 if (dwarf2_die_debug)
14884 fprintf_unfiltered (gdb_stdlog,
14885 "Read die from %s@0x%x of %s:\n",
14886 get_section_name (reader->die_section),
14887 (unsigned) (info_ptr - reader->die_section->buffer),
14888 bfd_get_filename (reader->abfd));
14889 dump_die (die, dwarf2_die_debug);
14895 /* Read a die and all its attributes, leave space for NUM_EXTRA_ATTRS
14897 The caller is responsible for filling in the extra attributes
14898 and updating (*DIEP)->num_attrs.
14899 Set DIEP to point to a newly allocated die with its information,
14900 except for its child, sibling, and parent fields.
14901 Set HAS_CHILDREN to tell whether the die has children or not. */
14903 static const gdb_byte *
14904 read_full_die_1 (const struct die_reader_specs *reader,
14905 struct die_info **diep, const gdb_byte *info_ptr,
14906 int *has_children, int num_extra_attrs)
14908 unsigned int abbrev_number, bytes_read, i;
14909 sect_offset offset;
14910 struct abbrev_info *abbrev;
14911 struct die_info *die;
14912 struct dwarf2_cu *cu = reader->cu;
14913 bfd *abfd = reader->abfd;
14915 offset.sect_off = info_ptr - reader->buffer;
14916 abbrev_number = read_unsigned_leb128 (abfd, info_ptr, &bytes_read);
14917 info_ptr += bytes_read;
14918 if (!abbrev_number)
14925 abbrev = abbrev_table_lookup_abbrev (cu->abbrev_table, abbrev_number);
14927 error (_("Dwarf Error: could not find abbrev number %d [in module %s]"),
14929 bfd_get_filename (abfd));
14931 die = dwarf_alloc_die (cu, abbrev->num_attrs + num_extra_attrs);
14932 die->offset = offset;
14933 die->tag = abbrev->tag;
14934 die->abbrev = abbrev_number;
14936 /* Make the result usable.
14937 The caller needs to update num_attrs after adding the extra
14939 die->num_attrs = abbrev->num_attrs;
14941 for (i = 0; i < abbrev->num_attrs; ++i)
14942 info_ptr = read_attribute (reader, &die->attrs[i], &abbrev->attrs[i],
14946 *has_children = abbrev->has_children;
14950 /* Read a die and all its attributes.
14951 Set DIEP to point to a newly allocated die with its information,
14952 except for its child, sibling, and parent fields.
14953 Set HAS_CHILDREN to tell whether the die has children or not. */
14955 static const gdb_byte *
14956 read_full_die (const struct die_reader_specs *reader,
14957 struct die_info **diep, const gdb_byte *info_ptr,
14960 const gdb_byte *result;
14962 result = read_full_die_1 (reader, diep, info_ptr, has_children, 0);
14964 if (dwarf2_die_debug)
14966 fprintf_unfiltered (gdb_stdlog,
14967 "Read die from %s@0x%x of %s:\n",
14968 get_section_name (reader->die_section),
14969 (unsigned) (info_ptr - reader->die_section->buffer),
14970 bfd_get_filename (reader->abfd));
14971 dump_die (*diep, dwarf2_die_debug);
14977 /* Abbreviation tables.
14979 In DWARF version 2, the description of the debugging information is
14980 stored in a separate .debug_abbrev section. Before we read any
14981 dies from a section we read in all abbreviations and install them
14982 in a hash table. */
14984 /* Allocate space for a struct abbrev_info object in ABBREV_TABLE. */
14986 static struct abbrev_info *
14987 abbrev_table_alloc_abbrev (struct abbrev_table *abbrev_table)
14989 struct abbrev_info *abbrev;
14991 abbrev = (struct abbrev_info *)
14992 obstack_alloc (&abbrev_table->abbrev_obstack, sizeof (struct abbrev_info));
14993 memset (abbrev, 0, sizeof (struct abbrev_info));
14997 /* Add an abbreviation to the table. */
15000 abbrev_table_add_abbrev (struct abbrev_table *abbrev_table,
15001 unsigned int abbrev_number,
15002 struct abbrev_info *abbrev)
15004 unsigned int hash_number;
15006 hash_number = abbrev_number % ABBREV_HASH_SIZE;
15007 abbrev->next = abbrev_table->abbrevs[hash_number];
15008 abbrev_table->abbrevs[hash_number] = abbrev;
15011 /* Look up an abbrev in the table.
15012 Returns NULL if the abbrev is not found. */
15014 static struct abbrev_info *
15015 abbrev_table_lookup_abbrev (const struct abbrev_table *abbrev_table,
15016 unsigned int abbrev_number)
15018 unsigned int hash_number;
15019 struct abbrev_info *abbrev;
15021 hash_number = abbrev_number % ABBREV_HASH_SIZE;
15022 abbrev = abbrev_table->abbrevs[hash_number];
15026 if (abbrev->number == abbrev_number)
15028 abbrev = abbrev->next;
15033 /* Read in an abbrev table. */
15035 static struct abbrev_table *
15036 abbrev_table_read_table (struct dwarf2_section_info *section,
15037 sect_offset offset)
15039 struct objfile *objfile = dwarf2_per_objfile->objfile;
15040 bfd *abfd = get_section_bfd_owner (section);
15041 struct abbrev_table *abbrev_table;
15042 const gdb_byte *abbrev_ptr;
15043 struct abbrev_info *cur_abbrev;
15044 unsigned int abbrev_number, bytes_read, abbrev_name;
15045 unsigned int abbrev_form;
15046 struct attr_abbrev *cur_attrs;
15047 unsigned int allocated_attrs;
15049 abbrev_table = XNEW (struct abbrev_table);
15050 abbrev_table->offset = offset;
15051 obstack_init (&abbrev_table->abbrev_obstack);
15052 abbrev_table->abbrevs = obstack_alloc (&abbrev_table->abbrev_obstack,
15054 * sizeof (struct abbrev_info *)));
15055 memset (abbrev_table->abbrevs, 0,
15056 ABBREV_HASH_SIZE * sizeof (struct abbrev_info *));
15058 dwarf2_read_section (objfile, section);
15059 abbrev_ptr = section->buffer + offset.sect_off;
15060 abbrev_number = read_unsigned_leb128 (abfd, abbrev_ptr, &bytes_read);
15061 abbrev_ptr += bytes_read;
15063 allocated_attrs = ATTR_ALLOC_CHUNK;
15064 cur_attrs = xmalloc (allocated_attrs * sizeof (struct attr_abbrev));
15066 /* Loop until we reach an abbrev number of 0. */
15067 while (abbrev_number)
15069 cur_abbrev = abbrev_table_alloc_abbrev (abbrev_table);
15071 /* read in abbrev header */
15072 cur_abbrev->number = abbrev_number;
15073 cur_abbrev->tag = read_unsigned_leb128 (abfd, abbrev_ptr, &bytes_read);
15074 abbrev_ptr += bytes_read;
15075 cur_abbrev->has_children = read_1_byte (abfd, abbrev_ptr);
15078 /* now read in declarations */
15079 abbrev_name = read_unsigned_leb128 (abfd, abbrev_ptr, &bytes_read);
15080 abbrev_ptr += bytes_read;
15081 abbrev_form = read_unsigned_leb128 (abfd, abbrev_ptr, &bytes_read);
15082 abbrev_ptr += bytes_read;
15083 while (abbrev_name)
15085 if (cur_abbrev->num_attrs == allocated_attrs)
15087 allocated_attrs += ATTR_ALLOC_CHUNK;
15089 = xrealloc (cur_attrs, (allocated_attrs
15090 * sizeof (struct attr_abbrev)));
15093 cur_attrs[cur_abbrev->num_attrs].name = abbrev_name;
15094 cur_attrs[cur_abbrev->num_attrs++].form = abbrev_form;
15095 abbrev_name = read_unsigned_leb128 (abfd, abbrev_ptr, &bytes_read);
15096 abbrev_ptr += bytes_read;
15097 abbrev_form = read_unsigned_leb128 (abfd, abbrev_ptr, &bytes_read);
15098 abbrev_ptr += bytes_read;
15101 cur_abbrev->attrs = obstack_alloc (&abbrev_table->abbrev_obstack,
15102 (cur_abbrev->num_attrs
15103 * sizeof (struct attr_abbrev)));
15104 memcpy (cur_abbrev->attrs, cur_attrs,
15105 cur_abbrev->num_attrs * sizeof (struct attr_abbrev));
15107 abbrev_table_add_abbrev (abbrev_table, abbrev_number, cur_abbrev);
15109 /* Get next abbreviation.
15110 Under Irix6 the abbreviations for a compilation unit are not
15111 always properly terminated with an abbrev number of 0.
15112 Exit loop if we encounter an abbreviation which we have
15113 already read (which means we are about to read the abbreviations
15114 for the next compile unit) or if the end of the abbreviation
15115 table is reached. */
15116 if ((unsigned int) (abbrev_ptr - section->buffer) >= section->size)
15118 abbrev_number = read_unsigned_leb128 (abfd, abbrev_ptr, &bytes_read);
15119 abbrev_ptr += bytes_read;
15120 if (abbrev_table_lookup_abbrev (abbrev_table, abbrev_number) != NULL)
15125 return abbrev_table;
15128 /* Free the resources held by ABBREV_TABLE. */
15131 abbrev_table_free (struct abbrev_table *abbrev_table)
15133 obstack_free (&abbrev_table->abbrev_obstack, NULL);
15134 xfree (abbrev_table);
15137 /* Same as abbrev_table_free but as a cleanup.
15138 We pass in a pointer to the pointer to the table so that we can
15139 set the pointer to NULL when we're done. It also simplifies
15140 build_type_psymtabs_1. */
15143 abbrev_table_free_cleanup (void *table_ptr)
15145 struct abbrev_table **abbrev_table_ptr = table_ptr;
15147 if (*abbrev_table_ptr != NULL)
15148 abbrev_table_free (*abbrev_table_ptr);
15149 *abbrev_table_ptr = NULL;
15152 /* Read the abbrev table for CU from ABBREV_SECTION. */
15155 dwarf2_read_abbrevs (struct dwarf2_cu *cu,
15156 struct dwarf2_section_info *abbrev_section)
15159 abbrev_table_read_table (abbrev_section, cu->header.abbrev_offset);
15162 /* Release the memory used by the abbrev table for a compilation unit. */
15165 dwarf2_free_abbrev_table (void *ptr_to_cu)
15167 struct dwarf2_cu *cu = ptr_to_cu;
15169 if (cu->abbrev_table != NULL)
15170 abbrev_table_free (cu->abbrev_table);
15171 /* Set this to NULL so that we SEGV if we try to read it later,
15172 and also because free_comp_unit verifies this is NULL. */
15173 cu->abbrev_table = NULL;
15176 /* Returns nonzero if TAG represents a type that we might generate a partial
15180 is_type_tag_for_partial (int tag)
15185 /* Some types that would be reasonable to generate partial symbols for,
15186 that we don't at present. */
15187 case DW_TAG_array_type:
15188 case DW_TAG_file_type:
15189 case DW_TAG_ptr_to_member_type:
15190 case DW_TAG_set_type:
15191 case DW_TAG_string_type:
15192 case DW_TAG_subroutine_type:
15194 case DW_TAG_base_type:
15195 case DW_TAG_class_type:
15196 case DW_TAG_interface_type:
15197 case DW_TAG_enumeration_type:
15198 case DW_TAG_structure_type:
15199 case DW_TAG_subrange_type:
15200 case DW_TAG_typedef:
15201 case DW_TAG_union_type:
15208 /* Load all DIEs that are interesting for partial symbols into memory. */
15210 static struct partial_die_info *
15211 load_partial_dies (const struct die_reader_specs *reader,
15212 const gdb_byte *info_ptr, int building_psymtab)
15214 struct dwarf2_cu *cu = reader->cu;
15215 struct objfile *objfile = cu->objfile;
15216 struct partial_die_info *part_die;
15217 struct partial_die_info *parent_die, *last_die, *first_die = NULL;
15218 struct abbrev_info *abbrev;
15219 unsigned int bytes_read;
15220 unsigned int load_all = 0;
15221 int nesting_level = 1;
15226 gdb_assert (cu->per_cu != NULL);
15227 if (cu->per_cu->load_all_dies)
15231 = htab_create_alloc_ex (cu->header.length / 12,
15235 &cu->comp_unit_obstack,
15236 hashtab_obstack_allocate,
15237 dummy_obstack_deallocate);
15239 part_die = obstack_alloc (&cu->comp_unit_obstack,
15240 sizeof (struct partial_die_info));
15244 abbrev = peek_die_abbrev (info_ptr, &bytes_read, cu);
15246 /* A NULL abbrev means the end of a series of children. */
15247 if (abbrev == NULL)
15249 if (--nesting_level == 0)
15251 /* PART_DIE was probably the last thing allocated on the
15252 comp_unit_obstack, so we could call obstack_free
15253 here. We don't do that because the waste is small,
15254 and will be cleaned up when we're done with this
15255 compilation unit. This way, we're also more robust
15256 against other users of the comp_unit_obstack. */
15259 info_ptr += bytes_read;
15260 last_die = parent_die;
15261 parent_die = parent_die->die_parent;
15265 /* Check for template arguments. We never save these; if
15266 they're seen, we just mark the parent, and go on our way. */
15267 if (parent_die != NULL
15268 && cu->language == language_cplus
15269 && (abbrev->tag == DW_TAG_template_type_param
15270 || abbrev->tag == DW_TAG_template_value_param))
15272 parent_die->has_template_arguments = 1;
15276 /* We don't need a partial DIE for the template argument. */
15277 info_ptr = skip_one_die (reader, info_ptr + bytes_read, abbrev);
15282 /* We only recurse into c++ subprograms looking for template arguments.
15283 Skip their other children. */
15285 && cu->language == language_cplus
15286 && parent_die != NULL
15287 && parent_die->tag == DW_TAG_subprogram)
15289 info_ptr = skip_one_die (reader, info_ptr + bytes_read, abbrev);
15293 /* Check whether this DIE is interesting enough to save. Normally
15294 we would not be interested in members here, but there may be
15295 later variables referencing them via DW_AT_specification (for
15296 static members). */
15298 && !is_type_tag_for_partial (abbrev->tag)
15299 && abbrev->tag != DW_TAG_constant
15300 && abbrev->tag != DW_TAG_enumerator
15301 && abbrev->tag != DW_TAG_subprogram
15302 && abbrev->tag != DW_TAG_lexical_block
15303 && abbrev->tag != DW_TAG_variable
15304 && abbrev->tag != DW_TAG_namespace
15305 && abbrev->tag != DW_TAG_module
15306 && abbrev->tag != DW_TAG_member
15307 && abbrev->tag != DW_TAG_imported_unit
15308 && abbrev->tag != DW_TAG_imported_declaration)
15310 /* Otherwise we skip to the next sibling, if any. */
15311 info_ptr = skip_one_die (reader, info_ptr + bytes_read, abbrev);
15315 info_ptr = read_partial_die (reader, part_die, abbrev, bytes_read,
15318 /* This two-pass algorithm for processing partial symbols has a
15319 high cost in cache pressure. Thus, handle some simple cases
15320 here which cover the majority of C partial symbols. DIEs
15321 which neither have specification tags in them, nor could have
15322 specification tags elsewhere pointing at them, can simply be
15323 processed and discarded.
15325 This segment is also optional; scan_partial_symbols and
15326 add_partial_symbol will handle these DIEs if we chain
15327 them in normally. When compilers which do not emit large
15328 quantities of duplicate debug information are more common,
15329 this code can probably be removed. */
15331 /* Any complete simple types at the top level (pretty much all
15332 of them, for a language without namespaces), can be processed
15334 if (parent_die == NULL
15335 && part_die->has_specification == 0
15336 && part_die->is_declaration == 0
15337 && ((part_die->tag == DW_TAG_typedef && !part_die->has_children)
15338 || part_die->tag == DW_TAG_base_type
15339 || part_die->tag == DW_TAG_subrange_type))
15341 if (building_psymtab && part_die->name != NULL)
15342 add_psymbol_to_list (part_die->name, strlen (part_die->name), 0,
15343 VAR_DOMAIN, LOC_TYPEDEF,
15344 &objfile->static_psymbols,
15345 0, (CORE_ADDR) 0, cu->language, objfile);
15346 info_ptr = locate_pdi_sibling (reader, part_die, info_ptr);
15350 /* The exception for DW_TAG_typedef with has_children above is
15351 a workaround of GCC PR debug/47510. In the case of this complaint
15352 type_name_no_tag_or_error will error on such types later.
15354 GDB skipped children of DW_TAG_typedef by the shortcut above and then
15355 it could not find the child DIEs referenced later, this is checked
15356 above. In correct DWARF DW_TAG_typedef should have no children. */
15358 if (part_die->tag == DW_TAG_typedef && part_die->has_children)
15359 complaint (&symfile_complaints,
15360 _("DW_TAG_typedef has childen - GCC PR debug/47510 bug "
15361 "- DIE at 0x%x [in module %s]"),
15362 part_die->offset.sect_off, objfile_name (objfile));
15364 /* If we're at the second level, and we're an enumerator, and
15365 our parent has no specification (meaning possibly lives in a
15366 namespace elsewhere), then we can add the partial symbol now
15367 instead of queueing it. */
15368 if (part_die->tag == DW_TAG_enumerator
15369 && parent_die != NULL
15370 && parent_die->die_parent == NULL
15371 && parent_die->tag == DW_TAG_enumeration_type
15372 && parent_die->has_specification == 0)
15374 if (part_die->name == NULL)
15375 complaint (&symfile_complaints,
15376 _("malformed enumerator DIE ignored"));
15377 else if (building_psymtab)
15378 add_psymbol_to_list (part_die->name, strlen (part_die->name), 0,
15379 VAR_DOMAIN, LOC_CONST,
15380 (cu->language == language_cplus
15381 || cu->language == language_java)
15382 ? &objfile->global_psymbols
15383 : &objfile->static_psymbols,
15384 0, (CORE_ADDR) 0, cu->language, objfile);
15386 info_ptr = locate_pdi_sibling (reader, part_die, info_ptr);
15390 /* We'll save this DIE so link it in. */
15391 part_die->die_parent = parent_die;
15392 part_die->die_sibling = NULL;
15393 part_die->die_child = NULL;
15395 if (last_die && last_die == parent_die)
15396 last_die->die_child = part_die;
15398 last_die->die_sibling = part_die;
15400 last_die = part_die;
15402 if (first_die == NULL)
15403 first_die = part_die;
15405 /* Maybe add the DIE to the hash table. Not all DIEs that we
15406 find interesting need to be in the hash table, because we
15407 also have the parent/sibling/child chains; only those that we
15408 might refer to by offset later during partial symbol reading.
15410 For now this means things that might have be the target of a
15411 DW_AT_specification, DW_AT_abstract_origin, or
15412 DW_AT_extension. DW_AT_extension will refer only to
15413 namespaces; DW_AT_abstract_origin refers to functions (and
15414 many things under the function DIE, but we do not recurse
15415 into function DIEs during partial symbol reading) and
15416 possibly variables as well; DW_AT_specification refers to
15417 declarations. Declarations ought to have the DW_AT_declaration
15418 flag. It happens that GCC forgets to put it in sometimes, but
15419 only for functions, not for types.
15421 Adding more things than necessary to the hash table is harmless
15422 except for the performance cost. Adding too few will result in
15423 wasted time in find_partial_die, when we reread the compilation
15424 unit with load_all_dies set. */
15427 || abbrev->tag == DW_TAG_constant
15428 || abbrev->tag == DW_TAG_subprogram
15429 || abbrev->tag == DW_TAG_variable
15430 || abbrev->tag == DW_TAG_namespace
15431 || part_die->is_declaration)
15435 slot = htab_find_slot_with_hash (cu->partial_dies, part_die,
15436 part_die->offset.sect_off, INSERT);
15440 part_die = obstack_alloc (&cu->comp_unit_obstack,
15441 sizeof (struct partial_die_info));
15443 /* For some DIEs we want to follow their children (if any). For C
15444 we have no reason to follow the children of structures; for other
15445 languages we have to, so that we can get at method physnames
15446 to infer fully qualified class names, for DW_AT_specification,
15447 and for C++ template arguments. For C++, we also look one level
15448 inside functions to find template arguments (if the name of the
15449 function does not already contain the template arguments).
15451 For Ada, we need to scan the children of subprograms and lexical
15452 blocks as well because Ada allows the definition of nested
15453 entities that could be interesting for the debugger, such as
15454 nested subprograms for instance. */
15455 if (last_die->has_children
15457 || last_die->tag == DW_TAG_namespace
15458 || last_die->tag == DW_TAG_module
15459 || last_die->tag == DW_TAG_enumeration_type
15460 || (cu->language == language_cplus
15461 && last_die->tag == DW_TAG_subprogram
15462 && (last_die->name == NULL
15463 || strchr (last_die->name, '<') == NULL))
15464 || (cu->language != language_c
15465 && (last_die->tag == DW_TAG_class_type
15466 || last_die->tag == DW_TAG_interface_type
15467 || last_die->tag == DW_TAG_structure_type
15468 || last_die->tag == DW_TAG_union_type))
15469 || (cu->language == language_ada
15470 && (last_die->tag == DW_TAG_subprogram
15471 || last_die->tag == DW_TAG_lexical_block))))
15474 parent_die = last_die;
15478 /* Otherwise we skip to the next sibling, if any. */
15479 info_ptr = locate_pdi_sibling (reader, last_die, info_ptr);
15481 /* Back to the top, do it again. */
15485 /* Read a minimal amount of information into the minimal die structure. */
15487 static const gdb_byte *
15488 read_partial_die (const struct die_reader_specs *reader,
15489 struct partial_die_info *part_die,
15490 struct abbrev_info *abbrev, unsigned int abbrev_len,
15491 const gdb_byte *info_ptr)
15493 struct dwarf2_cu *cu = reader->cu;
15494 struct objfile *objfile = cu->objfile;
15495 const gdb_byte *buffer = reader->buffer;
15497 struct attribute attr;
15498 int has_low_pc_attr = 0;
15499 int has_high_pc_attr = 0;
15500 int high_pc_relative = 0;
15502 memset (part_die, 0, sizeof (struct partial_die_info));
15504 part_die->offset.sect_off = info_ptr - buffer;
15506 info_ptr += abbrev_len;
15508 if (abbrev == NULL)
15511 part_die->tag = abbrev->tag;
15512 part_die->has_children = abbrev->has_children;
15514 for (i = 0; i < abbrev->num_attrs; ++i)
15516 info_ptr = read_attribute (reader, &attr, &abbrev->attrs[i], info_ptr);
15518 /* Store the data if it is of an attribute we want to keep in a
15519 partial symbol table. */
15523 switch (part_die->tag)
15525 case DW_TAG_compile_unit:
15526 case DW_TAG_partial_unit:
15527 case DW_TAG_type_unit:
15528 /* Compilation units have a DW_AT_name that is a filename, not
15529 a source language identifier. */
15530 case DW_TAG_enumeration_type:
15531 case DW_TAG_enumerator:
15532 /* These tags always have simple identifiers already; no need
15533 to canonicalize them. */
15534 part_die->name = DW_STRING (&attr);
15538 = dwarf2_canonicalize_name (DW_STRING (&attr), cu,
15539 &objfile->per_bfd->storage_obstack);
15543 case DW_AT_linkage_name:
15544 case DW_AT_MIPS_linkage_name:
15545 /* Note that both forms of linkage name might appear. We
15546 assume they will be the same, and we only store the last
15548 if (cu->language == language_ada)
15549 part_die->name = DW_STRING (&attr);
15550 part_die->linkage_name = DW_STRING (&attr);
15553 has_low_pc_attr = 1;
15554 part_die->lowpc = attr_value_as_address (&attr);
15556 case DW_AT_high_pc:
15557 has_high_pc_attr = 1;
15558 part_die->highpc = attr_value_as_address (&attr);
15559 if (cu->header.version >= 4 && attr_form_is_constant (&attr))
15560 high_pc_relative = 1;
15562 case DW_AT_location:
15563 /* Support the .debug_loc offsets. */
15564 if (attr_form_is_block (&attr))
15566 part_die->d.locdesc = DW_BLOCK (&attr);
15568 else if (attr_form_is_section_offset (&attr))
15570 dwarf2_complex_location_expr_complaint ();
15574 dwarf2_invalid_attrib_class_complaint ("DW_AT_location",
15575 "partial symbol information");
15578 case DW_AT_external:
15579 part_die->is_external = DW_UNSND (&attr);
15581 case DW_AT_declaration:
15582 part_die->is_declaration = DW_UNSND (&attr);
15585 part_die->has_type = 1;
15587 case DW_AT_abstract_origin:
15588 case DW_AT_specification:
15589 case DW_AT_extension:
15590 part_die->has_specification = 1;
15591 part_die->spec_offset = dwarf2_get_ref_die_offset (&attr);
15592 part_die->spec_is_dwz = (attr.form == DW_FORM_GNU_ref_alt
15593 || cu->per_cu->is_dwz);
15595 case DW_AT_sibling:
15596 /* Ignore absolute siblings, they might point outside of
15597 the current compile unit. */
15598 if (attr.form == DW_FORM_ref_addr)
15599 complaint (&symfile_complaints,
15600 _("ignoring absolute DW_AT_sibling"));
15603 unsigned int off = dwarf2_get_ref_die_offset (&attr).sect_off;
15604 const gdb_byte *sibling_ptr = buffer + off;
15606 if (sibling_ptr < info_ptr)
15607 complaint (&symfile_complaints,
15608 _("DW_AT_sibling points backwards"));
15609 else if (sibling_ptr > reader->buffer_end)
15610 dwarf2_section_buffer_overflow_complaint (reader->die_section);
15612 part_die->sibling = sibling_ptr;
15615 case DW_AT_byte_size:
15616 part_die->has_byte_size = 1;
15618 case DW_AT_calling_convention:
15619 /* DWARF doesn't provide a way to identify a program's source-level
15620 entry point. DW_AT_calling_convention attributes are only meant
15621 to describe functions' calling conventions.
15623 However, because it's a necessary piece of information in
15624 Fortran, and because DW_CC_program is the only piece of debugging
15625 information whose definition refers to a 'main program' at all,
15626 several compilers have begun marking Fortran main programs with
15627 DW_CC_program --- even when those functions use the standard
15628 calling conventions.
15630 So until DWARF specifies a way to provide this information and
15631 compilers pick up the new representation, we'll support this
15633 if (DW_UNSND (&attr) == DW_CC_program
15634 && cu->language == language_fortran)
15635 set_objfile_main_name (objfile, part_die->name, language_fortran);
15638 if (DW_UNSND (&attr) == DW_INL_inlined
15639 || DW_UNSND (&attr) == DW_INL_declared_inlined)
15640 part_die->may_be_inlined = 1;
15644 if (part_die->tag == DW_TAG_imported_unit)
15646 part_die->d.offset = dwarf2_get_ref_die_offset (&attr);
15647 part_die->is_dwz = (attr.form == DW_FORM_GNU_ref_alt
15648 || cu->per_cu->is_dwz);
15657 if (high_pc_relative)
15658 part_die->highpc += part_die->lowpc;
15660 if (has_low_pc_attr && has_high_pc_attr)
15662 /* When using the GNU linker, .gnu.linkonce. sections are used to
15663 eliminate duplicate copies of functions and vtables and such.
15664 The linker will arbitrarily choose one and discard the others.
15665 The AT_*_pc values for such functions refer to local labels in
15666 these sections. If the section from that file was discarded, the
15667 labels are not in the output, so the relocs get a value of 0.
15668 If this is a discarded function, mark the pc bounds as invalid,
15669 so that GDB will ignore it. */
15670 if (part_die->lowpc == 0 && !dwarf2_per_objfile->has_section_at_zero)
15672 struct gdbarch *gdbarch = get_objfile_arch (objfile);
15674 complaint (&symfile_complaints,
15675 _("DW_AT_low_pc %s is zero "
15676 "for DIE at 0x%x [in module %s]"),
15677 paddress (gdbarch, part_die->lowpc),
15678 part_die->offset.sect_off, objfile_name (objfile));
15680 /* dwarf2_get_pc_bounds has also the strict low < high requirement. */
15681 else if (part_die->lowpc >= part_die->highpc)
15683 struct gdbarch *gdbarch = get_objfile_arch (objfile);
15685 complaint (&symfile_complaints,
15686 _("DW_AT_low_pc %s is not < DW_AT_high_pc %s "
15687 "for DIE at 0x%x [in module %s]"),
15688 paddress (gdbarch, part_die->lowpc),
15689 paddress (gdbarch, part_die->highpc),
15690 part_die->offset.sect_off, objfile_name (objfile));
15693 part_die->has_pc_info = 1;
15699 /* Find a cached partial DIE at OFFSET in CU. */
15701 static struct partial_die_info *
15702 find_partial_die_in_comp_unit (sect_offset offset, struct dwarf2_cu *cu)
15704 struct partial_die_info *lookup_die = NULL;
15705 struct partial_die_info part_die;
15707 part_die.offset = offset;
15708 lookup_die = htab_find_with_hash (cu->partial_dies, &part_die,
15714 /* Find a partial DIE at OFFSET, which may or may not be in CU,
15715 except in the case of .debug_types DIEs which do not reference
15716 outside their CU (they do however referencing other types via
15717 DW_FORM_ref_sig8). */
15719 static struct partial_die_info *
15720 find_partial_die (sect_offset offset, int offset_in_dwz, struct dwarf2_cu *cu)
15722 struct objfile *objfile = cu->objfile;
15723 struct dwarf2_per_cu_data *per_cu = NULL;
15724 struct partial_die_info *pd = NULL;
15726 if (offset_in_dwz == cu->per_cu->is_dwz
15727 && offset_in_cu_p (&cu->header, offset))
15729 pd = find_partial_die_in_comp_unit (offset, cu);
15732 /* We missed recording what we needed.
15733 Load all dies and try again. */
15734 per_cu = cu->per_cu;
15738 /* TUs don't reference other CUs/TUs (except via type signatures). */
15739 if (cu->per_cu->is_debug_types)
15741 error (_("Dwarf Error: Type Unit at offset 0x%lx contains"
15742 " external reference to offset 0x%lx [in module %s].\n"),
15743 (long) cu->header.offset.sect_off, (long) offset.sect_off,
15744 bfd_get_filename (objfile->obfd));
15746 per_cu = dwarf2_find_containing_comp_unit (offset, offset_in_dwz,
15749 if (per_cu->cu == NULL || per_cu->cu->partial_dies == NULL)
15750 load_partial_comp_unit (per_cu);
15752 per_cu->cu->last_used = 0;
15753 pd = find_partial_die_in_comp_unit (offset, per_cu->cu);
15756 /* If we didn't find it, and not all dies have been loaded,
15757 load them all and try again. */
15759 if (pd == NULL && per_cu->load_all_dies == 0)
15761 per_cu->load_all_dies = 1;
15763 /* This is nasty. When we reread the DIEs, somewhere up the call chain
15764 THIS_CU->cu may already be in use. So we can't just free it and
15765 replace its DIEs with the ones we read in. Instead, we leave those
15766 DIEs alone (which can still be in use, e.g. in scan_partial_symbols),
15767 and clobber THIS_CU->cu->partial_dies with the hash table for the new
15769 load_partial_comp_unit (per_cu);
15771 pd = find_partial_die_in_comp_unit (offset, per_cu->cu);
15775 internal_error (__FILE__, __LINE__,
15776 _("could not find partial DIE 0x%x "
15777 "in cache [from module %s]\n"),
15778 offset.sect_off, bfd_get_filename (objfile->obfd));
15782 /* See if we can figure out if the class lives in a namespace. We do
15783 this by looking for a member function; its demangled name will
15784 contain namespace info, if there is any. */
15787 guess_partial_die_structure_name (struct partial_die_info *struct_pdi,
15788 struct dwarf2_cu *cu)
15790 /* NOTE: carlton/2003-10-07: Getting the info this way changes
15791 what template types look like, because the demangler
15792 frequently doesn't give the same name as the debug info. We
15793 could fix this by only using the demangled name to get the
15794 prefix (but see comment in read_structure_type). */
15796 struct partial_die_info *real_pdi;
15797 struct partial_die_info *child_pdi;
15799 /* If this DIE (this DIE's specification, if any) has a parent, then
15800 we should not do this. We'll prepend the parent's fully qualified
15801 name when we create the partial symbol. */
15803 real_pdi = struct_pdi;
15804 while (real_pdi->has_specification)
15805 real_pdi = find_partial_die (real_pdi->spec_offset,
15806 real_pdi->spec_is_dwz, cu);
15808 if (real_pdi->die_parent != NULL)
15811 for (child_pdi = struct_pdi->die_child;
15813 child_pdi = child_pdi->die_sibling)
15815 if (child_pdi->tag == DW_TAG_subprogram
15816 && child_pdi->linkage_name != NULL)
15818 char *actual_class_name
15819 = language_class_name_from_physname (cu->language_defn,
15820 child_pdi->linkage_name);
15821 if (actual_class_name != NULL)
15824 = obstack_copy0 (&cu->objfile->per_bfd->storage_obstack,
15826 strlen (actual_class_name));
15827 xfree (actual_class_name);
15834 /* Adjust PART_DIE before generating a symbol for it. This function
15835 may set the is_external flag or change the DIE's name. */
15838 fixup_partial_die (struct partial_die_info *part_die,
15839 struct dwarf2_cu *cu)
15841 /* Once we've fixed up a die, there's no point in doing so again.
15842 This also avoids a memory leak if we were to call
15843 guess_partial_die_structure_name multiple times. */
15844 if (part_die->fixup_called)
15847 /* If we found a reference attribute and the DIE has no name, try
15848 to find a name in the referred to DIE. */
15850 if (part_die->name == NULL && part_die->has_specification)
15852 struct partial_die_info *spec_die;
15854 spec_die = find_partial_die (part_die->spec_offset,
15855 part_die->spec_is_dwz, cu);
15857 fixup_partial_die (spec_die, cu);
15859 if (spec_die->name)
15861 part_die->name = spec_die->name;
15863 /* Copy DW_AT_external attribute if it is set. */
15864 if (spec_die->is_external)
15865 part_die->is_external = spec_die->is_external;
15869 /* Set default names for some unnamed DIEs. */
15871 if (part_die->name == NULL && part_die->tag == DW_TAG_namespace)
15872 part_die->name = CP_ANONYMOUS_NAMESPACE_STR;
15874 /* If there is no parent die to provide a namespace, and there are
15875 children, see if we can determine the namespace from their linkage
15877 if (cu->language == language_cplus
15878 && !VEC_empty (dwarf2_section_info_def, dwarf2_per_objfile->types)
15879 && part_die->die_parent == NULL
15880 && part_die->has_children
15881 && (part_die->tag == DW_TAG_class_type
15882 || part_die->tag == DW_TAG_structure_type
15883 || part_die->tag == DW_TAG_union_type))
15884 guess_partial_die_structure_name (part_die, cu);
15886 /* GCC might emit a nameless struct or union that has a linkage
15887 name. See http://gcc.gnu.org/bugzilla/show_bug.cgi?id=47510. */
15888 if (part_die->name == NULL
15889 && (part_die->tag == DW_TAG_class_type
15890 || part_die->tag == DW_TAG_interface_type
15891 || part_die->tag == DW_TAG_structure_type
15892 || part_die->tag == DW_TAG_union_type)
15893 && part_die->linkage_name != NULL)
15897 demangled = gdb_demangle (part_die->linkage_name, DMGL_TYPES);
15902 /* Strip any leading namespaces/classes, keep only the base name.
15903 DW_AT_name for named DIEs does not contain the prefixes. */
15904 base = strrchr (demangled, ':');
15905 if (base && base > demangled && base[-1] == ':')
15911 = obstack_copy0 (&cu->objfile->per_bfd->storage_obstack,
15912 base, strlen (base));
15917 part_die->fixup_called = 1;
15920 /* Read an attribute value described by an attribute form. */
15922 static const gdb_byte *
15923 read_attribute_value (const struct die_reader_specs *reader,
15924 struct attribute *attr, unsigned form,
15925 const gdb_byte *info_ptr)
15927 struct dwarf2_cu *cu = reader->cu;
15928 bfd *abfd = reader->abfd;
15929 struct comp_unit_head *cu_header = &cu->header;
15930 unsigned int bytes_read;
15931 struct dwarf_block *blk;
15936 case DW_FORM_ref_addr:
15937 if (cu->header.version == 2)
15938 DW_UNSND (attr) = read_address (abfd, info_ptr, cu, &bytes_read);
15940 DW_UNSND (attr) = read_offset (abfd, info_ptr,
15941 &cu->header, &bytes_read);
15942 info_ptr += bytes_read;
15944 case DW_FORM_GNU_ref_alt:
15945 DW_UNSND (attr) = read_offset (abfd, info_ptr, &cu->header, &bytes_read);
15946 info_ptr += bytes_read;
15949 DW_ADDR (attr) = read_address (abfd, info_ptr, cu, &bytes_read);
15950 info_ptr += bytes_read;
15952 case DW_FORM_block2:
15953 blk = dwarf_alloc_block (cu);
15954 blk->size = read_2_bytes (abfd, info_ptr);
15956 blk->data = read_n_bytes (abfd, info_ptr, blk->size);
15957 info_ptr += blk->size;
15958 DW_BLOCK (attr) = blk;
15960 case DW_FORM_block4:
15961 blk = dwarf_alloc_block (cu);
15962 blk->size = read_4_bytes (abfd, info_ptr);
15964 blk->data = read_n_bytes (abfd, info_ptr, blk->size);
15965 info_ptr += blk->size;
15966 DW_BLOCK (attr) = blk;
15968 case DW_FORM_data2:
15969 DW_UNSND (attr) = read_2_bytes (abfd, info_ptr);
15972 case DW_FORM_data4:
15973 DW_UNSND (attr) = read_4_bytes (abfd, info_ptr);
15976 case DW_FORM_data8:
15977 DW_UNSND (attr) = read_8_bytes (abfd, info_ptr);
15980 case DW_FORM_sec_offset:
15981 DW_UNSND (attr) = read_offset (abfd, info_ptr, &cu->header, &bytes_read);
15982 info_ptr += bytes_read;
15984 case DW_FORM_string:
15985 DW_STRING (attr) = read_direct_string (abfd, info_ptr, &bytes_read);
15986 DW_STRING_IS_CANONICAL (attr) = 0;
15987 info_ptr += bytes_read;
15990 if (!cu->per_cu->is_dwz)
15992 DW_STRING (attr) = read_indirect_string (abfd, info_ptr, cu_header,
15994 DW_STRING_IS_CANONICAL (attr) = 0;
15995 info_ptr += bytes_read;
15999 case DW_FORM_GNU_strp_alt:
16001 struct dwz_file *dwz = dwarf2_get_dwz_file ();
16002 LONGEST str_offset = read_offset (abfd, info_ptr, cu_header,
16005 DW_STRING (attr) = read_indirect_string_from_dwz (dwz, str_offset);
16006 DW_STRING_IS_CANONICAL (attr) = 0;
16007 info_ptr += bytes_read;
16010 case DW_FORM_exprloc:
16011 case DW_FORM_block:
16012 blk = dwarf_alloc_block (cu);
16013 blk->size = read_unsigned_leb128 (abfd, info_ptr, &bytes_read);
16014 info_ptr += bytes_read;
16015 blk->data = read_n_bytes (abfd, info_ptr, blk->size);
16016 info_ptr += blk->size;
16017 DW_BLOCK (attr) = blk;
16019 case DW_FORM_block1:
16020 blk = dwarf_alloc_block (cu);
16021 blk->size = read_1_byte (abfd, info_ptr);
16023 blk->data = read_n_bytes (abfd, info_ptr, blk->size);
16024 info_ptr += blk->size;
16025 DW_BLOCK (attr) = blk;
16027 case DW_FORM_data1:
16028 DW_UNSND (attr) = read_1_byte (abfd, info_ptr);
16032 DW_UNSND (attr) = read_1_byte (abfd, info_ptr);
16035 case DW_FORM_flag_present:
16036 DW_UNSND (attr) = 1;
16038 case DW_FORM_sdata:
16039 DW_SND (attr) = read_signed_leb128 (abfd, info_ptr, &bytes_read);
16040 info_ptr += bytes_read;
16042 case DW_FORM_udata:
16043 DW_UNSND (attr) = read_unsigned_leb128 (abfd, info_ptr, &bytes_read);
16044 info_ptr += bytes_read;
16047 DW_UNSND (attr) = (cu->header.offset.sect_off
16048 + read_1_byte (abfd, info_ptr));
16052 DW_UNSND (attr) = (cu->header.offset.sect_off
16053 + read_2_bytes (abfd, info_ptr));
16057 DW_UNSND (attr) = (cu->header.offset.sect_off
16058 + read_4_bytes (abfd, info_ptr));
16062 DW_UNSND (attr) = (cu->header.offset.sect_off
16063 + read_8_bytes (abfd, info_ptr));
16066 case DW_FORM_ref_sig8:
16067 DW_SIGNATURE (attr) = read_8_bytes (abfd, info_ptr);
16070 case DW_FORM_ref_udata:
16071 DW_UNSND (attr) = (cu->header.offset.sect_off
16072 + read_unsigned_leb128 (abfd, info_ptr, &bytes_read));
16073 info_ptr += bytes_read;
16075 case DW_FORM_indirect:
16076 form = read_unsigned_leb128 (abfd, info_ptr, &bytes_read);
16077 info_ptr += bytes_read;
16078 info_ptr = read_attribute_value (reader, attr, form, info_ptr);
16080 case DW_FORM_GNU_addr_index:
16081 if (reader->dwo_file == NULL)
16083 /* For now flag a hard error.
16084 Later we can turn this into a complaint. */
16085 error (_("Dwarf Error: %s found in non-DWO CU [in module %s]"),
16086 dwarf_form_name (form),
16087 bfd_get_filename (abfd));
16089 DW_ADDR (attr) = read_addr_index_from_leb128 (cu, info_ptr, &bytes_read);
16090 info_ptr += bytes_read;
16092 case DW_FORM_GNU_str_index:
16093 if (reader->dwo_file == NULL)
16095 /* For now flag a hard error.
16096 Later we can turn this into a complaint if warranted. */
16097 error (_("Dwarf Error: %s found in non-DWO CU [in module %s]"),
16098 dwarf_form_name (form),
16099 bfd_get_filename (abfd));
16102 ULONGEST str_index =
16103 read_unsigned_leb128 (abfd, info_ptr, &bytes_read);
16105 DW_STRING (attr) = read_str_index (reader, str_index);
16106 DW_STRING_IS_CANONICAL (attr) = 0;
16107 info_ptr += bytes_read;
16111 error (_("Dwarf Error: Cannot handle %s in DWARF reader [in module %s]"),
16112 dwarf_form_name (form),
16113 bfd_get_filename (abfd));
16117 if (cu->per_cu->is_dwz && attr_form_is_ref (attr))
16118 attr->form = DW_FORM_GNU_ref_alt;
16120 /* We have seen instances where the compiler tried to emit a byte
16121 size attribute of -1 which ended up being encoded as an unsigned
16122 0xffffffff. Although 0xffffffff is technically a valid size value,
16123 an object of this size seems pretty unlikely so we can relatively
16124 safely treat these cases as if the size attribute was invalid and
16125 treat them as zero by default. */
16126 if (attr->name == DW_AT_byte_size
16127 && form == DW_FORM_data4
16128 && DW_UNSND (attr) >= 0xffffffff)
16131 (&symfile_complaints,
16132 _("Suspicious DW_AT_byte_size value treated as zero instead of %s"),
16133 hex_string (DW_UNSND (attr)));
16134 DW_UNSND (attr) = 0;
16140 /* Read an attribute described by an abbreviated attribute. */
16142 static const gdb_byte *
16143 read_attribute (const struct die_reader_specs *reader,
16144 struct attribute *attr, struct attr_abbrev *abbrev,
16145 const gdb_byte *info_ptr)
16147 attr->name = abbrev->name;
16148 return read_attribute_value (reader, attr, abbrev->form, info_ptr);
16151 /* Read dwarf information from a buffer. */
16153 static unsigned int
16154 read_1_byte (bfd *abfd, const gdb_byte *buf)
16156 return bfd_get_8 (abfd, buf);
16160 read_1_signed_byte (bfd *abfd, const gdb_byte *buf)
16162 return bfd_get_signed_8 (abfd, buf);
16165 static unsigned int
16166 read_2_bytes (bfd *abfd, const gdb_byte *buf)
16168 return bfd_get_16 (abfd, buf);
16172 read_2_signed_bytes (bfd *abfd, const gdb_byte *buf)
16174 return bfd_get_signed_16 (abfd, buf);
16177 static unsigned int
16178 read_4_bytes (bfd *abfd, const gdb_byte *buf)
16180 return bfd_get_32 (abfd, buf);
16184 read_4_signed_bytes (bfd *abfd, const gdb_byte *buf)
16186 return bfd_get_signed_32 (abfd, buf);
16190 read_8_bytes (bfd *abfd, const gdb_byte *buf)
16192 return bfd_get_64 (abfd, buf);
16196 read_address (bfd *abfd, const gdb_byte *buf, struct dwarf2_cu *cu,
16197 unsigned int *bytes_read)
16199 struct comp_unit_head *cu_header = &cu->header;
16200 CORE_ADDR retval = 0;
16202 if (cu_header->signed_addr_p)
16204 switch (cu_header->addr_size)
16207 retval = bfd_get_signed_16 (abfd, buf);
16210 retval = bfd_get_signed_32 (abfd, buf);
16213 retval = bfd_get_signed_64 (abfd, buf);
16216 internal_error (__FILE__, __LINE__,
16217 _("read_address: bad switch, signed [in module %s]"),
16218 bfd_get_filename (abfd));
16223 switch (cu_header->addr_size)
16226 retval = bfd_get_16 (abfd, buf);
16229 retval = bfd_get_32 (abfd, buf);
16232 retval = bfd_get_64 (abfd, buf);
16235 internal_error (__FILE__, __LINE__,
16236 _("read_address: bad switch, "
16237 "unsigned [in module %s]"),
16238 bfd_get_filename (abfd));
16242 *bytes_read = cu_header->addr_size;
16246 /* Read the initial length from a section. The (draft) DWARF 3
16247 specification allows the initial length to take up either 4 bytes
16248 or 12 bytes. If the first 4 bytes are 0xffffffff, then the next 8
16249 bytes describe the length and all offsets will be 8 bytes in length
16252 An older, non-standard 64-bit format is also handled by this
16253 function. The older format in question stores the initial length
16254 as an 8-byte quantity without an escape value. Lengths greater
16255 than 2^32 aren't very common which means that the initial 4 bytes
16256 is almost always zero. Since a length value of zero doesn't make
16257 sense for the 32-bit format, this initial zero can be considered to
16258 be an escape value which indicates the presence of the older 64-bit
16259 format. As written, the code can't detect (old format) lengths
16260 greater than 4GB. If it becomes necessary to handle lengths
16261 somewhat larger than 4GB, we could allow other small values (such
16262 as the non-sensical values of 1, 2, and 3) to also be used as
16263 escape values indicating the presence of the old format.
16265 The value returned via bytes_read should be used to increment the
16266 relevant pointer after calling read_initial_length().
16268 [ Note: read_initial_length() and read_offset() are based on the
16269 document entitled "DWARF Debugging Information Format", revision
16270 3, draft 8, dated November 19, 2001. This document was obtained
16273 http://reality.sgiweb.org/davea/dwarf3-draft8-011125.pdf
16275 This document is only a draft and is subject to change. (So beware.)
16277 Details regarding the older, non-standard 64-bit format were
16278 determined empirically by examining 64-bit ELF files produced by
16279 the SGI toolchain on an IRIX 6.5 machine.
16281 - Kevin, July 16, 2002
16285 read_initial_length (bfd *abfd, const gdb_byte *buf, unsigned int *bytes_read)
16287 LONGEST length = bfd_get_32 (abfd, buf);
16289 if (length == 0xffffffff)
16291 length = bfd_get_64 (abfd, buf + 4);
16294 else if (length == 0)
16296 /* Handle the (non-standard) 64-bit DWARF2 format used by IRIX. */
16297 length = bfd_get_64 (abfd, buf);
16308 /* Cover function for read_initial_length.
16309 Returns the length of the object at BUF, and stores the size of the
16310 initial length in *BYTES_READ and stores the size that offsets will be in
16312 If the initial length size is not equivalent to that specified in
16313 CU_HEADER then issue a complaint.
16314 This is useful when reading non-comp-unit headers. */
16317 read_checked_initial_length_and_offset (bfd *abfd, const gdb_byte *buf,
16318 const struct comp_unit_head *cu_header,
16319 unsigned int *bytes_read,
16320 unsigned int *offset_size)
16322 LONGEST length = read_initial_length (abfd, buf, bytes_read);
16324 gdb_assert (cu_header->initial_length_size == 4
16325 || cu_header->initial_length_size == 8
16326 || cu_header->initial_length_size == 12);
16328 if (cu_header->initial_length_size != *bytes_read)
16329 complaint (&symfile_complaints,
16330 _("intermixed 32-bit and 64-bit DWARF sections"));
16332 *offset_size = (*bytes_read == 4) ? 4 : 8;
16336 /* Read an offset from the data stream. The size of the offset is
16337 given by cu_header->offset_size. */
16340 read_offset (bfd *abfd, const gdb_byte *buf,
16341 const struct comp_unit_head *cu_header,
16342 unsigned int *bytes_read)
16344 LONGEST offset = read_offset_1 (abfd, buf, cu_header->offset_size);
16346 *bytes_read = cu_header->offset_size;
16350 /* Read an offset from the data stream. */
16353 read_offset_1 (bfd *abfd, const gdb_byte *buf, unsigned int offset_size)
16355 LONGEST retval = 0;
16357 switch (offset_size)
16360 retval = bfd_get_32 (abfd, buf);
16363 retval = bfd_get_64 (abfd, buf);
16366 internal_error (__FILE__, __LINE__,
16367 _("read_offset_1: bad switch [in module %s]"),
16368 bfd_get_filename (abfd));
16374 static const gdb_byte *
16375 read_n_bytes (bfd *abfd, const gdb_byte *buf, unsigned int size)
16377 /* If the size of a host char is 8 bits, we can return a pointer
16378 to the buffer, otherwise we have to copy the data to a buffer
16379 allocated on the temporary obstack. */
16380 gdb_assert (HOST_CHAR_BIT == 8);
16384 static const char *
16385 read_direct_string (bfd *abfd, const gdb_byte *buf,
16386 unsigned int *bytes_read_ptr)
16388 /* If the size of a host char is 8 bits, we can return a pointer
16389 to the string, otherwise we have to copy the string to a buffer
16390 allocated on the temporary obstack. */
16391 gdb_assert (HOST_CHAR_BIT == 8);
16394 *bytes_read_ptr = 1;
16397 *bytes_read_ptr = strlen ((const char *) buf) + 1;
16398 return (const char *) buf;
16401 static const char *
16402 read_indirect_string_at_offset (bfd *abfd, LONGEST str_offset)
16404 dwarf2_read_section (dwarf2_per_objfile->objfile, &dwarf2_per_objfile->str);
16405 if (dwarf2_per_objfile->str.buffer == NULL)
16406 error (_("DW_FORM_strp used without .debug_str section [in module %s]"),
16407 bfd_get_filename (abfd));
16408 if (str_offset >= dwarf2_per_objfile->str.size)
16409 error (_("DW_FORM_strp pointing outside of "
16410 ".debug_str section [in module %s]"),
16411 bfd_get_filename (abfd));
16412 gdb_assert (HOST_CHAR_BIT == 8);
16413 if (dwarf2_per_objfile->str.buffer[str_offset] == '\0')
16415 return (const char *) (dwarf2_per_objfile->str.buffer + str_offset);
16418 /* Read a string at offset STR_OFFSET in the .debug_str section from
16419 the .dwz file DWZ. Throw an error if the offset is too large. If
16420 the string consists of a single NUL byte, return NULL; otherwise
16421 return a pointer to the string. */
16423 static const char *
16424 read_indirect_string_from_dwz (struct dwz_file *dwz, LONGEST str_offset)
16426 dwarf2_read_section (dwarf2_per_objfile->objfile, &dwz->str);
16428 if (dwz->str.buffer == NULL)
16429 error (_("DW_FORM_GNU_strp_alt used without .debug_str "
16430 "section [in module %s]"),
16431 bfd_get_filename (dwz->dwz_bfd));
16432 if (str_offset >= dwz->str.size)
16433 error (_("DW_FORM_GNU_strp_alt pointing outside of "
16434 ".debug_str section [in module %s]"),
16435 bfd_get_filename (dwz->dwz_bfd));
16436 gdb_assert (HOST_CHAR_BIT == 8);
16437 if (dwz->str.buffer[str_offset] == '\0')
16439 return (const char *) (dwz->str.buffer + str_offset);
16442 static const char *
16443 read_indirect_string (bfd *abfd, const gdb_byte *buf,
16444 const struct comp_unit_head *cu_header,
16445 unsigned int *bytes_read_ptr)
16447 LONGEST str_offset = read_offset (abfd, buf, cu_header, bytes_read_ptr);
16449 return read_indirect_string_at_offset (abfd, str_offset);
16453 read_unsigned_leb128 (bfd *abfd, const gdb_byte *buf,
16454 unsigned int *bytes_read_ptr)
16457 unsigned int num_read;
16459 unsigned char byte;
16467 byte = bfd_get_8 (abfd, buf);
16470 result |= ((ULONGEST) (byte & 127) << shift);
16471 if ((byte & 128) == 0)
16477 *bytes_read_ptr = num_read;
16482 read_signed_leb128 (bfd *abfd, const gdb_byte *buf,
16483 unsigned int *bytes_read_ptr)
16486 int i, shift, num_read;
16487 unsigned char byte;
16495 byte = bfd_get_8 (abfd, buf);
16498 result |= ((LONGEST) (byte & 127) << shift);
16500 if ((byte & 128) == 0)
16505 if ((shift < 8 * sizeof (result)) && (byte & 0x40))
16506 result |= -(((LONGEST) 1) << shift);
16507 *bytes_read_ptr = num_read;
16511 /* Given index ADDR_INDEX in .debug_addr, fetch the value.
16512 ADDR_BASE is the DW_AT_GNU_addr_base attribute or zero.
16513 ADDR_SIZE is the size of addresses from the CU header. */
16516 read_addr_index_1 (unsigned int addr_index, ULONGEST addr_base, int addr_size)
16518 struct objfile *objfile = dwarf2_per_objfile->objfile;
16519 bfd *abfd = objfile->obfd;
16520 const gdb_byte *info_ptr;
16522 dwarf2_read_section (objfile, &dwarf2_per_objfile->addr);
16523 if (dwarf2_per_objfile->addr.buffer == NULL)
16524 error (_("DW_FORM_addr_index used without .debug_addr section [in module %s]"),
16525 objfile_name (objfile));
16526 if (addr_base + addr_index * addr_size >= dwarf2_per_objfile->addr.size)
16527 error (_("DW_FORM_addr_index pointing outside of "
16528 ".debug_addr section [in module %s]"),
16529 objfile_name (objfile));
16530 info_ptr = (dwarf2_per_objfile->addr.buffer
16531 + addr_base + addr_index * addr_size);
16532 if (addr_size == 4)
16533 return bfd_get_32 (abfd, info_ptr);
16535 return bfd_get_64 (abfd, info_ptr);
16538 /* Given index ADDR_INDEX in .debug_addr, fetch the value. */
16541 read_addr_index (struct dwarf2_cu *cu, unsigned int addr_index)
16543 return read_addr_index_1 (addr_index, cu->addr_base, cu->header.addr_size);
16546 /* Given a pointer to an leb128 value, fetch the value from .debug_addr. */
16549 read_addr_index_from_leb128 (struct dwarf2_cu *cu, const gdb_byte *info_ptr,
16550 unsigned int *bytes_read)
16552 bfd *abfd = cu->objfile->obfd;
16553 unsigned int addr_index = read_unsigned_leb128 (abfd, info_ptr, bytes_read);
16555 return read_addr_index (cu, addr_index);
16558 /* Data structure to pass results from dwarf2_read_addr_index_reader
16559 back to dwarf2_read_addr_index. */
16561 struct dwarf2_read_addr_index_data
16563 ULONGEST addr_base;
16567 /* die_reader_func for dwarf2_read_addr_index. */
16570 dwarf2_read_addr_index_reader (const struct die_reader_specs *reader,
16571 const gdb_byte *info_ptr,
16572 struct die_info *comp_unit_die,
16576 struct dwarf2_cu *cu = reader->cu;
16577 struct dwarf2_read_addr_index_data *aidata =
16578 (struct dwarf2_read_addr_index_data *) data;
16580 aidata->addr_base = cu->addr_base;
16581 aidata->addr_size = cu->header.addr_size;
16584 /* Given an index in .debug_addr, fetch the value.
16585 NOTE: This can be called during dwarf expression evaluation,
16586 long after the debug information has been read, and thus per_cu->cu
16587 may no longer exist. */
16590 dwarf2_read_addr_index (struct dwarf2_per_cu_data *per_cu,
16591 unsigned int addr_index)
16593 struct objfile *objfile = per_cu->objfile;
16594 struct dwarf2_cu *cu = per_cu->cu;
16595 ULONGEST addr_base;
16598 /* This is intended to be called from outside this file. */
16599 dw2_setup (objfile);
16601 /* We need addr_base and addr_size.
16602 If we don't have PER_CU->cu, we have to get it.
16603 Nasty, but the alternative is storing the needed info in PER_CU,
16604 which at this point doesn't seem justified: it's not clear how frequently
16605 it would get used and it would increase the size of every PER_CU.
16606 Entry points like dwarf2_per_cu_addr_size do a similar thing
16607 so we're not in uncharted territory here.
16608 Alas we need to be a bit more complicated as addr_base is contained
16611 We don't need to read the entire CU(/TU).
16612 We just need the header and top level die.
16614 IWBN to use the aging mechanism to let us lazily later discard the CU.
16615 For now we skip this optimization. */
16619 addr_base = cu->addr_base;
16620 addr_size = cu->header.addr_size;
16624 struct dwarf2_read_addr_index_data aidata;
16626 /* Note: We can't use init_cutu_and_read_dies_simple here,
16627 we need addr_base. */
16628 init_cutu_and_read_dies (per_cu, NULL, 0, 0,
16629 dwarf2_read_addr_index_reader, &aidata);
16630 addr_base = aidata.addr_base;
16631 addr_size = aidata.addr_size;
16634 return read_addr_index_1 (addr_index, addr_base, addr_size);
16637 /* Given a DW_FORM_GNU_str_index, fetch the string.
16638 This is only used by the Fission support. */
16640 static const char *
16641 read_str_index (const struct die_reader_specs *reader, ULONGEST str_index)
16643 struct objfile *objfile = dwarf2_per_objfile->objfile;
16644 const char *objf_name = objfile_name (objfile);
16645 bfd *abfd = objfile->obfd;
16646 struct dwarf2_cu *cu = reader->cu;
16647 struct dwarf2_section_info *str_section = &reader->dwo_file->sections.str;
16648 struct dwarf2_section_info *str_offsets_section =
16649 &reader->dwo_file->sections.str_offsets;
16650 const gdb_byte *info_ptr;
16651 ULONGEST str_offset;
16652 static const char form_name[] = "DW_FORM_GNU_str_index";
16654 dwarf2_read_section (objfile, str_section);
16655 dwarf2_read_section (objfile, str_offsets_section);
16656 if (str_section->buffer == NULL)
16657 error (_("%s used without .debug_str.dwo section"
16658 " in CU at offset 0x%lx [in module %s]"),
16659 form_name, (long) cu->header.offset.sect_off, objf_name);
16660 if (str_offsets_section->buffer == NULL)
16661 error (_("%s used without .debug_str_offsets.dwo section"
16662 " in CU at offset 0x%lx [in module %s]"),
16663 form_name, (long) cu->header.offset.sect_off, objf_name);
16664 if (str_index * cu->header.offset_size >= str_offsets_section->size)
16665 error (_("%s pointing outside of .debug_str_offsets.dwo"
16666 " section in CU at offset 0x%lx [in module %s]"),
16667 form_name, (long) cu->header.offset.sect_off, objf_name);
16668 info_ptr = (str_offsets_section->buffer
16669 + str_index * cu->header.offset_size);
16670 if (cu->header.offset_size == 4)
16671 str_offset = bfd_get_32 (abfd, info_ptr);
16673 str_offset = bfd_get_64 (abfd, info_ptr);
16674 if (str_offset >= str_section->size)
16675 error (_("Offset from %s pointing outside of"
16676 " .debug_str.dwo section in CU at offset 0x%lx [in module %s]"),
16677 form_name, (long) cu->header.offset.sect_off, objf_name);
16678 return (const char *) (str_section->buffer + str_offset);
16681 /* Return the length of an LEB128 number in BUF. */
16684 leb128_size (const gdb_byte *buf)
16686 const gdb_byte *begin = buf;
16692 if ((byte & 128) == 0)
16693 return buf - begin;
16698 set_cu_language (unsigned int lang, struct dwarf2_cu *cu)
16706 cu->language = language_c;
16708 case DW_LANG_C_plus_plus:
16709 cu->language = language_cplus;
16712 cu->language = language_d;
16714 case DW_LANG_Fortran77:
16715 case DW_LANG_Fortran90:
16716 case DW_LANG_Fortran95:
16717 cu->language = language_fortran;
16720 cu->language = language_go;
16722 case DW_LANG_Mips_Assembler:
16723 cu->language = language_asm;
16726 cu->language = language_java;
16728 case DW_LANG_Ada83:
16729 case DW_LANG_Ada95:
16730 cu->language = language_ada;
16732 case DW_LANG_Modula2:
16733 cu->language = language_m2;
16735 case DW_LANG_Pascal83:
16736 cu->language = language_pascal;
16739 cu->language = language_objc;
16741 case DW_LANG_Cobol74:
16742 case DW_LANG_Cobol85:
16744 cu->language = language_minimal;
16747 cu->language_defn = language_def (cu->language);
16750 /* Return the named attribute or NULL if not there. */
16752 static struct attribute *
16753 dwarf2_attr (struct die_info *die, unsigned int name, struct dwarf2_cu *cu)
16758 struct attribute *spec = NULL;
16760 for (i = 0; i < die->num_attrs; ++i)
16762 if (die->attrs[i].name == name)
16763 return &die->attrs[i];
16764 if (die->attrs[i].name == DW_AT_specification
16765 || die->attrs[i].name == DW_AT_abstract_origin)
16766 spec = &die->attrs[i];
16772 die = follow_die_ref (die, spec, &cu);
16778 /* Return the named attribute or NULL if not there,
16779 but do not follow DW_AT_specification, etc.
16780 This is for use in contexts where we're reading .debug_types dies.
16781 Following DW_AT_specification, DW_AT_abstract_origin will take us
16782 back up the chain, and we want to go down. */
16784 static struct attribute *
16785 dwarf2_attr_no_follow (struct die_info *die, unsigned int name)
16789 for (i = 0; i < die->num_attrs; ++i)
16790 if (die->attrs[i].name == name)
16791 return &die->attrs[i];
16796 /* Return non-zero iff the attribute NAME is defined for the given DIE,
16797 and holds a non-zero value. This function should only be used for
16798 DW_FORM_flag or DW_FORM_flag_present attributes. */
16801 dwarf2_flag_true_p (struct die_info *die, unsigned name, struct dwarf2_cu *cu)
16803 struct attribute *attr = dwarf2_attr (die, name, cu);
16805 return (attr && DW_UNSND (attr));
16809 die_is_declaration (struct die_info *die, struct dwarf2_cu *cu)
16811 /* A DIE is a declaration if it has a DW_AT_declaration attribute
16812 which value is non-zero. However, we have to be careful with
16813 DIEs having a DW_AT_specification attribute, because dwarf2_attr()
16814 (via dwarf2_flag_true_p) follows this attribute. So we may
16815 end up accidently finding a declaration attribute that belongs
16816 to a different DIE referenced by the specification attribute,
16817 even though the given DIE does not have a declaration attribute. */
16818 return (dwarf2_flag_true_p (die, DW_AT_declaration, cu)
16819 && dwarf2_attr (die, DW_AT_specification, cu) == NULL);
16822 /* Return the die giving the specification for DIE, if there is
16823 one. *SPEC_CU is the CU containing DIE on input, and the CU
16824 containing the return value on output. If there is no
16825 specification, but there is an abstract origin, that is
16828 static struct die_info *
16829 die_specification (struct die_info *die, struct dwarf2_cu **spec_cu)
16831 struct attribute *spec_attr = dwarf2_attr (die, DW_AT_specification,
16834 if (spec_attr == NULL)
16835 spec_attr = dwarf2_attr (die, DW_AT_abstract_origin, *spec_cu);
16837 if (spec_attr == NULL)
16840 return follow_die_ref (die, spec_attr, spec_cu);
16843 /* Free the line_header structure *LH, and any arrays and strings it
16845 NOTE: This is also used as a "cleanup" function. */
16848 free_line_header (struct line_header *lh)
16850 if (lh->standard_opcode_lengths)
16851 xfree (lh->standard_opcode_lengths);
16853 /* Remember that all the lh->file_names[i].name pointers are
16854 pointers into debug_line_buffer, and don't need to be freed. */
16855 if (lh->file_names)
16856 xfree (lh->file_names);
16858 /* Similarly for the include directory names. */
16859 if (lh->include_dirs)
16860 xfree (lh->include_dirs);
16865 /* Add an entry to LH's include directory table. */
16868 add_include_dir (struct line_header *lh, const char *include_dir)
16870 /* Grow the array if necessary. */
16871 if (lh->include_dirs_size == 0)
16873 lh->include_dirs_size = 1; /* for testing */
16874 lh->include_dirs = xmalloc (lh->include_dirs_size
16875 * sizeof (*lh->include_dirs));
16877 else if (lh->num_include_dirs >= lh->include_dirs_size)
16879 lh->include_dirs_size *= 2;
16880 lh->include_dirs = xrealloc (lh->include_dirs,
16881 (lh->include_dirs_size
16882 * sizeof (*lh->include_dirs)));
16885 lh->include_dirs[lh->num_include_dirs++] = include_dir;
16888 /* Add an entry to LH's file name table. */
16891 add_file_name (struct line_header *lh,
16893 unsigned int dir_index,
16894 unsigned int mod_time,
16895 unsigned int length)
16897 struct file_entry *fe;
16899 /* Grow the array if necessary. */
16900 if (lh->file_names_size == 0)
16902 lh->file_names_size = 1; /* for testing */
16903 lh->file_names = xmalloc (lh->file_names_size
16904 * sizeof (*lh->file_names));
16906 else if (lh->num_file_names >= lh->file_names_size)
16908 lh->file_names_size *= 2;
16909 lh->file_names = xrealloc (lh->file_names,
16910 (lh->file_names_size
16911 * sizeof (*lh->file_names)));
16914 fe = &lh->file_names[lh->num_file_names++];
16916 fe->dir_index = dir_index;
16917 fe->mod_time = mod_time;
16918 fe->length = length;
16919 fe->included_p = 0;
16923 /* A convenience function to find the proper .debug_line section for a
16926 static struct dwarf2_section_info *
16927 get_debug_line_section (struct dwarf2_cu *cu)
16929 struct dwarf2_section_info *section;
16931 /* For TUs in DWO files, the DW_AT_stmt_list attribute lives in the
16933 if (cu->dwo_unit && cu->per_cu->is_debug_types)
16934 section = &cu->dwo_unit->dwo_file->sections.line;
16935 else if (cu->per_cu->is_dwz)
16937 struct dwz_file *dwz = dwarf2_get_dwz_file ();
16939 section = &dwz->line;
16942 section = &dwarf2_per_objfile->line;
16947 /* Read the statement program header starting at OFFSET in
16948 .debug_line, or .debug_line.dwo. Return a pointer
16949 to a struct line_header, allocated using xmalloc.
16951 NOTE: the strings in the include directory and file name tables of
16952 the returned object point into the dwarf line section buffer,
16953 and must not be freed. */
16955 static struct line_header *
16956 dwarf_decode_line_header (unsigned int offset, struct dwarf2_cu *cu)
16958 struct cleanup *back_to;
16959 struct line_header *lh;
16960 const gdb_byte *line_ptr;
16961 unsigned int bytes_read, offset_size;
16963 const char *cur_dir, *cur_file;
16964 struct dwarf2_section_info *section;
16967 section = get_debug_line_section (cu);
16968 dwarf2_read_section (dwarf2_per_objfile->objfile, section);
16969 if (section->buffer == NULL)
16971 if (cu->dwo_unit && cu->per_cu->is_debug_types)
16972 complaint (&symfile_complaints, _("missing .debug_line.dwo section"));
16974 complaint (&symfile_complaints, _("missing .debug_line section"));
16978 /* We can't do this until we know the section is non-empty.
16979 Only then do we know we have such a section. */
16980 abfd = get_section_bfd_owner (section);
16982 /* Make sure that at least there's room for the total_length field.
16983 That could be 12 bytes long, but we're just going to fudge that. */
16984 if (offset + 4 >= section->size)
16986 dwarf2_statement_list_fits_in_line_number_section_complaint ();
16990 lh = xmalloc (sizeof (*lh));
16991 memset (lh, 0, sizeof (*lh));
16992 back_to = make_cleanup ((make_cleanup_ftype *) free_line_header,
16995 line_ptr = section->buffer + offset;
16997 /* Read in the header. */
16999 read_checked_initial_length_and_offset (abfd, line_ptr, &cu->header,
17000 &bytes_read, &offset_size);
17001 line_ptr += bytes_read;
17002 if (line_ptr + lh->total_length > (section->buffer + section->size))
17004 dwarf2_statement_list_fits_in_line_number_section_complaint ();
17005 do_cleanups (back_to);
17008 lh->statement_program_end = line_ptr + lh->total_length;
17009 lh->version = read_2_bytes (abfd, line_ptr);
17011 lh->header_length = read_offset_1 (abfd, line_ptr, offset_size);
17012 line_ptr += offset_size;
17013 lh->minimum_instruction_length = read_1_byte (abfd, line_ptr);
17015 if (lh->version >= 4)
17017 lh->maximum_ops_per_instruction = read_1_byte (abfd, line_ptr);
17021 lh->maximum_ops_per_instruction = 1;
17023 if (lh->maximum_ops_per_instruction == 0)
17025 lh->maximum_ops_per_instruction = 1;
17026 complaint (&symfile_complaints,
17027 _("invalid maximum_ops_per_instruction "
17028 "in `.debug_line' section"));
17031 lh->default_is_stmt = read_1_byte (abfd, line_ptr);
17033 lh->line_base = read_1_signed_byte (abfd, line_ptr);
17035 lh->line_range = read_1_byte (abfd, line_ptr);
17037 lh->opcode_base = read_1_byte (abfd, line_ptr);
17039 lh->standard_opcode_lengths
17040 = xmalloc (lh->opcode_base * sizeof (lh->standard_opcode_lengths[0]));
17042 lh->standard_opcode_lengths[0] = 1; /* This should never be used anyway. */
17043 for (i = 1; i < lh->opcode_base; ++i)
17045 lh->standard_opcode_lengths[i] = read_1_byte (abfd, line_ptr);
17049 /* Read directory table. */
17050 while ((cur_dir = read_direct_string (abfd, line_ptr, &bytes_read)) != NULL)
17052 line_ptr += bytes_read;
17053 add_include_dir (lh, cur_dir);
17055 line_ptr += bytes_read;
17057 /* Read file name table. */
17058 while ((cur_file = read_direct_string (abfd, line_ptr, &bytes_read)) != NULL)
17060 unsigned int dir_index, mod_time, length;
17062 line_ptr += bytes_read;
17063 dir_index = read_unsigned_leb128 (abfd, line_ptr, &bytes_read);
17064 line_ptr += bytes_read;
17065 mod_time = read_unsigned_leb128 (abfd, line_ptr, &bytes_read);
17066 line_ptr += bytes_read;
17067 length = read_unsigned_leb128 (abfd, line_ptr, &bytes_read);
17068 line_ptr += bytes_read;
17070 add_file_name (lh, cur_file, dir_index, mod_time, length);
17072 line_ptr += bytes_read;
17073 lh->statement_program_start = line_ptr;
17075 if (line_ptr > (section->buffer + section->size))
17076 complaint (&symfile_complaints,
17077 _("line number info header doesn't "
17078 "fit in `.debug_line' section"));
17080 discard_cleanups (back_to);
17084 /* Subroutine of dwarf_decode_lines to simplify it.
17085 Return the file name of the psymtab for included file FILE_INDEX
17086 in line header LH of PST.
17087 COMP_DIR is the compilation directory (DW_AT_comp_dir) or NULL if unknown.
17088 If space for the result is malloc'd, it will be freed by a cleanup.
17089 Returns NULL if FILE_INDEX should be ignored, i.e., it is pst->filename.
17091 The function creates dangling cleanup registration. */
17093 static const char *
17094 psymtab_include_file_name (const struct line_header *lh, int file_index,
17095 const struct partial_symtab *pst,
17096 const char *comp_dir)
17098 const struct file_entry fe = lh->file_names [file_index];
17099 const char *include_name = fe.name;
17100 const char *include_name_to_compare = include_name;
17101 const char *dir_name = NULL;
17102 const char *pst_filename;
17103 char *copied_name = NULL;
17107 dir_name = lh->include_dirs[fe.dir_index - 1];
17109 if (!IS_ABSOLUTE_PATH (include_name)
17110 && (dir_name != NULL || comp_dir != NULL))
17112 /* Avoid creating a duplicate psymtab for PST.
17113 We do this by comparing INCLUDE_NAME and PST_FILENAME.
17114 Before we do the comparison, however, we need to account
17115 for DIR_NAME and COMP_DIR.
17116 First prepend dir_name (if non-NULL). If we still don't
17117 have an absolute path prepend comp_dir (if non-NULL).
17118 However, the directory we record in the include-file's
17119 psymtab does not contain COMP_DIR (to match the
17120 corresponding symtab(s)).
17125 bash$ gcc -g ./hello.c
17126 include_name = "hello.c"
17128 DW_AT_comp_dir = comp_dir = "/tmp"
17129 DW_AT_name = "./hello.c"
17133 if (dir_name != NULL)
17135 char *tem = concat (dir_name, SLASH_STRING,
17136 include_name, (char *)NULL);
17138 make_cleanup (xfree, tem);
17139 include_name = tem;
17140 include_name_to_compare = include_name;
17142 if (!IS_ABSOLUTE_PATH (include_name) && comp_dir != NULL)
17144 char *tem = concat (comp_dir, SLASH_STRING,
17145 include_name, (char *)NULL);
17147 make_cleanup (xfree, tem);
17148 include_name_to_compare = tem;
17152 pst_filename = pst->filename;
17153 if (!IS_ABSOLUTE_PATH (pst_filename) && pst->dirname != NULL)
17155 copied_name = concat (pst->dirname, SLASH_STRING,
17156 pst_filename, (char *)NULL);
17157 pst_filename = copied_name;
17160 file_is_pst = FILENAME_CMP (include_name_to_compare, pst_filename) == 0;
17162 if (copied_name != NULL)
17163 xfree (copied_name);
17167 return include_name;
17170 /* Ignore this record_line request. */
17173 noop_record_line (struct subfile *subfile, int line, CORE_ADDR pc)
17178 /* Return non-zero if we should add LINE to the line number table.
17179 LINE is the line to add, LAST_LINE is the last line that was added,
17180 LAST_SUBFILE is the subfile for LAST_LINE.
17181 LINE_HAS_NON_ZERO_DISCRIMINATOR is non-zero if LINE has ever
17182 had a non-zero discriminator.
17184 We have to be careful in the presence of discriminators.
17185 E.g., for this line:
17187 for (i = 0; i < 100000; i++);
17189 clang can emit four line number entries for that one line,
17190 each with a different discriminator.
17191 See gdb.dwarf2/dw2-single-line-discriminators.exp for an example.
17193 However, we want gdb to coalesce all four entries into one.
17194 Otherwise the user could stepi into the middle of the line and
17195 gdb would get confused about whether the pc really was in the
17196 middle of the line.
17198 Things are further complicated by the fact that two consecutive
17199 line number entries for the same line is a heuristic used by gcc
17200 to denote the end of the prologue. So we can't just discard duplicate
17201 entries, we have to be selective about it. The heuristic we use is
17202 that we only collapse consecutive entries for the same line if at least
17203 one of those entries has a non-zero discriminator. PR 17276.
17205 Note: Addresses in the line number state machine can never go backwards
17206 within one sequence, thus this coalescing is ok. */
17209 dwarf_record_line_p (unsigned int line, unsigned int last_line,
17210 int line_has_non_zero_discriminator,
17211 struct subfile *last_subfile)
17213 if (current_subfile != last_subfile)
17215 if (line != last_line)
17217 /* Same line for the same file that we've seen already.
17218 As a last check, for pr 17276, only record the line if the line
17219 has never had a non-zero discriminator. */
17220 if (!line_has_non_zero_discriminator)
17225 /* Use P_RECORD_LINE to record line number LINE beginning at address ADDRESS
17226 in the line table of subfile SUBFILE. */
17229 dwarf_record_line (struct gdbarch *gdbarch, struct subfile *subfile,
17230 unsigned int line, CORE_ADDR address,
17231 record_line_ftype p_record_line)
17233 CORE_ADDR addr = gdbarch_addr_bits_remove (gdbarch, address);
17235 (*p_record_line) (subfile, line, addr);
17238 /* Subroutine of dwarf_decode_lines_1 to simplify it.
17239 Mark the end of a set of line number records.
17240 The arguments are the same as for dwarf_record_line.
17241 If SUBFILE is NULL the request is ignored. */
17244 dwarf_finish_line (struct gdbarch *gdbarch, struct subfile *subfile,
17245 CORE_ADDR address, record_line_ftype p_record_line)
17247 if (subfile != NULL)
17248 dwarf_record_line (gdbarch, subfile, 0, address, p_record_line);
17251 /* Subroutine of dwarf_decode_lines to simplify it.
17252 Process the line number information in LH. */
17255 dwarf_decode_lines_1 (struct line_header *lh, const char *comp_dir,
17256 struct dwarf2_cu *cu, const int decode_for_pst_p,
17259 const gdb_byte *line_ptr, *extended_end;
17260 const gdb_byte *line_end;
17261 unsigned int bytes_read, extended_len;
17262 unsigned char op_code, extended_op;
17263 CORE_ADDR baseaddr;
17264 struct objfile *objfile = cu->objfile;
17265 bfd *abfd = objfile->obfd;
17266 struct gdbarch *gdbarch = get_objfile_arch (objfile);
17267 struct subfile *last_subfile = NULL;
17268 void (*p_record_line) (struct subfile *subfile, int line, CORE_ADDR pc)
17271 baseaddr = ANOFFSET (objfile->section_offsets, SECT_OFF_TEXT (objfile));
17273 line_ptr = lh->statement_program_start;
17274 line_end = lh->statement_program_end;
17276 /* Read the statement sequences until there's nothing left. */
17277 while (line_ptr < line_end)
17279 /* state machine registers */
17280 CORE_ADDR address = 0;
17281 unsigned int file = 1;
17282 unsigned int line = 1;
17283 int is_stmt = lh->default_is_stmt;
17284 int end_sequence = 0;
17285 unsigned char op_index = 0;
17286 unsigned int discriminator = 0;
17287 /* The last line number that was recorded, used to coalesce
17288 consecutive entries for the same line. This can happen, for
17289 example, when discriminators are present. PR 17276. */
17290 unsigned int last_line = 0;
17291 int line_has_non_zero_discriminator = 0;
17293 if (!decode_for_pst_p && lh->num_file_names >= file)
17295 /* Start a subfile for the current file of the state machine. */
17296 /* lh->include_dirs and lh->file_names are 0-based, but the
17297 directory and file name numbers in the statement program
17299 struct file_entry *fe = &lh->file_names[file - 1];
17300 const char *dir = NULL;
17303 dir = lh->include_dirs[fe->dir_index - 1];
17305 dwarf2_start_subfile (fe->name, dir, comp_dir);
17308 /* Decode the table. */
17309 while (!end_sequence)
17311 op_code = read_1_byte (abfd, line_ptr);
17313 if (line_ptr > line_end)
17315 dwarf2_debug_line_missing_end_sequence_complaint ();
17319 if (op_code >= lh->opcode_base)
17321 /* Special opcode. */
17322 unsigned char adj_opcode;
17325 adj_opcode = op_code - lh->opcode_base;
17326 address += (((op_index + (adj_opcode / lh->line_range))
17327 / lh->maximum_ops_per_instruction)
17328 * lh->minimum_instruction_length);
17329 op_index = ((op_index + (adj_opcode / lh->line_range))
17330 % lh->maximum_ops_per_instruction);
17331 line_delta = lh->line_base + (adj_opcode % lh->line_range);
17332 line += line_delta;
17333 if (line_delta != 0)
17334 line_has_non_zero_discriminator = discriminator != 0;
17335 if (lh->num_file_names < file || file == 0)
17336 dwarf2_debug_line_missing_file_complaint ();
17337 /* For now we ignore lines not starting on an
17338 instruction boundary. */
17339 else if (op_index == 0)
17341 lh->file_names[file - 1].included_p = 1;
17342 if (!decode_for_pst_p && is_stmt)
17344 if (last_subfile != current_subfile)
17346 dwarf_finish_line (gdbarch, last_subfile,
17347 address, p_record_line);
17349 if (dwarf_record_line_p (line, last_line,
17350 line_has_non_zero_discriminator,
17353 dwarf_record_line (gdbarch, current_subfile,
17354 line, address, p_record_line);
17356 last_subfile = current_subfile;
17362 else switch (op_code)
17364 case DW_LNS_extended_op:
17365 extended_len = read_unsigned_leb128 (abfd, line_ptr,
17367 line_ptr += bytes_read;
17368 extended_end = line_ptr + extended_len;
17369 extended_op = read_1_byte (abfd, line_ptr);
17371 switch (extended_op)
17373 case DW_LNE_end_sequence:
17374 p_record_line = record_line;
17377 case DW_LNE_set_address:
17378 address = read_address (abfd, line_ptr, cu, &bytes_read);
17380 /* If address < lowpc then it's not a usable value, it's
17381 outside the pc range of the CU. However, we restrict
17382 the test to only address values of zero to preserve
17383 GDB's previous behaviour which is to handle the specific
17384 case of a function being GC'd by the linker. */
17385 if (address == 0 && address < lowpc)
17387 /* This line table is for a function which has been
17388 GCd by the linker. Ignore it. PR gdb/12528 */
17391 = line_ptr - get_debug_line_section (cu)->buffer;
17393 complaint (&symfile_complaints,
17394 _(".debug_line address at offset 0x%lx is 0 "
17396 line_offset, objfile_name (objfile));
17397 p_record_line = noop_record_line;
17398 /* Note: p_record_line is left as noop_record_line
17399 until we see DW_LNE_end_sequence. */
17403 line_ptr += bytes_read;
17404 address += baseaddr;
17406 case DW_LNE_define_file:
17408 const char *cur_file;
17409 unsigned int dir_index, mod_time, length;
17411 cur_file = read_direct_string (abfd, line_ptr,
17413 line_ptr += bytes_read;
17415 read_unsigned_leb128 (abfd, line_ptr, &bytes_read);
17416 line_ptr += bytes_read;
17418 read_unsigned_leb128 (abfd, line_ptr, &bytes_read);
17419 line_ptr += bytes_read;
17421 read_unsigned_leb128 (abfd, line_ptr, &bytes_read);
17422 line_ptr += bytes_read;
17423 add_file_name (lh, cur_file, dir_index, mod_time, length);
17426 case DW_LNE_set_discriminator:
17427 /* The discriminator is not interesting to the debugger;
17428 just ignore it. We still need to check its value though:
17429 if there are consecutive entries for the same
17430 (non-prologue) line we want to coalesce them.
17432 discriminator = read_unsigned_leb128 (abfd, line_ptr,
17434 line_has_non_zero_discriminator |= discriminator != 0;
17435 line_ptr += bytes_read;
17438 complaint (&symfile_complaints,
17439 _("mangled .debug_line section"));
17442 /* Make sure that we parsed the extended op correctly. If e.g.
17443 we expected a different address size than the producer used,
17444 we may have read the wrong number of bytes. */
17445 if (line_ptr != extended_end)
17447 complaint (&symfile_complaints,
17448 _("mangled .debug_line section"));
17453 if (lh->num_file_names < file || file == 0)
17454 dwarf2_debug_line_missing_file_complaint ();
17457 lh->file_names[file - 1].included_p = 1;
17458 if (!decode_for_pst_p && is_stmt)
17460 if (last_subfile != current_subfile)
17462 dwarf_finish_line (gdbarch, last_subfile,
17463 address, p_record_line);
17465 if (dwarf_record_line_p (line, last_line,
17466 line_has_non_zero_discriminator,
17469 dwarf_record_line (gdbarch, current_subfile,
17470 line, address, p_record_line);
17472 last_subfile = current_subfile;
17478 case DW_LNS_advance_pc:
17481 = read_unsigned_leb128 (abfd, line_ptr, &bytes_read);
17483 address += (((op_index + adjust)
17484 / lh->maximum_ops_per_instruction)
17485 * lh->minimum_instruction_length);
17486 op_index = ((op_index + adjust)
17487 % lh->maximum_ops_per_instruction);
17488 line_ptr += bytes_read;
17491 case DW_LNS_advance_line:
17494 = read_signed_leb128 (abfd, line_ptr, &bytes_read);
17496 line += line_delta;
17497 if (line_delta != 0)
17498 line_has_non_zero_discriminator = discriminator != 0;
17499 line_ptr += bytes_read;
17502 case DW_LNS_set_file:
17504 /* The arrays lh->include_dirs and lh->file_names are
17505 0-based, but the directory and file name numbers in
17506 the statement program are 1-based. */
17507 struct file_entry *fe;
17508 const char *dir = NULL;
17510 file = read_unsigned_leb128 (abfd, line_ptr, &bytes_read);
17511 line_ptr += bytes_read;
17512 if (lh->num_file_names < file || file == 0)
17513 dwarf2_debug_line_missing_file_complaint ();
17516 fe = &lh->file_names[file - 1];
17518 dir = lh->include_dirs[fe->dir_index - 1];
17519 if (!decode_for_pst_p)
17521 last_subfile = current_subfile;
17522 line_has_non_zero_discriminator = discriminator != 0;
17523 dwarf2_start_subfile (fe->name, dir, comp_dir);
17528 case DW_LNS_set_column:
17529 (void) read_unsigned_leb128 (abfd, line_ptr, &bytes_read);
17530 line_ptr += bytes_read;
17532 case DW_LNS_negate_stmt:
17533 is_stmt = (!is_stmt);
17535 case DW_LNS_set_basic_block:
17537 /* Add to the address register of the state machine the
17538 address increment value corresponding to special opcode
17539 255. I.e., this value is scaled by the minimum
17540 instruction length since special opcode 255 would have
17541 scaled the increment. */
17542 case DW_LNS_const_add_pc:
17544 CORE_ADDR adjust = (255 - lh->opcode_base) / lh->line_range;
17546 address += (((op_index + adjust)
17547 / lh->maximum_ops_per_instruction)
17548 * lh->minimum_instruction_length);
17549 op_index = ((op_index + adjust)
17550 % lh->maximum_ops_per_instruction);
17553 case DW_LNS_fixed_advance_pc:
17554 address += read_2_bytes (abfd, line_ptr);
17560 /* Unknown standard opcode, ignore it. */
17563 for (i = 0; i < lh->standard_opcode_lengths[op_code]; i++)
17565 (void) read_unsigned_leb128 (abfd, line_ptr, &bytes_read);
17566 line_ptr += bytes_read;
17571 if (lh->num_file_names < file || file == 0)
17572 dwarf2_debug_line_missing_file_complaint ();
17575 lh->file_names[file - 1].included_p = 1;
17576 if (!decode_for_pst_p)
17578 dwarf_finish_line (gdbarch, current_subfile, address,
17585 /* Decode the Line Number Program (LNP) for the given line_header
17586 structure and CU. The actual information extracted and the type
17587 of structures created from the LNP depends on the value of PST.
17589 1. If PST is NULL, then this procedure uses the data from the program
17590 to create all necessary symbol tables, and their linetables.
17592 2. If PST is not NULL, this procedure reads the program to determine
17593 the list of files included by the unit represented by PST, and
17594 builds all the associated partial symbol tables.
17596 COMP_DIR is the compilation directory (DW_AT_comp_dir) or NULL if unknown.
17597 It is used for relative paths in the line table.
17598 NOTE: When processing partial symtabs (pst != NULL),
17599 comp_dir == pst->dirname.
17601 NOTE: It is important that psymtabs have the same file name (via strcmp)
17602 as the corresponding symtab. Since COMP_DIR is not used in the name of the
17603 symtab we don't use it in the name of the psymtabs we create.
17604 E.g. expand_line_sal requires this when finding psymtabs to expand.
17605 A good testcase for this is mb-inline.exp.
17607 LOWPC is the lowest address in CU (or 0 if not known). */
17610 dwarf_decode_lines (struct line_header *lh, const char *comp_dir,
17611 struct dwarf2_cu *cu, struct partial_symtab *pst,
17614 struct objfile *objfile = cu->objfile;
17615 const int decode_for_pst_p = (pst != NULL);
17616 struct subfile *first_subfile = current_subfile;
17618 dwarf_decode_lines_1 (lh, comp_dir, cu, decode_for_pst_p, lowpc);
17620 if (decode_for_pst_p)
17624 /* Now that we're done scanning the Line Header Program, we can
17625 create the psymtab of each included file. */
17626 for (file_index = 0; file_index < lh->num_file_names; file_index++)
17627 if (lh->file_names[file_index].included_p == 1)
17629 const char *include_name =
17630 psymtab_include_file_name (lh, file_index, pst, comp_dir);
17631 if (include_name != NULL)
17632 dwarf2_create_include_psymtab (include_name, pst, objfile);
17637 /* Make sure a symtab is created for every file, even files
17638 which contain only variables (i.e. no code with associated
17642 for (i = 0; i < lh->num_file_names; i++)
17644 const char *dir = NULL;
17645 struct file_entry *fe;
17647 fe = &lh->file_names[i];
17649 dir = lh->include_dirs[fe->dir_index - 1];
17650 dwarf2_start_subfile (fe->name, dir, comp_dir);
17652 /* Skip the main file; we don't need it, and it must be
17653 allocated last, so that it will show up before the
17654 non-primary symtabs in the objfile's symtab list. */
17655 if (current_subfile == first_subfile)
17658 if (current_subfile->symtab == NULL)
17659 current_subfile->symtab = allocate_symtab (current_subfile->name,
17661 fe->symtab = current_subfile->symtab;
17666 /* Start a subfile for DWARF. FILENAME is the name of the file and
17667 DIRNAME the name of the source directory which contains FILENAME
17668 or NULL if not known. COMP_DIR is the compilation directory for the
17669 linetable's compilation unit or NULL if not known.
17670 This routine tries to keep line numbers from identical absolute and
17671 relative file names in a common subfile.
17673 Using the `list' example from the GDB testsuite, which resides in
17674 /srcdir and compiling it with Irix6.2 cc in /compdir using a filename
17675 of /srcdir/list0.c yields the following debugging information for list0.c:
17677 DW_AT_name: /srcdir/list0.c
17678 DW_AT_comp_dir: /compdir
17679 files.files[0].name: list0.h
17680 files.files[0].dir: /srcdir
17681 files.files[1].name: list0.c
17682 files.files[1].dir: /srcdir
17684 The line number information for list0.c has to end up in a single
17685 subfile, so that `break /srcdir/list0.c:1' works as expected.
17686 start_subfile will ensure that this happens provided that we pass the
17687 concatenation of files.files[1].dir and files.files[1].name as the
17691 dwarf2_start_subfile (const char *filename, const char *dirname,
17692 const char *comp_dir)
17696 /* While reading the DIEs, we call start_symtab(DW_AT_name, DW_AT_comp_dir).
17697 `start_symtab' will always pass the contents of DW_AT_comp_dir as
17698 second argument to start_subfile. To be consistent, we do the
17699 same here. In order not to lose the line information directory,
17700 we concatenate it to the filename when it makes sense.
17701 Note that the Dwarf3 standard says (speaking of filenames in line
17702 information): ``The directory index is ignored for file names
17703 that represent full path names''. Thus ignoring dirname in the
17704 `else' branch below isn't an issue. */
17706 if (!IS_ABSOLUTE_PATH (filename) && dirname != NULL)
17708 copy = concat (dirname, SLASH_STRING, filename, (char *)NULL);
17712 start_subfile (filename, comp_dir);
17718 /* Start a symtab for DWARF.
17719 NAME, COMP_DIR, LOW_PC are passed to start_symtab. */
17722 dwarf2_start_symtab (struct dwarf2_cu *cu,
17723 const char *name, const char *comp_dir, CORE_ADDR low_pc)
17725 start_symtab (name, comp_dir, low_pc);
17726 record_debugformat ("DWARF 2");
17727 record_producer (cu->producer);
17729 /* We assume that we're processing GCC output. */
17730 processing_gcc_compilation = 2;
17732 cu->processing_has_namespace_info = 0;
17736 var_decode_location (struct attribute *attr, struct symbol *sym,
17737 struct dwarf2_cu *cu)
17739 struct objfile *objfile = cu->objfile;
17740 struct comp_unit_head *cu_header = &cu->header;
17742 /* NOTE drow/2003-01-30: There used to be a comment and some special
17743 code here to turn a symbol with DW_AT_external and a
17744 SYMBOL_VALUE_ADDRESS of 0 into a LOC_UNRESOLVED symbol. This was
17745 necessary for platforms (maybe Alpha, certainly PowerPC GNU/Linux
17746 with some versions of binutils) where shared libraries could have
17747 relocations against symbols in their debug information - the
17748 minimal symbol would have the right address, but the debug info
17749 would not. It's no longer necessary, because we will explicitly
17750 apply relocations when we read in the debug information now. */
17752 /* A DW_AT_location attribute with no contents indicates that a
17753 variable has been optimized away. */
17754 if (attr_form_is_block (attr) && DW_BLOCK (attr)->size == 0)
17756 SYMBOL_ACLASS_INDEX (sym) = LOC_OPTIMIZED_OUT;
17760 /* Handle one degenerate form of location expression specially, to
17761 preserve GDB's previous behavior when section offsets are
17762 specified. If this is just a DW_OP_addr or DW_OP_GNU_addr_index
17763 then mark this symbol as LOC_STATIC. */
17765 if (attr_form_is_block (attr)
17766 && ((DW_BLOCK (attr)->data[0] == DW_OP_addr
17767 && DW_BLOCK (attr)->size == 1 + cu_header->addr_size)
17768 || (DW_BLOCK (attr)->data[0] == DW_OP_GNU_addr_index
17769 && (DW_BLOCK (attr)->size
17770 == 1 + leb128_size (&DW_BLOCK (attr)->data[1])))))
17772 unsigned int dummy;
17774 if (DW_BLOCK (attr)->data[0] == DW_OP_addr)
17775 SYMBOL_VALUE_ADDRESS (sym) =
17776 read_address (objfile->obfd, DW_BLOCK (attr)->data + 1, cu, &dummy);
17778 SYMBOL_VALUE_ADDRESS (sym) =
17779 read_addr_index_from_leb128 (cu, DW_BLOCK (attr)->data + 1, &dummy);
17780 SYMBOL_ACLASS_INDEX (sym) = LOC_STATIC;
17781 fixup_symbol_section (sym, objfile);
17782 SYMBOL_VALUE_ADDRESS (sym) += ANOFFSET (objfile->section_offsets,
17783 SYMBOL_SECTION (sym));
17787 /* NOTE drow/2002-01-30: It might be worthwhile to have a static
17788 expression evaluator, and use LOC_COMPUTED only when necessary
17789 (i.e. when the value of a register or memory location is
17790 referenced, or a thread-local block, etc.). Then again, it might
17791 not be worthwhile. I'm assuming that it isn't unless performance
17792 or memory numbers show me otherwise. */
17794 dwarf2_symbol_mark_computed (attr, sym, cu, 0);
17796 if (SYMBOL_COMPUTED_OPS (sym)->location_has_loclist)
17797 cu->has_loclist = 1;
17800 /* Given a pointer to a DWARF information entry, figure out if we need
17801 to make a symbol table entry for it, and if so, create a new entry
17802 and return a pointer to it.
17803 If TYPE is NULL, determine symbol type from the die, otherwise
17804 used the passed type.
17805 If SPACE is not NULL, use it to hold the new symbol. If it is
17806 NULL, allocate a new symbol on the objfile's obstack. */
17808 static struct symbol *
17809 new_symbol_full (struct die_info *die, struct type *type, struct dwarf2_cu *cu,
17810 struct symbol *space)
17812 struct objfile *objfile = cu->objfile;
17813 struct symbol *sym = NULL;
17815 struct attribute *attr = NULL;
17816 struct attribute *attr2 = NULL;
17817 CORE_ADDR baseaddr;
17818 struct pending **list_to_add = NULL;
17820 int inlined_func = (die->tag == DW_TAG_inlined_subroutine);
17822 baseaddr = ANOFFSET (objfile->section_offsets, SECT_OFF_TEXT (objfile));
17824 name = dwarf2_name (die, cu);
17827 const char *linkagename;
17828 int suppress_add = 0;
17833 sym = allocate_symbol (objfile);
17834 OBJSTAT (objfile, n_syms++);
17836 /* Cache this symbol's name and the name's demangled form (if any). */
17837 SYMBOL_SET_LANGUAGE (sym, cu->language, &objfile->objfile_obstack);
17838 linkagename = dwarf2_physname (name, die, cu);
17839 SYMBOL_SET_NAMES (sym, linkagename, strlen (linkagename), 0, objfile);
17841 /* Fortran does not have mangling standard and the mangling does differ
17842 between gfortran, iFort etc. */
17843 if (cu->language == language_fortran
17844 && symbol_get_demangled_name (&(sym->ginfo)) == NULL)
17845 symbol_set_demangled_name (&(sym->ginfo),
17846 dwarf2_full_name (name, die, cu),
17849 /* Default assumptions.
17850 Use the passed type or decode it from the die. */
17851 SYMBOL_DOMAIN (sym) = VAR_DOMAIN;
17852 SYMBOL_ACLASS_INDEX (sym) = LOC_OPTIMIZED_OUT;
17854 SYMBOL_TYPE (sym) = type;
17856 SYMBOL_TYPE (sym) = die_type (die, cu);
17857 attr = dwarf2_attr (die,
17858 inlined_func ? DW_AT_call_line : DW_AT_decl_line,
17862 SYMBOL_LINE (sym) = DW_UNSND (attr);
17865 attr = dwarf2_attr (die,
17866 inlined_func ? DW_AT_call_file : DW_AT_decl_file,
17870 int file_index = DW_UNSND (attr);
17872 if (cu->line_header == NULL
17873 || file_index > cu->line_header->num_file_names)
17874 complaint (&symfile_complaints,
17875 _("file index out of range"));
17876 else if (file_index > 0)
17878 struct file_entry *fe;
17880 fe = &cu->line_header->file_names[file_index - 1];
17881 SYMBOL_SYMTAB (sym) = fe->symtab;
17888 attr = dwarf2_attr (die, DW_AT_low_pc, cu);
17890 SYMBOL_VALUE_ADDRESS (sym)
17891 = attr_value_as_address (attr) + baseaddr;
17892 SYMBOL_TYPE (sym) = objfile_type (objfile)->builtin_core_addr;
17893 SYMBOL_DOMAIN (sym) = LABEL_DOMAIN;
17894 SYMBOL_ACLASS_INDEX (sym) = LOC_LABEL;
17895 add_symbol_to_list (sym, cu->list_in_scope);
17897 case DW_TAG_subprogram:
17898 /* SYMBOL_BLOCK_VALUE (sym) will be filled in later by
17900 SYMBOL_ACLASS_INDEX (sym) = LOC_BLOCK;
17901 attr2 = dwarf2_attr (die, DW_AT_external, cu);
17902 if ((attr2 && (DW_UNSND (attr2) != 0))
17903 || cu->language == language_ada)
17905 /* Subprograms marked external are stored as a global symbol.
17906 Ada subprograms, whether marked external or not, are always
17907 stored as a global symbol, because we want to be able to
17908 access them globally. For instance, we want to be able
17909 to break on a nested subprogram without having to
17910 specify the context. */
17911 list_to_add = &global_symbols;
17915 list_to_add = cu->list_in_scope;
17918 case DW_TAG_inlined_subroutine:
17919 /* SYMBOL_BLOCK_VALUE (sym) will be filled in later by
17921 SYMBOL_ACLASS_INDEX (sym) = LOC_BLOCK;
17922 SYMBOL_INLINED (sym) = 1;
17923 list_to_add = cu->list_in_scope;
17925 case DW_TAG_template_value_param:
17927 /* Fall through. */
17928 case DW_TAG_constant:
17929 case DW_TAG_variable:
17930 case DW_TAG_member:
17931 /* Compilation with minimal debug info may result in
17932 variables with missing type entries. Change the
17933 misleading `void' type to something sensible. */
17934 if (TYPE_CODE (SYMBOL_TYPE (sym)) == TYPE_CODE_VOID)
17936 = objfile_type (objfile)->nodebug_data_symbol;
17938 attr = dwarf2_attr (die, DW_AT_const_value, cu);
17939 /* In the case of DW_TAG_member, we should only be called for
17940 static const members. */
17941 if (die->tag == DW_TAG_member)
17943 /* dwarf2_add_field uses die_is_declaration,
17944 so we do the same. */
17945 gdb_assert (die_is_declaration (die, cu));
17950 dwarf2_const_value (attr, sym, cu);
17951 attr2 = dwarf2_attr (die, DW_AT_external, cu);
17954 if (attr2 && (DW_UNSND (attr2) != 0))
17955 list_to_add = &global_symbols;
17957 list_to_add = cu->list_in_scope;
17961 attr = dwarf2_attr (die, DW_AT_location, cu);
17964 var_decode_location (attr, sym, cu);
17965 attr2 = dwarf2_attr (die, DW_AT_external, cu);
17967 /* Fortran explicitly imports any global symbols to the local
17968 scope by DW_TAG_common_block. */
17969 if (cu->language == language_fortran && die->parent
17970 && die->parent->tag == DW_TAG_common_block)
17973 if (SYMBOL_CLASS (sym) == LOC_STATIC
17974 && SYMBOL_VALUE_ADDRESS (sym) == 0
17975 && !dwarf2_per_objfile->has_section_at_zero)
17977 /* When a static variable is eliminated by the linker,
17978 the corresponding debug information is not stripped
17979 out, but the variable address is set to null;
17980 do not add such variables into symbol table. */
17982 else if (attr2 && (DW_UNSND (attr2) != 0))
17984 /* Workaround gfortran PR debug/40040 - it uses
17985 DW_AT_location for variables in -fPIC libraries which may
17986 get overriden by other libraries/executable and get
17987 a different address. Resolve it by the minimal symbol
17988 which may come from inferior's executable using copy
17989 relocation. Make this workaround only for gfortran as for
17990 other compilers GDB cannot guess the minimal symbol
17991 Fortran mangling kind. */
17992 if (cu->language == language_fortran && die->parent
17993 && die->parent->tag == DW_TAG_module
17995 && strncmp (cu->producer, "GNU Fortran ", 12) == 0)
17996 SYMBOL_ACLASS_INDEX (sym) = LOC_UNRESOLVED;
17998 /* A variable with DW_AT_external is never static,
17999 but it may be block-scoped. */
18000 list_to_add = (cu->list_in_scope == &file_symbols
18001 ? &global_symbols : cu->list_in_scope);
18004 list_to_add = cu->list_in_scope;
18008 /* We do not know the address of this symbol.
18009 If it is an external symbol and we have type information
18010 for it, enter the symbol as a LOC_UNRESOLVED symbol.
18011 The address of the variable will then be determined from
18012 the minimal symbol table whenever the variable is
18014 attr2 = dwarf2_attr (die, DW_AT_external, cu);
18016 /* Fortran explicitly imports any global symbols to the local
18017 scope by DW_TAG_common_block. */
18018 if (cu->language == language_fortran && die->parent
18019 && die->parent->tag == DW_TAG_common_block)
18021 /* SYMBOL_CLASS doesn't matter here because
18022 read_common_block is going to reset it. */
18024 list_to_add = cu->list_in_scope;
18026 else if (attr2 && (DW_UNSND (attr2) != 0)
18027 && dwarf2_attr (die, DW_AT_type, cu) != NULL)
18029 /* A variable with DW_AT_external is never static, but it
18030 may be block-scoped. */
18031 list_to_add = (cu->list_in_scope == &file_symbols
18032 ? &global_symbols : cu->list_in_scope);
18034 SYMBOL_ACLASS_INDEX (sym) = LOC_UNRESOLVED;
18036 else if (!die_is_declaration (die, cu))
18038 /* Use the default LOC_OPTIMIZED_OUT class. */
18039 gdb_assert (SYMBOL_CLASS (sym) == LOC_OPTIMIZED_OUT);
18041 list_to_add = cu->list_in_scope;
18045 case DW_TAG_formal_parameter:
18046 /* If we are inside a function, mark this as an argument. If
18047 not, we might be looking at an argument to an inlined function
18048 when we do not have enough information to show inlined frames;
18049 pretend it's a local variable in that case so that the user can
18051 if (context_stack_depth > 0
18052 && context_stack[context_stack_depth - 1].name != NULL)
18053 SYMBOL_IS_ARGUMENT (sym) = 1;
18054 attr = dwarf2_attr (die, DW_AT_location, cu);
18057 var_decode_location (attr, sym, cu);
18059 attr = dwarf2_attr (die, DW_AT_const_value, cu);
18062 dwarf2_const_value (attr, sym, cu);
18065 list_to_add = cu->list_in_scope;
18067 case DW_TAG_unspecified_parameters:
18068 /* From varargs functions; gdb doesn't seem to have any
18069 interest in this information, so just ignore it for now.
18072 case DW_TAG_template_type_param:
18074 /* Fall through. */
18075 case DW_TAG_class_type:
18076 case DW_TAG_interface_type:
18077 case DW_TAG_structure_type:
18078 case DW_TAG_union_type:
18079 case DW_TAG_set_type:
18080 case DW_TAG_enumeration_type:
18081 SYMBOL_ACLASS_INDEX (sym) = LOC_TYPEDEF;
18082 SYMBOL_DOMAIN (sym) = STRUCT_DOMAIN;
18085 /* NOTE: carlton/2003-11-10: C++ and Java class symbols shouldn't
18086 really ever be static objects: otherwise, if you try
18087 to, say, break of a class's method and you're in a file
18088 which doesn't mention that class, it won't work unless
18089 the check for all static symbols in lookup_symbol_aux
18090 saves you. See the OtherFileClass tests in
18091 gdb.c++/namespace.exp. */
18095 list_to_add = (cu->list_in_scope == &file_symbols
18096 && (cu->language == language_cplus
18097 || cu->language == language_java)
18098 ? &global_symbols : cu->list_in_scope);
18100 /* The semantics of C++ state that "struct foo {
18101 ... }" also defines a typedef for "foo". A Java
18102 class declaration also defines a typedef for the
18104 if (cu->language == language_cplus
18105 || cu->language == language_java
18106 || cu->language == language_ada)
18108 /* The symbol's name is already allocated along
18109 with this objfile, so we don't need to
18110 duplicate it for the type. */
18111 if (TYPE_NAME (SYMBOL_TYPE (sym)) == 0)
18112 TYPE_NAME (SYMBOL_TYPE (sym)) = SYMBOL_SEARCH_NAME (sym);
18117 case DW_TAG_typedef:
18118 SYMBOL_ACLASS_INDEX (sym) = LOC_TYPEDEF;
18119 SYMBOL_DOMAIN (sym) = VAR_DOMAIN;
18120 list_to_add = cu->list_in_scope;
18122 case DW_TAG_base_type:
18123 case DW_TAG_subrange_type:
18124 SYMBOL_ACLASS_INDEX (sym) = LOC_TYPEDEF;
18125 SYMBOL_DOMAIN (sym) = VAR_DOMAIN;
18126 list_to_add = cu->list_in_scope;
18128 case DW_TAG_enumerator:
18129 attr = dwarf2_attr (die, DW_AT_const_value, cu);
18132 dwarf2_const_value (attr, sym, cu);
18135 /* NOTE: carlton/2003-11-10: See comment above in the
18136 DW_TAG_class_type, etc. block. */
18138 list_to_add = (cu->list_in_scope == &file_symbols
18139 && (cu->language == language_cplus
18140 || cu->language == language_java)
18141 ? &global_symbols : cu->list_in_scope);
18144 case DW_TAG_imported_declaration:
18145 case DW_TAG_namespace:
18146 SYMBOL_ACLASS_INDEX (sym) = LOC_TYPEDEF;
18147 list_to_add = &global_symbols;
18149 case DW_TAG_module:
18150 SYMBOL_ACLASS_INDEX (sym) = LOC_TYPEDEF;
18151 SYMBOL_DOMAIN (sym) = MODULE_DOMAIN;
18152 list_to_add = &global_symbols;
18154 case DW_TAG_common_block:
18155 SYMBOL_ACLASS_INDEX (sym) = LOC_COMMON_BLOCK;
18156 SYMBOL_DOMAIN (sym) = COMMON_BLOCK_DOMAIN;
18157 add_symbol_to_list (sym, cu->list_in_scope);
18160 /* Not a tag we recognize. Hopefully we aren't processing
18161 trash data, but since we must specifically ignore things
18162 we don't recognize, there is nothing else we should do at
18164 complaint (&symfile_complaints, _("unsupported tag: '%s'"),
18165 dwarf_tag_name (die->tag));
18171 sym->hash_next = objfile->template_symbols;
18172 objfile->template_symbols = sym;
18173 list_to_add = NULL;
18176 if (list_to_add != NULL)
18177 add_symbol_to_list (sym, list_to_add);
18179 /* For the benefit of old versions of GCC, check for anonymous
18180 namespaces based on the demangled name. */
18181 if (!cu->processing_has_namespace_info
18182 && cu->language == language_cplus)
18183 cp_scan_for_anonymous_namespaces (sym, objfile);
18188 /* A wrapper for new_symbol_full that always allocates a new symbol. */
18190 static struct symbol *
18191 new_symbol (struct die_info *die, struct type *type, struct dwarf2_cu *cu)
18193 return new_symbol_full (die, type, cu, NULL);
18196 /* Given an attr with a DW_FORM_dataN value in host byte order,
18197 zero-extend it as appropriate for the symbol's type. The DWARF
18198 standard (v4) is not entirely clear about the meaning of using
18199 DW_FORM_dataN for a constant with a signed type, where the type is
18200 wider than the data. The conclusion of a discussion on the DWARF
18201 list was that this is unspecified. We choose to always zero-extend
18202 because that is the interpretation long in use by GCC. */
18205 dwarf2_const_value_data (const struct attribute *attr, struct obstack *obstack,
18206 struct dwarf2_cu *cu, LONGEST *value, int bits)
18208 struct objfile *objfile = cu->objfile;
18209 enum bfd_endian byte_order = bfd_big_endian (objfile->obfd) ?
18210 BFD_ENDIAN_BIG : BFD_ENDIAN_LITTLE;
18211 LONGEST l = DW_UNSND (attr);
18213 if (bits < sizeof (*value) * 8)
18215 l &= ((LONGEST) 1 << bits) - 1;
18218 else if (bits == sizeof (*value) * 8)
18222 gdb_byte *bytes = obstack_alloc (obstack, bits / 8);
18223 store_unsigned_integer (bytes, bits / 8, byte_order, l);
18230 /* Read a constant value from an attribute. Either set *VALUE, or if
18231 the value does not fit in *VALUE, set *BYTES - either already
18232 allocated on the objfile obstack, or newly allocated on OBSTACK,
18233 or, set *BATON, if we translated the constant to a location
18237 dwarf2_const_value_attr (const struct attribute *attr, struct type *type,
18238 const char *name, struct obstack *obstack,
18239 struct dwarf2_cu *cu,
18240 LONGEST *value, const gdb_byte **bytes,
18241 struct dwarf2_locexpr_baton **baton)
18243 struct objfile *objfile = cu->objfile;
18244 struct comp_unit_head *cu_header = &cu->header;
18245 struct dwarf_block *blk;
18246 enum bfd_endian byte_order = (bfd_big_endian (objfile->obfd) ?
18247 BFD_ENDIAN_BIG : BFD_ENDIAN_LITTLE);
18253 switch (attr->form)
18256 case DW_FORM_GNU_addr_index:
18260 if (TYPE_LENGTH (type) != cu_header->addr_size)
18261 dwarf2_const_value_length_mismatch_complaint (name,
18262 cu_header->addr_size,
18263 TYPE_LENGTH (type));
18264 /* Symbols of this form are reasonably rare, so we just
18265 piggyback on the existing location code rather than writing
18266 a new implementation of symbol_computed_ops. */
18267 *baton = obstack_alloc (obstack, sizeof (struct dwarf2_locexpr_baton));
18268 (*baton)->per_cu = cu->per_cu;
18269 gdb_assert ((*baton)->per_cu);
18271 (*baton)->size = 2 + cu_header->addr_size;
18272 data = obstack_alloc (obstack, (*baton)->size);
18273 (*baton)->data = data;
18275 data[0] = DW_OP_addr;
18276 store_unsigned_integer (&data[1], cu_header->addr_size,
18277 byte_order, DW_ADDR (attr));
18278 data[cu_header->addr_size + 1] = DW_OP_stack_value;
18281 case DW_FORM_string:
18283 case DW_FORM_GNU_str_index:
18284 case DW_FORM_GNU_strp_alt:
18285 /* DW_STRING is already allocated on the objfile obstack, point
18287 *bytes = (const gdb_byte *) DW_STRING (attr);
18289 case DW_FORM_block1:
18290 case DW_FORM_block2:
18291 case DW_FORM_block4:
18292 case DW_FORM_block:
18293 case DW_FORM_exprloc:
18294 blk = DW_BLOCK (attr);
18295 if (TYPE_LENGTH (type) != blk->size)
18296 dwarf2_const_value_length_mismatch_complaint (name, blk->size,
18297 TYPE_LENGTH (type));
18298 *bytes = blk->data;
18301 /* The DW_AT_const_value attributes are supposed to carry the
18302 symbol's value "represented as it would be on the target
18303 architecture." By the time we get here, it's already been
18304 converted to host endianness, so we just need to sign- or
18305 zero-extend it as appropriate. */
18306 case DW_FORM_data1:
18307 *bytes = dwarf2_const_value_data (attr, obstack, cu, value, 8);
18309 case DW_FORM_data2:
18310 *bytes = dwarf2_const_value_data (attr, obstack, cu, value, 16);
18312 case DW_FORM_data4:
18313 *bytes = dwarf2_const_value_data (attr, obstack, cu, value, 32);
18315 case DW_FORM_data8:
18316 *bytes = dwarf2_const_value_data (attr, obstack, cu, value, 64);
18319 case DW_FORM_sdata:
18320 *value = DW_SND (attr);
18323 case DW_FORM_udata:
18324 *value = DW_UNSND (attr);
18328 complaint (&symfile_complaints,
18329 _("unsupported const value attribute form: '%s'"),
18330 dwarf_form_name (attr->form));
18337 /* Copy constant value from an attribute to a symbol. */
18340 dwarf2_const_value (const struct attribute *attr, struct symbol *sym,
18341 struct dwarf2_cu *cu)
18343 struct objfile *objfile = cu->objfile;
18344 struct comp_unit_head *cu_header = &cu->header;
18346 const gdb_byte *bytes;
18347 struct dwarf2_locexpr_baton *baton;
18349 dwarf2_const_value_attr (attr, SYMBOL_TYPE (sym),
18350 SYMBOL_PRINT_NAME (sym),
18351 &objfile->objfile_obstack, cu,
18352 &value, &bytes, &baton);
18356 SYMBOL_LOCATION_BATON (sym) = baton;
18357 SYMBOL_ACLASS_INDEX (sym) = dwarf2_locexpr_index;
18359 else if (bytes != NULL)
18361 SYMBOL_VALUE_BYTES (sym) = bytes;
18362 SYMBOL_ACLASS_INDEX (sym) = LOC_CONST_BYTES;
18366 SYMBOL_VALUE (sym) = value;
18367 SYMBOL_ACLASS_INDEX (sym) = LOC_CONST;
18371 /* Return the type of the die in question using its DW_AT_type attribute. */
18373 static struct type *
18374 die_type (struct die_info *die, struct dwarf2_cu *cu)
18376 struct attribute *type_attr;
18378 type_attr = dwarf2_attr (die, DW_AT_type, cu);
18381 /* A missing DW_AT_type represents a void type. */
18382 return objfile_type (cu->objfile)->builtin_void;
18385 return lookup_die_type (die, type_attr, cu);
18388 /* True iff CU's producer generates GNAT Ada auxiliary information
18389 that allows to find parallel types through that information instead
18390 of having to do expensive parallel lookups by type name. */
18393 need_gnat_info (struct dwarf2_cu *cu)
18395 /* FIXME: brobecker/2010-10-12: As of now, only the AdaCore version
18396 of GNAT produces this auxiliary information, without any indication
18397 that it is produced. Part of enhancing the FSF version of GNAT
18398 to produce that information will be to put in place an indicator
18399 that we can use in order to determine whether the descriptive type
18400 info is available or not. One suggestion that has been made is
18401 to use a new attribute, attached to the CU die. For now, assume
18402 that the descriptive type info is not available. */
18406 /* Return the auxiliary type of the die in question using its
18407 DW_AT_GNAT_descriptive_type attribute. Returns NULL if the
18408 attribute is not present. */
18410 static struct type *
18411 die_descriptive_type (struct die_info *die, struct dwarf2_cu *cu)
18413 struct attribute *type_attr;
18415 type_attr = dwarf2_attr (die, DW_AT_GNAT_descriptive_type, cu);
18419 return lookup_die_type (die, type_attr, cu);
18422 /* If DIE has a descriptive_type attribute, then set the TYPE's
18423 descriptive type accordingly. */
18426 set_descriptive_type (struct type *type, struct die_info *die,
18427 struct dwarf2_cu *cu)
18429 struct type *descriptive_type = die_descriptive_type (die, cu);
18431 if (descriptive_type)
18433 ALLOCATE_GNAT_AUX_TYPE (type);
18434 TYPE_DESCRIPTIVE_TYPE (type) = descriptive_type;
18438 /* Return the containing type of the die in question using its
18439 DW_AT_containing_type attribute. */
18441 static struct type *
18442 die_containing_type (struct die_info *die, struct dwarf2_cu *cu)
18444 struct attribute *type_attr;
18446 type_attr = dwarf2_attr (die, DW_AT_containing_type, cu);
18448 error (_("Dwarf Error: Problem turning containing type into gdb type "
18449 "[in module %s]"), objfile_name (cu->objfile));
18451 return lookup_die_type (die, type_attr, cu);
18454 /* Return an error marker type to use for the ill formed type in DIE/CU. */
18456 static struct type *
18457 build_error_marker_type (struct dwarf2_cu *cu, struct die_info *die)
18459 struct objfile *objfile = dwarf2_per_objfile->objfile;
18460 char *message, *saved;
18462 message = xstrprintf (_("<unknown type in %s, CU 0x%x, DIE 0x%x>"),
18463 objfile_name (objfile),
18464 cu->header.offset.sect_off,
18465 die->offset.sect_off);
18466 saved = obstack_copy0 (&objfile->objfile_obstack,
18467 message, strlen (message));
18470 return init_type (TYPE_CODE_ERROR, 0, 0, saved, objfile);
18473 /* Look up the type of DIE in CU using its type attribute ATTR.
18474 ATTR must be one of: DW_AT_type, DW_AT_GNAT_descriptive_type,
18475 DW_AT_containing_type.
18476 If there is no type substitute an error marker. */
18478 static struct type *
18479 lookup_die_type (struct die_info *die, const struct attribute *attr,
18480 struct dwarf2_cu *cu)
18482 struct objfile *objfile = cu->objfile;
18483 struct type *this_type;
18485 gdb_assert (attr->name == DW_AT_type
18486 || attr->name == DW_AT_GNAT_descriptive_type
18487 || attr->name == DW_AT_containing_type);
18489 /* First see if we have it cached. */
18491 if (attr->form == DW_FORM_GNU_ref_alt)
18493 struct dwarf2_per_cu_data *per_cu;
18494 sect_offset offset = dwarf2_get_ref_die_offset (attr);
18496 per_cu = dwarf2_find_containing_comp_unit (offset, 1, cu->objfile);
18497 this_type = get_die_type_at_offset (offset, per_cu);
18499 else if (attr_form_is_ref (attr))
18501 sect_offset offset = dwarf2_get_ref_die_offset (attr);
18503 this_type = get_die_type_at_offset (offset, cu->per_cu);
18505 else if (attr->form == DW_FORM_ref_sig8)
18507 ULONGEST signature = DW_SIGNATURE (attr);
18509 return get_signatured_type (die, signature, cu);
18513 complaint (&symfile_complaints,
18514 _("Dwarf Error: Bad type attribute %s in DIE"
18515 " at 0x%x [in module %s]"),
18516 dwarf_attr_name (attr->name), die->offset.sect_off,
18517 objfile_name (objfile));
18518 return build_error_marker_type (cu, die);
18521 /* If not cached we need to read it in. */
18523 if (this_type == NULL)
18525 struct die_info *type_die = NULL;
18526 struct dwarf2_cu *type_cu = cu;
18528 if (attr_form_is_ref (attr))
18529 type_die = follow_die_ref (die, attr, &type_cu);
18530 if (type_die == NULL)
18531 return build_error_marker_type (cu, die);
18532 /* If we find the type now, it's probably because the type came
18533 from an inter-CU reference and the type's CU got expanded before
18535 this_type = read_type_die (type_die, type_cu);
18538 /* If we still don't have a type use an error marker. */
18540 if (this_type == NULL)
18541 return build_error_marker_type (cu, die);
18546 /* Return the type in DIE, CU.
18547 Returns NULL for invalid types.
18549 This first does a lookup in die_type_hash,
18550 and only reads the die in if necessary.
18552 NOTE: This can be called when reading in partial or full symbols. */
18554 static struct type *
18555 read_type_die (struct die_info *die, struct dwarf2_cu *cu)
18557 struct type *this_type;
18559 this_type = get_die_type (die, cu);
18563 return read_type_die_1 (die, cu);
18566 /* Read the type in DIE, CU.
18567 Returns NULL for invalid types. */
18569 static struct type *
18570 read_type_die_1 (struct die_info *die, struct dwarf2_cu *cu)
18572 struct type *this_type = NULL;
18576 case DW_TAG_class_type:
18577 case DW_TAG_interface_type:
18578 case DW_TAG_structure_type:
18579 case DW_TAG_union_type:
18580 this_type = read_structure_type (die, cu);
18582 case DW_TAG_enumeration_type:
18583 this_type = read_enumeration_type (die, cu);
18585 case DW_TAG_subprogram:
18586 case DW_TAG_subroutine_type:
18587 case DW_TAG_inlined_subroutine:
18588 this_type = read_subroutine_type (die, cu);
18590 case DW_TAG_array_type:
18591 this_type = read_array_type (die, cu);
18593 case DW_TAG_set_type:
18594 this_type = read_set_type (die, cu);
18596 case DW_TAG_pointer_type:
18597 this_type = read_tag_pointer_type (die, cu);
18599 case DW_TAG_ptr_to_member_type:
18600 this_type = read_tag_ptr_to_member_type (die, cu);
18602 case DW_TAG_reference_type:
18603 this_type = read_tag_reference_type (die, cu);
18605 case DW_TAG_const_type:
18606 this_type = read_tag_const_type (die, cu);
18608 case DW_TAG_volatile_type:
18609 this_type = read_tag_volatile_type (die, cu);
18611 case DW_TAG_restrict_type:
18612 this_type = read_tag_restrict_type (die, cu);
18614 case DW_TAG_string_type:
18615 this_type = read_tag_string_type (die, cu);
18617 case DW_TAG_typedef:
18618 this_type = read_typedef (die, cu);
18620 case DW_TAG_subrange_type:
18621 this_type = read_subrange_type (die, cu);
18623 case DW_TAG_base_type:
18624 this_type = read_base_type (die, cu);
18626 case DW_TAG_unspecified_type:
18627 this_type = read_unspecified_type (die, cu);
18629 case DW_TAG_namespace:
18630 this_type = read_namespace_type (die, cu);
18632 case DW_TAG_module:
18633 this_type = read_module_type (die, cu);
18636 complaint (&symfile_complaints,
18637 _("unexpected tag in read_type_die: '%s'"),
18638 dwarf_tag_name (die->tag));
18645 /* See if we can figure out if the class lives in a namespace. We do
18646 this by looking for a member function; its demangled name will
18647 contain namespace info, if there is any.
18648 Return the computed name or NULL.
18649 Space for the result is allocated on the objfile's obstack.
18650 This is the full-die version of guess_partial_die_structure_name.
18651 In this case we know DIE has no useful parent. */
18654 guess_full_die_structure_name (struct die_info *die, struct dwarf2_cu *cu)
18656 struct die_info *spec_die;
18657 struct dwarf2_cu *spec_cu;
18658 struct die_info *child;
18661 spec_die = die_specification (die, &spec_cu);
18662 if (spec_die != NULL)
18668 for (child = die->child;
18670 child = child->sibling)
18672 if (child->tag == DW_TAG_subprogram)
18674 struct attribute *attr;
18676 attr = dwarf2_attr (child, DW_AT_linkage_name, cu);
18678 attr = dwarf2_attr (child, DW_AT_MIPS_linkage_name, cu);
18682 = language_class_name_from_physname (cu->language_defn,
18686 if (actual_name != NULL)
18688 const char *die_name = dwarf2_name (die, cu);
18690 if (die_name != NULL
18691 && strcmp (die_name, actual_name) != 0)
18693 /* Strip off the class name from the full name.
18694 We want the prefix. */
18695 int die_name_len = strlen (die_name);
18696 int actual_name_len = strlen (actual_name);
18698 /* Test for '::' as a sanity check. */
18699 if (actual_name_len > die_name_len + 2
18700 && actual_name[actual_name_len
18701 - die_name_len - 1] == ':')
18703 obstack_copy0 (&cu->objfile->per_bfd->storage_obstack,
18705 actual_name_len - die_name_len - 2);
18708 xfree (actual_name);
18717 /* GCC might emit a nameless typedef that has a linkage name. Determine the
18718 prefix part in such case. See
18719 http://gcc.gnu.org/bugzilla/show_bug.cgi?id=47510. */
18722 anonymous_struct_prefix (struct die_info *die, struct dwarf2_cu *cu)
18724 struct attribute *attr;
18727 if (die->tag != DW_TAG_class_type && die->tag != DW_TAG_interface_type
18728 && die->tag != DW_TAG_structure_type && die->tag != DW_TAG_union_type)
18731 attr = dwarf2_attr (die, DW_AT_name, cu);
18732 if (attr != NULL && DW_STRING (attr) != NULL)
18735 attr = dwarf2_attr (die, DW_AT_linkage_name, cu);
18737 attr = dwarf2_attr (die, DW_AT_MIPS_linkage_name, cu);
18738 if (attr == NULL || DW_STRING (attr) == NULL)
18741 /* dwarf2_name had to be already called. */
18742 gdb_assert (DW_STRING_IS_CANONICAL (attr));
18744 /* Strip the base name, keep any leading namespaces/classes. */
18745 base = strrchr (DW_STRING (attr), ':');
18746 if (base == NULL || base == DW_STRING (attr) || base[-1] != ':')
18749 return obstack_copy0 (&cu->objfile->per_bfd->storage_obstack,
18750 DW_STRING (attr), &base[-1] - DW_STRING (attr));
18753 /* Return the name of the namespace/class that DIE is defined within,
18754 or "" if we can't tell. The caller should not xfree the result.
18756 For example, if we're within the method foo() in the following
18766 then determine_prefix on foo's die will return "N::C". */
18768 static const char *
18769 determine_prefix (struct die_info *die, struct dwarf2_cu *cu)
18771 struct die_info *parent, *spec_die;
18772 struct dwarf2_cu *spec_cu;
18773 struct type *parent_type;
18776 if (cu->language != language_cplus && cu->language != language_java
18777 && cu->language != language_fortran)
18780 retval = anonymous_struct_prefix (die, cu);
18784 /* We have to be careful in the presence of DW_AT_specification.
18785 For example, with GCC 3.4, given the code
18789 // Definition of N::foo.
18793 then we'll have a tree of DIEs like this:
18795 1: DW_TAG_compile_unit
18796 2: DW_TAG_namespace // N
18797 3: DW_TAG_subprogram // declaration of N::foo
18798 4: DW_TAG_subprogram // definition of N::foo
18799 DW_AT_specification // refers to die #3
18801 Thus, when processing die #4, we have to pretend that we're in
18802 the context of its DW_AT_specification, namely the contex of die
18805 spec_die = die_specification (die, &spec_cu);
18806 if (spec_die == NULL)
18807 parent = die->parent;
18810 parent = spec_die->parent;
18814 if (parent == NULL)
18816 else if (parent->building_fullname)
18819 const char *parent_name;
18821 /* It has been seen on RealView 2.2 built binaries,
18822 DW_TAG_template_type_param types actually _defined_ as
18823 children of the parent class:
18826 template class <class Enum> Class{};
18827 Class<enum E> class_e;
18829 1: DW_TAG_class_type (Class)
18830 2: DW_TAG_enumeration_type (E)
18831 3: DW_TAG_enumerator (enum1:0)
18832 3: DW_TAG_enumerator (enum2:1)
18834 2: DW_TAG_template_type_param
18835 DW_AT_type DW_FORM_ref_udata (E)
18837 Besides being broken debug info, it can put GDB into an
18838 infinite loop. Consider:
18840 When we're building the full name for Class<E>, we'll start
18841 at Class, and go look over its template type parameters,
18842 finding E. We'll then try to build the full name of E, and
18843 reach here. We're now trying to build the full name of E,
18844 and look over the parent DIE for containing scope. In the
18845 broken case, if we followed the parent DIE of E, we'd again
18846 find Class, and once again go look at its template type
18847 arguments, etc., etc. Simply don't consider such parent die
18848 as source-level parent of this die (it can't be, the language
18849 doesn't allow it), and break the loop here. */
18850 name = dwarf2_name (die, cu);
18851 parent_name = dwarf2_name (parent, cu);
18852 complaint (&symfile_complaints,
18853 _("template param type '%s' defined within parent '%s'"),
18854 name ? name : "<unknown>",
18855 parent_name ? parent_name : "<unknown>");
18859 switch (parent->tag)
18861 case DW_TAG_namespace:
18862 parent_type = read_type_die (parent, cu);
18863 /* GCC 4.0 and 4.1 had a bug (PR c++/28460) where they generated bogus
18864 DW_TAG_namespace DIEs with a name of "::" for the global namespace.
18865 Work around this problem here. */
18866 if (cu->language == language_cplus
18867 && strcmp (TYPE_TAG_NAME (parent_type), "::") == 0)
18869 /* We give a name to even anonymous namespaces. */
18870 return TYPE_TAG_NAME (parent_type);
18871 case DW_TAG_class_type:
18872 case DW_TAG_interface_type:
18873 case DW_TAG_structure_type:
18874 case DW_TAG_union_type:
18875 case DW_TAG_module:
18876 parent_type = read_type_die (parent, cu);
18877 if (TYPE_TAG_NAME (parent_type) != NULL)
18878 return TYPE_TAG_NAME (parent_type);
18880 /* An anonymous structure is only allowed non-static data
18881 members; no typedefs, no member functions, et cetera.
18882 So it does not need a prefix. */
18884 case DW_TAG_compile_unit:
18885 case DW_TAG_partial_unit:
18886 /* gcc-4.5 -gdwarf-4 can drop the enclosing namespace. Cope. */
18887 if (cu->language == language_cplus
18888 && !VEC_empty (dwarf2_section_info_def, dwarf2_per_objfile->types)
18889 && die->child != NULL
18890 && (die->tag == DW_TAG_class_type
18891 || die->tag == DW_TAG_structure_type
18892 || die->tag == DW_TAG_union_type))
18894 char *name = guess_full_die_structure_name (die, cu);
18899 case DW_TAG_enumeration_type:
18900 parent_type = read_type_die (parent, cu);
18901 if (TYPE_DECLARED_CLASS (parent_type))
18903 if (TYPE_TAG_NAME (parent_type) != NULL)
18904 return TYPE_TAG_NAME (parent_type);
18907 /* Fall through. */
18909 return determine_prefix (parent, cu);
18913 /* Return a newly-allocated string formed by concatenating PREFIX and SUFFIX
18914 with appropriate separator. If PREFIX or SUFFIX is NULL or empty, then
18915 simply copy the SUFFIX or PREFIX, respectively. If OBS is non-null, perform
18916 an obconcat, otherwise allocate storage for the result. The CU argument is
18917 used to determine the language and hence, the appropriate separator. */
18919 #define MAX_SEP_LEN 7 /* strlen ("__") + strlen ("_MOD_") */
18922 typename_concat (struct obstack *obs, const char *prefix, const char *suffix,
18923 int physname, struct dwarf2_cu *cu)
18925 const char *lead = "";
18928 if (suffix == NULL || suffix[0] == '\0'
18929 || prefix == NULL || prefix[0] == '\0')
18931 else if (cu->language == language_java)
18933 else if (cu->language == language_fortran && physname)
18935 /* This is gfortran specific mangling. Normally DW_AT_linkage_name or
18936 DW_AT_MIPS_linkage_name is preferred and used instead. */
18944 if (prefix == NULL)
18946 if (suffix == NULL)
18952 = xmalloc (strlen (prefix) + MAX_SEP_LEN + strlen (suffix) + 1);
18954 strcpy (retval, lead);
18955 strcat (retval, prefix);
18956 strcat (retval, sep);
18957 strcat (retval, suffix);
18962 /* We have an obstack. */
18963 return obconcat (obs, lead, prefix, sep, suffix, (char *) NULL);
18967 /* Return sibling of die, NULL if no sibling. */
18969 static struct die_info *
18970 sibling_die (struct die_info *die)
18972 return die->sibling;
18975 /* Get name of a die, return NULL if not found. */
18977 static const char *
18978 dwarf2_canonicalize_name (const char *name, struct dwarf2_cu *cu,
18979 struct obstack *obstack)
18981 if (name && cu->language == language_cplus)
18983 char *canon_name = cp_canonicalize_string (name);
18985 if (canon_name != NULL)
18987 if (strcmp (canon_name, name) != 0)
18988 name = obstack_copy0 (obstack, canon_name, strlen (canon_name));
18989 xfree (canon_name);
18996 /* Get name of a die, return NULL if not found. */
18998 static const char *
18999 dwarf2_name (struct die_info *die, struct dwarf2_cu *cu)
19001 struct attribute *attr;
19003 attr = dwarf2_attr (die, DW_AT_name, cu);
19004 if ((!attr || !DW_STRING (attr))
19005 && die->tag != DW_TAG_class_type
19006 && die->tag != DW_TAG_interface_type
19007 && die->tag != DW_TAG_structure_type
19008 && die->tag != DW_TAG_union_type)
19013 case DW_TAG_compile_unit:
19014 case DW_TAG_partial_unit:
19015 /* Compilation units have a DW_AT_name that is a filename, not
19016 a source language identifier. */
19017 case DW_TAG_enumeration_type:
19018 case DW_TAG_enumerator:
19019 /* These tags always have simple identifiers already; no need
19020 to canonicalize them. */
19021 return DW_STRING (attr);
19023 case DW_TAG_subprogram:
19024 /* Java constructors will all be named "<init>", so return
19025 the class name when we see this special case. */
19026 if (cu->language == language_java
19027 && DW_STRING (attr) != NULL
19028 && strcmp (DW_STRING (attr), "<init>") == 0)
19030 struct dwarf2_cu *spec_cu = cu;
19031 struct die_info *spec_die;
19033 /* GCJ will output '<init>' for Java constructor names.
19034 For this special case, return the name of the parent class. */
19036 /* GCJ may output subprogram DIEs with AT_specification set.
19037 If so, use the name of the specified DIE. */
19038 spec_die = die_specification (die, &spec_cu);
19039 if (spec_die != NULL)
19040 return dwarf2_name (spec_die, spec_cu);
19045 if (die->tag == DW_TAG_class_type)
19046 return dwarf2_name (die, cu);
19048 while (die->tag != DW_TAG_compile_unit
19049 && die->tag != DW_TAG_partial_unit);
19053 case DW_TAG_class_type:
19054 case DW_TAG_interface_type:
19055 case DW_TAG_structure_type:
19056 case DW_TAG_union_type:
19057 /* Some GCC versions emit spurious DW_AT_name attributes for unnamed
19058 structures or unions. These were of the form "._%d" in GCC 4.1,
19059 or simply "<anonymous struct>" or "<anonymous union>" in GCC 4.3
19060 and GCC 4.4. We work around this problem by ignoring these. */
19061 if (attr && DW_STRING (attr)
19062 && (strncmp (DW_STRING (attr), "._", 2) == 0
19063 || strncmp (DW_STRING (attr), "<anonymous", 10) == 0))
19066 /* GCC might emit a nameless typedef that has a linkage name. See
19067 http://gcc.gnu.org/bugzilla/show_bug.cgi?id=47510. */
19068 if (!attr || DW_STRING (attr) == NULL)
19070 char *demangled = NULL;
19072 attr = dwarf2_attr (die, DW_AT_linkage_name, cu);
19074 attr = dwarf2_attr (die, DW_AT_MIPS_linkage_name, cu);
19076 if (attr == NULL || DW_STRING (attr) == NULL)
19079 /* Avoid demangling DW_STRING (attr) the second time on a second
19080 call for the same DIE. */
19081 if (!DW_STRING_IS_CANONICAL (attr))
19082 demangled = gdb_demangle (DW_STRING (attr), DMGL_TYPES);
19088 /* FIXME: we already did this for the partial symbol... */
19090 = obstack_copy0 (&cu->objfile->per_bfd->storage_obstack,
19091 demangled, strlen (demangled));
19092 DW_STRING_IS_CANONICAL (attr) = 1;
19095 /* Strip any leading namespaces/classes, keep only the base name.
19096 DW_AT_name for named DIEs does not contain the prefixes. */
19097 base = strrchr (DW_STRING (attr), ':');
19098 if (base && base > DW_STRING (attr) && base[-1] == ':')
19101 return DW_STRING (attr);
19110 if (!DW_STRING_IS_CANONICAL (attr))
19113 = dwarf2_canonicalize_name (DW_STRING (attr), cu,
19114 &cu->objfile->per_bfd->storage_obstack);
19115 DW_STRING_IS_CANONICAL (attr) = 1;
19117 return DW_STRING (attr);
19120 /* Return the die that this die in an extension of, or NULL if there
19121 is none. *EXT_CU is the CU containing DIE on input, and the CU
19122 containing the return value on output. */
19124 static struct die_info *
19125 dwarf2_extension (struct die_info *die, struct dwarf2_cu **ext_cu)
19127 struct attribute *attr;
19129 attr = dwarf2_attr (die, DW_AT_extension, *ext_cu);
19133 return follow_die_ref (die, attr, ext_cu);
19136 /* Convert a DIE tag into its string name. */
19138 static const char *
19139 dwarf_tag_name (unsigned tag)
19141 const char *name = get_DW_TAG_name (tag);
19144 return "DW_TAG_<unknown>";
19149 /* Convert a DWARF attribute code into its string name. */
19151 static const char *
19152 dwarf_attr_name (unsigned attr)
19156 #ifdef MIPS /* collides with DW_AT_HP_block_index */
19157 if (attr == DW_AT_MIPS_fde)
19158 return "DW_AT_MIPS_fde";
19160 if (attr == DW_AT_HP_block_index)
19161 return "DW_AT_HP_block_index";
19164 name = get_DW_AT_name (attr);
19167 return "DW_AT_<unknown>";
19172 /* Convert a DWARF value form code into its string name. */
19174 static const char *
19175 dwarf_form_name (unsigned form)
19177 const char *name = get_DW_FORM_name (form);
19180 return "DW_FORM_<unknown>";
19186 dwarf_bool_name (unsigned mybool)
19194 /* Convert a DWARF type code into its string name. */
19196 static const char *
19197 dwarf_type_encoding_name (unsigned enc)
19199 const char *name = get_DW_ATE_name (enc);
19202 return "DW_ATE_<unknown>";
19208 dump_die_shallow (struct ui_file *f, int indent, struct die_info *die)
19212 print_spaces (indent, f);
19213 fprintf_unfiltered (f, "Die: %s (abbrev %d, offset 0x%x)\n",
19214 dwarf_tag_name (die->tag), die->abbrev, die->offset.sect_off);
19216 if (die->parent != NULL)
19218 print_spaces (indent, f);
19219 fprintf_unfiltered (f, " parent at offset: 0x%x\n",
19220 die->parent->offset.sect_off);
19223 print_spaces (indent, f);
19224 fprintf_unfiltered (f, " has children: %s\n",
19225 dwarf_bool_name (die->child != NULL));
19227 print_spaces (indent, f);
19228 fprintf_unfiltered (f, " attributes:\n");
19230 for (i = 0; i < die->num_attrs; ++i)
19232 print_spaces (indent, f);
19233 fprintf_unfiltered (f, " %s (%s) ",
19234 dwarf_attr_name (die->attrs[i].name),
19235 dwarf_form_name (die->attrs[i].form));
19237 switch (die->attrs[i].form)
19240 case DW_FORM_GNU_addr_index:
19241 fprintf_unfiltered (f, "address: ");
19242 fputs_filtered (hex_string (DW_ADDR (&die->attrs[i])), f);
19244 case DW_FORM_block2:
19245 case DW_FORM_block4:
19246 case DW_FORM_block:
19247 case DW_FORM_block1:
19248 fprintf_unfiltered (f, "block: size %s",
19249 pulongest (DW_BLOCK (&die->attrs[i])->size));
19251 case DW_FORM_exprloc:
19252 fprintf_unfiltered (f, "expression: size %s",
19253 pulongest (DW_BLOCK (&die->attrs[i])->size));
19255 case DW_FORM_ref_addr:
19256 fprintf_unfiltered (f, "ref address: ");
19257 fputs_filtered (hex_string (DW_UNSND (&die->attrs[i])), f);
19259 case DW_FORM_GNU_ref_alt:
19260 fprintf_unfiltered (f, "alt ref address: ");
19261 fputs_filtered (hex_string (DW_UNSND (&die->attrs[i])), f);
19267 case DW_FORM_ref_udata:
19268 fprintf_unfiltered (f, "constant ref: 0x%lx (adjusted)",
19269 (long) (DW_UNSND (&die->attrs[i])));
19271 case DW_FORM_data1:
19272 case DW_FORM_data2:
19273 case DW_FORM_data4:
19274 case DW_FORM_data8:
19275 case DW_FORM_udata:
19276 case DW_FORM_sdata:
19277 fprintf_unfiltered (f, "constant: %s",
19278 pulongest (DW_UNSND (&die->attrs[i])));
19280 case DW_FORM_sec_offset:
19281 fprintf_unfiltered (f, "section offset: %s",
19282 pulongest (DW_UNSND (&die->attrs[i])));
19284 case DW_FORM_ref_sig8:
19285 fprintf_unfiltered (f, "signature: %s",
19286 hex_string (DW_SIGNATURE (&die->attrs[i])));
19288 case DW_FORM_string:
19290 case DW_FORM_GNU_str_index:
19291 case DW_FORM_GNU_strp_alt:
19292 fprintf_unfiltered (f, "string: \"%s\" (%s canonicalized)",
19293 DW_STRING (&die->attrs[i])
19294 ? DW_STRING (&die->attrs[i]) : "",
19295 DW_STRING_IS_CANONICAL (&die->attrs[i]) ? "is" : "not");
19298 if (DW_UNSND (&die->attrs[i]))
19299 fprintf_unfiltered (f, "flag: TRUE");
19301 fprintf_unfiltered (f, "flag: FALSE");
19303 case DW_FORM_flag_present:
19304 fprintf_unfiltered (f, "flag: TRUE");
19306 case DW_FORM_indirect:
19307 /* The reader will have reduced the indirect form to
19308 the "base form" so this form should not occur. */
19309 fprintf_unfiltered (f,
19310 "unexpected attribute form: DW_FORM_indirect");
19313 fprintf_unfiltered (f, "unsupported attribute form: %d.",
19314 die->attrs[i].form);
19317 fprintf_unfiltered (f, "\n");
19322 dump_die_for_error (struct die_info *die)
19324 dump_die_shallow (gdb_stderr, 0, die);
19328 dump_die_1 (struct ui_file *f, int level, int max_level, struct die_info *die)
19330 int indent = level * 4;
19332 gdb_assert (die != NULL);
19334 if (level >= max_level)
19337 dump_die_shallow (f, indent, die);
19339 if (die->child != NULL)
19341 print_spaces (indent, f);
19342 fprintf_unfiltered (f, " Children:");
19343 if (level + 1 < max_level)
19345 fprintf_unfiltered (f, "\n");
19346 dump_die_1 (f, level + 1, max_level, die->child);
19350 fprintf_unfiltered (f,
19351 " [not printed, max nesting level reached]\n");
19355 if (die->sibling != NULL && level > 0)
19357 dump_die_1 (f, level, max_level, die->sibling);
19361 /* This is called from the pdie macro in gdbinit.in.
19362 It's not static so gcc will keep a copy callable from gdb. */
19365 dump_die (struct die_info *die, int max_level)
19367 dump_die_1 (gdb_stdlog, 0, max_level, die);
19371 store_in_ref_table (struct die_info *die, struct dwarf2_cu *cu)
19375 slot = htab_find_slot_with_hash (cu->die_hash, die, die->offset.sect_off,
19381 /* Return DIE offset of ATTR. Return 0 with complaint if ATTR is not of the
19385 dwarf2_get_ref_die_offset (const struct attribute *attr)
19387 sect_offset retval = { DW_UNSND (attr) };
19389 if (attr_form_is_ref (attr))
19392 retval.sect_off = 0;
19393 complaint (&symfile_complaints,
19394 _("unsupported die ref attribute form: '%s'"),
19395 dwarf_form_name (attr->form));
19399 /* Return the constant value held by ATTR. Return DEFAULT_VALUE if
19400 * the value held by the attribute is not constant. */
19403 dwarf2_get_attr_constant_value (const struct attribute *attr, int default_value)
19405 if (attr->form == DW_FORM_sdata)
19406 return DW_SND (attr);
19407 else if (attr->form == DW_FORM_udata
19408 || attr->form == DW_FORM_data1
19409 || attr->form == DW_FORM_data2
19410 || attr->form == DW_FORM_data4
19411 || attr->form == DW_FORM_data8)
19412 return DW_UNSND (attr);
19415 complaint (&symfile_complaints,
19416 _("Attribute value is not a constant (%s)"),
19417 dwarf_form_name (attr->form));
19418 return default_value;
19422 /* Follow reference or signature attribute ATTR of SRC_DIE.
19423 On entry *REF_CU is the CU of SRC_DIE.
19424 On exit *REF_CU is the CU of the result. */
19426 static struct die_info *
19427 follow_die_ref_or_sig (struct die_info *src_die, const struct attribute *attr,
19428 struct dwarf2_cu **ref_cu)
19430 struct die_info *die;
19432 if (attr_form_is_ref (attr))
19433 die = follow_die_ref (src_die, attr, ref_cu);
19434 else if (attr->form == DW_FORM_ref_sig8)
19435 die = follow_die_sig (src_die, attr, ref_cu);
19438 dump_die_for_error (src_die);
19439 error (_("Dwarf Error: Expected reference attribute [in module %s]"),
19440 objfile_name ((*ref_cu)->objfile));
19446 /* Follow reference OFFSET.
19447 On entry *REF_CU is the CU of the source die referencing OFFSET.
19448 On exit *REF_CU is the CU of the result.
19449 Returns NULL if OFFSET is invalid. */
19451 static struct die_info *
19452 follow_die_offset (sect_offset offset, int offset_in_dwz,
19453 struct dwarf2_cu **ref_cu)
19455 struct die_info temp_die;
19456 struct dwarf2_cu *target_cu, *cu = *ref_cu;
19458 gdb_assert (cu->per_cu != NULL);
19462 if (cu->per_cu->is_debug_types)
19464 /* .debug_types CUs cannot reference anything outside their CU.
19465 If they need to, they have to reference a signatured type via
19466 DW_FORM_ref_sig8. */
19467 if (! offset_in_cu_p (&cu->header, offset))
19470 else if (offset_in_dwz != cu->per_cu->is_dwz
19471 || ! offset_in_cu_p (&cu->header, offset))
19473 struct dwarf2_per_cu_data *per_cu;
19475 per_cu = dwarf2_find_containing_comp_unit (offset, offset_in_dwz,
19478 /* If necessary, add it to the queue and load its DIEs. */
19479 if (maybe_queue_comp_unit (cu, per_cu, cu->language))
19480 load_full_comp_unit (per_cu, cu->language);
19482 target_cu = per_cu->cu;
19484 else if (cu->dies == NULL)
19486 /* We're loading full DIEs during partial symbol reading. */
19487 gdb_assert (dwarf2_per_objfile->reading_partial_symbols);
19488 load_full_comp_unit (cu->per_cu, language_minimal);
19491 *ref_cu = target_cu;
19492 temp_die.offset = offset;
19493 return htab_find_with_hash (target_cu->die_hash, &temp_die, offset.sect_off);
19496 /* Follow reference attribute ATTR of SRC_DIE.
19497 On entry *REF_CU is the CU of SRC_DIE.
19498 On exit *REF_CU is the CU of the result. */
19500 static struct die_info *
19501 follow_die_ref (struct die_info *src_die, const struct attribute *attr,
19502 struct dwarf2_cu **ref_cu)
19504 sect_offset offset = dwarf2_get_ref_die_offset (attr);
19505 struct dwarf2_cu *cu = *ref_cu;
19506 struct die_info *die;
19508 die = follow_die_offset (offset,
19509 (attr->form == DW_FORM_GNU_ref_alt
19510 || cu->per_cu->is_dwz),
19513 error (_("Dwarf Error: Cannot find DIE at 0x%x referenced from DIE "
19514 "at 0x%x [in module %s]"),
19515 offset.sect_off, src_die->offset.sect_off,
19516 objfile_name (cu->objfile));
19521 /* Return DWARF block referenced by DW_AT_location of DIE at OFFSET at PER_CU.
19522 Returned value is intended for DW_OP_call*. Returned
19523 dwarf2_locexpr_baton->data has lifetime of PER_CU->OBJFILE. */
19525 struct dwarf2_locexpr_baton
19526 dwarf2_fetch_die_loc_sect_off (sect_offset offset,
19527 struct dwarf2_per_cu_data *per_cu,
19528 CORE_ADDR (*get_frame_pc) (void *baton),
19531 struct dwarf2_cu *cu;
19532 struct die_info *die;
19533 struct attribute *attr;
19534 struct dwarf2_locexpr_baton retval;
19536 dw2_setup (per_cu->objfile);
19538 if (per_cu->cu == NULL)
19542 die = follow_die_offset (offset, per_cu->is_dwz, &cu);
19544 error (_("Dwarf Error: Cannot find DIE at 0x%x referenced in module %s"),
19545 offset.sect_off, objfile_name (per_cu->objfile));
19547 attr = dwarf2_attr (die, DW_AT_location, cu);
19550 /* DWARF: "If there is no such attribute, then there is no effect.".
19551 DATA is ignored if SIZE is 0. */
19553 retval.data = NULL;
19556 else if (attr_form_is_section_offset (attr))
19558 struct dwarf2_loclist_baton loclist_baton;
19559 CORE_ADDR pc = (*get_frame_pc) (baton);
19562 fill_in_loclist_baton (cu, &loclist_baton, attr);
19564 retval.data = dwarf2_find_location_expression (&loclist_baton,
19566 retval.size = size;
19570 if (!attr_form_is_block (attr))
19571 error (_("Dwarf Error: DIE at 0x%x referenced in module %s "
19572 "is neither DW_FORM_block* nor DW_FORM_exprloc"),
19573 offset.sect_off, objfile_name (per_cu->objfile));
19575 retval.data = DW_BLOCK (attr)->data;
19576 retval.size = DW_BLOCK (attr)->size;
19578 retval.per_cu = cu->per_cu;
19580 age_cached_comp_units ();
19585 /* Like dwarf2_fetch_die_loc_sect_off, but take a CU
19588 struct dwarf2_locexpr_baton
19589 dwarf2_fetch_die_loc_cu_off (cu_offset offset_in_cu,
19590 struct dwarf2_per_cu_data *per_cu,
19591 CORE_ADDR (*get_frame_pc) (void *baton),
19594 sect_offset offset = { per_cu->offset.sect_off + offset_in_cu.cu_off };
19596 return dwarf2_fetch_die_loc_sect_off (offset, per_cu, get_frame_pc, baton);
19599 /* Write a constant of a given type as target-ordered bytes into
19602 static const gdb_byte *
19603 write_constant_as_bytes (struct obstack *obstack,
19604 enum bfd_endian byte_order,
19611 *len = TYPE_LENGTH (type);
19612 result = obstack_alloc (obstack, *len);
19613 store_unsigned_integer (result, *len, byte_order, value);
19618 /* If the DIE at OFFSET in PER_CU has a DW_AT_const_value, return a
19619 pointer to the constant bytes and set LEN to the length of the
19620 data. If memory is needed, allocate it on OBSTACK. If the DIE
19621 does not have a DW_AT_const_value, return NULL. */
19624 dwarf2_fetch_constant_bytes (sect_offset offset,
19625 struct dwarf2_per_cu_data *per_cu,
19626 struct obstack *obstack,
19629 struct dwarf2_cu *cu;
19630 struct die_info *die;
19631 struct attribute *attr;
19632 const gdb_byte *result = NULL;
19635 enum bfd_endian byte_order;
19637 dw2_setup (per_cu->objfile);
19639 if (per_cu->cu == NULL)
19643 die = follow_die_offset (offset, per_cu->is_dwz, &cu);
19645 error (_("Dwarf Error: Cannot find DIE at 0x%x referenced in module %s"),
19646 offset.sect_off, objfile_name (per_cu->objfile));
19649 attr = dwarf2_attr (die, DW_AT_const_value, cu);
19653 byte_order = (bfd_big_endian (per_cu->objfile->obfd)
19654 ? BFD_ENDIAN_BIG : BFD_ENDIAN_LITTLE);
19656 switch (attr->form)
19659 case DW_FORM_GNU_addr_index:
19663 *len = cu->header.addr_size;
19664 tem = obstack_alloc (obstack, *len);
19665 store_unsigned_integer (tem, *len, byte_order, DW_ADDR (attr));
19669 case DW_FORM_string:
19671 case DW_FORM_GNU_str_index:
19672 case DW_FORM_GNU_strp_alt:
19673 /* DW_STRING is already allocated on the objfile obstack, point
19675 result = (const gdb_byte *) DW_STRING (attr);
19676 *len = strlen (DW_STRING (attr));
19678 case DW_FORM_block1:
19679 case DW_FORM_block2:
19680 case DW_FORM_block4:
19681 case DW_FORM_block:
19682 case DW_FORM_exprloc:
19683 result = DW_BLOCK (attr)->data;
19684 *len = DW_BLOCK (attr)->size;
19687 /* The DW_AT_const_value attributes are supposed to carry the
19688 symbol's value "represented as it would be on the target
19689 architecture." By the time we get here, it's already been
19690 converted to host endianness, so we just need to sign- or
19691 zero-extend it as appropriate. */
19692 case DW_FORM_data1:
19693 type = die_type (die, cu);
19694 result = dwarf2_const_value_data (attr, obstack, cu, &value, 8);
19695 if (result == NULL)
19696 result = write_constant_as_bytes (obstack, byte_order,
19699 case DW_FORM_data2:
19700 type = die_type (die, cu);
19701 result = dwarf2_const_value_data (attr, obstack, cu, &value, 16);
19702 if (result == NULL)
19703 result = write_constant_as_bytes (obstack, byte_order,
19706 case DW_FORM_data4:
19707 type = die_type (die, cu);
19708 result = dwarf2_const_value_data (attr, obstack, cu, &value, 32);
19709 if (result == NULL)
19710 result = write_constant_as_bytes (obstack, byte_order,
19713 case DW_FORM_data8:
19714 type = die_type (die, cu);
19715 result = dwarf2_const_value_data (attr, obstack, cu, &value, 64);
19716 if (result == NULL)
19717 result = write_constant_as_bytes (obstack, byte_order,
19721 case DW_FORM_sdata:
19722 type = die_type (die, cu);
19723 result = write_constant_as_bytes (obstack, byte_order,
19724 type, DW_SND (attr), len);
19727 case DW_FORM_udata:
19728 type = die_type (die, cu);
19729 result = write_constant_as_bytes (obstack, byte_order,
19730 type, DW_UNSND (attr), len);
19734 complaint (&symfile_complaints,
19735 _("unsupported const value attribute form: '%s'"),
19736 dwarf_form_name (attr->form));
19743 /* Return the type of the DIE at DIE_OFFSET in the CU named by
19747 dwarf2_get_die_type (cu_offset die_offset,
19748 struct dwarf2_per_cu_data *per_cu)
19750 sect_offset die_offset_sect;
19752 dw2_setup (per_cu->objfile);
19754 die_offset_sect.sect_off = per_cu->offset.sect_off + die_offset.cu_off;
19755 return get_die_type_at_offset (die_offset_sect, per_cu);
19758 /* Follow type unit SIG_TYPE referenced by SRC_DIE.
19759 On entry *REF_CU is the CU of SRC_DIE.
19760 On exit *REF_CU is the CU of the result.
19761 Returns NULL if the referenced DIE isn't found. */
19763 static struct die_info *
19764 follow_die_sig_1 (struct die_info *src_die, struct signatured_type *sig_type,
19765 struct dwarf2_cu **ref_cu)
19767 struct objfile *objfile = (*ref_cu)->objfile;
19768 struct die_info temp_die;
19769 struct dwarf2_cu *sig_cu;
19770 struct die_info *die;
19772 /* While it might be nice to assert sig_type->type == NULL here,
19773 we can get here for DW_AT_imported_declaration where we need
19774 the DIE not the type. */
19776 /* If necessary, add it to the queue and load its DIEs. */
19778 if (maybe_queue_comp_unit (*ref_cu, &sig_type->per_cu, language_minimal))
19779 read_signatured_type (sig_type);
19781 sig_cu = sig_type->per_cu.cu;
19782 gdb_assert (sig_cu != NULL);
19783 gdb_assert (sig_type->type_offset_in_section.sect_off != 0);
19784 temp_die.offset = sig_type->type_offset_in_section;
19785 die = htab_find_with_hash (sig_cu->die_hash, &temp_die,
19786 temp_die.offset.sect_off);
19789 /* For .gdb_index version 7 keep track of included TUs.
19790 http://sourceware.org/bugzilla/show_bug.cgi?id=15021. */
19791 if (dwarf2_per_objfile->index_table != NULL
19792 && dwarf2_per_objfile->index_table->version <= 7)
19794 VEC_safe_push (dwarf2_per_cu_ptr,
19795 (*ref_cu)->per_cu->imported_symtabs,
19806 /* Follow signatured type referenced by ATTR in SRC_DIE.
19807 On entry *REF_CU is the CU of SRC_DIE.
19808 On exit *REF_CU is the CU of the result.
19809 The result is the DIE of the type.
19810 If the referenced type cannot be found an error is thrown. */
19812 static struct die_info *
19813 follow_die_sig (struct die_info *src_die, const struct attribute *attr,
19814 struct dwarf2_cu **ref_cu)
19816 ULONGEST signature = DW_SIGNATURE (attr);
19817 struct signatured_type *sig_type;
19818 struct die_info *die;
19820 gdb_assert (attr->form == DW_FORM_ref_sig8);
19822 sig_type = lookup_signatured_type (*ref_cu, signature);
19823 /* sig_type will be NULL if the signatured type is missing from
19825 if (sig_type == NULL)
19827 error (_("Dwarf Error: Cannot find signatured DIE %s referenced"
19828 " from DIE at 0x%x [in module %s]"),
19829 hex_string (signature), src_die->offset.sect_off,
19830 objfile_name ((*ref_cu)->objfile));
19833 die = follow_die_sig_1 (src_die, sig_type, ref_cu);
19836 dump_die_for_error (src_die);
19837 error (_("Dwarf Error: Problem reading signatured DIE %s referenced"
19838 " from DIE at 0x%x [in module %s]"),
19839 hex_string (signature), src_die->offset.sect_off,
19840 objfile_name ((*ref_cu)->objfile));
19846 /* Get the type specified by SIGNATURE referenced in DIE/CU,
19847 reading in and processing the type unit if necessary. */
19849 static struct type *
19850 get_signatured_type (struct die_info *die, ULONGEST signature,
19851 struct dwarf2_cu *cu)
19853 struct signatured_type *sig_type;
19854 struct dwarf2_cu *type_cu;
19855 struct die_info *type_die;
19858 sig_type = lookup_signatured_type (cu, signature);
19859 /* sig_type will be NULL if the signatured type is missing from
19861 if (sig_type == NULL)
19863 complaint (&symfile_complaints,
19864 _("Dwarf Error: Cannot find signatured DIE %s referenced"
19865 " from DIE at 0x%x [in module %s]"),
19866 hex_string (signature), die->offset.sect_off,
19867 objfile_name (dwarf2_per_objfile->objfile));
19868 return build_error_marker_type (cu, die);
19871 /* If we already know the type we're done. */
19872 if (sig_type->type != NULL)
19873 return sig_type->type;
19876 type_die = follow_die_sig_1 (die, sig_type, &type_cu);
19877 if (type_die != NULL)
19879 /* N.B. We need to call get_die_type to ensure only one type for this DIE
19880 is created. This is important, for example, because for c++ classes
19881 we need TYPE_NAME set which is only done by new_symbol. Blech. */
19882 type = read_type_die (type_die, type_cu);
19885 complaint (&symfile_complaints,
19886 _("Dwarf Error: Cannot build signatured type %s"
19887 " referenced from DIE at 0x%x [in module %s]"),
19888 hex_string (signature), die->offset.sect_off,
19889 objfile_name (dwarf2_per_objfile->objfile));
19890 type = build_error_marker_type (cu, die);
19895 complaint (&symfile_complaints,
19896 _("Dwarf Error: Problem reading signatured DIE %s referenced"
19897 " from DIE at 0x%x [in module %s]"),
19898 hex_string (signature), die->offset.sect_off,
19899 objfile_name (dwarf2_per_objfile->objfile));
19900 type = build_error_marker_type (cu, die);
19902 sig_type->type = type;
19907 /* Get the type specified by the DW_AT_signature ATTR in DIE/CU,
19908 reading in and processing the type unit if necessary. */
19910 static struct type *
19911 get_DW_AT_signature_type (struct die_info *die, const struct attribute *attr,
19912 struct dwarf2_cu *cu) /* ARI: editCase function */
19914 /* Yes, DW_AT_signature can use a non-ref_sig8 reference. */
19915 if (attr_form_is_ref (attr))
19917 struct dwarf2_cu *type_cu = cu;
19918 struct die_info *type_die = follow_die_ref (die, attr, &type_cu);
19920 return read_type_die (type_die, type_cu);
19922 else if (attr->form == DW_FORM_ref_sig8)
19924 return get_signatured_type (die, DW_SIGNATURE (attr), cu);
19928 complaint (&symfile_complaints,
19929 _("Dwarf Error: DW_AT_signature has bad form %s in DIE"
19930 " at 0x%x [in module %s]"),
19931 dwarf_form_name (attr->form), die->offset.sect_off,
19932 objfile_name (dwarf2_per_objfile->objfile));
19933 return build_error_marker_type (cu, die);
19937 /* Load the DIEs associated with type unit PER_CU into memory. */
19940 load_full_type_unit (struct dwarf2_per_cu_data *per_cu)
19942 struct signatured_type *sig_type;
19944 /* Caller is responsible for ensuring type_unit_groups don't get here. */
19945 gdb_assert (! IS_TYPE_UNIT_GROUP (per_cu));
19947 /* We have the per_cu, but we need the signatured_type.
19948 Fortunately this is an easy translation. */
19949 gdb_assert (per_cu->is_debug_types);
19950 sig_type = (struct signatured_type *) per_cu;
19952 gdb_assert (per_cu->cu == NULL);
19954 read_signatured_type (sig_type);
19956 gdb_assert (per_cu->cu != NULL);
19959 /* die_reader_func for read_signatured_type.
19960 This is identical to load_full_comp_unit_reader,
19961 but is kept separate for now. */
19964 read_signatured_type_reader (const struct die_reader_specs *reader,
19965 const gdb_byte *info_ptr,
19966 struct die_info *comp_unit_die,
19970 struct dwarf2_cu *cu = reader->cu;
19972 gdb_assert (cu->die_hash == NULL);
19974 htab_create_alloc_ex (cu->header.length / 12,
19978 &cu->comp_unit_obstack,
19979 hashtab_obstack_allocate,
19980 dummy_obstack_deallocate);
19983 comp_unit_die->child = read_die_and_siblings (reader, info_ptr,
19984 &info_ptr, comp_unit_die);
19985 cu->dies = comp_unit_die;
19986 /* comp_unit_die is not stored in die_hash, no need. */
19988 /* We try not to read any attributes in this function, because not
19989 all CUs needed for references have been loaded yet, and symbol
19990 table processing isn't initialized. But we have to set the CU language,
19991 or we won't be able to build types correctly.
19992 Similarly, if we do not read the producer, we can not apply
19993 producer-specific interpretation. */
19994 prepare_one_comp_unit (cu, cu->dies, language_minimal);
19997 /* Read in a signatured type and build its CU and DIEs.
19998 If the type is a stub for the real type in a DWO file,
19999 read in the real type from the DWO file as well. */
20002 read_signatured_type (struct signatured_type *sig_type)
20004 struct dwarf2_per_cu_data *per_cu = &sig_type->per_cu;
20006 gdb_assert (per_cu->is_debug_types);
20007 gdb_assert (per_cu->cu == NULL);
20009 init_cutu_and_read_dies (per_cu, NULL, 0, 1,
20010 read_signatured_type_reader, NULL);
20011 sig_type->per_cu.tu_read = 1;
20014 /* Decode simple location descriptions.
20015 Given a pointer to a dwarf block that defines a location, compute
20016 the location and return the value.
20018 NOTE drow/2003-11-18: This function is called in two situations
20019 now: for the address of static or global variables (partial symbols
20020 only) and for offsets into structures which are expected to be
20021 (more or less) constant. The partial symbol case should go away,
20022 and only the constant case should remain. That will let this
20023 function complain more accurately. A few special modes are allowed
20024 without complaint for global variables (for instance, global
20025 register values and thread-local values).
20027 A location description containing no operations indicates that the
20028 object is optimized out. The return value is 0 for that case.
20029 FIXME drow/2003-11-16: No callers check for this case any more; soon all
20030 callers will only want a very basic result and this can become a
20033 Note that stack[0] is unused except as a default error return. */
20036 decode_locdesc (struct dwarf_block *blk, struct dwarf2_cu *cu)
20038 struct objfile *objfile = cu->objfile;
20040 size_t size = blk->size;
20041 const gdb_byte *data = blk->data;
20042 CORE_ADDR stack[64];
20044 unsigned int bytes_read, unsnd;
20050 stack[++stacki] = 0;
20089 stack[++stacki] = op - DW_OP_lit0;
20124 stack[++stacki] = op - DW_OP_reg0;
20126 dwarf2_complex_location_expr_complaint ();
20130 unsnd = read_unsigned_leb128 (NULL, (data + i), &bytes_read);
20132 stack[++stacki] = unsnd;
20134 dwarf2_complex_location_expr_complaint ();
20138 stack[++stacki] = read_address (objfile->obfd, &data[i],
20143 case DW_OP_const1u:
20144 stack[++stacki] = read_1_byte (objfile->obfd, &data[i]);
20148 case DW_OP_const1s:
20149 stack[++stacki] = read_1_signed_byte (objfile->obfd, &data[i]);
20153 case DW_OP_const2u:
20154 stack[++stacki] = read_2_bytes (objfile->obfd, &data[i]);
20158 case DW_OP_const2s:
20159 stack[++stacki] = read_2_signed_bytes (objfile->obfd, &data[i]);
20163 case DW_OP_const4u:
20164 stack[++stacki] = read_4_bytes (objfile->obfd, &data[i]);
20168 case DW_OP_const4s:
20169 stack[++stacki] = read_4_signed_bytes (objfile->obfd, &data[i]);
20173 case DW_OP_const8u:
20174 stack[++stacki] = read_8_bytes (objfile->obfd, &data[i]);
20179 stack[++stacki] = read_unsigned_leb128 (NULL, (data + i),
20185 stack[++stacki] = read_signed_leb128 (NULL, (data + i), &bytes_read);
20190 stack[stacki + 1] = stack[stacki];
20195 stack[stacki - 1] += stack[stacki];
20199 case DW_OP_plus_uconst:
20200 stack[stacki] += read_unsigned_leb128 (NULL, (data + i),
20206 stack[stacki - 1] -= stack[stacki];
20211 /* If we're not the last op, then we definitely can't encode
20212 this using GDB's address_class enum. This is valid for partial
20213 global symbols, although the variable's address will be bogus
20216 dwarf2_complex_location_expr_complaint ();
20219 case DW_OP_GNU_push_tls_address:
20220 /* The top of the stack has the offset from the beginning
20221 of the thread control block at which the variable is located. */
20222 /* Nothing should follow this operator, so the top of stack would
20224 /* This is valid for partial global symbols, but the variable's
20225 address will be bogus in the psymtab. Make it always at least
20226 non-zero to not look as a variable garbage collected by linker
20227 which have DW_OP_addr 0. */
20229 dwarf2_complex_location_expr_complaint ();
20233 case DW_OP_GNU_uninit:
20236 case DW_OP_GNU_addr_index:
20237 case DW_OP_GNU_const_index:
20238 stack[++stacki] = read_addr_index_from_leb128 (cu, &data[i],
20245 const char *name = get_DW_OP_name (op);
20248 complaint (&symfile_complaints, _("unsupported stack op: '%s'"),
20251 complaint (&symfile_complaints, _("unsupported stack op: '%02x'"),
20255 return (stack[stacki]);
20258 /* Enforce maximum stack depth of SIZE-1 to avoid writing
20259 outside of the allocated space. Also enforce minimum>0. */
20260 if (stacki >= ARRAY_SIZE (stack) - 1)
20262 complaint (&symfile_complaints,
20263 _("location description stack overflow"));
20269 complaint (&symfile_complaints,
20270 _("location description stack underflow"));
20274 return (stack[stacki]);
20277 /* memory allocation interface */
20279 static struct dwarf_block *
20280 dwarf_alloc_block (struct dwarf2_cu *cu)
20282 struct dwarf_block *blk;
20284 blk = (struct dwarf_block *)
20285 obstack_alloc (&cu->comp_unit_obstack, sizeof (struct dwarf_block));
20289 static struct die_info *
20290 dwarf_alloc_die (struct dwarf2_cu *cu, int num_attrs)
20292 struct die_info *die;
20293 size_t size = sizeof (struct die_info);
20296 size += (num_attrs - 1) * sizeof (struct attribute);
20298 die = (struct die_info *) obstack_alloc (&cu->comp_unit_obstack, size);
20299 memset (die, 0, sizeof (struct die_info));
20304 /* Macro support. */
20306 /* Return file name relative to the compilation directory of file number I in
20307 *LH's file name table. The result is allocated using xmalloc; the caller is
20308 responsible for freeing it. */
20311 file_file_name (int file, struct line_header *lh)
20313 /* Is the file number a valid index into the line header's file name
20314 table? Remember that file numbers start with one, not zero. */
20315 if (1 <= file && file <= lh->num_file_names)
20317 struct file_entry *fe = &lh->file_names[file - 1];
20319 if (IS_ABSOLUTE_PATH (fe->name) || fe->dir_index == 0)
20320 return xstrdup (fe->name);
20321 return concat (lh->include_dirs[fe->dir_index - 1], SLASH_STRING,
20326 /* The compiler produced a bogus file number. We can at least
20327 record the macro definitions made in the file, even if we
20328 won't be able to find the file by name. */
20329 char fake_name[80];
20331 xsnprintf (fake_name, sizeof (fake_name),
20332 "<bad macro file number %d>", file);
20334 complaint (&symfile_complaints,
20335 _("bad file number in macro information (%d)"),
20338 return xstrdup (fake_name);
20342 /* Return the full name of file number I in *LH's file name table.
20343 Use COMP_DIR as the name of the current directory of the
20344 compilation. The result is allocated using xmalloc; the caller is
20345 responsible for freeing it. */
20347 file_full_name (int file, struct line_header *lh, const char *comp_dir)
20349 /* Is the file number a valid index into the line header's file name
20350 table? Remember that file numbers start with one, not zero. */
20351 if (1 <= file && file <= lh->num_file_names)
20353 char *relative = file_file_name (file, lh);
20355 if (IS_ABSOLUTE_PATH (relative) || comp_dir == NULL)
20357 return reconcat (relative, comp_dir, SLASH_STRING, relative, NULL);
20360 return file_file_name (file, lh);
20364 static struct macro_source_file *
20365 macro_start_file (int file, int line,
20366 struct macro_source_file *current_file,
20367 const char *comp_dir,
20368 struct line_header *lh, struct objfile *objfile)
20370 /* File name relative to the compilation directory of this source file. */
20371 char *file_name = file_file_name (file, lh);
20373 if (! current_file)
20375 /* Note: We don't create a macro table for this compilation unit
20376 at all until we actually get a filename. */
20377 struct macro_table *macro_table = get_macro_table (objfile, comp_dir);
20379 /* If we have no current file, then this must be the start_file
20380 directive for the compilation unit's main source file. */
20381 current_file = macro_set_main (macro_table, file_name);
20382 macro_define_special (macro_table);
20385 current_file = macro_include (current_file, line, file_name);
20389 return current_file;
20393 /* Copy the LEN characters at BUF to a xmalloc'ed block of memory,
20394 followed by a null byte. */
20396 copy_string (const char *buf, int len)
20398 char *s = xmalloc (len + 1);
20400 memcpy (s, buf, len);
20406 static const char *
20407 consume_improper_spaces (const char *p, const char *body)
20411 complaint (&symfile_complaints,
20412 _("macro definition contains spaces "
20413 "in formal argument list:\n`%s'"),
20425 parse_macro_definition (struct macro_source_file *file, int line,
20430 /* The body string takes one of two forms. For object-like macro
20431 definitions, it should be:
20433 <macro name> " " <definition>
20435 For function-like macro definitions, it should be:
20437 <macro name> "() " <definition>
20439 <macro name> "(" <arg name> ( "," <arg name> ) * ") " <definition>
20441 Spaces may appear only where explicitly indicated, and in the
20444 The Dwarf 2 spec says that an object-like macro's name is always
20445 followed by a space, but versions of GCC around March 2002 omit
20446 the space when the macro's definition is the empty string.
20448 The Dwarf 2 spec says that there should be no spaces between the
20449 formal arguments in a function-like macro's formal argument list,
20450 but versions of GCC around March 2002 include spaces after the
20454 /* Find the extent of the macro name. The macro name is terminated
20455 by either a space or null character (for an object-like macro) or
20456 an opening paren (for a function-like macro). */
20457 for (p = body; *p; p++)
20458 if (*p == ' ' || *p == '(')
20461 if (*p == ' ' || *p == '\0')
20463 /* It's an object-like macro. */
20464 int name_len = p - body;
20465 char *name = copy_string (body, name_len);
20466 const char *replacement;
20469 replacement = body + name_len + 1;
20472 dwarf2_macro_malformed_definition_complaint (body);
20473 replacement = body + name_len;
20476 macro_define_object (file, line, name, replacement);
20480 else if (*p == '(')
20482 /* It's a function-like macro. */
20483 char *name = copy_string (body, p - body);
20486 char **argv = xmalloc (argv_size * sizeof (*argv));
20490 p = consume_improper_spaces (p, body);
20492 /* Parse the formal argument list. */
20493 while (*p && *p != ')')
20495 /* Find the extent of the current argument name. */
20496 const char *arg_start = p;
20498 while (*p && *p != ',' && *p != ')' && *p != ' ')
20501 if (! *p || p == arg_start)
20502 dwarf2_macro_malformed_definition_complaint (body);
20505 /* Make sure argv has room for the new argument. */
20506 if (argc >= argv_size)
20509 argv = xrealloc (argv, argv_size * sizeof (*argv));
20512 argv[argc++] = copy_string (arg_start, p - arg_start);
20515 p = consume_improper_spaces (p, body);
20517 /* Consume the comma, if present. */
20522 p = consume_improper_spaces (p, body);
20531 /* Perfectly formed definition, no complaints. */
20532 macro_define_function (file, line, name,
20533 argc, (const char **) argv,
20535 else if (*p == '\0')
20537 /* Complain, but do define it. */
20538 dwarf2_macro_malformed_definition_complaint (body);
20539 macro_define_function (file, line, name,
20540 argc, (const char **) argv,
20544 /* Just complain. */
20545 dwarf2_macro_malformed_definition_complaint (body);
20548 /* Just complain. */
20549 dwarf2_macro_malformed_definition_complaint (body);
20555 for (i = 0; i < argc; i++)
20561 dwarf2_macro_malformed_definition_complaint (body);
20564 /* Skip some bytes from BYTES according to the form given in FORM.
20565 Returns the new pointer. */
20567 static const gdb_byte *
20568 skip_form_bytes (bfd *abfd, const gdb_byte *bytes, const gdb_byte *buffer_end,
20569 enum dwarf_form form,
20570 unsigned int offset_size,
20571 struct dwarf2_section_info *section)
20573 unsigned int bytes_read;
20577 case DW_FORM_data1:
20582 case DW_FORM_data2:
20586 case DW_FORM_data4:
20590 case DW_FORM_data8:
20594 case DW_FORM_string:
20595 read_direct_string (abfd, bytes, &bytes_read);
20596 bytes += bytes_read;
20599 case DW_FORM_sec_offset:
20601 case DW_FORM_GNU_strp_alt:
20602 bytes += offset_size;
20605 case DW_FORM_block:
20606 bytes += read_unsigned_leb128 (abfd, bytes, &bytes_read);
20607 bytes += bytes_read;
20610 case DW_FORM_block1:
20611 bytes += 1 + read_1_byte (abfd, bytes);
20613 case DW_FORM_block2:
20614 bytes += 2 + read_2_bytes (abfd, bytes);
20616 case DW_FORM_block4:
20617 bytes += 4 + read_4_bytes (abfd, bytes);
20620 case DW_FORM_sdata:
20621 case DW_FORM_udata:
20622 case DW_FORM_GNU_addr_index:
20623 case DW_FORM_GNU_str_index:
20624 bytes = gdb_skip_leb128 (bytes, buffer_end);
20627 dwarf2_section_buffer_overflow_complaint (section);
20635 complaint (&symfile_complaints,
20636 _("invalid form 0x%x in `%s'"),
20637 form, get_section_name (section));
20645 /* A helper for dwarf_decode_macros that handles skipping an unknown
20646 opcode. Returns an updated pointer to the macro data buffer; or,
20647 on error, issues a complaint and returns NULL. */
20649 static const gdb_byte *
20650 skip_unknown_opcode (unsigned int opcode,
20651 const gdb_byte **opcode_definitions,
20652 const gdb_byte *mac_ptr, const gdb_byte *mac_end,
20654 unsigned int offset_size,
20655 struct dwarf2_section_info *section)
20657 unsigned int bytes_read, i;
20659 const gdb_byte *defn;
20661 if (opcode_definitions[opcode] == NULL)
20663 complaint (&symfile_complaints,
20664 _("unrecognized DW_MACFINO opcode 0x%x"),
20669 defn = opcode_definitions[opcode];
20670 arg = read_unsigned_leb128 (abfd, defn, &bytes_read);
20671 defn += bytes_read;
20673 for (i = 0; i < arg; ++i)
20675 mac_ptr = skip_form_bytes (abfd, mac_ptr, mac_end, defn[i], offset_size,
20677 if (mac_ptr == NULL)
20679 /* skip_form_bytes already issued the complaint. */
20687 /* A helper function which parses the header of a macro section.
20688 If the macro section is the extended (for now called "GNU") type,
20689 then this updates *OFFSET_SIZE. Returns a pointer to just after
20690 the header, or issues a complaint and returns NULL on error. */
20692 static const gdb_byte *
20693 dwarf_parse_macro_header (const gdb_byte **opcode_definitions,
20695 const gdb_byte *mac_ptr,
20696 unsigned int *offset_size,
20697 int section_is_gnu)
20699 memset (opcode_definitions, 0, 256 * sizeof (gdb_byte *));
20701 if (section_is_gnu)
20703 unsigned int version, flags;
20705 version = read_2_bytes (abfd, mac_ptr);
20708 complaint (&symfile_complaints,
20709 _("unrecognized version `%d' in .debug_macro section"),
20715 flags = read_1_byte (abfd, mac_ptr);
20717 *offset_size = (flags & 1) ? 8 : 4;
20719 if ((flags & 2) != 0)
20720 /* We don't need the line table offset. */
20721 mac_ptr += *offset_size;
20723 /* Vendor opcode descriptions. */
20724 if ((flags & 4) != 0)
20726 unsigned int i, count;
20728 count = read_1_byte (abfd, mac_ptr);
20730 for (i = 0; i < count; ++i)
20732 unsigned int opcode, bytes_read;
20735 opcode = read_1_byte (abfd, mac_ptr);
20737 opcode_definitions[opcode] = mac_ptr;
20738 arg = read_unsigned_leb128 (abfd, mac_ptr, &bytes_read);
20739 mac_ptr += bytes_read;
20748 /* A helper for dwarf_decode_macros that handles the GNU extensions,
20749 including DW_MACRO_GNU_transparent_include. */
20752 dwarf_decode_macro_bytes (bfd *abfd,
20753 const gdb_byte *mac_ptr, const gdb_byte *mac_end,
20754 struct macro_source_file *current_file,
20755 struct line_header *lh, const char *comp_dir,
20756 struct dwarf2_section_info *section,
20757 int section_is_gnu, int section_is_dwz,
20758 unsigned int offset_size,
20759 struct objfile *objfile,
20760 htab_t include_hash)
20762 enum dwarf_macro_record_type macinfo_type;
20763 int at_commandline;
20764 const gdb_byte *opcode_definitions[256];
20766 mac_ptr = dwarf_parse_macro_header (opcode_definitions, abfd, mac_ptr,
20767 &offset_size, section_is_gnu);
20768 if (mac_ptr == NULL)
20770 /* We already issued a complaint. */
20774 /* Determines if GDB is still before first DW_MACINFO_start_file. If true
20775 GDB is still reading the definitions from command line. First
20776 DW_MACINFO_start_file will need to be ignored as it was already executed
20777 to create CURRENT_FILE for the main source holding also the command line
20778 definitions. On first met DW_MACINFO_start_file this flag is reset to
20779 normally execute all the remaining DW_MACINFO_start_file macinfos. */
20781 at_commandline = 1;
20785 /* Do we at least have room for a macinfo type byte? */
20786 if (mac_ptr >= mac_end)
20788 dwarf2_section_buffer_overflow_complaint (section);
20792 macinfo_type = read_1_byte (abfd, mac_ptr);
20795 /* Note that we rely on the fact that the corresponding GNU and
20796 DWARF constants are the same. */
20797 switch (macinfo_type)
20799 /* A zero macinfo type indicates the end of the macro
20804 case DW_MACRO_GNU_define:
20805 case DW_MACRO_GNU_undef:
20806 case DW_MACRO_GNU_define_indirect:
20807 case DW_MACRO_GNU_undef_indirect:
20808 case DW_MACRO_GNU_define_indirect_alt:
20809 case DW_MACRO_GNU_undef_indirect_alt:
20811 unsigned int bytes_read;
20816 line = read_unsigned_leb128 (abfd, mac_ptr, &bytes_read);
20817 mac_ptr += bytes_read;
20819 if (macinfo_type == DW_MACRO_GNU_define
20820 || macinfo_type == DW_MACRO_GNU_undef)
20822 body = read_direct_string (abfd, mac_ptr, &bytes_read);
20823 mac_ptr += bytes_read;
20827 LONGEST str_offset;
20829 str_offset = read_offset_1 (abfd, mac_ptr, offset_size);
20830 mac_ptr += offset_size;
20832 if (macinfo_type == DW_MACRO_GNU_define_indirect_alt
20833 || macinfo_type == DW_MACRO_GNU_undef_indirect_alt
20836 struct dwz_file *dwz = dwarf2_get_dwz_file ();
20838 body = read_indirect_string_from_dwz (dwz, str_offset);
20841 body = read_indirect_string_at_offset (abfd, str_offset);
20844 is_define = (macinfo_type == DW_MACRO_GNU_define
20845 || macinfo_type == DW_MACRO_GNU_define_indirect
20846 || macinfo_type == DW_MACRO_GNU_define_indirect_alt);
20847 if (! current_file)
20849 /* DWARF violation as no main source is present. */
20850 complaint (&symfile_complaints,
20851 _("debug info with no main source gives macro %s "
20853 is_define ? _("definition") : _("undefinition"),
20857 if ((line == 0 && !at_commandline)
20858 || (line != 0 && at_commandline))
20859 complaint (&symfile_complaints,
20860 _("debug info gives %s macro %s with %s line %d: %s"),
20861 at_commandline ? _("command-line") : _("in-file"),
20862 is_define ? _("definition") : _("undefinition"),
20863 line == 0 ? _("zero") : _("non-zero"), line, body);
20866 parse_macro_definition (current_file, line, body);
20869 gdb_assert (macinfo_type == DW_MACRO_GNU_undef
20870 || macinfo_type == DW_MACRO_GNU_undef_indirect
20871 || macinfo_type == DW_MACRO_GNU_undef_indirect_alt);
20872 macro_undef (current_file, line, body);
20877 case DW_MACRO_GNU_start_file:
20879 unsigned int bytes_read;
20882 line = read_unsigned_leb128 (abfd, mac_ptr, &bytes_read);
20883 mac_ptr += bytes_read;
20884 file = read_unsigned_leb128 (abfd, mac_ptr, &bytes_read);
20885 mac_ptr += bytes_read;
20887 if ((line == 0 && !at_commandline)
20888 || (line != 0 && at_commandline))
20889 complaint (&symfile_complaints,
20890 _("debug info gives source %d included "
20891 "from %s at %s line %d"),
20892 file, at_commandline ? _("command-line") : _("file"),
20893 line == 0 ? _("zero") : _("non-zero"), line);
20895 if (at_commandline)
20897 /* This DW_MACRO_GNU_start_file was executed in the
20899 at_commandline = 0;
20902 current_file = macro_start_file (file, line,
20903 current_file, comp_dir,
20908 case DW_MACRO_GNU_end_file:
20909 if (! current_file)
20910 complaint (&symfile_complaints,
20911 _("macro debug info has an unmatched "
20912 "`close_file' directive"));
20915 current_file = current_file->included_by;
20916 if (! current_file)
20918 enum dwarf_macro_record_type next_type;
20920 /* GCC circa March 2002 doesn't produce the zero
20921 type byte marking the end of the compilation
20922 unit. Complain if it's not there, but exit no
20925 /* Do we at least have room for a macinfo type byte? */
20926 if (mac_ptr >= mac_end)
20928 dwarf2_section_buffer_overflow_complaint (section);
20932 /* We don't increment mac_ptr here, so this is just
20934 next_type = read_1_byte (abfd, mac_ptr);
20935 if (next_type != 0)
20936 complaint (&symfile_complaints,
20937 _("no terminating 0-type entry for "
20938 "macros in `.debug_macinfo' section"));
20945 case DW_MACRO_GNU_transparent_include:
20946 case DW_MACRO_GNU_transparent_include_alt:
20950 bfd *include_bfd = abfd;
20951 struct dwarf2_section_info *include_section = section;
20952 struct dwarf2_section_info alt_section;
20953 const gdb_byte *include_mac_end = mac_end;
20954 int is_dwz = section_is_dwz;
20955 const gdb_byte *new_mac_ptr;
20957 offset = read_offset_1 (abfd, mac_ptr, offset_size);
20958 mac_ptr += offset_size;
20960 if (macinfo_type == DW_MACRO_GNU_transparent_include_alt)
20962 struct dwz_file *dwz = dwarf2_get_dwz_file ();
20964 dwarf2_read_section (dwarf2_per_objfile->objfile,
20967 include_section = &dwz->macro;
20968 include_bfd = get_section_bfd_owner (include_section);
20969 include_mac_end = dwz->macro.buffer + dwz->macro.size;
20973 new_mac_ptr = include_section->buffer + offset;
20974 slot = htab_find_slot (include_hash, new_mac_ptr, INSERT);
20978 /* This has actually happened; see
20979 http://sourceware.org/bugzilla/show_bug.cgi?id=13568. */
20980 complaint (&symfile_complaints,
20981 _("recursive DW_MACRO_GNU_transparent_include in "
20982 ".debug_macro section"));
20986 *slot = (void *) new_mac_ptr;
20988 dwarf_decode_macro_bytes (include_bfd, new_mac_ptr,
20989 include_mac_end, current_file,
20991 section, section_is_gnu, is_dwz,
20992 offset_size, objfile, include_hash);
20994 htab_remove_elt (include_hash, (void *) new_mac_ptr);
20999 case DW_MACINFO_vendor_ext:
21000 if (!section_is_gnu)
21002 unsigned int bytes_read;
21005 constant = read_unsigned_leb128 (abfd, mac_ptr, &bytes_read);
21006 mac_ptr += bytes_read;
21007 read_direct_string (abfd, mac_ptr, &bytes_read);
21008 mac_ptr += bytes_read;
21010 /* We don't recognize any vendor extensions. */
21016 mac_ptr = skip_unknown_opcode (macinfo_type, opcode_definitions,
21017 mac_ptr, mac_end, abfd, offset_size,
21019 if (mac_ptr == NULL)
21023 } while (macinfo_type != 0);
21027 dwarf_decode_macros (struct dwarf2_cu *cu, unsigned int offset,
21028 const char *comp_dir, int section_is_gnu)
21030 struct objfile *objfile = dwarf2_per_objfile->objfile;
21031 struct line_header *lh = cu->line_header;
21033 const gdb_byte *mac_ptr, *mac_end;
21034 struct macro_source_file *current_file = 0;
21035 enum dwarf_macro_record_type macinfo_type;
21036 unsigned int offset_size = cu->header.offset_size;
21037 const gdb_byte *opcode_definitions[256];
21038 struct cleanup *cleanup;
21039 htab_t include_hash;
21041 struct dwarf2_section_info *section;
21042 const char *section_name;
21044 if (cu->dwo_unit != NULL)
21046 if (section_is_gnu)
21048 section = &cu->dwo_unit->dwo_file->sections.macro;
21049 section_name = ".debug_macro.dwo";
21053 section = &cu->dwo_unit->dwo_file->sections.macinfo;
21054 section_name = ".debug_macinfo.dwo";
21059 if (section_is_gnu)
21061 section = &dwarf2_per_objfile->macro;
21062 section_name = ".debug_macro";
21066 section = &dwarf2_per_objfile->macinfo;
21067 section_name = ".debug_macinfo";
21071 dwarf2_read_section (objfile, section);
21072 if (section->buffer == NULL)
21074 complaint (&symfile_complaints, _("missing %s section"), section_name);
21077 abfd = get_section_bfd_owner (section);
21079 /* First pass: Find the name of the base filename.
21080 This filename is needed in order to process all macros whose definition
21081 (or undefinition) comes from the command line. These macros are defined
21082 before the first DW_MACINFO_start_file entry, and yet still need to be
21083 associated to the base file.
21085 To determine the base file name, we scan the macro definitions until we
21086 reach the first DW_MACINFO_start_file entry. We then initialize
21087 CURRENT_FILE accordingly so that any macro definition found before the
21088 first DW_MACINFO_start_file can still be associated to the base file. */
21090 mac_ptr = section->buffer + offset;
21091 mac_end = section->buffer + section->size;
21093 mac_ptr = dwarf_parse_macro_header (opcode_definitions, abfd, mac_ptr,
21094 &offset_size, section_is_gnu);
21095 if (mac_ptr == NULL)
21097 /* We already issued a complaint. */
21103 /* Do we at least have room for a macinfo type byte? */
21104 if (mac_ptr >= mac_end)
21106 /* Complaint is printed during the second pass as GDB will probably
21107 stop the first pass earlier upon finding
21108 DW_MACINFO_start_file. */
21112 macinfo_type = read_1_byte (abfd, mac_ptr);
21115 /* Note that we rely on the fact that the corresponding GNU and
21116 DWARF constants are the same. */
21117 switch (macinfo_type)
21119 /* A zero macinfo type indicates the end of the macro
21124 case DW_MACRO_GNU_define:
21125 case DW_MACRO_GNU_undef:
21126 /* Only skip the data by MAC_PTR. */
21128 unsigned int bytes_read;
21130 read_unsigned_leb128 (abfd, mac_ptr, &bytes_read);
21131 mac_ptr += bytes_read;
21132 read_direct_string (abfd, mac_ptr, &bytes_read);
21133 mac_ptr += bytes_read;
21137 case DW_MACRO_GNU_start_file:
21139 unsigned int bytes_read;
21142 line = read_unsigned_leb128 (abfd, mac_ptr, &bytes_read);
21143 mac_ptr += bytes_read;
21144 file = read_unsigned_leb128 (abfd, mac_ptr, &bytes_read);
21145 mac_ptr += bytes_read;
21147 current_file = macro_start_file (file, line, current_file,
21148 comp_dir, lh, objfile);
21152 case DW_MACRO_GNU_end_file:
21153 /* No data to skip by MAC_PTR. */
21156 case DW_MACRO_GNU_define_indirect:
21157 case DW_MACRO_GNU_undef_indirect:
21158 case DW_MACRO_GNU_define_indirect_alt:
21159 case DW_MACRO_GNU_undef_indirect_alt:
21161 unsigned int bytes_read;
21163 read_unsigned_leb128 (abfd, mac_ptr, &bytes_read);
21164 mac_ptr += bytes_read;
21165 mac_ptr += offset_size;
21169 case DW_MACRO_GNU_transparent_include:
21170 case DW_MACRO_GNU_transparent_include_alt:
21171 /* Note that, according to the spec, a transparent include
21172 chain cannot call DW_MACRO_GNU_start_file. So, we can just
21173 skip this opcode. */
21174 mac_ptr += offset_size;
21177 case DW_MACINFO_vendor_ext:
21178 /* Only skip the data by MAC_PTR. */
21179 if (!section_is_gnu)
21181 unsigned int bytes_read;
21183 read_unsigned_leb128 (abfd, mac_ptr, &bytes_read);
21184 mac_ptr += bytes_read;
21185 read_direct_string (abfd, mac_ptr, &bytes_read);
21186 mac_ptr += bytes_read;
21191 mac_ptr = skip_unknown_opcode (macinfo_type, opcode_definitions,
21192 mac_ptr, mac_end, abfd, offset_size,
21194 if (mac_ptr == NULL)
21198 } while (macinfo_type != 0 && current_file == NULL);
21200 /* Second pass: Process all entries.
21202 Use the AT_COMMAND_LINE flag to determine whether we are still processing
21203 command-line macro definitions/undefinitions. This flag is unset when we
21204 reach the first DW_MACINFO_start_file entry. */
21206 include_hash = htab_create_alloc (1, htab_hash_pointer, htab_eq_pointer,
21207 NULL, xcalloc, xfree);
21208 cleanup = make_cleanup_htab_delete (include_hash);
21209 mac_ptr = section->buffer + offset;
21210 slot = htab_find_slot (include_hash, mac_ptr, INSERT);
21211 *slot = (void *) mac_ptr;
21212 dwarf_decode_macro_bytes (abfd, mac_ptr, mac_end,
21213 current_file, lh, comp_dir, section,
21215 offset_size, objfile, include_hash);
21216 do_cleanups (cleanup);
21219 /* Check if the attribute's form is a DW_FORM_block*
21220 if so return true else false. */
21223 attr_form_is_block (const struct attribute *attr)
21225 return (attr == NULL ? 0 :
21226 attr->form == DW_FORM_block1
21227 || attr->form == DW_FORM_block2
21228 || attr->form == DW_FORM_block4
21229 || attr->form == DW_FORM_block
21230 || attr->form == DW_FORM_exprloc);
21233 /* Return non-zero if ATTR's value is a section offset --- classes
21234 lineptr, loclistptr, macptr or rangelistptr --- or zero, otherwise.
21235 You may use DW_UNSND (attr) to retrieve such offsets.
21237 Section 7.5.4, "Attribute Encodings", explains that no attribute
21238 may have a value that belongs to more than one of these classes; it
21239 would be ambiguous if we did, because we use the same forms for all
21243 attr_form_is_section_offset (const struct attribute *attr)
21245 return (attr->form == DW_FORM_data4
21246 || attr->form == DW_FORM_data8
21247 || attr->form == DW_FORM_sec_offset);
21250 /* Return non-zero if ATTR's value falls in the 'constant' class, or
21251 zero otherwise. When this function returns true, you can apply
21252 dwarf2_get_attr_constant_value to it.
21254 However, note that for some attributes you must check
21255 attr_form_is_section_offset before using this test. DW_FORM_data4
21256 and DW_FORM_data8 are members of both the constant class, and of
21257 the classes that contain offsets into other debug sections
21258 (lineptr, loclistptr, macptr or rangelistptr). The DWARF spec says
21259 that, if an attribute's can be either a constant or one of the
21260 section offset classes, DW_FORM_data4 and DW_FORM_data8 should be
21261 taken as section offsets, not constants. */
21264 attr_form_is_constant (const struct attribute *attr)
21266 switch (attr->form)
21268 case DW_FORM_sdata:
21269 case DW_FORM_udata:
21270 case DW_FORM_data1:
21271 case DW_FORM_data2:
21272 case DW_FORM_data4:
21273 case DW_FORM_data8:
21281 /* DW_ADDR is always stored already as sect_offset; despite for the forms
21282 besides DW_FORM_ref_addr it is stored as cu_offset in the DWARF file. */
21285 attr_form_is_ref (const struct attribute *attr)
21287 switch (attr->form)
21289 case DW_FORM_ref_addr:
21294 case DW_FORM_ref_udata:
21295 case DW_FORM_GNU_ref_alt:
21302 /* Return the .debug_loc section to use for CU.
21303 For DWO files use .debug_loc.dwo. */
21305 static struct dwarf2_section_info *
21306 cu_debug_loc_section (struct dwarf2_cu *cu)
21309 return &cu->dwo_unit->dwo_file->sections.loc;
21310 return &dwarf2_per_objfile->loc;
21313 /* A helper function that fills in a dwarf2_loclist_baton. */
21316 fill_in_loclist_baton (struct dwarf2_cu *cu,
21317 struct dwarf2_loclist_baton *baton,
21318 const struct attribute *attr)
21320 struct dwarf2_section_info *section = cu_debug_loc_section (cu);
21322 dwarf2_read_section (dwarf2_per_objfile->objfile, section);
21324 baton->per_cu = cu->per_cu;
21325 gdb_assert (baton->per_cu);
21326 /* We don't know how long the location list is, but make sure we
21327 don't run off the edge of the section. */
21328 baton->size = section->size - DW_UNSND (attr);
21329 baton->data = section->buffer + DW_UNSND (attr);
21330 baton->base_address = cu->base_address;
21331 baton->from_dwo = cu->dwo_unit != NULL;
21335 dwarf2_symbol_mark_computed (const struct attribute *attr, struct symbol *sym,
21336 struct dwarf2_cu *cu, int is_block)
21338 struct objfile *objfile = dwarf2_per_objfile->objfile;
21339 struct dwarf2_section_info *section = cu_debug_loc_section (cu);
21341 if (attr_form_is_section_offset (attr)
21342 /* .debug_loc{,.dwo} may not exist at all, or the offset may be outside
21343 the section. If so, fall through to the complaint in the
21345 && DW_UNSND (attr) < dwarf2_section_size (objfile, section))
21347 struct dwarf2_loclist_baton *baton;
21349 baton = obstack_alloc (&objfile->objfile_obstack,
21350 sizeof (struct dwarf2_loclist_baton));
21352 fill_in_loclist_baton (cu, baton, attr);
21354 if (cu->base_known == 0)
21355 complaint (&symfile_complaints,
21356 _("Location list used without "
21357 "specifying the CU base address."));
21359 SYMBOL_ACLASS_INDEX (sym) = (is_block
21360 ? dwarf2_loclist_block_index
21361 : dwarf2_loclist_index);
21362 SYMBOL_LOCATION_BATON (sym) = baton;
21366 struct dwarf2_locexpr_baton *baton;
21368 baton = obstack_alloc (&objfile->objfile_obstack,
21369 sizeof (struct dwarf2_locexpr_baton));
21370 baton->per_cu = cu->per_cu;
21371 gdb_assert (baton->per_cu);
21373 if (attr_form_is_block (attr))
21375 /* Note that we're just copying the block's data pointer
21376 here, not the actual data. We're still pointing into the
21377 info_buffer for SYM's objfile; right now we never release
21378 that buffer, but when we do clean up properly this may
21380 baton->size = DW_BLOCK (attr)->size;
21381 baton->data = DW_BLOCK (attr)->data;
21385 dwarf2_invalid_attrib_class_complaint ("location description",
21386 SYMBOL_NATURAL_NAME (sym));
21390 SYMBOL_ACLASS_INDEX (sym) = (is_block
21391 ? dwarf2_locexpr_block_index
21392 : dwarf2_locexpr_index);
21393 SYMBOL_LOCATION_BATON (sym) = baton;
21397 /* Return the OBJFILE associated with the compilation unit CU. If CU
21398 came from a separate debuginfo file, then the master objfile is
21402 dwarf2_per_cu_objfile (struct dwarf2_per_cu_data *per_cu)
21404 struct objfile *objfile = per_cu->objfile;
21406 /* Return the master objfile, so that we can report and look up the
21407 correct file containing this variable. */
21408 if (objfile->separate_debug_objfile_backlink)
21409 objfile = objfile->separate_debug_objfile_backlink;
21414 /* Return comp_unit_head for PER_CU, either already available in PER_CU->CU
21415 (CU_HEADERP is unused in such case) or prepare a temporary copy at
21416 CU_HEADERP first. */
21418 static const struct comp_unit_head *
21419 per_cu_header_read_in (struct comp_unit_head *cu_headerp,
21420 struct dwarf2_per_cu_data *per_cu)
21422 const gdb_byte *info_ptr;
21425 return &per_cu->cu->header;
21427 info_ptr = per_cu->section->buffer + per_cu->offset.sect_off;
21429 memset (cu_headerp, 0, sizeof (*cu_headerp));
21430 read_comp_unit_head (cu_headerp, info_ptr, per_cu->objfile->obfd);
21435 /* Return the address size given in the compilation unit header for CU. */
21438 dwarf2_per_cu_addr_size (struct dwarf2_per_cu_data *per_cu)
21440 struct comp_unit_head cu_header_local;
21441 const struct comp_unit_head *cu_headerp;
21443 cu_headerp = per_cu_header_read_in (&cu_header_local, per_cu);
21445 return cu_headerp->addr_size;
21448 /* Return the offset size given in the compilation unit header for CU. */
21451 dwarf2_per_cu_offset_size (struct dwarf2_per_cu_data *per_cu)
21453 struct comp_unit_head cu_header_local;
21454 const struct comp_unit_head *cu_headerp;
21456 cu_headerp = per_cu_header_read_in (&cu_header_local, per_cu);
21458 return cu_headerp->offset_size;
21461 /* See its dwarf2loc.h declaration. */
21464 dwarf2_per_cu_ref_addr_size (struct dwarf2_per_cu_data *per_cu)
21466 struct comp_unit_head cu_header_local;
21467 const struct comp_unit_head *cu_headerp;
21469 cu_headerp = per_cu_header_read_in (&cu_header_local, per_cu);
21471 if (cu_headerp->version == 2)
21472 return cu_headerp->addr_size;
21474 return cu_headerp->offset_size;
21477 /* Return the text offset of the CU. The returned offset comes from
21478 this CU's objfile. If this objfile came from a separate debuginfo
21479 file, then the offset may be different from the corresponding
21480 offset in the parent objfile. */
21483 dwarf2_per_cu_text_offset (struct dwarf2_per_cu_data *per_cu)
21485 struct objfile *objfile = per_cu->objfile;
21487 return ANOFFSET (objfile->section_offsets, SECT_OFF_TEXT (objfile));
21490 /* Locate the .debug_info compilation unit from CU's objfile which contains
21491 the DIE at OFFSET. Raises an error on failure. */
21493 static struct dwarf2_per_cu_data *
21494 dwarf2_find_containing_comp_unit (sect_offset offset,
21495 unsigned int offset_in_dwz,
21496 struct objfile *objfile)
21498 struct dwarf2_per_cu_data *this_cu;
21500 const sect_offset *cu_off;
21503 high = dwarf2_per_objfile->n_comp_units - 1;
21506 struct dwarf2_per_cu_data *mid_cu;
21507 int mid = low + (high - low) / 2;
21509 mid_cu = dwarf2_per_objfile->all_comp_units[mid];
21510 cu_off = &mid_cu->offset;
21511 if (mid_cu->is_dwz > offset_in_dwz
21512 || (mid_cu->is_dwz == offset_in_dwz
21513 && cu_off->sect_off >= offset.sect_off))
21518 gdb_assert (low == high);
21519 this_cu = dwarf2_per_objfile->all_comp_units[low];
21520 cu_off = &this_cu->offset;
21521 if (this_cu->is_dwz != offset_in_dwz || cu_off->sect_off > offset.sect_off)
21523 if (low == 0 || this_cu->is_dwz != offset_in_dwz)
21524 error (_("Dwarf Error: could not find partial DIE containing "
21525 "offset 0x%lx [in module %s]"),
21526 (long) offset.sect_off, bfd_get_filename (objfile->obfd));
21528 gdb_assert (dwarf2_per_objfile->all_comp_units[low-1]->offset.sect_off
21529 <= offset.sect_off);
21530 return dwarf2_per_objfile->all_comp_units[low-1];
21534 this_cu = dwarf2_per_objfile->all_comp_units[low];
21535 if (low == dwarf2_per_objfile->n_comp_units - 1
21536 && offset.sect_off >= this_cu->offset.sect_off + this_cu->length)
21537 error (_("invalid dwarf2 offset %u"), offset.sect_off);
21538 gdb_assert (offset.sect_off < this_cu->offset.sect_off + this_cu->length);
21543 /* Initialize dwarf2_cu CU, owned by PER_CU. */
21546 init_one_comp_unit (struct dwarf2_cu *cu, struct dwarf2_per_cu_data *per_cu)
21548 memset (cu, 0, sizeof (*cu));
21550 cu->per_cu = per_cu;
21551 cu->objfile = per_cu->objfile;
21552 obstack_init (&cu->comp_unit_obstack);
21555 /* Initialize basic fields of dwarf_cu CU according to DIE COMP_UNIT_DIE. */
21558 prepare_one_comp_unit (struct dwarf2_cu *cu, struct die_info *comp_unit_die,
21559 enum language pretend_language)
21561 struct attribute *attr;
21563 /* Set the language we're debugging. */
21564 attr = dwarf2_attr (comp_unit_die, DW_AT_language, cu);
21566 set_cu_language (DW_UNSND (attr), cu);
21569 cu->language = pretend_language;
21570 cu->language_defn = language_def (cu->language);
21573 attr = dwarf2_attr (comp_unit_die, DW_AT_producer, cu);
21575 cu->producer = DW_STRING (attr);
21578 /* Release one cached compilation unit, CU. We unlink it from the tree
21579 of compilation units, but we don't remove it from the read_in_chain;
21580 the caller is responsible for that.
21581 NOTE: DATA is a void * because this function is also used as a
21582 cleanup routine. */
21585 free_heap_comp_unit (void *data)
21587 struct dwarf2_cu *cu = data;
21589 gdb_assert (cu->per_cu != NULL);
21590 cu->per_cu->cu = NULL;
21593 obstack_free (&cu->comp_unit_obstack, NULL);
21598 /* This cleanup function is passed the address of a dwarf2_cu on the stack
21599 when we're finished with it. We can't free the pointer itself, but be
21600 sure to unlink it from the cache. Also release any associated storage. */
21603 free_stack_comp_unit (void *data)
21605 struct dwarf2_cu *cu = data;
21607 gdb_assert (cu->per_cu != NULL);
21608 cu->per_cu->cu = NULL;
21611 obstack_free (&cu->comp_unit_obstack, NULL);
21612 cu->partial_dies = NULL;
21615 /* Free all cached compilation units. */
21618 free_cached_comp_units (void *data)
21620 struct dwarf2_per_cu_data *per_cu, **last_chain;
21622 per_cu = dwarf2_per_objfile->read_in_chain;
21623 last_chain = &dwarf2_per_objfile->read_in_chain;
21624 while (per_cu != NULL)
21626 struct dwarf2_per_cu_data *next_cu;
21628 next_cu = per_cu->cu->read_in_chain;
21630 free_heap_comp_unit (per_cu->cu);
21631 *last_chain = next_cu;
21637 /* Increase the age counter on each cached compilation unit, and free
21638 any that are too old. */
21641 age_cached_comp_units (void)
21643 struct dwarf2_per_cu_data *per_cu, **last_chain;
21645 dwarf2_clear_marks (dwarf2_per_objfile->read_in_chain);
21646 per_cu = dwarf2_per_objfile->read_in_chain;
21647 while (per_cu != NULL)
21649 per_cu->cu->last_used ++;
21650 if (per_cu->cu->last_used <= dwarf2_max_cache_age)
21651 dwarf2_mark (per_cu->cu);
21652 per_cu = per_cu->cu->read_in_chain;
21655 per_cu = dwarf2_per_objfile->read_in_chain;
21656 last_chain = &dwarf2_per_objfile->read_in_chain;
21657 while (per_cu != NULL)
21659 struct dwarf2_per_cu_data *next_cu;
21661 next_cu = per_cu->cu->read_in_chain;
21663 if (!per_cu->cu->mark)
21665 free_heap_comp_unit (per_cu->cu);
21666 *last_chain = next_cu;
21669 last_chain = &per_cu->cu->read_in_chain;
21675 /* Remove a single compilation unit from the cache. */
21678 free_one_cached_comp_unit (struct dwarf2_per_cu_data *target_per_cu)
21680 struct dwarf2_per_cu_data *per_cu, **last_chain;
21682 per_cu = dwarf2_per_objfile->read_in_chain;
21683 last_chain = &dwarf2_per_objfile->read_in_chain;
21684 while (per_cu != NULL)
21686 struct dwarf2_per_cu_data *next_cu;
21688 next_cu = per_cu->cu->read_in_chain;
21690 if (per_cu == target_per_cu)
21692 free_heap_comp_unit (per_cu->cu);
21694 *last_chain = next_cu;
21698 last_chain = &per_cu->cu->read_in_chain;
21704 /* Release all extra memory associated with OBJFILE. */
21707 dwarf2_free_objfile (struct objfile *objfile)
21709 dwarf2_per_objfile = objfile_data (objfile, dwarf2_objfile_data_key);
21711 if (dwarf2_per_objfile == NULL)
21714 /* Cached DIE trees use xmalloc and the comp_unit_obstack. */
21715 free_cached_comp_units (NULL);
21717 if (dwarf2_per_objfile->quick_file_names_table)
21718 htab_delete (dwarf2_per_objfile->quick_file_names_table);
21720 /* Everything else should be on the objfile obstack. */
21723 /* A set of CU "per_cu" pointer, DIE offset, and GDB type pointer.
21724 We store these in a hash table separate from the DIEs, and preserve them
21725 when the DIEs are flushed out of cache.
21727 The CU "per_cu" pointer is needed because offset alone is not enough to
21728 uniquely identify the type. A file may have multiple .debug_types sections,
21729 or the type may come from a DWO file. Furthermore, while it's more logical
21730 to use per_cu->section+offset, with Fission the section with the data is in
21731 the DWO file but we don't know that section at the point we need it.
21732 We have to use something in dwarf2_per_cu_data (or the pointer to it)
21733 because we can enter the lookup routine, get_die_type_at_offset, from
21734 outside this file, and thus won't necessarily have PER_CU->cu.
21735 Fortunately, PER_CU is stable for the life of the objfile. */
21737 struct dwarf2_per_cu_offset_and_type
21739 const struct dwarf2_per_cu_data *per_cu;
21740 sect_offset offset;
21744 /* Hash function for a dwarf2_per_cu_offset_and_type. */
21747 per_cu_offset_and_type_hash (const void *item)
21749 const struct dwarf2_per_cu_offset_and_type *ofs = item;
21751 return (uintptr_t) ofs->per_cu + ofs->offset.sect_off;
21754 /* Equality function for a dwarf2_per_cu_offset_and_type. */
21757 per_cu_offset_and_type_eq (const void *item_lhs, const void *item_rhs)
21759 const struct dwarf2_per_cu_offset_and_type *ofs_lhs = item_lhs;
21760 const struct dwarf2_per_cu_offset_and_type *ofs_rhs = item_rhs;
21762 return (ofs_lhs->per_cu == ofs_rhs->per_cu
21763 && ofs_lhs->offset.sect_off == ofs_rhs->offset.sect_off);
21766 /* Set the type associated with DIE to TYPE. Save it in CU's hash
21767 table if necessary. For convenience, return TYPE.
21769 The DIEs reading must have careful ordering to:
21770 * Not cause infite loops trying to read in DIEs as a prerequisite for
21771 reading current DIE.
21772 * Not trying to dereference contents of still incompletely read in types
21773 while reading in other DIEs.
21774 * Enable referencing still incompletely read in types just by a pointer to
21775 the type without accessing its fields.
21777 Therefore caller should follow these rules:
21778 * Try to fetch any prerequisite types we may need to build this DIE type
21779 before building the type and calling set_die_type.
21780 * After building type call set_die_type for current DIE as soon as
21781 possible before fetching more types to complete the current type.
21782 * Make the type as complete as possible before fetching more types. */
21784 static struct type *
21785 set_die_type (struct die_info *die, struct type *type, struct dwarf2_cu *cu)
21787 struct dwarf2_per_cu_offset_and_type **slot, ofs;
21788 struct objfile *objfile = cu->objfile;
21789 struct attribute *attr;
21790 struct dynamic_prop prop;
21792 /* For Ada types, make sure that the gnat-specific data is always
21793 initialized (if not already set). There are a few types where
21794 we should not be doing so, because the type-specific area is
21795 already used to hold some other piece of info (eg: TYPE_CODE_FLT
21796 where the type-specific area is used to store the floatformat).
21797 But this is not a problem, because the gnat-specific information
21798 is actually not needed for these types. */
21799 if (need_gnat_info (cu)
21800 && TYPE_CODE (type) != TYPE_CODE_FUNC
21801 && TYPE_CODE (type) != TYPE_CODE_FLT
21802 && !HAVE_GNAT_AUX_INFO (type))
21803 INIT_GNAT_SPECIFIC (type);
21805 /* Read DW_AT_data_location and set in type. */
21806 attr = dwarf2_attr (die, DW_AT_data_location, cu);
21807 if (attr_to_dynamic_prop (attr, die, cu, &prop))
21809 TYPE_DATA_LOCATION (type)
21810 = obstack_alloc (&objfile->objfile_obstack, sizeof (prop));
21811 *TYPE_DATA_LOCATION (type) = prop;
21814 if (dwarf2_per_objfile->die_type_hash == NULL)
21816 dwarf2_per_objfile->die_type_hash =
21817 htab_create_alloc_ex (127,
21818 per_cu_offset_and_type_hash,
21819 per_cu_offset_and_type_eq,
21821 &objfile->objfile_obstack,
21822 hashtab_obstack_allocate,
21823 dummy_obstack_deallocate);
21826 ofs.per_cu = cu->per_cu;
21827 ofs.offset = die->offset;
21829 slot = (struct dwarf2_per_cu_offset_and_type **)
21830 htab_find_slot (dwarf2_per_objfile->die_type_hash, &ofs, INSERT);
21832 complaint (&symfile_complaints,
21833 _("A problem internal to GDB: DIE 0x%x has type already set"),
21834 die->offset.sect_off);
21835 *slot = obstack_alloc (&objfile->objfile_obstack, sizeof (**slot));
21840 /* Look up the type for the die at OFFSET in PER_CU in die_type_hash,
21841 or return NULL if the die does not have a saved type. */
21843 static struct type *
21844 get_die_type_at_offset (sect_offset offset,
21845 struct dwarf2_per_cu_data *per_cu)
21847 struct dwarf2_per_cu_offset_and_type *slot, ofs;
21849 if (dwarf2_per_objfile->die_type_hash == NULL)
21852 ofs.per_cu = per_cu;
21853 ofs.offset = offset;
21854 slot = htab_find (dwarf2_per_objfile->die_type_hash, &ofs);
21861 /* Look up the type for DIE in CU in die_type_hash,
21862 or return NULL if DIE does not have a saved type. */
21864 static struct type *
21865 get_die_type (struct die_info *die, struct dwarf2_cu *cu)
21867 return get_die_type_at_offset (die->offset, cu->per_cu);
21870 /* Add a dependence relationship from CU to REF_PER_CU. */
21873 dwarf2_add_dependence (struct dwarf2_cu *cu,
21874 struct dwarf2_per_cu_data *ref_per_cu)
21878 if (cu->dependencies == NULL)
21880 = htab_create_alloc_ex (5, htab_hash_pointer, htab_eq_pointer,
21881 NULL, &cu->comp_unit_obstack,
21882 hashtab_obstack_allocate,
21883 dummy_obstack_deallocate);
21885 slot = htab_find_slot (cu->dependencies, ref_per_cu, INSERT);
21887 *slot = ref_per_cu;
21890 /* Subroutine of dwarf2_mark to pass to htab_traverse.
21891 Set the mark field in every compilation unit in the
21892 cache that we must keep because we are keeping CU. */
21895 dwarf2_mark_helper (void **slot, void *data)
21897 struct dwarf2_per_cu_data *per_cu;
21899 per_cu = (struct dwarf2_per_cu_data *) *slot;
21901 /* cu->dependencies references may not yet have been ever read if QUIT aborts
21902 reading of the chain. As such dependencies remain valid it is not much
21903 useful to track and undo them during QUIT cleanups. */
21904 if (per_cu->cu == NULL)
21907 if (per_cu->cu->mark)
21909 per_cu->cu->mark = 1;
21911 if (per_cu->cu->dependencies != NULL)
21912 htab_traverse (per_cu->cu->dependencies, dwarf2_mark_helper, NULL);
21917 /* Set the mark field in CU and in every other compilation unit in the
21918 cache that we must keep because we are keeping CU. */
21921 dwarf2_mark (struct dwarf2_cu *cu)
21926 if (cu->dependencies != NULL)
21927 htab_traverse (cu->dependencies, dwarf2_mark_helper, NULL);
21931 dwarf2_clear_marks (struct dwarf2_per_cu_data *per_cu)
21935 per_cu->cu->mark = 0;
21936 per_cu = per_cu->cu->read_in_chain;
21940 /* Trivial hash function for partial_die_info: the hash value of a DIE
21941 is its offset in .debug_info for this objfile. */
21944 partial_die_hash (const void *item)
21946 const struct partial_die_info *part_die = item;
21948 return part_die->offset.sect_off;
21951 /* Trivial comparison function for partial_die_info structures: two DIEs
21952 are equal if they have the same offset. */
21955 partial_die_eq (const void *item_lhs, const void *item_rhs)
21957 const struct partial_die_info *part_die_lhs = item_lhs;
21958 const struct partial_die_info *part_die_rhs = item_rhs;
21960 return part_die_lhs->offset.sect_off == part_die_rhs->offset.sect_off;
21963 static struct cmd_list_element *set_dwarf2_cmdlist;
21964 static struct cmd_list_element *show_dwarf2_cmdlist;
21967 set_dwarf2_cmd (char *args, int from_tty)
21969 help_list (set_dwarf2_cmdlist, "maintenance set dwarf2 ", all_commands,
21974 show_dwarf2_cmd (char *args, int from_tty)
21976 cmd_show_list (show_dwarf2_cmdlist, from_tty, "");
21979 /* Free data associated with OBJFILE, if necessary. */
21982 dwarf2_per_objfile_free (struct objfile *objfile, void *d)
21984 struct dwarf2_per_objfile *data = d;
21987 /* Make sure we don't accidentally use dwarf2_per_objfile while
21989 dwarf2_per_objfile = NULL;
21991 for (ix = 0; ix < data->n_comp_units; ++ix)
21992 VEC_free (dwarf2_per_cu_ptr, data->all_comp_units[ix]->imported_symtabs);
21994 for (ix = 0; ix < data->n_type_units; ++ix)
21995 VEC_free (dwarf2_per_cu_ptr,
21996 data->all_type_units[ix]->per_cu.imported_symtabs);
21997 xfree (data->all_type_units);
21999 VEC_free (dwarf2_section_info_def, data->types);
22001 if (data->dwo_files)
22002 free_dwo_files (data->dwo_files, objfile);
22003 if (data->dwp_file)
22004 gdb_bfd_unref (data->dwp_file->dbfd);
22006 if (data->dwz_file && data->dwz_file->dwz_bfd)
22007 gdb_bfd_unref (data->dwz_file->dwz_bfd);
22011 /* The "save gdb-index" command. */
22013 /* The contents of the hash table we create when building the string
22015 struct strtab_entry
22017 offset_type offset;
22021 /* Hash function for a strtab_entry.
22023 Function is used only during write_hash_table so no index format backward
22024 compatibility is needed. */
22027 hash_strtab_entry (const void *e)
22029 const struct strtab_entry *entry = e;
22030 return mapped_index_string_hash (INT_MAX, entry->str);
22033 /* Equality function for a strtab_entry. */
22036 eq_strtab_entry (const void *a, const void *b)
22038 const struct strtab_entry *ea = a;
22039 const struct strtab_entry *eb = b;
22040 return !strcmp (ea->str, eb->str);
22043 /* Create a strtab_entry hash table. */
22046 create_strtab (void)
22048 return htab_create_alloc (100, hash_strtab_entry, eq_strtab_entry,
22049 xfree, xcalloc, xfree);
22052 /* Add a string to the constant pool. Return the string's offset in
22056 add_string (htab_t table, struct obstack *cpool, const char *str)
22059 struct strtab_entry entry;
22060 struct strtab_entry *result;
22063 slot = htab_find_slot (table, &entry, INSERT);
22068 result = XNEW (struct strtab_entry);
22069 result->offset = obstack_object_size (cpool);
22071 obstack_grow_str0 (cpool, str);
22074 return result->offset;
22077 /* An entry in the symbol table. */
22078 struct symtab_index_entry
22080 /* The name of the symbol. */
22082 /* The offset of the name in the constant pool. */
22083 offset_type index_offset;
22084 /* A sorted vector of the indices of all the CUs that hold an object
22086 VEC (offset_type) *cu_indices;
22089 /* The symbol table. This is a power-of-2-sized hash table. */
22090 struct mapped_symtab
22092 offset_type n_elements;
22094 struct symtab_index_entry **data;
22097 /* Hash function for a symtab_index_entry. */
22100 hash_symtab_entry (const void *e)
22102 const struct symtab_index_entry *entry = e;
22103 return iterative_hash (VEC_address (offset_type, entry->cu_indices),
22104 sizeof (offset_type) * VEC_length (offset_type,
22105 entry->cu_indices),
22109 /* Equality function for a symtab_index_entry. */
22112 eq_symtab_entry (const void *a, const void *b)
22114 const struct symtab_index_entry *ea = a;
22115 const struct symtab_index_entry *eb = b;
22116 int len = VEC_length (offset_type, ea->cu_indices);
22117 if (len != VEC_length (offset_type, eb->cu_indices))
22119 return !memcmp (VEC_address (offset_type, ea->cu_indices),
22120 VEC_address (offset_type, eb->cu_indices),
22121 sizeof (offset_type) * len);
22124 /* Destroy a symtab_index_entry. */
22127 delete_symtab_entry (void *p)
22129 struct symtab_index_entry *entry = p;
22130 VEC_free (offset_type, entry->cu_indices);
22134 /* Create a hash table holding symtab_index_entry objects. */
22137 create_symbol_hash_table (void)
22139 return htab_create_alloc (100, hash_symtab_entry, eq_symtab_entry,
22140 delete_symtab_entry, xcalloc, xfree);
22143 /* Create a new mapped symtab object. */
22145 static struct mapped_symtab *
22146 create_mapped_symtab (void)
22148 struct mapped_symtab *symtab = XNEW (struct mapped_symtab);
22149 symtab->n_elements = 0;
22150 symtab->size = 1024;
22151 symtab->data = XCNEWVEC (struct symtab_index_entry *, symtab->size);
22155 /* Destroy a mapped_symtab. */
22158 cleanup_mapped_symtab (void *p)
22160 struct mapped_symtab *symtab = p;
22161 /* The contents of the array are freed when the other hash table is
22163 xfree (symtab->data);
22167 /* Find a slot in SYMTAB for the symbol NAME. Returns a pointer to
22170 Function is used only during write_hash_table so no index format backward
22171 compatibility is needed. */
22173 static struct symtab_index_entry **
22174 find_slot (struct mapped_symtab *symtab, const char *name)
22176 offset_type index, step, hash = mapped_index_string_hash (INT_MAX, name);
22178 index = hash & (symtab->size - 1);
22179 step = ((hash * 17) & (symtab->size - 1)) | 1;
22183 if (!symtab->data[index] || !strcmp (name, symtab->data[index]->name))
22184 return &symtab->data[index];
22185 index = (index + step) & (symtab->size - 1);
22189 /* Expand SYMTAB's hash table. */
22192 hash_expand (struct mapped_symtab *symtab)
22194 offset_type old_size = symtab->size;
22196 struct symtab_index_entry **old_entries = symtab->data;
22199 symtab->data = XCNEWVEC (struct symtab_index_entry *, symtab->size);
22201 for (i = 0; i < old_size; ++i)
22203 if (old_entries[i])
22205 struct symtab_index_entry **slot = find_slot (symtab,
22206 old_entries[i]->name);
22207 *slot = old_entries[i];
22211 xfree (old_entries);
22214 /* Add an entry to SYMTAB. NAME is the name of the symbol.
22215 CU_INDEX is the index of the CU in which the symbol appears.
22216 IS_STATIC is one if the symbol is static, otherwise zero (global). */
22219 add_index_entry (struct mapped_symtab *symtab, const char *name,
22220 int is_static, gdb_index_symbol_kind kind,
22221 offset_type cu_index)
22223 struct symtab_index_entry **slot;
22224 offset_type cu_index_and_attrs;
22226 ++symtab->n_elements;
22227 if (4 * symtab->n_elements / 3 >= symtab->size)
22228 hash_expand (symtab);
22230 slot = find_slot (symtab, name);
22233 *slot = XNEW (struct symtab_index_entry);
22234 (*slot)->name = name;
22235 /* index_offset is set later. */
22236 (*slot)->cu_indices = NULL;
22239 cu_index_and_attrs = 0;
22240 DW2_GDB_INDEX_CU_SET_VALUE (cu_index_and_attrs, cu_index);
22241 DW2_GDB_INDEX_SYMBOL_STATIC_SET_VALUE (cu_index_and_attrs, is_static);
22242 DW2_GDB_INDEX_SYMBOL_KIND_SET_VALUE (cu_index_and_attrs, kind);
22244 /* We don't want to record an index value twice as we want to avoid the
22246 We process all global symbols and then all static symbols
22247 (which would allow us to avoid the duplication by only having to check
22248 the last entry pushed), but a symbol could have multiple kinds in one CU.
22249 To keep things simple we don't worry about the duplication here and
22250 sort and uniqufy the list after we've processed all symbols. */
22251 VEC_safe_push (offset_type, (*slot)->cu_indices, cu_index_and_attrs);
22254 /* qsort helper routine for uniquify_cu_indices. */
22257 offset_type_compare (const void *ap, const void *bp)
22259 offset_type a = *(offset_type *) ap;
22260 offset_type b = *(offset_type *) bp;
22262 return (a > b) - (b > a);
22265 /* Sort and remove duplicates of all symbols' cu_indices lists. */
22268 uniquify_cu_indices (struct mapped_symtab *symtab)
22272 for (i = 0; i < symtab->size; ++i)
22274 struct symtab_index_entry *entry = symtab->data[i];
22277 && entry->cu_indices != NULL)
22279 unsigned int next_to_insert, next_to_check;
22280 offset_type last_value;
22282 qsort (VEC_address (offset_type, entry->cu_indices),
22283 VEC_length (offset_type, entry->cu_indices),
22284 sizeof (offset_type), offset_type_compare);
22286 last_value = VEC_index (offset_type, entry->cu_indices, 0);
22287 next_to_insert = 1;
22288 for (next_to_check = 1;
22289 next_to_check < VEC_length (offset_type, entry->cu_indices);
22292 if (VEC_index (offset_type, entry->cu_indices, next_to_check)
22295 last_value = VEC_index (offset_type, entry->cu_indices,
22297 VEC_replace (offset_type, entry->cu_indices, next_to_insert,
22302 VEC_truncate (offset_type, entry->cu_indices, next_to_insert);
22307 /* Add a vector of indices to the constant pool. */
22310 add_indices_to_cpool (htab_t symbol_hash_table, struct obstack *cpool,
22311 struct symtab_index_entry *entry)
22315 slot = htab_find_slot (symbol_hash_table, entry, INSERT);
22318 offset_type len = VEC_length (offset_type, entry->cu_indices);
22319 offset_type val = MAYBE_SWAP (len);
22324 entry->index_offset = obstack_object_size (cpool);
22326 obstack_grow (cpool, &val, sizeof (val));
22328 VEC_iterate (offset_type, entry->cu_indices, i, iter);
22331 val = MAYBE_SWAP (iter);
22332 obstack_grow (cpool, &val, sizeof (val));
22337 struct symtab_index_entry *old_entry = *slot;
22338 entry->index_offset = old_entry->index_offset;
22341 return entry->index_offset;
22344 /* Write the mapped hash table SYMTAB to the obstack OUTPUT, with
22345 constant pool entries going into the obstack CPOOL. */
22348 write_hash_table (struct mapped_symtab *symtab,
22349 struct obstack *output, struct obstack *cpool)
22352 htab_t symbol_hash_table;
22355 symbol_hash_table = create_symbol_hash_table ();
22356 str_table = create_strtab ();
22358 /* We add all the index vectors to the constant pool first, to
22359 ensure alignment is ok. */
22360 for (i = 0; i < symtab->size; ++i)
22362 if (symtab->data[i])
22363 add_indices_to_cpool (symbol_hash_table, cpool, symtab->data[i]);
22366 /* Now write out the hash table. */
22367 for (i = 0; i < symtab->size; ++i)
22369 offset_type str_off, vec_off;
22371 if (symtab->data[i])
22373 str_off = add_string (str_table, cpool, symtab->data[i]->name);
22374 vec_off = symtab->data[i]->index_offset;
22378 /* While 0 is a valid constant pool index, it is not valid
22379 to have 0 for both offsets. */
22384 str_off = MAYBE_SWAP (str_off);
22385 vec_off = MAYBE_SWAP (vec_off);
22387 obstack_grow (output, &str_off, sizeof (str_off));
22388 obstack_grow (output, &vec_off, sizeof (vec_off));
22391 htab_delete (str_table);
22392 htab_delete (symbol_hash_table);
22395 /* Struct to map psymtab to CU index in the index file. */
22396 struct psymtab_cu_index_map
22398 struct partial_symtab *psymtab;
22399 unsigned int cu_index;
22403 hash_psymtab_cu_index (const void *item)
22405 const struct psymtab_cu_index_map *map = item;
22407 return htab_hash_pointer (map->psymtab);
22411 eq_psymtab_cu_index (const void *item_lhs, const void *item_rhs)
22413 const struct psymtab_cu_index_map *lhs = item_lhs;
22414 const struct psymtab_cu_index_map *rhs = item_rhs;
22416 return lhs->psymtab == rhs->psymtab;
22419 /* Helper struct for building the address table. */
22420 struct addrmap_index_data
22422 struct objfile *objfile;
22423 struct obstack *addr_obstack;
22424 htab_t cu_index_htab;
22426 /* Non-zero if the previous_* fields are valid.
22427 We can't write an entry until we see the next entry (since it is only then
22428 that we know the end of the entry). */
22429 int previous_valid;
22430 /* Index of the CU in the table of all CUs in the index file. */
22431 unsigned int previous_cu_index;
22432 /* Start address of the CU. */
22433 CORE_ADDR previous_cu_start;
22436 /* Write an address entry to OBSTACK. */
22439 add_address_entry (struct objfile *objfile, struct obstack *obstack,
22440 CORE_ADDR start, CORE_ADDR end, unsigned int cu_index)
22442 offset_type cu_index_to_write;
22444 CORE_ADDR baseaddr;
22446 baseaddr = ANOFFSET (objfile->section_offsets, SECT_OFF_TEXT (objfile));
22448 store_unsigned_integer (addr, 8, BFD_ENDIAN_LITTLE, start - baseaddr);
22449 obstack_grow (obstack, addr, 8);
22450 store_unsigned_integer (addr, 8, BFD_ENDIAN_LITTLE, end - baseaddr);
22451 obstack_grow (obstack, addr, 8);
22452 cu_index_to_write = MAYBE_SWAP (cu_index);
22453 obstack_grow (obstack, &cu_index_to_write, sizeof (offset_type));
22456 /* Worker function for traversing an addrmap to build the address table. */
22459 add_address_entry_worker (void *datap, CORE_ADDR start_addr, void *obj)
22461 struct addrmap_index_data *data = datap;
22462 struct partial_symtab *pst = obj;
22464 if (data->previous_valid)
22465 add_address_entry (data->objfile, data->addr_obstack,
22466 data->previous_cu_start, start_addr,
22467 data->previous_cu_index);
22469 data->previous_cu_start = start_addr;
22472 struct psymtab_cu_index_map find_map, *map;
22473 find_map.psymtab = pst;
22474 map = htab_find (data->cu_index_htab, &find_map);
22475 gdb_assert (map != NULL);
22476 data->previous_cu_index = map->cu_index;
22477 data->previous_valid = 1;
22480 data->previous_valid = 0;
22485 /* Write OBJFILE's address map to OBSTACK.
22486 CU_INDEX_HTAB is used to map addrmap entries to their CU indices
22487 in the index file. */
22490 write_address_map (struct objfile *objfile, struct obstack *obstack,
22491 htab_t cu_index_htab)
22493 struct addrmap_index_data addrmap_index_data;
22495 /* When writing the address table, we have to cope with the fact that
22496 the addrmap iterator only provides the start of a region; we have to
22497 wait until the next invocation to get the start of the next region. */
22499 addrmap_index_data.objfile = objfile;
22500 addrmap_index_data.addr_obstack = obstack;
22501 addrmap_index_data.cu_index_htab = cu_index_htab;
22502 addrmap_index_data.previous_valid = 0;
22504 addrmap_foreach (objfile->psymtabs_addrmap, add_address_entry_worker,
22505 &addrmap_index_data);
22507 /* It's highly unlikely the last entry (end address = 0xff...ff)
22508 is valid, but we should still handle it.
22509 The end address is recorded as the start of the next region, but that
22510 doesn't work here. To cope we pass 0xff...ff, this is a rare situation
22512 if (addrmap_index_data.previous_valid)
22513 add_address_entry (objfile, obstack,
22514 addrmap_index_data.previous_cu_start, (CORE_ADDR) -1,
22515 addrmap_index_data.previous_cu_index);
22518 /* Return the symbol kind of PSYM. */
22520 static gdb_index_symbol_kind
22521 symbol_kind (struct partial_symbol *psym)
22523 domain_enum domain = PSYMBOL_DOMAIN (psym);
22524 enum address_class aclass = PSYMBOL_CLASS (psym);
22532 return GDB_INDEX_SYMBOL_KIND_FUNCTION;
22534 return GDB_INDEX_SYMBOL_KIND_TYPE;
22536 case LOC_CONST_BYTES:
22537 case LOC_OPTIMIZED_OUT:
22539 return GDB_INDEX_SYMBOL_KIND_VARIABLE;
22541 /* Note: It's currently impossible to recognize psyms as enum values
22542 short of reading the type info. For now punt. */
22543 return GDB_INDEX_SYMBOL_KIND_VARIABLE;
22545 /* There are other LOC_FOO values that one might want to classify
22546 as variables, but dwarf2read.c doesn't currently use them. */
22547 return GDB_INDEX_SYMBOL_KIND_OTHER;
22549 case STRUCT_DOMAIN:
22550 return GDB_INDEX_SYMBOL_KIND_TYPE;
22552 return GDB_INDEX_SYMBOL_KIND_OTHER;
22556 /* Add a list of partial symbols to SYMTAB. */
22559 write_psymbols (struct mapped_symtab *symtab,
22561 struct partial_symbol **psymp,
22563 offset_type cu_index,
22566 for (; count-- > 0; ++psymp)
22568 struct partial_symbol *psym = *psymp;
22571 if (SYMBOL_LANGUAGE (psym) == language_ada)
22572 error (_("Ada is not currently supported by the index"));
22574 /* Only add a given psymbol once. */
22575 slot = htab_find_slot (psyms_seen, psym, INSERT);
22578 gdb_index_symbol_kind kind = symbol_kind (psym);
22581 add_index_entry (symtab, SYMBOL_SEARCH_NAME (psym),
22582 is_static, kind, cu_index);
22587 /* Write the contents of an ("unfinished") obstack to FILE. Throw an
22588 exception if there is an error. */
22591 write_obstack (FILE *file, struct obstack *obstack)
22593 if (fwrite (obstack_base (obstack), 1, obstack_object_size (obstack),
22595 != obstack_object_size (obstack))
22596 error (_("couldn't data write to file"));
22599 /* Unlink a file if the argument is not NULL. */
22602 unlink_if_set (void *p)
22604 char **filename = p;
22606 unlink (*filename);
22609 /* A helper struct used when iterating over debug_types. */
22610 struct signatured_type_index_data
22612 struct objfile *objfile;
22613 struct mapped_symtab *symtab;
22614 struct obstack *types_list;
22619 /* A helper function that writes a single signatured_type to an
22623 write_one_signatured_type (void **slot, void *d)
22625 struct signatured_type_index_data *info = d;
22626 struct signatured_type *entry = (struct signatured_type *) *slot;
22627 struct partial_symtab *psymtab = entry->per_cu.v.psymtab;
22630 write_psymbols (info->symtab,
22632 info->objfile->global_psymbols.list
22633 + psymtab->globals_offset,
22634 psymtab->n_global_syms, info->cu_index,
22636 write_psymbols (info->symtab,
22638 info->objfile->static_psymbols.list
22639 + psymtab->statics_offset,
22640 psymtab->n_static_syms, info->cu_index,
22643 store_unsigned_integer (val, 8, BFD_ENDIAN_LITTLE,
22644 entry->per_cu.offset.sect_off);
22645 obstack_grow (info->types_list, val, 8);
22646 store_unsigned_integer (val, 8, BFD_ENDIAN_LITTLE,
22647 entry->type_offset_in_tu.cu_off);
22648 obstack_grow (info->types_list, val, 8);
22649 store_unsigned_integer (val, 8, BFD_ENDIAN_LITTLE, entry->signature);
22650 obstack_grow (info->types_list, val, 8);
22657 /* Recurse into all "included" dependencies and write their symbols as
22658 if they appeared in this psymtab. */
22661 recursively_write_psymbols (struct objfile *objfile,
22662 struct partial_symtab *psymtab,
22663 struct mapped_symtab *symtab,
22665 offset_type cu_index)
22669 for (i = 0; i < psymtab->number_of_dependencies; ++i)
22670 if (psymtab->dependencies[i]->user != NULL)
22671 recursively_write_psymbols (objfile, psymtab->dependencies[i],
22672 symtab, psyms_seen, cu_index);
22674 write_psymbols (symtab,
22676 objfile->global_psymbols.list + psymtab->globals_offset,
22677 psymtab->n_global_syms, cu_index,
22679 write_psymbols (symtab,
22681 objfile->static_psymbols.list + psymtab->statics_offset,
22682 psymtab->n_static_syms, cu_index,
22686 /* Create an index file for OBJFILE in the directory DIR. */
22689 write_psymtabs_to_index (struct objfile *objfile, const char *dir)
22691 struct cleanup *cleanup;
22692 char *filename, *cleanup_filename;
22693 struct obstack contents, addr_obstack, constant_pool, symtab_obstack;
22694 struct obstack cu_list, types_cu_list;
22697 struct mapped_symtab *symtab;
22698 offset_type val, size_of_contents, total_len;
22701 htab_t cu_index_htab;
22702 struct psymtab_cu_index_map *psymtab_cu_index_map;
22704 if (dwarf2_per_objfile->using_index)
22705 error (_("Cannot use an index to create the index"));
22707 if (VEC_length (dwarf2_section_info_def, dwarf2_per_objfile->types) > 1)
22708 error (_("Cannot make an index when the file has multiple .debug_types sections"));
22710 if (!objfile->psymtabs || !objfile->psymtabs_addrmap)
22713 if (stat (objfile_name (objfile), &st) < 0)
22714 perror_with_name (objfile_name (objfile));
22716 filename = concat (dir, SLASH_STRING, lbasename (objfile_name (objfile)),
22717 INDEX_SUFFIX, (char *) NULL);
22718 cleanup = make_cleanup (xfree, filename);
22720 out_file = gdb_fopen_cloexec (filename, "wb");
22722 error (_("Can't open `%s' for writing"), filename);
22724 cleanup_filename = filename;
22725 make_cleanup (unlink_if_set, &cleanup_filename);
22727 symtab = create_mapped_symtab ();
22728 make_cleanup (cleanup_mapped_symtab, symtab);
22730 obstack_init (&addr_obstack);
22731 make_cleanup_obstack_free (&addr_obstack);
22733 obstack_init (&cu_list);
22734 make_cleanup_obstack_free (&cu_list);
22736 obstack_init (&types_cu_list);
22737 make_cleanup_obstack_free (&types_cu_list);
22739 psyms_seen = htab_create_alloc (100, htab_hash_pointer, htab_eq_pointer,
22740 NULL, xcalloc, xfree);
22741 make_cleanup_htab_delete (psyms_seen);
22743 /* While we're scanning CU's create a table that maps a psymtab pointer
22744 (which is what addrmap records) to its index (which is what is recorded
22745 in the index file). This will later be needed to write the address
22747 cu_index_htab = htab_create_alloc (100,
22748 hash_psymtab_cu_index,
22749 eq_psymtab_cu_index,
22750 NULL, xcalloc, xfree);
22751 make_cleanup_htab_delete (cu_index_htab);
22752 psymtab_cu_index_map = (struct psymtab_cu_index_map *)
22753 xmalloc (sizeof (struct psymtab_cu_index_map)
22754 * dwarf2_per_objfile->n_comp_units);
22755 make_cleanup (xfree, psymtab_cu_index_map);
22757 /* The CU list is already sorted, so we don't need to do additional
22758 work here. Also, the debug_types entries do not appear in
22759 all_comp_units, but only in their own hash table. */
22760 for (i = 0; i < dwarf2_per_objfile->n_comp_units; ++i)
22762 struct dwarf2_per_cu_data *per_cu
22763 = dwarf2_per_objfile->all_comp_units[i];
22764 struct partial_symtab *psymtab = per_cu->v.psymtab;
22766 struct psymtab_cu_index_map *map;
22769 /* CU of a shared file from 'dwz -m' may be unused by this main file.
22770 It may be referenced from a local scope but in such case it does not
22771 need to be present in .gdb_index. */
22772 if (psymtab == NULL)
22775 if (psymtab->user == NULL)
22776 recursively_write_psymbols (objfile, psymtab, symtab, psyms_seen, i);
22778 map = &psymtab_cu_index_map[i];
22779 map->psymtab = psymtab;
22781 slot = htab_find_slot (cu_index_htab, map, INSERT);
22782 gdb_assert (slot != NULL);
22783 gdb_assert (*slot == NULL);
22786 store_unsigned_integer (val, 8, BFD_ENDIAN_LITTLE,
22787 per_cu->offset.sect_off);
22788 obstack_grow (&cu_list, val, 8);
22789 store_unsigned_integer (val, 8, BFD_ENDIAN_LITTLE, per_cu->length);
22790 obstack_grow (&cu_list, val, 8);
22793 /* Dump the address map. */
22794 write_address_map (objfile, &addr_obstack, cu_index_htab);
22796 /* Write out the .debug_type entries, if any. */
22797 if (dwarf2_per_objfile->signatured_types)
22799 struct signatured_type_index_data sig_data;
22801 sig_data.objfile = objfile;
22802 sig_data.symtab = symtab;
22803 sig_data.types_list = &types_cu_list;
22804 sig_data.psyms_seen = psyms_seen;
22805 sig_data.cu_index = dwarf2_per_objfile->n_comp_units;
22806 htab_traverse_noresize (dwarf2_per_objfile->signatured_types,
22807 write_one_signatured_type, &sig_data);
22810 /* Now that we've processed all symbols we can shrink their cu_indices
22812 uniquify_cu_indices (symtab);
22814 obstack_init (&constant_pool);
22815 make_cleanup_obstack_free (&constant_pool);
22816 obstack_init (&symtab_obstack);
22817 make_cleanup_obstack_free (&symtab_obstack);
22818 write_hash_table (symtab, &symtab_obstack, &constant_pool);
22820 obstack_init (&contents);
22821 make_cleanup_obstack_free (&contents);
22822 size_of_contents = 6 * sizeof (offset_type);
22823 total_len = size_of_contents;
22825 /* The version number. */
22826 val = MAYBE_SWAP (8);
22827 obstack_grow (&contents, &val, sizeof (val));
22829 /* The offset of the CU list from the start of the file. */
22830 val = MAYBE_SWAP (total_len);
22831 obstack_grow (&contents, &val, sizeof (val));
22832 total_len += obstack_object_size (&cu_list);
22834 /* The offset of the types CU list from the start of the file. */
22835 val = MAYBE_SWAP (total_len);
22836 obstack_grow (&contents, &val, sizeof (val));
22837 total_len += obstack_object_size (&types_cu_list);
22839 /* The offset of the address table from the start of the file. */
22840 val = MAYBE_SWAP (total_len);
22841 obstack_grow (&contents, &val, sizeof (val));
22842 total_len += obstack_object_size (&addr_obstack);
22844 /* The offset of the symbol table from the start of the file. */
22845 val = MAYBE_SWAP (total_len);
22846 obstack_grow (&contents, &val, sizeof (val));
22847 total_len += obstack_object_size (&symtab_obstack);
22849 /* The offset of the constant pool from the start of the file. */
22850 val = MAYBE_SWAP (total_len);
22851 obstack_grow (&contents, &val, sizeof (val));
22852 total_len += obstack_object_size (&constant_pool);
22854 gdb_assert (obstack_object_size (&contents) == size_of_contents);
22856 write_obstack (out_file, &contents);
22857 write_obstack (out_file, &cu_list);
22858 write_obstack (out_file, &types_cu_list);
22859 write_obstack (out_file, &addr_obstack);
22860 write_obstack (out_file, &symtab_obstack);
22861 write_obstack (out_file, &constant_pool);
22865 /* We want to keep the file, so we set cleanup_filename to NULL
22866 here. See unlink_if_set. */
22867 cleanup_filename = NULL;
22869 do_cleanups (cleanup);
22872 /* Implementation of the `save gdb-index' command.
22874 Note that the file format used by this command is documented in the
22875 GDB manual. Any changes here must be documented there. */
22878 save_gdb_index_command (char *arg, int from_tty)
22880 struct objfile *objfile;
22883 error (_("usage: save gdb-index DIRECTORY"));
22885 ALL_OBJFILES (objfile)
22889 /* If the objfile does not correspond to an actual file, skip it. */
22890 if (stat (objfile_name (objfile), &st) < 0)
22893 dwarf2_per_objfile = objfile_data (objfile, dwarf2_objfile_data_key);
22894 if (dwarf2_per_objfile)
22896 volatile struct gdb_exception except;
22898 TRY_CATCH (except, RETURN_MASK_ERROR)
22900 write_psymtabs_to_index (objfile, arg);
22902 if (except.reason < 0)
22903 exception_fprintf (gdb_stderr, except,
22904 _("Error while writing index for `%s': "),
22905 objfile_name (objfile));
22912 int dwarf2_always_disassemble;
22915 show_dwarf2_always_disassemble (struct ui_file *file, int from_tty,
22916 struct cmd_list_element *c, const char *value)
22918 fprintf_filtered (file,
22919 _("Whether to always disassemble "
22920 "DWARF expressions is %s.\n"),
22925 show_check_physname (struct ui_file *file, int from_tty,
22926 struct cmd_list_element *c, const char *value)
22928 fprintf_filtered (file,
22929 _("Whether to check \"physname\" is %s.\n"),
22933 void _initialize_dwarf2_read (void);
22936 _initialize_dwarf2_read (void)
22938 struct cmd_list_element *c;
22940 dwarf2_objfile_data_key
22941 = register_objfile_data_with_cleanup (NULL, dwarf2_per_objfile_free);
22943 add_prefix_cmd ("dwarf2", class_maintenance, set_dwarf2_cmd, _("\
22944 Set DWARF 2 specific variables.\n\
22945 Configure DWARF 2 variables such as the cache size"),
22946 &set_dwarf2_cmdlist, "maintenance set dwarf2 ",
22947 0/*allow-unknown*/, &maintenance_set_cmdlist);
22949 add_prefix_cmd ("dwarf2", class_maintenance, show_dwarf2_cmd, _("\
22950 Show DWARF 2 specific variables\n\
22951 Show DWARF 2 variables such as the cache size"),
22952 &show_dwarf2_cmdlist, "maintenance show dwarf2 ",
22953 0/*allow-unknown*/, &maintenance_show_cmdlist);
22955 add_setshow_zinteger_cmd ("max-cache-age", class_obscure,
22956 &dwarf2_max_cache_age, _("\
22957 Set the upper bound on the age of cached dwarf2 compilation units."), _("\
22958 Show the upper bound on the age of cached dwarf2 compilation units."), _("\
22959 A higher limit means that cached compilation units will be stored\n\
22960 in memory longer, and more total memory will be used. Zero disables\n\
22961 caching, which can slow down startup."),
22963 show_dwarf2_max_cache_age,
22964 &set_dwarf2_cmdlist,
22965 &show_dwarf2_cmdlist);
22967 add_setshow_boolean_cmd ("always-disassemble", class_obscure,
22968 &dwarf2_always_disassemble, _("\
22969 Set whether `info address' always disassembles DWARF expressions."), _("\
22970 Show whether `info address' always disassembles DWARF expressions."), _("\
22971 When enabled, DWARF expressions are always printed in an assembly-like\n\
22972 syntax. When disabled, expressions will be printed in a more\n\
22973 conversational style, when possible."),
22975 show_dwarf2_always_disassemble,
22976 &set_dwarf2_cmdlist,
22977 &show_dwarf2_cmdlist);
22979 add_setshow_zuinteger_cmd ("dwarf2-read", no_class, &dwarf2_read_debug, _("\
22980 Set debugging of the dwarf2 reader."), _("\
22981 Show debugging of the dwarf2 reader."), _("\
22982 When enabled (non-zero), debugging messages are printed during dwarf2\n\
22983 reading and symtab expansion. A value of 1 (one) provides basic\n\
22984 information. A value greater than 1 provides more verbose information."),
22987 &setdebuglist, &showdebuglist);
22989 add_setshow_zuinteger_cmd ("dwarf2-die", no_class, &dwarf2_die_debug, _("\
22990 Set debugging of the dwarf2 DIE reader."), _("\
22991 Show debugging of the dwarf2 DIE reader."), _("\
22992 When enabled (non-zero), DIEs are dumped after they are read in.\n\
22993 The value is the maximum depth to print."),
22996 &setdebuglist, &showdebuglist);
22998 add_setshow_boolean_cmd ("check-physname", no_class, &check_physname, _("\
22999 Set cross-checking of \"physname\" code against demangler."), _("\
23000 Show cross-checking of \"physname\" code against demangler."), _("\
23001 When enabled, GDB's internal \"physname\" code is checked against\n\
23003 NULL, show_check_physname,
23004 &setdebuglist, &showdebuglist);
23006 add_setshow_boolean_cmd ("use-deprecated-index-sections",
23007 no_class, &use_deprecated_index_sections, _("\
23008 Set whether to use deprecated gdb_index sections."), _("\
23009 Show whether to use deprecated gdb_index sections."), _("\
23010 When enabled, deprecated .gdb_index sections are used anyway.\n\
23011 Normally they are ignored either because of a missing feature or\n\
23012 performance issue.\n\
23013 Warning: This option must be enabled before gdb reads the file."),
23016 &setlist, &showlist);
23018 c = add_cmd ("gdb-index", class_files, save_gdb_index_command,
23020 Save a gdb-index file.\n\
23021 Usage: save gdb-index DIRECTORY"),
23023 set_cmd_completer (c, filename_completer);
23025 dwarf2_locexpr_index = register_symbol_computed_impl (LOC_COMPUTED,
23026 &dwarf2_locexpr_funcs);
23027 dwarf2_loclist_index = register_symbol_computed_impl (LOC_COMPUTED,
23028 &dwarf2_loclist_funcs);
23030 dwarf2_locexpr_block_index = register_symbol_block_impl (LOC_BLOCK,
23031 &dwarf2_block_frame_base_locexpr_funcs);
23032 dwarf2_loclist_block_index = register_symbol_block_impl (LOC_BLOCK,
23033 &dwarf2_block_frame_base_loclist_funcs);