void reassignSectionAddress(unsigned SectionID, uint64_t Addr);
public:
-
- using NotifyStubEmittedFunction =
- std::function<void(StringRef FileName, StringRef SectionName,
- StringRef SymbolName, uint32_t StubOffset)>;
+ using NotifyStubEmittedFunction = std::function<void(
+ StringRef FileName, StringRef SectionName, StringRef SymbolName,
+ unsigned SectionID, uint32_t StubOffset)>;
/// Information about the loaded object.
class LoadedObjectInfo : public llvm::LoadedObjectInfo {
///
/// ident_expr = 'decode_operand' '(' symbol ',' operand-index ')'
/// | 'next_pc' '(' symbol ')'
-/// | 'stub_addr' '(' file-name ',' section-name ',' symbol ')'
+/// | 'stub_addr' '(' stub-container-name ',' symbol ')'
+/// | 'got_addr' '(' stub-container-name ',' symbol ')'
/// | symbol
///
/// binary_expr = expr '+' expr
///
class RuntimeDyldChecker {
public:
+ struct MemoryRegionInfo {
+ StringRef Content;
+ JITTargetAddress TargetAddress;
+ };
using IsSymbolValidFunction = std::function<bool(StringRef Symbol)>;
- using GetSymbolAddressFunction =
- std::function<Expected<JITTargetAddress>(StringRef Symbol)>;
- using GetSymbolContentFunction =
- std::function<Expected<StringRef>(StringRef Symbol)>;
- using GetSectionLoadAddressFunction =
- std::function<Optional<JITTargetAddress>(StringRef FileName,
- StringRef SectionName)>;
- using GetSectionContentFunction =
- std::function<Expected<StringRef>(StringRef FileName,
- StringRef SectionName)>;
- using GetStubOffsetInSectionFunction =
- std::function<Expected<uint32_t>(StringRef FileName,
- StringRef SectionName,
- StringRef SymbolName)>;
+ using GetSymbolInfoFunction =
+ std::function<Expected<MemoryRegionInfo>(StringRef SymbolName)>;
+ using GetSectionInfoFunction = std::function<Expected<MemoryRegionInfo>(
+ StringRef FileName, StringRef SectionName)>;
+ using GetStubInfoFunction = std::function<Expected<MemoryRegionInfo>(
+ StringRef StubContainer, StringRef TargetName)>;
+ using GetGOTInfoFunction = std::function<Expected<MemoryRegionInfo>(
+ StringRef GOTContainer, StringRef TargetName)>;
RuntimeDyldChecker(IsSymbolValidFunction IsSymbolValid,
- GetSymbolAddressFunction GetSymbolAddress,
- GetSymbolContentFunction GetSymbolContent,
- GetSectionLoadAddressFunction GetSectionLoadAddresss,
- GetSectionContentFunction GetSectionContent,
- GetStubOffsetInSectionFunction GetStubOffsetInSection,
+ GetSymbolInfoFunction GetSymbolInfo,
+ GetSectionInfoFunction GetSectionInfo,
+ GetStubInfoFunction GetStubInfo,
+ GetGOTInfoFunction GetGOTInfo,
support::endianness Endianness,
- MCDisassembler *Disassembler,
- MCInstPrinter *InstPrinter, raw_ostream &ErrStream);
+ MCDisassembler *Disassembler, MCInstPrinter *InstPrinter,
+ raw_ostream &ErrStream);
~RuntimeDyldChecker();
/// Check a single expression against the attached RuntimeDyld
// If this is a named stub, just call NotifyStubEmitted.
if (VR.SymbolName) {
- NotifyStubEmitted(FileName, SectionName, VR.SymbolName, StubAddr);
+ NotifyStubEmitted(FileName, SectionName, VR.SymbolName, SectionID,
+ StubAddr);
continue;
}
auto &GSTEntry = GSTMapEntry.second;
if (GSTEntry.getSectionID() == VR.SectionID &&
GSTEntry.getOffset() == VR.Offset) {
- NotifyStubEmitted(FileName, SectionName, SymbolName, StubAddr);
+ NotifyStubEmitted(FileName, SectionName, SymbolName, SectionID,
+ StubAddr);
break;
}
}
return std::make_pair(EvalResult(NextPC), RemainingExpr);
}
- // Evaluate a call to stub_addr.
+ // Evaluate a call to stub_addr/got_addr.
// Look up and return the address of the stub for the given
// (<file name>, <section name>, <symbol name>) tuple.
// On success, returns a pair containing the stub address, plus the expression
// remaining to be evaluated.
- std::pair<EvalResult, StringRef> evalStubAddr(StringRef Expr,
- ParseContext PCtx) const {
+ std::pair<EvalResult, StringRef>
+ evalStubOrGOTAddr(StringRef Expr, ParseContext PCtx, bool IsStubAddr) const {
if (!Expr.startswith("("))
return std::make_pair(unexpectedToken(Expr, Expr, "expected '('"), "");
StringRef RemainingExpr = Expr.substr(1).ltrim();
// Handle file-name specially, as it may contain characters that aren't
// legal for symbols.
- StringRef FileName;
+ StringRef StubContainerName;
size_t ComaIdx = RemainingExpr.find(',');
- FileName = RemainingExpr.substr(0, ComaIdx).rtrim();
+ StubContainerName = RemainingExpr.substr(0, ComaIdx).rtrim();
RemainingExpr = RemainingExpr.substr(ComaIdx).ltrim();
if (!RemainingExpr.startswith(","))
unexpectedToken(RemainingExpr, Expr, "expected ','"), "");
RemainingExpr = RemainingExpr.substr(1).ltrim();
- StringRef SectionName;
- std::tie(SectionName, RemainingExpr) = parseSymbol(RemainingExpr);
-
- if (!RemainingExpr.startswith(","))
- return std::make_pair(
- unexpectedToken(RemainingExpr, Expr, "expected ','"), "");
- RemainingExpr = RemainingExpr.substr(1).ltrim();
-
StringRef Symbol;
std::tie(Symbol, RemainingExpr) = parseSymbol(RemainingExpr);
uint64_t StubAddr;
std::string ErrorMsg = "";
- std::tie(StubAddr, ErrorMsg) = Checker.getStubAddrFor(
- FileName, SectionName, Symbol, PCtx.IsInsideLoad);
+ std::tie(StubAddr, ErrorMsg) = Checker.getStubOrGOTAddrFor(
+ StubContainerName, Symbol, PCtx.IsInsideLoad, IsStubAddr);
if (ErrorMsg != "")
return std::make_pair(EvalResult(ErrorMsg), "");
else if (Symbol == "next_pc")
return evalNextPC(RemainingExpr, PCtx);
else if (Symbol == "stub_addr")
- return evalStubAddr(RemainingExpr, PCtx);
+ return evalStubOrGOTAddr(RemainingExpr, PCtx, true);
+ else if (Symbol == "got_addr")
+ return evalStubOrGOTAddr(RemainingExpr, PCtx, false);
else if (Symbol == "section_addr")
return evalSectionAddr(RemainingExpr, PCtx);
}
RuntimeDyldCheckerImpl::RuntimeDyldCheckerImpl(
- IsSymbolValidFunction IsSymbolValid,
- GetSymbolAddressFunction GetSymbolAddress,
- GetSymbolContentFunction GetSymbolContent,
- GetSectionLoadAddressFunction GetSectionLoadAddress,
- GetSectionContentFunction GetSectionContent,
- GetStubOffsetInSectionFunction GetStubOffsetInSection,
- support::endianness Endianness,
- MCDisassembler *Disassembler,
- MCInstPrinter *InstPrinter,
- raw_ostream &ErrStream)
+ IsSymbolValidFunction IsSymbolValid, GetSymbolInfoFunction GetSymbolInfo,
+ GetSectionInfoFunction GetSectionInfo, GetStubInfoFunction GetStubInfo,
+ GetGOTInfoFunction GetGOTInfo, support::endianness Endianness,
+ MCDisassembler *Disassembler, MCInstPrinter *InstPrinter,
+ raw_ostream &ErrStream)
: IsSymbolValid(std::move(IsSymbolValid)),
- GetSymbolAddress(std::move(GetSymbolAddress)),
- GetSymbolContent(std::move(GetSymbolContent)),
- GetSectionLoadAddress(std::move(GetSectionLoadAddress)),
- GetSectionContent(std::move(GetSectionContent)),
- GetStubOffsetInSection(std::move(GetStubOffsetInSection)),
+ GetSymbolInfo(std::move(GetSymbolInfo)),
+ GetSectionInfo(std::move(GetSectionInfo)),
+ GetStubInfo(std::move(GetStubInfo)), GetGOTInfo(std::move(GetGOTInfo)),
Endianness(Endianness), Disassembler(Disassembler),
InstPrinter(InstPrinter), ErrStream(ErrStream) {}
}
uint64_t RuntimeDyldCheckerImpl::getSymbolLocalAddr(StringRef Symbol) const {
- auto Contents = GetSymbolContent(Symbol);
- if (!Contents) {
- logAllUnhandledErrors(Contents.takeError(), errs(), "RTDyldChecker: ");
+ auto SymInfo = GetSymbolInfo(Symbol);
+ if (!SymInfo) {
+ logAllUnhandledErrors(SymInfo.takeError(), errs(), "RTDyldChecker: ");
return 0;
}
- return static_cast<uint64_t>(reinterpret_cast<uintptr_t>(Contents->data()));
+ return static_cast<uint64_t>(
+ reinterpret_cast<uintptr_t>(SymInfo->Content.data()));
}
uint64_t RuntimeDyldCheckerImpl::getSymbolRemoteAddr(StringRef Symbol) const {
- auto Addr = GetSymbolAddress(Symbol);
- if (!Addr) {
- logAllUnhandledErrors(Addr.takeError(), errs(), "RTDyldChecker: ");
+ auto SymInfo = GetSymbolInfo(Symbol);
+ if (!SymInfo) {
+ logAllUnhandledErrors(SymInfo.takeError(), errs(), "RTDyldChecker: ");
return 0;
}
- return *Addr;
+ return SymInfo->TargetAddress;
}
uint64_t RuntimeDyldCheckerImpl::readMemoryAtAddr(uint64_t SrcAddr,
}
StringRef RuntimeDyldCheckerImpl::getSymbolContent(StringRef Symbol) const {
- auto Content = GetSymbolContent(Symbol);
- if (!Content) {
- logAllUnhandledErrors(Content.takeError(), errs(), "RTDyldChecker: ");
+ auto SymInfo = GetSymbolInfo(Symbol);
+ if (!SymInfo) {
+ logAllUnhandledErrors(SymInfo.takeError(), errs(), "RTDyldChecker: ");
return StringRef();
}
- return *Content;
+ return SymInfo->Content;
}
std::pair<uint64_t, std::string> RuntimeDyldCheckerImpl::getSectionAddr(
StringRef FileName, StringRef SectionName, bool IsInsideLoad) const {
- uint64_t Addr = 0;
- std::string ErrMsg;
-
- // If this address is being looked up in "load" mode, return the content
- // pointer.
- if (IsInsideLoad) {
- if (auto Content = GetSectionContent(FileName, SectionName))
- Addr = pointerToJITTargetAddress(Content->data());
- else {
+ auto SecInfo = GetSectionInfo(FileName, SectionName);
+ if (!SecInfo) {
+ std::string ErrMsg;
+ {
raw_string_ostream ErrMsgStream(ErrMsg);
- logAllUnhandledErrors(Content.takeError(), ErrMsgStream,
+ logAllUnhandledErrors(SecInfo.takeError(), ErrMsgStream,
"RTDyldChecker: ");
}
- return std::make_pair(Addr, std::move(ErrMsg));
+ return std::make_pair(0, std::move(ErrMsg));
}
- // ... otherwise return the target pointer.
- if (auto LoadAddr = GetSectionLoadAddress(FileName, SectionName))
- Addr = *LoadAddr;
- else
- return std::make_pair(Addr, ("Section (" + FileName + ", " +
- SectionName + ") does not exist").str());
+ // If this address is being looked up in "load" mode, return the content
+ // pointer, otherwise return the target address.
- return std::make_pair(Addr, std::move(ErrMsg));
-}
+ uint64_t Addr = 0;
-std::pair<uint64_t, std::string> RuntimeDyldCheckerImpl::getStubAddrFor(
- StringRef FileName, StringRef SectionName, StringRef SymbolName,
- bool IsInsideLoad) const {
+ if (IsInsideLoad)
+ Addr = pointerToJITTargetAddress(SecInfo->Content.data());
+ else
+ Addr = SecInfo->TargetAddress;
- auto SectionAddr = getSectionAddr(FileName, SectionName, IsInsideLoad);
+ return std::make_pair(Addr, "");
+}
- if (!SectionAddr.second.empty())
- return SectionAddr;
+std::pair<uint64_t, std::string> RuntimeDyldCheckerImpl::getStubOrGOTAddrFor(
+ StringRef StubContainerName, StringRef SymbolName, bool IsInsideLoad,
+ bool IsStubAddr) const {
- auto StubOffset = GetStubOffsetInSection(FileName, SectionName, SymbolName);
+ auto StubInfo = IsStubAddr ? GetStubInfo(StubContainerName, SymbolName)
+ : GetGOTInfo(StubContainerName, SymbolName);
- if (!StubOffset) {
+ if (!StubInfo) {
std::string ErrMsg;
{
raw_string_ostream ErrMsgStream(ErrMsg);
- logAllUnhandledErrors(StubOffset.takeError(), ErrMsgStream,
+ logAllUnhandledErrors(StubInfo.takeError(), ErrMsgStream,
"RTDyldChecker: ");
}
return std::make_pair((uint64_t)0, std::move(ErrMsg));
}
- return std::make_pair(SectionAddr.first + *StubOffset, "");
+ uint64_t Addr = 0;
+
+ if (IsInsideLoad)
+ Addr = pointerToJITTargetAddress(StubInfo->Content.data());
+ else
+ Addr = StubInfo->TargetAddress;
+
+ return std::make_pair(Addr, "");
}
RuntimeDyldChecker::RuntimeDyldChecker(
- IsSymbolValidFunction IsSymbolValid,
- GetSymbolAddressFunction GetSymbolAddress,
- GetSymbolContentFunction GetSymbolContent,
- GetSectionLoadAddressFunction GetSectionLoadAddress,
- GetSectionContentFunction GetSectionContent,
- GetStubOffsetInSectionFunction GetStubOffsetInSection,
- support::endianness Endianness,
- MCDisassembler *Disassembler,
- MCInstPrinter *InstPrinter,
- raw_ostream &ErrStream)
+ IsSymbolValidFunction IsSymbolValid, GetSymbolInfoFunction GetSymbolInfo,
+ GetSectionInfoFunction GetSectionInfo, GetStubInfoFunction GetStubInfo,
+ GetGOTInfoFunction GetGOTInfo, support::endianness Endianness,
+ MCDisassembler *Disassembler, MCInstPrinter *InstPrinter,
+ raw_ostream &ErrStream)
: Impl(::llvm::make_unique<RuntimeDyldCheckerImpl>(
- std::move(IsSymbolValid),
- std::move(GetSymbolAddress),
- std::move(GetSymbolContent),
- std::move(GetSectionLoadAddress),
- std::move(GetSectionContent),
- std::move(GetStubOffsetInSection),
- Endianness, Disassembler,
- InstPrinter, ErrStream)) {}
+ std::move(IsSymbolValid), std::move(GetSymbolInfo),
+ std::move(GetSectionInfo), std::move(GetStubInfo),
+ std::move(GetGOTInfo), Endianness, Disassembler, InstPrinter,
+ ErrStream)) {}
RuntimeDyldChecker::~RuntimeDyldChecker() {}
using IsSymbolValidFunction =
RuntimeDyldChecker::IsSymbolValidFunction;
- using GetSymbolAddressFunction =
- RuntimeDyldChecker::GetSymbolAddressFunction;
- using GetSymbolContentFunction =
- RuntimeDyldChecker::GetSymbolContentFunction;
-
- using GetSectionLoadAddressFunction =
- RuntimeDyldChecker::GetSectionLoadAddressFunction;
- using GetSectionContentFunction =
- RuntimeDyldChecker::GetSectionContentFunction;
-
- using GetStubOffsetInSectionFunction =
- RuntimeDyldChecker::GetStubOffsetInSectionFunction;
+ using GetSymbolInfoFunction = RuntimeDyldChecker::GetSymbolInfoFunction;
+ using GetSectionInfoFunction = RuntimeDyldChecker::GetSectionInfoFunction;
+ using GetStubInfoFunction = RuntimeDyldChecker::GetStubInfoFunction;
+ using GetGOTInfoFunction = RuntimeDyldChecker::GetGOTInfoFunction;
public:
RuntimeDyldCheckerImpl(
- IsSymbolValidFunction IsSymbolValid,
- GetSymbolAddressFunction GetSymbolAddress,
- GetSymbolContentFunction GetSymbolContent,
- GetSectionLoadAddressFunction GetSectionLoadAddress,
- GetSectionContentFunction GetSectionContent,
- GetStubOffsetInSectionFunction GetStubOffsetInSection,
- support::endianness Endianness,
- MCDisassembler *Disassembler,
- MCInstPrinter *InstPrinter,
- llvm::raw_ostream &ErrStream);
+ IsSymbolValidFunction IsSymbolValid, GetSymbolInfoFunction GetSymbolInfo,
+ GetSectionInfoFunction GetSectionInfo, GetStubInfoFunction GetStubInfo,
+ GetGOTInfoFunction GetGOTInfo, support::endianness Endianness,
+ MCDisassembler *Disassembler, MCInstPrinter *InstPrinter,
+ llvm::raw_ostream &ErrStream);
bool check(StringRef CheckExpr) const;
bool checkAllRulesInBuffer(StringRef RulePrefix, MemoryBuffer *MemBuf) const;
StringRef SectionName,
bool IsInsideLoad) const;
- std::pair<uint64_t, std::string> getStubAddrFor(StringRef FileName,
- StringRef SectionName,
- StringRef Symbol,
- bool IsInsideLoad) const;
+ std::pair<uint64_t, std::string>
+ getStubOrGOTAddrFor(StringRef StubContainerName, StringRef Symbol,
+ bool IsInsideLoad, bool IsStubAddr) const;
Optional<uint64_t> getSectionLoadAddress(void *LocalAddr) const;
IsSymbolValidFunction IsSymbolValid;
- GetSymbolAddressFunction GetSymbolAddress;
- GetSymbolContentFunction GetSymbolContent;
- GetSectionLoadAddressFunction GetSectionLoadAddress;
- GetSectionContentFunction GetSectionContent;
- GetStubOffsetInSectionFunction GetStubOffsetInSection;
+ GetSymbolInfoFunction GetSymbolInfo;
+ GetSectionInfoFunction GetSectionInfo;
+ GetStubInfoFunction GetStubInfo;
+ GetGOTInfoFunction GetGOTInfo;
support::endianness Endianness;
MCDisassembler *Disassembler;
MCInstPrinter *InstPrinter;
void resolveBPFRelocation(const SectionEntry &Section, uint64_t Offset,
uint64_t Value, uint32_t Type, int64_t Addend);
- unsigned getMaxStubSize() override {
+ unsigned getMaxStubSize() const override {
if (Arch == Triple::aarch64 || Arch == Triple::aarch64_be)
return 20; // movz; movk; movk; movk; br
if (Arch == Triple::arm || Arch == Triple::thumb)
RuntimeDyld::NotifyStubEmittedFunction;
NotifyStubEmittedFunction NotifyStubEmitted;
- virtual unsigned getMaxStubSize() = 0;
+ virtual unsigned getMaxStubSize() const = 0;
virtual unsigned getStubAlignment() = 0;
bool HasError;
}
StringRef getSectionContent(unsigned SectionID) const {
- return StringRef(reinterpret_cast<char*>(Sections[SectionID].getAddress()),
- Sections[SectionID].getSize());
+ return StringRef(reinterpret_cast<char *>(Sections[SectionID].getAddress()),
+ Sections[SectionID].getStubOffset() + getMaxStubSize());
}
uint8_t* getSymbolLocalAddress(StringRef Name) const {
JITSymbolResolver &Resolver)
: RuntimeDyldCOFF(MM, Resolver) {}
- unsigned getMaxStubSize() override {
+ unsigned getMaxStubSize() const override {
return 8; // 2-byte jmp instruction + 32-bit relative address + 2 byte pad
}
JITSymbolResolver &Resolver)
: RuntimeDyldCOFF(MM, Resolver) {}
- unsigned getMaxStubSize() override {
+ unsigned getMaxStubSize() const override {
return 16; // 8-byte load instructions, 4-byte jump, 4-byte padding
}
unsigned getStubAlignment() override { return 1; }
// 2-byte jmp instruction + 32-bit relative address + 64-bit absolute jump
- unsigned getMaxStubSize() override { return 14; }
+ unsigned getMaxStubSize() const override { return 14; }
// The target location for the relocation is described by RE.SectionID and
// RE.Offset. RE.SectionID can be used to find the SectionEntry. Each
JITSymbolResolver &Resolver)
: RuntimeDyldMachOCRTPBase(MM, Resolver) {}
- unsigned getMaxStubSize() override { return 8; }
+ unsigned getMaxStubSize() const override { return 8; }
unsigned getStubAlignment() override { return 8; }
JITSymbolResolver &Resolver)
: RuntimeDyldMachOCRTPBase(MM, Resolver) {}
- unsigned getMaxStubSize() override { return 8; }
+ unsigned getMaxStubSize() const override { return 8; }
unsigned getStubAlignment() override { return 4; }
JITSymbolResolver &Resolver)
: RuntimeDyldMachOCRTPBase(MM, Resolver) {}
- unsigned getMaxStubSize() override { return 0; }
+ unsigned getMaxStubSize() const override { return 0; }
unsigned getStubAlignment() override { return 1; }
JITSymbolResolver &Resolver)
: RuntimeDyldMachOCRTPBase(MM, Resolver) {}
- unsigned getMaxStubSize() override { return 8; }
+ unsigned getMaxStubSize() const override { return 8; }
unsigned getStubAlignment() override { return 1; }
# adrp instruction and the GOT entry for ptr. ldr encodes the offset of the GOT
# entry within the page. The ldr instruction perfroms an implicit shift on the
# encoded immediate (imm<<3).
-# rtdyld-check: *{8}(stub_addr(foo.o, __text, _ptr)) = _ptr
-# rtdyld-check: decode_operand(adrp2, 1) = (stub_addr(foo.o, __text, _ptr)[32:12] - adrp2[32:12])
-# rtdyld-check: decode_operand(ldr2, 2) = stub_addr(foo.o, __text, _ptr)[11:3]
+# rtdyld-check: *{8}(stub_addr(foo.o/__text, _ptr)) = _ptr
+# rtdyld-check: decode_operand(adrp2, 1) = (stub_addr(foo.o/__text, _ptr)[32:12] - adrp2[32:12])
+# rtdyld-check: decode_operand(ldr2, 2) = stub_addr(foo.o/__text, _ptr)[11:3]
.globl _test_adrp_ldr
.align 2
_test_got_adrp_ldr:
.quad _test_branch_reloc - _foo
# Test 32-bit relative ARM64_RELOC_POINTER_TO_GOT
-# rtdyld-check: *{4}_pointer_to_got_32_rel = (stub_addr(foo.o, __data, _dummy1) - _pointer_to_got_32_rel)
+# rtdyld-check: *{4}_pointer_to_got_32_rel = (stub_addr(foo.o/__data, _dummy1) - _pointer_to_got_32_rel)
_pointer_to_got_32_rel:
.long _dummy1@got - .
# Test 64-bit absolute ARM64_RELOC_POINTER_TO_GOT
-# rtdyld-check: *{8}_pointer_to_got_64_abs = stub_addr(foo.o, __data, _dummy1)
+# rtdyld-check: *{8}_pointer_to_got_64_abs = stub_addr(foo.o/__data, _dummy1)
_pointer_to_got_64_abs:
.quad _dummy1@got
# Check both the content of the stub, and the reference to the stub.
# Stub should contain '0xe51ff004' (ldr pc, [pc, #-4]), followed by the target.
#
-# rtdyld-check: *{4}(stub_addr(foo.o, __text, baz)) = 0xe51ff004
-# rtdyld-check: *{4}(stub_addr(foo.o, __text, baz) + 4) = baz
+# rtdyld-check: *{4}(stub_addr(foo.o/__text, baz)) = 0xe51ff004
+# rtdyld-check: *{4}(stub_addr(foo.o/__text, baz) + 4) = baz
#
-# rtdyld-check: decode_operand(insn3, 0) = stub_addr(foo.o, __text, baz) - (insn3 + 8)
+# rtdyld-check: decode_operand(insn3, 0) = stub_addr(foo.o/__text, baz) - (insn3 + 8)
insn3:
bl baz
# Check stub generation for internal symbols by referencing 'bar'.
-# rtdyld-check: *{4}(stub_addr(foo.o, __text, bar) + 4) = bar
+# rtdyld-check: *{4}(stub_addr(foo.o/__text, bar) + 4) = bar
insn4:
bl bar
bx lr
# Check that stubs for thumb callers use thumb code (not arm), and that thumb
# callees have the low bit set on their addresses.
#
-# rtdyld-check: *{4}(stub_addr(MachO_Thumb.o, __text, thumb_caller_thumb_callee)) = 0xf000f8df
-# rtdyld-check: *{4}(stub_addr(MachO_Thumb.o, __text, thumb_caller_thumb_callee) + 4) = (thumb_caller_thumb_callee | 0x1)
+# rtdyld-check: *{4}(stub_addr(MachO_Thumb.o/__text, thumb_caller_thumb_callee)) = 0xf000f8df
+# rtdyld-check: *{4}(stub_addr(MachO_Thumb.o/__text, thumb_caller_thumb_callee) + 4) = (thumb_caller_thumb_callee | 0x1)
bl thumb_caller_thumb_callee
# Check that arm callees do not have the low bit set on their addresses.
#
-# rtdyld-check: *{4}(stub_addr(MachO_Thumb.o, __text, thumb_caller_arm_callee)) = 0xf000f8df
-# rtdyld-check: *{4}(stub_addr(MachO_Thumb.o, __text, thumb_caller_arm_callee) + 4) = thumb_caller_arm_callee
+# rtdyld-check: *{4}(stub_addr(MachO_Thumb.o/__text, thumb_caller_arm_callee)) = 0xf000f8df
+# rtdyld-check: *{4}(stub_addr(MachO_Thumb.o/__text, thumb_caller_arm_callee) + 4) = thumb_caller_arm_callee
bl thumb_caller_arm_callee
.globl arm_caller
# Check that stubs for arm callers use arm code (not thumb), and that thumb
# callees have the low bit set on their addresses.
-# rtdyld-check: *{4}(stub_addr(MachO_Thumb.o, __text, arm_caller_thumb_callee)) = 0xe51ff004
-# rtdyld-check: *{4}(stub_addr(MachO_Thumb.o, __text, arm_caller_thumb_callee) + 4) = (arm_caller_thumb_callee | 0x1)
+# rtdyld-check: *{4}(stub_addr(MachO_Thumb.o/__text, arm_caller_thumb_callee)) = 0xe51ff004
+# rtdyld-check: *{4}(stub_addr(MachO_Thumb.o/__text, arm_caller_thumb_callee) + 4) = (arm_caller_thumb_callee | 0x1)
bl arm_caller_thumb_callee
nop
sd $4, 8($fp)
# Test R_MIPS_26 relocation.
-# rtdyld-check: decode_operand(insn1, 0)[27:0] = stub_addr(test_ELF_Mips64N64.o, .text, foo)[27:0]
+# rtdyld-check: decode_operand(insn1, 0)[27:0] = stub_addr(test_ELF_Mips64N64.o/.text, foo)[27:0]
insn1:
.option pic0
jal foo
sd $4, 8($fp)
# Test R_MIPS_26 relocation.
-# rtdyld-check: decode_operand(insn1, 0)[27:0] = stub_addr(test_ELF_N32.o, .text, foo)[27:0]
+# rtdyld-check: decode_operand(insn1, 0)[27:0] = stub_addr(test_ELF_N32.o/.text, foo)[27:0]
insn1:
.option pic0
jal foo
.globl bar
.type bar,@function
bar:
-# rtdyld-check: decode_operand(R_MIPS_26, 0)[27:0] = stub_addr(test_ELF_O32.o, .text, foo)[27:0]
+# rtdyld-check: decode_operand(R_MIPS_26, 0)[27:0] = stub_addr(test_ELF_O32.o/.text, foo)[27:0]
# rtdyld-check: decode_operand(R_MIPS_26, 0)[1:0] = 0
R_MIPS_26:
j foo
stdu 1, -32(1)
.cfi_def_cfa_offset 32
.cfi_offset lr, 16
-# rtdyld-check: (*{4}(stub_addr(ppc64_elf.o, .text, foo) + 0)) [15:0] = foo_gep [63:48]
-# rtdyld-check: (*{4}(stub_addr(ppc64_elf.o, .text, foo) + 4)) [15:0] = foo_gep [47:32]
-# rtdyld-check: (*{4}(stub_addr(ppc64_elf.o, .text, foo) + 12)) [15:0] = foo_gep [31:16]
-# rtdyld-check: (*{4}(stub_addr(ppc64_elf.o, .text, foo) + 16)) [15:0] = foo_gep [15:0]
-# rtdyld-check: decode_operand(foo_call, 0) = (stub_addr(ppc64_elf.o, .text, foo) - foo_call) >> 2
+# rtdyld-check: (*{4}(stub_addr(ppc64_elf.o/.text, foo) + 0)) [15:0] = foo_gep [63:48]
+# rtdyld-check: (*{4}(stub_addr(ppc64_elf.o/.text, foo) + 4)) [15:0] = foo_gep [47:32]
+# rtdyld-check: (*{4}(stub_addr(ppc64_elf.o/.text, foo) + 12)) [15:0] = foo_gep [31:16]
+# rtdyld-check: (*{4}(stub_addr(ppc64_elf.o/.text, foo) + 16)) [15:0] = foo_gep [15:0]
+# rtdyld-check: decode_operand(foo_call, 0) = (stub_addr(ppc64_elf.o/.text, foo) - foo_call) >> 2
foo_call:
bl foo
nop
# Test PC-rel GOT relocation.
# Verify both the contents of the GOT entry for y, and that the movq instruction
# references the correct GOT entry address:
-# rtdyld-check: *{8}(stub_addr(test_x86-64.o, __text, y)) = y
-# rtdyld-check: decode_operand(insn3, 4) = stub_addr(test_x86-64.o, __text, y) - next_pc(insn3)
+# rtdyld-check: *{8}(stub_addr(test_x86-64.o/__text, y)) = y
+# rtdyld-check: decode_operand(insn3, 4) = stub_addr(test_x86-64.o/__text, y) - next_pc(insn3)
insn3:
movq y@GOTPCREL(%rip), %rax
outs() << "allocateCodeSection(Size = " << Size << ", Alignment = "
<< Alignment << ", SectionName = " << SectionName << ")\n";
- dbgs() << " Registering code section \"" << SectionName << "\"\n";
if (SecIDMap)
(*SecIDMap)[SectionName] = SectionID;
outs() << "allocateDataSection(Size = " << Size << ", Alignment = "
<< Alignment << ", SectionName = " << SectionName << ")\n";
- dbgs() << " Registering code section \"" << SectionName << "\"\n";
if (SecIDMap)
(*SecIDMap)[SectionName] = SectionID;
TrivialMemoryManager MemMgr;
doPreallocation(MemMgr);
- using StubOffsets = StringMap<uint32_t>;
- using SectionStubs = StringMap<StubOffsets>;
- using FileStubs = StringMap<SectionStubs>;
+ struct StubID {
+ unsigned SectionID;
+ uint32_t Offset;
+ };
+ using StubInfos = StringMap<StubID>;
+ using StubContainers = StringMap<StubInfos>;
- FileStubs StubMap;
+ StubContainers StubMap;
RuntimeDyld Dyld(MemMgr, MemMgr);
Dyld.setProcessAllSections(true);
- Dyld.setNotifyStubEmitted(
- [&StubMap](StringRef FilePath, StringRef SectionName,
- StringRef SymbolName, uint32_t StubOffset) {
- StubMap[sys::path::filename(FilePath)][SectionName][SymbolName] =
- StubOffset;
- });
-
- auto GetSymbolAddress =
- [&Dyld, &MemMgr](StringRef Symbol) -> Expected<JITTargetAddress> {
- if (auto InternalSymbol = Dyld.getSymbol(Symbol))
- return InternalSymbol.getAddress();
-
+ Dyld.setNotifyStubEmitted([&StubMap](StringRef FilePath,
+ StringRef SectionName,
+ StringRef SymbolName, unsigned SectionID,
+ uint32_t StubOffset) {
+ std::string ContainerName =
+ (sys::path::filename(FilePath) + "/" + SectionName).str();
+ StubMap[ContainerName][SymbolName] = {SectionID, StubOffset};
+ });
+
+ auto GetSymbolInfo =
+ [&Dyld, &MemMgr](
+ StringRef Symbol) -> Expected<RuntimeDyldChecker::MemoryRegionInfo> {
+ RuntimeDyldChecker::MemoryRegionInfo SymInfo;
+
+ // First get the target address.
+ if (auto InternalSymbol = Dyld.getSymbol(Symbol))
+ SymInfo.TargetAddress = InternalSymbol.getAddress();
+ else {
+ // Symbol not found in RuntimeDyld. Fall back to external lookup.
#ifdef _MSC_VER
- using ExpectedLookupResult = MSVCPExpected<JITSymbolResolver::LookupResult>;
+ using ExpectedLookupResult =
+ MSVCPExpected<JITSymbolResolver::LookupResult>;
#else
using ExpectedLookupResult = Expected<JITSymbolResolver::LookupResult>;
#endif
auto ResultP = std::make_shared<std::promise<ExpectedLookupResult>>();
auto ResultF = ResultP->get_future();
- MemMgr.lookup(
- JITSymbolResolver::LookupSet({Symbol}),
- [=](Expected<JITSymbolResolver::LookupResult> Result) {
- ResultP->set_value(std::move(Result));
- });
+ MemMgr.lookup(JITSymbolResolver::LookupSet({Symbol}),
+ [=](Expected<JITSymbolResolver::LookupResult> Result) {
+ ResultP->set_value(std::move(Result));
+ });
auto Result = ResultF.get();
if (!Result)
auto I = Result->find(Symbol);
assert(I != Result->end() &&
"Expected symbol address if no error occurred");
- return I->second.getAddress();
- };
-
- auto IsSymbolValid =
- [&Dyld, GetSymbolAddress](StringRef Symbol) {
- if (Dyld.getSymbol(Symbol))
- return true;
- auto Addr = GetSymbolAddress(Symbol);
- if (!Addr) {
- logAllUnhandledErrors(Addr.takeError(), errs(), "RTDyldChecker: ");
- return false;
+ SymInfo.TargetAddress = I->second.getAddress();
+ }
+
+ // Now find the symbol content if possible (otherwise leave content as a
+ // default-constructed StringRef).
+ if (auto *SymAddr = Dyld.getSymbolLocalAddress(Symbol)) {
+ unsigned SectionID = Dyld.getSymbolSectionID(Symbol);
+ if (SectionID != ~0U) {
+ char *CSymAddr = static_cast<char *>(SymAddr);
+ StringRef SecContent = Dyld.getSectionContent(SectionID);
+ uint64_t SymSize = SecContent.size() - (CSymAddr - SecContent.data());
+ SymInfo.Content = StringRef(CSymAddr, SymSize);
}
- return *Addr != 0;
- };
+ }
+ return SymInfo;
+ };
+
+ auto IsSymbolValid = [&Dyld, GetSymbolInfo](StringRef Symbol) {
+ if (Dyld.getSymbol(Symbol))
+ return true;
+ auto SymInfo = GetSymbolInfo(Symbol);
+ if (!SymInfo) {
+ logAllUnhandledErrors(SymInfo.takeError(), errs(), "RTDyldChecker: ");
+ return false;
+ }
+ return SymInfo->TargetAddress != 0;
+ };
FileToSectionIDMap FileToSecIDMap;
- auto GetSectionAddress =
- [&Dyld, &FileToSecIDMap](StringRef FileName, StringRef SectionName) {
- unsigned SectionID =
- ExitOnErr(getSectionId(FileToSecIDMap, FileName, SectionName));
- return Dyld.getSectionLoadAddress(SectionID);
- };
-
- auto GetSectionContent =
- [&Dyld, &FileToSecIDMap](StringRef FileName, StringRef SectionName) {
- unsigned SectionID =
- ExitOnErr(getSectionId(FileToSecIDMap, FileName, SectionName));
- return Dyld.getSectionContent(SectionID);
- };
-
-
- auto GetSymbolContents =
- [&Dyld](StringRef Symbol) {
- auto *SymAddr = static_cast<char*>(Dyld.getSymbolLocalAddress(Symbol));
- if (!SymAddr)
- return StringRef();
- unsigned SectionID = Dyld.getSymbolSectionID(Symbol);
- if (SectionID == ~0U)
- return StringRef();
- StringRef SecContent = Dyld.getSectionContent(SectionID);
- uint64_t SymSize = SecContent.size() - (SymAddr - SecContent.data());
- return StringRef(SymAddr, SymSize);
- };
-
- auto GetStubOffset =
- [&StubMap](StringRef FileName, StringRef SectionName, StringRef SymbolName) -> Expected<uint32_t> {
- if (!StubMap.count(FileName))
- return make_error<StringError>("File name not found", inconvertibleErrorCode());
- if (!StubMap[FileName].count(SectionName))
- return make_error<StringError>("Section name not found", inconvertibleErrorCode());
- if (!StubMap[FileName][SectionName].count(SymbolName))
- return make_error<StringError>("Symbol name not found", inconvertibleErrorCode());
- return StubMap[FileName][SectionName][SymbolName];
- };
+ auto GetSectionInfo = [&Dyld, &FileToSecIDMap](StringRef FileName,
+ StringRef SectionName)
+ -> Expected<RuntimeDyldChecker::MemoryRegionInfo> {
+ auto SectionID = getSectionId(FileToSecIDMap, FileName, SectionName);
+ if (!SectionID)
+ return SectionID.takeError();
+ RuntimeDyldChecker::MemoryRegionInfo SecInfo;
+ SecInfo.TargetAddress = Dyld.getSectionLoadAddress(*SectionID);
+ SecInfo.Content = Dyld.getSectionContent(*SectionID);
+ return SecInfo;
+ };
+
+ auto GetStubInfo = [&Dyld, &StubMap](StringRef StubContainer,
+ StringRef SymbolName)
+ -> Expected<RuntimeDyldChecker::MemoryRegionInfo> {
+ if (!StubMap.count(StubContainer))
+ return make_error<StringError>("Stub container not found: " +
+ StubContainer,
+ inconvertibleErrorCode());
+ if (!StubMap[StubContainer].count(SymbolName))
+ return make_error<StringError>("Symbol name " + SymbolName +
+ " in stub container " + StubContainer,
+ inconvertibleErrorCode());
+ auto &SI = StubMap[StubContainer][SymbolName];
+ RuntimeDyldChecker::MemoryRegionInfo StubMemInfo;
+ StubMemInfo.TargetAddress =
+ Dyld.getSectionLoadAddress(SI.SectionID) + SI.Offset;
+ StubMemInfo.Content =
+ Dyld.getSectionContent(SI.SectionID).substr(SI.Offset);
+ return StubMemInfo;
+ };
// We will initialize this below once we have the first object file and can
// know the endianness.
ObjectFile &Obj = **MaybeObj;
if (!Checker)
- Checker =
- llvm::make_unique<RuntimeDyldChecker>(IsSymbolValid, GetSymbolAddress,
- GetSymbolContents,
- GetSectionAddress,
- GetSectionContent, GetStubOffset,
- Obj.isLittleEndian()
- ? support::little
- : support::big,
- Disassembler.get(),
- InstPrinter.get(), dbgs());
+ Checker = llvm::make_unique<RuntimeDyldChecker>(
+ IsSymbolValid, GetSymbolInfo, GetSectionInfo, GetStubInfo,
+ GetStubInfo, Obj.isLittleEndian() ? support::little : support::big,
+ Disassembler.get(), InstPrinter.get(), dbgs());
auto FileName = sys::path::filename(InputFile);
- dbgs() << "In " << FileName << ":\n";
MemMgr.setSectionIDsMap(&FileToSecIDMap[FileName]);
// Load the object file
projects / llvm / commitdiff