DWARFDebugArangeSet.cpp [plain text]
#include "DWARFDebugArangeSet.h"
#include "llvm/Support/Format.h"
#include "llvm/Support/raw_ostream.h"
#include <algorithm>
#include <cassert>
using namespace llvm;
void DWARFDebugArangeSet::clear() {
Offset = -1U;
std::memset(&Header, 0, sizeof(Header));
ArangeDescriptors.clear();
}
void DWARFDebugArangeSet::compact() {
if (ArangeDescriptors.empty())
return;
uint32_t i = 0;
while (i + 1 < ArangeDescriptors.size()) {
if (ArangeDescriptors[i].getEndAddress() >= ArangeDescriptors[i+1].Address){
const uint64_t max_end_addr =
std::max(ArangeDescriptors[i].getEndAddress(),
ArangeDescriptors[i+1].getEndAddress());
ArangeDescriptors[i].Length = max_end_addr - ArangeDescriptors[i].Address;
ArangeDescriptors.erase(ArangeDescriptors.begin()+i+1);
} else {
++i;
}
}
}
bool
DWARFDebugArangeSet::extract(DataExtractor data, uint32_t *offset_ptr) {
if (data.isValidOffset(*offset_ptr)) {
ArangeDescriptors.clear();
Offset = *offset_ptr;
Header.Length = data.getU32(offset_ptr);
Header.Version = data.getU16(offset_ptr);
Header.CuOffset = data.getU32(offset_ptr);
Header.AddrSize = data.getU8(offset_ptr);
Header.SegSize = data.getU8(offset_ptr);
if (!data.isValidOffsetForDataOfSize(Offset, Header.Length) ||
(Header.AddrSize != 4 && Header.AddrSize != 8)) {
clear();
return false;
}
const uint32_t header_size = *offset_ptr - Offset;
const uint32_t tuple_size = Header.AddrSize * 2;
uint32_t first_tuple_offset = 0;
while (first_tuple_offset < header_size)
first_tuple_offset += tuple_size;
*offset_ptr = Offset + first_tuple_offset;
Descriptor arangeDescriptor;
assert(sizeof(arangeDescriptor.Address) == sizeof(arangeDescriptor.Length));
assert(sizeof(arangeDescriptor.Address) >= Header.AddrSize);
while (data.isValidOffset(*offset_ptr)) {
arangeDescriptor.Address = data.getUnsigned(offset_ptr, Header.AddrSize);
arangeDescriptor.Length = data.getUnsigned(offset_ptr, Header.AddrSize);
if (arangeDescriptor.Address || arangeDescriptor.Length)
ArangeDescriptors.push_back(arangeDescriptor);
else
break; }
return !ArangeDescriptors.empty();
}
return false;
}
void DWARFDebugArangeSet::dump(raw_ostream &OS) const {
OS << format("Address Range Header: length = 0x%8.8x, version = 0x%4.4x, ",
Header.Length, Header.Version)
<< format("cu_offset = 0x%8.8x, addr_size = 0x%2.2x, seg_size = 0x%2.2x\n",
Header.CuOffset, Header.AddrSize, Header.SegSize);
const uint32_t hex_width = Header.AddrSize * 2;
for (DescriptorConstIter pos = ArangeDescriptors.begin(),
end = ArangeDescriptors.end(); pos != end; ++pos)
OS << format("[0x%*.*" PRIx64 " -", hex_width, hex_width, pos->Address)
<< format(" 0x%*.*" PRIx64 ")\n",
hex_width, hex_width, pos->getEndAddress());
}
namespace {
class DescriptorContainsAddress {
const uint64_t Address;
public:
DescriptorContainsAddress(uint64_t address) : Address(address) {}
bool operator()(const DWARFDebugArangeSet::Descriptor &desc) const {
return Address >= desc.Address && Address < (desc.Address + desc.Length);
}
};
}
uint32_t DWARFDebugArangeSet::findAddress(uint64_t address) const {
DescriptorConstIter end = ArangeDescriptors.end();
DescriptorConstIter pos =
std::find_if(ArangeDescriptors.begin(), end, DescriptorContainsAddress(address)); if (pos != end)
return Header.CuOffset;
return -1U;
}