// dwarf_reader.cc -- parse dwarf2/3 debug information
-// Copyright 2007 Free Software Foundation, Inc.
+// Copyright 2007, 2008 Free Software Foundation, Inc.
// Written by Ian Lance Taylor <iant@google.com>.
// This file is part of gold.
#include "gold.h"
+#include <algorithm>
+#include <vector>
+
#include "elfcpp_swap.h"
#include "dwarf.h"
#include "object.h"
#include "reloc.h"
#include "dwarf_reader.h"
-namespace {
+namespace gold {
// Read an unsigned LEB128 number. Each byte contains 7 bits of
// information, plus one bit saying whether the number continues or
do
{
+ if (num_read >= 64 / 7)
+ {
+ gold_warning(_("Unusually large LEB128 decoded, "
+ "debug information may be corrupted"));
+ break;
+ }
byte = *buffer++;
num_read++;
result |= (static_cast<uint64_t>(byte & 0x7f)) << shift;
do
{
+ if (num_read >= 64 / 7)
+ {
+ gold_warning(_("Unusually large LEB128 decoded, "
+ "debug information may be corrupted"));
+ break;
+ }
byte = *buffer++;
num_read++;
result |= (static_cast<uint64_t>(byte & 0x7f) << shift);
return result;
}
-} // End anonymous namespace.
-
-
-namespace gold {
-
// This is the format of a DWARF2/3 line state machine that we process
// opcodes using. There is no need for anything outside the lineinfo
// processor to know how this works.
// Now that we have successfully read all the data, parse the debug
// info.
this->data_valid_ = true;
- this->read_line_mappings(read_shndx);
+ this->read_line_mappings(object, read_shndx);
}
// Read the DWARF header.
Sized_dwarf_line_info<size, big_endian>::read_header_prolog(
const unsigned char* lineptr)
{
- uint32_t initial_length = elfcpp::Swap<32, big_endian>::readval(lineptr);
+ uint32_t initial_length = elfcpp::Swap_unaligned<32, big_endian>::readval(lineptr);
lineptr += 4;
// In DWARF2/3, if the initial length is all 1 bits, then the offset
if (initial_length == 0xffffffff)
{
header_.offset_size = 8;
- initial_length = elfcpp::Swap<64, big_endian>::readval(lineptr);
+ initial_length = elfcpp::Swap_unaligned<64, big_endian>::readval(lineptr);
lineptr += 8;
}
else
gold_assert(lineptr + header_.total_length <= buffer_end_);
- header_.version = elfcpp::Swap<16, big_endian>::readval(lineptr);
+ header_.version = elfcpp::Swap_unaligned<16, big_endian>::readval(lineptr);
lineptr += 2;
if (header_.offset_size == 4)
- header_.prologue_length = elfcpp::Swap<32, big_endian>::readval(lineptr);
+ header_.prologue_length = elfcpp::Swap_unaligned<32, big_endian>::readval(lineptr);
else
- header_.prologue_length = elfcpp::Swap<64, big_endian>::readval(lineptr);
+ header_.prologue_length = elfcpp::Swap_unaligned<64, big_endian>::readval(lineptr);
lineptr += header_.offset_size;
header_.min_insn_length = *lineptr;
case elfcpp::DW_LNS_fixed_advance_pc:
{
int advance_address;
- advance_address = elfcpp::Swap<16, big_endian>::readval(start);
+ advance_address = elfcpp::Swap_unaligned<16, big_endian>::readval(start);
oplen += 2;
lsm->address += advance_address;
}
case elfcpp::DW_LNE_set_address:
{
- lsm->address = elfcpp::Swap<size, big_endian>::readval(start);
+ lsm->address = elfcpp::Swap_unaligned<size, big_endian>::readval(start);
typename Reloc_map::const_iterator it
= reloc_map_.find(start - this->buffer_);
if (it != reloc_map_.end())
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)
+ 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 elfsym.get_st_shndx();
+ 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()
+Sized_dwarf_line_info<size, big_endian>::read_relocs(Object* object)
{
if (this->symtab_buffer_ == NULL)
return;
while ((reloc_offset = this->track_relocs_.next_offset()) != -1)
{
const unsigned int sym = this->track_relocs_.next_symndx();
- const unsigned int shndx = this->symbol_section(sym, &value);
- this->reloc_map_[reloc_offset] = std::make_pair(shndx, value);
+
+ bool is_ordinary;
+ const unsigned int shndx = this->symbol_section(object, sym, &value,
+ &is_ordinary);
+
+ // 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)
+ this->reloc_map_[reloc_offset] = std::make_pair(shndx, value);
+
this->track_relocs_.advance(reloc_offset + 1);
}
}
template<int size, bool big_endian>
void
-Sized_dwarf_line_info<size, big_endian>::read_line_mappings(off_t shndx)
+Sized_dwarf_line_info<size, big_endian>::read_line_mappings(Object* object,
+ off_t shndx)
{
gold_assert(this->data_valid_ == true);
- read_relocs();
+ this->read_relocs(object);
while (this->buffer_ < this->buffer_end_)
{
const unsigned char* lineptr = this->buffer_;
// Dwarf_line_info routines.
+static unsigned int next_generation_count = 0;
+
+struct Addr2line_cache_entry
+{
+ Object* object;
+ unsigned int shndx;
+ Dwarf_line_info* dwarf_line_info;
+ unsigned int generation_count;
+ unsigned int access_count;
+
+ Addr2line_cache_entry(Object* o, unsigned int s, Dwarf_line_info* d)
+ : object(o), shndx(s), dwarf_line_info(d),
+ generation_count(next_generation_count), access_count(0)
+ {
+ if (next_generation_count < (1U << 31))
+ ++next_generation_count;
+ }
+};
+// We expect this cache to be small, so don't bother with a hashtable
+// or priority queue or anything: just use a simple vector.
+static std::vector<Addr2line_cache_entry> addr2line_cache;
+
std::string
Dwarf_line_info::one_addr2line(Object* object,
- unsigned int shndx, off_t offset)
+ unsigned int shndx, off_t offset,
+ size_t cache_size)
{
- if (parameters->get_size() == 32 && !parameters->is_big_endian())
+ Dwarf_line_info* lineinfo = NULL;
+ std::vector<Addr2line_cache_entry>::iterator it;
+
+ // First, check the cache. If we hit, update the counts.
+ for (it = addr2line_cache.begin(); it != addr2line_cache.end(); ++it)
+ {
+ if (it->object == object && it->shndx == shndx)
+ {
+ lineinfo = it->dwarf_line_info;
+ it->generation_count = next_generation_count;
+ // We cap generation_count at 2^31 -1 to avoid overflow.
+ if (next_generation_count < (1U << 31))
+ ++next_generation_count;
+ // We cap access_count at 31 so 2^access_count doesn't overflow
+ if (it->access_count < 31)
+ ++it->access_count;
+ break;
+ }
+ }
+
+ // If we don't hit the cache, create a new object and insert into the
+ // cache.
+ if (lineinfo == NULL)
+ {
+ switch (parameters->size_and_endianness())
+ {
#ifdef HAVE_TARGET_32_LITTLE
- return Sized_dwarf_line_info<32, false>(object, shndx).addr2line(shndx,
- offset);
-#else
- gold_unreachable();
+ case Parameters::TARGET_32_LITTLE:
+ lineinfo = new Sized_dwarf_line_info<32, false>(object, shndx); break;
#endif
- else if (parameters->get_size() == 32 && parameters->is_big_endian())
#ifdef HAVE_TARGET_32_BIG
- return Sized_dwarf_line_info<32, true>(object, shndx).addr2line(shndx,
- offset);
-#else
- gold_unreachable();
+ case Parameters::TARGET_32_BIG:
+ lineinfo = new Sized_dwarf_line_info<32, true>(object, shndx); break;
#endif
- else if (parameters->get_size() == 64 && !parameters->is_big_endian())
#ifdef HAVE_TARGET_64_LITTLE
- return Sized_dwarf_line_info<64, false>(object, shndx).addr2line(shndx,
- offset);
-#else
- gold_unreachable();
+ case Parameters::TARGET_64_LITTLE:
+ lineinfo = new Sized_dwarf_line_info<64, false>(object, shndx); break;
#endif
- else if (parameters->get_size() == 64 && parameters->is_big_endian())
-#ifdef HAVE_TARGET_64_BIT
- return Sized_dwarf_line_info<64, true>(object, shndx).addr2line(shndx,
- offset);
-#else
- gold_unreachable();
+#ifdef HAVE_TARGET_64_BIG
+ case Parameters::TARGET_64_BIG:
+ lineinfo = new Sized_dwarf_line_info<64, true>(object, shndx); break;
#endif
- else
- gold_unreachable();
+ default:
+ gold_unreachable();
+ }
+ addr2line_cache.push_back(Addr2line_cache_entry(object, shndx, lineinfo));
+ }
+
+ // Now that we have our object, figure out the answer
+ std::string retval = lineinfo->addr2line(shndx, offset);
+
+ // Finally, if our cache has grown too big, delete old objects. We
+ // assume the common (probably only) case is deleting only one object.
+ // We use a pretty simple scheme to evict: function of LRU and MFU.
+ while (addr2line_cache.size() > cache_size)
+ {
+ unsigned int lowest_score = ~0U;
+ std::vector<Addr2line_cache_entry>::iterator lowest
+ = addr2line_cache.end();
+ for (it = addr2line_cache.begin(); it != addr2line_cache.end(); ++it)
+ {
+ const unsigned int score = (it->generation_count
+ + (1U << it->access_count));
+ if (score < lowest_score)
+ {
+ lowest_score = score;
+ lowest = it;
+ }
+ }
+ if (lowest != addr2line_cache.end())
+ {
+ delete lowest->dwarf_line_info;
+ addr2line_cache.erase(lowest);
+ }
+ }
+
+ return retval;
+}
+
+void
+Dwarf_line_info::clear_addr2line_cache()
+{
+ for (std::vector<Addr2line_cache_entry>::iterator it = addr2line_cache.begin();
+ it != addr2line_cache.end();
+ ++it)
+ delete it->dwarf_line_info;
+ addr2line_cache.clear();
}
#ifdef HAVE_TARGET_32_LITTLE
projects / deliverable / binutils-gdb.git / blobdiff