22 #define DEBUG_TYPE "rtdyld"
38 size_t EQIdx = Expr.
find(
'=');
40 ParseContext OutsideLoad(
false);
46 std::tie(LHSResult, RemainingExpr) =
47 evalComplexExpr(evalSimpleExpr(LHSExpr, OutsideLoad), OutsideLoad);
48 if (LHSResult.hasError())
49 return handleError(Expr, LHSResult);
50 if (RemainingExpr !=
"")
51 return handleError(Expr, unexpectedToken(RemainingExpr, LHSExpr,
""));
56 std::tie(RHSResult, RemainingExpr) =
57 evalComplexExpr(evalSimpleExpr(RHSExpr, OutsideLoad), OutsideLoad);
58 if (RHSResult.hasError())
59 return handleError(Expr, RHSResult);
60 if (RemainingExpr !=
"")
61 return handleError(Expr, unexpectedToken(RemainingExpr, RHSExpr,
""));
63 if (LHSResult.getValue() != RHSResult.getValue()) {
64 Checker.ErrStream <<
"Expression '" << Expr <<
"' is false: "
65 <<
format(
"0x%" PRIx64, LHSResult.getValue())
66 <<
" != " <<
format(
"0x%" PRIx64, RHSResult.getValue())
82 ParseContext(
bool IsInsideLoad) : IsInsideLoad(IsInsideLoad) {}
99 EvalResult() :
Value(0), ErrorMsg(
"") {}
100 EvalResult(uint64_t
Value) : Value(Value), ErrorMsg(
"") {}
101 EvalResult(std::string ErrorMsg)
102 :
Value(0), ErrorMsg(std::move(ErrorMsg)) {}
103 uint64_t getValue()
const {
return Value; }
104 bool hasError()
const {
return ErrorMsg !=
""; }
105 const std::string &getErrorMsg()
const {
return ErrorMsg; }
109 std::string ErrorMsg;
117 if (isalpha(Expr[0]))
118 std::tie(Token, Remaining) = parseSymbol(Expr);
119 else if (isdigit(Expr[0]))
120 std::tie(Token, Remaining) = parseNumberString(Expr);
125 Token = Expr.
substr(0, TokLen);
132 std::string ErrorMsg(
"Encountered unexpected token '");
133 ErrorMsg += getTokenForError(TokenStart);
135 ErrorMsg +=
"' while parsing subexpression '";
143 return EvalResult(std::move(ErrorMsg));
146 bool handleError(
StringRef Expr,
const EvalResult &R)
const {
147 assert(R.hasError() &&
"Not an error result.");
148 Checker.ErrStream <<
"Error evaluating expression '" << Expr
149 <<
"': " << R.getErrorMsg() <<
"\n";
153 std::pair<BinOpToken, StringRef> parseBinOpToken(
StringRef Expr)
const {
185 EvalResult computeBinOpResult(BinOpToken Op,
const EvalResult &LHSResult,
186 const EvalResult &RHSResult)
const {
191 return EvalResult(LHSResult.getValue() + RHSResult.getValue());
193 return EvalResult(LHSResult.getValue() - RHSResult.getValue());
195 return EvalResult(LHSResult.getValue() & RHSResult.getValue());
197 return EvalResult(LHSResult.getValue() | RHSResult.getValue());
199 return EvalResult(LHSResult.getValue() << RHSResult.getValue());
201 return EvalResult(LHSResult.getValue() >> RHSResult.getValue());
207 std::pair<StringRef, StringRef> parseSymbol(
StringRef Expr)
const {
209 "abcdefghijklmnopqrstuvwxyz"
210 "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
212 return std::make_pair(Expr.
substr(0, FirstNonSymbol),
222 std::pair<EvalResult, StringRef> evalDecodeOperand(
StringRef Expr)
const {
224 return std::make_pair(unexpectedToken(Expr, Expr,
"expected '('"),
"");
227 std::tie(Symbol, RemainingExpr) = parseSymbol(RemainingExpr);
229 if (!Checker.isSymbolValid(Symbol))
230 return std::make_pair(
231 EvalResult((
"Cannot decode unknown symbol '" + Symbol +
"'").str()),
235 return std::make_pair(
236 unexpectedToken(RemainingExpr, RemainingExpr,
"expected ','"),
"");
239 EvalResult OpIdxExpr;
240 std::tie(OpIdxExpr, RemainingExpr) = evalNumberExpr(RemainingExpr);
241 if (OpIdxExpr.hasError())
242 return std::make_pair(OpIdxExpr,
"");
245 return std::make_pair(
246 unexpectedToken(RemainingExpr, RemainingExpr,
"expected ')'"),
"");
251 if (!decodeInst(Symbol, Inst, Size))
252 return std::make_pair(
253 EvalResult((
"Couldn't decode instruction at '" + Symbol +
"'").str()),
256 unsigned OpIdx = OpIdxExpr.getValue();
260 ErrMsgStream <<
"Invalid operand index '" <<
format(
"%i", OpIdx)
261 <<
"' for instruction '" << Symbol
262 <<
"'. Instruction has only "
264 <<
" operands.\nInstruction is:\n ";
265 Inst.
dump_pretty(ErrMsgStream, Checker.InstPrinter);
266 return std::make_pair(EvalResult(ErrMsgStream.str()),
"");
273 ErrMsgStream <<
"Operand '" <<
format(
"%i", OpIdx) <<
"' of instruction '"
274 << Symbol <<
"' is not an immediate.\nInstruction is:\n ";
275 Inst.
dump_pretty(ErrMsgStream, Checker.InstPrinter);
277 return std::make_pair(EvalResult(ErrMsgStream.str()),
"");
280 return std::make_pair(EvalResult(Op.
getImm()), RemainingExpr);
289 std::pair<EvalResult, StringRef> evalNextPC(
StringRef Expr,
290 ParseContext PCtx)
const {
292 return std::make_pair(unexpectedToken(Expr, Expr,
"expected '('"),
"");
295 std::tie(Symbol, RemainingExpr) = parseSymbol(RemainingExpr);
297 if (!Checker.isSymbolValid(Symbol))
298 return std::make_pair(
299 EvalResult((
"Cannot decode unknown symbol '" + Symbol +
"'").str()),
303 return std::make_pair(
304 unexpectedToken(RemainingExpr, RemainingExpr,
"expected ')'"),
"");
309 if (!decodeInst(Symbol, Inst, InstSize))
310 return std::make_pair(
311 EvalResult((
"Couldn't decode instruction at '" + Symbol +
"'").str()),
314 uint64_t SymbolAddr = PCtx.IsInsideLoad
315 ? Checker.getSymbolLocalAddr(Symbol)
316 : Checker.getSymbolRemoteAddr(Symbol);
317 uint64_t NextPC = SymbolAddr + InstSize;
319 return std::make_pair(EvalResult(NextPC), RemainingExpr);
327 std::pair<EvalResult, StringRef> evalStubAddr(
StringRef Expr,
328 ParseContext PCtx)
const {
330 return std::make_pair(unexpectedToken(Expr, Expr,
"expected '('"),
"");
336 size_t ComaIdx = RemainingExpr.
find(
',');
337 FileName = RemainingExpr.
substr(0, ComaIdx).
rtrim();
338 RemainingExpr = RemainingExpr.
substr(ComaIdx).
ltrim();
341 return std::make_pair(
342 unexpectedToken(RemainingExpr, Expr,
"expected ','"),
"");
346 std::tie(SectionName, RemainingExpr) = parseSymbol(RemainingExpr);
349 return std::make_pair(
350 unexpectedToken(RemainingExpr, Expr,
"expected ','"),
"");
354 std::tie(Symbol, RemainingExpr) = parseSymbol(RemainingExpr);
357 return std::make_pair(
358 unexpectedToken(RemainingExpr, Expr,
"expected ')'"),
"");
362 std::string ErrorMsg =
"";
363 std::tie(StubAddr, ErrorMsg) = Checker.getStubAddrFor(
364 FileName, SectionName, Symbol, PCtx.IsInsideLoad);
367 return std::make_pair(EvalResult(ErrorMsg),
"");
369 return std::make_pair(EvalResult(StubAddr), RemainingExpr);
372 std::pair<EvalResult, StringRef> evalSectionAddr(
StringRef Expr,
373 ParseContext PCtx)
const {
375 return std::make_pair(unexpectedToken(Expr, Expr,
"expected '('"),
"");
381 size_t ComaIdx = RemainingExpr.
find(
',');
382 FileName = RemainingExpr.
substr(0, ComaIdx).
rtrim();
383 RemainingExpr = RemainingExpr.
substr(ComaIdx).
ltrim();
386 return std::make_pair(
387 unexpectedToken(RemainingExpr, Expr,
"expected ','"),
"");
391 std::tie(SectionName, RemainingExpr) = parseSymbol(RemainingExpr);
394 return std::make_pair(
395 unexpectedToken(RemainingExpr, Expr,
"expected ')'"),
"");
399 std::string ErrorMsg =
"";
400 std::tie(StubAddr, ErrorMsg) = Checker.getSectionAddr(
401 FileName, SectionName, PCtx.IsInsideLoad);
404 return std::make_pair(EvalResult(ErrorMsg),
"");
406 return std::make_pair(EvalResult(StubAddr), RemainingExpr);
412 std::pair<EvalResult, StringRef> evalIdentifierExpr(
StringRef Expr,
413 ParseContext PCtx)
const {
416 std::tie(Symbol, RemainingExpr) = parseSymbol(Expr);
419 if (Symbol ==
"decode_operand")
420 return evalDecodeOperand(RemainingExpr);
421 else if (Symbol ==
"next_pc")
422 return evalNextPC(RemainingExpr, PCtx);
423 else if (Symbol ==
"stub_addr")
424 return evalStubAddr(RemainingExpr, PCtx);
425 else if (Symbol ==
"section_addr")
426 return evalSectionAddr(RemainingExpr, PCtx);
428 if (!Checker.isSymbolValid(Symbol)) {
429 std::string ErrMsg(
"No known address for symbol '");
433 ErrMsg +=
" (this appears to be an assembler local label - "
434 " perhaps drop the 'L'?)";
436 return std::make_pair(EvalResult(ErrMsg),
"");
442 uint64_t
Value = PCtx.IsInsideLoad ? Checker.getSymbolLocalAddr(Symbol)
443 : Checker.getSymbolRemoteAddr(Symbol);
446 return std::make_pair(EvalResult(Value), RemainingExpr);
451 std::pair<StringRef, StringRef> parseNumberString(
StringRef Expr)
const {
456 FirstNonDigit = Expr.
size();
460 FirstNonDigit = Expr.
size();
462 return std::make_pair(Expr.
substr(0, FirstNonDigit),
463 Expr.
substr(FirstNonDigit));
469 std::pair<EvalResult, StringRef> evalNumberExpr(
StringRef Expr)
const {
472 std::tie(ValueStr, RemainingExpr) = parseNumberString(Expr);
474 if (ValueStr.
empty() || !isdigit(ValueStr[0]))
475 return std::make_pair(
476 unexpectedToken(RemainingExpr, RemainingExpr,
"expected number"),
"");
479 return std::make_pair(EvalResult(Value), RemainingExpr);
485 std::pair<EvalResult, StringRef> evalParensExpr(
StringRef Expr,
486 ParseContext PCtx)
const {
488 EvalResult SubExprResult;
490 std::tie(SubExprResult, RemainingExpr) =
491 evalComplexExpr(evalSimpleExpr(Expr.
substr(1).
ltrim(), PCtx), PCtx);
492 if (SubExprResult.hasError())
493 return std::make_pair(SubExprResult,
"");
495 return std::make_pair(
496 unexpectedToken(RemainingExpr, Expr,
"expected ')'"),
"");
498 return std::make_pair(SubExprResult, RemainingExpr);
505 std::pair<EvalResult, StringRef> evalLoadExpr(
StringRef Expr)
const {
510 if (!RemainingExpr.startswith(
"{"))
511 return std::make_pair(EvalResult(
"Expected '{' following '*'."),
"");
513 EvalResult ReadSizeExpr;
514 std::tie(ReadSizeExpr, RemainingExpr) = evalNumberExpr(RemainingExpr);
515 if (ReadSizeExpr.hasError())
516 return std::make_pair(ReadSizeExpr, RemainingExpr);
517 uint64_t ReadSize = ReadSizeExpr.getValue();
518 if (ReadSize < 1 || ReadSize > 8)
519 return std::make_pair(EvalResult(
"Invalid size for dereference."),
"");
520 if (!RemainingExpr.startswith(
"}"))
521 return std::make_pair(EvalResult(
"Missing '}' for dereference."),
"");
522 RemainingExpr = RemainingExpr.substr(1).ltrim();
525 ParseContext LoadCtx(
true);
526 EvalResult LoadAddrExprResult;
527 std::tie(LoadAddrExprResult, RemainingExpr) =
528 evalComplexExpr(evalSimpleExpr(RemainingExpr, LoadCtx), LoadCtx);
530 if (LoadAddrExprResult.hasError())
531 return std::make_pair(LoadAddrExprResult,
"");
533 uint64_t LoadAddr = LoadAddrExprResult.getValue();
535 return std::make_pair(
536 EvalResult(Checker.readMemoryAtAddr(LoadAddr, ReadSize)),
547 std::pair<EvalResult, StringRef> evalSimpleExpr(
StringRef Expr,
548 ParseContext PCtx)
const {
549 EvalResult SubExprResult;
553 return std::make_pair(EvalResult(
"Unexpected end of expression"),
"");
556 std::tie(SubExprResult, RemainingExpr) = evalParensExpr(Expr, PCtx);
557 else if (Expr[0] ==
'*')
558 std::tie(SubExprResult, RemainingExpr) = evalLoadExpr(Expr);
559 else if (isalpha(Expr[0]) || Expr[0] ==
'_')
560 std::tie(SubExprResult, RemainingExpr) = evalIdentifierExpr(Expr, PCtx);
561 else if (isdigit(Expr[0]))
562 std::tie(SubExprResult, RemainingExpr) = evalNumberExpr(Expr);
564 return std::make_pair(
565 unexpectedToken(Expr, Expr,
566 "expected '(', '*', identifier, or number"),
"");
568 if (SubExprResult.hasError())
569 return std::make_pair(SubExprResult, RemainingExpr);
573 std::tie(SubExprResult, RemainingExpr) =
574 evalSliceExpr(std::make_pair(SubExprResult, RemainingExpr));
576 return std::make_pair(SubExprResult, RemainingExpr);
586 std::pair<EvalResult, StringRef>
587 evalSliceExpr(
const std::pair<EvalResult, StringRef> &Ctx)
const {
588 EvalResult SubExprResult;
590 std::tie(SubExprResult, RemainingExpr) = Ctx;
595 EvalResult HighBitExpr;
596 std::tie(HighBitExpr, RemainingExpr) = evalNumberExpr(RemainingExpr);
598 if (HighBitExpr.hasError())
599 return std::make_pair(HighBitExpr, RemainingExpr);
601 if (!RemainingExpr.startswith(
":"))
602 return std::make_pair(
603 unexpectedToken(RemainingExpr, RemainingExpr,
"expected ':'"),
"");
604 RemainingExpr = RemainingExpr.substr(1).ltrim();
606 EvalResult LowBitExpr;
607 std::tie(LowBitExpr, RemainingExpr) = evalNumberExpr(RemainingExpr);
609 if (LowBitExpr.hasError())
610 return std::make_pair(LowBitExpr, RemainingExpr);
612 if (!RemainingExpr.startswith(
"]"))
613 return std::make_pair(
614 unexpectedToken(RemainingExpr, RemainingExpr,
"expected ']'"),
"");
615 RemainingExpr = RemainingExpr.substr(1).ltrim();
617 unsigned HighBit = HighBitExpr.getValue();
618 unsigned LowBit = LowBitExpr.getValue();
619 uint64_t
Mask = ((uint64_t)1 << (HighBit - LowBit + 1)) - 1;
620 uint64_t SlicedValue = (SubExprResult.getValue() >> LowBit) & Mask;
621 return std::make_pair(EvalResult(SlicedValue), RemainingExpr);
630 std::pair<EvalResult, StringRef>
631 evalComplexExpr(
const std::pair<EvalResult, StringRef> &LHSAndRemaining,
632 ParseContext PCtx)
const {
633 EvalResult LHSResult;
635 std::tie(LHSResult, RemainingExpr) = LHSAndRemaining;
639 if (LHSResult.hasError() || RemainingExpr ==
"")
640 return std::make_pair(LHSResult, RemainingExpr);
644 std::tie(BinOp, RemainingExpr) = parseBinOpToken(RemainingExpr);
648 return std::make_pair(LHSResult, RemainingExpr);
651 EvalResult RHSResult;
652 std::tie(RHSResult, RemainingExpr) = evalSimpleExpr(RemainingExpr, PCtx);
655 if (RHSResult.hasError())
656 return std::make_pair(RHSResult, RemainingExpr);
660 EvalResult ThisResult(computeBinOpResult(BinOp, LHSResult, RHSResult));
662 return evalComplexExpr(std::make_pair(ThisResult, RemainingExpr), PCtx);
665 bool decodeInst(
StringRef Symbol,
MCInst &Inst, uint64_t &Size)
const {
667 StringRef SectionMem = Checker.getSubsectionStartingAt(Symbol);
669 reinterpret_cast<const uint8_t *>(SectionMem.
data()),
684 : RTDyld(RTDyld), Disassembler(Disassembler), InstPrinter(InstPrinter),
685 ErrStream(ErrStream) {
686 RTDyld.Checker =
this;
690 CheckExpr = CheckExpr.
trim();
691 DEBUG(
dbgs() <<
"RuntimeDyldChecker: Checking '" << CheckExpr <<
"'...\n");
693 bool Result = P.
evaluate(CheckExpr);
695 DEBUG(
dbgs() <<
"RuntimeDyldChecker: '" << CheckExpr <<
"' "
696 << (Result ?
"passed" :
"FAILED") <<
".\n");
702 bool DidAllTestsPass =
true;
703 unsigned NumRules = 0;
708 while (LineStart != MemBuf->
getBufferEnd() && std::isspace(*LineStart))
711 while (LineStart != MemBuf->
getBufferEnd() && *LineStart !=
'\0') {
712 const char *LineEnd = LineStart;
713 while (LineEnd != MemBuf->
getBufferEnd() && *LineEnd !=
'\r' &&
717 StringRef Line(LineStart, LineEnd - LineStart);
725 while (LineStart != MemBuf->
getBufferEnd() && std::isspace(*LineStart))
728 return DidAllTestsPass && (NumRules != 0);
731 bool RuntimeDyldCheckerImpl::isSymbolValid(
StringRef Symbol)
const {
737 uint64_t RuntimeDyldCheckerImpl::getSymbolLocalAddr(
StringRef Symbol)
const {
738 return static_cast<uint64_t
>(
742 uint64_t RuntimeDyldCheckerImpl::getSymbolRemoteAddr(
StringRef Symbol)
const {
743 if (
auto InternalSymbol = getRTDyld().
getSymbol(Symbol))
748 uint64_t RuntimeDyldCheckerImpl::readMemoryAtAddr(uint64_t SrcAddr,
749 unsigned Size)
const {
750 uintptr_t PtrSizedAddr =
static_cast<uintptr_t
>(SrcAddr);
751 assert(PtrSizedAddr == SrcAddr &&
"Linker memory pointer out-of-range.");
752 uint8_t *Src =
reinterpret_cast<uint8_t*
>(PtrSizedAddr);
757 std::pair<const RuntimeDyldCheckerImpl::SectionAddressInfo*, std::string>
758 RuntimeDyldCheckerImpl::findSectionAddrInfo(
StringRef FileName,
761 auto SectionMapItr = Stubs.find(FileName);
762 if (SectionMapItr == Stubs.end()) {
763 std::string ErrorMsg =
"File '";
764 ErrorMsg += FileName;
765 ErrorMsg +=
"' not found. ";
767 ErrorMsg +=
"No stubs registered.";
769 ErrorMsg +=
"Available files are:";
770 for (
const auto& StubEntry : Stubs) {
772 ErrorMsg += StubEntry.first;
777 return std::make_pair(
nullptr, ErrorMsg);
780 auto SectionInfoItr = SectionMapItr->second.find(SectionName);
781 if (SectionInfoItr == SectionMapItr->second.end())
782 return std::make_pair(
nullptr,
783 (
"Section '" + SectionName +
"' not found in file '" +
784 FileName +
"'\n").str());
786 return std::make_pair(&SectionInfoItr->second, std::string(
""));
789 std::pair<uint64_t, std::string> RuntimeDyldCheckerImpl::getSectionAddr(
792 const SectionAddressInfo *SectionInfo =
nullptr;
794 std::string ErrorMsg;
795 std::tie(SectionInfo, ErrorMsg) =
796 findSectionAddrInfo(FileName, SectionName);
798 return std::make_pair(0, ErrorMsg);
801 unsigned SectionID = SectionInfo->SectionID;
804 Addr =
static_cast<uint64_t
>(
reinterpret_cast<uintptr_t
>(
805 getRTDyld().
Sections[SectionID].getAddress()));
807 Addr = getRTDyld().
Sections[SectionID].getLoadAddress();
809 return std::make_pair(Addr, std::string(
""));
812 std::pair<uint64_t, std::string> RuntimeDyldCheckerImpl::getStubAddrFor(
814 bool IsInsideLoad)
const {
816 const SectionAddressInfo *SectionInfo =
nullptr;
818 std::string ErrorMsg;
819 std::tie(SectionInfo, ErrorMsg) =
820 findSectionAddrInfo(FileName, SectionName);
822 return std::make_pair(0, ErrorMsg);
825 unsigned SectionID = SectionInfo->SectionID;
826 const StubOffsetsMap &SymbolStubs = SectionInfo->StubOffsets;
827 auto StubOffsetItr = SymbolStubs.find(SymbolName);
828 if (StubOffsetItr == SymbolStubs.end())
829 return std::make_pair(0,
830 (
"Stub for symbol '" + SymbolName +
"' not found. "
831 "If '" + SymbolName +
"' is an internal symbol this "
832 "may indicate that the stub target offset is being "
833 "computed incorrectly.\n").str());
835 uint64_t StubOffset = StubOffsetItr->second;
839 uintptr_t SectionBase =
reinterpret_cast<uintptr_t
>(
840 getRTDyld().
Sections[SectionID].getAddress());
841 Addr =
static_cast<uint64_t
>(SectionBase) + StubOffset;
843 uint64_t SectionBase = getRTDyld().
Sections[SectionID].getLoadAddress();
844 Addr = SectionBase + StubOffset;
847 return std::make_pair(Addr, std::string(
""));
851 RuntimeDyldCheckerImpl::getSubsectionStartingAt(
StringRef Name)
const {
854 if (pos == getRTDyld().GlobalSymbolTable.end())
856 const auto &SymInfo = pos->
second;
858 return StringRef(reinterpret_cast<const char *>(SectionAddr) +
860 getRTDyld().
Sections[SymInfo.getSectionID()].getSize() -
861 SymInfo.getOffset());
864 void RuntimeDyldCheckerImpl::registerSection(
865 StringRef FilePath,
unsigned SectionID) {
870 Stubs[FileName][
SectionName].SectionID = SectionID;
873 void RuntimeDyldCheckerImpl::registerStubMap(
880 Stubs[FileName][
SectionName].SectionID = SectionID;
882 for (
auto &StubMapEntry : RTDyldStubs) {
883 std::string SymbolName =
"";
885 if (StubMapEntry.first.SymbolName)
886 SymbolName = StubMapEntry.first.SymbolName;
890 for (
auto &GSTEntry : getRTDyld().GlobalSymbolTable) {
891 const auto &SymInfo = GSTEntry.second;
892 if (SymInfo.getSectionID() == StubMapEntry.first.SectionID &&
893 SymInfo.getOffset() ==
894 static_cast<uint64_t
>(StubMapEntry.first.Offset)) {
895 SymbolName = GSTEntry.first();
901 if (SymbolName !=
"")
902 Stubs[FileName][
SectionName].StubOffsets[SymbolName] =
912 InstPrinter, ErrStream)) {}
925 return Impl->check(CheckExpr);
930 return Impl->checkAllRulesInBuffer(RulePrefix, MemBuf);
933 std::pair<uint64_t, std::string>
936 return Impl->getSectionAddr(FileName, SectionName, LocalAddress);
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.
JITTargetAddress getAddress()
Get the address of the symbol in the target address space.
const char * getBufferStart() const
RuntimeDyldCheckerImpl(RuntimeDyld &RTDyld, MCDisassembler *Disassembler, MCInstPrinter *InstPrinter, llvm::raw_ostream &ErrStream)
DecodeStatus
Ternary decode status.
Superclass for all disassemblers.
iterator find(StringRef Key)
RuntimeDyld & getRTDyld()
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.
RuntimeDyldCheckerExprEval(const RuntimeDyldCheckerImpl &Checker, raw_ostream &ErrStream)
bool evaluate(StringRef Expr) const
std::map< RelocationValueRef, uintptr_t > StubMap
LLVM_NODISCARD StringRef rtrim(char Char) const
Return string with consecutive Char characters starting from the right removed.
LLVM_NODISCARD LLVM_ATTRIBUTE_ALWAYS_INLINE bool startswith(StringRef Prefix) const
Check if this string starts with the given Prefix.
bool checkAllRulesInBuffer(StringRef RulePrefix, MemoryBuffer *MemBuf) const
Scan the given memory buffer for lines beginning with the string in RulePrefix.
LLVM_NODISCARD LLVM_ATTRIBUTE_ALWAYS_INLINE size_t size() const
size - Get the string size.
virtual JITSymbol findSymbol(const std::string &Name)=0
This method returns the address of the specified function or variable.
Expected< const typename ELFT::Sym * > getSymbol(typename ELFT::SymRange Symbols, uint32_t Index)
Instances of this class represent a single low-level machine instruction.
format_object< Ts...> format(const char *Fmt, const Ts &...Vals)
These are helper functions used to produce formatted output.
StringRef filename(StringRef path)
Get filename.
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 LLVM_ATTRIBUTE_ALWAYS_INLINE size_t find(char C, size_t From=0) const
Search for the first character C in the string.
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...
uint64_t readBytesUnaligned(uint8_t *Src, unsigned Size) const
Endian-aware read Read the least significant Size bytes from Src.
LLVM_NODISCARD LLVM_ATTRIBUTE_ALWAYS_INLINE StringRef substr(size_t Start, size_t N=npos) const
Return a reference to the substring from [Start, Start + N).
LLVM_NODISCARD StringRef trim(char Char) const
Return string with consecutive Char characters starting from the left and right removed.
uint8_t * getSectionAddress(unsigned SectionID) const
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.
#define llvm_unreachable(msg)
Marks that the current location is not supposed to be reachable.
bool check(StringRef CheckExpr) const
Check a single expression against the attached RuntimeDyld instance.
bool check(StringRef CheckExpr) 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.
LLVM_NODISCARD LLVM_ATTRIBUTE_ALWAYS_INLINE bool empty() const
empty - Check if the string is empty.
This is an instance of a target assembly language printer that converts an MCInst to valid target ass...
unsigned getNumOperands() const
LLVM_NODISCARD StringRef ltrim(char Char) const
Return string with consecutive Char characters starting from the the left removed.
bool checkAllRulesInBuffer(StringRef RulePrefix, MemoryBuffer *MemBuf) const
const char * getBufferEnd() const
SectionEntry - represents a section emitted into memory by the dynamic linker.
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 LLVM_ATTRIBUTE_ALWAYS_INLINE const char * data() const
data - Get a pointer to the start of the string (which may not be null terminated).
uint8_t * getSymbolLocalAddress(StringRef Name) const
StringRef - Represent a constant reference to a string, i.e.
StringRef getName() const
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.
const MCOperand & getOperand(unsigned i) const