1 // gdb-index.cc -- generate .gdb_index section for fast debug lookup
3 // Copyright 2012 Free Software Foundation, Inc.
4 // Written by Cary Coutant <ccoutant@google.com>.
6 // This file is part of gold.
8 // This program is free software; you can redistribute it and/or modify
9 // it under the terms of the GNU General Public License as published by
10 // the Free Software Foundation; either version 3 of the License, or
11 // (at your option) any later version.
13 // This program is distributed in the hope that it will be useful,
14 // but WITHOUT ANY WARRANTY; without even the implied warranty of
15 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 // GNU General Public License for more details.
18 // You should have received a copy of the GNU General Public License
19 // along with this program; if not, write to the Free Software
20 // Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,
21 // MA 02110-1301, USA.
25 #include "gdb-index.h"
26 #include "dwarf_reader.h"
35 const int gdb_index_version
= 5;
37 // Sizes of various records in the .gdb_index section.
38 const int gdb_index_offset_size
= 4;
39 const int gdb_index_hdr_size
= 6 * gdb_index_offset_size
;
40 const int gdb_index_cu_size
= 16;
41 const int gdb_index_tu_size
= 24;
42 const int gdb_index_addr_size
= 16 + gdb_index_offset_size
;
43 const int gdb_index_sym_size
= 2 * gdb_index_offset_size
;
45 // This class manages the hashed symbol table for the .gdb_index section.
46 // It is essentially equivalent to the hashtab implementation in libiberty,
47 // but is copied into gdb sources and here for compatibility because its
48 // data structure is exposed on disk.
55 : size_(0), capacity_(0), hashtab_(NULL
)
60 for (size_t i
= 0; i
< this->capacity_
; ++i
)
61 if (this->hashtab_
[i
] != NULL
)
62 delete this->hashtab_
[i
];
63 delete[] this->hashtab_
;
70 // Resize the hash table if necessary.
71 if (4 * this->size_
/ 3 >= this->capacity_
)
74 T
** slot
= this->find_slot(symbol
);
84 // Return the current size.
87 { return this->size_
; }
89 // Return the current capacity.
92 { return this->capacity_
; }
94 // Return the contents of slot N.
97 { return this->hashtab_
[n
]; }
100 // Find a symbol in the hash table, or return an empty slot if
101 // the symbol is not in the table.
105 unsigned int index
= symbol
->hash() & (this->capacity_
- 1);
106 unsigned int step
= ((symbol
->hash() * 17) & (this->capacity_
- 1)) | 1;
110 if (this->hashtab_
[index
] == NULL
111 || this->hashtab_
[index
]->equal(symbol
))
112 return &this->hashtab_
[index
];
113 index
= (index
+ step
) & (this->capacity_
- 1);
117 // Expand the hash table.
121 if (this->capacity_
== 0)
123 // Allocate the hash table for the first time.
124 this->capacity_
= Gdb_hashtab::initial_size
;
125 this->hashtab_
= new T
*[this->capacity_
];
126 memset(this->hashtab_
, 0, this->capacity_
* sizeof(T
*));
130 // Expand and rehash.
131 unsigned int old_cap
= this->capacity_
;
132 T
** old_hashtab
= this->hashtab_
;
133 this->capacity_
*= 2;
134 this->hashtab_
= new T
*[this->capacity_
];
135 memset(this->hashtab_
, 0, this->capacity_
* sizeof(T
*));
136 for (size_t i
= 0; i
< old_cap
; ++i
)
138 if (old_hashtab
[i
] != NULL
)
140 T
** slot
= this->find_slot(old_hashtab
[i
]);
141 *slot
= old_hashtab
[i
];
144 delete[] old_hashtab
;
148 // Initial size of the hash table; must be a power of 2.
149 static const int initial_size
= 1024;
155 // The hash function for strings in the mapped index. This is copied
156 // directly from gdb/dwarf2read.c.
159 mapped_index_string_hash(const unsigned char* str
)
164 while ((c
= *str
++) != 0)
166 if (gdb_index_version
>= 5)
168 r
= r
* 67 + c
- 113;
174 // A specialization of Dwarf_info_reader, for building the .gdb_index.
176 class Gdb_index_info_reader
: public Dwarf_info_reader
179 Gdb_index_info_reader(bool is_type_unit
,
181 const unsigned char* symbols
,
184 unsigned int reloc_shndx
,
185 unsigned int reloc_type
,
186 Gdb_index
* gdb_index
)
187 : Dwarf_info_reader(is_type_unit
, object
, symbols
, symbols_size
, shndx
,
188 reloc_shndx
, reloc_type
),
189 gdb_index_(gdb_index
), cu_index_(0), cu_language_(0)
192 ~Gdb_index_info_reader()
193 { this->clear_declarations(); }
195 // Print usage statistics.
200 // Visit a compilation unit.
202 visit_compilation_unit(off_t cu_offset
, off_t cu_length
, Dwarf_die
*);
204 // Visit a type unit.
206 visit_type_unit(off_t tu_offset
, off_t tu_length
, off_t type_offset
,
207 uint64_t signature
, Dwarf_die
*);
210 // A map for recording DIEs we've seen that may be referred to be
211 // later DIEs (via DW_AT_specification or DW_AT_abstract_origin).
212 // The map is indexed by a DIE offset within the compile unit.
213 // PARENT_OFFSET_ is the offset of the DIE that represents the
214 // outer context, and NAME_ is a pointer to a component of the
215 // fully-qualified name.
216 // Normally, the names we point to are in a string table, so we don't
217 // have to manage them, but when we have a fully-qualified name
218 // computed, we put it in the table, and set PARENT_OFFSET_ to -1
219 // indicate a string that we are managing.
220 struct Declaration_pair
222 Declaration_pair(off_t parent_offset
, const char* name
)
223 : parent_offset_(parent_offset
), name_(name
)
226 off_t parent_offset_
;
229 typedef Unordered_map
<off_t
, Declaration_pair
> Declaration_map
;
231 // Visit a top-level DIE.
233 visit_top_die(Dwarf_die
* die
);
235 // Visit the children of a DIE.
237 visit_children(Dwarf_die
* die
, Dwarf_die
* context
);
241 visit_die(Dwarf_die
* die
, Dwarf_die
* context
);
243 // Visit the children of a DIE.
245 visit_children_for_decls(Dwarf_die
* die
);
249 visit_die_for_decls(Dwarf_die
* die
, Dwarf_die
* context
);
251 // Guess a fully-qualified name for a class type, based on member function
254 guess_full_class_name(Dwarf_die
* die
);
256 // Add a declaration DIE to the table of declarations.
258 add_declaration(Dwarf_die
* die
, Dwarf_die
* context
);
260 // Add a declaration whose fully-qualified name is already known.
262 add_declaration_with_full_name(Dwarf_die
* die
, const char* full_name
);
264 // Return the context for a DIE whose parent is at DIE_OFFSET.
266 get_context(off_t die_offset
);
268 // Construct a fully-qualified name for DIE.
270 get_qualified_name(Dwarf_die
* die
, Dwarf_die
* context
);
272 // Record the address ranges for a compilation unit.
274 record_cu_ranges(Dwarf_die
* die
);
276 // Wrapper for read_pubtable.
278 read_pubnames_and_pubtypes(Dwarf_die
* die
);
280 // Read the .debug_pubnames and .debug_pubtypes tables.
282 read_pubtable(Dwarf_pubnames_table
* table
, off_t offset
);
284 // Clear the declarations map.
286 clear_declarations();
288 // The Gdb_index section.
289 Gdb_index
* gdb_index_
;
290 // The current CU index (negative for a TU).
292 // The language of the current CU or TU.
293 unsigned int cu_language_
;
294 // Map from DIE offset to (parent offset, name) pair,
295 // for DW_AT_specification.
296 Declaration_map declarations_
;
299 // Total number of DWARF compilation units processed.
300 static unsigned int dwarf_cu_count
;
301 // Number of DWARF compilation units with pubnames/pubtypes.
302 static unsigned int dwarf_cu_nopubnames_count
;
303 // Total number of DWARF type units processed.
304 static unsigned int dwarf_tu_count
;
305 // Number of DWARF type units with pubnames/pubtypes.
306 static unsigned int dwarf_tu_nopubnames_count
;
309 // Total number of DWARF compilation units processed.
310 unsigned int Gdb_index_info_reader::dwarf_cu_count
= 0;
311 // Number of DWARF compilation units without pubnames/pubtypes.
312 unsigned int Gdb_index_info_reader::dwarf_cu_nopubnames_count
= 0;
313 // Total number of DWARF type units processed.
314 unsigned int Gdb_index_info_reader::dwarf_tu_count
= 0;
315 // Number of DWARF type units without pubnames/pubtypes.
316 unsigned int Gdb_index_info_reader::dwarf_tu_nopubnames_count
= 0;
318 // Process a compilation unit and parse its child DIE.
321 Gdb_index_info_reader::visit_compilation_unit(off_t cu_offset
, off_t cu_length
,
324 ++Gdb_index_info_reader::dwarf_cu_count
;
325 this->cu_index_
= this->gdb_index_
->add_comp_unit(cu_offset
, cu_length
);
326 this->visit_top_die(root_die
);
329 // Process a type unit and parse its child DIE.
332 Gdb_index_info_reader::visit_type_unit(off_t tu_offset
, off_t
,
333 off_t type_offset
, uint64_t signature
,
336 ++Gdb_index_info_reader::dwarf_tu_count
;
337 // Use a negative index to flag this as a TU instead of a CU.
338 this->cu_index_
= -1 - this->gdb_index_
->add_type_unit(tu_offset
, type_offset
,
340 this->visit_top_die(root_die
);
343 // Process a top-level DIE.
344 // For compile_unit DIEs, record the address ranges. For all
345 // interesting tags, add qualified names to the symbol table
346 // and process interesting children. We may need to process
347 // certain children just for saving declarations that might be
348 // referenced by later DIEs with a DW_AT_specification attribute.
351 Gdb_index_info_reader::visit_top_die(Dwarf_die
* die
)
353 this->clear_declarations();
357 case elfcpp::DW_TAG_compile_unit
:
358 case elfcpp::DW_TAG_type_unit
:
359 this->cu_language_
= die
->int_attribute(elfcpp::DW_AT_language
);
360 // Check for languages that require specialized knowledge to
361 // construct fully-qualified names, that we don't yet support.
362 if (this->cu_language_
== elfcpp::DW_LANG_Ada83
363 || this->cu_language_
== elfcpp::DW_LANG_Fortran77
364 || this->cu_language_
== elfcpp::DW_LANG_Fortran90
365 || this->cu_language_
== elfcpp::DW_LANG_Java
366 || this->cu_language_
== elfcpp::DW_LANG_Ada95
367 || this->cu_language_
== elfcpp::DW_LANG_Fortran95
)
369 gold_warning(_("%s: --gdb-index currently supports "
370 "only C and C++ languages"),
371 this->object()->name().c_str());
374 if (die
->tag() == elfcpp::DW_TAG_compile_unit
)
375 this->record_cu_ranges(die
);
376 // If there is a pubnames and/or pubtypes section for this
377 // compilation unit, use those; otherwise, parse the DWARF
378 // info to extract the names.
379 if (!this->read_pubnames_and_pubtypes(die
))
381 if (die
->tag() == elfcpp::DW_TAG_compile_unit
)
382 ++Gdb_index_info_reader::dwarf_cu_nopubnames_count
;
384 ++Gdb_index_info_reader::dwarf_tu_nopubnames_count
;
385 this->visit_children(die
, NULL
);
389 // The top level DIE should be one of the above.
390 gold_warning(_("%s: top level DIE is not DW_TAG_compile_unit "
391 "or DW_TAG_type_unit"),
392 this->object()->name().c_str());
398 // Visit the children of PARENT, looking for symbols to add to the index.
399 // CONTEXT points to the DIE to use for constructing the qualified name --
400 // NULL if PARENT is the top-level DIE; otherwise it is the same as PARENT.
403 Gdb_index_info_reader::visit_children(Dwarf_die
* parent
, Dwarf_die
* context
)
405 off_t next_offset
= 0;
406 for (off_t die_offset
= parent
->child_offset();
408 die_offset
= next_offset
)
410 Dwarf_die
die(this, die_offset
, parent
);
413 this->visit_die(&die
, context
);
414 next_offset
= die
.sibling_offset();
418 // Visit a child DIE, looking for symbols to add to the index.
419 // CONTEXT is the parent DIE, used for constructing the qualified name;
420 // it is NULL if the parent DIE is the top-level DIE.
423 Gdb_index_info_reader::visit_die(Dwarf_die
* die
, Dwarf_die
* context
)
427 case elfcpp::DW_TAG_subprogram
:
428 case elfcpp::DW_TAG_constant
:
429 case elfcpp::DW_TAG_variable
:
430 case elfcpp::DW_TAG_enumerator
:
431 case elfcpp::DW_TAG_base_type
:
432 if (die
->is_declaration())
433 this->add_declaration(die
, context
);
436 // If the DIE is not a declaration, add it to the index.
437 std::string full_name
= this->get_qualified_name(die
, context
);
438 if (!full_name
.empty())
439 this->gdb_index_
->add_symbol(this->cu_index_
, full_name
.c_str());
442 case elfcpp::DW_TAG_typedef
:
443 case elfcpp::DW_TAG_union_type
:
444 case elfcpp::DW_TAG_class_type
:
445 case elfcpp::DW_TAG_interface_type
:
446 case elfcpp::DW_TAG_structure_type
:
447 case elfcpp::DW_TAG_enumeration_type
:
448 case elfcpp::DW_TAG_subrange_type
:
449 case elfcpp::DW_TAG_namespace
:
451 std::string full_name
;
453 // For classes at the top level, we need to look for a
454 // member function with a linkage name in order to get
455 // the properly-canonicalized name.
457 && (die
->tag() == elfcpp::DW_TAG_class_type
458 || die
->tag() == elfcpp::DW_TAG_structure_type
459 || die
->tag() == elfcpp::DW_TAG_union_type
))
460 full_name
.assign(this->guess_full_class_name(die
));
462 // Because we will visit the children, we need to add this DIE
463 // to the declarations table.
464 if (full_name
.empty())
465 this->add_declaration(die
, context
);
467 this->add_declaration_with_full_name(die
, full_name
.c_str());
469 // If the DIE is not a declaration, add it to the index.
470 // Gdb stores a namespace in the index even when it is
472 if (die
->tag() == elfcpp::DW_TAG_namespace
473 || !die
->is_declaration())
475 if (full_name
.empty())
476 full_name
= this->get_qualified_name(die
, context
);
477 if (!full_name
.empty())
478 this->gdb_index_
->add_symbol(this->cu_index_
,
482 // We're interested in the children only for namespaces and
483 // enumeration types. For enumeration types, we do not include
484 // the enumeration tag as part of the full name. For other tags,
485 // visit the children only to collect declarations.
486 if (die
->tag() == elfcpp::DW_TAG_namespace
487 || die
->tag() == elfcpp::DW_TAG_enumeration_type
)
488 this->visit_children(die
, die
);
490 this->visit_children_for_decls(die
);
498 // Visit the children of PARENT, looking only for declarations that
499 // may be referenced by later specification DIEs.
502 Gdb_index_info_reader::visit_children_for_decls(Dwarf_die
* parent
)
504 off_t next_offset
= 0;
505 for (off_t die_offset
= parent
->child_offset();
507 die_offset
= next_offset
)
509 Dwarf_die
die(this, die_offset
, parent
);
512 this->visit_die_for_decls(&die
, parent
);
513 next_offset
= die
.sibling_offset();
517 // Visit a child DIE, looking only for declarations that
518 // may be referenced by later specification DIEs.
521 Gdb_index_info_reader::visit_die_for_decls(Dwarf_die
* die
, Dwarf_die
* context
)
525 case elfcpp::DW_TAG_subprogram
:
526 case elfcpp::DW_TAG_constant
:
527 case elfcpp::DW_TAG_variable
:
528 case elfcpp::DW_TAG_enumerator
:
529 case elfcpp::DW_TAG_base_type
:
531 if (die
->is_declaration())
532 this->add_declaration(die
, context
);
535 case elfcpp::DW_TAG_typedef
:
536 case elfcpp::DW_TAG_union_type
:
537 case elfcpp::DW_TAG_class_type
:
538 case elfcpp::DW_TAG_interface_type
:
539 case elfcpp::DW_TAG_structure_type
:
540 case elfcpp::DW_TAG_enumeration_type
:
541 case elfcpp::DW_TAG_subrange_type
:
542 case elfcpp::DW_TAG_namespace
:
544 if (die
->is_declaration())
545 this->add_declaration(die
, context
);
546 this->visit_children_for_decls(die
);
554 // Extract the class name from the linkage name of a member function.
555 // This code is adapted from ../gdb/cp-support.c.
557 #define d_left(dc) (dc)->u.s_binary.left
558 #define d_right(dc) (dc)->u.s_binary.right
561 class_name_from_linkage_name(const char* linkage_name
)
564 struct demangle_component
* tree
=
565 cplus_demangle_v3_components(linkage_name
, DMGL_NO_OPTS
, &storage
);
571 // First strip off any qualifiers, if we have a function or
576 case DEMANGLE_COMPONENT_CONST
:
577 case DEMANGLE_COMPONENT_RESTRICT
:
578 case DEMANGLE_COMPONENT_VOLATILE
:
579 case DEMANGLE_COMPONENT_CONST_THIS
:
580 case DEMANGLE_COMPONENT_RESTRICT_THIS
:
581 case DEMANGLE_COMPONENT_VOLATILE_THIS
:
582 case DEMANGLE_COMPONENT_VENDOR_TYPE_QUAL
:
590 // If what we have now is a function, discard the argument list.
591 if (tree
->type
== DEMANGLE_COMPONENT_TYPED_NAME
)
594 // If what we have now is a template, strip off the template
595 // arguments. The left subtree may be a qualified name.
596 if (tree
->type
== DEMANGLE_COMPONENT_TEMPLATE
)
599 // What we have now should be a name, possibly qualified.
600 // Additional qualifiers could live in the left subtree or the right
601 // subtree. Find the last piece.
603 struct demangle_component
* prev_comp
= NULL
;
604 struct demangle_component
* cur_comp
= tree
;
606 switch (cur_comp
->type
)
608 case DEMANGLE_COMPONENT_QUAL_NAME
:
609 case DEMANGLE_COMPONENT_LOCAL_NAME
:
610 prev_comp
= cur_comp
;
611 cur_comp
= d_right(cur_comp
);
613 case DEMANGLE_COMPONENT_TEMPLATE
:
614 case DEMANGLE_COMPONENT_NAME
:
615 case DEMANGLE_COMPONENT_CTOR
:
616 case DEMANGLE_COMPONENT_DTOR
:
617 case DEMANGLE_COMPONENT_OPERATOR
:
618 case DEMANGLE_COMPONENT_EXTENDED_OPERATOR
:
628 if (cur_comp
!= NULL
&& prev_comp
!= NULL
)
630 // We want to discard the rightmost child of PREV_COMP.
631 *prev_comp
= *d_left(prev_comp
);
632 size_t allocated_size
;
633 ret
= cplus_demangle_print(DMGL_NO_OPTS
, tree
, 30, &allocated_size
);
640 // Guess a fully-qualified name for a class type, based on member function
641 // linkage names. This is needed for class/struct/union types at the
642 // top level, because GCC does not always properly embed them within
643 // the namespace. As in gdb, we look for a member function with a linkage
644 // name and extract the qualified name from the demangled name.
647 Gdb_index_info_reader::guess_full_class_name(Dwarf_die
* die
)
649 std::string full_name
;
650 off_t next_offset
= 0;
652 // This routine scans ahead in the DIE structure, possibly advancing
653 // the relocation tracker beyond the current DIE. We need to checkpoint
654 // the tracker and reset it when we're done.
655 uint64_t checkpoint
= this->get_reloc_checkpoint();
657 for (off_t child_offset
= die
->child_offset();
659 child_offset
= next_offset
)
661 Dwarf_die
child(this, child_offset
, die
);
662 if (child
.tag() == 0)
664 if (child
.tag() == elfcpp::DW_TAG_subprogram
)
666 const char* linkage_name
= child
.linkage_name();
667 if (linkage_name
!= NULL
)
669 char* guess
= class_name_from_linkage_name(linkage_name
);
672 full_name
.assign(guess
);
678 next_offset
= child
.sibling_offset();
681 this->reset_relocs(checkpoint
);
685 // Add a declaration DIE to the table of declarations.
688 Gdb_index_info_reader::add_declaration(Dwarf_die
* die
, Dwarf_die
* context
)
690 const char* name
= die
->name();
692 off_t parent_offset
= context
!= NULL
? context
->offset() : 0;
694 // If this DIE has a DW_AT_specification or DW_AT_abstract_origin
695 // attribute, use the parent and name from the earlier declaration.
696 off_t spec
= die
->specification();
698 spec
= die
->abstract_origin();
701 Declaration_map::iterator it
= this->declarations_
.find(spec
);
702 if (it
!= this->declarations_
.end())
704 parent_offset
= it
->second
.parent_offset_
;
705 name
= it
->second
.name_
;
711 if (die
->tag() == elfcpp::DW_TAG_namespace
)
712 name
= "(anonymous namespace)";
713 else if (die
->tag() == elfcpp::DW_TAG_union_type
)
714 name
= "(anonymous union)";
719 Declaration_pair
decl(parent_offset
, name
);
720 this->declarations_
.insert(std::make_pair(die
->offset(), decl
));
723 // Add a declaration whose fully-qualified name is already known.
724 // In the case where we had to get the canonical name by demangling
725 // a linkage name, this ensures we use that name instead of the one
726 // provided in DW_AT_name.
729 Gdb_index_info_reader::add_declaration_with_full_name(
731 const char* full_name
)
733 // We need to copy the name.
734 int len
= strlen(full_name
);
735 char* copy
= new char[len
+ 1];
736 memcpy(copy
, full_name
, len
+ 1);
738 // Flag that we now manage the memory this points to.
739 Declaration_pair
decl(-1, copy
);
740 this->declarations_
.insert(std::make_pair(die
->offset(), decl
));
743 // Return the context for a DIE whose parent is at DIE_OFFSET.
746 Gdb_index_info_reader::get_context(off_t die_offset
)
749 Declaration_map::iterator it
= this->declarations_
.find(die_offset
);
750 if (it
!= this->declarations_
.end())
752 off_t parent_offset
= it
->second
.parent_offset_
;
753 if (parent_offset
> 0)
755 context
= get_context(parent_offset
);
756 context
.append("::");
758 if (it
->second
.name_
!= NULL
)
759 context
.append(it
->second
.name_
);
764 // Construct the fully-qualified name for DIE.
767 Gdb_index_info_reader::get_qualified_name(Dwarf_die
* die
, Dwarf_die
* context
)
769 std::string full_name
;
770 const char* name
= die
->name();
772 off_t parent_offset
= context
!= NULL
? context
->offset() : 0;
774 // If this DIE has a DW_AT_specification or DW_AT_abstract_origin
775 // attribute, use the parent and name from the earlier declaration.
776 off_t spec
= die
->specification();
778 spec
= die
->abstract_origin();
781 Declaration_map::iterator it
= this->declarations_
.find(spec
);
782 if (it
!= this->declarations_
.end())
784 parent_offset
= it
->second
.parent_offset_
;
785 name
= it
->second
.name_
;
789 if (name
== NULL
&& die
->tag() == elfcpp::DW_TAG_namespace
)
790 name
= "(anonymous namespace)";
791 else if (name
== NULL
)
794 // If this is an enumerator constant, skip the immediate parent,
795 // which is the enumeration tag.
796 if (die
->tag() == elfcpp::DW_TAG_enumerator
)
798 Declaration_map::iterator it
= this->declarations_
.find(parent_offset
);
799 if (it
!= this->declarations_
.end())
800 parent_offset
= it
->second
.parent_offset_
;
803 if (parent_offset
> 0)
805 full_name
.assign(this->get_context(parent_offset
));
806 full_name
.append("::");
808 full_name
.append(name
);
813 // Record the address ranges for a compilation unit.
816 Gdb_index_info_reader::record_cu_ranges(Dwarf_die
* die
)
821 off_t ranges_offset
= die
->ref_attribute(elfcpp::DW_AT_ranges
, &shndx
);
822 if (ranges_offset
!= -1)
824 Dwarf_range_list
* ranges
= this->read_range_list(shndx
, ranges_offset
);
826 this->gdb_index_
->add_address_range_list(this->object(),
827 this->cu_index_
, ranges
);
831 off_t low_pc
= die
->address_attribute(elfcpp::DW_AT_low_pc
, &shndx
);
832 off_t high_pc
= die
->address_attribute(elfcpp::DW_AT_high_pc
, &shndx2
);
835 high_pc
= die
->uint_attribute(elfcpp::DW_AT_high_pc
);
839 if ((low_pc
!= 0 || high_pc
!= 0) && low_pc
!= -1)
843 gold_warning(_("%s: DWARF info may be corrupt; low_pc and high_pc "
844 "are in different sections"),
845 this->object()->name().c_str());
848 if (shndx
== 0 || this->object()->is_section_included(shndx
))
850 Dwarf_range_list
* ranges
= new Dwarf_range_list();
851 ranges
->add(shndx
, low_pc
, high_pc
);
852 this->gdb_index_
->add_address_range_list(this->object(),
853 this->cu_index_
, ranges
);
858 // Read table and add the relevant names to the index. Returns true
859 // if any names were added.
862 Gdb_index_info_reader::read_pubtable(Dwarf_pubnames_table
* table
, off_t offset
)
864 // If we couldn't read the section when building the cu_pubname_map,
865 // then we won't find any pubnames now.
869 if (!table
->read_header(offset
))
873 const char* name
= table
->next_name();
877 this->gdb_index_
->add_symbol(this->cu_index_
, name
);
882 // Read the .debug_pubnames and .debug_pubtypes tables for the CU or TU.
883 // Returns TRUE if either a pubnames or pubtypes section was found.
886 Gdb_index_info_reader::read_pubnames_and_pubtypes(Dwarf_die
* die
)
888 // We use stmt_list_off as a unique identifier for the
889 // compilation unit and its associated type units.
891 off_t stmt_list_off
= die
->ref_attribute (elfcpp::DW_AT_stmt_list
,
893 // Look for the attr as either a flag or a ref.
894 off_t offset
= die
->ref_attribute(elfcpp::DW_AT_GNU_pubnames
, &shndx
);
896 // Newer versions of GCC generate CUs, but not TUs, with
897 // DW_AT_FORM_flag_present.
898 unsigned int flag
= die
->uint_attribute(elfcpp::DW_AT_GNU_pubnames
);
899 if (offset
== -1 && flag
== 0)
901 // Didn't find the attribute.
902 if (die
->tag() == elfcpp::DW_TAG_type_unit
)
904 // If die is a TU, then it might correspond to a CU which we
905 // have read. If it does, then no need to read the pubnames.
906 // If it doesn't, then the caller will have to parse the
907 // dies manually to find the names.
908 return this->gdb_index_
->pubnames_read(this->object(),
913 // No attribute on the CU means that no pubnames were read.
918 // We found the attribute, so we can check if the corresponding
919 // pubnames have been read.
920 if (this->gdb_index_
->pubnames_read(this->object(), stmt_list_off
))
923 this->gdb_index_
->set_pubnames_read(this->object(), stmt_list_off
);
925 // We have an attribute, and the pubnames haven't been read, so read
928 // In some of the cases, we could rely on the previous value of
929 // offset here, but sorting out which cases complicates the logic
930 // enough that it isn't worth it. So just look up the offset again.
931 offset
= this->gdb_index_
->find_pubname_offset(this->cu_offset());
932 names
= this->read_pubtable(this->gdb_index_
->pubnames_table(), offset
);
935 offset
= this->gdb_index_
->find_pubtype_offset(this->cu_offset());
936 types
= this->read_pubtable(this->gdb_index_
->pubtypes_table(), offset
);
937 return names
|| types
;
940 // Clear the declarations map.
942 Gdb_index_info_reader::clear_declarations()
944 // Free strings in memory we manage.
945 for (Declaration_map::iterator it
= this->declarations_
.begin();
946 it
!= this->declarations_
.end();
949 if (it
->second
.parent_offset_
== -1)
950 delete[] it
->second
.name_
;
953 this->declarations_
.clear();
956 // Print usage statistics.
958 Gdb_index_info_reader::print_stats()
960 fprintf(stderr
, _("%s: DWARF CUs: %u\n"),
961 program_name
, Gdb_index_info_reader::dwarf_cu_count
);
962 fprintf(stderr
, _("%s: DWARF CUs without pubnames/pubtypes: %u\n"),
963 program_name
, Gdb_index_info_reader::dwarf_cu_nopubnames_count
);
964 fprintf(stderr
, _("%s: DWARF TUs: %u\n"),
965 program_name
, Gdb_index_info_reader::dwarf_tu_count
);
966 fprintf(stderr
, _("%s: DWARF TUs without pubnames/pubtypes: %u\n"),
967 program_name
, Gdb_index_info_reader::dwarf_tu_nopubnames_count
);
972 // Construct the .gdb_index section.
974 Gdb_index::Gdb_index(Output_section
* gdb_index_section
)
975 : Output_section_data(4),
976 pubnames_table_(NULL
),
977 pubtypes_table_(NULL
),
978 gdb_index_section_(gdb_index_section
),
983 cu_vector_offsets_(NULL
),
989 stringpool_offset_(0),
990 pubnames_object_(NULL
),
991 stmt_list_offset_(-1)
993 this->gdb_symtab_
= new Gdb_hashtab
<Gdb_symbol
>();
996 Gdb_index::~Gdb_index()
998 // Free the memory used by the symbol table.
999 delete this->gdb_symtab_
;
1000 // Free the memory used by the CU vectors.
1001 for (unsigned int i
= 0; i
< this->cu_vector_list_
.size(); ++i
)
1002 delete this->cu_vector_list_
[i
];
1006 // Scan the pubnames and pubtypes sections and build a map of the
1007 // various cus and tus they refer to, so we can process the entries
1008 // when we encounter the die for that cu or tu.
1009 // Return the just-read table so it can be cached.
1011 Dwarf_pubnames_table
*
1012 Gdb_index::map_pubtable_to_dies(unsigned int attr
,
1013 Gdb_index_info_reader
* dwinfo
,
1015 const unsigned char* symbols
,
1018 uint64_t section_offset
= 0;
1019 Dwarf_pubnames_table
* table
;
1020 Pubname_offset_map
* map
;
1022 if (attr
== elfcpp::DW_AT_GNU_pubnames
)
1024 table
= new Dwarf_pubnames_table(dwinfo
, false);
1025 map
= &this->cu_pubname_map_
;
1029 table
= new Dwarf_pubnames_table(dwinfo
, true);
1030 map
= &this->cu_pubtype_map_
;
1034 if (!table
->read_section(object
, symbols
, symbols_size
))
1037 while (table
->read_header(section_offset
))
1039 map
->insert(std::make_pair(table
->cu_offset(), section_offset
));
1040 section_offset
+= table
->subsection_size();
1046 // Wrapper for map_pubtable_to_dies
1049 Gdb_index::map_pubnames_and_types_to_dies(Gdb_index_info_reader
* dwinfo
,
1051 const unsigned char* symbols
,
1054 // This is a new object, so reset the relevant variables.
1055 this->pubnames_object_
= object
;
1056 this->stmt_list_offset_
= -1;
1058 delete this->pubnames_table_
;
1059 this->pubnames_table_
1060 = this->map_pubtable_to_dies(elfcpp::DW_AT_GNU_pubnames
, dwinfo
,
1061 object
, symbols
, symbols_size
);
1062 delete this->pubtypes_table_
;
1063 this->pubtypes_table_
1064 = this->map_pubtable_to_dies(elfcpp::DW_AT_GNU_pubtypes
, dwinfo
,
1065 object
, symbols
, symbols_size
);
1068 // Given a cu_offset, find the associated section of the pubnames
1072 Gdb_index::find_pubname_offset(off_t cu_offset
)
1074 Pubname_offset_map::iterator it
= this->cu_pubname_map_
.find(cu_offset
);
1075 if (it
!= this->cu_pubname_map_
.end())
1080 // Given a cu_offset, find the associated section of the pubnames
1084 Gdb_index::find_pubtype_offset(off_t cu_offset
)
1086 Pubname_offset_map::iterator it
= this->cu_pubtype_map_
.find(cu_offset
);
1087 if (it
!= this->cu_pubtype_map_
.end())
1092 // Scan a .debug_info or .debug_types input section.
1095 Gdb_index::scan_debug_info(bool is_type_unit
,
1097 const unsigned char* symbols
,
1100 unsigned int reloc_shndx
,
1101 unsigned int reloc_type
)
1103 Gdb_index_info_reader
dwinfo(is_type_unit
, object
,
1104 symbols
, symbols_size
,
1107 if (object
!= this->pubnames_object_
)
1108 map_pubnames_and_types_to_dies(&dwinfo
, object
, symbols
, symbols_size
);
1115 Gdb_index::add_symbol(int cu_index
, const char* sym_name
)
1117 unsigned int hash
= mapped_index_string_hash(
1118 reinterpret_cast<const unsigned char*>(sym_name
));
1119 Gdb_symbol
* sym
= new Gdb_symbol();
1120 this->stringpool_
.add(sym_name
, true, &sym
->name_key
);
1121 sym
->hashval
= hash
;
1122 sym
->cu_vector_index
= 0;
1124 Gdb_symbol
* found
= this->gdb_symtab_
->add(sym
);
1127 // New symbol -- allocate a new CU index vector.
1128 found
->cu_vector_index
= this->cu_vector_list_
.size();
1129 this->cu_vector_list_
.push_back(new Cu_vector());
1133 // Found an existing symbol -- append to the existing
1138 // Add the CU index to the vector list for this symbol,
1139 // if it's not already on the list. We only need to
1140 // check the last added entry.
1141 Cu_vector
* cu_vec
= this->cu_vector_list_
[found
->cu_vector_index
];
1142 if (cu_vec
->size() == 0 || cu_vec
->back() != cu_index
)
1143 cu_vec
->push_back(cu_index
);
1146 // Return TRUE if we have already processed the pubnames associated
1147 // with the statement list at the given OFFSET.
1150 Gdb_index::pubnames_read(const Relobj
* object
, off_t offset
)
1152 bool ret
= (this->pubnames_object_
== object
1153 && this->stmt_list_offset_
== offset
);
1157 // Record that we have processed the pubnames associated with the
1158 // statement list for OBJECT at the given OFFSET.
1161 Gdb_index::set_pubnames_read(const Relobj
* object
, off_t offset
)
1163 this->pubnames_object_
= object
;
1164 this->stmt_list_offset_
= offset
;
1167 // Set the size of the .gdb_index section.
1170 Gdb_index::set_final_data_size()
1172 // Finalize the string pool.
1173 this->stringpool_
.set_string_offsets();
1175 // Compute the total size of the CU vectors.
1176 // For each CU vector, include one entry for the count at the
1177 // beginning of the vector.
1178 unsigned int cu_vector_count
= this->cu_vector_list_
.size();
1179 unsigned int cu_vector_size
= 0;
1180 this->cu_vector_offsets_
= new off_t
[cu_vector_count
];
1181 for (unsigned int i
= 0; i
< cu_vector_count
; ++i
)
1183 Cu_vector
* cu_vec
= this->cu_vector_list_
[i
];
1184 cu_vector_offsets_
[i
] = cu_vector_size
;
1185 cu_vector_size
+= gdb_index_offset_size
* (cu_vec
->size() + 1);
1188 // Assign relative offsets to each portion of the index,
1189 // and find the total size of the section.
1190 section_size_type data_size
= gdb_index_hdr_size
;
1191 data_size
+= this->comp_units_
.size() * gdb_index_cu_size
;
1192 this->tu_offset_
= data_size
;
1193 data_size
+= this->type_units_
.size() * gdb_index_tu_size
;
1194 this->addr_offset_
= data_size
;
1195 for (unsigned int i
= 0; i
< this->ranges_
.size(); ++i
)
1196 data_size
+= this->ranges_
[i
].ranges
->size() * gdb_index_addr_size
;
1197 this->symtab_offset_
= data_size
;
1198 data_size
+= this->gdb_symtab_
->capacity() * gdb_index_sym_size
;
1199 this->cu_pool_offset_
= data_size
;
1200 data_size
+= cu_vector_size
;
1201 this->stringpool_offset_
= data_size
;
1202 data_size
+= this->stringpool_
.get_strtab_size();
1204 this->set_data_size(data_size
);
1207 // Write the data to the file.
1210 Gdb_index::do_write(Output_file
* of
)
1212 const off_t off
= this->offset();
1213 const off_t oview_size
= this->data_size();
1214 unsigned char* const oview
= of
->get_output_view(off
, oview_size
);
1215 unsigned char* pov
= oview
;
1217 // Write the file header.
1218 // (1) Version number.
1219 elfcpp::Swap
<32, false>::writeval(pov
, gdb_index_version
);
1221 // (2) Offset of the CU list.
1222 elfcpp::Swap
<32, false>::writeval(pov
, gdb_index_hdr_size
);
1224 // (3) Offset of the types CU list.
1225 elfcpp::Swap
<32, false>::writeval(pov
, this->tu_offset_
);
1227 // (4) Offset of the address area.
1228 elfcpp::Swap
<32, false>::writeval(pov
, this->addr_offset_
);
1230 // (5) Offset of the symbol table.
1231 elfcpp::Swap
<32, false>::writeval(pov
, this->symtab_offset_
);
1233 // (6) Offset of the constant pool.
1234 elfcpp::Swap
<32, false>::writeval(pov
, this->cu_pool_offset_
);
1237 gold_assert(pov
- oview
== gdb_index_hdr_size
);
1239 // Write the CU list.
1240 unsigned int comp_units_count
= this->comp_units_
.size();
1241 for (unsigned int i
= 0; i
< comp_units_count
; ++i
)
1243 const Comp_unit
& cu
= this->comp_units_
[i
];
1244 elfcpp::Swap
<64, false>::writeval(pov
, cu
.cu_offset
);
1245 elfcpp::Swap
<64, false>::writeval(pov
+ 8, cu
.cu_length
);
1249 gold_assert(pov
- oview
== this->tu_offset_
);
1251 // Write the types CU list.
1252 for (unsigned int i
= 0; i
< this->type_units_
.size(); ++i
)
1254 const Type_unit
& tu
= this->type_units_
[i
];
1255 elfcpp::Swap
<64, false>::writeval(pov
, tu
.tu_offset
);
1256 elfcpp::Swap
<64, false>::writeval(pov
+ 8, tu
.type_offset
);
1257 elfcpp::Swap
<64, false>::writeval(pov
+ 16, tu
.type_signature
);
1261 gold_assert(pov
- oview
== this->addr_offset_
);
1263 // Write the address area.
1264 for (unsigned int i
= 0; i
< this->ranges_
.size(); ++i
)
1266 int cu_index
= this->ranges_
[i
].cu_index
;
1267 // Translate negative indexes, which refer to a TU, to a
1268 // logical index into a concatenated CU/TU list.
1270 cu_index
= comp_units_count
+ (-1 - cu_index
);
1271 Relobj
* object
= this->ranges_
[i
].object
;
1272 const Dwarf_range_list
& ranges
= *this->ranges_
[i
].ranges
;
1273 for (unsigned int j
= 0; j
< ranges
.size(); ++j
)
1275 const Dwarf_range_list::Range
& range
= ranges
[j
];
1277 if (range
.shndx
> 0)
1279 const Output_section
* os
= object
->output_section(range
.shndx
);
1280 base
= (os
->address()
1281 + object
->output_section_offset(range
.shndx
));
1283 elfcpp::Swap_aligned32
<64, false>::writeval(pov
, base
+ range
.start
);
1284 elfcpp::Swap_aligned32
<64, false>::writeval(pov
+ 8,
1286 elfcpp::Swap
<32, false>::writeval(pov
+ 16, cu_index
);
1291 gold_assert(pov
- oview
== this->symtab_offset_
);
1293 // Write the symbol table.
1294 for (unsigned int i
= 0; i
< this->gdb_symtab_
->capacity(); ++i
)
1296 const Gdb_symbol
* sym
= (*this->gdb_symtab_
)[i
];
1297 section_offset_type name_offset
= 0;
1298 unsigned int cu_vector_offset
= 0;
1301 name_offset
= (this->stringpool_
.get_offset_from_key(sym
->name_key
)
1302 + this->stringpool_offset_
- this->cu_pool_offset_
);
1303 cu_vector_offset
= this->cu_vector_offsets_
[sym
->cu_vector_index
];
1305 elfcpp::Swap
<32, false>::writeval(pov
, name_offset
);
1306 elfcpp::Swap
<32, false>::writeval(pov
+ 4, cu_vector_offset
);
1310 gold_assert(pov
- oview
== this->cu_pool_offset_
);
1312 // Write the CU vectors into the constant pool.
1313 for (unsigned int i
= 0; i
< this->cu_vector_list_
.size(); ++i
)
1315 Cu_vector
* cu_vec
= this->cu_vector_list_
[i
];
1316 elfcpp::Swap
<32, false>::writeval(pov
, cu_vec
->size());
1318 for (unsigned int j
= 0; j
< cu_vec
->size(); ++j
)
1320 int cu_index
= (*cu_vec
)[j
];
1322 cu_index
= comp_units_count
+ (-1 - cu_index
);
1323 elfcpp::Swap
<32, false>::writeval(pov
, cu_index
);
1328 gold_assert(pov
- oview
== this->stringpool_offset_
);
1330 // Write the strings into the constant pool.
1331 this->stringpool_
.write_to_buffer(pov
, oview_size
- this->stringpool_offset_
);
1333 of
->write_output_view(off
, oview_size
, oview
);
1336 // Print usage statistics.
1338 Gdb_index::print_stats()
1340 if (parameters
->options().gdb_index())
1341 Gdb_index_info_reader::print_stats();
1344 } // End namespace gold.