// dwarf_reader.cc -- parse dwarf2/3 debug information
-// Copyright 2007, 2008 Free Software Foundation, Inc.
+// Copyright 2007, 2008, 2009 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 "parameters.h"
#include "reloc.h"
#include "dwarf_reader.h"
-
-namespace {
-
-// Read an unsigned LEB128 number. Each byte contains 7 bits of
-// information, plus one bit saying whether the number continues or
-// not.
-
-uint64_t
-read_unsigned_LEB_128(const unsigned char* buffer, size_t* len)
-{
- uint64_t result = 0;
- size_t num_read = 0;
- unsigned int shift = 0;
- unsigned char byte;
-
- do
- {
- byte = *buffer++;
- num_read++;
- result |= (static_cast<uint64_t>(byte & 0x7f)) << shift;
- shift += 7;
- }
- while (byte & 0x80);
-
- *len = num_read;
-
- return result;
-}
-
-// Read a signed LEB128 number. These are like regular LEB128
-// numbers, except the last byte may have a sign bit set.
-
-int64_t
-read_signed_LEB_128(const unsigned char* buffer, size_t* len)
-{
- int64_t result = 0;
- int shift = 0;
- size_t num_read = 0;
- unsigned char byte;
-
- do
- {
- byte = *buffer++;
- num_read++;
- result |= (static_cast<uint64_t>(byte & 0x7f) << shift);
- shift += 7;
- }
- while (byte & 0x80);
-
- if ((shift < 8 * static_cast<int>(sizeof(result))) && (byte & 0x40))
- result |= -((static_cast<int64_t>(1)) << shift);
- *len = num_read;
- return result;
-}
-
-} // End anonymous namespace.
-
+#include "int_encoding.h"
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.
-
struct LineStateMachine
{
int file_num;
template<int size, bool big_endian>
Sized_dwarf_line_info<size, big_endian>::Sized_dwarf_line_info(Object* object,
- off_t read_shndx)
+ unsigned int read_shndx)
: data_valid_(false), buffer_(NULL), symtab_buffer_(NULL),
directories_(), files_(), current_header_index_(-1)
{
template<int size, bool big_endian>
unsigned const char*
Sized_dwarf_line_info<size, big_endian>::read_lines(unsigned const char* lineptr,
- off_t shndx)
+ unsigned int shndx)
{
struct LineStateMachine lsm;
template<int size, bool big_endian>
void
Sized_dwarf_line_info<size, big_endian>::read_line_mappings(Object* object,
- off_t shndx)
+ unsigned int shndx)
{
gold_assert(this->data_valid_ == true);
// 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)
{
- switch (parameters->size_and_endianness())
+ 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
- case Parameters::TARGET_32_LITTLE:
- return Sized_dwarf_line_info<32, false>(object, shndx).addr2line(shndx,
- offset);
+ case Parameters::TARGET_32_LITTLE:
+ lineinfo = new Sized_dwarf_line_info<32, false>(object, shndx); break;
#endif
#ifdef HAVE_TARGET_32_BIG
- case Parameters::TARGET_32_BIG:
- return Sized_dwarf_line_info<32, true>(object, shndx).addr2line(shndx,
- offset);
+ case Parameters::TARGET_32_BIG:
+ lineinfo = new Sized_dwarf_line_info<32, true>(object, shndx); break;
#endif
#ifdef HAVE_TARGET_64_LITTLE
- case Parameters::TARGET_64_LITTLE:
- return Sized_dwarf_line_info<64, false>(object, shndx).addr2line(shndx,
- offset);
+ case Parameters::TARGET_64_LITTLE:
+ lineinfo = new Sized_dwarf_line_info<64, false>(object, shndx); break;
#endif
#ifdef HAVE_TARGET_64_BIG
- case Parameters::TARGET_64_BIG:
- return Sized_dwarf_line_info<64, true>(object, shndx).addr2line(shndx,
- offset);
+ case Parameters::TARGET_64_BIG:
+ lineinfo = new Sized_dwarf_line_info<64, true>(object, shndx); break;
#endif
- default:
- 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 / binutils-gdb.git / blobdiff