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.

1 files changed, 813 insertions, 15 deletions

diff --git a/gold/dwarf_reader.h b/gold/dwarf_reader.h
index 722ee64..0c3dab6 100644
--- a/gold/dwarf_reader.h
+++ b/gold/dwarf_reader.h
@@ -1,6 +1,6 @@
 // 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.
@@ -26,6 +26,7 @@
 #include <vector>
 #include <map>
 #include <limits.h>
+#include <sys/types.h>
 
 #include "elfcpp.h"
 #include "elfcpp_swap.h"
@@ -35,10 +36,815 @@
 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
@@ -140,18 +946,12 @@ class Sized_dwarf_line_info : public Dwarf_line_info
   // 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.
@@ -212,7 +1012,7 @@ class Sized_dwarf_line_info : public Dwarf_line_info
   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_;
 
@@ -232,9 +1032,7 @@ class Sized_dwarf_line_info : public Dwarf_line_info
 
   // 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_;