23 #define DEBUG_TYPE "rtdyld" 39 size_t EQIdx = Expr.
find(
'=');
41 ParseContext OutsideLoad(
false);
47 std::tie(LHSResult, RemainingExpr) =
48 evalComplexExpr(evalSimpleExpr(LHSExpr, OutsideLoad), OutsideLoad);
49 if (LHSResult.hasError())
50 return handleError(Expr, LHSResult);
51 if (RemainingExpr !=
"")
52 return handleError(Expr, unexpectedToken(RemainingExpr, LHSExpr,
""));
57 std::tie(RHSResult, RemainingExpr) =
58 evalComplexExpr(evalSimpleExpr(RHSExpr, OutsideLoad), OutsideLoad);
59 if (RHSResult.hasError())
60 return handleError(Expr, RHSResult);
61 if (RemainingExpr !=
"")
62 return handleError(Expr, unexpectedToken(RemainingExpr, RHSExpr,
""));
64 if (LHSResult.getValue() != RHSResult.getValue()) {
65 Checker.ErrStream <<
"Expression '" << Expr <<
"' is false: " 66 <<
format(
"0x%" PRIx64, LHSResult.getValue())
67 <<
" != " <<
format(
"0x%" PRIx64, RHSResult.getValue())
83 ParseContext(
bool IsInsideLoad) : IsInsideLoad(IsInsideLoad) {}
100 EvalResult() :
Value(0), ErrorMsg(
"") {}
101 EvalResult(uint64_t
Value) : Value(Value), ErrorMsg(
"") {}
102 EvalResult(std::string ErrorMsg)
103 : Value(0), ErrorMsg(std::move(ErrorMsg)) {}
104 uint64_t getValue()
const {
return Value; }
105 bool hasError()
const {
return ErrorMsg !=
""; }
106 const std::string &getErrorMsg()
const {
return ErrorMsg; }
110 std::string ErrorMsg;
118 if (isalpha(Expr[0]))
119 std::tie(Token, Remaining) = parseSymbol(Expr);
120 else if (isdigit(Expr[0]))
121 std::tie(Token, Remaining) = parseNumberString(Expr);
126 Token = Expr.
substr(0, TokLen);
133 std::string ErrorMsg(
"Encountered unexpected token '");
134 ErrorMsg += getTokenForError(TokenStart);
136 ErrorMsg +=
"' while parsing subexpression '";
144 return EvalResult(std::move(ErrorMsg));
147 bool handleError(
StringRef Expr,
const EvalResult &R)
const {
148 assert(R.hasError() &&
"Not an error result.");
149 Checker.ErrStream <<
"Error evaluating expression '" << Expr
150 <<
"': " << R.getErrorMsg() <<
"\n";
154 std::pair<BinOpToken, StringRef> parseBinOpToken(
StringRef Expr)
const {
156 return std::make_pair(BinOpToken::Invalid,
"");
160 return std::make_pair(BinOpToken::ShiftLeft, Expr.
substr(2).
ltrim());
162 return std::make_pair(BinOpToken::ShiftRight, Expr.
substr(2).
ltrim());
168 return std::make_pair(BinOpToken::Invalid, Expr);
170 Op = BinOpToken::Add;
173 Op = BinOpToken::Sub;
176 Op = BinOpToken::BitwiseAnd;
179 Op = BinOpToken::BitwiseOr;
186 EvalResult computeBinOpResult(BinOpToken
Op,
const EvalResult &LHSResult,
187 const EvalResult &RHSResult)
const {
191 case BinOpToken::Add:
192 return EvalResult(LHSResult.getValue() + RHSResult.getValue());
193 case BinOpToken::Sub:
194 return EvalResult(LHSResult.getValue() - RHSResult.getValue());
195 case BinOpToken::BitwiseAnd:
196 return EvalResult(LHSResult.getValue() & RHSResult.getValue());
197 case BinOpToken::BitwiseOr:
198 return EvalResult(LHSResult.getValue() | RHSResult.getValue());
199 case BinOpToken::ShiftLeft:
200 return EvalResult(LHSResult.getValue() << RHSResult.getValue());
201 case BinOpToken::ShiftRight:
202 return EvalResult(LHSResult.getValue() >> RHSResult.getValue());
208 std::pair<StringRef, StringRef> parseSymbol(
StringRef Expr)
const {
210 "abcdefghijklmnopqrstuvwxyz" 211 "ABCDEFGHIJKLMNOPQRSTUVWXYZ" 213 return std::make_pair(Expr.
substr(0, FirstNonSymbol),
223 std::pair<EvalResult, StringRef> evalDecodeOperand(
StringRef Expr)
const {
225 return std::make_pair(unexpectedToken(Expr, Expr,
"expected '('"),
"");
228 std::tie(Symbol, RemainingExpr) = parseSymbol(RemainingExpr);
230 if (!Checker.isSymbolValid(Symbol))
231 return std::make_pair(
232 EvalResult((
"Cannot decode unknown symbol '" + Symbol +
"'").str()),
236 return std::make_pair(
237 unexpectedToken(RemainingExpr, RemainingExpr,
"expected ','"),
"");
240 EvalResult OpIdxExpr;
241 std::tie(OpIdxExpr, RemainingExpr) = evalNumberExpr(RemainingExpr);
242 if (OpIdxExpr.hasError())
243 return std::make_pair(OpIdxExpr,
"");
246 return std::make_pair(
247 unexpectedToken(RemainingExpr, RemainingExpr,
"expected ')'"),
"");
252 if (!decodeInst(Symbol, Inst, Size))
253 return std::make_pair(
254 EvalResult((
"Couldn't decode instruction at '" + Symbol +
"'").str()),
257 unsigned OpIdx = OpIdxExpr.getValue();
261 ErrMsgStream <<
"Invalid operand index '" <<
format(
"%i", OpIdx)
262 <<
"' for instruction '" << Symbol
263 <<
"'. Instruction has only " 265 <<
" operands.\nInstruction is:\n ";
266 Inst.
dump_pretty(ErrMsgStream, Checker.InstPrinter);
267 return std::make_pair(EvalResult(ErrMsgStream.
str()),
"");
274 ErrMsgStream <<
"Operand '" <<
format(
"%i", OpIdx) <<
"' of instruction '" 275 << Symbol <<
"' is not an immediate.\nInstruction is:\n ";
276 Inst.
dump_pretty(ErrMsgStream, Checker.InstPrinter);
278 return std::make_pair(EvalResult(ErrMsgStream.
str()),
"");
281 return std::make_pair(EvalResult(Op.
getImm()), RemainingExpr);
290 std::pair<EvalResult, StringRef> evalNextPC(
StringRef Expr,
291 ParseContext PCtx)
const {
293 return std::make_pair(unexpectedToken(Expr, Expr,
"expected '('"),
"");
296 std::tie(Symbol, RemainingExpr) = parseSymbol(RemainingExpr);
298 if (!Checker.isSymbolValid(Symbol))
299 return std::make_pair(
300 EvalResult((
"Cannot decode unknown symbol '" + Symbol +
"'").str()),
304 return std::make_pair(
305 unexpectedToken(RemainingExpr, RemainingExpr,
"expected ')'"),
"");
310 if (!decodeInst(Symbol, Inst, InstSize))
311 return std::make_pair(
312 EvalResult((
"Couldn't decode instruction at '" + Symbol +
"'").str()),
315 uint64_t SymbolAddr = PCtx.IsInsideLoad
316 ? Checker.getSymbolLocalAddr(Symbol)
317 : Checker.getSymbolRemoteAddr(Symbol);
318 uint64_t NextPC = SymbolAddr + InstSize;
320 return std::make_pair(EvalResult(NextPC), RemainingExpr);
328 std::pair<EvalResult, StringRef> evalStubAddr(
StringRef Expr,
329 ParseContext PCtx)
const {
331 return std::make_pair(unexpectedToken(Expr, Expr,
"expected '('"),
"");
337 size_t ComaIdx = RemainingExpr.
find(
',');
338 FileName = RemainingExpr.
substr(0, ComaIdx).
rtrim();
339 RemainingExpr = RemainingExpr.
substr(ComaIdx).
ltrim();
342 return std::make_pair(
343 unexpectedToken(RemainingExpr, Expr,
"expected ','"),
"");
347 std::tie(SectionName, RemainingExpr) = parseSymbol(RemainingExpr);
350 return std::make_pair(
351 unexpectedToken(RemainingExpr, Expr,
"expected ','"),
"");
355 std::tie(Symbol, RemainingExpr) = parseSymbol(RemainingExpr);
358 return std::make_pair(
359 unexpectedToken(RemainingExpr, Expr,
"expected ')'"),
"");
363 std::string ErrorMsg =
"";
364 std::tie(StubAddr, ErrorMsg) = Checker.getStubAddrFor(
365 FileName, SectionName, Symbol, PCtx.IsInsideLoad);
368 return std::make_pair(EvalResult(ErrorMsg),
"");
370 return std::make_pair(EvalResult(StubAddr), RemainingExpr);
373 std::pair<EvalResult, StringRef> evalSectionAddr(
StringRef Expr,
374 ParseContext PCtx)
const {
376 return std::make_pair(unexpectedToken(Expr, Expr,
"expected '('"),
"");
382 size_t ComaIdx = RemainingExpr.
find(
',');
383 FileName = RemainingExpr.
substr(0, ComaIdx).
rtrim();
384 RemainingExpr = RemainingExpr.
substr(ComaIdx).
ltrim();
387 return std::make_pair(
388 unexpectedToken(RemainingExpr, Expr,
"expected ','"),
"");
392 std::tie(SectionName, RemainingExpr) = parseSymbol(RemainingExpr);
395 return std::make_pair(
396 unexpectedToken(RemainingExpr, Expr,
"expected ')'"),
"");
400 std::string ErrorMsg =
"";
401 std::tie(StubAddr, ErrorMsg) = Checker.getSectionAddr(
402 FileName, SectionName, PCtx.IsInsideLoad);
405 return std::make_pair(EvalResult(ErrorMsg),
"");
407 return std::make_pair(EvalResult(StubAddr), RemainingExpr);
413 std::pair<EvalResult, StringRef> evalIdentifierExpr(
StringRef Expr,
414 ParseContext PCtx)
const {
417 std::tie(Symbol, RemainingExpr) = parseSymbol(Expr);
420 if (Symbol ==
"decode_operand")
421 return evalDecodeOperand(RemainingExpr);
422 else if (Symbol ==
"next_pc")
423 return evalNextPC(RemainingExpr, PCtx);
424 else if (Symbol ==
"stub_addr")
425 return evalStubAddr(RemainingExpr, PCtx);
426 else if (Symbol ==
"section_addr")
427 return evalSectionAddr(RemainingExpr, PCtx);
429 if (!Checker.isSymbolValid(Symbol)) {
430 std::string ErrMsg(
"No known address for symbol '");
434 ErrMsg +=
" (this appears to be an assembler local label - " 435 " perhaps drop the 'L'?)";
437 return std::make_pair(EvalResult(ErrMsg),
"");
443 uint64_t
Value = PCtx.IsInsideLoad ? Checker.getSymbolLocalAddr(Symbol)
444 : Checker.getSymbolRemoteAddr(Symbol);
447 return std::make_pair(EvalResult(Value), RemainingExpr);
452 std::pair<StringRef, StringRef> parseNumberString(
StringRef Expr)
const {
457 FirstNonDigit = Expr.
size();
461 FirstNonDigit = Expr.
size();
463 return std::make_pair(Expr.
substr(0, FirstNonDigit),
464 Expr.
substr(FirstNonDigit));
470 std::pair<EvalResult, StringRef> evalNumberExpr(
StringRef Expr)
const {
473 std::tie(ValueStr, RemainingExpr) = parseNumberString(Expr);
475 if (ValueStr.
empty() || !isdigit(ValueStr[0]))
476 return std::make_pair(
477 unexpectedToken(RemainingExpr, RemainingExpr,
"expected number"),
"");
480 return std::make_pair(EvalResult(Value), RemainingExpr);
486 std::pair<EvalResult, StringRef> evalParensExpr(
StringRef Expr,
487 ParseContext PCtx)
const {
489 EvalResult SubExprResult;
491 std::tie(SubExprResult, RemainingExpr) =
492 evalComplexExpr(evalSimpleExpr(Expr.
substr(1).
ltrim(), PCtx), PCtx);
493 if (SubExprResult.hasError())
494 return std::make_pair(SubExprResult,
"");
496 return std::make_pair(
497 unexpectedToken(RemainingExpr, Expr,
"expected ')'"),
"");
499 return std::make_pair(SubExprResult, RemainingExpr);
506 std::pair<EvalResult, StringRef> evalLoadExpr(
StringRef Expr)
const {
511 if (!RemainingExpr.startswith(
"{"))
512 return std::make_pair(EvalResult(
"Expected '{' following '*'."),
"");
514 EvalResult ReadSizeExpr;
515 std::tie(ReadSizeExpr, RemainingExpr) = evalNumberExpr(RemainingExpr);
516 if (ReadSizeExpr.hasError())
517 return std::make_pair(ReadSizeExpr, RemainingExpr);
518 uint64_t ReadSize = ReadSizeExpr.getValue();
519 if (ReadSize < 1 || ReadSize > 8)
520 return std::make_pair(EvalResult(
"Invalid size for dereference."),
"");
521 if (!RemainingExpr.startswith(
"}"))
522 return std::make_pair(EvalResult(
"Missing '}' for dereference."),
"");
523 RemainingExpr = RemainingExpr.substr(1).ltrim();
526 ParseContext LoadCtx(
true);
527 EvalResult LoadAddrExprResult;
528 std::tie(LoadAddrExprResult, RemainingExpr) =
529 evalComplexExpr(evalSimpleExpr(RemainingExpr, LoadCtx), LoadCtx);
531 if (LoadAddrExprResult.hasError())
532 return std::make_pair(LoadAddrExprResult,
"");
534 uint64_t LoadAddr = LoadAddrExprResult.getValue();
536 return std::make_pair(
537 EvalResult(Checker.readMemoryAtAddr(LoadAddr, ReadSize)),
548 std::pair<EvalResult, StringRef> evalSimpleExpr(
StringRef Expr,
549 ParseContext PCtx)
const {
550 EvalResult SubExprResult;
554 return std::make_pair(EvalResult(
"Unexpected end of expression"),
"");
557 std::tie(SubExprResult, RemainingExpr) = evalParensExpr(Expr, PCtx);
558 else if (Expr[0] ==
'*')
559 std::tie(SubExprResult, RemainingExpr) = evalLoadExpr(Expr);
560 else if (isalpha(Expr[0]) || Expr[0] ==
'_')
561 std::tie(SubExprResult, RemainingExpr) = evalIdentifierExpr(Expr, PCtx);
562 else if (isdigit(Expr[0]))
563 std::tie(SubExprResult, RemainingExpr) = evalNumberExpr(Expr);
565 return std::make_pair(
566 unexpectedToken(Expr, Expr,
567 "expected '(', '*', identifier, or number"),
"");
569 if (SubExprResult.hasError())
570 return std::make_pair(SubExprResult, RemainingExpr);
574 std::tie(SubExprResult, RemainingExpr) =
575 evalSliceExpr(std::make_pair(SubExprResult, RemainingExpr));
577 return std::make_pair(SubExprResult, RemainingExpr);
587 std::pair<EvalResult, StringRef>
588 evalSliceExpr(
const std::pair<EvalResult, StringRef> &Ctx)
const {
589 EvalResult SubExprResult;
591 std::tie(SubExprResult, RemainingExpr) = Ctx;
596 EvalResult HighBitExpr;
597 std::tie(HighBitExpr, RemainingExpr) = evalNumberExpr(RemainingExpr);
599 if (HighBitExpr.hasError())
600 return std::make_pair(HighBitExpr, RemainingExpr);
602 if (!RemainingExpr.startswith(
":"))
603 return std::make_pair(
604 unexpectedToken(RemainingExpr, RemainingExpr,
"expected ':'"),
"");
605 RemainingExpr = RemainingExpr.substr(1).ltrim();
607 EvalResult LowBitExpr;
608 std::tie(LowBitExpr, RemainingExpr) = evalNumberExpr(RemainingExpr);
610 if (LowBitExpr.hasError())
611 return std::make_pair(LowBitExpr, RemainingExpr);
613 if (!RemainingExpr.startswith(
"]"))
614 return std::make_pair(
615 unexpectedToken(RemainingExpr, RemainingExpr,
"expected ']'"),
"");
616 RemainingExpr = RemainingExpr.substr(1).ltrim();
618 unsigned HighBit = HighBitExpr.getValue();
619 unsigned LowBit = LowBitExpr.getValue();
620 uint64_t
Mask = ((uint64_t)1 << (HighBit - LowBit + 1)) - 1;
621 uint64_t SlicedValue = (SubExprResult.getValue() >> LowBit) & Mask;
622 return std::make_pair(EvalResult(SlicedValue), RemainingExpr);
631 std::pair<EvalResult, StringRef>
632 evalComplexExpr(
const std::pair<EvalResult, StringRef> &LHSAndRemaining,
633 ParseContext PCtx)
const {
634 EvalResult LHSResult;
636 std::tie(LHSResult, RemainingExpr) = LHSAndRemaining;
640 if (LHSResult.hasError() || RemainingExpr ==
"")
641 return std::make_pair(LHSResult, RemainingExpr);
645 std::tie(BinOp, RemainingExpr) = parseBinOpToken(RemainingExpr);
648 if (BinOp == BinOpToken::Invalid)
649 return std::make_pair(LHSResult, RemainingExpr);
652 EvalResult RHSResult;
653 std::tie(RHSResult, RemainingExpr) = evalSimpleExpr(RemainingExpr, PCtx);
656 if (RHSResult.hasError())
657 return std::make_pair(RHSResult, RemainingExpr);
661 EvalResult ThisResult(computeBinOpResult(BinOp, LHSResult, RHSResult));
663 return evalComplexExpr(std::make_pair(ThisResult, RemainingExpr), PCtx);
668 StringRef SectionMem = Checker.getSubsectionStartingAt(Symbol);
670 reinterpret_cast<const uint8_t *>(SectionMem.
data()),
685 : RTDyld(RTDyld), Disassembler(Disassembler), InstPrinter(InstPrinter),
686 ErrStream(ErrStream) {
687 RTDyld.Checker =
this;
691 CheckExpr = CheckExpr.
trim();
692 LLVM_DEBUG(
dbgs() <<
"RuntimeDyldChecker: Checking '" << CheckExpr
695 bool Result = P.
evaluate(CheckExpr);
698 << (Result ?
"passed" :
"FAILED") <<
".\n");
704 bool DidAllTestsPass =
true;
705 unsigned NumRules = 0;
710 while (LineStart != MemBuf->
getBufferEnd() && std::isspace(*LineStart))
713 while (LineStart != MemBuf->
getBufferEnd() && *LineStart !=
'\0') {
714 const char *LineEnd = LineStart;
715 while (LineEnd != MemBuf->
getBufferEnd() && *LineEnd !=
'\r' &&
719 StringRef Line(LineStart, LineEnd - LineStart);
727 while (LineStart != MemBuf->
getBufferEnd() && std::isspace(*LineStart))
730 return DidAllTestsPass && (NumRules != 0);
742 auto ResultP = std::make_shared<std::promise<ExpectedLookupResult>>();
743 auto ResultF = ResultP->get_future();
747 ResultP->set_value(std::move(Result));
749 return ResultF.get();
755 auto Result = lookup({Symbol});
762 assert(Result->count(Symbol) &&
"Missing symbol result");
766 uint64_t RuntimeDyldCheckerImpl::getSymbolLocalAddr(
StringRef Symbol)
const {
767 return static_cast<uint64_t
>(
771 uint64_t RuntimeDyldCheckerImpl::getSymbolRemoteAddr(
StringRef Symbol)
const {
772 if (
auto InternalSymbol = getRTDyld().
getSymbol(Symbol))
773 return InternalSymbol.getAddress();
775 auto Result = lookup({Symbol});
780 auto I = Result->find(Symbol);
781 assert(
I != Result->end() &&
"Missing symbol result");
782 return I->second.getAddress();
785 uint64_t RuntimeDyldCheckerImpl::readMemoryAtAddr(uint64_t SrcAddr,
786 unsigned Size)
const {
787 uintptr_t PtrSizedAddr =
static_cast<uintptr_t
>(SrcAddr);
788 assert(PtrSizedAddr == SrcAddr &&
"Linker memory pointer out-of-range.");
789 uint8_t *Src =
reinterpret_cast<uint8_t*
>(PtrSizedAddr);
794 std::pair<const RuntimeDyldCheckerImpl::SectionAddressInfo*, std::string>
795 RuntimeDyldCheckerImpl::findSectionAddrInfo(
StringRef FileName,
798 auto SectionMapItr = Stubs.find(FileName);
799 if (SectionMapItr == Stubs.end()) {
800 std::string ErrorMsg =
"File '";
801 ErrorMsg += FileName;
802 ErrorMsg +=
"' not found. ";
804 ErrorMsg +=
"No stubs registered.";
806 ErrorMsg +=
"Available files are:";
807 for (
const auto& StubEntry : Stubs) {
809 ErrorMsg += StubEntry.first;
814 return std::make_pair(
nullptr, ErrorMsg);
817 auto SectionInfoItr = SectionMapItr->second.find(SectionName);
818 if (SectionInfoItr == SectionMapItr->second.end())
819 return std::make_pair(
nullptr,
820 (
"Section '" + SectionName +
"' not found in file '" +
821 FileName +
"'\n").str());
823 return std::make_pair(&SectionInfoItr->second, std::string(
""));
826 std::pair<uint64_t, std::string> RuntimeDyldCheckerImpl::getSectionAddr(
829 const SectionAddressInfo *SectionInfo =
nullptr;
831 std::string ErrorMsg;
832 std::tie(SectionInfo, ErrorMsg) =
833 findSectionAddrInfo(FileName, SectionName);
835 return std::make_pair(0, ErrorMsg);
838 unsigned SectionID = SectionInfo->SectionID;
841 Addr =
static_cast<uint64_t
>(
reinterpret_cast<uintptr_t
>(
842 getRTDyld().
Sections[SectionID].getAddress()));
844 Addr = getRTDyld().
Sections[SectionID].getLoadAddress();
846 return std::make_pair(Addr, std::string(
""));
849 std::pair<uint64_t, std::string> RuntimeDyldCheckerImpl::getStubAddrFor(
851 bool IsInsideLoad)
const {
853 const SectionAddressInfo *SectionInfo =
nullptr;
855 std::string ErrorMsg;
856 std::tie(SectionInfo, ErrorMsg) =
857 findSectionAddrInfo(FileName, SectionName);
859 return std::make_pair(0, ErrorMsg);
862 unsigned SectionID = SectionInfo->SectionID;
863 const StubOffsetsMap &SymbolStubs = SectionInfo->StubOffsets;
864 auto StubOffsetItr = SymbolStubs.find(SymbolName);
865 if (StubOffsetItr == SymbolStubs.end())
866 return std::make_pair(0,
867 (
"Stub for symbol '" + SymbolName +
"' not found. " 868 "If '" + SymbolName +
"' is an internal symbol this " 869 "may indicate that the stub target offset is being " 870 "computed incorrectly.\n").str());
872 uint64_t StubOffset = StubOffsetItr->second;
876 uintptr_t SectionBase =
reinterpret_cast<uintptr_t
>(
877 getRTDyld().
Sections[SectionID].getAddress());
878 Addr =
static_cast<uint64_t
>(SectionBase) + StubOffset;
880 uint64_t SectionBase = getRTDyld().
Sections[SectionID].getLoadAddress();
881 Addr = SectionBase + StubOffset;
884 return std::make_pair(Addr, std::string(
""));
888 RuntimeDyldCheckerImpl::getSubsectionStartingAt(
StringRef Name)
const {
891 if (pos == getRTDyld().GlobalSymbolTable.end())
893 const auto &
SymInfo = pos->second;
895 return StringRef(reinterpret_cast<const char *>(SectionAddr) +
902 RuntimeDyldCheckerImpl::getSectionLoadAddress(
void *LocalAddress)
const {
903 for (
auto &S : getRTDyld().Sections) {
904 if (S.getAddress() == LocalAddress)
905 return S.getLoadAddress();
910 void RuntimeDyldCheckerImpl::registerSection(
911 StringRef FilePath,
unsigned SectionID) {
916 Stubs[FileName][
SectionName].SectionID = SectionID;
919 void RuntimeDyldCheckerImpl::registerStubMap(
926 Stubs[FileName][
SectionName].SectionID = SectionID;
928 for (
auto &StubMapEntry : RTDyldStubs) {
929 std::string SymbolName =
"";
931 if (StubMapEntry.first.SymbolName)
932 SymbolName = StubMapEntry.first.SymbolName;
936 for (
auto &GSTEntry : getRTDyld().GlobalSymbolTable) {
937 const auto &
SymInfo = GSTEntry.second;
938 if (
SymInfo.getSectionID() == StubMapEntry.first.SectionID &&
940 static_cast<uint64_t
>(StubMapEntry.first.Offset)) {
941 SymbolName = GSTEntry.first();
947 if (SymbolName !=
"")
958 InstPrinter, ErrStream)) {}
971 return Impl->check(CheckExpr);
976 return Impl->checkAllRulesInBuffer(RulePrefix, MemBuf);
979 std::pair<uint64_t, std::string>
982 return Impl->getSectionAddr(FileName, SectionName, LocalAddress);
987 return Impl->getSectionLoadAddress(LocalAddress);
uint8_t * getSymbolLocalAddress(StringRef Name) const
raw_ostream & errs()
This returns a reference to a raw_ostream for standard error.
bool checkAllRulesInBuffer(StringRef RulePrefix, MemoryBuffer *MemBuf) const
Scan the given memory buffer for lines beginning with the string in RulePrefix.
bool checkAllRulesInBuffer(StringRef RulePrefix, MemoryBuffer *MemBuf) const
This class represents lattice values for constants.
RuntimeDyldCheckerImpl(RuntimeDyld &RTDyld, MCDisassembler *Disassembler, MCInstPrinter *InstPrinter, llvm::raw_ostream &ErrStream)
DecodeStatus
Ternary decode status.
amdgpu Simplify well known AMD library false FunctionCallee Value const Twine & Name
Superclass for all disassemblers.
LLVM_NODISCARD bool startswith(StringRef Prefix) const
Check if this string starts with the given Prefix.
uint64_t readBytesUnaligned(uint8_t *Src, unsigned Size) const
Endian-aware read Read the least significant Size bytes from Src.
void dump_pretty(raw_ostream &OS, const MCInstPrinter *Printer=nullptr, StringRef Separator=" ") const
Dump the MCInst as prettily as possible using the additional MC structures, if given.
format_object< Ts... > format(const char *Fmt, const Ts &... Vals)
These are helper functions used to produce formatted output.
iterator find(StringRef Key)
RuntimeDyld & getRTDyld()
LLVM_NODISCARD StringRef ltrim(char Char) const
Return string with consecutive Char characters starting from the the left removed.
std::enable_if<!std::is_array< T >::value, std::unique_ptr< T > >::type make_unique(Args &&... args)
Constructs a new T() with the given args and returns a unique_ptr<T> which owns the object...
std::set< StringRef > LookupSet
RuntimeDyldCheckerExprEval(const RuntimeDyldCheckerImpl &Checker, raw_ostream &ErrStream)
constexpr char SymbolName[]
Key for Kernel::Metadata::mSymbolName.
std::map< RelocationValueRef, uintptr_t > StubMap
Tagged union holding either a T or a Error.
LLVM_NODISCARD StringRef substr(size_t Start, size_t N=npos) const
Return a reference to the substring from [Start, Start + N).
LLVM_NODISCARD bool empty() const
empty - Check if the string is empty.
LLVM_NODISCARD size_t size() const
size - Get the string size.
Expected< const typename ELFT::Sym * > getSymbol(typename ELFT::SymRange Symbols, uint32_t Index)
Instances of this class represent a single low-level machine instruction.
Optional< uint64_t > getSectionLoadAddress(void *LocalAddress) const
If there is a section at the given local address, return its load address, otherwise return none...
std::pair< uint64_t, std::string > getSectionAddr(StringRef FileName, StringRef SectionName, bool LocalAddress)
Returns the address of the requested section (or an error message in the second element of the pair i...
LLVM_NODISCARD StringRef trim(char Char) const
Return string with consecutive Char characters starting from the left and right removed.
LLVM_NODISCARD size_t find_first_not_of(char C, size_t From=0) const
Find the first character in the string that is not C or npos if not found.
bool check(StringRef CheckExpr) const
Check a single expression against the attached RuntimeDyld instance.
LLVM_NODISCARD size_t find(char C, size_t From=0) const
Search for the first character C in the string.
unsigned getNumOperands() const
virtual void lookup(const LookupSet &Symbols, OnResolvedFunction OnResolved)=0
Returns the fully resolved address and flags for each of the given symbols.
uint8_t * getSectionAddress(unsigned SectionID) const
void logAllUnhandledErrors(Error E, raw_ostream &OS, Twine ErrorBanner={})
Log all errors (if any) in E to OS.
std::string & str()
Flushes the stream contents to the target string and returns the string's reference.
#define llvm_unreachable(msg)
Marks that the current location is not supposed to be reachable.
std::enable_if< std::numeric_limits< T >::is_signed, bool >::type getAsInteger(unsigned Radix, T &Result) const
Parse the current string as an integer of the specified radix.
const MCOperand & getOperand(unsigned i) const
JITSymbolResolver & Resolver
This interface provides simple read-only access to a block of memory, and provides simple methods for...
raw_ostream & dbgs()
dbgs() - This returns a reference to a raw_ostream for debugging messages.
bool evaluate(StringRef Expr) const
const char * getBufferEnd() const
This is an instance of a target assembly language printer that converts an MCInst to valid target ass...
StringRef filename(StringRef path, Style style=Style::native)
Get filename.
const char * getBufferStart() const
bool check(StringRef CheckExpr) const
StringRef getName() const
SymInfo contains information about symbol: it's address and section index which is -1LL for absolute ...
SectionEntry - represents a section emitted into memory by the dynamic linker.
LLVM_NODISCARD const char * data() const
data - Get a pointer to the start of the string (which may not be null terminated).
assert(ImpDefSCC.getReg()==AMDGPU::SCC &&ImpDefSCC.isDef())
A raw_ostream that writes to an std::string.
LLVM Value Representation.
RuntimeDyldChecker(RuntimeDyld &RTDyld, MCDisassembler *Disassembler, MCInstPrinter *InstPrinter, raw_ostream &ErrStream)
RTDyldSymbolTable GlobalSymbolTable
raw_ostream & nulls()
This returns a reference to a raw_ostream which simply discards output.
std::underlying_type< E >::type Mask()
Get a bitmask with 1s in all places up to the high-order bit of E's largest value.
This class implements an extremely fast bulk output stream that can only output to a stream...
LLVM_NODISCARD StringRef rtrim(char Char) const
Return string with consecutive Char characters starting from the right removed.
StringRef - Represent a constant reference to a string, i.e.
virtual DecodeStatus getInstruction(MCInst &Instr, uint64_t &Size, ArrayRef< uint8_t > Bytes, uint64_t Address, raw_ostream &VStream, raw_ostream &CStream) const =0
Returns the disassembly of a single instruction.
Instances of this class represent operands of the MCInst class.