MachODebugMapParser.cpp [plain text]
#include "BinaryHolder.h"
#include "DebugMap.h"
#include "dsymutil.h"
#include "llvm/Object/MachO.h"
#include "llvm/Support/Path.h"
#include "llvm/Support/raw_ostream.h"
namespace {
using namespace llvm;
using namespace llvm::dsymutil;
using namespace llvm::object;
class MachODebugMapParser {
public:
MachODebugMapParser(StringRef BinaryPath,
ArrayRef<std::string> Archs,
StringRef PathPrefix = "", bool Verbose = false)
: BinaryPath(BinaryPath), Archs(Archs.begin(), Archs.end()),
PathPrefix(PathPrefix), MainBinaryHolder(Verbose),
CurrentObjectHolder(Verbose), CurrentDebugMapObject(nullptr) {}
ErrorOr<std::vector<std::unique_ptr<DebugMap>>> parse();
bool dumpStab();
private:
std::string BinaryPath;
SmallVector<StringRef, 1> Archs;
std::string PathPrefix;
BinaryHolder MainBinaryHolder;
StringMap<uint64_t> MainBinarySymbolAddresses;
StringRef MainBinaryStrings;
std::unique_ptr<DebugMap> Result;
BinaryHolder CurrentObjectHolder;
StringMap<std::pair<uint64_t, StringRef>> CurrentObjectAddresses;
DebugMapObject *CurrentDebugMapObject;
const char *CurrentFunctionName;
uint64_t CurrentFunctionAddress;
std::unique_ptr<DebugMap> parseOneBinary(const MachOObjectFile &MainBinary,
StringRef BinaryPath);
void switchToNewDebugMapObject(StringRef Filename, sys::TimeValue Timestamp);
void resetParserState();
uint64_t getMainBinarySymbolAddress(StringRef Name);
void loadMainBinarySymbols(const MachOObjectFile &MainBinary);
void loadCurrentObjectFileSymbols(const MachOObjectFile &Obj);
void handleStabSymbolTableEntry(uint32_t StringIndex, uint8_t Type,
uint8_t SectionIndex, uint16_t Flags,
uint64_t Value);
template <typename STEType> void handleStabDebugMapEntry(const STEType &STE) {
handleStabSymbolTableEntry(STE.n_strx, STE.n_type, STE.n_sect, STE.n_desc,
STE.n_value);
}
void dumpSymTabHeader(raw_ostream &OS, StringRef Arch);
void dumpSymTabEntry(raw_ostream &OS, uint64_t Index, uint32_t StringIndex,
uint8_t Type, uint8_t SectionIndex, uint16_t Flags,
uint64_t Value);
template <typename STEType> void dumpSymTabEntry(raw_ostream &OS,
uint64_t Index,
const STEType &STE) {
dumpSymTabEntry(OS, Index, STE.n_strx, STE.n_type, STE.n_sect, STE.n_desc,
STE.n_value);
}
void dumpOneBinaryStab(const MachOObjectFile &MainBinary,
StringRef BinaryPath);
void Warning(const Twine &Msg, StringRef File = StringRef()) {
errs() << "warning: (" << getArchName(Result->getTriple()) << ") "
<< File << " " << Msg << "\n";
if (getenv("RC_DEBUG_OPTIONS")) {
if (!File.empty())
Result->addDebugMapObject(File, sys::TimeValue::ZeroTime());
Result->back().addWarning(Msg.str());
}
}
};
}
void MachODebugMapParser::resetParserState() {
CurrentObjectAddresses.clear();
CurrentDebugMapObject = nullptr;
}
void MachODebugMapParser::switchToNewDebugMapObject(StringRef Filename,
sys::TimeValue Timestamp) {
resetParserState();
SmallString<80> Path(PathPrefix);
sys::path::append(Path, Filename);
auto MachOOrError =
CurrentObjectHolder.GetFilesAs<MachOObjectFile>(Path, Timestamp);
if (auto Error = MachOOrError.getError()) {
Warning("unable to open object file: " + Error.message(), Path.str());
return;
}
auto ErrOrAchObj =
CurrentObjectHolder.GetAs<MachOObjectFile>(Result->getTriple());
if (auto Err = ErrOrAchObj.getError()) {
return Warning(Twine("cannot open debug object \"") + Path.str() + "\": " +
Err.message() + "\n", Path.str());
}
CurrentDebugMapObject = &Result->addDebugMapObject(Path, Timestamp);
loadCurrentObjectFileSymbols(*ErrOrAchObj);
}
static Triple getTriple(const object::MachOObjectFile &Obj) {
Triple ThumbTriple;
Triple T = Obj.getArch(nullptr, &ThumbTriple);
return ThumbTriple.str().empty() ? T : ThumbTriple;
}
static std::string getArchName(const object::MachOObjectFile &Obj) {
Triple ThumbTriple;
Triple T = Obj.getArch(nullptr, &ThumbTriple);
return T.getArchName();
}
std::unique_ptr<DebugMap>
MachODebugMapParser::parseOneBinary(const MachOObjectFile &MainBinary,
StringRef BinaryPath) {
loadMainBinarySymbols(MainBinary);
ArrayRef<uint8_t> UUID = MainBinary.getUuid();
Result = make_unique<DebugMap>(getTriple(MainBinary), BinaryPath, UUID);
MainBinaryStrings = MainBinary.getStringTableData();
for (const SymbolRef &Symbol : MainBinary.symbols()) {
const DataRefImpl &DRI = Symbol.getRawDataRefImpl();
if (MainBinary.is64Bit())
handleStabDebugMapEntry(MainBinary.getSymbol64TableEntry(DRI));
else
handleStabDebugMapEntry(MainBinary.getSymbolTableEntry(DRI));
}
resetParserState();
return std::move(Result);
}
struct DarwinStabName {
uint8_t NType;
const char *Name;
};
static const struct DarwinStabName DarwinStabNames[] = {
{ MachO::N_GSYM, "N_GSYM" },
{ MachO::N_FNAME, "N_FNAME" },
{ MachO::N_FUN, "N_FUN" },
{ MachO::N_STSYM, "N_STSYM" },
{ MachO::N_LCSYM, "N_LCSYM" },
{ MachO::N_BNSYM, "N_BNSYM" },
{ MachO::N_PC, "N_PC" },
{ MachO::N_AST, "N_AST" },
{ MachO::N_OPT, "N_OPT" },
{ MachO::N_RSYM, "N_RSYM" },
{ MachO::N_SLINE, "N_SLINE" },
{ MachO::N_ENSYM, "N_ENSYM" },
{ MachO::N_SSYM, "N_SSYM" },
{ MachO::N_SO, "N_SO" },
{ MachO::N_OSO, "N_OSO" },
{ MachO::N_LSYM, "N_LSYM" },
{ MachO::N_BINCL, "N_BINCL" },
{ MachO::N_SOL, "N_SOL" },
{ MachO::N_PARAMS, "N_PARAM" },
{ MachO::N_VERSION, "N_VERS" },
{ MachO::N_OLEVEL, "N_OLEV" },
{ MachO::N_PSYM, "N_PSYM" },
{ MachO::N_EINCL, "N_EINCL" },
{ MachO::N_ENTRY, "N_ENTRY" },
{ MachO::N_LBRAC, "N_LBRAC" },
{ MachO::N_EXCL, "N_EXCL" },
{ MachO::N_RBRAC, "N_RBRAC" },
{ MachO::N_BCOMM, "N_BCOMM" },
{ MachO::N_ECOMM, "N_ECOMM" },
{ MachO::N_ECOML, "N_ECOML" },
{ MachO::N_LENG, "N_LENG" },
{0, 0}};
static const char *getDarwinStabString(uint8_t NType) {
for (unsigned i = 0; DarwinStabNames[i].Name; i++) {
if (DarwinStabNames[i].NType == NType)
return DarwinStabNames[i].Name;
}
return 0;
}
void MachODebugMapParser::dumpSymTabHeader(raw_ostream &OS, StringRef Arch) {
OS << "-----------------------------------"
"-----------------------------------\n";
OS << "Symbol table for: '" << BinaryPath << "' (" << Arch.data() << ")\n";
OS << "-----------------------------------"
"-----------------------------------\n";
OS << "Index n_strx n_type n_sect n_desc n_value\n";
OS << "======== -------- ------------------ ------ ------ ----------------\n";
}
void MachODebugMapParser::dumpSymTabEntry(raw_ostream &OS, uint64_t Index,
uint32_t StringIndex, uint8_t Type, uint8_t SectionIndex,
uint16_t Flags, uint64_t Value) {
OS << '[' << format_decimal(Index, 6) << "] "
<< format_hex_no_prefix(StringIndex, 8) << ' '
<< format_hex_no_prefix(Type, 2) << " (";
if (Type & MachO::N_STAB)
OS << left_justify(getDarwinStabString(Type), 13);
else {
if (Type & MachO::N_PEXT)
OS << "PEXT ";
else
OS << " ";
switch (Type & MachO::N_TYPE) {
case MachO::N_UNDF: OS << "UNDF"; break;
case MachO::N_ABS : OS << "ABS "; break;
case MachO::N_SECT: OS << "SECT"; break;
case MachO::N_PBUD: OS << "PBUD"; break;
case MachO::N_INDR: OS << "INDR"; break;
default: OS << format_hex_no_prefix(Type, 2) << " "; break;
}
if (Type & MachO::N_EXT)
OS << " EXT";
else
OS << " ";
}
OS << ") "
<< format_hex_no_prefix(SectionIndex, 2) << " "
<< format_hex_no_prefix(Flags, 4) << " "
<< format_hex_no_prefix(Value, 16);
const char *Name = &MainBinaryStrings.data()[StringIndex];
if (Name && Name[0])
OS << " '" << Name << "'";
OS << "\n";
}
void MachODebugMapParser::dumpOneBinaryStab(const MachOObjectFile &MainBinary,
StringRef BinaryPath) {
loadMainBinarySymbols(MainBinary);
MainBinaryStrings = MainBinary.getStringTableData();
raw_ostream &OS(llvm::outs());
StringRef ArchName = getArchName(MainBinary);
dumpSymTabHeader(OS, ArchName);
uint64_t Idx = 0;
for (const SymbolRef &Symbol : MainBinary.symbols()) {
const DataRefImpl &DRI = Symbol.getRawDataRefImpl();
if (MainBinary.is64Bit())
dumpSymTabEntry(OS, Idx, MainBinary.getSymbol64TableEntry(DRI));
else
dumpSymTabEntry(OS, Idx, MainBinary.getSymbolTableEntry(DRI));
Idx++;
}
OS << "\n\n";
resetParserState();
}
static bool shouldLinkArch(SmallVectorImpl<StringRef> &Archs,
StringRef Arch) {
if (Archs.empty() ||
std::find(Archs.begin(), Archs.end(), "all") != Archs.end() ||
std::find(Archs.begin(), Archs.end(), "*") != Archs.end())
return true;
if (std::find(Archs.begin(), Archs.end(), "arm") != Archs.end() &&
Arch.startswith("arm"))
return true;
return std::find(Archs.begin(), Archs.end(), Arch) != Archs.end();
}
bool MachODebugMapParser::dumpStab() {
auto MainBinOrError = MainBinaryHolder.GetFilesAs<MachOObjectFile>(BinaryPath);
if (auto Error = MainBinOrError.getError()) {
llvm::errs() << "Cannot get '" << BinaryPath << "' as MachO file: "
<< Error.message() << "\n";
return false;
}
Triple T;
for (const auto *Binary : *MainBinOrError)
if (shouldLinkArch(Archs, Binary->getArch(nullptr, &T).getArchName()))
dumpOneBinaryStab(*Binary, BinaryPath);
return true;
}
ErrorOr<std::vector<std::unique_ptr<DebugMap>>> MachODebugMapParser::parse() {
auto MainBinOrError =
MainBinaryHolder.GetFilesAs<MachOObjectFile>(BinaryPath);
if (auto Error = MainBinOrError.getError())
return Error;
std::vector<std::unique_ptr<DebugMap>> Results;
Triple T;
for (const auto *Binary : *MainBinOrError)
if (shouldLinkArch(Archs, Binary->getArch(nullptr, &T).getArchName()))
Results.push_back(parseOneBinary(*Binary, BinaryPath));
return std::move(Results);
}
void MachODebugMapParser::handleStabSymbolTableEntry(uint32_t StringIndex,
uint8_t Type,
uint8_t SectionIndex,
uint16_t Flags,
uint64_t Value) {
if (!(Type & MachO::N_STAB))
return;
const char *Name = &MainBinaryStrings.data()[StringIndex];
if (Type == MachO::N_OSO) {
sys::TimeValue Timestamp;
Timestamp.fromEpochTime(Value);
return switchToNewDebugMapObject(Name, Timestamp);
}
if (Type == MachO::N_AST) {
sys::TimeValue Timestamp;
Timestamp.fromEpochTime(Value);
Result->addDebugMapObject(Name, Timestamp, true);
return;
}
if (!CurrentDebugMapObject)
return;
uint32_t Size = 0;
switch (Type) {
case MachO::N_GSYM:
Value = getMainBinarySymbolAddress(Name);
if (Value == UnknownAddressOrSize)
return;
break;
case MachO::N_FUN:
if (Name[0] == '\0') {
Size = Value;
Value = CurrentFunctionAddress;
Name = CurrentFunctionName;
break;
} else {
CurrentFunctionName = Name;
CurrentFunctionAddress = Value;
return;
}
case MachO::N_STSYM:
break;
default:
return;
}
auto ObjectSymIt = CurrentObjectAddresses.find(Name);
if (ObjectSymIt == CurrentObjectAddresses.end()) {
if (Name[0] == '_')
Warning("could not find object file symbol for symbol " +
Twine(Name));
return;
}
if (!CurrentDebugMapObject->addSymbol(Name, ObjectSymIt->getValue().first, Value,
Size, ObjectSymIt->getValue().second))
return Warning(Twine("failed to insert symbol '") + Name +
"' in the debug map.");
}
void MachODebugMapParser::loadCurrentObjectFileSymbols(
const object::MachOObjectFile &Obj) {
CurrentObjectAddresses.clear();
for (auto Sym : Obj.symbols()) {
StringRef Name;
uint64_t Addr = UnknownAddressOrSize;
SymbolRef::Type Type;
StringRef SecName;
Sym.getAddress(Addr);
object::section_iterator Section = Obj.section_end();
if (!Sym.getSection(Section) && Section != Obj.section_end())
Section->getName(SecName);
if (Sym.getName(Name) || Name.empty() ||
Sym.getType(Type) || Type == SymbolRef::ST_Other)
continue;
CurrentObjectAddresses.insert(std::make_pair(Name, std::make_pair(Addr, SecName)));
uint32_t Flags;
Flags = Sym.getFlags();
uint64_t Value;
Value = getMainBinarySymbolAddress(Name);
if (Addr != UnknownAddressOrSize || Value != UnknownAddressOrSize)
CurrentDebugMapObject->addSymbol(Name, Addr, Value, 0, SecName, true);
}
}
uint64_t MachODebugMapParser::getMainBinarySymbolAddress(StringRef Name) {
auto Sym = MainBinarySymbolAddresses.find(Name);
if (Sym == MainBinarySymbolAddresses.end())
return UnknownAddressOrSize;
return Sym->second;
}
void MachODebugMapParser::loadMainBinarySymbols(
const MachOObjectFile &MainBinary) {
MainBinarySymbolAddresses.clear();
for (const auto &Sym : MainBinary.symbols()) {
SymbolRef::Type Type;
if (Sym.getType(Type) || (Type & SymbolRef::ST_Debug) ||
(Type & SymbolRef::ST_Unknown))
continue;
StringRef Name;
uint64_t Addr;
if (Sym.getAddress(Addr) || Addr == UnknownAddressOrSize ||
Sym.getName(Name) || Name.size() == 0 || Name[0] == '\0') {
continue;
}
uint64_t &AddrInMap = MainBinarySymbolAddresses[Name];
if (!AddrInMap)
AddrInMap = Addr;
}
}
namespace llvm {
namespace dsymutil {
llvm::ErrorOr<std::vector<std::unique_ptr<DebugMap>>>
parseDebugMap(StringRef InputFile, ArrayRef<std::string> Archs,
StringRef PrependPath, bool Verbose) {
MachODebugMapParser Parser(InputFile, Archs, PrependPath, Verbose);
return Parser.parse();
}
bool dumpStab(StringRef InputFile, ArrayRef<std::string> Archs,
StringRef PrependPath) {
MachODebugMapParser Parser(InputFile, Archs, PrependPath, false);
return Parser.dumpStab();
}
}
}