* Makefile.am: Add gdb-index.cc, gdb-index.h.
* Makefile.in: Regenerate.
* dwarf_reader.cc (Sized_elf_reloc_mapper::do_initialize): New function.
(Sized_elf_reloc_mapper::symbol_section): New function.
(Sized_elf_reloc_mapper::do_get_reloc_target): New function.
(make_elf_reloc_mapper): New function.
(Dwarf_abbrev_table::clear_abbrev_codes): New function.
(Dwarf_abbrev_table::do_read_abbrevs): New function.
(Dwarf_abbrev_table::do_get_abbrev): New function.
(Dwarf_ranges_table::read_ranges_table): New function.
(Dwarf_ranges_table::read_range_list): New function.
(Dwarf_pubnames_table::read_section): New function.
(Dwarf_pubnames_table::read_header): New function.
(Dwarf_pubnames_table::next_name): New function.
(Dwarf_die::Dwarf_die): New function.
(Dwarf_die::read_attributes): New function.
(Dwarf_die::skip_attributes): New function.
(Dwarf_die::set_name): New function.
(Dwarf_die::set_linkage_name): New function.
(Dwarf_die::attribute): New function.
(Dwarf_die::string_attribute): New function.
(Dwarf_die::int_attribute): New function.
(Dwarf_die::uint_attribute): New function.
(Dwarf_die::ref_attribute): New function.
(Dwarf_die::child_offset): New function.
(Dwarf_die::sibling_offset): New function.
(Dwarf_info_reader::check_buffer): New function.
(Dwarf_info_reader::parse): New function.
(Dwarf_info_reader::do_parse): New function.
(Dwarf_info_reader::do_read_string_table): New function.
(Dwarf_info_reader::lookup_reloc): New function.
(Dwarf_info_reader::get_string): New function.
(Dwarf_info_reader::visit_compilation_unit): New function.
(Dwarf_info_reader::visit_type_unit): New function.
(Sized_dwarf_line_info::Sized_dwarf_line_info): Use
Sized_elf_reloc_mapper.
(Sized_dwarf_line_info::symbol_section): Remove function.
(Sized_dwarf_line_info::read_relocs): Use Sized_elf_reloc_mapper.
(Sized_dwarf_line_info::read_line_mappings): Remove object
parameter, adjust callers.
(Sized_dwarf_line_info::format_file_lineno): Fix type of cast.
* dwarf_reader.h: Include <sys/types.h>.
(class Track_relocs): Remove forward declaration.
(class Elf_reloc_mapper): New class.
(class Sized_elf_reloc_mapper): New class.
(class Dwarf_abbrev_table): New class.
(class Dwarf_range_list): New class.
(class Dwarf_ranges_table): New class.
(class Dwarf_pubnames_table): New class.
(class Dwarf_die): New class.
(class Dwarf_info_reader): New class.
(Sized_dwarf_line_info::read_line_mappings): Remove object parameter.
(Sized_dwarf_line_info::symbol_section): Remove member function.
* dynobj.h (Sized_dynobj::do_section_contents): Refactor code from
base class.
* gdb-index.cc: New source file.
* gdb-index.h: New source file.
* incremental.cc (Sized_relobj_incr::do_layout): Track .debug_info
and .debug_types sections, call Layout::add_to_gdb_index.
(Sized_relobj_incr::do_section_name): Implement.
(Sized_relobj_incr::do_section_contents): Adjust parameter list and
return type; Implement.
(Sized_incr_dynobj::do_section_contents): Adjust parameter list and
return type.
* incremental.h (Sized_relobj_incr::do_section_contents): Adjust
parameter list and return type.
(Sized_incr_dynobj::do_section_contents): Likewise.
* layout.cc: Include gdb-index.h.
(Layout::Layout): Initialize gdb_index_data_.
(Layout::init_fixed_output_section): Check for .gdb_index section.
(Layout::add_to_gdb_index): New function. Instantiate.
* layout.h: Add forward declaration for class Gdb_index.
(Layout::add_to_gdb_index): New member function.
(Layout::gdb_index_data_): New data member.
* main.cc: Include gdb-index.h.
(main): Print statistics for gdb index.
* object.cc (Object::section_contents): Move code into
do_section_contents.
(need_decompressed_section): Check for sections needed when building
gdb index.
(build_compressed_section_map): Likewise.
(Sized_relobj_file::do_read_symbols): Need local symbols when building
gdb index.
(Sized_relobj_file::do_layout): Track .debug_info and .debug_types
sections; call Layout::add_to_gdb_index.
(Sized_relobj_file::do_decompressed_section_contents): Call
do_section_contents directly.
* object.h (Object::do_section_contents): Adjust parameter list and
return type.
(Object::do_decompressed_section_contents): Call do_section_contents
directly.
(Sized_relobj_file::do_section_contents): Adjust parameter list and
return type.
* options.h (class General_options): Add --gdb-index option.
* plugin.cc (Sized_pluginobj::do_section_contents): Adjust parameter
list and return type.
* plugin.h (Sized_pluginobj::do_section_contents): Likewise.
* reloc.h (Track_relocs::checkpoint): New function.
(Track_relocs::reset): New function.
* testsuite/Makefile.am (gdb_index_test_1.sh, gdb_index_test_2.sh):
New test cases.
* testsuite/Makefile.in: Regenerate.
* testsuite/gdb_index_test.cc: New test source file.
* testsuite/gdb_index_test_1.sh: New test source file.
* testsuite/gdb_index_test_2.sh: New test source file.
+2012-03-21 Cary Coutant <ccoutant@google.com>
+
+ * Makefile.am: Add gdb-index.cc, gdb-index.h.
+ * Makefile.in: Regenerate.
+ * dwarf_reader.cc (Sized_elf_reloc_mapper::do_initialize): New function.
+ (Sized_elf_reloc_mapper::symbol_section): New function.
+ (Sized_elf_reloc_mapper::do_get_reloc_target): New function.
+ (make_elf_reloc_mapper): New function.
+ (Dwarf_abbrev_table::clear_abbrev_codes): New function.
+ (Dwarf_abbrev_table::do_read_abbrevs): New function.
+ (Dwarf_abbrev_table::do_get_abbrev): New function.
+ (Dwarf_ranges_table::read_ranges_table): New function.
+ (Dwarf_ranges_table::read_range_list): New function.
+ (Dwarf_pubnames_table::read_section): New function.
+ (Dwarf_pubnames_table::read_header): New function.
+ (Dwarf_pubnames_table::next_name): New function.
+ (Dwarf_die::Dwarf_die): New function.
+ (Dwarf_die::read_attributes): New function.
+ (Dwarf_die::skip_attributes): New function.
+ (Dwarf_die::set_name): New function.
+ (Dwarf_die::set_linkage_name): New function.
+ (Dwarf_die::attribute): New function.
+ (Dwarf_die::string_attribute): New function.
+ (Dwarf_die::int_attribute): New function.
+ (Dwarf_die::uint_attribute): New function.
+ (Dwarf_die::ref_attribute): New function.
+ (Dwarf_die::child_offset): New function.
+ (Dwarf_die::sibling_offset): New function.
+ (Dwarf_info_reader::check_buffer): New function.
+ (Dwarf_info_reader::parse): New function.
+ (Dwarf_info_reader::do_parse): New function.
+ (Dwarf_info_reader::do_read_string_table): New function.
+ (Dwarf_info_reader::lookup_reloc): New function.
+ (Dwarf_info_reader::get_string): New function.
+ (Dwarf_info_reader::visit_compilation_unit): New function.
+ (Dwarf_info_reader::visit_type_unit): New function.
+ (Sized_dwarf_line_info::Sized_dwarf_line_info): Use
+ Sized_elf_reloc_mapper.
+ (Sized_dwarf_line_info::symbol_section): Remove function.
+ (Sized_dwarf_line_info::read_relocs): Use Sized_elf_reloc_mapper.
+ (Sized_dwarf_line_info::read_line_mappings): Remove object
+ parameter, adjust callers.
+ (Sized_dwarf_line_info::format_file_lineno): Fix type of cast.
+ * dwarf_reader.h: Include <sys/types.h>.
+ (class Track_relocs): Remove forward declaration.
+ (class Elf_reloc_mapper): New class.
+ (class Sized_elf_reloc_mapper): New class.
+ (class Dwarf_abbrev_table): New class.
+ (class Dwarf_range_list): New class.
+ (class Dwarf_ranges_table): New class.
+ (class Dwarf_pubnames_table): New class.
+ (class Dwarf_die): New class.
+ (class Dwarf_info_reader): New class.
+ (Sized_dwarf_line_info::read_line_mappings): Remove object parameter.
+ (Sized_dwarf_line_info::symbol_section): Remove member function.
+ * dynobj.h (Sized_dynobj::do_section_contents): Refactor code from
+ base class.
+ * gdb-index.cc: New source file.
+ * gdb-index.h: New source file.
+ * incremental.cc (Sized_relobj_incr::do_layout): Track .debug_info
+ and .debug_types sections, call Layout::add_to_gdb_index.
+ (Sized_relobj_incr::do_section_name): Implement.
+ (Sized_relobj_incr::do_section_contents): Adjust parameter list and
+ return type; Implement.
+ (Sized_incr_dynobj::do_section_contents): Adjust parameter list and
+ return type.
+ * incremental.h (Sized_relobj_incr::do_section_contents): Adjust
+ parameter list and return type.
+ (Sized_incr_dynobj::do_section_contents): Likewise.
+ * layout.cc: Include gdb-index.h.
+ (Layout::Layout): Initialize gdb_index_data_.
+ (Layout::init_fixed_output_section): Check for .gdb_index section.
+ (Layout::add_to_gdb_index): New function. Instantiate.
+ * layout.h: Add forward declaration for class Gdb_index.
+ (Layout::add_to_gdb_index): New member function.
+ (Layout::gdb_index_data_): New data member.
+ * main.cc: Include gdb-index.h.
+ (main): Print statistics for gdb index.
+ * object.cc (Object::section_contents): Move code into
+ do_section_contents.
+ (need_decompressed_section): Check for sections needed when building
+ gdb index.
+ (build_compressed_section_map): Likewise.
+ (Sized_relobj_file::do_read_symbols): Need local symbols when building
+ gdb index.
+ (Sized_relobj_file::do_layout): Track .debug_info and .debug_types
+ sections; call Layout::add_to_gdb_index.
+ (Sized_relobj_file::do_decompressed_section_contents): Call
+ do_section_contents directly.
+ * object.h (Object::do_section_contents): Adjust parameter list and
+ return type.
+ (Object::do_decompressed_section_contents): Call do_section_contents
+ directly.
+ (Sized_relobj_file::do_section_contents): Adjust parameter list and
+ return type.
+ * options.h (class General_options): Add --gdb-index option.
+ * plugin.cc (Sized_pluginobj::do_section_contents): Adjust parameter
+ list and return type.
+ * plugin.h (Sized_pluginobj::do_section_contents): Likewise.
+ * reloc.h (Track_relocs::checkpoint): New function.
+ (Track_relocs::reset): New function.
+
+ * testsuite/Makefile.am (gdb_index_test_1.sh, gdb_index_test_2.sh):
+ New test cases.
+ * testsuite/Makefile.in: Regenerate.
+ * testsuite/gdb_index_test.cc: New test source file.
+ * testsuite/gdb_index_test_1.sh: New test source file.
+ * testsuite/gdb_index_test_2.sh: New test source file.
+
2012-03-19 Doug Kwan <dougkwan@google.com>
* arm.cc (Target_arm::do_define_standard_symbols): New method.
expression.cc \
fileread.cc \
gc.cc \
+ gdb-index.cc \
gold.cc \
gold-threads.cc \
icf.cc \
fileread.h \
freebsd.h \
gc.h \
+ gdb-index.h \
gold.h \
gold-threads.h \
icf.h \
descriptors.$(OBJEXT) dirsearch.$(OBJEXT) dynobj.$(OBJEXT) \
dwarf_reader.$(OBJEXT) ehframe.$(OBJEXT) errors.$(OBJEXT) \
expression.$(OBJEXT) fileread.$(OBJEXT) gc.$(OBJEXT) \
- gold.$(OBJEXT) gold-threads.$(OBJEXT) icf.$(OBJEXT) \
- incremental.$(OBJEXT) int_encoding.$(OBJEXT) layout.$(OBJEXT) \
- mapfile.$(OBJEXT) merge.$(OBJEXT) object.$(OBJEXT) \
- options.$(OBJEXT) output.$(OBJEXT) parameters.$(OBJEXT) \
- plugin.$(OBJEXT) readsyms.$(OBJEXT) \
+ gdb-index.$(OBJEXT) gold.$(OBJEXT) gold-threads.$(OBJEXT) \
+ icf.$(OBJEXT) incremental.$(OBJEXT) int_encoding.$(OBJEXT) \
+ layout.$(OBJEXT) mapfile.$(OBJEXT) merge.$(OBJEXT) \
+ object.$(OBJEXT) options.$(OBJEXT) output.$(OBJEXT) \
+ parameters.$(OBJEXT) plugin.$(OBJEXT) readsyms.$(OBJEXT) \
reduced_debug_output.$(OBJEXT) reloc.$(OBJEXT) \
resolve.$(OBJEXT) script-sections.$(OBJEXT) script.$(OBJEXT) \
stringpool.$(OBJEXT) symtab.$(OBJEXT) target.$(OBJEXT) \
expression.cc \
fileread.cc \
gc.cc \
+ gdb-index.cc \
gold.cc \
gold-threads.cc \
icf.cc \
fileread.h \
freebsd.h \
gc.h \
+ gdb-index.h \
gold.h \
gold-threads.h \
icf.h \
@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/expression.Po@am__quote@
@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/fileread.Po@am__quote@
@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/gc.Po@am__quote@
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/gdb-index.Po@am__quote@
@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/gold-threads.Po@am__quote@
@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/gold.Po@am__quote@
@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/i386.Po@am__quote@
// dwarf_reader.cc -- parse dwarf2/3 debug information
-// Copyright 2007, 2008, 2009, 2010, 2011 Free Software Foundation, Inc.
+// Copyright 2007, 2008, 2009, 2010, 2011, 2012 Free Software Foundation, Inc.
// Written by Ian Lance Taylor <iant@google.com>.
// This file is part of gold.
namespace gold {
+// Class Sized_elf_reloc_mapper
+
+// Initialize the relocation tracker for section RELOC_SHNDX.
+
+template<int size, bool big_endian>
+bool
+Sized_elf_reloc_mapper<size, big_endian>::do_initialize(
+ unsigned int reloc_shndx, unsigned int reloc_type)
+{
+ this->reloc_type_ = reloc_type;
+ return this->track_relocs_.initialize(this->object_, reloc_shndx,
+ reloc_type);
+}
+
+// Looks in the symtab to see what section a symbol is in.
+
+template<int size, bool big_endian>
+unsigned int
+Sized_elf_reloc_mapper<size, big_endian>::symbol_section(
+ unsigned int symndx, Address* value, bool* is_ordinary)
+{
+ const int symsize = elfcpp::Elf_sizes<size>::sym_size;
+ gold_assert((symndx + 1) * symsize <= this->symtab_size_);
+ elfcpp::Sym<size, big_endian> elfsym(this->symtab_ + symndx * symsize);
+ *value = elfsym.get_st_value();
+ return this->object_->adjust_sym_shndx(symndx, elfsym.get_st_shndx(),
+ is_ordinary);
+}
+
+// Return the section index and offset within the section of
+// the target of the relocation for RELOC_OFFSET.
+
+template<int size, bool big_endian>
+unsigned int
+Sized_elf_reloc_mapper<size, big_endian>::do_get_reloc_target(
+ off_t reloc_offset, off_t* target_offset)
+{
+ this->track_relocs_.advance(reloc_offset);
+ if (reloc_offset != this->track_relocs_.next_offset())
+ return 0;
+ unsigned int symndx = this->track_relocs_.next_symndx();
+ typename elfcpp::Elf_types<size>::Elf_Addr value;
+ bool is_ordinary;
+ unsigned int target_shndx = this->symbol_section(symndx, &value,
+ &is_ordinary);
+ if (!is_ordinary)
+ return 0;
+ if (this->reloc_type_ == elfcpp::SHT_RELA)
+ value += this->track_relocs_.next_addend();
+ *target_offset = value;
+ return target_shndx;
+}
+
+static inline Elf_reloc_mapper*
+make_elf_reloc_mapper(Object* object, const unsigned char* symtab,
+ off_t symtab_size)
+{
+ switch (parameters->size_and_endianness())
+ {
+#ifdef HAVE_TARGET_32_LITTLE
+ case Parameters::TARGET_32_LITTLE:
+ return new Sized_elf_reloc_mapper<32, false>(object, symtab,
+ symtab_size);
+#endif
+#ifdef HAVE_TARGET_32_BIG
+ case Parameters::TARGET_32_BIG:
+ return new Sized_elf_reloc_mapper<32, true>(object, symtab,
+ symtab_size);
+#endif
+#ifdef HAVE_TARGET_64_LITTLE
+ case Parameters::TARGET_64_LITTLE:
+ return new Sized_elf_reloc_mapper<64, false>(object, symtab,
+ symtab_size);
+#endif
+#ifdef HAVE_TARGET_64_BIG
+ case Parameters::TARGET_64_BIG:
+ return new Sized_elf_reloc_mapper<64, true>(object, symtab,
+ symtab_size);
+#endif
+ default:
+ gold_unreachable();
+ }
+}
+
+// class Dwarf_abbrev_table
+
+void
+Dwarf_abbrev_table::clear_abbrev_codes()
+{
+ for (unsigned int code = 0; code < this->low_abbrev_code_max_; ++code)
+ {
+ if (this->low_abbrev_codes_[code] != NULL)
+ {
+ delete this->low_abbrev_codes_[code];
+ this->low_abbrev_codes_[code] = NULL;
+ }
+ }
+ for (Abbrev_code_table::iterator it = this->high_abbrev_codes_.begin();
+ it != this->high_abbrev_codes_.end();
+ ++it)
+ {
+ if (it->second != NULL)
+ delete it->second;
+ }
+ this->high_abbrev_codes_.clear();
+}
+
+// Read the abbrev table from an object file.
+
+bool
+Dwarf_abbrev_table::do_read_abbrevs(
+ Relobj* object,
+ unsigned int abbrev_shndx,
+ off_t abbrev_offset)
+{
+ this->clear_abbrev_codes();
+
+ // If we don't have relocations, abbrev_shndx will be 0, and
+ // we'll have to hunt for the .debug_abbrev section.
+ if (abbrev_shndx == 0 && this->abbrev_shndx_ > 0)
+ abbrev_shndx = this->abbrev_shndx_;
+ else if (abbrev_shndx == 0)
+ {
+ for (unsigned int i = 1; i < object->shnum(); ++i)
+ {
+ std::string name = object->section_name(i);
+ if (name == ".debug_abbrev")
+ {
+ abbrev_shndx = i;
+ // Correct the offset. For incremental update links, we have a
+ // relocated offset that is relative to the output section, but
+ // here we need an offset relative to the input section.
+ abbrev_offset -= object->output_section_offset(i);
+ break;
+ }
+ }
+ if (abbrev_shndx == 0)
+ return false;
+ }
+
+ // Get the section contents and decompress if necessary.
+ if (abbrev_shndx != this->abbrev_shndx_)
+ {
+ if (this->owns_buffer_ && this->buffer_ != NULL)
+ {
+ delete[] this->buffer_;
+ this->owns_buffer_ = false;
+ }
+
+ section_size_type buffer_size;
+ this->buffer_ =
+ object->decompressed_section_contents(abbrev_shndx,
+ &buffer_size,
+ &this->owns_buffer_);
+ this->buffer_end_ = this->buffer_ + buffer_size;
+ this->abbrev_shndx_ = abbrev_shndx;
+ }
+
+ this->buffer_pos_ = this->buffer_ + abbrev_offset;
+ return true;
+}
+
+// Lookup the abbrev code entry for CODE. This function is called
+// only when the abbrev code is not in the direct lookup table.
+// It may be in the hash table, it may not have been read yet,
+// or it may not exist in the abbrev table.
+
+const Dwarf_abbrev_table::Abbrev_code*
+Dwarf_abbrev_table::do_get_abbrev(unsigned int code)
+{
+ // See if the abbrev code is already in the hash table.
+ Abbrev_code_table::const_iterator it = this->high_abbrev_codes_.find(code);
+ if (it != this->high_abbrev_codes_.end())
+ return it->second;
+
+ // Read and store abbrev code definitions until we find the
+ // one we're looking for.
+ for (;;)
+ {
+ // Read the abbrev code. A zero here indicates the end of the
+ // abbrev table.
+ size_t len;
+ if (this->buffer_pos_ >= this->buffer_end_)
+ return NULL;
+ uint64_t nextcode = read_unsigned_LEB_128(this->buffer_pos_, &len);
+ if (nextcode == 0)
+ {
+ this->buffer_pos_ = this->buffer_end_;
+ return NULL;
+ }
+ this->buffer_pos_ += len;
+
+ // Read the tag.
+ if (this->buffer_pos_ >= this->buffer_end_)
+ return NULL;
+ uint64_t tag = read_unsigned_LEB_128(this->buffer_pos_, &len);
+ this->buffer_pos_ += len;
+
+ // Read the has_children flag.
+ if (this->buffer_pos_ >= this->buffer_end_)
+ return NULL;
+ bool has_children = *this->buffer_pos_ == elfcpp::DW_CHILDREN_yes;
+ this->buffer_pos_ += 1;
+
+ // Read the list of (attribute, form) pairs.
+ Abbrev_code* entry = new Abbrev_code(tag, has_children);
+ for (;;)
+ {
+ // Read the attribute.
+ if (this->buffer_pos_ >= this->buffer_end_)
+ return NULL;
+ uint64_t attr = read_unsigned_LEB_128(this->buffer_pos_, &len);
+ this->buffer_pos_ += len;
+
+ // Read the form.
+ if (this->buffer_pos_ >= this->buffer_end_)
+ return NULL;
+ uint64_t form = read_unsigned_LEB_128(this->buffer_pos_, &len);
+ this->buffer_pos_ += len;
+
+ // A (0,0) pair terminates the list.
+ if (attr == 0 && form == 0)
+ break;
+
+ if (attr == elfcpp::DW_AT_sibling)
+ entry->has_sibling_attribute = true;
+
+ entry->add_attribute(attr, form);
+ }
+
+ this->store_abbrev(nextcode, entry);
+ if (nextcode == code)
+ return entry;
+ }
+
+ return NULL;
+}
+
+// class Dwarf_ranges_table
+
+// Read the ranges table from an object file.
+
+bool
+Dwarf_ranges_table::read_ranges_table(
+ Relobj* object,
+ const unsigned char* symtab,
+ off_t symtab_size,
+ unsigned int ranges_shndx)
+{
+ // If we've already read this abbrev table, return immediately.
+ if (this->ranges_shndx_ > 0
+ && this->ranges_shndx_ == ranges_shndx)
+ return true;
+
+ // If we don't have relocations, ranges_shndx will be 0, and
+ // we'll have to hunt for the .debug_ranges section.
+ if (ranges_shndx == 0 && this->ranges_shndx_ > 0)
+ ranges_shndx = this->ranges_shndx_;
+ else if (ranges_shndx == 0)
+ {
+ for (unsigned int i = 1; i < object->shnum(); ++i)
+ {
+ std::string name = object->section_name(i);
+ if (name == ".debug_ranges")
+ {
+ ranges_shndx = i;
+ this->output_section_offset_ = object->output_section_offset(i);
+ break;
+ }
+ }
+ if (ranges_shndx == 0)
+ return false;
+ }
+
+ // Get the section contents and decompress if necessary.
+ if (ranges_shndx != this->ranges_shndx_)
+ {
+ if (this->owns_ranges_buffer_ && this->ranges_buffer_ != NULL)
+ {
+ delete[] this->ranges_buffer_;
+ this->owns_ranges_buffer_ = false;
+ }
+
+ section_size_type buffer_size;
+ this->ranges_buffer_ =
+ object->decompressed_section_contents(ranges_shndx,
+ &buffer_size,
+ &this->owns_ranges_buffer_);
+ this->ranges_buffer_end_ = this->ranges_buffer_ + buffer_size;
+ this->ranges_shndx_ = ranges_shndx;
+ }
+
+ if (this->ranges_reloc_mapper_ != NULL)
+ {
+ delete this->ranges_reloc_mapper_;
+ this->ranges_reloc_mapper_ = NULL;
+ }
+
+ // For incremental objects, we have no relocations.
+ if (object->is_incremental())
+ return true;
+
+ // Find the relocation section for ".debug_ranges".
+ unsigned int reloc_shndx = 0;
+ unsigned int reloc_type = 0;
+ for (unsigned int i = 0; i < object->shnum(); ++i)
+ {
+ reloc_type = object->section_type(i);
+ if ((reloc_type == elfcpp::SHT_REL
+ || reloc_type == elfcpp::SHT_RELA)
+ && object->section_info(i) == ranges_shndx)
+ {
+ reloc_shndx = i;
+ break;
+ }
+ }
+
+ this->ranges_reloc_mapper_ = make_elf_reloc_mapper(object, symtab,
+ symtab_size);
+ this->ranges_reloc_mapper_->initialize(reloc_shndx, reloc_type);
+
+ return true;
+}
+
+// Read a range list from section RANGES_SHNDX at offset RANGES_OFFSET.
+
+Dwarf_range_list*
+Dwarf_ranges_table::read_range_list(
+ Relobj* object,
+ const unsigned char* symtab,
+ off_t symtab_size,
+ unsigned int addr_size,
+ unsigned int ranges_shndx,
+ off_t offset)
+{
+ Dwarf_range_list* ranges;
+
+ if (!this->read_ranges_table(object, symtab, symtab_size, ranges_shndx))
+ return NULL;
+
+ // Correct the offset. For incremental update links, we have a
+ // relocated offset that is relative to the output section, but
+ // here we need an offset relative to the input section.
+ offset -= this->output_section_offset_;
+
+ // Read the range list at OFFSET.
+ ranges = new Dwarf_range_list();
+ off_t base = 0;
+ for (;
+ this->ranges_buffer_ + offset < this->ranges_buffer_end_;
+ offset += 2 * addr_size)
+ {
+ off_t start;
+ off_t end;
+
+ // Read the raw contents of the section.
+ if (addr_size == 4)
+ {
+ start = read_from_pointer<32>(this->ranges_buffer_ + offset);
+ end = read_from_pointer<32>(this->ranges_buffer_ + offset + 4);
+ }
+ else
+ {
+ start = read_from_pointer<64>(this->ranges_buffer_ + offset);
+ end = read_from_pointer<64>(this->ranges_buffer_ + offset + 8);
+ }
+
+ // Check for relocations and adjust the values.
+ unsigned int shndx1 = 0;
+ unsigned int shndx2 = 0;
+ if (this->ranges_reloc_mapper_ != NULL)
+ {
+ shndx1 =
+ this->ranges_reloc_mapper_->get_reloc_target(offset, &start);
+ shndx2 =
+ this->ranges_reloc_mapper_->get_reloc_target(offset + addr_size,
+ &end);
+ }
+
+ // End of list is marked by a pair of zeroes.
+ if (shndx1 == 0 && start == 0 && end == 0)
+ break;
+
+ // A "base address selection entry" is identified by
+ // 0xffffffff for the first value of the pair. The second
+ // value is used as a base for subsequent range list entries.
+ if (shndx1 == 0 && start == -1)
+ base = end;
+ else if (shndx1 == shndx2)
+ {
+ if (shndx1 == 0 || object->is_section_included(shndx1))
+ ranges->add(shndx1, base + start, base + end);
+ }
+ else
+ gold_warning(_("%s: DWARF info may be corrupt; offsets in a "
+ "range list entry are in different sections"),
+ object->name().c_str());
+ }
+
+ return ranges;
+}
+
+// class Dwarf_pubnames_table
+
+// Read the pubnames section SHNDX from the object file.
+
+bool
+Dwarf_pubnames_table::read_section(Relobj* object, unsigned int shndx)
+{
+ section_size_type buffer_size;
+
+ // If we don't have relocations, shndx will be 0, and
+ // we'll have to hunt for the .debug_pubnames/pubtypes section.
+ if (shndx == 0)
+ {
+ const char* name = (this->is_pubtypes_
+ ? ".debug_pubtypes"
+ : ".debug_pubnames");
+ for (unsigned int i = 1; i < object->shnum(); ++i)
+ {
+ if (object->section_name(i) == name)
+ {
+ shndx = i;
+ this->output_section_offset_ = object->output_section_offset(i);
+ break;
+ }
+ }
+ if (shndx == 0)
+ return false;
+ }
+
+ this->buffer_ = object->decompressed_section_contents(shndx,
+ &buffer_size,
+ &this->owns_buffer_);
+ if (this->buffer_ == NULL)
+ return false;
+ this->buffer_end_ = this->buffer_ + buffer_size;
+ return true;
+}
+
+// Read the header for the set at OFFSET.
+
+bool
+Dwarf_pubnames_table::read_header(off_t offset)
+{
+ // Correct the offset. For incremental update links, we have a
+ // relocated offset that is relative to the output section, but
+ // here we need an offset relative to the input section.
+ offset -= this->output_section_offset_;
+
+ if (offset < 0 || offset + 14 >= this->buffer_end_ - this->buffer_)
+ return false;
+
+ const unsigned char* pinfo = this->buffer_ + offset;
+
+ // Read the unit_length field.
+ uint32_t unit_length = read_from_pointer<32>(pinfo);
+ pinfo += 4;
+ if (unit_length == 0xffffffff)
+ {
+ unit_length = read_from_pointer<64>(pinfo);
+ pinfo += 8;
+ this->offset_size_ = 8;
+ }
+ else
+ this->offset_size_ = 4;
+
+ // Check the version.
+ unsigned int version = read_from_pointer<16>(pinfo);
+ pinfo += 2;
+ if (version != 2)
+ return false;
+
+ // Skip the debug_info_offset and debug_info_size fields.
+ pinfo += 2 * this->offset_size_;
+
+ if (pinfo >= this->buffer_end_)
+ return false;
+
+ this->pinfo_ = pinfo;
+ return true;
+}
+
+// Read the next name from the set.
+
+const char*
+Dwarf_pubnames_table::next_name()
+{
+ const unsigned char* pinfo = this->pinfo_;
+
+ // Read the offset within the CU. If this is zero, we have reached
+ // the end of the list.
+ uint32_t offset;
+ if (this->offset_size_ == 4)
+ offset = read_from_pointer<32>(&pinfo);
+ else
+ offset = read_from_pointer<64>(&pinfo);
+ if (offset == 0)
+ return NULL;
+
+ // Return a pointer to the string at the current location,
+ // and advance the pointer to the next entry.
+ const char* ret = reinterpret_cast<const char*>(pinfo);
+ while (pinfo < this->buffer_end_ && *pinfo != '\0')
+ ++pinfo;
+ if (pinfo < this->buffer_end_)
+ ++pinfo;
+
+ this->pinfo_ = pinfo;
+ return ret;
+}
+
+// class Dwarf_die
+
+Dwarf_die::Dwarf_die(
+ Dwarf_info_reader* dwinfo,
+ off_t die_offset,
+ Dwarf_die* parent)
+ : dwinfo_(dwinfo), parent_(parent), die_offset_(die_offset),
+ child_offset_(0), sibling_offset_(0), abbrev_code_(NULL), attributes_(),
+ attributes_read_(false), name_(NULL), name_off_(-1), linkage_name_(NULL),
+ linkage_name_off_(-1), string_shndx_(0), specification_(0),
+ abstract_origin_(0)
+{
+ size_t len;
+ const unsigned char* pdie = dwinfo->buffer_at_offset(die_offset);
+ if (pdie == NULL)
+ return;
+ unsigned int code = read_unsigned_LEB_128(pdie, &len);
+ if (code == 0)
+ {
+ if (parent != NULL)
+ parent->set_sibling_offset(die_offset + len);
+ return;
+ }
+ this->attr_offset_ = len;
+
+ // Lookup the abbrev code in the abbrev table.
+ this->abbrev_code_ = dwinfo->get_abbrev(code);
+}
+
+// Read all the attributes of the DIE.
+
+bool
+Dwarf_die::read_attributes()
+{
+ if (this->attributes_read_)
+ return true;
+
+ gold_assert(this->abbrev_code_ != NULL);
+
+ const unsigned char* pdie =
+ this->dwinfo_->buffer_at_offset(this->die_offset_);
+ if (pdie == NULL)
+ return false;
+ const unsigned char* pattr = pdie + this->attr_offset_;
+
+ unsigned int nattr = this->abbrev_code_->attributes.size();
+ this->attributes_.reserve(nattr);
+ for (unsigned int i = 0; i < nattr; ++i)
+ {
+ size_t len;
+ unsigned int attr = this->abbrev_code_->attributes[i].attr;
+ unsigned int form = this->abbrev_code_->attributes[i].form;
+ if (form == elfcpp::DW_FORM_indirect)
+ {
+ form = read_unsigned_LEB_128(pattr, &len);
+ pattr += len;
+ }
+ off_t attr_off = this->die_offset_ + (pattr - pdie);
+ bool ref_form = false;
+ Attribute_value attr_value;
+ attr_value.attr = attr;
+ attr_value.form = form;
+ attr_value.aux.shndx = 0;
+ switch(form)
+ {
+ case elfcpp::DW_FORM_null:
+ attr_value.val.intval = 0;
+ break;
+ case elfcpp::DW_FORM_flag_present:
+ attr_value.val.intval = 1;
+ break;
+ case elfcpp::DW_FORM_strp:
+ {
+ off_t str_off;
+ if (this->dwinfo_->offset_size() == 4)
+ str_off = read_from_pointer<32>(&pattr);
+ else
+ str_off = read_from_pointer<64>(&pattr);
+ unsigned int shndx =
+ this->dwinfo_->lookup_reloc(attr_off, &str_off);
+ attr_value.aux.shndx = shndx;
+ attr_value.val.refval = str_off;
+ break;
+ }
+ case elfcpp::DW_FORM_sec_offset:
+ {
+ off_t sec_off;
+ if (this->dwinfo_->offset_size() == 4)
+ sec_off = read_from_pointer<32>(&pattr);
+ else
+ sec_off = read_from_pointer<64>(&pattr);
+ unsigned int shndx =
+ this->dwinfo_->lookup_reloc(attr_off, &sec_off);
+ attr_value.aux.shndx = shndx;
+ attr_value.val.refval = sec_off;
+ ref_form = true;
+ break;
+ }
+ case elfcpp::DW_FORM_addr:
+ case elfcpp::DW_FORM_ref_addr:
+ {
+ off_t sec_off;
+ if (this->dwinfo_->address_size() == 4)
+ sec_off = read_from_pointer<32>(&pattr);
+ else
+ sec_off = read_from_pointer<64>(&pattr);
+ unsigned int shndx =
+ this->dwinfo_->lookup_reloc(attr_off, &sec_off);
+ attr_value.aux.shndx = shndx;
+ attr_value.val.refval = sec_off;
+ ref_form = true;
+ break;
+ }
+ case elfcpp::DW_FORM_block1:
+ attr_value.aux.blocklen = *pattr++;
+ attr_value.val.blockval = pattr;
+ pattr += attr_value.aux.blocklen;
+ break;
+ case elfcpp::DW_FORM_block2:
+ attr_value.aux.blocklen = read_from_pointer<16>(&pattr);
+ attr_value.val.blockval = pattr;
+ pattr += attr_value.aux.blocklen;
+ break;
+ case elfcpp::DW_FORM_block4:
+ attr_value.aux.blocklen = read_from_pointer<32>(&pattr);
+ attr_value.val.blockval = pattr;
+ pattr += attr_value.aux.blocklen;
+ break;
+ case elfcpp::DW_FORM_block:
+ case elfcpp::DW_FORM_exprloc:
+ attr_value.aux.blocklen = read_unsigned_LEB_128(pattr, &len);
+ attr_value.val.blockval = pattr + len;
+ pattr += len + attr_value.aux.blocklen;
+ break;
+ case elfcpp::DW_FORM_data1:
+ case elfcpp::DW_FORM_flag:
+ attr_value.val.intval = *pattr++;
+ break;
+ case elfcpp::DW_FORM_ref1:
+ attr_value.val.refval = *pattr++;
+ ref_form = true;
+ break;
+ case elfcpp::DW_FORM_data2:
+ attr_value.val.intval = read_from_pointer<16>(&pattr);
+ break;
+ case elfcpp::DW_FORM_ref2:
+ attr_value.val.refval = read_from_pointer<16>(&pattr);
+ ref_form = true;
+ break;
+ case elfcpp::DW_FORM_data4:
+ {
+ off_t sec_off;
+ sec_off = read_from_pointer<32>(&pattr);
+ unsigned int shndx =
+ this->dwinfo_->lookup_reloc(attr_off, &sec_off);
+ attr_value.aux.shndx = shndx;
+ attr_value.val.intval = sec_off;
+ break;
+ }
+ case elfcpp::DW_FORM_ref4:
+ {
+ off_t sec_off;
+ sec_off = read_from_pointer<32>(&pattr);
+ unsigned int shndx =
+ this->dwinfo_->lookup_reloc(attr_off, &sec_off);
+ attr_value.aux.shndx = shndx;
+ attr_value.val.refval = sec_off;
+ ref_form = true;
+ break;
+ }
+ case elfcpp::DW_FORM_data8:
+ {
+ off_t sec_off;
+ sec_off = read_from_pointer<64>(&pattr);
+ unsigned int shndx =
+ this->dwinfo_->lookup_reloc(attr_off, &sec_off);
+ attr_value.aux.shndx = shndx;
+ attr_value.val.intval = sec_off;
+ break;
+ }
+ case elfcpp::DW_FORM_ref_sig8:
+ attr_value.val.uintval = read_from_pointer<64>(&pattr);
+ break;
+ case elfcpp::DW_FORM_ref8:
+ {
+ off_t sec_off;
+ sec_off = read_from_pointer<64>(&pattr);
+ unsigned int shndx =
+ this->dwinfo_->lookup_reloc(attr_off, &sec_off);
+ attr_value.aux.shndx = shndx;
+ attr_value.val.refval = sec_off;
+ ref_form = true;
+ break;
+ }
+ case elfcpp::DW_FORM_ref_udata:
+ attr_value.val.refval = read_unsigned_LEB_128(pattr, &len);
+ ref_form = true;
+ pattr += len;
+ break;
+ case elfcpp::DW_FORM_udata:
+ attr_value.val.uintval = read_unsigned_LEB_128(pattr, &len);
+ pattr += len;
+ break;
+ case elfcpp::DW_FORM_sdata:
+ attr_value.val.intval = read_signed_LEB_128(pattr, &len);
+ pattr += len;
+ break;
+ case elfcpp::DW_FORM_string:
+ attr_value.val.stringval = reinterpret_cast<const char*>(pattr);
+ len = strlen(attr_value.val.stringval);
+ pattr += len + 1;
+ break;
+ default:
+ return false;
+ }
+
+ // Cache the most frequently-requested attributes.
+ switch (attr)
+ {
+ case elfcpp::DW_AT_name:
+ if (form == elfcpp::DW_FORM_string)
+ this->name_ = attr_value.val.stringval;
+ else if (form == elfcpp::DW_FORM_strp)
+ {
+ // All indirect strings should refer to the same
+ // string section, so we just save the last one seen.
+ this->string_shndx_ = attr_value.aux.shndx;
+ this->name_off_ = attr_value.val.refval;
+ }
+ break;
+ case elfcpp::DW_AT_linkage_name:
+ case elfcpp::DW_AT_MIPS_linkage_name:
+ if (form == elfcpp::DW_FORM_string)
+ this->linkage_name_ = attr_value.val.stringval;
+ else if (form == elfcpp::DW_FORM_strp)
+ {
+ // All indirect strings should refer to the same
+ // string section, so we just save the last one seen.
+ this->string_shndx_ = attr_value.aux.shndx;
+ this->linkage_name_off_ = attr_value.val.refval;
+ }
+ break;
+ case elfcpp::DW_AT_specification:
+ if (ref_form)
+ this->specification_ = attr_value.val.refval;
+ break;
+ case elfcpp::DW_AT_abstract_origin:
+ if (ref_form)
+ this->abstract_origin_ = attr_value.val.refval;
+ break;
+ case elfcpp::DW_AT_sibling:
+ if (ref_form && attr_value.aux.shndx == 0)
+ this->sibling_offset_ = attr_value.val.refval;
+ default:
+ break;
+ }
+
+ this->attributes_.push_back(attr_value);
+ }
+
+ // Now that we know where the next DIE begins, record the offset
+ // to avoid later recalculation.
+ if (this->has_children())
+ this->child_offset_ = this->die_offset_ + (pattr - pdie);
+ else
+ this->sibling_offset_ = this->die_offset_ + (pattr - pdie);
+
+ this->attributes_read_ = true;
+ return true;
+}
+
+// Skip all the attributes of the DIE and return the offset of the next DIE.
+
+off_t
+Dwarf_die::skip_attributes()
+{
+ typedef Dwarf_abbrev_table::Attribute Attribute;
+
+ gold_assert(this->abbrev_code_ != NULL);
+
+ const unsigned char* pdie =
+ this->dwinfo_->buffer_at_offset(this->die_offset_);
+ if (pdie == NULL)
+ return 0;
+ const unsigned char* pattr = pdie + this->attr_offset_;
+
+ for (unsigned int i = 0; i < this->abbrev_code_->attributes.size(); ++i)
+ {
+ size_t len;
+ unsigned int form = this->abbrev_code_->attributes[i].form;
+ if (form == elfcpp::DW_FORM_indirect)
+ {
+ form = read_unsigned_LEB_128(pattr, &len);
+ pattr += len;
+ }
+ switch(form)
+ {
+ case elfcpp::DW_FORM_null:
+ case elfcpp::DW_FORM_flag_present:
+ break;
+ case elfcpp::DW_FORM_strp:
+ case elfcpp::DW_FORM_sec_offset:
+ pattr += this->dwinfo_->offset_size();
+ break;
+ case elfcpp::DW_FORM_addr:
+ case elfcpp::DW_FORM_ref_addr:
+ pattr += this->dwinfo_->address_size();
+ break;
+ case elfcpp::DW_FORM_block1:
+ pattr += 1 + *pattr;
+ break;
+ case elfcpp::DW_FORM_block2:
+ {
+ uint16_t block_size;
+ block_size = read_from_pointer<16>(&pattr);
+ pattr += block_size;
+ break;
+ }
+ case elfcpp::DW_FORM_block4:
+ {
+ uint32_t block_size;
+ block_size = read_from_pointer<32>(&pattr);
+ pattr += block_size;
+ break;
+ }
+ case elfcpp::DW_FORM_block:
+ case elfcpp::DW_FORM_exprloc:
+ {
+ uint64_t block_size;
+ block_size = read_unsigned_LEB_128(pattr, &len);
+ pattr += len + block_size;
+ break;
+ }
+ case elfcpp::DW_FORM_data1:
+ case elfcpp::DW_FORM_ref1:
+ case elfcpp::DW_FORM_flag:
+ pattr += 1;
+ break;
+ case elfcpp::DW_FORM_data2:
+ case elfcpp::DW_FORM_ref2:
+ pattr += 2;
+ break;
+ case elfcpp::DW_FORM_data4:
+ case elfcpp::DW_FORM_ref4:
+ pattr += 4;
+ break;
+ case elfcpp::DW_FORM_data8:
+ case elfcpp::DW_FORM_ref8:
+ case elfcpp::DW_FORM_ref_sig8:
+ pattr += 8;
+ break;
+ case elfcpp::DW_FORM_ref_udata:
+ case elfcpp::DW_FORM_udata:
+ read_unsigned_LEB_128(pattr, &len);
+ pattr += len;
+ break;
+ case elfcpp::DW_FORM_sdata:
+ read_signed_LEB_128(pattr, &len);
+ pattr += len;
+ break;
+ case elfcpp::DW_FORM_string:
+ len = strlen(reinterpret_cast<const char*>(pattr));
+ pattr += len + 1;
+ break;
+ default:
+ return 0;
+ }
+ }
+
+ return this->die_offset_ + (pattr - pdie);
+}
+
+// Get the name of the DIE and cache it.
+
+void
+Dwarf_die::set_name()
+{
+ if (this->name_ != NULL || !this->read_attributes())
+ return;
+ if (this->name_off_ != -1)
+ this->name_ = this->dwinfo_->get_string(this->name_off_,
+ this->string_shndx_);
+}
+
+// Get the linkage name of the DIE and cache it.
+
+void
+Dwarf_die::set_linkage_name()
+{
+ if (this->linkage_name_ != NULL || !this->read_attributes())
+ return;
+ if (this->linkage_name_off_ != -1)
+ this->linkage_name_ = this->dwinfo_->get_string(this->linkage_name_off_,
+ this->string_shndx_);
+}
+
+// Return the value of attribute ATTR.
+
+const Dwarf_die::Attribute_value*
+Dwarf_die::attribute(unsigned int attr)
+{
+ if (!this->read_attributes())
+ return NULL;
+ for (unsigned int i = 0; i < this->attributes_.size(); ++i)
+ {
+ if (this->attributes_[i].attr == attr)
+ return &this->attributes_[i];
+ }
+ return NULL;
+}
+
+const char*
+Dwarf_die::string_attribute(unsigned int attr)
+{
+ const Attribute_value* attr_val = this->attribute(attr);
+ if (attr_val == NULL)
+ return NULL;
+ switch (attr_val->form)
+ {
+ case elfcpp::DW_FORM_string:
+ return attr_val->val.stringval;
+ case elfcpp::DW_FORM_strp:
+ return this->dwinfo_->get_string(attr_val->val.refval,
+ attr_val->aux.shndx);
+ default:
+ return NULL;
+ }
+}
+
+int64_t
+Dwarf_die::int_attribute(unsigned int attr)
+{
+ const Attribute_value* attr_val = this->attribute(attr);
+ if (attr_val == NULL)
+ return 0;
+ switch (attr_val->form)
+ {
+ case elfcpp::DW_FORM_null:
+ case elfcpp::DW_FORM_flag_present:
+ case elfcpp::DW_FORM_data1:
+ case elfcpp::DW_FORM_flag:
+ case elfcpp::DW_FORM_data2:
+ case elfcpp::DW_FORM_data4:
+ case elfcpp::DW_FORM_data8:
+ case elfcpp::DW_FORM_sdata:
+ return attr_val->val.intval;
+ default:
+ return 0;
+ }
+}
+
+uint64_t
+Dwarf_die::uint_attribute(unsigned int attr)
+{
+ const Attribute_value* attr_val = this->attribute(attr);
+ if (attr_val == NULL)
+ return 0;
+ switch (attr_val->form)
+ {
+ case elfcpp::DW_FORM_null:
+ case elfcpp::DW_FORM_flag_present:
+ case elfcpp::DW_FORM_data1:
+ case elfcpp::DW_FORM_flag:
+ case elfcpp::DW_FORM_data4:
+ case elfcpp::DW_FORM_data8:
+ case elfcpp::DW_FORM_ref_sig8:
+ case elfcpp::DW_FORM_udata:
+ return attr_val->val.uintval;
+ default:
+ return 0;
+ }
+}
+
+off_t
+Dwarf_die::ref_attribute(unsigned int attr, unsigned int* shndx)
+{
+ const Attribute_value* attr_val = this->attribute(attr);
+ if (attr_val == NULL)
+ return -1;
+ switch (attr_val->form)
+ {
+ case elfcpp::DW_FORM_sec_offset:
+ case elfcpp::DW_FORM_addr:
+ case elfcpp::DW_FORM_ref_addr:
+ case elfcpp::DW_FORM_ref1:
+ case elfcpp::DW_FORM_ref2:
+ case elfcpp::DW_FORM_ref4:
+ case elfcpp::DW_FORM_ref8:
+ case elfcpp::DW_FORM_ref_udata:
+ *shndx = attr_val->aux.shndx;
+ return attr_val->val.refval;
+ case elfcpp::DW_FORM_ref_sig8:
+ *shndx = attr_val->aux.shndx;
+ return attr_val->val.uintval;
+ case elfcpp::DW_FORM_data4:
+ case elfcpp::DW_FORM_data8:
+ *shndx = attr_val->aux.shndx;
+ return attr_val->val.intval;
+ default:
+ return -1;
+ }
+}
+
+// Return the offset of this DIE's first child.
+
+off_t
+Dwarf_die::child_offset()
+{
+ gold_assert(this->abbrev_code_ != NULL);
+ if (!this->has_children())
+ return 0;
+ if (this->child_offset_ == 0)
+ this->child_offset_ = this->skip_attributes();
+ return this->child_offset_;
+}
+
+// Return the offset of this DIE's next sibling.
+
+off_t
+Dwarf_die::sibling_offset()
+{
+ gold_assert(this->abbrev_code_ != NULL);
+
+ if (this->sibling_offset_ != 0)
+ return this->sibling_offset_;
+
+ if (!this->has_children())
+ {
+ this->sibling_offset_ = this->skip_attributes();
+ return this->sibling_offset_;
+ }
+
+ if (this->has_sibling_attribute())
+ {
+ if (!this->read_attributes())
+ return 0;
+ if (this->sibling_offset_ != 0)
+ return this->sibling_offset_;
+ }
+
+ // Skip over the children.
+ off_t child_offset = this->child_offset();
+ while (child_offset > 0)
+ {
+ Dwarf_die die(this->dwinfo_, child_offset, this);
+ // The Dwarf_die ctor will set this DIE's sibling offset
+ // when it reads a zero abbrev code.
+ if (die.tag() == 0)
+ break;
+ child_offset = die.sibling_offset();
+ }
+
+ // This should be set by now. If not, there was a problem reading
+ // the DWARF info, and we return 0.
+ return this->sibling_offset_;
+}
+
+// class Dwarf_info_reader
+
+// Check that the pointer P is within the current compilation unit.
+
+inline bool
+Dwarf_info_reader::check_buffer(const unsigned char* p) const
+{
+ if (p > this->buffer_ + this->cu_offset_ + this->cu_length_)
+ {
+ gold_warning(_("%s: corrupt debug info in %s"),
+ this->object_->name().c_str(),
+ this->object_->section_name(this->shndx_).c_str());
+ return false;
+ }
+ return true;
+}
+
+// Begin parsing the debug info. This calls visit_compilation_unit()
+// or visit_type_unit() for each compilation or type unit found in the
+// section, and visit_die() for each top-level DIE.
+
+void
+Dwarf_info_reader::parse()
+{
+ switch (parameters->size_and_endianness())
+ {
+#ifdef HAVE_TARGET_32_LITTLE
+ case Parameters::TARGET_32_LITTLE:
+ this->do_parse<false>();
+ break;
+#endif
+#ifdef HAVE_TARGET_32_BIG
+ case Parameters::TARGET_32_BIG:
+ this->do_parse<true>();
+ break;
+#endif
+#ifdef HAVE_TARGET_64_LITTLE
+ case Parameters::TARGET_64_LITTLE:
+ this->do_parse<false>();
+ break;
+#endif
+#ifdef HAVE_TARGET_64_BIG
+ case Parameters::TARGET_64_BIG:
+ this->do_parse<true>();
+ break;
+#endif
+ default:
+ gold_unreachable();
+ }
+}
+
+template<bool big_endian>
+void
+Dwarf_info_reader::do_parse()
+{
+ // Get the section contents and decompress if necessary.
+ section_size_type buffer_size;
+ bool buffer_is_new;
+ this->buffer_ = this->object_->decompressed_section_contents(this->shndx_,
+ &buffer_size,
+ &buffer_is_new);
+ if (this->buffer_ == NULL || buffer_size == 0)
+ return;
+ this->buffer_end_ = this->buffer_ + buffer_size;
+
+ // The offset of this input section in the output section.
+ off_t section_offset = this->object_->output_section_offset(this->shndx_);
+
+ // Start tracking relocations for this section.
+ this->reloc_mapper_ = make_elf_reloc_mapper(this->object_, this->symtab_,
+ this->symtab_size_);
+ this->reloc_mapper_->initialize(this->reloc_shndx_, this->reloc_type_);
+
+ // Loop over compilation units (or type units).
+ unsigned int abbrev_shndx = 0;
+ off_t abbrev_offset = 0;
+ const unsigned char* pinfo = this->buffer_;
+ while (pinfo < this->buffer_end_)
+ {
+ // Read the compilation (or type) unit header.
+ const unsigned char* cu_start = pinfo;
+ this->cu_offset_ = cu_start - this->buffer_;
+ this->cu_length_ = this->buffer_end_ - cu_start;
+
+ // Read unit_length (4 or 12 bytes).
+ if (!this->check_buffer(pinfo + 4))
+ break;
+ uint32_t unit_length =
+ elfcpp::Swap_unaligned<32, big_endian>::readval(pinfo);
+ pinfo += 4;
+ if (unit_length == 0xffffffff)
+ {
+ if (!this->check_buffer(pinfo + 8))
+ break;
+ unit_length = elfcpp::Swap_unaligned<64, big_endian>::readval(pinfo);
+ pinfo += 8;
+ this->offset_size_ = 8;
+ }
+ else
+ this->offset_size_ = 4;
+ if (!this->check_buffer(pinfo + unit_length))
+ break;
+ const unsigned char* cu_end = pinfo + unit_length;
+ this->cu_length_ = cu_end - cu_start;
+ if (!this->check_buffer(pinfo + 2 + this->offset_size_ + 1))
+ break;
+
+ // Read version (2 bytes).
+ this->cu_version_ =
+ elfcpp::Swap_unaligned<16, big_endian>::readval(pinfo);
+ pinfo += 2;
+
+ // Read debug_abbrev_offset (4 or 8 bytes).
+ if (this->offset_size_ == 4)
+ abbrev_offset = elfcpp::Swap_unaligned<32, big_endian>::readval(pinfo);
+ else
+ abbrev_offset = elfcpp::Swap_unaligned<64, big_endian>::readval(pinfo);
+ if (this->reloc_shndx_ > 0)
+ {
+ off_t reloc_offset = pinfo - this->buffer_;
+ off_t value;
+ abbrev_shndx =
+ this->reloc_mapper_->get_reloc_target(reloc_offset, &value);
+ if (abbrev_shndx == 0)
+ return;
+ if (this->reloc_type_ == elfcpp::SHT_REL)
+ abbrev_offset += value;
+ else
+ abbrev_offset = value;
+ }
+ pinfo += this->offset_size_;
+
+ // Read address_size (1 byte).
+ this->address_size_ = *pinfo++;
+
+ // For type units, read the two extra fields.
+ uint64_t signature = 0;
+ off_t type_offset = 0;
+ if (this->is_type_unit_)
+ {
+ if (!this->check_buffer(pinfo + 8 + this->offset_size_))
+ break;
+
+ // Read type_signature (8 bytes).
+ signature = elfcpp::Swap_unaligned<64, big_endian>::readval(pinfo);
+ pinfo += 8;
+
+ // Read type_offset (4 or 8 bytes).
+ if (this->offset_size_ == 4)
+ type_offset =
+ elfcpp::Swap_unaligned<32, big_endian>::readval(pinfo);
+ else
+ type_offset =
+ elfcpp::Swap_unaligned<64, big_endian>::readval(pinfo);
+ pinfo += this->offset_size_;
+ }
+
+ // Read the .debug_abbrev table.
+ this->abbrev_table_.read_abbrevs(this->object_, abbrev_shndx,
+ abbrev_offset);
+
+ // Visit the root DIE.
+ Dwarf_die root_die(this,
+ pinfo - (this->buffer_ + this->cu_offset_),
+ NULL);
+ if (root_die.tag() != 0)
+ {
+ // Visit the CU or TU.
+ if (this->is_type_unit_)
+ this->visit_type_unit(section_offset + this->cu_offset_,
+ type_offset, signature, &root_die);
+ else
+ this->visit_compilation_unit(section_offset + this->cu_offset_,
+ cu_end - cu_start, &root_die);
+ }
+
+ // Advance to the next CU.
+ pinfo = cu_end;
+ }
+
+ if (buffer_is_new)
+ {
+ delete[] this->buffer_;
+ this->buffer_ = NULL;
+ }
+}
+
+// Read the DWARF string table.
+
+bool
+Dwarf_info_reader::do_read_string_table(unsigned int string_shndx)
+{
+ Relobj* object = this->object_;
+
+ // If we don't have relocations, string_shndx will be 0, and
+ // we'll have to hunt for the .debug_str section.
+ if (string_shndx == 0)
+ {
+ for (unsigned int i = 1; i < this->object_->shnum(); ++i)
+ {
+ std::string name = object->section_name(i);
+ if (name == ".debug_str")
+ {
+ string_shndx = i;
+ this->string_output_section_offset_ =
+ object->output_section_offset(i);
+ break;
+ }
+ }
+ if (string_shndx == 0)
+ return false;
+ }
+
+ if (this->owns_string_buffer_ && this->string_buffer_ != NULL)
+ {
+ delete[] this->string_buffer_;
+ this->owns_string_buffer_ = false;
+ }
+
+ // Get the secton contents and decompress if necessary.
+ section_size_type buffer_size;
+ const unsigned char* buffer =
+ object->decompressed_section_contents(string_shndx,
+ &buffer_size,
+ &this->owns_string_buffer_);
+ this->string_buffer_ = reinterpret_cast<const char*>(buffer);
+ this->string_buffer_end_ = this->string_buffer_ + buffer_size;
+ this->string_shndx_ = string_shndx;
+ return true;
+}
+
+// Look for a relocation at offset ATTR_OFF in the dwarf info,
+// and return the section index and offset of the target.
+
+unsigned int
+Dwarf_info_reader::lookup_reloc(off_t attr_off, off_t* target_off)
+{
+ off_t value;
+ attr_off += this->cu_offset_;
+ unsigned int shndx = this->reloc_mapper_->get_reloc_target(attr_off, &value);
+ if (shndx == 0)
+ return 0;
+ if (this->reloc_type_ == elfcpp::SHT_REL)
+ *target_off += value;
+ else
+ *target_off = value;
+ return shndx;
+}
+
+// Return a string from the DWARF string table.
+
+const char*
+Dwarf_info_reader::get_string(off_t str_off, unsigned int string_shndx)
+{
+ if (!this->read_string_table(string_shndx))
+ return NULL;
+
+ // Correct the offset. For incremental update links, we have a
+ // relocated offset that is relative to the output section, but
+ // here we need an offset relative to the input section.
+ str_off -= this->string_output_section_offset_;
+
+ const char* p = this->string_buffer_ + str_off;
+
+ if (p < this->string_buffer_ || p >= this->string_buffer_end_)
+ return NULL;
+
+ return p;
+}
+
+// The following are default, do-nothing, implementations of the
+// hook methods normally provided by a derived class. We provide
+// default implementations rather than no implementation so that
+// a derived class needs to implement only the hooks that it needs
+// to use.
+
+// Process a compilation unit and parse its child DIE.
+
+void
+Dwarf_info_reader::visit_compilation_unit(off_t, off_t, Dwarf_die*)
+{
+}
+
+// Process a type unit and parse its child DIE.
+
+void
+Dwarf_info_reader::visit_type_unit(off_t, off_t, uint64_t, Dwarf_die*)
+{
+}
+
+// class Sized_dwarf_line_info
+
struct LineStateMachine
{
int file_num;
Object* object,
unsigned int read_shndx)
: data_valid_(false), buffer_(NULL), buffer_start_(NULL),
- symtab_buffer_(NULL), directories_(), files_(), current_header_index_(-1)
+ reloc_mapper_(NULL), symtab_buffer_(NULL), directories_(), files_(),
+ current_header_index_(-1)
{
unsigned int debug_shndx;
// Find the relocation section for ".debug_line".
// We expect these for relobjs (.o's) but not dynobjs (.so's).
- bool got_relocs = false;
- for (unsigned int reloc_shndx = 0;
- reloc_shndx < object->shnum();
- ++reloc_shndx)
+ unsigned int reloc_shndx = 0;
+ for (unsigned int i = 0; i < object->shnum(); ++i)
{
- unsigned int reloc_sh_type = object->section_type(reloc_shndx);
+ unsigned int reloc_sh_type = object->section_type(i);
if ((reloc_sh_type == elfcpp::SHT_REL
|| reloc_sh_type == elfcpp::SHT_RELA)
- && object->section_info(reloc_shndx) == debug_shndx)
+ && object->section_info(i) == debug_shndx)
{
- got_relocs = this->track_relocs_.initialize(object, reloc_shndx,
- reloc_sh_type);
+ reloc_shndx = i;
this->track_relocs_type_ = reloc_sh_type;
break;
}
}
// Finally, we need the symtab section to interpret the relocs.
- if (got_relocs)
+ if (reloc_shndx != 0)
{
unsigned int symtab_shndx;
for (symtab_shndx = 0; symtab_shndx < object->shnum(); ++symtab_shndx)
if (object->section_type(symtab_shndx) == elfcpp::SHT_SYMTAB)
{
- this->symtab_buffer_ = object->section_contents(
- symtab_shndx, &this->symtab_buffer_size_, false);
+ this->symtab_buffer_ = object->section_contents(
+ symtab_shndx, &this->symtab_buffer_size_, false);
break;
}
if (this->symtab_buffer_ == NULL)
return;
}
+ this->reloc_mapper_ =
+ new Sized_elf_reloc_mapper<size, big_endian>(object,
+ this->symtab_buffer_,
+ this->symtab_buffer_size_);
+ if (!this->reloc_mapper_->initialize(reloc_shndx, this->track_relocs_type_))
+ return;
+
// Now that we have successfully read all the data, parse the debug
// info.
this->data_valid_ = true;
- this->read_line_mappings(object, read_shndx);
+ this->read_line_mappings(read_shndx);
}
// Read the DWARF header.
return lengthstart + header_.total_length;
}
-// Looks in the symtab to see what section a symbol is in.
-
-template<int size, bool big_endian>
-unsigned int
-Sized_dwarf_line_info<size, big_endian>::symbol_section(
- Object* object,
- unsigned int sym,
- typename elfcpp::Elf_types<size>::Elf_Addr* value,
- bool* is_ordinary)
-{
- const int symsize = elfcpp::Elf_sizes<size>::sym_size;
- gold_assert(sym * symsize < this->symtab_buffer_size_);
- elfcpp::Sym<size, big_endian> elfsym(this->symtab_buffer_ + sym * symsize);
- *value = elfsym.get_st_value();
- return object->adjust_sym_shndx(sym, elfsym.get_st_shndx(), is_ordinary);
-}
-
// Read the relocations into a Reloc_map.
template<int size, bool big_endian>
void
-Sized_dwarf_line_info<size, big_endian>::read_relocs(Object* object)
+Sized_dwarf_line_info<size, big_endian>::read_relocs()
{
if (this->symtab_buffer_ == NULL)
return;
- typename elfcpp::Elf_types<size>::Elf_Addr value;
+ off_t value;
off_t reloc_offset;
- while ((reloc_offset = this->track_relocs_.next_offset()) != -1)
+ while ((reloc_offset = this->reloc_mapper_->next_offset()) != -1)
{
- const unsigned int sym = this->track_relocs_.next_symndx();
-
- bool is_ordinary;
- const unsigned int shndx = this->symbol_section(object, sym, &value,
- &is_ordinary);
+ const unsigned int shndx =
+ this->reloc_mapper_->get_reloc_target(reloc_offset, &value);
// There is no reason to record non-ordinary section indexes, or
// SHN_UNDEF, because they will never match the real section.
- if (is_ordinary && shndx != elfcpp::SHN_UNDEF)
- {
- value += this->track_relocs_.next_addend();
- this->reloc_map_[reloc_offset] = std::make_pair(shndx, value);
- }
+ if (shndx != 0)
+ this->reloc_map_[reloc_offset] = std::make_pair(shndx, value);
- this->track_relocs_.advance(reloc_offset + 1);
+ this->reloc_mapper_->advance(reloc_offset + 1);
}
}
template<int size, bool big_endian>
void
-Sized_dwarf_line_info<size, big_endian>::read_line_mappings(Object* object,
- unsigned int shndx)
+Sized_dwarf_line_info<size, big_endian>::read_line_mappings(unsigned int shndx)
{
gold_assert(this->data_valid_ == true);
- this->read_relocs(object);
+ this->read_relocs();
while (this->buffer_ < this->buffer_end_)
{
const unsigned char* lineptr = this->buffer_;
gold_assert(loc.header_num < static_cast<int>(this->files_.size()));
gold_assert(loc.file_num
- < static_cast<int>(this->files_[loc.header_num].size()));
+ < static_cast<unsigned int>(this->files_[loc.header_num].size()));
const std::pair<int, std::string>& filename_pair
= this->files_[loc.header_num][loc.file_num];
const std::string& filename = filename_pair.second;
// dwarf_reader.h -- parse dwarf2/3 debug information for gold -*- C++ -*-
-// Copyright 2007, 2008, 2009, 2010 Free Software Foundation, Inc.
+// Copyright 2007, 2008, 2009, 2010, 2011, 2012 Free Software Foundation, Inc.
// Written by Ian Lance Taylor <iant@google.com>.
// This file is part of gold.
#include <vector>
#include <map>
#include <limits.h>
+#include <sys/types.h>
#include "elfcpp.h"
#include "elfcpp_swap.h"
namespace gold
{
-template<int size, bool big_endian>
-class Track_relocs;
+class Dwarf_info_reader;
struct LineStateMachine;
+// This class is used to extract the section index and offset of
+// the target of a relocation for a given offset within the section.
+
+class Elf_reloc_mapper
+{
+ public:
+ Elf_reloc_mapper()
+ { }
+
+ virtual
+ ~Elf_reloc_mapper()
+ { }
+
+ // Initialize the relocation tracker for section RELOC_SHNDX.
+ bool
+ initialize(unsigned int reloc_shndx, unsigned int reloc_type)
+ { return this->do_initialize(reloc_shndx, reloc_type); }
+
+ // Return the next reloc_offset.
+ off_t
+ next_offset()
+ { return this->do_next_offset(); }
+
+ // Advance to the next relocation past OFFSET.
+ void
+ advance(off_t offset)
+ { this->do_advance(offset); }
+
+ // Return the section index and offset within the section of the target
+ // of the relocation for RELOC_OFFSET in the referring section.
+ unsigned int
+ get_reloc_target(off_t reloc_offset, off_t* target_offset)
+ { return this->do_get_reloc_target(reloc_offset, target_offset); }
+
+ // Checkpoint the current position in the reloc section.
+ uint64_t
+ checkpoint() const
+ { return this->do_checkpoint(); }
+
+ // Reset the current position to the CHECKPOINT.
+ void
+ reset(uint64_t checkpoint)
+ { this->do_reset(checkpoint); }
+
+ protected:
+ virtual bool
+ do_initialize(unsigned int, unsigned int) = 0;
+
+ // Return the next reloc_offset.
+ virtual off_t
+ do_next_offset() = 0;
+
+ // Advance to the next relocation past OFFSET.
+ virtual void
+ do_advance(off_t offset) = 0;
+
+ virtual unsigned int
+ do_get_reloc_target(off_t reloc_offset, off_t* target_offset) = 0;
+
+ // Checkpoint the current position in the reloc section.
+ virtual uint64_t
+ do_checkpoint() const = 0;
+
+ // Reset the current position to the CHECKPOINT.
+ virtual void
+ do_reset(uint64_t checkpoint) = 0;
+};
+
+template<int size, bool big_endian>
+class Sized_elf_reloc_mapper : public Elf_reloc_mapper
+{
+ public:
+ Sized_elf_reloc_mapper(Object* object, const unsigned char* symtab,
+ off_t symtab_size)
+ : object_(object), symtab_(symtab), symtab_size_(symtab_size),
+ reloc_type_(0), track_relocs_()
+ { }
+
+ protected:
+ bool
+ do_initialize(unsigned int reloc_shndx, unsigned int reloc_type);
+
+ // Return the next reloc_offset.
+ virtual off_t
+ do_next_offset()
+ { return this->track_relocs_.next_offset(); }
+
+ // Advance to the next relocation past OFFSET.
+ virtual void
+ do_advance(off_t offset)
+ { this->track_relocs_.advance(offset); }
+
+ unsigned int
+ do_get_reloc_target(off_t reloc_offset, off_t* target_offset);
+
+ // Checkpoint the current position in the reloc section.
+ uint64_t
+ do_checkpoint() const
+ { return this->track_relocs_.checkpoint(); }
+
+ // Reset the current position to the CHECKPOINT.
+ void
+ do_reset(uint64_t checkpoint)
+ { this->track_relocs_.reset(checkpoint); }
+
+ private:
+ typedef typename elfcpp::Elf_types<size>::Elf_Addr Address;
+
+ // Return the section index of symbol SYMNDX, and copy its value to *VALUE.
+ // Set *IS_ORDINARY true if the section index is an ordinary section index.
+ unsigned int
+ symbol_section(unsigned int symndx, Address* value, bool* is_ordinary);
+
+ // The object file.
+ Object* object_;
+ // The ELF symbol table.
+ const unsigned char* symtab_;
+ // The size of the ELF symbol table.
+ off_t symtab_size_;
+ // Type of the relocation section (SHT_REL or SHT_RELA).
+ unsigned int reloc_type_;
+ // Relocations for the referring section.
+ Track_relocs<size, big_endian> track_relocs_;
+};
+
+// This class is used to read the abbreviations table from the
+// .debug_abbrev section of the object file.
+
+class Dwarf_abbrev_table
+{
+ public:
+ // An attribute list entry.
+ struct Attribute
+ {
+ Attribute(unsigned int a, unsigned int f)
+ : attr(a), form(f)
+ { }
+ unsigned int attr;
+ unsigned int form;
+ };
+
+ // An abbrev code entry.
+ struct Abbrev_code
+ {
+ Abbrev_code(unsigned int t, bool hc)
+ : tag(t), has_children(hc), has_sibling_attribute(false), attributes()
+ {
+ this->attributes.reserve(10);
+ }
+
+ void
+ add_attribute(unsigned int attr, unsigned int form)
+ {
+ this->attributes.push_back(Attribute(attr, form));
+ }
+
+ // The DWARF tag.
+ unsigned int tag;
+ // True if the DIE has children.
+ bool has_children : 1;
+ // True if the DIE has a sibling attribute.
+ bool has_sibling_attribute : 1;
+ // The list of attributes and forms.
+ std::vector<Attribute> attributes;
+ };
+
+ Dwarf_abbrev_table()
+ : abbrev_shndx_(0), abbrev_offset_(0), buffer_(NULL), buffer_end_(NULL),
+ owns_buffer_(false), buffer_pos_(NULL), high_abbrev_codes_()
+ {
+ memset(this->low_abbrev_codes_, 0, sizeof(this->low_abbrev_codes_));
+ }
+
+ ~Dwarf_abbrev_table()
+ {
+ if (this->owns_buffer_ && this->buffer_ != NULL)
+ delete[] this->buffer_;
+ this->clear_abbrev_codes();
+ }
+
+ // Read the abbrev table from an object file.
+ bool
+ read_abbrevs(Relobj* object,
+ unsigned int abbrev_shndx,
+ off_t abbrev_offset)
+ {
+ // If we've already read this abbrev table, return immediately.
+ if (this->abbrev_shndx_ > 0
+ && this->abbrev_shndx_ == abbrev_shndx
+ && this->abbrev_offset_ == abbrev_offset)
+ return true;
+ return this->do_read_abbrevs(object, abbrev_shndx, abbrev_offset);
+ }
+
+ // Return the abbrev code entry for CODE. This is a fast path for
+ // abbrev codes that are in the direct lookup table. If not found
+ // there, we call do_get_abbrev() to do the hard work.
+ const Abbrev_code*
+ get_abbrev(unsigned int code)
+ {
+ if (code < this->low_abbrev_code_max_
+ && this->low_abbrev_codes_[code] != NULL)
+ return this->low_abbrev_codes_[code];
+ return this->do_get_abbrev(code);
+ }
+
+ private:
+ // Read the abbrev table from an object file.
+ bool
+ do_read_abbrevs(Relobj* object,
+ unsigned int abbrev_shndx,
+ off_t abbrev_offset);
+
+ // Lookup the abbrev code entry for CODE.
+ const Abbrev_code*
+ do_get_abbrev(unsigned int code);
+
+ // Store an abbrev code entry for CODE.
+ void
+ store_abbrev(unsigned int code, const Abbrev_code* entry)
+ {
+ if (code < this->low_abbrev_code_max_)
+ this->low_abbrev_codes_[code] = entry;
+ else
+ this->high_abbrev_codes_[code] = entry;
+ }
+
+ // Clear the abbrev code table and release the memory it uses.
+ void
+ clear_abbrev_codes();
+
+ typedef Unordered_map<unsigned int, const Abbrev_code*> Abbrev_code_table;
+
+ // The section index of the current abbrev table.
+ unsigned int abbrev_shndx_;
+ // The offset within the section of the current abbrev table.
+ off_t abbrev_offset_;
+ // The buffer containing the .debug_abbrev section.
+ const unsigned char* buffer_;
+ const unsigned char* buffer_end_;
+ // True if this object owns the buffer and needs to delete it.
+ bool owns_buffer_;
+ // Pointer to the current position in the buffer.
+ const unsigned char* buffer_pos_;
+ // The table of abbrev codes.
+ // We use a direct-lookup array for low abbrev codes,
+ // and store the rest in a hash table.
+ static const unsigned int low_abbrev_code_max_ = 256;
+ const Abbrev_code* low_abbrev_codes_[low_abbrev_code_max_];
+ Abbrev_code_table high_abbrev_codes_;
+};
+
+// A DWARF range list. The start and end offsets are relative
+// to the input section SHNDX. Each range must lie entirely
+// within a single section.
+
+class Dwarf_range_list
+{
+ public:
+ struct Range
+ {
+ Range(unsigned int a_shndx, off_t a_start, off_t a_end)
+ : shndx(a_shndx), start(a_start), end(a_end)
+ { }
+
+ unsigned int shndx;
+ off_t start;
+ off_t end;
+ };
+
+ Dwarf_range_list()
+ : range_list_()
+ { }
+
+ void
+ add(unsigned int shndx, off_t start, off_t end)
+ { this->range_list_.push_back(Range(shndx, start, end)); }
+
+ size_t
+ size() const
+ { return this->range_list_.size(); }
+
+ const Range&
+ operator[](off_t i) const
+ { return this->range_list_[i]; }
+
+ private:
+ std::vector<Range> range_list_;
+};
+
+// This class is used to read the ranges table from the
+// .debug_ranges section of the object file.
+
+class Dwarf_ranges_table
+{
+ public:
+ Dwarf_ranges_table()
+ : ranges_shndx_(0), ranges_buffer_(NULL), ranges_buffer_end_(NULL),
+ owns_ranges_buffer_(false), ranges_reloc_mapper_(NULL),
+ output_section_offset_(0)
+ { }
+
+ ~Dwarf_ranges_table()
+ {
+ if (this->owns_ranges_buffer_ && this->ranges_buffer_ != NULL)
+ delete[] this->ranges_buffer_;
+ if (this->ranges_reloc_mapper_ != NULL)
+ delete this->ranges_reloc_mapper_;
+ }
+
+ // Read the ranges table from an object file.
+ bool
+ read_ranges_table(Relobj* object,
+ const unsigned char* symtab,
+ off_t symtab_size,
+ unsigned int ranges_shndx);
+
+ // Read the range table from an object file.
+ Dwarf_range_list*
+ read_range_list(Relobj* object,
+ const unsigned char* symtab,
+ off_t symtab_size,
+ unsigned int address_size,
+ unsigned int ranges_shndx,
+ off_t ranges_offset);
+
+ private:
+ // The section index of the ranges table.
+ unsigned int ranges_shndx_;
+ // The buffer containing the .debug_ranges section.
+ const unsigned char* ranges_buffer_;
+ const unsigned char* ranges_buffer_end_;
+ // True if this object owns the buffer and needs to delete it.
+ bool owns_ranges_buffer_;
+ // Relocation mapper for the .debug_ranges section.
+ Elf_reloc_mapper* ranges_reloc_mapper_;
+ // For incremental update links, this will hold the offset of the
+ // input section within the output section. Offsets read from
+ // relocated data will be relative to the output section, and need
+ // to be corrected before reading data from the input section.
+ uint64_t output_section_offset_;
+};
+
+// This class is used to read the pubnames and pubtypes tables from the
+// .debug_pubnames and .debug_pubtypes sections of the object file.
+
+class Dwarf_pubnames_table
+{
+ public:
+ Dwarf_pubnames_table(bool is_pubtypes)
+ : buffer_(NULL), buffer_end_(NULL), owns_buffer_(false),
+ offset_size_(0), pinfo_(NULL), is_pubtypes_(is_pubtypes),
+ output_section_offset_(0)
+ { }
+
+ ~Dwarf_pubnames_table()
+ {
+ if (this->owns_buffer_ && this->buffer_ != NULL)
+ delete[] this->buffer_;
+ }
+
+ // Read the pubnames section SHNDX from the object file.
+ bool
+ read_section(Relobj* object, unsigned int shndx);
+
+ // Read the header for the set at OFFSET.
+ bool
+ read_header(off_t offset);
+
+ // Read the next name from the set.
+ const char*
+ next_name();
+
+ private:
+ // The buffer containing the .debug_ranges section.
+ const unsigned char* buffer_;
+ const unsigned char* buffer_end_;
+ // True if this object owns the buffer and needs to delete it.
+ bool owns_buffer_;
+ // The size of a DWARF offset for the current set.
+ unsigned int offset_size_;
+ // The current position within the buffer.
+ const unsigned char* pinfo_;
+ // TRUE if this is a .debug_pubtypes section.
+ bool is_pubtypes_;
+ // For incremental update links, this will hold the offset of the
+ // input section within the output section. Offsets read from
+ // relocated data will be relative to the output section, and need
+ // to be corrected before reading data from the input section.
+ uint64_t output_section_offset_;
+};
+
+// This class represents a DWARF Debug Info Entry (DIE).
+
+class Dwarf_die
+{
+ public:
+ // An attribute value.
+ struct Attribute_value
+ {
+ unsigned int attr;
+ unsigned int form;
+ union
+ {
+ int64_t intval;
+ uint64_t uintval;
+ const char* stringval;
+ const unsigned char* blockval;
+ off_t refval;
+ } val;
+ union
+ {
+ // Section index for reference forms.
+ unsigned int shndx;
+ // Block length for block forms.
+ unsigned int blocklen;
+ // Attribute offset for DW_FORM_strp.
+ unsigned int attr_off;
+ } aux;
+ };
+
+ // A list of attribute values.
+ typedef std::vector<Attribute_value> Attributes;
+
+ Dwarf_die(Dwarf_info_reader* dwinfo,
+ off_t die_offset,
+ Dwarf_die* parent);
+
+ // Return the DWARF tag for this DIE.
+ unsigned int
+ tag() const
+ {
+ if (this->abbrev_code_ == NULL)
+ return 0;
+ return this->abbrev_code_->tag;
+ }
+
+ // Return true if this DIE has children.
+ bool
+ has_children() const
+ {
+ gold_assert(this->abbrev_code_ != NULL);
+ return this->abbrev_code_->has_children;
+ }
+
+ // Return true if this DIE has a sibling attribute.
+ bool
+ has_sibling_attribute() const
+ {
+ gold_assert(this->abbrev_code_ != NULL);
+ return this->abbrev_code_->has_sibling_attribute;
+ }
+
+ // Return the value of attribute ATTR.
+ const Attribute_value*
+ attribute(unsigned int attr);
+
+ // Return the value of the DW_AT_name attribute.
+ const char*
+ name()
+ {
+ if (this->name_ == NULL)
+ this->set_name();
+ return this->name_;
+ }
+
+ // Return the value of the DW_AT_linkage_name
+ // or DW_AT_MIPS_linkage_name attribute.
+ const char*
+ linkage_name()
+ {
+ if (this->linkage_name_ == NULL)
+ this->set_linkage_name();
+ return this->linkage_name_;
+ }
+
+ // Return the value of the DW_AT_specification attribute.
+ off_t
+ specification()
+ {
+ if (!this->attributes_read_)
+ this->read_attributes();
+ return this->specification_;
+ }
+
+ // Return the value of the DW_AT_abstract_origin attribute.
+ off_t
+ abstract_origin()
+ {
+ if (!this->attributes_read_)
+ this->read_attributes();
+ return this->abstract_origin_;
+ }
+
+ // Return the value of attribute ATTR as a string.
+ const char*
+ string_attribute(unsigned int attr);
+
+ // Return the value of attribute ATTR as an integer.
+ int64_t
+ int_attribute(unsigned int attr);
+
+ // Return the value of attribute ATTR as an unsigned integer.
+ uint64_t
+ uint_attribute(unsigned int attr);
+
+ // Return the value of attribute ATTR as a reference.
+ off_t
+ ref_attribute(unsigned int attr,
+ unsigned int* shndx);
+
+ // Return the value of attribute ATTR as a flag.
+ bool
+ flag_attribute(unsigned int attr)
+ { return this->int_attribute(attr) != 0; }
+
+ // Return true if this DIE is a declaration.
+ bool
+ is_declaration()
+ { return this->flag_attribute(elfcpp::DW_AT_declaration); }
+
+ // Return the parent of this DIE.
+ Dwarf_die*
+ parent() const
+ { return this->parent_; }
+
+ // Return the offset of this DIE.
+ off_t
+ offset() const
+ { return this->die_offset_; }
+
+ // Return the offset of this DIE's first child.
+ off_t
+ child_offset();
+
+ // Set the offset of this DIE's next sibling.
+ void
+ set_sibling_offset(off_t sibling_offset)
+ { this->sibling_offset_ = sibling_offset; }
+
+ // Return the offset of this DIE's next sibling.
+ off_t
+ sibling_offset();
+
+ private:
+ typedef Dwarf_abbrev_table::Abbrev_code Abbrev_code;
+
+ // Read all the attributes of the DIE.
+ bool
+ read_attributes();
+
+ // Set the name of the DIE if present.
+ void
+ set_name();
+
+ // Set the linkage name if present.
+ void
+ set_linkage_name();
+
+ // Skip all the attributes of the DIE and return the offset
+ // of the next DIE.
+ off_t
+ skip_attributes();
+
+ // The Dwarf_info_reader, for reading attributes.
+ Dwarf_info_reader* dwinfo_;
+ // The parent of this DIE.
+ Dwarf_die* parent_;
+ // Offset of this DIE within its compilation unit.
+ off_t die_offset_;
+ // Offset of the first attribute, relative to the beginning of the DIE.
+ off_t attr_offset_;
+ // Offset of the first child, relative to the compilation unit.
+ off_t child_offset_;
+ // Offset of the next sibling, relative to the compilation unit.
+ off_t sibling_offset_;
+ // The abbreviation table entry.
+ const Abbrev_code* abbrev_code_;
+ // The list of attributes.
+ Attributes attributes_;
+ // True if the attributes have been read.
+ bool attributes_read_;
+ // The following fields hold common attributes to avoid a linear
+ // search through the attribute list.
+ // The DIE name (DW_AT_name).
+ const char* name_;
+ // Offset of the name in the string table (for DW_FORM_strp).
+ off_t name_off_;
+ // The linkage name (DW_AT_linkage_name or DW_AT_MIPS_linkage_name).
+ const char* linkage_name_;
+ // Offset of the linkage name in the string table (for DW_FORM_strp).
+ off_t linkage_name_off_;
+ // Section index of the string table (for DW_FORM_strp).
+ unsigned int string_shndx_;
+ // The value of a DW_AT_specification attribute.
+ off_t specification_;
+ // The value of a DW_AT_abstract_origin attribute.
+ off_t abstract_origin_;
+};
+
+// This class is used to read the debug info from the .debug_info
+// or .debug_types sections. This is a base class that implements
+// the generic parsing of the compilation unit header and DIE
+// structure. The parse() method parses the entire section, and
+// calls the various visit_xxx() methods for each header. Clients
+// should derive a new class from this one and implement the
+// visit_compilation_unit() and visit_type_unit() functions.
+
+class Dwarf_info_reader
+{
+ public:
+ Dwarf_info_reader(bool is_type_unit,
+ Relobj* object,
+ const unsigned char* symtab,
+ off_t symtab_size,
+ unsigned int shndx,
+ unsigned int reloc_shndx,
+ unsigned int reloc_type)
+ : is_type_unit_(is_type_unit), object_(object), symtab_(symtab),
+ symtab_size_(symtab_size), shndx_(shndx), reloc_shndx_(reloc_shndx),
+ reloc_type_(reloc_type), string_shndx_(0), buffer_(NULL),
+ buffer_end_(NULL), cu_offset_(0), cu_length_(0), offset_size_(0),
+ address_size_(0), cu_version_(0), type_signature_(0), type_offset_(0),
+ abbrev_table_(), reloc_mapper_(NULL), string_buffer_(NULL),
+ string_buffer_end_(NULL), owns_string_buffer_(false),
+ string_output_section_offset_(0)
+ { }
+
+ virtual
+ ~Dwarf_info_reader()
+ {
+ if (this->reloc_mapper_ != NULL)
+ delete this->reloc_mapper_;
+ if (this->owns_string_buffer_ && this->string_buffer_ != NULL)
+ delete[] this->string_buffer_;
+ }
+
+ // Begin parsing the debug info. This calls visit_compilation_unit()
+ // or visit_type_unit() for each compilation or type unit found in the
+ // section, and visit_die() for each top-level DIE.
+ void
+ parse();
+
+ // Return the abbrev code entry for a CODE.
+ const Dwarf_abbrev_table::Abbrev_code*
+ get_abbrev(unsigned int code)
+ { return this->abbrev_table_.get_abbrev(code); }
+
+ // Return a pointer to the DWARF info buffer at OFFSET.
+ const unsigned char*
+ buffer_at_offset(off_t offset) const
+ {
+ const unsigned char* p = this->buffer_ + this->cu_offset_ + offset;
+ if (this->check_buffer(p + 1))
+ return p;
+ return NULL;
+ }
+
+ // Look for a relocation at offset ATTR_OFF in the dwarf info,
+ // and return the section index and offset of the target.
+ unsigned int
+ lookup_reloc(off_t attr_off, off_t* target_off);
+
+ // Return a string from the DWARF string table.
+ const char*
+ get_string(off_t str_off, unsigned int string_shndx);
+
+ // Return the size of a DWARF offset.
+ unsigned int
+ offset_size() const
+ { return this->offset_size_; }
+
+ // Return the size of an address.
+ unsigned int
+ address_size() const
+ { return this->address_size_; }
+
+ protected:
+ // Begin parsing the debug info. This calls visit_compilation_unit()
+ // or visit_type_unit() for each compilation or type unit found in the
+ // section, and visit_die() for each top-level DIE.
+ template<bool big_endian>
+ void
+ do_parse();
+
+ // The following methods are hooks that are meant to be implemented
+ // by a derived class. A default, do-nothing, implementation of
+ // each is provided for this base class.
+
+ // Visit a compilation unit.
+ virtual void
+ visit_compilation_unit(off_t cu_offset, off_t cu_length, Dwarf_die* root_die);
+
+ // Visit a type unit.
+ virtual void
+ visit_type_unit(off_t tu_offset, off_t type_offset, uint64_t signature,
+ Dwarf_die* root_die);
+
+ // Read the range table.
+ Dwarf_range_list*
+ read_range_list(unsigned int ranges_shndx, off_t ranges_offset)
+ {
+ return this->ranges_table_.read_range_list(this->object_,
+ this->symtab_,
+ this->symtab_size_,
+ this->address_size_,
+ ranges_shndx,
+ ranges_offset);
+ }
+
+ // Return the object.
+ Relobj*
+ object() const
+ { return this->object_; }
+
+ // Return a pointer to the object file's ELF symbol table.
+ const unsigned char*
+ symtab() const
+ { return this->symtab_; }
+
+ // Return the size of the object file's ELF symbol table.
+ off_t
+ symtab_size() const
+ { return this->symtab_size_; }
+
+ // Checkpoint the relocation tracker.
+ uint64_t
+ get_reloc_checkpoint() const
+ { return this->reloc_mapper_->checkpoint(); }
+
+ // Reset the relocation tracker to the CHECKPOINT.
+ void
+ reset_relocs(uint64_t checkpoint)
+ { this->reloc_mapper_->reset(checkpoint); }
+
+ private:
+ // Check that P is within the bounds of the current section.
+ bool
+ check_buffer(const unsigned char* p) const;
+
+ // Read the DWARF string table.
+ bool
+ read_string_table(unsigned int string_shndx)
+ {
+ // If we've already read this string table, return immediately.
+ if (this->string_shndx_ > 0 && this->string_shndx_ == string_shndx)
+ return true;
+ if (string_shndx == 0 && this->string_shndx_ > 0)
+ return true;
+ return this->do_read_string_table(string_shndx);
+ }
+
+ bool
+ do_read_string_table(unsigned int string_shndx);
+
+ // True if this is a type unit; false for a compilation unit.
+ bool is_type_unit_;
+ // The object containing the .debug_info or .debug_types input section.
+ Relobj* object_;
+ // The ELF symbol table.
+ const unsigned char* symtab_;
+ // The size of the ELF symbol table.
+ off_t symtab_size_;
+ // Index of the .debug_info or .debug_types section.
+ unsigned int shndx_;
+ // Index of the relocation section.
+ unsigned int reloc_shndx_;
+ // Type of the relocation section (SHT_REL or SHT_RELA).
+ unsigned int reloc_type_;
+ // Index of the .debug_str section.
+ unsigned int string_shndx_;
+ // The buffer for the debug info.
+ const unsigned char* buffer_;
+ const unsigned char* buffer_end_;
+ // Offset of the current compilation unit.
+ off_t cu_offset_;
+ // Length of the current compilation unit.
+ off_t cu_length_;
+ // Size of a DWARF offset for the current compilation unit.
+ unsigned int offset_size_;
+ // Size of an address for the target architecture.
+ unsigned int address_size_;
+ // Compilation unit version number.
+ unsigned int cu_version_;
+ // Type signature (for a type unit).
+ uint64_t type_signature_;
+ // Offset from the type unit header to the type DIE (for a type unit).
+ off_t type_offset_;
+ // Abbreviations table for current compilation unit.
+ Dwarf_abbrev_table abbrev_table_;
+ // Ranges table for the current compilation unit.
+ Dwarf_ranges_table ranges_table_;
+ // Relocation mapper for the section.
+ Elf_reloc_mapper* reloc_mapper_;
+ // The buffer for the debug string table.
+ const char* string_buffer_;
+ const char* string_buffer_end_;
+ // True if this object owns the buffer and needs to delete it.
+ bool owns_string_buffer_;
+ // For incremental update links, this will hold the offset of the
+ // input .debug_str section within the output section. Offsets read
+ // from relocated data will be relative to the output section, and need
+ // to be corrected before reading data from the input section.
+ uint64_t string_output_section_offset_;
+};
+
// We can't do better than to keep the offsets in a sorted vector.
// Here, offset is the key, and file_num/line_num is the value.
struct Offset_to_lineno_entry
// If SHNDX is non-negative, only store debug information that
// pertains to the specified section.
void
- read_line_mappings(Object*, unsigned int shndx);
+ read_line_mappings(unsigned int shndx);
// Reads the relocation section associated with .debug_line and
// stores relocation information in reloc_map_.
void
- read_relocs(Object*);
-
- // Looks in the symtab to see what section a symbol is in.
- unsigned int
- symbol_section(Object*, unsigned int sym,
- typename elfcpp::Elf_types<size>::Elf_Addr* value,
- bool* is_ordinary);
+ read_relocs();
// Reads the DWARF2/3 header for this line info. Each takes as input
// a starting buffer position, and returns the ending position.
const unsigned char* buffer_start_;
// This has relocations that point into buffer.
- Track_relocs<size, big_endian> track_relocs_;
+ Sized_elf_reloc_mapper<size, big_endian>* reloc_mapper_;
// The type of the reloc section in track_relocs_--SHT_REL or SHT_RELA.
unsigned int track_relocs_type_;
// A sorted map from offset of the relocation target to the shndx
// and addend for the relocation.
- typedef std::map<typename elfcpp::Elf_types<size>::Elf_Addr,
- std::pair<unsigned int,
- typename elfcpp::Elf_types<size>::Elf_Swxword> >
+ typedef std::map<off_t, std::pair<unsigned int, off_t> >
Reloc_map;
Reloc_map reloc_map_;
// Return a view of the contents of a section. Set *PLEN to the
// size.
- Object::Location
- do_section_contents(unsigned int shndx)
- { return this->elf_file_.section_contents(shndx); }
+ const unsigned char*
+ do_section_contents(unsigned int shndx, section_size_type* plen,
+ bool cache)
+ {
+ Location loc(this->elf_file_.section_contents(shndx));
+ *plen = convert_to_section_size_type(loc.data_size);
+ if (*plen == 0)
+ {
+ static const unsigned char empty[1] = { '\0' };
+ return empty;
+ }
+ return this->get_view(loc.file_offset, *plen, true, cache);
+ }
// Return section flags.
uint64_t
--- /dev/null
+// gdb-index.cc -- generate .gdb_index section for fast debug lookup
+
+// Copyright 2012 Free Software Foundation, Inc.
+// Written by Cary Coutant <ccoutant@google.com>.
+
+// This file is part of gold.
+
+// This program is free software; you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation; either version 3 of the License, or
+// (at your option) any later version.
+
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+// GNU General Public License for more details.
+
+// You should have received a copy of the GNU General Public License
+// along with this program; if not, write to the Free Software
+// Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,
+// MA 02110-1301, USA.
+
+#include "gold.h"
+
+#include "gdb-index.h"
+#include "dwarf_reader.h"
+#include "dwarf.h"
+#include "object.h"
+#include "output.h"
+#include "demangle.h"
+
+namespace gold
+{
+
+const int gdb_index_version = 5;
+
+// Sizes of various records in the .gdb_index section.
+const int gdb_index_offset_size = 4;
+const int gdb_index_hdr_size = 6 * gdb_index_offset_size;
+const int gdb_index_cu_size = 16;
+const int gdb_index_tu_size = 24;
+const int gdb_index_addr_size = 16 + gdb_index_offset_size;
+const int gdb_index_sym_size = 2 * gdb_index_offset_size;
+
+// This class manages the hashed symbol table for the .gdb_index section.
+// It is essentially equivalent to the hashtab implementation in libiberty,
+// but is copied into gdb sources and here for compatibility because its
+// data structure is exposed on disk.
+
+template <typename T>
+class Gdb_hashtab
+{
+ public:
+ Gdb_hashtab()
+ : size_(0), capacity_(0), hashtab_(NULL)
+ { }
+
+ ~Gdb_hashtab()
+ {
+ for (size_t i = 0; i < this->capacity_; ++i)
+ if (this->hashtab_[i] != NULL)
+ delete this->hashtab_[i];
+ delete[] this->hashtab_;
+ }
+
+ // Add a symbol.
+ T*
+ add(T* symbol)
+ {
+ // Resize the hash table if necessary.
+ if (4 * this->size_ / 3 >= this->capacity_)
+ this->expand();
+
+ T** slot = this->find_slot(symbol);
+ if (*slot == NULL)
+ {
+ ++this->size_;
+ *slot = symbol;
+ }
+
+ return *slot;
+ }
+
+ // Return the current size.
+ size_t
+ size() const
+ { return this->size_; }
+
+ // Return the current capacity.
+ size_t
+ capacity() const
+ { return this->capacity_; }
+
+ // Return the contents of slot N.
+ T*
+ operator[](size_t n)
+ { return this->hashtab_[n]; }
+
+ private:
+ // Find a symbol in the hash table, or return an empty slot if
+ // the symbol is not in the table.
+ T**
+ find_slot(T* symbol)
+ {
+ unsigned int index = symbol->hash() & (this->capacity_ - 1);
+ unsigned int step = ((symbol->hash() * 17) & (this->capacity_ - 1)) | 1;
+
+ for (;;)
+ {
+ if (this->hashtab_[index] == NULL
+ || this->hashtab_[index]->equal(symbol))
+ return &this->hashtab_[index];
+ index = (index + step) & (this->capacity_ - 1);
+ }
+ }
+
+ // Expand the hash table.
+ void
+ expand()
+ {
+ if (this->capacity_ == 0)
+ {
+ // Allocate the hash table for the first time.
+ this->capacity_ = Gdb_hashtab::initial_size;
+ this->hashtab_ = new T*[this->capacity_];
+ memset(this->hashtab_, 0, this->capacity_ * sizeof(T*));
+ }
+ else
+ {
+ // Expand and rehash.
+ unsigned int old_cap = this->capacity_;
+ T** old_hashtab = this->hashtab_;
+ this->capacity_ *= 2;
+ this->hashtab_ = new T*[this->capacity_];
+ memset(this->hashtab_, 0, this->capacity_ * sizeof(T*));
+ for (size_t i = 0; i < old_cap; ++i)
+ {
+ if (old_hashtab[i] != NULL)
+ {
+ T** slot = this->find_slot(old_hashtab[i]);
+ *slot = old_hashtab[i];
+ }
+ }
+ delete[] old_hashtab;
+ }
+ }
+
+ // Initial size of the hash table; must be a power of 2.
+ static const int initial_size = 1024;
+ size_t size_;
+ size_t capacity_;
+ T** hashtab_;
+};
+
+// The hash function for strings in the mapped index. This is copied
+// directly from gdb/dwarf2read.c.
+
+static unsigned int
+mapped_index_string_hash(const unsigned char* str)
+{
+ unsigned int r = 0;
+ unsigned char c;
+
+ while ((c = *str++) != 0)
+ {
+ if (gdb_index_version >= 5)
+ c = tolower (c);
+ r = r * 67 + c - 113;
+ }
+
+ return r;
+}
+
+// A specialization of Dwarf_info_reader, for building the .gdb_index.
+
+class Gdb_index_info_reader : public Dwarf_info_reader
+{
+ public:
+ Gdb_index_info_reader(bool is_type_unit,
+ Relobj* object,
+ const unsigned char* symbols,
+ off_t symbols_size,
+ unsigned int shndx,
+ unsigned int reloc_shndx,
+ unsigned int reloc_type,
+ Gdb_index* gdb_index)
+ : Dwarf_info_reader(is_type_unit, object, symbols, symbols_size, shndx,
+ reloc_shndx, reloc_type),
+ gdb_index_(gdb_index), cu_index_(0), cu_language_(0)
+ { }
+
+ ~Gdb_index_info_reader()
+ { this->clear_declarations(); }
+
+ // Print usage statistics.
+ static void
+ print_stats();
+
+ protected:
+ // Visit a compilation unit.
+ virtual void
+ visit_compilation_unit(off_t cu_offset, off_t cu_length, Dwarf_die*);
+
+ // Visit a type unit.
+ virtual void
+ visit_type_unit(off_t tu_offset, off_t type_offset, uint64_t signature,
+ Dwarf_die*);
+
+ private:
+ // A map for recording DIEs we've seen that may be referred to be
+ // later DIEs (via DW_AT_specification or DW_AT_abstract_origin).
+ // The map is indexed by a DIE offset within the compile unit.
+ // PARENT_OFFSET_ is the offset of the DIE that represents the
+ // outer context, and NAME_ is a pointer to a component of the
+ // fully-qualified name.
+ // Normally, the names we point to are in a string table, so we don't
+ // have to manage them, but when we have a fully-qualified name
+ // computed, we put it in the table, and set PARENT_OFFSET_ to -1
+ // indicate a string that we are managing.
+ struct Declaration_pair
+ {
+ Declaration_pair(off_t parent_offset, const char* name)
+ : parent_offset_(parent_offset), name_(name)
+ { }
+
+ off_t parent_offset_;
+ const char* name_;
+ };
+ typedef Unordered_map<off_t, Declaration_pair> Declaration_map;
+
+ // Visit a top-level DIE.
+ void
+ visit_top_die(Dwarf_die* die);
+
+ // Visit the children of a DIE.
+ void
+ visit_children(Dwarf_die* die, Dwarf_die* context);
+
+ // Visit a DIE.
+ void
+ visit_die(Dwarf_die* die, Dwarf_die* context);
+
+ // Visit the children of a DIE.
+ void
+ visit_children_for_decls(Dwarf_die* die);
+
+ // Visit a DIE.
+ void
+ visit_die_for_decls(Dwarf_die* die, Dwarf_die* context);
+
+ // Guess a fully-qualified name for a class type, based on member function
+ // linkage names.
+ std::string
+ guess_full_class_name(Dwarf_die* die);
+
+ // Add a declaration DIE to the table of declarations.
+ void
+ add_declaration(Dwarf_die* die, Dwarf_die* context);
+
+ // Add a declaration whose fully-qualified name is already known.
+ void
+ add_declaration_with_full_name(Dwarf_die* die, const char* full_name);
+
+ // Return the context for a DIE whose parent is at DIE_OFFSET.
+ std::string
+ get_context(off_t die_offset);
+
+ // Construct a fully-qualified name for DIE.
+ std::string
+ get_qualified_name(Dwarf_die* die, Dwarf_die* context);
+
+ // Record the address ranges for a compilation unit.
+ void
+ record_cu_ranges(Dwarf_die* die);
+
+ // Read the .debug_pubnames and .debug_pubtypes tables.
+ bool
+ read_pubnames_and_pubtypes(Dwarf_die* die);
+
+ // Clear the declarations map.
+ void
+ clear_declarations();
+
+ // The Gdb_index section.
+ Gdb_index* gdb_index_;
+ // The current CU index (negative for a TU).
+ int cu_index_;
+ // The language of the current CU or TU.
+ unsigned int cu_language_;
+ // Map from DIE offset to (parent offset, name) pair,
+ // for DW_AT_specification.
+ Declaration_map declarations_;
+
+ // Statistics.
+ // Total number of DWARF compilation units processed.
+ static unsigned int dwarf_cu_count;
+ // Number of DWARF compilation units with pubnames/pubtypes.
+ static unsigned int dwarf_cu_nopubnames_count;
+ // Total number of DWARF type units processed.
+ static unsigned int dwarf_tu_count;
+ // Number of DWARF type units with pubnames/pubtypes.
+ static unsigned int dwarf_tu_nopubnames_count;
+};
+
+// Total number of DWARF compilation units processed.
+unsigned int Gdb_index_info_reader::dwarf_cu_count = 0;
+// Number of DWARF compilation units without pubnames/pubtypes.
+unsigned int Gdb_index_info_reader::dwarf_cu_nopubnames_count = 0;
+// Total number of DWARF type units processed.
+unsigned int Gdb_index_info_reader::dwarf_tu_count = 0;
+// Number of DWARF type units without pubnames/pubtypes.
+unsigned int Gdb_index_info_reader::dwarf_tu_nopubnames_count = 0;
+
+// Process a compilation unit and parse its child DIE.
+
+void
+Gdb_index_info_reader::visit_compilation_unit(off_t cu_offset, off_t cu_length,
+ Dwarf_die* root_die)
+{
+ ++Gdb_index_info_reader::dwarf_cu_count;
+ this->cu_index_ = this->gdb_index_->add_comp_unit(cu_offset, cu_length);
+ this->visit_top_die(root_die);
+}
+
+// Process a type unit and parse its child DIE.
+
+void
+Gdb_index_info_reader::visit_type_unit(off_t tu_offset, off_t type_offset,
+ uint64_t signature, Dwarf_die* root_die)
+{
+ ++Gdb_index_info_reader::dwarf_tu_count;
+ // Use a negative index to flag this as a TU instead of a CU.
+ this->cu_index_ = -1 - this->gdb_index_->add_type_unit(tu_offset, type_offset,
+ signature);
+ this->visit_top_die(root_die);
+}
+
+// Process a top-level DIE.
+// For compile_unit DIEs, record the address ranges. For all
+// interesting tags, add qualified names to the symbol table
+// and process interesting children. We may need to process
+// certain children just for saving declarations that might be
+// referenced by later DIEs with a DW_AT_specification attribute.
+
+void
+Gdb_index_info_reader::visit_top_die(Dwarf_die* die)
+{
+ this->clear_declarations();
+
+ switch (die->tag())
+ {
+ case elfcpp::DW_TAG_compile_unit:
+ case elfcpp::DW_TAG_type_unit:
+ this->cu_language_ = die->int_attribute(elfcpp::DW_AT_language);
+ // Check for languages that require specialized knowledge to
+ // construct fully-qualified names, that we don't yet support.
+ if (this->cu_language_ == elfcpp::DW_LANG_Ada83
+ || this->cu_language_ == elfcpp::DW_LANG_Fortran77
+ || this->cu_language_ == elfcpp::DW_LANG_Fortran90
+ || this->cu_language_ == elfcpp::DW_LANG_Java
+ || this->cu_language_ == elfcpp::DW_LANG_Ada95
+ || this->cu_language_ == elfcpp::DW_LANG_Fortran95)
+ {
+ gold_warning(_("%s: --gdb-index currently supports "
+ "only C and C++ languages"),
+ this->object()->name().c_str());
+ return;
+ }
+ if (die->tag() == elfcpp::DW_TAG_compile_unit)
+ this->record_cu_ranges(die);
+ // If there is a pubnames and/or pubtypes section for this
+ // compilation unit, use those; otherwise, parse the DWARF
+ // info to extract the names.
+ if (!this->read_pubnames_and_pubtypes(die))
+ {
+ if (die->tag() == elfcpp::DW_TAG_compile_unit)
+ ++Gdb_index_info_reader::dwarf_cu_nopubnames_count;
+ else
+ ++Gdb_index_info_reader::dwarf_tu_nopubnames_count;
+ this->visit_children(die, NULL);
+ }
+ break;
+ default:
+ // The top level DIE should be one of the above.
+ gold_warning(_("%s: top level DIE is not DW_TAG_compile_unit "
+ "or DW_TAG_type_unit"),
+ this->object()->name().c_str());
+ return;
+ }
+
+}
+
+// Visit the children of PARENT, looking for symbols to add to the index.
+// CONTEXT points to the DIE to use for constructing the qualified name --
+// NULL if PARENT is the top-level DIE; otherwise it is the same as PARENT.
+
+void
+Gdb_index_info_reader::visit_children(Dwarf_die* parent, Dwarf_die* context)
+{
+ off_t next_offset = 0;
+ for (off_t die_offset = parent->child_offset();
+ die_offset != 0;
+ die_offset = next_offset)
+ {
+ Dwarf_die die(this, die_offset, parent);
+ if (die.tag() == 0)
+ break;
+ this->visit_die(&die, context);
+ next_offset = die.sibling_offset();
+ }
+}
+
+// Visit a child DIE, looking for symbols to add to the index.
+// CONTEXT is the parent DIE, used for constructing the qualified name;
+// it is NULL if the parent DIE is the top-level DIE.
+
+void
+Gdb_index_info_reader::visit_die(Dwarf_die* die, Dwarf_die* context)
+{
+ switch (die->tag())
+ {
+ case elfcpp::DW_TAG_subprogram:
+ case elfcpp::DW_TAG_constant:
+ case elfcpp::DW_TAG_variable:
+ case elfcpp::DW_TAG_enumerator:
+ case elfcpp::DW_TAG_base_type:
+ if (die->is_declaration())
+ this->add_declaration(die, context);
+ else
+ {
+ // If the DIE is not a declaration, add it to the index.
+ std::string full_name = this->get_qualified_name(die, context);
+ if (!full_name.empty())
+ this->gdb_index_->add_symbol(this->cu_index_, full_name.c_str());
+ }
+ break;
+ case elfcpp::DW_TAG_typedef:
+ case elfcpp::DW_TAG_union_type:
+ case elfcpp::DW_TAG_class_type:
+ case elfcpp::DW_TAG_interface_type:
+ case elfcpp::DW_TAG_structure_type:
+ case elfcpp::DW_TAG_enumeration_type:
+ case elfcpp::DW_TAG_subrange_type:
+ case elfcpp::DW_TAG_namespace:
+ {
+ std::string full_name;
+
+ // For classes at the top level, we need to look for a
+ // member function with a linkage name in order to get
+ // the properly-canonicalized name.
+ if (context == NULL
+ && (die->tag() == elfcpp::DW_TAG_class_type
+ || die->tag() == elfcpp::DW_TAG_structure_type
+ || die->tag() == elfcpp::DW_TAG_union_type))
+ full_name.assign(this->guess_full_class_name(die));
+
+ // Because we will visit the children, we need to add this DIE
+ // to the declarations table.
+ if (full_name.empty())
+ this->add_declaration(die, context);
+ else
+ this->add_declaration_with_full_name(die, full_name.c_str());
+
+ // If the DIE is not a declaration, add it to the index.
+ // Gdb stores a namespace in the index even when it is
+ // a declaration.
+ if (die->tag() == elfcpp::DW_TAG_namespace
+ || !die->is_declaration())
+ {
+ if (full_name.empty())
+ full_name = this->get_qualified_name(die, context);
+ if (!full_name.empty())
+ this->gdb_index_->add_symbol(this->cu_index_,
+ full_name.c_str());
+ }
+
+ // We're interested in the children only for namespaces and
+ // enumeration types. For enumeration types, we do not include
+ // the enumeration tag as part of the full name. For other tags,
+ // visit the children only to collect declarations.
+ if (die->tag() == elfcpp::DW_TAG_namespace
+ || die->tag() == elfcpp::DW_TAG_enumeration_type)
+ this->visit_children(die, die);
+ else
+ this->visit_children_for_decls(die);
+ }
+ break;
+ default:
+ break;
+ }
+}
+
+// Visit the children of PARENT, looking only for declarations that
+// may be referenced by later specification DIEs.
+
+void
+Gdb_index_info_reader::visit_children_for_decls(Dwarf_die* parent)
+{
+ off_t next_offset = 0;
+ for (off_t die_offset = parent->child_offset();
+ die_offset != 0;
+ die_offset = next_offset)
+ {
+ Dwarf_die die(this, die_offset, parent);
+ if (die.tag() == 0)
+ break;
+ this->visit_die_for_decls(&die, parent);
+ next_offset = die.sibling_offset();
+ }
+}
+
+// Visit a child DIE, looking only for declarations that
+// may be referenced by later specification DIEs.
+
+void
+Gdb_index_info_reader::visit_die_for_decls(Dwarf_die* die, Dwarf_die* context)
+{
+ switch (die->tag())
+ {
+ case elfcpp::DW_TAG_subprogram:
+ case elfcpp::DW_TAG_constant:
+ case elfcpp::DW_TAG_variable:
+ case elfcpp::DW_TAG_enumerator:
+ case elfcpp::DW_TAG_base_type:
+ {
+ if (die->is_declaration())
+ this->add_declaration(die, context);
+ }
+ break;
+ case elfcpp::DW_TAG_typedef:
+ case elfcpp::DW_TAG_union_type:
+ case elfcpp::DW_TAG_class_type:
+ case elfcpp::DW_TAG_interface_type:
+ case elfcpp::DW_TAG_structure_type:
+ case elfcpp::DW_TAG_enumeration_type:
+ case elfcpp::DW_TAG_subrange_type:
+ case elfcpp::DW_TAG_namespace:
+ {
+ if (die->is_declaration())
+ this->add_declaration(die, context);
+ this->visit_children_for_decls(die);
+ }
+ break;
+ default:
+ break;
+ }
+}
+
+// Extract the class name from the linkage name of a member function.
+// This code is adapted from ../gdb/cp-support.c.
+
+#define d_left(dc) (dc)->u.s_binary.left
+#define d_right(dc) (dc)->u.s_binary.right
+
+static char*
+class_name_from_linkage_name(const char* linkage_name)
+{
+ void* storage;
+ struct demangle_component* tree =
+ cplus_demangle_v3_components(linkage_name, DMGL_NO_OPTS, &storage);
+ if (tree == NULL)
+ return NULL;
+
+ int done = 0;
+
+ // First strip off any qualifiers, if we have a function or
+ // method.
+ while (!done)
+ switch (tree->type)
+ {
+ case DEMANGLE_COMPONENT_CONST:
+ case DEMANGLE_COMPONENT_RESTRICT:
+ case DEMANGLE_COMPONENT_VOLATILE:
+ case DEMANGLE_COMPONENT_CONST_THIS:
+ case DEMANGLE_COMPONENT_RESTRICT_THIS:
+ case DEMANGLE_COMPONENT_VOLATILE_THIS:
+ case DEMANGLE_COMPONENT_VENDOR_TYPE_QUAL:
+ tree = d_left(tree);
+ break;
+ default:
+ done = 1;
+ break;
+ }
+
+ // If what we have now is a function, discard the argument list.
+ if (tree->type == DEMANGLE_COMPONENT_TYPED_NAME)
+ tree = d_left(tree);
+
+ // If what we have now is a template, strip off the template
+ // arguments. The left subtree may be a qualified name.
+ if (tree->type == DEMANGLE_COMPONENT_TEMPLATE)
+ tree = d_left(tree);
+
+ // What we have now should be a name, possibly qualified.
+ // Additional qualifiers could live in the left subtree or the right
+ // subtree. Find the last piece.
+ done = 0;
+ struct demangle_component* prev_comp = NULL;
+ struct demangle_component* cur_comp = tree;
+ while (!done)
+ switch (cur_comp->type)
+ {
+ case DEMANGLE_COMPONENT_QUAL_NAME:
+ case DEMANGLE_COMPONENT_LOCAL_NAME:
+ prev_comp = cur_comp;
+ cur_comp = d_right(cur_comp);
+ break;
+ case DEMANGLE_COMPONENT_TEMPLATE:
+ case DEMANGLE_COMPONENT_NAME:
+ case DEMANGLE_COMPONENT_CTOR:
+ case DEMANGLE_COMPONENT_DTOR:
+ case DEMANGLE_COMPONENT_OPERATOR:
+ case DEMANGLE_COMPONENT_EXTENDED_OPERATOR:
+ done = 1;
+ break;
+ default:
+ done = 1;
+ cur_comp = NULL;
+ break;
+ }
+
+ char* ret = NULL;
+ if (cur_comp != NULL && prev_comp != NULL)
+ {
+ // We want to discard the rightmost child of PREV_COMP.
+ *prev_comp = *d_left(prev_comp);
+ size_t allocated_size;
+ ret = cplus_demangle_print(DMGL_NO_OPTS, tree, 30, &allocated_size);
+ }
+
+ free(storage);
+ return ret;
+}
+
+// Guess a fully-qualified name for a class type, based on member function
+// linkage names. This is needed for class/struct/union types at the
+// top level, because GCC does not always properly embed them within
+// the namespace. As in gdb, we look for a member function with a linkage
+// name and extract the qualified name from the demangled name.
+
+std::string
+Gdb_index_info_reader::guess_full_class_name(Dwarf_die* die)
+{
+ std::string full_name;
+ off_t next_offset = 0;
+
+ // This routine scans ahead in the DIE structure, possibly advancing
+ // the relocation tracker beyond the current DIE. We need to checkpoint
+ // the tracker and reset it when we're done.
+ uint64_t checkpoint = this->get_reloc_checkpoint();
+
+ for (off_t child_offset = die->child_offset();
+ child_offset != 0;
+ child_offset = next_offset)
+ {
+ Dwarf_die child(this, child_offset, die);
+ if (child.tag() == 0)
+ break;
+ if (child.tag() == elfcpp::DW_TAG_subprogram)
+ {
+ const char* linkage_name = child.linkage_name();
+ if (linkage_name != NULL)
+ {
+ char* guess = class_name_from_linkage_name(linkage_name);
+ if (guess != NULL)
+ {
+ full_name.assign(guess);
+ free(guess);
+ break;
+ }
+ }
+ }
+ next_offset = child.sibling_offset();
+ }
+
+ this->reset_relocs(checkpoint);
+ return full_name;
+}
+
+// Add a declaration DIE to the table of declarations.
+
+void
+Gdb_index_info_reader::add_declaration(Dwarf_die* die, Dwarf_die* context)
+{
+ const char* name = die->name();
+
+ off_t parent_offset = context != NULL ? context->offset() : 0;
+
+ // If this DIE has a DW_AT_specification or DW_AT_abstract_origin
+ // attribute, use the parent and name from the earlier declaration.
+ off_t spec = die->specification();
+ if (spec == 0)
+ spec = die->abstract_origin();
+ if (spec > 0)
+ {
+ Declaration_map::iterator it = this->declarations_.find(spec);
+ if (it != this->declarations_.end())
+ {
+ parent_offset = it->second.parent_offset_;
+ name = it->second.name_;
+ }
+ }
+
+ if (name == NULL)
+ {
+ if (die->tag() == elfcpp::DW_TAG_namespace)
+ name = "(anonymous namespace)";
+ else if (die->tag() == elfcpp::DW_TAG_union_type)
+ name = "(anonymous union)";
+ else
+ name = "(unknown)";
+ }
+
+ Declaration_pair decl(parent_offset, name);
+ this->declarations_.insert(std::make_pair(die->offset(), decl));
+}
+
+// Add a declaration whose fully-qualified name is already known.
+// In the case where we had to get the canonical name by demangling
+// a linkage name, this ensures we use that name instead of the one
+// provided in DW_AT_name.
+
+void
+Gdb_index_info_reader::add_declaration_with_full_name(
+ Dwarf_die* die,
+ const char* full_name)
+{
+ // We need to copy the name.
+ int len = strlen(full_name);
+ char* copy = new char[len + 1];
+ memcpy(copy, full_name, len + 1);
+
+ // Flag that we now manage the memory this points to.
+ Declaration_pair decl(-1, copy);
+ this->declarations_.insert(std::make_pair(die->offset(), decl));
+}
+
+// Return the context for a DIE whose parent is at DIE_OFFSET.
+
+std::string
+Gdb_index_info_reader::get_context(off_t die_offset)
+{
+ std::string context;
+ Declaration_map::iterator it = this->declarations_.find(die_offset);
+ if (it != this->declarations_.end())
+ {
+ off_t parent_offset = it->second.parent_offset_;
+ if (parent_offset > 0)
+ {
+ context = get_context(parent_offset);
+ context.append("::");
+ }
+ if (it->second.name_ != NULL)
+ context.append(it->second.name_);
+ }
+ return context;
+}
+
+// Construct the fully-qualified name for DIE.
+
+std::string
+Gdb_index_info_reader::get_qualified_name(Dwarf_die* die, Dwarf_die* context)
+{
+ std::string full_name;
+ const char* name = die->name();
+
+ off_t parent_offset = context != NULL ? context->offset() : 0;
+
+ // If this DIE has a DW_AT_specification or DW_AT_abstract_origin
+ // attribute, use the parent and name from the earlier declaration.
+ off_t spec = die->specification();
+ if (spec == 0)
+ spec = die->abstract_origin();
+ if (spec > 0)
+ {
+ Declaration_map::iterator it = this->declarations_.find(spec);
+ if (it != this->declarations_.end())
+ {
+ parent_offset = it->second.parent_offset_;
+ name = it->second.name_;
+ }
+ }
+
+ if (name == NULL && die->tag() == elfcpp::DW_TAG_namespace)
+ name = "(anonymous namespace)";
+ else if (name == NULL)
+ return full_name;
+
+ // If this is an enumerator constant, skip the immediate parent,
+ // which is the enumeration tag.
+ if (die->tag() == elfcpp::DW_TAG_enumerator)
+ {
+ Declaration_map::iterator it = this->declarations_.find(parent_offset);
+ if (it != this->declarations_.end())
+ parent_offset = it->second.parent_offset_;
+ }
+
+ if (parent_offset > 0)
+ {
+ full_name.assign(this->get_context(parent_offset));
+ full_name.append("::");
+ }
+ full_name.append(name);
+
+ return full_name;
+}
+
+// Record the address ranges for a compilation unit.
+
+void
+Gdb_index_info_reader::record_cu_ranges(Dwarf_die* die)
+{
+ unsigned int shndx;
+ unsigned int shndx2;
+
+ off_t ranges_offset = die->ref_attribute(elfcpp::DW_AT_ranges, &shndx);
+ if (ranges_offset != -1)
+ {
+ Dwarf_range_list* ranges = this->read_range_list(shndx, ranges_offset);
+ if (ranges != NULL)
+ this->gdb_index_->add_address_range_list(this->object(),
+ this->cu_index_, ranges);
+ return;
+ }
+
+ off_t low_pc = die->ref_attribute(elfcpp::DW_AT_low_pc, &shndx);
+ off_t high_pc = die->ref_attribute(elfcpp::DW_AT_high_pc, &shndx2);
+ if (low_pc != 0 && high_pc != 0 && low_pc != -1 && high_pc != -1)
+ {
+ if (shndx != shndx2)
+ {
+ gold_warning(_("%s: DWARF info may be corrupt; low_pc and high_pc "
+ "are in different sections"),
+ this->object()->name().c_str());
+ return;
+ }
+ if (shndx == 0 || this->object()->is_section_included(shndx))
+ {
+ Dwarf_range_list* ranges = new Dwarf_range_list();
+ ranges->add(shndx, low_pc, high_pc);
+ this->gdb_index_->add_address_range_list(this->object(),
+ this->cu_index_, ranges);
+ }
+ }
+}
+
+// Read the .debug_pubnames and .debug_pubtypes tables for the CU or TU.
+// Returns TRUE if either a pubnames or pubtypes section was found.
+
+bool
+Gdb_index_info_reader::read_pubnames_and_pubtypes(Dwarf_die* die)
+{
+ bool ret = false;
+
+ // If we find a DW_AT_GNU_pubnames attribute, read the pubnames table.
+ unsigned int pubnames_shndx;
+ off_t pubnames_offset = die->ref_attribute(elfcpp::DW_AT_GNU_pubnames,
+ &pubnames_shndx);
+ if (pubnames_offset != -1)
+ {
+ if (this->gdb_index_->pubnames_read(pubnames_shndx, pubnames_offset))
+ ret = true;
+ else
+ {
+ Dwarf_pubnames_table pubnames(false);
+ if (!pubnames.read_section(this->object(), pubnames_shndx))
+ return false;
+ if (!pubnames.read_header(pubnames_offset))
+ return false;
+ while (true)
+ {
+ const char* name = pubnames.next_name();
+ if (name == NULL)
+ break;
+ this->gdb_index_->add_symbol(this->cu_index_, name);
+ }
+ ret = true;
+ }
+ }
+
+ // If we find a DW_AT_GNU_pubtypes attribute, read the pubtypes table.
+ unsigned int pubtypes_shndx;
+ off_t pubtypes_offset = die->ref_attribute(elfcpp::DW_AT_GNU_pubtypes,
+ &pubtypes_shndx);
+ if (pubtypes_offset != -1)
+ {
+ if (this->gdb_index_->pubtypes_read(pubtypes_shndx, pubtypes_offset))
+ ret = true;
+ else
+ {
+ Dwarf_pubnames_table pubtypes(true);
+ if (!pubtypes.read_section(this->object(), pubtypes_shndx))
+ return false;
+ if (!pubtypes.read_header(pubtypes_offset))
+ return false;
+ while (true)
+ {
+ const char* name = pubtypes.next_name();
+ if (name == NULL)
+ break;
+ this->gdb_index_->add_symbol(this->cu_index_, name);
+ }
+ ret = true;
+ }
+ }
+
+ return ret;
+}
+
+// Clear the declarations map.
+void
+Gdb_index_info_reader::clear_declarations()
+{
+ // Free strings in memory we manage.
+ for (Declaration_map::iterator it = this->declarations_.begin();
+ it != this->declarations_.end();
+ ++it)
+ {
+ if (it->second.parent_offset_ == -1)
+ delete[] it->second.name_;
+ }
+
+ this->declarations_.clear();
+}
+
+// Print usage statistics.
+void
+Gdb_index_info_reader::print_stats()
+{
+ fprintf(stderr, _("%s: DWARF CUs: %u\n"),
+ program_name, Gdb_index_info_reader::dwarf_cu_count);
+ fprintf(stderr, _("%s: DWARF CUs without pubnames/pubtypes: %u\n"),
+ program_name, Gdb_index_info_reader::dwarf_cu_nopubnames_count);
+ fprintf(stderr, _("%s: DWARF TUs: %u\n"),
+ program_name, Gdb_index_info_reader::dwarf_tu_count);
+ fprintf(stderr, _("%s: DWARF TUs without pubnames/pubtypes: %u\n"),
+ program_name, Gdb_index_info_reader::dwarf_tu_nopubnames_count);
+}
+
+// Class Gdb_index.
+
+// Construct the .gdb_index section.
+
+Gdb_index::Gdb_index(Output_section* gdb_index_section)
+ : Output_section_data(4),
+ gdb_index_section_(gdb_index_section),
+ comp_units_(),
+ type_units_(),
+ ranges_(),
+ cu_vector_list_(),
+ cu_vector_offsets_(NULL),
+ stringpool_(),
+ tu_offset_(0),
+ addr_offset_(0),
+ symtab_offset_(0),
+ cu_pool_offset_(0),
+ stringpool_offset_(0),
+ pubnames_shndx_(0),
+ pubnames_offset_(0),
+ pubtypes_shndx_(0),
+ pubtypes_offset_(0)
+{
+ this->gdb_symtab_ = new Gdb_hashtab<Gdb_symbol>();
+}
+
+Gdb_index::~Gdb_index()
+{
+ // Free the memory used by the symbol table.
+ delete this->gdb_symtab_;
+ // Free the memory used by the CU vectors.
+ for (unsigned int i = 0; i < this->cu_vector_list_.size(); ++i)
+ delete this->cu_vector_list_[i];
+}
+
+// Scan a .debug_info or .debug_types input section.
+
+void
+Gdb_index::scan_debug_info(bool is_type_unit,
+ Relobj* object,
+ const unsigned char* symbols,
+ off_t symbols_size,
+ unsigned int shndx,
+ unsigned int reloc_shndx,
+ unsigned int reloc_type)
+{
+ Gdb_index_info_reader dwinfo(is_type_unit, object,
+ symbols, symbols_size,
+ shndx, reloc_shndx,
+ reloc_type, this);
+ dwinfo.parse();
+}
+
+// Add a symbol.
+
+void
+Gdb_index::add_symbol(int cu_index, const char* sym_name)
+{
+ unsigned int hash = mapped_index_string_hash(
+ reinterpret_cast<const unsigned char*>(sym_name));
+ Gdb_symbol* sym = new Gdb_symbol();
+ this->stringpool_.add(sym_name, true, &sym->name_key);
+ sym->hashval = hash;
+ sym->cu_vector_index = 0;
+
+ Gdb_symbol* found = this->gdb_symtab_->add(sym);
+ if (found == sym)
+ {
+ // New symbol -- allocate a new CU index vector.
+ found->cu_vector_index = this->cu_vector_list_.size();
+ this->cu_vector_list_.push_back(new Cu_vector());
+ }
+ else
+ {
+ // Found an existing symbol -- append to the existing
+ // CU index vector.
+ delete sym;
+ }
+
+ // Add the CU index to the vector list for this symbol,
+ // if it's not already on the list. We only need to
+ // check the last added entry.
+ Cu_vector* cu_vec = this->cu_vector_list_[found->cu_vector_index];
+ if (cu_vec->size() == 0 || cu_vec->back() != cu_index)
+ cu_vec->push_back(cu_index);
+}
+
+// Return TRUE if we have already processed the pubnames set at
+// OFFSET in section SHNDX
+
+bool
+Gdb_index::pubnames_read(unsigned int shndx, off_t offset)
+{
+ bool ret = (this->pubnames_shndx_ == shndx
+ && this->pubnames_offset_ == offset);
+ this->pubnames_shndx_ = shndx;
+ this->pubnames_offset_ = offset;
+ return ret;
+}
+
+// Return TRUE if we have already processed the pubtypes set at
+// OFFSET in section SHNDX
+
+bool
+Gdb_index::pubtypes_read(unsigned int shndx, off_t offset)
+{
+ bool ret = (this->pubtypes_shndx_ == shndx
+ && this->pubtypes_offset_ == offset);
+ this->pubtypes_shndx_ = shndx;
+ this->pubtypes_offset_ = offset;
+ return ret;
+}
+
+// Set the size of the .gdb_index section.
+
+void
+Gdb_index::set_final_data_size()
+{
+ // Finalize the string pool.
+ this->stringpool_.set_string_offsets();
+
+ // Compute the total size of the CU vectors.
+ // For each CU vector, include one entry for the count at the
+ // beginning of the vector.
+ unsigned int cu_vector_count = this->cu_vector_list_.size();
+ unsigned int cu_vector_size = 0;
+ this->cu_vector_offsets_ = new off_t[cu_vector_count];
+ for (unsigned int i = 0; i < cu_vector_count; ++i)
+ {
+ Cu_vector* cu_vec = this->cu_vector_list_[i];
+ cu_vector_offsets_[i] = cu_vector_size;
+ cu_vector_size += gdb_index_offset_size * (cu_vec->size() + 1);
+ }
+
+ // Assign relative offsets to each portion of the index,
+ // and find the total size of the section.
+ section_size_type data_size = gdb_index_hdr_size;
+ data_size += this->comp_units_.size() * gdb_index_cu_size;
+ this->tu_offset_ = data_size;
+ data_size += this->type_units_.size() * gdb_index_tu_size;
+ this->addr_offset_ = data_size;
+ for (unsigned int i = 0; i < this->ranges_.size(); ++i)
+ data_size += this->ranges_[i].ranges->size() * gdb_index_addr_size;
+ this->symtab_offset_ = data_size;
+ data_size += this->gdb_symtab_->capacity() * gdb_index_sym_size;
+ this->cu_pool_offset_ = data_size;
+ data_size += cu_vector_size;
+ this->stringpool_offset_ = data_size;
+ data_size += this->stringpool_.get_strtab_size();
+
+ this->set_data_size(data_size);
+}
+
+// Write the data to the file.
+
+void
+Gdb_index::do_write(Output_file* of)
+{
+ const off_t off = this->offset();
+ const off_t oview_size = this->data_size();
+ unsigned char* const oview = of->get_output_view(off, oview_size);
+ unsigned char* pov = oview;
+
+ // Write the file header.
+ // (1) Version number.
+ elfcpp::Swap<32, false>::writeval(pov, gdb_index_version);
+ pov += 4;
+ // (2) Offset of the CU list.
+ elfcpp::Swap<32, false>::writeval(pov, gdb_index_hdr_size);
+ pov += 4;
+ // (3) Offset of the types CU list.
+ elfcpp::Swap<32, false>::writeval(pov, this->tu_offset_);
+ pov += 4;
+ // (4) Offset of the address area.
+ elfcpp::Swap<32, false>::writeval(pov, this->addr_offset_);
+ pov += 4;
+ // (5) Offset of the symbol table.
+ elfcpp::Swap<32, false>::writeval(pov, this->symtab_offset_);
+ pov += 4;
+ // (6) Offset of the constant pool.
+ elfcpp::Swap<32, false>::writeval(pov, this->cu_pool_offset_);
+ pov += 4;
+
+ gold_assert(pov - oview == gdb_index_hdr_size);
+
+ // Write the CU list.
+ unsigned int comp_units_count = this->comp_units_.size();
+ for (unsigned int i = 0; i < comp_units_count; ++i)
+ {
+ const Comp_unit& cu = this->comp_units_[i];
+ elfcpp::Swap<64, false>::writeval(pov, cu.cu_offset);
+ elfcpp::Swap<64, false>::writeval(pov + 8, cu.cu_length);
+ pov += 16;
+ }
+
+ gold_assert(pov - oview == this->tu_offset_);
+
+ // Write the types CU list.
+ for (unsigned int i = 0; i < this->type_units_.size(); ++i)
+ {
+ const Type_unit& tu = this->type_units_[i];
+ elfcpp::Swap<64, false>::writeval(pov, tu.tu_offset);
+ elfcpp::Swap<64, false>::writeval(pov + 8, tu.type_offset);
+ elfcpp::Swap<64, false>::writeval(pov + 16, tu.type_signature);
+ pov += 24;
+ }
+
+ gold_assert(pov - oview == this->addr_offset_);
+
+ // Write the address area.
+ for (unsigned int i = 0; i < this->ranges_.size(); ++i)
+ {
+ int cu_index = this->ranges_[i].cu_index;
+ // Translate negative indexes, which refer to a TU, to a
+ // logical index into a concatenated CU/TU list.
+ if (cu_index < 0)
+ cu_index = comp_units_count + (-1 - cu_index);
+ Relobj* object = this->ranges_[i].object;
+ const Dwarf_range_list& ranges = *this->ranges_[i].ranges;
+ for (unsigned int j = 0; j < ranges.size(); ++j)
+ {
+ const Dwarf_range_list::Range& range = ranges[j];
+ uint64_t base = 0;
+ if (range.shndx > 0)
+ {
+ const Output_section* os = object->output_section(range.shndx);
+ base = (os->address()
+ + object->output_section_offset(range.shndx));
+ }
+ elfcpp::Swap<64, false>::writeval(pov, base + range.start);
+ elfcpp::Swap<64, false>::writeval(pov + 8, base + range.end);
+ elfcpp::Swap<32, false>::writeval(pov + 16, cu_index);
+ pov += 20;
+ }
+ }
+
+ gold_assert(pov - oview == this->symtab_offset_);
+
+ // Write the symbol table.
+ for (unsigned int i = 0; i < this->gdb_symtab_->capacity(); ++i)
+ {
+ const Gdb_symbol* sym = (*this->gdb_symtab_)[i];
+ section_offset_type name_offset = 0;
+ unsigned int cu_vector_offset = 0;
+ if (sym != NULL)
+ {
+ name_offset = (this->stringpool_.get_offset_from_key(sym->name_key)
+ + this->stringpool_offset_ - this->cu_pool_offset_);
+ cu_vector_offset = this->cu_vector_offsets_[sym->cu_vector_index];
+ }
+ elfcpp::Swap<32, false>::writeval(pov, name_offset);
+ elfcpp::Swap<32, false>::writeval(pov + 4, cu_vector_offset);
+ pov += 8;
+ }
+
+ gold_assert(pov - oview == this->cu_pool_offset_);
+
+ // Write the CU vectors into the constant pool.
+ for (unsigned int i = 0; i < this->cu_vector_list_.size(); ++i)
+ {
+ Cu_vector* cu_vec = this->cu_vector_list_[i];
+ elfcpp::Swap<32, false>::writeval(pov, cu_vec->size());
+ pov += 4;
+ for (unsigned int j = 0; j < cu_vec->size(); ++j)
+ {
+ int cu_index = (*cu_vec)[j];
+ if (cu_index < 0)
+ cu_index = comp_units_count + (-1 - cu_index);
+ elfcpp::Swap<32, false>::writeval(pov, cu_index);
+ pov += 4;
+ }
+ }
+
+ gold_assert(pov - oview == this->stringpool_offset_);
+
+ // Write the strings into the constant pool.
+ this->stringpool_.write_to_buffer(pov, oview_size - this->stringpool_offset_);
+
+ of->write_output_view(off, oview_size, oview);
+}
+
+// Print usage statistics.
+void
+Gdb_index::print_stats()
+{
+ if (parameters->options().gdb_index())
+ Gdb_index_info_reader::print_stats();
+}
+
+} // End namespace gold.
--- /dev/null
+// gdb-index.h -- generate .gdb_index section for fast debug lookup -*- C++ -*-
+
+// Copyright 2012 Free Software Foundation, Inc.
+// Written by Cary Coutant <ccoutant@google.com>.
+
+// This file is part of gold.
+
+// This program is free software; you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation; either version 3 of the License, or
+// (at your option) any later version.
+
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+// GNU General Public License for more details.
+
+// You should have received a copy of the GNU General Public License
+// along with this program; if not, write to the Free Software
+// Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,
+// MA 02110-1301, USA.
+
+#include <sys/types.h>
+#include <vector>
+
+#include "gold.h"
+#include "output.h"
+#include "mapfile.h"
+#include "stringpool.h"
+
+#ifndef GOLD_GDB_INDEX_H
+#define GOLD_GDB_INDEX_H
+
+namespace gold
+{
+
+class Output_section;
+class Output_file;
+class Mapfile;
+template<int size, bool big_endian>
+class Sized_relobj;
+class Dwarf_range_list;
+template <typename T>
+class Gdb_hashtab;
+
+// This class manages the .gdb_index section, which is a fast
+// lookup table for DWARF information used by the gdb debugger.
+// The format of this section is described in gdb/doc/gdb.texinfo.
+
+class Gdb_index : public Output_section_data
+{
+ public:
+ Gdb_index(Output_section* gdb_index_section);
+
+ ~Gdb_index();
+
+ // Scan a .debug_info or .debug_types input section.
+ void scan_debug_info(bool is_type_unit,
+ Relobj* object,
+ const unsigned char* symbols,
+ off_t symbols_size,
+ unsigned int shndx,
+ unsigned int reloc_shndx,
+ unsigned int reloc_type);
+
+ // Add a compilation unit.
+ int
+ add_comp_unit(off_t cu_offset, off_t cu_length)
+ {
+ this->comp_units_.push_back(Comp_unit(cu_offset, cu_length));
+ return this->comp_units_.size() - 1;
+ }
+
+ // Add a type unit.
+ int
+ add_type_unit(off_t tu_offset, off_t type_offset, uint64_t signature)
+ {
+ this->type_units_.push_back(Type_unit(tu_offset, type_offset, signature));
+ return this->type_units_.size() - 1;
+ }
+
+ // Add an address range.
+ void
+ add_address_range_list(Relobj* object, unsigned int cu_index,
+ Dwarf_range_list* ranges)
+ {
+ this->ranges_.push_back(Per_cu_range_list(object, cu_index, ranges));
+ }
+
+ // Add a symbol.
+ void
+ add_symbol(int cu_index, const char* sym_name);
+
+ // Return TRUE if we have already processed the pubnames set at
+ // OFFSET in section SHNDX
+ bool
+ pubnames_read(unsigned int shndx, off_t offset);
+
+ // Return TRUE if we have already processed the pubtypes set at
+ // OFFSET in section SHNDX
+ bool
+ pubtypes_read(unsigned int shndx, off_t offset);
+
+ // Print usage statistics.
+ static void
+ print_stats();
+
+ protected:
+ // This is called to update the section size prior to assigning
+ // the address and file offset.
+ void
+ update_data_size()
+ { this->set_final_data_size(); }
+
+ // Set the final data size.
+ void
+ set_final_data_size();
+
+ // Write the data to the file.
+ void
+ do_write(Output_file*);
+
+ // Write to a map file.
+ void
+ do_print_to_mapfile(Mapfile* mapfile) const
+ { mapfile->print_output_data(this, _("** gdb_index")); }
+
+ private:
+ // An entry in the compilation unit list.
+ struct Comp_unit
+ {
+ Comp_unit(off_t off, off_t len)
+ : cu_offset(off), cu_length(len)
+ { }
+ uint64_t cu_offset;
+ uint64_t cu_length;
+ };
+
+ // An entry in the type unit list.
+ struct Type_unit
+ {
+ Type_unit(off_t off, off_t toff, uint64_t sig)
+ : tu_offset(off), type_offset(toff), type_signature(sig)
+ { }
+ uint64_t tu_offset;
+ uint64_t type_offset;
+ uint64_t type_signature;
+ };
+
+ // An entry in the address range list.
+ struct Per_cu_range_list
+ {
+ Per_cu_range_list(Relobj* obj, uint32_t index, Dwarf_range_list* r)
+ : object(obj), cu_index(index), ranges(r)
+ { }
+ Relobj* object;
+ uint32_t cu_index;
+ Dwarf_range_list* ranges;
+ };
+
+ // A symbol table entry.
+ struct Gdb_symbol
+ {
+ Stringpool::Key name_key;
+ unsigned int hashval;
+ unsigned int cu_vector_index;
+
+ // Return the hash value.
+ unsigned int
+ hash()
+ { return this->hashval; }
+
+ // Return true if this symbol is the same as SYMBOL.
+ bool
+ equal(Gdb_symbol* symbol)
+ { return this->name_key == symbol->name_key; }
+ };
+
+ typedef std::vector<int> Cu_vector;
+
+ // The .gdb_index section.
+ Output_section* gdb_index_section_;
+ // The list of DWARF compilation units.
+ std::vector<Comp_unit> comp_units_;
+ // The list of DWARF type units.
+ std::vector<Type_unit> type_units_;
+ // The list of address ranges.
+ std::vector<Per_cu_range_list> ranges_;
+ // The symbol table.
+ Gdb_hashtab<Gdb_symbol>* gdb_symtab_;
+ // The CU vector portion of the constant pool.
+ std::vector<Cu_vector*> cu_vector_list_;
+ // An array to map from a CU vector index to an offset to the constant pool.
+ off_t* cu_vector_offsets_;
+ // The string portion of the constant pool.
+ Stringpool stringpool_;
+ // Offsets of the various pieces of the .gdb_index section.
+ off_t tu_offset_;
+ off_t addr_offset_;
+ off_t symtab_offset_;
+ off_t cu_pool_offset_;
+ off_t stringpool_offset_;
+ // Section index and offset of last read pubnames section.
+ unsigned int pubnames_shndx_;
+ off_t pubnames_offset_;
+ // Section index and offset of last read pubtypes section.
+ unsigned int pubtypes_shndx_;
+ off_t pubtypes_offset_;
+};
+
+} // End namespace gold.
+
+#endif // !defined(GOLD_GDB_INDEX_H)
Output_sections& out_sections(this->output_sections());
out_sections.resize(shnum);
this->section_offsets().resize(shnum);
+
+ // Keep track of .debug_info and .debug_types sections.
+ std::vector<unsigned int> debug_info_sections;
+ std::vector<unsigned int> debug_types_sections;
+
for (unsigned int i = 1; i < shnum; i++)
{
typename Input_entry_reader::Input_section_info sect =
gold_assert(os != NULL);
out_sections[i] = os;
this->section_offsets()[i] = static_cast<Address>(sect.sh_offset);
+
+ // When generating a .gdb_index section, we do additional
+ // processing of .debug_info and .debug_types sections after all
+ // the other sections.
+ if (parameters->options().gdb_index())
+ {
+ const char* name = os->name();
+ if (strcmp(name, ".debug_info") == 0)
+ debug_info_sections.push_back(i);
+ else if (strcmp(name, ".debug_types") == 0)
+ debug_types_sections.push_back(i);
+ }
}
// Process the COMDAT groups.
this->error(_("COMDAT group %s included twice in incremental link"),
signature);
}
+
+ // When building a .gdb_index section, scan the .debug_info and
+ // .debug_types sections.
+ for (std::vector<unsigned int>::const_iterator p
+ = debug_info_sections.begin();
+ p != debug_info_sections.end();
+ ++p)
+ {
+ unsigned int i = *p;
+ layout->add_to_gdb_index(false, this, NULL, 0, i, 0, 0);
+ }
+ for (std::vector<unsigned int>::const_iterator p
+ = debug_types_sections.begin();
+ p != debug_types_sections.end();
+ ++p)
+ {
+ unsigned int i = *p;
+ layout->add_to_gdb_index(true, this, 0, 0, i, 0, 0);
+ }
}
// Layout sections whose layout was deferred while waiting for
gold_unreachable();
}
-// Get the name of a section.
+// Get the name of a section. This returns the name of the output
+// section, because we don't usually track the names of the input
+// sections.
template<int size, bool big_endian>
std::string
-Sized_relobj_incr<size, big_endian>::do_section_name(unsigned int)
+Sized_relobj_incr<size, big_endian>::do_section_name(unsigned int shndx)
{
- gold_unreachable();
+ Output_sections& out_sections(this->output_sections());
+ Output_section* os = out_sections[shndx];
+ if (os == NULL)
+ return NULL;
+ return os->name();
}
// Return a view of the contents of a section.
template<int size, bool big_endian>
-Object::Location
-Sized_relobj_incr<size, big_endian>::do_section_contents(unsigned int)
+const unsigned char*
+Sized_relobj_incr<size, big_endian>::do_section_contents(
+ unsigned int shndx,
+ section_size_type* plen,
+ bool)
{
- gold_unreachable();
+ Output_sections& out_sections(this->output_sections());
+ Output_section* os = out_sections[shndx];
+ gold_assert(os != NULL);
+ off_t section_offset = os->offset();
+ typename Input_entry_reader::Input_section_info sect =
+ this->input_reader_.get_input_section(shndx - 1);
+ section_offset += sect.sh_offset;
+ *plen = sect.sh_size;
+ return this->ibase_->view(section_offset, sect.sh_size).data();
}
// Return section flags.
// Return a view of the contents of a section.
template<int size, bool big_endian>
-Object::Location
-Sized_incr_dynobj<size, big_endian>::do_section_contents(unsigned int)
+const unsigned char*
+Sized_incr_dynobj<size, big_endian>::do_section_contents(
+ unsigned int,
+ section_size_type*,
+ bool)
{
gold_unreachable();
}
do_section_name(unsigned int shndx);
// Return a view of the contents of a section.
- Object::Location
- do_section_contents(unsigned int shndx);
+ const unsigned char*
+ do_section_contents(unsigned int shndx, section_size_type* plen,
+ bool cache);
// Return section flags.
uint64_t
do_section_name(unsigned int shndx);
// Return a view of the contents of a section.
- Object::Location
- do_section_contents(unsigned int shndx);
+ const unsigned char*
+ do_section_contents(unsigned int shndx, section_size_type* plen,
+ bool cache);
// Return section flags.
uint64_t
#include "symtab.h"
#include "dynobj.h"
#include "ehframe.h"
+#include "gdb-index.h"
#include "compressed_output.h"
#include "reduced_debug_output.h"
#include "object.h"
eh_frame_data_(NULL),
added_eh_frame_data_(false),
eh_frame_hdr_section_(NULL),
+ gdb_index_data_(NULL),
build_id_note_(NULL),
debug_abbrev_(NULL),
debug_info_(NULL),
if (!can_incremental_update(sh_type))
return NULL;
+ // If we're generating a .gdb_index section, we need to regenerate
+ // it from scratch.
+ if (parameters->options().gdb_index()
+ && sh_type == elfcpp::SHT_PROGBITS
+ && strcmp(name, ".gdb_index") == 0)
+ return NULL;
+
typename elfcpp::Elf_types<size>::Elf_Addr sh_addr = shdr.get_sh_addr();
typename elfcpp::Elf_types<size>::Elf_Off sh_offset = shdr.get_sh_offset();
typename elfcpp::Elf_types<size>::Elf_WXword sh_size = shdr.get_sh_size();
}
}
+// Scan a .debug_info or .debug_types section, and add summary
+// information to the .gdb_index section.
+
+template<int size, bool big_endian>
+void
+Layout::add_to_gdb_index(bool is_type_unit,
+ Sized_relobj<size, big_endian>* object,
+ const unsigned char* symbols,
+ off_t symbols_size,
+ unsigned int shndx,
+ unsigned int reloc_shndx,
+ unsigned int reloc_type)
+{
+ if (this->gdb_index_data_ == NULL)
+ {
+ Output_section* os = this->choose_output_section(NULL, ".gdb_index",
+ elfcpp::SHT_PROGBITS, 0,
+ false, ORDER_INVALID,
+ false);
+ if (os == NULL)
+ return;
+
+ this->gdb_index_data_ = new Gdb_index(os);
+ os->add_output_section_data(this->gdb_index_data_);
+ os->set_after_input_sections();
+ }
+
+ this->gdb_index_data_->scan_debug_info(is_type_unit, object, symbols,
+ symbols_size, shndx, reloc_shndx,
+ reloc_type);
+}
+
// Add POSD to an output section using NAME, TYPE, and FLAGS. Return
// the output section.
off_t* off);
#endif
+#ifdef HAVE_TARGET_32_LITTLE
+template
+void
+Layout::add_to_gdb_index(bool is_type_unit,
+ Sized_relobj<32, false>* object,
+ const unsigned char* symbols,
+ off_t symbols_size,
+ unsigned int shndx,
+ unsigned int reloc_shndx,
+ unsigned int reloc_type);
+#endif
+
+#ifdef HAVE_TARGET_32_BIG
+template
+void
+Layout::add_to_gdb_index(bool is_type_unit,
+ Sized_relobj<32, true>* object,
+ const unsigned char* symbols,
+ off_t symbols_size,
+ unsigned int shndx,
+ unsigned int reloc_shndx,
+ unsigned int reloc_type);
+#endif
+
+#ifdef HAVE_TARGET_64_LITTLE
+template
+void
+Layout::add_to_gdb_index(bool is_type_unit,
+ Sized_relobj<64, false>* object,
+ const unsigned char* symbols,
+ off_t symbols_size,
+ unsigned int shndx,
+ unsigned int reloc_shndx,
+ unsigned int reloc_type);
+#endif
+
+#ifdef HAVE_TARGET_64_BIG
+template
+void
+Layout::add_to_gdb_index(bool is_type_unit,
+ Sized_relobj<64, true>* object,
+ const unsigned char* symbols,
+ off_t symbols_size,
+ unsigned int shndx,
+ unsigned int reloc_shndx,
+ unsigned int reloc_type);
+#endif
+
} // End namespace gold.
class Output_reduced_debug_abbrev_section;
class Output_reduced_debug_info_section;
class Eh_frame;
+class Gdb_index;
class Target;
struct Timespec;
size_t cie_length, const unsigned char* fde_data,
size_t fde_length);
+ // Scan a .debug_info or .debug_types section, and add summary
+ // information to the .gdb_index section.
+ template<int size, bool big_endian>
+ void
+ add_to_gdb_index(bool is_type_unit,
+ Sized_relobj<size, big_endian>* object,
+ const unsigned char* symbols,
+ off_t symbols_size,
+ unsigned int shndx,
+ unsigned int reloc_shndx,
+ unsigned int reloc_type);
+
// Handle a GNU stack note. This is called once per input object
// file. SEEN_GNU_STACK is true if the object file has a
// .note.GNU-stack section. GNU_STACK_FLAGS is the section flags
bool added_eh_frame_data_;
// The exception frame header output section if there is one.
Output_section* eh_frame_hdr_section_;
+ // The data for the .gdb_index section.
+ Gdb_index* gdb_index_data_;
// The space for the build ID checksum if there is one.
Output_section_data* build_id_note_;
// The output section containing dwarf abbreviations
#include "gc.h"
#include "icf.h"
#include "incremental.h"
+#include "gdb-index.h"
#include "timer.h"
using namespace gold;
program_name, static_cast<long long>(layout.output_file_size()));
symtab.print_stats();
layout.print_stats();
+ Gdb_index::print_stats();
Free_list::print_stats();
}
const unsigned char*
Object::section_contents(unsigned int shndx, section_size_type* plen,
bool cache)
-{
- Location loc(this->do_section_contents(shndx));
- *plen = convert_to_section_size_type(loc.data_size);
- if (*plen == 0)
- {
- static const unsigned char empty[1] = { '\0' };
- return empty;
- }
- return this->get_view(loc.file_offset, *plen, true, cache);
-}
+{ return this->do_section_contents(shndx, plen, cache); }
// Read the section data into SD. This is code common to Sized_relobj_file
// and Sized_dynobj, so we put it into Object.
return false;
}
-#ifdef ENABLE_THREADS
-
// Return TRUE if this is a section whose contents will be needed in the
-// Add_symbols task.
+// Add_symbols task. This function is only called for sections that have
+// already passed the test in is_compressed_debug_section(), so we know
+// that the section name begins with ".zdebug".
static bool
need_decompressed_section(const char* name)
{
- // We will need .zdebug_str if this is not an incremental link
- // (i.e., we are processing string merge sections).
- if (!parameters->incremental() && strcmp(name, ".zdebug_str") == 0)
+ // Skip over the ".zdebug" and a quick check for the "_".
+ name += 7;
+ if (*name++ != '_')
+ return false;
+
+#ifdef ENABLE_THREADS
+ // Decompressing these sections now will help only if we're
+ // multithreaded.
+ if (parameters->options().threads())
+ {
+ // We will need .zdebug_str if this is not an incremental link
+ // (i.e., we are processing string merge sections) or if we need
+ // to build a gdb index.
+ if ((!parameters->incremental() || parameters->options().gdb_index())
+ && strcmp(name, "str") == 0)
+ return true;
+
+ // We will need these other sections when building a gdb index.
+ if (parameters->options().gdb_index()
+ && (strcmp(name, "info") == 0
+ || strcmp(name, "types") == 0
+ || strcmp(name, "pubnames") == 0
+ || strcmp(name, "pubtypes") == 0
+ || strcmp(name, "ranges") == 0
+ || strcmp(name, "abbrev") == 0))
+ return true;
+ }
+#endif
+
+ // Even when single-threaded, we will need .zdebug_str if this is
+ // not an incremental link and we are building a gdb index.
+ // Otherwise, we would decompress the section twice: once for
+ // string merge processing, and once for building the gdb index.
+ if (!parameters->incremental()
+ && parameters->options().gdb_index()
+ && strcmp(name, "str") == 0)
return true;
return false;
}
-#endif
-
// Build a table for any compressed debug sections, mapping each section index
// to the uncompressed size and (if needed) the decompressed contents.
const unsigned char* contents =
obj->section_contents(i, &len, false);
uint64_t uncompressed_size = get_uncompressed_size(contents, len);
+ Compressed_section_info info;
+ info.size = convert_to_section_size_type(uncompressed_size);
+ info.contents = NULL;
if (uncompressed_size != -1ULL)
{
- Compressed_section_info info;
- info.size = convert_to_section_size_type(uncompressed_size);
- info.contents = NULL;
-
-#ifdef ENABLE_THREADS
- // If we're multi-threaded, it will help to decompress
- // any sections that will be needed during the Add_symbols
- // task, so that several decompressions can run in
- // parallel.
- if (parameters->options().threads())
+ unsigned char* uncompressed_data = NULL;
+ if (need_decompressed_section(name))
{
- unsigned char* uncompressed_data = NULL;
- if (need_decompressed_section(name))
- {
- uncompressed_data = new unsigned char[uncompressed_size];
- if (decompress_input_section(contents, len,
- uncompressed_data,
- uncompressed_size))
- info.contents = uncompressed_data;
- else
- delete[] uncompressed_data;
- }
+ uncompressed_data = new unsigned char[uncompressed_size];
+ if (decompress_input_section(contents, len,
+ uncompressed_data,
+ uncompressed_size))
+ info.contents = uncompressed_data;
+ else
+ delete[] uncompressed_data;
}
-#endif
-
(*uncompressed_map)[i] = info;
}
}
void
Sized_relobj_file<size, big_endian>::do_read_symbols(Read_symbols_data* sd)
{
+ bool need_local_symbols = false;
+
this->read_section_data(&this->elf_file_, sd);
const unsigned char* const pshdrs = sd->section_headers->data();
build_compressed_section_map(pshdrs, this->shnum(), names,
sd->section_names_size, this);
+ if (this->has_eh_frame_
+ || (!parameters->options().relocatable()
+ && parameters->options().gdb_index()
+ && (memmem(names, sd->section_names_size, "debug_info", 12) == 0
+ || memmem(names, sd->section_names_size, "debug_types",
+ 13) == 0)))
+ need_local_symbols = true;
+
sd->symbols = NULL;
sd->symbols_size = 0;
sd->external_symbols_offset = 0;
+ this->symtab_shndx_ * This::shdr_size);
gold_assert(symtabshdr.get_sh_type() == elfcpp::SHT_SYMTAB);
- // If this object has a .eh_frame section, we need all the symbols.
+ // If this object has a .eh_frame section, or if building a .gdb_index
+ // section and there is debug info, we need all the symbols.
// Otherwise we only need the external symbols. While it would be
// simpler to just always read all the symbols, I've seen object
// files with well over 2000 local symbols, which for a 64-bit
off_t extoff = dataoff + locsize;
section_size_type extsize = datasize - locsize;
- off_t readoff = this->has_eh_frame_ ? dataoff : extoff;
- section_size_type readsize = this->has_eh_frame_ ? datasize : extsize;
+ off_t readoff = need_local_symbols ? dataoff : extoff;
+ section_size_type readsize = need_local_symbols ? datasize : extsize;
if (readsize == 0)
{
sd->symbols = fvsymtab;
sd->symbols_size = readsize;
- sd->external_symbols_offset = this->has_eh_frame_ ? locsize : 0;
+ sd->external_symbols_offset = need_local_symbols ? locsize : 0;
sd->symbol_names = fvstrtab;
sd->symbol_names_size =
convert_to_section_size_type(strtabshdr.get_sh_size());
// Keep track of .eh_frame sections.
std::vector<unsigned int> eh_frame_sections;
+ // Keep track of .debug_info and .debug_types sections.
+ std::vector<unsigned int> debug_info_sections;
+ std::vector<unsigned int> debug_types_sections;
+
// Skip the first, dummy, section.
pshdrs = shdrs + This::shdr_size;
for (unsigned int i = 1; i < shnum; ++i, pshdrs += This::shdr_size)
// only happens in the second call.
this->layout_section(layout, i, name, shdr, reloc_shndx[i],
reloc_type[i]);
+
+ // When generating a .gdb_index section, we do additional
+ // processing of .debug_info and .debug_types sections after all
+ // the other sections for the same reason as above.
+ if (!relocatable
+ && parameters->options().gdb_index()
+ && !(shdr.get_sh_flags() & elfcpp::SHF_ALLOC))
+ {
+ if (strcmp(name, ".debug_info") == 0
+ || strcmp(name, ".zdebug_info") == 0)
+ debug_info_sections.push_back(i);
+ else if (strcmp(name, ".debug_types") == 0
+ || strcmp(name, ".zdebug_types") == 0)
+ debug_types_sections.push_back(i);
+ }
}
}
reloc_type[i]);
}
+ // When building a .gdb_index section, scan the .debug_info and
+ // .debug_types sections.
+ gold_assert(!is_gc_pass_one
+ || (debug_info_sections.empty() && debug_types_sections.empty()));
+ for (std::vector<unsigned int>::const_iterator p
+ = debug_info_sections.begin();
+ p != debug_info_sections.end();
+ ++p)
+ {
+ unsigned int i = *p;
+ layout->add_to_gdb_index(false, this, symbols_data, symbols_size,
+ i, reloc_shndx[i], reloc_type[i]);
+ }
+ for (std::vector<unsigned int>::const_iterator p
+ = debug_types_sections.begin();
+ p != debug_types_sections.end();
+ ++p)
+ {
+ unsigned int i = *p;
+ layout->add_to_gdb_index(true, this, symbols_data, symbols_size,
+ i, reloc_shndx[i], reloc_type[i]);
+ }
+
if (is_gc_pass_two)
{
delete[] gc_sd->section_headers_data;
bool* is_new)
{
section_size_type buffer_size;
- const unsigned char* buffer = this->section_contents(shndx, &buffer_size,
- false);
+ const unsigned char* buffer = this->do_section_contents(shndx, &buffer_size,
+ false);
if (this->compressed_sections_ == NULL)
{
section_size_type* uncompressed_size) const
{ return this->do_section_is_compressed(shndx, uncompressed_size); }
- // Return a view of the uncompressed contents of a section. Set *PLEN
+ // Return a view of the decompressed contents of a section. Set *PLEN
// to the size. Set *IS_NEW to true if the contents need to be freed
// by the caller.
const unsigned char*
// Return the location of the contents of a section. Implemented by
// child class.
- virtual Location
- do_section_contents(unsigned int shndx) = 0;
+ virtual const unsigned char*
+ do_section_contents(unsigned int shndx, section_size_type* plen,
+ bool cache) = 0;
// Get the size of a section--implemented by child class.
virtual uint64_t
bool* is_new)
{
*is_new = false;
- return this->section_contents(shndx, plen, false);
+ return this->do_section_contents(shndx, plen, false);
}
// Discard any buffers of decompressed sections. This is done
{ return this->elf_file_.section_name(shndx); }
// Return the location of the contents of a section.
- Object::Location
- do_section_contents(unsigned int shndx)
- { return this->elf_file_.section_contents(shndx); }
+ const unsigned char*
+ do_section_contents(unsigned int shndx, section_size_type* plen,
+ bool cache)
+ {
+ Object::Location loc(this->elf_file_.section_contents(shndx));
+ *plen = convert_to_section_size_type(loc.data_size);
+ if (*plen == 0)
+ {
+ static const unsigned char empty[1] = { '\0' };
+ return empty;
+ }
+ return this->get_view(loc.file_offset, *plen, true, cache);
+ }
// Return section flags.
uint64_t
section_size_type* plen,
bool* is_new);
- // Discard any buffers of uncompressed sections. This is done
+ // Discard any buffers of decompressed sections. This is done
// at the end of the Add_symbols task.
void
do_discard_decompressed_sections();
DEFINE_bool(g, options::EXACTLY_ONE_DASH, '\0', false,
N_("Ignored"), NULL);
+ DEFINE_bool(gdb_index, options::TWO_DASHES, '\0', false,
+ N_("Generate .gdb_index section"),
+ N_("Do not generate .gdb_index section"));
+
DEFINE_bool(gnu_unique, options::TWO_DASHES, '\0', true,
N_("Enable STB_GNU_UNIQUE symbol binding (default)"),
N_("Disable STB_GNU_UNIQUE symbol binding"));
// Return a view of the contents of a section. Not used for plugin objects.
template<int size, bool big_endian>
-Object::Location
-Sized_pluginobj<size, big_endian>::do_section_contents(unsigned int)
+const unsigned char*
+Sized_pluginobj<size, big_endian>::do_section_contents(
+ unsigned int,
+ section_size_type*,
+ bool)
{
- Location loc(0, 0);
-
gold_unreachable();
- return loc;
+ return NULL;
}
// Return section flags. Not used for plugin objects.
do_section_name(unsigned int shndx);
// Return a view of the contents of a section.
- Object::Location
- do_section_contents(unsigned int shndx);
+ const unsigned char*
+ do_section_contents(unsigned int shndx, section_size_type* plen,
+ bool cache);
// Return section flags.
uint64_t
int
advance(off_t offset);
+ // Checkpoint the current position in the reloc section.
+ section_size_type
+ checkpoint() const
+ { return this->pos_; }
+
+ // Reset the position to CHECKPOINT.
+ void
+ reset(section_size_type checkpoint)
+ { this->pos_ = checkpoint; }
+
private:
// The contents of the input object's reloc section.
const unsigned char* prelocs_;
memory_test.stdout: memory_test
$(TEST_READELF) -lWS $< > $@
+# Test that --gdb-index functions correctly.
+check_SCRIPTS += gdb_index_test_1.sh
+check_DATA += gdb_index_test_1.stdout
+MOSTLYCLEANFILES += gdb_index_test_1.stdout gdb_index_test_1
+gdb_index_test.o: gdb_index_test.cc
+ $(CXXCOMPILE) -O0 -g -c -o $@ $<
+gdb_index_test_1: gdb_index_test.o gcctestdir/ld
+ $(CXXLINK) -Bgcctestdir/ -Wl,--gdb-index $<
+gdb_index_test_1.stdout: gdb_index_test_1
+ $(TEST_READELF) --debug-dump=gdb_index $< > $@
+
+if HAVE_ZLIB
+
+check_SCRIPTS += gdb_index_test_2.sh
+check_DATA += gdb_index_test_2.stdout
+MOSTLYCLEANFILES += gdb_index_test_2.stdout gdb_index_test_2
+gdb_index_test_cdebug.o: gdb_index_test.cc
+ $(CXXCOMPILE) -Bgcctestdir/ -O0 -g -Wa,--compress-debug-sections -c -o $@ $<
+gdb_index_test_2: gdb_index_test_cdebug.o gcctestdir/ld
+ $(CXXLINK) -Bgcctestdir/ -Wl,--gdb-index $<
+gdb_index_test_2.stdout: gdb_index_test_2
+ $(TEST_READELF) --debug-dump=gdb_index $< > $@
+
+endif HAVE_ZLIB
+
# End-to-end incremental linking tests.
# Incremental linking is currently supported only on the x86_64 target.
# weak reference in a DSO.
# Test that MEMORY region support works.
+
+# Test that --gdb-index functions correctly.
@GCC_TRUE@@NATIVE_LINKER_TRUE@am__append_38 = exclude_libs_test.sh \
@GCC_TRUE@@NATIVE_LINKER_TRUE@ discard_locals_test.sh \
@GCC_TRUE@@NATIVE_LINKER_TRUE@ hidden_test.sh \
@GCC_TRUE@@NATIVE_LINKER_TRUE@ retain_symbols_file_test.sh \
@GCC_TRUE@@NATIVE_LINKER_TRUE@ no_version_test.sh \
@GCC_TRUE@@NATIVE_LINKER_TRUE@ strong_ref_weak_def.sh \
-@GCC_TRUE@@NATIVE_LINKER_TRUE@ dyn_weak_ref.sh memory_test.sh
+@GCC_TRUE@@NATIVE_LINKER_TRUE@ dyn_weak_ref.sh memory_test.sh \
+@GCC_TRUE@@NATIVE_LINKER_TRUE@ gdb_index_test_1.sh
@GCC_TRUE@@NATIVE_LINKER_TRUE@am__append_39 = exclude_libs_test.syms \
@GCC_TRUE@@NATIVE_LINKER_TRUE@ discard_locals_test.syms \
@GCC_TRUE@@NATIVE_LINKER_TRUE@ discard_locals_relocatable_test1.syms \
@GCC_TRUE@@NATIVE_LINKER_TRUE@ no_version_test.stdout \
@GCC_TRUE@@NATIVE_LINKER_TRUE@ strong_ref_weak_def.stdout \
@GCC_TRUE@@NATIVE_LINKER_TRUE@ dyn_weak_ref.stdout \
-@GCC_TRUE@@NATIVE_LINKER_TRUE@ memory_test.stdout
+@GCC_TRUE@@NATIVE_LINKER_TRUE@ memory_test.stdout \
+@GCC_TRUE@@NATIVE_LINKER_TRUE@ gdb_index_test_1.stdout
@GCC_TRUE@@NATIVE_LINKER_TRUE@am__append_40 = exclude_libs_test.syms \
@GCC_TRUE@@NATIVE_LINKER_TRUE@ libexclude_libs_test_1.a \
@GCC_TRUE@@NATIVE_LINKER_TRUE@ libexclude_libs_test_2.a \
@GCC_TRUE@@NATIVE_LINKER_TRUE@ dyn_weak_ref_2.so \
@GCC_TRUE@@NATIVE_LINKER_TRUE@ dyn_weak_ref.stdout \
@GCC_TRUE@@NATIVE_LINKER_TRUE@ memory_test.stdout memory_test \
-@GCC_TRUE@@NATIVE_LINKER_TRUE@ memory_test.o
+@GCC_TRUE@@NATIVE_LINKER_TRUE@ memory_test.o \
+@GCC_TRUE@@NATIVE_LINKER_TRUE@ gdb_index_test_1.stdout \
+@GCC_TRUE@@NATIVE_LINKER_TRUE@ gdb_index_test_1
@GCC_TRUE@@MCMODEL_MEDIUM_TRUE@@NATIVE_LINKER_TRUE@am__append_41 = large
@GCC_FALSE@large_DEPENDENCIES =
@MCMODEL_MEDIUM_FALSE@large_DEPENDENCIES =
# Test that --start-lib and --end-lib function correctly.
@GCC_TRUE@@NATIVE_LINKER_TRUE@am__append_53 = start_lib_test
+@GCC_TRUE@@HAVE_ZLIB_TRUE@@NATIVE_LINKER_TRUE@am__append_54 = gdb_index_test_2.sh
+@GCC_TRUE@@HAVE_ZLIB_TRUE@@NATIVE_LINKER_TRUE@am__append_55 = gdb_index_test_2.stdout
+@GCC_TRUE@@HAVE_ZLIB_TRUE@@NATIVE_LINKER_TRUE@am__append_56 = gdb_index_test_2.stdout gdb_index_test_2
# Test the --incremental-unchanged flag with an archive library.
# The second link should not update the library.
-@DEFAULT_TARGET_X86_64_TRUE@@GCC_TRUE@@NATIVE_LINKER_TRUE@am__append_54 = incremental_test_2 \
+@DEFAULT_TARGET_X86_64_TRUE@@GCC_TRUE@@NATIVE_LINKER_TRUE@am__append_57 = incremental_test_2 \
@DEFAULT_TARGET_X86_64_TRUE@@GCC_TRUE@@NATIVE_LINKER_TRUE@ incremental_test_3 \
@DEFAULT_TARGET_X86_64_TRUE@@GCC_TRUE@@NATIVE_LINKER_TRUE@ incremental_test_4 \
@DEFAULT_TARGET_X86_64_TRUE@@GCC_TRUE@@NATIVE_LINKER_TRUE@ incremental_test_5 \
@DEFAULT_TARGET_X86_64_TRUE@@GCC_TRUE@@NATIVE_LINKER_TRUE@ incremental_copy_test \
@DEFAULT_TARGET_X86_64_TRUE@@GCC_TRUE@@NATIVE_LINKER_TRUE@ incremental_common_test_1 \
@DEFAULT_TARGET_X86_64_TRUE@@GCC_TRUE@@NATIVE_LINKER_TRUE@ incremental_comdat_test_1
-@DEFAULT_TARGET_X86_64_TRUE@@GCC_TRUE@@NATIVE_LINKER_TRUE@am__append_55 = two_file_test_tmp_2.o \
+@DEFAULT_TARGET_X86_64_TRUE@@GCC_TRUE@@NATIVE_LINKER_TRUE@am__append_58 = two_file_test_tmp_2.o \
@DEFAULT_TARGET_X86_64_TRUE@@GCC_TRUE@@NATIVE_LINKER_TRUE@ two_file_test_tmp_3.o \
@DEFAULT_TARGET_X86_64_TRUE@@GCC_TRUE@@NATIVE_LINKER_TRUE@ incremental_test_4.base \
@DEFAULT_TARGET_X86_64_TRUE@@GCC_TRUE@@NATIVE_LINKER_TRUE@ two_file_test_tmp_4.o \
# These tests work with native and cross linkers.
# Test script section order.
-@NATIVE_OR_CROSS_LINKER_TRUE@am__append_56 = script_test_10.sh
-@NATIVE_OR_CROSS_LINKER_TRUE@am__append_57 = script_test_10.stdout
+@NATIVE_OR_CROSS_LINKER_TRUE@am__append_59 = script_test_10.sh
+@NATIVE_OR_CROSS_LINKER_TRUE@am__append_60 = script_test_10.stdout
# These tests work with cross linkers only.
-@DEFAULT_TARGET_I386_TRUE@@NATIVE_OR_CROSS_LINKER_TRUE@am__append_58 = split_i386.sh
-@DEFAULT_TARGET_I386_TRUE@@NATIVE_OR_CROSS_LINKER_TRUE@am__append_59 = split_i386_1.stdout split_i386_2.stdout \
+@DEFAULT_TARGET_I386_TRUE@@NATIVE_OR_CROSS_LINKER_TRUE@am__append_61 = split_i386.sh
+@DEFAULT_TARGET_I386_TRUE@@NATIVE_OR_CROSS_LINKER_TRUE@am__append_62 = split_i386_1.stdout split_i386_2.stdout \
@DEFAULT_TARGET_I386_TRUE@@NATIVE_OR_CROSS_LINKER_TRUE@ split_i386_3.stdout split_i386_4.stdout split_i386_r.stdout
-@DEFAULT_TARGET_I386_TRUE@@NATIVE_OR_CROSS_LINKER_TRUE@am__append_60 = split_i386_1 split_i386_2 split_i386_3 \
+@DEFAULT_TARGET_I386_TRUE@@NATIVE_OR_CROSS_LINKER_TRUE@am__append_63 = split_i386_1 split_i386_2 split_i386_3 \
@DEFAULT_TARGET_I386_TRUE@@NATIVE_OR_CROSS_LINKER_TRUE@ split_i386_4 split_i386_r
-@DEFAULT_TARGET_X86_64_TRUE@@NATIVE_OR_CROSS_LINKER_TRUE@am__append_61 = split_x86_64.sh
-@DEFAULT_TARGET_X86_64_TRUE@@NATIVE_OR_CROSS_LINKER_TRUE@am__append_62 = split_x86_64_1.stdout split_x86_64_2.stdout \
+@DEFAULT_TARGET_X86_64_TRUE@@NATIVE_OR_CROSS_LINKER_TRUE@am__append_64 = split_x86_64.sh
+@DEFAULT_TARGET_X86_64_TRUE@@NATIVE_OR_CROSS_LINKER_TRUE@am__append_65 = split_x86_64_1.stdout split_x86_64_2.stdout \
@DEFAULT_TARGET_X86_64_TRUE@@NATIVE_OR_CROSS_LINKER_TRUE@ split_x86_64_3.stdout split_x86_64_4.stdout split_x86_64_r.stdout
-@DEFAULT_TARGET_X86_64_TRUE@@NATIVE_OR_CROSS_LINKER_TRUE@am__append_63 = split_x86_64_1 split_x86_64_2 split_x86_64_3 \
+@DEFAULT_TARGET_X86_64_TRUE@@NATIVE_OR_CROSS_LINKER_TRUE@am__append_66 = split_x86_64_1 split_x86_64_2 split_x86_64_3 \
@DEFAULT_TARGET_X86_64_TRUE@@NATIVE_OR_CROSS_LINKER_TRUE@ split_x86_64_4 split_x86_64_r
# Check Thumb to Thumb farcall veneers
# Check Thumb to ARM farcall veneers
-@DEFAULT_TARGET_ARM_TRUE@@NATIVE_OR_CROSS_LINKER_TRUE@am__append_64 = arm_abs_global.sh \
+@DEFAULT_TARGET_ARM_TRUE@@NATIVE_OR_CROSS_LINKER_TRUE@am__append_67 = arm_abs_global.sh \
@DEFAULT_TARGET_ARM_TRUE@@NATIVE_OR_CROSS_LINKER_TRUE@ arm_branch_in_range.sh \
@DEFAULT_TARGET_ARM_TRUE@@NATIVE_OR_CROSS_LINKER_TRUE@ arm_branch_out_of_range.sh \
@DEFAULT_TARGET_ARM_TRUE@@NATIVE_OR_CROSS_LINKER_TRUE@ arm_fix_v4bx.sh \
@DEFAULT_TARGET_ARM_TRUE@@NATIVE_OR_CROSS_LINKER_TRUE@ arm_farcall_arm_thumb.sh \
@DEFAULT_TARGET_ARM_TRUE@@NATIVE_OR_CROSS_LINKER_TRUE@ arm_farcall_thumb_thumb.sh \
@DEFAULT_TARGET_ARM_TRUE@@NATIVE_OR_CROSS_LINKER_TRUE@ arm_farcall_thumb_arm.sh
-@DEFAULT_TARGET_ARM_TRUE@@NATIVE_OR_CROSS_LINKER_TRUE@am__append_65 = arm_abs_global.stdout \
+@DEFAULT_TARGET_ARM_TRUE@@NATIVE_OR_CROSS_LINKER_TRUE@am__append_68 = arm_abs_global.stdout \
@DEFAULT_TARGET_ARM_TRUE@@NATIVE_OR_CROSS_LINKER_TRUE@ arm_bl_in_range.stdout \
@DEFAULT_TARGET_ARM_TRUE@@NATIVE_OR_CROSS_LINKER_TRUE@ arm_bl_out_of_range.stdout \
@DEFAULT_TARGET_ARM_TRUE@@NATIVE_OR_CROSS_LINKER_TRUE@ thumb_bl_in_range.stdout \
@DEFAULT_TARGET_ARM_TRUE@@NATIVE_OR_CROSS_LINKER_TRUE@ arm_farcall_thumb_thumb_6m.stdout \
@DEFAULT_TARGET_ARM_TRUE@@NATIVE_OR_CROSS_LINKER_TRUE@ arm_farcall_thumb_arm.stdout \
@DEFAULT_TARGET_ARM_TRUE@@NATIVE_OR_CROSS_LINKER_TRUE@ arm_farcall_thumb_arm_5t.stdout
-@DEFAULT_TARGET_ARM_TRUE@@NATIVE_OR_CROSS_LINKER_TRUE@am__append_66 = arm_abs_global \
+@DEFAULT_TARGET_ARM_TRUE@@NATIVE_OR_CROSS_LINKER_TRUE@am__append_69 = arm_abs_global \
@DEFAULT_TARGET_ARM_TRUE@@NATIVE_OR_CROSS_LINKER_TRUE@ arm_bl_in_range \
@DEFAULT_TARGET_ARM_TRUE@@NATIVE_OR_CROSS_LINKER_TRUE@ arm_bl_out_of_range \
@DEFAULT_TARGET_ARM_TRUE@@NATIVE_OR_CROSS_LINKER_TRUE@ thumb_bl_in_range \
MOSTLYCLEANFILES = *.so *.syms *.stdout $(am__append_4) \
$(am__append_17) $(am__append_26) $(am__append_28) \
$(am__append_30) $(am__append_36) $(am__append_40) \
- $(am__append_55) $(am__append_60) $(am__append_63) \
- $(am__append_66)
+ $(am__append_56) $(am__append_58) $(am__append_63) \
+ $(am__append_66) $(am__append_69)
# We will add to these later, for each individual test. Note
# that we add each test under check_SCRIPTS or check_PROGRAMS;
# the TESTS variable is automatically populated from these.
check_SCRIPTS = $(am__append_2) $(am__append_34) $(am__append_38) \
- $(am__append_56) $(am__append_58) $(am__append_61) \
- $(am__append_64)
+ $(am__append_54) $(am__append_59) $(am__append_61) \
+ $(am__append_64) $(am__append_67)
check_DATA = $(am__append_3) $(am__append_27) $(am__append_29) \
- $(am__append_35) $(am__append_39) $(am__append_57) \
- $(am__append_59) $(am__append_62) $(am__append_65)
+ $(am__append_35) $(am__append_39) $(am__append_55) \
+ $(am__append_60) $(am__append_62) $(am__append_65) \
+ $(am__append_68)
BUILT_SOURCES = $(am__append_25)
TESTS = $(check_SCRIPTS) $(check_PROGRAMS)
@p='dyn_weak_ref.sh'; $(am__check_pre) $(LOG_COMPILE) "$$tst" $(am__check_post)
memory_test.sh.log: memory_test.sh
@p='memory_test.sh'; $(am__check_pre) $(LOG_COMPILE) "$$tst" $(am__check_post)
+gdb_index_test_1.sh.log: gdb_index_test_1.sh
+ @p='gdb_index_test_1.sh'; $(am__check_pre) $(LOG_COMPILE) "$$tst" $(am__check_post)
+gdb_index_test_2.sh.log: gdb_index_test_2.sh
+ @p='gdb_index_test_2.sh'; $(am__check_pre) $(LOG_COMPILE) "$$tst" $(am__check_post)
script_test_10.sh.log: script_test_10.sh
@p='script_test_10.sh'; $(am__check_pre) $(LOG_COMPILE) "$$tst" $(am__check_post)
split_i386.sh.log: split_i386.sh
@GCC_TRUE@@NATIVE_LINKER_TRUE@ $(LINK) -Bgcctestdir/ -nostartfiles -nostdlib -T $(srcdir)/memory_test.t -o $@ memory_test.o
@GCC_TRUE@@NATIVE_LINKER_TRUE@memory_test.stdout: memory_test
@GCC_TRUE@@NATIVE_LINKER_TRUE@ $(TEST_READELF) -lWS $< > $@
+@GCC_TRUE@@NATIVE_LINKER_TRUE@gdb_index_test.o: gdb_index_test.cc
+@GCC_TRUE@@NATIVE_LINKER_TRUE@ $(CXXCOMPILE) -O0 -g -c -o $@ $<
+@GCC_TRUE@@NATIVE_LINKER_TRUE@gdb_index_test_1: gdb_index_test.o gcctestdir/ld
+@GCC_TRUE@@NATIVE_LINKER_TRUE@ $(CXXLINK) -Bgcctestdir/ -Wl,--gdb-index $<
+@GCC_TRUE@@NATIVE_LINKER_TRUE@gdb_index_test_1.stdout: gdb_index_test_1
+@GCC_TRUE@@NATIVE_LINKER_TRUE@ $(TEST_READELF) --debug-dump=gdb_index $< > $@
+@GCC_TRUE@@HAVE_ZLIB_TRUE@@NATIVE_LINKER_TRUE@gdb_index_test_cdebug.o: gdb_index_test.cc
+@GCC_TRUE@@HAVE_ZLIB_TRUE@@NATIVE_LINKER_TRUE@ $(CXXCOMPILE) -Bgcctestdir/ -O0 -g -Wa,--compress-debug-sections -c -o $@ $<
+@GCC_TRUE@@HAVE_ZLIB_TRUE@@NATIVE_LINKER_TRUE@gdb_index_test_2: gdb_index_test_cdebug.o gcctestdir/ld
+@GCC_TRUE@@HAVE_ZLIB_TRUE@@NATIVE_LINKER_TRUE@ $(CXXLINK) -Bgcctestdir/ -Wl,--gdb-index $<
+@GCC_TRUE@@HAVE_ZLIB_TRUE@@NATIVE_LINKER_TRUE@gdb_index_test_2.stdout: gdb_index_test_2
+@GCC_TRUE@@HAVE_ZLIB_TRUE@@NATIVE_LINKER_TRUE@ $(TEST_READELF) --debug-dump=gdb_index $< > $@
# End-to-end incremental linking tests.
# Incremental linking is currently supported only on the x86_64 target.
--- /dev/null
+// gdb_index_test.cc -- a test case for the --gdb-index option.
+
+// Copyright 2012 Free Software Foundation, Inc.
+// Written by Cary Coutant <ccoutant@google.com>.
+
+// This file is part of gold.
+
+// This program is free software; you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation; either version 3 of the License, or
+// (at your option) any later version.
+
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+// GNU General Public License for more details.
+
+// You should have received a copy of the GNU General Public License
+// along with this program; if not, write to the Free Software
+// Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,
+// MA 02110-1301, USA.
+
+// This source file defines a number of symbols of different forms
+// to exercise the DWARF scanner in gold.
+
+namespace
+{
+int c1_count;
+int c2_count;
+};
+
+namespace one
+{
+
+enum G
+{
+ G_A,
+ G_B,
+ G_C
+};
+
+class c1
+{
+ public:
+ static int count;
+
+ c1()
+ { ++c1_count; }
+
+ ~c1()
+ {
+ --c1_count;
+ }
+
+ enum E
+ {
+ E_A,
+ E_B,
+ E_C,
+ };
+
+ int
+ val()
+ { return E_A; }
+};
+
+c1 c1v;
+};
+
+namespace two
+{
+const int ci = 3;
+
+template <typename T>
+class c2
+{
+ public:
+ c2(T t)
+ : t_(t)
+ {
+ ++c2_count;
+ }
+
+ ~c2()
+ { --c2_count; }
+
+ T
+ val()
+ { return this->t_; }
+
+ T t_;
+};
+
+c2<int> c2v1(1);
+c2<double> c2v2(2.0);
+c2<int const*> c2v3(&ci);
+};
+
+enum F
+{
+ F_A,
+ F_B,
+ F_C
+};
+
+template <class C>
+bool
+check(C* c)
+{ return c->val() == 0; }
+
+bool
+check_enum(int i)
+{ return i > 0; }
+
+struct anonymous_union_container {
+ union {
+ struct astruct {
+ int a;
+ };
+ int b;
+ } u;
+};
+
+anonymous_union_container anonymous_union_var;
+
+int
+main()
+{
+ F f = F_A;
+ one::G g = one::G_A;
+ check_enum(f);
+ check_enum(g);
+ check(&one::c1v);
+ check(&two::c2v1);
+ check(&two::c2v2);
+ check(&two::c2v3);
+ return anonymous_union_var.u.b;
+}
--- /dev/null
+#!/bin/sh
+
+# gdb_index_test_1.sh -- a test case for the --gdb-index option.
+
+# Copyright 2012 Free Software Foundation, Inc.
+# Written by Cary Coutant <ccoutant@google.com>.
+
+# This file is part of gold.
+
+# This program is free software; you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation; either version 3 of the License, or
+# (at your option) any later version.
+
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+# GNU General Public License for more details.
+
+# You should have received a copy of the GNU General Public License
+# along with this program; if not, write to the Free Software
+# Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,
+# MA 02110-1301, USA.
+
+check()
+{
+ if ! grep -q "$2" "$1"
+ then
+ echo "Did not find expected output:"
+ echo " $2"
+ echo ""
+ echo "Actual error output below:"
+ cat "$1"
+ exit 1
+ fi
+}
+
+STDOUT=gdb_index_test_1.stdout
+
+check $STDOUT "^Version [45]"
+
+# Look for the symbols we know should be in the symbol table.
+
+check $STDOUT "^\[ *[0-9]*\] (anonymous namespace): "
+check $STDOUT "^\[ *[0-9]*\] (anonymous namespace)::c1_count: "
+check $STDOUT "^\[ *[0-9]*\] (anonymous namespace)::c2_count: "
+check $STDOUT "^\[ *[0-9]*\] bool: "
+check $STDOUT "^\[ *[0-9]*\] check<one::c1>: "
+check $STDOUT "^\[ *[0-9]*\] check<two::c2<double> >: "
+check $STDOUT "^\[ *[0-9]*\] check<two::c2<int> >: "
+# check $STDOUT "^\[ *[0-9]*\] check<two::c2<int const\*> >: "
+check $STDOUT "^\[ *[0-9]*\] double: "
+check $STDOUT "^\[ *[0-9]*\] F_A: "
+check $STDOUT "^\[ *[0-9]*\] F_B: "
+check $STDOUT "^\[ *[0-9]*\] F_C: "
+check $STDOUT "^\[ *[0-9]*\] int: "
+check $STDOUT "^\[ *[0-9]*\] main: "
+check $STDOUT "^\[ *[0-9]*\] one: "
+check $STDOUT "^\[ *[0-9]*\] one::c1: "
+check $STDOUT "^\[ *[0-9]*\] one::c1::~c1: "
+check $STDOUT "^\[ *[0-9]*\] one::c1::c1: "
+check $STDOUT "^\[ *[0-9]*\] one::c1::val: "
+check $STDOUT "^\[ *[0-9]*\] one::c1v: "
+check $STDOUT "^\[ *[0-9]*\] one::G_A: "
+check $STDOUT "^\[ *[0-9]*\] one::G_B: "
+check $STDOUT "^\[ *[0-9]*\] one::G_B: "
+check $STDOUT "^\[ *[0-9]*\] two: "
+check $STDOUT "^\[ *[0-9]*\] two::c2<double>::~c2: "
+check $STDOUT "^\[ *[0-9]*\] two::c2<double>::c2: "
+check $STDOUT "^\[ *[0-9]*\] two::c2<double>::val: "
+check $STDOUT "^\[ *[0-9]*\] two::c2<double>: "
+check $STDOUT "^\[ *[0-9]*\] two::c2<int const\*>: "
+check $STDOUT "^\[ *[0-9]*\] two::c2<int const\*>::~c2: "
+check $STDOUT "^\[ *[0-9]*\] two::c2<int const\*>::c2: "
+check $STDOUT "^\[ *[0-9]*\] two::c2<int const\*>::val: "
+check $STDOUT "^\[ *[0-9]*\] two::c2<int>::~c2: "
+check $STDOUT "^\[ *[0-9]*\] two::c2<int>::c2: "
+check $STDOUT "^\[ *[0-9]*\] two::c2<int>::val: "
+check $STDOUT "^\[ *[0-9]*\] two::c2<int>: "
+check $STDOUT "^\[ *[0-9]*\] two::c2v1: "
+check $STDOUT "^\[ *[0-9]*\] two::c2v2: "
+check $STDOUT "^\[ *[0-9]*\] anonymous_union_var: "
+
+exit 0
--- /dev/null
+#!/bin/sh
+
+# gdb_index_test_2.sh -- a test case for the --gdb-index option.
+
+# Copyright 2012 Free Software Foundation, Inc.
+# Written by Cary Coutant <ccoutant@google.com>.
+
+# This file is part of gold.
+
+# This program is free software; you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation; either version 3 of the License, or
+# (at your option) any later version.
+
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+# GNU General Public License for more details.
+
+# You should have received a copy of the GNU General Public License
+# along with this program; if not, write to the Free Software
+# Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,
+# MA 02110-1301, USA.
+
+check()
+{
+ if ! grep -q "$2" "$1"
+ then
+ echo "Did not find expected output:"
+ echo " $2"
+ echo ""
+ echo "Actual error output below:"
+ cat "$1"
+ exit 1
+ fi
+}
+
+STDOUT=gdb_index_test_2.stdout
+
+check $STDOUT "^Version [45]"
+
+# Look for the symbols we know should be in the symbol table.
+
+check $STDOUT "^\[ *[0-9]*\] (anonymous namespace): "
+check $STDOUT "^\[ *[0-9]*\] (anonymous namespace)::c1_count: "
+check $STDOUT "^\[ *[0-9]*\] (anonymous namespace)::c2_count: "
+check $STDOUT "^\[ *[0-9]*\] bool: "
+check $STDOUT "^\[ *[0-9]*\] check<one::c1>: "
+check $STDOUT "^\[ *[0-9]*\] check<two::c2<double> >: "
+check $STDOUT "^\[ *[0-9]*\] check<two::c2<int> >: "
+# check $STDOUT "^\[ *[0-9]*\] check<two::c2<int const\*> >: "
+check $STDOUT "^\[ *[0-9]*\] double: "
+check $STDOUT "^\[ *[0-9]*\] F_A: "
+check $STDOUT "^\[ *[0-9]*\] F_B: "
+check $STDOUT "^\[ *[0-9]*\] F_C: "
+check $STDOUT "^\[ *[0-9]*\] int: "
+check $STDOUT "^\[ *[0-9]*\] main: "
+check $STDOUT "^\[ *[0-9]*\] one: "
+check $STDOUT "^\[ *[0-9]*\] one::c1: "
+check $STDOUT "^\[ *[0-9]*\] one::c1::~c1: "
+check $STDOUT "^\[ *[0-9]*\] one::c1::c1: "
+check $STDOUT "^\[ *[0-9]*\] one::c1::val: "
+check $STDOUT "^\[ *[0-9]*\] one::c1v: "
+check $STDOUT "^\[ *[0-9]*\] one::G_A: "
+check $STDOUT "^\[ *[0-9]*\] one::G_B: "
+check $STDOUT "^\[ *[0-9]*\] one::G_B: "
+check $STDOUT "^\[ *[0-9]*\] two: "
+check $STDOUT "^\[ *[0-9]*\] two::c2<double>::~c2: "
+check $STDOUT "^\[ *[0-9]*\] two::c2<double>::c2: "
+check $STDOUT "^\[ *[0-9]*\] two::c2<double>::val: "
+check $STDOUT "^\[ *[0-9]*\] two::c2<double>: "
+check $STDOUT "^\[ *[0-9]*\] two::c2<int const\*>: "
+check $STDOUT "^\[ *[0-9]*\] two::c2<int const\*>::~c2: "
+check $STDOUT "^\[ *[0-9]*\] two::c2<int const\*>::c2: "
+check $STDOUT "^\[ *[0-9]*\] two::c2<int const\*>::val: "
+check $STDOUT "^\[ *[0-9]*\] two::c2<int>::~c2: "
+check $STDOUT "^\[ *[0-9]*\] two::c2<int>::c2: "
+check $STDOUT "^\[ *[0-9]*\] two::c2<int>::val: "
+check $STDOUT "^\[ *[0-9]*\] two::c2<int>: "
+check $STDOUT "^\[ *[0-9]*\] two::c2v1: "
+check $STDOUT "^\[ *[0-9]*\] two::c2v2: "
+check $STDOUT "^\[ *[0-9]*\] anonymous_union_var: "
+
+exit 0
projects / deliverable / binutils-gdb.git / commitdiff
