mirror of
https://github.com/c64scene-ar/llvm-6502.git
synced 2024-09-04 09:30:13 +00:00
Summary: 1) Make llvm-symbolizer properly symbolize files with split debug info (by using stanalone .dwo files). 2) Make DWARFCompileUnit parse and store corresponding .dwo file, if necessary. 3) Make bits of DWARF parsing more CompileUnit-oriented. Reviewers: echristo Reviewed By: echristo CC: bkramer, llvm-commits Differential Revision: http://llvm-reviews.chandlerc.com/D1164 git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@189329 91177308-0d34-0410-b5e6-96231b3b80d8
231 lines
7.5 KiB
C++
231 lines
7.5 KiB
C++
//===-- DWARFDebugAranges.cpp -----------------------------------*- C++ -*-===//
|
|
//
|
|
// The LLVM Compiler Infrastructure
|
|
//
|
|
// This file is distributed under the University of Illinois Open Source
|
|
// License. See LICENSE.TXT for details.
|
|
//
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
#include "DWARFDebugAranges.h"
|
|
#include "DWARFCompileUnit.h"
|
|
#include "DWARFContext.h"
|
|
#include "llvm/Support/Format.h"
|
|
#include "llvm/Support/raw_ostream.h"
|
|
#include <algorithm>
|
|
#include <cassert>
|
|
using namespace llvm;
|
|
|
|
// Compare function DWARFDebugAranges::Range structures
|
|
static bool RangeLessThan(const DWARFDebugAranges::Range &range1,
|
|
const DWARFDebugAranges::Range &range2) {
|
|
return range1.LoPC < range2.LoPC;
|
|
}
|
|
|
|
namespace {
|
|
class CountArangeDescriptors {
|
|
public:
|
|
CountArangeDescriptors(uint32_t &count_ref) : Count(count_ref) {}
|
|
void operator()(const DWARFDebugArangeSet &Set) {
|
|
Count += Set.getNumDescriptors();
|
|
}
|
|
uint32_t &Count;
|
|
};
|
|
|
|
class AddArangeDescriptors {
|
|
public:
|
|
AddArangeDescriptors(DWARFDebugAranges::RangeColl &Ranges,
|
|
DWARFDebugAranges::ParsedCUOffsetColl &CUOffsets)
|
|
: RangeCollection(Ranges),
|
|
CUOffsetCollection(CUOffsets) {}
|
|
void operator()(const DWARFDebugArangeSet &Set) {
|
|
DWARFDebugAranges::Range Range;
|
|
Range.Offset = Set.getCompileUnitDIEOffset();
|
|
CUOffsetCollection.insert(Range.Offset);
|
|
|
|
for (uint32_t i = 0, n = Set.getNumDescriptors(); i < n; ++i) {
|
|
const DWARFDebugArangeSet::Descriptor *ArangeDescPtr =
|
|
Set.getDescriptor(i);
|
|
Range.LoPC = ArangeDescPtr->Address;
|
|
Range.Length = ArangeDescPtr->Length;
|
|
|
|
// Insert each item in increasing address order so binary searching
|
|
// can later be done!
|
|
DWARFDebugAranges::RangeColl::iterator InsertPos =
|
|
std::lower_bound(RangeCollection.begin(), RangeCollection.end(),
|
|
Range, RangeLessThan);
|
|
RangeCollection.insert(InsertPos, Range);
|
|
}
|
|
|
|
}
|
|
DWARFDebugAranges::RangeColl &RangeCollection;
|
|
DWARFDebugAranges::ParsedCUOffsetColl &CUOffsetCollection;
|
|
};
|
|
}
|
|
|
|
bool DWARFDebugAranges::extract(DataExtractor debug_aranges_data) {
|
|
if (debug_aranges_data.isValidOffset(0)) {
|
|
uint32_t offset = 0;
|
|
|
|
typedef std::vector<DWARFDebugArangeSet> SetCollection;
|
|
SetCollection sets;
|
|
|
|
DWARFDebugArangeSet set;
|
|
Range range;
|
|
while (set.extract(debug_aranges_data, &offset))
|
|
sets.push_back(set);
|
|
|
|
uint32_t count = 0;
|
|
|
|
std::for_each(sets.begin(), sets.end(), CountArangeDescriptors(count));
|
|
|
|
if (count > 0) {
|
|
Aranges.reserve(count);
|
|
AddArangeDescriptors range_adder(Aranges, ParsedCUOffsets);
|
|
std::for_each(sets.begin(), sets.end(), range_adder);
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
|
|
bool DWARFDebugAranges::generate(DWARFContext *ctx) {
|
|
if (ctx) {
|
|
const uint32_t num_compile_units = ctx->getNumCompileUnits();
|
|
for (uint32_t cu_idx = 0; cu_idx < num_compile_units; ++cu_idx) {
|
|
if (DWARFCompileUnit *cu = ctx->getCompileUnitAtIndex(cu_idx)) {
|
|
uint32_t CUOffset = cu->getOffset();
|
|
if (ParsedCUOffsets.insert(CUOffset).second)
|
|
cu->buildAddressRangeTable(this, true, CUOffset);
|
|
}
|
|
}
|
|
}
|
|
sort(true, /* overlap size */ 0);
|
|
return !isEmpty();
|
|
}
|
|
|
|
void DWARFDebugAranges::dump(raw_ostream &OS) const {
|
|
const uint32_t num_ranges = getNumRanges();
|
|
for (uint32_t i = 0; i < num_ranges; ++i) {
|
|
const Range &range = Aranges[i];
|
|
OS << format("0x%8.8x: [0x%8.8" PRIx64 " - 0x%8.8" PRIx64 ")\n",
|
|
range.Offset, (uint64_t)range.LoPC, (uint64_t)range.HiPC());
|
|
}
|
|
}
|
|
|
|
void DWARFDebugAranges::Range::dump(raw_ostream &OS) const {
|
|
OS << format("{0x%8.8x}: [0x%8.8" PRIx64 " - 0x%8.8" PRIx64 ")\n",
|
|
Offset, LoPC, HiPC());
|
|
}
|
|
|
|
void DWARFDebugAranges::appendRange(uint32_t offset, uint64_t low_pc,
|
|
uint64_t high_pc) {
|
|
if (!Aranges.empty()) {
|
|
if (Aranges.back().Offset == offset && Aranges.back().HiPC() == low_pc) {
|
|
Aranges.back().setHiPC(high_pc);
|
|
return;
|
|
}
|
|
}
|
|
Aranges.push_back(Range(low_pc, high_pc, offset));
|
|
}
|
|
|
|
void DWARFDebugAranges::sort(bool minimize, uint32_t n) {
|
|
const size_t orig_arange_size = Aranges.size();
|
|
// Size of one? If so, no sorting is needed
|
|
if (orig_arange_size <= 1)
|
|
return;
|
|
// Sort our address range entries
|
|
std::stable_sort(Aranges.begin(), Aranges.end(), RangeLessThan);
|
|
|
|
if (!minimize)
|
|
return;
|
|
|
|
// Most address ranges are contiguous from function to function
|
|
// so our new ranges will likely be smaller. We calculate the size
|
|
// of the new ranges since although std::vector objects can be resized,
|
|
// the will never reduce their allocated block size and free any excesss
|
|
// memory, so we might as well start a brand new collection so it is as
|
|
// small as possible.
|
|
|
|
// First calculate the size of the new minimal arange vector
|
|
// so we don't have to do a bunch of re-allocations as we
|
|
// copy the new minimal stuff over to the new collection.
|
|
size_t minimal_size = 1;
|
|
for (size_t i = 1; i < orig_arange_size; ++i) {
|
|
if (!Range::SortedOverlapCheck(Aranges[i-1], Aranges[i], n))
|
|
++minimal_size;
|
|
}
|
|
|
|
// If the sizes are the same, then no consecutive aranges can be
|
|
// combined, we are done.
|
|
if (minimal_size == orig_arange_size)
|
|
return;
|
|
|
|
// Else, make a new RangeColl that _only_ contains what we need.
|
|
RangeColl minimal_aranges;
|
|
minimal_aranges.resize(minimal_size);
|
|
uint32_t j = 0;
|
|
minimal_aranges[j] = Aranges[0];
|
|
for (size_t i = 1; i < orig_arange_size; ++i) {
|
|
if(Range::SortedOverlapCheck (minimal_aranges[j], Aranges[i], n)) {
|
|
minimal_aranges[j].setHiPC (Aranges[i].HiPC());
|
|
} else {
|
|
// Only increment j if we aren't merging
|
|
minimal_aranges[++j] = Aranges[i];
|
|
}
|
|
}
|
|
assert (j+1 == minimal_size);
|
|
|
|
// Now swap our new minimal aranges into place. The local
|
|
// minimal_aranges will then contian the old big collection
|
|
// which will get freed.
|
|
minimal_aranges.swap(Aranges);
|
|
}
|
|
|
|
uint32_t DWARFDebugAranges::findAddress(uint64_t address) const {
|
|
if (!Aranges.empty()) {
|
|
Range range(address);
|
|
RangeCollIterator begin = Aranges.begin();
|
|
RangeCollIterator end = Aranges.end();
|
|
RangeCollIterator pos = std::lower_bound(begin, end, range, RangeLessThan);
|
|
|
|
if (pos != end && pos->LoPC <= address && address < pos->HiPC()) {
|
|
return pos->Offset;
|
|
} else if (pos != begin) {
|
|
--pos;
|
|
if (pos->LoPC <= address && address < pos->HiPC())
|
|
return (*pos).Offset;
|
|
}
|
|
}
|
|
return -1U;
|
|
}
|
|
|
|
bool
|
|
DWARFDebugAranges::allRangesAreContiguous(uint64_t &LoPC, uint64_t &HiPC) const{
|
|
if (Aranges.empty())
|
|
return false;
|
|
|
|
uint64_t next_addr = 0;
|
|
RangeCollIterator begin = Aranges.begin();
|
|
for (RangeCollIterator pos = begin, end = Aranges.end(); pos != end;
|
|
++pos) {
|
|
if (pos != begin && pos->LoPC != next_addr)
|
|
return false;
|
|
next_addr = pos->HiPC();
|
|
}
|
|
// We checked for empty at the start of function so front() will be valid.
|
|
LoPC = Aranges.front().LoPC;
|
|
// We checked for empty at the start of function so back() will be valid.
|
|
HiPC = Aranges.back().HiPC();
|
|
return true;
|
|
}
|
|
|
|
bool DWARFDebugAranges::getMaxRange(uint64_t &LoPC, uint64_t &HiPC) const {
|
|
if (Aranges.empty())
|
|
return false;
|
|
// We checked for empty at the start of function so front() will be valid.
|
|
LoPC = Aranges.front().LoPC;
|
|
// We checked for empty at the start of function so back() will be valid.
|
|
HiPC = Aranges.back().HiPC();
|
|
return true;
|
|
}
|