1 /* DWARF 2 debugging format support for GDB.
3 Copyright (C) 1994-2013 Free Software Foundation, Inc.
5 Adapted by Gary Funck (gary@intrepid.com), Intrepid Technology,
6 Inc. with support from Florida State University (under contract
7 with the Ada Joint Program Office), and Silicon Graphics, Inc.
8 Initial contribution by Brent Benson, Harris Computer Systems, Inc.,
9 based on Fred Fish's (Cygnus Support) implementation of DWARF 1
12 This file is part of GDB.
14 This program is free software; you can redistribute it and/or modify
15 it under the terms of the GNU General Public License as published by
16 the Free Software Foundation; either version 3 of the License, or
17 (at your option) any later version.
19 This program is distributed in the hope that it will be useful,
20 but WITHOUT ANY WARRANTY; without even the implied warranty of
21 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
22 GNU General Public License for more details.
24 You should have received a copy of the GNU General Public License
25 along with this program. If not, see <http://www.gnu.org/licenses/>. */
27 /* FIXME: Various die-reading functions need to be more careful with
28 reading off the end of the section.
29 E.g., load_partial_dies, read_partial_die. */
40 #include "gdb-demangle.h"
41 #include "expression.h"
42 #include "filenames.h" /* for DOSish file names */
45 #include "complaints.h"
47 #include "dwarf2expr.h"
48 #include "dwarf2loc.h"
49 #include "cp-support.h"
55 #include "typeprint.h"
58 #include "exceptions.h"
60 #include "completer.h"
65 #include "gdbcore.h" /* for gnutarget */
66 #include "gdb/gdb-index.h"
73 #include "gdb_string.h"
74 #include "gdb_assert.h"
75 #include <sys/types.h>
77 typedef struct symbol
*symbolp
;
80 /* When non-zero, print basic high level tracing messages.
81 This is in contrast to the low level DIE reading of dwarf2_die_debug. */
82 static 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 struct dwarf2_section_info
107 /* True if we have tried to read this section. */
111 typedef struct dwarf2_section_info dwarf2_section_info_def
;
112 DEF_VEC_O (dwarf2_section_info_def
);
114 /* All offsets in the index are of this type. It must be
115 architecture-independent. */
116 typedef uint32_t offset_type
;
118 DEF_VEC_I (offset_type
);
120 /* Ensure only legit values are used. */
121 #define DW2_GDB_INDEX_SYMBOL_STATIC_SET_VALUE(cu_index, value) \
123 gdb_assert ((unsigned int) (value) <= 1); \
124 GDB_INDEX_SYMBOL_STATIC_SET_VALUE((cu_index), (value)); \
127 /* Ensure only legit values are used. */
128 #define DW2_GDB_INDEX_SYMBOL_KIND_SET_VALUE(cu_index, value) \
130 gdb_assert ((value) >= GDB_INDEX_SYMBOL_KIND_TYPE \
131 && (value) <= GDB_INDEX_SYMBOL_KIND_OTHER); \
132 GDB_INDEX_SYMBOL_KIND_SET_VALUE((cu_index), (value)); \
135 /* Ensure we don't use more than the alloted nuber of bits for the CU. */
136 #define DW2_GDB_INDEX_CU_SET_VALUE(cu_index, value) \
138 gdb_assert (((value) & ~GDB_INDEX_CU_MASK) == 0); \
139 GDB_INDEX_CU_SET_VALUE((cu_index), (value)); \
142 /* A description of the mapped index. The file format is described in
143 a comment by the code that writes the index. */
146 /* Index data format version. */
149 /* The total length of the buffer. */
152 /* A pointer to the address table data. */
153 const gdb_byte
*address_table
;
155 /* Size of the address table data in bytes. */
156 offset_type address_table_size
;
158 /* The symbol table, implemented as a hash table. */
159 const offset_type
*symbol_table
;
161 /* Size in slots, each slot is 2 offset_types. */
162 offset_type symbol_table_slots
;
164 /* A pointer to the constant pool. */
165 const char *constant_pool
;
168 typedef struct dwarf2_per_cu_data
*dwarf2_per_cu_ptr
;
169 DEF_VEC_P (dwarf2_per_cu_ptr
);
171 /* Collection of data recorded per objfile.
172 This hangs off of dwarf2_objfile_data_key. */
174 struct dwarf2_per_objfile
176 struct dwarf2_section_info info
;
177 struct dwarf2_section_info abbrev
;
178 struct dwarf2_section_info line
;
179 struct dwarf2_section_info loc
;
180 struct dwarf2_section_info macinfo
;
181 struct dwarf2_section_info macro
;
182 struct dwarf2_section_info str
;
183 struct dwarf2_section_info ranges
;
184 struct dwarf2_section_info addr
;
185 struct dwarf2_section_info frame
;
186 struct dwarf2_section_info eh_frame
;
187 struct dwarf2_section_info gdb_index
;
189 VEC (dwarf2_section_info_def
) *types
;
192 struct objfile
*objfile
;
194 /* Table of all the compilation units. This is used to locate
195 the target compilation unit of a particular reference. */
196 struct dwarf2_per_cu_data
**all_comp_units
;
198 /* The number of compilation units in ALL_COMP_UNITS. */
201 /* The number of .debug_types-related CUs. */
204 /* The .debug_types-related CUs (TUs). */
205 struct signatured_type
**all_type_units
;
207 /* The number of entries in all_type_unit_groups. */
208 int n_type_unit_groups
;
210 /* Table of type unit groups.
211 This exists to make it easy to iterate over all CUs and TU groups. */
212 struct type_unit_group
**all_type_unit_groups
;
214 /* Table of struct type_unit_group objects.
215 The hash key is the DW_AT_stmt_list value. */
216 htab_t type_unit_groups
;
218 /* A table mapping .debug_types signatures to its signatured_type entry.
219 This is NULL if the .debug_types section hasn't been read in yet. */
220 htab_t signatured_types
;
222 /* Type unit statistics, to see how well the scaling improvements
226 int nr_uniq_abbrev_tables
;
228 int nr_symtab_sharers
;
229 int nr_stmt_less_type_units
;
232 /* A chain of compilation units that are currently read in, so that
233 they can be freed later. */
234 struct dwarf2_per_cu_data
*read_in_chain
;
236 /* A table mapping DW_AT_dwo_name values to struct dwo_file objects.
237 This is NULL if the table hasn't been allocated yet. */
240 /* Non-zero if we've check for whether there is a DWP file. */
243 /* The DWP file if there is one, or NULL. */
244 struct dwp_file
*dwp_file
;
246 /* The shared '.dwz' file, if one exists. This is used when the
247 original data was compressed using 'dwz -m'. */
248 struct dwz_file
*dwz_file
;
250 /* A flag indicating wether this objfile has a section loaded at a
252 int has_section_at_zero
;
254 /* True if we are using the mapped index,
255 or we are faking it for OBJF_READNOW's sake. */
256 unsigned char using_index
;
258 /* The mapped index, or NULL if .gdb_index is missing or not being used. */
259 struct mapped_index
*index_table
;
261 /* When using index_table, this keeps track of all quick_file_names entries.
262 TUs typically share line table entries with a CU, so we maintain a
263 separate table of all line table entries to support the sharing.
264 Note that while there can be way more TUs than CUs, we've already
265 sorted all the TUs into "type unit groups", grouped by their
266 DW_AT_stmt_list value. Therefore the only sharing done here is with a
267 CU and its associated TU group if there is one. */
268 htab_t quick_file_names_table
;
270 /* Set during partial symbol reading, to prevent queueing of full
272 int reading_partial_symbols
;
274 /* Table mapping type DIEs to their struct type *.
275 This is NULL if not allocated yet.
276 The mapping is done via (CU/TU + DIE offset) -> type. */
277 htab_t die_type_hash
;
279 /* The CUs we recently read. */
280 VEC (dwarf2_per_cu_ptr
) *just_read_cus
;
283 static struct dwarf2_per_objfile
*dwarf2_per_objfile
;
285 /* Default names of the debugging sections. */
287 /* Note that if the debugging section has been compressed, it might
288 have a name like .zdebug_info. */
290 static const struct dwarf2_debug_sections dwarf2_elf_names
=
292 { ".debug_info", ".zdebug_info" },
293 { ".debug_abbrev", ".zdebug_abbrev" },
294 { ".debug_line", ".zdebug_line" },
295 { ".debug_loc", ".zdebug_loc" },
296 { ".debug_macinfo", ".zdebug_macinfo" },
297 { ".debug_macro", ".zdebug_macro" },
298 { ".debug_str", ".zdebug_str" },
299 { ".debug_ranges", ".zdebug_ranges" },
300 { ".debug_types", ".zdebug_types" },
301 { ".debug_addr", ".zdebug_addr" },
302 { ".debug_frame", ".zdebug_frame" },
303 { ".eh_frame", NULL
},
304 { ".gdb_index", ".zgdb_index" },
308 /* List of DWO/DWP sections. */
310 static const struct dwop_section_names
312 struct dwarf2_section_names abbrev_dwo
;
313 struct dwarf2_section_names info_dwo
;
314 struct dwarf2_section_names line_dwo
;
315 struct dwarf2_section_names loc_dwo
;
316 struct dwarf2_section_names macinfo_dwo
;
317 struct dwarf2_section_names macro_dwo
;
318 struct dwarf2_section_names str_dwo
;
319 struct dwarf2_section_names str_offsets_dwo
;
320 struct dwarf2_section_names types_dwo
;
321 struct dwarf2_section_names cu_index
;
322 struct dwarf2_section_names tu_index
;
326 { ".debug_abbrev.dwo", ".zdebug_abbrev.dwo" },
327 { ".debug_info.dwo", ".zdebug_info.dwo" },
328 { ".debug_line.dwo", ".zdebug_line.dwo" },
329 { ".debug_loc.dwo", ".zdebug_loc.dwo" },
330 { ".debug_macinfo.dwo", ".zdebug_macinfo.dwo" },
331 { ".debug_macro.dwo", ".zdebug_macro.dwo" },
332 { ".debug_str.dwo", ".zdebug_str.dwo" },
333 { ".debug_str_offsets.dwo", ".zdebug_str_offsets.dwo" },
334 { ".debug_types.dwo", ".zdebug_types.dwo" },
335 { ".debug_cu_index", ".zdebug_cu_index" },
336 { ".debug_tu_index", ".zdebug_tu_index" },
339 /* local data types */
341 /* The data in a compilation unit header, after target2host
342 translation, looks like this. */
343 struct comp_unit_head
347 unsigned char addr_size
;
348 unsigned char signed_addr_p
;
349 sect_offset abbrev_offset
;
351 /* Size of file offsets; either 4 or 8. */
352 unsigned int offset_size
;
354 /* Size of the length field; either 4 or 12. */
355 unsigned int initial_length_size
;
357 /* Offset to the first byte of this compilation unit header in the
358 .debug_info section, for resolving relative reference dies. */
361 /* Offset to first die in this cu from the start of the cu.
362 This will be the first byte following the compilation unit header. */
363 cu_offset first_die_offset
;
366 /* Type used for delaying computation of method physnames.
367 See comments for compute_delayed_physnames. */
368 struct delayed_method_info
370 /* The type to which the method is attached, i.e., its parent class. */
373 /* The index of the method in the type's function fieldlists. */
376 /* The index of the method in the fieldlist. */
379 /* The name of the DIE. */
382 /* The DIE associated with this method. */
383 struct die_info
*die
;
386 typedef struct delayed_method_info delayed_method_info
;
387 DEF_VEC_O (delayed_method_info
);
389 /* Internal state when decoding a particular compilation unit. */
392 /* The objfile containing this compilation unit. */
393 struct objfile
*objfile
;
395 /* The header of the compilation unit. */
396 struct comp_unit_head header
;
398 /* Base address of this compilation unit. */
399 CORE_ADDR base_address
;
401 /* Non-zero if base_address has been set. */
404 /* The language we are debugging. */
405 enum language language
;
406 const struct language_defn
*language_defn
;
408 const char *producer
;
410 /* The generic symbol table building routines have separate lists for
411 file scope symbols and all all other scopes (local scopes). So
412 we need to select the right one to pass to add_symbol_to_list().
413 We do it by keeping a pointer to the correct list in list_in_scope.
415 FIXME: The original dwarf code just treated the file scope as the
416 first local scope, and all other local scopes as nested local
417 scopes, and worked fine. Check to see if we really need to
418 distinguish these in buildsym.c. */
419 struct pending
**list_in_scope
;
421 /* The abbrev table for this CU.
422 Normally this points to the abbrev table in the objfile.
423 But if DWO_UNIT is non-NULL this is the abbrev table in the DWO file. */
424 struct abbrev_table
*abbrev_table
;
426 /* Hash table holding all the loaded partial DIEs
427 with partial_die->offset.SECT_OFF as hash. */
430 /* Storage for things with the same lifetime as this read-in compilation
431 unit, including partial DIEs. */
432 struct obstack comp_unit_obstack
;
434 /* When multiple dwarf2_cu structures are living in memory, this field
435 chains them all together, so that they can be released efficiently.
436 We will probably also want a generation counter so that most-recently-used
437 compilation units are cached... */
438 struct dwarf2_per_cu_data
*read_in_chain
;
440 /* Backchain to our per_cu entry if the tree has been built. */
441 struct dwarf2_per_cu_data
*per_cu
;
443 /* How many compilation units ago was this CU last referenced? */
446 /* A hash table of DIE cu_offset for following references with
447 die_info->offset.sect_off as hash. */
450 /* Full DIEs if read in. */
451 struct die_info
*dies
;
453 /* A set of pointers to dwarf2_per_cu_data objects for compilation
454 units referenced by this one. Only set during full symbol processing;
455 partial symbol tables do not have dependencies. */
458 /* Header data from the line table, during full symbol processing. */
459 struct line_header
*line_header
;
461 /* A list of methods which need to have physnames computed
462 after all type information has been read. */
463 VEC (delayed_method_info
) *method_list
;
465 /* To be copied to symtab->call_site_htab. */
466 htab_t call_site_htab
;
468 /* Non-NULL if this CU came from a DWO file.
469 There is an invariant here that is important to remember:
470 Except for attributes copied from the top level DIE in the "main"
471 (or "stub") file in preparation for reading the DWO file
472 (e.g., DW_AT_GNU_addr_base), we KISS: there is only *one* CU.
473 Either there isn't a DWO file (in which case this is NULL and the point
474 is moot), or there is and either we're not going to read it (in which
475 case this is NULL) or there is and we are reading it (in which case this
477 struct dwo_unit
*dwo_unit
;
479 /* The DW_AT_addr_base attribute if present, zero otherwise
480 (zero is a valid value though).
481 Note this value comes from the stub CU/TU's DIE. */
484 /* The DW_AT_ranges_base attribute if present, zero otherwise
485 (zero is a valid value though).
486 Note this value comes from the stub CU/TU's DIE.
487 Also note that the value is zero in the non-DWO case so this value can
488 be used without needing to know whether DWO files are in use or not.
489 N.B. This does not apply to DW_AT_ranges appearing in
490 DW_TAG_compile_unit dies. This is a bit of a wart, consider if ever
491 DW_AT_ranges appeared in the DW_TAG_compile_unit of DWO DIEs: then
492 DW_AT_ranges_base *would* have to be applied, and we'd have to care
493 whether the DW_AT_ranges attribute came from the skeleton or DWO. */
494 ULONGEST ranges_base
;
496 /* Mark used when releasing cached dies. */
497 unsigned int mark
: 1;
499 /* This CU references .debug_loc. See the symtab->locations_valid field.
500 This test is imperfect as there may exist optimized debug code not using
501 any location list and still facing inlining issues if handled as
502 unoptimized code. For a future better test see GCC PR other/32998. */
503 unsigned int has_loclist
: 1;
505 /* These cache the results for producer_is_* fields. CHECKED_PRODUCER is set
506 if all the producer_is_* fields are valid. This information is cached
507 because profiling CU expansion showed excessive time spent in
508 producer_is_gxx_lt_4_6. */
509 unsigned int checked_producer
: 1;
510 unsigned int producer_is_gxx_lt_4_6
: 1;
511 unsigned int producer_is_gcc_lt_4_3
: 1;
512 unsigned int producer_is_icc
: 1;
514 /* When set, the file that we're processing is known to have
515 debugging info for C++ namespaces. GCC 3.3.x did not produce
516 this information, but later versions do. */
518 unsigned int processing_has_namespace_info
: 1;
521 /* Persistent data held for a compilation unit, even when not
522 processing it. We put a pointer to this structure in the
523 read_symtab_private field of the psymtab. */
525 struct dwarf2_per_cu_data
527 /* The start offset and length of this compilation unit.
528 NOTE: Unlike comp_unit_head.length, this length includes
530 If the DIE refers to a DWO file, this is always of the original die,
535 /* Flag indicating this compilation unit will be read in before
536 any of the current compilation units are processed. */
537 unsigned int queued
: 1;
539 /* This flag will be set when reading partial DIEs if we need to load
540 absolutely all DIEs for this compilation unit, instead of just the ones
541 we think are interesting. It gets set if we look for a DIE in the
542 hash table and don't find it. */
543 unsigned int load_all_dies
: 1;
545 /* Non-zero if this CU is from .debug_types.
546 Struct dwarf2_per_cu_data is contained in struct signatured_type iff
548 unsigned int is_debug_types
: 1;
550 /* Non-zero if this CU is from the .dwz file. */
551 unsigned int is_dwz
: 1;
553 /* The section this CU/TU lives in.
554 If the DIE refers to a DWO file, this is always the original die,
556 struct dwarf2_section_info
*section
;
558 /* Set to non-NULL iff this CU is currently loaded. When it gets freed out
559 of the CU cache it gets reset to NULL again. */
560 struct dwarf2_cu
*cu
;
562 /* The corresponding objfile.
563 Normally we can get the objfile from dwarf2_per_objfile.
564 However we can enter this file with just a "per_cu" handle. */
565 struct objfile
*objfile
;
567 /* When using partial symbol tables, the 'psymtab' field is active.
568 Otherwise the 'quick' field is active. */
571 /* The partial symbol table associated with this compilation unit,
572 or NULL for unread partial units. */
573 struct partial_symtab
*psymtab
;
575 /* Data needed by the "quick" functions. */
576 struct dwarf2_per_cu_quick_data
*quick
;
579 /* The CUs we import using DW_TAG_imported_unit. This is filled in
580 while reading psymtabs, used to compute the psymtab dependencies,
581 and then cleared. Then it is filled in again while reading full
582 symbols, and only deleted when the objfile is destroyed.
584 This is also used to work around a difference between the way gold
585 generates .gdb_index version <=7 and the way gdb does. Arguably this
586 is a gold bug. For symbols coming from TUs, gold records in the index
587 the CU that includes the TU instead of the TU itself. This breaks
588 dw2_lookup_symbol: It assumes that if the index says symbol X lives
589 in CU/TU Y, then one need only expand Y and a subsequent lookup in Y
590 will find X. Alas TUs live in their own symtab, so after expanding CU Y
591 we need to look in TU Z to find X. Fortunately, this is akin to
592 DW_TAG_imported_unit, so we just use the same mechanism: For
593 .gdb_index version <=7 this also records the TUs that the CU referred
594 to. Concurrently with this change gdb was modified to emit version 8
595 indices so we only pay a price for gold generated indices. */
596 VEC (dwarf2_per_cu_ptr
) *imported_symtabs
;
599 /* Entry in the signatured_types hash table. */
601 struct signatured_type
603 /* The "per_cu" object of this type.
604 N.B.: This is the first member so that it's easy to convert pointers
606 struct dwarf2_per_cu_data per_cu
;
608 /* The type's signature. */
611 /* Offset in the TU of the type's DIE, as read from the TU header.
612 If this TU is a DWO stub and the definition lives in a DWO file
613 (specified by DW_AT_GNU_dwo_name), this value is unusable. */
614 cu_offset type_offset_in_tu
;
616 /* Offset in the section of the type's DIE.
617 If the definition lives in a DWO file, this is the offset in the
618 .debug_types.dwo section.
619 The value is zero until the actual value is known.
620 Zero is otherwise not a valid section offset. */
621 sect_offset type_offset_in_section
;
623 /* Type units are grouped by their DW_AT_stmt_list entry so that they
624 can share them. This points to the containing symtab. */
625 struct type_unit_group
*type_unit_group
;
628 typedef struct signatured_type
*sig_type_ptr
;
629 DEF_VEC_P (sig_type_ptr
);
631 /* A struct that can be used as a hash key for tables based on DW_AT_stmt_list.
632 This includes type_unit_group and quick_file_names. */
634 struct stmt_list_hash
636 /* The DWO unit this table is from or NULL if there is none. */
637 struct dwo_unit
*dwo_unit
;
639 /* Offset in .debug_line or .debug_line.dwo. */
640 sect_offset line_offset
;
643 /* Each element of dwarf2_per_objfile->type_unit_groups is a pointer to
644 an object of this type. */
646 struct type_unit_group
648 /* dwarf2read.c's main "handle" on a TU symtab.
649 To simplify things we create an artificial CU that "includes" all the
650 type units using this stmt_list so that the rest of the code still has
651 a "per_cu" handle on the symtab.
652 This PER_CU is recognized by having no section. */
653 #define IS_TYPE_UNIT_GROUP(per_cu) ((per_cu)->section == NULL)
654 struct dwarf2_per_cu_data per_cu
;
656 /* The TUs that share this DW_AT_stmt_list entry.
657 This is added to while parsing type units to build partial symtabs,
658 and is deleted afterwards and not used again. */
659 VEC (sig_type_ptr
) *tus
;
661 /* The primary symtab.
662 Type units in a group needn't all be defined in the same source file,
663 so we create an essentially anonymous symtab as the primary symtab. */
664 struct symtab
*primary_symtab
;
666 /* The data used to construct the hash key. */
667 struct stmt_list_hash hash
;
669 /* The number of symtabs from the line header.
670 The value here must match line_header.num_file_names. */
671 unsigned int num_symtabs
;
673 /* The symbol tables for this TU (obtained from the files listed in
675 WARNING: The order of entries here must match the order of entries
676 in the line header. After the first TU using this type_unit_group, the
677 line header for the subsequent TUs is recreated from this. This is done
678 because we need to use the same symtabs for each TU using the same
679 DW_AT_stmt_list value. Also note that symtabs may be repeated here,
680 there's no guarantee the line header doesn't have duplicate entries. */
681 struct symtab
**symtabs
;
684 /* These sections are what may appear in a DWO file. */
688 struct dwarf2_section_info abbrev
;
689 struct dwarf2_section_info line
;
690 struct dwarf2_section_info loc
;
691 struct dwarf2_section_info macinfo
;
692 struct dwarf2_section_info macro
;
693 struct dwarf2_section_info str
;
694 struct dwarf2_section_info str_offsets
;
695 /* In the case of a virtual DWO file, these two are unused. */
696 struct dwarf2_section_info info
;
697 VEC (dwarf2_section_info_def
) *types
;
700 /* CUs/TUs in DWP/DWO files. */
704 /* Backlink to the containing struct dwo_file. */
705 struct dwo_file
*dwo_file
;
707 /* The "id" that distinguishes this CU/TU.
708 .debug_info calls this "dwo_id", .debug_types calls this "signature".
709 Since signatures came first, we stick with it for consistency. */
712 /* The section this CU/TU lives in, in the DWO file. */
713 struct dwarf2_section_info
*section
;
715 /* Same as dwarf2_per_cu_data:{offset,length} but for the DWO section. */
719 /* For types, offset in the type's DIE of the type defined by this TU. */
720 cu_offset type_offset_in_tu
;
723 /* Data for one DWO file.
724 This includes virtual DWO files that have been packaged into a
729 /* The DW_AT_GNU_dwo_name attribute.
730 For virtual DWO files the name is constructed from the section offsets
731 of abbrev,line,loc,str_offsets so that we combine virtual DWO files
732 from related CU+TUs. */
733 const char *dwo_name
;
735 /* The DW_AT_comp_dir attribute. */
736 const char *comp_dir
;
738 /* The bfd, when the file is open. Otherwise this is NULL.
739 This is unused(NULL) for virtual DWO files where we use dwp_file.dbfd. */
742 /* Section info for this file. */
743 struct dwo_sections sections
;
745 /* Table of CUs in the file.
746 Each element is a struct dwo_unit. */
749 /* Table of TUs in the file.
750 Each element is a struct dwo_unit. */
754 /* These sections are what may appear in a DWP file. */
758 struct dwarf2_section_info str
;
759 struct dwarf2_section_info cu_index
;
760 struct dwarf2_section_info tu_index
;
761 /* The .debug_info.dwo, .debug_types.dwo, and other sections are referenced
762 by section number. We don't need to record them here. */
765 /* These sections are what may appear in a virtual DWO file. */
767 struct virtual_dwo_sections
769 struct dwarf2_section_info abbrev
;
770 struct dwarf2_section_info line
;
771 struct dwarf2_section_info loc
;
772 struct dwarf2_section_info macinfo
;
773 struct dwarf2_section_info macro
;
774 struct dwarf2_section_info str_offsets
;
775 /* Each DWP hash table entry records one CU or one TU.
776 That is recorded here, and copied to dwo_unit.section. */
777 struct dwarf2_section_info info_or_types
;
780 /* Contents of DWP hash tables. */
782 struct dwp_hash_table
784 uint32_t nr_units
, nr_slots
;
785 const gdb_byte
*hash_table
, *unit_table
, *section_pool
;
788 /* Data for one DWP file. */
792 /* Name of the file. */
795 /* The bfd, when the file is open. Otherwise this is NULL. */
798 /* Section info for this file. */
799 struct dwp_sections sections
;
801 /* Table of CUs in the file. */
802 const struct dwp_hash_table
*cus
;
804 /* Table of TUs in the file. */
805 const struct dwp_hash_table
*tus
;
807 /* Table of loaded CUs/TUs. Each entry is a struct dwo_unit *. */
810 /* Table to map ELF section numbers to their sections. */
811 unsigned int num_sections
;
812 asection
**elf_sections
;
815 /* This represents a '.dwz' file. */
819 /* A dwz file can only contain a few sections. */
820 struct dwarf2_section_info abbrev
;
821 struct dwarf2_section_info info
;
822 struct dwarf2_section_info str
;
823 struct dwarf2_section_info line
;
824 struct dwarf2_section_info macro
;
825 struct dwarf2_section_info gdb_index
;
831 /* Struct used to pass misc. parameters to read_die_and_children, et
832 al. which are used for both .debug_info and .debug_types dies.
833 All parameters here are unchanging for the life of the call. This
834 struct exists to abstract away the constant parameters of die reading. */
836 struct die_reader_specs
838 /* die_section->asection->owner. */
841 /* The CU of the DIE we are parsing. */
842 struct dwarf2_cu
*cu
;
844 /* Non-NULL if reading a DWO file (including one packaged into a DWP). */
845 struct dwo_file
*dwo_file
;
847 /* The section the die comes from.
848 This is either .debug_info or .debug_types, or the .dwo variants. */
849 struct dwarf2_section_info
*die_section
;
851 /* die_section->buffer. */
854 /* The end of the buffer. */
855 const gdb_byte
*buffer_end
;
858 /* Type of function passed to init_cutu_and_read_dies, et.al. */
859 typedef void (die_reader_func_ftype
) (const struct die_reader_specs
*reader
,
861 struct die_info
*comp_unit_die
,
865 /* The line number information for a compilation unit (found in the
866 .debug_line section) begins with a "statement program header",
867 which contains the following information. */
870 unsigned int total_length
;
871 unsigned short version
;
872 unsigned int header_length
;
873 unsigned char minimum_instruction_length
;
874 unsigned char maximum_ops_per_instruction
;
875 unsigned char default_is_stmt
;
877 unsigned char line_range
;
878 unsigned char opcode_base
;
880 /* standard_opcode_lengths[i] is the number of operands for the
881 standard opcode whose value is i. This means that
882 standard_opcode_lengths[0] is unused, and the last meaningful
883 element is standard_opcode_lengths[opcode_base - 1]. */
884 unsigned char *standard_opcode_lengths
;
886 /* The include_directories table. NOTE! These strings are not
887 allocated with xmalloc; instead, they are pointers into
888 debug_line_buffer. If you try to free them, `free' will get
890 unsigned int num_include_dirs
, include_dirs_size
;
893 /* The file_names table. NOTE! These strings are not allocated
894 with xmalloc; instead, they are pointers into debug_line_buffer.
895 Don't try to free them directly. */
896 unsigned int num_file_names
, file_names_size
;
900 unsigned int dir_index
;
901 unsigned int mod_time
;
903 int included_p
; /* Non-zero if referenced by the Line Number Program. */
904 struct symtab
*symtab
; /* The associated symbol table, if any. */
907 /* The start and end of the statement program following this
908 header. These point into dwarf2_per_objfile->line_buffer. */
909 gdb_byte
*statement_program_start
, *statement_program_end
;
912 /* When we construct a partial symbol table entry we only
913 need this much information. */
914 struct partial_die_info
916 /* Offset of this DIE. */
919 /* DWARF-2 tag for this DIE. */
920 ENUM_BITFIELD(dwarf_tag
) tag
: 16;
922 /* Assorted flags describing the data found in this DIE. */
923 unsigned int has_children
: 1;
924 unsigned int is_external
: 1;
925 unsigned int is_declaration
: 1;
926 unsigned int has_type
: 1;
927 unsigned int has_specification
: 1;
928 unsigned int has_pc_info
: 1;
929 unsigned int may_be_inlined
: 1;
931 /* Flag set if the SCOPE field of this structure has been
933 unsigned int scope_set
: 1;
935 /* Flag set if the DIE has a byte_size attribute. */
936 unsigned int has_byte_size
: 1;
938 /* Flag set if any of the DIE's children are template arguments. */
939 unsigned int has_template_arguments
: 1;
941 /* Flag set if fixup_partial_die has been called on this die. */
942 unsigned int fixup_called
: 1;
944 /* Flag set if DW_TAG_imported_unit uses DW_FORM_GNU_ref_alt. */
945 unsigned int is_dwz
: 1;
947 /* Flag set if spec_offset uses DW_FORM_GNU_ref_alt. */
948 unsigned int spec_is_dwz
: 1;
950 /* The name of this DIE. Normally the value of DW_AT_name, but
951 sometimes a default name for unnamed DIEs. */
954 /* The linkage name, if present. */
955 const char *linkage_name
;
957 /* The scope to prepend to our children. This is generally
958 allocated on the comp_unit_obstack, so will disappear
959 when this compilation unit leaves the cache. */
962 /* Some data associated with the partial DIE. The tag determines
963 which field is live. */
966 /* The location description associated with this DIE, if any. */
967 struct dwarf_block
*locdesc
;
968 /* The offset of an import, for DW_TAG_imported_unit. */
972 /* If HAS_PC_INFO, the PC range associated with this DIE. */
976 /* Pointer into the info_buffer (or types_buffer) pointing at the target of
977 DW_AT_sibling, if any. */
978 /* NOTE: This member isn't strictly necessary, read_partial_die could
979 return DW_AT_sibling values to its caller load_partial_dies. */
982 /* If HAS_SPECIFICATION, the offset of the DIE referred to by
983 DW_AT_specification (or DW_AT_abstract_origin or
985 sect_offset spec_offset
;
987 /* Pointers to this DIE's parent, first child, and next sibling,
989 struct partial_die_info
*die_parent
, *die_child
, *die_sibling
;
992 /* This data structure holds the information of an abbrev. */
995 unsigned int number
; /* number identifying abbrev */
996 enum dwarf_tag tag
; /* dwarf tag */
997 unsigned short has_children
; /* boolean */
998 unsigned short num_attrs
; /* number of attributes */
999 struct attr_abbrev
*attrs
; /* an array of attribute descriptions */
1000 struct abbrev_info
*next
; /* next in chain */
1005 ENUM_BITFIELD(dwarf_attribute
) name
: 16;
1006 ENUM_BITFIELD(dwarf_form
) form
: 16;
1009 /* Size of abbrev_table.abbrev_hash_table. */
1010 #define ABBREV_HASH_SIZE 121
1012 /* Top level data structure to contain an abbreviation table. */
1016 /* Where the abbrev table came from.
1017 This is used as a sanity check when the table is used. */
1020 /* Storage for the abbrev table. */
1021 struct obstack abbrev_obstack
;
1023 /* Hash table of abbrevs.
1024 This is an array of size ABBREV_HASH_SIZE allocated in abbrev_obstack.
1025 It could be statically allocated, but the previous code didn't so we
1027 struct abbrev_info
**abbrevs
;
1030 /* Attributes have a name and a value. */
1033 ENUM_BITFIELD(dwarf_attribute
) name
: 16;
1034 ENUM_BITFIELD(dwarf_form
) form
: 15;
1036 /* Has DW_STRING already been updated by dwarf2_canonicalize_name? This
1037 field should be in u.str (existing only for DW_STRING) but it is kept
1038 here for better struct attribute alignment. */
1039 unsigned int string_is_canonical
: 1;
1044 struct dwarf_block
*blk
;
1048 struct signatured_type
*signatured_type
;
1053 /* This data structure holds a complete die structure. */
1056 /* DWARF-2 tag for this DIE. */
1057 ENUM_BITFIELD(dwarf_tag
) tag
: 16;
1059 /* Number of attributes */
1060 unsigned char num_attrs
;
1062 /* True if we're presently building the full type name for the
1063 type derived from this DIE. */
1064 unsigned char building_fullname
: 1;
1067 unsigned int abbrev
;
1069 /* Offset in .debug_info or .debug_types section. */
1072 /* The dies in a compilation unit form an n-ary tree. PARENT
1073 points to this die's parent; CHILD points to the first child of
1074 this node; and all the children of a given node are chained
1075 together via their SIBLING fields. */
1076 struct die_info
*child
; /* Its first child, if any. */
1077 struct die_info
*sibling
; /* Its next sibling, if any. */
1078 struct die_info
*parent
; /* Its parent, if any. */
1080 /* An array of attributes, with NUM_ATTRS elements. There may be
1081 zero, but it's not common and zero-sized arrays are not
1082 sufficiently portable C. */
1083 struct attribute attrs
[1];
1086 /* Get at parts of an attribute structure. */
1088 #define DW_STRING(attr) ((attr)->u.str)
1089 #define DW_STRING_IS_CANONICAL(attr) ((attr)->string_is_canonical)
1090 #define DW_UNSND(attr) ((attr)->u.unsnd)
1091 #define DW_BLOCK(attr) ((attr)->u.blk)
1092 #define DW_SND(attr) ((attr)->u.snd)
1093 #define DW_ADDR(attr) ((attr)->u.addr)
1094 #define DW_SIGNATURED_TYPE(attr) ((attr)->u.signatured_type)
1096 /* Blocks are a bunch of untyped bytes. */
1101 /* Valid only if SIZE is not zero. */
1105 #ifndef ATTR_ALLOC_CHUNK
1106 #define ATTR_ALLOC_CHUNK 4
1109 /* Allocate fields for structs, unions and enums in this size. */
1110 #ifndef DW_FIELD_ALLOC_CHUNK
1111 #define DW_FIELD_ALLOC_CHUNK 4
1114 /* FIXME: We might want to set this from BFD via bfd_arch_bits_per_byte,
1115 but this would require a corresponding change in unpack_field_as_long
1117 static int bits_per_byte
= 8;
1119 /* The routines that read and process dies for a C struct or C++ class
1120 pass lists of data member fields and lists of member function fields
1121 in an instance of a field_info structure, as defined below. */
1124 /* List of data member and baseclasses fields. */
1127 struct nextfield
*next
;
1132 *fields
, *baseclasses
;
1134 /* Number of fields (including baseclasses). */
1137 /* Number of baseclasses. */
1140 /* Set if the accesibility of one of the fields is not public. */
1141 int non_public_fields
;
1143 /* Member function fields array, entries are allocated in the order they
1144 are encountered in the object file. */
1147 struct nextfnfield
*next
;
1148 struct fn_field fnfield
;
1152 /* Member function fieldlist array, contains name of possibly overloaded
1153 member function, number of overloaded member functions and a pointer
1154 to the head of the member function field chain. */
1159 struct nextfnfield
*head
;
1163 /* Number of entries in the fnfieldlists array. */
1166 /* typedefs defined inside this class. TYPEDEF_FIELD_LIST contains head of
1167 a NULL terminated list of TYPEDEF_FIELD_LIST_COUNT elements. */
1168 struct typedef_field_list
1170 struct typedef_field field
;
1171 struct typedef_field_list
*next
;
1173 *typedef_field_list
;
1174 unsigned typedef_field_list_count
;
1177 /* One item on the queue of compilation units to read in full symbols
1179 struct dwarf2_queue_item
1181 struct dwarf2_per_cu_data
*per_cu
;
1182 enum language pretend_language
;
1183 struct dwarf2_queue_item
*next
;
1186 /* The current queue. */
1187 static struct dwarf2_queue_item
*dwarf2_queue
, *dwarf2_queue_tail
;
1189 /* Loaded secondary compilation units are kept in memory until they
1190 have not been referenced for the processing of this many
1191 compilation units. Set this to zero to disable caching. Cache
1192 sizes of up to at least twenty will improve startup time for
1193 typical inter-CU-reference binaries, at an obvious memory cost. */
1194 static int dwarf2_max_cache_age
= 5;
1196 show_dwarf2_max_cache_age (struct ui_file
*file
, int from_tty
,
1197 struct cmd_list_element
*c
, const char *value
)
1199 fprintf_filtered (file
, _("The upper bound on the age of cached "
1200 "dwarf2 compilation units is %s.\n"),
1205 /* Various complaints about symbol reading that don't abort the process. */
1208 dwarf2_statement_list_fits_in_line_number_section_complaint (void)
1210 complaint (&symfile_complaints
,
1211 _("statement list doesn't fit in .debug_line section"));
1215 dwarf2_debug_line_missing_file_complaint (void)
1217 complaint (&symfile_complaints
,
1218 _(".debug_line section has line data without a file"));
1222 dwarf2_debug_line_missing_end_sequence_complaint (void)
1224 complaint (&symfile_complaints
,
1225 _(".debug_line section has line "
1226 "program sequence without an end"));
1230 dwarf2_complex_location_expr_complaint (void)
1232 complaint (&symfile_complaints
, _("location expression too complex"));
1236 dwarf2_const_value_length_mismatch_complaint (const char *arg1
, int arg2
,
1239 complaint (&symfile_complaints
,
1240 _("const value length mismatch for '%s', got %d, expected %d"),
1245 dwarf2_section_buffer_overflow_complaint (struct dwarf2_section_info
*section
)
1247 complaint (&symfile_complaints
,
1248 _("debug info runs off end of %s section"
1250 section
->asection
->name
,
1251 bfd_get_filename (section
->asection
->owner
));
1255 dwarf2_macro_malformed_definition_complaint (const char *arg1
)
1257 complaint (&symfile_complaints
,
1258 _("macro debug info contains a "
1259 "malformed macro definition:\n`%s'"),
1264 dwarf2_invalid_attrib_class_complaint (const char *arg1
, const char *arg2
)
1266 complaint (&symfile_complaints
,
1267 _("invalid attribute class or form for '%s' in '%s'"),
1271 /* local function prototypes */
1273 static void dwarf2_locate_sections (bfd
*, asection
*, void *);
1275 static void dwarf2_create_include_psymtab (char *, struct partial_symtab
*,
1278 static void dwarf2_find_base_address (struct die_info
*die
,
1279 struct dwarf2_cu
*cu
);
1281 static struct partial_symtab
*create_partial_symtab
1282 (struct dwarf2_per_cu_data
*per_cu
, const char *name
);
1284 static void dwarf2_build_psymtabs_hard (struct objfile
*);
1286 static void scan_partial_symbols (struct partial_die_info
*,
1287 CORE_ADDR
*, CORE_ADDR
*,
1288 int, struct dwarf2_cu
*);
1290 static void add_partial_symbol (struct partial_die_info
*,
1291 struct dwarf2_cu
*);
1293 static void add_partial_namespace (struct partial_die_info
*pdi
,
1294 CORE_ADDR
*lowpc
, CORE_ADDR
*highpc
,
1295 int need_pc
, struct dwarf2_cu
*cu
);
1297 static void add_partial_module (struct partial_die_info
*pdi
, CORE_ADDR
*lowpc
,
1298 CORE_ADDR
*highpc
, int need_pc
,
1299 struct dwarf2_cu
*cu
);
1301 static void add_partial_enumeration (struct partial_die_info
*enum_pdi
,
1302 struct dwarf2_cu
*cu
);
1304 static void add_partial_subprogram (struct partial_die_info
*pdi
,
1305 CORE_ADDR
*lowpc
, CORE_ADDR
*highpc
,
1306 int need_pc
, struct dwarf2_cu
*cu
);
1308 static void dwarf2_read_symtab (struct partial_symtab
*,
1311 static void psymtab_to_symtab_1 (struct partial_symtab
*);
1313 static struct abbrev_info
*abbrev_table_lookup_abbrev
1314 (const struct abbrev_table
*, unsigned int);
1316 static struct abbrev_table
*abbrev_table_read_table
1317 (struct dwarf2_section_info
*, sect_offset
);
1319 static void abbrev_table_free (struct abbrev_table
*);
1321 static void abbrev_table_free_cleanup (void *);
1323 static void dwarf2_read_abbrevs (struct dwarf2_cu
*,
1324 struct dwarf2_section_info
*);
1326 static void dwarf2_free_abbrev_table (void *);
1328 static unsigned int peek_abbrev_code (bfd
*, gdb_byte
*);
1330 static struct partial_die_info
*load_partial_dies
1331 (const struct die_reader_specs
*, gdb_byte
*, int);
1333 static gdb_byte
*read_partial_die (const struct die_reader_specs
*,
1334 struct partial_die_info
*,
1335 struct abbrev_info
*,
1339 static struct partial_die_info
*find_partial_die (sect_offset
, int,
1340 struct dwarf2_cu
*);
1342 static void fixup_partial_die (struct partial_die_info
*,
1343 struct dwarf2_cu
*);
1345 static gdb_byte
*read_attribute (const struct die_reader_specs
*,
1346 struct attribute
*, struct attr_abbrev
*,
1349 static unsigned int read_1_byte (bfd
*, const gdb_byte
*);
1351 static int read_1_signed_byte (bfd
*, const gdb_byte
*);
1353 static unsigned int read_2_bytes (bfd
*, const gdb_byte
*);
1355 static unsigned int read_4_bytes (bfd
*, const gdb_byte
*);
1357 static ULONGEST
read_8_bytes (bfd
*, const gdb_byte
*);
1359 static CORE_ADDR
read_address (bfd
*, gdb_byte
*ptr
, struct dwarf2_cu
*,
1362 static LONGEST
read_initial_length (bfd
*, gdb_byte
*, unsigned int *);
1364 static LONGEST read_checked_initial_length_and_offset
1365 (bfd
*, gdb_byte
*, const struct comp_unit_head
*,
1366 unsigned int *, unsigned int *);
1368 static LONGEST
read_offset (bfd
*, gdb_byte
*, const struct comp_unit_head
*,
1371 static LONGEST
read_offset_1 (bfd
*, gdb_byte
*, unsigned int);
1373 static sect_offset
read_abbrev_offset (struct dwarf2_section_info
*,
1376 static gdb_byte
*read_n_bytes (bfd
*, gdb_byte
*, unsigned int);
1378 static char *read_direct_string (bfd
*, gdb_byte
*, unsigned int *);
1380 static char *read_indirect_string (bfd
*, gdb_byte
*,
1381 const struct comp_unit_head
*,
1384 static char *read_indirect_string_from_dwz (struct dwz_file
*, LONGEST
);
1386 static ULONGEST
read_unsigned_leb128 (bfd
*, gdb_byte
*, unsigned int *);
1388 static LONGEST
read_signed_leb128 (bfd
*, gdb_byte
*, unsigned int *);
1390 static CORE_ADDR
read_addr_index_from_leb128 (struct dwarf2_cu
*, gdb_byte
*,
1393 static char *read_str_index (const struct die_reader_specs
*reader
,
1394 struct dwarf2_cu
*cu
, ULONGEST str_index
);
1396 static void set_cu_language (unsigned int, struct dwarf2_cu
*);
1398 static struct attribute
*dwarf2_attr (struct die_info
*, unsigned int,
1399 struct dwarf2_cu
*);
1401 static struct attribute
*dwarf2_attr_no_follow (struct die_info
*,
1404 static int dwarf2_flag_true_p (struct die_info
*die
, unsigned name
,
1405 struct dwarf2_cu
*cu
);
1407 static int die_is_declaration (struct die_info
*, struct dwarf2_cu
*cu
);
1409 static struct die_info
*die_specification (struct die_info
*die
,
1410 struct dwarf2_cu
**);
1412 static void free_line_header (struct line_header
*lh
);
1414 static void add_file_name (struct line_header
*, char *, unsigned int,
1415 unsigned int, unsigned int);
1417 static struct line_header
*dwarf_decode_line_header (unsigned int offset
,
1418 struct dwarf2_cu
*cu
);
1420 static void dwarf_decode_lines (struct line_header
*, const char *,
1421 struct dwarf2_cu
*, struct partial_symtab
*,
1424 static void dwarf2_start_subfile (char *, const char *, const char *);
1426 static void dwarf2_start_symtab (struct dwarf2_cu
*,
1427 const char *, const char *, CORE_ADDR
);
1429 static struct symbol
*new_symbol (struct die_info
*, struct type
*,
1430 struct dwarf2_cu
*);
1432 static struct symbol
*new_symbol_full (struct die_info
*, struct type
*,
1433 struct dwarf2_cu
*, struct symbol
*);
1435 static void dwarf2_const_value (struct attribute
*, struct symbol
*,
1436 struct dwarf2_cu
*);
1438 static void dwarf2_const_value_attr (struct attribute
*attr
,
1441 struct obstack
*obstack
,
1442 struct dwarf2_cu
*cu
, LONGEST
*value
,
1444 struct dwarf2_locexpr_baton
**baton
);
1446 static struct type
*die_type (struct die_info
*, struct dwarf2_cu
*);
1448 static int need_gnat_info (struct dwarf2_cu
*);
1450 static struct type
*die_descriptive_type (struct die_info
*,
1451 struct dwarf2_cu
*);
1453 static void set_descriptive_type (struct type
*, struct die_info
*,
1454 struct dwarf2_cu
*);
1456 static struct type
*die_containing_type (struct die_info
*,
1457 struct dwarf2_cu
*);
1459 static struct type
*lookup_die_type (struct die_info
*, struct attribute
*,
1460 struct dwarf2_cu
*);
1462 static struct type
*read_type_die (struct die_info
*, struct dwarf2_cu
*);
1464 static struct type
*read_type_die_1 (struct die_info
*, struct dwarf2_cu
*);
1466 static const char *determine_prefix (struct die_info
*die
, struct dwarf2_cu
*);
1468 static char *typename_concat (struct obstack
*obs
, const char *prefix
,
1469 const char *suffix
, int physname
,
1470 struct dwarf2_cu
*cu
);
1472 static void read_file_scope (struct die_info
*, struct dwarf2_cu
*);
1474 static void read_type_unit_scope (struct die_info
*, struct dwarf2_cu
*);
1476 static void read_func_scope (struct die_info
*, struct dwarf2_cu
*);
1478 static void read_lexical_block_scope (struct die_info
*, struct dwarf2_cu
*);
1480 static void read_call_site_scope (struct die_info
*die
, struct dwarf2_cu
*cu
);
1482 static int dwarf2_ranges_read (unsigned, CORE_ADDR
*, CORE_ADDR
*,
1483 struct dwarf2_cu
*, struct partial_symtab
*);
1485 static int dwarf2_get_pc_bounds (struct die_info
*,
1486 CORE_ADDR
*, CORE_ADDR
*, struct dwarf2_cu
*,
1487 struct partial_symtab
*);
1489 static void get_scope_pc_bounds (struct die_info
*,
1490 CORE_ADDR
*, CORE_ADDR
*,
1491 struct dwarf2_cu
*);
1493 static void dwarf2_record_block_ranges (struct die_info
*, struct block
*,
1494 CORE_ADDR
, struct dwarf2_cu
*);
1496 static void dwarf2_add_field (struct field_info
*, struct die_info
*,
1497 struct dwarf2_cu
*);
1499 static void dwarf2_attach_fields_to_type (struct field_info
*,
1500 struct type
*, struct dwarf2_cu
*);
1502 static void dwarf2_add_member_fn (struct field_info
*,
1503 struct die_info
*, struct type
*,
1504 struct dwarf2_cu
*);
1506 static void dwarf2_attach_fn_fields_to_type (struct field_info
*,
1508 struct dwarf2_cu
*);
1510 static void process_structure_scope (struct die_info
*, struct dwarf2_cu
*);
1512 static void read_common_block (struct die_info
*, struct dwarf2_cu
*);
1514 static void read_namespace (struct die_info
*die
, struct dwarf2_cu
*);
1516 static void read_module (struct die_info
*die
, struct dwarf2_cu
*cu
);
1518 static void read_import_statement (struct die_info
*die
, struct dwarf2_cu
*);
1520 static struct type
*read_module_type (struct die_info
*die
,
1521 struct dwarf2_cu
*cu
);
1523 static const char *namespace_name (struct die_info
*die
,
1524 int *is_anonymous
, struct dwarf2_cu
*);
1526 static void process_enumeration_scope (struct die_info
*, struct dwarf2_cu
*);
1528 static CORE_ADDR
decode_locdesc (struct dwarf_block
*, struct dwarf2_cu
*);
1530 static enum dwarf_array_dim_ordering
read_array_order (struct die_info
*,
1531 struct dwarf2_cu
*);
1533 static struct die_info
*read_die_and_siblings_1
1534 (const struct die_reader_specs
*, gdb_byte
*, gdb_byte
**,
1537 static struct die_info
*read_die_and_siblings (const struct die_reader_specs
*,
1539 gdb_byte
**new_info_ptr
,
1540 struct die_info
*parent
);
1542 static gdb_byte
*read_full_die_1 (const struct die_reader_specs
*,
1543 struct die_info
**, gdb_byte
*, int *, int);
1545 static gdb_byte
*read_full_die (const struct die_reader_specs
*,
1546 struct die_info
**, gdb_byte
*, int *);
1548 static void process_die (struct die_info
*, struct dwarf2_cu
*);
1550 static const char *dwarf2_canonicalize_name (const char *, struct dwarf2_cu
*,
1553 static const char *dwarf2_name (struct die_info
*die
, struct dwarf2_cu
*);
1555 static const char *dwarf2_full_name (const char *name
,
1556 struct die_info
*die
,
1557 struct dwarf2_cu
*cu
);
1559 static const char *dwarf2_physname (const char *name
, struct die_info
*die
,
1560 struct dwarf2_cu
*cu
);
1562 static struct die_info
*dwarf2_extension (struct die_info
*die
,
1563 struct dwarf2_cu
**);
1565 static const char *dwarf_tag_name (unsigned int);
1567 static const char *dwarf_attr_name (unsigned int);
1569 static const char *dwarf_form_name (unsigned int);
1571 static char *dwarf_bool_name (unsigned int);
1573 static const char *dwarf_type_encoding_name (unsigned int);
1575 static struct die_info
*sibling_die (struct die_info
*);
1577 static void dump_die_shallow (struct ui_file
*, int indent
, struct die_info
*);
1579 static void dump_die_for_error (struct die_info
*);
1581 static void dump_die_1 (struct ui_file
*, int level
, int max_level
,
1584 /*static*/ void dump_die (struct die_info
*, int max_level
);
1586 static void store_in_ref_table (struct die_info
*,
1587 struct dwarf2_cu
*);
1589 static int is_ref_attr (struct attribute
*);
1591 static sect_offset
dwarf2_get_ref_die_offset (struct attribute
*);
1593 static LONGEST
dwarf2_get_attr_constant_value (struct attribute
*, int);
1595 static struct die_info
*follow_die_ref_or_sig (struct die_info
*,
1597 struct dwarf2_cu
**);
1599 static struct die_info
*follow_die_ref (struct die_info
*,
1601 struct dwarf2_cu
**);
1603 static struct die_info
*follow_die_sig (struct die_info
*,
1605 struct dwarf2_cu
**);
1607 static void load_full_type_unit (struct dwarf2_per_cu_data
*per_cu
);
1609 static void read_signatured_type (struct signatured_type
*);
1611 static struct type_unit_group
*get_type_unit_group
1612 (struct dwarf2_cu
*, struct attribute
*);
1614 static void build_type_unit_groups (die_reader_func_ftype
*, void *);
1616 /* memory allocation interface */
1618 static struct dwarf_block
*dwarf_alloc_block (struct dwarf2_cu
*);
1620 static struct die_info
*dwarf_alloc_die (struct dwarf2_cu
*, int);
1622 static void dwarf_decode_macros (struct dwarf2_cu
*, unsigned int,
1625 static int attr_form_is_block (struct attribute
*);
1627 static int attr_form_is_section_offset (struct attribute
*);
1629 static int attr_form_is_constant (struct attribute
*);
1631 static void fill_in_loclist_baton (struct dwarf2_cu
*cu
,
1632 struct dwarf2_loclist_baton
*baton
,
1633 struct attribute
*attr
);
1635 static void dwarf2_symbol_mark_computed (struct attribute
*attr
,
1637 struct dwarf2_cu
*cu
,
1640 static gdb_byte
*skip_one_die (const struct die_reader_specs
*reader
,
1642 struct abbrev_info
*abbrev
);
1644 static void free_stack_comp_unit (void *);
1646 static hashval_t
partial_die_hash (const void *item
);
1648 static int partial_die_eq (const void *item_lhs
, const void *item_rhs
);
1650 static struct dwarf2_per_cu_data
*dwarf2_find_containing_comp_unit
1651 (sect_offset offset
, unsigned int offset_in_dwz
, struct objfile
*objfile
);
1653 static void init_one_comp_unit (struct dwarf2_cu
*cu
,
1654 struct dwarf2_per_cu_data
*per_cu
);
1656 static void prepare_one_comp_unit (struct dwarf2_cu
*cu
,
1657 struct die_info
*comp_unit_die
,
1658 enum language pretend_language
);
1660 static void free_heap_comp_unit (void *);
1662 static void free_cached_comp_units (void *);
1664 static void age_cached_comp_units (void);
1666 static void free_one_cached_comp_unit (struct dwarf2_per_cu_data
*);
1668 static struct type
*set_die_type (struct die_info
*, struct type
*,
1669 struct dwarf2_cu
*);
1671 static void create_all_comp_units (struct objfile
*);
1673 static int create_all_type_units (struct objfile
*);
1675 static void load_full_comp_unit (struct dwarf2_per_cu_data
*,
1678 static void process_full_comp_unit (struct dwarf2_per_cu_data
*,
1681 static void process_full_type_unit (struct dwarf2_per_cu_data
*,
1684 static void dwarf2_add_dependence (struct dwarf2_cu
*,
1685 struct dwarf2_per_cu_data
*);
1687 static void dwarf2_mark (struct dwarf2_cu
*);
1689 static void dwarf2_clear_marks (struct dwarf2_per_cu_data
*);
1691 static struct type
*get_die_type_at_offset (sect_offset
,
1692 struct dwarf2_per_cu_data
*per_cu
);
1694 static struct type
*get_die_type (struct die_info
*die
, struct dwarf2_cu
*cu
);
1696 static void dwarf2_release_queue (void *dummy
);
1698 static void queue_comp_unit (struct dwarf2_per_cu_data
*per_cu
,
1699 enum language pretend_language
);
1701 static int maybe_queue_comp_unit (struct dwarf2_cu
*this_cu
,
1702 struct dwarf2_per_cu_data
*per_cu
,
1703 enum language pretend_language
);
1705 static void process_queue (void);
1707 static void find_file_and_directory (struct die_info
*die
,
1708 struct dwarf2_cu
*cu
,
1709 const char **name
, const char **comp_dir
);
1711 static char *file_full_name (int file
, struct line_header
*lh
,
1712 const char *comp_dir
);
1714 static gdb_byte
*read_and_check_comp_unit_head
1715 (struct comp_unit_head
*header
,
1716 struct dwarf2_section_info
*section
,
1717 struct dwarf2_section_info
*abbrev_section
, gdb_byte
*info_ptr
,
1718 int is_debug_types_section
);
1720 static void init_cutu_and_read_dies
1721 (struct dwarf2_per_cu_data
*this_cu
, struct abbrev_table
*abbrev_table
,
1722 int use_existing_cu
, int keep
,
1723 die_reader_func_ftype
*die_reader_func
, void *data
);
1725 static void init_cutu_and_read_dies_simple
1726 (struct dwarf2_per_cu_data
*this_cu
,
1727 die_reader_func_ftype
*die_reader_func
, void *data
);
1729 static htab_t
allocate_signatured_type_table (struct objfile
*objfile
);
1731 static htab_t
allocate_dwo_unit_table (struct objfile
*objfile
);
1733 static struct dwo_unit
*lookup_dwo_comp_unit
1734 (struct dwarf2_per_cu_data
*, const char *, const char *, ULONGEST
);
1736 static struct dwo_unit
*lookup_dwo_type_unit
1737 (struct signatured_type
*, const char *, const char *);
1739 static void free_dwo_file_cleanup (void *);
1741 static void process_cu_includes (void);
1743 static void check_producer (struct dwarf2_cu
*cu
);
1747 /* Convert VALUE between big- and little-endian. */
1749 byte_swap (offset_type value
)
1753 result
= (value
& 0xff) << 24;
1754 result
|= (value
& 0xff00) << 8;
1755 result
|= (value
& 0xff0000) >> 8;
1756 result
|= (value
& 0xff000000) >> 24;
1760 #define MAYBE_SWAP(V) byte_swap (V)
1763 #define MAYBE_SWAP(V) (V)
1764 #endif /* WORDS_BIGENDIAN */
1766 /* The suffix for an index file. */
1767 #define INDEX_SUFFIX ".gdb-index"
1769 /* Try to locate the sections we need for DWARF 2 debugging
1770 information and return true if we have enough to do something.
1771 NAMES points to the dwarf2 section names, or is NULL if the standard
1772 ELF names are used. */
1775 dwarf2_has_info (struct objfile
*objfile
,
1776 const struct dwarf2_debug_sections
*names
)
1778 dwarf2_per_objfile
= objfile_data (objfile
, dwarf2_objfile_data_key
);
1779 if (!dwarf2_per_objfile
)
1781 /* Initialize per-objfile state. */
1782 struct dwarf2_per_objfile
*data
1783 = obstack_alloc (&objfile
->objfile_obstack
, sizeof (*data
));
1785 memset (data
, 0, sizeof (*data
));
1786 set_objfile_data (objfile
, dwarf2_objfile_data_key
, data
);
1787 dwarf2_per_objfile
= data
;
1789 bfd_map_over_sections (objfile
->obfd
, dwarf2_locate_sections
,
1791 dwarf2_per_objfile
->objfile
= objfile
;
1793 return (dwarf2_per_objfile
->info
.asection
!= NULL
1794 && dwarf2_per_objfile
->abbrev
.asection
!= NULL
);
1797 /* When loading sections, we look either for uncompressed section or for
1798 compressed section names. */
1801 section_is_p (const char *section_name
,
1802 const struct dwarf2_section_names
*names
)
1804 if (names
->normal
!= NULL
1805 && strcmp (section_name
, names
->normal
) == 0)
1807 if (names
->compressed
!= NULL
1808 && strcmp (section_name
, names
->compressed
) == 0)
1813 /* This function is mapped across the sections and remembers the
1814 offset and size of each of the debugging sections we are interested
1818 dwarf2_locate_sections (bfd
*abfd
, asection
*sectp
, void *vnames
)
1820 const struct dwarf2_debug_sections
*names
;
1821 flagword aflag
= bfd_get_section_flags (abfd
, sectp
);
1824 names
= &dwarf2_elf_names
;
1826 names
= (const struct dwarf2_debug_sections
*) vnames
;
1828 if ((aflag
& SEC_HAS_CONTENTS
) == 0)
1831 else if (section_is_p (sectp
->name
, &names
->info
))
1833 dwarf2_per_objfile
->info
.asection
= sectp
;
1834 dwarf2_per_objfile
->info
.size
= bfd_get_section_size (sectp
);
1836 else if (section_is_p (sectp
->name
, &names
->abbrev
))
1838 dwarf2_per_objfile
->abbrev
.asection
= sectp
;
1839 dwarf2_per_objfile
->abbrev
.size
= bfd_get_section_size (sectp
);
1841 else if (section_is_p (sectp
->name
, &names
->line
))
1843 dwarf2_per_objfile
->line
.asection
= sectp
;
1844 dwarf2_per_objfile
->line
.size
= bfd_get_section_size (sectp
);
1846 else if (section_is_p (sectp
->name
, &names
->loc
))
1848 dwarf2_per_objfile
->loc
.asection
= sectp
;
1849 dwarf2_per_objfile
->loc
.size
= bfd_get_section_size (sectp
);
1851 else if (section_is_p (sectp
->name
, &names
->macinfo
))
1853 dwarf2_per_objfile
->macinfo
.asection
= sectp
;
1854 dwarf2_per_objfile
->macinfo
.size
= bfd_get_section_size (sectp
);
1856 else if (section_is_p (sectp
->name
, &names
->macro
))
1858 dwarf2_per_objfile
->macro
.asection
= sectp
;
1859 dwarf2_per_objfile
->macro
.size
= bfd_get_section_size (sectp
);
1861 else if (section_is_p (sectp
->name
, &names
->str
))
1863 dwarf2_per_objfile
->str
.asection
= sectp
;
1864 dwarf2_per_objfile
->str
.size
= bfd_get_section_size (sectp
);
1866 else if (section_is_p (sectp
->name
, &names
->addr
))
1868 dwarf2_per_objfile
->addr
.asection
= sectp
;
1869 dwarf2_per_objfile
->addr
.size
= bfd_get_section_size (sectp
);
1871 else if (section_is_p (sectp
->name
, &names
->frame
))
1873 dwarf2_per_objfile
->frame
.asection
= sectp
;
1874 dwarf2_per_objfile
->frame
.size
= bfd_get_section_size (sectp
);
1876 else if (section_is_p (sectp
->name
, &names
->eh_frame
))
1878 dwarf2_per_objfile
->eh_frame
.asection
= sectp
;
1879 dwarf2_per_objfile
->eh_frame
.size
= bfd_get_section_size (sectp
);
1881 else if (section_is_p (sectp
->name
, &names
->ranges
))
1883 dwarf2_per_objfile
->ranges
.asection
= sectp
;
1884 dwarf2_per_objfile
->ranges
.size
= bfd_get_section_size (sectp
);
1886 else if (section_is_p (sectp
->name
, &names
->types
))
1888 struct dwarf2_section_info type_section
;
1890 memset (&type_section
, 0, sizeof (type_section
));
1891 type_section
.asection
= sectp
;
1892 type_section
.size
= bfd_get_section_size (sectp
);
1894 VEC_safe_push (dwarf2_section_info_def
, dwarf2_per_objfile
->types
,
1897 else if (section_is_p (sectp
->name
, &names
->gdb_index
))
1899 dwarf2_per_objfile
->gdb_index
.asection
= sectp
;
1900 dwarf2_per_objfile
->gdb_index
.size
= bfd_get_section_size (sectp
);
1903 if ((bfd_get_section_flags (abfd
, sectp
) & SEC_LOAD
)
1904 && bfd_section_vma (abfd
, sectp
) == 0)
1905 dwarf2_per_objfile
->has_section_at_zero
= 1;
1908 /* A helper function that decides whether a section is empty,
1912 dwarf2_section_empty_p (struct dwarf2_section_info
*info
)
1914 return info
->asection
== NULL
|| info
->size
== 0;
1917 /* Read the contents of the section INFO.
1918 OBJFILE is the main object file, but not necessarily the file where
1919 the section comes from. E.g., for DWO files INFO->asection->owner
1920 is the bfd of the DWO file.
1921 If the section is compressed, uncompress it before returning. */
1924 dwarf2_read_section (struct objfile
*objfile
, struct dwarf2_section_info
*info
)
1926 asection
*sectp
= info
->asection
;
1928 gdb_byte
*buf
, *retbuf
;
1929 unsigned char header
[4];
1933 info
->buffer
= NULL
;
1936 if (dwarf2_section_empty_p (info
))
1939 abfd
= sectp
->owner
;
1941 /* If the section has relocations, we must read it ourselves.
1942 Otherwise we attach it to the BFD. */
1943 if ((sectp
->flags
& SEC_RELOC
) == 0)
1945 const gdb_byte
*bytes
= gdb_bfd_map_section (sectp
, &info
->size
);
1947 /* We have to cast away const here for historical reasons.
1948 Fixing dwarf2read to be const-correct would be quite nice. */
1949 info
->buffer
= (gdb_byte
*) bytes
;
1953 buf
= obstack_alloc (&objfile
->objfile_obstack
, info
->size
);
1956 /* When debugging .o files, we may need to apply relocations; see
1957 http://sourceware.org/ml/gdb-patches/2002-04/msg00136.html .
1958 We never compress sections in .o files, so we only need to
1959 try this when the section is not compressed. */
1960 retbuf
= symfile_relocate_debug_section (objfile
, sectp
, buf
);
1963 info
->buffer
= retbuf
;
1967 if (bfd_seek (abfd
, sectp
->filepos
, SEEK_SET
) != 0
1968 || bfd_bread (buf
, info
->size
, abfd
) != info
->size
)
1969 error (_("Dwarf Error: Can't read DWARF data from '%s'"),
1970 bfd_get_filename (abfd
));
1973 /* A helper function that returns the size of a section in a safe way.
1974 If you are positive that the section has been read before using the
1975 size, then it is safe to refer to the dwarf2_section_info object's
1976 "size" field directly. In other cases, you must call this
1977 function, because for compressed sections the size field is not set
1978 correctly until the section has been read. */
1980 static bfd_size_type
1981 dwarf2_section_size (struct objfile
*objfile
,
1982 struct dwarf2_section_info
*info
)
1985 dwarf2_read_section (objfile
, info
);
1989 /* Fill in SECTP, BUFP and SIZEP with section info, given OBJFILE and
1993 dwarf2_get_section_info (struct objfile
*objfile
,
1994 enum dwarf2_section_enum sect
,
1995 asection
**sectp
, gdb_byte
**bufp
,
1996 bfd_size_type
*sizep
)
1998 struct dwarf2_per_objfile
*data
1999 = objfile_data (objfile
, dwarf2_objfile_data_key
);
2000 struct dwarf2_section_info
*info
;
2002 /* We may see an objfile without any DWARF, in which case we just
2013 case DWARF2_DEBUG_FRAME
:
2014 info
= &data
->frame
;
2016 case DWARF2_EH_FRAME
:
2017 info
= &data
->eh_frame
;
2020 gdb_assert_not_reached ("unexpected section");
2023 dwarf2_read_section (objfile
, info
);
2025 *sectp
= info
->asection
;
2026 *bufp
= info
->buffer
;
2027 *sizep
= info
->size
;
2030 /* A helper function to find the sections for a .dwz file. */
2033 locate_dwz_sections (bfd
*abfd
, asection
*sectp
, void *arg
)
2035 struct dwz_file
*dwz_file
= arg
;
2037 /* Note that we only support the standard ELF names, because .dwz
2038 is ELF-only (at the time of writing). */
2039 if (section_is_p (sectp
->name
, &dwarf2_elf_names
.abbrev
))
2041 dwz_file
->abbrev
.asection
= sectp
;
2042 dwz_file
->abbrev
.size
= bfd_get_section_size (sectp
);
2044 else if (section_is_p (sectp
->name
, &dwarf2_elf_names
.info
))
2046 dwz_file
->info
.asection
= sectp
;
2047 dwz_file
->info
.size
= bfd_get_section_size (sectp
);
2049 else if (section_is_p (sectp
->name
, &dwarf2_elf_names
.str
))
2051 dwz_file
->str
.asection
= sectp
;
2052 dwz_file
->str
.size
= bfd_get_section_size (sectp
);
2054 else if (section_is_p (sectp
->name
, &dwarf2_elf_names
.line
))
2056 dwz_file
->line
.asection
= sectp
;
2057 dwz_file
->line
.size
= bfd_get_section_size (sectp
);
2059 else if (section_is_p (sectp
->name
, &dwarf2_elf_names
.macro
))
2061 dwz_file
->macro
.asection
= sectp
;
2062 dwz_file
->macro
.size
= bfd_get_section_size (sectp
);
2064 else if (section_is_p (sectp
->name
, &dwarf2_elf_names
.gdb_index
))
2066 dwz_file
->gdb_index
.asection
= sectp
;
2067 dwz_file
->gdb_index
.size
= bfd_get_section_size (sectp
);
2071 /* Open the separate '.dwz' debug file, if needed. Error if the file
2074 static struct dwz_file
*
2075 dwarf2_get_dwz_file (void)
2077 bfd
*abfd
, *dwz_bfd
;
2080 struct cleanup
*cleanup
;
2081 const char *filename
;
2082 struct dwz_file
*result
;
2084 if (dwarf2_per_objfile
->dwz_file
!= NULL
)
2085 return dwarf2_per_objfile
->dwz_file
;
2087 abfd
= dwarf2_per_objfile
->objfile
->obfd
;
2088 section
= bfd_get_section_by_name (abfd
, ".gnu_debugaltlink");
2089 if (section
== NULL
)
2090 error (_("could not find '.gnu_debugaltlink' section"));
2091 if (!bfd_malloc_and_get_section (abfd
, section
, &data
))
2092 error (_("could not read '.gnu_debugaltlink' section: %s"),
2093 bfd_errmsg (bfd_get_error ()));
2094 cleanup
= make_cleanup (xfree
, data
);
2097 if (!IS_ABSOLUTE_PATH (filename
))
2099 char *abs
= gdb_realpath (dwarf2_per_objfile
->objfile
->name
);
2102 make_cleanup (xfree
, abs
);
2103 abs
= ldirname (abs
);
2104 make_cleanup (xfree
, abs
);
2106 rel
= concat (abs
, SLASH_STRING
, filename
, (char *) NULL
);
2107 make_cleanup (xfree
, rel
);
2111 /* The format is just a NUL-terminated file name, followed by the
2112 build-id. For now, though, we ignore the build-id. */
2113 dwz_bfd
= gdb_bfd_open (filename
, gnutarget
, -1);
2114 if (dwz_bfd
== NULL
)
2115 error (_("could not read '%s': %s"), filename
,
2116 bfd_errmsg (bfd_get_error ()));
2118 if (!bfd_check_format (dwz_bfd
, bfd_object
))
2120 gdb_bfd_unref (dwz_bfd
);
2121 error (_("file '%s' was not usable: %s"), filename
,
2122 bfd_errmsg (bfd_get_error ()));
2125 result
= OBSTACK_ZALLOC (&dwarf2_per_objfile
->objfile
->objfile_obstack
,
2127 result
->dwz_bfd
= dwz_bfd
;
2129 bfd_map_over_sections (dwz_bfd
, locate_dwz_sections
, result
);
2131 do_cleanups (cleanup
);
2133 dwarf2_per_objfile
->dwz_file
= result
;
2137 /* DWARF quick_symbols_functions support. */
2139 /* TUs can share .debug_line entries, and there can be a lot more TUs than
2140 unique line tables, so we maintain a separate table of all .debug_line
2141 derived entries to support the sharing.
2142 All the quick functions need is the list of file names. We discard the
2143 line_header when we're done and don't need to record it here. */
2144 struct quick_file_names
2146 /* The data used to construct the hash key. */
2147 struct stmt_list_hash hash
;
2149 /* The number of entries in file_names, real_names. */
2150 unsigned int num_file_names
;
2152 /* The file names from the line table, after being run through
2154 const char **file_names
;
2156 /* The file names from the line table after being run through
2157 gdb_realpath. These are computed lazily. */
2158 const char **real_names
;
2161 /* When using the index (and thus not using psymtabs), each CU has an
2162 object of this type. This is used to hold information needed by
2163 the various "quick" methods. */
2164 struct dwarf2_per_cu_quick_data
2166 /* The file table. This can be NULL if there was no file table
2167 or it's currently not read in.
2168 NOTE: This points into dwarf2_per_objfile->quick_file_names_table. */
2169 struct quick_file_names
*file_names
;
2171 /* The corresponding symbol table. This is NULL if symbols for this
2172 CU have not yet been read. */
2173 struct symtab
*symtab
;
2175 /* A temporary mark bit used when iterating over all CUs in
2176 expand_symtabs_matching. */
2177 unsigned int mark
: 1;
2179 /* True if we've tried to read the file table and found there isn't one.
2180 There will be no point in trying to read it again next time. */
2181 unsigned int no_file_data
: 1;
2184 /* Utility hash function for a stmt_list_hash. */
2187 hash_stmt_list_entry (const struct stmt_list_hash
*stmt_list_hash
)
2191 if (stmt_list_hash
->dwo_unit
!= NULL
)
2192 v
+= (uintptr_t) stmt_list_hash
->dwo_unit
->dwo_file
;
2193 v
+= stmt_list_hash
->line_offset
.sect_off
;
2197 /* Utility equality function for a stmt_list_hash. */
2200 eq_stmt_list_entry (const struct stmt_list_hash
*lhs
,
2201 const struct stmt_list_hash
*rhs
)
2203 if ((lhs
->dwo_unit
!= NULL
) != (rhs
->dwo_unit
!= NULL
))
2205 if (lhs
->dwo_unit
!= NULL
2206 && lhs
->dwo_unit
->dwo_file
!= rhs
->dwo_unit
->dwo_file
)
2209 return lhs
->line_offset
.sect_off
== rhs
->line_offset
.sect_off
;
2212 /* Hash function for a quick_file_names. */
2215 hash_file_name_entry (const void *e
)
2217 const struct quick_file_names
*file_data
= e
;
2219 return hash_stmt_list_entry (&file_data
->hash
);
2222 /* Equality function for a quick_file_names. */
2225 eq_file_name_entry (const void *a
, const void *b
)
2227 const struct quick_file_names
*ea
= a
;
2228 const struct quick_file_names
*eb
= b
;
2230 return eq_stmt_list_entry (&ea
->hash
, &eb
->hash
);
2233 /* Delete function for a quick_file_names. */
2236 delete_file_name_entry (void *e
)
2238 struct quick_file_names
*file_data
= e
;
2241 for (i
= 0; i
< file_data
->num_file_names
; ++i
)
2243 xfree ((void*) file_data
->file_names
[i
]);
2244 if (file_data
->real_names
)
2245 xfree ((void*) file_data
->real_names
[i
]);
2248 /* The space for the struct itself lives on objfile_obstack,
2249 so we don't free it here. */
2252 /* Create a quick_file_names hash table. */
2255 create_quick_file_names_table (unsigned int nr_initial_entries
)
2257 return htab_create_alloc (nr_initial_entries
,
2258 hash_file_name_entry
, eq_file_name_entry
,
2259 delete_file_name_entry
, xcalloc
, xfree
);
2262 /* Read in PER_CU->CU. This function is unrelated to symtabs, symtab would
2263 have to be created afterwards. You should call age_cached_comp_units after
2264 processing PER_CU->CU. dw2_setup must have been already called. */
2267 load_cu (struct dwarf2_per_cu_data
*per_cu
)
2269 if (per_cu
->is_debug_types
)
2270 load_full_type_unit (per_cu
);
2272 load_full_comp_unit (per_cu
, language_minimal
);
2274 gdb_assert (per_cu
->cu
!= NULL
);
2276 dwarf2_find_base_address (per_cu
->cu
->dies
, per_cu
->cu
);
2279 /* Read in the symbols for PER_CU. */
2282 dw2_do_instantiate_symtab (struct dwarf2_per_cu_data
*per_cu
)
2284 struct cleanup
*back_to
;
2286 /* Skip type_unit_groups, reading the type units they contain
2287 is handled elsewhere. */
2288 if (IS_TYPE_UNIT_GROUP (per_cu
))
2291 back_to
= make_cleanup (dwarf2_release_queue
, NULL
);
2293 if (dwarf2_per_objfile
->using_index
2294 ? per_cu
->v
.quick
->symtab
== NULL
2295 : (per_cu
->v
.psymtab
== NULL
|| !per_cu
->v
.psymtab
->readin
))
2297 queue_comp_unit (per_cu
, language_minimal
);
2303 /* Age the cache, releasing compilation units that have not
2304 been used recently. */
2305 age_cached_comp_units ();
2307 do_cleanups (back_to
);
2310 /* Ensure that the symbols for PER_CU have been read in. OBJFILE is
2311 the objfile from which this CU came. Returns the resulting symbol
2314 static struct symtab
*
2315 dw2_instantiate_symtab (struct dwarf2_per_cu_data
*per_cu
)
2317 gdb_assert (dwarf2_per_objfile
->using_index
);
2318 if (!per_cu
->v
.quick
->symtab
)
2320 struct cleanup
*back_to
= make_cleanup (free_cached_comp_units
, NULL
);
2321 increment_reading_symtab ();
2322 dw2_do_instantiate_symtab (per_cu
);
2323 process_cu_includes ();
2324 do_cleanups (back_to
);
2326 return per_cu
->v
.quick
->symtab
;
2329 /* Return the CU given its index.
2331 This is intended for loops like:
2333 for (i = 0; i < (dwarf2_per_objfile->n_comp_units
2334 + dwarf2_per_objfile->n_type_units); ++i)
2336 struct dwarf2_per_cu_data *per_cu = dw2_get_cu (i);
2342 static struct dwarf2_per_cu_data
*
2343 dw2_get_cu (int index
)
2345 if (index
>= dwarf2_per_objfile
->n_comp_units
)
2347 index
-= dwarf2_per_objfile
->n_comp_units
;
2348 gdb_assert (index
< dwarf2_per_objfile
->n_type_units
);
2349 return &dwarf2_per_objfile
->all_type_units
[index
]->per_cu
;
2352 return dwarf2_per_objfile
->all_comp_units
[index
];
2355 /* Return the primary CU given its index.
2356 The difference between this function and dw2_get_cu is in the handling
2357 of type units (TUs). Here we return the type_unit_group object.
2359 This is intended for loops like:
2361 for (i = 0; i < (dwarf2_per_objfile->n_comp_units
2362 + dwarf2_per_objfile->n_type_unit_groups); ++i)
2364 struct dwarf2_per_cu_data *per_cu = dw2_get_primary_cu (i);
2370 static struct dwarf2_per_cu_data
*
2371 dw2_get_primary_cu (int index
)
2373 if (index
>= dwarf2_per_objfile
->n_comp_units
)
2375 index
-= dwarf2_per_objfile
->n_comp_units
;
2376 gdb_assert (index
< dwarf2_per_objfile
->n_type_unit_groups
);
2377 return &dwarf2_per_objfile
->all_type_unit_groups
[index
]->per_cu
;
2380 return dwarf2_per_objfile
->all_comp_units
[index
];
2383 /* A helper for create_cus_from_index that handles a given list of
2387 create_cus_from_index_list (struct objfile
*objfile
,
2388 const gdb_byte
*cu_list
, offset_type n_elements
,
2389 struct dwarf2_section_info
*section
,
2395 for (i
= 0; i
< n_elements
; i
+= 2)
2397 struct dwarf2_per_cu_data
*the_cu
;
2398 ULONGEST offset
, length
;
2400 gdb_static_assert (sizeof (ULONGEST
) >= 8);
2401 offset
= extract_unsigned_integer (cu_list
, 8, BFD_ENDIAN_LITTLE
);
2402 length
= extract_unsigned_integer (cu_list
+ 8, 8, BFD_ENDIAN_LITTLE
);
2405 the_cu
= OBSTACK_ZALLOC (&objfile
->objfile_obstack
,
2406 struct dwarf2_per_cu_data
);
2407 the_cu
->offset
.sect_off
= offset
;
2408 the_cu
->length
= length
;
2409 the_cu
->objfile
= objfile
;
2410 the_cu
->section
= section
;
2411 the_cu
->v
.quick
= OBSTACK_ZALLOC (&objfile
->objfile_obstack
,
2412 struct dwarf2_per_cu_quick_data
);
2413 the_cu
->is_dwz
= is_dwz
;
2414 dwarf2_per_objfile
->all_comp_units
[base_offset
+ i
/ 2] = the_cu
;
2418 /* Read the CU list from the mapped index, and use it to create all
2419 the CU objects for this objfile. */
2422 create_cus_from_index (struct objfile
*objfile
,
2423 const gdb_byte
*cu_list
, offset_type cu_list_elements
,
2424 const gdb_byte
*dwz_list
, offset_type dwz_elements
)
2426 struct dwz_file
*dwz
;
2428 dwarf2_per_objfile
->n_comp_units
= (cu_list_elements
+ dwz_elements
) / 2;
2429 dwarf2_per_objfile
->all_comp_units
2430 = obstack_alloc (&objfile
->objfile_obstack
,
2431 dwarf2_per_objfile
->n_comp_units
2432 * sizeof (struct dwarf2_per_cu_data
*));
2434 create_cus_from_index_list (objfile
, cu_list
, cu_list_elements
,
2435 &dwarf2_per_objfile
->info
, 0, 0);
2437 if (dwz_elements
== 0)
2440 dwz
= dwarf2_get_dwz_file ();
2441 create_cus_from_index_list (objfile
, dwz_list
, dwz_elements
, &dwz
->info
, 1,
2442 cu_list_elements
/ 2);
2445 /* Create the signatured type hash table from the index. */
2448 create_signatured_type_table_from_index (struct objfile
*objfile
,
2449 struct dwarf2_section_info
*section
,
2450 const gdb_byte
*bytes
,
2451 offset_type elements
)
2454 htab_t sig_types_hash
;
2456 dwarf2_per_objfile
->n_type_units
= elements
/ 3;
2457 dwarf2_per_objfile
->all_type_units
2458 = obstack_alloc (&objfile
->objfile_obstack
,
2459 dwarf2_per_objfile
->n_type_units
2460 * sizeof (struct signatured_type
*));
2462 sig_types_hash
= allocate_signatured_type_table (objfile
);
2464 for (i
= 0; i
< elements
; i
+= 3)
2466 struct signatured_type
*sig_type
;
2467 ULONGEST offset
, type_offset_in_tu
, signature
;
2470 gdb_static_assert (sizeof (ULONGEST
) >= 8);
2471 offset
= extract_unsigned_integer (bytes
, 8, BFD_ENDIAN_LITTLE
);
2472 type_offset_in_tu
= extract_unsigned_integer (bytes
+ 8, 8,
2474 signature
= extract_unsigned_integer (bytes
+ 16, 8, BFD_ENDIAN_LITTLE
);
2477 sig_type
= OBSTACK_ZALLOC (&objfile
->objfile_obstack
,
2478 struct signatured_type
);
2479 sig_type
->signature
= signature
;
2480 sig_type
->type_offset_in_tu
.cu_off
= type_offset_in_tu
;
2481 sig_type
->per_cu
.is_debug_types
= 1;
2482 sig_type
->per_cu
.section
= section
;
2483 sig_type
->per_cu
.offset
.sect_off
= offset
;
2484 sig_type
->per_cu
.objfile
= objfile
;
2485 sig_type
->per_cu
.v
.quick
2486 = OBSTACK_ZALLOC (&objfile
->objfile_obstack
,
2487 struct dwarf2_per_cu_quick_data
);
2489 slot
= htab_find_slot (sig_types_hash
, sig_type
, INSERT
);
2492 dwarf2_per_objfile
->all_type_units
[i
/ 3] = sig_type
;
2495 dwarf2_per_objfile
->signatured_types
= sig_types_hash
;
2498 /* Read the address map data from the mapped index, and use it to
2499 populate the objfile's psymtabs_addrmap. */
2502 create_addrmap_from_index (struct objfile
*objfile
, struct mapped_index
*index
)
2504 const gdb_byte
*iter
, *end
;
2505 struct obstack temp_obstack
;
2506 struct addrmap
*mutable_map
;
2507 struct cleanup
*cleanup
;
2510 obstack_init (&temp_obstack
);
2511 cleanup
= make_cleanup_obstack_free (&temp_obstack
);
2512 mutable_map
= addrmap_create_mutable (&temp_obstack
);
2514 iter
= index
->address_table
;
2515 end
= iter
+ index
->address_table_size
;
2517 baseaddr
= ANOFFSET (objfile
->section_offsets
, SECT_OFF_TEXT (objfile
));
2521 ULONGEST hi
, lo
, cu_index
;
2522 lo
= extract_unsigned_integer (iter
, 8, BFD_ENDIAN_LITTLE
);
2524 hi
= extract_unsigned_integer (iter
, 8, BFD_ENDIAN_LITTLE
);
2526 cu_index
= extract_unsigned_integer (iter
, 4, BFD_ENDIAN_LITTLE
);
2529 if (cu_index
< dwarf2_per_objfile
->n_comp_units
)
2531 addrmap_set_empty (mutable_map
, lo
+ baseaddr
, hi
+ baseaddr
- 1,
2532 dw2_get_cu (cu_index
));
2536 complaint (&symfile_complaints
,
2537 _(".gdb_index address table has invalid CU number %u"),
2538 (unsigned) cu_index
);
2542 objfile
->psymtabs_addrmap
= addrmap_create_fixed (mutable_map
,
2543 &objfile
->objfile_obstack
);
2544 do_cleanups (cleanup
);
2547 /* The hash function for strings in the mapped index. This is the same as
2548 SYMBOL_HASH_NEXT, but we keep a separate copy to maintain control over the
2549 implementation. This is necessary because the hash function is tied to the
2550 format of the mapped index file. The hash values do not have to match with
2553 Use INT_MAX for INDEX_VERSION if you generate the current index format. */
2556 mapped_index_string_hash (int index_version
, const void *p
)
2558 const unsigned char *str
= (const unsigned char *) p
;
2562 while ((c
= *str
++) != 0)
2564 if (index_version
>= 5)
2566 r
= r
* 67 + c
- 113;
2572 /* Find a slot in the mapped index INDEX for the object named NAME.
2573 If NAME is found, set *VEC_OUT to point to the CU vector in the
2574 constant pool and return 1. If NAME cannot be found, return 0. */
2577 find_slot_in_mapped_hash (struct mapped_index
*index
, const char *name
,
2578 offset_type
**vec_out
)
2580 struct cleanup
*back_to
= make_cleanup (null_cleanup
, 0);
2582 offset_type slot
, step
;
2583 int (*cmp
) (const char *, const char *);
2585 if (current_language
->la_language
== language_cplus
2586 || current_language
->la_language
== language_java
2587 || current_language
->la_language
== language_fortran
)
2589 /* NAME is already canonical. Drop any qualifiers as .gdb_index does
2591 const char *paren
= strchr (name
, '(');
2597 dup
= xmalloc (paren
- name
+ 1);
2598 memcpy (dup
, name
, paren
- name
);
2599 dup
[paren
- name
] = 0;
2601 make_cleanup (xfree
, dup
);
2606 /* Index version 4 did not support case insensitive searches. But the
2607 indices for case insensitive languages are built in lowercase, therefore
2608 simulate our NAME being searched is also lowercased. */
2609 hash
= mapped_index_string_hash ((index
->version
== 4
2610 && case_sensitivity
== case_sensitive_off
2611 ? 5 : index
->version
),
2614 slot
= hash
& (index
->symbol_table_slots
- 1);
2615 step
= ((hash
* 17) & (index
->symbol_table_slots
- 1)) | 1;
2616 cmp
= (case_sensitivity
== case_sensitive_on
? strcmp
: strcasecmp
);
2620 /* Convert a slot number to an offset into the table. */
2621 offset_type i
= 2 * slot
;
2623 if (index
->symbol_table
[i
] == 0 && index
->symbol_table
[i
+ 1] == 0)
2625 do_cleanups (back_to
);
2629 str
= index
->constant_pool
+ MAYBE_SWAP (index
->symbol_table
[i
]);
2630 if (!cmp (name
, str
))
2632 *vec_out
= (offset_type
*) (index
->constant_pool
2633 + MAYBE_SWAP (index
->symbol_table
[i
+ 1]));
2634 do_cleanups (back_to
);
2638 slot
= (slot
+ step
) & (index
->symbol_table_slots
- 1);
2642 /* A helper function that reads the .gdb_index from SECTION and fills
2643 in MAP. FILENAME is the name of the file containing the section;
2644 it is used for error reporting. DEPRECATED_OK is nonzero if it is
2645 ok to use deprecated sections.
2647 CU_LIST, CU_LIST_ELEMENTS, TYPES_LIST, and TYPES_LIST_ELEMENTS are
2648 out parameters that are filled in with information about the CU and
2649 TU lists in the section.
2651 Returns 1 if all went well, 0 otherwise. */
2654 read_index_from_section (struct objfile
*objfile
,
2655 const char *filename
,
2657 struct dwarf2_section_info
*section
,
2658 struct mapped_index
*map
,
2659 const gdb_byte
**cu_list
,
2660 offset_type
*cu_list_elements
,
2661 const gdb_byte
**types_list
,
2662 offset_type
*types_list_elements
)
2665 offset_type version
;
2666 offset_type
*metadata
;
2669 if (dwarf2_section_empty_p (section
))
2672 /* Older elfutils strip versions could keep the section in the main
2673 executable while splitting it for the separate debug info file. */
2674 if ((bfd_get_file_flags (section
->asection
) & SEC_HAS_CONTENTS
) == 0)
2677 dwarf2_read_section (objfile
, section
);
2679 addr
= section
->buffer
;
2680 /* Version check. */
2681 version
= MAYBE_SWAP (*(offset_type
*) addr
);
2682 /* Versions earlier than 3 emitted every copy of a psymbol. This
2683 causes the index to behave very poorly for certain requests. Version 3
2684 contained incomplete addrmap. So, it seems better to just ignore such
2688 static int warning_printed
= 0;
2689 if (!warning_printed
)
2691 warning (_("Skipping obsolete .gdb_index section in %s."),
2693 warning_printed
= 1;
2697 /* Index version 4 uses a different hash function than index version
2700 Versions earlier than 6 did not emit psymbols for inlined
2701 functions. Using these files will cause GDB not to be able to
2702 set breakpoints on inlined functions by name, so we ignore these
2703 indices unless the user has done
2704 "set use-deprecated-index-sections on". */
2705 if (version
< 6 && !deprecated_ok
)
2707 static int warning_printed
= 0;
2708 if (!warning_printed
)
2711 Skipping deprecated .gdb_index section in %s.\n\
2712 Do \"set use-deprecated-index-sections on\" before the file is read\n\
2713 to use the section anyway."),
2715 warning_printed
= 1;
2719 /* Version 7 indices generated by gold refer to the CU for a symbol instead
2720 of the TU (for symbols coming from TUs). It's just a performance bug, and
2721 we can't distinguish gdb-generated indices from gold-generated ones, so
2722 nothing to do here. */
2724 /* Indexes with higher version than the one supported by GDB may be no
2725 longer backward compatible. */
2729 map
->version
= version
;
2730 map
->total_size
= section
->size
;
2732 metadata
= (offset_type
*) (addr
+ sizeof (offset_type
));
2735 *cu_list
= addr
+ MAYBE_SWAP (metadata
[i
]);
2736 *cu_list_elements
= ((MAYBE_SWAP (metadata
[i
+ 1]) - MAYBE_SWAP (metadata
[i
]))
2740 *types_list
= addr
+ MAYBE_SWAP (metadata
[i
]);
2741 *types_list_elements
= ((MAYBE_SWAP (metadata
[i
+ 1])
2742 - MAYBE_SWAP (metadata
[i
]))
2746 map
->address_table
= addr
+ MAYBE_SWAP (metadata
[i
]);
2747 map
->address_table_size
= (MAYBE_SWAP (metadata
[i
+ 1])
2748 - MAYBE_SWAP (metadata
[i
]));
2751 map
->symbol_table
= (offset_type
*) (addr
+ MAYBE_SWAP (metadata
[i
]));
2752 map
->symbol_table_slots
= ((MAYBE_SWAP (metadata
[i
+ 1])
2753 - MAYBE_SWAP (metadata
[i
]))
2754 / (2 * sizeof (offset_type
)));
2757 map
->constant_pool
= addr
+ MAYBE_SWAP (metadata
[i
]);
2763 /* Read the index file. If everything went ok, initialize the "quick"
2764 elements of all the CUs and return 1. Otherwise, return 0. */
2767 dwarf2_read_index (struct objfile
*objfile
)
2769 struct mapped_index local_map
, *map
;
2770 const gdb_byte
*cu_list
, *types_list
, *dwz_list
= NULL
;
2771 offset_type cu_list_elements
, types_list_elements
, dwz_list_elements
= 0;
2773 if (!read_index_from_section (objfile
, objfile
->name
,
2774 use_deprecated_index_sections
,
2775 &dwarf2_per_objfile
->gdb_index
, &local_map
,
2776 &cu_list
, &cu_list_elements
,
2777 &types_list
, &types_list_elements
))
2780 /* Don't use the index if it's empty. */
2781 if (local_map
.symbol_table_slots
== 0)
2784 /* If there is a .dwz file, read it so we can get its CU list as
2786 if (bfd_get_section_by_name (objfile
->obfd
, ".gnu_debugaltlink") != NULL
)
2788 struct dwz_file
*dwz
= dwarf2_get_dwz_file ();
2789 struct mapped_index dwz_map
;
2790 const gdb_byte
*dwz_types_ignore
;
2791 offset_type dwz_types_elements_ignore
;
2793 if (!read_index_from_section (objfile
, bfd_get_filename (dwz
->dwz_bfd
),
2795 &dwz
->gdb_index
, &dwz_map
,
2796 &dwz_list
, &dwz_list_elements
,
2798 &dwz_types_elements_ignore
))
2800 warning (_("could not read '.gdb_index' section from %s; skipping"),
2801 bfd_get_filename (dwz
->dwz_bfd
));
2806 create_cus_from_index (objfile
, cu_list
, cu_list_elements
, dwz_list
,
2809 if (types_list_elements
)
2811 struct dwarf2_section_info
*section
;
2813 /* We can only handle a single .debug_types when we have an
2815 if (VEC_length (dwarf2_section_info_def
, dwarf2_per_objfile
->types
) != 1)
2818 section
= VEC_index (dwarf2_section_info_def
,
2819 dwarf2_per_objfile
->types
, 0);
2821 create_signatured_type_table_from_index (objfile
, section
, types_list
,
2822 types_list_elements
);
2825 create_addrmap_from_index (objfile
, &local_map
);
2827 map
= obstack_alloc (&objfile
->objfile_obstack
, sizeof (struct mapped_index
));
2830 dwarf2_per_objfile
->index_table
= map
;
2831 dwarf2_per_objfile
->using_index
= 1;
2832 dwarf2_per_objfile
->quick_file_names_table
=
2833 create_quick_file_names_table (dwarf2_per_objfile
->n_comp_units
);
2838 /* A helper for the "quick" functions which sets the global
2839 dwarf2_per_objfile according to OBJFILE. */
2842 dw2_setup (struct objfile
*objfile
)
2844 dwarf2_per_objfile
= objfile_data (objfile
, dwarf2_objfile_data_key
);
2845 gdb_assert (dwarf2_per_objfile
);
2848 /* die_reader_func for dw2_get_file_names. */
2851 dw2_get_file_names_reader (const struct die_reader_specs
*reader
,
2853 struct die_info
*comp_unit_die
,
2857 struct dwarf2_cu
*cu
= reader
->cu
;
2858 struct dwarf2_per_cu_data
*this_cu
= cu
->per_cu
;
2859 struct objfile
*objfile
= dwarf2_per_objfile
->objfile
;
2860 struct dwarf2_per_cu_data
*lh_cu
;
2861 struct line_header
*lh
;
2862 struct attribute
*attr
;
2864 const char *name
, *comp_dir
;
2866 struct quick_file_names
*qfn
;
2867 unsigned int line_offset
;
2869 gdb_assert (! this_cu
->is_debug_types
);
2871 /* Our callers never want to match partial units -- instead they
2872 will match the enclosing full CU. */
2873 if (comp_unit_die
->tag
== DW_TAG_partial_unit
)
2875 this_cu
->v
.quick
->no_file_data
= 1;
2884 attr
= dwarf2_attr (comp_unit_die
, DW_AT_stmt_list
, cu
);
2887 struct quick_file_names find_entry
;
2889 line_offset
= DW_UNSND (attr
);
2891 /* We may have already read in this line header (TU line header sharing).
2892 If we have we're done. */
2893 find_entry
.hash
.dwo_unit
= cu
->dwo_unit
;
2894 find_entry
.hash
.line_offset
.sect_off
= line_offset
;
2895 slot
= htab_find_slot (dwarf2_per_objfile
->quick_file_names_table
,
2896 &find_entry
, INSERT
);
2899 lh_cu
->v
.quick
->file_names
= *slot
;
2903 lh
= dwarf_decode_line_header (line_offset
, cu
);
2907 lh_cu
->v
.quick
->no_file_data
= 1;
2911 qfn
= obstack_alloc (&objfile
->objfile_obstack
, sizeof (*qfn
));
2912 qfn
->hash
.dwo_unit
= cu
->dwo_unit
;
2913 qfn
->hash
.line_offset
.sect_off
= line_offset
;
2914 gdb_assert (slot
!= NULL
);
2917 find_file_and_directory (comp_unit_die
, cu
, &name
, &comp_dir
);
2919 qfn
->num_file_names
= lh
->num_file_names
;
2920 qfn
->file_names
= obstack_alloc (&objfile
->objfile_obstack
,
2921 lh
->num_file_names
* sizeof (char *));
2922 for (i
= 0; i
< lh
->num_file_names
; ++i
)
2923 qfn
->file_names
[i
] = file_full_name (i
+ 1, lh
, comp_dir
);
2924 qfn
->real_names
= NULL
;
2926 free_line_header (lh
);
2928 lh_cu
->v
.quick
->file_names
= qfn
;
2931 /* A helper for the "quick" functions which attempts to read the line
2932 table for THIS_CU. */
2934 static struct quick_file_names
*
2935 dw2_get_file_names (struct dwarf2_per_cu_data
*this_cu
)
2937 /* This should never be called for TUs. */
2938 gdb_assert (! this_cu
->is_debug_types
);
2939 /* Nor type unit groups. */
2940 gdb_assert (! IS_TYPE_UNIT_GROUP (this_cu
));
2942 if (this_cu
->v
.quick
->file_names
!= NULL
)
2943 return this_cu
->v
.quick
->file_names
;
2944 /* If we know there is no line data, no point in looking again. */
2945 if (this_cu
->v
.quick
->no_file_data
)
2948 init_cutu_and_read_dies_simple (this_cu
, dw2_get_file_names_reader
, NULL
);
2950 if (this_cu
->v
.quick
->no_file_data
)
2952 return this_cu
->v
.quick
->file_names
;
2955 /* A helper for the "quick" functions which computes and caches the
2956 real path for a given file name from the line table. */
2959 dw2_get_real_path (struct objfile
*objfile
,
2960 struct quick_file_names
*qfn
, int index
)
2962 if (qfn
->real_names
== NULL
)
2963 qfn
->real_names
= OBSTACK_CALLOC (&objfile
->objfile_obstack
,
2964 qfn
->num_file_names
, sizeof (char *));
2966 if (qfn
->real_names
[index
] == NULL
)
2967 qfn
->real_names
[index
] = gdb_realpath (qfn
->file_names
[index
]);
2969 return qfn
->real_names
[index
];
2972 static struct symtab
*
2973 dw2_find_last_source_symtab (struct objfile
*objfile
)
2977 dw2_setup (objfile
);
2978 index
= dwarf2_per_objfile
->n_comp_units
- 1;
2979 return dw2_instantiate_symtab (dw2_get_cu (index
));
2982 /* Traversal function for dw2_forget_cached_source_info. */
2985 dw2_free_cached_file_names (void **slot
, void *info
)
2987 struct quick_file_names
*file_data
= (struct quick_file_names
*) *slot
;
2989 if (file_data
->real_names
)
2993 for (i
= 0; i
< file_data
->num_file_names
; ++i
)
2995 xfree ((void*) file_data
->real_names
[i
]);
2996 file_data
->real_names
[i
] = NULL
;
3004 dw2_forget_cached_source_info (struct objfile
*objfile
)
3006 dw2_setup (objfile
);
3008 htab_traverse_noresize (dwarf2_per_objfile
->quick_file_names_table
,
3009 dw2_free_cached_file_names
, NULL
);
3012 /* Helper function for dw2_map_symtabs_matching_filename that expands
3013 the symtabs and calls the iterator. */
3016 dw2_map_expand_apply (struct objfile
*objfile
,
3017 struct dwarf2_per_cu_data
*per_cu
,
3018 const char *name
, const char *real_path
,
3019 int (*callback
) (struct symtab
*, void *),
3022 struct symtab
*last_made
= objfile
->symtabs
;
3024 /* Don't visit already-expanded CUs. */
3025 if (per_cu
->v
.quick
->symtab
)
3028 /* This may expand more than one symtab, and we want to iterate over
3030 dw2_instantiate_symtab (per_cu
);
3032 return iterate_over_some_symtabs (name
, real_path
, callback
, data
,
3033 objfile
->symtabs
, last_made
);
3036 /* Implementation of the map_symtabs_matching_filename method. */
3039 dw2_map_symtabs_matching_filename (struct objfile
*objfile
, const char *name
,
3040 const char *real_path
,
3041 int (*callback
) (struct symtab
*, void *),
3045 const char *name_basename
= lbasename (name
);
3047 dw2_setup (objfile
);
3049 /* The rule is CUs specify all the files, including those used by
3050 any TU, so there's no need to scan TUs here. */
3052 for (i
= 0; i
< dwarf2_per_objfile
->n_comp_units
; ++i
)
3055 struct dwarf2_per_cu_data
*per_cu
= dw2_get_primary_cu (i
);
3056 struct quick_file_names
*file_data
;
3058 /* We only need to look at symtabs not already expanded. */
3059 if (per_cu
->v
.quick
->symtab
)
3062 file_data
= dw2_get_file_names (per_cu
);
3063 if (file_data
== NULL
)
3066 for (j
= 0; j
< file_data
->num_file_names
; ++j
)
3068 const char *this_name
= file_data
->file_names
[j
];
3069 const char *this_real_name
;
3071 if (compare_filenames_for_search (this_name
, name
))
3073 if (dw2_map_expand_apply (objfile
, per_cu
, name
, real_path
,
3079 /* Before we invoke realpath, which can get expensive when many
3080 files are involved, do a quick comparison of the basenames. */
3081 if (! basenames_may_differ
3082 && FILENAME_CMP (lbasename (this_name
), name_basename
) != 0)
3085 this_real_name
= dw2_get_real_path (objfile
, file_data
, j
);
3086 if (compare_filenames_for_search (this_real_name
, name
))
3088 if (dw2_map_expand_apply (objfile
, per_cu
, name
, real_path
,
3094 if (real_path
!= NULL
)
3096 gdb_assert (IS_ABSOLUTE_PATH (real_path
));
3097 gdb_assert (IS_ABSOLUTE_PATH (name
));
3098 if (this_real_name
!= NULL
3099 && FILENAME_CMP (real_path
, this_real_name
) == 0)
3101 if (dw2_map_expand_apply (objfile
, per_cu
, name
, real_path
,
3113 /* Struct used to manage iterating over all CUs looking for a symbol. */
3115 struct dw2_symtab_iterator
3117 /* The internalized form of .gdb_index. */
3118 struct mapped_index
*index
;
3119 /* If non-zero, only look for symbols that match BLOCK_INDEX. */
3120 int want_specific_block
;
3121 /* One of GLOBAL_BLOCK or STATIC_BLOCK.
3122 Unused if !WANT_SPECIFIC_BLOCK. */
3124 /* The kind of symbol we're looking for. */
3126 /* The list of CUs from the index entry of the symbol,
3127 or NULL if not found. */
3129 /* The next element in VEC to look at. */
3131 /* The number of elements in VEC, or zero if there is no match. */
3135 /* Initialize the index symtab iterator ITER.
3136 If WANT_SPECIFIC_BLOCK is non-zero, only look for symbols
3137 in block BLOCK_INDEX. Otherwise BLOCK_INDEX is ignored. */
3140 dw2_symtab_iter_init (struct dw2_symtab_iterator
*iter
,
3141 struct mapped_index
*index
,
3142 int want_specific_block
,
3147 iter
->index
= index
;
3148 iter
->want_specific_block
= want_specific_block
;
3149 iter
->block_index
= block_index
;
3150 iter
->domain
= domain
;
3153 if (find_slot_in_mapped_hash (index
, name
, &iter
->vec
))
3154 iter
->length
= MAYBE_SWAP (*iter
->vec
);
3162 /* Return the next matching CU or NULL if there are no more. */
3164 static struct dwarf2_per_cu_data
*
3165 dw2_symtab_iter_next (struct dw2_symtab_iterator
*iter
)
3167 for ( ; iter
->next
< iter
->length
; ++iter
->next
)
3169 offset_type cu_index_and_attrs
=
3170 MAYBE_SWAP (iter
->vec
[iter
->next
+ 1]);
3171 offset_type cu_index
= GDB_INDEX_CU_VALUE (cu_index_and_attrs
);
3172 struct dwarf2_per_cu_data
*per_cu
= dw2_get_cu (cu_index
);
3173 int want_static
= iter
->block_index
!= GLOBAL_BLOCK
;
3174 /* This value is only valid for index versions >= 7. */
3175 int is_static
= GDB_INDEX_SYMBOL_STATIC_VALUE (cu_index_and_attrs
);
3176 gdb_index_symbol_kind symbol_kind
=
3177 GDB_INDEX_SYMBOL_KIND_VALUE (cu_index_and_attrs
);
3178 /* Only check the symbol attributes if they're present.
3179 Indices prior to version 7 don't record them,
3180 and indices >= 7 may elide them for certain symbols
3181 (gold does this). */
3183 (iter
->index
->version
>= 7
3184 && symbol_kind
!= GDB_INDEX_SYMBOL_KIND_NONE
);
3186 /* Skip if already read in. */
3187 if (per_cu
->v
.quick
->symtab
)
3191 && iter
->want_specific_block
3192 && want_static
!= is_static
)
3195 /* Only check the symbol's kind if it has one. */
3198 switch (iter
->domain
)
3201 if (symbol_kind
!= GDB_INDEX_SYMBOL_KIND_VARIABLE
3202 && symbol_kind
!= GDB_INDEX_SYMBOL_KIND_FUNCTION
3203 /* Some types are also in VAR_DOMAIN. */
3204 && symbol_kind
!= GDB_INDEX_SYMBOL_KIND_TYPE
)
3208 if (symbol_kind
!= GDB_INDEX_SYMBOL_KIND_TYPE
)
3212 if (symbol_kind
!= GDB_INDEX_SYMBOL_KIND_OTHER
)
3227 static struct symtab
*
3228 dw2_lookup_symbol (struct objfile
*objfile
, int block_index
,
3229 const char *name
, domain_enum domain
)
3231 struct symtab
*stab_best
= NULL
;
3232 struct mapped_index
*index
;
3234 dw2_setup (objfile
);
3236 index
= dwarf2_per_objfile
->index_table
;
3238 /* index is NULL if OBJF_READNOW. */
3241 struct dw2_symtab_iterator iter
;
3242 struct dwarf2_per_cu_data
*per_cu
;
3244 dw2_symtab_iter_init (&iter
, index
, 1, block_index
, domain
, name
);
3246 while ((per_cu
= dw2_symtab_iter_next (&iter
)) != NULL
)
3248 struct symbol
*sym
= NULL
;
3249 struct symtab
*stab
= dw2_instantiate_symtab (per_cu
);
3251 /* Some caution must be observed with overloaded functions
3252 and methods, since the index will not contain any overload
3253 information (but NAME might contain it). */
3256 struct blockvector
*bv
= BLOCKVECTOR (stab
);
3257 struct block
*block
= BLOCKVECTOR_BLOCK (bv
, block_index
);
3259 sym
= lookup_block_symbol (block
, name
, domain
);
3262 if (sym
&& strcmp_iw (SYMBOL_SEARCH_NAME (sym
), name
) == 0)
3264 if (!TYPE_IS_OPAQUE (SYMBOL_TYPE (sym
)))
3270 /* Keep looking through other CUs. */
3278 dw2_print_stats (struct objfile
*objfile
)
3280 int i
, total
, count
;
3282 dw2_setup (objfile
);
3283 total
= dwarf2_per_objfile
->n_comp_units
+ dwarf2_per_objfile
->n_type_units
;
3285 for (i
= 0; i
< total
; ++i
)
3287 struct dwarf2_per_cu_data
*per_cu
= dw2_get_cu (i
);
3289 if (!per_cu
->v
.quick
->symtab
)
3292 printf_filtered (_(" Number of read CUs: %d\n"), total
- count
);
3293 printf_filtered (_(" Number of unread CUs: %d\n"), count
);
3297 dw2_dump (struct objfile
*objfile
)
3299 /* Nothing worth printing. */
3303 dw2_relocate (struct objfile
*objfile
, struct section_offsets
*new_offsets
,
3304 struct section_offsets
*delta
)
3306 /* There's nothing to relocate here. */
3310 dw2_expand_symtabs_for_function (struct objfile
*objfile
,
3311 const char *func_name
)
3313 struct mapped_index
*index
;
3315 dw2_setup (objfile
);
3317 index
= dwarf2_per_objfile
->index_table
;
3319 /* index is NULL if OBJF_READNOW. */
3322 struct dw2_symtab_iterator iter
;
3323 struct dwarf2_per_cu_data
*per_cu
;
3325 /* Note: It doesn't matter what we pass for block_index here. */
3326 dw2_symtab_iter_init (&iter
, index
, 0, GLOBAL_BLOCK
, VAR_DOMAIN
,
3329 while ((per_cu
= dw2_symtab_iter_next (&iter
)) != NULL
)
3330 dw2_instantiate_symtab (per_cu
);
3335 dw2_expand_all_symtabs (struct objfile
*objfile
)
3339 dw2_setup (objfile
);
3341 for (i
= 0; i
< (dwarf2_per_objfile
->n_comp_units
3342 + dwarf2_per_objfile
->n_type_units
); ++i
)
3344 struct dwarf2_per_cu_data
*per_cu
= dw2_get_cu (i
);
3346 dw2_instantiate_symtab (per_cu
);
3351 dw2_expand_symtabs_with_fullname (struct objfile
*objfile
,
3352 const char *fullname
)
3356 dw2_setup (objfile
);
3358 /* We don't need to consider type units here.
3359 This is only called for examining code, e.g. expand_line_sal.
3360 There can be an order of magnitude (or more) more type units
3361 than comp units, and we avoid them if we can. */
3363 for (i
= 0; i
< dwarf2_per_objfile
->n_comp_units
; ++i
)
3366 struct dwarf2_per_cu_data
*per_cu
= dw2_get_cu (i
);
3367 struct quick_file_names
*file_data
;
3369 /* We only need to look at symtabs not already expanded. */
3370 if (per_cu
->v
.quick
->symtab
)
3373 file_data
= dw2_get_file_names (per_cu
);
3374 if (file_data
== NULL
)
3377 for (j
= 0; j
< file_data
->num_file_names
; ++j
)
3379 const char *this_fullname
= file_data
->file_names
[j
];
3381 if (filename_cmp (this_fullname
, fullname
) == 0)
3383 dw2_instantiate_symtab (per_cu
);
3390 /* A helper function for dw2_find_symbol_file that finds the primary
3391 file name for a given CU. This is a die_reader_func. */
3394 dw2_get_primary_filename_reader (const struct die_reader_specs
*reader
,
3396 struct die_info
*comp_unit_die
,
3400 const char **result_ptr
= data
;
3401 struct dwarf2_cu
*cu
= reader
->cu
;
3402 struct attribute
*attr
;
3404 attr
= dwarf2_attr (comp_unit_die
, DW_AT_name
, cu
);
3408 *result_ptr
= DW_STRING (attr
);
3412 dw2_find_symbol_file (struct objfile
*objfile
, const char *name
)
3414 struct dwarf2_per_cu_data
*per_cu
;
3416 const char *filename
;
3418 dw2_setup (objfile
);
3420 /* index_table is NULL if OBJF_READNOW. */
3421 if (!dwarf2_per_objfile
->index_table
)
3425 ALL_OBJFILE_PRIMARY_SYMTABS (objfile
, s
)
3427 struct blockvector
*bv
= BLOCKVECTOR (s
);
3428 const struct block
*block
= BLOCKVECTOR_BLOCK (bv
, GLOBAL_BLOCK
);
3429 struct symbol
*sym
= lookup_block_symbol (block
, name
, VAR_DOMAIN
);
3433 /* Only file extension of returned filename is recognized. */
3434 return SYMBOL_SYMTAB (sym
)->filename
;
3440 if (!find_slot_in_mapped_hash (dwarf2_per_objfile
->index_table
,
3444 /* Note that this just looks at the very first one named NAME -- but
3445 actually we are looking for a function. find_main_filename
3446 should be rewritten so that it doesn't require a custom hook. It
3447 could just use the ordinary symbol tables. */
3448 /* vec[0] is the length, which must always be >0. */
3449 per_cu
= dw2_get_cu (GDB_INDEX_CU_VALUE (MAYBE_SWAP (vec
[1])));
3451 if (per_cu
->v
.quick
->symtab
!= NULL
)
3453 /* Only file extension of returned filename is recognized. */
3454 return per_cu
->v
.quick
->symtab
->filename
;
3457 init_cutu_and_read_dies (per_cu
, NULL
, 0, 0,
3458 dw2_get_primary_filename_reader
, &filename
);
3460 /* Only file extension of returned filename is recognized. */
3465 dw2_map_matching_symbols (const char * name
, domain_enum
namespace,
3466 struct objfile
*objfile
, int global
,
3467 int (*callback
) (struct block
*,
3468 struct symbol
*, void *),
3469 void *data
, symbol_compare_ftype
*match
,
3470 symbol_compare_ftype
*ordered_compare
)
3472 /* Currently unimplemented; used for Ada. The function can be called if the
3473 current language is Ada for a non-Ada objfile using GNU index. As Ada
3474 does not look for non-Ada symbols this function should just return. */
3478 dw2_expand_symtabs_matching
3479 (struct objfile
*objfile
,
3480 int (*file_matcher
) (const char *, void *, int basenames
),
3481 int (*name_matcher
) (const char *, void *),
3482 enum search_domain kind
,
3487 struct mapped_index
*index
;
3489 dw2_setup (objfile
);
3491 /* index_table is NULL if OBJF_READNOW. */
3492 if (!dwarf2_per_objfile
->index_table
)
3494 index
= dwarf2_per_objfile
->index_table
;
3496 if (file_matcher
!= NULL
)
3498 struct cleanup
*cleanup
;
3499 htab_t visited_found
, visited_not_found
;
3501 visited_found
= htab_create_alloc (10,
3502 htab_hash_pointer
, htab_eq_pointer
,
3503 NULL
, xcalloc
, xfree
);
3504 cleanup
= make_cleanup_htab_delete (visited_found
);
3505 visited_not_found
= htab_create_alloc (10,
3506 htab_hash_pointer
, htab_eq_pointer
,
3507 NULL
, xcalloc
, xfree
);
3508 make_cleanup_htab_delete (visited_not_found
);
3510 /* The rule is CUs specify all the files, including those used by
3511 any TU, so there's no need to scan TUs here. */
3513 for (i
= 0; i
< dwarf2_per_objfile
->n_comp_units
; ++i
)
3516 struct dwarf2_per_cu_data
*per_cu
= dw2_get_primary_cu (i
);
3517 struct quick_file_names
*file_data
;
3520 per_cu
->v
.quick
->mark
= 0;
3522 /* We only need to look at symtabs not already expanded. */
3523 if (per_cu
->v
.quick
->symtab
)
3526 file_data
= dw2_get_file_names (per_cu
);
3527 if (file_data
== NULL
)
3530 if (htab_find (visited_not_found
, file_data
) != NULL
)
3532 else if (htab_find (visited_found
, file_data
) != NULL
)
3534 per_cu
->v
.quick
->mark
= 1;
3538 for (j
= 0; j
< file_data
->num_file_names
; ++j
)
3540 const char *this_real_name
;
3542 if (file_matcher (file_data
->file_names
[j
], data
, 0))
3544 per_cu
->v
.quick
->mark
= 1;
3548 /* Before we invoke realpath, which can get expensive when many
3549 files are involved, do a quick comparison of the basenames. */
3550 if (!basenames_may_differ
3551 && !file_matcher (lbasename (file_data
->file_names
[j
]),
3555 this_real_name
= dw2_get_real_path (objfile
, file_data
, j
);
3556 if (file_matcher (this_real_name
, data
, 0))
3558 per_cu
->v
.quick
->mark
= 1;
3563 slot
= htab_find_slot (per_cu
->v
.quick
->mark
3565 : visited_not_found
,
3570 do_cleanups (cleanup
);
3573 for (iter
= 0; iter
< index
->symbol_table_slots
; ++iter
)
3575 offset_type idx
= 2 * iter
;
3577 offset_type
*vec
, vec_len
, vec_idx
;
3579 if (index
->symbol_table
[idx
] == 0 && index
->symbol_table
[idx
+ 1] == 0)
3582 name
= index
->constant_pool
+ MAYBE_SWAP (index
->symbol_table
[idx
]);
3584 if (! (*name_matcher
) (name
, data
))
3587 /* The name was matched, now expand corresponding CUs that were
3589 vec
= (offset_type
*) (index
->constant_pool
3590 + MAYBE_SWAP (index
->symbol_table
[idx
+ 1]));
3591 vec_len
= MAYBE_SWAP (vec
[0]);
3592 for (vec_idx
= 0; vec_idx
< vec_len
; ++vec_idx
)
3594 struct dwarf2_per_cu_data
*per_cu
;
3595 offset_type cu_index_and_attrs
= MAYBE_SWAP (vec
[vec_idx
+ 1]);
3596 gdb_index_symbol_kind symbol_kind
=
3597 GDB_INDEX_SYMBOL_KIND_VALUE (cu_index_and_attrs
);
3598 int cu_index
= GDB_INDEX_CU_VALUE (cu_index_and_attrs
);
3600 /* Don't crash on bad data. */
3601 if (cu_index
>= (dwarf2_per_objfile
->n_comp_units
3602 + dwarf2_per_objfile
->n_type_units
))
3605 /* Only check the symbol's kind if it has one.
3606 Indices prior to version 7 don't record it. */
3607 if (index
->version
>= 7)
3611 case VARIABLES_DOMAIN
:
3612 if (symbol_kind
!= GDB_INDEX_SYMBOL_KIND_VARIABLE
)
3615 case FUNCTIONS_DOMAIN
:
3616 if (symbol_kind
!= GDB_INDEX_SYMBOL_KIND_FUNCTION
)
3620 if (symbol_kind
!= GDB_INDEX_SYMBOL_KIND_TYPE
)
3628 per_cu
= dw2_get_cu (cu_index
);
3629 if (file_matcher
== NULL
|| per_cu
->v
.quick
->mark
)
3630 dw2_instantiate_symtab (per_cu
);
3635 /* A helper for dw2_find_pc_sect_symtab which finds the most specific
3638 static struct symtab
*
3639 recursively_find_pc_sect_symtab (struct symtab
*symtab
, CORE_ADDR pc
)
3643 if (BLOCKVECTOR (symtab
) != NULL
3644 && blockvector_contains_pc (BLOCKVECTOR (symtab
), pc
))
3647 if (symtab
->includes
== NULL
)
3650 for (i
= 0; symtab
->includes
[i
]; ++i
)
3652 struct symtab
*s
= symtab
->includes
[i
];
3654 s
= recursively_find_pc_sect_symtab (s
, pc
);
3662 static struct symtab
*
3663 dw2_find_pc_sect_symtab (struct objfile
*objfile
,
3664 struct minimal_symbol
*msymbol
,
3666 struct obj_section
*section
,
3669 struct dwarf2_per_cu_data
*data
;
3670 struct symtab
*result
;
3672 dw2_setup (objfile
);
3674 if (!objfile
->psymtabs_addrmap
)
3677 data
= addrmap_find (objfile
->psymtabs_addrmap
, pc
);
3681 if (warn_if_readin
&& data
->v
.quick
->symtab
)
3682 warning (_("(Internal error: pc %s in read in CU, but not in symtab.)"),
3683 paddress (get_objfile_arch (objfile
), pc
));
3685 result
= recursively_find_pc_sect_symtab (dw2_instantiate_symtab (data
), pc
);
3686 gdb_assert (result
!= NULL
);
3691 dw2_map_symbol_filenames (struct objfile
*objfile
, symbol_filename_ftype
*fun
,
3692 void *data
, int need_fullname
)
3695 struct cleanup
*cleanup
;
3696 htab_t visited
= htab_create_alloc (10, htab_hash_pointer
, htab_eq_pointer
,
3697 NULL
, xcalloc
, xfree
);
3699 cleanup
= make_cleanup_htab_delete (visited
);
3700 dw2_setup (objfile
);
3702 /* The rule is CUs specify all the files, including those used by
3703 any TU, so there's no need to scan TUs here.
3704 We can ignore file names coming from already-expanded CUs. */
3706 for (i
= 0; i
< dwarf2_per_objfile
->n_comp_units
; ++i
)
3708 struct dwarf2_per_cu_data
*per_cu
= dw2_get_cu (i
);
3710 if (per_cu
->v
.quick
->symtab
)
3712 void **slot
= htab_find_slot (visited
, per_cu
->v
.quick
->file_names
,
3715 *slot
= per_cu
->v
.quick
->file_names
;
3719 for (i
= 0; i
< dwarf2_per_objfile
->n_comp_units
; ++i
)
3722 struct dwarf2_per_cu_data
*per_cu
= dw2_get_primary_cu (i
);
3723 struct quick_file_names
*file_data
;
3726 /* We only need to look at symtabs not already expanded. */
3727 if (per_cu
->v
.quick
->symtab
)
3730 file_data
= dw2_get_file_names (per_cu
);
3731 if (file_data
== NULL
)
3734 slot
= htab_find_slot (visited
, file_data
, INSERT
);
3737 /* Already visited. */
3742 for (j
= 0; j
< file_data
->num_file_names
; ++j
)
3744 const char *this_real_name
;
3747 this_real_name
= dw2_get_real_path (objfile
, file_data
, j
);
3749 this_real_name
= NULL
;
3750 (*fun
) (file_data
->file_names
[j
], this_real_name
, data
);
3754 do_cleanups (cleanup
);
3758 dw2_has_symbols (struct objfile
*objfile
)
3763 const struct quick_symbol_functions dwarf2_gdb_index_functions
=
3766 dw2_find_last_source_symtab
,
3767 dw2_forget_cached_source_info
,
3768 dw2_map_symtabs_matching_filename
,
3773 dw2_expand_symtabs_for_function
,
3774 dw2_expand_all_symtabs
,
3775 dw2_expand_symtabs_with_fullname
,
3776 dw2_find_symbol_file
,
3777 dw2_map_matching_symbols
,
3778 dw2_expand_symtabs_matching
,
3779 dw2_find_pc_sect_symtab
,
3780 dw2_map_symbol_filenames
3783 /* Initialize for reading DWARF for this objfile. Return 0 if this
3784 file will use psymtabs, or 1 if using the GNU index. */
3787 dwarf2_initialize_objfile (struct objfile
*objfile
)
3789 /* If we're about to read full symbols, don't bother with the
3790 indices. In this case we also don't care if some other debug
3791 format is making psymtabs, because they are all about to be
3793 if ((objfile
->flags
& OBJF_READNOW
))
3797 dwarf2_per_objfile
->using_index
= 1;
3798 create_all_comp_units (objfile
);
3799 create_all_type_units (objfile
);
3800 dwarf2_per_objfile
->quick_file_names_table
=
3801 create_quick_file_names_table (dwarf2_per_objfile
->n_comp_units
);
3803 for (i
= 0; i
< (dwarf2_per_objfile
->n_comp_units
3804 + dwarf2_per_objfile
->n_type_units
); ++i
)
3806 struct dwarf2_per_cu_data
*per_cu
= dw2_get_cu (i
);
3808 per_cu
->v
.quick
= OBSTACK_ZALLOC (&objfile
->objfile_obstack
,
3809 struct dwarf2_per_cu_quick_data
);
3812 /* Return 1 so that gdb sees the "quick" functions. However,
3813 these functions will be no-ops because we will have expanded
3818 if (dwarf2_read_index (objfile
))
3826 /* Build a partial symbol table. */
3829 dwarf2_build_psymtabs (struct objfile
*objfile
)
3831 volatile struct gdb_exception except
;
3833 if (objfile
->global_psymbols
.size
== 0 && objfile
->static_psymbols
.size
== 0)
3835 init_psymbol_list (objfile
, 1024);
3838 TRY_CATCH (except
, RETURN_MASK_ERROR
)
3840 /* This isn't really ideal: all the data we allocate on the
3841 objfile's obstack is still uselessly kept around. However,
3842 freeing it seems unsafe. */
3843 struct cleanup
*cleanups
= make_cleanup_discard_psymtabs (objfile
);
3845 dwarf2_build_psymtabs_hard (objfile
);
3846 discard_cleanups (cleanups
);
3848 if (except
.reason
< 0)
3849 exception_print (gdb_stderr
, except
);
3852 /* Return the total length of the CU described by HEADER. */
3855 get_cu_length (const struct comp_unit_head
*header
)
3857 return header
->initial_length_size
+ header
->length
;
3860 /* Return TRUE if OFFSET is within CU_HEADER. */
3863 offset_in_cu_p (const struct comp_unit_head
*cu_header
, sect_offset offset
)
3865 sect_offset bottom
= { cu_header
->offset
.sect_off
};
3866 sect_offset top
= { cu_header
->offset
.sect_off
+ get_cu_length (cu_header
) };
3868 return (offset
.sect_off
>= bottom
.sect_off
&& offset
.sect_off
< top
.sect_off
);
3871 /* Find the base address of the compilation unit for range lists and
3872 location lists. It will normally be specified by DW_AT_low_pc.
3873 In DWARF-3 draft 4, the base address could be overridden by
3874 DW_AT_entry_pc. It's been removed, but GCC still uses this for
3875 compilation units with discontinuous ranges. */
3878 dwarf2_find_base_address (struct die_info
*die
, struct dwarf2_cu
*cu
)
3880 struct attribute
*attr
;
3883 cu
->base_address
= 0;
3885 attr
= dwarf2_attr (die
, DW_AT_entry_pc
, cu
);
3888 cu
->base_address
= DW_ADDR (attr
);
3893 attr
= dwarf2_attr (die
, DW_AT_low_pc
, cu
);
3896 cu
->base_address
= DW_ADDR (attr
);
3902 /* Read in the comp unit header information from the debug_info at info_ptr.
3903 NOTE: This leaves members offset, first_die_offset to be filled in
3907 read_comp_unit_head (struct comp_unit_head
*cu_header
,
3908 gdb_byte
*info_ptr
, bfd
*abfd
)
3911 unsigned int bytes_read
;
3913 cu_header
->length
= read_initial_length (abfd
, info_ptr
, &bytes_read
);
3914 cu_header
->initial_length_size
= bytes_read
;
3915 cu_header
->offset_size
= (bytes_read
== 4) ? 4 : 8;
3916 info_ptr
+= bytes_read
;
3917 cu_header
->version
= read_2_bytes (abfd
, info_ptr
);
3919 cu_header
->abbrev_offset
.sect_off
= read_offset (abfd
, info_ptr
, cu_header
,
3921 info_ptr
+= bytes_read
;
3922 cu_header
->addr_size
= read_1_byte (abfd
, info_ptr
);
3924 signed_addr
= bfd_get_sign_extend_vma (abfd
);
3925 if (signed_addr
< 0)
3926 internal_error (__FILE__
, __LINE__
,
3927 _("read_comp_unit_head: dwarf from non elf file"));
3928 cu_header
->signed_addr_p
= signed_addr
;
3933 /* Helper function that returns the proper abbrev section for
3936 static struct dwarf2_section_info
*
3937 get_abbrev_section_for_cu (struct dwarf2_per_cu_data
*this_cu
)
3939 struct dwarf2_section_info
*abbrev
;
3941 if (this_cu
->is_dwz
)
3942 abbrev
= &dwarf2_get_dwz_file ()->abbrev
;
3944 abbrev
= &dwarf2_per_objfile
->abbrev
;
3949 /* Subroutine of read_and_check_comp_unit_head and
3950 read_and_check_type_unit_head to simplify them.
3951 Perform various error checking on the header. */
3954 error_check_comp_unit_head (struct comp_unit_head
*header
,
3955 struct dwarf2_section_info
*section
,
3956 struct dwarf2_section_info
*abbrev_section
)
3958 bfd
*abfd
= section
->asection
->owner
;
3959 const char *filename
= bfd_get_filename (abfd
);
3961 if (header
->version
!= 2 && header
->version
!= 3 && header
->version
!= 4)
3962 error (_("Dwarf Error: wrong version in compilation unit header "
3963 "(is %d, should be 2, 3, or 4) [in module %s]"), header
->version
,
3966 if (header
->abbrev_offset
.sect_off
3967 >= dwarf2_section_size (dwarf2_per_objfile
->objfile
, abbrev_section
))
3968 error (_("Dwarf Error: bad offset (0x%lx) in compilation unit header "
3969 "(offset 0x%lx + 6) [in module %s]"),
3970 (long) header
->abbrev_offset
.sect_off
, (long) header
->offset
.sect_off
,
3973 /* Cast to unsigned long to use 64-bit arithmetic when possible to
3974 avoid potential 32-bit overflow. */
3975 if (((unsigned long) header
->offset
.sect_off
+ get_cu_length (header
))
3977 error (_("Dwarf Error: bad length (0x%lx) in compilation unit header "
3978 "(offset 0x%lx + 0) [in module %s]"),
3979 (long) header
->length
, (long) header
->offset
.sect_off
,
3983 /* Read in a CU/TU header and perform some basic error checking.
3984 The contents of the header are stored in HEADER.
3985 The result is a pointer to the start of the first DIE. */
3988 read_and_check_comp_unit_head (struct comp_unit_head
*header
,
3989 struct dwarf2_section_info
*section
,
3990 struct dwarf2_section_info
*abbrev_section
,
3992 int is_debug_types_section
)
3994 gdb_byte
*beg_of_comp_unit
= info_ptr
;
3995 bfd
*abfd
= section
->asection
->owner
;
3997 header
->offset
.sect_off
= beg_of_comp_unit
- section
->buffer
;
3999 info_ptr
= read_comp_unit_head (header
, info_ptr
, abfd
);
4001 /* If we're reading a type unit, skip over the signature and
4002 type_offset fields. */
4003 if (is_debug_types_section
)
4004 info_ptr
+= 8 /*signature*/ + header
->offset_size
;
4006 header
->first_die_offset
.cu_off
= info_ptr
- beg_of_comp_unit
;
4008 error_check_comp_unit_head (header
, section
, abbrev_section
);
4013 /* Read in the types comp unit header information from .debug_types entry at
4014 types_ptr. The result is a pointer to one past the end of the header. */
4017 read_and_check_type_unit_head (struct comp_unit_head
*header
,
4018 struct dwarf2_section_info
*section
,
4019 struct dwarf2_section_info
*abbrev_section
,
4021 ULONGEST
*signature
,
4022 cu_offset
*type_offset_in_tu
)
4024 gdb_byte
*beg_of_comp_unit
= info_ptr
;
4025 bfd
*abfd
= section
->asection
->owner
;
4027 header
->offset
.sect_off
= beg_of_comp_unit
- section
->buffer
;
4029 info_ptr
= read_comp_unit_head (header
, info_ptr
, abfd
);
4031 /* If we're reading a type unit, skip over the signature and
4032 type_offset fields. */
4033 if (signature
!= NULL
)
4034 *signature
= read_8_bytes (abfd
, info_ptr
);
4036 if (type_offset_in_tu
!= NULL
)
4037 type_offset_in_tu
->cu_off
= read_offset_1 (abfd
, info_ptr
,
4038 header
->offset_size
);
4039 info_ptr
+= header
->offset_size
;
4041 header
->first_die_offset
.cu_off
= info_ptr
- beg_of_comp_unit
;
4043 error_check_comp_unit_head (header
, section
, abbrev_section
);
4048 /* Fetch the abbreviation table offset from a comp or type unit header. */
4051 read_abbrev_offset (struct dwarf2_section_info
*section
,
4054 bfd
*abfd
= section
->asection
->owner
;
4056 unsigned int length
, initial_length_size
, offset_size
;
4057 sect_offset abbrev_offset
;
4059 dwarf2_read_section (dwarf2_per_objfile
->objfile
, section
);
4060 info_ptr
= section
->buffer
+ offset
.sect_off
;
4061 length
= read_initial_length (abfd
, info_ptr
, &initial_length_size
);
4062 offset_size
= initial_length_size
== 4 ? 4 : 8;
4063 info_ptr
+= initial_length_size
+ 2 /*version*/;
4064 abbrev_offset
.sect_off
= read_offset_1 (abfd
, info_ptr
, offset_size
);
4065 return abbrev_offset
;
4068 /* Allocate a new partial symtab for file named NAME and mark this new
4069 partial symtab as being an include of PST. */
4072 dwarf2_create_include_psymtab (char *name
, struct partial_symtab
*pst
,
4073 struct objfile
*objfile
)
4075 struct partial_symtab
*subpst
= allocate_psymtab (name
, objfile
);
4077 if (!IS_ABSOLUTE_PATH (subpst
->filename
))
4079 /* It shares objfile->objfile_obstack. */
4080 subpst
->dirname
= pst
->dirname
;
4083 subpst
->section_offsets
= pst
->section_offsets
;
4084 subpst
->textlow
= 0;
4085 subpst
->texthigh
= 0;
4087 subpst
->dependencies
= (struct partial_symtab
**)
4088 obstack_alloc (&objfile
->objfile_obstack
,
4089 sizeof (struct partial_symtab
*));
4090 subpst
->dependencies
[0] = pst
;
4091 subpst
->number_of_dependencies
= 1;
4093 subpst
->globals_offset
= 0;
4094 subpst
->n_global_syms
= 0;
4095 subpst
->statics_offset
= 0;
4096 subpst
->n_static_syms
= 0;
4097 subpst
->symtab
= NULL
;
4098 subpst
->read_symtab
= pst
->read_symtab
;
4101 /* No private part is necessary for include psymtabs. This property
4102 can be used to differentiate between such include psymtabs and
4103 the regular ones. */
4104 subpst
->read_symtab_private
= NULL
;
4107 /* Read the Line Number Program data and extract the list of files
4108 included by the source file represented by PST. Build an include
4109 partial symtab for each of these included files. */
4112 dwarf2_build_include_psymtabs (struct dwarf2_cu
*cu
,
4113 struct die_info
*die
,
4114 struct partial_symtab
*pst
)
4116 struct line_header
*lh
= NULL
;
4117 struct attribute
*attr
;
4119 attr
= dwarf2_attr (die
, DW_AT_stmt_list
, cu
);
4121 lh
= dwarf_decode_line_header (DW_UNSND (attr
), cu
);
4123 return; /* No linetable, so no includes. */
4125 /* NOTE: pst->dirname is DW_AT_comp_dir (if present). */
4126 dwarf_decode_lines (lh
, pst
->dirname
, cu
, pst
, 1);
4128 free_line_header (lh
);
4132 hash_signatured_type (const void *item
)
4134 const struct signatured_type
*sig_type
= item
;
4136 /* This drops the top 32 bits of the signature, but is ok for a hash. */
4137 return sig_type
->signature
;
4141 eq_signatured_type (const void *item_lhs
, const void *item_rhs
)
4143 const struct signatured_type
*lhs
= item_lhs
;
4144 const struct signatured_type
*rhs
= item_rhs
;
4146 return lhs
->signature
== rhs
->signature
;
4149 /* Allocate a hash table for signatured types. */
4152 allocate_signatured_type_table (struct objfile
*objfile
)
4154 return htab_create_alloc_ex (41,
4155 hash_signatured_type
,
4158 &objfile
->objfile_obstack
,
4159 hashtab_obstack_allocate
,
4160 dummy_obstack_deallocate
);
4163 /* A helper function to add a signatured type CU to a table. */
4166 add_signatured_type_cu_to_table (void **slot
, void *datum
)
4168 struct signatured_type
*sigt
= *slot
;
4169 struct signatured_type
***datap
= datum
;
4177 /* Create the hash table of all entries in the .debug_types
4178 (or .debug_types.dwo) section(s).
4179 If reading a DWO file, then DWO_FILE is a pointer to the DWO file object,
4180 otherwise it is NULL.
4182 The result is a pointer to the hash table or NULL if there are no types.
4184 Note: This function processes DWO files only, not DWP files. */
4187 create_debug_types_hash_table (struct dwo_file
*dwo_file
,
4188 VEC (dwarf2_section_info_def
) *types
)
4190 struct objfile
*objfile
= dwarf2_per_objfile
->objfile
;
4191 htab_t types_htab
= NULL
;
4193 struct dwarf2_section_info
*section
;
4194 struct dwarf2_section_info
*abbrev_section
;
4196 if (VEC_empty (dwarf2_section_info_def
, types
))
4199 abbrev_section
= (dwo_file
!= NULL
4200 ? &dwo_file
->sections
.abbrev
4201 : &dwarf2_per_objfile
->abbrev
);
4203 if (dwarf2_read_debug
)
4204 fprintf_unfiltered (gdb_stdlog
, "Reading .debug_types%s for %s:\n",
4205 dwo_file
? ".dwo" : "",
4206 bfd_get_filename (abbrev_section
->asection
->owner
));
4209 VEC_iterate (dwarf2_section_info_def
, types
, ix
, section
);
4213 gdb_byte
*info_ptr
, *end_ptr
;
4214 struct dwarf2_section_info
*abbrev_section
;
4216 dwarf2_read_section (objfile
, section
);
4217 info_ptr
= section
->buffer
;
4219 if (info_ptr
== NULL
)
4222 /* We can't set abfd until now because the section may be empty or
4223 not present, in which case section->asection will be NULL. */
4224 abfd
= section
->asection
->owner
;
4227 abbrev_section
= &dwo_file
->sections
.abbrev
;
4229 abbrev_section
= &dwarf2_per_objfile
->abbrev
;
4231 /* We don't use init_cutu_and_read_dies_simple, or some such, here
4232 because we don't need to read any dies: the signature is in the
4235 end_ptr
= info_ptr
+ section
->size
;
4236 while (info_ptr
< end_ptr
)
4239 cu_offset type_offset_in_tu
;
4241 struct signatured_type
*sig_type
;
4242 struct dwo_unit
*dwo_tu
;
4244 gdb_byte
*ptr
= info_ptr
;
4245 struct comp_unit_head header
;
4246 unsigned int length
;
4248 offset
.sect_off
= ptr
- section
->buffer
;
4250 /* We need to read the type's signature in order to build the hash
4251 table, but we don't need anything else just yet. */
4253 ptr
= read_and_check_type_unit_head (&header
, section
,
4254 abbrev_section
, ptr
,
4255 &signature
, &type_offset_in_tu
);
4257 length
= get_cu_length (&header
);
4259 /* Skip dummy type units. */
4260 if (ptr
>= info_ptr
+ length
4261 || peek_abbrev_code (abfd
, ptr
) == 0)
4267 if (types_htab
== NULL
)
4270 types_htab
= allocate_dwo_unit_table (objfile
);
4272 types_htab
= allocate_signatured_type_table (objfile
);
4278 dwo_tu
= OBSTACK_ZALLOC (&objfile
->objfile_obstack
,
4280 dwo_tu
->dwo_file
= dwo_file
;
4281 dwo_tu
->signature
= signature
;
4282 dwo_tu
->type_offset_in_tu
= type_offset_in_tu
;
4283 dwo_tu
->section
= section
;
4284 dwo_tu
->offset
= offset
;
4285 dwo_tu
->length
= length
;
4289 /* N.B.: type_offset is not usable if this type uses a DWO file.
4290 The real type_offset is in the DWO file. */
4292 sig_type
= OBSTACK_ZALLOC (&objfile
->objfile_obstack
,
4293 struct signatured_type
);
4294 sig_type
->signature
= signature
;
4295 sig_type
->type_offset_in_tu
= type_offset_in_tu
;
4296 sig_type
->per_cu
.objfile
= objfile
;
4297 sig_type
->per_cu
.is_debug_types
= 1;
4298 sig_type
->per_cu
.section
= section
;
4299 sig_type
->per_cu
.offset
= offset
;
4300 sig_type
->per_cu
.length
= length
;
4303 slot
= htab_find_slot (types_htab
,
4304 dwo_file
? (void*) dwo_tu
: (void *) sig_type
,
4306 gdb_assert (slot
!= NULL
);
4309 sect_offset dup_offset
;
4313 const struct dwo_unit
*dup_tu
= *slot
;
4315 dup_offset
= dup_tu
->offset
;
4319 const struct signatured_type
*dup_tu
= *slot
;
4321 dup_offset
= dup_tu
->per_cu
.offset
;
4324 complaint (&symfile_complaints
,
4325 _("debug type entry at offset 0x%x is duplicate to"
4326 " the entry at offset 0x%x, signature 0x%s"),
4327 offset
.sect_off
, dup_offset
.sect_off
,
4328 phex (signature
, sizeof (signature
)));
4330 *slot
= dwo_file
? (void *) dwo_tu
: (void *) sig_type
;
4332 if (dwarf2_read_debug
)
4333 fprintf_unfiltered (gdb_stdlog
, " offset 0x%x, signature 0x%s\n",
4335 phex (signature
, sizeof (signature
)));
4344 /* Create the hash table of all entries in the .debug_types section,
4345 and initialize all_type_units.
4346 The result is zero if there is an error (e.g. missing .debug_types section),
4347 otherwise non-zero. */
4350 create_all_type_units (struct objfile
*objfile
)
4353 struct signatured_type
**iter
;
4355 types_htab
= create_debug_types_hash_table (NULL
, dwarf2_per_objfile
->types
);
4356 if (types_htab
== NULL
)
4358 dwarf2_per_objfile
->signatured_types
= NULL
;
4362 dwarf2_per_objfile
->signatured_types
= types_htab
;
4364 dwarf2_per_objfile
->n_type_units
= htab_elements (types_htab
);
4365 dwarf2_per_objfile
->all_type_units
4366 = obstack_alloc (&objfile
->objfile_obstack
,
4367 dwarf2_per_objfile
->n_type_units
4368 * sizeof (struct signatured_type
*));
4369 iter
= &dwarf2_per_objfile
->all_type_units
[0];
4370 htab_traverse_noresize (types_htab
, add_signatured_type_cu_to_table
, &iter
);
4371 gdb_assert (iter
- &dwarf2_per_objfile
->all_type_units
[0]
4372 == dwarf2_per_objfile
->n_type_units
);
4377 /* Lookup a signature based type for DW_FORM_ref_sig8.
4378 Returns NULL if signature SIG is not present in the table.
4379 It is up to the caller to complain about this. */
4381 static struct signatured_type
*
4382 lookup_signatured_type (ULONGEST sig
)
4384 struct signatured_type find_entry
, *entry
;
4386 if (dwarf2_per_objfile
->signatured_types
== NULL
)
4388 find_entry
.signature
= sig
;
4389 entry
= htab_find (dwarf2_per_objfile
->signatured_types
, &find_entry
);
4393 /* Low level DIE reading support. */
4395 /* Initialize a die_reader_specs struct from a dwarf2_cu struct. */
4398 init_cu_die_reader (struct die_reader_specs
*reader
,
4399 struct dwarf2_cu
*cu
,
4400 struct dwarf2_section_info
*section
,
4401 struct dwo_file
*dwo_file
)
4403 gdb_assert (section
->readin
&& section
->buffer
!= NULL
);
4404 reader
->abfd
= section
->asection
->owner
;
4406 reader
->dwo_file
= dwo_file
;
4407 reader
->die_section
= section
;
4408 reader
->buffer
= section
->buffer
;
4409 reader
->buffer_end
= section
->buffer
+ section
->size
;
4412 /* Subroutine of init_cutu_and_read_dies to simplify it.
4413 Read in the rest of a CU/TU top level DIE from DWO_UNIT.
4414 There's just a lot of work to do, and init_cutu_and_read_dies is big enough
4417 STUB_COMP_UNIT_DIE is for the stub DIE, we copy over certain attributes
4418 from it to the DIE in the DWO. If NULL we are skipping the stub.
4419 *RESULT_READER,*RESULT_INFO_PTR,*RESULT_COMP_UNIT_DIE,*RESULT_HAS_CHILDREN
4420 are filled in with the info of the DIE from the DWO file.
4421 ABBREV_TABLE_PROVIDED is non-zero if the caller of init_cutu_and_read_dies
4422 provided an abbrev table to use.
4423 The result is non-zero if a valid (non-dummy) DIE was found. */
4426 read_cutu_die_from_dwo (struct dwarf2_per_cu_data
*this_cu
,
4427 struct dwo_unit
*dwo_unit
,
4428 int abbrev_table_provided
,
4429 struct die_info
*stub_comp_unit_die
,
4430 struct die_reader_specs
*result_reader
,
4431 gdb_byte
**result_info_ptr
,
4432 struct die_info
**result_comp_unit_die
,
4433 int *result_has_children
)
4435 struct objfile
*objfile
= dwarf2_per_objfile
->objfile
;
4436 struct dwarf2_cu
*cu
= this_cu
->cu
;
4437 struct dwarf2_section_info
*section
;
4439 gdb_byte
*begin_info_ptr
, *info_ptr
;
4440 const char *comp_dir_string
;
4441 ULONGEST signature
; /* Or dwo_id. */
4442 struct attribute
*comp_dir
, *stmt_list
, *low_pc
, *high_pc
, *ranges
;
4443 int i
,num_extra_attrs
;
4444 struct dwarf2_section_info
*dwo_abbrev_section
;
4445 struct attribute
*attr
;
4446 struct die_info
*comp_unit_die
;
4448 /* These attributes aren't processed until later:
4449 DW_AT_stmt_list, DW_AT_low_pc, DW_AT_high_pc, DW_AT_ranges.
4450 However, the attribute is found in the stub which we won't have later.
4451 In order to not impose this complication on the rest of the code,
4452 we read them here and copy them to the DWO CU/TU die. */
4460 if (stub_comp_unit_die
!= NULL
)
4462 /* For TUs in DWO files, the DW_AT_stmt_list attribute lives in the
4464 if (! this_cu
->is_debug_types
)
4465 stmt_list
= dwarf2_attr (stub_comp_unit_die
, DW_AT_stmt_list
, cu
);
4466 low_pc
= dwarf2_attr (stub_comp_unit_die
, DW_AT_low_pc
, cu
);
4467 high_pc
= dwarf2_attr (stub_comp_unit_die
, DW_AT_high_pc
, cu
);
4468 ranges
= dwarf2_attr (stub_comp_unit_die
, DW_AT_ranges
, cu
);
4469 comp_dir
= dwarf2_attr (stub_comp_unit_die
, DW_AT_comp_dir
, cu
);
4471 /* There should be a DW_AT_addr_base attribute here (if needed).
4472 We need the value before we can process DW_FORM_GNU_addr_index. */
4474 attr
= dwarf2_attr (stub_comp_unit_die
, DW_AT_GNU_addr_base
, cu
);
4476 cu
->addr_base
= DW_UNSND (attr
);
4478 /* There should be a DW_AT_ranges_base attribute here (if needed).
4479 We need the value before we can process DW_AT_ranges. */
4480 cu
->ranges_base
= 0;
4481 attr
= dwarf2_attr (stub_comp_unit_die
, DW_AT_GNU_ranges_base
, cu
);
4483 cu
->ranges_base
= DW_UNSND (attr
);
4486 /* Set up for reading the DWO CU/TU. */
4487 cu
->dwo_unit
= dwo_unit
;
4488 section
= dwo_unit
->section
;
4489 dwarf2_read_section (objfile
, section
);
4490 abfd
= section
->asection
->owner
;
4491 begin_info_ptr
= info_ptr
= section
->buffer
+ dwo_unit
->offset
.sect_off
;
4492 dwo_abbrev_section
= &dwo_unit
->dwo_file
->sections
.abbrev
;
4493 init_cu_die_reader (result_reader
, cu
, section
, dwo_unit
->dwo_file
);
4495 if (this_cu
->is_debug_types
)
4497 ULONGEST header_signature
;
4498 cu_offset type_offset_in_tu
;
4499 struct signatured_type
*sig_type
= (struct signatured_type
*) this_cu
;
4501 info_ptr
= read_and_check_type_unit_head (&cu
->header
, section
,
4505 &type_offset_in_tu
);
4506 gdb_assert (sig_type
->signature
== header_signature
);
4507 gdb_assert (dwo_unit
->offset
.sect_off
== cu
->header
.offset
.sect_off
);
4508 /* For DWOs coming from DWP files, we don't know the CU length
4509 nor the type's offset in the TU until now. */
4510 dwo_unit
->length
= get_cu_length (&cu
->header
);
4511 dwo_unit
->type_offset_in_tu
= type_offset_in_tu
;
4513 /* Establish the type offset that can be used to lookup the type.
4514 For DWO files, we don't know it until now. */
4515 sig_type
->type_offset_in_section
.sect_off
=
4516 dwo_unit
->offset
.sect_off
+ dwo_unit
->type_offset_in_tu
.cu_off
;
4520 info_ptr
= read_and_check_comp_unit_head (&cu
->header
, section
,
4523 gdb_assert (dwo_unit
->offset
.sect_off
== cu
->header
.offset
.sect_off
);
4524 /* For DWOs coming from DWP files, we don't know the CU length
4526 dwo_unit
->length
= get_cu_length (&cu
->header
);
4529 /* Replace the CU's original abbrev table with the DWO's.
4530 Reminder: We can't read the abbrev table until we've read the header. */
4531 if (abbrev_table_provided
)
4533 /* Don't free the provided abbrev table, the caller of
4534 init_cutu_and_read_dies owns it. */
4535 dwarf2_read_abbrevs (cu
, dwo_abbrev_section
);
4536 /* Ensure the DWO abbrev table gets freed. */
4537 make_cleanup (dwarf2_free_abbrev_table
, cu
);
4541 dwarf2_free_abbrev_table (cu
);
4542 dwarf2_read_abbrevs (cu
, dwo_abbrev_section
);
4543 /* Leave any existing abbrev table cleanup as is. */
4546 /* Read in the die, but leave space to copy over the attributes
4547 from the stub. This has the benefit of simplifying the rest of
4548 the code - all the work to maintain the illusion of a single
4549 DW_TAG_{compile,type}_unit DIE is done here. */
4550 num_extra_attrs
= ((stmt_list
!= NULL
)
4554 + (comp_dir
!= NULL
));
4555 info_ptr
= read_full_die_1 (result_reader
, result_comp_unit_die
, info_ptr
,
4556 result_has_children
, num_extra_attrs
);
4558 /* Copy over the attributes from the stub to the DIE we just read in. */
4559 comp_unit_die
= *result_comp_unit_die
;
4560 i
= comp_unit_die
->num_attrs
;
4561 if (stmt_list
!= NULL
)
4562 comp_unit_die
->attrs
[i
++] = *stmt_list
;
4564 comp_unit_die
->attrs
[i
++] = *low_pc
;
4565 if (high_pc
!= NULL
)
4566 comp_unit_die
->attrs
[i
++] = *high_pc
;
4568 comp_unit_die
->attrs
[i
++] = *ranges
;
4569 if (comp_dir
!= NULL
)
4570 comp_unit_die
->attrs
[i
++] = *comp_dir
;
4571 comp_unit_die
->num_attrs
+= num_extra_attrs
;
4573 if (dwarf2_die_debug
)
4575 fprintf_unfiltered (gdb_stdlog
,
4576 "Read die from %s@0x%x of %s:\n",
4577 bfd_section_name (abfd
, section
->asection
),
4578 (unsigned) (begin_info_ptr
- section
->buffer
),
4579 bfd_get_filename (abfd
));
4580 dump_die (comp_unit_die
, dwarf2_die_debug
);
4583 /* Skip dummy compilation units. */
4584 if (info_ptr
>= begin_info_ptr
+ dwo_unit
->length
4585 || peek_abbrev_code (abfd
, info_ptr
) == 0)
4588 *result_info_ptr
= info_ptr
;
4592 /* Subroutine of init_cutu_and_read_dies to simplify it.
4593 Look up the DWO unit specified by COMP_UNIT_DIE of THIS_CU.
4594 If the specified DWO unit cannot be found an error is thrown. */
4596 static struct dwo_unit
*
4597 lookup_dwo_unit (struct dwarf2_per_cu_data
*this_cu
,
4598 struct die_info
*comp_unit_die
)
4600 struct dwarf2_cu
*cu
= this_cu
->cu
;
4601 struct attribute
*attr
;
4603 struct dwo_unit
*dwo_unit
;
4604 const char *comp_dir
, *dwo_name
;
4606 /* Yeah, we look dwo_name up again, but it simplifies the code. */
4607 attr
= dwarf2_attr (comp_unit_die
, DW_AT_GNU_dwo_name
, cu
);
4608 gdb_assert (attr
!= NULL
);
4609 dwo_name
= DW_STRING (attr
);
4611 attr
= dwarf2_attr (comp_unit_die
, DW_AT_comp_dir
, cu
);
4613 comp_dir
= DW_STRING (attr
);
4615 if (this_cu
->is_debug_types
)
4617 struct signatured_type
*sig_type
;
4619 /* Since this_cu is the first member of struct signatured_type,
4620 we can go from a pointer to one to a pointer to the other. */
4621 sig_type
= (struct signatured_type
*) this_cu
;
4622 signature
= sig_type
->signature
;
4623 dwo_unit
= lookup_dwo_type_unit (sig_type
, dwo_name
, comp_dir
);
4627 struct attribute
*attr
;
4629 attr
= dwarf2_attr (comp_unit_die
, DW_AT_GNU_dwo_id
, cu
);
4631 error (_("Dwarf Error: missing dwo_id for dwo_name %s"
4633 dwo_name
, this_cu
->objfile
->name
);
4634 signature
= DW_UNSND (attr
);
4635 dwo_unit
= lookup_dwo_comp_unit (this_cu
, dwo_name
, comp_dir
,
4639 if (dwo_unit
== NULL
)
4641 error (_("Dwarf Error: CU at offset 0x%x references unknown DWO"
4642 " with ID %s [in module %s]"),
4643 this_cu
->offset
.sect_off
,
4644 phex (signature
, sizeof (signature
)),
4645 this_cu
->objfile
->name
);
4651 /* Initialize a CU (or TU) and read its DIEs.
4652 If the CU defers to a DWO file, read the DWO file as well.
4654 ABBREV_TABLE, if non-NULL, is the abbreviation table to use.
4655 Otherwise the table specified in the comp unit header is read in and used.
4656 This is an optimization for when we already have the abbrev table.
4658 If USE_EXISTING_CU is non-zero, and THIS_CU->cu is non-NULL, then use it.
4659 Otherwise, a new CU is allocated with xmalloc.
4661 If KEEP is non-zero, then if we allocated a dwarf2_cu we add it to
4662 read_in_chain. Otherwise the dwarf2_cu data is freed at the end.
4664 WARNING: If THIS_CU is a "dummy CU" (used as filler by the incremental
4665 linker) then DIE_READER_FUNC will not get called. */
4668 init_cutu_and_read_dies (struct dwarf2_per_cu_data
*this_cu
,
4669 struct abbrev_table
*abbrev_table
,
4670 int use_existing_cu
, int keep
,
4671 die_reader_func_ftype
*die_reader_func
,
4674 struct objfile
*objfile
= dwarf2_per_objfile
->objfile
;
4675 struct dwarf2_section_info
*section
= this_cu
->section
;
4676 bfd
*abfd
= section
->asection
->owner
;
4677 struct dwarf2_cu
*cu
;
4678 gdb_byte
*begin_info_ptr
, *info_ptr
;
4679 struct die_reader_specs reader
;
4680 struct die_info
*comp_unit_die
;
4682 struct attribute
*attr
;
4683 struct cleanup
*cleanups
, *free_cu_cleanup
= NULL
;
4684 struct signatured_type
*sig_type
= NULL
;
4685 struct dwarf2_section_info
*abbrev_section
;
4686 /* Non-zero if CU currently points to a DWO file and we need to
4687 reread it. When this happens we need to reread the skeleton die
4688 before we can reread the DWO file. */
4689 int rereading_dwo_cu
= 0;
4691 if (dwarf2_die_debug
)
4692 fprintf_unfiltered (gdb_stdlog
, "Reading %s unit at offset 0x%x\n",
4693 this_cu
->is_debug_types
? "type" : "comp",
4694 this_cu
->offset
.sect_off
);
4696 if (use_existing_cu
)
4699 cleanups
= make_cleanup (null_cleanup
, NULL
);
4701 /* This is cheap if the section is already read in. */
4702 dwarf2_read_section (objfile
, section
);
4704 begin_info_ptr
= info_ptr
= section
->buffer
+ this_cu
->offset
.sect_off
;
4706 abbrev_section
= get_abbrev_section_for_cu (this_cu
);
4708 if (use_existing_cu
&& this_cu
->cu
!= NULL
)
4712 /* If this CU is from a DWO file we need to start over, we need to
4713 refetch the attributes from the skeleton CU.
4714 This could be optimized by retrieving those attributes from when we
4715 were here the first time: the previous comp_unit_die was stored in
4716 comp_unit_obstack. But there's no data yet that we need this
4718 if (cu
->dwo_unit
!= NULL
)
4719 rereading_dwo_cu
= 1;
4723 /* If !use_existing_cu, this_cu->cu must be NULL. */
4724 gdb_assert (this_cu
->cu
== NULL
);
4726 cu
= xmalloc (sizeof (*cu
));
4727 init_one_comp_unit (cu
, this_cu
);
4729 /* If an error occurs while loading, release our storage. */
4730 free_cu_cleanup
= make_cleanup (free_heap_comp_unit
, cu
);
4733 /* Get the header. */
4734 if (cu
->header
.first_die_offset
.cu_off
!= 0 && ! rereading_dwo_cu
)
4736 /* We already have the header, there's no need to read it in again. */
4737 info_ptr
+= cu
->header
.first_die_offset
.cu_off
;
4741 if (this_cu
->is_debug_types
)
4744 cu_offset type_offset_in_tu
;
4746 info_ptr
= read_and_check_type_unit_head (&cu
->header
, section
,
4747 abbrev_section
, info_ptr
,
4749 &type_offset_in_tu
);
4751 /* Since per_cu is the first member of struct signatured_type,
4752 we can go from a pointer to one to a pointer to the other. */
4753 sig_type
= (struct signatured_type
*) this_cu
;
4754 gdb_assert (sig_type
->signature
== signature
);
4755 gdb_assert (sig_type
->type_offset_in_tu
.cu_off
4756 == type_offset_in_tu
.cu_off
);
4757 gdb_assert (this_cu
->offset
.sect_off
== cu
->header
.offset
.sect_off
);
4759 /* LENGTH has not been set yet for type units if we're
4760 using .gdb_index. */
4761 this_cu
->length
= get_cu_length (&cu
->header
);
4763 /* Establish the type offset that can be used to lookup the type. */
4764 sig_type
->type_offset_in_section
.sect_off
=
4765 this_cu
->offset
.sect_off
+ sig_type
->type_offset_in_tu
.cu_off
;
4769 info_ptr
= read_and_check_comp_unit_head (&cu
->header
, section
,
4773 gdb_assert (this_cu
->offset
.sect_off
== cu
->header
.offset
.sect_off
);
4774 gdb_assert (this_cu
->length
== get_cu_length (&cu
->header
));
4778 /* Skip dummy compilation units. */
4779 if (info_ptr
>= begin_info_ptr
+ this_cu
->length
4780 || peek_abbrev_code (abfd
, info_ptr
) == 0)
4782 do_cleanups (cleanups
);
4786 /* If we don't have them yet, read the abbrevs for this compilation unit.
4787 And if we need to read them now, make sure they're freed when we're
4788 done. Note that it's important that if the CU had an abbrev table
4789 on entry we don't free it when we're done: Somewhere up the call stack
4790 it may be in use. */
4791 if (abbrev_table
!= NULL
)
4793 gdb_assert (cu
->abbrev_table
== NULL
);
4794 gdb_assert (cu
->header
.abbrev_offset
.sect_off
4795 == abbrev_table
->offset
.sect_off
);
4796 cu
->abbrev_table
= abbrev_table
;
4798 else if (cu
->abbrev_table
== NULL
)
4800 dwarf2_read_abbrevs (cu
, abbrev_section
);
4801 make_cleanup (dwarf2_free_abbrev_table
, cu
);
4803 else if (rereading_dwo_cu
)
4805 dwarf2_free_abbrev_table (cu
);
4806 dwarf2_read_abbrevs (cu
, abbrev_section
);
4809 /* Read the top level CU/TU die. */
4810 init_cu_die_reader (&reader
, cu
, section
, NULL
);
4811 info_ptr
= read_full_die (&reader
, &comp_unit_die
, info_ptr
, &has_children
);
4813 /* If we are in a DWO stub, process it and then read in the "real" CU/TU
4815 Note that if USE_EXISTING_OK != 0, and THIS_CU->cu already contains a
4816 DWO CU, that this test will fail (the attribute will not be present). */
4817 attr
= dwarf2_attr (comp_unit_die
, DW_AT_GNU_dwo_name
, cu
);
4820 struct dwo_unit
*dwo_unit
;
4821 struct die_info
*dwo_comp_unit_die
;
4824 error (_("Dwarf Error: compilation unit with DW_AT_GNU_dwo_name"
4825 " has children (offset 0x%x) [in module %s]"),
4826 this_cu
->offset
.sect_off
, bfd_get_filename (abfd
));
4827 dwo_unit
= lookup_dwo_unit (this_cu
, comp_unit_die
);
4828 if (read_cutu_die_from_dwo (this_cu
, dwo_unit
,
4829 abbrev_table
!= NULL
,
4832 &dwo_comp_unit_die
, &has_children
) == 0)
4835 do_cleanups (cleanups
);
4838 comp_unit_die
= dwo_comp_unit_die
;
4841 /* All of the above is setup for this call. Yikes. */
4842 die_reader_func (&reader
, info_ptr
, comp_unit_die
, has_children
, data
);
4844 /* Done, clean up. */
4845 if (free_cu_cleanup
!= NULL
)
4849 /* We've successfully allocated this compilation unit. Let our
4850 caller clean it up when finished with it. */
4851 discard_cleanups (free_cu_cleanup
);
4853 /* We can only discard free_cu_cleanup and all subsequent cleanups.
4854 So we have to manually free the abbrev table. */
4855 dwarf2_free_abbrev_table (cu
);
4857 /* Link this CU into read_in_chain. */
4858 this_cu
->cu
->read_in_chain
= dwarf2_per_objfile
->read_in_chain
;
4859 dwarf2_per_objfile
->read_in_chain
= this_cu
;
4862 do_cleanups (free_cu_cleanup
);
4865 do_cleanups (cleanups
);
4868 /* Read CU/TU THIS_CU in section SECTION,
4869 but do not follow DW_AT_GNU_dwo_name if present.
4870 DWOP_FILE, if non-NULL, is the DWO/DWP file to read (the caller is assumed
4871 to have already done the lookup to find the DWO/DWP file).
4873 The caller is required to fill in THIS_CU->section, THIS_CU->offset, and
4874 THIS_CU->is_debug_types, but nothing else.
4876 We fill in THIS_CU->length.
4878 WARNING: If THIS_CU is a "dummy CU" (used as filler by the incremental
4879 linker) then DIE_READER_FUNC will not get called.
4881 THIS_CU->cu is always freed when done.
4882 This is done in order to not leave THIS_CU->cu in a state where we have
4883 to care whether it refers to the "main" CU or the DWO CU. */
4886 init_cutu_and_read_dies_no_follow (struct dwarf2_per_cu_data
*this_cu
,
4887 struct dwarf2_section_info
*abbrev_section
,
4888 struct dwo_file
*dwo_file
,
4889 die_reader_func_ftype
*die_reader_func
,
4892 struct objfile
*objfile
= dwarf2_per_objfile
->objfile
;
4893 struct dwarf2_section_info
*section
= this_cu
->section
;
4894 bfd
*abfd
= section
->asection
->owner
;
4895 struct dwarf2_cu cu
;
4896 gdb_byte
*begin_info_ptr
, *info_ptr
;
4897 struct die_reader_specs reader
;
4898 struct cleanup
*cleanups
;
4899 struct die_info
*comp_unit_die
;
4902 if (dwarf2_die_debug
)
4903 fprintf_unfiltered (gdb_stdlog
, "Reading %s unit at offset 0x%x\n",
4904 this_cu
->is_debug_types
? "type" : "comp",
4905 this_cu
->offset
.sect_off
);
4907 gdb_assert (this_cu
->cu
== NULL
);
4909 /* This is cheap if the section is already read in. */
4910 dwarf2_read_section (objfile
, section
);
4912 init_one_comp_unit (&cu
, this_cu
);
4914 cleanups
= make_cleanup (free_stack_comp_unit
, &cu
);
4916 begin_info_ptr
= info_ptr
= section
->buffer
+ this_cu
->offset
.sect_off
;
4917 info_ptr
= read_and_check_comp_unit_head (&cu
.header
, section
,
4918 abbrev_section
, info_ptr
,
4919 this_cu
->is_debug_types
);
4921 this_cu
->length
= get_cu_length (&cu
.header
);
4923 /* Skip dummy compilation units. */
4924 if (info_ptr
>= begin_info_ptr
+ this_cu
->length
4925 || peek_abbrev_code (abfd
, info_ptr
) == 0)
4927 do_cleanups (cleanups
);
4931 dwarf2_read_abbrevs (&cu
, abbrev_section
);
4932 make_cleanup (dwarf2_free_abbrev_table
, &cu
);
4934 init_cu_die_reader (&reader
, &cu
, section
, dwo_file
);
4935 info_ptr
= read_full_die (&reader
, &comp_unit_die
, info_ptr
, &has_children
);
4937 die_reader_func (&reader
, info_ptr
, comp_unit_die
, has_children
, data
);
4939 do_cleanups (cleanups
);
4942 /* Read a CU/TU, except that this does not look for DW_AT_GNU_dwo_name and
4943 does not lookup the specified DWO file.
4944 This cannot be used to read DWO files.
4946 THIS_CU->cu is always freed when done.
4947 This is done in order to not leave THIS_CU->cu in a state where we have
4948 to care whether it refers to the "main" CU or the DWO CU.
4949 We can revisit this if the data shows there's a performance issue. */
4952 init_cutu_and_read_dies_simple (struct dwarf2_per_cu_data
*this_cu
,
4953 die_reader_func_ftype
*die_reader_func
,
4956 init_cutu_and_read_dies_no_follow (this_cu
,
4957 get_abbrev_section_for_cu (this_cu
),
4959 die_reader_func
, data
);
4962 /* Type Unit Groups.
4964 Type Unit Groups are a way to collapse the set of all TUs (type units) into
4965 a more manageable set. The grouping is done by DW_AT_stmt_list entry
4966 so that all types coming from the same compilation (.o file) are grouped
4967 together. A future step could be to put the types in the same symtab as
4968 the CU the types ultimately came from. */
4971 hash_type_unit_group (const void *item
)
4973 const struct type_unit_group
*tu_group
= item
;
4975 return hash_stmt_list_entry (&tu_group
->hash
);
4979 eq_type_unit_group (const void *item_lhs
, const void *item_rhs
)
4981 const struct type_unit_group
*lhs
= item_lhs
;
4982 const struct type_unit_group
*rhs
= item_rhs
;
4984 return eq_stmt_list_entry (&lhs
->hash
, &rhs
->hash
);
4987 /* Allocate a hash table for type unit groups. */
4990 allocate_type_unit_groups_table (void)
4992 return htab_create_alloc_ex (3,
4993 hash_type_unit_group
,
4996 &dwarf2_per_objfile
->objfile
->objfile_obstack
,
4997 hashtab_obstack_allocate
,
4998 dummy_obstack_deallocate
);
5001 /* Type units that don't have DW_AT_stmt_list are grouped into their own
5002 partial symtabs. We combine several TUs per psymtab to not let the size
5003 of any one psymtab grow too big. */
5004 #define NO_STMT_LIST_TYPE_UNIT_PSYMTAB (1 << 31)
5005 #define NO_STMT_LIST_TYPE_UNIT_PSYMTAB_SIZE 10
5007 /* Helper routine for get_type_unit_group.
5008 Create the type_unit_group object used to hold one or more TUs. */
5010 static struct type_unit_group
*
5011 create_type_unit_group (struct dwarf2_cu
*cu
, sect_offset line_offset_struct
)
5013 struct objfile
*objfile
= dwarf2_per_objfile
->objfile
;
5014 struct dwarf2_per_cu_data
*per_cu
;
5015 struct type_unit_group
*tu_group
;
5017 tu_group
= OBSTACK_ZALLOC (&objfile
->objfile_obstack
,
5018 struct type_unit_group
);
5019 per_cu
= &tu_group
->per_cu
;
5020 per_cu
->objfile
= objfile
;
5022 if (dwarf2_per_objfile
->using_index
)
5024 per_cu
->v
.quick
= OBSTACK_ZALLOC (&objfile
->objfile_obstack
,
5025 struct dwarf2_per_cu_quick_data
);
5029 unsigned int line_offset
= line_offset_struct
.sect_off
;
5030 struct partial_symtab
*pst
;
5033 /* Give the symtab a useful name for debug purposes. */
5034 if ((line_offset
& NO_STMT_LIST_TYPE_UNIT_PSYMTAB
) != 0)
5035 name
= xstrprintf ("<type_units_%d>",
5036 (line_offset
& ~NO_STMT_LIST_TYPE_UNIT_PSYMTAB
));
5038 name
= xstrprintf ("<type_units_at_0x%x>", line_offset
);
5040 pst
= create_partial_symtab (per_cu
, name
);
5046 tu_group
->hash
.dwo_unit
= cu
->dwo_unit
;
5047 tu_group
->hash
.line_offset
= line_offset_struct
;
5052 /* Look up the type_unit_group for type unit CU, and create it if necessary.
5053 STMT_LIST is a DW_AT_stmt_list attribute. */
5055 static struct type_unit_group
*
5056 get_type_unit_group (struct dwarf2_cu
*cu
, struct attribute
*stmt_list
)
5058 struct tu_stats
*tu_stats
= &dwarf2_per_objfile
->tu_stats
;
5059 struct type_unit_group
*tu_group
;
5061 unsigned int line_offset
;
5062 struct type_unit_group type_unit_group_for_lookup
;
5064 if (dwarf2_per_objfile
->type_unit_groups
== NULL
)
5066 dwarf2_per_objfile
->type_unit_groups
=
5067 allocate_type_unit_groups_table ();
5070 /* Do we need to create a new group, or can we use an existing one? */
5074 line_offset
= DW_UNSND (stmt_list
);
5075 ++tu_stats
->nr_symtab_sharers
;
5079 /* Ugh, no stmt_list. Rare, but we have to handle it.
5080 We can do various things here like create one group per TU or
5081 spread them over multiple groups to split up the expansion work.
5082 To avoid worst case scenarios (too many groups or too large groups)
5083 we, umm, group them in bunches. */
5084 line_offset
= (NO_STMT_LIST_TYPE_UNIT_PSYMTAB
5085 | (tu_stats
->nr_stmt_less_type_units
5086 / NO_STMT_LIST_TYPE_UNIT_PSYMTAB_SIZE
));
5087 ++tu_stats
->nr_stmt_less_type_units
;
5090 type_unit_group_for_lookup
.hash
.dwo_unit
= cu
->dwo_unit
;
5091 type_unit_group_for_lookup
.hash
.line_offset
.sect_off
= line_offset
;
5092 slot
= htab_find_slot (dwarf2_per_objfile
->type_unit_groups
,
5093 &type_unit_group_for_lookup
, INSERT
);
5097 gdb_assert (tu_group
!= NULL
);
5101 sect_offset line_offset_struct
;
5103 line_offset_struct
.sect_off
= line_offset
;
5104 tu_group
= create_type_unit_group (cu
, line_offset_struct
);
5106 ++tu_stats
->nr_symtabs
;
5112 /* Struct used to sort TUs by their abbreviation table offset. */
5114 struct tu_abbrev_offset
5116 struct signatured_type
*sig_type
;
5117 sect_offset abbrev_offset
;
5120 /* Helper routine for build_type_unit_groups, passed to qsort. */
5123 sort_tu_by_abbrev_offset (const void *ap
, const void *bp
)
5125 const struct tu_abbrev_offset
* const *a
= ap
;
5126 const struct tu_abbrev_offset
* const *b
= bp
;
5127 unsigned int aoff
= (*a
)->abbrev_offset
.sect_off
;
5128 unsigned int boff
= (*b
)->abbrev_offset
.sect_off
;
5130 return (aoff
> boff
) - (aoff
< boff
);
5133 /* A helper function to add a type_unit_group to a table. */
5136 add_type_unit_group_to_table (void **slot
, void *datum
)
5138 struct type_unit_group
*tu_group
= *slot
;
5139 struct type_unit_group
***datap
= datum
;
5147 /* Efficiently read all the type units, calling init_cutu_and_read_dies on
5148 each one passing FUNC,DATA.
5150 The efficiency is because we sort TUs by the abbrev table they use and
5151 only read each abbrev table once. In one program there are 200K TUs
5152 sharing 8K abbrev tables.
5154 The main purpose of this function is to support building the
5155 dwarf2_per_objfile->type_unit_groups table.
5156 TUs typically share the DW_AT_stmt_list of the CU they came from, so we
5157 can collapse the search space by grouping them by stmt_list.
5158 The savings can be significant, in the same program from above the 200K TUs
5159 share 8K stmt_list tables.
5161 FUNC is expected to call get_type_unit_group, which will create the
5162 struct type_unit_group if necessary and add it to
5163 dwarf2_per_objfile->type_unit_groups. */
5166 build_type_unit_groups (die_reader_func_ftype
*func
, void *data
)
5168 struct objfile
*objfile
= dwarf2_per_objfile
->objfile
;
5169 struct tu_stats
*tu_stats
= &dwarf2_per_objfile
->tu_stats
;
5170 struct cleanup
*cleanups
;
5171 struct abbrev_table
*abbrev_table
;
5172 sect_offset abbrev_offset
;
5173 struct tu_abbrev_offset
*sorted_by_abbrev
;
5174 struct type_unit_group
**iter
;
5177 /* It's up to the caller to not call us multiple times. */
5178 gdb_assert (dwarf2_per_objfile
->type_unit_groups
== NULL
);
5180 if (dwarf2_per_objfile
->n_type_units
== 0)
5183 /* TUs typically share abbrev tables, and there can be way more TUs than
5184 abbrev tables. Sort by abbrev table to reduce the number of times we
5185 read each abbrev table in.
5186 Alternatives are to punt or to maintain a cache of abbrev tables.
5187 This is simpler and efficient enough for now.
5189 Later we group TUs by their DW_AT_stmt_list value (as this defines the
5190 symtab to use). Typically TUs with the same abbrev offset have the same
5191 stmt_list value too so in practice this should work well.
5193 The basic algorithm here is:
5195 sort TUs by abbrev table
5196 for each TU with same abbrev table:
5197 read abbrev table if first user
5198 read TU top level DIE
5199 [IWBN if DWO skeletons had DW_AT_stmt_list]
5202 if (dwarf2_read_debug
)
5203 fprintf_unfiltered (gdb_stdlog
, "Building type unit groups ...\n");
5205 /* Sort in a separate table to maintain the order of all_type_units
5206 for .gdb_index: TU indices directly index all_type_units. */
5207 sorted_by_abbrev
= XNEWVEC (struct tu_abbrev_offset
,
5208 dwarf2_per_objfile
->n_type_units
);
5209 for (i
= 0; i
< dwarf2_per_objfile
->n_type_units
; ++i
)
5211 struct signatured_type
*sig_type
= dwarf2_per_objfile
->all_type_units
[i
];
5213 sorted_by_abbrev
[i
].sig_type
= sig_type
;
5214 sorted_by_abbrev
[i
].abbrev_offset
=
5215 read_abbrev_offset (sig_type
->per_cu
.section
,
5216 sig_type
->per_cu
.offset
);
5218 cleanups
= make_cleanup (xfree
, sorted_by_abbrev
);
5219 qsort (sorted_by_abbrev
, dwarf2_per_objfile
->n_type_units
,
5220 sizeof (struct tu_abbrev_offset
), sort_tu_by_abbrev_offset
);
5222 /* Note: In the .gdb_index case, get_type_unit_group may have already been
5223 called any number of times, so we don't reset tu_stats here. */
5225 abbrev_offset
.sect_off
= ~(unsigned) 0;
5226 abbrev_table
= NULL
;
5227 make_cleanup (abbrev_table_free_cleanup
, &abbrev_table
);
5229 for (i
= 0; i
< dwarf2_per_objfile
->n_type_units
; ++i
)
5231 const struct tu_abbrev_offset
*tu
= &sorted_by_abbrev
[i
];
5233 /* Switch to the next abbrev table if necessary. */
5234 if (abbrev_table
== NULL
5235 || tu
->abbrev_offset
.sect_off
!= abbrev_offset
.sect_off
)
5237 if (abbrev_table
!= NULL
)
5239 abbrev_table_free (abbrev_table
);
5240 /* Reset to NULL in case abbrev_table_read_table throws
5241 an error: abbrev_table_free_cleanup will get called. */
5242 abbrev_table
= NULL
;
5244 abbrev_offset
= tu
->abbrev_offset
;
5246 abbrev_table_read_table (&dwarf2_per_objfile
->abbrev
,
5248 ++tu_stats
->nr_uniq_abbrev_tables
;
5251 init_cutu_and_read_dies (&tu
->sig_type
->per_cu
, abbrev_table
, 0, 0,
5255 /* Create a vector of pointers to primary type units to make it easy to
5256 iterate over them and CUs. See dw2_get_primary_cu. */
5257 dwarf2_per_objfile
->n_type_unit_groups
=
5258 htab_elements (dwarf2_per_objfile
->type_unit_groups
);
5259 dwarf2_per_objfile
->all_type_unit_groups
=
5260 obstack_alloc (&objfile
->objfile_obstack
,
5261 dwarf2_per_objfile
->n_type_unit_groups
5262 * sizeof (struct type_unit_group
*));
5263 iter
= &dwarf2_per_objfile
->all_type_unit_groups
[0];
5264 htab_traverse_noresize (dwarf2_per_objfile
->type_unit_groups
,
5265 add_type_unit_group_to_table
, &iter
);
5266 gdb_assert (iter
- &dwarf2_per_objfile
->all_type_unit_groups
[0]
5267 == dwarf2_per_objfile
->n_type_unit_groups
);
5269 do_cleanups (cleanups
);
5271 if (dwarf2_read_debug
)
5273 fprintf_unfiltered (gdb_stdlog
, "Done building type unit groups:\n");
5274 fprintf_unfiltered (gdb_stdlog
, " %d TUs\n",
5275 dwarf2_per_objfile
->n_type_units
);
5276 fprintf_unfiltered (gdb_stdlog
, " %d uniq abbrev tables\n",
5277 tu_stats
->nr_uniq_abbrev_tables
);
5278 fprintf_unfiltered (gdb_stdlog
, " %d symtabs from stmt_list entries\n",
5279 tu_stats
->nr_symtabs
);
5280 fprintf_unfiltered (gdb_stdlog
, " %d symtab sharers\n",
5281 tu_stats
->nr_symtab_sharers
);
5282 fprintf_unfiltered (gdb_stdlog
, " %d type units without a stmt_list\n",
5283 tu_stats
->nr_stmt_less_type_units
);
5287 /* Partial symbol tables. */
5289 /* Create a psymtab named NAME and assign it to PER_CU.
5291 The caller must fill in the following details:
5292 dirname, textlow, texthigh. */
5294 static struct partial_symtab
*
5295 create_partial_symtab (struct dwarf2_per_cu_data
*per_cu
, const char *name
)
5297 struct objfile
*objfile
= per_cu
->objfile
;
5298 struct partial_symtab
*pst
;
5300 pst
= start_psymtab_common (objfile
, objfile
->section_offsets
,
5302 objfile
->global_psymbols
.next
,
5303 objfile
->static_psymbols
.next
);
5305 pst
->psymtabs_addrmap_supported
= 1;
5307 /* This is the glue that links PST into GDB's symbol API. */
5308 pst
->read_symtab_private
= per_cu
;
5309 pst
->read_symtab
= dwarf2_read_symtab
;
5310 per_cu
->v
.psymtab
= pst
;
5315 /* die_reader_func for process_psymtab_comp_unit. */
5318 process_psymtab_comp_unit_reader (const struct die_reader_specs
*reader
,
5320 struct die_info
*comp_unit_die
,
5324 struct dwarf2_cu
*cu
= reader
->cu
;
5325 struct objfile
*objfile
= cu
->objfile
;
5326 struct dwarf2_per_cu_data
*per_cu
= cu
->per_cu
;
5327 struct attribute
*attr
;
5329 CORE_ADDR best_lowpc
= 0, best_highpc
= 0;
5330 struct partial_symtab
*pst
;
5332 const char *filename
;
5333 int *want_partial_unit_ptr
= data
;
5335 if (comp_unit_die
->tag
== DW_TAG_partial_unit
5336 && (want_partial_unit_ptr
== NULL
5337 || !*want_partial_unit_ptr
))
5340 gdb_assert (! per_cu
->is_debug_types
);
5342 prepare_one_comp_unit (cu
, comp_unit_die
, language_minimal
);
5344 cu
->list_in_scope
= &file_symbols
;
5346 /* Allocate a new partial symbol table structure. */
5347 attr
= dwarf2_attr (comp_unit_die
, DW_AT_name
, cu
);
5348 if (attr
== NULL
|| !DW_STRING (attr
))
5351 filename
= DW_STRING (attr
);
5353 pst
= create_partial_symtab (per_cu
, filename
);
5355 /* This must be done before calling dwarf2_build_include_psymtabs. */
5356 attr
= dwarf2_attr (comp_unit_die
, DW_AT_comp_dir
, cu
);
5358 pst
->dirname
= DW_STRING (attr
);
5360 baseaddr
= ANOFFSET (objfile
->section_offsets
, SECT_OFF_TEXT (objfile
));
5362 dwarf2_find_base_address (comp_unit_die
, cu
);
5364 /* Possibly set the default values of LOWPC and HIGHPC from
5366 has_pc_info
= dwarf2_get_pc_bounds (comp_unit_die
, &best_lowpc
,
5367 &best_highpc
, cu
, pst
);
5368 if (has_pc_info
== 1 && best_lowpc
< best_highpc
)
5369 /* Store the contiguous range if it is not empty; it can be empty for
5370 CUs with no code. */
5371 addrmap_set_empty (objfile
->psymtabs_addrmap
,
5372 best_lowpc
+ baseaddr
,
5373 best_highpc
+ baseaddr
- 1, pst
);
5375 /* Check if comp unit has_children.
5376 If so, read the rest of the partial symbols from this comp unit.
5377 If not, there's no more debug_info for this comp unit. */
5380 struct partial_die_info
*first_die
;
5381 CORE_ADDR lowpc
, highpc
;
5383 lowpc
= ((CORE_ADDR
) -1);
5384 highpc
= ((CORE_ADDR
) 0);
5386 first_die
= load_partial_dies (reader
, info_ptr
, 1);
5388 scan_partial_symbols (first_die
, &lowpc
, &highpc
,
5391 /* If we didn't find a lowpc, set it to highpc to avoid
5392 complaints from `maint check'. */
5393 if (lowpc
== ((CORE_ADDR
) -1))
5396 /* If the compilation unit didn't have an explicit address range,
5397 then use the information extracted from its child dies. */
5401 best_highpc
= highpc
;
5404 pst
->textlow
= best_lowpc
+ baseaddr
;
5405 pst
->texthigh
= best_highpc
+ baseaddr
;
5407 pst
->n_global_syms
= objfile
->global_psymbols
.next
-
5408 (objfile
->global_psymbols
.list
+ pst
->globals_offset
);
5409 pst
->n_static_syms
= objfile
->static_psymbols
.next
-
5410 (objfile
->static_psymbols
.list
+ pst
->statics_offset
);
5411 sort_pst_symbols (objfile
, pst
);
5413 if (!VEC_empty (dwarf2_per_cu_ptr
, cu
->per_cu
->imported_symtabs
))
5416 int len
= VEC_length (dwarf2_per_cu_ptr
, cu
->per_cu
->imported_symtabs
);
5417 struct dwarf2_per_cu_data
*iter
;
5419 /* Fill in 'dependencies' here; we fill in 'users' in a
5421 pst
->number_of_dependencies
= len
;
5422 pst
->dependencies
= obstack_alloc (&objfile
->objfile_obstack
,
5423 len
* sizeof (struct symtab
*));
5425 VEC_iterate (dwarf2_per_cu_ptr
, cu
->per_cu
->imported_symtabs
,
5428 pst
->dependencies
[i
] = iter
->v
.psymtab
;
5430 VEC_free (dwarf2_per_cu_ptr
, cu
->per_cu
->imported_symtabs
);
5433 /* Get the list of files included in the current compilation unit,
5434 and build a psymtab for each of them. */
5435 dwarf2_build_include_psymtabs (cu
, comp_unit_die
, pst
);
5437 if (dwarf2_read_debug
)
5439 struct gdbarch
*gdbarch
= get_objfile_arch (objfile
);
5441 fprintf_unfiltered (gdb_stdlog
,
5442 "Psymtab for %s unit @0x%x: %s - %s"
5443 ", %d global, %d static syms\n",
5444 per_cu
->is_debug_types
? "type" : "comp",
5445 per_cu
->offset
.sect_off
,
5446 paddress (gdbarch
, pst
->textlow
),
5447 paddress (gdbarch
, pst
->texthigh
),
5448 pst
->n_global_syms
, pst
->n_static_syms
);
5452 /* Subroutine of dwarf2_build_psymtabs_hard to simplify it.
5453 Process compilation unit THIS_CU for a psymtab. */
5456 process_psymtab_comp_unit (struct dwarf2_per_cu_data
*this_cu
,
5457 int want_partial_unit
)
5459 /* If this compilation unit was already read in, free the
5460 cached copy in order to read it in again. This is
5461 necessary because we skipped some symbols when we first
5462 read in the compilation unit (see load_partial_dies).
5463 This problem could be avoided, but the benefit is unclear. */
5464 if (this_cu
->cu
!= NULL
)
5465 free_one_cached_comp_unit (this_cu
);
5467 gdb_assert (! this_cu
->is_debug_types
);
5468 init_cutu_and_read_dies (this_cu
, NULL
, 0, 0,
5469 process_psymtab_comp_unit_reader
,
5470 &want_partial_unit
);
5472 /* Age out any secondary CUs. */
5473 age_cached_comp_units ();
5476 /* Reader function for build_type_psymtabs. */
5479 build_type_psymtabs_reader (const struct die_reader_specs
*reader
,
5481 struct die_info
*type_unit_die
,
5485 struct objfile
*objfile
= dwarf2_per_objfile
->objfile
;
5486 struct dwarf2_cu
*cu
= reader
->cu
;
5487 struct dwarf2_per_cu_data
*per_cu
= cu
->per_cu
;
5488 struct signatured_type
*sig_type
;
5489 struct type_unit_group
*tu_group
;
5490 struct attribute
*attr
;
5491 struct partial_die_info
*first_die
;
5492 CORE_ADDR lowpc
, highpc
;
5493 struct partial_symtab
*pst
;
5495 gdb_assert (data
== NULL
);
5496 gdb_assert (per_cu
->is_debug_types
);
5497 sig_type
= (struct signatured_type
*) per_cu
;
5502 attr
= dwarf2_attr_no_follow (type_unit_die
, DW_AT_stmt_list
);
5503 tu_group
= get_type_unit_group (cu
, attr
);
5505 VEC_safe_push (sig_type_ptr
, tu_group
->tus
, sig_type
);
5507 prepare_one_comp_unit (cu
, type_unit_die
, language_minimal
);
5508 cu
->list_in_scope
= &file_symbols
;
5509 pst
= create_partial_symtab (per_cu
, "");
5512 first_die
= load_partial_dies (reader
, info_ptr
, 1);
5514 lowpc
= (CORE_ADDR
) -1;
5515 highpc
= (CORE_ADDR
) 0;
5516 scan_partial_symbols (first_die
, &lowpc
, &highpc
, 0, cu
);
5518 pst
->n_global_syms
= objfile
->global_psymbols
.next
-
5519 (objfile
->global_psymbols
.list
+ pst
->globals_offset
);
5520 pst
->n_static_syms
= objfile
->static_psymbols
.next
-
5521 (objfile
->static_psymbols
.list
+ pst
->statics_offset
);
5522 sort_pst_symbols (objfile
, pst
);
5525 /* Traversal function for build_type_psymtabs. */
5528 build_type_psymtab_dependencies (void **slot
, void *info
)
5530 struct objfile
*objfile
= dwarf2_per_objfile
->objfile
;
5531 struct type_unit_group
*tu_group
= (struct type_unit_group
*) *slot
;
5532 struct dwarf2_per_cu_data
*per_cu
= &tu_group
->per_cu
;
5533 struct partial_symtab
*pst
= per_cu
->v
.psymtab
;
5534 int len
= VEC_length (sig_type_ptr
, tu_group
->tus
);
5535 struct signatured_type
*iter
;
5538 gdb_assert (len
> 0);
5539 gdb_assert (IS_TYPE_UNIT_GROUP (per_cu
));
5541 pst
->number_of_dependencies
= len
;
5542 pst
->dependencies
= obstack_alloc (&objfile
->objfile_obstack
,
5543 len
* sizeof (struct psymtab
*));
5545 VEC_iterate (sig_type_ptr
, tu_group
->tus
, i
, iter
);
5548 gdb_assert (iter
->per_cu
.is_debug_types
);
5549 pst
->dependencies
[i
] = iter
->per_cu
.v
.psymtab
;
5550 iter
->type_unit_group
= tu_group
;
5553 VEC_free (sig_type_ptr
, tu_group
->tus
);
5558 /* Subroutine of dwarf2_build_psymtabs_hard to simplify it.
5559 Build partial symbol tables for the .debug_types comp-units. */
5562 build_type_psymtabs (struct objfile
*objfile
)
5564 if (! create_all_type_units (objfile
))
5567 build_type_unit_groups (build_type_psymtabs_reader
, NULL
);
5569 /* Now that all TUs have been processed we can fill in the dependencies. */
5570 htab_traverse_noresize (dwarf2_per_objfile
->type_unit_groups
,
5571 build_type_psymtab_dependencies
, NULL
);
5574 /* A cleanup function that clears objfile's psymtabs_addrmap field. */
5577 psymtabs_addrmap_cleanup (void *o
)
5579 struct objfile
*objfile
= o
;
5581 objfile
->psymtabs_addrmap
= NULL
;
5584 /* Compute the 'user' field for each psymtab in OBJFILE. */
5587 set_partial_user (struct objfile
*objfile
)
5591 for (i
= 0; i
< dwarf2_per_objfile
->n_comp_units
; ++i
)
5593 struct dwarf2_per_cu_data
*per_cu
= dw2_get_cu (i
);
5594 struct partial_symtab
*pst
= per_cu
->v
.psymtab
;
5600 for (j
= 0; j
< pst
->number_of_dependencies
; ++j
)
5602 /* Set the 'user' field only if it is not already set. */
5603 if (pst
->dependencies
[j
]->user
== NULL
)
5604 pst
->dependencies
[j
]->user
= pst
;
5609 /* Build the partial symbol table by doing a quick pass through the
5610 .debug_info and .debug_abbrev sections. */
5613 dwarf2_build_psymtabs_hard (struct objfile
*objfile
)
5615 struct cleanup
*back_to
, *addrmap_cleanup
;
5616 struct obstack temp_obstack
;
5619 if (dwarf2_read_debug
)
5621 fprintf_unfiltered (gdb_stdlog
, "Building psymtabs of objfile %s ...\n",
5625 dwarf2_per_objfile
->reading_partial_symbols
= 1;
5627 dwarf2_read_section (objfile
, &dwarf2_per_objfile
->info
);
5629 /* Any cached compilation units will be linked by the per-objfile
5630 read_in_chain. Make sure to free them when we're done. */
5631 back_to
= make_cleanup (free_cached_comp_units
, NULL
);
5633 build_type_psymtabs (objfile
);
5635 create_all_comp_units (objfile
);
5637 /* Create a temporary address map on a temporary obstack. We later
5638 copy this to the final obstack. */
5639 obstack_init (&temp_obstack
);
5640 make_cleanup_obstack_free (&temp_obstack
);
5641 objfile
->psymtabs_addrmap
= addrmap_create_mutable (&temp_obstack
);
5642 addrmap_cleanup
= make_cleanup (psymtabs_addrmap_cleanup
, objfile
);
5644 for (i
= 0; i
< dwarf2_per_objfile
->n_comp_units
; ++i
)
5646 struct dwarf2_per_cu_data
*per_cu
= dw2_get_cu (i
);
5648 process_psymtab_comp_unit (per_cu
, 0);
5651 set_partial_user (objfile
);
5653 objfile
->psymtabs_addrmap
= addrmap_create_fixed (objfile
->psymtabs_addrmap
,
5654 &objfile
->objfile_obstack
);
5655 discard_cleanups (addrmap_cleanup
);
5657 do_cleanups (back_to
);
5659 if (dwarf2_read_debug
)
5660 fprintf_unfiltered (gdb_stdlog
, "Done building psymtabs of %s\n",
5664 /* die_reader_func for load_partial_comp_unit. */
5667 load_partial_comp_unit_reader (const struct die_reader_specs
*reader
,
5669 struct die_info
*comp_unit_die
,
5673 struct dwarf2_cu
*cu
= reader
->cu
;
5675 prepare_one_comp_unit (cu
, comp_unit_die
, language_minimal
);
5677 /* Check if comp unit has_children.
5678 If so, read the rest of the partial symbols from this comp unit.
5679 If not, there's no more debug_info for this comp unit. */
5681 load_partial_dies (reader
, info_ptr
, 0);
5684 /* Load the partial DIEs for a secondary CU into memory.
5685 This is also used when rereading a primary CU with load_all_dies. */
5688 load_partial_comp_unit (struct dwarf2_per_cu_data
*this_cu
)
5690 init_cutu_and_read_dies (this_cu
, NULL
, 1, 1,
5691 load_partial_comp_unit_reader
, NULL
);
5695 read_comp_units_from_section (struct objfile
*objfile
,
5696 struct dwarf2_section_info
*section
,
5697 unsigned int is_dwz
,
5700 struct dwarf2_per_cu_data
***all_comp_units
)
5703 bfd
*abfd
= section
->asection
->owner
;
5705 if (dwarf2_read_debug
)
5706 fprintf_unfiltered (gdb_stdlog
, "Reading %s for %s\n",
5707 section
->asection
->name
, bfd_get_filename (abfd
));
5709 dwarf2_read_section (objfile
, section
);
5711 info_ptr
= section
->buffer
;
5713 while (info_ptr
< section
->buffer
+ section
->size
)
5715 unsigned int length
, initial_length_size
;
5716 struct dwarf2_per_cu_data
*this_cu
;
5719 offset
.sect_off
= info_ptr
- section
->buffer
;
5721 /* Read just enough information to find out where the next
5722 compilation unit is. */
5723 length
= read_initial_length (abfd
, info_ptr
, &initial_length_size
);
5725 /* Save the compilation unit for later lookup. */
5726 this_cu
= obstack_alloc (&objfile
->objfile_obstack
,
5727 sizeof (struct dwarf2_per_cu_data
));
5728 memset (this_cu
, 0, sizeof (*this_cu
));
5729 this_cu
->offset
= offset
;
5730 this_cu
->length
= length
+ initial_length_size
;
5731 this_cu
->is_dwz
= is_dwz
;
5732 this_cu
->objfile
= objfile
;
5733 this_cu
->section
= section
;
5735 if (*n_comp_units
== *n_allocated
)
5738 *all_comp_units
= xrealloc (*all_comp_units
,
5740 * sizeof (struct dwarf2_per_cu_data
*));
5742 (*all_comp_units
)[*n_comp_units
] = this_cu
;
5745 info_ptr
= info_ptr
+ this_cu
->length
;
5749 /* Create a list of all compilation units in OBJFILE.
5750 This is only done for -readnow and building partial symtabs. */
5753 create_all_comp_units (struct objfile
*objfile
)
5757 struct dwarf2_per_cu_data
**all_comp_units
;
5761 all_comp_units
= xmalloc (n_allocated
5762 * sizeof (struct dwarf2_per_cu_data
*));
5764 read_comp_units_from_section (objfile
, &dwarf2_per_objfile
->info
, 0,
5765 &n_allocated
, &n_comp_units
, &all_comp_units
);
5767 if (bfd_get_section_by_name (objfile
->obfd
, ".gnu_debugaltlink") != NULL
)
5769 struct dwz_file
*dwz
= dwarf2_get_dwz_file ();
5771 read_comp_units_from_section (objfile
, &dwz
->info
, 1,
5772 &n_allocated
, &n_comp_units
,
5776 dwarf2_per_objfile
->all_comp_units
5777 = obstack_alloc (&objfile
->objfile_obstack
,
5778 n_comp_units
* sizeof (struct dwarf2_per_cu_data
*));
5779 memcpy (dwarf2_per_objfile
->all_comp_units
, all_comp_units
,
5780 n_comp_units
* sizeof (struct dwarf2_per_cu_data
*));
5781 xfree (all_comp_units
);
5782 dwarf2_per_objfile
->n_comp_units
= n_comp_units
;
5785 /* Process all loaded DIEs for compilation unit CU, starting at
5786 FIRST_DIE. The caller should pass NEED_PC == 1 if the compilation
5787 unit DIE did not have PC info (DW_AT_low_pc and DW_AT_high_pc, or
5788 DW_AT_ranges). If NEED_PC is set, then this function will set
5789 *LOWPC and *HIGHPC to the lowest and highest PC values found in CU
5790 and record the covered ranges in the addrmap. */
5793 scan_partial_symbols (struct partial_die_info
*first_die
, CORE_ADDR
*lowpc
,
5794 CORE_ADDR
*highpc
, int need_pc
, struct dwarf2_cu
*cu
)
5796 struct partial_die_info
*pdi
;
5798 /* Now, march along the PDI's, descending into ones which have
5799 interesting children but skipping the children of the other ones,
5800 until we reach the end of the compilation unit. */
5806 fixup_partial_die (pdi
, cu
);
5808 /* Anonymous namespaces or modules have no name but have interesting
5809 children, so we need to look at them. Ditto for anonymous
5812 if (pdi
->name
!= NULL
|| pdi
->tag
== DW_TAG_namespace
5813 || pdi
->tag
== DW_TAG_module
|| pdi
->tag
== DW_TAG_enumeration_type
5814 || pdi
->tag
== DW_TAG_imported_unit
)
5818 case DW_TAG_subprogram
:
5819 add_partial_subprogram (pdi
, lowpc
, highpc
, need_pc
, cu
);
5821 case DW_TAG_constant
:
5822 case DW_TAG_variable
:
5823 case DW_TAG_typedef
:
5824 case DW_TAG_union_type
:
5825 if (!pdi
->is_declaration
)
5827 add_partial_symbol (pdi
, cu
);
5830 case DW_TAG_class_type
:
5831 case DW_TAG_interface_type
:
5832 case DW_TAG_structure_type
:
5833 if (!pdi
->is_declaration
)
5835 add_partial_symbol (pdi
, cu
);
5838 case DW_TAG_enumeration_type
:
5839 if (!pdi
->is_declaration
)
5840 add_partial_enumeration (pdi
, cu
);
5842 case DW_TAG_base_type
:
5843 case DW_TAG_subrange_type
:
5844 /* File scope base type definitions are added to the partial
5846 add_partial_symbol (pdi
, cu
);
5848 case DW_TAG_namespace
:
5849 add_partial_namespace (pdi
, lowpc
, highpc
, need_pc
, cu
);
5852 add_partial_module (pdi
, lowpc
, highpc
, need_pc
, cu
);
5854 case DW_TAG_imported_unit
:
5856 struct dwarf2_per_cu_data
*per_cu
;
5858 /* For now we don't handle imported units in type units. */
5859 if (cu
->per_cu
->is_debug_types
)
5861 error (_("Dwarf Error: DW_TAG_imported_unit is not"
5862 " supported in type units [in module %s]"),
5866 per_cu
= dwarf2_find_containing_comp_unit (pdi
->d
.offset
,
5870 /* Go read the partial unit, if needed. */
5871 if (per_cu
->v
.psymtab
== NULL
)
5872 process_psymtab_comp_unit (per_cu
, 1);
5874 VEC_safe_push (dwarf2_per_cu_ptr
,
5875 cu
->per_cu
->imported_symtabs
, per_cu
);
5883 /* If the die has a sibling, skip to the sibling. */
5885 pdi
= pdi
->die_sibling
;
5889 /* Functions used to compute the fully scoped name of a partial DIE.
5891 Normally, this is simple. For C++, the parent DIE's fully scoped
5892 name is concatenated with "::" and the partial DIE's name. For
5893 Java, the same thing occurs except that "." is used instead of "::".
5894 Enumerators are an exception; they use the scope of their parent
5895 enumeration type, i.e. the name of the enumeration type is not
5896 prepended to the enumerator.
5898 There are two complexities. One is DW_AT_specification; in this
5899 case "parent" means the parent of the target of the specification,
5900 instead of the direct parent of the DIE. The other is compilers
5901 which do not emit DW_TAG_namespace; in this case we try to guess
5902 the fully qualified name of structure types from their members'
5903 linkage names. This must be done using the DIE's children rather
5904 than the children of any DW_AT_specification target. We only need
5905 to do this for structures at the top level, i.e. if the target of
5906 any DW_AT_specification (if any; otherwise the DIE itself) does not
5909 /* Compute the scope prefix associated with PDI's parent, in
5910 compilation unit CU. The result will be allocated on CU's
5911 comp_unit_obstack, or a copy of the already allocated PDI->NAME
5912 field. NULL is returned if no prefix is necessary. */
5914 partial_die_parent_scope (struct partial_die_info
*pdi
,
5915 struct dwarf2_cu
*cu
)
5917 const char *grandparent_scope
;
5918 struct partial_die_info
*parent
, *real_pdi
;
5920 /* We need to look at our parent DIE; if we have a DW_AT_specification,
5921 then this means the parent of the specification DIE. */
5924 while (real_pdi
->has_specification
)
5925 real_pdi
= find_partial_die (real_pdi
->spec_offset
,
5926 real_pdi
->spec_is_dwz
, cu
);
5928 parent
= real_pdi
->die_parent
;
5932 if (parent
->scope_set
)
5933 return parent
->scope
;
5935 fixup_partial_die (parent
, cu
);
5937 grandparent_scope
= partial_die_parent_scope (parent
, cu
);
5939 /* GCC 4.0 and 4.1 had a bug (PR c++/28460) where they generated bogus
5940 DW_TAG_namespace DIEs with a name of "::" for the global namespace.
5941 Work around this problem here. */
5942 if (cu
->language
== language_cplus
5943 && parent
->tag
== DW_TAG_namespace
5944 && strcmp (parent
->name
, "::") == 0
5945 && grandparent_scope
== NULL
)
5947 parent
->scope
= NULL
;
5948 parent
->scope_set
= 1;
5952 if (pdi
->tag
== DW_TAG_enumerator
)
5953 /* Enumerators should not get the name of the enumeration as a prefix. */
5954 parent
->scope
= grandparent_scope
;
5955 else if (parent
->tag
== DW_TAG_namespace
5956 || parent
->tag
== DW_TAG_module
5957 || parent
->tag
== DW_TAG_structure_type
5958 || parent
->tag
== DW_TAG_class_type
5959 || parent
->tag
== DW_TAG_interface_type
5960 || parent
->tag
== DW_TAG_union_type
5961 || parent
->tag
== DW_TAG_enumeration_type
)
5963 if (grandparent_scope
== NULL
)
5964 parent
->scope
= parent
->name
;
5966 parent
->scope
= typename_concat (&cu
->comp_unit_obstack
,
5968 parent
->name
, 0, cu
);
5972 /* FIXME drow/2004-04-01: What should we be doing with
5973 function-local names? For partial symbols, we should probably be
5975 complaint (&symfile_complaints
,
5976 _("unhandled containing DIE tag %d for DIE at %d"),
5977 parent
->tag
, pdi
->offset
.sect_off
);
5978 parent
->scope
= grandparent_scope
;
5981 parent
->scope_set
= 1;
5982 return parent
->scope
;
5985 /* Return the fully scoped name associated with PDI, from compilation unit
5986 CU. The result will be allocated with malloc. */
5989 partial_die_full_name (struct partial_die_info
*pdi
,
5990 struct dwarf2_cu
*cu
)
5992 const char *parent_scope
;
5994 /* If this is a template instantiation, we can not work out the
5995 template arguments from partial DIEs. So, unfortunately, we have
5996 to go through the full DIEs. At least any work we do building
5997 types here will be reused if full symbols are loaded later. */
5998 if (pdi
->has_template_arguments
)
6000 fixup_partial_die (pdi
, cu
);
6002 if (pdi
->name
!= NULL
&& strchr (pdi
->name
, '<') == NULL
)
6004 struct die_info
*die
;
6005 struct attribute attr
;
6006 struct dwarf2_cu
*ref_cu
= cu
;
6008 /* DW_FORM_ref_addr is using section offset. */
6010 attr
.form
= DW_FORM_ref_addr
;
6011 attr
.u
.unsnd
= pdi
->offset
.sect_off
;
6012 die
= follow_die_ref (NULL
, &attr
, &ref_cu
);
6014 return xstrdup (dwarf2_full_name (NULL
, die
, ref_cu
));
6018 parent_scope
= partial_die_parent_scope (pdi
, cu
);
6019 if (parent_scope
== NULL
)
6022 return typename_concat (NULL
, parent_scope
, pdi
->name
, 0, cu
);
6026 add_partial_symbol (struct partial_die_info
*pdi
, struct dwarf2_cu
*cu
)
6028 struct objfile
*objfile
= cu
->objfile
;
6030 const char *actual_name
= NULL
;
6032 char *built_actual_name
;
6034 baseaddr
= ANOFFSET (objfile
->section_offsets
, SECT_OFF_TEXT (objfile
));
6036 built_actual_name
= partial_die_full_name (pdi
, cu
);
6037 if (built_actual_name
!= NULL
)
6038 actual_name
= built_actual_name
;
6040 if (actual_name
== NULL
)
6041 actual_name
= pdi
->name
;
6045 case DW_TAG_subprogram
:
6046 if (pdi
->is_external
|| cu
->language
== language_ada
)
6048 /* brobecker/2007-12-26: Normally, only "external" DIEs are part
6049 of the global scope. But in Ada, we want to be able to access
6050 nested procedures globally. So all Ada subprograms are stored
6051 in the global scope. */
6052 /* prim_record_minimal_symbol (actual_name, pdi->lowpc + baseaddr,
6053 mst_text, objfile); */
6054 add_psymbol_to_list (actual_name
, strlen (actual_name
),
6055 built_actual_name
!= NULL
,
6056 VAR_DOMAIN
, LOC_BLOCK
,
6057 &objfile
->global_psymbols
,
6058 0, pdi
->lowpc
+ baseaddr
,
6059 cu
->language
, objfile
);
6063 /* prim_record_minimal_symbol (actual_name, pdi->lowpc + baseaddr,
6064 mst_file_text, objfile); */
6065 add_psymbol_to_list (actual_name
, strlen (actual_name
),
6066 built_actual_name
!= NULL
,
6067 VAR_DOMAIN
, LOC_BLOCK
,
6068 &objfile
->static_psymbols
,
6069 0, pdi
->lowpc
+ baseaddr
,
6070 cu
->language
, objfile
);
6073 case DW_TAG_constant
:
6075 struct psymbol_allocation_list
*list
;
6077 if (pdi
->is_external
)
6078 list
= &objfile
->global_psymbols
;
6080 list
= &objfile
->static_psymbols
;
6081 add_psymbol_to_list (actual_name
, strlen (actual_name
),
6082 built_actual_name
!= NULL
, VAR_DOMAIN
, LOC_STATIC
,
6083 list
, 0, 0, cu
->language
, objfile
);
6086 case DW_TAG_variable
:
6088 addr
= decode_locdesc (pdi
->d
.locdesc
, cu
);
6092 && !dwarf2_per_objfile
->has_section_at_zero
)
6094 /* A global or static variable may also have been stripped
6095 out by the linker if unused, in which case its address
6096 will be nullified; do not add such variables into partial
6097 symbol table then. */
6099 else if (pdi
->is_external
)
6102 Don't enter into the minimal symbol tables as there is
6103 a minimal symbol table entry from the ELF symbols already.
6104 Enter into partial symbol table if it has a location
6105 descriptor or a type.
6106 If the location descriptor is missing, new_symbol will create
6107 a LOC_UNRESOLVED symbol, the address of the variable will then
6108 be determined from the minimal symbol table whenever the variable
6110 The address for the partial symbol table entry is not
6111 used by GDB, but it comes in handy for debugging partial symbol
6114 if (pdi
->d
.locdesc
|| pdi
->has_type
)
6115 add_psymbol_to_list (actual_name
, strlen (actual_name
),
6116 built_actual_name
!= NULL
,
6117 VAR_DOMAIN
, LOC_STATIC
,
6118 &objfile
->global_psymbols
,
6120 cu
->language
, objfile
);
6124 /* Static Variable. Skip symbols without location descriptors. */
6125 if (pdi
->d
.locdesc
== NULL
)
6127 xfree (built_actual_name
);
6130 /* prim_record_minimal_symbol (actual_name, addr + baseaddr,
6131 mst_file_data, objfile); */
6132 add_psymbol_to_list (actual_name
, strlen (actual_name
),
6133 built_actual_name
!= NULL
,
6134 VAR_DOMAIN
, LOC_STATIC
,
6135 &objfile
->static_psymbols
,
6137 cu
->language
, objfile
);
6140 case DW_TAG_typedef
:
6141 case DW_TAG_base_type
:
6142 case DW_TAG_subrange_type
:
6143 add_psymbol_to_list (actual_name
, strlen (actual_name
),
6144 built_actual_name
!= NULL
,
6145 VAR_DOMAIN
, LOC_TYPEDEF
,
6146 &objfile
->static_psymbols
,
6147 0, (CORE_ADDR
) 0, cu
->language
, objfile
);
6149 case DW_TAG_namespace
:
6150 add_psymbol_to_list (actual_name
, strlen (actual_name
),
6151 built_actual_name
!= NULL
,
6152 VAR_DOMAIN
, LOC_TYPEDEF
,
6153 &objfile
->global_psymbols
,
6154 0, (CORE_ADDR
) 0, cu
->language
, objfile
);
6156 case DW_TAG_class_type
:
6157 case DW_TAG_interface_type
:
6158 case DW_TAG_structure_type
:
6159 case DW_TAG_union_type
:
6160 case DW_TAG_enumeration_type
:
6161 /* Skip external references. The DWARF standard says in the section
6162 about "Structure, Union, and Class Type Entries": "An incomplete
6163 structure, union or class type is represented by a structure,
6164 union or class entry that does not have a byte size attribute
6165 and that has a DW_AT_declaration attribute." */
6166 if (!pdi
->has_byte_size
&& pdi
->is_declaration
)
6168 xfree (built_actual_name
);
6172 /* NOTE: carlton/2003-10-07: See comment in new_symbol about
6173 static vs. global. */
6174 add_psymbol_to_list (actual_name
, strlen (actual_name
),
6175 built_actual_name
!= NULL
,
6176 STRUCT_DOMAIN
, LOC_TYPEDEF
,
6177 (cu
->language
== language_cplus
6178 || cu
->language
== language_java
)
6179 ? &objfile
->global_psymbols
6180 : &objfile
->static_psymbols
,
6181 0, (CORE_ADDR
) 0, cu
->language
, objfile
);
6184 case DW_TAG_enumerator
:
6185 add_psymbol_to_list (actual_name
, strlen (actual_name
),
6186 built_actual_name
!= NULL
,
6187 VAR_DOMAIN
, LOC_CONST
,
6188 (cu
->language
== language_cplus
6189 || cu
->language
== language_java
)
6190 ? &objfile
->global_psymbols
6191 : &objfile
->static_psymbols
,
6192 0, (CORE_ADDR
) 0, cu
->language
, objfile
);
6198 xfree (built_actual_name
);
6201 /* Read a partial die corresponding to a namespace; also, add a symbol
6202 corresponding to that namespace to the symbol table. NAMESPACE is
6203 the name of the enclosing namespace. */
6206 add_partial_namespace (struct partial_die_info
*pdi
,
6207 CORE_ADDR
*lowpc
, CORE_ADDR
*highpc
,
6208 int need_pc
, struct dwarf2_cu
*cu
)
6210 /* Add a symbol for the namespace. */
6212 add_partial_symbol (pdi
, cu
);
6214 /* Now scan partial symbols in that namespace. */
6216 if (pdi
->has_children
)
6217 scan_partial_symbols (pdi
->die_child
, lowpc
, highpc
, need_pc
, cu
);
6220 /* Read a partial die corresponding to a Fortran module. */
6223 add_partial_module (struct partial_die_info
*pdi
, CORE_ADDR
*lowpc
,
6224 CORE_ADDR
*highpc
, int need_pc
, struct dwarf2_cu
*cu
)
6226 /* Now scan partial symbols in that module. */
6228 if (pdi
->has_children
)
6229 scan_partial_symbols (pdi
->die_child
, lowpc
, highpc
, need_pc
, cu
);
6232 /* Read a partial die corresponding to a subprogram and create a partial
6233 symbol for that subprogram. When the CU language allows it, this
6234 routine also defines a partial symbol for each nested subprogram
6235 that this subprogram contains.
6237 DIE my also be a lexical block, in which case we simply search
6238 recursively for suprograms defined inside that lexical block.
6239 Again, this is only performed when the CU language allows this
6240 type of definitions. */
6243 add_partial_subprogram (struct partial_die_info
*pdi
,
6244 CORE_ADDR
*lowpc
, CORE_ADDR
*highpc
,
6245 int need_pc
, struct dwarf2_cu
*cu
)
6247 if (pdi
->tag
== DW_TAG_subprogram
)
6249 if (pdi
->has_pc_info
)
6251 if (pdi
->lowpc
< *lowpc
)
6252 *lowpc
= pdi
->lowpc
;
6253 if (pdi
->highpc
> *highpc
)
6254 *highpc
= pdi
->highpc
;
6258 struct objfile
*objfile
= cu
->objfile
;
6260 baseaddr
= ANOFFSET (objfile
->section_offsets
,
6261 SECT_OFF_TEXT (objfile
));
6262 addrmap_set_empty (objfile
->psymtabs_addrmap
,
6263 pdi
->lowpc
+ baseaddr
,
6264 pdi
->highpc
- 1 + baseaddr
,
6265 cu
->per_cu
->v
.psymtab
);
6269 if (pdi
->has_pc_info
|| (!pdi
->is_external
&& pdi
->may_be_inlined
))
6271 if (!pdi
->is_declaration
)
6272 /* Ignore subprogram DIEs that do not have a name, they are
6273 illegal. Do not emit a complaint at this point, we will
6274 do so when we convert this psymtab into a symtab. */
6276 add_partial_symbol (pdi
, cu
);
6280 if (! pdi
->has_children
)
6283 if (cu
->language
== language_ada
)
6285 pdi
= pdi
->die_child
;
6288 fixup_partial_die (pdi
, cu
);
6289 if (pdi
->tag
== DW_TAG_subprogram
6290 || pdi
->tag
== DW_TAG_lexical_block
)
6291 add_partial_subprogram (pdi
, lowpc
, highpc
, need_pc
, cu
);
6292 pdi
= pdi
->die_sibling
;
6297 /* Read a partial die corresponding to an enumeration type. */
6300 add_partial_enumeration (struct partial_die_info
*enum_pdi
,
6301 struct dwarf2_cu
*cu
)
6303 struct partial_die_info
*pdi
;
6305 if (enum_pdi
->name
!= NULL
)
6306 add_partial_symbol (enum_pdi
, cu
);
6308 pdi
= enum_pdi
->die_child
;
6311 if (pdi
->tag
!= DW_TAG_enumerator
|| pdi
->name
== NULL
)
6312 complaint (&symfile_complaints
, _("malformed enumerator DIE ignored"));
6314 add_partial_symbol (pdi
, cu
);
6315 pdi
= pdi
->die_sibling
;
6319 /* Return the initial uleb128 in the die at INFO_PTR. */
6322 peek_abbrev_code (bfd
*abfd
, gdb_byte
*info_ptr
)
6324 unsigned int bytes_read
;
6326 return read_unsigned_leb128 (abfd
, info_ptr
, &bytes_read
);
6329 /* Read the initial uleb128 in the die at INFO_PTR in compilation unit CU.
6330 Return the corresponding abbrev, or NULL if the number is zero (indicating
6331 an empty DIE). In either case *BYTES_READ will be set to the length of
6332 the initial number. */
6334 static struct abbrev_info
*
6335 peek_die_abbrev (gdb_byte
*info_ptr
, unsigned int *bytes_read
,
6336 struct dwarf2_cu
*cu
)
6338 bfd
*abfd
= cu
->objfile
->obfd
;
6339 unsigned int abbrev_number
;
6340 struct abbrev_info
*abbrev
;
6342 abbrev_number
= read_unsigned_leb128 (abfd
, info_ptr
, bytes_read
);
6344 if (abbrev_number
== 0)
6347 abbrev
= abbrev_table_lookup_abbrev (cu
->abbrev_table
, abbrev_number
);
6350 error (_("Dwarf Error: Could not find abbrev number %d [in module %s]"),
6351 abbrev_number
, bfd_get_filename (abfd
));
6357 /* Scan the debug information for CU starting at INFO_PTR in buffer BUFFER.
6358 Returns a pointer to the end of a series of DIEs, terminated by an empty
6359 DIE. Any children of the skipped DIEs will also be skipped. */
6362 skip_children (const struct die_reader_specs
*reader
, gdb_byte
*info_ptr
)
6364 struct dwarf2_cu
*cu
= reader
->cu
;
6365 struct abbrev_info
*abbrev
;
6366 unsigned int bytes_read
;
6370 abbrev
= peek_die_abbrev (info_ptr
, &bytes_read
, cu
);
6372 return info_ptr
+ bytes_read
;
6374 info_ptr
= skip_one_die (reader
, info_ptr
+ bytes_read
, abbrev
);
6378 /* Scan the debug information for CU starting at INFO_PTR in buffer BUFFER.
6379 INFO_PTR should point just after the initial uleb128 of a DIE, and the
6380 abbrev corresponding to that skipped uleb128 should be passed in
6381 ABBREV. Returns a pointer to this DIE's sibling, skipping any
6385 skip_one_die (const struct die_reader_specs
*reader
, gdb_byte
*info_ptr
,
6386 struct abbrev_info
*abbrev
)
6388 unsigned int bytes_read
;
6389 struct attribute attr
;
6390 bfd
*abfd
= reader
->abfd
;
6391 struct dwarf2_cu
*cu
= reader
->cu
;
6392 gdb_byte
*buffer
= reader
->buffer
;
6393 const gdb_byte
*buffer_end
= reader
->buffer_end
;
6394 gdb_byte
*start_info_ptr
= info_ptr
;
6395 unsigned int form
, i
;
6397 for (i
= 0; i
< abbrev
->num_attrs
; i
++)
6399 /* The only abbrev we care about is DW_AT_sibling. */
6400 if (abbrev
->attrs
[i
].name
== DW_AT_sibling
)
6402 read_attribute (reader
, &attr
, &abbrev
->attrs
[i
], info_ptr
);
6403 if (attr
.form
== DW_FORM_ref_addr
)
6404 complaint (&symfile_complaints
,
6405 _("ignoring absolute DW_AT_sibling"));
6407 return buffer
+ dwarf2_get_ref_die_offset (&attr
).sect_off
;
6410 /* If it isn't DW_AT_sibling, skip this attribute. */
6411 form
= abbrev
->attrs
[i
].form
;
6415 case DW_FORM_ref_addr
:
6416 /* In DWARF 2, DW_FORM_ref_addr is address sized; in DWARF 3
6417 and later it is offset sized. */
6418 if (cu
->header
.version
== 2)
6419 info_ptr
+= cu
->header
.addr_size
;
6421 info_ptr
+= cu
->header
.offset_size
;
6423 case DW_FORM_GNU_ref_alt
:
6424 info_ptr
+= cu
->header
.offset_size
;
6427 info_ptr
+= cu
->header
.addr_size
;
6434 case DW_FORM_flag_present
:
6446 case DW_FORM_ref_sig8
:
6449 case DW_FORM_string
:
6450 read_direct_string (abfd
, info_ptr
, &bytes_read
);
6451 info_ptr
+= bytes_read
;
6453 case DW_FORM_sec_offset
:
6455 case DW_FORM_GNU_strp_alt
:
6456 info_ptr
+= cu
->header
.offset_size
;
6458 case DW_FORM_exprloc
:
6460 info_ptr
+= read_unsigned_leb128 (abfd
, info_ptr
, &bytes_read
);
6461 info_ptr
+= bytes_read
;
6463 case DW_FORM_block1
:
6464 info_ptr
+= 1 + read_1_byte (abfd
, info_ptr
);
6466 case DW_FORM_block2
:
6467 info_ptr
+= 2 + read_2_bytes (abfd
, info_ptr
);
6469 case DW_FORM_block4
:
6470 info_ptr
+= 4 + read_4_bytes (abfd
, info_ptr
);
6474 case DW_FORM_ref_udata
:
6475 case DW_FORM_GNU_addr_index
:
6476 case DW_FORM_GNU_str_index
:
6477 info_ptr
= (gdb_byte
*) safe_skip_leb128 (info_ptr
, buffer_end
);
6479 case DW_FORM_indirect
:
6480 form
= read_unsigned_leb128 (abfd
, info_ptr
, &bytes_read
);
6481 info_ptr
+= bytes_read
;
6482 /* We need to continue parsing from here, so just go back to
6484 goto skip_attribute
;
6487 error (_("Dwarf Error: Cannot handle %s "
6488 "in DWARF reader [in module %s]"),
6489 dwarf_form_name (form
),
6490 bfd_get_filename (abfd
));
6494 if (abbrev
->has_children
)
6495 return skip_children (reader
, info_ptr
);
6500 /* Locate ORIG_PDI's sibling.
6501 INFO_PTR should point to the start of the next DIE after ORIG_PDI. */
6504 locate_pdi_sibling (const struct die_reader_specs
*reader
,
6505 struct partial_die_info
*orig_pdi
,
6508 /* Do we know the sibling already? */
6510 if (orig_pdi
->sibling
)
6511 return orig_pdi
->sibling
;
6513 /* Are there any children to deal with? */
6515 if (!orig_pdi
->has_children
)
6518 /* Skip the children the long way. */
6520 return skip_children (reader
, info_ptr
);
6523 /* Expand this partial symbol table into a full symbol table. SELF is
6527 dwarf2_read_symtab (struct partial_symtab
*self
,
6528 struct objfile
*objfile
)
6532 warning (_("bug: psymtab for %s is already read in."),
6539 printf_filtered (_("Reading in symbols for %s..."),
6541 gdb_flush (gdb_stdout
);
6544 /* Restore our global data. */
6545 dwarf2_per_objfile
= objfile_data (objfile
, dwarf2_objfile_data_key
);
6547 /* If this psymtab is constructed from a debug-only objfile, the
6548 has_section_at_zero flag will not necessarily be correct. We
6549 can get the correct value for this flag by looking at the data
6550 associated with the (presumably stripped) associated objfile. */
6551 if (objfile
->separate_debug_objfile_backlink
)
6553 struct dwarf2_per_objfile
*dpo_backlink
6554 = objfile_data (objfile
->separate_debug_objfile_backlink
,
6555 dwarf2_objfile_data_key
);
6557 dwarf2_per_objfile
->has_section_at_zero
6558 = dpo_backlink
->has_section_at_zero
;
6561 dwarf2_per_objfile
->reading_partial_symbols
= 0;
6563 psymtab_to_symtab_1 (self
);
6565 /* Finish up the debug error message. */
6567 printf_filtered (_("done.\n"));
6570 process_cu_includes ();
6573 /* Reading in full CUs. */
6575 /* Add PER_CU to the queue. */
6578 queue_comp_unit (struct dwarf2_per_cu_data
*per_cu
,
6579 enum language pretend_language
)
6581 struct dwarf2_queue_item
*item
;
6584 item
= xmalloc (sizeof (*item
));
6585 item
->per_cu
= per_cu
;
6586 item
->pretend_language
= pretend_language
;
6589 if (dwarf2_queue
== NULL
)
6590 dwarf2_queue
= item
;
6592 dwarf2_queue_tail
->next
= item
;
6594 dwarf2_queue_tail
= item
;
6597 /* THIS_CU has a reference to PER_CU. If necessary, load the new compilation
6598 unit and add it to our queue.
6599 The result is non-zero if PER_CU was queued, otherwise the result is zero
6600 meaning either PER_CU is already queued or it is already loaded. */
6603 maybe_queue_comp_unit (struct dwarf2_cu
*this_cu
,
6604 struct dwarf2_per_cu_data
*per_cu
,
6605 enum language pretend_language
)
6607 /* We may arrive here during partial symbol reading, if we need full
6608 DIEs to process an unusual case (e.g. template arguments). Do
6609 not queue PER_CU, just tell our caller to load its DIEs. */
6610 if (dwarf2_per_objfile
->reading_partial_symbols
)
6612 if (per_cu
->cu
== NULL
|| per_cu
->cu
->dies
== NULL
)
6617 /* Mark the dependence relation so that we don't flush PER_CU
6619 dwarf2_add_dependence (this_cu
, per_cu
);
6621 /* If it's already on the queue, we have nothing to do. */
6625 /* If the compilation unit is already loaded, just mark it as
6627 if (per_cu
->cu
!= NULL
)
6629 per_cu
->cu
->last_used
= 0;
6633 /* Add it to the queue. */
6634 queue_comp_unit (per_cu
, pretend_language
);
6639 /* Process the queue. */
6642 process_queue (void)
6644 struct dwarf2_queue_item
*item
, *next_item
;
6646 if (dwarf2_read_debug
)
6648 fprintf_unfiltered (gdb_stdlog
,
6649 "Expanding one or more symtabs of objfile %s ...\n",
6650 dwarf2_per_objfile
->objfile
->name
);
6653 /* The queue starts out with one item, but following a DIE reference
6654 may load a new CU, adding it to the end of the queue. */
6655 for (item
= dwarf2_queue
; item
!= NULL
; dwarf2_queue
= item
= next_item
)
6657 if (dwarf2_per_objfile
->using_index
6658 ? !item
->per_cu
->v
.quick
->symtab
6659 : (item
->per_cu
->v
.psymtab
&& !item
->per_cu
->v
.psymtab
->readin
))
6661 struct dwarf2_per_cu_data
*per_cu
= item
->per_cu
;
6663 if (dwarf2_read_debug
)
6665 fprintf_unfiltered (gdb_stdlog
,
6666 "Expanding symtab of %s at offset 0x%x\n",
6667 per_cu
->is_debug_types
? "TU" : "CU",
6668 per_cu
->offset
.sect_off
);
6671 if (per_cu
->is_debug_types
)
6672 process_full_type_unit (per_cu
, item
->pretend_language
);
6674 process_full_comp_unit (per_cu
, item
->pretend_language
);
6676 if (dwarf2_read_debug
)
6678 fprintf_unfiltered (gdb_stdlog
,
6679 "Done expanding %s at offset 0x%x\n",
6680 per_cu
->is_debug_types
? "TU" : "CU",
6681 per_cu
->offset
.sect_off
);
6685 item
->per_cu
->queued
= 0;
6686 next_item
= item
->next
;
6690 dwarf2_queue_tail
= NULL
;
6692 if (dwarf2_read_debug
)
6694 fprintf_unfiltered (gdb_stdlog
, "Done expanding symtabs of %s.\n",
6695 dwarf2_per_objfile
->objfile
->name
);
6699 /* Free all allocated queue entries. This function only releases anything if
6700 an error was thrown; if the queue was processed then it would have been
6701 freed as we went along. */
6704 dwarf2_release_queue (void *dummy
)
6706 struct dwarf2_queue_item
*item
, *last
;
6708 item
= dwarf2_queue
;
6711 /* Anything still marked queued is likely to be in an
6712 inconsistent state, so discard it. */
6713 if (item
->per_cu
->queued
)
6715 if (item
->per_cu
->cu
!= NULL
)
6716 free_one_cached_comp_unit (item
->per_cu
);
6717 item
->per_cu
->queued
= 0;
6725 dwarf2_queue
= dwarf2_queue_tail
= NULL
;
6728 /* Read in full symbols for PST, and anything it depends on. */
6731 psymtab_to_symtab_1 (struct partial_symtab
*pst
)
6733 struct dwarf2_per_cu_data
*per_cu
;
6739 for (i
= 0; i
< pst
->number_of_dependencies
; i
++)
6740 if (!pst
->dependencies
[i
]->readin
6741 && pst
->dependencies
[i
]->user
== NULL
)
6743 /* Inform about additional files that need to be read in. */
6746 /* FIXME: i18n: Need to make this a single string. */
6747 fputs_filtered (" ", gdb_stdout
);
6749 fputs_filtered ("and ", gdb_stdout
);
6751 printf_filtered ("%s...", pst
->dependencies
[i
]->filename
);
6752 wrap_here (""); /* Flush output. */
6753 gdb_flush (gdb_stdout
);
6755 psymtab_to_symtab_1 (pst
->dependencies
[i
]);
6758 per_cu
= pst
->read_symtab_private
;
6762 /* It's an include file, no symbols to read for it.
6763 Everything is in the parent symtab. */
6768 dw2_do_instantiate_symtab (per_cu
);
6771 /* Trivial hash function for die_info: the hash value of a DIE
6772 is its offset in .debug_info for this objfile. */
6775 die_hash (const void *item
)
6777 const struct die_info
*die
= item
;
6779 return die
->offset
.sect_off
;
6782 /* Trivial comparison function for die_info structures: two DIEs
6783 are equal if they have the same offset. */
6786 die_eq (const void *item_lhs
, const void *item_rhs
)
6788 const struct die_info
*die_lhs
= item_lhs
;
6789 const struct die_info
*die_rhs
= item_rhs
;
6791 return die_lhs
->offset
.sect_off
== die_rhs
->offset
.sect_off
;
6794 /* die_reader_func for load_full_comp_unit.
6795 This is identical to read_signatured_type_reader,
6796 but is kept separate for now. */
6799 load_full_comp_unit_reader (const struct die_reader_specs
*reader
,
6801 struct die_info
*comp_unit_die
,
6805 struct dwarf2_cu
*cu
= reader
->cu
;
6806 enum language
*language_ptr
= data
;
6808 gdb_assert (cu
->die_hash
== NULL
);
6810 htab_create_alloc_ex (cu
->header
.length
/ 12,
6814 &cu
->comp_unit_obstack
,
6815 hashtab_obstack_allocate
,
6816 dummy_obstack_deallocate
);
6819 comp_unit_die
->child
= read_die_and_siblings (reader
, info_ptr
,
6820 &info_ptr
, comp_unit_die
);
6821 cu
->dies
= comp_unit_die
;
6822 /* comp_unit_die is not stored in die_hash, no need. */
6824 /* We try not to read any attributes in this function, because not
6825 all CUs needed for references have been loaded yet, and symbol
6826 table processing isn't initialized. But we have to set the CU language,
6827 or we won't be able to build types correctly.
6828 Similarly, if we do not read the producer, we can not apply
6829 producer-specific interpretation. */
6830 prepare_one_comp_unit (cu
, cu
->dies
, *language_ptr
);
6833 /* Load the DIEs associated with PER_CU into memory. */
6836 load_full_comp_unit (struct dwarf2_per_cu_data
*this_cu
,
6837 enum language pretend_language
)
6839 gdb_assert (! this_cu
->is_debug_types
);
6841 init_cutu_and_read_dies (this_cu
, NULL
, 1, 1,
6842 load_full_comp_unit_reader
, &pretend_language
);
6845 /* Add a DIE to the delayed physname list. */
6848 add_to_method_list (struct type
*type
, int fnfield_index
, int index
,
6849 const char *name
, struct die_info
*die
,
6850 struct dwarf2_cu
*cu
)
6852 struct delayed_method_info mi
;
6854 mi
.fnfield_index
= fnfield_index
;
6858 VEC_safe_push (delayed_method_info
, cu
->method_list
, &mi
);
6861 /* A cleanup for freeing the delayed method list. */
6864 free_delayed_list (void *ptr
)
6866 struct dwarf2_cu
*cu
= (struct dwarf2_cu
*) ptr
;
6867 if (cu
->method_list
!= NULL
)
6869 VEC_free (delayed_method_info
, cu
->method_list
);
6870 cu
->method_list
= NULL
;
6874 /* Compute the physnames of any methods on the CU's method list.
6876 The computation of method physnames is delayed in order to avoid the
6877 (bad) condition that one of the method's formal parameters is of an as yet
6881 compute_delayed_physnames (struct dwarf2_cu
*cu
)
6884 struct delayed_method_info
*mi
;
6885 for (i
= 0; VEC_iterate (delayed_method_info
, cu
->method_list
, i
, mi
) ; ++i
)
6887 const char *physname
;
6888 struct fn_fieldlist
*fn_flp
6889 = &TYPE_FN_FIELDLIST (mi
->type
, mi
->fnfield_index
);
6890 physname
= dwarf2_physname (mi
->name
, mi
->die
, cu
);
6891 fn_flp
->fn_fields
[mi
->index
].physname
= physname
? physname
: "";
6895 /* Go objects should be embedded in a DW_TAG_module DIE,
6896 and it's not clear if/how imported objects will appear.
6897 To keep Go support simple until that's worked out,
6898 go back through what we've read and create something usable.
6899 We could do this while processing each DIE, and feels kinda cleaner,
6900 but that way is more invasive.
6901 This is to, for example, allow the user to type "p var" or "b main"
6902 without having to specify the package name, and allow lookups
6903 of module.object to work in contexts that use the expression
6907 fixup_go_packaging (struct dwarf2_cu
*cu
)
6909 char *package_name
= NULL
;
6910 struct pending
*list
;
6913 for (list
= global_symbols
; list
!= NULL
; list
= list
->next
)
6915 for (i
= 0; i
< list
->nsyms
; ++i
)
6917 struct symbol
*sym
= list
->symbol
[i
];
6919 if (SYMBOL_LANGUAGE (sym
) == language_go
6920 && SYMBOL_CLASS (sym
) == LOC_BLOCK
)
6922 char *this_package_name
= go_symbol_package_name (sym
);
6924 if (this_package_name
== NULL
)
6926 if (package_name
== NULL
)
6927 package_name
= this_package_name
;
6930 if (strcmp (package_name
, this_package_name
) != 0)
6931 complaint (&symfile_complaints
,
6932 _("Symtab %s has objects from two different Go packages: %s and %s"),
6933 (SYMBOL_SYMTAB (sym
)
6934 ? symtab_to_filename_for_display (SYMBOL_SYMTAB (sym
))
6935 : cu
->objfile
->name
),
6936 this_package_name
, package_name
);
6937 xfree (this_package_name
);
6943 if (package_name
!= NULL
)
6945 struct objfile
*objfile
= cu
->objfile
;
6946 const char *saved_package_name
= obstack_copy0 (&objfile
->objfile_obstack
,
6948 strlen (package_name
));
6949 struct type
*type
= init_type (TYPE_CODE_MODULE
, 0, 0,
6950 saved_package_name
, objfile
);
6953 TYPE_TAG_NAME (type
) = TYPE_NAME (type
);
6955 sym
= allocate_symbol (objfile
);
6956 SYMBOL_SET_LANGUAGE (sym
, language_go
, &objfile
->objfile_obstack
);
6957 SYMBOL_SET_NAMES (sym
, saved_package_name
,
6958 strlen (saved_package_name
), 0, objfile
);
6959 /* This is not VAR_DOMAIN because we want a way to ensure a lookup of,
6960 e.g., "main" finds the "main" module and not C's main(). */
6961 SYMBOL_DOMAIN (sym
) = STRUCT_DOMAIN
;
6962 SYMBOL_ACLASS_INDEX (sym
) = LOC_TYPEDEF
;
6963 SYMBOL_TYPE (sym
) = type
;
6965 add_symbol_to_list (sym
, &global_symbols
);
6967 xfree (package_name
);
6971 /* Return the symtab for PER_CU. This works properly regardless of
6972 whether we're using the index or psymtabs. */
6974 static struct symtab
*
6975 get_symtab (struct dwarf2_per_cu_data
*per_cu
)
6977 return (dwarf2_per_objfile
->using_index
6978 ? per_cu
->v
.quick
->symtab
6979 : per_cu
->v
.psymtab
->symtab
);
6982 /* A helper function for computing the list of all symbol tables
6983 included by PER_CU. */
6986 recursively_compute_inclusions (VEC (dwarf2_per_cu_ptr
) **result
,
6987 htab_t all_children
,
6988 struct dwarf2_per_cu_data
*per_cu
)
6992 struct dwarf2_per_cu_data
*iter
;
6994 slot
= htab_find_slot (all_children
, per_cu
, INSERT
);
6997 /* This inclusion and its children have been processed. */
7002 /* Only add a CU if it has a symbol table. */
7003 if (get_symtab (per_cu
) != NULL
)
7004 VEC_safe_push (dwarf2_per_cu_ptr
, *result
, per_cu
);
7007 VEC_iterate (dwarf2_per_cu_ptr
, per_cu
->imported_symtabs
, ix
, iter
);
7009 recursively_compute_inclusions (result
, all_children
, iter
);
7012 /* Compute the symtab 'includes' fields for the symtab related to
7016 compute_symtab_includes (struct dwarf2_per_cu_data
*per_cu
)
7018 gdb_assert (! per_cu
->is_debug_types
);
7020 if (!VEC_empty (dwarf2_per_cu_ptr
, per_cu
->imported_symtabs
))
7023 struct dwarf2_per_cu_data
*iter
;
7024 VEC (dwarf2_per_cu_ptr
) *result_children
= NULL
;
7025 htab_t all_children
;
7026 struct symtab
*symtab
= get_symtab (per_cu
);
7028 /* If we don't have a symtab, we can just skip this case. */
7032 all_children
= htab_create_alloc (1, htab_hash_pointer
, htab_eq_pointer
,
7033 NULL
, xcalloc
, xfree
);
7036 VEC_iterate (dwarf2_per_cu_ptr
, per_cu
->imported_symtabs
,
7039 recursively_compute_inclusions (&result_children
, all_children
, iter
);
7041 /* Now we have a transitive closure of all the included CUs, and
7042 for .gdb_index version 7 the included TUs, so we can convert it
7043 to a list of symtabs. */
7044 len
= VEC_length (dwarf2_per_cu_ptr
, result_children
);
7046 = obstack_alloc (&dwarf2_per_objfile
->objfile
->objfile_obstack
,
7047 (len
+ 1) * sizeof (struct symtab
*));
7049 VEC_iterate (dwarf2_per_cu_ptr
, result_children
, ix
, iter
);
7051 symtab
->includes
[ix
] = get_symtab (iter
);
7052 symtab
->includes
[len
] = NULL
;
7054 VEC_free (dwarf2_per_cu_ptr
, result_children
);
7055 htab_delete (all_children
);
7059 /* Compute the 'includes' field for the symtabs of all the CUs we just
7063 process_cu_includes (void)
7066 struct dwarf2_per_cu_data
*iter
;
7069 VEC_iterate (dwarf2_per_cu_ptr
, dwarf2_per_objfile
->just_read_cus
,
7073 if (! iter
->is_debug_types
)
7074 compute_symtab_includes (iter
);
7077 VEC_free (dwarf2_per_cu_ptr
, dwarf2_per_objfile
->just_read_cus
);
7080 /* Generate full symbol information for PER_CU, whose DIEs have
7081 already been loaded into memory. */
7084 process_full_comp_unit (struct dwarf2_per_cu_data
*per_cu
,
7085 enum language pretend_language
)
7087 struct dwarf2_cu
*cu
= per_cu
->cu
;
7088 struct objfile
*objfile
= per_cu
->objfile
;
7089 CORE_ADDR lowpc
, highpc
;
7090 struct symtab
*symtab
;
7091 struct cleanup
*back_to
, *delayed_list_cleanup
;
7093 struct block
*static_block
;
7095 baseaddr
= ANOFFSET (objfile
->section_offsets
, SECT_OFF_TEXT (objfile
));
7098 back_to
= make_cleanup (really_free_pendings
, NULL
);
7099 delayed_list_cleanup
= make_cleanup (free_delayed_list
, cu
);
7101 cu
->list_in_scope
= &file_symbols
;
7103 cu
->language
= pretend_language
;
7104 cu
->language_defn
= language_def (cu
->language
);
7106 /* Do line number decoding in read_file_scope () */
7107 process_die (cu
->dies
, cu
);
7109 /* For now fudge the Go package. */
7110 if (cu
->language
== language_go
)
7111 fixup_go_packaging (cu
);
7113 /* Now that we have processed all the DIEs in the CU, all the types
7114 should be complete, and it should now be safe to compute all of the
7116 compute_delayed_physnames (cu
);
7117 do_cleanups (delayed_list_cleanup
);
7119 /* Some compilers don't define a DW_AT_high_pc attribute for the
7120 compilation unit. If the DW_AT_high_pc is missing, synthesize
7121 it, by scanning the DIE's below the compilation unit. */
7122 get_scope_pc_bounds (cu
->dies
, &lowpc
, &highpc
, cu
);
7125 = end_symtab_get_static_block (highpc
+ baseaddr
, objfile
, 0,
7126 per_cu
->imported_symtabs
!= NULL
);
7128 /* If the comp unit has DW_AT_ranges, it may have discontiguous ranges.
7129 Also, DW_AT_ranges may record ranges not belonging to any child DIEs
7130 (such as virtual method tables). Record the ranges in STATIC_BLOCK's
7131 addrmap to help ensure it has an accurate map of pc values belonging to
7133 dwarf2_record_block_ranges (cu
->dies
, static_block
, baseaddr
, cu
);
7135 symtab
= end_symtab_from_static_block (static_block
, objfile
,
7136 SECT_OFF_TEXT (objfile
), 0);
7140 int gcc_4_minor
= producer_is_gcc_ge_4 (cu
->producer
);
7142 /* Set symtab language to language from DW_AT_language. If the
7143 compilation is from a C file generated by language preprocessors, do
7144 not set the language if it was already deduced by start_subfile. */
7145 if (!(cu
->language
== language_c
&& symtab
->language
!= language_c
))
7146 symtab
->language
= cu
->language
;
7148 /* GCC-4.0 has started to support -fvar-tracking. GCC-3.x still can
7149 produce DW_AT_location with location lists but it can be possibly
7150 invalid without -fvar-tracking. Still up to GCC-4.4.x incl. 4.4.0
7151 there were bugs in prologue debug info, fixed later in GCC-4.5
7152 by "unwind info for epilogues" patch (which is not directly related).
7154 For -gdwarf-4 type units LOCATIONS_VALID indication is fortunately not
7155 needed, it would be wrong due to missing DW_AT_producer there.
7157 Still one can confuse GDB by using non-standard GCC compilation
7158 options - this waits on GCC PR other/32998 (-frecord-gcc-switches).
7160 if (cu
->has_loclist
&& gcc_4_minor
>= 5)
7161 symtab
->locations_valid
= 1;
7163 if (gcc_4_minor
>= 5)
7164 symtab
->epilogue_unwind_valid
= 1;
7166 symtab
->call_site_htab
= cu
->call_site_htab
;
7169 if (dwarf2_per_objfile
->using_index
)
7170 per_cu
->v
.quick
->symtab
= symtab
;
7173 struct partial_symtab
*pst
= per_cu
->v
.psymtab
;
7174 pst
->symtab
= symtab
;
7178 /* Push it for inclusion processing later. */
7179 VEC_safe_push (dwarf2_per_cu_ptr
, dwarf2_per_objfile
->just_read_cus
, per_cu
);
7181 do_cleanups (back_to
);
7184 /* Generate full symbol information for type unit PER_CU, whose DIEs have
7185 already been loaded into memory. */
7188 process_full_type_unit (struct dwarf2_per_cu_data
*per_cu
,
7189 enum language pretend_language
)
7191 struct dwarf2_cu
*cu
= per_cu
->cu
;
7192 struct objfile
*objfile
= per_cu
->objfile
;
7193 struct symtab
*symtab
;
7194 struct cleanup
*back_to
, *delayed_list_cleanup
;
7195 struct signatured_type
*sig_type
;
7197 gdb_assert (per_cu
->is_debug_types
);
7198 sig_type
= (struct signatured_type
*) per_cu
;
7201 back_to
= make_cleanup (really_free_pendings
, NULL
);
7202 delayed_list_cleanup
= make_cleanup (free_delayed_list
, cu
);
7204 cu
->list_in_scope
= &file_symbols
;
7206 cu
->language
= pretend_language
;
7207 cu
->language_defn
= language_def (cu
->language
);
7209 /* The symbol tables are set up in read_type_unit_scope. */
7210 process_die (cu
->dies
, cu
);
7212 /* For now fudge the Go package. */
7213 if (cu
->language
== language_go
)
7214 fixup_go_packaging (cu
);
7216 /* Now that we have processed all the DIEs in the CU, all the types
7217 should be complete, and it should now be safe to compute all of the
7219 compute_delayed_physnames (cu
);
7220 do_cleanups (delayed_list_cleanup
);
7222 /* TUs share symbol tables.
7223 If this is the first TU to use this symtab, complete the construction
7224 of it with end_expandable_symtab. Otherwise, complete the addition of
7225 this TU's symbols to the existing symtab. */
7226 if (sig_type
->type_unit_group
->primary_symtab
== NULL
)
7228 symtab
= end_expandable_symtab (0, objfile
, SECT_OFF_TEXT (objfile
));
7229 sig_type
->type_unit_group
->primary_symtab
= symtab
;
7233 /* Set symtab language to language from DW_AT_language. If the
7234 compilation is from a C file generated by language preprocessors,
7235 do not set the language if it was already deduced by
7237 if (!(cu
->language
== language_c
&& symtab
->language
!= language_c
))
7238 symtab
->language
= cu
->language
;
7243 augment_type_symtab (objfile
,
7244 sig_type
->type_unit_group
->primary_symtab
);
7245 symtab
= sig_type
->type_unit_group
->primary_symtab
;
7248 if (dwarf2_per_objfile
->using_index
)
7249 per_cu
->v
.quick
->symtab
= symtab
;
7252 struct partial_symtab
*pst
= per_cu
->v
.psymtab
;
7253 pst
->symtab
= symtab
;
7257 do_cleanups (back_to
);
7260 /* Process an imported unit DIE. */
7263 process_imported_unit_die (struct die_info
*die
, struct dwarf2_cu
*cu
)
7265 struct attribute
*attr
;
7267 /* For now we don't handle imported units in type units. */
7268 if (cu
->per_cu
->is_debug_types
)
7270 error (_("Dwarf Error: DW_TAG_imported_unit is not"
7271 " supported in type units [in module %s]"),
7275 attr
= dwarf2_attr (die
, DW_AT_import
, cu
);
7278 struct dwarf2_per_cu_data
*per_cu
;
7279 struct symtab
*imported_symtab
;
7283 offset
= dwarf2_get_ref_die_offset (attr
);
7284 is_dwz
= (attr
->form
== DW_FORM_GNU_ref_alt
|| cu
->per_cu
->is_dwz
);
7285 per_cu
= dwarf2_find_containing_comp_unit (offset
, is_dwz
, cu
->objfile
);
7287 /* Queue the unit, if needed. */
7288 if (maybe_queue_comp_unit (cu
, per_cu
, cu
->language
))
7289 load_full_comp_unit (per_cu
, cu
->language
);
7291 VEC_safe_push (dwarf2_per_cu_ptr
, cu
->per_cu
->imported_symtabs
,
7296 /* Process a die and its children. */
7299 process_die (struct die_info
*die
, struct dwarf2_cu
*cu
)
7303 case DW_TAG_padding
:
7305 case DW_TAG_compile_unit
:
7306 case DW_TAG_partial_unit
:
7307 read_file_scope (die
, cu
);
7309 case DW_TAG_type_unit
:
7310 read_type_unit_scope (die
, cu
);
7312 case DW_TAG_subprogram
:
7313 case DW_TAG_inlined_subroutine
:
7314 read_func_scope (die
, cu
);
7316 case DW_TAG_lexical_block
:
7317 case DW_TAG_try_block
:
7318 case DW_TAG_catch_block
:
7319 read_lexical_block_scope (die
, cu
);
7321 case DW_TAG_GNU_call_site
:
7322 read_call_site_scope (die
, cu
);
7324 case DW_TAG_class_type
:
7325 case DW_TAG_interface_type
:
7326 case DW_TAG_structure_type
:
7327 case DW_TAG_union_type
:
7328 process_structure_scope (die
, cu
);
7330 case DW_TAG_enumeration_type
:
7331 process_enumeration_scope (die
, cu
);
7334 /* These dies have a type, but processing them does not create
7335 a symbol or recurse to process the children. Therefore we can
7336 read them on-demand through read_type_die. */
7337 case DW_TAG_subroutine_type
:
7338 case DW_TAG_set_type
:
7339 case DW_TAG_array_type
:
7340 case DW_TAG_pointer_type
:
7341 case DW_TAG_ptr_to_member_type
:
7342 case DW_TAG_reference_type
:
7343 case DW_TAG_string_type
:
7346 case DW_TAG_base_type
:
7347 case DW_TAG_subrange_type
:
7348 case DW_TAG_typedef
:
7349 /* Add a typedef symbol for the type definition, if it has a
7351 new_symbol (die
, read_type_die (die
, cu
), cu
);
7353 case DW_TAG_common_block
:
7354 read_common_block (die
, cu
);
7356 case DW_TAG_common_inclusion
:
7358 case DW_TAG_namespace
:
7359 cu
->processing_has_namespace_info
= 1;
7360 read_namespace (die
, cu
);
7363 cu
->processing_has_namespace_info
= 1;
7364 read_module (die
, cu
);
7366 case DW_TAG_imported_declaration
:
7367 case DW_TAG_imported_module
:
7368 cu
->processing_has_namespace_info
= 1;
7369 if (die
->child
!= NULL
&& (die
->tag
== DW_TAG_imported_declaration
7370 || cu
->language
!= language_fortran
))
7371 complaint (&symfile_complaints
, _("Tag '%s' has unexpected children"),
7372 dwarf_tag_name (die
->tag
));
7373 read_import_statement (die
, cu
);
7376 case DW_TAG_imported_unit
:
7377 process_imported_unit_die (die
, cu
);
7381 new_symbol (die
, NULL
, cu
);
7386 /* DWARF name computation. */
7388 /* A helper function for dwarf2_compute_name which determines whether DIE
7389 needs to have the name of the scope prepended to the name listed in the
7393 die_needs_namespace (struct die_info
*die
, struct dwarf2_cu
*cu
)
7395 struct attribute
*attr
;
7399 case DW_TAG_namespace
:
7400 case DW_TAG_typedef
:
7401 case DW_TAG_class_type
:
7402 case DW_TAG_interface_type
:
7403 case DW_TAG_structure_type
:
7404 case DW_TAG_union_type
:
7405 case DW_TAG_enumeration_type
:
7406 case DW_TAG_enumerator
:
7407 case DW_TAG_subprogram
:
7411 case DW_TAG_variable
:
7412 case DW_TAG_constant
:
7413 /* We only need to prefix "globally" visible variables. These include
7414 any variable marked with DW_AT_external or any variable that
7415 lives in a namespace. [Variables in anonymous namespaces
7416 require prefixing, but they are not DW_AT_external.] */
7418 if (dwarf2_attr (die
, DW_AT_specification
, cu
))
7420 struct dwarf2_cu
*spec_cu
= cu
;
7422 return die_needs_namespace (die_specification (die
, &spec_cu
),
7426 attr
= dwarf2_attr (die
, DW_AT_external
, cu
);
7427 if (attr
== NULL
&& die
->parent
->tag
!= DW_TAG_namespace
7428 && die
->parent
->tag
!= DW_TAG_module
)
7430 /* A variable in a lexical block of some kind does not need a
7431 namespace, even though in C++ such variables may be external
7432 and have a mangled name. */
7433 if (die
->parent
->tag
== DW_TAG_lexical_block
7434 || die
->parent
->tag
== DW_TAG_try_block
7435 || die
->parent
->tag
== DW_TAG_catch_block
7436 || die
->parent
->tag
== DW_TAG_subprogram
)
7445 /* Retrieve the last character from a mem_file. */
7448 do_ui_file_peek_last (void *object
, const char *buffer
, long length
)
7450 char *last_char_p
= (char *) object
;
7453 *last_char_p
= buffer
[length
- 1];
7456 /* Compute the fully qualified name of DIE in CU. If PHYSNAME is nonzero,
7457 compute the physname for the object, which include a method's:
7458 - formal parameters (C++/Java),
7459 - receiver type (Go),
7460 - return type (Java).
7462 The term "physname" is a bit confusing.
7463 For C++, for example, it is the demangled name.
7464 For Go, for example, it's the mangled name.
7466 For Ada, return the DIE's linkage name rather than the fully qualified
7467 name. PHYSNAME is ignored..
7469 The result is allocated on the objfile_obstack and canonicalized. */
7472 dwarf2_compute_name (const char *name
,
7473 struct die_info
*die
, struct dwarf2_cu
*cu
,
7476 struct objfile
*objfile
= cu
->objfile
;
7479 name
= dwarf2_name (die
, cu
);
7481 /* For Fortran GDB prefers DW_AT_*linkage_name if present but otherwise
7482 compute it by typename_concat inside GDB. */
7483 if (cu
->language
== language_ada
7484 || (cu
->language
== language_fortran
&& physname
))
7486 /* For Ada unit, we prefer the linkage name over the name, as
7487 the former contains the exported name, which the user expects
7488 to be able to reference. Ideally, we want the user to be able
7489 to reference this entity using either natural or linkage name,
7490 but we haven't started looking at this enhancement yet. */
7491 struct attribute
*attr
;
7493 attr
= dwarf2_attr (die
, DW_AT_linkage_name
, cu
);
7495 attr
= dwarf2_attr (die
, DW_AT_MIPS_linkage_name
, cu
);
7496 if (attr
&& DW_STRING (attr
))
7497 return DW_STRING (attr
);
7500 /* These are the only languages we know how to qualify names in. */
7502 && (cu
->language
== language_cplus
|| cu
->language
== language_java
7503 || cu
->language
== language_fortran
))
7505 if (die_needs_namespace (die
, cu
))
7509 struct ui_file
*buf
;
7511 prefix
= determine_prefix (die
, cu
);
7512 buf
= mem_fileopen ();
7513 if (*prefix
!= '\0')
7515 char *prefixed_name
= typename_concat (NULL
, prefix
, name
,
7518 fputs_unfiltered (prefixed_name
, buf
);
7519 xfree (prefixed_name
);
7522 fputs_unfiltered (name
, buf
);
7524 /* Template parameters may be specified in the DIE's DW_AT_name, or
7525 as children with DW_TAG_template_type_param or
7526 DW_TAG_value_type_param. If the latter, add them to the name
7527 here. If the name already has template parameters, then
7528 skip this step; some versions of GCC emit both, and
7529 it is more efficient to use the pre-computed name.
7531 Something to keep in mind about this process: it is very
7532 unlikely, or in some cases downright impossible, to produce
7533 something that will match the mangled name of a function.
7534 If the definition of the function has the same debug info,
7535 we should be able to match up with it anyway. But fallbacks
7536 using the minimal symbol, for instance to find a method
7537 implemented in a stripped copy of libstdc++, will not work.
7538 If we do not have debug info for the definition, we will have to
7539 match them up some other way.
7541 When we do name matching there is a related problem with function
7542 templates; two instantiated function templates are allowed to
7543 differ only by their return types, which we do not add here. */
7545 if (cu
->language
== language_cplus
&& strchr (name
, '<') == NULL
)
7547 struct attribute
*attr
;
7548 struct die_info
*child
;
7551 die
->building_fullname
= 1;
7553 for (child
= die
->child
; child
!= NULL
; child
= child
->sibling
)
7558 struct dwarf2_locexpr_baton
*baton
;
7561 if (child
->tag
!= DW_TAG_template_type_param
7562 && child
->tag
!= DW_TAG_template_value_param
)
7567 fputs_unfiltered ("<", buf
);
7571 fputs_unfiltered (", ", buf
);
7573 attr
= dwarf2_attr (child
, DW_AT_type
, cu
);
7576 complaint (&symfile_complaints
,
7577 _("template parameter missing DW_AT_type"));
7578 fputs_unfiltered ("UNKNOWN_TYPE", buf
);
7581 type
= die_type (child
, cu
);
7583 if (child
->tag
== DW_TAG_template_type_param
)
7585 c_print_type (type
, "", buf
, -1, 0, &type_print_raw_options
);
7589 attr
= dwarf2_attr (child
, DW_AT_const_value
, cu
);
7592 complaint (&symfile_complaints
,
7593 _("template parameter missing "
7594 "DW_AT_const_value"));
7595 fputs_unfiltered ("UNKNOWN_VALUE", buf
);
7599 dwarf2_const_value_attr (attr
, type
, name
,
7600 &cu
->comp_unit_obstack
, cu
,
7601 &value
, &bytes
, &baton
);
7603 if (TYPE_NOSIGN (type
))
7604 /* GDB prints characters as NUMBER 'CHAR'. If that's
7605 changed, this can use value_print instead. */
7606 c_printchar (value
, type
, buf
);
7609 struct value_print_options opts
;
7612 v
= dwarf2_evaluate_loc_desc (type
, NULL
,
7616 else if (bytes
!= NULL
)
7618 v
= allocate_value (type
);
7619 memcpy (value_contents_writeable (v
), bytes
,
7620 TYPE_LENGTH (type
));
7623 v
= value_from_longest (type
, value
);
7625 /* Specify decimal so that we do not depend on
7627 get_formatted_print_options (&opts
, 'd');
7629 value_print (v
, buf
, &opts
);
7635 die
->building_fullname
= 0;
7639 /* Close the argument list, with a space if necessary
7640 (nested templates). */
7641 char last_char
= '\0';
7642 ui_file_put (buf
, do_ui_file_peek_last
, &last_char
);
7643 if (last_char
== '>')
7644 fputs_unfiltered (" >", buf
);
7646 fputs_unfiltered (">", buf
);
7650 /* For Java and C++ methods, append formal parameter type
7651 information, if PHYSNAME. */
7653 if (physname
&& die
->tag
== DW_TAG_subprogram
7654 && (cu
->language
== language_cplus
7655 || cu
->language
== language_java
))
7657 struct type
*type
= read_type_die (die
, cu
);
7659 c_type_print_args (type
, buf
, 1, cu
->language
,
7660 &type_print_raw_options
);
7662 if (cu
->language
== language_java
)
7664 /* For java, we must append the return type to method
7666 if (die
->tag
== DW_TAG_subprogram
)
7667 java_print_type (TYPE_TARGET_TYPE (type
), "", buf
,
7668 0, 0, &type_print_raw_options
);
7670 else if (cu
->language
== language_cplus
)
7672 /* Assume that an artificial first parameter is
7673 "this", but do not crash if it is not. RealView
7674 marks unnamed (and thus unused) parameters as
7675 artificial; there is no way to differentiate
7677 if (TYPE_NFIELDS (type
) > 0
7678 && TYPE_FIELD_ARTIFICIAL (type
, 0)
7679 && TYPE_CODE (TYPE_FIELD_TYPE (type
, 0)) == TYPE_CODE_PTR
7680 && TYPE_CONST (TYPE_TARGET_TYPE (TYPE_FIELD_TYPE (type
,
7682 fputs_unfiltered (" const", buf
);
7686 name
= ui_file_obsavestring (buf
, &objfile
->objfile_obstack
,
7688 ui_file_delete (buf
);
7690 if (cu
->language
== language_cplus
)
7693 = dwarf2_canonicalize_name (name
, cu
,
7694 &objfile
->objfile_obstack
);
7705 /* Return the fully qualified name of DIE, based on its DW_AT_name.
7706 If scope qualifiers are appropriate they will be added. The result
7707 will be allocated on the objfile_obstack, or NULL if the DIE does
7708 not have a name. NAME may either be from a previous call to
7709 dwarf2_name or NULL.
7711 The output string will be canonicalized (if C++/Java). */
7714 dwarf2_full_name (const char *name
, struct die_info
*die
, struct dwarf2_cu
*cu
)
7716 return dwarf2_compute_name (name
, die
, cu
, 0);
7719 /* Construct a physname for the given DIE in CU. NAME may either be
7720 from a previous call to dwarf2_name or NULL. The result will be
7721 allocated on the objfile_objstack or NULL if the DIE does not have a
7724 The output string will be canonicalized (if C++/Java). */
7727 dwarf2_physname (const char *name
, struct die_info
*die
, struct dwarf2_cu
*cu
)
7729 struct objfile
*objfile
= cu
->objfile
;
7730 struct attribute
*attr
;
7731 const char *retval
, *mangled
= NULL
, *canon
= NULL
;
7732 struct cleanup
*back_to
;
7735 /* In this case dwarf2_compute_name is just a shortcut not building anything
7737 if (!die_needs_namespace (die
, cu
))
7738 return dwarf2_compute_name (name
, die
, cu
, 1);
7740 back_to
= make_cleanup (null_cleanup
, NULL
);
7742 attr
= dwarf2_attr (die
, DW_AT_linkage_name
, cu
);
7744 attr
= dwarf2_attr (die
, DW_AT_MIPS_linkage_name
, cu
);
7746 /* DW_AT_linkage_name is missing in some cases - depend on what GDB
7748 if (attr
&& DW_STRING (attr
))
7752 mangled
= DW_STRING (attr
);
7754 /* Use DMGL_RET_DROP for C++ template functions to suppress their return
7755 type. It is easier for GDB users to search for such functions as
7756 `name(params)' than `long name(params)'. In such case the minimal
7757 symbol names do not match the full symbol names but for template
7758 functions there is never a need to look up their definition from their
7759 declaration so the only disadvantage remains the minimal symbol
7760 variant `long name(params)' does not have the proper inferior type.
7763 if (cu
->language
== language_go
)
7765 /* This is a lie, but we already lie to the caller new_symbol_full.
7766 new_symbol_full assumes we return the mangled name.
7767 This just undoes that lie until things are cleaned up. */
7772 demangled
= cplus_demangle (mangled
,
7773 (DMGL_PARAMS
| DMGL_ANSI
7774 | (cu
->language
== language_java
7775 ? DMGL_JAVA
| DMGL_RET_POSTFIX
7780 make_cleanup (xfree
, demangled
);
7790 if (canon
== NULL
|| check_physname
)
7792 const char *physname
= dwarf2_compute_name (name
, die
, cu
, 1);
7794 if (canon
!= NULL
&& strcmp (physname
, canon
) != 0)
7796 /* It may not mean a bug in GDB. The compiler could also
7797 compute DW_AT_linkage_name incorrectly. But in such case
7798 GDB would need to be bug-to-bug compatible. */
7800 complaint (&symfile_complaints
,
7801 _("Computed physname <%s> does not match demangled <%s> "
7802 "(from linkage <%s>) - DIE at 0x%x [in module %s]"),
7803 physname
, canon
, mangled
, die
->offset
.sect_off
, objfile
->name
);
7805 /* Prefer DW_AT_linkage_name (in the CANON form) - when it
7806 is available here - over computed PHYSNAME. It is safer
7807 against both buggy GDB and buggy compilers. */
7821 retval
= obstack_copy0 (&objfile
->objfile_obstack
, retval
, strlen (retval
));
7823 do_cleanups (back_to
);
7827 /* Read the import statement specified by the given die and record it. */
7830 read_import_statement (struct die_info
*die
, struct dwarf2_cu
*cu
)
7832 struct objfile
*objfile
= cu
->objfile
;
7833 struct attribute
*import_attr
;
7834 struct die_info
*imported_die
, *child_die
;
7835 struct dwarf2_cu
*imported_cu
;
7836 const char *imported_name
;
7837 const char *imported_name_prefix
;
7838 const char *canonical_name
;
7839 const char *import_alias
;
7840 const char *imported_declaration
= NULL
;
7841 const char *import_prefix
;
7842 VEC (const_char_ptr
) *excludes
= NULL
;
7843 struct cleanup
*cleanups
;
7845 import_attr
= dwarf2_attr (die
, DW_AT_import
, cu
);
7846 if (import_attr
== NULL
)
7848 complaint (&symfile_complaints
, _("Tag '%s' has no DW_AT_import"),
7849 dwarf_tag_name (die
->tag
));
7854 imported_die
= follow_die_ref_or_sig (die
, import_attr
, &imported_cu
);
7855 imported_name
= dwarf2_name (imported_die
, imported_cu
);
7856 if (imported_name
== NULL
)
7858 /* GCC bug: https://bugzilla.redhat.com/show_bug.cgi?id=506524
7860 The import in the following code:
7874 <2><51>: Abbrev Number: 3 (DW_TAG_imported_declaration)
7875 <52> DW_AT_decl_file : 1
7876 <53> DW_AT_decl_line : 6
7877 <54> DW_AT_import : <0x75>
7878 <2><58>: Abbrev Number: 4 (DW_TAG_typedef)
7880 <5b> DW_AT_decl_file : 1
7881 <5c> DW_AT_decl_line : 2
7882 <5d> DW_AT_type : <0x6e>
7884 <1><75>: Abbrev Number: 7 (DW_TAG_base_type)
7885 <76> DW_AT_byte_size : 4
7886 <77> DW_AT_encoding : 5 (signed)
7888 imports the wrong die ( 0x75 instead of 0x58 ).
7889 This case will be ignored until the gcc bug is fixed. */
7893 /* Figure out the local name after import. */
7894 import_alias
= dwarf2_name (die
, cu
);
7896 /* Figure out where the statement is being imported to. */
7897 import_prefix
= determine_prefix (die
, cu
);
7899 /* Figure out what the scope of the imported die is and prepend it
7900 to the name of the imported die. */
7901 imported_name_prefix
= determine_prefix (imported_die
, imported_cu
);
7903 if (imported_die
->tag
!= DW_TAG_namespace
7904 && imported_die
->tag
!= DW_TAG_module
)
7906 imported_declaration
= imported_name
;
7907 canonical_name
= imported_name_prefix
;
7909 else if (strlen (imported_name_prefix
) > 0)
7910 canonical_name
= obconcat (&objfile
->objfile_obstack
,
7911 imported_name_prefix
, "::", imported_name
,
7914 canonical_name
= imported_name
;
7916 cleanups
= make_cleanup (VEC_cleanup (const_char_ptr
), &excludes
);
7918 if (die
->tag
== DW_TAG_imported_module
&& cu
->language
== language_fortran
)
7919 for (child_die
= die
->child
; child_die
&& child_die
->tag
;
7920 child_die
= sibling_die (child_die
))
7922 /* DWARF-4: A Fortran use statement with a “rename list” may be
7923 represented by an imported module entry with an import attribute
7924 referring to the module and owned entries corresponding to those
7925 entities that are renamed as part of being imported. */
7927 if (child_die
->tag
!= DW_TAG_imported_declaration
)
7929 complaint (&symfile_complaints
,
7930 _("child DW_TAG_imported_declaration expected "
7931 "- DIE at 0x%x [in module %s]"),
7932 child_die
->offset
.sect_off
, objfile
->name
);
7936 import_attr
= dwarf2_attr (child_die
, DW_AT_import
, cu
);
7937 if (import_attr
== NULL
)
7939 complaint (&symfile_complaints
, _("Tag '%s' has no DW_AT_import"),
7940 dwarf_tag_name (child_die
->tag
));
7945 imported_die
= follow_die_ref_or_sig (child_die
, import_attr
,
7947 imported_name
= dwarf2_name (imported_die
, imported_cu
);
7948 if (imported_name
== NULL
)
7950 complaint (&symfile_complaints
,
7951 _("child DW_TAG_imported_declaration has unknown "
7952 "imported name - DIE at 0x%x [in module %s]"),
7953 child_die
->offset
.sect_off
, objfile
->name
);
7957 VEC_safe_push (const_char_ptr
, excludes
, imported_name
);
7959 process_die (child_die
, cu
);
7962 cp_add_using_directive (import_prefix
,
7965 imported_declaration
,
7968 &objfile
->objfile_obstack
);
7970 do_cleanups (cleanups
);
7973 /* Cleanup function for handle_DW_AT_stmt_list. */
7976 free_cu_line_header (void *arg
)
7978 struct dwarf2_cu
*cu
= arg
;
7980 free_line_header (cu
->line_header
);
7981 cu
->line_header
= NULL
;
7984 /* Check for possibly missing DW_AT_comp_dir with relative .debug_line
7985 directory paths. GCC SVN r127613 (new option -fdebug-prefix-map) fixed
7986 this, it was first present in GCC release 4.3.0. */
7989 producer_is_gcc_lt_4_3 (struct dwarf2_cu
*cu
)
7991 if (!cu
->checked_producer
)
7992 check_producer (cu
);
7994 return cu
->producer_is_gcc_lt_4_3
;
7998 find_file_and_directory (struct die_info
*die
, struct dwarf2_cu
*cu
,
7999 const char **name
, const char **comp_dir
)
8001 struct attribute
*attr
;
8006 /* Find the filename. Do not use dwarf2_name here, since the filename
8007 is not a source language identifier. */
8008 attr
= dwarf2_attr (die
, DW_AT_name
, cu
);
8011 *name
= DW_STRING (attr
);
8014 attr
= dwarf2_attr (die
, DW_AT_comp_dir
, cu
);
8016 *comp_dir
= DW_STRING (attr
);
8017 else if (producer_is_gcc_lt_4_3 (cu
) && *name
!= NULL
8018 && IS_ABSOLUTE_PATH (*name
))
8020 char *d
= ldirname (*name
);
8024 make_cleanup (xfree
, d
);
8026 if (*comp_dir
!= NULL
)
8028 /* Irix 6.2 native cc prepends <machine>.: to the compilation
8029 directory, get rid of it. */
8030 char *cp
= strchr (*comp_dir
, ':');
8032 if (cp
&& cp
!= *comp_dir
&& cp
[-1] == '.' && cp
[1] == '/')
8037 *name
= "<unknown>";
8040 /* Handle DW_AT_stmt_list for a compilation unit.
8041 DIE is the DW_TAG_compile_unit die for CU.
8042 COMP_DIR is the compilation directory.
8043 WANT_LINE_INFO is non-zero if the pc/line-number mapping is needed. */
8046 handle_DW_AT_stmt_list (struct die_info
*die
, struct dwarf2_cu
*cu
,
8047 const char *comp_dir
)
8049 struct attribute
*attr
;
8051 gdb_assert (! cu
->per_cu
->is_debug_types
);
8053 attr
= dwarf2_attr (die
, DW_AT_stmt_list
, cu
);
8056 unsigned int line_offset
= DW_UNSND (attr
);
8057 struct line_header
*line_header
8058 = dwarf_decode_line_header (line_offset
, cu
);
8062 cu
->line_header
= line_header
;
8063 make_cleanup (free_cu_line_header
, cu
);
8064 dwarf_decode_lines (line_header
, comp_dir
, cu
, NULL
, 1);
8069 /* Process DW_TAG_compile_unit or DW_TAG_partial_unit. */
8072 read_file_scope (struct die_info
*die
, struct dwarf2_cu
*cu
)
8074 struct objfile
*objfile
= dwarf2_per_objfile
->objfile
;
8075 struct cleanup
*back_to
= make_cleanup (null_cleanup
, 0);
8076 CORE_ADDR lowpc
= ((CORE_ADDR
) -1);
8077 CORE_ADDR highpc
= ((CORE_ADDR
) 0);
8078 struct attribute
*attr
;
8079 const char *name
= NULL
;
8080 const char *comp_dir
= NULL
;
8081 struct die_info
*child_die
;
8082 bfd
*abfd
= objfile
->obfd
;
8085 baseaddr
= ANOFFSET (objfile
->section_offsets
, SECT_OFF_TEXT (objfile
));
8087 get_scope_pc_bounds (die
, &lowpc
, &highpc
, cu
);
8089 /* If we didn't find a lowpc, set it to highpc to avoid complaints
8090 from finish_block. */
8091 if (lowpc
== ((CORE_ADDR
) -1))
8096 find_file_and_directory (die
, cu
, &name
, &comp_dir
);
8098 prepare_one_comp_unit (cu
, die
, cu
->language
);
8100 /* The XLCL doesn't generate DW_LANG_OpenCL because this attribute is not
8101 standardised yet. As a workaround for the language detection we fall
8102 back to the DW_AT_producer string. */
8103 if (cu
->producer
&& strstr (cu
->producer
, "IBM XL C for OpenCL") != NULL
)
8104 cu
->language
= language_opencl
;
8106 /* Similar hack for Go. */
8107 if (cu
->producer
&& strstr (cu
->producer
, "GNU Go ") != NULL
)
8108 set_cu_language (DW_LANG_Go
, cu
);
8110 dwarf2_start_symtab (cu
, name
, comp_dir
, lowpc
);
8112 /* Decode line number information if present. We do this before
8113 processing child DIEs, so that the line header table is available
8114 for DW_AT_decl_file. */
8115 handle_DW_AT_stmt_list (die
, cu
, comp_dir
);
8117 /* Process all dies in compilation unit. */
8118 if (die
->child
!= NULL
)
8120 child_die
= die
->child
;
8121 while (child_die
&& child_die
->tag
)
8123 process_die (child_die
, cu
);
8124 child_die
= sibling_die (child_die
);
8128 /* Decode macro information, if present. Dwarf 2 macro information
8129 refers to information in the line number info statement program
8130 header, so we can only read it if we've read the header
8132 attr
= dwarf2_attr (die
, DW_AT_GNU_macros
, cu
);
8133 if (attr
&& cu
->line_header
)
8135 if (dwarf2_attr (die
, DW_AT_macro_info
, cu
))
8136 complaint (&symfile_complaints
,
8137 _("CU refers to both DW_AT_GNU_macros and DW_AT_macro_info"));
8139 dwarf_decode_macros (cu
, DW_UNSND (attr
), comp_dir
, 1);
8143 attr
= dwarf2_attr (die
, DW_AT_macro_info
, cu
);
8144 if (attr
&& cu
->line_header
)
8146 unsigned int macro_offset
= DW_UNSND (attr
);
8148 dwarf_decode_macros (cu
, macro_offset
, comp_dir
, 0);
8152 do_cleanups (back_to
);
8155 /* TU version of handle_DW_AT_stmt_list for read_type_unit_scope.
8156 Create the set of symtabs used by this TU, or if this TU is sharing
8157 symtabs with another TU and the symtabs have already been created
8158 then restore those symtabs in the line header.
8159 We don't need the pc/line-number mapping for type units. */
8162 setup_type_unit_groups (struct die_info
*die
, struct dwarf2_cu
*cu
)
8164 struct objfile
*objfile
= dwarf2_per_objfile
->objfile
;
8165 struct dwarf2_per_cu_data
*per_cu
= cu
->per_cu
;
8166 struct type_unit_group
*tu_group
;
8168 struct line_header
*lh
;
8169 struct attribute
*attr
;
8170 unsigned int i
, line_offset
;
8171 struct signatured_type
*sig_type
;
8173 gdb_assert (per_cu
->is_debug_types
);
8174 sig_type
= (struct signatured_type
*) per_cu
;
8176 attr
= dwarf2_attr (die
, DW_AT_stmt_list
, cu
);
8178 /* If we're using .gdb_index (includes -readnow) then
8179 per_cu->s.type_unit_group may not have been set up yet. */
8180 if (sig_type
->type_unit_group
== NULL
)
8181 sig_type
->type_unit_group
= get_type_unit_group (cu
, attr
);
8182 tu_group
= sig_type
->type_unit_group
;
8184 /* If we've already processed this stmt_list there's no real need to
8185 do it again, we could fake it and just recreate the part we need
8186 (file name,index -> symtab mapping). If data shows this optimization
8187 is useful we can do it then. */
8188 first_time
= tu_group
->primary_symtab
== NULL
;
8190 /* We have to handle the case of both a missing DW_AT_stmt_list or bad
8195 line_offset
= DW_UNSND (attr
);
8196 lh
= dwarf_decode_line_header (line_offset
, cu
);
8201 dwarf2_start_symtab (cu
, "", NULL
, 0);
8204 gdb_assert (tu_group
->symtabs
== NULL
);
8207 /* Note: The primary symtab will get allocated at the end. */
8211 cu
->line_header
= lh
;
8212 make_cleanup (free_cu_line_header
, cu
);
8216 dwarf2_start_symtab (cu
, "", NULL
, 0);
8218 tu_group
->num_symtabs
= lh
->num_file_names
;
8219 tu_group
->symtabs
= XNEWVEC (struct symtab
*, lh
->num_file_names
);
8221 for (i
= 0; i
< lh
->num_file_names
; ++i
)
8224 struct file_entry
*fe
= &lh
->file_names
[i
];
8227 dir
= lh
->include_dirs
[fe
->dir_index
- 1];
8228 dwarf2_start_subfile (fe
->name
, dir
, NULL
);
8230 /* Note: We don't have to watch for the main subfile here, type units
8231 don't have DW_AT_name. */
8233 if (current_subfile
->symtab
== NULL
)
8235 /* NOTE: start_subfile will recognize when it's been passed
8236 a file it has already seen. So we can't assume there's a
8237 simple mapping from lh->file_names to subfiles,
8238 lh->file_names may contain dups. */
8239 current_subfile
->symtab
= allocate_symtab (current_subfile
->name
,
8243 fe
->symtab
= current_subfile
->symtab
;
8244 tu_group
->symtabs
[i
] = fe
->symtab
;
8251 for (i
= 0; i
< lh
->num_file_names
; ++i
)
8253 struct file_entry
*fe
= &lh
->file_names
[i
];
8255 fe
->symtab
= tu_group
->symtabs
[i
];
8259 /* The main symtab is allocated last. Type units don't have DW_AT_name
8260 so they don't have a "real" (so to speak) symtab anyway.
8261 There is later code that will assign the main symtab to all symbols
8262 that don't have one. We need to handle the case of a symbol with a
8263 missing symtab (DW_AT_decl_file) anyway. */
8266 /* Process DW_TAG_type_unit.
8267 For TUs we want to skip the first top level sibling if it's not the
8268 actual type being defined by this TU. In this case the first top
8269 level sibling is there to provide context only. */
8272 read_type_unit_scope (struct die_info
*die
, struct dwarf2_cu
*cu
)
8274 struct die_info
*child_die
;
8276 prepare_one_comp_unit (cu
, die
, language_minimal
);
8278 /* Initialize (or reinitialize) the machinery for building symtabs.
8279 We do this before processing child DIEs, so that the line header table
8280 is available for DW_AT_decl_file. */
8281 setup_type_unit_groups (die
, cu
);
8283 if (die
->child
!= NULL
)
8285 child_die
= die
->child
;
8286 while (child_die
&& child_die
->tag
)
8288 process_die (child_die
, cu
);
8289 child_die
= sibling_die (child_die
);
8296 http://gcc.gnu.org/wiki/DebugFission
8297 http://gcc.gnu.org/wiki/DebugFissionDWP
8299 To simplify handling of both DWO files ("object" files with the DWARF info)
8300 and DWP files (a file with the DWOs packaged up into one file), we treat
8301 DWP files as having a collection of virtual DWO files. */
8304 hash_dwo_file (const void *item
)
8306 const struct dwo_file
*dwo_file
= item
;
8308 return (htab_hash_string (dwo_file
->dwo_name
)
8309 + htab_hash_string (dwo_file
->comp_dir
));
8313 eq_dwo_file (const void *item_lhs
, const void *item_rhs
)
8315 const struct dwo_file
*lhs
= item_lhs
;
8316 const struct dwo_file
*rhs
= item_rhs
;
8318 return (strcmp (lhs
->dwo_name
, rhs
->dwo_name
) == 0
8319 && strcmp (lhs
->comp_dir
, rhs
->comp_dir
) == 0);
8322 /* Allocate a hash table for DWO files. */
8325 allocate_dwo_file_hash_table (void)
8327 struct objfile
*objfile
= dwarf2_per_objfile
->objfile
;
8329 return htab_create_alloc_ex (41,
8333 &objfile
->objfile_obstack
,
8334 hashtab_obstack_allocate
,
8335 dummy_obstack_deallocate
);
8338 /* Lookup DWO file DWO_NAME. */
8341 lookup_dwo_file_slot (const char *dwo_name
, const char *comp_dir
)
8343 struct dwo_file find_entry
;
8346 if (dwarf2_per_objfile
->dwo_files
== NULL
)
8347 dwarf2_per_objfile
->dwo_files
= allocate_dwo_file_hash_table ();
8349 memset (&find_entry
, 0, sizeof (find_entry
));
8350 find_entry
.dwo_name
= dwo_name
;
8351 find_entry
.comp_dir
= comp_dir
;
8352 slot
= htab_find_slot (dwarf2_per_objfile
->dwo_files
, &find_entry
, INSERT
);
8358 hash_dwo_unit (const void *item
)
8360 const struct dwo_unit
*dwo_unit
= item
;
8362 /* This drops the top 32 bits of the id, but is ok for a hash. */
8363 return dwo_unit
->signature
;
8367 eq_dwo_unit (const void *item_lhs
, const void *item_rhs
)
8369 const struct dwo_unit
*lhs
= item_lhs
;
8370 const struct dwo_unit
*rhs
= item_rhs
;
8372 /* The signature is assumed to be unique within the DWO file.
8373 So while object file CU dwo_id's always have the value zero,
8374 that's OK, assuming each object file DWO file has only one CU,
8375 and that's the rule for now. */
8376 return lhs
->signature
== rhs
->signature
;
8379 /* Allocate a hash table for DWO CUs,TUs.
8380 There is one of these tables for each of CUs,TUs for each DWO file. */
8383 allocate_dwo_unit_table (struct objfile
*objfile
)
8385 /* Start out with a pretty small number.
8386 Generally DWO files contain only one CU and maybe some TUs. */
8387 return htab_create_alloc_ex (3,
8391 &objfile
->objfile_obstack
,
8392 hashtab_obstack_allocate
,
8393 dummy_obstack_deallocate
);
8396 /* Structure used to pass data to create_dwo_debug_info_hash_table_reader. */
8398 struct create_dwo_info_table_data
8400 struct dwo_file
*dwo_file
;
8404 /* die_reader_func for create_dwo_debug_info_hash_table. */
8407 create_dwo_debug_info_hash_table_reader (const struct die_reader_specs
*reader
,
8409 struct die_info
*comp_unit_die
,
8413 struct dwarf2_cu
*cu
= reader
->cu
;
8414 struct objfile
*objfile
= dwarf2_per_objfile
->objfile
;
8415 sect_offset offset
= cu
->per_cu
->offset
;
8416 struct dwarf2_section_info
*section
= cu
->per_cu
->section
;
8417 struct create_dwo_info_table_data
*data
= datap
;
8418 struct dwo_file
*dwo_file
= data
->dwo_file
;
8419 htab_t cu_htab
= data
->cu_htab
;
8421 struct attribute
*attr
;
8422 struct dwo_unit
*dwo_unit
;
8424 attr
= dwarf2_attr (comp_unit_die
, DW_AT_GNU_dwo_id
, cu
);
8427 error (_("Dwarf Error: debug entry at offset 0x%x is missing"
8428 " its dwo_id [in module %s]"),
8429 offset
.sect_off
, dwo_file
->dwo_name
);
8433 dwo_unit
= OBSTACK_ZALLOC (&objfile
->objfile_obstack
, struct dwo_unit
);
8434 dwo_unit
->dwo_file
= dwo_file
;
8435 dwo_unit
->signature
= DW_UNSND (attr
);
8436 dwo_unit
->section
= section
;
8437 dwo_unit
->offset
= offset
;
8438 dwo_unit
->length
= cu
->per_cu
->length
;
8440 slot
= htab_find_slot (cu_htab
, dwo_unit
, INSERT
);
8441 gdb_assert (slot
!= NULL
);
8444 const struct dwo_unit
*dup_dwo_unit
= *slot
;
8446 complaint (&symfile_complaints
,
8447 _("debug entry at offset 0x%x is duplicate to the entry at"
8448 " offset 0x%x, dwo_id 0x%s [in module %s]"),
8449 offset
.sect_off
, dup_dwo_unit
->offset
.sect_off
,
8450 phex (dwo_unit
->signature
, sizeof (dwo_unit
->signature
)),
8451 dwo_file
->dwo_name
);
8456 if (dwarf2_read_debug
)
8457 fprintf_unfiltered (gdb_stdlog
, " offset 0x%x, dwo_id 0x%s\n",
8459 phex (dwo_unit
->signature
,
8460 sizeof (dwo_unit
->signature
)));
8463 /* Create a hash table to map DWO IDs to their CU entry in
8464 .debug_info.dwo in DWO_FILE.
8465 Note: This function processes DWO files only, not DWP files.
8466 Note: A DWO file generally contains one CU, but we don't assume this. */
8469 create_dwo_debug_info_hash_table (struct dwo_file
*dwo_file
)
8471 struct objfile
*objfile
= dwarf2_per_objfile
->objfile
;
8472 struct dwarf2_section_info
*section
= &dwo_file
->sections
.info
;
8475 gdb_byte
*info_ptr
, *end_ptr
;
8476 struct create_dwo_info_table_data create_dwo_info_table_data
;
8478 dwarf2_read_section (objfile
, section
);
8479 info_ptr
= section
->buffer
;
8481 if (info_ptr
== NULL
)
8484 /* We can't set abfd until now because the section may be empty or
8485 not present, in which case section->asection will be NULL. */
8486 abfd
= section
->asection
->owner
;
8488 if (dwarf2_read_debug
)
8489 fprintf_unfiltered (gdb_stdlog
, "Reading .debug_info.dwo for %s:\n",
8490 bfd_get_filename (abfd
));
8492 cu_htab
= allocate_dwo_unit_table (objfile
);
8494 create_dwo_info_table_data
.dwo_file
= dwo_file
;
8495 create_dwo_info_table_data
.cu_htab
= cu_htab
;
8497 end_ptr
= info_ptr
+ section
->size
;
8498 while (info_ptr
< end_ptr
)
8500 struct dwarf2_per_cu_data per_cu
;
8502 memset (&per_cu
, 0, sizeof (per_cu
));
8503 per_cu
.objfile
= objfile
;
8504 per_cu
.is_debug_types
= 0;
8505 per_cu
.offset
.sect_off
= info_ptr
- section
->buffer
;
8506 per_cu
.section
= section
;
8508 init_cutu_and_read_dies_no_follow (&per_cu
,
8509 &dwo_file
->sections
.abbrev
,
8511 create_dwo_debug_info_hash_table_reader
,
8512 &create_dwo_info_table_data
);
8514 info_ptr
+= per_cu
.length
;
8520 /* DWP file .debug_{cu,tu}_index section format:
8521 [ref: http://gcc.gnu.org/wiki/DebugFissionDWP]
8523 Both index sections have the same format, and serve to map a 64-bit
8524 signature to a set of section numbers. Each section begins with a header,
8525 followed by a hash table of 64-bit signatures, a parallel table of 32-bit
8526 indexes, and a pool of 32-bit section numbers. The index sections will be
8527 aligned at 8-byte boundaries in the file.
8529 The index section header contains two unsigned 32-bit values (using the
8530 byte order of the application binary):
8532 N, the number of compilation units or type units in the index
8533 M, the number of slots in the hash table
8535 (We assume that N and M will not exceed 2^32 - 1.)
8537 The size of the hash table, M, must be 2^k such that 2^k > 3*N/2.
8539 The hash table begins at offset 8 in the section, and consists of an array
8540 of M 64-bit slots. Each slot contains a 64-bit signature (using the byte
8541 order of the application binary). Unused slots in the hash table are 0.
8542 (We rely on the extreme unlikeliness of a signature being exactly 0.)
8544 The parallel table begins immediately after the hash table
8545 (at offset 8 + 8 * M from the beginning of the section), and consists of an
8546 array of 32-bit indexes (using the byte order of the application binary),
8547 corresponding 1-1 with slots in the hash table. Each entry in the parallel
8548 table contains a 32-bit index into the pool of section numbers. For unused
8549 hash table slots, the corresponding entry in the parallel table will be 0.
8551 Given a 64-bit compilation unit signature or a type signature S, an entry
8552 in the hash table is located as follows:
8554 1) Calculate a primary hash H = S & MASK(k), where MASK(k) is a mask with
8555 the low-order k bits all set to 1.
8557 2) Calculate a secondary hash H' = (((S >> 32) & MASK(k)) | 1).
8559 3) If the hash table entry at index H matches the signature, use that
8560 entry. If the hash table entry at index H is unused (all zeroes),
8561 terminate the search: the signature is not present in the table.
8563 4) Let H = (H + H') modulo M. Repeat at Step 3.
8565 Because M > N and H' and M are relatively prime, the search is guaranteed
8566 to stop at an unused slot or find the match.
8568 The pool of section numbers begins immediately following the hash table
8569 (at offset 8 + 12 * M from the beginning of the section). The pool of
8570 section numbers consists of an array of 32-bit words (using the byte order
8571 of the application binary). Each item in the array is indexed starting
8572 from 0. The hash table entry provides the index of the first section
8573 number in the set. Additional section numbers in the set follow, and the
8574 set is terminated by a 0 entry (section number 0 is not used in ELF).
8576 In each set of section numbers, the .debug_info.dwo or .debug_types.dwo
8577 section must be the first entry in the set, and the .debug_abbrev.dwo must
8578 be the second entry. Other members of the set may follow in any order. */
8580 /* Create a hash table to map DWO IDs to their CU/TU entry in
8581 .debug_{info,types}.dwo in DWP_FILE.
8582 Returns NULL if there isn't one.
8583 Note: This function processes DWP files only, not DWO files. */
8585 static struct dwp_hash_table
*
8586 create_dwp_hash_table (struct dwp_file
*dwp_file
, int is_debug_types
)
8588 struct objfile
*objfile
= dwarf2_per_objfile
->objfile
;
8589 bfd
*dbfd
= dwp_file
->dbfd
;
8590 char *index_ptr
, *index_end
;
8591 struct dwarf2_section_info
*index
;
8592 uint32_t version
, nr_units
, nr_slots
;
8593 struct dwp_hash_table
*htab
;
8596 index
= &dwp_file
->sections
.tu_index
;
8598 index
= &dwp_file
->sections
.cu_index
;
8600 if (dwarf2_section_empty_p (index
))
8602 dwarf2_read_section (objfile
, index
);
8604 index_ptr
= index
->buffer
;
8605 index_end
= index_ptr
+ index
->size
;
8607 version
= read_4_bytes (dbfd
, index_ptr
);
8608 index_ptr
+= 8; /* Skip the unused word. */
8609 nr_units
= read_4_bytes (dbfd
, index_ptr
);
8611 nr_slots
= read_4_bytes (dbfd
, index_ptr
);
8616 error (_("Dwarf Error: unsupported DWP file version (%u)"
8618 version
, dwp_file
->name
);
8620 if (nr_slots
!= (nr_slots
& -nr_slots
))
8622 error (_("Dwarf Error: number of slots in DWP hash table (%u)"
8623 " is not power of 2 [in module %s]"),
8624 nr_slots
, dwp_file
->name
);
8627 htab
= OBSTACK_ZALLOC (&objfile
->objfile_obstack
, struct dwp_hash_table
);
8628 htab
->nr_units
= nr_units
;
8629 htab
->nr_slots
= nr_slots
;
8630 htab
->hash_table
= index_ptr
;
8631 htab
->unit_table
= htab
->hash_table
+ sizeof (uint64_t) * nr_slots
;
8632 htab
->section_pool
= htab
->unit_table
+ sizeof (uint32_t) * nr_slots
;
8637 /* Update SECTIONS with the data from SECTP.
8639 This function is like the other "locate" section routines that are
8640 passed to bfd_map_over_sections, but in this context the sections to
8641 read comes from the DWP hash table, not the full ELF section table.
8643 The result is non-zero for success, or zero if an error was found. */
8646 locate_virtual_dwo_sections (asection
*sectp
,
8647 struct virtual_dwo_sections
*sections
)
8649 const struct dwop_section_names
*names
= &dwop_section_names
;
8651 if (section_is_p (sectp
->name
, &names
->abbrev_dwo
))
8653 /* There can be only one. */
8654 if (sections
->abbrev
.asection
!= NULL
)
8656 sections
->abbrev
.asection
= sectp
;
8657 sections
->abbrev
.size
= bfd_get_section_size (sectp
);
8659 else if (section_is_p (sectp
->name
, &names
->info_dwo
)
8660 || section_is_p (sectp
->name
, &names
->types_dwo
))
8662 /* There can be only one. */
8663 if (sections
->info_or_types
.asection
!= NULL
)
8665 sections
->info_or_types
.asection
= sectp
;
8666 sections
->info_or_types
.size
= bfd_get_section_size (sectp
);
8668 else if (section_is_p (sectp
->name
, &names
->line_dwo
))
8670 /* There can be only one. */
8671 if (sections
->line
.asection
!= NULL
)
8673 sections
->line
.asection
= sectp
;
8674 sections
->line
.size
= bfd_get_section_size (sectp
);
8676 else if (section_is_p (sectp
->name
, &names
->loc_dwo
))
8678 /* There can be only one. */
8679 if (sections
->loc
.asection
!= NULL
)
8681 sections
->loc
.asection
= sectp
;
8682 sections
->loc
.size
= bfd_get_section_size (sectp
);
8684 else if (section_is_p (sectp
->name
, &names
->macinfo_dwo
))
8686 /* There can be only one. */
8687 if (sections
->macinfo
.asection
!= NULL
)
8689 sections
->macinfo
.asection
= sectp
;
8690 sections
->macinfo
.size
= bfd_get_section_size (sectp
);
8692 else if (section_is_p (sectp
->name
, &names
->macro_dwo
))
8694 /* There can be only one. */
8695 if (sections
->macro
.asection
!= NULL
)
8697 sections
->macro
.asection
= sectp
;
8698 sections
->macro
.size
= bfd_get_section_size (sectp
);
8700 else if (section_is_p (sectp
->name
, &names
->str_offsets_dwo
))
8702 /* There can be only one. */
8703 if (sections
->str_offsets
.asection
!= NULL
)
8705 sections
->str_offsets
.asection
= sectp
;
8706 sections
->str_offsets
.size
= bfd_get_section_size (sectp
);
8710 /* No other kind of section is valid. */
8717 /* Create a dwo_unit object for the DWO with signature SIGNATURE.
8718 HTAB is the hash table from the DWP file.
8719 SECTION_INDEX is the index of the DWO in HTAB.
8720 COMP_DIR is the DW_AT_comp_dir attribute of the referencing CU. */
8722 static struct dwo_unit
*
8723 create_dwo_in_dwp (struct dwp_file
*dwp_file
,
8724 const struct dwp_hash_table
*htab
,
8725 uint32_t section_index
,
8726 const char *comp_dir
,
8727 ULONGEST signature
, int is_debug_types
)
8729 struct objfile
*objfile
= dwarf2_per_objfile
->objfile
;
8730 bfd
*dbfd
= dwp_file
->dbfd
;
8731 const char *kind
= is_debug_types
? "TU" : "CU";
8732 struct dwo_file
*dwo_file
;
8733 struct dwo_unit
*dwo_unit
;
8734 struct virtual_dwo_sections sections
;
8735 void **dwo_file_slot
;
8736 char *virtual_dwo_name
;
8737 struct dwarf2_section_info
*cutu
;
8738 struct cleanup
*cleanups
;
8741 if (dwarf2_read_debug
)
8743 fprintf_unfiltered (gdb_stdlog
, "Reading %s %u/0x%s in DWP file: %s\n",
8745 section_index
, phex (signature
, sizeof (signature
)),
8749 /* Fetch the sections of this DWO.
8750 Put a limit on the number of sections we look for so that bad data
8751 doesn't cause us to loop forever. */
8753 #define MAX_NR_DWO_SECTIONS \
8754 (1 /* .debug_info or .debug_types */ \
8755 + 1 /* .debug_abbrev */ \
8756 + 1 /* .debug_line */ \
8757 + 1 /* .debug_loc */ \
8758 + 1 /* .debug_str_offsets */ \
8759 + 1 /* .debug_macro */ \
8760 + 1 /* .debug_macinfo */ \
8761 + 1 /* trailing zero */)
8763 memset (§ions
, 0, sizeof (sections
));
8764 cleanups
= make_cleanup (null_cleanup
, 0);
8766 for (i
= 0; i
< MAX_NR_DWO_SECTIONS
; ++i
)
8769 uint32_t section_nr
=
8772 + (section_index
+ i
) * sizeof (uint32_t));
8774 if (section_nr
== 0)
8776 if (section_nr
>= dwp_file
->num_sections
)
8778 error (_("Dwarf Error: bad DWP hash table, section number too large"
8783 sectp
= dwp_file
->elf_sections
[section_nr
];
8784 if (! locate_virtual_dwo_sections (sectp
, §ions
))
8786 error (_("Dwarf Error: bad DWP hash table, invalid section found"
8793 || sections
.info_or_types
.asection
== NULL
8794 || sections
.abbrev
.asection
== NULL
)
8796 error (_("Dwarf Error: bad DWP hash table, missing DWO sections"
8800 if (i
== MAX_NR_DWO_SECTIONS
)
8802 error (_("Dwarf Error: bad DWP hash table, too many DWO sections"
8807 /* It's easier for the rest of the code if we fake a struct dwo_file and
8808 have dwo_unit "live" in that. At least for now.
8810 The DWP file can be made up of a random collection of CUs and TUs.
8811 However, for each CU + set of TUs that came from the same original DWO
8812 file, we want to combine them back into a virtual DWO file to save space
8813 (fewer struct dwo_file objects to allocated). Remember that for really
8814 large apps there can be on the order of 8K CUs and 200K TUs, or more. */
8817 xstrprintf ("virtual-dwo/%d-%d-%d-%d",
8818 sections
.abbrev
.asection
? sections
.abbrev
.asection
->id
: 0,
8819 sections
.line
.asection
? sections
.line
.asection
->id
: 0,
8820 sections
.loc
.asection
? sections
.loc
.asection
->id
: 0,
8821 (sections
.str_offsets
.asection
8822 ? sections
.str_offsets
.asection
->id
8824 make_cleanup (xfree
, virtual_dwo_name
);
8825 /* Can we use an existing virtual DWO file? */
8826 dwo_file_slot
= lookup_dwo_file_slot (virtual_dwo_name
, comp_dir
);
8827 /* Create one if necessary. */
8828 if (*dwo_file_slot
== NULL
)
8830 if (dwarf2_read_debug
)
8832 fprintf_unfiltered (gdb_stdlog
, "Creating virtual DWO: %s\n",
8835 dwo_file
= OBSTACK_ZALLOC (&objfile
->objfile_obstack
, struct dwo_file
);
8836 dwo_file
->dwo_name
= obstack_copy0 (&objfile
->objfile_obstack
,
8838 strlen (virtual_dwo_name
));
8839 dwo_file
->comp_dir
= comp_dir
;
8840 dwo_file
->sections
.abbrev
= sections
.abbrev
;
8841 dwo_file
->sections
.line
= sections
.line
;
8842 dwo_file
->sections
.loc
= sections
.loc
;
8843 dwo_file
->sections
.macinfo
= sections
.macinfo
;
8844 dwo_file
->sections
.macro
= sections
.macro
;
8845 dwo_file
->sections
.str_offsets
= sections
.str_offsets
;
8846 /* The "str" section is global to the entire DWP file. */
8847 dwo_file
->sections
.str
= dwp_file
->sections
.str
;
8848 /* The info or types section is assigned later to dwo_unit,
8849 there's no need to record it in dwo_file.
8850 Also, we can't simply record type sections in dwo_file because
8851 we record a pointer into the vector in dwo_unit. As we collect more
8852 types we'll grow the vector and eventually have to reallocate space
8853 for it, invalidating all the pointers into the current copy. */
8854 *dwo_file_slot
= dwo_file
;
8858 if (dwarf2_read_debug
)
8860 fprintf_unfiltered (gdb_stdlog
, "Using existing virtual DWO: %s\n",
8863 dwo_file
= *dwo_file_slot
;
8865 do_cleanups (cleanups
);
8867 dwo_unit
= OBSTACK_ZALLOC (&objfile
->objfile_obstack
, struct dwo_unit
);
8868 dwo_unit
->dwo_file
= dwo_file
;
8869 dwo_unit
->signature
= signature
;
8870 dwo_unit
->section
= obstack_alloc (&objfile
->objfile_obstack
,
8871 sizeof (struct dwarf2_section_info
));
8872 *dwo_unit
->section
= sections
.info_or_types
;
8873 /* offset, length, type_offset_in_tu are set later. */
8878 /* Lookup the DWO with SIGNATURE in DWP_FILE. */
8880 static struct dwo_unit
*
8881 lookup_dwo_in_dwp (struct dwp_file
*dwp_file
,
8882 const struct dwp_hash_table
*htab
,
8883 const char *comp_dir
,
8884 ULONGEST signature
, int is_debug_types
)
8886 bfd
*dbfd
= dwp_file
->dbfd
;
8887 uint32_t mask
= htab
->nr_slots
- 1;
8888 uint32_t hash
= signature
& mask
;
8889 uint32_t hash2
= ((signature
>> 32) & mask
) | 1;
8892 struct dwo_unit find_dwo_cu
, *dwo_cu
;
8894 memset (&find_dwo_cu
, 0, sizeof (find_dwo_cu
));
8895 find_dwo_cu
.signature
= signature
;
8896 slot
= htab_find_slot (dwp_file
->loaded_cutus
, &find_dwo_cu
, INSERT
);
8901 /* Use a for loop so that we don't loop forever on bad debug info. */
8902 for (i
= 0; i
< htab
->nr_slots
; ++i
)
8904 ULONGEST signature_in_table
;
8906 signature_in_table
=
8907 read_8_bytes (dbfd
, htab
->hash_table
+ hash
* sizeof (uint64_t));
8908 if (signature_in_table
== signature
)
8910 uint32_t section_index
=
8911 read_4_bytes (dbfd
, htab
->unit_table
+ hash
* sizeof (uint32_t));
8913 *slot
= create_dwo_in_dwp (dwp_file
, htab
, section_index
,
8914 comp_dir
, signature
, is_debug_types
);
8917 if (signature_in_table
== 0)
8919 hash
= (hash
+ hash2
) & mask
;
8922 error (_("Dwarf Error: bad DWP hash table, lookup didn't terminate"
8927 /* Subroutine of open_dwo_file,open_dwp_file to simplify them.
8928 Open the file specified by FILE_NAME and hand it off to BFD for
8929 preliminary analysis. Return a newly initialized bfd *, which
8930 includes a canonicalized copy of FILE_NAME.
8931 If IS_DWP is TRUE, we're opening a DWP file, otherwise a DWO file.
8932 In case of trouble, return NULL.
8933 NOTE: This function is derived from symfile_bfd_open. */
8936 try_open_dwop_file (const char *file_name
, int is_dwp
)
8940 char *absolute_name
;
8942 flags
= OPF_TRY_CWD_FIRST
;
8944 flags
|= OPF_SEARCH_IN_PATH
;
8945 desc
= openp (debug_file_directory
, flags
, file_name
,
8946 O_RDONLY
| O_BINARY
, &absolute_name
);
8950 sym_bfd
= gdb_bfd_open (absolute_name
, gnutarget
, desc
);
8953 xfree (absolute_name
);
8956 xfree (absolute_name
);
8957 bfd_set_cacheable (sym_bfd
, 1);
8959 if (!bfd_check_format (sym_bfd
, bfd_object
))
8961 gdb_bfd_unref (sym_bfd
); /* This also closes desc. */
8968 /* Try to open DWO file FILE_NAME.
8969 COMP_DIR is the DW_AT_comp_dir attribute.
8970 The result is the bfd handle of the file.
8971 If there is a problem finding or opening the file, return NULL.
8972 Upon success, the canonicalized path of the file is stored in the bfd,
8973 same as symfile_bfd_open. */
8976 open_dwo_file (const char *file_name
, const char *comp_dir
)
8980 if (IS_ABSOLUTE_PATH (file_name
))
8981 return try_open_dwop_file (file_name
, 0 /*is_dwp*/);
8983 /* Before trying the search path, try DWO_NAME in COMP_DIR. */
8985 if (comp_dir
!= NULL
)
8987 char *path_to_try
= concat (comp_dir
, SLASH_STRING
, file_name
, NULL
);
8989 /* NOTE: If comp_dir is a relative path, this will also try the
8990 search path, which seems useful. */
8991 abfd
= try_open_dwop_file (path_to_try
, 0 /*is_dwp*/);
8992 xfree (path_to_try
);
8997 /* That didn't work, try debug-file-directory, which, despite its name,
8998 is a list of paths. */
9000 if (*debug_file_directory
== '\0')
9003 return try_open_dwop_file (file_name
, 0 /*is_dwp*/);
9006 /* This function is mapped across the sections and remembers the offset and
9007 size of each of the DWO debugging sections we are interested in. */
9010 dwarf2_locate_dwo_sections (bfd
*abfd
, asection
*sectp
, void *dwo_sections_ptr
)
9012 struct dwo_sections
*dwo_sections
= dwo_sections_ptr
;
9013 const struct dwop_section_names
*names
= &dwop_section_names
;
9015 if (section_is_p (sectp
->name
, &names
->abbrev_dwo
))
9017 dwo_sections
->abbrev
.asection
= sectp
;
9018 dwo_sections
->abbrev
.size
= bfd_get_section_size (sectp
);
9020 else if (section_is_p (sectp
->name
, &names
->info_dwo
))
9022 dwo_sections
->info
.asection
= sectp
;
9023 dwo_sections
->info
.size
= bfd_get_section_size (sectp
);
9025 else if (section_is_p (sectp
->name
, &names
->line_dwo
))
9027 dwo_sections
->line
.asection
= sectp
;
9028 dwo_sections
->line
.size
= bfd_get_section_size (sectp
);
9030 else if (section_is_p (sectp
->name
, &names
->loc_dwo
))
9032 dwo_sections
->loc
.asection
= sectp
;
9033 dwo_sections
->loc
.size
= bfd_get_section_size (sectp
);
9035 else if (section_is_p (sectp
->name
, &names
->macinfo_dwo
))
9037 dwo_sections
->macinfo
.asection
= sectp
;
9038 dwo_sections
->macinfo
.size
= bfd_get_section_size (sectp
);
9040 else if (section_is_p (sectp
->name
, &names
->macro_dwo
))
9042 dwo_sections
->macro
.asection
= sectp
;
9043 dwo_sections
->macro
.size
= bfd_get_section_size (sectp
);
9045 else if (section_is_p (sectp
->name
, &names
->str_dwo
))
9047 dwo_sections
->str
.asection
= sectp
;
9048 dwo_sections
->str
.size
= bfd_get_section_size (sectp
);
9050 else if (section_is_p (sectp
->name
, &names
->str_offsets_dwo
))
9052 dwo_sections
->str_offsets
.asection
= sectp
;
9053 dwo_sections
->str_offsets
.size
= bfd_get_section_size (sectp
);
9055 else if (section_is_p (sectp
->name
, &names
->types_dwo
))
9057 struct dwarf2_section_info type_section
;
9059 memset (&type_section
, 0, sizeof (type_section
));
9060 type_section
.asection
= sectp
;
9061 type_section
.size
= bfd_get_section_size (sectp
);
9062 VEC_safe_push (dwarf2_section_info_def
, dwo_sections
->types
,
9067 /* Initialize the use of the DWO file specified by DWO_NAME and referenced
9069 The result is NULL if DWO_NAME can't be found. */
9071 static struct dwo_file
*
9072 open_and_init_dwo_file (struct dwarf2_per_cu_data
*per_cu
,
9073 const char *dwo_name
, const char *comp_dir
)
9075 struct objfile
*objfile
= dwarf2_per_objfile
->objfile
;
9076 struct dwo_file
*dwo_file
;
9078 struct cleanup
*cleanups
;
9080 dbfd
= open_dwo_file (dwo_name
, comp_dir
);
9083 if (dwarf2_read_debug
)
9084 fprintf_unfiltered (gdb_stdlog
, "DWO file not found: %s\n", dwo_name
);
9087 dwo_file
= OBSTACK_ZALLOC (&objfile
->objfile_obstack
, struct dwo_file
);
9088 dwo_file
->dwo_name
= dwo_name
;
9089 dwo_file
->comp_dir
= comp_dir
;
9090 dwo_file
->dbfd
= dbfd
;
9092 cleanups
= make_cleanup (free_dwo_file_cleanup
, dwo_file
);
9094 bfd_map_over_sections (dbfd
, dwarf2_locate_dwo_sections
, &dwo_file
->sections
);
9096 dwo_file
->cus
= create_dwo_debug_info_hash_table (dwo_file
);
9098 dwo_file
->tus
= create_debug_types_hash_table (dwo_file
,
9099 dwo_file
->sections
.types
);
9101 discard_cleanups (cleanups
);
9103 if (dwarf2_read_debug
)
9104 fprintf_unfiltered (gdb_stdlog
, "DWO file found: %s\n", dwo_name
);
9109 /* This function is mapped across the sections and remembers the offset and
9110 size of each of the DWP debugging sections we are interested in. */
9113 dwarf2_locate_dwp_sections (bfd
*abfd
, asection
*sectp
, void *dwp_file_ptr
)
9115 struct dwp_file
*dwp_file
= dwp_file_ptr
;
9116 const struct dwop_section_names
*names
= &dwop_section_names
;
9117 unsigned int elf_section_nr
= elf_section_data (sectp
)->this_idx
;
9119 /* Record the ELF section number for later lookup: this is what the
9120 .debug_cu_index,.debug_tu_index tables use. */
9121 gdb_assert (elf_section_nr
< dwp_file
->num_sections
);
9122 dwp_file
->elf_sections
[elf_section_nr
] = sectp
;
9124 /* Look for specific sections that we need. */
9125 if (section_is_p (sectp
->name
, &names
->str_dwo
))
9127 dwp_file
->sections
.str
.asection
= sectp
;
9128 dwp_file
->sections
.str
.size
= bfd_get_section_size (sectp
);
9130 else if (section_is_p (sectp
->name
, &names
->cu_index
))
9132 dwp_file
->sections
.cu_index
.asection
= sectp
;
9133 dwp_file
->sections
.cu_index
.size
= bfd_get_section_size (sectp
);
9135 else if (section_is_p (sectp
->name
, &names
->tu_index
))
9137 dwp_file
->sections
.tu_index
.asection
= sectp
;
9138 dwp_file
->sections
.tu_index
.size
= bfd_get_section_size (sectp
);
9142 /* Hash function for dwp_file loaded CUs/TUs. */
9145 hash_dwp_loaded_cutus (const void *item
)
9147 const struct dwo_unit
*dwo_unit
= item
;
9149 /* This drops the top 32 bits of the signature, but is ok for a hash. */
9150 return dwo_unit
->signature
;
9153 /* Equality function for dwp_file loaded CUs/TUs. */
9156 eq_dwp_loaded_cutus (const void *a
, const void *b
)
9158 const struct dwo_unit
*dua
= a
;
9159 const struct dwo_unit
*dub
= b
;
9161 return dua
->signature
== dub
->signature
;
9164 /* Allocate a hash table for dwp_file loaded CUs/TUs. */
9167 allocate_dwp_loaded_cutus_table (struct objfile
*objfile
)
9169 return htab_create_alloc_ex (3,
9170 hash_dwp_loaded_cutus
,
9171 eq_dwp_loaded_cutus
,
9173 &objfile
->objfile_obstack
,
9174 hashtab_obstack_allocate
,
9175 dummy_obstack_deallocate
);
9178 /* Try to open DWP file FILE_NAME.
9179 The result is the bfd handle of the file.
9180 If there is a problem finding or opening the file, return NULL.
9181 Upon success, the canonicalized path of the file is stored in the bfd,
9182 same as symfile_bfd_open. */
9185 open_dwp_file (const char *file_name
)
9187 return try_open_dwop_file (file_name
, 1 /*is_dwp*/);
9190 /* Initialize the use of the DWP file for the current objfile.
9191 By convention the name of the DWP file is ${objfile}.dwp.
9192 The result is NULL if it can't be found. */
9194 static struct dwp_file
*
9195 open_and_init_dwp_file (void)
9197 struct objfile
*objfile
= dwarf2_per_objfile
->objfile
;
9198 struct dwp_file
*dwp_file
;
9201 struct cleanup
*cleanups
;
9203 dwp_name
= xstrprintf ("%s.dwp", dwarf2_per_objfile
->objfile
->name
);
9204 cleanups
= make_cleanup (xfree
, dwp_name
);
9206 dbfd
= open_dwp_file (dwp_name
);
9209 if (dwarf2_read_debug
)
9210 fprintf_unfiltered (gdb_stdlog
, "DWP file not found: %s\n", dwp_name
);
9211 do_cleanups (cleanups
);
9214 dwp_file
= OBSTACK_ZALLOC (&objfile
->objfile_obstack
, struct dwp_file
);
9215 dwp_file
->name
= obstack_copy0 (&objfile
->objfile_obstack
,
9216 dwp_name
, strlen (dwp_name
));
9217 dwp_file
->dbfd
= dbfd
;
9218 do_cleanups (cleanups
);
9220 /* +1: section 0 is unused */
9221 dwp_file
->num_sections
= bfd_count_sections (dbfd
) + 1;
9222 dwp_file
->elf_sections
=
9223 OBSTACK_CALLOC (&objfile
->objfile_obstack
,
9224 dwp_file
->num_sections
, asection
*);
9226 bfd_map_over_sections (dbfd
, dwarf2_locate_dwp_sections
, dwp_file
);
9228 dwp_file
->cus
= create_dwp_hash_table (dwp_file
, 0);
9230 dwp_file
->tus
= create_dwp_hash_table (dwp_file
, 1);
9232 dwp_file
->loaded_cutus
= allocate_dwp_loaded_cutus_table (objfile
);
9234 if (dwarf2_read_debug
)
9236 fprintf_unfiltered (gdb_stdlog
, "DWP file found: %s\n", dwp_file
->name
);
9237 fprintf_unfiltered (gdb_stdlog
,
9238 " %u CUs, %u TUs\n",
9239 dwp_file
->cus
? dwp_file
->cus
->nr_units
: 0,
9240 dwp_file
->tus
? dwp_file
->tus
->nr_units
: 0);
9246 /* Wrapper around open_and_init_dwp_file, only open it once. */
9248 static struct dwp_file
*
9251 if (! dwarf2_per_objfile
->dwp_checked
)
9253 dwarf2_per_objfile
->dwp_file
= open_and_init_dwp_file ();
9254 dwarf2_per_objfile
->dwp_checked
= 1;
9256 return dwarf2_per_objfile
->dwp_file
;
9259 /* Subroutine of lookup_dwo_comp_unit, lookup_dwo_type_unit.
9260 Look up the CU/TU with signature SIGNATURE, either in DWO file DWO_NAME
9261 or in the DWP file for the objfile, referenced by THIS_UNIT.
9262 If non-NULL, comp_dir is the DW_AT_comp_dir attribute.
9263 IS_DEBUG_TYPES is non-zero if reading a TU, otherwise read a CU.
9265 This is called, for example, when wanting to read a variable with a
9266 complex location. Therefore we don't want to do file i/o for every call.
9267 Therefore we don't want to look for a DWO file on every call.
9268 Therefore we first see if we've already seen SIGNATURE in a DWP file,
9269 then we check if we've already seen DWO_NAME, and only THEN do we check
9272 The result is a pointer to the dwo_unit object or NULL if we didn't find it
9273 (dwo_id mismatch or couldn't find the DWO/DWP file). */
9275 static struct dwo_unit
*
9276 lookup_dwo_cutu (struct dwarf2_per_cu_data
*this_unit
,
9277 const char *dwo_name
, const char *comp_dir
,
9278 ULONGEST signature
, int is_debug_types
)
9280 struct objfile
*objfile
= dwarf2_per_objfile
->objfile
;
9281 const char *kind
= is_debug_types
? "TU" : "CU";
9282 void **dwo_file_slot
;
9283 struct dwo_file
*dwo_file
;
9284 struct dwp_file
*dwp_file
;
9286 /* Have we already read SIGNATURE from a DWP file? */
9288 dwp_file
= get_dwp_file ();
9289 if (dwp_file
!= NULL
)
9291 const struct dwp_hash_table
*dwp_htab
=
9292 is_debug_types
? dwp_file
->tus
: dwp_file
->cus
;
9294 if (dwp_htab
!= NULL
)
9296 struct dwo_unit
*dwo_cutu
=
9297 lookup_dwo_in_dwp (dwp_file
, dwp_htab
, comp_dir
,
9298 signature
, is_debug_types
);
9300 if (dwo_cutu
!= NULL
)
9302 if (dwarf2_read_debug
)
9304 fprintf_unfiltered (gdb_stdlog
,
9305 "Virtual DWO %s %s found: @%s\n",
9306 kind
, hex_string (signature
),
9307 host_address_to_string (dwo_cutu
));
9314 /* Have we already seen DWO_NAME? */
9316 dwo_file_slot
= lookup_dwo_file_slot (dwo_name
, comp_dir
);
9317 if (*dwo_file_slot
== NULL
)
9319 /* Read in the file and build a table of the DWOs it contains. */
9320 *dwo_file_slot
= open_and_init_dwo_file (this_unit
, dwo_name
, comp_dir
);
9322 /* NOTE: This will be NULL if unable to open the file. */
9323 dwo_file
= *dwo_file_slot
;
9325 if (dwo_file
!= NULL
)
9327 htab_t htab
= is_debug_types
? dwo_file
->tus
: dwo_file
->cus
;
9331 struct dwo_unit find_dwo_cutu
, *dwo_cutu
;
9333 memset (&find_dwo_cutu
, 0, sizeof (find_dwo_cutu
));
9334 find_dwo_cutu
.signature
= signature
;
9335 dwo_cutu
= htab_find (htab
, &find_dwo_cutu
);
9337 if (dwo_cutu
!= NULL
)
9339 if (dwarf2_read_debug
)
9341 fprintf_unfiltered (gdb_stdlog
, "DWO %s %s(%s) found: @%s\n",
9342 kind
, dwo_name
, hex_string (signature
),
9343 host_address_to_string (dwo_cutu
));
9350 /* We didn't find it. This could mean a dwo_id mismatch, or
9351 someone deleted the DWO/DWP file, or the search path isn't set up
9352 correctly to find the file. */
9354 if (dwarf2_read_debug
)
9356 fprintf_unfiltered (gdb_stdlog
, "DWO %s %s(%s) not found\n",
9357 kind
, dwo_name
, hex_string (signature
));
9360 complaint (&symfile_complaints
,
9361 _("Could not find DWO %s referenced by CU at offset 0x%x"
9363 kind
, this_unit
->offset
.sect_off
, objfile
->name
);
9367 /* Lookup the DWO CU DWO_NAME/SIGNATURE referenced from THIS_CU.
9368 See lookup_dwo_cutu_unit for details. */
9370 static struct dwo_unit
*
9371 lookup_dwo_comp_unit (struct dwarf2_per_cu_data
*this_cu
,
9372 const char *dwo_name
, const char *comp_dir
,
9375 return lookup_dwo_cutu (this_cu
, dwo_name
, comp_dir
, signature
, 0);
9378 /* Lookup the DWO TU DWO_NAME/SIGNATURE referenced from THIS_TU.
9379 See lookup_dwo_cutu_unit for details. */
9381 static struct dwo_unit
*
9382 lookup_dwo_type_unit (struct signatured_type
*this_tu
,
9383 const char *dwo_name
, const char *comp_dir
)
9385 return lookup_dwo_cutu (&this_tu
->per_cu
, dwo_name
, comp_dir
, this_tu
->signature
, 1);
9388 /* Free all resources associated with DWO_FILE.
9389 Close the DWO file and munmap the sections.
9390 All memory should be on the objfile obstack. */
9393 free_dwo_file (struct dwo_file
*dwo_file
, struct objfile
*objfile
)
9396 struct dwarf2_section_info
*section
;
9398 /* Note: dbfd is NULL for virtual DWO files. */
9399 gdb_bfd_unref (dwo_file
->dbfd
);
9401 VEC_free (dwarf2_section_info_def
, dwo_file
->sections
.types
);
9404 /* Wrapper for free_dwo_file for use in cleanups. */
9407 free_dwo_file_cleanup (void *arg
)
9409 struct dwo_file
*dwo_file
= (struct dwo_file
*) arg
;
9410 struct objfile
*objfile
= dwarf2_per_objfile
->objfile
;
9412 free_dwo_file (dwo_file
, objfile
);
9415 /* Traversal function for free_dwo_files. */
9418 free_dwo_file_from_slot (void **slot
, void *info
)
9420 struct dwo_file
*dwo_file
= (struct dwo_file
*) *slot
;
9421 struct objfile
*objfile
= (struct objfile
*) info
;
9423 free_dwo_file (dwo_file
, objfile
);
9428 /* Free all resources associated with DWO_FILES. */
9431 free_dwo_files (htab_t dwo_files
, struct objfile
*objfile
)
9433 htab_traverse_noresize (dwo_files
, free_dwo_file_from_slot
, objfile
);
9436 /* Read in various DIEs. */
9438 /* qsort helper for inherit_abstract_dies. */
9441 unsigned_int_compar (const void *ap
, const void *bp
)
9443 unsigned int a
= *(unsigned int *) ap
;
9444 unsigned int b
= *(unsigned int *) bp
;
9446 return (a
> b
) - (b
> a
);
9449 /* DW_AT_abstract_origin inherits whole DIEs (not just their attributes).
9450 Inherit only the children of the DW_AT_abstract_origin DIE not being
9451 already referenced by DW_AT_abstract_origin from the children of the
9455 inherit_abstract_dies (struct die_info
*die
, struct dwarf2_cu
*cu
)
9457 struct die_info
*child_die
;
9458 unsigned die_children_count
;
9459 /* CU offsets which were referenced by children of the current DIE. */
9460 sect_offset
*offsets
;
9461 sect_offset
*offsets_end
, *offsetp
;
9462 /* Parent of DIE - referenced by DW_AT_abstract_origin. */
9463 struct die_info
*origin_die
;
9464 /* Iterator of the ORIGIN_DIE children. */
9465 struct die_info
*origin_child_die
;
9466 struct cleanup
*cleanups
;
9467 struct attribute
*attr
;
9468 struct dwarf2_cu
*origin_cu
;
9469 struct pending
**origin_previous_list_in_scope
;
9471 attr
= dwarf2_attr (die
, DW_AT_abstract_origin
, cu
);
9475 /* Note that following die references may follow to a die in a
9479 origin_die
= follow_die_ref (die
, attr
, &origin_cu
);
9481 /* We're inheriting ORIGIN's children into the scope we'd put DIE's
9483 origin_previous_list_in_scope
= origin_cu
->list_in_scope
;
9484 origin_cu
->list_in_scope
= cu
->list_in_scope
;
9486 if (die
->tag
!= origin_die
->tag
9487 && !(die
->tag
== DW_TAG_inlined_subroutine
9488 && origin_die
->tag
== DW_TAG_subprogram
))
9489 complaint (&symfile_complaints
,
9490 _("DIE 0x%x and its abstract origin 0x%x have different tags"),
9491 die
->offset
.sect_off
, origin_die
->offset
.sect_off
);
9493 child_die
= die
->child
;
9494 die_children_count
= 0;
9495 while (child_die
&& child_die
->tag
)
9497 child_die
= sibling_die (child_die
);
9498 die_children_count
++;
9500 offsets
= xmalloc (sizeof (*offsets
) * die_children_count
);
9501 cleanups
= make_cleanup (xfree
, offsets
);
9503 offsets_end
= offsets
;
9504 child_die
= die
->child
;
9505 while (child_die
&& child_die
->tag
)
9507 /* For each CHILD_DIE, find the corresponding child of
9508 ORIGIN_DIE. If there is more than one layer of
9509 DW_AT_abstract_origin, follow them all; there shouldn't be,
9510 but GCC versions at least through 4.4 generate this (GCC PR
9512 struct die_info
*child_origin_die
= child_die
;
9513 struct dwarf2_cu
*child_origin_cu
= cu
;
9517 attr
= dwarf2_attr (child_origin_die
, DW_AT_abstract_origin
,
9521 child_origin_die
= follow_die_ref (child_origin_die
, attr
,
9525 /* According to DWARF3 3.3.8.2 #3 new entries without their abstract
9526 counterpart may exist. */
9527 if (child_origin_die
!= child_die
)
9529 if (child_die
->tag
!= child_origin_die
->tag
9530 && !(child_die
->tag
== DW_TAG_inlined_subroutine
9531 && child_origin_die
->tag
== DW_TAG_subprogram
))
9532 complaint (&symfile_complaints
,
9533 _("Child DIE 0x%x and its abstract origin 0x%x have "
9534 "different tags"), child_die
->offset
.sect_off
,
9535 child_origin_die
->offset
.sect_off
);
9536 if (child_origin_die
->parent
!= origin_die
)
9537 complaint (&symfile_complaints
,
9538 _("Child DIE 0x%x and its abstract origin 0x%x have "
9539 "different parents"), child_die
->offset
.sect_off
,
9540 child_origin_die
->offset
.sect_off
);
9542 *offsets_end
++ = child_origin_die
->offset
;
9544 child_die
= sibling_die (child_die
);
9546 qsort (offsets
, offsets_end
- offsets
, sizeof (*offsets
),
9547 unsigned_int_compar
);
9548 for (offsetp
= offsets
+ 1; offsetp
< offsets_end
; offsetp
++)
9549 if (offsetp
[-1].sect_off
== offsetp
->sect_off
)
9550 complaint (&symfile_complaints
,
9551 _("Multiple children of DIE 0x%x refer "
9552 "to DIE 0x%x as their abstract origin"),
9553 die
->offset
.sect_off
, offsetp
->sect_off
);
9556 origin_child_die
= origin_die
->child
;
9557 while (origin_child_die
&& origin_child_die
->tag
)
9559 /* Is ORIGIN_CHILD_DIE referenced by any of the DIE children? */
9560 while (offsetp
< offsets_end
9561 && offsetp
->sect_off
< origin_child_die
->offset
.sect_off
)
9563 if (offsetp
>= offsets_end
9564 || offsetp
->sect_off
> origin_child_die
->offset
.sect_off
)
9566 /* Found that ORIGIN_CHILD_DIE is really not referenced. */
9567 process_die (origin_child_die
, origin_cu
);
9569 origin_child_die
= sibling_die (origin_child_die
);
9571 origin_cu
->list_in_scope
= origin_previous_list_in_scope
;
9573 do_cleanups (cleanups
);
9577 read_func_scope (struct die_info
*die
, struct dwarf2_cu
*cu
)
9579 struct objfile
*objfile
= cu
->objfile
;
9580 struct context_stack
*new;
9583 struct die_info
*child_die
;
9584 struct attribute
*attr
, *call_line
, *call_file
;
9587 struct block
*block
;
9588 int inlined_func
= (die
->tag
== DW_TAG_inlined_subroutine
);
9589 VEC (symbolp
) *template_args
= NULL
;
9590 struct template_symbol
*templ_func
= NULL
;
9594 /* If we do not have call site information, we can't show the
9595 caller of this inlined function. That's too confusing, so
9596 only use the scope for local variables. */
9597 call_line
= dwarf2_attr (die
, DW_AT_call_line
, cu
);
9598 call_file
= dwarf2_attr (die
, DW_AT_call_file
, cu
);
9599 if (call_line
== NULL
|| call_file
== NULL
)
9601 read_lexical_block_scope (die
, cu
);
9606 baseaddr
= ANOFFSET (objfile
->section_offsets
, SECT_OFF_TEXT (objfile
));
9608 name
= dwarf2_name (die
, cu
);
9610 /* Ignore functions with missing or empty names. These are actually
9611 illegal according to the DWARF standard. */
9614 complaint (&symfile_complaints
,
9615 _("missing name for subprogram DIE at %d"),
9616 die
->offset
.sect_off
);
9620 /* Ignore functions with missing or invalid low and high pc attributes. */
9621 if (!dwarf2_get_pc_bounds (die
, &lowpc
, &highpc
, cu
, NULL
))
9623 attr
= dwarf2_attr (die
, DW_AT_external
, cu
);
9624 if (!attr
|| !DW_UNSND (attr
))
9625 complaint (&symfile_complaints
,
9626 _("cannot get low and high bounds "
9627 "for subprogram DIE at %d"),
9628 die
->offset
.sect_off
);
9635 /* If we have any template arguments, then we must allocate a
9636 different sort of symbol. */
9637 for (child_die
= die
->child
; child_die
; child_die
= sibling_die (child_die
))
9639 if (child_die
->tag
== DW_TAG_template_type_param
9640 || child_die
->tag
== DW_TAG_template_value_param
)
9642 templ_func
= allocate_template_symbol (objfile
);
9643 templ_func
->base
.is_cplus_template_function
= 1;
9648 new = push_context (0, lowpc
);
9649 new->name
= new_symbol_full (die
, read_type_die (die
, cu
), cu
,
9650 (struct symbol
*) templ_func
);
9652 /* If there is a location expression for DW_AT_frame_base, record
9654 attr
= dwarf2_attr (die
, DW_AT_frame_base
, cu
);
9656 dwarf2_symbol_mark_computed (attr
, new->name
, cu
, 1);
9658 cu
->list_in_scope
= &local_symbols
;
9660 if (die
->child
!= NULL
)
9662 child_die
= die
->child
;
9663 while (child_die
&& child_die
->tag
)
9665 if (child_die
->tag
== DW_TAG_template_type_param
9666 || child_die
->tag
== DW_TAG_template_value_param
)
9668 struct symbol
*arg
= new_symbol (child_die
, NULL
, cu
);
9671 VEC_safe_push (symbolp
, template_args
, arg
);
9674 process_die (child_die
, cu
);
9675 child_die
= sibling_die (child_die
);
9679 inherit_abstract_dies (die
, cu
);
9681 /* If we have a DW_AT_specification, we might need to import using
9682 directives from the context of the specification DIE. See the
9683 comment in determine_prefix. */
9684 if (cu
->language
== language_cplus
9685 && dwarf2_attr (die
, DW_AT_specification
, cu
))
9687 struct dwarf2_cu
*spec_cu
= cu
;
9688 struct die_info
*spec_die
= die_specification (die
, &spec_cu
);
9692 child_die
= spec_die
->child
;
9693 while (child_die
&& child_die
->tag
)
9695 if (child_die
->tag
== DW_TAG_imported_module
)
9696 process_die (child_die
, spec_cu
);
9697 child_die
= sibling_die (child_die
);
9700 /* In some cases, GCC generates specification DIEs that
9701 themselves contain DW_AT_specification attributes. */
9702 spec_die
= die_specification (spec_die
, &spec_cu
);
9706 new = pop_context ();
9707 /* Make a block for the local symbols within. */
9708 block
= finish_block (new->name
, &local_symbols
, new->old_blocks
,
9709 lowpc
, highpc
, objfile
);
9711 /* For C++, set the block's scope. */
9712 if ((cu
->language
== language_cplus
|| cu
->language
== language_fortran
)
9713 && cu
->processing_has_namespace_info
)
9714 block_set_scope (block
, determine_prefix (die
, cu
),
9715 &objfile
->objfile_obstack
);
9717 /* If we have address ranges, record them. */
9718 dwarf2_record_block_ranges (die
, block
, baseaddr
, cu
);
9720 /* Attach template arguments to function. */
9721 if (! VEC_empty (symbolp
, template_args
))
9723 gdb_assert (templ_func
!= NULL
);
9725 templ_func
->n_template_arguments
= VEC_length (symbolp
, template_args
);
9726 templ_func
->template_arguments
9727 = obstack_alloc (&objfile
->objfile_obstack
,
9728 (templ_func
->n_template_arguments
9729 * sizeof (struct symbol
*)));
9730 memcpy (templ_func
->template_arguments
,
9731 VEC_address (symbolp
, template_args
),
9732 (templ_func
->n_template_arguments
* sizeof (struct symbol
*)));
9733 VEC_free (symbolp
, template_args
);
9736 /* In C++, we can have functions nested inside functions (e.g., when
9737 a function declares a class that has methods). This means that
9738 when we finish processing a function scope, we may need to go
9739 back to building a containing block's symbol lists. */
9740 local_symbols
= new->locals
;
9741 using_directives
= new->using_directives
;
9743 /* If we've finished processing a top-level function, subsequent
9744 symbols go in the file symbol list. */
9745 if (outermost_context_p ())
9746 cu
->list_in_scope
= &file_symbols
;
9749 /* Process all the DIES contained within a lexical block scope. Start
9750 a new scope, process the dies, and then close the scope. */
9753 read_lexical_block_scope (struct die_info
*die
, struct dwarf2_cu
*cu
)
9755 struct objfile
*objfile
= cu
->objfile
;
9756 struct context_stack
*new;
9757 CORE_ADDR lowpc
, highpc
;
9758 struct die_info
*child_die
;
9761 baseaddr
= ANOFFSET (objfile
->section_offsets
, SECT_OFF_TEXT (objfile
));
9763 /* Ignore blocks with missing or invalid low and high pc attributes. */
9764 /* ??? Perhaps consider discontiguous blocks defined by DW_AT_ranges
9765 as multiple lexical blocks? Handling children in a sane way would
9766 be nasty. Might be easier to properly extend generic blocks to
9768 if (!dwarf2_get_pc_bounds (die
, &lowpc
, &highpc
, cu
, NULL
))
9773 push_context (0, lowpc
);
9774 if (die
->child
!= NULL
)
9776 child_die
= die
->child
;
9777 while (child_die
&& child_die
->tag
)
9779 process_die (child_die
, cu
);
9780 child_die
= sibling_die (child_die
);
9783 new = pop_context ();
9785 if (local_symbols
!= NULL
|| using_directives
!= NULL
)
9788 = finish_block (0, &local_symbols
, new->old_blocks
, new->start_addr
,
9791 /* Note that recording ranges after traversing children, as we
9792 do here, means that recording a parent's ranges entails
9793 walking across all its children's ranges as they appear in
9794 the address map, which is quadratic behavior.
9796 It would be nicer to record the parent's ranges before
9797 traversing its children, simply overriding whatever you find
9798 there. But since we don't even decide whether to create a
9799 block until after we've traversed its children, that's hard
9801 dwarf2_record_block_ranges (die
, block
, baseaddr
, cu
);
9803 local_symbols
= new->locals
;
9804 using_directives
= new->using_directives
;
9807 /* Read in DW_TAG_GNU_call_site and insert it to CU->call_site_htab. */
9810 read_call_site_scope (struct die_info
*die
, struct dwarf2_cu
*cu
)
9812 struct objfile
*objfile
= cu
->objfile
;
9813 struct gdbarch
*gdbarch
= get_objfile_arch (objfile
);
9814 CORE_ADDR pc
, baseaddr
;
9815 struct attribute
*attr
;
9816 struct call_site
*call_site
, call_site_local
;
9819 struct die_info
*child_die
;
9821 baseaddr
= ANOFFSET (objfile
->section_offsets
, SECT_OFF_TEXT (objfile
));
9823 attr
= dwarf2_attr (die
, DW_AT_low_pc
, cu
);
9826 complaint (&symfile_complaints
,
9827 _("missing DW_AT_low_pc for DW_TAG_GNU_call_site "
9828 "DIE 0x%x [in module %s]"),
9829 die
->offset
.sect_off
, objfile
->name
);
9832 pc
= DW_ADDR (attr
) + baseaddr
;
9834 if (cu
->call_site_htab
== NULL
)
9835 cu
->call_site_htab
= htab_create_alloc_ex (16, core_addr_hash
, core_addr_eq
,
9836 NULL
, &objfile
->objfile_obstack
,
9837 hashtab_obstack_allocate
, NULL
);
9838 call_site_local
.pc
= pc
;
9839 slot
= htab_find_slot (cu
->call_site_htab
, &call_site_local
, INSERT
);
9842 complaint (&symfile_complaints
,
9843 _("Duplicate PC %s for DW_TAG_GNU_call_site "
9844 "DIE 0x%x [in module %s]"),
9845 paddress (gdbarch
, pc
), die
->offset
.sect_off
, objfile
->name
);
9849 /* Count parameters at the caller. */
9852 for (child_die
= die
->child
; child_die
&& child_die
->tag
;
9853 child_die
= sibling_die (child_die
))
9855 if (child_die
->tag
!= DW_TAG_GNU_call_site_parameter
)
9857 complaint (&symfile_complaints
,
9858 _("Tag %d is not DW_TAG_GNU_call_site_parameter in "
9859 "DW_TAG_GNU_call_site child DIE 0x%x [in module %s]"),
9860 child_die
->tag
, child_die
->offset
.sect_off
, objfile
->name
);
9867 call_site
= obstack_alloc (&objfile
->objfile_obstack
,
9868 (sizeof (*call_site
)
9869 + (sizeof (*call_site
->parameter
)
9872 memset (call_site
, 0, sizeof (*call_site
) - sizeof (*call_site
->parameter
));
9875 if (dwarf2_flag_true_p (die
, DW_AT_GNU_tail_call
, cu
))
9877 struct die_info
*func_die
;
9879 /* Skip also over DW_TAG_inlined_subroutine. */
9880 for (func_die
= die
->parent
;
9881 func_die
&& func_die
->tag
!= DW_TAG_subprogram
9882 && func_die
->tag
!= DW_TAG_subroutine_type
;
9883 func_die
= func_die
->parent
);
9885 /* DW_AT_GNU_all_call_sites is a superset
9886 of DW_AT_GNU_all_tail_call_sites. */
9888 && !dwarf2_flag_true_p (func_die
, DW_AT_GNU_all_call_sites
, cu
)
9889 && !dwarf2_flag_true_p (func_die
, DW_AT_GNU_all_tail_call_sites
, cu
))
9891 /* TYPE_TAIL_CALL_LIST is not interesting in functions where it is
9892 not complete. But keep CALL_SITE for look ups via call_site_htab,
9893 both the initial caller containing the real return address PC and
9894 the final callee containing the current PC of a chain of tail
9895 calls do not need to have the tail call list complete. But any
9896 function candidate for a virtual tail call frame searched via
9897 TYPE_TAIL_CALL_LIST must have the tail call list complete to be
9898 determined unambiguously. */
9902 struct type
*func_type
= NULL
;
9905 func_type
= get_die_type (func_die
, cu
);
9906 if (func_type
!= NULL
)
9908 gdb_assert (TYPE_CODE (func_type
) == TYPE_CODE_FUNC
);
9910 /* Enlist this call site to the function. */
9911 call_site
->tail_call_next
= TYPE_TAIL_CALL_LIST (func_type
);
9912 TYPE_TAIL_CALL_LIST (func_type
) = call_site
;
9915 complaint (&symfile_complaints
,
9916 _("Cannot find function owning DW_TAG_GNU_call_site "
9917 "DIE 0x%x [in module %s]"),
9918 die
->offset
.sect_off
, objfile
->name
);
9922 attr
= dwarf2_attr (die
, DW_AT_GNU_call_site_target
, cu
);
9924 attr
= dwarf2_attr (die
, DW_AT_abstract_origin
, cu
);
9925 SET_FIELD_DWARF_BLOCK (call_site
->target
, NULL
);
9926 if (!attr
|| (attr_form_is_block (attr
) && DW_BLOCK (attr
)->size
== 0))
9927 /* Keep NULL DWARF_BLOCK. */;
9928 else if (attr_form_is_block (attr
))
9930 struct dwarf2_locexpr_baton
*dlbaton
;
9932 dlbaton
= obstack_alloc (&objfile
->objfile_obstack
, sizeof (*dlbaton
));
9933 dlbaton
->data
= DW_BLOCK (attr
)->data
;
9934 dlbaton
->size
= DW_BLOCK (attr
)->size
;
9935 dlbaton
->per_cu
= cu
->per_cu
;
9937 SET_FIELD_DWARF_BLOCK (call_site
->target
, dlbaton
);
9939 else if (is_ref_attr (attr
))
9941 struct dwarf2_cu
*target_cu
= cu
;
9942 struct die_info
*target_die
;
9944 target_die
= follow_die_ref_or_sig (die
, attr
, &target_cu
);
9945 gdb_assert (target_cu
->objfile
== objfile
);
9946 if (die_is_declaration (target_die
, target_cu
))
9948 const char *target_physname
= NULL
;
9949 struct attribute
*target_attr
;
9951 /* Prefer the mangled name; otherwise compute the demangled one. */
9952 target_attr
= dwarf2_attr (target_die
, DW_AT_linkage_name
, target_cu
);
9953 if (target_attr
== NULL
)
9954 target_attr
= dwarf2_attr (target_die
, DW_AT_MIPS_linkage_name
,
9956 if (target_attr
!= NULL
&& DW_STRING (target_attr
) != NULL
)
9957 target_physname
= DW_STRING (target_attr
);
9959 target_physname
= dwarf2_physname (NULL
, target_die
, target_cu
);
9960 if (target_physname
== NULL
)
9961 complaint (&symfile_complaints
,
9962 _("DW_AT_GNU_call_site_target target DIE has invalid "
9963 "physname, for referencing DIE 0x%x [in module %s]"),
9964 die
->offset
.sect_off
, objfile
->name
);
9966 SET_FIELD_PHYSNAME (call_site
->target
, target_physname
);
9972 /* DW_AT_entry_pc should be preferred. */
9973 if (!dwarf2_get_pc_bounds (target_die
, &lowpc
, NULL
, target_cu
, NULL
))
9974 complaint (&symfile_complaints
,
9975 _("DW_AT_GNU_call_site_target target DIE has invalid "
9976 "low pc, for referencing DIE 0x%x [in module %s]"),
9977 die
->offset
.sect_off
, objfile
->name
);
9979 SET_FIELD_PHYSADDR (call_site
->target
, lowpc
+ baseaddr
);
9983 complaint (&symfile_complaints
,
9984 _("DW_TAG_GNU_call_site DW_AT_GNU_call_site_target is neither "
9985 "block nor reference, for DIE 0x%x [in module %s]"),
9986 die
->offset
.sect_off
, objfile
->name
);
9988 call_site
->per_cu
= cu
->per_cu
;
9990 for (child_die
= die
->child
;
9991 child_die
&& child_die
->tag
;
9992 child_die
= sibling_die (child_die
))
9994 struct call_site_parameter
*parameter
;
9995 struct attribute
*loc
, *origin
;
9997 if (child_die
->tag
!= DW_TAG_GNU_call_site_parameter
)
9999 /* Already printed the complaint above. */
10003 gdb_assert (call_site
->parameter_count
< nparams
);
10004 parameter
= &call_site
->parameter
[call_site
->parameter_count
];
10006 /* DW_AT_location specifies the register number or DW_AT_abstract_origin
10007 specifies DW_TAG_formal_parameter. Value of the data assumed for the
10008 register is contained in DW_AT_GNU_call_site_value. */
10010 loc
= dwarf2_attr (child_die
, DW_AT_location
, cu
);
10011 origin
= dwarf2_attr (child_die
, DW_AT_abstract_origin
, cu
);
10012 if (loc
== NULL
&& origin
!= NULL
&& is_ref_attr (origin
))
10014 sect_offset offset
;
10016 parameter
->kind
= CALL_SITE_PARAMETER_PARAM_OFFSET
;
10017 offset
= dwarf2_get_ref_die_offset (origin
);
10018 if (!offset_in_cu_p (&cu
->header
, offset
))
10020 /* As DW_OP_GNU_parameter_ref uses CU-relative offset this
10021 binding can be done only inside one CU. Such referenced DIE
10022 therefore cannot be even moved to DW_TAG_partial_unit. */
10023 complaint (&symfile_complaints
,
10024 _("DW_AT_abstract_origin offset is not in CU for "
10025 "DW_TAG_GNU_call_site child DIE 0x%x "
10027 child_die
->offset
.sect_off
, objfile
->name
);
10030 parameter
->u
.param_offset
.cu_off
= (offset
.sect_off
10031 - cu
->header
.offset
.sect_off
);
10033 else if (loc
== NULL
|| origin
!= NULL
|| !attr_form_is_block (loc
))
10035 complaint (&symfile_complaints
,
10036 _("No DW_FORM_block* DW_AT_location for "
10037 "DW_TAG_GNU_call_site child DIE 0x%x [in module %s]"),
10038 child_die
->offset
.sect_off
, objfile
->name
);
10043 parameter
->u
.dwarf_reg
= dwarf_block_to_dwarf_reg
10044 (DW_BLOCK (loc
)->data
, &DW_BLOCK (loc
)->data
[DW_BLOCK (loc
)->size
]);
10045 if (parameter
->u
.dwarf_reg
!= -1)
10046 parameter
->kind
= CALL_SITE_PARAMETER_DWARF_REG
;
10047 else if (dwarf_block_to_sp_offset (gdbarch
, DW_BLOCK (loc
)->data
,
10048 &DW_BLOCK (loc
)->data
[DW_BLOCK (loc
)->size
],
10049 ¶meter
->u
.fb_offset
))
10050 parameter
->kind
= CALL_SITE_PARAMETER_FB_OFFSET
;
10053 complaint (&symfile_complaints
,
10054 _("Only single DW_OP_reg or DW_OP_fbreg is supported "
10055 "for DW_FORM_block* DW_AT_location is supported for "
10056 "DW_TAG_GNU_call_site child DIE 0x%x "
10058 child_die
->offset
.sect_off
, objfile
->name
);
10063 attr
= dwarf2_attr (child_die
, DW_AT_GNU_call_site_value
, cu
);
10064 if (!attr_form_is_block (attr
))
10066 complaint (&symfile_complaints
,
10067 _("No DW_FORM_block* DW_AT_GNU_call_site_value for "
10068 "DW_TAG_GNU_call_site child DIE 0x%x [in module %s]"),
10069 child_die
->offset
.sect_off
, objfile
->name
);
10072 parameter
->value
= DW_BLOCK (attr
)->data
;
10073 parameter
->value_size
= DW_BLOCK (attr
)->size
;
10075 /* Parameters are not pre-cleared by memset above. */
10076 parameter
->data_value
= NULL
;
10077 parameter
->data_value_size
= 0;
10078 call_site
->parameter_count
++;
10080 attr
= dwarf2_attr (child_die
, DW_AT_GNU_call_site_data_value
, cu
);
10083 if (!attr_form_is_block (attr
))
10084 complaint (&symfile_complaints
,
10085 _("No DW_FORM_block* DW_AT_GNU_call_site_data_value for "
10086 "DW_TAG_GNU_call_site child DIE 0x%x [in module %s]"),
10087 child_die
->offset
.sect_off
, objfile
->name
);
10090 parameter
->data_value
= DW_BLOCK (attr
)->data
;
10091 parameter
->data_value_size
= DW_BLOCK (attr
)->size
;
10097 /* Get low and high pc attributes from DW_AT_ranges attribute value OFFSET.
10098 Return 1 if the attributes are present and valid, otherwise, return 0.
10099 If RANGES_PST is not NULL we should setup `objfile->psymtabs_addrmap'. */
10102 dwarf2_ranges_read (unsigned offset
, CORE_ADDR
*low_return
,
10103 CORE_ADDR
*high_return
, struct dwarf2_cu
*cu
,
10104 struct partial_symtab
*ranges_pst
)
10106 struct objfile
*objfile
= cu
->objfile
;
10107 struct comp_unit_head
*cu_header
= &cu
->header
;
10108 bfd
*obfd
= objfile
->obfd
;
10109 unsigned int addr_size
= cu_header
->addr_size
;
10110 CORE_ADDR mask
= ~(~(CORE_ADDR
)1 << (addr_size
* 8 - 1));
10111 /* Base address selection entry. */
10114 unsigned int dummy
;
10119 CORE_ADDR high
= 0;
10120 CORE_ADDR baseaddr
;
10122 found_base
= cu
->base_known
;
10123 base
= cu
->base_address
;
10125 dwarf2_read_section (objfile
, &dwarf2_per_objfile
->ranges
);
10126 if (offset
>= dwarf2_per_objfile
->ranges
.size
)
10128 complaint (&symfile_complaints
,
10129 _("Offset %d out of bounds for DW_AT_ranges attribute"),
10133 buffer
= dwarf2_per_objfile
->ranges
.buffer
+ offset
;
10135 /* Read in the largest possible address. */
10136 marker
= read_address (obfd
, buffer
, cu
, &dummy
);
10137 if ((marker
& mask
) == mask
)
10139 /* If we found the largest possible address, then
10140 read the base address. */
10141 base
= read_address (obfd
, buffer
+ addr_size
, cu
, &dummy
);
10142 buffer
+= 2 * addr_size
;
10143 offset
+= 2 * addr_size
;
10149 baseaddr
= ANOFFSET (objfile
->section_offsets
, SECT_OFF_TEXT (objfile
));
10153 CORE_ADDR range_beginning
, range_end
;
10155 range_beginning
= read_address (obfd
, buffer
, cu
, &dummy
);
10156 buffer
+= addr_size
;
10157 range_end
= read_address (obfd
, buffer
, cu
, &dummy
);
10158 buffer
+= addr_size
;
10159 offset
+= 2 * addr_size
;
10161 /* An end of list marker is a pair of zero addresses. */
10162 if (range_beginning
== 0 && range_end
== 0)
10163 /* Found the end of list entry. */
10166 /* Each base address selection entry is a pair of 2 values.
10167 The first is the largest possible address, the second is
10168 the base address. Check for a base address here. */
10169 if ((range_beginning
& mask
) == mask
)
10171 /* If we found the largest possible address, then
10172 read the base address. */
10173 base
= read_address (obfd
, buffer
+ addr_size
, cu
, &dummy
);
10180 /* We have no valid base address for the ranges
10182 complaint (&symfile_complaints
,
10183 _("Invalid .debug_ranges data (no base address)"));
10187 if (range_beginning
> range_end
)
10189 /* Inverted range entries are invalid. */
10190 complaint (&symfile_complaints
,
10191 _("Invalid .debug_ranges data (inverted range)"));
10195 /* Empty range entries have no effect. */
10196 if (range_beginning
== range_end
)
10199 range_beginning
+= base
;
10202 /* A not-uncommon case of bad debug info.
10203 Don't pollute the addrmap with bad data. */
10204 if (range_beginning
+ baseaddr
== 0
10205 && !dwarf2_per_objfile
->has_section_at_zero
)
10207 complaint (&symfile_complaints
,
10208 _(".debug_ranges entry has start address of zero"
10209 " [in module %s]"), objfile
->name
);
10213 if (ranges_pst
!= NULL
)
10214 addrmap_set_empty (objfile
->psymtabs_addrmap
,
10215 range_beginning
+ baseaddr
,
10216 range_end
- 1 + baseaddr
,
10219 /* FIXME: This is recording everything as a low-high
10220 segment of consecutive addresses. We should have a
10221 data structure for discontiguous block ranges
10225 low
= range_beginning
;
10231 if (range_beginning
< low
)
10232 low
= range_beginning
;
10233 if (range_end
> high
)
10239 /* If the first entry is an end-of-list marker, the range
10240 describes an empty scope, i.e. no instructions. */
10246 *high_return
= high
;
10250 /* Get low and high pc attributes from a die. Return 1 if the attributes
10251 are present and valid, otherwise, return 0. Return -1 if the range is
10252 discontinuous, i.e. derived from DW_AT_ranges information. */
10255 dwarf2_get_pc_bounds (struct die_info
*die
, CORE_ADDR
*lowpc
,
10256 CORE_ADDR
*highpc
, struct dwarf2_cu
*cu
,
10257 struct partial_symtab
*pst
)
10259 struct attribute
*attr
;
10260 struct attribute
*attr_high
;
10262 CORE_ADDR high
= 0;
10265 attr_high
= dwarf2_attr (die
, DW_AT_high_pc
, cu
);
10268 attr
= dwarf2_attr (die
, DW_AT_low_pc
, cu
);
10271 low
= DW_ADDR (attr
);
10272 if (attr_high
->form
== DW_FORM_addr
10273 || attr_high
->form
== DW_FORM_GNU_addr_index
)
10274 high
= DW_ADDR (attr_high
);
10276 high
= low
+ DW_UNSND (attr_high
);
10279 /* Found high w/o low attribute. */
10282 /* Found consecutive range of addresses. */
10287 attr
= dwarf2_attr (die
, DW_AT_ranges
, cu
);
10290 /* DW_AT_ranges_base does not apply to DIEs from the DWO skeleton.
10291 We take advantage of the fact that DW_AT_ranges does not appear
10292 in DW_TAG_compile_unit of DWO files. */
10293 int need_ranges_base
= die
->tag
!= DW_TAG_compile_unit
;
10294 unsigned int ranges_offset
= (DW_UNSND (attr
)
10295 + (need_ranges_base
10299 /* Value of the DW_AT_ranges attribute is the offset in the
10300 .debug_ranges section. */
10301 if (!dwarf2_ranges_read (ranges_offset
, &low
, &high
, cu
, pst
))
10303 /* Found discontinuous range of addresses. */
10308 /* read_partial_die has also the strict LOW < HIGH requirement. */
10312 /* When using the GNU linker, .gnu.linkonce. sections are used to
10313 eliminate duplicate copies of functions and vtables and such.
10314 The linker will arbitrarily choose one and discard the others.
10315 The AT_*_pc values for such functions refer to local labels in
10316 these sections. If the section from that file was discarded, the
10317 labels are not in the output, so the relocs get a value of 0.
10318 If this is a discarded function, mark the pc bounds as invalid,
10319 so that GDB will ignore it. */
10320 if (low
== 0 && !dwarf2_per_objfile
->has_section_at_zero
)
10329 /* Assuming that DIE represents a subprogram DIE or a lexical block, get
10330 its low and high PC addresses. Do nothing if these addresses could not
10331 be determined. Otherwise, set LOWPC to the low address if it is smaller,
10332 and HIGHPC to the high address if greater than HIGHPC. */
10335 dwarf2_get_subprogram_pc_bounds (struct die_info
*die
,
10336 CORE_ADDR
*lowpc
, CORE_ADDR
*highpc
,
10337 struct dwarf2_cu
*cu
)
10339 CORE_ADDR low
, high
;
10340 struct die_info
*child
= die
->child
;
10342 if (dwarf2_get_pc_bounds (die
, &low
, &high
, cu
, NULL
))
10344 *lowpc
= min (*lowpc
, low
);
10345 *highpc
= max (*highpc
, high
);
10348 /* If the language does not allow nested subprograms (either inside
10349 subprograms or lexical blocks), we're done. */
10350 if (cu
->language
!= language_ada
)
10353 /* Check all the children of the given DIE. If it contains nested
10354 subprograms, then check their pc bounds. Likewise, we need to
10355 check lexical blocks as well, as they may also contain subprogram
10357 while (child
&& child
->tag
)
10359 if (child
->tag
== DW_TAG_subprogram
10360 || child
->tag
== DW_TAG_lexical_block
)
10361 dwarf2_get_subprogram_pc_bounds (child
, lowpc
, highpc
, cu
);
10362 child
= sibling_die (child
);
10366 /* Get the low and high pc's represented by the scope DIE, and store
10367 them in *LOWPC and *HIGHPC. If the correct values can't be
10368 determined, set *LOWPC to -1 and *HIGHPC to 0. */
10371 get_scope_pc_bounds (struct die_info
*die
,
10372 CORE_ADDR
*lowpc
, CORE_ADDR
*highpc
,
10373 struct dwarf2_cu
*cu
)
10375 CORE_ADDR best_low
= (CORE_ADDR
) -1;
10376 CORE_ADDR best_high
= (CORE_ADDR
) 0;
10377 CORE_ADDR current_low
, current_high
;
10379 if (dwarf2_get_pc_bounds (die
, ¤t_low
, ¤t_high
, cu
, NULL
))
10381 best_low
= current_low
;
10382 best_high
= current_high
;
10386 struct die_info
*child
= die
->child
;
10388 while (child
&& child
->tag
)
10390 switch (child
->tag
) {
10391 case DW_TAG_subprogram
:
10392 dwarf2_get_subprogram_pc_bounds (child
, &best_low
, &best_high
, cu
);
10394 case DW_TAG_namespace
:
10395 case DW_TAG_module
:
10396 /* FIXME: carlton/2004-01-16: Should we do this for
10397 DW_TAG_class_type/DW_TAG_structure_type, too? I think
10398 that current GCC's always emit the DIEs corresponding
10399 to definitions of methods of classes as children of a
10400 DW_TAG_compile_unit or DW_TAG_namespace (as opposed to
10401 the DIEs giving the declarations, which could be
10402 anywhere). But I don't see any reason why the
10403 standards says that they have to be there. */
10404 get_scope_pc_bounds (child
, ¤t_low
, ¤t_high
, cu
);
10406 if (current_low
!= ((CORE_ADDR
) -1))
10408 best_low
= min (best_low
, current_low
);
10409 best_high
= max (best_high
, current_high
);
10417 child
= sibling_die (child
);
10422 *highpc
= best_high
;
10425 /* Record the address ranges for BLOCK, offset by BASEADDR, as given
10429 dwarf2_record_block_ranges (struct die_info
*die
, struct block
*block
,
10430 CORE_ADDR baseaddr
, struct dwarf2_cu
*cu
)
10432 struct objfile
*objfile
= cu
->objfile
;
10433 struct attribute
*attr
;
10434 struct attribute
*attr_high
;
10436 attr_high
= dwarf2_attr (die
, DW_AT_high_pc
, cu
);
10439 attr
= dwarf2_attr (die
, DW_AT_low_pc
, cu
);
10442 CORE_ADDR low
= DW_ADDR (attr
);
10444 if (attr_high
->form
== DW_FORM_addr
10445 || attr_high
->form
== DW_FORM_GNU_addr_index
)
10446 high
= DW_ADDR (attr_high
);
10448 high
= low
+ DW_UNSND (attr_high
);
10450 record_block_range (block
, baseaddr
+ low
, baseaddr
+ high
- 1);
10454 attr
= dwarf2_attr (die
, DW_AT_ranges
, cu
);
10457 bfd
*obfd
= objfile
->obfd
;
10458 /* DW_AT_ranges_base does not apply to DIEs from the DWO skeleton.
10459 We take advantage of the fact that DW_AT_ranges does not appear
10460 in DW_TAG_compile_unit of DWO files. */
10461 int need_ranges_base
= die
->tag
!= DW_TAG_compile_unit
;
10463 /* The value of the DW_AT_ranges attribute is the offset of the
10464 address range list in the .debug_ranges section. */
10465 unsigned long offset
= (DW_UNSND (attr
)
10466 + (need_ranges_base
? cu
->ranges_base
: 0));
10467 gdb_byte
*buffer
= dwarf2_per_objfile
->ranges
.buffer
+ offset
;
10469 /* For some target architectures, but not others, the
10470 read_address function sign-extends the addresses it returns.
10471 To recognize base address selection entries, we need a
10473 unsigned int addr_size
= cu
->header
.addr_size
;
10474 CORE_ADDR base_select_mask
= ~(~(CORE_ADDR
)1 << (addr_size
* 8 - 1));
10476 /* The base address, to which the next pair is relative. Note
10477 that this 'base' is a DWARF concept: most entries in a range
10478 list are relative, to reduce the number of relocs against the
10479 debugging information. This is separate from this function's
10480 'baseaddr' argument, which GDB uses to relocate debugging
10481 information from a shared library based on the address at
10482 which the library was loaded. */
10483 CORE_ADDR base
= cu
->base_address
;
10484 int base_known
= cu
->base_known
;
10486 gdb_assert (dwarf2_per_objfile
->ranges
.readin
);
10487 if (offset
>= dwarf2_per_objfile
->ranges
.size
)
10489 complaint (&symfile_complaints
,
10490 _("Offset %lu out of bounds for DW_AT_ranges attribute"),
10497 unsigned int bytes_read
;
10498 CORE_ADDR start
, end
;
10500 start
= read_address (obfd
, buffer
, cu
, &bytes_read
);
10501 buffer
+= bytes_read
;
10502 end
= read_address (obfd
, buffer
, cu
, &bytes_read
);
10503 buffer
+= bytes_read
;
10505 /* Did we find the end of the range list? */
10506 if (start
== 0 && end
== 0)
10509 /* Did we find a base address selection entry? */
10510 else if ((start
& base_select_mask
) == base_select_mask
)
10516 /* We found an ordinary address range. */
10521 complaint (&symfile_complaints
,
10522 _("Invalid .debug_ranges data "
10523 "(no base address)"));
10529 /* Inverted range entries are invalid. */
10530 complaint (&symfile_complaints
,
10531 _("Invalid .debug_ranges data "
10532 "(inverted range)"));
10536 /* Empty range entries have no effect. */
10540 start
+= base
+ baseaddr
;
10541 end
+= base
+ baseaddr
;
10543 /* A not-uncommon case of bad debug info.
10544 Don't pollute the addrmap with bad data. */
10545 if (start
== 0 && !dwarf2_per_objfile
->has_section_at_zero
)
10547 complaint (&symfile_complaints
,
10548 _(".debug_ranges entry has start address of zero"
10549 " [in module %s]"), objfile
->name
);
10553 record_block_range (block
, start
, end
- 1);
10559 /* Check whether the producer field indicates either of GCC < 4.6, or the
10560 Intel C/C++ compiler, and cache the result in CU. */
10563 check_producer (struct dwarf2_cu
*cu
)
10566 int major
, minor
, release
;
10568 if (cu
->producer
== NULL
)
10570 /* For unknown compilers expect their behavior is DWARF version
10573 GCC started to support .debug_types sections by -gdwarf-4 since
10574 gcc-4.5.x. As the .debug_types sections are missing DW_AT_producer
10575 for their space efficiency GDB cannot workaround gcc-4.5.x -gdwarf-4
10576 combination. gcc-4.5.x -gdwarf-4 binaries have DW_AT_accessibility
10577 interpreted incorrectly by GDB now - GCC PR debug/48229. */
10579 else if (strncmp (cu
->producer
, "GNU ", strlen ("GNU ")) == 0)
10581 /* Skip any identifier after "GNU " - such as "C++" or "Java". */
10583 cs
= &cu
->producer
[strlen ("GNU ")];
10584 while (*cs
&& !isdigit (*cs
))
10586 if (sscanf (cs
, "%d.%d.%d", &major
, &minor
, &release
) != 3)
10588 /* Not recognized as GCC. */
10592 cu
->producer_is_gxx_lt_4_6
= major
< 4 || (major
== 4 && minor
< 6);
10593 cu
->producer_is_gcc_lt_4_3
= major
< 4 || (major
== 4 && minor
< 3);
10596 else if (strncmp (cu
->producer
, "Intel(R) C", strlen ("Intel(R) C")) == 0)
10597 cu
->producer_is_icc
= 1;
10600 /* For other non-GCC compilers, expect their behavior is DWARF version
10604 cu
->checked_producer
= 1;
10607 /* Check for GCC PR debug/45124 fix which is not present in any G++ version up
10608 to 4.5.any while it is present already in G++ 4.6.0 - the PR has been fixed
10609 during 4.6.0 experimental. */
10612 producer_is_gxx_lt_4_6 (struct dwarf2_cu
*cu
)
10614 if (!cu
->checked_producer
)
10615 check_producer (cu
);
10617 return cu
->producer_is_gxx_lt_4_6
;
10620 /* Return the default accessibility type if it is not overriden by
10621 DW_AT_accessibility. */
10623 static enum dwarf_access_attribute
10624 dwarf2_default_access_attribute (struct die_info
*die
, struct dwarf2_cu
*cu
)
10626 if (cu
->header
.version
< 3 || producer_is_gxx_lt_4_6 (cu
))
10628 /* The default DWARF 2 accessibility for members is public, the default
10629 accessibility for inheritance is private. */
10631 if (die
->tag
!= DW_TAG_inheritance
)
10632 return DW_ACCESS_public
;
10634 return DW_ACCESS_private
;
10638 /* DWARF 3+ defines the default accessibility a different way. The same
10639 rules apply now for DW_TAG_inheritance as for the members and it only
10640 depends on the container kind. */
10642 if (die
->parent
->tag
== DW_TAG_class_type
)
10643 return DW_ACCESS_private
;
10645 return DW_ACCESS_public
;
10649 /* Look for DW_AT_data_member_location. Set *OFFSET to the byte
10650 offset. If the attribute was not found return 0, otherwise return
10651 1. If it was found but could not properly be handled, set *OFFSET
10655 handle_data_member_location (struct die_info
*die
, struct dwarf2_cu
*cu
,
10658 struct attribute
*attr
;
10660 attr
= dwarf2_attr (die
, DW_AT_data_member_location
, cu
);
10665 /* Note that we do not check for a section offset first here.
10666 This is because DW_AT_data_member_location is new in DWARF 4,
10667 so if we see it, we can assume that a constant form is really
10668 a constant and not a section offset. */
10669 if (attr_form_is_constant (attr
))
10670 *offset
= dwarf2_get_attr_constant_value (attr
, 0);
10671 else if (attr_form_is_section_offset (attr
))
10672 dwarf2_complex_location_expr_complaint ();
10673 else if (attr_form_is_block (attr
))
10674 *offset
= decode_locdesc (DW_BLOCK (attr
), cu
);
10676 dwarf2_complex_location_expr_complaint ();
10684 /* Add an aggregate field to the field list. */
10687 dwarf2_add_field (struct field_info
*fip
, struct die_info
*die
,
10688 struct dwarf2_cu
*cu
)
10690 struct objfile
*objfile
= cu
->objfile
;
10691 struct gdbarch
*gdbarch
= get_objfile_arch (objfile
);
10692 struct nextfield
*new_field
;
10693 struct attribute
*attr
;
10695 const char *fieldname
= "";
10697 /* Allocate a new field list entry and link it in. */
10698 new_field
= (struct nextfield
*) xmalloc (sizeof (struct nextfield
));
10699 make_cleanup (xfree
, new_field
);
10700 memset (new_field
, 0, sizeof (struct nextfield
));
10702 if (die
->tag
== DW_TAG_inheritance
)
10704 new_field
->next
= fip
->baseclasses
;
10705 fip
->baseclasses
= new_field
;
10709 new_field
->next
= fip
->fields
;
10710 fip
->fields
= new_field
;
10714 attr
= dwarf2_attr (die
, DW_AT_accessibility
, cu
);
10716 new_field
->accessibility
= DW_UNSND (attr
);
10718 new_field
->accessibility
= dwarf2_default_access_attribute (die
, cu
);
10719 if (new_field
->accessibility
!= DW_ACCESS_public
)
10720 fip
->non_public_fields
= 1;
10722 attr
= dwarf2_attr (die
, DW_AT_virtuality
, cu
);
10724 new_field
->virtuality
= DW_UNSND (attr
);
10726 new_field
->virtuality
= DW_VIRTUALITY_none
;
10728 fp
= &new_field
->field
;
10730 if (die
->tag
== DW_TAG_member
&& ! die_is_declaration (die
, cu
))
10734 /* Data member other than a C++ static data member. */
10736 /* Get type of field. */
10737 fp
->type
= die_type (die
, cu
);
10739 SET_FIELD_BITPOS (*fp
, 0);
10741 /* Get bit size of field (zero if none). */
10742 attr
= dwarf2_attr (die
, DW_AT_bit_size
, cu
);
10745 FIELD_BITSIZE (*fp
) = DW_UNSND (attr
);
10749 FIELD_BITSIZE (*fp
) = 0;
10752 /* Get bit offset of field. */
10753 if (handle_data_member_location (die
, cu
, &offset
))
10754 SET_FIELD_BITPOS (*fp
, offset
* bits_per_byte
);
10755 attr
= dwarf2_attr (die
, DW_AT_bit_offset
, cu
);
10758 if (gdbarch_bits_big_endian (gdbarch
))
10760 /* For big endian bits, the DW_AT_bit_offset gives the
10761 additional bit offset from the MSB of the containing
10762 anonymous object to the MSB of the field. We don't
10763 have to do anything special since we don't need to
10764 know the size of the anonymous object. */
10765 SET_FIELD_BITPOS (*fp
, FIELD_BITPOS (*fp
) + DW_UNSND (attr
));
10769 /* For little endian bits, compute the bit offset to the
10770 MSB of the anonymous object, subtract off the number of
10771 bits from the MSB of the field to the MSB of the
10772 object, and then subtract off the number of bits of
10773 the field itself. The result is the bit offset of
10774 the LSB of the field. */
10775 int anonymous_size
;
10776 int bit_offset
= DW_UNSND (attr
);
10778 attr
= dwarf2_attr (die
, DW_AT_byte_size
, cu
);
10781 /* The size of the anonymous object containing
10782 the bit field is explicit, so use the
10783 indicated size (in bytes). */
10784 anonymous_size
= DW_UNSND (attr
);
10788 /* The size of the anonymous object containing
10789 the bit field must be inferred from the type
10790 attribute of the data member containing the
10792 anonymous_size
= TYPE_LENGTH (fp
->type
);
10794 SET_FIELD_BITPOS (*fp
,
10795 (FIELD_BITPOS (*fp
)
10796 + anonymous_size
* bits_per_byte
10797 - bit_offset
- FIELD_BITSIZE (*fp
)));
10801 /* Get name of field. */
10802 fieldname
= dwarf2_name (die
, cu
);
10803 if (fieldname
== NULL
)
10806 /* The name is already allocated along with this objfile, so we don't
10807 need to duplicate it for the type. */
10808 fp
->name
= fieldname
;
10810 /* Change accessibility for artificial fields (e.g. virtual table
10811 pointer or virtual base class pointer) to private. */
10812 if (dwarf2_attr (die
, DW_AT_artificial
, cu
))
10814 FIELD_ARTIFICIAL (*fp
) = 1;
10815 new_field
->accessibility
= DW_ACCESS_private
;
10816 fip
->non_public_fields
= 1;
10819 else if (die
->tag
== DW_TAG_member
|| die
->tag
== DW_TAG_variable
)
10821 /* C++ static member. */
10823 /* NOTE: carlton/2002-11-05: It should be a DW_TAG_member that
10824 is a declaration, but all versions of G++ as of this writing
10825 (so through at least 3.2.1) incorrectly generate
10826 DW_TAG_variable tags. */
10828 const char *physname
;
10830 /* Get name of field. */
10831 fieldname
= dwarf2_name (die
, cu
);
10832 if (fieldname
== NULL
)
10835 attr
= dwarf2_attr (die
, DW_AT_const_value
, cu
);
10837 /* Only create a symbol if this is an external value.
10838 new_symbol checks this and puts the value in the global symbol
10839 table, which we want. If it is not external, new_symbol
10840 will try to put the value in cu->list_in_scope which is wrong. */
10841 && dwarf2_flag_true_p (die
, DW_AT_external
, cu
))
10843 /* A static const member, not much different than an enum as far as
10844 we're concerned, except that we can support more types. */
10845 new_symbol (die
, NULL
, cu
);
10848 /* Get physical name. */
10849 physname
= dwarf2_physname (fieldname
, die
, cu
);
10851 /* The name is already allocated along with this objfile, so we don't
10852 need to duplicate it for the type. */
10853 SET_FIELD_PHYSNAME (*fp
, physname
? physname
: "");
10854 FIELD_TYPE (*fp
) = die_type (die
, cu
);
10855 FIELD_NAME (*fp
) = fieldname
;
10857 else if (die
->tag
== DW_TAG_inheritance
)
10861 /* C++ base class field. */
10862 if (handle_data_member_location (die
, cu
, &offset
))
10863 SET_FIELD_BITPOS (*fp
, offset
* bits_per_byte
);
10864 FIELD_BITSIZE (*fp
) = 0;
10865 FIELD_TYPE (*fp
) = die_type (die
, cu
);
10866 FIELD_NAME (*fp
) = type_name_no_tag (fp
->type
);
10867 fip
->nbaseclasses
++;
10871 /* Add a typedef defined in the scope of the FIP's class. */
10874 dwarf2_add_typedef (struct field_info
*fip
, struct die_info
*die
,
10875 struct dwarf2_cu
*cu
)
10877 struct objfile
*objfile
= cu
->objfile
;
10878 struct typedef_field_list
*new_field
;
10879 struct attribute
*attr
;
10880 struct typedef_field
*fp
;
10881 char *fieldname
= "";
10883 /* Allocate a new field list entry and link it in. */
10884 new_field
= xzalloc (sizeof (*new_field
));
10885 make_cleanup (xfree
, new_field
);
10887 gdb_assert (die
->tag
== DW_TAG_typedef
);
10889 fp
= &new_field
->field
;
10891 /* Get name of field. */
10892 fp
->name
= dwarf2_name (die
, cu
);
10893 if (fp
->name
== NULL
)
10896 fp
->type
= read_type_die (die
, cu
);
10898 new_field
->next
= fip
->typedef_field_list
;
10899 fip
->typedef_field_list
= new_field
;
10900 fip
->typedef_field_list_count
++;
10903 /* Create the vector of fields, and attach it to the type. */
10906 dwarf2_attach_fields_to_type (struct field_info
*fip
, struct type
*type
,
10907 struct dwarf2_cu
*cu
)
10909 int nfields
= fip
->nfields
;
10911 /* Record the field count, allocate space for the array of fields,
10912 and create blank accessibility bitfields if necessary. */
10913 TYPE_NFIELDS (type
) = nfields
;
10914 TYPE_FIELDS (type
) = (struct field
*)
10915 TYPE_ALLOC (type
, sizeof (struct field
) * nfields
);
10916 memset (TYPE_FIELDS (type
), 0, sizeof (struct field
) * nfields
);
10918 if (fip
->non_public_fields
&& cu
->language
!= language_ada
)
10920 ALLOCATE_CPLUS_STRUCT_TYPE (type
);
10922 TYPE_FIELD_PRIVATE_BITS (type
) =
10923 (B_TYPE
*) TYPE_ALLOC (type
, B_BYTES (nfields
));
10924 B_CLRALL (TYPE_FIELD_PRIVATE_BITS (type
), nfields
);
10926 TYPE_FIELD_PROTECTED_BITS (type
) =
10927 (B_TYPE
*) TYPE_ALLOC (type
, B_BYTES (nfields
));
10928 B_CLRALL (TYPE_FIELD_PROTECTED_BITS (type
), nfields
);
10930 TYPE_FIELD_IGNORE_BITS (type
) =
10931 (B_TYPE
*) TYPE_ALLOC (type
, B_BYTES (nfields
));
10932 B_CLRALL (TYPE_FIELD_IGNORE_BITS (type
), nfields
);
10935 /* If the type has baseclasses, allocate and clear a bit vector for
10936 TYPE_FIELD_VIRTUAL_BITS. */
10937 if (fip
->nbaseclasses
&& cu
->language
!= language_ada
)
10939 int num_bytes
= B_BYTES (fip
->nbaseclasses
);
10940 unsigned char *pointer
;
10942 ALLOCATE_CPLUS_STRUCT_TYPE (type
);
10943 pointer
= TYPE_ALLOC (type
, num_bytes
);
10944 TYPE_FIELD_VIRTUAL_BITS (type
) = pointer
;
10945 B_CLRALL (TYPE_FIELD_VIRTUAL_BITS (type
), fip
->nbaseclasses
);
10946 TYPE_N_BASECLASSES (type
) = fip
->nbaseclasses
;
10949 /* Copy the saved-up fields into the field vector. Start from the head of
10950 the list, adding to the tail of the field array, so that they end up in
10951 the same order in the array in which they were added to the list. */
10952 while (nfields
-- > 0)
10954 struct nextfield
*fieldp
;
10958 fieldp
= fip
->fields
;
10959 fip
->fields
= fieldp
->next
;
10963 fieldp
= fip
->baseclasses
;
10964 fip
->baseclasses
= fieldp
->next
;
10967 TYPE_FIELD (type
, nfields
) = fieldp
->field
;
10968 switch (fieldp
->accessibility
)
10970 case DW_ACCESS_private
:
10971 if (cu
->language
!= language_ada
)
10972 SET_TYPE_FIELD_PRIVATE (type
, nfields
);
10975 case DW_ACCESS_protected
:
10976 if (cu
->language
!= language_ada
)
10977 SET_TYPE_FIELD_PROTECTED (type
, nfields
);
10980 case DW_ACCESS_public
:
10984 /* Unknown accessibility. Complain and treat it as public. */
10986 complaint (&symfile_complaints
, _("unsupported accessibility %d"),
10987 fieldp
->accessibility
);
10991 if (nfields
< fip
->nbaseclasses
)
10993 switch (fieldp
->virtuality
)
10995 case DW_VIRTUALITY_virtual
:
10996 case DW_VIRTUALITY_pure_virtual
:
10997 if (cu
->language
== language_ada
)
10998 error (_("unexpected virtuality in component of Ada type"));
10999 SET_TYPE_FIELD_VIRTUAL (type
, nfields
);
11006 /* Return true if this member function is a constructor, false
11010 dwarf2_is_constructor (struct die_info
*die
, struct dwarf2_cu
*cu
)
11012 const char *fieldname
;
11013 const char *typename
;
11016 if (die
->parent
== NULL
)
11019 if (die
->parent
->tag
!= DW_TAG_structure_type
11020 && die
->parent
->tag
!= DW_TAG_union_type
11021 && die
->parent
->tag
!= DW_TAG_class_type
)
11024 fieldname
= dwarf2_name (die
, cu
);
11025 typename
= dwarf2_name (die
->parent
, cu
);
11026 if (fieldname
== NULL
|| typename
== NULL
)
11029 len
= strlen (fieldname
);
11030 return (strncmp (fieldname
, typename
, len
) == 0
11031 && (typename
[len
] == '\0' || typename
[len
] == '<'));
11034 /* Add a member function to the proper fieldlist. */
11037 dwarf2_add_member_fn (struct field_info
*fip
, struct die_info
*die
,
11038 struct type
*type
, struct dwarf2_cu
*cu
)
11040 struct objfile
*objfile
= cu
->objfile
;
11041 struct attribute
*attr
;
11042 struct fnfieldlist
*flp
;
11044 struct fn_field
*fnp
;
11045 const char *fieldname
;
11046 struct nextfnfield
*new_fnfield
;
11047 struct type
*this_type
;
11048 enum dwarf_access_attribute accessibility
;
11050 if (cu
->language
== language_ada
)
11051 error (_("unexpected member function in Ada type"));
11053 /* Get name of member function. */
11054 fieldname
= dwarf2_name (die
, cu
);
11055 if (fieldname
== NULL
)
11058 /* Look up member function name in fieldlist. */
11059 for (i
= 0; i
< fip
->nfnfields
; i
++)
11061 if (strcmp (fip
->fnfieldlists
[i
].name
, fieldname
) == 0)
11065 /* Create new list element if necessary. */
11066 if (i
< fip
->nfnfields
)
11067 flp
= &fip
->fnfieldlists
[i
];
11070 if ((fip
->nfnfields
% DW_FIELD_ALLOC_CHUNK
) == 0)
11072 fip
->fnfieldlists
= (struct fnfieldlist
*)
11073 xrealloc (fip
->fnfieldlists
,
11074 (fip
->nfnfields
+ DW_FIELD_ALLOC_CHUNK
)
11075 * sizeof (struct fnfieldlist
));
11076 if (fip
->nfnfields
== 0)
11077 make_cleanup (free_current_contents
, &fip
->fnfieldlists
);
11079 flp
= &fip
->fnfieldlists
[fip
->nfnfields
];
11080 flp
->name
= fieldname
;
11083 i
= fip
->nfnfields
++;
11086 /* Create a new member function field and chain it to the field list
11088 new_fnfield
= (struct nextfnfield
*) xmalloc (sizeof (struct nextfnfield
));
11089 make_cleanup (xfree
, new_fnfield
);
11090 memset (new_fnfield
, 0, sizeof (struct nextfnfield
));
11091 new_fnfield
->next
= flp
->head
;
11092 flp
->head
= new_fnfield
;
11095 /* Fill in the member function field info. */
11096 fnp
= &new_fnfield
->fnfield
;
11098 /* Delay processing of the physname until later. */
11099 if (cu
->language
== language_cplus
|| cu
->language
== language_java
)
11101 add_to_method_list (type
, i
, flp
->length
- 1, fieldname
,
11106 const char *physname
= dwarf2_physname (fieldname
, die
, cu
);
11107 fnp
->physname
= physname
? physname
: "";
11110 fnp
->type
= alloc_type (objfile
);
11111 this_type
= read_type_die (die
, cu
);
11112 if (this_type
&& TYPE_CODE (this_type
) == TYPE_CODE_FUNC
)
11114 int nparams
= TYPE_NFIELDS (this_type
);
11116 /* TYPE is the domain of this method, and THIS_TYPE is the type
11117 of the method itself (TYPE_CODE_METHOD). */
11118 smash_to_method_type (fnp
->type
, type
,
11119 TYPE_TARGET_TYPE (this_type
),
11120 TYPE_FIELDS (this_type
),
11121 TYPE_NFIELDS (this_type
),
11122 TYPE_VARARGS (this_type
));
11124 /* Handle static member functions.
11125 Dwarf2 has no clean way to discern C++ static and non-static
11126 member functions. G++ helps GDB by marking the first
11127 parameter for non-static member functions (which is the this
11128 pointer) as artificial. We obtain this information from
11129 read_subroutine_type via TYPE_FIELD_ARTIFICIAL. */
11130 if (nparams
== 0 || TYPE_FIELD_ARTIFICIAL (this_type
, 0) == 0)
11131 fnp
->voffset
= VOFFSET_STATIC
;
11134 complaint (&symfile_complaints
, _("member function type missing for '%s'"),
11135 dwarf2_full_name (fieldname
, die
, cu
));
11137 /* Get fcontext from DW_AT_containing_type if present. */
11138 if (dwarf2_attr (die
, DW_AT_containing_type
, cu
) != NULL
)
11139 fnp
->fcontext
= die_containing_type (die
, cu
);
11141 /* dwarf2 doesn't have stubbed physical names, so the setting of is_const and
11142 is_volatile is irrelevant, as it is needed by gdb_mangle_name only. */
11144 /* Get accessibility. */
11145 attr
= dwarf2_attr (die
, DW_AT_accessibility
, cu
);
11147 accessibility
= DW_UNSND (attr
);
11149 accessibility
= dwarf2_default_access_attribute (die
, cu
);
11150 switch (accessibility
)
11152 case DW_ACCESS_private
:
11153 fnp
->is_private
= 1;
11155 case DW_ACCESS_protected
:
11156 fnp
->is_protected
= 1;
11160 /* Check for artificial methods. */
11161 attr
= dwarf2_attr (die
, DW_AT_artificial
, cu
);
11162 if (attr
&& DW_UNSND (attr
) != 0)
11163 fnp
->is_artificial
= 1;
11165 fnp
->is_constructor
= dwarf2_is_constructor (die
, cu
);
11167 /* Get index in virtual function table if it is a virtual member
11168 function. For older versions of GCC, this is an offset in the
11169 appropriate virtual table, as specified by DW_AT_containing_type.
11170 For everyone else, it is an expression to be evaluated relative
11171 to the object address. */
11173 attr
= dwarf2_attr (die
, DW_AT_vtable_elem_location
, cu
);
11176 if (attr_form_is_block (attr
) && DW_BLOCK (attr
)->size
> 0)
11178 if (DW_BLOCK (attr
)->data
[0] == DW_OP_constu
)
11180 /* Old-style GCC. */
11181 fnp
->voffset
= decode_locdesc (DW_BLOCK (attr
), cu
) + 2;
11183 else if (DW_BLOCK (attr
)->data
[0] == DW_OP_deref
11184 || (DW_BLOCK (attr
)->size
> 1
11185 && DW_BLOCK (attr
)->data
[0] == DW_OP_deref_size
11186 && DW_BLOCK (attr
)->data
[1] == cu
->header
.addr_size
))
11188 struct dwarf_block blk
;
11191 offset
= (DW_BLOCK (attr
)->data
[0] == DW_OP_deref
11193 blk
.size
= DW_BLOCK (attr
)->size
- offset
;
11194 blk
.data
= DW_BLOCK (attr
)->data
+ offset
;
11195 fnp
->voffset
= decode_locdesc (DW_BLOCK (attr
), cu
);
11196 if ((fnp
->voffset
% cu
->header
.addr_size
) != 0)
11197 dwarf2_complex_location_expr_complaint ();
11199 fnp
->voffset
/= cu
->header
.addr_size
;
11203 dwarf2_complex_location_expr_complaint ();
11205 if (!fnp
->fcontext
)
11206 fnp
->fcontext
= TYPE_TARGET_TYPE (TYPE_FIELD_TYPE (this_type
, 0));
11208 else if (attr_form_is_section_offset (attr
))
11210 dwarf2_complex_location_expr_complaint ();
11214 dwarf2_invalid_attrib_class_complaint ("DW_AT_vtable_elem_location",
11220 attr
= dwarf2_attr (die
, DW_AT_virtuality
, cu
);
11221 if (attr
&& DW_UNSND (attr
))
11223 /* GCC does this, as of 2008-08-25; PR debug/37237. */
11224 complaint (&symfile_complaints
,
11225 _("Member function \"%s\" (offset %d) is virtual "
11226 "but the vtable offset is not specified"),
11227 fieldname
, die
->offset
.sect_off
);
11228 ALLOCATE_CPLUS_STRUCT_TYPE (type
);
11229 TYPE_CPLUS_DYNAMIC (type
) = 1;
11234 /* Create the vector of member function fields, and attach it to the type. */
11237 dwarf2_attach_fn_fields_to_type (struct field_info
*fip
, struct type
*type
,
11238 struct dwarf2_cu
*cu
)
11240 struct fnfieldlist
*flp
;
11243 if (cu
->language
== language_ada
)
11244 error (_("unexpected member functions in Ada type"));
11246 ALLOCATE_CPLUS_STRUCT_TYPE (type
);
11247 TYPE_FN_FIELDLISTS (type
) = (struct fn_fieldlist
*)
11248 TYPE_ALLOC (type
, sizeof (struct fn_fieldlist
) * fip
->nfnfields
);
11250 for (i
= 0, flp
= fip
->fnfieldlists
; i
< fip
->nfnfields
; i
++, flp
++)
11252 struct nextfnfield
*nfp
= flp
->head
;
11253 struct fn_fieldlist
*fn_flp
= &TYPE_FN_FIELDLIST (type
, i
);
11256 TYPE_FN_FIELDLIST_NAME (type
, i
) = flp
->name
;
11257 TYPE_FN_FIELDLIST_LENGTH (type
, i
) = flp
->length
;
11258 fn_flp
->fn_fields
= (struct fn_field
*)
11259 TYPE_ALLOC (type
, sizeof (struct fn_field
) * flp
->length
);
11260 for (k
= flp
->length
; (k
--, nfp
); nfp
= nfp
->next
)
11261 fn_flp
->fn_fields
[k
] = nfp
->fnfield
;
11264 TYPE_NFN_FIELDS (type
) = fip
->nfnfields
;
11267 /* Returns non-zero if NAME is the name of a vtable member in CU's
11268 language, zero otherwise. */
11270 is_vtable_name (const char *name
, struct dwarf2_cu
*cu
)
11272 static const char vptr
[] = "_vptr";
11273 static const char vtable
[] = "vtable";
11275 /* Look for the C++ and Java forms of the vtable. */
11276 if ((cu
->language
== language_java
11277 && strncmp (name
, vtable
, sizeof (vtable
) - 1) == 0)
11278 || (strncmp (name
, vptr
, sizeof (vptr
) - 1) == 0
11279 && is_cplus_marker (name
[sizeof (vptr
) - 1])))
11285 /* GCC outputs unnamed structures that are really pointers to member
11286 functions, with the ABI-specified layout. If TYPE describes
11287 such a structure, smash it into a member function type.
11289 GCC shouldn't do this; it should just output pointer to member DIEs.
11290 This is GCC PR debug/28767. */
11293 quirk_gcc_member_function_pointer (struct type
*type
, struct objfile
*objfile
)
11295 struct type
*pfn_type
, *domain_type
, *new_type
;
11297 /* Check for a structure with no name and two children. */
11298 if (TYPE_CODE (type
) != TYPE_CODE_STRUCT
|| TYPE_NFIELDS (type
) != 2)
11301 /* Check for __pfn and __delta members. */
11302 if (TYPE_FIELD_NAME (type
, 0) == NULL
11303 || strcmp (TYPE_FIELD_NAME (type
, 0), "__pfn") != 0
11304 || TYPE_FIELD_NAME (type
, 1) == NULL
11305 || strcmp (TYPE_FIELD_NAME (type
, 1), "__delta") != 0)
11308 /* Find the type of the method. */
11309 pfn_type
= TYPE_FIELD_TYPE (type
, 0);
11310 if (pfn_type
== NULL
11311 || TYPE_CODE (pfn_type
) != TYPE_CODE_PTR
11312 || TYPE_CODE (TYPE_TARGET_TYPE (pfn_type
)) != TYPE_CODE_FUNC
)
11315 /* Look for the "this" argument. */
11316 pfn_type
= TYPE_TARGET_TYPE (pfn_type
);
11317 if (TYPE_NFIELDS (pfn_type
) == 0
11318 /* || TYPE_FIELD_TYPE (pfn_type, 0) == NULL */
11319 || TYPE_CODE (TYPE_FIELD_TYPE (pfn_type
, 0)) != TYPE_CODE_PTR
)
11322 domain_type
= TYPE_TARGET_TYPE (TYPE_FIELD_TYPE (pfn_type
, 0));
11323 new_type
= alloc_type (objfile
);
11324 smash_to_method_type (new_type
, domain_type
, TYPE_TARGET_TYPE (pfn_type
),
11325 TYPE_FIELDS (pfn_type
), TYPE_NFIELDS (pfn_type
),
11326 TYPE_VARARGS (pfn_type
));
11327 smash_to_methodptr_type (type
, new_type
);
11330 /* Return non-zero if the CU's PRODUCER string matches the Intel C/C++ compiler
11334 producer_is_icc (struct dwarf2_cu
*cu
)
11336 if (!cu
->checked_producer
)
11337 check_producer (cu
);
11339 return cu
->producer_is_icc
;
11342 /* Called when we find the DIE that starts a structure or union scope
11343 (definition) to create a type for the structure or union. Fill in
11344 the type's name and general properties; the members will not be
11345 processed until process_structure_scope.
11347 NOTE: we need to call these functions regardless of whether or not the
11348 DIE has a DW_AT_name attribute, since it might be an anonymous
11349 structure or union. This gets the type entered into our set of
11350 user defined types.
11352 However, if the structure is incomplete (an opaque struct/union)
11353 then suppress creating a symbol table entry for it since gdb only
11354 wants to find the one with the complete definition. Note that if
11355 it is complete, we just call new_symbol, which does it's own
11356 checking about whether the struct/union is anonymous or not (and
11357 suppresses creating a symbol table entry itself). */
11359 static struct type
*
11360 read_structure_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
11362 struct objfile
*objfile
= cu
->objfile
;
11364 struct attribute
*attr
;
11367 /* If the definition of this type lives in .debug_types, read that type.
11368 Don't follow DW_AT_specification though, that will take us back up
11369 the chain and we want to go down. */
11370 attr
= dwarf2_attr_no_follow (die
, DW_AT_signature
);
11373 struct dwarf2_cu
*type_cu
= cu
;
11374 struct die_info
*type_die
= follow_die_ref_or_sig (die
, attr
, &type_cu
);
11376 /* We could just recurse on read_structure_type, but we need to call
11377 get_die_type to ensure only one type for this DIE is created.
11378 This is important, for example, because for c++ classes we need
11379 TYPE_NAME set which is only done by new_symbol. Blech. */
11380 type
= read_type_die (type_die
, type_cu
);
11382 /* TYPE_CU may not be the same as CU.
11383 Ensure TYPE is recorded with CU in die_type_hash. */
11384 return set_die_type (die
, type
, cu
);
11387 type
= alloc_type (objfile
);
11388 INIT_CPLUS_SPECIFIC (type
);
11390 name
= dwarf2_name (die
, cu
);
11393 if (cu
->language
== language_cplus
11394 || cu
->language
== language_java
)
11396 const char *full_name
= dwarf2_full_name (name
, die
, cu
);
11398 /* dwarf2_full_name might have already finished building the DIE's
11399 type. If so, there is no need to continue. */
11400 if (get_die_type (die
, cu
) != NULL
)
11401 return get_die_type (die
, cu
);
11403 TYPE_TAG_NAME (type
) = full_name
;
11404 if (die
->tag
== DW_TAG_structure_type
11405 || die
->tag
== DW_TAG_class_type
)
11406 TYPE_NAME (type
) = TYPE_TAG_NAME (type
);
11410 /* The name is already allocated along with this objfile, so
11411 we don't need to duplicate it for the type. */
11412 TYPE_TAG_NAME (type
) = name
;
11413 if (die
->tag
== DW_TAG_class_type
)
11414 TYPE_NAME (type
) = TYPE_TAG_NAME (type
);
11418 if (die
->tag
== DW_TAG_structure_type
)
11420 TYPE_CODE (type
) = TYPE_CODE_STRUCT
;
11422 else if (die
->tag
== DW_TAG_union_type
)
11424 TYPE_CODE (type
) = TYPE_CODE_UNION
;
11428 TYPE_CODE (type
) = TYPE_CODE_CLASS
;
11431 if (cu
->language
== language_cplus
&& die
->tag
== DW_TAG_class_type
)
11432 TYPE_DECLARED_CLASS (type
) = 1;
11434 attr
= dwarf2_attr (die
, DW_AT_byte_size
, cu
);
11437 TYPE_LENGTH (type
) = DW_UNSND (attr
);
11441 TYPE_LENGTH (type
) = 0;
11444 if (producer_is_icc (cu
))
11446 /* ICC does not output the required DW_AT_declaration
11447 on incomplete types, but gives them a size of zero. */
11450 TYPE_STUB_SUPPORTED (type
) = 1;
11452 if (die_is_declaration (die
, cu
))
11453 TYPE_STUB (type
) = 1;
11454 else if (attr
== NULL
&& die
->child
== NULL
11455 && producer_is_realview (cu
->producer
))
11456 /* RealView does not output the required DW_AT_declaration
11457 on incomplete types. */
11458 TYPE_STUB (type
) = 1;
11460 /* We need to add the type field to the die immediately so we don't
11461 infinitely recurse when dealing with pointers to the structure
11462 type within the structure itself. */
11463 set_die_type (die
, type
, cu
);
11465 /* set_die_type should be already done. */
11466 set_descriptive_type (type
, die
, cu
);
11471 /* Finish creating a structure or union type, including filling in
11472 its members and creating a symbol for it. */
11475 process_structure_scope (struct die_info
*die
, struct dwarf2_cu
*cu
)
11477 struct objfile
*objfile
= cu
->objfile
;
11478 struct die_info
*child_die
= die
->child
;
11481 type
= get_die_type (die
, cu
);
11483 type
= read_structure_type (die
, cu
);
11485 if (die
->child
!= NULL
&& ! die_is_declaration (die
, cu
))
11487 struct field_info fi
;
11488 struct die_info
*child_die
;
11489 VEC (symbolp
) *template_args
= NULL
;
11490 struct cleanup
*back_to
= make_cleanup (null_cleanup
, 0);
11492 memset (&fi
, 0, sizeof (struct field_info
));
11494 child_die
= die
->child
;
11496 while (child_die
&& child_die
->tag
)
11498 if (child_die
->tag
== DW_TAG_member
11499 || child_die
->tag
== DW_TAG_variable
)
11501 /* NOTE: carlton/2002-11-05: A C++ static data member
11502 should be a DW_TAG_member that is a declaration, but
11503 all versions of G++ as of this writing (so through at
11504 least 3.2.1) incorrectly generate DW_TAG_variable
11505 tags for them instead. */
11506 dwarf2_add_field (&fi
, child_die
, cu
);
11508 else if (child_die
->tag
== DW_TAG_subprogram
)
11510 /* C++ member function. */
11511 dwarf2_add_member_fn (&fi
, child_die
, type
, cu
);
11513 else if (child_die
->tag
== DW_TAG_inheritance
)
11515 /* C++ base class field. */
11516 dwarf2_add_field (&fi
, child_die
, cu
);
11518 else if (child_die
->tag
== DW_TAG_typedef
)
11519 dwarf2_add_typedef (&fi
, child_die
, cu
);
11520 else if (child_die
->tag
== DW_TAG_template_type_param
11521 || child_die
->tag
== DW_TAG_template_value_param
)
11523 struct symbol
*arg
= new_symbol (child_die
, NULL
, cu
);
11526 VEC_safe_push (symbolp
, template_args
, arg
);
11529 child_die
= sibling_die (child_die
);
11532 /* Attach template arguments to type. */
11533 if (! VEC_empty (symbolp
, template_args
))
11535 ALLOCATE_CPLUS_STRUCT_TYPE (type
);
11536 TYPE_N_TEMPLATE_ARGUMENTS (type
)
11537 = VEC_length (symbolp
, template_args
);
11538 TYPE_TEMPLATE_ARGUMENTS (type
)
11539 = obstack_alloc (&objfile
->objfile_obstack
,
11540 (TYPE_N_TEMPLATE_ARGUMENTS (type
)
11541 * sizeof (struct symbol
*)));
11542 memcpy (TYPE_TEMPLATE_ARGUMENTS (type
),
11543 VEC_address (symbolp
, template_args
),
11544 (TYPE_N_TEMPLATE_ARGUMENTS (type
)
11545 * sizeof (struct symbol
*)));
11546 VEC_free (symbolp
, template_args
);
11549 /* Attach fields and member functions to the type. */
11551 dwarf2_attach_fields_to_type (&fi
, type
, cu
);
11554 dwarf2_attach_fn_fields_to_type (&fi
, type
, cu
);
11556 /* Get the type which refers to the base class (possibly this
11557 class itself) which contains the vtable pointer for the current
11558 class from the DW_AT_containing_type attribute. This use of
11559 DW_AT_containing_type is a GNU extension. */
11561 if (dwarf2_attr (die
, DW_AT_containing_type
, cu
) != NULL
)
11563 struct type
*t
= die_containing_type (die
, cu
);
11565 TYPE_VPTR_BASETYPE (type
) = t
;
11570 /* Our own class provides vtbl ptr. */
11571 for (i
= TYPE_NFIELDS (t
) - 1;
11572 i
>= TYPE_N_BASECLASSES (t
);
11575 const char *fieldname
= TYPE_FIELD_NAME (t
, i
);
11577 if (is_vtable_name (fieldname
, cu
))
11579 TYPE_VPTR_FIELDNO (type
) = i
;
11584 /* Complain if virtual function table field not found. */
11585 if (i
< TYPE_N_BASECLASSES (t
))
11586 complaint (&symfile_complaints
,
11587 _("virtual function table pointer "
11588 "not found when defining class '%s'"),
11589 TYPE_TAG_NAME (type
) ? TYPE_TAG_NAME (type
) :
11594 TYPE_VPTR_FIELDNO (type
) = TYPE_VPTR_FIELDNO (t
);
11597 else if (cu
->producer
11598 && strncmp (cu
->producer
,
11599 "IBM(R) XL C/C++ Advanced Edition", 32) == 0)
11601 /* The IBM XLC compiler does not provide direct indication
11602 of the containing type, but the vtable pointer is
11603 always named __vfp. */
11607 for (i
= TYPE_NFIELDS (type
) - 1;
11608 i
>= TYPE_N_BASECLASSES (type
);
11611 if (strcmp (TYPE_FIELD_NAME (type
, i
), "__vfp") == 0)
11613 TYPE_VPTR_FIELDNO (type
) = i
;
11614 TYPE_VPTR_BASETYPE (type
) = type
;
11621 /* Copy fi.typedef_field_list linked list elements content into the
11622 allocated array TYPE_TYPEDEF_FIELD_ARRAY (type). */
11623 if (fi
.typedef_field_list
)
11625 int i
= fi
.typedef_field_list_count
;
11627 ALLOCATE_CPLUS_STRUCT_TYPE (type
);
11628 TYPE_TYPEDEF_FIELD_ARRAY (type
)
11629 = TYPE_ALLOC (type
, sizeof (TYPE_TYPEDEF_FIELD (type
, 0)) * i
);
11630 TYPE_TYPEDEF_FIELD_COUNT (type
) = i
;
11632 /* Reverse the list order to keep the debug info elements order. */
11635 struct typedef_field
*dest
, *src
;
11637 dest
= &TYPE_TYPEDEF_FIELD (type
, i
);
11638 src
= &fi
.typedef_field_list
->field
;
11639 fi
.typedef_field_list
= fi
.typedef_field_list
->next
;
11644 do_cleanups (back_to
);
11646 if (HAVE_CPLUS_STRUCT (type
))
11647 TYPE_CPLUS_REALLY_JAVA (type
) = cu
->language
== language_java
;
11650 quirk_gcc_member_function_pointer (type
, objfile
);
11652 /* NOTE: carlton/2004-03-16: GCC 3.4 (or at least one of its
11653 snapshots) has been known to create a die giving a declaration
11654 for a class that has, as a child, a die giving a definition for a
11655 nested class. So we have to process our children even if the
11656 current die is a declaration. Normally, of course, a declaration
11657 won't have any children at all. */
11659 while (child_die
!= NULL
&& child_die
->tag
)
11661 if (child_die
->tag
== DW_TAG_member
11662 || child_die
->tag
== DW_TAG_variable
11663 || child_die
->tag
== DW_TAG_inheritance
11664 || child_die
->tag
== DW_TAG_template_value_param
11665 || child_die
->tag
== DW_TAG_template_type_param
)
11670 process_die (child_die
, cu
);
11672 child_die
= sibling_die (child_die
);
11675 /* Do not consider external references. According to the DWARF standard,
11676 these DIEs are identified by the fact that they have no byte_size
11677 attribute, and a declaration attribute. */
11678 if (dwarf2_attr (die
, DW_AT_byte_size
, cu
) != NULL
11679 || !die_is_declaration (die
, cu
))
11680 new_symbol (die
, type
, cu
);
11683 /* Given a DW_AT_enumeration_type die, set its type. We do not
11684 complete the type's fields yet, or create any symbols. */
11686 static struct type
*
11687 read_enumeration_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
11689 struct objfile
*objfile
= cu
->objfile
;
11691 struct attribute
*attr
;
11694 /* If the definition of this type lives in .debug_types, read that type.
11695 Don't follow DW_AT_specification though, that will take us back up
11696 the chain and we want to go down. */
11697 attr
= dwarf2_attr_no_follow (die
, DW_AT_signature
);
11700 struct dwarf2_cu
*type_cu
= cu
;
11701 struct die_info
*type_die
= follow_die_ref_or_sig (die
, attr
, &type_cu
);
11703 type
= read_type_die (type_die
, type_cu
);
11705 /* TYPE_CU may not be the same as CU.
11706 Ensure TYPE is recorded with CU in die_type_hash. */
11707 return set_die_type (die
, type
, cu
);
11710 type
= alloc_type (objfile
);
11712 TYPE_CODE (type
) = TYPE_CODE_ENUM
;
11713 name
= dwarf2_full_name (NULL
, die
, cu
);
11715 TYPE_TAG_NAME (type
) = name
;
11717 attr
= dwarf2_attr (die
, DW_AT_byte_size
, cu
);
11720 TYPE_LENGTH (type
) = DW_UNSND (attr
);
11724 TYPE_LENGTH (type
) = 0;
11727 /* The enumeration DIE can be incomplete. In Ada, any type can be
11728 declared as private in the package spec, and then defined only
11729 inside the package body. Such types are known as Taft Amendment
11730 Types. When another package uses such a type, an incomplete DIE
11731 may be generated by the compiler. */
11732 if (die_is_declaration (die
, cu
))
11733 TYPE_STUB (type
) = 1;
11735 return set_die_type (die
, type
, cu
);
11738 /* Given a pointer to a die which begins an enumeration, process all
11739 the dies that define the members of the enumeration, and create the
11740 symbol for the enumeration type.
11742 NOTE: We reverse the order of the element list. */
11745 process_enumeration_scope (struct die_info
*die
, struct dwarf2_cu
*cu
)
11747 struct type
*this_type
;
11749 this_type
= get_die_type (die
, cu
);
11750 if (this_type
== NULL
)
11751 this_type
= read_enumeration_type (die
, cu
);
11753 if (die
->child
!= NULL
)
11755 struct die_info
*child_die
;
11756 struct symbol
*sym
;
11757 struct field
*fields
= NULL
;
11758 int num_fields
= 0;
11759 int unsigned_enum
= 1;
11764 child_die
= die
->child
;
11765 while (child_die
&& child_die
->tag
)
11767 if (child_die
->tag
!= DW_TAG_enumerator
)
11769 process_die (child_die
, cu
);
11773 name
= dwarf2_name (child_die
, cu
);
11776 sym
= new_symbol (child_die
, this_type
, cu
);
11777 if (SYMBOL_VALUE (sym
) < 0)
11782 else if ((mask
& SYMBOL_VALUE (sym
)) != 0)
11785 mask
|= SYMBOL_VALUE (sym
);
11787 if ((num_fields
% DW_FIELD_ALLOC_CHUNK
) == 0)
11789 fields
= (struct field
*)
11791 (num_fields
+ DW_FIELD_ALLOC_CHUNK
)
11792 * sizeof (struct field
));
11795 FIELD_NAME (fields
[num_fields
]) = SYMBOL_LINKAGE_NAME (sym
);
11796 FIELD_TYPE (fields
[num_fields
]) = NULL
;
11797 SET_FIELD_ENUMVAL (fields
[num_fields
], SYMBOL_VALUE (sym
));
11798 FIELD_BITSIZE (fields
[num_fields
]) = 0;
11804 child_die
= sibling_die (child_die
);
11809 TYPE_NFIELDS (this_type
) = num_fields
;
11810 TYPE_FIELDS (this_type
) = (struct field
*)
11811 TYPE_ALLOC (this_type
, sizeof (struct field
) * num_fields
);
11812 memcpy (TYPE_FIELDS (this_type
), fields
,
11813 sizeof (struct field
) * num_fields
);
11817 TYPE_UNSIGNED (this_type
) = 1;
11819 TYPE_FLAG_ENUM (this_type
) = 1;
11822 /* If we are reading an enum from a .debug_types unit, and the enum
11823 is a declaration, and the enum is not the signatured type in the
11824 unit, then we do not want to add a symbol for it. Adding a
11825 symbol would in some cases obscure the true definition of the
11826 enum, giving users an incomplete type when the definition is
11827 actually available. Note that we do not want to do this for all
11828 enums which are just declarations, because C++0x allows forward
11829 enum declarations. */
11830 if (cu
->per_cu
->is_debug_types
11831 && die_is_declaration (die
, cu
))
11833 struct signatured_type
*sig_type
;
11835 sig_type
= (struct signatured_type
*) cu
->per_cu
;
11836 gdb_assert (sig_type
->type_offset_in_section
.sect_off
!= 0);
11837 if (sig_type
->type_offset_in_section
.sect_off
!= die
->offset
.sect_off
)
11841 new_symbol (die
, this_type
, cu
);
11844 /* Extract all information from a DW_TAG_array_type DIE and put it in
11845 the DIE's type field. For now, this only handles one dimensional
11848 static struct type
*
11849 read_array_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
11851 struct objfile
*objfile
= cu
->objfile
;
11852 struct die_info
*child_die
;
11854 struct type
*element_type
, *range_type
, *index_type
;
11855 struct type
**range_types
= NULL
;
11856 struct attribute
*attr
;
11858 struct cleanup
*back_to
;
11861 element_type
= die_type (die
, cu
);
11863 /* The die_type call above may have already set the type for this DIE. */
11864 type
= get_die_type (die
, cu
);
11868 /* Irix 6.2 native cc creates array types without children for
11869 arrays with unspecified length. */
11870 if (die
->child
== NULL
)
11872 index_type
= objfile_type (objfile
)->builtin_int
;
11873 range_type
= create_range_type (NULL
, index_type
, 0, -1);
11874 type
= create_array_type (NULL
, element_type
, range_type
);
11875 return set_die_type (die
, type
, cu
);
11878 back_to
= make_cleanup (null_cleanup
, NULL
);
11879 child_die
= die
->child
;
11880 while (child_die
&& child_die
->tag
)
11882 if (child_die
->tag
== DW_TAG_subrange_type
)
11884 struct type
*child_type
= read_type_die (child_die
, cu
);
11886 if (child_type
!= NULL
)
11888 /* The range type was succesfully read. Save it for the
11889 array type creation. */
11890 if ((ndim
% DW_FIELD_ALLOC_CHUNK
) == 0)
11892 range_types
= (struct type
**)
11893 xrealloc (range_types
, (ndim
+ DW_FIELD_ALLOC_CHUNK
)
11894 * sizeof (struct type
*));
11896 make_cleanup (free_current_contents
, &range_types
);
11898 range_types
[ndim
++] = child_type
;
11901 child_die
= sibling_die (child_die
);
11904 /* Dwarf2 dimensions are output from left to right, create the
11905 necessary array types in backwards order. */
11907 type
= element_type
;
11909 if (read_array_order (die
, cu
) == DW_ORD_col_major
)
11914 type
= create_array_type (NULL
, type
, range_types
[i
++]);
11919 type
= create_array_type (NULL
, type
, range_types
[ndim
]);
11922 /* Understand Dwarf2 support for vector types (like they occur on
11923 the PowerPC w/ AltiVec). Gcc just adds another attribute to the
11924 array type. This is not part of the Dwarf2/3 standard yet, but a
11925 custom vendor extension. The main difference between a regular
11926 array and the vector variant is that vectors are passed by value
11928 attr
= dwarf2_attr (die
, DW_AT_GNU_vector
, cu
);
11930 make_vector_type (type
);
11932 /* The DIE may have DW_AT_byte_size set. For example an OpenCL
11933 implementation may choose to implement triple vectors using this
11935 attr
= dwarf2_attr (die
, DW_AT_byte_size
, cu
);
11938 if (DW_UNSND (attr
) >= TYPE_LENGTH (type
))
11939 TYPE_LENGTH (type
) = DW_UNSND (attr
);
11941 complaint (&symfile_complaints
,
11942 _("DW_AT_byte_size for array type smaller "
11943 "than the total size of elements"));
11946 name
= dwarf2_name (die
, cu
);
11948 TYPE_NAME (type
) = name
;
11950 /* Install the type in the die. */
11951 set_die_type (die
, type
, cu
);
11953 /* set_die_type should be already done. */
11954 set_descriptive_type (type
, die
, cu
);
11956 do_cleanups (back_to
);
11961 static enum dwarf_array_dim_ordering
11962 read_array_order (struct die_info
*die
, struct dwarf2_cu
*cu
)
11964 struct attribute
*attr
;
11966 attr
= dwarf2_attr (die
, DW_AT_ordering
, cu
);
11968 if (attr
) return DW_SND (attr
);
11970 /* GNU F77 is a special case, as at 08/2004 array type info is the
11971 opposite order to the dwarf2 specification, but data is still
11972 laid out as per normal fortran.
11974 FIXME: dsl/2004-8-20: If G77 is ever fixed, this will also need
11975 version checking. */
11977 if (cu
->language
== language_fortran
11978 && cu
->producer
&& strstr (cu
->producer
, "GNU F77"))
11980 return DW_ORD_row_major
;
11983 switch (cu
->language_defn
->la_array_ordering
)
11985 case array_column_major
:
11986 return DW_ORD_col_major
;
11987 case array_row_major
:
11989 return DW_ORD_row_major
;
11993 /* Extract all information from a DW_TAG_set_type DIE and put it in
11994 the DIE's type field. */
11996 static struct type
*
11997 read_set_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
11999 struct type
*domain_type
, *set_type
;
12000 struct attribute
*attr
;
12002 domain_type
= die_type (die
, cu
);
12004 /* The die_type call above may have already set the type for this DIE. */
12005 set_type
= get_die_type (die
, cu
);
12009 set_type
= create_set_type (NULL
, domain_type
);
12011 attr
= dwarf2_attr (die
, DW_AT_byte_size
, cu
);
12013 TYPE_LENGTH (set_type
) = DW_UNSND (attr
);
12015 return set_die_type (die
, set_type
, cu
);
12018 /* A helper for read_common_block that creates a locexpr baton.
12019 SYM is the symbol which we are marking as computed.
12020 COMMON_DIE is the DIE for the common block.
12021 COMMON_LOC is the location expression attribute for the common
12023 MEMBER_LOC is the location expression attribute for the particular
12024 member of the common block that we are processing.
12025 CU is the CU from which the above come. */
12028 mark_common_block_symbol_computed (struct symbol
*sym
,
12029 struct die_info
*common_die
,
12030 struct attribute
*common_loc
,
12031 struct attribute
*member_loc
,
12032 struct dwarf2_cu
*cu
)
12034 struct objfile
*objfile
= dwarf2_per_objfile
->objfile
;
12035 struct dwarf2_locexpr_baton
*baton
;
12037 unsigned int cu_off
;
12038 enum bfd_endian byte_order
= gdbarch_byte_order (get_objfile_arch (objfile
));
12039 LONGEST offset
= 0;
12041 gdb_assert (common_loc
&& member_loc
);
12042 gdb_assert (attr_form_is_block (common_loc
));
12043 gdb_assert (attr_form_is_block (member_loc
)
12044 || attr_form_is_constant (member_loc
));
12046 baton
= obstack_alloc (&objfile
->objfile_obstack
,
12047 sizeof (struct dwarf2_locexpr_baton
));
12048 baton
->per_cu
= cu
->per_cu
;
12049 gdb_assert (baton
->per_cu
);
12051 baton
->size
= 5 /* DW_OP_call4 */ + 1 /* DW_OP_plus */;
12053 if (attr_form_is_constant (member_loc
))
12055 offset
= dwarf2_get_attr_constant_value (member_loc
, 0);
12056 baton
->size
+= 1 /* DW_OP_addr */ + cu
->header
.addr_size
;
12059 baton
->size
+= DW_BLOCK (member_loc
)->size
;
12061 ptr
= obstack_alloc (&objfile
->objfile_obstack
, baton
->size
);
12064 *ptr
++ = DW_OP_call4
;
12065 cu_off
= common_die
->offset
.sect_off
- cu
->per_cu
->offset
.sect_off
;
12066 store_unsigned_integer (ptr
, 4, byte_order
, cu_off
);
12069 if (attr_form_is_constant (member_loc
))
12071 *ptr
++ = DW_OP_addr
;
12072 store_unsigned_integer (ptr
, cu
->header
.addr_size
, byte_order
, offset
);
12073 ptr
+= cu
->header
.addr_size
;
12077 /* We have to copy the data here, because DW_OP_call4 will only
12078 use a DW_AT_location attribute. */
12079 memcpy (ptr
, DW_BLOCK (member_loc
)->data
, DW_BLOCK (member_loc
)->size
);
12080 ptr
+= DW_BLOCK (member_loc
)->size
;
12083 *ptr
++ = DW_OP_plus
;
12084 gdb_assert (ptr
- baton
->data
== baton
->size
);
12086 SYMBOL_LOCATION_BATON (sym
) = baton
;
12087 SYMBOL_ACLASS_INDEX (sym
) = dwarf2_locexpr_index
;
12090 /* Create appropriate locally-scoped variables for all the
12091 DW_TAG_common_block entries. Also create a struct common_block
12092 listing all such variables for `info common'. COMMON_BLOCK_DOMAIN
12093 is used to sepate the common blocks name namespace from regular
12097 read_common_block (struct die_info
*die
, struct dwarf2_cu
*cu
)
12099 struct attribute
*attr
;
12101 attr
= dwarf2_attr (die
, DW_AT_location
, cu
);
12104 /* Support the .debug_loc offsets. */
12105 if (attr_form_is_block (attr
))
12109 else if (attr_form_is_section_offset (attr
))
12111 dwarf2_complex_location_expr_complaint ();
12116 dwarf2_invalid_attrib_class_complaint ("DW_AT_location",
12117 "common block member");
12122 if (die
->child
!= NULL
)
12124 struct objfile
*objfile
= cu
->objfile
;
12125 struct die_info
*child_die
;
12126 size_t n_entries
= 0, size
;
12127 struct common_block
*common_block
;
12128 struct symbol
*sym
;
12130 for (child_die
= die
->child
;
12131 child_die
&& child_die
->tag
;
12132 child_die
= sibling_die (child_die
))
12135 size
= (sizeof (struct common_block
)
12136 + (n_entries
- 1) * sizeof (struct symbol
*));
12137 common_block
= obstack_alloc (&objfile
->objfile_obstack
, size
);
12138 memset (common_block
->contents
, 0, n_entries
* sizeof (struct symbol
*));
12139 common_block
->n_entries
= 0;
12141 for (child_die
= die
->child
;
12142 child_die
&& child_die
->tag
;
12143 child_die
= sibling_die (child_die
))
12145 /* Create the symbol in the DW_TAG_common_block block in the current
12147 sym
= new_symbol (child_die
, NULL
, cu
);
12150 struct attribute
*member_loc
;
12152 common_block
->contents
[common_block
->n_entries
++] = sym
;
12154 member_loc
= dwarf2_attr (child_die
, DW_AT_data_member_location
,
12158 /* GDB has handled this for a long time, but it is
12159 not specified by DWARF. It seems to have been
12160 emitted by gfortran at least as recently as:
12161 http://gcc.gnu.org/bugzilla/show_bug.cgi?id=23057. */
12162 complaint (&symfile_complaints
,
12163 _("Variable in common block has "
12164 "DW_AT_data_member_location "
12165 "- DIE at 0x%x [in module %s]"),
12166 child_die
->offset
.sect_off
, cu
->objfile
->name
);
12168 if (attr_form_is_section_offset (member_loc
))
12169 dwarf2_complex_location_expr_complaint ();
12170 else if (attr_form_is_constant (member_loc
)
12171 || attr_form_is_block (member_loc
))
12174 mark_common_block_symbol_computed (sym
, die
, attr
,
12178 dwarf2_complex_location_expr_complaint ();
12183 sym
= new_symbol (die
, objfile_type (objfile
)->builtin_void
, cu
);
12184 SYMBOL_VALUE_COMMON_BLOCK (sym
) = common_block
;
12188 /* Create a type for a C++ namespace. */
12190 static struct type
*
12191 read_namespace_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
12193 struct objfile
*objfile
= cu
->objfile
;
12194 const char *previous_prefix
, *name
;
12198 /* For extensions, reuse the type of the original namespace. */
12199 if (dwarf2_attr (die
, DW_AT_extension
, cu
) != NULL
)
12201 struct die_info
*ext_die
;
12202 struct dwarf2_cu
*ext_cu
= cu
;
12204 ext_die
= dwarf2_extension (die
, &ext_cu
);
12205 type
= read_type_die (ext_die
, ext_cu
);
12207 /* EXT_CU may not be the same as CU.
12208 Ensure TYPE is recorded with CU in die_type_hash. */
12209 return set_die_type (die
, type
, cu
);
12212 name
= namespace_name (die
, &is_anonymous
, cu
);
12214 /* Now build the name of the current namespace. */
12216 previous_prefix
= determine_prefix (die
, cu
);
12217 if (previous_prefix
[0] != '\0')
12218 name
= typename_concat (&objfile
->objfile_obstack
,
12219 previous_prefix
, name
, 0, cu
);
12221 /* Create the type. */
12222 type
= init_type (TYPE_CODE_NAMESPACE
, 0, 0, NULL
,
12224 TYPE_NAME (type
) = name
;
12225 TYPE_TAG_NAME (type
) = TYPE_NAME (type
);
12227 return set_die_type (die
, type
, cu
);
12230 /* Read a C++ namespace. */
12233 read_namespace (struct die_info
*die
, struct dwarf2_cu
*cu
)
12235 struct objfile
*objfile
= cu
->objfile
;
12238 /* Add a symbol associated to this if we haven't seen the namespace
12239 before. Also, add a using directive if it's an anonymous
12242 if (dwarf2_attr (die
, DW_AT_extension
, cu
) == NULL
)
12246 type
= read_type_die (die
, cu
);
12247 new_symbol (die
, type
, cu
);
12249 namespace_name (die
, &is_anonymous
, cu
);
12252 const char *previous_prefix
= determine_prefix (die
, cu
);
12254 cp_add_using_directive (previous_prefix
, TYPE_NAME (type
), NULL
,
12255 NULL
, NULL
, 0, &objfile
->objfile_obstack
);
12259 if (die
->child
!= NULL
)
12261 struct die_info
*child_die
= die
->child
;
12263 while (child_die
&& child_die
->tag
)
12265 process_die (child_die
, cu
);
12266 child_die
= sibling_die (child_die
);
12271 /* Read a Fortran module as type. This DIE can be only a declaration used for
12272 imported module. Still we need that type as local Fortran "use ... only"
12273 declaration imports depend on the created type in determine_prefix. */
12275 static struct type
*
12276 read_module_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
12278 struct objfile
*objfile
= cu
->objfile
;
12279 const char *module_name
;
12282 module_name
= dwarf2_name (die
, cu
);
12284 complaint (&symfile_complaints
,
12285 _("DW_TAG_module has no name, offset 0x%x"),
12286 die
->offset
.sect_off
);
12287 type
= init_type (TYPE_CODE_MODULE
, 0, 0, module_name
, objfile
);
12289 /* determine_prefix uses TYPE_TAG_NAME. */
12290 TYPE_TAG_NAME (type
) = TYPE_NAME (type
);
12292 return set_die_type (die
, type
, cu
);
12295 /* Read a Fortran module. */
12298 read_module (struct die_info
*die
, struct dwarf2_cu
*cu
)
12300 struct die_info
*child_die
= die
->child
;
12302 while (child_die
&& child_die
->tag
)
12304 process_die (child_die
, cu
);
12305 child_die
= sibling_die (child_die
);
12309 /* Return the name of the namespace represented by DIE. Set
12310 *IS_ANONYMOUS to tell whether or not the namespace is an anonymous
12313 static const char *
12314 namespace_name (struct die_info
*die
, int *is_anonymous
, struct dwarf2_cu
*cu
)
12316 struct die_info
*current_die
;
12317 const char *name
= NULL
;
12319 /* Loop through the extensions until we find a name. */
12321 for (current_die
= die
;
12322 current_die
!= NULL
;
12323 current_die
= dwarf2_extension (die
, &cu
))
12325 name
= dwarf2_name (current_die
, cu
);
12330 /* Is it an anonymous namespace? */
12332 *is_anonymous
= (name
== NULL
);
12334 name
= CP_ANONYMOUS_NAMESPACE_STR
;
12339 /* Extract all information from a DW_TAG_pointer_type DIE and add to
12340 the user defined type vector. */
12342 static struct type
*
12343 read_tag_pointer_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
12345 struct gdbarch
*gdbarch
= get_objfile_arch (cu
->objfile
);
12346 struct comp_unit_head
*cu_header
= &cu
->header
;
12348 struct attribute
*attr_byte_size
;
12349 struct attribute
*attr_address_class
;
12350 int byte_size
, addr_class
;
12351 struct type
*target_type
;
12353 target_type
= die_type (die
, cu
);
12355 /* The die_type call above may have already set the type for this DIE. */
12356 type
= get_die_type (die
, cu
);
12360 type
= lookup_pointer_type (target_type
);
12362 attr_byte_size
= dwarf2_attr (die
, DW_AT_byte_size
, cu
);
12363 if (attr_byte_size
)
12364 byte_size
= DW_UNSND (attr_byte_size
);
12366 byte_size
= cu_header
->addr_size
;
12368 attr_address_class
= dwarf2_attr (die
, DW_AT_address_class
, cu
);
12369 if (attr_address_class
)
12370 addr_class
= DW_UNSND (attr_address_class
);
12372 addr_class
= DW_ADDR_none
;
12374 /* If the pointer size or address class is different than the
12375 default, create a type variant marked as such and set the
12376 length accordingly. */
12377 if (TYPE_LENGTH (type
) != byte_size
|| addr_class
!= DW_ADDR_none
)
12379 if (gdbarch_address_class_type_flags_p (gdbarch
))
12383 type_flags
= gdbarch_address_class_type_flags
12384 (gdbarch
, byte_size
, addr_class
);
12385 gdb_assert ((type_flags
& ~TYPE_INSTANCE_FLAG_ADDRESS_CLASS_ALL
)
12387 type
= make_type_with_address_space (type
, type_flags
);
12389 else if (TYPE_LENGTH (type
) != byte_size
)
12391 complaint (&symfile_complaints
,
12392 _("invalid pointer size %d"), byte_size
);
12396 /* Should we also complain about unhandled address classes? */
12400 TYPE_LENGTH (type
) = byte_size
;
12401 return set_die_type (die
, type
, cu
);
12404 /* Extract all information from a DW_TAG_ptr_to_member_type DIE and add to
12405 the user defined type vector. */
12407 static struct type
*
12408 read_tag_ptr_to_member_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
12411 struct type
*to_type
;
12412 struct type
*domain
;
12414 to_type
= die_type (die
, cu
);
12415 domain
= die_containing_type (die
, cu
);
12417 /* The calls above may have already set the type for this DIE. */
12418 type
= get_die_type (die
, cu
);
12422 if (TYPE_CODE (check_typedef (to_type
)) == TYPE_CODE_METHOD
)
12423 type
= lookup_methodptr_type (to_type
);
12424 else if (TYPE_CODE (check_typedef (to_type
)) == TYPE_CODE_FUNC
)
12426 struct type
*new_type
= alloc_type (cu
->objfile
);
12428 smash_to_method_type (new_type
, domain
, TYPE_TARGET_TYPE (to_type
),
12429 TYPE_FIELDS (to_type
), TYPE_NFIELDS (to_type
),
12430 TYPE_VARARGS (to_type
));
12431 type
= lookup_methodptr_type (new_type
);
12434 type
= lookup_memberptr_type (to_type
, domain
);
12436 return set_die_type (die
, type
, cu
);
12439 /* Extract all information from a DW_TAG_reference_type DIE and add to
12440 the user defined type vector. */
12442 static struct type
*
12443 read_tag_reference_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
12445 struct comp_unit_head
*cu_header
= &cu
->header
;
12446 struct type
*type
, *target_type
;
12447 struct attribute
*attr
;
12449 target_type
= die_type (die
, cu
);
12451 /* The die_type call above may have already set the type for this DIE. */
12452 type
= get_die_type (die
, cu
);
12456 type
= lookup_reference_type (target_type
);
12457 attr
= dwarf2_attr (die
, DW_AT_byte_size
, cu
);
12460 TYPE_LENGTH (type
) = DW_UNSND (attr
);
12464 TYPE_LENGTH (type
) = cu_header
->addr_size
;
12466 return set_die_type (die
, type
, cu
);
12469 static struct type
*
12470 read_tag_const_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
12472 struct type
*base_type
, *cv_type
;
12474 base_type
= die_type (die
, cu
);
12476 /* The die_type call above may have already set the type for this DIE. */
12477 cv_type
= get_die_type (die
, cu
);
12481 /* In case the const qualifier is applied to an array type, the element type
12482 is so qualified, not the array type (section 6.7.3 of C99). */
12483 if (TYPE_CODE (base_type
) == TYPE_CODE_ARRAY
)
12485 struct type
*el_type
, *inner_array
;
12487 base_type
= copy_type (base_type
);
12488 inner_array
= base_type
;
12490 while (TYPE_CODE (TYPE_TARGET_TYPE (inner_array
)) == TYPE_CODE_ARRAY
)
12492 TYPE_TARGET_TYPE (inner_array
) =
12493 copy_type (TYPE_TARGET_TYPE (inner_array
));
12494 inner_array
= TYPE_TARGET_TYPE (inner_array
);
12497 el_type
= TYPE_TARGET_TYPE (inner_array
);
12498 TYPE_TARGET_TYPE (inner_array
) =
12499 make_cv_type (1, TYPE_VOLATILE (el_type
), el_type
, NULL
);
12501 return set_die_type (die
, base_type
, cu
);
12504 cv_type
= make_cv_type (1, TYPE_VOLATILE (base_type
), base_type
, 0);
12505 return set_die_type (die
, cv_type
, cu
);
12508 static struct type
*
12509 read_tag_volatile_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
12511 struct type
*base_type
, *cv_type
;
12513 base_type
= die_type (die
, cu
);
12515 /* The die_type call above may have already set the type for this DIE. */
12516 cv_type
= get_die_type (die
, cu
);
12520 cv_type
= make_cv_type (TYPE_CONST (base_type
), 1, base_type
, 0);
12521 return set_die_type (die
, cv_type
, cu
);
12524 /* Handle DW_TAG_restrict_type. */
12526 static struct type
*
12527 read_tag_restrict_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
12529 struct type
*base_type
, *cv_type
;
12531 base_type
= die_type (die
, cu
);
12533 /* The die_type call above may have already set the type for this DIE. */
12534 cv_type
= get_die_type (die
, cu
);
12538 cv_type
= make_restrict_type (base_type
);
12539 return set_die_type (die
, cv_type
, cu
);
12542 /* Extract all information from a DW_TAG_string_type DIE and add to
12543 the user defined type vector. It isn't really a user defined type,
12544 but it behaves like one, with other DIE's using an AT_user_def_type
12545 attribute to reference it. */
12547 static struct type
*
12548 read_tag_string_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
12550 struct objfile
*objfile
= cu
->objfile
;
12551 struct gdbarch
*gdbarch
= get_objfile_arch (objfile
);
12552 struct type
*type
, *range_type
, *index_type
, *char_type
;
12553 struct attribute
*attr
;
12554 unsigned int length
;
12556 attr
= dwarf2_attr (die
, DW_AT_string_length
, cu
);
12559 length
= DW_UNSND (attr
);
12563 /* Check for the DW_AT_byte_size attribute. */
12564 attr
= dwarf2_attr (die
, DW_AT_byte_size
, cu
);
12567 length
= DW_UNSND (attr
);
12575 index_type
= objfile_type (objfile
)->builtin_int
;
12576 range_type
= create_range_type (NULL
, index_type
, 1, length
);
12577 char_type
= language_string_char_type (cu
->language_defn
, gdbarch
);
12578 type
= create_string_type (NULL
, char_type
, range_type
);
12580 return set_die_type (die
, type
, cu
);
12583 /* Handle DIES due to C code like:
12587 int (*funcp)(int a, long l);
12591 ('funcp' generates a DW_TAG_subroutine_type DIE). */
12593 static struct type
*
12594 read_subroutine_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
12596 struct objfile
*objfile
= cu
->objfile
;
12597 struct type
*type
; /* Type that this function returns. */
12598 struct type
*ftype
; /* Function that returns above type. */
12599 struct attribute
*attr
;
12601 type
= die_type (die
, cu
);
12603 /* The die_type call above may have already set the type for this DIE. */
12604 ftype
= get_die_type (die
, cu
);
12608 ftype
= lookup_function_type (type
);
12610 /* All functions in C++, Pascal and Java have prototypes. */
12611 attr
= dwarf2_attr (die
, DW_AT_prototyped
, cu
);
12612 if ((attr
&& (DW_UNSND (attr
) != 0))
12613 || cu
->language
== language_cplus
12614 || cu
->language
== language_java
12615 || cu
->language
== language_pascal
)
12616 TYPE_PROTOTYPED (ftype
) = 1;
12617 else if (producer_is_realview (cu
->producer
))
12618 /* RealView does not emit DW_AT_prototyped. We can not
12619 distinguish prototyped and unprototyped functions; default to
12620 prototyped, since that is more common in modern code (and
12621 RealView warns about unprototyped functions). */
12622 TYPE_PROTOTYPED (ftype
) = 1;
12624 /* Store the calling convention in the type if it's available in
12625 the subroutine die. Otherwise set the calling convention to
12626 the default value DW_CC_normal. */
12627 attr
= dwarf2_attr (die
, DW_AT_calling_convention
, cu
);
12629 TYPE_CALLING_CONVENTION (ftype
) = DW_UNSND (attr
);
12630 else if (cu
->producer
&& strstr (cu
->producer
, "IBM XL C for OpenCL"))
12631 TYPE_CALLING_CONVENTION (ftype
) = DW_CC_GDB_IBM_OpenCL
;
12633 TYPE_CALLING_CONVENTION (ftype
) = DW_CC_normal
;
12635 /* We need to add the subroutine type to the die immediately so
12636 we don't infinitely recurse when dealing with parameters
12637 declared as the same subroutine type. */
12638 set_die_type (die
, ftype
, cu
);
12640 if (die
->child
!= NULL
)
12642 struct type
*void_type
= objfile_type (objfile
)->builtin_void
;
12643 struct die_info
*child_die
;
12644 int nparams
, iparams
;
12646 /* Count the number of parameters.
12647 FIXME: GDB currently ignores vararg functions, but knows about
12648 vararg member functions. */
12650 child_die
= die
->child
;
12651 while (child_die
&& child_die
->tag
)
12653 if (child_die
->tag
== DW_TAG_formal_parameter
)
12655 else if (child_die
->tag
== DW_TAG_unspecified_parameters
)
12656 TYPE_VARARGS (ftype
) = 1;
12657 child_die
= sibling_die (child_die
);
12660 /* Allocate storage for parameters and fill them in. */
12661 TYPE_NFIELDS (ftype
) = nparams
;
12662 TYPE_FIELDS (ftype
) = (struct field
*)
12663 TYPE_ZALLOC (ftype
, nparams
* sizeof (struct field
));
12665 /* TYPE_FIELD_TYPE must never be NULL. Pre-fill the array to ensure it
12666 even if we error out during the parameters reading below. */
12667 for (iparams
= 0; iparams
< nparams
; iparams
++)
12668 TYPE_FIELD_TYPE (ftype
, iparams
) = void_type
;
12671 child_die
= die
->child
;
12672 while (child_die
&& child_die
->tag
)
12674 if (child_die
->tag
== DW_TAG_formal_parameter
)
12676 struct type
*arg_type
;
12678 /* DWARF version 2 has no clean way to discern C++
12679 static and non-static member functions. G++ helps
12680 GDB by marking the first parameter for non-static
12681 member functions (which is the this pointer) as
12682 artificial. We pass this information to
12683 dwarf2_add_member_fn via TYPE_FIELD_ARTIFICIAL.
12685 DWARF version 3 added DW_AT_object_pointer, which GCC
12686 4.5 does not yet generate. */
12687 attr
= dwarf2_attr (child_die
, DW_AT_artificial
, cu
);
12689 TYPE_FIELD_ARTIFICIAL (ftype
, iparams
) = DW_UNSND (attr
);
12692 TYPE_FIELD_ARTIFICIAL (ftype
, iparams
) = 0;
12694 /* GCC/43521: In java, the formal parameter
12695 "this" is sometimes not marked with DW_AT_artificial. */
12696 if (cu
->language
== language_java
)
12698 const char *name
= dwarf2_name (child_die
, cu
);
12700 if (name
&& !strcmp (name
, "this"))
12701 TYPE_FIELD_ARTIFICIAL (ftype
, iparams
) = 1;
12704 arg_type
= die_type (child_die
, cu
);
12706 /* RealView does not mark THIS as const, which the testsuite
12707 expects. GCC marks THIS as const in method definitions,
12708 but not in the class specifications (GCC PR 43053). */
12709 if (cu
->language
== language_cplus
&& !TYPE_CONST (arg_type
)
12710 && TYPE_FIELD_ARTIFICIAL (ftype
, iparams
))
12713 struct dwarf2_cu
*arg_cu
= cu
;
12714 const char *name
= dwarf2_name (child_die
, cu
);
12716 attr
= dwarf2_attr (die
, DW_AT_object_pointer
, cu
);
12719 /* If the compiler emits this, use it. */
12720 if (follow_die_ref (die
, attr
, &arg_cu
) == child_die
)
12723 else if (name
&& strcmp (name
, "this") == 0)
12724 /* Function definitions will have the argument names. */
12726 else if (name
== NULL
&& iparams
== 0)
12727 /* Declarations may not have the names, so like
12728 elsewhere in GDB, assume an artificial first
12729 argument is "this". */
12733 arg_type
= make_cv_type (1, TYPE_VOLATILE (arg_type
),
12737 TYPE_FIELD_TYPE (ftype
, iparams
) = arg_type
;
12740 child_die
= sibling_die (child_die
);
12747 static struct type
*
12748 read_typedef (struct die_info
*die
, struct dwarf2_cu
*cu
)
12750 struct objfile
*objfile
= cu
->objfile
;
12751 const char *name
= NULL
;
12752 struct type
*this_type
, *target_type
;
12754 name
= dwarf2_full_name (NULL
, die
, cu
);
12755 this_type
= init_type (TYPE_CODE_TYPEDEF
, 0,
12756 TYPE_FLAG_TARGET_STUB
, NULL
, objfile
);
12757 TYPE_NAME (this_type
) = name
;
12758 set_die_type (die
, this_type
, cu
);
12759 target_type
= die_type (die
, cu
);
12760 if (target_type
!= this_type
)
12761 TYPE_TARGET_TYPE (this_type
) = target_type
;
12764 /* Self-referential typedefs are, it seems, not allowed by the DWARF
12765 spec and cause infinite loops in GDB. */
12766 complaint (&symfile_complaints
,
12767 _("Self-referential DW_TAG_typedef "
12768 "- DIE at 0x%x [in module %s]"),
12769 die
->offset
.sect_off
, objfile
->name
);
12770 TYPE_TARGET_TYPE (this_type
) = NULL
;
12775 /* Find a representation of a given base type and install
12776 it in the TYPE field of the die. */
12778 static struct type
*
12779 read_base_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
12781 struct objfile
*objfile
= cu
->objfile
;
12783 struct attribute
*attr
;
12784 int encoding
= 0, size
= 0;
12786 enum type_code code
= TYPE_CODE_INT
;
12787 int type_flags
= 0;
12788 struct type
*target_type
= NULL
;
12790 attr
= dwarf2_attr (die
, DW_AT_encoding
, cu
);
12793 encoding
= DW_UNSND (attr
);
12795 attr
= dwarf2_attr (die
, DW_AT_byte_size
, cu
);
12798 size
= DW_UNSND (attr
);
12800 name
= dwarf2_name (die
, cu
);
12803 complaint (&symfile_complaints
,
12804 _("DW_AT_name missing from DW_TAG_base_type"));
12809 case DW_ATE_address
:
12810 /* Turn DW_ATE_address into a void * pointer. */
12811 code
= TYPE_CODE_PTR
;
12812 type_flags
|= TYPE_FLAG_UNSIGNED
;
12813 target_type
= init_type (TYPE_CODE_VOID
, 1, 0, NULL
, objfile
);
12815 case DW_ATE_boolean
:
12816 code
= TYPE_CODE_BOOL
;
12817 type_flags
|= TYPE_FLAG_UNSIGNED
;
12819 case DW_ATE_complex_float
:
12820 code
= TYPE_CODE_COMPLEX
;
12821 target_type
= init_type (TYPE_CODE_FLT
, size
/ 2, 0, NULL
, objfile
);
12823 case DW_ATE_decimal_float
:
12824 code
= TYPE_CODE_DECFLOAT
;
12827 code
= TYPE_CODE_FLT
;
12829 case DW_ATE_signed
:
12831 case DW_ATE_unsigned
:
12832 type_flags
|= TYPE_FLAG_UNSIGNED
;
12833 if (cu
->language
== language_fortran
12835 && strncmp (name
, "character(", sizeof ("character(") - 1) == 0)
12836 code
= TYPE_CODE_CHAR
;
12838 case DW_ATE_signed_char
:
12839 if (cu
->language
== language_ada
|| cu
->language
== language_m2
12840 || cu
->language
== language_pascal
12841 || cu
->language
== language_fortran
)
12842 code
= TYPE_CODE_CHAR
;
12844 case DW_ATE_unsigned_char
:
12845 if (cu
->language
== language_ada
|| cu
->language
== language_m2
12846 || cu
->language
== language_pascal
12847 || cu
->language
== language_fortran
)
12848 code
= TYPE_CODE_CHAR
;
12849 type_flags
|= TYPE_FLAG_UNSIGNED
;
12852 /* We just treat this as an integer and then recognize the
12853 type by name elsewhere. */
12857 complaint (&symfile_complaints
, _("unsupported DW_AT_encoding: '%s'"),
12858 dwarf_type_encoding_name (encoding
));
12862 type
= init_type (code
, size
, type_flags
, NULL
, objfile
);
12863 TYPE_NAME (type
) = name
;
12864 TYPE_TARGET_TYPE (type
) = target_type
;
12866 if (name
&& strcmp (name
, "char") == 0)
12867 TYPE_NOSIGN (type
) = 1;
12869 return set_die_type (die
, type
, cu
);
12872 /* Read the given DW_AT_subrange DIE. */
12874 static struct type
*
12875 read_subrange_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
12877 struct type
*base_type
, *orig_base_type
;
12878 struct type
*range_type
;
12879 struct attribute
*attr
;
12881 int low_default_is_valid
;
12883 LONGEST negative_mask
;
12885 orig_base_type
= die_type (die
, cu
);
12886 /* If ORIG_BASE_TYPE is a typedef, it will not be TYPE_UNSIGNED,
12887 whereas the real type might be. So, we use ORIG_BASE_TYPE when
12888 creating the range type, but we use the result of check_typedef
12889 when examining properties of the type. */
12890 base_type
= check_typedef (orig_base_type
);
12892 /* The die_type call above may have already set the type for this DIE. */
12893 range_type
= get_die_type (die
, cu
);
12897 /* Set LOW_DEFAULT_IS_VALID if current language and DWARF version allow
12898 omitting DW_AT_lower_bound. */
12899 switch (cu
->language
)
12902 case language_cplus
:
12904 low_default_is_valid
= 1;
12906 case language_fortran
:
12908 low_default_is_valid
= 1;
12911 case language_java
:
12912 case language_objc
:
12914 low_default_is_valid
= (cu
->header
.version
>= 4);
12918 case language_pascal
:
12920 low_default_is_valid
= (cu
->header
.version
>= 4);
12924 low_default_is_valid
= 0;
12928 /* FIXME: For variable sized arrays either of these could be
12929 a variable rather than a constant value. We'll allow it,
12930 but we don't know how to handle it. */
12931 attr
= dwarf2_attr (die
, DW_AT_lower_bound
, cu
);
12933 low
= dwarf2_get_attr_constant_value (attr
, low
);
12934 else if (!low_default_is_valid
)
12935 complaint (&symfile_complaints
, _("Missing DW_AT_lower_bound "
12936 "- DIE at 0x%x [in module %s]"),
12937 die
->offset
.sect_off
, cu
->objfile
->name
);
12939 attr
= dwarf2_attr (die
, DW_AT_upper_bound
, cu
);
12942 if (attr_form_is_block (attr
) || is_ref_attr (attr
))
12944 /* GCC encodes arrays with unspecified or dynamic length
12945 with a DW_FORM_block1 attribute or a reference attribute.
12946 FIXME: GDB does not yet know how to handle dynamic
12947 arrays properly, treat them as arrays with unspecified
12950 FIXME: jimb/2003-09-22: GDB does not really know
12951 how to handle arrays of unspecified length
12952 either; we just represent them as zero-length
12953 arrays. Choose an appropriate upper bound given
12954 the lower bound we've computed above. */
12958 high
= dwarf2_get_attr_constant_value (attr
, 1);
12962 attr
= dwarf2_attr (die
, DW_AT_count
, cu
);
12965 int count
= dwarf2_get_attr_constant_value (attr
, 1);
12966 high
= low
+ count
- 1;
12970 /* Unspecified array length. */
12975 /* Dwarf-2 specifications explicitly allows to create subrange types
12976 without specifying a base type.
12977 In that case, the base type must be set to the type of
12978 the lower bound, upper bound or count, in that order, if any of these
12979 three attributes references an object that has a type.
12980 If no base type is found, the Dwarf-2 specifications say that
12981 a signed integer type of size equal to the size of an address should
12983 For the following C code: `extern char gdb_int [];'
12984 GCC produces an empty range DIE.
12985 FIXME: muller/2010-05-28: Possible references to object for low bound,
12986 high bound or count are not yet handled by this code. */
12987 if (TYPE_CODE (base_type
) == TYPE_CODE_VOID
)
12989 struct objfile
*objfile
= cu
->objfile
;
12990 struct gdbarch
*gdbarch
= get_objfile_arch (objfile
);
12991 int addr_size
= gdbarch_addr_bit (gdbarch
) /8;
12992 struct type
*int_type
= objfile_type (objfile
)->builtin_int
;
12994 /* Test "int", "long int", and "long long int" objfile types,
12995 and select the first one having a size above or equal to the
12996 architecture address size. */
12997 if (int_type
&& TYPE_LENGTH (int_type
) >= addr_size
)
12998 base_type
= int_type
;
13001 int_type
= objfile_type (objfile
)->builtin_long
;
13002 if (int_type
&& TYPE_LENGTH (int_type
) >= addr_size
)
13003 base_type
= int_type
;
13006 int_type
= objfile_type (objfile
)->builtin_long_long
;
13007 if (int_type
&& TYPE_LENGTH (int_type
) >= addr_size
)
13008 base_type
= int_type
;
13014 (LONGEST
) -1 << (TYPE_LENGTH (base_type
) * TARGET_CHAR_BIT
- 1);
13015 if (!TYPE_UNSIGNED (base_type
) && (low
& negative_mask
))
13016 low
|= negative_mask
;
13017 if (!TYPE_UNSIGNED (base_type
) && (high
& negative_mask
))
13018 high
|= negative_mask
;
13020 range_type
= create_range_type (NULL
, orig_base_type
, low
, high
);
13022 /* Mark arrays with dynamic length at least as an array of unspecified
13023 length. GDB could check the boundary but before it gets implemented at
13024 least allow accessing the array elements. */
13025 if (attr
&& attr_form_is_block (attr
))
13026 TYPE_HIGH_BOUND_UNDEFINED (range_type
) = 1;
13028 /* Ada expects an empty array on no boundary attributes. */
13029 if (attr
== NULL
&& cu
->language
!= language_ada
)
13030 TYPE_HIGH_BOUND_UNDEFINED (range_type
) = 1;
13032 name
= dwarf2_name (die
, cu
);
13034 TYPE_NAME (range_type
) = name
;
13036 attr
= dwarf2_attr (die
, DW_AT_byte_size
, cu
);
13038 TYPE_LENGTH (range_type
) = DW_UNSND (attr
);
13040 set_die_type (die
, range_type
, cu
);
13042 /* set_die_type should be already done. */
13043 set_descriptive_type (range_type
, die
, cu
);
13048 static struct type
*
13049 read_unspecified_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
13053 /* For now, we only support the C meaning of an unspecified type: void. */
13055 type
= init_type (TYPE_CODE_VOID
, 0, 0, NULL
, cu
->objfile
);
13056 TYPE_NAME (type
) = dwarf2_name (die
, cu
);
13058 return set_die_type (die
, type
, cu
);
13061 /* Read a single die and all its descendents. Set the die's sibling
13062 field to NULL; set other fields in the die correctly, and set all
13063 of the descendents' fields correctly. Set *NEW_INFO_PTR to the
13064 location of the info_ptr after reading all of those dies. PARENT
13065 is the parent of the die in question. */
13067 static struct die_info
*
13068 read_die_and_children (const struct die_reader_specs
*reader
,
13069 gdb_byte
*info_ptr
,
13070 gdb_byte
**new_info_ptr
,
13071 struct die_info
*parent
)
13073 struct die_info
*die
;
13077 cur_ptr
= read_full_die_1 (reader
, &die
, info_ptr
, &has_children
, 0);
13080 *new_info_ptr
= cur_ptr
;
13083 store_in_ref_table (die
, reader
->cu
);
13086 die
->child
= read_die_and_siblings_1 (reader
, cur_ptr
, new_info_ptr
, die
);
13090 *new_info_ptr
= cur_ptr
;
13093 die
->sibling
= NULL
;
13094 die
->parent
= parent
;
13098 /* Read a die, all of its descendents, and all of its siblings; set
13099 all of the fields of all of the dies correctly. Arguments are as
13100 in read_die_and_children. */
13102 static struct die_info
*
13103 read_die_and_siblings_1 (const struct die_reader_specs
*reader
,
13104 gdb_byte
*info_ptr
,
13105 gdb_byte
**new_info_ptr
,
13106 struct die_info
*parent
)
13108 struct die_info
*first_die
, *last_sibling
;
13111 cur_ptr
= info_ptr
;
13112 first_die
= last_sibling
= NULL
;
13116 struct die_info
*die
13117 = read_die_and_children (reader
, cur_ptr
, &cur_ptr
, parent
);
13121 *new_info_ptr
= cur_ptr
;
13128 last_sibling
->sibling
= die
;
13130 last_sibling
= die
;
13134 /* Read a die, all of its descendents, and all of its siblings; set
13135 all of the fields of all of the dies correctly. Arguments are as
13136 in read_die_and_children.
13137 This the main entry point for reading a DIE and all its children. */
13139 static struct die_info
*
13140 read_die_and_siblings (const struct die_reader_specs
*reader
,
13141 gdb_byte
*info_ptr
,
13142 gdb_byte
**new_info_ptr
,
13143 struct die_info
*parent
)
13145 struct die_info
*die
= read_die_and_siblings_1 (reader
, info_ptr
,
13146 new_info_ptr
, parent
);
13148 if (dwarf2_die_debug
)
13150 fprintf_unfiltered (gdb_stdlog
,
13151 "Read die from %s@0x%x of %s:\n",
13152 bfd_section_name (reader
->abfd
,
13153 reader
->die_section
->asection
),
13154 (unsigned) (info_ptr
- reader
->die_section
->buffer
),
13155 bfd_get_filename (reader
->abfd
));
13156 dump_die (die
, dwarf2_die_debug
);
13162 /* Read a die and all its attributes, leave space for NUM_EXTRA_ATTRS
13164 The caller is responsible for filling in the extra attributes
13165 and updating (*DIEP)->num_attrs.
13166 Set DIEP to point to a newly allocated die with its information,
13167 except for its child, sibling, and parent fields.
13168 Set HAS_CHILDREN to tell whether the die has children or not. */
13171 read_full_die_1 (const struct die_reader_specs
*reader
,
13172 struct die_info
**diep
, gdb_byte
*info_ptr
,
13173 int *has_children
, int num_extra_attrs
)
13175 unsigned int abbrev_number
, bytes_read
, i
;
13176 sect_offset offset
;
13177 struct abbrev_info
*abbrev
;
13178 struct die_info
*die
;
13179 struct dwarf2_cu
*cu
= reader
->cu
;
13180 bfd
*abfd
= reader
->abfd
;
13182 offset
.sect_off
= info_ptr
- reader
->buffer
;
13183 abbrev_number
= read_unsigned_leb128 (abfd
, info_ptr
, &bytes_read
);
13184 info_ptr
+= bytes_read
;
13185 if (!abbrev_number
)
13192 abbrev
= abbrev_table_lookup_abbrev (cu
->abbrev_table
, abbrev_number
);
13194 error (_("Dwarf Error: could not find abbrev number %d [in module %s]"),
13196 bfd_get_filename (abfd
));
13198 die
= dwarf_alloc_die (cu
, abbrev
->num_attrs
+ num_extra_attrs
);
13199 die
->offset
= offset
;
13200 die
->tag
= abbrev
->tag
;
13201 die
->abbrev
= abbrev_number
;
13203 /* Make the result usable.
13204 The caller needs to update num_attrs after adding the extra
13206 die
->num_attrs
= abbrev
->num_attrs
;
13208 for (i
= 0; i
< abbrev
->num_attrs
; ++i
)
13209 info_ptr
= read_attribute (reader
, &die
->attrs
[i
], &abbrev
->attrs
[i
],
13213 *has_children
= abbrev
->has_children
;
13217 /* Read a die and all its attributes.
13218 Set DIEP to point to a newly allocated die with its information,
13219 except for its child, sibling, and parent fields.
13220 Set HAS_CHILDREN to tell whether the die has children or not. */
13223 read_full_die (const struct die_reader_specs
*reader
,
13224 struct die_info
**diep
, gdb_byte
*info_ptr
,
13229 result
= read_full_die_1 (reader
, diep
, info_ptr
, has_children
, 0);
13231 if (dwarf2_die_debug
)
13233 fprintf_unfiltered (gdb_stdlog
,
13234 "Read die from %s@0x%x of %s:\n",
13235 bfd_section_name (reader
->abfd
,
13236 reader
->die_section
->asection
),
13237 (unsigned) (info_ptr
- reader
->die_section
->buffer
),
13238 bfd_get_filename (reader
->abfd
));
13239 dump_die (*diep
, dwarf2_die_debug
);
13245 /* Abbreviation tables.
13247 In DWARF version 2, the description of the debugging information is
13248 stored in a separate .debug_abbrev section. Before we read any
13249 dies from a section we read in all abbreviations and install them
13250 in a hash table. */
13252 /* Allocate space for a struct abbrev_info object in ABBREV_TABLE. */
13254 static struct abbrev_info
*
13255 abbrev_table_alloc_abbrev (struct abbrev_table
*abbrev_table
)
13257 struct abbrev_info
*abbrev
;
13259 abbrev
= (struct abbrev_info
*)
13260 obstack_alloc (&abbrev_table
->abbrev_obstack
, sizeof (struct abbrev_info
));
13261 memset (abbrev
, 0, sizeof (struct abbrev_info
));
13265 /* Add an abbreviation to the table. */
13268 abbrev_table_add_abbrev (struct abbrev_table
*abbrev_table
,
13269 unsigned int abbrev_number
,
13270 struct abbrev_info
*abbrev
)
13272 unsigned int hash_number
;
13274 hash_number
= abbrev_number
% ABBREV_HASH_SIZE
;
13275 abbrev
->next
= abbrev_table
->abbrevs
[hash_number
];
13276 abbrev_table
->abbrevs
[hash_number
] = abbrev
;
13279 /* Look up an abbrev in the table.
13280 Returns NULL if the abbrev is not found. */
13282 static struct abbrev_info
*
13283 abbrev_table_lookup_abbrev (const struct abbrev_table
*abbrev_table
,
13284 unsigned int abbrev_number
)
13286 unsigned int hash_number
;
13287 struct abbrev_info
*abbrev
;
13289 hash_number
= abbrev_number
% ABBREV_HASH_SIZE
;
13290 abbrev
= abbrev_table
->abbrevs
[hash_number
];
13294 if (abbrev
->number
== abbrev_number
)
13296 abbrev
= abbrev
->next
;
13301 /* Read in an abbrev table. */
13303 static struct abbrev_table
*
13304 abbrev_table_read_table (struct dwarf2_section_info
*section
,
13305 sect_offset offset
)
13307 struct objfile
*objfile
= dwarf2_per_objfile
->objfile
;
13308 bfd
*abfd
= section
->asection
->owner
;
13309 struct abbrev_table
*abbrev_table
;
13310 gdb_byte
*abbrev_ptr
;
13311 struct abbrev_info
*cur_abbrev
;
13312 unsigned int abbrev_number
, bytes_read
, abbrev_name
;
13313 unsigned int abbrev_form
;
13314 struct attr_abbrev
*cur_attrs
;
13315 unsigned int allocated_attrs
;
13317 abbrev_table
= XMALLOC (struct abbrev_table
);
13318 abbrev_table
->offset
= offset
;
13319 obstack_init (&abbrev_table
->abbrev_obstack
);
13320 abbrev_table
->abbrevs
= obstack_alloc (&abbrev_table
->abbrev_obstack
,
13322 * sizeof (struct abbrev_info
*)));
13323 memset (abbrev_table
->abbrevs
, 0,
13324 ABBREV_HASH_SIZE
* sizeof (struct abbrev_info
*));
13326 dwarf2_read_section (objfile
, section
);
13327 abbrev_ptr
= section
->buffer
+ offset
.sect_off
;
13328 abbrev_number
= read_unsigned_leb128 (abfd
, abbrev_ptr
, &bytes_read
);
13329 abbrev_ptr
+= bytes_read
;
13331 allocated_attrs
= ATTR_ALLOC_CHUNK
;
13332 cur_attrs
= xmalloc (allocated_attrs
* sizeof (struct attr_abbrev
));
13334 /* Loop until we reach an abbrev number of 0. */
13335 while (abbrev_number
)
13337 cur_abbrev
= abbrev_table_alloc_abbrev (abbrev_table
);
13339 /* read in abbrev header */
13340 cur_abbrev
->number
= abbrev_number
;
13341 cur_abbrev
->tag
= read_unsigned_leb128 (abfd
, abbrev_ptr
, &bytes_read
);
13342 abbrev_ptr
+= bytes_read
;
13343 cur_abbrev
->has_children
= read_1_byte (abfd
, abbrev_ptr
);
13346 /* now read in declarations */
13347 abbrev_name
= read_unsigned_leb128 (abfd
, abbrev_ptr
, &bytes_read
);
13348 abbrev_ptr
+= bytes_read
;
13349 abbrev_form
= read_unsigned_leb128 (abfd
, abbrev_ptr
, &bytes_read
);
13350 abbrev_ptr
+= bytes_read
;
13351 while (abbrev_name
)
13353 if (cur_abbrev
->num_attrs
== allocated_attrs
)
13355 allocated_attrs
+= ATTR_ALLOC_CHUNK
;
13357 = xrealloc (cur_attrs
, (allocated_attrs
13358 * sizeof (struct attr_abbrev
)));
13361 cur_attrs
[cur_abbrev
->num_attrs
].name
= abbrev_name
;
13362 cur_attrs
[cur_abbrev
->num_attrs
++].form
= abbrev_form
;
13363 abbrev_name
= read_unsigned_leb128 (abfd
, abbrev_ptr
, &bytes_read
);
13364 abbrev_ptr
+= bytes_read
;
13365 abbrev_form
= read_unsigned_leb128 (abfd
, abbrev_ptr
, &bytes_read
);
13366 abbrev_ptr
+= bytes_read
;
13369 cur_abbrev
->attrs
= obstack_alloc (&abbrev_table
->abbrev_obstack
,
13370 (cur_abbrev
->num_attrs
13371 * sizeof (struct attr_abbrev
)));
13372 memcpy (cur_abbrev
->attrs
, cur_attrs
,
13373 cur_abbrev
->num_attrs
* sizeof (struct attr_abbrev
));
13375 abbrev_table_add_abbrev (abbrev_table
, abbrev_number
, cur_abbrev
);
13377 /* Get next abbreviation.
13378 Under Irix6 the abbreviations for a compilation unit are not
13379 always properly terminated with an abbrev number of 0.
13380 Exit loop if we encounter an abbreviation which we have
13381 already read (which means we are about to read the abbreviations
13382 for the next compile unit) or if the end of the abbreviation
13383 table is reached. */
13384 if ((unsigned int) (abbrev_ptr
- section
->buffer
) >= section
->size
)
13386 abbrev_number
= read_unsigned_leb128 (abfd
, abbrev_ptr
, &bytes_read
);
13387 abbrev_ptr
+= bytes_read
;
13388 if (abbrev_table_lookup_abbrev (abbrev_table
, abbrev_number
) != NULL
)
13393 return abbrev_table
;
13396 /* Free the resources held by ABBREV_TABLE. */
13399 abbrev_table_free (struct abbrev_table
*abbrev_table
)
13401 obstack_free (&abbrev_table
->abbrev_obstack
, NULL
);
13402 xfree (abbrev_table
);
13405 /* Same as abbrev_table_free but as a cleanup.
13406 We pass in a pointer to the pointer to the table so that we can
13407 set the pointer to NULL when we're done. It also simplifies
13408 build_type_unit_groups. */
13411 abbrev_table_free_cleanup (void *table_ptr
)
13413 struct abbrev_table
**abbrev_table_ptr
= table_ptr
;
13415 if (*abbrev_table_ptr
!= NULL
)
13416 abbrev_table_free (*abbrev_table_ptr
);
13417 *abbrev_table_ptr
= NULL
;
13420 /* Read the abbrev table for CU from ABBREV_SECTION. */
13423 dwarf2_read_abbrevs (struct dwarf2_cu
*cu
,
13424 struct dwarf2_section_info
*abbrev_section
)
13427 abbrev_table_read_table (abbrev_section
, cu
->header
.abbrev_offset
);
13430 /* Release the memory used by the abbrev table for a compilation unit. */
13433 dwarf2_free_abbrev_table (void *ptr_to_cu
)
13435 struct dwarf2_cu
*cu
= ptr_to_cu
;
13437 abbrev_table_free (cu
->abbrev_table
);
13438 /* Set this to NULL so that we SEGV if we try to read it later,
13439 and also because free_comp_unit verifies this is NULL. */
13440 cu
->abbrev_table
= NULL
;
13443 /* Returns nonzero if TAG represents a type that we might generate a partial
13447 is_type_tag_for_partial (int tag
)
13452 /* Some types that would be reasonable to generate partial symbols for,
13453 that we don't at present. */
13454 case DW_TAG_array_type
:
13455 case DW_TAG_file_type
:
13456 case DW_TAG_ptr_to_member_type
:
13457 case DW_TAG_set_type
:
13458 case DW_TAG_string_type
:
13459 case DW_TAG_subroutine_type
:
13461 case DW_TAG_base_type
:
13462 case DW_TAG_class_type
:
13463 case DW_TAG_interface_type
:
13464 case DW_TAG_enumeration_type
:
13465 case DW_TAG_structure_type
:
13466 case DW_TAG_subrange_type
:
13467 case DW_TAG_typedef
:
13468 case DW_TAG_union_type
:
13475 /* Load all DIEs that are interesting for partial symbols into memory. */
13477 static struct partial_die_info
*
13478 load_partial_dies (const struct die_reader_specs
*reader
,
13479 gdb_byte
*info_ptr
, int building_psymtab
)
13481 struct dwarf2_cu
*cu
= reader
->cu
;
13482 struct objfile
*objfile
= cu
->objfile
;
13483 struct partial_die_info
*part_die
;
13484 struct partial_die_info
*parent_die
, *last_die
, *first_die
= NULL
;
13485 struct abbrev_info
*abbrev
;
13486 unsigned int bytes_read
;
13487 unsigned int load_all
= 0;
13488 int nesting_level
= 1;
13493 gdb_assert (cu
->per_cu
!= NULL
);
13494 if (cu
->per_cu
->load_all_dies
)
13498 = htab_create_alloc_ex (cu
->header
.length
/ 12,
13502 &cu
->comp_unit_obstack
,
13503 hashtab_obstack_allocate
,
13504 dummy_obstack_deallocate
);
13506 part_die
= obstack_alloc (&cu
->comp_unit_obstack
,
13507 sizeof (struct partial_die_info
));
13511 abbrev
= peek_die_abbrev (info_ptr
, &bytes_read
, cu
);
13513 /* A NULL abbrev means the end of a series of children. */
13514 if (abbrev
== NULL
)
13516 if (--nesting_level
== 0)
13518 /* PART_DIE was probably the last thing allocated on the
13519 comp_unit_obstack, so we could call obstack_free
13520 here. We don't do that because the waste is small,
13521 and will be cleaned up when we're done with this
13522 compilation unit. This way, we're also more robust
13523 against other users of the comp_unit_obstack. */
13526 info_ptr
+= bytes_read
;
13527 last_die
= parent_die
;
13528 parent_die
= parent_die
->die_parent
;
13532 /* Check for template arguments. We never save these; if
13533 they're seen, we just mark the parent, and go on our way. */
13534 if (parent_die
!= NULL
13535 && cu
->language
== language_cplus
13536 && (abbrev
->tag
== DW_TAG_template_type_param
13537 || abbrev
->tag
== DW_TAG_template_value_param
))
13539 parent_die
->has_template_arguments
= 1;
13543 /* We don't need a partial DIE for the template argument. */
13544 info_ptr
= skip_one_die (reader
, info_ptr
+ bytes_read
, abbrev
);
13549 /* We only recurse into c++ subprograms looking for template arguments.
13550 Skip their other children. */
13552 && cu
->language
== language_cplus
13553 && parent_die
!= NULL
13554 && parent_die
->tag
== DW_TAG_subprogram
)
13556 info_ptr
= skip_one_die (reader
, info_ptr
+ bytes_read
, abbrev
);
13560 /* Check whether this DIE is interesting enough to save. Normally
13561 we would not be interested in members here, but there may be
13562 later variables referencing them via DW_AT_specification (for
13563 static members). */
13565 && !is_type_tag_for_partial (abbrev
->tag
)
13566 && abbrev
->tag
!= DW_TAG_constant
13567 && abbrev
->tag
!= DW_TAG_enumerator
13568 && abbrev
->tag
!= DW_TAG_subprogram
13569 && abbrev
->tag
!= DW_TAG_lexical_block
13570 && abbrev
->tag
!= DW_TAG_variable
13571 && abbrev
->tag
!= DW_TAG_namespace
13572 && abbrev
->tag
!= DW_TAG_module
13573 && abbrev
->tag
!= DW_TAG_member
13574 && abbrev
->tag
!= DW_TAG_imported_unit
)
13576 /* Otherwise we skip to the next sibling, if any. */
13577 info_ptr
= skip_one_die (reader
, info_ptr
+ bytes_read
, abbrev
);
13581 info_ptr
= read_partial_die (reader
, part_die
, abbrev
, bytes_read
,
13584 /* This two-pass algorithm for processing partial symbols has a
13585 high cost in cache pressure. Thus, handle some simple cases
13586 here which cover the majority of C partial symbols. DIEs
13587 which neither have specification tags in them, nor could have
13588 specification tags elsewhere pointing at them, can simply be
13589 processed and discarded.
13591 This segment is also optional; scan_partial_symbols and
13592 add_partial_symbol will handle these DIEs if we chain
13593 them in normally. When compilers which do not emit large
13594 quantities of duplicate debug information are more common,
13595 this code can probably be removed. */
13597 /* Any complete simple types at the top level (pretty much all
13598 of them, for a language without namespaces), can be processed
13600 if (parent_die
== NULL
13601 && part_die
->has_specification
== 0
13602 && part_die
->is_declaration
== 0
13603 && ((part_die
->tag
== DW_TAG_typedef
&& !part_die
->has_children
)
13604 || part_die
->tag
== DW_TAG_base_type
13605 || part_die
->tag
== DW_TAG_subrange_type
))
13607 if (building_psymtab
&& part_die
->name
!= NULL
)
13608 add_psymbol_to_list (part_die
->name
, strlen (part_die
->name
), 0,
13609 VAR_DOMAIN
, LOC_TYPEDEF
,
13610 &objfile
->static_psymbols
,
13611 0, (CORE_ADDR
) 0, cu
->language
, objfile
);
13612 info_ptr
= locate_pdi_sibling (reader
, part_die
, info_ptr
);
13616 /* The exception for DW_TAG_typedef with has_children above is
13617 a workaround of GCC PR debug/47510. In the case of this complaint
13618 type_name_no_tag_or_error will error on such types later.
13620 GDB skipped children of DW_TAG_typedef by the shortcut above and then
13621 it could not find the child DIEs referenced later, this is checked
13622 above. In correct DWARF DW_TAG_typedef should have no children. */
13624 if (part_die
->tag
== DW_TAG_typedef
&& part_die
->has_children
)
13625 complaint (&symfile_complaints
,
13626 _("DW_TAG_typedef has childen - GCC PR debug/47510 bug "
13627 "- DIE at 0x%x [in module %s]"),
13628 part_die
->offset
.sect_off
, objfile
->name
);
13630 /* If we're at the second level, and we're an enumerator, and
13631 our parent has no specification (meaning possibly lives in a
13632 namespace elsewhere), then we can add the partial symbol now
13633 instead of queueing it. */
13634 if (part_die
->tag
== DW_TAG_enumerator
13635 && parent_die
!= NULL
13636 && parent_die
->die_parent
== NULL
13637 && parent_die
->tag
== DW_TAG_enumeration_type
13638 && parent_die
->has_specification
== 0)
13640 if (part_die
->name
== NULL
)
13641 complaint (&symfile_complaints
,
13642 _("malformed enumerator DIE ignored"));
13643 else if (building_psymtab
)
13644 add_psymbol_to_list (part_die
->name
, strlen (part_die
->name
), 0,
13645 VAR_DOMAIN
, LOC_CONST
,
13646 (cu
->language
== language_cplus
13647 || cu
->language
== language_java
)
13648 ? &objfile
->global_psymbols
13649 : &objfile
->static_psymbols
,
13650 0, (CORE_ADDR
) 0, cu
->language
, objfile
);
13652 info_ptr
= locate_pdi_sibling (reader
, part_die
, info_ptr
);
13656 /* We'll save this DIE so link it in. */
13657 part_die
->die_parent
= parent_die
;
13658 part_die
->die_sibling
= NULL
;
13659 part_die
->die_child
= NULL
;
13661 if (last_die
&& last_die
== parent_die
)
13662 last_die
->die_child
= part_die
;
13664 last_die
->die_sibling
= part_die
;
13666 last_die
= part_die
;
13668 if (first_die
== NULL
)
13669 first_die
= part_die
;
13671 /* Maybe add the DIE to the hash table. Not all DIEs that we
13672 find interesting need to be in the hash table, because we
13673 also have the parent/sibling/child chains; only those that we
13674 might refer to by offset later during partial symbol reading.
13676 For now this means things that might have be the target of a
13677 DW_AT_specification, DW_AT_abstract_origin, or
13678 DW_AT_extension. DW_AT_extension will refer only to
13679 namespaces; DW_AT_abstract_origin refers to functions (and
13680 many things under the function DIE, but we do not recurse
13681 into function DIEs during partial symbol reading) and
13682 possibly variables as well; DW_AT_specification refers to
13683 declarations. Declarations ought to have the DW_AT_declaration
13684 flag. It happens that GCC forgets to put it in sometimes, but
13685 only for functions, not for types.
13687 Adding more things than necessary to the hash table is harmless
13688 except for the performance cost. Adding too few will result in
13689 wasted time in find_partial_die, when we reread the compilation
13690 unit with load_all_dies set. */
13693 || abbrev
->tag
== DW_TAG_constant
13694 || abbrev
->tag
== DW_TAG_subprogram
13695 || abbrev
->tag
== DW_TAG_variable
13696 || abbrev
->tag
== DW_TAG_namespace
13697 || part_die
->is_declaration
)
13701 slot
= htab_find_slot_with_hash (cu
->partial_dies
, part_die
,
13702 part_die
->offset
.sect_off
, INSERT
);
13706 part_die
= obstack_alloc (&cu
->comp_unit_obstack
,
13707 sizeof (struct partial_die_info
));
13709 /* For some DIEs we want to follow their children (if any). For C
13710 we have no reason to follow the children of structures; for other
13711 languages we have to, so that we can get at method physnames
13712 to infer fully qualified class names, for DW_AT_specification,
13713 and for C++ template arguments. For C++, we also look one level
13714 inside functions to find template arguments (if the name of the
13715 function does not already contain the template arguments).
13717 For Ada, we need to scan the children of subprograms and lexical
13718 blocks as well because Ada allows the definition of nested
13719 entities that could be interesting for the debugger, such as
13720 nested subprograms for instance. */
13721 if (last_die
->has_children
13723 || last_die
->tag
== DW_TAG_namespace
13724 || last_die
->tag
== DW_TAG_module
13725 || last_die
->tag
== DW_TAG_enumeration_type
13726 || (cu
->language
== language_cplus
13727 && last_die
->tag
== DW_TAG_subprogram
13728 && (last_die
->name
== NULL
13729 || strchr (last_die
->name
, '<') == NULL
))
13730 || (cu
->language
!= language_c
13731 && (last_die
->tag
== DW_TAG_class_type
13732 || last_die
->tag
== DW_TAG_interface_type
13733 || last_die
->tag
== DW_TAG_structure_type
13734 || last_die
->tag
== DW_TAG_union_type
))
13735 || (cu
->language
== language_ada
13736 && (last_die
->tag
== DW_TAG_subprogram
13737 || last_die
->tag
== DW_TAG_lexical_block
))))
13740 parent_die
= last_die
;
13744 /* Otherwise we skip to the next sibling, if any. */
13745 info_ptr
= locate_pdi_sibling (reader
, last_die
, info_ptr
);
13747 /* Back to the top, do it again. */
13751 /* Read a minimal amount of information into the minimal die structure. */
13754 read_partial_die (const struct die_reader_specs
*reader
,
13755 struct partial_die_info
*part_die
,
13756 struct abbrev_info
*abbrev
, unsigned int abbrev_len
,
13757 gdb_byte
*info_ptr
)
13759 struct dwarf2_cu
*cu
= reader
->cu
;
13760 struct objfile
*objfile
= cu
->objfile
;
13761 gdb_byte
*buffer
= reader
->buffer
;
13763 struct attribute attr
;
13764 int has_low_pc_attr
= 0;
13765 int has_high_pc_attr
= 0;
13766 int high_pc_relative
= 0;
13768 memset (part_die
, 0, sizeof (struct partial_die_info
));
13770 part_die
->offset
.sect_off
= info_ptr
- buffer
;
13772 info_ptr
+= abbrev_len
;
13774 if (abbrev
== NULL
)
13777 part_die
->tag
= abbrev
->tag
;
13778 part_die
->has_children
= abbrev
->has_children
;
13780 for (i
= 0; i
< abbrev
->num_attrs
; ++i
)
13782 info_ptr
= read_attribute (reader
, &attr
, &abbrev
->attrs
[i
], info_ptr
);
13784 /* Store the data if it is of an attribute we want to keep in a
13785 partial symbol table. */
13789 switch (part_die
->tag
)
13791 case DW_TAG_compile_unit
:
13792 case DW_TAG_partial_unit
:
13793 case DW_TAG_type_unit
:
13794 /* Compilation units have a DW_AT_name that is a filename, not
13795 a source language identifier. */
13796 case DW_TAG_enumeration_type
:
13797 case DW_TAG_enumerator
:
13798 /* These tags always have simple identifiers already; no need
13799 to canonicalize them. */
13800 part_die
->name
= DW_STRING (&attr
);
13804 = dwarf2_canonicalize_name (DW_STRING (&attr
), cu
,
13805 &objfile
->objfile_obstack
);
13809 case DW_AT_linkage_name
:
13810 case DW_AT_MIPS_linkage_name
:
13811 /* Note that both forms of linkage name might appear. We
13812 assume they will be the same, and we only store the last
13814 if (cu
->language
== language_ada
)
13815 part_die
->name
= DW_STRING (&attr
);
13816 part_die
->linkage_name
= DW_STRING (&attr
);
13819 has_low_pc_attr
= 1;
13820 part_die
->lowpc
= DW_ADDR (&attr
);
13822 case DW_AT_high_pc
:
13823 has_high_pc_attr
= 1;
13824 if (attr
.form
== DW_FORM_addr
13825 || attr
.form
== DW_FORM_GNU_addr_index
)
13826 part_die
->highpc
= DW_ADDR (&attr
);
13829 high_pc_relative
= 1;
13830 part_die
->highpc
= DW_UNSND (&attr
);
13833 case DW_AT_location
:
13834 /* Support the .debug_loc offsets. */
13835 if (attr_form_is_block (&attr
))
13837 part_die
->d
.locdesc
= DW_BLOCK (&attr
);
13839 else if (attr_form_is_section_offset (&attr
))
13841 dwarf2_complex_location_expr_complaint ();
13845 dwarf2_invalid_attrib_class_complaint ("DW_AT_location",
13846 "partial symbol information");
13849 case DW_AT_external
:
13850 part_die
->is_external
= DW_UNSND (&attr
);
13852 case DW_AT_declaration
:
13853 part_die
->is_declaration
= DW_UNSND (&attr
);
13856 part_die
->has_type
= 1;
13858 case DW_AT_abstract_origin
:
13859 case DW_AT_specification
:
13860 case DW_AT_extension
:
13861 part_die
->has_specification
= 1;
13862 part_die
->spec_offset
= dwarf2_get_ref_die_offset (&attr
);
13863 part_die
->spec_is_dwz
= (attr
.form
== DW_FORM_GNU_ref_alt
13864 || cu
->per_cu
->is_dwz
);
13866 case DW_AT_sibling
:
13867 /* Ignore absolute siblings, they might point outside of
13868 the current compile unit. */
13869 if (attr
.form
== DW_FORM_ref_addr
)
13870 complaint (&symfile_complaints
,
13871 _("ignoring absolute DW_AT_sibling"));
13873 part_die
->sibling
= buffer
+ dwarf2_get_ref_die_offset (&attr
).sect_off
;
13875 case DW_AT_byte_size
:
13876 part_die
->has_byte_size
= 1;
13878 case DW_AT_calling_convention
:
13879 /* DWARF doesn't provide a way to identify a program's source-level
13880 entry point. DW_AT_calling_convention attributes are only meant
13881 to describe functions' calling conventions.
13883 However, because it's a necessary piece of information in
13884 Fortran, and because DW_CC_program is the only piece of debugging
13885 information whose definition refers to a 'main program' at all,
13886 several compilers have begun marking Fortran main programs with
13887 DW_CC_program --- even when those functions use the standard
13888 calling conventions.
13890 So until DWARF specifies a way to provide this information and
13891 compilers pick up the new representation, we'll support this
13893 if (DW_UNSND (&attr
) == DW_CC_program
13894 && cu
->language
== language_fortran
)
13896 set_main_name (part_die
->name
);
13898 /* As this DIE has a static linkage the name would be difficult
13899 to look up later. */
13900 language_of_main
= language_fortran
;
13904 if (DW_UNSND (&attr
) == DW_INL_inlined
13905 || DW_UNSND (&attr
) == DW_INL_declared_inlined
)
13906 part_die
->may_be_inlined
= 1;
13910 if (part_die
->tag
== DW_TAG_imported_unit
)
13912 part_die
->d
.offset
= dwarf2_get_ref_die_offset (&attr
);
13913 part_die
->is_dwz
= (attr
.form
== DW_FORM_GNU_ref_alt
13914 || cu
->per_cu
->is_dwz
);
13923 if (high_pc_relative
)
13924 part_die
->highpc
+= part_die
->lowpc
;
13926 if (has_low_pc_attr
&& has_high_pc_attr
)
13928 /* When using the GNU linker, .gnu.linkonce. sections are used to
13929 eliminate duplicate copies of functions and vtables and such.
13930 The linker will arbitrarily choose one and discard the others.
13931 The AT_*_pc values for such functions refer to local labels in
13932 these sections. If the section from that file was discarded, the
13933 labels are not in the output, so the relocs get a value of 0.
13934 If this is a discarded function, mark the pc bounds as invalid,
13935 so that GDB will ignore it. */
13936 if (part_die
->lowpc
== 0 && !dwarf2_per_objfile
->has_section_at_zero
)
13938 struct gdbarch
*gdbarch
= get_objfile_arch (objfile
);
13940 complaint (&symfile_complaints
,
13941 _("DW_AT_low_pc %s is zero "
13942 "for DIE at 0x%x [in module %s]"),
13943 paddress (gdbarch
, part_die
->lowpc
),
13944 part_die
->offset
.sect_off
, objfile
->name
);
13946 /* dwarf2_get_pc_bounds has also the strict low < high requirement. */
13947 else if (part_die
->lowpc
>= part_die
->highpc
)
13949 struct gdbarch
*gdbarch
= get_objfile_arch (objfile
);
13951 complaint (&symfile_complaints
,
13952 _("DW_AT_low_pc %s is not < DW_AT_high_pc %s "
13953 "for DIE at 0x%x [in module %s]"),
13954 paddress (gdbarch
, part_die
->lowpc
),
13955 paddress (gdbarch
, part_die
->highpc
),
13956 part_die
->offset
.sect_off
, objfile
->name
);
13959 part_die
->has_pc_info
= 1;
13965 /* Find a cached partial DIE at OFFSET in CU. */
13967 static struct partial_die_info
*
13968 find_partial_die_in_comp_unit (sect_offset offset
, struct dwarf2_cu
*cu
)
13970 struct partial_die_info
*lookup_die
= NULL
;
13971 struct partial_die_info part_die
;
13973 part_die
.offset
= offset
;
13974 lookup_die
= htab_find_with_hash (cu
->partial_dies
, &part_die
,
13980 /* Find a partial DIE at OFFSET, which may or may not be in CU,
13981 except in the case of .debug_types DIEs which do not reference
13982 outside their CU (they do however referencing other types via
13983 DW_FORM_ref_sig8). */
13985 static struct partial_die_info
*
13986 find_partial_die (sect_offset offset
, int offset_in_dwz
, struct dwarf2_cu
*cu
)
13988 struct objfile
*objfile
= cu
->objfile
;
13989 struct dwarf2_per_cu_data
*per_cu
= NULL
;
13990 struct partial_die_info
*pd
= NULL
;
13992 if (offset_in_dwz
== cu
->per_cu
->is_dwz
13993 && offset_in_cu_p (&cu
->header
, offset
))
13995 pd
= find_partial_die_in_comp_unit (offset
, cu
);
13998 /* We missed recording what we needed.
13999 Load all dies and try again. */
14000 per_cu
= cu
->per_cu
;
14004 /* TUs don't reference other CUs/TUs (except via type signatures). */
14005 if (cu
->per_cu
->is_debug_types
)
14007 error (_("Dwarf Error: Type Unit at offset 0x%lx contains"
14008 " external reference to offset 0x%lx [in module %s].\n"),
14009 (long) cu
->header
.offset
.sect_off
, (long) offset
.sect_off
,
14010 bfd_get_filename (objfile
->obfd
));
14012 per_cu
= dwarf2_find_containing_comp_unit (offset
, offset_in_dwz
,
14015 if (per_cu
->cu
== NULL
|| per_cu
->cu
->partial_dies
== NULL
)
14016 load_partial_comp_unit (per_cu
);
14018 per_cu
->cu
->last_used
= 0;
14019 pd
= find_partial_die_in_comp_unit (offset
, per_cu
->cu
);
14022 /* If we didn't find it, and not all dies have been loaded,
14023 load them all and try again. */
14025 if (pd
== NULL
&& per_cu
->load_all_dies
== 0)
14027 per_cu
->load_all_dies
= 1;
14029 /* This is nasty. When we reread the DIEs, somewhere up the call chain
14030 THIS_CU->cu may already be in use. So we can't just free it and
14031 replace its DIEs with the ones we read in. Instead, we leave those
14032 DIEs alone (which can still be in use, e.g. in scan_partial_symbols),
14033 and clobber THIS_CU->cu->partial_dies with the hash table for the new
14035 load_partial_comp_unit (per_cu
);
14037 pd
= find_partial_die_in_comp_unit (offset
, per_cu
->cu
);
14041 internal_error (__FILE__
, __LINE__
,
14042 _("could not find partial DIE 0x%x "
14043 "in cache [from module %s]\n"),
14044 offset
.sect_off
, bfd_get_filename (objfile
->obfd
));
14048 /* See if we can figure out if the class lives in a namespace. We do
14049 this by looking for a member function; its demangled name will
14050 contain namespace info, if there is any. */
14053 guess_partial_die_structure_name (struct partial_die_info
*struct_pdi
,
14054 struct dwarf2_cu
*cu
)
14056 /* NOTE: carlton/2003-10-07: Getting the info this way changes
14057 what template types look like, because the demangler
14058 frequently doesn't give the same name as the debug info. We
14059 could fix this by only using the demangled name to get the
14060 prefix (but see comment in read_structure_type). */
14062 struct partial_die_info
*real_pdi
;
14063 struct partial_die_info
*child_pdi
;
14065 /* If this DIE (this DIE's specification, if any) has a parent, then
14066 we should not do this. We'll prepend the parent's fully qualified
14067 name when we create the partial symbol. */
14069 real_pdi
= struct_pdi
;
14070 while (real_pdi
->has_specification
)
14071 real_pdi
= find_partial_die (real_pdi
->spec_offset
,
14072 real_pdi
->spec_is_dwz
, cu
);
14074 if (real_pdi
->die_parent
!= NULL
)
14077 for (child_pdi
= struct_pdi
->die_child
;
14079 child_pdi
= child_pdi
->die_sibling
)
14081 if (child_pdi
->tag
== DW_TAG_subprogram
14082 && child_pdi
->linkage_name
!= NULL
)
14084 char *actual_class_name
14085 = language_class_name_from_physname (cu
->language_defn
,
14086 child_pdi
->linkage_name
);
14087 if (actual_class_name
!= NULL
)
14090 = obstack_copy0 (&cu
->objfile
->objfile_obstack
,
14092 strlen (actual_class_name
));
14093 xfree (actual_class_name
);
14100 /* Adjust PART_DIE before generating a symbol for it. This function
14101 may set the is_external flag or change the DIE's name. */
14104 fixup_partial_die (struct partial_die_info
*part_die
,
14105 struct dwarf2_cu
*cu
)
14107 /* Once we've fixed up a die, there's no point in doing so again.
14108 This also avoids a memory leak if we were to call
14109 guess_partial_die_structure_name multiple times. */
14110 if (part_die
->fixup_called
)
14113 /* If we found a reference attribute and the DIE has no name, try
14114 to find a name in the referred to DIE. */
14116 if (part_die
->name
== NULL
&& part_die
->has_specification
)
14118 struct partial_die_info
*spec_die
;
14120 spec_die
= find_partial_die (part_die
->spec_offset
,
14121 part_die
->spec_is_dwz
, cu
);
14123 fixup_partial_die (spec_die
, cu
);
14125 if (spec_die
->name
)
14127 part_die
->name
= spec_die
->name
;
14129 /* Copy DW_AT_external attribute if it is set. */
14130 if (spec_die
->is_external
)
14131 part_die
->is_external
= spec_die
->is_external
;
14135 /* Set default names for some unnamed DIEs. */
14137 if (part_die
->name
== NULL
&& part_die
->tag
== DW_TAG_namespace
)
14138 part_die
->name
= CP_ANONYMOUS_NAMESPACE_STR
;
14140 /* If there is no parent die to provide a namespace, and there are
14141 children, see if we can determine the namespace from their linkage
14143 if (cu
->language
== language_cplus
14144 && !VEC_empty (dwarf2_section_info_def
, dwarf2_per_objfile
->types
)
14145 && part_die
->die_parent
== NULL
14146 && part_die
->has_children
14147 && (part_die
->tag
== DW_TAG_class_type
14148 || part_die
->tag
== DW_TAG_structure_type
14149 || part_die
->tag
== DW_TAG_union_type
))
14150 guess_partial_die_structure_name (part_die
, cu
);
14152 /* GCC might emit a nameless struct or union that has a linkage
14153 name. See http://gcc.gnu.org/bugzilla/show_bug.cgi?id=47510. */
14154 if (part_die
->name
== NULL
14155 && (part_die
->tag
== DW_TAG_class_type
14156 || part_die
->tag
== DW_TAG_interface_type
14157 || part_die
->tag
== DW_TAG_structure_type
14158 || part_die
->tag
== DW_TAG_union_type
)
14159 && part_die
->linkage_name
!= NULL
)
14163 demangled
= cplus_demangle (part_die
->linkage_name
, DMGL_TYPES
);
14168 /* Strip any leading namespaces/classes, keep only the base name.
14169 DW_AT_name for named DIEs does not contain the prefixes. */
14170 base
= strrchr (demangled
, ':');
14171 if (base
&& base
> demangled
&& base
[-1] == ':')
14176 part_die
->name
= obstack_copy0 (&cu
->objfile
->objfile_obstack
,
14177 base
, strlen (base
));
14182 part_die
->fixup_called
= 1;
14185 /* Read an attribute value described by an attribute form. */
14188 read_attribute_value (const struct die_reader_specs
*reader
,
14189 struct attribute
*attr
, unsigned form
,
14190 gdb_byte
*info_ptr
)
14192 struct dwarf2_cu
*cu
= reader
->cu
;
14193 bfd
*abfd
= reader
->abfd
;
14194 struct comp_unit_head
*cu_header
= &cu
->header
;
14195 unsigned int bytes_read
;
14196 struct dwarf_block
*blk
;
14201 case DW_FORM_ref_addr
:
14202 if (cu
->header
.version
== 2)
14203 DW_UNSND (attr
) = read_address (abfd
, info_ptr
, cu
, &bytes_read
);
14205 DW_UNSND (attr
) = read_offset (abfd
, info_ptr
,
14206 &cu
->header
, &bytes_read
);
14207 info_ptr
+= bytes_read
;
14209 case DW_FORM_GNU_ref_alt
:
14210 DW_UNSND (attr
) = read_offset (abfd
, info_ptr
, &cu
->header
, &bytes_read
);
14211 info_ptr
+= bytes_read
;
14214 DW_ADDR (attr
) = read_address (abfd
, info_ptr
, cu
, &bytes_read
);
14215 info_ptr
+= bytes_read
;
14217 case DW_FORM_block2
:
14218 blk
= dwarf_alloc_block (cu
);
14219 blk
->size
= read_2_bytes (abfd
, info_ptr
);
14221 blk
->data
= read_n_bytes (abfd
, info_ptr
, blk
->size
);
14222 info_ptr
+= blk
->size
;
14223 DW_BLOCK (attr
) = blk
;
14225 case DW_FORM_block4
:
14226 blk
= dwarf_alloc_block (cu
);
14227 blk
->size
= read_4_bytes (abfd
, info_ptr
);
14229 blk
->data
= read_n_bytes (abfd
, info_ptr
, blk
->size
);
14230 info_ptr
+= blk
->size
;
14231 DW_BLOCK (attr
) = blk
;
14233 case DW_FORM_data2
:
14234 DW_UNSND (attr
) = read_2_bytes (abfd
, info_ptr
);
14237 case DW_FORM_data4
:
14238 DW_UNSND (attr
) = read_4_bytes (abfd
, info_ptr
);
14241 case DW_FORM_data8
:
14242 DW_UNSND (attr
) = read_8_bytes (abfd
, info_ptr
);
14245 case DW_FORM_sec_offset
:
14246 DW_UNSND (attr
) = read_offset (abfd
, info_ptr
, &cu
->header
, &bytes_read
);
14247 info_ptr
+= bytes_read
;
14249 case DW_FORM_string
:
14250 DW_STRING (attr
) = read_direct_string (abfd
, info_ptr
, &bytes_read
);
14251 DW_STRING_IS_CANONICAL (attr
) = 0;
14252 info_ptr
+= bytes_read
;
14255 if (!cu
->per_cu
->is_dwz
)
14257 DW_STRING (attr
) = read_indirect_string (abfd
, info_ptr
, cu_header
,
14259 DW_STRING_IS_CANONICAL (attr
) = 0;
14260 info_ptr
+= bytes_read
;
14264 case DW_FORM_GNU_strp_alt
:
14266 struct dwz_file
*dwz
= dwarf2_get_dwz_file ();
14267 LONGEST str_offset
= read_offset (abfd
, info_ptr
, cu_header
,
14270 DW_STRING (attr
) = read_indirect_string_from_dwz (dwz
, str_offset
);
14271 DW_STRING_IS_CANONICAL (attr
) = 0;
14272 info_ptr
+= bytes_read
;
14275 case DW_FORM_exprloc
:
14276 case DW_FORM_block
:
14277 blk
= dwarf_alloc_block (cu
);
14278 blk
->size
= read_unsigned_leb128 (abfd
, info_ptr
, &bytes_read
);
14279 info_ptr
+= bytes_read
;
14280 blk
->data
= read_n_bytes (abfd
, info_ptr
, blk
->size
);
14281 info_ptr
+= blk
->size
;
14282 DW_BLOCK (attr
) = blk
;
14284 case DW_FORM_block1
:
14285 blk
= dwarf_alloc_block (cu
);
14286 blk
->size
= read_1_byte (abfd
, info_ptr
);
14288 blk
->data
= read_n_bytes (abfd
, info_ptr
, blk
->size
);
14289 info_ptr
+= blk
->size
;
14290 DW_BLOCK (attr
) = blk
;
14292 case DW_FORM_data1
:
14293 DW_UNSND (attr
) = read_1_byte (abfd
, info_ptr
);
14297 DW_UNSND (attr
) = read_1_byte (abfd
, info_ptr
);
14300 case DW_FORM_flag_present
:
14301 DW_UNSND (attr
) = 1;
14303 case DW_FORM_sdata
:
14304 DW_SND (attr
) = read_signed_leb128 (abfd
, info_ptr
, &bytes_read
);
14305 info_ptr
+= bytes_read
;
14307 case DW_FORM_udata
:
14308 DW_UNSND (attr
) = read_unsigned_leb128 (abfd
, info_ptr
, &bytes_read
);
14309 info_ptr
+= bytes_read
;
14312 DW_UNSND (attr
) = (cu
->header
.offset
.sect_off
14313 + read_1_byte (abfd
, info_ptr
));
14317 DW_UNSND (attr
) = (cu
->header
.offset
.sect_off
14318 + read_2_bytes (abfd
, info_ptr
));
14322 DW_UNSND (attr
) = (cu
->header
.offset
.sect_off
14323 + read_4_bytes (abfd
, info_ptr
));
14327 DW_UNSND (attr
) = (cu
->header
.offset
.sect_off
14328 + read_8_bytes (abfd
, info_ptr
));
14331 case DW_FORM_ref_sig8
:
14332 /* Convert the signature to something we can record in DW_UNSND
14334 NOTE: This is NULL if the type wasn't found. */
14335 DW_SIGNATURED_TYPE (attr
) =
14336 lookup_signatured_type (read_8_bytes (abfd
, info_ptr
));
14339 case DW_FORM_ref_udata
:
14340 DW_UNSND (attr
) = (cu
->header
.offset
.sect_off
14341 + read_unsigned_leb128 (abfd
, info_ptr
, &bytes_read
));
14342 info_ptr
+= bytes_read
;
14344 case DW_FORM_indirect
:
14345 form
= read_unsigned_leb128 (abfd
, info_ptr
, &bytes_read
);
14346 info_ptr
+= bytes_read
;
14347 info_ptr
= read_attribute_value (reader
, attr
, form
, info_ptr
);
14349 case DW_FORM_GNU_addr_index
:
14350 if (reader
->dwo_file
== NULL
)
14352 /* For now flag a hard error.
14353 Later we can turn this into a complaint. */
14354 error (_("Dwarf Error: %s found in non-DWO CU [in module %s]"),
14355 dwarf_form_name (form
),
14356 bfd_get_filename (abfd
));
14358 DW_ADDR (attr
) = read_addr_index_from_leb128 (cu
, info_ptr
, &bytes_read
);
14359 info_ptr
+= bytes_read
;
14361 case DW_FORM_GNU_str_index
:
14362 if (reader
->dwo_file
== NULL
)
14364 /* For now flag a hard error.
14365 Later we can turn this into a complaint if warranted. */
14366 error (_("Dwarf Error: %s found in non-DWO CU [in module %s]"),
14367 dwarf_form_name (form
),
14368 bfd_get_filename (abfd
));
14371 ULONGEST str_index
=
14372 read_unsigned_leb128 (abfd
, info_ptr
, &bytes_read
);
14374 DW_STRING (attr
) = read_str_index (reader
, cu
, str_index
);
14375 DW_STRING_IS_CANONICAL (attr
) = 0;
14376 info_ptr
+= bytes_read
;
14380 error (_("Dwarf Error: Cannot handle %s in DWARF reader [in module %s]"),
14381 dwarf_form_name (form
),
14382 bfd_get_filename (abfd
));
14386 if (cu
->per_cu
->is_dwz
&& is_ref_attr (attr
))
14387 attr
->form
= DW_FORM_GNU_ref_alt
;
14389 /* We have seen instances where the compiler tried to emit a byte
14390 size attribute of -1 which ended up being encoded as an unsigned
14391 0xffffffff. Although 0xffffffff is technically a valid size value,
14392 an object of this size seems pretty unlikely so we can relatively
14393 safely treat these cases as if the size attribute was invalid and
14394 treat them as zero by default. */
14395 if (attr
->name
== DW_AT_byte_size
14396 && form
== DW_FORM_data4
14397 && DW_UNSND (attr
) >= 0xffffffff)
14400 (&symfile_complaints
,
14401 _("Suspicious DW_AT_byte_size value treated as zero instead of %s"),
14402 hex_string (DW_UNSND (attr
)));
14403 DW_UNSND (attr
) = 0;
14409 /* Read an attribute described by an abbreviated attribute. */
14412 read_attribute (const struct die_reader_specs
*reader
,
14413 struct attribute
*attr
, struct attr_abbrev
*abbrev
,
14414 gdb_byte
*info_ptr
)
14416 attr
->name
= abbrev
->name
;
14417 return read_attribute_value (reader
, attr
, abbrev
->form
, info_ptr
);
14420 /* Read dwarf information from a buffer. */
14422 static unsigned int
14423 read_1_byte (bfd
*abfd
, const gdb_byte
*buf
)
14425 return bfd_get_8 (abfd
, buf
);
14429 read_1_signed_byte (bfd
*abfd
, const gdb_byte
*buf
)
14431 return bfd_get_signed_8 (abfd
, buf
);
14434 static unsigned int
14435 read_2_bytes (bfd
*abfd
, const gdb_byte
*buf
)
14437 return bfd_get_16 (abfd
, buf
);
14441 read_2_signed_bytes (bfd
*abfd
, const gdb_byte
*buf
)
14443 return bfd_get_signed_16 (abfd
, buf
);
14446 static unsigned int
14447 read_4_bytes (bfd
*abfd
, const gdb_byte
*buf
)
14449 return bfd_get_32 (abfd
, buf
);
14453 read_4_signed_bytes (bfd
*abfd
, const gdb_byte
*buf
)
14455 return bfd_get_signed_32 (abfd
, buf
);
14459 read_8_bytes (bfd
*abfd
, const gdb_byte
*buf
)
14461 return bfd_get_64 (abfd
, buf
);
14465 read_address (bfd
*abfd
, gdb_byte
*buf
, struct dwarf2_cu
*cu
,
14466 unsigned int *bytes_read
)
14468 struct comp_unit_head
*cu_header
= &cu
->header
;
14469 CORE_ADDR retval
= 0;
14471 if (cu_header
->signed_addr_p
)
14473 switch (cu_header
->addr_size
)
14476 retval
= bfd_get_signed_16 (abfd
, buf
);
14479 retval
= bfd_get_signed_32 (abfd
, buf
);
14482 retval
= bfd_get_signed_64 (abfd
, buf
);
14485 internal_error (__FILE__
, __LINE__
,
14486 _("read_address: bad switch, signed [in module %s]"),
14487 bfd_get_filename (abfd
));
14492 switch (cu_header
->addr_size
)
14495 retval
= bfd_get_16 (abfd
, buf
);
14498 retval
= bfd_get_32 (abfd
, buf
);
14501 retval
= bfd_get_64 (abfd
, buf
);
14504 internal_error (__FILE__
, __LINE__
,
14505 _("read_address: bad switch, "
14506 "unsigned [in module %s]"),
14507 bfd_get_filename (abfd
));
14511 *bytes_read
= cu_header
->addr_size
;
14515 /* Read the initial length from a section. The (draft) DWARF 3
14516 specification allows the initial length to take up either 4 bytes
14517 or 12 bytes. If the first 4 bytes are 0xffffffff, then the next 8
14518 bytes describe the length and all offsets will be 8 bytes in length
14521 An older, non-standard 64-bit format is also handled by this
14522 function. The older format in question stores the initial length
14523 as an 8-byte quantity without an escape value. Lengths greater
14524 than 2^32 aren't very common which means that the initial 4 bytes
14525 is almost always zero. Since a length value of zero doesn't make
14526 sense for the 32-bit format, this initial zero can be considered to
14527 be an escape value which indicates the presence of the older 64-bit
14528 format. As written, the code can't detect (old format) lengths
14529 greater than 4GB. If it becomes necessary to handle lengths
14530 somewhat larger than 4GB, we could allow other small values (such
14531 as the non-sensical values of 1, 2, and 3) to also be used as
14532 escape values indicating the presence of the old format.
14534 The value returned via bytes_read should be used to increment the
14535 relevant pointer after calling read_initial_length().
14537 [ Note: read_initial_length() and read_offset() are based on the
14538 document entitled "DWARF Debugging Information Format", revision
14539 3, draft 8, dated November 19, 2001. This document was obtained
14542 http://reality.sgiweb.org/davea/dwarf3-draft8-011125.pdf
14544 This document is only a draft and is subject to change. (So beware.)
14546 Details regarding the older, non-standard 64-bit format were
14547 determined empirically by examining 64-bit ELF files produced by
14548 the SGI toolchain on an IRIX 6.5 machine.
14550 - Kevin, July 16, 2002
14554 read_initial_length (bfd
*abfd
, gdb_byte
*buf
, unsigned int *bytes_read
)
14556 LONGEST length
= bfd_get_32 (abfd
, buf
);
14558 if (length
== 0xffffffff)
14560 length
= bfd_get_64 (abfd
, buf
+ 4);
14563 else if (length
== 0)
14565 /* Handle the (non-standard) 64-bit DWARF2 format used by IRIX. */
14566 length
= bfd_get_64 (abfd
, buf
);
14577 /* Cover function for read_initial_length.
14578 Returns the length of the object at BUF, and stores the size of the
14579 initial length in *BYTES_READ and stores the size that offsets will be in
14581 If the initial length size is not equivalent to that specified in
14582 CU_HEADER then issue a complaint.
14583 This is useful when reading non-comp-unit headers. */
14586 read_checked_initial_length_and_offset (bfd
*abfd
, gdb_byte
*buf
,
14587 const struct comp_unit_head
*cu_header
,
14588 unsigned int *bytes_read
,
14589 unsigned int *offset_size
)
14591 LONGEST length
= read_initial_length (abfd
, buf
, bytes_read
);
14593 gdb_assert (cu_header
->initial_length_size
== 4
14594 || cu_header
->initial_length_size
== 8
14595 || cu_header
->initial_length_size
== 12);
14597 if (cu_header
->initial_length_size
!= *bytes_read
)
14598 complaint (&symfile_complaints
,
14599 _("intermixed 32-bit and 64-bit DWARF sections"));
14601 *offset_size
= (*bytes_read
== 4) ? 4 : 8;
14605 /* Read an offset from the data stream. The size of the offset is
14606 given by cu_header->offset_size. */
14609 read_offset (bfd
*abfd
, gdb_byte
*buf
, const struct comp_unit_head
*cu_header
,
14610 unsigned int *bytes_read
)
14612 LONGEST offset
= read_offset_1 (abfd
, buf
, cu_header
->offset_size
);
14614 *bytes_read
= cu_header
->offset_size
;
14618 /* Read an offset from the data stream. */
14621 read_offset_1 (bfd
*abfd
, gdb_byte
*buf
, unsigned int offset_size
)
14623 LONGEST retval
= 0;
14625 switch (offset_size
)
14628 retval
= bfd_get_32 (abfd
, buf
);
14631 retval
= bfd_get_64 (abfd
, buf
);
14634 internal_error (__FILE__
, __LINE__
,
14635 _("read_offset_1: bad switch [in module %s]"),
14636 bfd_get_filename (abfd
));
14643 read_n_bytes (bfd
*abfd
, gdb_byte
*buf
, unsigned int size
)
14645 /* If the size of a host char is 8 bits, we can return a pointer
14646 to the buffer, otherwise we have to copy the data to a buffer
14647 allocated on the temporary obstack. */
14648 gdb_assert (HOST_CHAR_BIT
== 8);
14653 read_direct_string (bfd
*abfd
, gdb_byte
*buf
, unsigned int *bytes_read_ptr
)
14655 /* If the size of a host char is 8 bits, we can return a pointer
14656 to the string, otherwise we have to copy the string to a buffer
14657 allocated on the temporary obstack. */
14658 gdb_assert (HOST_CHAR_BIT
== 8);
14661 *bytes_read_ptr
= 1;
14664 *bytes_read_ptr
= strlen ((char *) buf
) + 1;
14665 return (char *) buf
;
14669 read_indirect_string_at_offset (bfd
*abfd
, LONGEST str_offset
)
14671 dwarf2_read_section (dwarf2_per_objfile
->objfile
, &dwarf2_per_objfile
->str
);
14672 if (dwarf2_per_objfile
->str
.buffer
== NULL
)
14673 error (_("DW_FORM_strp used without .debug_str section [in module %s]"),
14674 bfd_get_filename (abfd
));
14675 if (str_offset
>= dwarf2_per_objfile
->str
.size
)
14676 error (_("DW_FORM_strp pointing outside of "
14677 ".debug_str section [in module %s]"),
14678 bfd_get_filename (abfd
));
14679 gdb_assert (HOST_CHAR_BIT
== 8);
14680 if (dwarf2_per_objfile
->str
.buffer
[str_offset
] == '\0')
14682 return (char *) (dwarf2_per_objfile
->str
.buffer
+ str_offset
);
14685 /* Read a string at offset STR_OFFSET in the .debug_str section from
14686 the .dwz file DWZ. Throw an error if the offset is too large. If
14687 the string consists of a single NUL byte, return NULL; otherwise
14688 return a pointer to the string. */
14691 read_indirect_string_from_dwz (struct dwz_file
*dwz
, LONGEST str_offset
)
14693 dwarf2_read_section (dwarf2_per_objfile
->objfile
, &dwz
->str
);
14695 if (dwz
->str
.buffer
== NULL
)
14696 error (_("DW_FORM_GNU_strp_alt used without .debug_str "
14697 "section [in module %s]"),
14698 bfd_get_filename (dwz
->dwz_bfd
));
14699 if (str_offset
>= dwz
->str
.size
)
14700 error (_("DW_FORM_GNU_strp_alt pointing outside of "
14701 ".debug_str section [in module %s]"),
14702 bfd_get_filename (dwz
->dwz_bfd
));
14703 gdb_assert (HOST_CHAR_BIT
== 8);
14704 if (dwz
->str
.buffer
[str_offset
] == '\0')
14706 return (char *) (dwz
->str
.buffer
+ str_offset
);
14710 read_indirect_string (bfd
*abfd
, gdb_byte
*buf
,
14711 const struct comp_unit_head
*cu_header
,
14712 unsigned int *bytes_read_ptr
)
14714 LONGEST str_offset
= read_offset (abfd
, buf
, cu_header
, bytes_read_ptr
);
14716 return read_indirect_string_at_offset (abfd
, str_offset
);
14720 read_unsigned_leb128 (bfd
*abfd
, gdb_byte
*buf
, unsigned int *bytes_read_ptr
)
14723 unsigned int num_read
;
14725 unsigned char byte
;
14733 byte
= bfd_get_8 (abfd
, buf
);
14736 result
|= ((ULONGEST
) (byte
& 127) << shift
);
14737 if ((byte
& 128) == 0)
14743 *bytes_read_ptr
= num_read
;
14748 read_signed_leb128 (bfd
*abfd
, gdb_byte
*buf
, unsigned int *bytes_read_ptr
)
14751 int i
, shift
, num_read
;
14752 unsigned char byte
;
14760 byte
= bfd_get_8 (abfd
, buf
);
14763 result
|= ((LONGEST
) (byte
& 127) << shift
);
14765 if ((byte
& 128) == 0)
14770 if ((shift
< 8 * sizeof (result
)) && (byte
& 0x40))
14771 result
|= -(((LONGEST
) 1) << shift
);
14772 *bytes_read_ptr
= num_read
;
14776 /* Given index ADDR_INDEX in .debug_addr, fetch the value.
14777 ADDR_BASE is the DW_AT_GNU_addr_base attribute or zero.
14778 ADDR_SIZE is the size of addresses from the CU header. */
14781 read_addr_index_1 (unsigned int addr_index
, ULONGEST addr_base
, int addr_size
)
14783 struct objfile
*objfile
= dwarf2_per_objfile
->objfile
;
14784 bfd
*abfd
= objfile
->obfd
;
14785 const gdb_byte
*info_ptr
;
14787 dwarf2_read_section (objfile
, &dwarf2_per_objfile
->addr
);
14788 if (dwarf2_per_objfile
->addr
.buffer
== NULL
)
14789 error (_("DW_FORM_addr_index used without .debug_addr section [in module %s]"),
14791 if (addr_base
+ addr_index
* addr_size
>= dwarf2_per_objfile
->addr
.size
)
14792 error (_("DW_FORM_addr_index pointing outside of "
14793 ".debug_addr section [in module %s]"),
14795 info_ptr
= (dwarf2_per_objfile
->addr
.buffer
14796 + addr_base
+ addr_index
* addr_size
);
14797 if (addr_size
== 4)
14798 return bfd_get_32 (abfd
, info_ptr
);
14800 return bfd_get_64 (abfd
, info_ptr
);
14803 /* Given index ADDR_INDEX in .debug_addr, fetch the value. */
14806 read_addr_index (struct dwarf2_cu
*cu
, unsigned int addr_index
)
14808 return read_addr_index_1 (addr_index
, cu
->addr_base
, cu
->header
.addr_size
);
14811 /* Given a pointer to an leb128 value, fetch the value from .debug_addr. */
14814 read_addr_index_from_leb128 (struct dwarf2_cu
*cu
, gdb_byte
*info_ptr
,
14815 unsigned int *bytes_read
)
14817 bfd
*abfd
= cu
->objfile
->obfd
;
14818 unsigned int addr_index
= read_unsigned_leb128 (abfd
, info_ptr
, bytes_read
);
14820 return read_addr_index (cu
, addr_index
);
14823 /* Data structure to pass results from dwarf2_read_addr_index_reader
14824 back to dwarf2_read_addr_index. */
14826 struct dwarf2_read_addr_index_data
14828 ULONGEST addr_base
;
14832 /* die_reader_func for dwarf2_read_addr_index. */
14835 dwarf2_read_addr_index_reader (const struct die_reader_specs
*reader
,
14836 gdb_byte
*info_ptr
,
14837 struct die_info
*comp_unit_die
,
14841 struct dwarf2_cu
*cu
= reader
->cu
;
14842 struct dwarf2_read_addr_index_data
*aidata
=
14843 (struct dwarf2_read_addr_index_data
*) data
;
14845 aidata
->addr_base
= cu
->addr_base
;
14846 aidata
->addr_size
= cu
->header
.addr_size
;
14849 /* Given an index in .debug_addr, fetch the value.
14850 NOTE: This can be called during dwarf expression evaluation,
14851 long after the debug information has been read, and thus per_cu->cu
14852 may no longer exist. */
14855 dwarf2_read_addr_index (struct dwarf2_per_cu_data
*per_cu
,
14856 unsigned int addr_index
)
14858 struct objfile
*objfile
= per_cu
->objfile
;
14859 struct dwarf2_cu
*cu
= per_cu
->cu
;
14860 ULONGEST addr_base
;
14863 /* This is intended to be called from outside this file. */
14864 dw2_setup (objfile
);
14866 /* We need addr_base and addr_size.
14867 If we don't have PER_CU->cu, we have to get it.
14868 Nasty, but the alternative is storing the needed info in PER_CU,
14869 which at this point doesn't seem justified: it's not clear how frequently
14870 it would get used and it would increase the size of every PER_CU.
14871 Entry points like dwarf2_per_cu_addr_size do a similar thing
14872 so we're not in uncharted territory here.
14873 Alas we need to be a bit more complicated as addr_base is contained
14876 We don't need to read the entire CU(/TU).
14877 We just need the header and top level die.
14879 IWBN to use the aging mechanism to let us lazily later discard the CU.
14880 For now we skip this optimization. */
14884 addr_base
= cu
->addr_base
;
14885 addr_size
= cu
->header
.addr_size
;
14889 struct dwarf2_read_addr_index_data aidata
;
14891 /* Note: We can't use init_cutu_and_read_dies_simple here,
14892 we need addr_base. */
14893 init_cutu_and_read_dies (per_cu
, NULL
, 0, 0,
14894 dwarf2_read_addr_index_reader
, &aidata
);
14895 addr_base
= aidata
.addr_base
;
14896 addr_size
= aidata
.addr_size
;
14899 return read_addr_index_1 (addr_index
, addr_base
, addr_size
);
14902 /* Given a DW_AT_str_index, fetch the string. */
14905 read_str_index (const struct die_reader_specs
*reader
,
14906 struct dwarf2_cu
*cu
, ULONGEST str_index
)
14908 struct objfile
*objfile
= dwarf2_per_objfile
->objfile
;
14909 const char *dwo_name
= objfile
->name
;
14910 bfd
*abfd
= objfile
->obfd
;
14911 struct dwo_sections
*sections
= &reader
->dwo_file
->sections
;
14912 gdb_byte
*info_ptr
;
14913 ULONGEST str_offset
;
14915 dwarf2_read_section (objfile
, §ions
->str
);
14916 dwarf2_read_section (objfile
, §ions
->str_offsets
);
14917 if (sections
->str
.buffer
== NULL
)
14918 error (_("DW_FORM_str_index used without .debug_str.dwo section"
14919 " in CU at offset 0x%lx [in module %s]"),
14920 (long) cu
->header
.offset
.sect_off
, dwo_name
);
14921 if (sections
->str_offsets
.buffer
== NULL
)
14922 error (_("DW_FORM_str_index used without .debug_str_offsets.dwo section"
14923 " in CU at offset 0x%lx [in module %s]"),
14924 (long) cu
->header
.offset
.sect_off
, dwo_name
);
14925 if (str_index
* cu
->header
.offset_size
>= sections
->str_offsets
.size
)
14926 error (_("DW_FORM_str_index pointing outside of .debug_str_offsets.dwo"
14927 " section in CU at offset 0x%lx [in module %s]"),
14928 (long) cu
->header
.offset
.sect_off
, dwo_name
);
14929 info_ptr
= (sections
->str_offsets
.buffer
14930 + str_index
* cu
->header
.offset_size
);
14931 if (cu
->header
.offset_size
== 4)
14932 str_offset
= bfd_get_32 (abfd
, info_ptr
);
14934 str_offset
= bfd_get_64 (abfd
, info_ptr
);
14935 if (str_offset
>= sections
->str
.size
)
14936 error (_("Offset from DW_FORM_str_index pointing outside of"
14937 " .debug_str.dwo section in CU at offset 0x%lx [in module %s]"),
14938 (long) cu
->header
.offset
.sect_off
, dwo_name
);
14939 return (char *) (sections
->str
.buffer
+ str_offset
);
14942 /* Return the length of an LEB128 number in BUF. */
14945 leb128_size (const gdb_byte
*buf
)
14947 const gdb_byte
*begin
= buf
;
14953 if ((byte
& 128) == 0)
14954 return buf
- begin
;
14959 set_cu_language (unsigned int lang
, struct dwarf2_cu
*cu
)
14966 cu
->language
= language_c
;
14968 case DW_LANG_C_plus_plus
:
14969 cu
->language
= language_cplus
;
14972 cu
->language
= language_d
;
14974 case DW_LANG_Fortran77
:
14975 case DW_LANG_Fortran90
:
14976 case DW_LANG_Fortran95
:
14977 cu
->language
= language_fortran
;
14980 cu
->language
= language_go
;
14982 case DW_LANG_Mips_Assembler
:
14983 cu
->language
= language_asm
;
14986 cu
->language
= language_java
;
14988 case DW_LANG_Ada83
:
14989 case DW_LANG_Ada95
:
14990 cu
->language
= language_ada
;
14992 case DW_LANG_Modula2
:
14993 cu
->language
= language_m2
;
14995 case DW_LANG_Pascal83
:
14996 cu
->language
= language_pascal
;
14999 cu
->language
= language_objc
;
15001 case DW_LANG_Cobol74
:
15002 case DW_LANG_Cobol85
:
15004 cu
->language
= language_minimal
;
15007 cu
->language_defn
= language_def (cu
->language
);
15010 /* Return the named attribute or NULL if not there. */
15012 static struct attribute
*
15013 dwarf2_attr (struct die_info
*die
, unsigned int name
, struct dwarf2_cu
*cu
)
15018 struct attribute
*spec
= NULL
;
15020 for (i
= 0; i
< die
->num_attrs
; ++i
)
15022 if (die
->attrs
[i
].name
== name
)
15023 return &die
->attrs
[i
];
15024 if (die
->attrs
[i
].name
== DW_AT_specification
15025 || die
->attrs
[i
].name
== DW_AT_abstract_origin
)
15026 spec
= &die
->attrs
[i
];
15032 die
= follow_die_ref (die
, spec
, &cu
);
15038 /* Return the named attribute or NULL if not there,
15039 but do not follow DW_AT_specification, etc.
15040 This is for use in contexts where we're reading .debug_types dies.
15041 Following DW_AT_specification, DW_AT_abstract_origin will take us
15042 back up the chain, and we want to go down. */
15044 static struct attribute
*
15045 dwarf2_attr_no_follow (struct die_info
*die
, unsigned int name
)
15049 for (i
= 0; i
< die
->num_attrs
; ++i
)
15050 if (die
->attrs
[i
].name
== name
)
15051 return &die
->attrs
[i
];
15056 /* Return non-zero iff the attribute NAME is defined for the given DIE,
15057 and holds a non-zero value. This function should only be used for
15058 DW_FORM_flag or DW_FORM_flag_present attributes. */
15061 dwarf2_flag_true_p (struct die_info
*die
, unsigned name
, struct dwarf2_cu
*cu
)
15063 struct attribute
*attr
= dwarf2_attr (die
, name
, cu
);
15065 return (attr
&& DW_UNSND (attr
));
15069 die_is_declaration (struct die_info
*die
, struct dwarf2_cu
*cu
)
15071 /* A DIE is a declaration if it has a DW_AT_declaration attribute
15072 which value is non-zero. However, we have to be careful with
15073 DIEs having a DW_AT_specification attribute, because dwarf2_attr()
15074 (via dwarf2_flag_true_p) follows this attribute. So we may
15075 end up accidently finding a declaration attribute that belongs
15076 to a different DIE referenced by the specification attribute,
15077 even though the given DIE does not have a declaration attribute. */
15078 return (dwarf2_flag_true_p (die
, DW_AT_declaration
, cu
)
15079 && dwarf2_attr (die
, DW_AT_specification
, cu
) == NULL
);
15082 /* Return the die giving the specification for DIE, if there is
15083 one. *SPEC_CU is the CU containing DIE on input, and the CU
15084 containing the return value on output. If there is no
15085 specification, but there is an abstract origin, that is
15088 static struct die_info
*
15089 die_specification (struct die_info
*die
, struct dwarf2_cu
**spec_cu
)
15091 struct attribute
*spec_attr
= dwarf2_attr (die
, DW_AT_specification
,
15094 if (spec_attr
== NULL
)
15095 spec_attr
= dwarf2_attr (die
, DW_AT_abstract_origin
, *spec_cu
);
15097 if (spec_attr
== NULL
)
15100 return follow_die_ref (die
, spec_attr
, spec_cu
);
15103 /* Free the line_header structure *LH, and any arrays and strings it
15105 NOTE: This is also used as a "cleanup" function. */
15108 free_line_header (struct line_header
*lh
)
15110 if (lh
->standard_opcode_lengths
)
15111 xfree (lh
->standard_opcode_lengths
);
15113 /* Remember that all the lh->file_names[i].name pointers are
15114 pointers into debug_line_buffer, and don't need to be freed. */
15115 if (lh
->file_names
)
15116 xfree (lh
->file_names
);
15118 /* Similarly for the include directory names. */
15119 if (lh
->include_dirs
)
15120 xfree (lh
->include_dirs
);
15125 /* Add an entry to LH's include directory table. */
15128 add_include_dir (struct line_header
*lh
, char *include_dir
)
15130 /* Grow the array if necessary. */
15131 if (lh
->include_dirs_size
== 0)
15133 lh
->include_dirs_size
= 1; /* for testing */
15134 lh
->include_dirs
= xmalloc (lh
->include_dirs_size
15135 * sizeof (*lh
->include_dirs
));
15137 else if (lh
->num_include_dirs
>= lh
->include_dirs_size
)
15139 lh
->include_dirs_size
*= 2;
15140 lh
->include_dirs
= xrealloc (lh
->include_dirs
,
15141 (lh
->include_dirs_size
15142 * sizeof (*lh
->include_dirs
)));
15145 lh
->include_dirs
[lh
->num_include_dirs
++] = include_dir
;
15148 /* Add an entry to LH's file name table. */
15151 add_file_name (struct line_header
*lh
,
15153 unsigned int dir_index
,
15154 unsigned int mod_time
,
15155 unsigned int length
)
15157 struct file_entry
*fe
;
15159 /* Grow the array if necessary. */
15160 if (lh
->file_names_size
== 0)
15162 lh
->file_names_size
= 1; /* for testing */
15163 lh
->file_names
= xmalloc (lh
->file_names_size
15164 * sizeof (*lh
->file_names
));
15166 else if (lh
->num_file_names
>= lh
->file_names_size
)
15168 lh
->file_names_size
*= 2;
15169 lh
->file_names
= xrealloc (lh
->file_names
,
15170 (lh
->file_names_size
15171 * sizeof (*lh
->file_names
)));
15174 fe
= &lh
->file_names
[lh
->num_file_names
++];
15176 fe
->dir_index
= dir_index
;
15177 fe
->mod_time
= mod_time
;
15178 fe
->length
= length
;
15179 fe
->included_p
= 0;
15183 /* A convenience function to find the proper .debug_line section for a
15186 static struct dwarf2_section_info
*
15187 get_debug_line_section (struct dwarf2_cu
*cu
)
15189 struct dwarf2_section_info
*section
;
15191 /* For TUs in DWO files, the DW_AT_stmt_list attribute lives in the
15193 if (cu
->dwo_unit
&& cu
->per_cu
->is_debug_types
)
15194 section
= &cu
->dwo_unit
->dwo_file
->sections
.line
;
15195 else if (cu
->per_cu
->is_dwz
)
15197 struct dwz_file
*dwz
= dwarf2_get_dwz_file ();
15199 section
= &dwz
->line
;
15202 section
= &dwarf2_per_objfile
->line
;
15207 /* Read the statement program header starting at OFFSET in
15208 .debug_line, or .debug_line.dwo. Return a pointer
15209 to a struct line_header, allocated using xmalloc.
15211 NOTE: the strings in the include directory and file name tables of
15212 the returned object point into the dwarf line section buffer,
15213 and must not be freed. */
15215 static struct line_header
*
15216 dwarf_decode_line_header (unsigned int offset
, struct dwarf2_cu
*cu
)
15218 struct cleanup
*back_to
;
15219 struct line_header
*lh
;
15220 gdb_byte
*line_ptr
;
15221 unsigned int bytes_read
, offset_size
;
15223 char *cur_dir
, *cur_file
;
15224 struct dwarf2_section_info
*section
;
15227 section
= get_debug_line_section (cu
);
15228 dwarf2_read_section (dwarf2_per_objfile
->objfile
, section
);
15229 if (section
->buffer
== NULL
)
15231 if (cu
->dwo_unit
&& cu
->per_cu
->is_debug_types
)
15232 complaint (&symfile_complaints
, _("missing .debug_line.dwo section"));
15234 complaint (&symfile_complaints
, _("missing .debug_line section"));
15238 /* We can't do this until we know the section is non-empty.
15239 Only then do we know we have such a section. */
15240 abfd
= section
->asection
->owner
;
15242 /* Make sure that at least there's room for the total_length field.
15243 That could be 12 bytes long, but we're just going to fudge that. */
15244 if (offset
+ 4 >= section
->size
)
15246 dwarf2_statement_list_fits_in_line_number_section_complaint ();
15250 lh
= xmalloc (sizeof (*lh
));
15251 memset (lh
, 0, sizeof (*lh
));
15252 back_to
= make_cleanup ((make_cleanup_ftype
*) free_line_header
,
15255 line_ptr
= section
->buffer
+ offset
;
15257 /* Read in the header. */
15259 read_checked_initial_length_and_offset (abfd
, line_ptr
, &cu
->header
,
15260 &bytes_read
, &offset_size
);
15261 line_ptr
+= bytes_read
;
15262 if (line_ptr
+ lh
->total_length
> (section
->buffer
+ section
->size
))
15264 dwarf2_statement_list_fits_in_line_number_section_complaint ();
15267 lh
->statement_program_end
= line_ptr
+ lh
->total_length
;
15268 lh
->version
= read_2_bytes (abfd
, line_ptr
);
15270 lh
->header_length
= read_offset_1 (abfd
, line_ptr
, offset_size
);
15271 line_ptr
+= offset_size
;
15272 lh
->minimum_instruction_length
= read_1_byte (abfd
, line_ptr
);
15274 if (lh
->version
>= 4)
15276 lh
->maximum_ops_per_instruction
= read_1_byte (abfd
, line_ptr
);
15280 lh
->maximum_ops_per_instruction
= 1;
15282 if (lh
->maximum_ops_per_instruction
== 0)
15284 lh
->maximum_ops_per_instruction
= 1;
15285 complaint (&symfile_complaints
,
15286 _("invalid maximum_ops_per_instruction "
15287 "in `.debug_line' section"));
15290 lh
->default_is_stmt
= read_1_byte (abfd
, line_ptr
);
15292 lh
->line_base
= read_1_signed_byte (abfd
, line_ptr
);
15294 lh
->line_range
= read_1_byte (abfd
, line_ptr
);
15296 lh
->opcode_base
= read_1_byte (abfd
, line_ptr
);
15298 lh
->standard_opcode_lengths
15299 = xmalloc (lh
->opcode_base
* sizeof (lh
->standard_opcode_lengths
[0]));
15301 lh
->standard_opcode_lengths
[0] = 1; /* This should never be used anyway. */
15302 for (i
= 1; i
< lh
->opcode_base
; ++i
)
15304 lh
->standard_opcode_lengths
[i
] = read_1_byte (abfd
, line_ptr
);
15308 /* Read directory table. */
15309 while ((cur_dir
= read_direct_string (abfd
, line_ptr
, &bytes_read
)) != NULL
)
15311 line_ptr
+= bytes_read
;
15312 add_include_dir (lh
, cur_dir
);
15314 line_ptr
+= bytes_read
;
15316 /* Read file name table. */
15317 while ((cur_file
= read_direct_string (abfd
, line_ptr
, &bytes_read
)) != NULL
)
15319 unsigned int dir_index
, mod_time
, length
;
15321 line_ptr
+= bytes_read
;
15322 dir_index
= read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
15323 line_ptr
+= bytes_read
;
15324 mod_time
= read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
15325 line_ptr
+= bytes_read
;
15326 length
= read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
15327 line_ptr
+= bytes_read
;
15329 add_file_name (lh
, cur_file
, dir_index
, mod_time
, length
);
15331 line_ptr
+= bytes_read
;
15332 lh
->statement_program_start
= line_ptr
;
15334 if (line_ptr
> (section
->buffer
+ section
->size
))
15335 complaint (&symfile_complaints
,
15336 _("line number info header doesn't "
15337 "fit in `.debug_line' section"));
15339 discard_cleanups (back_to
);
15343 /* Subroutine of dwarf_decode_lines to simplify it.
15344 Return the file name of the psymtab for included file FILE_INDEX
15345 in line header LH of PST.
15346 COMP_DIR is the compilation directory (DW_AT_comp_dir) or NULL if unknown.
15347 If space for the result is malloc'd, it will be freed by a cleanup.
15348 Returns NULL if FILE_INDEX should be ignored, i.e., it is pst->filename.
15350 The function creates dangling cleanup registration. */
15353 psymtab_include_file_name (const struct line_header
*lh
, int file_index
,
15354 const struct partial_symtab
*pst
,
15355 const char *comp_dir
)
15357 const struct file_entry fe
= lh
->file_names
[file_index
];
15358 char *include_name
= fe
.name
;
15359 char *include_name_to_compare
= include_name
;
15360 char *dir_name
= NULL
;
15361 const char *pst_filename
;
15362 char *copied_name
= NULL
;
15366 dir_name
= lh
->include_dirs
[fe
.dir_index
- 1];
15368 if (!IS_ABSOLUTE_PATH (include_name
)
15369 && (dir_name
!= NULL
|| comp_dir
!= NULL
))
15371 /* Avoid creating a duplicate psymtab for PST.
15372 We do this by comparing INCLUDE_NAME and PST_FILENAME.
15373 Before we do the comparison, however, we need to account
15374 for DIR_NAME and COMP_DIR.
15375 First prepend dir_name (if non-NULL). If we still don't
15376 have an absolute path prepend comp_dir (if non-NULL).
15377 However, the directory we record in the include-file's
15378 psymtab does not contain COMP_DIR (to match the
15379 corresponding symtab(s)).
15384 bash$ gcc -g ./hello.c
15385 include_name = "hello.c"
15387 DW_AT_comp_dir = comp_dir = "/tmp"
15388 DW_AT_name = "./hello.c" */
15390 if (dir_name
!= NULL
)
15392 include_name
= concat (dir_name
, SLASH_STRING
,
15393 include_name
, (char *)NULL
);
15394 include_name_to_compare
= include_name
;
15395 make_cleanup (xfree
, include_name
);
15397 if (!IS_ABSOLUTE_PATH (include_name
) && comp_dir
!= NULL
)
15399 include_name_to_compare
= concat (comp_dir
, SLASH_STRING
,
15400 include_name
, (char *)NULL
);
15404 pst_filename
= pst
->filename
;
15405 if (!IS_ABSOLUTE_PATH (pst_filename
) && pst
->dirname
!= NULL
)
15407 copied_name
= concat (pst
->dirname
, SLASH_STRING
,
15408 pst_filename
, (char *)NULL
);
15409 pst_filename
= copied_name
;
15412 file_is_pst
= FILENAME_CMP (include_name_to_compare
, pst_filename
) == 0;
15414 if (include_name_to_compare
!= include_name
)
15415 xfree (include_name_to_compare
);
15416 if (copied_name
!= NULL
)
15417 xfree (copied_name
);
15421 return include_name
;
15424 /* Ignore this record_line request. */
15427 noop_record_line (struct subfile
*subfile
, int line
, CORE_ADDR pc
)
15432 /* Subroutine of dwarf_decode_lines to simplify it.
15433 Process the line number information in LH. */
15436 dwarf_decode_lines_1 (struct line_header
*lh
, const char *comp_dir
,
15437 struct dwarf2_cu
*cu
, struct partial_symtab
*pst
)
15439 gdb_byte
*line_ptr
, *extended_end
;
15440 gdb_byte
*line_end
;
15441 unsigned int bytes_read
, extended_len
;
15442 unsigned char op_code
, extended_op
, adj_opcode
;
15443 CORE_ADDR baseaddr
;
15444 struct objfile
*objfile
= cu
->objfile
;
15445 bfd
*abfd
= objfile
->obfd
;
15446 struct gdbarch
*gdbarch
= get_objfile_arch (objfile
);
15447 const int decode_for_pst_p
= (pst
!= NULL
);
15448 struct subfile
*last_subfile
= NULL
;
15449 void (*p_record_line
) (struct subfile
*subfile
, int line
, CORE_ADDR pc
)
15452 baseaddr
= ANOFFSET (objfile
->section_offsets
, SECT_OFF_TEXT (objfile
));
15454 line_ptr
= lh
->statement_program_start
;
15455 line_end
= lh
->statement_program_end
;
15457 /* Read the statement sequences until there's nothing left. */
15458 while (line_ptr
< line_end
)
15460 /* state machine registers */
15461 CORE_ADDR address
= 0;
15462 unsigned int file
= 1;
15463 unsigned int line
= 1;
15464 unsigned int column
= 0;
15465 int is_stmt
= lh
->default_is_stmt
;
15466 int basic_block
= 0;
15467 int end_sequence
= 0;
15469 unsigned char op_index
= 0;
15471 if (!decode_for_pst_p
&& lh
->num_file_names
>= file
)
15473 /* Start a subfile for the current file of the state machine. */
15474 /* lh->include_dirs and lh->file_names are 0-based, but the
15475 directory and file name numbers in the statement program
15477 struct file_entry
*fe
= &lh
->file_names
[file
- 1];
15481 dir
= lh
->include_dirs
[fe
->dir_index
- 1];
15483 dwarf2_start_subfile (fe
->name
, dir
, comp_dir
);
15486 /* Decode the table. */
15487 while (!end_sequence
)
15489 op_code
= read_1_byte (abfd
, line_ptr
);
15491 if (line_ptr
> line_end
)
15493 dwarf2_debug_line_missing_end_sequence_complaint ();
15497 if (op_code
>= lh
->opcode_base
)
15499 /* Special operand. */
15500 adj_opcode
= op_code
- lh
->opcode_base
;
15501 address
+= (((op_index
+ (adj_opcode
/ lh
->line_range
))
15502 / lh
->maximum_ops_per_instruction
)
15503 * lh
->minimum_instruction_length
);
15504 op_index
= ((op_index
+ (adj_opcode
/ lh
->line_range
))
15505 % lh
->maximum_ops_per_instruction
);
15506 line
+= lh
->line_base
+ (adj_opcode
% lh
->line_range
);
15507 if (lh
->num_file_names
< file
|| file
== 0)
15508 dwarf2_debug_line_missing_file_complaint ();
15509 /* For now we ignore lines not starting on an
15510 instruction boundary. */
15511 else if (op_index
== 0)
15513 lh
->file_names
[file
- 1].included_p
= 1;
15514 if (!decode_for_pst_p
&& is_stmt
)
15516 if (last_subfile
!= current_subfile
)
15518 addr
= gdbarch_addr_bits_remove (gdbarch
, address
);
15520 (*p_record_line
) (last_subfile
, 0, addr
);
15521 last_subfile
= current_subfile
;
15523 /* Append row to matrix using current values. */
15524 addr
= gdbarch_addr_bits_remove (gdbarch
, address
);
15525 (*p_record_line
) (current_subfile
, line
, addr
);
15530 else switch (op_code
)
15532 case DW_LNS_extended_op
:
15533 extended_len
= read_unsigned_leb128 (abfd
, line_ptr
,
15535 line_ptr
+= bytes_read
;
15536 extended_end
= line_ptr
+ extended_len
;
15537 extended_op
= read_1_byte (abfd
, line_ptr
);
15539 switch (extended_op
)
15541 case DW_LNE_end_sequence
:
15542 p_record_line
= record_line
;
15545 case DW_LNE_set_address
:
15546 address
= read_address (abfd
, line_ptr
, cu
, &bytes_read
);
15548 if (address
== 0 && !dwarf2_per_objfile
->has_section_at_zero
)
15550 /* This line table is for a function which has been
15551 GCd by the linker. Ignore it. PR gdb/12528 */
15554 = line_ptr
- get_debug_line_section (cu
)->buffer
;
15556 complaint (&symfile_complaints
,
15557 _(".debug_line address at offset 0x%lx is 0 "
15559 line_offset
, objfile
->name
);
15560 p_record_line
= noop_record_line
;
15564 line_ptr
+= bytes_read
;
15565 address
+= baseaddr
;
15567 case DW_LNE_define_file
:
15570 unsigned int dir_index
, mod_time
, length
;
15572 cur_file
= read_direct_string (abfd
, line_ptr
,
15574 line_ptr
+= bytes_read
;
15576 read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
15577 line_ptr
+= bytes_read
;
15579 read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
15580 line_ptr
+= bytes_read
;
15582 read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
15583 line_ptr
+= bytes_read
;
15584 add_file_name (lh
, cur_file
, dir_index
, mod_time
, length
);
15587 case DW_LNE_set_discriminator
:
15588 /* The discriminator is not interesting to the debugger;
15590 line_ptr
= extended_end
;
15593 complaint (&symfile_complaints
,
15594 _("mangled .debug_line section"));
15597 /* Make sure that we parsed the extended op correctly. If e.g.
15598 we expected a different address size than the producer used,
15599 we may have read the wrong number of bytes. */
15600 if (line_ptr
!= extended_end
)
15602 complaint (&symfile_complaints
,
15603 _("mangled .debug_line section"));
15608 if (lh
->num_file_names
< file
|| file
== 0)
15609 dwarf2_debug_line_missing_file_complaint ();
15612 lh
->file_names
[file
- 1].included_p
= 1;
15613 if (!decode_for_pst_p
&& is_stmt
)
15615 if (last_subfile
!= current_subfile
)
15617 addr
= gdbarch_addr_bits_remove (gdbarch
, address
);
15619 (*p_record_line
) (last_subfile
, 0, addr
);
15620 last_subfile
= current_subfile
;
15622 addr
= gdbarch_addr_bits_remove (gdbarch
, address
);
15623 (*p_record_line
) (current_subfile
, line
, addr
);
15628 case DW_LNS_advance_pc
:
15631 = read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
15633 address
+= (((op_index
+ adjust
)
15634 / lh
->maximum_ops_per_instruction
)
15635 * lh
->minimum_instruction_length
);
15636 op_index
= ((op_index
+ adjust
)
15637 % lh
->maximum_ops_per_instruction
);
15638 line_ptr
+= bytes_read
;
15641 case DW_LNS_advance_line
:
15642 line
+= read_signed_leb128 (abfd
, line_ptr
, &bytes_read
);
15643 line_ptr
+= bytes_read
;
15645 case DW_LNS_set_file
:
15647 /* The arrays lh->include_dirs and lh->file_names are
15648 0-based, but the directory and file name numbers in
15649 the statement program are 1-based. */
15650 struct file_entry
*fe
;
15653 file
= read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
15654 line_ptr
+= bytes_read
;
15655 if (lh
->num_file_names
< file
|| file
== 0)
15656 dwarf2_debug_line_missing_file_complaint ();
15659 fe
= &lh
->file_names
[file
- 1];
15661 dir
= lh
->include_dirs
[fe
->dir_index
- 1];
15662 if (!decode_for_pst_p
)
15664 last_subfile
= current_subfile
;
15665 dwarf2_start_subfile (fe
->name
, dir
, comp_dir
);
15670 case DW_LNS_set_column
:
15671 column
= read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
15672 line_ptr
+= bytes_read
;
15674 case DW_LNS_negate_stmt
:
15675 is_stmt
= (!is_stmt
);
15677 case DW_LNS_set_basic_block
:
15680 /* Add to the address register of the state machine the
15681 address increment value corresponding to special opcode
15682 255. I.e., this value is scaled by the minimum
15683 instruction length since special opcode 255 would have
15684 scaled the increment. */
15685 case DW_LNS_const_add_pc
:
15687 CORE_ADDR adjust
= (255 - lh
->opcode_base
) / lh
->line_range
;
15689 address
+= (((op_index
+ adjust
)
15690 / lh
->maximum_ops_per_instruction
)
15691 * lh
->minimum_instruction_length
);
15692 op_index
= ((op_index
+ adjust
)
15693 % lh
->maximum_ops_per_instruction
);
15696 case DW_LNS_fixed_advance_pc
:
15697 address
+= read_2_bytes (abfd
, line_ptr
);
15703 /* Unknown standard opcode, ignore it. */
15706 for (i
= 0; i
< lh
->standard_opcode_lengths
[op_code
]; i
++)
15708 (void) read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
15709 line_ptr
+= bytes_read
;
15714 if (lh
->num_file_names
< file
|| file
== 0)
15715 dwarf2_debug_line_missing_file_complaint ();
15718 lh
->file_names
[file
- 1].included_p
= 1;
15719 if (!decode_for_pst_p
)
15721 addr
= gdbarch_addr_bits_remove (gdbarch
, address
);
15722 (*p_record_line
) (current_subfile
, 0, addr
);
15728 /* Decode the Line Number Program (LNP) for the given line_header
15729 structure and CU. The actual information extracted and the type
15730 of structures created from the LNP depends on the value of PST.
15732 1. If PST is NULL, then this procedure uses the data from the program
15733 to create all necessary symbol tables, and their linetables.
15735 2. If PST is not NULL, this procedure reads the program to determine
15736 the list of files included by the unit represented by PST, and
15737 builds all the associated partial symbol tables.
15739 COMP_DIR is the compilation directory (DW_AT_comp_dir) or NULL if unknown.
15740 It is used for relative paths in the line table.
15741 NOTE: When processing partial symtabs (pst != NULL),
15742 comp_dir == pst->dirname.
15744 NOTE: It is important that psymtabs have the same file name (via strcmp)
15745 as the corresponding symtab. Since COMP_DIR is not used in the name of the
15746 symtab we don't use it in the name of the psymtabs we create.
15747 E.g. expand_line_sal requires this when finding psymtabs to expand.
15748 A good testcase for this is mb-inline.exp. */
15751 dwarf_decode_lines (struct line_header
*lh
, const char *comp_dir
,
15752 struct dwarf2_cu
*cu
, struct partial_symtab
*pst
,
15753 int want_line_info
)
15755 struct objfile
*objfile
= cu
->objfile
;
15756 const int decode_for_pst_p
= (pst
!= NULL
);
15757 struct subfile
*first_subfile
= current_subfile
;
15759 if (want_line_info
)
15760 dwarf_decode_lines_1 (lh
, comp_dir
, cu
, pst
);
15762 if (decode_for_pst_p
)
15766 /* Now that we're done scanning the Line Header Program, we can
15767 create the psymtab of each included file. */
15768 for (file_index
= 0; file_index
< lh
->num_file_names
; file_index
++)
15769 if (lh
->file_names
[file_index
].included_p
== 1)
15771 char *include_name
=
15772 psymtab_include_file_name (lh
, file_index
, pst
, comp_dir
);
15773 if (include_name
!= NULL
)
15774 dwarf2_create_include_psymtab (include_name
, pst
, objfile
);
15779 /* Make sure a symtab is created for every file, even files
15780 which contain only variables (i.e. no code with associated
15784 for (i
= 0; i
< lh
->num_file_names
; i
++)
15787 struct file_entry
*fe
;
15789 fe
= &lh
->file_names
[i
];
15791 dir
= lh
->include_dirs
[fe
->dir_index
- 1];
15792 dwarf2_start_subfile (fe
->name
, dir
, comp_dir
);
15794 /* Skip the main file; we don't need it, and it must be
15795 allocated last, so that it will show up before the
15796 non-primary symtabs in the objfile's symtab list. */
15797 if (current_subfile
== first_subfile
)
15800 if (current_subfile
->symtab
== NULL
)
15801 current_subfile
->symtab
= allocate_symtab (current_subfile
->name
,
15803 fe
->symtab
= current_subfile
->symtab
;
15808 /* Start a subfile for DWARF. FILENAME is the name of the file and
15809 DIRNAME the name of the source directory which contains FILENAME
15810 or NULL if not known. COMP_DIR is the compilation directory for the
15811 linetable's compilation unit or NULL if not known.
15812 This routine tries to keep line numbers from identical absolute and
15813 relative file names in a common subfile.
15815 Using the `list' example from the GDB testsuite, which resides in
15816 /srcdir and compiling it with Irix6.2 cc in /compdir using a filename
15817 of /srcdir/list0.c yields the following debugging information for list0.c:
15819 DW_AT_name: /srcdir/list0.c
15820 DW_AT_comp_dir: /compdir
15821 files.files[0].name: list0.h
15822 files.files[0].dir: /srcdir
15823 files.files[1].name: list0.c
15824 files.files[1].dir: /srcdir
15826 The line number information for list0.c has to end up in a single
15827 subfile, so that `break /srcdir/list0.c:1' works as expected.
15828 start_subfile will ensure that this happens provided that we pass the
15829 concatenation of files.files[1].dir and files.files[1].name as the
15833 dwarf2_start_subfile (char *filename
, const char *dirname
,
15834 const char *comp_dir
)
15838 /* While reading the DIEs, we call start_symtab(DW_AT_name, DW_AT_comp_dir).
15839 `start_symtab' will always pass the contents of DW_AT_comp_dir as
15840 second argument to start_subfile. To be consistent, we do the
15841 same here. In order not to lose the line information directory,
15842 we concatenate it to the filename when it makes sense.
15843 Note that the Dwarf3 standard says (speaking of filenames in line
15844 information): ``The directory index is ignored for file names
15845 that represent full path names''. Thus ignoring dirname in the
15846 `else' branch below isn't an issue. */
15848 if (!IS_ABSOLUTE_PATH (filename
) && dirname
!= NULL
)
15849 fullname
= concat (dirname
, SLASH_STRING
, filename
, (char *)NULL
);
15851 fullname
= filename
;
15853 start_subfile (fullname
, comp_dir
);
15855 if (fullname
!= filename
)
15859 /* Start a symtab for DWARF.
15860 NAME, COMP_DIR, LOW_PC are passed to start_symtab. */
15863 dwarf2_start_symtab (struct dwarf2_cu
*cu
,
15864 const char *name
, const char *comp_dir
, CORE_ADDR low_pc
)
15866 start_symtab (name
, comp_dir
, low_pc
);
15867 record_debugformat ("DWARF 2");
15868 record_producer (cu
->producer
);
15870 /* We assume that we're processing GCC output. */
15871 processing_gcc_compilation
= 2;
15873 cu
->processing_has_namespace_info
= 0;
15877 var_decode_location (struct attribute
*attr
, struct symbol
*sym
,
15878 struct dwarf2_cu
*cu
)
15880 struct objfile
*objfile
= cu
->objfile
;
15881 struct comp_unit_head
*cu_header
= &cu
->header
;
15883 /* NOTE drow/2003-01-30: There used to be a comment and some special
15884 code here to turn a symbol with DW_AT_external and a
15885 SYMBOL_VALUE_ADDRESS of 0 into a LOC_UNRESOLVED symbol. This was
15886 necessary for platforms (maybe Alpha, certainly PowerPC GNU/Linux
15887 with some versions of binutils) where shared libraries could have
15888 relocations against symbols in their debug information - the
15889 minimal symbol would have the right address, but the debug info
15890 would not. It's no longer necessary, because we will explicitly
15891 apply relocations when we read in the debug information now. */
15893 /* A DW_AT_location attribute with no contents indicates that a
15894 variable has been optimized away. */
15895 if (attr_form_is_block (attr
) && DW_BLOCK (attr
)->size
== 0)
15897 SYMBOL_ACLASS_INDEX (sym
) = LOC_OPTIMIZED_OUT
;
15901 /* Handle one degenerate form of location expression specially, to
15902 preserve GDB's previous behavior when section offsets are
15903 specified. If this is just a DW_OP_addr or DW_OP_GNU_addr_index
15904 then mark this symbol as LOC_STATIC. */
15906 if (attr_form_is_block (attr
)
15907 && ((DW_BLOCK (attr
)->data
[0] == DW_OP_addr
15908 && DW_BLOCK (attr
)->size
== 1 + cu_header
->addr_size
)
15909 || (DW_BLOCK (attr
)->data
[0] == DW_OP_GNU_addr_index
15910 && (DW_BLOCK (attr
)->size
15911 == 1 + leb128_size (&DW_BLOCK (attr
)->data
[1])))))
15913 unsigned int dummy
;
15915 if (DW_BLOCK (attr
)->data
[0] == DW_OP_addr
)
15916 SYMBOL_VALUE_ADDRESS (sym
) =
15917 read_address (objfile
->obfd
, DW_BLOCK (attr
)->data
+ 1, cu
, &dummy
);
15919 SYMBOL_VALUE_ADDRESS (sym
) =
15920 read_addr_index_from_leb128 (cu
, DW_BLOCK (attr
)->data
+ 1, &dummy
);
15921 SYMBOL_ACLASS_INDEX (sym
) = LOC_STATIC
;
15922 fixup_symbol_section (sym
, objfile
);
15923 SYMBOL_VALUE_ADDRESS (sym
) += ANOFFSET (objfile
->section_offsets
,
15924 SYMBOL_SECTION (sym
));
15928 /* NOTE drow/2002-01-30: It might be worthwhile to have a static
15929 expression evaluator, and use LOC_COMPUTED only when necessary
15930 (i.e. when the value of a register or memory location is
15931 referenced, or a thread-local block, etc.). Then again, it might
15932 not be worthwhile. I'm assuming that it isn't unless performance
15933 or memory numbers show me otherwise. */
15935 dwarf2_symbol_mark_computed (attr
, sym
, cu
, 0);
15937 if (SYMBOL_COMPUTED_OPS (sym
)->location_has_loclist
)
15938 cu
->has_loclist
= 1;
15941 /* Given a pointer to a DWARF information entry, figure out if we need
15942 to make a symbol table entry for it, and if so, create a new entry
15943 and return a pointer to it.
15944 If TYPE is NULL, determine symbol type from the die, otherwise
15945 used the passed type.
15946 If SPACE is not NULL, use it to hold the new symbol. If it is
15947 NULL, allocate a new symbol on the objfile's obstack. */
15949 static struct symbol
*
15950 new_symbol_full (struct die_info
*die
, struct type
*type
, struct dwarf2_cu
*cu
,
15951 struct symbol
*space
)
15953 struct objfile
*objfile
= cu
->objfile
;
15954 struct symbol
*sym
= NULL
;
15956 struct attribute
*attr
= NULL
;
15957 struct attribute
*attr2
= NULL
;
15958 CORE_ADDR baseaddr
;
15959 struct pending
**list_to_add
= NULL
;
15961 int inlined_func
= (die
->tag
== DW_TAG_inlined_subroutine
);
15963 baseaddr
= ANOFFSET (objfile
->section_offsets
, SECT_OFF_TEXT (objfile
));
15965 name
= dwarf2_name (die
, cu
);
15968 const char *linkagename
;
15969 int suppress_add
= 0;
15974 sym
= allocate_symbol (objfile
);
15975 OBJSTAT (objfile
, n_syms
++);
15977 /* Cache this symbol's name and the name's demangled form (if any). */
15978 SYMBOL_SET_LANGUAGE (sym
, cu
->language
, &objfile
->objfile_obstack
);
15979 linkagename
= dwarf2_physname (name
, die
, cu
);
15980 SYMBOL_SET_NAMES (sym
, linkagename
, strlen (linkagename
), 0, objfile
);
15982 /* Fortran does not have mangling standard and the mangling does differ
15983 between gfortran, iFort etc. */
15984 if (cu
->language
== language_fortran
15985 && symbol_get_demangled_name (&(sym
->ginfo
)) == NULL
)
15986 symbol_set_demangled_name (&(sym
->ginfo
),
15987 dwarf2_full_name (name
, die
, cu
),
15990 /* Default assumptions.
15991 Use the passed type or decode it from the die. */
15992 SYMBOL_DOMAIN (sym
) = VAR_DOMAIN
;
15993 SYMBOL_ACLASS_INDEX (sym
) = LOC_OPTIMIZED_OUT
;
15995 SYMBOL_TYPE (sym
) = type
;
15997 SYMBOL_TYPE (sym
) = die_type (die
, cu
);
15998 attr
= dwarf2_attr (die
,
15999 inlined_func
? DW_AT_call_line
: DW_AT_decl_line
,
16003 SYMBOL_LINE (sym
) = DW_UNSND (attr
);
16006 attr
= dwarf2_attr (die
,
16007 inlined_func
? DW_AT_call_file
: DW_AT_decl_file
,
16011 int file_index
= DW_UNSND (attr
);
16013 if (cu
->line_header
== NULL
16014 || file_index
> cu
->line_header
->num_file_names
)
16015 complaint (&symfile_complaints
,
16016 _("file index out of range"));
16017 else if (file_index
> 0)
16019 struct file_entry
*fe
;
16021 fe
= &cu
->line_header
->file_names
[file_index
- 1];
16022 SYMBOL_SYMTAB (sym
) = fe
->symtab
;
16029 attr
= dwarf2_attr (die
, DW_AT_low_pc
, cu
);
16032 SYMBOL_VALUE_ADDRESS (sym
) = DW_ADDR (attr
) + baseaddr
;
16034 SYMBOL_TYPE (sym
) = objfile_type (objfile
)->builtin_core_addr
;
16035 SYMBOL_DOMAIN (sym
) = LABEL_DOMAIN
;
16036 SYMBOL_ACLASS_INDEX (sym
) = LOC_LABEL
;
16037 add_symbol_to_list (sym
, cu
->list_in_scope
);
16039 case DW_TAG_subprogram
:
16040 /* SYMBOL_BLOCK_VALUE (sym) will be filled in later by
16042 SYMBOL_ACLASS_INDEX (sym
) = LOC_BLOCK
;
16043 attr2
= dwarf2_attr (die
, DW_AT_external
, cu
);
16044 if ((attr2
&& (DW_UNSND (attr2
) != 0))
16045 || cu
->language
== language_ada
)
16047 /* Subprograms marked external are stored as a global symbol.
16048 Ada subprograms, whether marked external or not, are always
16049 stored as a global symbol, because we want to be able to
16050 access them globally. For instance, we want to be able
16051 to break on a nested subprogram without having to
16052 specify the context. */
16053 list_to_add
= &global_symbols
;
16057 list_to_add
= cu
->list_in_scope
;
16060 case DW_TAG_inlined_subroutine
:
16061 /* SYMBOL_BLOCK_VALUE (sym) will be filled in later by
16063 SYMBOL_ACLASS_INDEX (sym
) = LOC_BLOCK
;
16064 SYMBOL_INLINED (sym
) = 1;
16065 list_to_add
= cu
->list_in_scope
;
16067 case DW_TAG_template_value_param
:
16069 /* Fall through. */
16070 case DW_TAG_constant
:
16071 case DW_TAG_variable
:
16072 case DW_TAG_member
:
16073 /* Compilation with minimal debug info may result in
16074 variables with missing type entries. Change the
16075 misleading `void' type to something sensible. */
16076 if (TYPE_CODE (SYMBOL_TYPE (sym
)) == TYPE_CODE_VOID
)
16078 = objfile_type (objfile
)->nodebug_data_symbol
;
16080 attr
= dwarf2_attr (die
, DW_AT_const_value
, cu
);
16081 /* In the case of DW_TAG_member, we should only be called for
16082 static const members. */
16083 if (die
->tag
== DW_TAG_member
)
16085 /* dwarf2_add_field uses die_is_declaration,
16086 so we do the same. */
16087 gdb_assert (die_is_declaration (die
, cu
));
16092 dwarf2_const_value (attr
, sym
, cu
);
16093 attr2
= dwarf2_attr (die
, DW_AT_external
, cu
);
16096 if (attr2
&& (DW_UNSND (attr2
) != 0))
16097 list_to_add
= &global_symbols
;
16099 list_to_add
= cu
->list_in_scope
;
16103 attr
= dwarf2_attr (die
, DW_AT_location
, cu
);
16106 var_decode_location (attr
, sym
, cu
);
16107 attr2
= dwarf2_attr (die
, DW_AT_external
, cu
);
16109 /* Fortran explicitly imports any global symbols to the local
16110 scope by DW_TAG_common_block. */
16111 if (cu
->language
== language_fortran
&& die
->parent
16112 && die
->parent
->tag
== DW_TAG_common_block
)
16115 if (SYMBOL_CLASS (sym
) == LOC_STATIC
16116 && SYMBOL_VALUE_ADDRESS (sym
) == 0
16117 && !dwarf2_per_objfile
->has_section_at_zero
)
16119 /* When a static variable is eliminated by the linker,
16120 the corresponding debug information is not stripped
16121 out, but the variable address is set to null;
16122 do not add such variables into symbol table. */
16124 else if (attr2
&& (DW_UNSND (attr2
) != 0))
16126 /* Workaround gfortran PR debug/40040 - it uses
16127 DW_AT_location for variables in -fPIC libraries which may
16128 get overriden by other libraries/executable and get
16129 a different address. Resolve it by the minimal symbol
16130 which may come from inferior's executable using copy
16131 relocation. Make this workaround only for gfortran as for
16132 other compilers GDB cannot guess the minimal symbol
16133 Fortran mangling kind. */
16134 if (cu
->language
== language_fortran
&& die
->parent
16135 && die
->parent
->tag
== DW_TAG_module
16137 && strncmp (cu
->producer
, "GNU Fortran ", 12) == 0)
16138 SYMBOL_ACLASS_INDEX (sym
) = LOC_UNRESOLVED
;
16140 /* A variable with DW_AT_external is never static,
16141 but it may be block-scoped. */
16142 list_to_add
= (cu
->list_in_scope
== &file_symbols
16143 ? &global_symbols
: cu
->list_in_scope
);
16146 list_to_add
= cu
->list_in_scope
;
16150 /* We do not know the address of this symbol.
16151 If it is an external symbol and we have type information
16152 for it, enter the symbol as a LOC_UNRESOLVED symbol.
16153 The address of the variable will then be determined from
16154 the minimal symbol table whenever the variable is
16156 attr2
= dwarf2_attr (die
, DW_AT_external
, cu
);
16158 /* Fortran explicitly imports any global symbols to the local
16159 scope by DW_TAG_common_block. */
16160 if (cu
->language
== language_fortran
&& die
->parent
16161 && die
->parent
->tag
== DW_TAG_common_block
)
16163 /* SYMBOL_CLASS doesn't matter here because
16164 read_common_block is going to reset it. */
16166 list_to_add
= cu
->list_in_scope
;
16168 else if (attr2
&& (DW_UNSND (attr2
) != 0)
16169 && dwarf2_attr (die
, DW_AT_type
, cu
) != NULL
)
16171 /* A variable with DW_AT_external is never static, but it
16172 may be block-scoped. */
16173 list_to_add
= (cu
->list_in_scope
== &file_symbols
16174 ? &global_symbols
: cu
->list_in_scope
);
16176 SYMBOL_ACLASS_INDEX (sym
) = LOC_UNRESOLVED
;
16178 else if (!die_is_declaration (die
, cu
))
16180 /* Use the default LOC_OPTIMIZED_OUT class. */
16181 gdb_assert (SYMBOL_CLASS (sym
) == LOC_OPTIMIZED_OUT
);
16183 list_to_add
= cu
->list_in_scope
;
16187 case DW_TAG_formal_parameter
:
16188 /* If we are inside a function, mark this as an argument. If
16189 not, we might be looking at an argument to an inlined function
16190 when we do not have enough information to show inlined frames;
16191 pretend it's a local variable in that case so that the user can
16193 if (context_stack_depth
> 0
16194 && context_stack
[context_stack_depth
- 1].name
!= NULL
)
16195 SYMBOL_IS_ARGUMENT (sym
) = 1;
16196 attr
= dwarf2_attr (die
, DW_AT_location
, cu
);
16199 var_decode_location (attr
, sym
, cu
);
16201 attr
= dwarf2_attr (die
, DW_AT_const_value
, cu
);
16204 dwarf2_const_value (attr
, sym
, cu
);
16207 list_to_add
= cu
->list_in_scope
;
16209 case DW_TAG_unspecified_parameters
:
16210 /* From varargs functions; gdb doesn't seem to have any
16211 interest in this information, so just ignore it for now.
16214 case DW_TAG_template_type_param
:
16216 /* Fall through. */
16217 case DW_TAG_class_type
:
16218 case DW_TAG_interface_type
:
16219 case DW_TAG_structure_type
:
16220 case DW_TAG_union_type
:
16221 case DW_TAG_set_type
:
16222 case DW_TAG_enumeration_type
:
16223 SYMBOL_ACLASS_INDEX (sym
) = LOC_TYPEDEF
;
16224 SYMBOL_DOMAIN (sym
) = STRUCT_DOMAIN
;
16227 /* NOTE: carlton/2003-11-10: C++ and Java class symbols shouldn't
16228 really ever be static objects: otherwise, if you try
16229 to, say, break of a class's method and you're in a file
16230 which doesn't mention that class, it won't work unless
16231 the check for all static symbols in lookup_symbol_aux
16232 saves you. See the OtherFileClass tests in
16233 gdb.c++/namespace.exp. */
16237 list_to_add
= (cu
->list_in_scope
== &file_symbols
16238 && (cu
->language
== language_cplus
16239 || cu
->language
== language_java
)
16240 ? &global_symbols
: cu
->list_in_scope
);
16242 /* The semantics of C++ state that "struct foo {
16243 ... }" also defines a typedef for "foo". A Java
16244 class declaration also defines a typedef for the
16246 if (cu
->language
== language_cplus
16247 || cu
->language
== language_java
16248 || cu
->language
== language_ada
)
16250 /* The symbol's name is already allocated along
16251 with this objfile, so we don't need to
16252 duplicate it for the type. */
16253 if (TYPE_NAME (SYMBOL_TYPE (sym
)) == 0)
16254 TYPE_NAME (SYMBOL_TYPE (sym
)) = SYMBOL_SEARCH_NAME (sym
);
16259 case DW_TAG_typedef
:
16260 SYMBOL_ACLASS_INDEX (sym
) = LOC_TYPEDEF
;
16261 SYMBOL_DOMAIN (sym
) = VAR_DOMAIN
;
16262 list_to_add
= cu
->list_in_scope
;
16264 case DW_TAG_base_type
:
16265 case DW_TAG_subrange_type
:
16266 SYMBOL_ACLASS_INDEX (sym
) = LOC_TYPEDEF
;
16267 SYMBOL_DOMAIN (sym
) = VAR_DOMAIN
;
16268 list_to_add
= cu
->list_in_scope
;
16270 case DW_TAG_enumerator
:
16271 attr
= dwarf2_attr (die
, DW_AT_const_value
, cu
);
16274 dwarf2_const_value (attr
, sym
, cu
);
16277 /* NOTE: carlton/2003-11-10: See comment above in the
16278 DW_TAG_class_type, etc. block. */
16280 list_to_add
= (cu
->list_in_scope
== &file_symbols
16281 && (cu
->language
== language_cplus
16282 || cu
->language
== language_java
)
16283 ? &global_symbols
: cu
->list_in_scope
);
16286 case DW_TAG_namespace
:
16287 SYMBOL_ACLASS_INDEX (sym
) = LOC_TYPEDEF
;
16288 list_to_add
= &global_symbols
;
16290 case DW_TAG_common_block
:
16291 SYMBOL_ACLASS_INDEX (sym
) = LOC_COMMON_BLOCK
;
16292 SYMBOL_DOMAIN (sym
) = COMMON_BLOCK_DOMAIN
;
16293 add_symbol_to_list (sym
, cu
->list_in_scope
);
16296 /* Not a tag we recognize. Hopefully we aren't processing
16297 trash data, but since we must specifically ignore things
16298 we don't recognize, there is nothing else we should do at
16300 complaint (&symfile_complaints
, _("unsupported tag: '%s'"),
16301 dwarf_tag_name (die
->tag
));
16307 sym
->hash_next
= objfile
->template_symbols
;
16308 objfile
->template_symbols
= sym
;
16309 list_to_add
= NULL
;
16312 if (list_to_add
!= NULL
)
16313 add_symbol_to_list (sym
, list_to_add
);
16315 /* For the benefit of old versions of GCC, check for anonymous
16316 namespaces based on the demangled name. */
16317 if (!cu
->processing_has_namespace_info
16318 && cu
->language
== language_cplus
)
16319 cp_scan_for_anonymous_namespaces (sym
, objfile
);
16324 /* A wrapper for new_symbol_full that always allocates a new symbol. */
16326 static struct symbol
*
16327 new_symbol (struct die_info
*die
, struct type
*type
, struct dwarf2_cu
*cu
)
16329 return new_symbol_full (die
, type
, cu
, NULL
);
16332 /* Given an attr with a DW_FORM_dataN value in host byte order,
16333 zero-extend it as appropriate for the symbol's type. The DWARF
16334 standard (v4) is not entirely clear about the meaning of using
16335 DW_FORM_dataN for a constant with a signed type, where the type is
16336 wider than the data. The conclusion of a discussion on the DWARF
16337 list was that this is unspecified. We choose to always zero-extend
16338 because that is the interpretation long in use by GCC. */
16341 dwarf2_const_value_data (struct attribute
*attr
, struct type
*type
,
16342 const char *name
, struct obstack
*obstack
,
16343 struct dwarf2_cu
*cu
, LONGEST
*value
, int bits
)
16345 struct objfile
*objfile
= cu
->objfile
;
16346 enum bfd_endian byte_order
= bfd_big_endian (objfile
->obfd
) ?
16347 BFD_ENDIAN_BIG
: BFD_ENDIAN_LITTLE
;
16348 LONGEST l
= DW_UNSND (attr
);
16350 if (bits
< sizeof (*value
) * 8)
16352 l
&= ((LONGEST
) 1 << bits
) - 1;
16355 else if (bits
== sizeof (*value
) * 8)
16359 gdb_byte
*bytes
= obstack_alloc (obstack
, bits
/ 8);
16360 store_unsigned_integer (bytes
, bits
/ 8, byte_order
, l
);
16367 /* Read a constant value from an attribute. Either set *VALUE, or if
16368 the value does not fit in *VALUE, set *BYTES - either already
16369 allocated on the objfile obstack, or newly allocated on OBSTACK,
16370 or, set *BATON, if we translated the constant to a location
16374 dwarf2_const_value_attr (struct attribute
*attr
, struct type
*type
,
16375 const char *name
, struct obstack
*obstack
,
16376 struct dwarf2_cu
*cu
,
16377 LONGEST
*value
, gdb_byte
**bytes
,
16378 struct dwarf2_locexpr_baton
**baton
)
16380 struct objfile
*objfile
= cu
->objfile
;
16381 struct comp_unit_head
*cu_header
= &cu
->header
;
16382 struct dwarf_block
*blk
;
16383 enum bfd_endian byte_order
= (bfd_big_endian (objfile
->obfd
) ?
16384 BFD_ENDIAN_BIG
: BFD_ENDIAN_LITTLE
);
16390 switch (attr
->form
)
16393 case DW_FORM_GNU_addr_index
:
16397 if (TYPE_LENGTH (type
) != cu_header
->addr_size
)
16398 dwarf2_const_value_length_mismatch_complaint (name
,
16399 cu_header
->addr_size
,
16400 TYPE_LENGTH (type
));
16401 /* Symbols of this form are reasonably rare, so we just
16402 piggyback on the existing location code rather than writing
16403 a new implementation of symbol_computed_ops. */
16404 *baton
= obstack_alloc (&objfile
->objfile_obstack
,
16405 sizeof (struct dwarf2_locexpr_baton
));
16406 (*baton
)->per_cu
= cu
->per_cu
;
16407 gdb_assert ((*baton
)->per_cu
);
16409 (*baton
)->size
= 2 + cu_header
->addr_size
;
16410 data
= obstack_alloc (&objfile
->objfile_obstack
, (*baton
)->size
);
16411 (*baton
)->data
= data
;
16413 data
[0] = DW_OP_addr
;
16414 store_unsigned_integer (&data
[1], cu_header
->addr_size
,
16415 byte_order
, DW_ADDR (attr
));
16416 data
[cu_header
->addr_size
+ 1] = DW_OP_stack_value
;
16419 case DW_FORM_string
:
16421 case DW_FORM_GNU_str_index
:
16422 case DW_FORM_GNU_strp_alt
:
16423 /* DW_STRING is already allocated on the objfile obstack, point
16425 *bytes
= (gdb_byte
*) DW_STRING (attr
);
16427 case DW_FORM_block1
:
16428 case DW_FORM_block2
:
16429 case DW_FORM_block4
:
16430 case DW_FORM_block
:
16431 case DW_FORM_exprloc
:
16432 blk
= DW_BLOCK (attr
);
16433 if (TYPE_LENGTH (type
) != blk
->size
)
16434 dwarf2_const_value_length_mismatch_complaint (name
, blk
->size
,
16435 TYPE_LENGTH (type
));
16436 *bytes
= blk
->data
;
16439 /* The DW_AT_const_value attributes are supposed to carry the
16440 symbol's value "represented as it would be on the target
16441 architecture." By the time we get here, it's already been
16442 converted to host endianness, so we just need to sign- or
16443 zero-extend it as appropriate. */
16444 case DW_FORM_data1
:
16445 *bytes
= dwarf2_const_value_data (attr
, type
, name
,
16446 obstack
, cu
, value
, 8);
16448 case DW_FORM_data2
:
16449 *bytes
= dwarf2_const_value_data (attr
, type
, name
,
16450 obstack
, cu
, value
, 16);
16452 case DW_FORM_data4
:
16453 *bytes
= dwarf2_const_value_data (attr
, type
, name
,
16454 obstack
, cu
, value
, 32);
16456 case DW_FORM_data8
:
16457 *bytes
= dwarf2_const_value_data (attr
, type
, name
,
16458 obstack
, cu
, value
, 64);
16461 case DW_FORM_sdata
:
16462 *value
= DW_SND (attr
);
16465 case DW_FORM_udata
:
16466 *value
= DW_UNSND (attr
);
16470 complaint (&symfile_complaints
,
16471 _("unsupported const value attribute form: '%s'"),
16472 dwarf_form_name (attr
->form
));
16479 /* Copy constant value from an attribute to a symbol. */
16482 dwarf2_const_value (struct attribute
*attr
, struct symbol
*sym
,
16483 struct dwarf2_cu
*cu
)
16485 struct objfile
*objfile
= cu
->objfile
;
16486 struct comp_unit_head
*cu_header
= &cu
->header
;
16489 struct dwarf2_locexpr_baton
*baton
;
16491 dwarf2_const_value_attr (attr
, SYMBOL_TYPE (sym
),
16492 SYMBOL_PRINT_NAME (sym
),
16493 &objfile
->objfile_obstack
, cu
,
16494 &value
, &bytes
, &baton
);
16498 SYMBOL_LOCATION_BATON (sym
) = baton
;
16499 SYMBOL_ACLASS_INDEX (sym
) = dwarf2_locexpr_index
;
16501 else if (bytes
!= NULL
)
16503 SYMBOL_VALUE_BYTES (sym
) = bytes
;
16504 SYMBOL_ACLASS_INDEX (sym
) = LOC_CONST_BYTES
;
16508 SYMBOL_VALUE (sym
) = value
;
16509 SYMBOL_ACLASS_INDEX (sym
) = LOC_CONST
;
16513 /* Return the type of the die in question using its DW_AT_type attribute. */
16515 static struct type
*
16516 die_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
16518 struct attribute
*type_attr
;
16520 type_attr
= dwarf2_attr (die
, DW_AT_type
, cu
);
16523 /* A missing DW_AT_type represents a void type. */
16524 return objfile_type (cu
->objfile
)->builtin_void
;
16527 return lookup_die_type (die
, type_attr
, cu
);
16530 /* True iff CU's producer generates GNAT Ada auxiliary information
16531 that allows to find parallel types through that information instead
16532 of having to do expensive parallel lookups by type name. */
16535 need_gnat_info (struct dwarf2_cu
*cu
)
16537 /* FIXME: brobecker/2010-10-12: As of now, only the AdaCore version
16538 of GNAT produces this auxiliary information, without any indication
16539 that it is produced. Part of enhancing the FSF version of GNAT
16540 to produce that information will be to put in place an indicator
16541 that we can use in order to determine whether the descriptive type
16542 info is available or not. One suggestion that has been made is
16543 to use a new attribute, attached to the CU die. For now, assume
16544 that the descriptive type info is not available. */
16548 /* Return the auxiliary type of the die in question using its
16549 DW_AT_GNAT_descriptive_type attribute. Returns NULL if the
16550 attribute is not present. */
16552 static struct type
*
16553 die_descriptive_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
16555 struct attribute
*type_attr
;
16557 type_attr
= dwarf2_attr (die
, DW_AT_GNAT_descriptive_type
, cu
);
16561 return lookup_die_type (die
, type_attr
, cu
);
16564 /* If DIE has a descriptive_type attribute, then set the TYPE's
16565 descriptive type accordingly. */
16568 set_descriptive_type (struct type
*type
, struct die_info
*die
,
16569 struct dwarf2_cu
*cu
)
16571 struct type
*descriptive_type
= die_descriptive_type (die
, cu
);
16573 if (descriptive_type
)
16575 ALLOCATE_GNAT_AUX_TYPE (type
);
16576 TYPE_DESCRIPTIVE_TYPE (type
) = descriptive_type
;
16580 /* Return the containing type of the die in question using its
16581 DW_AT_containing_type attribute. */
16583 static struct type
*
16584 die_containing_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
16586 struct attribute
*type_attr
;
16588 type_attr
= dwarf2_attr (die
, DW_AT_containing_type
, cu
);
16590 error (_("Dwarf Error: Problem turning containing type into gdb type "
16591 "[in module %s]"), cu
->objfile
->name
);
16593 return lookup_die_type (die
, type_attr
, cu
);
16596 /* Look up the type of DIE in CU using its type attribute ATTR.
16597 If there is no type substitute an error marker. */
16599 static struct type
*
16600 lookup_die_type (struct die_info
*die
, struct attribute
*attr
,
16601 struct dwarf2_cu
*cu
)
16603 struct objfile
*objfile
= cu
->objfile
;
16604 struct type
*this_type
;
16606 /* First see if we have it cached. */
16608 if (attr
->form
== DW_FORM_GNU_ref_alt
)
16610 struct dwarf2_per_cu_data
*per_cu
;
16611 sect_offset offset
= dwarf2_get_ref_die_offset (attr
);
16613 per_cu
= dwarf2_find_containing_comp_unit (offset
, 1, cu
->objfile
);
16614 this_type
= get_die_type_at_offset (offset
, per_cu
);
16616 else if (is_ref_attr (attr
))
16618 sect_offset offset
= dwarf2_get_ref_die_offset (attr
);
16620 this_type
= get_die_type_at_offset (offset
, cu
->per_cu
);
16622 else if (attr
->form
== DW_FORM_ref_sig8
)
16624 struct signatured_type
*sig_type
= DW_SIGNATURED_TYPE (attr
);
16626 /* sig_type will be NULL if the signatured type is missing from
16628 if (sig_type
== NULL
)
16629 error (_("Dwarf Error: Cannot find signatured DIE referenced from DIE "
16630 "at 0x%x [in module %s]"),
16631 die
->offset
.sect_off
, objfile
->name
);
16633 gdb_assert (sig_type
->per_cu
.is_debug_types
);
16634 /* If we haven't filled in type_offset_in_section yet, then we
16635 haven't read the type in yet. */
16637 if (sig_type
->type_offset_in_section
.sect_off
!= 0)
16640 get_die_type_at_offset (sig_type
->type_offset_in_section
,
16641 &sig_type
->per_cu
);
16646 dump_die_for_error (die
);
16647 error (_("Dwarf Error: Bad type attribute %s [in module %s]"),
16648 dwarf_attr_name (attr
->name
), objfile
->name
);
16651 /* If not cached we need to read it in. */
16653 if (this_type
== NULL
)
16655 struct die_info
*type_die
;
16656 struct dwarf2_cu
*type_cu
= cu
;
16658 type_die
= follow_die_ref_or_sig (die
, attr
, &type_cu
);
16659 /* If we found the type now, it's probably because the type came
16660 from an inter-CU reference and the type's CU got expanded before
16662 this_type
= get_die_type (type_die
, type_cu
);
16663 if (this_type
== NULL
)
16664 this_type
= read_type_die_1 (type_die
, type_cu
);
16667 /* If we still don't have a type use an error marker. */
16669 if (this_type
== NULL
)
16671 char *message
, *saved
;
16673 /* read_type_die already issued a complaint. */
16674 message
= xstrprintf (_("<unknown type in %s, CU 0x%x, DIE 0x%x>"),
16676 cu
->header
.offset
.sect_off
,
16677 die
->offset
.sect_off
);
16678 saved
= obstack_copy0 (&objfile
->objfile_obstack
,
16679 message
, strlen (message
));
16682 this_type
= init_type (TYPE_CODE_ERROR
, 0, 0, saved
, objfile
);
16688 /* Return the type in DIE, CU.
16689 Returns NULL for invalid types.
16691 This first does a lookup in die_type_hash,
16692 and only reads the die in if necessary.
16694 NOTE: This can be called when reading in partial or full symbols. */
16696 static struct type
*
16697 read_type_die (struct die_info
*die
, struct dwarf2_cu
*cu
)
16699 struct type
*this_type
;
16701 this_type
= get_die_type (die
, cu
);
16705 return read_type_die_1 (die
, cu
);
16708 /* Read the type in DIE, CU.
16709 Returns NULL for invalid types. */
16711 static struct type
*
16712 read_type_die_1 (struct die_info
*die
, struct dwarf2_cu
*cu
)
16714 struct type
*this_type
= NULL
;
16718 case DW_TAG_class_type
:
16719 case DW_TAG_interface_type
:
16720 case DW_TAG_structure_type
:
16721 case DW_TAG_union_type
:
16722 this_type
= read_structure_type (die
, cu
);
16724 case DW_TAG_enumeration_type
:
16725 this_type
= read_enumeration_type (die
, cu
);
16727 case DW_TAG_subprogram
:
16728 case DW_TAG_subroutine_type
:
16729 case DW_TAG_inlined_subroutine
:
16730 this_type
= read_subroutine_type (die
, cu
);
16732 case DW_TAG_array_type
:
16733 this_type
= read_array_type (die
, cu
);
16735 case DW_TAG_set_type
:
16736 this_type
= read_set_type (die
, cu
);
16738 case DW_TAG_pointer_type
:
16739 this_type
= read_tag_pointer_type (die
, cu
);
16741 case DW_TAG_ptr_to_member_type
:
16742 this_type
= read_tag_ptr_to_member_type (die
, cu
);
16744 case DW_TAG_reference_type
:
16745 this_type
= read_tag_reference_type (die
, cu
);
16747 case DW_TAG_const_type
:
16748 this_type
= read_tag_const_type (die
, cu
);
16750 case DW_TAG_volatile_type
:
16751 this_type
= read_tag_volatile_type (die
, cu
);
16753 case DW_TAG_restrict_type
:
16754 this_type
= read_tag_restrict_type (die
, cu
);
16756 case DW_TAG_string_type
:
16757 this_type
= read_tag_string_type (die
, cu
);
16759 case DW_TAG_typedef
:
16760 this_type
= read_typedef (die
, cu
);
16762 case DW_TAG_subrange_type
:
16763 this_type
= read_subrange_type (die
, cu
);
16765 case DW_TAG_base_type
:
16766 this_type
= read_base_type (die
, cu
);
16768 case DW_TAG_unspecified_type
:
16769 this_type
= read_unspecified_type (die
, cu
);
16771 case DW_TAG_namespace
:
16772 this_type
= read_namespace_type (die
, cu
);
16774 case DW_TAG_module
:
16775 this_type
= read_module_type (die
, cu
);
16778 complaint (&symfile_complaints
,
16779 _("unexpected tag in read_type_die: '%s'"),
16780 dwarf_tag_name (die
->tag
));
16787 /* See if we can figure out if the class lives in a namespace. We do
16788 this by looking for a member function; its demangled name will
16789 contain namespace info, if there is any.
16790 Return the computed name or NULL.
16791 Space for the result is allocated on the objfile's obstack.
16792 This is the full-die version of guess_partial_die_structure_name.
16793 In this case we know DIE has no useful parent. */
16796 guess_full_die_structure_name (struct die_info
*die
, struct dwarf2_cu
*cu
)
16798 struct die_info
*spec_die
;
16799 struct dwarf2_cu
*spec_cu
;
16800 struct die_info
*child
;
16803 spec_die
= die_specification (die
, &spec_cu
);
16804 if (spec_die
!= NULL
)
16810 for (child
= die
->child
;
16812 child
= child
->sibling
)
16814 if (child
->tag
== DW_TAG_subprogram
)
16816 struct attribute
*attr
;
16818 attr
= dwarf2_attr (child
, DW_AT_linkage_name
, cu
);
16820 attr
= dwarf2_attr (child
, DW_AT_MIPS_linkage_name
, cu
);
16824 = language_class_name_from_physname (cu
->language_defn
,
16828 if (actual_name
!= NULL
)
16830 const char *die_name
= dwarf2_name (die
, cu
);
16832 if (die_name
!= NULL
16833 && strcmp (die_name
, actual_name
) != 0)
16835 /* Strip off the class name from the full name.
16836 We want the prefix. */
16837 int die_name_len
= strlen (die_name
);
16838 int actual_name_len
= strlen (actual_name
);
16840 /* Test for '::' as a sanity check. */
16841 if (actual_name_len
> die_name_len
+ 2
16842 && actual_name
[actual_name_len
16843 - die_name_len
- 1] == ':')
16845 obstack_copy0 (&cu
->objfile
->objfile_obstack
,
16847 actual_name_len
- die_name_len
- 2);
16850 xfree (actual_name
);
16859 /* GCC might emit a nameless typedef that has a linkage name. Determine the
16860 prefix part in such case. See
16861 http://gcc.gnu.org/bugzilla/show_bug.cgi?id=47510. */
16864 anonymous_struct_prefix (struct die_info
*die
, struct dwarf2_cu
*cu
)
16866 struct attribute
*attr
;
16869 if (die
->tag
!= DW_TAG_class_type
&& die
->tag
!= DW_TAG_interface_type
16870 && die
->tag
!= DW_TAG_structure_type
&& die
->tag
!= DW_TAG_union_type
)
16873 attr
= dwarf2_attr (die
, DW_AT_name
, cu
);
16874 if (attr
!= NULL
&& DW_STRING (attr
) != NULL
)
16877 attr
= dwarf2_attr (die
, DW_AT_linkage_name
, cu
);
16879 attr
= dwarf2_attr (die
, DW_AT_MIPS_linkage_name
, cu
);
16880 if (attr
== NULL
|| DW_STRING (attr
) == NULL
)
16883 /* dwarf2_name had to be already called. */
16884 gdb_assert (DW_STRING_IS_CANONICAL (attr
));
16886 /* Strip the base name, keep any leading namespaces/classes. */
16887 base
= strrchr (DW_STRING (attr
), ':');
16888 if (base
== NULL
|| base
== DW_STRING (attr
) || base
[-1] != ':')
16891 return obstack_copy0 (&cu
->objfile
->objfile_obstack
,
16892 DW_STRING (attr
), &base
[-1] - DW_STRING (attr
));
16895 /* Return the name of the namespace/class that DIE is defined within,
16896 or "" if we can't tell. The caller should not xfree the result.
16898 For example, if we're within the method foo() in the following
16908 then determine_prefix on foo's die will return "N::C". */
16910 static const char *
16911 determine_prefix (struct die_info
*die
, struct dwarf2_cu
*cu
)
16913 struct die_info
*parent
, *spec_die
;
16914 struct dwarf2_cu
*spec_cu
;
16915 struct type
*parent_type
;
16918 if (cu
->language
!= language_cplus
&& cu
->language
!= language_java
16919 && cu
->language
!= language_fortran
)
16922 retval
= anonymous_struct_prefix (die
, cu
);
16926 /* We have to be careful in the presence of DW_AT_specification.
16927 For example, with GCC 3.4, given the code
16931 // Definition of N::foo.
16935 then we'll have a tree of DIEs like this:
16937 1: DW_TAG_compile_unit
16938 2: DW_TAG_namespace // N
16939 3: DW_TAG_subprogram // declaration of N::foo
16940 4: DW_TAG_subprogram // definition of N::foo
16941 DW_AT_specification // refers to die #3
16943 Thus, when processing die #4, we have to pretend that we're in
16944 the context of its DW_AT_specification, namely the contex of die
16947 spec_die
= die_specification (die
, &spec_cu
);
16948 if (spec_die
== NULL
)
16949 parent
= die
->parent
;
16952 parent
= spec_die
->parent
;
16956 if (parent
== NULL
)
16958 else if (parent
->building_fullname
)
16961 const char *parent_name
;
16963 /* It has been seen on RealView 2.2 built binaries,
16964 DW_TAG_template_type_param types actually _defined_ as
16965 children of the parent class:
16968 template class <class Enum> Class{};
16969 Class<enum E> class_e;
16971 1: DW_TAG_class_type (Class)
16972 2: DW_TAG_enumeration_type (E)
16973 3: DW_TAG_enumerator (enum1:0)
16974 3: DW_TAG_enumerator (enum2:1)
16976 2: DW_TAG_template_type_param
16977 DW_AT_type DW_FORM_ref_udata (E)
16979 Besides being broken debug info, it can put GDB into an
16980 infinite loop. Consider:
16982 When we're building the full name for Class<E>, we'll start
16983 at Class, and go look over its template type parameters,
16984 finding E. We'll then try to build the full name of E, and
16985 reach here. We're now trying to build the full name of E,
16986 and look over the parent DIE for containing scope. In the
16987 broken case, if we followed the parent DIE of E, we'd again
16988 find Class, and once again go look at its template type
16989 arguments, etc., etc. Simply don't consider such parent die
16990 as source-level parent of this die (it can't be, the language
16991 doesn't allow it), and break the loop here. */
16992 name
= dwarf2_name (die
, cu
);
16993 parent_name
= dwarf2_name (parent
, cu
);
16994 complaint (&symfile_complaints
,
16995 _("template param type '%s' defined within parent '%s'"),
16996 name
? name
: "<unknown>",
16997 parent_name
? parent_name
: "<unknown>");
17001 switch (parent
->tag
)
17003 case DW_TAG_namespace
:
17004 parent_type
= read_type_die (parent
, cu
);
17005 /* GCC 4.0 and 4.1 had a bug (PR c++/28460) where they generated bogus
17006 DW_TAG_namespace DIEs with a name of "::" for the global namespace.
17007 Work around this problem here. */
17008 if (cu
->language
== language_cplus
17009 && strcmp (TYPE_TAG_NAME (parent_type
), "::") == 0)
17011 /* We give a name to even anonymous namespaces. */
17012 return TYPE_TAG_NAME (parent_type
);
17013 case DW_TAG_class_type
:
17014 case DW_TAG_interface_type
:
17015 case DW_TAG_structure_type
:
17016 case DW_TAG_union_type
:
17017 case DW_TAG_module
:
17018 parent_type
= read_type_die (parent
, cu
);
17019 if (TYPE_TAG_NAME (parent_type
) != NULL
)
17020 return TYPE_TAG_NAME (parent_type
);
17022 /* An anonymous structure is only allowed non-static data
17023 members; no typedefs, no member functions, et cetera.
17024 So it does not need a prefix. */
17026 case DW_TAG_compile_unit
:
17027 case DW_TAG_partial_unit
:
17028 /* gcc-4.5 -gdwarf-4 can drop the enclosing namespace. Cope. */
17029 if (cu
->language
== language_cplus
17030 && !VEC_empty (dwarf2_section_info_def
, dwarf2_per_objfile
->types
)
17031 && die
->child
!= NULL
17032 && (die
->tag
== DW_TAG_class_type
17033 || die
->tag
== DW_TAG_structure_type
17034 || die
->tag
== DW_TAG_union_type
))
17036 char *name
= guess_full_die_structure_name (die
, cu
);
17042 return determine_prefix (parent
, cu
);
17046 /* Return a newly-allocated string formed by concatenating PREFIX and SUFFIX
17047 with appropriate separator. If PREFIX or SUFFIX is NULL or empty, then
17048 simply copy the SUFFIX or PREFIX, respectively. If OBS is non-null, perform
17049 an obconcat, otherwise allocate storage for the result. The CU argument is
17050 used to determine the language and hence, the appropriate separator. */
17052 #define MAX_SEP_LEN 7 /* strlen ("__") + strlen ("_MOD_") */
17055 typename_concat (struct obstack
*obs
, const char *prefix
, const char *suffix
,
17056 int physname
, struct dwarf2_cu
*cu
)
17058 const char *lead
= "";
17061 if (suffix
== NULL
|| suffix
[0] == '\0'
17062 || prefix
== NULL
|| prefix
[0] == '\0')
17064 else if (cu
->language
== language_java
)
17066 else if (cu
->language
== language_fortran
&& physname
)
17068 /* This is gfortran specific mangling. Normally DW_AT_linkage_name or
17069 DW_AT_MIPS_linkage_name is preferred and used instead. */
17077 if (prefix
== NULL
)
17079 if (suffix
== NULL
)
17085 = xmalloc (strlen (prefix
) + MAX_SEP_LEN
+ strlen (suffix
) + 1);
17087 strcpy (retval
, lead
);
17088 strcat (retval
, prefix
);
17089 strcat (retval
, sep
);
17090 strcat (retval
, suffix
);
17095 /* We have an obstack. */
17096 return obconcat (obs
, lead
, prefix
, sep
, suffix
, (char *) NULL
);
17100 /* Return sibling of die, NULL if no sibling. */
17102 static struct die_info
*
17103 sibling_die (struct die_info
*die
)
17105 return die
->sibling
;
17108 /* Get name of a die, return NULL if not found. */
17110 static const char *
17111 dwarf2_canonicalize_name (const char *name
, struct dwarf2_cu
*cu
,
17112 struct obstack
*obstack
)
17114 if (name
&& cu
->language
== language_cplus
)
17116 char *canon_name
= cp_canonicalize_string (name
);
17118 if (canon_name
!= NULL
)
17120 if (strcmp (canon_name
, name
) != 0)
17121 name
= obstack_copy0 (obstack
, canon_name
, strlen (canon_name
));
17122 xfree (canon_name
);
17129 /* Get name of a die, return NULL if not found. */
17131 static const char *
17132 dwarf2_name (struct die_info
*die
, struct dwarf2_cu
*cu
)
17134 struct attribute
*attr
;
17136 attr
= dwarf2_attr (die
, DW_AT_name
, cu
);
17137 if ((!attr
|| !DW_STRING (attr
))
17138 && die
->tag
!= DW_TAG_class_type
17139 && die
->tag
!= DW_TAG_interface_type
17140 && die
->tag
!= DW_TAG_structure_type
17141 && die
->tag
!= DW_TAG_union_type
)
17146 case DW_TAG_compile_unit
:
17147 case DW_TAG_partial_unit
:
17148 /* Compilation units have a DW_AT_name that is a filename, not
17149 a source language identifier. */
17150 case DW_TAG_enumeration_type
:
17151 case DW_TAG_enumerator
:
17152 /* These tags always have simple identifiers already; no need
17153 to canonicalize them. */
17154 return DW_STRING (attr
);
17156 case DW_TAG_subprogram
:
17157 /* Java constructors will all be named "<init>", so return
17158 the class name when we see this special case. */
17159 if (cu
->language
== language_java
17160 && DW_STRING (attr
) != NULL
17161 && strcmp (DW_STRING (attr
), "<init>") == 0)
17163 struct dwarf2_cu
*spec_cu
= cu
;
17164 struct die_info
*spec_die
;
17166 /* GCJ will output '<init>' for Java constructor names.
17167 For this special case, return the name of the parent class. */
17169 /* GCJ may output suprogram DIEs with AT_specification set.
17170 If so, use the name of the specified DIE. */
17171 spec_die
= die_specification (die
, &spec_cu
);
17172 if (spec_die
!= NULL
)
17173 return dwarf2_name (spec_die
, spec_cu
);
17178 if (die
->tag
== DW_TAG_class_type
)
17179 return dwarf2_name (die
, cu
);
17181 while (die
->tag
!= DW_TAG_compile_unit
17182 && die
->tag
!= DW_TAG_partial_unit
);
17186 case DW_TAG_class_type
:
17187 case DW_TAG_interface_type
:
17188 case DW_TAG_structure_type
:
17189 case DW_TAG_union_type
:
17190 /* Some GCC versions emit spurious DW_AT_name attributes for unnamed
17191 structures or unions. These were of the form "._%d" in GCC 4.1,
17192 or simply "<anonymous struct>" or "<anonymous union>" in GCC 4.3
17193 and GCC 4.4. We work around this problem by ignoring these. */
17194 if (attr
&& DW_STRING (attr
)
17195 && (strncmp (DW_STRING (attr
), "._", 2) == 0
17196 || strncmp (DW_STRING (attr
), "<anonymous", 10) == 0))
17199 /* GCC might emit a nameless typedef that has a linkage name. See
17200 http://gcc.gnu.org/bugzilla/show_bug.cgi?id=47510. */
17201 if (!attr
|| DW_STRING (attr
) == NULL
)
17203 char *demangled
= NULL
;
17205 attr
= dwarf2_attr (die
, DW_AT_linkage_name
, cu
);
17207 attr
= dwarf2_attr (die
, DW_AT_MIPS_linkage_name
, cu
);
17209 if (attr
== NULL
|| DW_STRING (attr
) == NULL
)
17212 /* Avoid demangling DW_STRING (attr) the second time on a second
17213 call for the same DIE. */
17214 if (!DW_STRING_IS_CANONICAL (attr
))
17215 demangled
= cplus_demangle (DW_STRING (attr
), DMGL_TYPES
);
17221 /* FIXME: we already did this for the partial symbol... */
17222 DW_STRING (attr
) = obstack_copy0 (&cu
->objfile
->objfile_obstack
,
17223 demangled
, strlen (demangled
));
17224 DW_STRING_IS_CANONICAL (attr
) = 1;
17227 /* Strip any leading namespaces/classes, keep only the base name.
17228 DW_AT_name for named DIEs does not contain the prefixes. */
17229 base
= strrchr (DW_STRING (attr
), ':');
17230 if (base
&& base
> DW_STRING (attr
) && base
[-1] == ':')
17233 return DW_STRING (attr
);
17242 if (!DW_STRING_IS_CANONICAL (attr
))
17245 = dwarf2_canonicalize_name (DW_STRING (attr
), cu
,
17246 &cu
->objfile
->objfile_obstack
);
17247 DW_STRING_IS_CANONICAL (attr
) = 1;
17249 return DW_STRING (attr
);
17252 /* Return the die that this die in an extension of, or NULL if there
17253 is none. *EXT_CU is the CU containing DIE on input, and the CU
17254 containing the return value on output. */
17256 static struct die_info
*
17257 dwarf2_extension (struct die_info
*die
, struct dwarf2_cu
**ext_cu
)
17259 struct attribute
*attr
;
17261 attr
= dwarf2_attr (die
, DW_AT_extension
, *ext_cu
);
17265 return follow_die_ref (die
, attr
, ext_cu
);
17268 /* Convert a DIE tag into its string name. */
17270 static const char *
17271 dwarf_tag_name (unsigned tag
)
17273 const char *name
= get_DW_TAG_name (tag
);
17276 return "DW_TAG_<unknown>";
17281 /* Convert a DWARF attribute code into its string name. */
17283 static const char *
17284 dwarf_attr_name (unsigned attr
)
17288 #ifdef MIPS /* collides with DW_AT_HP_block_index */
17289 if (attr
== DW_AT_MIPS_fde
)
17290 return "DW_AT_MIPS_fde";
17292 if (attr
== DW_AT_HP_block_index
)
17293 return "DW_AT_HP_block_index";
17296 name
= get_DW_AT_name (attr
);
17299 return "DW_AT_<unknown>";
17304 /* Convert a DWARF value form code into its string name. */
17306 static const char *
17307 dwarf_form_name (unsigned form
)
17309 const char *name
= get_DW_FORM_name (form
);
17312 return "DW_FORM_<unknown>";
17318 dwarf_bool_name (unsigned mybool
)
17326 /* Convert a DWARF type code into its string name. */
17328 static const char *
17329 dwarf_type_encoding_name (unsigned enc
)
17331 const char *name
= get_DW_ATE_name (enc
);
17334 return "DW_ATE_<unknown>";
17340 dump_die_shallow (struct ui_file
*f
, int indent
, struct die_info
*die
)
17344 print_spaces (indent
, f
);
17345 fprintf_unfiltered (f
, "Die: %s (abbrev %d, offset 0x%x)\n",
17346 dwarf_tag_name (die
->tag
), die
->abbrev
, die
->offset
.sect_off
);
17348 if (die
->parent
!= NULL
)
17350 print_spaces (indent
, f
);
17351 fprintf_unfiltered (f
, " parent at offset: 0x%x\n",
17352 die
->parent
->offset
.sect_off
);
17355 print_spaces (indent
, f
);
17356 fprintf_unfiltered (f
, " has children: %s\n",
17357 dwarf_bool_name (die
->child
!= NULL
));
17359 print_spaces (indent
, f
);
17360 fprintf_unfiltered (f
, " attributes:\n");
17362 for (i
= 0; i
< die
->num_attrs
; ++i
)
17364 print_spaces (indent
, f
);
17365 fprintf_unfiltered (f
, " %s (%s) ",
17366 dwarf_attr_name (die
->attrs
[i
].name
),
17367 dwarf_form_name (die
->attrs
[i
].form
));
17369 switch (die
->attrs
[i
].form
)
17372 case DW_FORM_GNU_addr_index
:
17373 fprintf_unfiltered (f
, "address: ");
17374 fputs_filtered (hex_string (DW_ADDR (&die
->attrs
[i
])), f
);
17376 case DW_FORM_block2
:
17377 case DW_FORM_block4
:
17378 case DW_FORM_block
:
17379 case DW_FORM_block1
:
17380 fprintf_unfiltered (f
, "block: size %s",
17381 pulongest (DW_BLOCK (&die
->attrs
[i
])->size
));
17383 case DW_FORM_exprloc
:
17384 fprintf_unfiltered (f
, "expression: size %s",
17385 pulongest (DW_BLOCK (&die
->attrs
[i
])->size
));
17387 case DW_FORM_ref_addr
:
17388 fprintf_unfiltered (f
, "ref address: ");
17389 fputs_filtered (hex_string (DW_UNSND (&die
->attrs
[i
])), f
);
17391 case DW_FORM_GNU_ref_alt
:
17392 fprintf_unfiltered (f
, "alt ref address: ");
17393 fputs_filtered (hex_string (DW_UNSND (&die
->attrs
[i
])), f
);
17399 case DW_FORM_ref_udata
:
17400 fprintf_unfiltered (f
, "constant ref: 0x%lx (adjusted)",
17401 (long) (DW_UNSND (&die
->attrs
[i
])));
17403 case DW_FORM_data1
:
17404 case DW_FORM_data2
:
17405 case DW_FORM_data4
:
17406 case DW_FORM_data8
:
17407 case DW_FORM_udata
:
17408 case DW_FORM_sdata
:
17409 fprintf_unfiltered (f
, "constant: %s",
17410 pulongest (DW_UNSND (&die
->attrs
[i
])));
17412 case DW_FORM_sec_offset
:
17413 fprintf_unfiltered (f
, "section offset: %s",
17414 pulongest (DW_UNSND (&die
->attrs
[i
])));
17416 case DW_FORM_ref_sig8
:
17417 if (DW_SIGNATURED_TYPE (&die
->attrs
[i
]) != NULL
)
17419 struct signatured_type
*sig_type
=
17420 DW_SIGNATURED_TYPE (&die
->attrs
[i
]);
17422 fprintf_unfiltered (f
, "signatured type: 0x%s, offset 0x%x",
17423 hex_string (sig_type
->signature
),
17424 sig_type
->per_cu
.offset
.sect_off
);
17427 fprintf_unfiltered (f
, "signatured type, unknown");
17429 case DW_FORM_string
:
17431 case DW_FORM_GNU_str_index
:
17432 case DW_FORM_GNU_strp_alt
:
17433 fprintf_unfiltered (f
, "string: \"%s\" (%s canonicalized)",
17434 DW_STRING (&die
->attrs
[i
])
17435 ? DW_STRING (&die
->attrs
[i
]) : "",
17436 DW_STRING_IS_CANONICAL (&die
->attrs
[i
]) ? "is" : "not");
17439 if (DW_UNSND (&die
->attrs
[i
]))
17440 fprintf_unfiltered (f
, "flag: TRUE");
17442 fprintf_unfiltered (f
, "flag: FALSE");
17444 case DW_FORM_flag_present
:
17445 fprintf_unfiltered (f
, "flag: TRUE");
17447 case DW_FORM_indirect
:
17448 /* The reader will have reduced the indirect form to
17449 the "base form" so this form should not occur. */
17450 fprintf_unfiltered (f
,
17451 "unexpected attribute form: DW_FORM_indirect");
17454 fprintf_unfiltered (f
, "unsupported attribute form: %d.",
17455 die
->attrs
[i
].form
);
17458 fprintf_unfiltered (f
, "\n");
17463 dump_die_for_error (struct die_info
*die
)
17465 dump_die_shallow (gdb_stderr
, 0, die
);
17469 dump_die_1 (struct ui_file
*f
, int level
, int max_level
, struct die_info
*die
)
17471 int indent
= level
* 4;
17473 gdb_assert (die
!= NULL
);
17475 if (level
>= max_level
)
17478 dump_die_shallow (f
, indent
, die
);
17480 if (die
->child
!= NULL
)
17482 print_spaces (indent
, f
);
17483 fprintf_unfiltered (f
, " Children:");
17484 if (level
+ 1 < max_level
)
17486 fprintf_unfiltered (f
, "\n");
17487 dump_die_1 (f
, level
+ 1, max_level
, die
->child
);
17491 fprintf_unfiltered (f
,
17492 " [not printed, max nesting level reached]\n");
17496 if (die
->sibling
!= NULL
&& level
> 0)
17498 dump_die_1 (f
, level
, max_level
, die
->sibling
);
17502 /* This is called from the pdie macro in gdbinit.in.
17503 It's not static so gcc will keep a copy callable from gdb. */
17506 dump_die (struct die_info
*die
, int max_level
)
17508 dump_die_1 (gdb_stdlog
, 0, max_level
, die
);
17512 store_in_ref_table (struct die_info
*die
, struct dwarf2_cu
*cu
)
17516 slot
= htab_find_slot_with_hash (cu
->die_hash
, die
, die
->offset
.sect_off
,
17522 /* DW_ADDR is always stored already as sect_offset; despite for the forms
17523 besides DW_FORM_ref_addr it is stored as cu_offset in the DWARF file. */
17526 is_ref_attr (struct attribute
*attr
)
17528 switch (attr
->form
)
17530 case DW_FORM_ref_addr
:
17535 case DW_FORM_ref_udata
:
17536 case DW_FORM_GNU_ref_alt
:
17543 /* Return DIE offset of ATTR. Return 0 with complaint if ATTR is not of the
17547 dwarf2_get_ref_die_offset (struct attribute
*attr
)
17549 sect_offset retval
= { DW_UNSND (attr
) };
17551 if (is_ref_attr (attr
))
17554 retval
.sect_off
= 0;
17555 complaint (&symfile_complaints
,
17556 _("unsupported die ref attribute form: '%s'"),
17557 dwarf_form_name (attr
->form
));
17561 /* Return the constant value held by ATTR. Return DEFAULT_VALUE if
17562 * the value held by the attribute is not constant. */
17565 dwarf2_get_attr_constant_value (struct attribute
*attr
, int default_value
)
17567 if (attr
->form
== DW_FORM_sdata
)
17568 return DW_SND (attr
);
17569 else if (attr
->form
== DW_FORM_udata
17570 || attr
->form
== DW_FORM_data1
17571 || attr
->form
== DW_FORM_data2
17572 || attr
->form
== DW_FORM_data4
17573 || attr
->form
== DW_FORM_data8
)
17574 return DW_UNSND (attr
);
17577 complaint (&symfile_complaints
,
17578 _("Attribute value is not a constant (%s)"),
17579 dwarf_form_name (attr
->form
));
17580 return default_value
;
17584 /* Follow reference or signature attribute ATTR of SRC_DIE.
17585 On entry *REF_CU is the CU of SRC_DIE.
17586 On exit *REF_CU is the CU of the result. */
17588 static struct die_info
*
17589 follow_die_ref_or_sig (struct die_info
*src_die
, struct attribute
*attr
,
17590 struct dwarf2_cu
**ref_cu
)
17592 struct die_info
*die
;
17594 if (is_ref_attr (attr
))
17595 die
= follow_die_ref (src_die
, attr
, ref_cu
);
17596 else if (attr
->form
== DW_FORM_ref_sig8
)
17597 die
= follow_die_sig (src_die
, attr
, ref_cu
);
17600 dump_die_for_error (src_die
);
17601 error (_("Dwarf Error: Expected reference attribute [in module %s]"),
17602 (*ref_cu
)->objfile
->name
);
17608 /* Follow reference OFFSET.
17609 On entry *REF_CU is the CU of the source die referencing OFFSET.
17610 On exit *REF_CU is the CU of the result.
17611 Returns NULL if OFFSET is invalid. */
17613 static struct die_info
*
17614 follow_die_offset (sect_offset offset
, int offset_in_dwz
,
17615 struct dwarf2_cu
**ref_cu
)
17617 struct die_info temp_die
;
17618 struct dwarf2_cu
*target_cu
, *cu
= *ref_cu
;
17620 gdb_assert (cu
->per_cu
!= NULL
);
17624 if (cu
->per_cu
->is_debug_types
)
17626 /* .debug_types CUs cannot reference anything outside their CU.
17627 If they need to, they have to reference a signatured type via
17628 DW_FORM_ref_sig8. */
17629 if (! offset_in_cu_p (&cu
->header
, offset
))
17632 else if (offset_in_dwz
!= cu
->per_cu
->is_dwz
17633 || ! offset_in_cu_p (&cu
->header
, offset
))
17635 struct dwarf2_per_cu_data
*per_cu
;
17637 per_cu
= dwarf2_find_containing_comp_unit (offset
, offset_in_dwz
,
17640 /* If necessary, add it to the queue and load its DIEs. */
17641 if (maybe_queue_comp_unit (cu
, per_cu
, cu
->language
))
17642 load_full_comp_unit (per_cu
, cu
->language
);
17644 target_cu
= per_cu
->cu
;
17646 else if (cu
->dies
== NULL
)
17648 /* We're loading full DIEs during partial symbol reading. */
17649 gdb_assert (dwarf2_per_objfile
->reading_partial_symbols
);
17650 load_full_comp_unit (cu
->per_cu
, language_minimal
);
17653 *ref_cu
= target_cu
;
17654 temp_die
.offset
= offset
;
17655 return htab_find_with_hash (target_cu
->die_hash
, &temp_die
, offset
.sect_off
);
17658 /* Follow reference attribute ATTR of SRC_DIE.
17659 On entry *REF_CU is the CU of SRC_DIE.
17660 On exit *REF_CU is the CU of the result. */
17662 static struct die_info
*
17663 follow_die_ref (struct die_info
*src_die
, struct attribute
*attr
,
17664 struct dwarf2_cu
**ref_cu
)
17666 sect_offset offset
= dwarf2_get_ref_die_offset (attr
);
17667 struct dwarf2_cu
*cu
= *ref_cu
;
17668 struct die_info
*die
;
17670 die
= follow_die_offset (offset
,
17671 (attr
->form
== DW_FORM_GNU_ref_alt
17672 || cu
->per_cu
->is_dwz
),
17675 error (_("Dwarf Error: Cannot find DIE at 0x%x referenced from DIE "
17676 "at 0x%x [in module %s]"),
17677 offset
.sect_off
, src_die
->offset
.sect_off
, cu
->objfile
->name
);
17682 /* Return DWARF block referenced by DW_AT_location of DIE at OFFSET at PER_CU.
17683 Returned value is intended for DW_OP_call*. Returned
17684 dwarf2_locexpr_baton->data has lifetime of PER_CU->OBJFILE. */
17686 struct dwarf2_locexpr_baton
17687 dwarf2_fetch_die_loc_sect_off (sect_offset offset
,
17688 struct dwarf2_per_cu_data
*per_cu
,
17689 CORE_ADDR (*get_frame_pc
) (void *baton
),
17692 struct dwarf2_cu
*cu
;
17693 struct die_info
*die
;
17694 struct attribute
*attr
;
17695 struct dwarf2_locexpr_baton retval
;
17697 dw2_setup (per_cu
->objfile
);
17699 if (per_cu
->cu
== NULL
)
17703 die
= follow_die_offset (offset
, per_cu
->is_dwz
, &cu
);
17705 error (_("Dwarf Error: Cannot find DIE at 0x%x referenced in module %s"),
17706 offset
.sect_off
, per_cu
->objfile
->name
);
17708 attr
= dwarf2_attr (die
, DW_AT_location
, cu
);
17711 /* DWARF: "If there is no such attribute, then there is no effect.".
17712 DATA is ignored if SIZE is 0. */
17714 retval
.data
= NULL
;
17717 else if (attr_form_is_section_offset (attr
))
17719 struct dwarf2_loclist_baton loclist_baton
;
17720 CORE_ADDR pc
= (*get_frame_pc
) (baton
);
17723 fill_in_loclist_baton (cu
, &loclist_baton
, attr
);
17725 retval
.data
= dwarf2_find_location_expression (&loclist_baton
,
17727 retval
.size
= size
;
17731 if (!attr_form_is_block (attr
))
17732 error (_("Dwarf Error: DIE at 0x%x referenced in module %s "
17733 "is neither DW_FORM_block* nor DW_FORM_exprloc"),
17734 offset
.sect_off
, per_cu
->objfile
->name
);
17736 retval
.data
= DW_BLOCK (attr
)->data
;
17737 retval
.size
= DW_BLOCK (attr
)->size
;
17739 retval
.per_cu
= cu
->per_cu
;
17741 age_cached_comp_units ();
17746 /* Like dwarf2_fetch_die_loc_sect_off, but take a CU
17749 struct dwarf2_locexpr_baton
17750 dwarf2_fetch_die_loc_cu_off (cu_offset offset_in_cu
,
17751 struct dwarf2_per_cu_data
*per_cu
,
17752 CORE_ADDR (*get_frame_pc
) (void *baton
),
17755 sect_offset offset
= { per_cu
->offset
.sect_off
+ offset_in_cu
.cu_off
};
17757 return dwarf2_fetch_die_loc_sect_off (offset
, per_cu
, get_frame_pc
, baton
);
17760 /* Return the type of the DIE at DIE_OFFSET in the CU named by
17764 dwarf2_get_die_type (cu_offset die_offset
,
17765 struct dwarf2_per_cu_data
*per_cu
)
17767 sect_offset die_offset_sect
;
17769 dw2_setup (per_cu
->objfile
);
17771 die_offset_sect
.sect_off
= per_cu
->offset
.sect_off
+ die_offset
.cu_off
;
17772 return get_die_type_at_offset (die_offset_sect
, per_cu
);
17775 /* Follow the signature attribute ATTR in SRC_DIE.
17776 On entry *REF_CU is the CU of SRC_DIE.
17777 On exit *REF_CU is the CU of the result. */
17779 static struct die_info
*
17780 follow_die_sig (struct die_info
*src_die
, struct attribute
*attr
,
17781 struct dwarf2_cu
**ref_cu
)
17783 struct objfile
*objfile
= (*ref_cu
)->objfile
;
17784 struct die_info temp_die
;
17785 struct signatured_type
*sig_type
= DW_SIGNATURED_TYPE (attr
);
17786 struct dwarf2_cu
*sig_cu
;
17787 struct die_info
*die
;
17789 /* sig_type will be NULL if the signatured type is missing from
17791 if (sig_type
== NULL
)
17792 error (_("Dwarf Error: Cannot find signatured DIE referenced from DIE "
17793 "at 0x%x [in module %s]"),
17794 src_die
->offset
.sect_off
, objfile
->name
);
17796 /* If necessary, add it to the queue and load its DIEs. */
17798 if (maybe_queue_comp_unit (*ref_cu
, &sig_type
->per_cu
, language_minimal
))
17799 read_signatured_type (sig_type
);
17801 gdb_assert (sig_type
->per_cu
.cu
!= NULL
);
17803 sig_cu
= sig_type
->per_cu
.cu
;
17804 gdb_assert (sig_type
->type_offset_in_section
.sect_off
!= 0);
17805 temp_die
.offset
= sig_type
->type_offset_in_section
;
17806 die
= htab_find_with_hash (sig_cu
->die_hash
, &temp_die
,
17807 temp_die
.offset
.sect_off
);
17810 /* For .gdb_index version 7 keep track of included TUs.
17811 http://sourceware.org/bugzilla/show_bug.cgi?id=15021. */
17812 if (dwarf2_per_objfile
->index_table
!= NULL
17813 && dwarf2_per_objfile
->index_table
->version
<= 7)
17815 VEC_safe_push (dwarf2_per_cu_ptr
,
17816 (*ref_cu
)->per_cu
->imported_symtabs
,
17824 error (_("Dwarf Error: Cannot find signatured DIE at 0x%x referenced "
17825 "from DIE at 0x%x [in module %s]"),
17826 temp_die
.offset
.sect_off
, src_die
->offset
.sect_off
, objfile
->name
);
17829 /* Load the DIEs associated with type unit PER_CU into memory. */
17832 load_full_type_unit (struct dwarf2_per_cu_data
*per_cu
)
17834 struct signatured_type
*sig_type
;
17836 /* Caller is responsible for ensuring type_unit_groups don't get here. */
17837 gdb_assert (! IS_TYPE_UNIT_GROUP (per_cu
));
17839 /* We have the per_cu, but we need the signatured_type.
17840 Fortunately this is an easy translation. */
17841 gdb_assert (per_cu
->is_debug_types
);
17842 sig_type
= (struct signatured_type
*) per_cu
;
17844 gdb_assert (per_cu
->cu
== NULL
);
17846 read_signatured_type (sig_type
);
17848 gdb_assert (per_cu
->cu
!= NULL
);
17851 /* die_reader_func for read_signatured_type.
17852 This is identical to load_full_comp_unit_reader,
17853 but is kept separate for now. */
17856 read_signatured_type_reader (const struct die_reader_specs
*reader
,
17857 gdb_byte
*info_ptr
,
17858 struct die_info
*comp_unit_die
,
17862 struct dwarf2_cu
*cu
= reader
->cu
;
17864 gdb_assert (cu
->die_hash
== NULL
);
17866 htab_create_alloc_ex (cu
->header
.length
/ 12,
17870 &cu
->comp_unit_obstack
,
17871 hashtab_obstack_allocate
,
17872 dummy_obstack_deallocate
);
17875 comp_unit_die
->child
= read_die_and_siblings (reader
, info_ptr
,
17876 &info_ptr
, comp_unit_die
);
17877 cu
->dies
= comp_unit_die
;
17878 /* comp_unit_die is not stored in die_hash, no need. */
17880 /* We try not to read any attributes in this function, because not
17881 all CUs needed for references have been loaded yet, and symbol
17882 table processing isn't initialized. But we have to set the CU language,
17883 or we won't be able to build types correctly.
17884 Similarly, if we do not read the producer, we can not apply
17885 producer-specific interpretation. */
17886 prepare_one_comp_unit (cu
, cu
->dies
, language_minimal
);
17889 /* Read in a signatured type and build its CU and DIEs.
17890 If the type is a stub for the real type in a DWO file,
17891 read in the real type from the DWO file as well. */
17894 read_signatured_type (struct signatured_type
*sig_type
)
17896 struct dwarf2_per_cu_data
*per_cu
= &sig_type
->per_cu
;
17898 gdb_assert (per_cu
->is_debug_types
);
17899 gdb_assert (per_cu
->cu
== NULL
);
17901 init_cutu_and_read_dies (per_cu
, NULL
, 0, 1,
17902 read_signatured_type_reader
, NULL
);
17905 /* Decode simple location descriptions.
17906 Given a pointer to a dwarf block that defines a location, compute
17907 the location and return the value.
17909 NOTE drow/2003-11-18: This function is called in two situations
17910 now: for the address of static or global variables (partial symbols
17911 only) and for offsets into structures which are expected to be
17912 (more or less) constant. The partial symbol case should go away,
17913 and only the constant case should remain. That will let this
17914 function complain more accurately. A few special modes are allowed
17915 without complaint for global variables (for instance, global
17916 register values and thread-local values).
17918 A location description containing no operations indicates that the
17919 object is optimized out. The return value is 0 for that case.
17920 FIXME drow/2003-11-16: No callers check for this case any more; soon all
17921 callers will only want a very basic result and this can become a
17924 Note that stack[0] is unused except as a default error return. */
17927 decode_locdesc (struct dwarf_block
*blk
, struct dwarf2_cu
*cu
)
17929 struct objfile
*objfile
= cu
->objfile
;
17931 size_t size
= blk
->size
;
17932 gdb_byte
*data
= blk
->data
;
17933 CORE_ADDR stack
[64];
17935 unsigned int bytes_read
, unsnd
;
17941 stack
[++stacki
] = 0;
17980 stack
[++stacki
] = op
- DW_OP_lit0
;
18015 stack
[++stacki
] = op
- DW_OP_reg0
;
18017 dwarf2_complex_location_expr_complaint ();
18021 unsnd
= read_unsigned_leb128 (NULL
, (data
+ i
), &bytes_read
);
18023 stack
[++stacki
] = unsnd
;
18025 dwarf2_complex_location_expr_complaint ();
18029 stack
[++stacki
] = read_address (objfile
->obfd
, &data
[i
],
18034 case DW_OP_const1u
:
18035 stack
[++stacki
] = read_1_byte (objfile
->obfd
, &data
[i
]);
18039 case DW_OP_const1s
:
18040 stack
[++stacki
] = read_1_signed_byte (objfile
->obfd
, &data
[i
]);
18044 case DW_OP_const2u
:
18045 stack
[++stacki
] = read_2_bytes (objfile
->obfd
, &data
[i
]);
18049 case DW_OP_const2s
:
18050 stack
[++stacki
] = read_2_signed_bytes (objfile
->obfd
, &data
[i
]);
18054 case DW_OP_const4u
:
18055 stack
[++stacki
] = read_4_bytes (objfile
->obfd
, &data
[i
]);
18059 case DW_OP_const4s
:
18060 stack
[++stacki
] = read_4_signed_bytes (objfile
->obfd
, &data
[i
]);
18064 case DW_OP_const8u
:
18065 stack
[++stacki
] = read_8_bytes (objfile
->obfd
, &data
[i
]);
18070 stack
[++stacki
] = read_unsigned_leb128 (NULL
, (data
+ i
),
18076 stack
[++stacki
] = read_signed_leb128 (NULL
, (data
+ i
), &bytes_read
);
18081 stack
[stacki
+ 1] = stack
[stacki
];
18086 stack
[stacki
- 1] += stack
[stacki
];
18090 case DW_OP_plus_uconst
:
18091 stack
[stacki
] += read_unsigned_leb128 (NULL
, (data
+ i
),
18097 stack
[stacki
- 1] -= stack
[stacki
];
18102 /* If we're not the last op, then we definitely can't encode
18103 this using GDB's address_class enum. This is valid for partial
18104 global symbols, although the variable's address will be bogus
18107 dwarf2_complex_location_expr_complaint ();
18110 case DW_OP_GNU_push_tls_address
:
18111 /* The top of the stack has the offset from the beginning
18112 of the thread control block at which the variable is located. */
18113 /* Nothing should follow this operator, so the top of stack would
18115 /* This is valid for partial global symbols, but the variable's
18116 address will be bogus in the psymtab. Make it always at least
18117 non-zero to not look as a variable garbage collected by linker
18118 which have DW_OP_addr 0. */
18120 dwarf2_complex_location_expr_complaint ();
18124 case DW_OP_GNU_uninit
:
18127 case DW_OP_GNU_addr_index
:
18128 case DW_OP_GNU_const_index
:
18129 stack
[++stacki
] = read_addr_index_from_leb128 (cu
, &data
[i
],
18136 const char *name
= get_DW_OP_name (op
);
18139 complaint (&symfile_complaints
, _("unsupported stack op: '%s'"),
18142 complaint (&symfile_complaints
, _("unsupported stack op: '%02x'"),
18146 return (stack
[stacki
]);
18149 /* Enforce maximum stack depth of SIZE-1 to avoid writing
18150 outside of the allocated space. Also enforce minimum>0. */
18151 if (stacki
>= ARRAY_SIZE (stack
) - 1)
18153 complaint (&symfile_complaints
,
18154 _("location description stack overflow"));
18160 complaint (&symfile_complaints
,
18161 _("location description stack underflow"));
18165 return (stack
[stacki
]);
18168 /* memory allocation interface */
18170 static struct dwarf_block
*
18171 dwarf_alloc_block (struct dwarf2_cu
*cu
)
18173 struct dwarf_block
*blk
;
18175 blk
= (struct dwarf_block
*)
18176 obstack_alloc (&cu
->comp_unit_obstack
, sizeof (struct dwarf_block
));
18180 static struct die_info
*
18181 dwarf_alloc_die (struct dwarf2_cu
*cu
, int num_attrs
)
18183 struct die_info
*die
;
18184 size_t size
= sizeof (struct die_info
);
18187 size
+= (num_attrs
- 1) * sizeof (struct attribute
);
18189 die
= (struct die_info
*) obstack_alloc (&cu
->comp_unit_obstack
, size
);
18190 memset (die
, 0, sizeof (struct die_info
));
18195 /* Macro support. */
18197 /* Return file name relative to the compilation directory of file number I in
18198 *LH's file name table. The result is allocated using xmalloc; the caller is
18199 responsible for freeing it. */
18202 file_file_name (int file
, struct line_header
*lh
)
18204 /* Is the file number a valid index into the line header's file name
18205 table? Remember that file numbers start with one, not zero. */
18206 if (1 <= file
&& file
<= lh
->num_file_names
)
18208 struct file_entry
*fe
= &lh
->file_names
[file
- 1];
18210 if (IS_ABSOLUTE_PATH (fe
->name
) || fe
->dir_index
== 0)
18211 return xstrdup (fe
->name
);
18212 return concat (lh
->include_dirs
[fe
->dir_index
- 1], SLASH_STRING
,
18217 /* The compiler produced a bogus file number. We can at least
18218 record the macro definitions made in the file, even if we
18219 won't be able to find the file by name. */
18220 char fake_name
[80];
18222 xsnprintf (fake_name
, sizeof (fake_name
),
18223 "<bad macro file number %d>", file
);
18225 complaint (&symfile_complaints
,
18226 _("bad file number in macro information (%d)"),
18229 return xstrdup (fake_name
);
18233 /* Return the full name of file number I in *LH's file name table.
18234 Use COMP_DIR as the name of the current directory of the
18235 compilation. The result is allocated using xmalloc; the caller is
18236 responsible for freeing it. */
18238 file_full_name (int file
, struct line_header
*lh
, const char *comp_dir
)
18240 /* Is the file number a valid index into the line header's file name
18241 table? Remember that file numbers start with one, not zero. */
18242 if (1 <= file
&& file
<= lh
->num_file_names
)
18244 char *relative
= file_file_name (file
, lh
);
18246 if (IS_ABSOLUTE_PATH (relative
) || comp_dir
== NULL
)
18248 return reconcat (relative
, comp_dir
, SLASH_STRING
, relative
, NULL
);
18251 return file_file_name (file
, lh
);
18255 static struct macro_source_file
*
18256 macro_start_file (int file
, int line
,
18257 struct macro_source_file
*current_file
,
18258 const char *comp_dir
,
18259 struct line_header
*lh
, struct objfile
*objfile
)
18261 /* File name relative to the compilation directory of this source file. */
18262 char *file_name
= file_file_name (file
, lh
);
18264 /* We don't create a macro table for this compilation unit
18265 at all until we actually get a filename. */
18266 if (! pending_macros
)
18267 pending_macros
= new_macro_table (&objfile
->per_bfd
->storage_obstack
,
18268 objfile
->per_bfd
->macro_cache
,
18271 if (! current_file
)
18273 /* If we have no current file, then this must be the start_file
18274 directive for the compilation unit's main source file. */
18275 current_file
= macro_set_main (pending_macros
, file_name
);
18276 macro_define_special (pending_macros
);
18279 current_file
= macro_include (current_file
, line
, file_name
);
18283 return current_file
;
18287 /* Copy the LEN characters at BUF to a xmalloc'ed block of memory,
18288 followed by a null byte. */
18290 copy_string (const char *buf
, int len
)
18292 char *s
= xmalloc (len
+ 1);
18294 memcpy (s
, buf
, len
);
18300 static const char *
18301 consume_improper_spaces (const char *p
, const char *body
)
18305 complaint (&symfile_complaints
,
18306 _("macro definition contains spaces "
18307 "in formal argument list:\n`%s'"),
18319 parse_macro_definition (struct macro_source_file
*file
, int line
,
18324 /* The body string takes one of two forms. For object-like macro
18325 definitions, it should be:
18327 <macro name> " " <definition>
18329 For function-like macro definitions, it should be:
18331 <macro name> "() " <definition>
18333 <macro name> "(" <arg name> ( "," <arg name> ) * ") " <definition>
18335 Spaces may appear only where explicitly indicated, and in the
18338 The Dwarf 2 spec says that an object-like macro's name is always
18339 followed by a space, but versions of GCC around March 2002 omit
18340 the space when the macro's definition is the empty string.
18342 The Dwarf 2 spec says that there should be no spaces between the
18343 formal arguments in a function-like macro's formal argument list,
18344 but versions of GCC around March 2002 include spaces after the
18348 /* Find the extent of the macro name. The macro name is terminated
18349 by either a space or null character (for an object-like macro) or
18350 an opening paren (for a function-like macro). */
18351 for (p
= body
; *p
; p
++)
18352 if (*p
== ' ' || *p
== '(')
18355 if (*p
== ' ' || *p
== '\0')
18357 /* It's an object-like macro. */
18358 int name_len
= p
- body
;
18359 char *name
= copy_string (body
, name_len
);
18360 const char *replacement
;
18363 replacement
= body
+ name_len
+ 1;
18366 dwarf2_macro_malformed_definition_complaint (body
);
18367 replacement
= body
+ name_len
;
18370 macro_define_object (file
, line
, name
, replacement
);
18374 else if (*p
== '(')
18376 /* It's a function-like macro. */
18377 char *name
= copy_string (body
, p
- body
);
18380 char **argv
= xmalloc (argv_size
* sizeof (*argv
));
18384 p
= consume_improper_spaces (p
, body
);
18386 /* Parse the formal argument list. */
18387 while (*p
&& *p
!= ')')
18389 /* Find the extent of the current argument name. */
18390 const char *arg_start
= p
;
18392 while (*p
&& *p
!= ',' && *p
!= ')' && *p
!= ' ')
18395 if (! *p
|| p
== arg_start
)
18396 dwarf2_macro_malformed_definition_complaint (body
);
18399 /* Make sure argv has room for the new argument. */
18400 if (argc
>= argv_size
)
18403 argv
= xrealloc (argv
, argv_size
* sizeof (*argv
));
18406 argv
[argc
++] = copy_string (arg_start
, p
- arg_start
);
18409 p
= consume_improper_spaces (p
, body
);
18411 /* Consume the comma, if present. */
18416 p
= consume_improper_spaces (p
, body
);
18425 /* Perfectly formed definition, no complaints. */
18426 macro_define_function (file
, line
, name
,
18427 argc
, (const char **) argv
,
18429 else if (*p
== '\0')
18431 /* Complain, but do define it. */
18432 dwarf2_macro_malformed_definition_complaint (body
);
18433 macro_define_function (file
, line
, name
,
18434 argc
, (const char **) argv
,
18438 /* Just complain. */
18439 dwarf2_macro_malformed_definition_complaint (body
);
18442 /* Just complain. */
18443 dwarf2_macro_malformed_definition_complaint (body
);
18449 for (i
= 0; i
< argc
; i
++)
18455 dwarf2_macro_malformed_definition_complaint (body
);
18458 /* Skip some bytes from BYTES according to the form given in FORM.
18459 Returns the new pointer. */
18462 skip_form_bytes (bfd
*abfd
, gdb_byte
*bytes
, gdb_byte
*buffer_end
,
18463 enum dwarf_form form
,
18464 unsigned int offset_size
,
18465 struct dwarf2_section_info
*section
)
18467 unsigned int bytes_read
;
18471 case DW_FORM_data1
:
18476 case DW_FORM_data2
:
18480 case DW_FORM_data4
:
18484 case DW_FORM_data8
:
18488 case DW_FORM_string
:
18489 read_direct_string (abfd
, bytes
, &bytes_read
);
18490 bytes
+= bytes_read
;
18493 case DW_FORM_sec_offset
:
18495 case DW_FORM_GNU_strp_alt
:
18496 bytes
+= offset_size
;
18499 case DW_FORM_block
:
18500 bytes
+= read_unsigned_leb128 (abfd
, bytes
, &bytes_read
);
18501 bytes
+= bytes_read
;
18504 case DW_FORM_block1
:
18505 bytes
+= 1 + read_1_byte (abfd
, bytes
);
18507 case DW_FORM_block2
:
18508 bytes
+= 2 + read_2_bytes (abfd
, bytes
);
18510 case DW_FORM_block4
:
18511 bytes
+= 4 + read_4_bytes (abfd
, bytes
);
18514 case DW_FORM_sdata
:
18515 case DW_FORM_udata
:
18516 case DW_FORM_GNU_addr_index
:
18517 case DW_FORM_GNU_str_index
:
18518 bytes
= (gdb_byte
*) gdb_skip_leb128 (bytes
, buffer_end
);
18521 dwarf2_section_buffer_overflow_complaint (section
);
18529 complaint (&symfile_complaints
,
18530 _("invalid form 0x%x in `%s'"),
18532 section
->asection
->name
);
18540 /* A helper for dwarf_decode_macros that handles skipping an unknown
18541 opcode. Returns an updated pointer to the macro data buffer; or,
18542 on error, issues a complaint and returns NULL. */
18545 skip_unknown_opcode (unsigned int opcode
,
18546 gdb_byte
**opcode_definitions
,
18547 gdb_byte
*mac_ptr
, gdb_byte
*mac_end
,
18549 unsigned int offset_size
,
18550 struct dwarf2_section_info
*section
)
18552 unsigned int bytes_read
, i
;
18556 if (opcode_definitions
[opcode
] == NULL
)
18558 complaint (&symfile_complaints
,
18559 _("unrecognized DW_MACFINO opcode 0x%x"),
18564 defn
= opcode_definitions
[opcode
];
18565 arg
= read_unsigned_leb128 (abfd
, defn
, &bytes_read
);
18566 defn
+= bytes_read
;
18568 for (i
= 0; i
< arg
; ++i
)
18570 mac_ptr
= skip_form_bytes (abfd
, mac_ptr
, mac_end
, defn
[i
], offset_size
,
18572 if (mac_ptr
== NULL
)
18574 /* skip_form_bytes already issued the complaint. */
18582 /* A helper function which parses the header of a macro section.
18583 If the macro section is the extended (for now called "GNU") type,
18584 then this updates *OFFSET_SIZE. Returns a pointer to just after
18585 the header, or issues a complaint and returns NULL on error. */
18588 dwarf_parse_macro_header (gdb_byte
**opcode_definitions
,
18591 unsigned int *offset_size
,
18592 int section_is_gnu
)
18594 memset (opcode_definitions
, 0, 256 * sizeof (gdb_byte
*));
18596 if (section_is_gnu
)
18598 unsigned int version
, flags
;
18600 version
= read_2_bytes (abfd
, mac_ptr
);
18603 complaint (&symfile_complaints
,
18604 _("unrecognized version `%d' in .debug_macro section"),
18610 flags
= read_1_byte (abfd
, mac_ptr
);
18612 *offset_size
= (flags
& 1) ? 8 : 4;
18614 if ((flags
& 2) != 0)
18615 /* We don't need the line table offset. */
18616 mac_ptr
+= *offset_size
;
18618 /* Vendor opcode descriptions. */
18619 if ((flags
& 4) != 0)
18621 unsigned int i
, count
;
18623 count
= read_1_byte (abfd
, mac_ptr
);
18625 for (i
= 0; i
< count
; ++i
)
18627 unsigned int opcode
, bytes_read
;
18630 opcode
= read_1_byte (abfd
, mac_ptr
);
18632 opcode_definitions
[opcode
] = mac_ptr
;
18633 arg
= read_unsigned_leb128 (abfd
, mac_ptr
, &bytes_read
);
18634 mac_ptr
+= bytes_read
;
18643 /* A helper for dwarf_decode_macros that handles the GNU extensions,
18644 including DW_MACRO_GNU_transparent_include. */
18647 dwarf_decode_macro_bytes (bfd
*abfd
, gdb_byte
*mac_ptr
, gdb_byte
*mac_end
,
18648 struct macro_source_file
*current_file
,
18649 struct line_header
*lh
, const char *comp_dir
,
18650 struct dwarf2_section_info
*section
,
18651 int section_is_gnu
, int section_is_dwz
,
18652 unsigned int offset_size
,
18653 struct objfile
*objfile
,
18654 htab_t include_hash
)
18656 enum dwarf_macro_record_type macinfo_type
;
18657 int at_commandline
;
18658 gdb_byte
*opcode_definitions
[256];
18660 mac_ptr
= dwarf_parse_macro_header (opcode_definitions
, abfd
, mac_ptr
,
18661 &offset_size
, section_is_gnu
);
18662 if (mac_ptr
== NULL
)
18664 /* We already issued a complaint. */
18668 /* Determines if GDB is still before first DW_MACINFO_start_file. If true
18669 GDB is still reading the definitions from command line. First
18670 DW_MACINFO_start_file will need to be ignored as it was already executed
18671 to create CURRENT_FILE for the main source holding also the command line
18672 definitions. On first met DW_MACINFO_start_file this flag is reset to
18673 normally execute all the remaining DW_MACINFO_start_file macinfos. */
18675 at_commandline
= 1;
18679 /* Do we at least have room for a macinfo type byte? */
18680 if (mac_ptr
>= mac_end
)
18682 dwarf2_section_buffer_overflow_complaint (section
);
18686 macinfo_type
= read_1_byte (abfd
, mac_ptr
);
18689 /* Note that we rely on the fact that the corresponding GNU and
18690 DWARF constants are the same. */
18691 switch (macinfo_type
)
18693 /* A zero macinfo type indicates the end of the macro
18698 case DW_MACRO_GNU_define
:
18699 case DW_MACRO_GNU_undef
:
18700 case DW_MACRO_GNU_define_indirect
:
18701 case DW_MACRO_GNU_undef_indirect
:
18702 case DW_MACRO_GNU_define_indirect_alt
:
18703 case DW_MACRO_GNU_undef_indirect_alt
:
18705 unsigned int bytes_read
;
18710 line
= read_unsigned_leb128 (abfd
, mac_ptr
, &bytes_read
);
18711 mac_ptr
+= bytes_read
;
18713 if (macinfo_type
== DW_MACRO_GNU_define
18714 || macinfo_type
== DW_MACRO_GNU_undef
)
18716 body
= read_direct_string (abfd
, mac_ptr
, &bytes_read
);
18717 mac_ptr
+= bytes_read
;
18721 LONGEST str_offset
;
18723 str_offset
= read_offset_1 (abfd
, mac_ptr
, offset_size
);
18724 mac_ptr
+= offset_size
;
18726 if (macinfo_type
== DW_MACRO_GNU_define_indirect_alt
18727 || macinfo_type
== DW_MACRO_GNU_undef_indirect_alt
18730 struct dwz_file
*dwz
= dwarf2_get_dwz_file ();
18732 body
= read_indirect_string_from_dwz (dwz
, str_offset
);
18735 body
= read_indirect_string_at_offset (abfd
, str_offset
);
18738 is_define
= (macinfo_type
== DW_MACRO_GNU_define
18739 || macinfo_type
== DW_MACRO_GNU_define_indirect
18740 || macinfo_type
== DW_MACRO_GNU_define_indirect_alt
);
18741 if (! current_file
)
18743 /* DWARF violation as no main source is present. */
18744 complaint (&symfile_complaints
,
18745 _("debug info with no main source gives macro %s "
18747 is_define
? _("definition") : _("undefinition"),
18751 if ((line
== 0 && !at_commandline
)
18752 || (line
!= 0 && at_commandline
))
18753 complaint (&symfile_complaints
,
18754 _("debug info gives %s macro %s with %s line %d: %s"),
18755 at_commandline
? _("command-line") : _("in-file"),
18756 is_define
? _("definition") : _("undefinition"),
18757 line
== 0 ? _("zero") : _("non-zero"), line
, body
);
18760 parse_macro_definition (current_file
, line
, body
);
18763 gdb_assert (macinfo_type
== DW_MACRO_GNU_undef
18764 || macinfo_type
== DW_MACRO_GNU_undef_indirect
18765 || macinfo_type
== DW_MACRO_GNU_undef_indirect_alt
);
18766 macro_undef (current_file
, line
, body
);
18771 case DW_MACRO_GNU_start_file
:
18773 unsigned int bytes_read
;
18776 line
= read_unsigned_leb128 (abfd
, mac_ptr
, &bytes_read
);
18777 mac_ptr
+= bytes_read
;
18778 file
= read_unsigned_leb128 (abfd
, mac_ptr
, &bytes_read
);
18779 mac_ptr
+= bytes_read
;
18781 if ((line
== 0 && !at_commandline
)
18782 || (line
!= 0 && at_commandline
))
18783 complaint (&symfile_complaints
,
18784 _("debug info gives source %d included "
18785 "from %s at %s line %d"),
18786 file
, at_commandline
? _("command-line") : _("file"),
18787 line
== 0 ? _("zero") : _("non-zero"), line
);
18789 if (at_commandline
)
18791 /* This DW_MACRO_GNU_start_file was executed in the
18793 at_commandline
= 0;
18796 current_file
= macro_start_file (file
, line
,
18797 current_file
, comp_dir
,
18802 case DW_MACRO_GNU_end_file
:
18803 if (! current_file
)
18804 complaint (&symfile_complaints
,
18805 _("macro debug info has an unmatched "
18806 "`close_file' directive"));
18809 current_file
= current_file
->included_by
;
18810 if (! current_file
)
18812 enum dwarf_macro_record_type next_type
;
18814 /* GCC circa March 2002 doesn't produce the zero
18815 type byte marking the end of the compilation
18816 unit. Complain if it's not there, but exit no
18819 /* Do we at least have room for a macinfo type byte? */
18820 if (mac_ptr
>= mac_end
)
18822 dwarf2_section_buffer_overflow_complaint (section
);
18826 /* We don't increment mac_ptr here, so this is just
18828 next_type
= read_1_byte (abfd
, mac_ptr
);
18829 if (next_type
!= 0)
18830 complaint (&symfile_complaints
,
18831 _("no terminating 0-type entry for "
18832 "macros in `.debug_macinfo' section"));
18839 case DW_MACRO_GNU_transparent_include
:
18840 case DW_MACRO_GNU_transparent_include_alt
:
18844 bfd
*include_bfd
= abfd
;
18845 struct dwarf2_section_info
*include_section
= section
;
18846 struct dwarf2_section_info alt_section
;
18847 gdb_byte
*include_mac_end
= mac_end
;
18848 int is_dwz
= section_is_dwz
;
18849 gdb_byte
*new_mac_ptr
;
18851 offset
= read_offset_1 (abfd
, mac_ptr
, offset_size
);
18852 mac_ptr
+= offset_size
;
18854 if (macinfo_type
== DW_MACRO_GNU_transparent_include_alt
)
18856 struct dwz_file
*dwz
= dwarf2_get_dwz_file ();
18858 dwarf2_read_section (dwarf2_per_objfile
->objfile
,
18861 include_bfd
= dwz
->macro
.asection
->owner
;
18862 include_section
= &dwz
->macro
;
18863 include_mac_end
= dwz
->macro
.buffer
+ dwz
->macro
.size
;
18867 new_mac_ptr
= include_section
->buffer
+ offset
;
18868 slot
= htab_find_slot (include_hash
, new_mac_ptr
, INSERT
);
18872 /* This has actually happened; see
18873 http://sourceware.org/bugzilla/show_bug.cgi?id=13568. */
18874 complaint (&symfile_complaints
,
18875 _("recursive DW_MACRO_GNU_transparent_include in "
18876 ".debug_macro section"));
18880 *slot
= new_mac_ptr
;
18882 dwarf_decode_macro_bytes (include_bfd
, new_mac_ptr
,
18883 include_mac_end
, current_file
,
18885 section
, section_is_gnu
, is_dwz
,
18886 offset_size
, objfile
, include_hash
);
18888 htab_remove_elt (include_hash
, new_mac_ptr
);
18893 case DW_MACINFO_vendor_ext
:
18894 if (!section_is_gnu
)
18896 unsigned int bytes_read
;
18899 constant
= read_unsigned_leb128 (abfd
, mac_ptr
, &bytes_read
);
18900 mac_ptr
+= bytes_read
;
18901 read_direct_string (abfd
, mac_ptr
, &bytes_read
);
18902 mac_ptr
+= bytes_read
;
18904 /* We don't recognize any vendor extensions. */
18910 mac_ptr
= skip_unknown_opcode (macinfo_type
, opcode_definitions
,
18911 mac_ptr
, mac_end
, abfd
, offset_size
,
18913 if (mac_ptr
== NULL
)
18917 } while (macinfo_type
!= 0);
18921 dwarf_decode_macros (struct dwarf2_cu
*cu
, unsigned int offset
,
18922 const char *comp_dir
, int section_is_gnu
)
18924 struct objfile
*objfile
= dwarf2_per_objfile
->objfile
;
18925 struct line_header
*lh
= cu
->line_header
;
18927 gdb_byte
*mac_ptr
, *mac_end
;
18928 struct macro_source_file
*current_file
= 0;
18929 enum dwarf_macro_record_type macinfo_type
;
18930 unsigned int offset_size
= cu
->header
.offset_size
;
18931 gdb_byte
*opcode_definitions
[256];
18932 struct cleanup
*cleanup
;
18933 htab_t include_hash
;
18935 struct dwarf2_section_info
*section
;
18936 const char *section_name
;
18938 if (cu
->dwo_unit
!= NULL
)
18940 if (section_is_gnu
)
18942 section
= &cu
->dwo_unit
->dwo_file
->sections
.macro
;
18943 section_name
= ".debug_macro.dwo";
18947 section
= &cu
->dwo_unit
->dwo_file
->sections
.macinfo
;
18948 section_name
= ".debug_macinfo.dwo";
18953 if (section_is_gnu
)
18955 section
= &dwarf2_per_objfile
->macro
;
18956 section_name
= ".debug_macro";
18960 section
= &dwarf2_per_objfile
->macinfo
;
18961 section_name
= ".debug_macinfo";
18965 dwarf2_read_section (objfile
, section
);
18966 if (section
->buffer
== NULL
)
18968 complaint (&symfile_complaints
, _("missing %s section"), section_name
);
18971 abfd
= section
->asection
->owner
;
18973 /* First pass: Find the name of the base filename.
18974 This filename is needed in order to process all macros whose definition
18975 (or undefinition) comes from the command line. These macros are defined
18976 before the first DW_MACINFO_start_file entry, and yet still need to be
18977 associated to the base file.
18979 To determine the base file name, we scan the macro definitions until we
18980 reach the first DW_MACINFO_start_file entry. We then initialize
18981 CURRENT_FILE accordingly so that any macro definition found before the
18982 first DW_MACINFO_start_file can still be associated to the base file. */
18984 mac_ptr
= section
->buffer
+ offset
;
18985 mac_end
= section
->buffer
+ section
->size
;
18987 mac_ptr
= dwarf_parse_macro_header (opcode_definitions
, abfd
, mac_ptr
,
18988 &offset_size
, section_is_gnu
);
18989 if (mac_ptr
== NULL
)
18991 /* We already issued a complaint. */
18997 /* Do we at least have room for a macinfo type byte? */
18998 if (mac_ptr
>= mac_end
)
19000 /* Complaint is printed during the second pass as GDB will probably
19001 stop the first pass earlier upon finding
19002 DW_MACINFO_start_file. */
19006 macinfo_type
= read_1_byte (abfd
, mac_ptr
);
19009 /* Note that we rely on the fact that the corresponding GNU and
19010 DWARF constants are the same. */
19011 switch (macinfo_type
)
19013 /* A zero macinfo type indicates the end of the macro
19018 case DW_MACRO_GNU_define
:
19019 case DW_MACRO_GNU_undef
:
19020 /* Only skip the data by MAC_PTR. */
19022 unsigned int bytes_read
;
19024 read_unsigned_leb128 (abfd
, mac_ptr
, &bytes_read
);
19025 mac_ptr
+= bytes_read
;
19026 read_direct_string (abfd
, mac_ptr
, &bytes_read
);
19027 mac_ptr
+= bytes_read
;
19031 case DW_MACRO_GNU_start_file
:
19033 unsigned int bytes_read
;
19036 line
= read_unsigned_leb128 (abfd
, mac_ptr
, &bytes_read
);
19037 mac_ptr
+= bytes_read
;
19038 file
= read_unsigned_leb128 (abfd
, mac_ptr
, &bytes_read
);
19039 mac_ptr
+= bytes_read
;
19041 current_file
= macro_start_file (file
, line
, current_file
,
19042 comp_dir
, lh
, objfile
);
19046 case DW_MACRO_GNU_end_file
:
19047 /* No data to skip by MAC_PTR. */
19050 case DW_MACRO_GNU_define_indirect
:
19051 case DW_MACRO_GNU_undef_indirect
:
19052 case DW_MACRO_GNU_define_indirect_alt
:
19053 case DW_MACRO_GNU_undef_indirect_alt
:
19055 unsigned int bytes_read
;
19057 read_unsigned_leb128 (abfd
, mac_ptr
, &bytes_read
);
19058 mac_ptr
+= bytes_read
;
19059 mac_ptr
+= offset_size
;
19063 case DW_MACRO_GNU_transparent_include
:
19064 case DW_MACRO_GNU_transparent_include_alt
:
19065 /* Note that, according to the spec, a transparent include
19066 chain cannot call DW_MACRO_GNU_start_file. So, we can just
19067 skip this opcode. */
19068 mac_ptr
+= offset_size
;
19071 case DW_MACINFO_vendor_ext
:
19072 /* Only skip the data by MAC_PTR. */
19073 if (!section_is_gnu
)
19075 unsigned int bytes_read
;
19077 read_unsigned_leb128 (abfd
, mac_ptr
, &bytes_read
);
19078 mac_ptr
+= bytes_read
;
19079 read_direct_string (abfd
, mac_ptr
, &bytes_read
);
19080 mac_ptr
+= bytes_read
;
19085 mac_ptr
= skip_unknown_opcode (macinfo_type
, opcode_definitions
,
19086 mac_ptr
, mac_end
, abfd
, offset_size
,
19088 if (mac_ptr
== NULL
)
19092 } while (macinfo_type
!= 0 && current_file
== NULL
);
19094 /* Second pass: Process all entries.
19096 Use the AT_COMMAND_LINE flag to determine whether we are still processing
19097 command-line macro definitions/undefinitions. This flag is unset when we
19098 reach the first DW_MACINFO_start_file entry. */
19100 include_hash
= htab_create_alloc (1, htab_hash_pointer
, htab_eq_pointer
,
19101 NULL
, xcalloc
, xfree
);
19102 cleanup
= make_cleanup_htab_delete (include_hash
);
19103 mac_ptr
= section
->buffer
+ offset
;
19104 slot
= htab_find_slot (include_hash
, mac_ptr
, INSERT
);
19106 dwarf_decode_macro_bytes (abfd
, mac_ptr
, mac_end
,
19107 current_file
, lh
, comp_dir
, section
,
19109 offset_size
, objfile
, include_hash
);
19110 do_cleanups (cleanup
);
19113 /* Check if the attribute's form is a DW_FORM_block*
19114 if so return true else false. */
19117 attr_form_is_block (struct attribute
*attr
)
19119 return (attr
== NULL
? 0 :
19120 attr
->form
== DW_FORM_block1
19121 || attr
->form
== DW_FORM_block2
19122 || attr
->form
== DW_FORM_block4
19123 || attr
->form
== DW_FORM_block
19124 || attr
->form
== DW_FORM_exprloc
);
19127 /* Return non-zero if ATTR's value is a section offset --- classes
19128 lineptr, loclistptr, macptr or rangelistptr --- or zero, otherwise.
19129 You may use DW_UNSND (attr) to retrieve such offsets.
19131 Section 7.5.4, "Attribute Encodings", explains that no attribute
19132 may have a value that belongs to more than one of these classes; it
19133 would be ambiguous if we did, because we use the same forms for all
19137 attr_form_is_section_offset (struct attribute
*attr
)
19139 return (attr
->form
== DW_FORM_data4
19140 || attr
->form
== DW_FORM_data8
19141 || attr
->form
== DW_FORM_sec_offset
);
19144 /* Return non-zero if ATTR's value falls in the 'constant' class, or
19145 zero otherwise. When this function returns true, you can apply
19146 dwarf2_get_attr_constant_value to it.
19148 However, note that for some attributes you must check
19149 attr_form_is_section_offset before using this test. DW_FORM_data4
19150 and DW_FORM_data8 are members of both the constant class, and of
19151 the classes that contain offsets into other debug sections
19152 (lineptr, loclistptr, macptr or rangelistptr). The DWARF spec says
19153 that, if an attribute's can be either a constant or one of the
19154 section offset classes, DW_FORM_data4 and DW_FORM_data8 should be
19155 taken as section offsets, not constants. */
19158 attr_form_is_constant (struct attribute
*attr
)
19160 switch (attr
->form
)
19162 case DW_FORM_sdata
:
19163 case DW_FORM_udata
:
19164 case DW_FORM_data1
:
19165 case DW_FORM_data2
:
19166 case DW_FORM_data4
:
19167 case DW_FORM_data8
:
19174 /* Return the .debug_loc section to use for CU.
19175 For DWO files use .debug_loc.dwo. */
19177 static struct dwarf2_section_info
*
19178 cu_debug_loc_section (struct dwarf2_cu
*cu
)
19181 return &cu
->dwo_unit
->dwo_file
->sections
.loc
;
19182 return &dwarf2_per_objfile
->loc
;
19185 /* A helper function that fills in a dwarf2_loclist_baton. */
19188 fill_in_loclist_baton (struct dwarf2_cu
*cu
,
19189 struct dwarf2_loclist_baton
*baton
,
19190 struct attribute
*attr
)
19192 struct dwarf2_section_info
*section
= cu_debug_loc_section (cu
);
19194 dwarf2_read_section (dwarf2_per_objfile
->objfile
, section
);
19196 baton
->per_cu
= cu
->per_cu
;
19197 gdb_assert (baton
->per_cu
);
19198 /* We don't know how long the location list is, but make sure we
19199 don't run off the edge of the section. */
19200 baton
->size
= section
->size
- DW_UNSND (attr
);
19201 baton
->data
= section
->buffer
+ DW_UNSND (attr
);
19202 baton
->base_address
= cu
->base_address
;
19203 baton
->from_dwo
= cu
->dwo_unit
!= NULL
;
19207 dwarf2_symbol_mark_computed (struct attribute
*attr
, struct symbol
*sym
,
19208 struct dwarf2_cu
*cu
, int is_block
)
19210 struct objfile
*objfile
= dwarf2_per_objfile
->objfile
;
19211 struct dwarf2_section_info
*section
= cu_debug_loc_section (cu
);
19213 if (attr_form_is_section_offset (attr
)
19214 /* .debug_loc{,.dwo} may not exist at all, or the offset may be outside
19215 the section. If so, fall through to the complaint in the
19217 && DW_UNSND (attr
) < dwarf2_section_size (objfile
, section
))
19219 struct dwarf2_loclist_baton
*baton
;
19221 baton
= obstack_alloc (&objfile
->objfile_obstack
,
19222 sizeof (struct dwarf2_loclist_baton
));
19224 fill_in_loclist_baton (cu
, baton
, attr
);
19226 if (cu
->base_known
== 0)
19227 complaint (&symfile_complaints
,
19228 _("Location list used without "
19229 "specifying the CU base address."));
19231 SYMBOL_ACLASS_INDEX (sym
) = (is_block
19232 ? dwarf2_loclist_block_index
19233 : dwarf2_loclist_index
);
19234 SYMBOL_LOCATION_BATON (sym
) = baton
;
19238 struct dwarf2_locexpr_baton
*baton
;
19240 baton
= obstack_alloc (&objfile
->objfile_obstack
,
19241 sizeof (struct dwarf2_locexpr_baton
));
19242 baton
->per_cu
= cu
->per_cu
;
19243 gdb_assert (baton
->per_cu
);
19245 if (attr_form_is_block (attr
))
19247 /* Note that we're just copying the block's data pointer
19248 here, not the actual data. We're still pointing into the
19249 info_buffer for SYM's objfile; right now we never release
19250 that buffer, but when we do clean up properly this may
19252 baton
->size
= DW_BLOCK (attr
)->size
;
19253 baton
->data
= DW_BLOCK (attr
)->data
;
19257 dwarf2_invalid_attrib_class_complaint ("location description",
19258 SYMBOL_NATURAL_NAME (sym
));
19262 SYMBOL_ACLASS_INDEX (sym
) = (is_block
19263 ? dwarf2_locexpr_block_index
19264 : dwarf2_locexpr_index
);
19265 SYMBOL_LOCATION_BATON (sym
) = baton
;
19269 /* Return the OBJFILE associated with the compilation unit CU. If CU
19270 came from a separate debuginfo file, then the master objfile is
19274 dwarf2_per_cu_objfile (struct dwarf2_per_cu_data
*per_cu
)
19276 struct objfile
*objfile
= per_cu
->objfile
;
19278 /* Return the master objfile, so that we can report and look up the
19279 correct file containing this variable. */
19280 if (objfile
->separate_debug_objfile_backlink
)
19281 objfile
= objfile
->separate_debug_objfile_backlink
;
19286 /* Return comp_unit_head for PER_CU, either already available in PER_CU->CU
19287 (CU_HEADERP is unused in such case) or prepare a temporary copy at
19288 CU_HEADERP first. */
19290 static const struct comp_unit_head
*
19291 per_cu_header_read_in (struct comp_unit_head
*cu_headerp
,
19292 struct dwarf2_per_cu_data
*per_cu
)
19294 gdb_byte
*info_ptr
;
19297 return &per_cu
->cu
->header
;
19299 info_ptr
= per_cu
->section
->buffer
+ per_cu
->offset
.sect_off
;
19301 memset (cu_headerp
, 0, sizeof (*cu_headerp
));
19302 read_comp_unit_head (cu_headerp
, info_ptr
, per_cu
->objfile
->obfd
);
19307 /* Return the address size given in the compilation unit header for CU. */
19310 dwarf2_per_cu_addr_size (struct dwarf2_per_cu_data
*per_cu
)
19312 struct comp_unit_head cu_header_local
;
19313 const struct comp_unit_head
*cu_headerp
;
19315 cu_headerp
= per_cu_header_read_in (&cu_header_local
, per_cu
);
19317 return cu_headerp
->addr_size
;
19320 /* Return the offset size given in the compilation unit header for CU. */
19323 dwarf2_per_cu_offset_size (struct dwarf2_per_cu_data
*per_cu
)
19325 struct comp_unit_head cu_header_local
;
19326 const struct comp_unit_head
*cu_headerp
;
19328 cu_headerp
= per_cu_header_read_in (&cu_header_local
, per_cu
);
19330 return cu_headerp
->offset_size
;
19333 /* See its dwarf2loc.h declaration. */
19336 dwarf2_per_cu_ref_addr_size (struct dwarf2_per_cu_data
*per_cu
)
19338 struct comp_unit_head cu_header_local
;
19339 const struct comp_unit_head
*cu_headerp
;
19341 cu_headerp
= per_cu_header_read_in (&cu_header_local
, per_cu
);
19343 if (cu_headerp
->version
== 2)
19344 return cu_headerp
->addr_size
;
19346 return cu_headerp
->offset_size
;
19349 /* Return the text offset of the CU. The returned offset comes from
19350 this CU's objfile. If this objfile came from a separate debuginfo
19351 file, then the offset may be different from the corresponding
19352 offset in the parent objfile. */
19355 dwarf2_per_cu_text_offset (struct dwarf2_per_cu_data
*per_cu
)
19357 struct objfile
*objfile
= per_cu
->objfile
;
19359 return ANOFFSET (objfile
->section_offsets
, SECT_OFF_TEXT (objfile
));
19362 /* Locate the .debug_info compilation unit from CU's objfile which contains
19363 the DIE at OFFSET. Raises an error on failure. */
19365 static struct dwarf2_per_cu_data
*
19366 dwarf2_find_containing_comp_unit (sect_offset offset
,
19367 unsigned int offset_in_dwz
,
19368 struct objfile
*objfile
)
19370 struct dwarf2_per_cu_data
*this_cu
;
19372 const sect_offset
*cu_off
;
19375 high
= dwarf2_per_objfile
->n_comp_units
- 1;
19378 struct dwarf2_per_cu_data
*mid_cu
;
19379 int mid
= low
+ (high
- low
) / 2;
19381 mid_cu
= dwarf2_per_objfile
->all_comp_units
[mid
];
19382 cu_off
= &mid_cu
->offset
;
19383 if (mid_cu
->is_dwz
> offset_in_dwz
19384 || (mid_cu
->is_dwz
== offset_in_dwz
19385 && cu_off
->sect_off
>= offset
.sect_off
))
19390 gdb_assert (low
== high
);
19391 this_cu
= dwarf2_per_objfile
->all_comp_units
[low
];
19392 cu_off
= &this_cu
->offset
;
19393 if (this_cu
->is_dwz
!= offset_in_dwz
|| cu_off
->sect_off
> offset
.sect_off
)
19395 if (low
== 0 || this_cu
->is_dwz
!= offset_in_dwz
)
19396 error (_("Dwarf Error: could not find partial DIE containing "
19397 "offset 0x%lx [in module %s]"),
19398 (long) offset
.sect_off
, bfd_get_filename (objfile
->obfd
));
19400 gdb_assert (dwarf2_per_objfile
->all_comp_units
[low
-1]->offset
.sect_off
19401 <= offset
.sect_off
);
19402 return dwarf2_per_objfile
->all_comp_units
[low
-1];
19406 this_cu
= dwarf2_per_objfile
->all_comp_units
[low
];
19407 if (low
== dwarf2_per_objfile
->n_comp_units
- 1
19408 && offset
.sect_off
>= this_cu
->offset
.sect_off
+ this_cu
->length
)
19409 error (_("invalid dwarf2 offset %u"), offset
.sect_off
);
19410 gdb_assert (offset
.sect_off
< this_cu
->offset
.sect_off
+ this_cu
->length
);
19415 /* Initialize dwarf2_cu CU, owned by PER_CU. */
19418 init_one_comp_unit (struct dwarf2_cu
*cu
, struct dwarf2_per_cu_data
*per_cu
)
19420 memset (cu
, 0, sizeof (*cu
));
19422 cu
->per_cu
= per_cu
;
19423 cu
->objfile
= per_cu
->objfile
;
19424 obstack_init (&cu
->comp_unit_obstack
);
19427 /* Initialize basic fields of dwarf_cu CU according to DIE COMP_UNIT_DIE. */
19430 prepare_one_comp_unit (struct dwarf2_cu
*cu
, struct die_info
*comp_unit_die
,
19431 enum language pretend_language
)
19433 struct attribute
*attr
;
19435 /* Set the language we're debugging. */
19436 attr
= dwarf2_attr (comp_unit_die
, DW_AT_language
, cu
);
19438 set_cu_language (DW_UNSND (attr
), cu
);
19441 cu
->language
= pretend_language
;
19442 cu
->language_defn
= language_def (cu
->language
);
19445 attr
= dwarf2_attr (comp_unit_die
, DW_AT_producer
, cu
);
19447 cu
->producer
= DW_STRING (attr
);
19450 /* Release one cached compilation unit, CU. We unlink it from the tree
19451 of compilation units, but we don't remove it from the read_in_chain;
19452 the caller is responsible for that.
19453 NOTE: DATA is a void * because this function is also used as a
19454 cleanup routine. */
19457 free_heap_comp_unit (void *data
)
19459 struct dwarf2_cu
*cu
= data
;
19461 gdb_assert (cu
->per_cu
!= NULL
);
19462 cu
->per_cu
->cu
= NULL
;
19465 obstack_free (&cu
->comp_unit_obstack
, NULL
);
19470 /* This cleanup function is passed the address of a dwarf2_cu on the stack
19471 when we're finished with it. We can't free the pointer itself, but be
19472 sure to unlink it from the cache. Also release any associated storage. */
19475 free_stack_comp_unit (void *data
)
19477 struct dwarf2_cu
*cu
= data
;
19479 gdb_assert (cu
->per_cu
!= NULL
);
19480 cu
->per_cu
->cu
= NULL
;
19483 obstack_free (&cu
->comp_unit_obstack
, NULL
);
19484 cu
->partial_dies
= NULL
;
19487 /* Free all cached compilation units. */
19490 free_cached_comp_units (void *data
)
19492 struct dwarf2_per_cu_data
*per_cu
, **last_chain
;
19494 per_cu
= dwarf2_per_objfile
->read_in_chain
;
19495 last_chain
= &dwarf2_per_objfile
->read_in_chain
;
19496 while (per_cu
!= NULL
)
19498 struct dwarf2_per_cu_data
*next_cu
;
19500 next_cu
= per_cu
->cu
->read_in_chain
;
19502 free_heap_comp_unit (per_cu
->cu
);
19503 *last_chain
= next_cu
;
19509 /* Increase the age counter on each cached compilation unit, and free
19510 any that are too old. */
19513 age_cached_comp_units (void)
19515 struct dwarf2_per_cu_data
*per_cu
, **last_chain
;
19517 dwarf2_clear_marks (dwarf2_per_objfile
->read_in_chain
);
19518 per_cu
= dwarf2_per_objfile
->read_in_chain
;
19519 while (per_cu
!= NULL
)
19521 per_cu
->cu
->last_used
++;
19522 if (per_cu
->cu
->last_used
<= dwarf2_max_cache_age
)
19523 dwarf2_mark (per_cu
->cu
);
19524 per_cu
= per_cu
->cu
->read_in_chain
;
19527 per_cu
= dwarf2_per_objfile
->read_in_chain
;
19528 last_chain
= &dwarf2_per_objfile
->read_in_chain
;
19529 while (per_cu
!= NULL
)
19531 struct dwarf2_per_cu_data
*next_cu
;
19533 next_cu
= per_cu
->cu
->read_in_chain
;
19535 if (!per_cu
->cu
->mark
)
19537 free_heap_comp_unit (per_cu
->cu
);
19538 *last_chain
= next_cu
;
19541 last_chain
= &per_cu
->cu
->read_in_chain
;
19547 /* Remove a single compilation unit from the cache. */
19550 free_one_cached_comp_unit (struct dwarf2_per_cu_data
*target_per_cu
)
19552 struct dwarf2_per_cu_data
*per_cu
, **last_chain
;
19554 per_cu
= dwarf2_per_objfile
->read_in_chain
;
19555 last_chain
= &dwarf2_per_objfile
->read_in_chain
;
19556 while (per_cu
!= NULL
)
19558 struct dwarf2_per_cu_data
*next_cu
;
19560 next_cu
= per_cu
->cu
->read_in_chain
;
19562 if (per_cu
== target_per_cu
)
19564 free_heap_comp_unit (per_cu
->cu
);
19566 *last_chain
= next_cu
;
19570 last_chain
= &per_cu
->cu
->read_in_chain
;
19576 /* Release all extra memory associated with OBJFILE. */
19579 dwarf2_free_objfile (struct objfile
*objfile
)
19581 dwarf2_per_objfile
= objfile_data (objfile
, dwarf2_objfile_data_key
);
19583 if (dwarf2_per_objfile
== NULL
)
19586 /* Cached DIE trees use xmalloc and the comp_unit_obstack. */
19587 free_cached_comp_units (NULL
);
19589 if (dwarf2_per_objfile
->quick_file_names_table
)
19590 htab_delete (dwarf2_per_objfile
->quick_file_names_table
);
19592 /* Everything else should be on the objfile obstack. */
19595 /* A set of CU "per_cu" pointer, DIE offset, and GDB type pointer.
19596 We store these in a hash table separate from the DIEs, and preserve them
19597 when the DIEs are flushed out of cache.
19599 The CU "per_cu" pointer is needed because offset alone is not enough to
19600 uniquely identify the type. A file may have multiple .debug_types sections,
19601 or the type may come from a DWO file. Furthermore, while it's more logical
19602 to use per_cu->section+offset, with Fission the section with the data is in
19603 the DWO file but we don't know that section at the point we need it.
19604 We have to use something in dwarf2_per_cu_data (or the pointer to it)
19605 because we can enter the lookup routine, get_die_type_at_offset, from
19606 outside this file, and thus won't necessarily have PER_CU->cu.
19607 Fortunately, PER_CU is stable for the life of the objfile. */
19609 struct dwarf2_per_cu_offset_and_type
19611 const struct dwarf2_per_cu_data
*per_cu
;
19612 sect_offset offset
;
19616 /* Hash function for a dwarf2_per_cu_offset_and_type. */
19619 per_cu_offset_and_type_hash (const void *item
)
19621 const struct dwarf2_per_cu_offset_and_type
*ofs
= item
;
19623 return (uintptr_t) ofs
->per_cu
+ ofs
->offset
.sect_off
;
19626 /* Equality function for a dwarf2_per_cu_offset_and_type. */
19629 per_cu_offset_and_type_eq (const void *item_lhs
, const void *item_rhs
)
19631 const struct dwarf2_per_cu_offset_and_type
*ofs_lhs
= item_lhs
;
19632 const struct dwarf2_per_cu_offset_and_type
*ofs_rhs
= item_rhs
;
19634 return (ofs_lhs
->per_cu
== ofs_rhs
->per_cu
19635 && ofs_lhs
->offset
.sect_off
== ofs_rhs
->offset
.sect_off
);
19638 /* Set the type associated with DIE to TYPE. Save it in CU's hash
19639 table if necessary. For convenience, return TYPE.
19641 The DIEs reading must have careful ordering to:
19642 * Not cause infite loops trying to read in DIEs as a prerequisite for
19643 reading current DIE.
19644 * Not trying to dereference contents of still incompletely read in types
19645 while reading in other DIEs.
19646 * Enable referencing still incompletely read in types just by a pointer to
19647 the type without accessing its fields.
19649 Therefore caller should follow these rules:
19650 * Try to fetch any prerequisite types we may need to build this DIE type
19651 before building the type and calling set_die_type.
19652 * After building type call set_die_type for current DIE as soon as
19653 possible before fetching more types to complete the current type.
19654 * Make the type as complete as possible before fetching more types. */
19656 static struct type
*
19657 set_die_type (struct die_info
*die
, struct type
*type
, struct dwarf2_cu
*cu
)
19659 struct dwarf2_per_cu_offset_and_type
**slot
, ofs
;
19660 struct objfile
*objfile
= cu
->objfile
;
19662 /* For Ada types, make sure that the gnat-specific data is always
19663 initialized (if not already set). There are a few types where
19664 we should not be doing so, because the type-specific area is
19665 already used to hold some other piece of info (eg: TYPE_CODE_FLT
19666 where the type-specific area is used to store the floatformat).
19667 But this is not a problem, because the gnat-specific information
19668 is actually not needed for these types. */
19669 if (need_gnat_info (cu
)
19670 && TYPE_CODE (type
) != TYPE_CODE_FUNC
19671 && TYPE_CODE (type
) != TYPE_CODE_FLT
19672 && !HAVE_GNAT_AUX_INFO (type
))
19673 INIT_GNAT_SPECIFIC (type
);
19675 if (dwarf2_per_objfile
->die_type_hash
== NULL
)
19677 dwarf2_per_objfile
->die_type_hash
=
19678 htab_create_alloc_ex (127,
19679 per_cu_offset_and_type_hash
,
19680 per_cu_offset_and_type_eq
,
19682 &objfile
->objfile_obstack
,
19683 hashtab_obstack_allocate
,
19684 dummy_obstack_deallocate
);
19687 ofs
.per_cu
= cu
->per_cu
;
19688 ofs
.offset
= die
->offset
;
19690 slot
= (struct dwarf2_per_cu_offset_and_type
**)
19691 htab_find_slot (dwarf2_per_objfile
->die_type_hash
, &ofs
, INSERT
);
19693 complaint (&symfile_complaints
,
19694 _("A problem internal to GDB: DIE 0x%x has type already set"),
19695 die
->offset
.sect_off
);
19696 *slot
= obstack_alloc (&objfile
->objfile_obstack
, sizeof (**slot
));
19701 /* Look up the type for the die at OFFSET in PER_CU in die_type_hash,
19702 or return NULL if the die does not have a saved type. */
19704 static struct type
*
19705 get_die_type_at_offset (sect_offset offset
,
19706 struct dwarf2_per_cu_data
*per_cu
)
19708 struct dwarf2_per_cu_offset_and_type
*slot
, ofs
;
19710 if (dwarf2_per_objfile
->die_type_hash
== NULL
)
19713 ofs
.per_cu
= per_cu
;
19714 ofs
.offset
= offset
;
19715 slot
= htab_find (dwarf2_per_objfile
->die_type_hash
, &ofs
);
19722 /* Look up the type for DIE in CU in die_type_hash,
19723 or return NULL if DIE does not have a saved type. */
19725 static struct type
*
19726 get_die_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
19728 return get_die_type_at_offset (die
->offset
, cu
->per_cu
);
19731 /* Add a dependence relationship from CU to REF_PER_CU. */
19734 dwarf2_add_dependence (struct dwarf2_cu
*cu
,
19735 struct dwarf2_per_cu_data
*ref_per_cu
)
19739 if (cu
->dependencies
== NULL
)
19741 = htab_create_alloc_ex (5, htab_hash_pointer
, htab_eq_pointer
,
19742 NULL
, &cu
->comp_unit_obstack
,
19743 hashtab_obstack_allocate
,
19744 dummy_obstack_deallocate
);
19746 slot
= htab_find_slot (cu
->dependencies
, ref_per_cu
, INSERT
);
19748 *slot
= ref_per_cu
;
19751 /* Subroutine of dwarf2_mark to pass to htab_traverse.
19752 Set the mark field in every compilation unit in the
19753 cache that we must keep because we are keeping CU. */
19756 dwarf2_mark_helper (void **slot
, void *data
)
19758 struct dwarf2_per_cu_data
*per_cu
;
19760 per_cu
= (struct dwarf2_per_cu_data
*) *slot
;
19762 /* cu->dependencies references may not yet have been ever read if QUIT aborts
19763 reading of the chain. As such dependencies remain valid it is not much
19764 useful to track and undo them during QUIT cleanups. */
19765 if (per_cu
->cu
== NULL
)
19768 if (per_cu
->cu
->mark
)
19770 per_cu
->cu
->mark
= 1;
19772 if (per_cu
->cu
->dependencies
!= NULL
)
19773 htab_traverse (per_cu
->cu
->dependencies
, dwarf2_mark_helper
, NULL
);
19778 /* Set the mark field in CU and in every other compilation unit in the
19779 cache that we must keep because we are keeping CU. */
19782 dwarf2_mark (struct dwarf2_cu
*cu
)
19787 if (cu
->dependencies
!= NULL
)
19788 htab_traverse (cu
->dependencies
, dwarf2_mark_helper
, NULL
);
19792 dwarf2_clear_marks (struct dwarf2_per_cu_data
*per_cu
)
19796 per_cu
->cu
->mark
= 0;
19797 per_cu
= per_cu
->cu
->read_in_chain
;
19801 /* Trivial hash function for partial_die_info: the hash value of a DIE
19802 is its offset in .debug_info for this objfile. */
19805 partial_die_hash (const void *item
)
19807 const struct partial_die_info
*part_die
= item
;
19809 return part_die
->offset
.sect_off
;
19812 /* Trivial comparison function for partial_die_info structures: two DIEs
19813 are equal if they have the same offset. */
19816 partial_die_eq (const void *item_lhs
, const void *item_rhs
)
19818 const struct partial_die_info
*part_die_lhs
= item_lhs
;
19819 const struct partial_die_info
*part_die_rhs
= item_rhs
;
19821 return part_die_lhs
->offset
.sect_off
== part_die_rhs
->offset
.sect_off
;
19824 static struct cmd_list_element
*set_dwarf2_cmdlist
;
19825 static struct cmd_list_element
*show_dwarf2_cmdlist
;
19828 set_dwarf2_cmd (char *args
, int from_tty
)
19830 help_list (set_dwarf2_cmdlist
, "maintenance set dwarf2 ", -1, gdb_stdout
);
19834 show_dwarf2_cmd (char *args
, int from_tty
)
19836 cmd_show_list (show_dwarf2_cmdlist
, from_tty
, "");
19839 /* Free data associated with OBJFILE, if necessary. */
19842 dwarf2_per_objfile_free (struct objfile
*objfile
, void *d
)
19844 struct dwarf2_per_objfile
*data
= d
;
19847 for (ix
= 0; ix
< dwarf2_per_objfile
->n_comp_units
; ++ix
)
19848 VEC_free (dwarf2_per_cu_ptr
,
19849 dwarf2_per_objfile
->all_comp_units
[ix
]->imported_symtabs
);
19851 for (ix
= 0; ix
< dwarf2_per_objfile
->n_type_units
; ++ix
)
19852 VEC_free (dwarf2_per_cu_ptr
,
19853 dwarf2_per_objfile
->all_type_units
[ix
]->per_cu
.imported_symtabs
);
19855 VEC_free (dwarf2_section_info_def
, data
->types
);
19857 if (data
->dwo_files
)
19858 free_dwo_files (data
->dwo_files
, objfile
);
19859 if (data
->dwp_file
)
19860 gdb_bfd_unref (data
->dwp_file
->dbfd
);
19862 if (data
->dwz_file
&& data
->dwz_file
->dwz_bfd
)
19863 gdb_bfd_unref (data
->dwz_file
->dwz_bfd
);
19867 /* The "save gdb-index" command. */
19869 /* The contents of the hash table we create when building the string
19871 struct strtab_entry
19873 offset_type offset
;
19877 /* Hash function for a strtab_entry.
19879 Function is used only during write_hash_table so no index format backward
19880 compatibility is needed. */
19883 hash_strtab_entry (const void *e
)
19885 const struct strtab_entry
*entry
= e
;
19886 return mapped_index_string_hash (INT_MAX
, entry
->str
);
19889 /* Equality function for a strtab_entry. */
19892 eq_strtab_entry (const void *a
, const void *b
)
19894 const struct strtab_entry
*ea
= a
;
19895 const struct strtab_entry
*eb
= b
;
19896 return !strcmp (ea
->str
, eb
->str
);
19899 /* Create a strtab_entry hash table. */
19902 create_strtab (void)
19904 return htab_create_alloc (100, hash_strtab_entry
, eq_strtab_entry
,
19905 xfree
, xcalloc
, xfree
);
19908 /* Add a string to the constant pool. Return the string's offset in
19912 add_string (htab_t table
, struct obstack
*cpool
, const char *str
)
19915 struct strtab_entry entry
;
19916 struct strtab_entry
*result
;
19919 slot
= htab_find_slot (table
, &entry
, INSERT
);
19924 result
= XNEW (struct strtab_entry
);
19925 result
->offset
= obstack_object_size (cpool
);
19927 obstack_grow_str0 (cpool
, str
);
19930 return result
->offset
;
19933 /* An entry in the symbol table. */
19934 struct symtab_index_entry
19936 /* The name of the symbol. */
19938 /* The offset of the name in the constant pool. */
19939 offset_type index_offset
;
19940 /* A sorted vector of the indices of all the CUs that hold an object
19942 VEC (offset_type
) *cu_indices
;
19945 /* The symbol table. This is a power-of-2-sized hash table. */
19946 struct mapped_symtab
19948 offset_type n_elements
;
19950 struct symtab_index_entry
**data
;
19953 /* Hash function for a symtab_index_entry. */
19956 hash_symtab_entry (const void *e
)
19958 const struct symtab_index_entry
*entry
= e
;
19959 return iterative_hash (VEC_address (offset_type
, entry
->cu_indices
),
19960 sizeof (offset_type
) * VEC_length (offset_type
,
19961 entry
->cu_indices
),
19965 /* Equality function for a symtab_index_entry. */
19968 eq_symtab_entry (const void *a
, const void *b
)
19970 const struct symtab_index_entry
*ea
= a
;
19971 const struct symtab_index_entry
*eb
= b
;
19972 int len
= VEC_length (offset_type
, ea
->cu_indices
);
19973 if (len
!= VEC_length (offset_type
, eb
->cu_indices
))
19975 return !memcmp (VEC_address (offset_type
, ea
->cu_indices
),
19976 VEC_address (offset_type
, eb
->cu_indices
),
19977 sizeof (offset_type
) * len
);
19980 /* Destroy a symtab_index_entry. */
19983 delete_symtab_entry (void *p
)
19985 struct symtab_index_entry
*entry
= p
;
19986 VEC_free (offset_type
, entry
->cu_indices
);
19990 /* Create a hash table holding symtab_index_entry objects. */
19993 create_symbol_hash_table (void)
19995 return htab_create_alloc (100, hash_symtab_entry
, eq_symtab_entry
,
19996 delete_symtab_entry
, xcalloc
, xfree
);
19999 /* Create a new mapped symtab object. */
20001 static struct mapped_symtab
*
20002 create_mapped_symtab (void)
20004 struct mapped_symtab
*symtab
= XNEW (struct mapped_symtab
);
20005 symtab
->n_elements
= 0;
20006 symtab
->size
= 1024;
20007 symtab
->data
= XCNEWVEC (struct symtab_index_entry
*, symtab
->size
);
20011 /* Destroy a mapped_symtab. */
20014 cleanup_mapped_symtab (void *p
)
20016 struct mapped_symtab
*symtab
= p
;
20017 /* The contents of the array are freed when the other hash table is
20019 xfree (symtab
->data
);
20023 /* Find a slot in SYMTAB for the symbol NAME. Returns a pointer to
20026 Function is used only during write_hash_table so no index format backward
20027 compatibility is needed. */
20029 static struct symtab_index_entry
**
20030 find_slot (struct mapped_symtab
*symtab
, const char *name
)
20032 offset_type index
, step
, hash
= mapped_index_string_hash (INT_MAX
, name
);
20034 index
= hash
& (symtab
->size
- 1);
20035 step
= ((hash
* 17) & (symtab
->size
- 1)) | 1;
20039 if (!symtab
->data
[index
] || !strcmp (name
, symtab
->data
[index
]->name
))
20040 return &symtab
->data
[index
];
20041 index
= (index
+ step
) & (symtab
->size
- 1);
20045 /* Expand SYMTAB's hash table. */
20048 hash_expand (struct mapped_symtab
*symtab
)
20050 offset_type old_size
= symtab
->size
;
20052 struct symtab_index_entry
**old_entries
= symtab
->data
;
20055 symtab
->data
= XCNEWVEC (struct symtab_index_entry
*, symtab
->size
);
20057 for (i
= 0; i
< old_size
; ++i
)
20059 if (old_entries
[i
])
20061 struct symtab_index_entry
**slot
= find_slot (symtab
,
20062 old_entries
[i
]->name
);
20063 *slot
= old_entries
[i
];
20067 xfree (old_entries
);
20070 /* Add an entry to SYMTAB. NAME is the name of the symbol.
20071 CU_INDEX is the index of the CU in which the symbol appears.
20072 IS_STATIC is one if the symbol is static, otherwise zero (global). */
20075 add_index_entry (struct mapped_symtab
*symtab
, const char *name
,
20076 int is_static
, gdb_index_symbol_kind kind
,
20077 offset_type cu_index
)
20079 struct symtab_index_entry
**slot
;
20080 offset_type cu_index_and_attrs
;
20082 ++symtab
->n_elements
;
20083 if (4 * symtab
->n_elements
/ 3 >= symtab
->size
)
20084 hash_expand (symtab
);
20086 slot
= find_slot (symtab
, name
);
20089 *slot
= XNEW (struct symtab_index_entry
);
20090 (*slot
)->name
= name
;
20091 /* index_offset is set later. */
20092 (*slot
)->cu_indices
= NULL
;
20095 cu_index_and_attrs
= 0;
20096 DW2_GDB_INDEX_CU_SET_VALUE (cu_index_and_attrs
, cu_index
);
20097 DW2_GDB_INDEX_SYMBOL_STATIC_SET_VALUE (cu_index_and_attrs
, is_static
);
20098 DW2_GDB_INDEX_SYMBOL_KIND_SET_VALUE (cu_index_and_attrs
, kind
);
20100 /* We don't want to record an index value twice as we want to avoid the
20102 We process all global symbols and then all static symbols
20103 (which would allow us to avoid the duplication by only having to check
20104 the last entry pushed), but a symbol could have multiple kinds in one CU.
20105 To keep things simple we don't worry about the duplication here and
20106 sort and uniqufy the list after we've processed all symbols. */
20107 VEC_safe_push (offset_type
, (*slot
)->cu_indices
, cu_index_and_attrs
);
20110 /* qsort helper routine for uniquify_cu_indices. */
20113 offset_type_compare (const void *ap
, const void *bp
)
20115 offset_type a
= *(offset_type
*) ap
;
20116 offset_type b
= *(offset_type
*) bp
;
20118 return (a
> b
) - (b
> a
);
20121 /* Sort and remove duplicates of all symbols' cu_indices lists. */
20124 uniquify_cu_indices (struct mapped_symtab
*symtab
)
20128 for (i
= 0; i
< symtab
->size
; ++i
)
20130 struct symtab_index_entry
*entry
= symtab
->data
[i
];
20133 && entry
->cu_indices
!= NULL
)
20135 unsigned int next_to_insert
, next_to_check
;
20136 offset_type last_value
;
20138 qsort (VEC_address (offset_type
, entry
->cu_indices
),
20139 VEC_length (offset_type
, entry
->cu_indices
),
20140 sizeof (offset_type
), offset_type_compare
);
20142 last_value
= VEC_index (offset_type
, entry
->cu_indices
, 0);
20143 next_to_insert
= 1;
20144 for (next_to_check
= 1;
20145 next_to_check
< VEC_length (offset_type
, entry
->cu_indices
);
20148 if (VEC_index (offset_type
, entry
->cu_indices
, next_to_check
)
20151 last_value
= VEC_index (offset_type
, entry
->cu_indices
,
20153 VEC_replace (offset_type
, entry
->cu_indices
, next_to_insert
,
20158 VEC_truncate (offset_type
, entry
->cu_indices
, next_to_insert
);
20163 /* Add a vector of indices to the constant pool. */
20166 add_indices_to_cpool (htab_t symbol_hash_table
, struct obstack
*cpool
,
20167 struct symtab_index_entry
*entry
)
20171 slot
= htab_find_slot (symbol_hash_table
, entry
, INSERT
);
20174 offset_type len
= VEC_length (offset_type
, entry
->cu_indices
);
20175 offset_type val
= MAYBE_SWAP (len
);
20180 entry
->index_offset
= obstack_object_size (cpool
);
20182 obstack_grow (cpool
, &val
, sizeof (val
));
20184 VEC_iterate (offset_type
, entry
->cu_indices
, i
, iter
);
20187 val
= MAYBE_SWAP (iter
);
20188 obstack_grow (cpool
, &val
, sizeof (val
));
20193 struct symtab_index_entry
*old_entry
= *slot
;
20194 entry
->index_offset
= old_entry
->index_offset
;
20197 return entry
->index_offset
;
20200 /* Write the mapped hash table SYMTAB to the obstack OUTPUT, with
20201 constant pool entries going into the obstack CPOOL. */
20204 write_hash_table (struct mapped_symtab
*symtab
,
20205 struct obstack
*output
, struct obstack
*cpool
)
20208 htab_t symbol_hash_table
;
20211 symbol_hash_table
= create_symbol_hash_table ();
20212 str_table
= create_strtab ();
20214 /* We add all the index vectors to the constant pool first, to
20215 ensure alignment is ok. */
20216 for (i
= 0; i
< symtab
->size
; ++i
)
20218 if (symtab
->data
[i
])
20219 add_indices_to_cpool (symbol_hash_table
, cpool
, symtab
->data
[i
]);
20222 /* Now write out the hash table. */
20223 for (i
= 0; i
< symtab
->size
; ++i
)
20225 offset_type str_off
, vec_off
;
20227 if (symtab
->data
[i
])
20229 str_off
= add_string (str_table
, cpool
, symtab
->data
[i
]->name
);
20230 vec_off
= symtab
->data
[i
]->index_offset
;
20234 /* While 0 is a valid constant pool index, it is not valid
20235 to have 0 for both offsets. */
20240 str_off
= MAYBE_SWAP (str_off
);
20241 vec_off
= MAYBE_SWAP (vec_off
);
20243 obstack_grow (output
, &str_off
, sizeof (str_off
));
20244 obstack_grow (output
, &vec_off
, sizeof (vec_off
));
20247 htab_delete (str_table
);
20248 htab_delete (symbol_hash_table
);
20251 /* Struct to map psymtab to CU index in the index file. */
20252 struct psymtab_cu_index_map
20254 struct partial_symtab
*psymtab
;
20255 unsigned int cu_index
;
20259 hash_psymtab_cu_index (const void *item
)
20261 const struct psymtab_cu_index_map
*map
= item
;
20263 return htab_hash_pointer (map
->psymtab
);
20267 eq_psymtab_cu_index (const void *item_lhs
, const void *item_rhs
)
20269 const struct psymtab_cu_index_map
*lhs
= item_lhs
;
20270 const struct psymtab_cu_index_map
*rhs
= item_rhs
;
20272 return lhs
->psymtab
== rhs
->psymtab
;
20275 /* Helper struct for building the address table. */
20276 struct addrmap_index_data
20278 struct objfile
*objfile
;
20279 struct obstack
*addr_obstack
;
20280 htab_t cu_index_htab
;
20282 /* Non-zero if the previous_* fields are valid.
20283 We can't write an entry until we see the next entry (since it is only then
20284 that we know the end of the entry). */
20285 int previous_valid
;
20286 /* Index of the CU in the table of all CUs in the index file. */
20287 unsigned int previous_cu_index
;
20288 /* Start address of the CU. */
20289 CORE_ADDR previous_cu_start
;
20292 /* Write an address entry to OBSTACK. */
20295 add_address_entry (struct objfile
*objfile
, struct obstack
*obstack
,
20296 CORE_ADDR start
, CORE_ADDR end
, unsigned int cu_index
)
20298 offset_type cu_index_to_write
;
20300 CORE_ADDR baseaddr
;
20302 baseaddr
= ANOFFSET (objfile
->section_offsets
, SECT_OFF_TEXT (objfile
));
20304 store_unsigned_integer (addr
, 8, BFD_ENDIAN_LITTLE
, start
- baseaddr
);
20305 obstack_grow (obstack
, addr
, 8);
20306 store_unsigned_integer (addr
, 8, BFD_ENDIAN_LITTLE
, end
- baseaddr
);
20307 obstack_grow (obstack
, addr
, 8);
20308 cu_index_to_write
= MAYBE_SWAP (cu_index
);
20309 obstack_grow (obstack
, &cu_index_to_write
, sizeof (offset_type
));
20312 /* Worker function for traversing an addrmap to build the address table. */
20315 add_address_entry_worker (void *datap
, CORE_ADDR start_addr
, void *obj
)
20317 struct addrmap_index_data
*data
= datap
;
20318 struct partial_symtab
*pst
= obj
;
20320 if (data
->previous_valid
)
20321 add_address_entry (data
->objfile
, data
->addr_obstack
,
20322 data
->previous_cu_start
, start_addr
,
20323 data
->previous_cu_index
);
20325 data
->previous_cu_start
= start_addr
;
20328 struct psymtab_cu_index_map find_map
, *map
;
20329 find_map
.psymtab
= pst
;
20330 map
= htab_find (data
->cu_index_htab
, &find_map
);
20331 gdb_assert (map
!= NULL
);
20332 data
->previous_cu_index
= map
->cu_index
;
20333 data
->previous_valid
= 1;
20336 data
->previous_valid
= 0;
20341 /* Write OBJFILE's address map to OBSTACK.
20342 CU_INDEX_HTAB is used to map addrmap entries to their CU indices
20343 in the index file. */
20346 write_address_map (struct objfile
*objfile
, struct obstack
*obstack
,
20347 htab_t cu_index_htab
)
20349 struct addrmap_index_data addrmap_index_data
;
20351 /* When writing the address table, we have to cope with the fact that
20352 the addrmap iterator only provides the start of a region; we have to
20353 wait until the next invocation to get the start of the next region. */
20355 addrmap_index_data
.objfile
= objfile
;
20356 addrmap_index_data
.addr_obstack
= obstack
;
20357 addrmap_index_data
.cu_index_htab
= cu_index_htab
;
20358 addrmap_index_data
.previous_valid
= 0;
20360 addrmap_foreach (objfile
->psymtabs_addrmap
, add_address_entry_worker
,
20361 &addrmap_index_data
);
20363 /* It's highly unlikely the last entry (end address = 0xff...ff)
20364 is valid, but we should still handle it.
20365 The end address is recorded as the start of the next region, but that
20366 doesn't work here. To cope we pass 0xff...ff, this is a rare situation
20368 if (addrmap_index_data
.previous_valid
)
20369 add_address_entry (objfile
, obstack
,
20370 addrmap_index_data
.previous_cu_start
, (CORE_ADDR
) -1,
20371 addrmap_index_data
.previous_cu_index
);
20374 /* Return the symbol kind of PSYM. */
20376 static gdb_index_symbol_kind
20377 symbol_kind (struct partial_symbol
*psym
)
20379 domain_enum domain
= PSYMBOL_DOMAIN (psym
);
20380 enum address_class aclass
= PSYMBOL_CLASS (psym
);
20388 return GDB_INDEX_SYMBOL_KIND_FUNCTION
;
20390 return GDB_INDEX_SYMBOL_KIND_TYPE
;
20392 case LOC_CONST_BYTES
:
20393 case LOC_OPTIMIZED_OUT
:
20395 return GDB_INDEX_SYMBOL_KIND_VARIABLE
;
20397 /* Note: It's currently impossible to recognize psyms as enum values
20398 short of reading the type info. For now punt. */
20399 return GDB_INDEX_SYMBOL_KIND_VARIABLE
;
20401 /* There are other LOC_FOO values that one might want to classify
20402 as variables, but dwarf2read.c doesn't currently use them. */
20403 return GDB_INDEX_SYMBOL_KIND_OTHER
;
20405 case STRUCT_DOMAIN
:
20406 return GDB_INDEX_SYMBOL_KIND_TYPE
;
20408 return GDB_INDEX_SYMBOL_KIND_OTHER
;
20412 /* Add a list of partial symbols to SYMTAB. */
20415 write_psymbols (struct mapped_symtab
*symtab
,
20417 struct partial_symbol
**psymp
,
20419 offset_type cu_index
,
20422 for (; count
-- > 0; ++psymp
)
20424 struct partial_symbol
*psym
= *psymp
;
20427 if (SYMBOL_LANGUAGE (psym
) == language_ada
)
20428 error (_("Ada is not currently supported by the index"));
20430 /* Only add a given psymbol once. */
20431 slot
= htab_find_slot (psyms_seen
, psym
, INSERT
);
20434 gdb_index_symbol_kind kind
= symbol_kind (psym
);
20437 add_index_entry (symtab
, SYMBOL_SEARCH_NAME (psym
),
20438 is_static
, kind
, cu_index
);
20443 /* Write the contents of an ("unfinished") obstack to FILE. Throw an
20444 exception if there is an error. */
20447 write_obstack (FILE *file
, struct obstack
*obstack
)
20449 if (fwrite (obstack_base (obstack
), 1, obstack_object_size (obstack
),
20451 != obstack_object_size (obstack
))
20452 error (_("couldn't data write to file"));
20455 /* Unlink a file if the argument is not NULL. */
20458 unlink_if_set (void *p
)
20460 char **filename
= p
;
20462 unlink (*filename
);
20465 /* A helper struct used when iterating over debug_types. */
20466 struct signatured_type_index_data
20468 struct objfile
*objfile
;
20469 struct mapped_symtab
*symtab
;
20470 struct obstack
*types_list
;
20475 /* A helper function that writes a single signatured_type to an
20479 write_one_signatured_type (void **slot
, void *d
)
20481 struct signatured_type_index_data
*info
= d
;
20482 struct signatured_type
*entry
= (struct signatured_type
*) *slot
;
20483 struct partial_symtab
*psymtab
= entry
->per_cu
.v
.psymtab
;
20486 write_psymbols (info
->symtab
,
20488 info
->objfile
->global_psymbols
.list
20489 + psymtab
->globals_offset
,
20490 psymtab
->n_global_syms
, info
->cu_index
,
20492 write_psymbols (info
->symtab
,
20494 info
->objfile
->static_psymbols
.list
20495 + psymtab
->statics_offset
,
20496 psymtab
->n_static_syms
, info
->cu_index
,
20499 store_unsigned_integer (val
, 8, BFD_ENDIAN_LITTLE
,
20500 entry
->per_cu
.offset
.sect_off
);
20501 obstack_grow (info
->types_list
, val
, 8);
20502 store_unsigned_integer (val
, 8, BFD_ENDIAN_LITTLE
,
20503 entry
->type_offset_in_tu
.cu_off
);
20504 obstack_grow (info
->types_list
, val
, 8);
20505 store_unsigned_integer (val
, 8, BFD_ENDIAN_LITTLE
, entry
->signature
);
20506 obstack_grow (info
->types_list
, val
, 8);
20513 /* Recurse into all "included" dependencies and write their symbols as
20514 if they appeared in this psymtab. */
20517 recursively_write_psymbols (struct objfile
*objfile
,
20518 struct partial_symtab
*psymtab
,
20519 struct mapped_symtab
*symtab
,
20521 offset_type cu_index
)
20525 for (i
= 0; i
< psymtab
->number_of_dependencies
; ++i
)
20526 if (psymtab
->dependencies
[i
]->user
!= NULL
)
20527 recursively_write_psymbols (objfile
, psymtab
->dependencies
[i
],
20528 symtab
, psyms_seen
, cu_index
);
20530 write_psymbols (symtab
,
20532 objfile
->global_psymbols
.list
+ psymtab
->globals_offset
,
20533 psymtab
->n_global_syms
, cu_index
,
20535 write_psymbols (symtab
,
20537 objfile
->static_psymbols
.list
+ psymtab
->statics_offset
,
20538 psymtab
->n_static_syms
, cu_index
,
20542 /* Create an index file for OBJFILE in the directory DIR. */
20545 write_psymtabs_to_index (struct objfile
*objfile
, const char *dir
)
20547 struct cleanup
*cleanup
;
20548 char *filename
, *cleanup_filename
;
20549 struct obstack contents
, addr_obstack
, constant_pool
, symtab_obstack
;
20550 struct obstack cu_list
, types_cu_list
;
20553 struct mapped_symtab
*symtab
;
20554 offset_type val
, size_of_contents
, total_len
;
20557 htab_t cu_index_htab
;
20558 struct psymtab_cu_index_map
*psymtab_cu_index_map
;
20560 if (!objfile
->psymtabs
|| !objfile
->psymtabs_addrmap
)
20563 if (dwarf2_per_objfile
->using_index
)
20564 error (_("Cannot use an index to create the index"));
20566 if (VEC_length (dwarf2_section_info_def
, dwarf2_per_objfile
->types
) > 1)
20567 error (_("Cannot make an index when the file has multiple .debug_types sections"));
20569 if (stat (objfile
->name
, &st
) < 0)
20570 perror_with_name (objfile
->name
);
20572 filename
= concat (dir
, SLASH_STRING
, lbasename (objfile
->name
),
20573 INDEX_SUFFIX
, (char *) NULL
);
20574 cleanup
= make_cleanup (xfree
, filename
);
20576 out_file
= fopen (filename
, "wb");
20578 error (_("Can't open `%s' for writing"), filename
);
20580 cleanup_filename
= filename
;
20581 make_cleanup (unlink_if_set
, &cleanup_filename
);
20583 symtab
= create_mapped_symtab ();
20584 make_cleanup (cleanup_mapped_symtab
, symtab
);
20586 obstack_init (&addr_obstack
);
20587 make_cleanup_obstack_free (&addr_obstack
);
20589 obstack_init (&cu_list
);
20590 make_cleanup_obstack_free (&cu_list
);
20592 obstack_init (&types_cu_list
);
20593 make_cleanup_obstack_free (&types_cu_list
);
20595 psyms_seen
= htab_create_alloc (100, htab_hash_pointer
, htab_eq_pointer
,
20596 NULL
, xcalloc
, xfree
);
20597 make_cleanup_htab_delete (psyms_seen
);
20599 /* While we're scanning CU's create a table that maps a psymtab pointer
20600 (which is what addrmap records) to its index (which is what is recorded
20601 in the index file). This will later be needed to write the address
20603 cu_index_htab
= htab_create_alloc (100,
20604 hash_psymtab_cu_index
,
20605 eq_psymtab_cu_index
,
20606 NULL
, xcalloc
, xfree
);
20607 make_cleanup_htab_delete (cu_index_htab
);
20608 psymtab_cu_index_map
= (struct psymtab_cu_index_map
*)
20609 xmalloc (sizeof (struct psymtab_cu_index_map
)
20610 * dwarf2_per_objfile
->n_comp_units
);
20611 make_cleanup (xfree
, psymtab_cu_index_map
);
20613 /* The CU list is already sorted, so we don't need to do additional
20614 work here. Also, the debug_types entries do not appear in
20615 all_comp_units, but only in their own hash table. */
20616 for (i
= 0; i
< dwarf2_per_objfile
->n_comp_units
; ++i
)
20618 struct dwarf2_per_cu_data
*per_cu
20619 = dwarf2_per_objfile
->all_comp_units
[i
];
20620 struct partial_symtab
*psymtab
= per_cu
->v
.psymtab
;
20622 struct psymtab_cu_index_map
*map
;
20625 if (psymtab
->user
== NULL
)
20626 recursively_write_psymbols (objfile
, psymtab
, symtab
, psyms_seen
, i
);
20628 map
= &psymtab_cu_index_map
[i
];
20629 map
->psymtab
= psymtab
;
20631 slot
= htab_find_slot (cu_index_htab
, map
, INSERT
);
20632 gdb_assert (slot
!= NULL
);
20633 gdb_assert (*slot
== NULL
);
20636 store_unsigned_integer (val
, 8, BFD_ENDIAN_LITTLE
,
20637 per_cu
->offset
.sect_off
);
20638 obstack_grow (&cu_list
, val
, 8);
20639 store_unsigned_integer (val
, 8, BFD_ENDIAN_LITTLE
, per_cu
->length
);
20640 obstack_grow (&cu_list
, val
, 8);
20643 /* Dump the address map. */
20644 write_address_map (objfile
, &addr_obstack
, cu_index_htab
);
20646 /* Write out the .debug_type entries, if any. */
20647 if (dwarf2_per_objfile
->signatured_types
)
20649 struct signatured_type_index_data sig_data
;
20651 sig_data
.objfile
= objfile
;
20652 sig_data
.symtab
= symtab
;
20653 sig_data
.types_list
= &types_cu_list
;
20654 sig_data
.psyms_seen
= psyms_seen
;
20655 sig_data
.cu_index
= dwarf2_per_objfile
->n_comp_units
;
20656 htab_traverse_noresize (dwarf2_per_objfile
->signatured_types
,
20657 write_one_signatured_type
, &sig_data
);
20660 /* Now that we've processed all symbols we can shrink their cu_indices
20662 uniquify_cu_indices (symtab
);
20664 obstack_init (&constant_pool
);
20665 make_cleanup_obstack_free (&constant_pool
);
20666 obstack_init (&symtab_obstack
);
20667 make_cleanup_obstack_free (&symtab_obstack
);
20668 write_hash_table (symtab
, &symtab_obstack
, &constant_pool
);
20670 obstack_init (&contents
);
20671 make_cleanup_obstack_free (&contents
);
20672 size_of_contents
= 6 * sizeof (offset_type
);
20673 total_len
= size_of_contents
;
20675 /* The version number. */
20676 val
= MAYBE_SWAP (8);
20677 obstack_grow (&contents
, &val
, sizeof (val
));
20679 /* The offset of the CU list from the start of the file. */
20680 val
= MAYBE_SWAP (total_len
);
20681 obstack_grow (&contents
, &val
, sizeof (val
));
20682 total_len
+= obstack_object_size (&cu_list
);
20684 /* The offset of the types CU list from the start of the file. */
20685 val
= MAYBE_SWAP (total_len
);
20686 obstack_grow (&contents
, &val
, sizeof (val
));
20687 total_len
+= obstack_object_size (&types_cu_list
);
20689 /* The offset of the address table from the start of the file. */
20690 val
= MAYBE_SWAP (total_len
);
20691 obstack_grow (&contents
, &val
, sizeof (val
));
20692 total_len
+= obstack_object_size (&addr_obstack
);
20694 /* The offset of the symbol table from the start of the file. */
20695 val
= MAYBE_SWAP (total_len
);
20696 obstack_grow (&contents
, &val
, sizeof (val
));
20697 total_len
+= obstack_object_size (&symtab_obstack
);
20699 /* The offset of the constant pool from the start of the file. */
20700 val
= MAYBE_SWAP (total_len
);
20701 obstack_grow (&contents
, &val
, sizeof (val
));
20702 total_len
+= obstack_object_size (&constant_pool
);
20704 gdb_assert (obstack_object_size (&contents
) == size_of_contents
);
20706 write_obstack (out_file
, &contents
);
20707 write_obstack (out_file
, &cu_list
);
20708 write_obstack (out_file
, &types_cu_list
);
20709 write_obstack (out_file
, &addr_obstack
);
20710 write_obstack (out_file
, &symtab_obstack
);
20711 write_obstack (out_file
, &constant_pool
);
20715 /* We want to keep the file, so we set cleanup_filename to NULL
20716 here. See unlink_if_set. */
20717 cleanup_filename
= NULL
;
20719 do_cleanups (cleanup
);
20722 /* Implementation of the `save gdb-index' command.
20724 Note that the file format used by this command is documented in the
20725 GDB manual. Any changes here must be documented there. */
20728 save_gdb_index_command (char *arg
, int from_tty
)
20730 struct objfile
*objfile
;
20733 error (_("usage: save gdb-index DIRECTORY"));
20735 ALL_OBJFILES (objfile
)
20739 /* If the objfile does not correspond to an actual file, skip it. */
20740 if (stat (objfile
->name
, &st
) < 0)
20743 dwarf2_per_objfile
= objfile_data (objfile
, dwarf2_objfile_data_key
);
20744 if (dwarf2_per_objfile
)
20746 volatile struct gdb_exception except
;
20748 TRY_CATCH (except
, RETURN_MASK_ERROR
)
20750 write_psymtabs_to_index (objfile
, arg
);
20752 if (except
.reason
< 0)
20753 exception_fprintf (gdb_stderr
, except
,
20754 _("Error while writing index for `%s': "),
20762 int dwarf2_always_disassemble
;
20765 show_dwarf2_always_disassemble (struct ui_file
*file
, int from_tty
,
20766 struct cmd_list_element
*c
, const char *value
)
20768 fprintf_filtered (file
,
20769 _("Whether to always disassemble "
20770 "DWARF expressions is %s.\n"),
20775 show_check_physname (struct ui_file
*file
, int from_tty
,
20776 struct cmd_list_element
*c
, const char *value
)
20778 fprintf_filtered (file
,
20779 _("Whether to check \"physname\" is %s.\n"),
20783 void _initialize_dwarf2_read (void);
20786 _initialize_dwarf2_read (void)
20788 struct cmd_list_element
*c
;
20790 dwarf2_objfile_data_key
20791 = register_objfile_data_with_cleanup (NULL
, dwarf2_per_objfile_free
);
20793 add_prefix_cmd ("dwarf2", class_maintenance
, set_dwarf2_cmd
, _("\
20794 Set DWARF 2 specific variables.\n\
20795 Configure DWARF 2 variables such as the cache size"),
20796 &set_dwarf2_cmdlist
, "maintenance set dwarf2 ",
20797 0/*allow-unknown*/, &maintenance_set_cmdlist
);
20799 add_prefix_cmd ("dwarf2", class_maintenance
, show_dwarf2_cmd
, _("\
20800 Show DWARF 2 specific variables\n\
20801 Show DWARF 2 variables such as the cache size"),
20802 &show_dwarf2_cmdlist
, "maintenance show dwarf2 ",
20803 0/*allow-unknown*/, &maintenance_show_cmdlist
);
20805 add_setshow_zinteger_cmd ("max-cache-age", class_obscure
,
20806 &dwarf2_max_cache_age
, _("\
20807 Set the upper bound on the age of cached dwarf2 compilation units."), _("\
20808 Show the upper bound on the age of cached dwarf2 compilation units."), _("\
20809 A higher limit means that cached compilation units will be stored\n\
20810 in memory longer, and more total memory will be used. Zero disables\n\
20811 caching, which can slow down startup."),
20813 show_dwarf2_max_cache_age
,
20814 &set_dwarf2_cmdlist
,
20815 &show_dwarf2_cmdlist
);
20817 add_setshow_boolean_cmd ("always-disassemble", class_obscure
,
20818 &dwarf2_always_disassemble
, _("\
20819 Set whether `info address' always disassembles DWARF expressions."), _("\
20820 Show whether `info address' always disassembles DWARF expressions."), _("\
20821 When enabled, DWARF expressions are always printed in an assembly-like\n\
20822 syntax. When disabled, expressions will be printed in a more\n\
20823 conversational style, when possible."),
20825 show_dwarf2_always_disassemble
,
20826 &set_dwarf2_cmdlist
,
20827 &show_dwarf2_cmdlist
);
20829 add_setshow_boolean_cmd ("dwarf2-read", no_class
, &dwarf2_read_debug
, _("\
20830 Set debugging of the dwarf2 reader."), _("\
20831 Show debugging of the dwarf2 reader."), _("\
20832 When enabled, debugging messages are printed during dwarf2 reading\n\
20833 and symtab expansion."),
20836 &setdebuglist
, &showdebuglist
);
20838 add_setshow_zuinteger_cmd ("dwarf2-die", no_class
, &dwarf2_die_debug
, _("\
20839 Set debugging of the dwarf2 DIE reader."), _("\
20840 Show debugging of the dwarf2 DIE reader."), _("\
20841 When enabled (non-zero), DIEs are dumped after they are read in.\n\
20842 The value is the maximum depth to print."),
20845 &setdebuglist
, &showdebuglist
);
20847 add_setshow_boolean_cmd ("check-physname", no_class
, &check_physname
, _("\
20848 Set cross-checking of \"physname\" code against demangler."), _("\
20849 Show cross-checking of \"physname\" code against demangler."), _("\
20850 When enabled, GDB's internal \"physname\" code is checked against\n\
20852 NULL
, show_check_physname
,
20853 &setdebuglist
, &showdebuglist
);
20855 add_setshow_boolean_cmd ("use-deprecated-index-sections",
20856 no_class
, &use_deprecated_index_sections
, _("\
20857 Set whether to use deprecated gdb_index sections."), _("\
20858 Show whether to use deprecated gdb_index sections."), _("\
20859 When enabled, deprecated .gdb_index sections are used anyway.\n\
20860 Normally they are ignored either because of a missing feature or\n\
20861 performance issue.\n\
20862 Warning: This option must be enabled before gdb reads the file."),
20865 &setlist
, &showlist
);
20867 c
= add_cmd ("gdb-index", class_files
, save_gdb_index_command
,
20869 Save a gdb-index file.\n\
20870 Usage: save gdb-index DIRECTORY"),
20872 set_cmd_completer (c
, filename_completer
);
20874 dwarf2_locexpr_index
= register_symbol_computed_impl (LOC_COMPUTED
,
20875 &dwarf2_locexpr_funcs
);
20876 dwarf2_loclist_index
= register_symbol_computed_impl (LOC_COMPUTED
,
20877 &dwarf2_loclist_funcs
);
20879 dwarf2_locexpr_block_index
= register_symbol_block_impl (LOC_BLOCK
,
20880 &dwarf2_block_frame_base_locexpr_funcs
);
20881 dwarf2_loclist_block_index
= register_symbol_block_impl (LOC_BLOCK
,
20882 &dwarf2_block_frame_base_loclist_funcs
);