void MCJIT::addObjectFile(object::OwningBinary<object::ObjectFile> Obj) {
std::unique_ptr<object::ObjectFile> ObjFile;
std::unique_ptr<MemoryBuffer> MemBuf;
std::tie(ObjFile, MemBuf) = Obj.takeBinary();
addObjectFile(std::move(ObjFile));
Buffers.push_back(std::move(MemBuf));
}
static Error
loadObj(StringRef Filename, object::OwningBinary<object::ObjectFile> &ObjFile,
InstrumentationMap::SledContainer &Sleds,
InstrumentationMap::FunctionAddressMap &FunctionAddresses,
InstrumentationMap::FunctionAddressReverseMap &FunctionIds) {
InstrumentationMap Map;
// Find the section named "xray_instr_map".
if ((!ObjFile.getBinary()->isELF() && !ObjFile.getBinary()->isMachO()) ||
!(ObjFile.getBinary()->getArch() == Triple::x86_64 ||
ObjFile.getBinary()->getArch() == Triple::ppc64le))
return make_error<StringError>(
"File format not supported (only does ELF and Mach-O little endian 64-bit).",
std::make_error_code(std::errc::not_supported));
StringRef Contents = "";
const auto &Sections = ObjFile.getBinary()->sections();
auto I = llvm::find_if(Sections, [&](object::SectionRef Section) {
StringRef Name = "";
if (Section.getName(Name))
return false;
return Name == "xray_instr_map";
});
if (I == Sections.end())
return make_error<StringError>(
"Failed to find XRay instrumentation map.",
std::make_error_code(std::errc::executable_format_error));
if (I->getContents(Contents))
return errorCodeToError(
std::make_error_code(std::errc::executable_format_error));
RelocMap Relocs;
if (ObjFile.getBinary()->isELF()) {
uint32_t RelativeRelocation = [](object::ObjectFile *ObjFile) {
if (const auto *ELFObj = dyn_cast<object::ELF32LEObjectFile>(ObjFile))
return ELFObj->getELFFile()->getRelativeRelocationType();
else if (const auto *ELFObj = dyn_cast<object::ELF32BEObjectFile>(ObjFile))
return ELFObj->getELFFile()->getRelativeRelocationType();
else if (const auto *ELFObj = dyn_cast<object::ELF64LEObjectFile>(ObjFile))
return ELFObj->getELFFile()->getRelativeRelocationType();
else if (const auto *ELFObj = dyn_cast<object::ELF64BEObjectFile>(ObjFile))
return ELFObj->getELFFile()->getRelativeRelocationType();
else
return static_cast<uint32_t>(0);
}(ObjFile.getBinary());
for (const object::SectionRef &Section : Sections) {
for (const object::RelocationRef &Reloc : Section.relocations()) {
if (Reloc.getType() != RelativeRelocation)
continue;
if (auto AddendOrErr = object::ELFRelocationRef(Reloc).getAddend())
Relocs.insert({Reloc.getOffset(), *AddendOrErr});
}
}
}
// Copy the instrumentation map data into the Sleds data structure.
auto C = Contents.bytes_begin();
static constexpr size_t ELF64SledEntrySize = 32;
if ((C - Contents.bytes_end()) % ELF64SledEntrySize != 0)
return make_error<StringError>(
Twine("Instrumentation map entries not evenly divisible by size of "
"an XRay sled entry in ELF64."),
std::make_error_code(std::errc::executable_format_error));
auto RelocateOrElse = [&](uint32_t Offset, uint64_t Address) {
if (!Address) {
uint64_t A = I->getAddress() + C - Contents.bytes_begin() + Offset;
RelocMap::const_iterator R = Relocs.find(A);
if (R != Relocs.end())
return R->second;
}
return Address;
};
int32_t FuncId = 1;
uint64_t CurFn = 0;
for (; C != Contents.bytes_end(); C += ELF64SledEntrySize) {
DataExtractor Extractor(
StringRef(reinterpret_cast<const char *>(C), ELF64SledEntrySize), true,
8);
Sleds.push_back({});
auto &Entry = Sleds.back();
uint32_t OffsetPtr = 0;
uint32_t AddrOff = OffsetPtr;
Entry.Address = RelocateOrElse(AddrOff, Extractor.getU64(&OffsetPtr));
uint32_t FuncOff = OffsetPtr;
Entry.Function = RelocateOrElse(FuncOff, Extractor.getU64(&OffsetPtr));
auto Kind = Extractor.getU8(&OffsetPtr);
static constexpr SledEntry::FunctionKinds Kinds[] = {
SledEntry::FunctionKinds::ENTRY, SledEntry::FunctionKinds::EXIT,
SledEntry::FunctionKinds::TAIL,
SledEntry::FunctionKinds::LOG_ARGS_ENTER,
SledEntry::FunctionKinds::CUSTOM_EVENT};
if (Kind >= sizeof(Kinds))
return errorCodeToError(
std::make_error_code(std::errc::executable_format_error));
Entry.Kind = Kinds[Kind];
Entry.AlwaysInstrument = Extractor.getU8(&OffsetPtr) != 0;
// We do replicate the function id generation scheme implemented in the
// XRay runtime.
// FIXME: Figure out how to keep this consistent with the XRay runtime.
if (CurFn == 0) {
CurFn = Entry.Function;
FunctionAddresses[FuncId] = Entry.Function;
FunctionIds[Entry.Function] = FuncId;
}
if (Entry.Function != CurFn) {
++FuncId;
CurFn = Entry.Function;
FunctionAddresses[FuncId] = Entry.Function;
FunctionIds[Entry.Function] = FuncId;
}
}
return Error::success();
}
void MCJIT::addObjectFile(object::OwningBinary<object::ObjectFile> Obj) {
addObjectFile(std::move(Obj.getBinary()));
Buffers.push_back(std::move(Obj.getBuffer()));
}