2011-09-13 19:42:23 +00:00
|
|
|
//===-- DWARFContext.cpp --------------------------------------------------===//
|
|
|
|
//
|
|
|
|
// The LLVM Compiler Infrastructure
|
|
|
|
//
|
|
|
|
// This file is distributed under the University of Illinois Open Source
|
|
|
|
// License. See LICENSE.TXT for details.
|
|
|
|
//
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
|
|
|
|
#include "DWARFContext.h"
|
2012-07-19 07:03:58 +00:00
|
|
|
#include "llvm/ADT/SmallString.h"
|
2011-09-15 18:02:20 +00:00
|
|
|
#include "llvm/Support/Dwarf.h"
|
2011-09-15 16:57:13 +00:00
|
|
|
#include "llvm/Support/Format.h"
|
2012-07-19 07:03:58 +00:00
|
|
|
#include "llvm/Support/Path.h"
|
2011-09-14 01:09:52 +00:00
|
|
|
#include "llvm/Support/raw_ostream.h"
|
2011-09-15 20:43:22 +00:00
|
|
|
#include <algorithm>
|
2011-09-13 19:42:23 +00:00
|
|
|
using namespace llvm;
|
2011-09-15 18:02:20 +00:00
|
|
|
using namespace dwarf;
|
2011-09-13 19:42:23 +00:00
|
|
|
|
|
|
|
void DWARFContext::dump(raw_ostream &OS) {
|
2011-09-14 01:09:52 +00:00
|
|
|
OS << ".debug_abbrev contents:\n";
|
2011-09-13 19:42:23 +00:00
|
|
|
getDebugAbbrev()->dump(OS);
|
2011-09-14 01:09:52 +00:00
|
|
|
|
|
|
|
OS << "\n.debug_info contents:\n";
|
2011-09-13 19:42:23 +00:00
|
|
|
for (unsigned i = 0, e = getNumCompileUnits(); i != e; ++i)
|
|
|
|
getCompileUnitAtIndex(i)->dump(OS);
|
2011-09-14 01:09:52 +00:00
|
|
|
|
|
|
|
OS << "\n.debug_aranges contents:\n";
|
|
|
|
DataExtractor arangesData(getARangeSection(), isLittleEndian(), 0);
|
|
|
|
uint32_t offset = 0;
|
|
|
|
DWARFDebugArangeSet set;
|
|
|
|
while (set.extract(arangesData, &offset))
|
|
|
|
set.dump(OS);
|
2011-09-15 02:12:05 +00:00
|
|
|
|
2012-08-27 07:17:47 +00:00
|
|
|
uint8_t savedAddressByteSize = 0;
|
2011-09-15 02:12:05 +00:00
|
|
|
OS << "\n.debug_lines contents:\n";
|
2011-09-15 18:02:20 +00:00
|
|
|
for (unsigned i = 0, e = getNumCompileUnits(); i != e; ++i) {
|
|
|
|
DWARFCompileUnit *cu = getCompileUnitAtIndex(i);
|
2012-08-27 07:17:47 +00:00
|
|
|
savedAddressByteSize = cu->getAddressByteSize();
|
2011-09-15 18:02:20 +00:00
|
|
|
unsigned stmtOffset =
|
|
|
|
cu->getCompileUnitDIE()->getAttributeValueAsUnsigned(cu, DW_AT_stmt_list,
|
|
|
|
-1U);
|
|
|
|
if (stmtOffset != -1U) {
|
|
|
|
DataExtractor lineData(getLineSection(), isLittleEndian(),
|
2012-08-27 07:17:47 +00:00
|
|
|
savedAddressByteSize);
|
2011-09-15 18:02:20 +00:00
|
|
|
DWARFDebugLine::DumpingState state(OS);
|
|
|
|
DWARFDebugLine::parseStatementTable(lineData, &stmtOffset, state);
|
|
|
|
}
|
|
|
|
}
|
2011-09-15 16:57:13 +00:00
|
|
|
|
|
|
|
OS << "\n.debug_str contents:\n";
|
|
|
|
DataExtractor strData(getStringSection(), isLittleEndian(), 0);
|
|
|
|
offset = 0;
|
|
|
|
uint32_t lastOffset = 0;
|
|
|
|
while (const char *s = strData.getCStr(&offset)) {
|
|
|
|
OS << format("0x%8.8x: \"%s\"\n", lastOffset, s);
|
|
|
|
lastOffset = offset;
|
|
|
|
}
|
2012-08-27 07:17:47 +00:00
|
|
|
|
|
|
|
OS << "\n.debug_ranges contents:\n";
|
|
|
|
// In fact, different compile units may have different address byte
|
|
|
|
// sizes, but for simplicity we just use the address byte size of the last
|
|
|
|
// compile unit (there is no easy and fast way to associate address range
|
|
|
|
// list and the compile unit it describes).
|
|
|
|
DataExtractor rangesData(getRangeSection(), isLittleEndian(),
|
|
|
|
savedAddressByteSize);
|
|
|
|
offset = 0;
|
|
|
|
DWARFDebugRangeList rangeList;
|
|
|
|
while (rangeList.extract(rangesData, &offset))
|
|
|
|
rangeList.dump(OS);
|
2011-09-13 19:42:23 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
const DWARFDebugAbbrev *DWARFContext::getDebugAbbrev() {
|
|
|
|
if (Abbrev)
|
|
|
|
return Abbrev.get();
|
|
|
|
|
|
|
|
DataExtractor abbrData(getAbbrevSection(), isLittleEndian(), 0);
|
|
|
|
|
|
|
|
Abbrev.reset(new DWARFDebugAbbrev());
|
|
|
|
Abbrev->parse(abbrData);
|
|
|
|
return Abbrev.get();
|
|
|
|
}
|
|
|
|
|
2011-09-14 01:09:52 +00:00
|
|
|
const DWARFDebugAranges *DWARFContext::getDebugAranges() {
|
|
|
|
if (Aranges)
|
|
|
|
return Aranges.get();
|
|
|
|
|
|
|
|
DataExtractor arangesData(getARangeSection(), isLittleEndian(), 0);
|
|
|
|
|
|
|
|
Aranges.reset(new DWARFDebugAranges());
|
|
|
|
Aranges->extract(arangesData);
|
2011-09-14 20:52:27 +00:00
|
|
|
if (Aranges->isEmpty()) // No aranges in file, generate them from the DIEs.
|
|
|
|
Aranges->generate(this);
|
2011-09-14 01:09:52 +00:00
|
|
|
return Aranges.get();
|
|
|
|
}
|
|
|
|
|
2011-09-15 20:43:18 +00:00
|
|
|
const DWARFDebugLine::LineTable *
|
|
|
|
DWARFContext::getLineTableForCompileUnit(DWARFCompileUnit *cu) {
|
|
|
|
if (!Line)
|
|
|
|
Line.reset(new DWARFDebugLine());
|
|
|
|
|
|
|
|
unsigned stmtOffset =
|
|
|
|
cu->getCompileUnitDIE()->getAttributeValueAsUnsigned(cu, DW_AT_stmt_list,
|
|
|
|
-1U);
|
|
|
|
if (stmtOffset == -1U)
|
|
|
|
return 0; // No line table for this compile unit.
|
|
|
|
|
|
|
|
// See if the line table is cached.
|
|
|
|
if (const DWARFDebugLine::LineTable *lt = Line->getLineTable(stmtOffset))
|
|
|
|
return lt;
|
|
|
|
|
|
|
|
// We have to parse it first.
|
|
|
|
DataExtractor lineData(getLineSection(), isLittleEndian(),
|
|
|
|
cu->getAddressByteSize());
|
|
|
|
return Line->getOrParseLineTable(lineData, stmtOffset);
|
2011-09-15 02:12:05 +00:00
|
|
|
}
|
|
|
|
|
2011-09-13 19:42:23 +00:00
|
|
|
void DWARFContext::parseCompileUnits() {
|
|
|
|
uint32_t offset = 0;
|
|
|
|
const DataExtractor &debug_info_data = DataExtractor(getInfoSection(),
|
|
|
|
isLittleEndian(), 0);
|
|
|
|
while (debug_info_data.isValidOffset(offset)) {
|
|
|
|
CUs.push_back(DWARFCompileUnit(*this));
|
|
|
|
if (!CUs.back().extract(debug_info_data, &offset)) {
|
|
|
|
CUs.pop_back();
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
offset = CUs.back().getNextCompileUnitOffset();
|
|
|
|
}
|
|
|
|
}
|
2011-09-15 20:43:22 +00:00
|
|
|
|
|
|
|
namespace {
|
|
|
|
struct OffsetComparator {
|
|
|
|
bool operator()(const DWARFCompileUnit &LHS,
|
|
|
|
const DWARFCompileUnit &RHS) const {
|
|
|
|
return LHS.getOffset() < RHS.getOffset();
|
|
|
|
}
|
|
|
|
bool operator()(const DWARFCompileUnit &LHS, uint32_t RHS) const {
|
|
|
|
return LHS.getOffset() < RHS;
|
|
|
|
}
|
|
|
|
bool operator()(uint32_t LHS, const DWARFCompileUnit &RHS) const {
|
|
|
|
return LHS < RHS.getOffset();
|
|
|
|
}
|
|
|
|
};
|
|
|
|
}
|
|
|
|
|
|
|
|
DWARFCompileUnit *DWARFContext::getCompileUnitForOffset(uint32_t offset) {
|
|
|
|
if (CUs.empty())
|
|
|
|
parseCompileUnits();
|
|
|
|
|
|
|
|
DWARFCompileUnit *i = std::lower_bound(CUs.begin(), CUs.end(), offset,
|
|
|
|
OffsetComparator());
|
|
|
|
if (i != CUs.end())
|
|
|
|
return &*i;
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2012-07-02 05:54:45 +00:00
|
|
|
DILineInfo DWARFContext::getLineInfoForAddress(uint64_t address,
|
|
|
|
DILineInfoSpecifier specifier) {
|
2011-09-15 21:59:13 +00:00
|
|
|
// First, get the offset of the compile unit.
|
|
|
|
uint32_t cuOffset = getDebugAranges()->findAddress(address);
|
2011-09-15 20:43:22 +00:00
|
|
|
// Retrieve the compile unit.
|
|
|
|
DWARFCompileUnit *cu = getCompileUnitForOffset(cuOffset);
|
2011-09-15 21:08:54 +00:00
|
|
|
if (!cu)
|
2012-07-02 05:54:45 +00:00
|
|
|
return DILineInfo();
|
2012-07-19 07:03:58 +00:00
|
|
|
SmallString<16> fileName("<invalid>");
|
|
|
|
SmallString<16> functionName("<invalid>");
|
2012-07-02 05:54:45 +00:00
|
|
|
uint32_t line = 0;
|
|
|
|
uint32_t column = 0;
|
|
|
|
if (specifier.needs(DILineInfoSpecifier::FunctionName)) {
|
|
|
|
const DWARFDebugInfoEntryMinimal *function_die =
|
|
|
|
cu->getFunctionDIEForAddress(address);
|
2012-07-17 15:28:35 +00:00
|
|
|
if (function_die) {
|
|
|
|
if (const char *name = function_die->getSubprogramName(cu))
|
|
|
|
functionName = name;
|
|
|
|
}
|
2012-07-02 05:54:45 +00:00
|
|
|
}
|
|
|
|
if (specifier.needs(DILineInfoSpecifier::FileLineInfo)) {
|
|
|
|
// Get the line table for this compile unit.
|
|
|
|
const DWARFDebugLine::LineTable *lineTable = getLineTableForCompileUnit(cu);
|
|
|
|
if (lineTable) {
|
|
|
|
// Get the index of the row we're looking for in the line table.
|
2012-08-07 11:46:57 +00:00
|
|
|
uint32_t rowIndex = lineTable->lookupAddress(address);
|
2012-07-02 05:54:45 +00:00
|
|
|
if (rowIndex != -1U) {
|
|
|
|
const DWARFDebugLine::Row &row = lineTable->Rows[rowIndex];
|
|
|
|
// Take file/line info from the line table.
|
2012-07-19 07:03:58 +00:00
|
|
|
const DWARFDebugLine::FileNameEntry &fileNameEntry =
|
|
|
|
lineTable->Prologue.FileNames[row.File - 1];
|
|
|
|
fileName = fileNameEntry.Name;
|
|
|
|
if (specifier.needs(DILineInfoSpecifier::AbsoluteFilePath) &&
|
|
|
|
sys::path::is_relative(fileName.str())) {
|
|
|
|
// Append include directory of file (if it is present in line table)
|
|
|
|
// and compilation directory of compile unit to make path absolute.
|
|
|
|
const char *includeDir = 0;
|
|
|
|
if (uint64_t includeDirIndex = fileNameEntry.DirIdx) {
|
|
|
|
includeDir = lineTable->Prologue
|
|
|
|
.IncludeDirectories[includeDirIndex - 1];
|
|
|
|
}
|
|
|
|
SmallString<16> absFileName;
|
|
|
|
if (includeDir == 0 || sys::path::is_relative(includeDir)) {
|
|
|
|
if (const char *compilationDir = cu->getCompilationDir())
|
|
|
|
sys::path::append(absFileName, compilationDir);
|
|
|
|
}
|
|
|
|
if (includeDir) {
|
|
|
|
sys::path::append(absFileName, includeDir);
|
|
|
|
}
|
|
|
|
sys::path::append(absFileName, fileName.str());
|
|
|
|
fileName = absFileName;
|
|
|
|
}
|
2012-07-02 05:54:45 +00:00
|
|
|
line = row.Line;
|
|
|
|
column = row.Column;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return DILineInfo(fileName, functionName, line, column);
|
2011-09-15 20:43:22 +00:00
|
|
|
}
|
2011-12-20 02:50:00 +00:00
|
|
|
|
|
|
|
void DWARFContextInMemory::anchor() { }
|