, ) tuple. // On success, returns a pair containing the stub address, plus the expression // remaining to be evaluated. std::pair 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 StubContainerName; size_t ComaIdx = RemainingExpr.find(','); StubContainerName = RemainingExpr.substr(0, ComaIdx).rtrim(); RemainingExpr = RemainingExpr.substr(ComaIdx).ltrim(); if (!RemainingExpr.startswith(",")) return std::make_pair( unexpectedToken(RemainingExpr, Expr, "expected ','"), ""); RemainingExpr = RemainingExpr.substr(1).ltrim(); StringRef Symbol; std::tie(Symbol, RemainingExpr) = parseSymbol(RemainingExpr); if (!RemainingExpr.startswith(")")) return std::make_pair( unexpectedToken(RemainingExpr, Expr, "expected ')'"), ""); RemainingExpr = RemainingExpr.substr(1).ltrim(); uint64_t StubAddr; std::string ErrorMsg; std::tie(StubAddr, ErrorMsg) = Checker.getStubOrGOTAddrFor( StubContainerName, Symbol, PCtx.IsInsideLoad, IsStubAddr); if (ErrorMsg != "") return std::make_pair(EvalResult(ErrorMsg), ""); return std::make_pair(EvalResult(StubAddr), RemainingExpr); } std::pair evalSectionAddr(StringRef Expr, ParseContext PCtx) 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; size_t ComaIdx = RemainingExpr.find(','); FileName = RemainingExpr.substr(0, ComaIdx).rtrim(); RemainingExpr = RemainingExpr.substr(ComaIdx).ltrim(); if (!RemainingExpr.startswith(",")) return std::make_pair( unexpectedToken(RemainingExpr, Expr, "expected ','"), ""); RemainingExpr = RemainingExpr.substr(1).ltrim(); StringRef SectionName; size_t CloseParensIdx = RemainingExpr.find(')'); SectionName = RemainingExpr.substr(0, CloseParensIdx).rtrim(); RemainingExpr = RemainingExpr.substr(CloseParensIdx).ltrim(); if (!RemainingExpr.startswith(")")) return std::make_pair( unexpectedToken(RemainingExpr, Expr, "expected ')'"), ""); RemainingExpr = RemainingExpr.substr(1).ltrim(); uint64_t StubAddr; std::string ErrorMsg; std::tie(StubAddr, ErrorMsg) = Checker.getSectionAddr( FileName, SectionName, PCtx.IsInsideLoad); if (ErrorMsg != "") return std::make_pair(EvalResult(ErrorMsg), ""); return std::make_pair(EvalResult(StubAddr), RemainingExpr); } // Evaluate an identiefer expr, which may be a symbol, or a call to // one of the builtin functions: get_insn_opcode or get_insn_length. // Return the result, plus the expression remaining to be parsed. std::pair evalIdentifierExpr(StringRef Expr, ParseContext PCtx) const { StringRef Symbol; StringRef RemainingExpr; std::tie(Symbol, RemainingExpr) = parseSymbol(Expr); // Check for builtin function calls. if (Symbol == "decode_operand") return evalDecodeOperand(RemainingExpr); else if (Symbol == "next_pc") return evalNextPC(RemainingExpr, PCtx); else if (Symbol == "stub_addr") return evalStubOrGOTAddr(RemainingExpr, PCtx, true); else if (Symbol == "got_addr") return evalStubOrGOTAddr(RemainingExpr, PCtx, false); else if (Symbol == "section_addr") return evalSectionAddr(RemainingExpr, PCtx); if (!Checker.isSymbolValid(Symbol)) { std::string ErrMsg("No known address for symbol '"); ErrMsg += Symbol; ErrMsg += "'"; if (Symbol.startswith("L")) ErrMsg += " (this appears to be an assembler local label - " " perhaps drop the 'L'?)"; return std::make_pair(EvalResult(ErrMsg), ""); } // The value for the symbol depends on the context we're evaluating in: // Inside a load this is the address in the linker's memory, outside a // load it's the address in the target processes memory. uint64_t Value = PCtx.IsInsideLoad ? Checker.getSymbolLocalAddr(Symbol) : Checker.getSymbolRemoteAddr(Symbol); // Looks like a plain symbol reference. return std::make_pair(EvalResult(Value), RemainingExpr); } // Parse a number (hexadecimal or decimal) and return a (string, string) // pair representing the number and the expression remaining to be parsed. std::pair parseNumberString(StringRef Expr) const { size_t FirstNonDigit = StringRef::npos; if (Expr.startswith("0x")) { FirstNonDigit = Expr.find_first_not_of("0123456789abcdefABCDEF", 2); if (FirstNonDigit == StringRef::npos) FirstNonDigit = Expr.size(); } else { FirstNonDigit = Expr.find_first_not_of("0123456789"); if (FirstNonDigit == StringRef::npos) FirstNonDigit = Expr.size(); } return std::make_pair(Expr.substr(0, FirstNonDigit), Expr.substr(FirstNonDigit)); } // Evaluate a constant numeric expression (hexadecimal or decimal) and // return a pair containing the result, and the expression remaining to be // evaluated. std::pair evalNumberExpr(StringRef Expr) const { StringRef ValueStr; StringRef RemainingExpr; std::tie(ValueStr, RemainingExpr) = parseNumberString(Expr); if (ValueStr.empty() || !isdigit(ValueStr[0])) return std::make_pair( unexpectedToken(RemainingExpr, RemainingExpr, "expected number"), ""); uint64_t Value; ValueStr.getAsInteger(0, Value); return std::make_pair(EvalResult(Value), RemainingExpr); } // Evaluate an expression of the form "()" and return a pair // containing the result of evaluating , plus the expression // remaining to be parsed. std::pair evalParensExpr(StringRef Expr, ParseContext PCtx) const { assert(Expr.startswith("(") && "Not a parenthesized expression"); EvalResult SubExprResult; StringRef RemainingExpr; std::tie(SubExprResult, RemainingExpr) = evalComplexExpr(evalSimpleExpr(Expr.substr(1).ltrim(), PCtx), PCtx); if (SubExprResult.hasError()) return std::make_pair(SubExprResult, ""); if (!RemainingExpr.startswith(")")) return std::make_pair( unexpectedToken(RemainingExpr, Expr, "expected ')'"), ""); RemainingExpr = RemainingExpr.substr(1).ltrim(); return std::make_pair(SubExprResult, RemainingExpr); } // Evaluate an expression in one of the following forms: // *{} // Return a pair containing the result, plus the expression remaining to be // parsed. std::pair evalLoadExpr(StringRef Expr) const { assert(Expr.startswith("*") && "Not a load expression"); StringRef RemainingExpr = Expr.substr(1).ltrim(); // Parse read size. if (!RemainingExpr.startswith("{")) return std::make_pair(EvalResult("Expected '{' following '*'."), ""); RemainingExpr = RemainingExpr.substr(1).ltrim(); EvalResult ReadSizeExpr; std::tie(ReadSizeExpr, RemainingExpr) = evalNumberExpr(RemainingExpr); if (ReadSizeExpr.hasError()) return std::make_pair(ReadSizeExpr, RemainingExpr); uint64_t ReadSize = ReadSizeExpr.getValue(); if (ReadSize < 1 || ReadSize > 8) return std::make_pair(EvalResult("Invalid size for dereference."), ""); if (!RemainingExpr.startswith("}")) return std::make_pair(EvalResult("Missing '}' for dereference."), ""); RemainingExpr = RemainingExpr.substr(1).ltrim(); // Evaluate the expression representing the load address. ParseContext LoadCtx(true); EvalResult LoadAddrExprResult; std::tie(LoadAddrExprResult, RemainingExpr) = evalComplexExpr(evalSimpleExpr(RemainingExpr, LoadCtx), LoadCtx); if (LoadAddrExprResult.hasError()) return std::make_pair(LoadAddrExprResult, ""); uint64_t LoadAddr = LoadAddrExprResult.getValue(); // If there is no error but the content pointer is null then this is a // zero-fill symbol/section. if (LoadAddr == 0) return std::make_pair(0, RemainingExpr); return std::make_pair( EvalResult(Checker.readMemoryAtAddr(LoadAddr, ReadSize)), RemainingExpr); } // Evaluate a "simple" expression. This is any expression that _isn't_ an // un-parenthesized binary expression. // // "Simple" expressions can be optionally bit-sliced. See evalSlicedExpr. // // Returns a pair containing the result of the evaluation, plus the // expression remaining to be parsed. std::pair evalSimpleExpr(StringRef Expr, ParseContext PCtx) const { EvalResult SubExprResult; StringRef RemainingExpr; if (Expr.empty()) return std::make_pair(EvalResult("Unexpected end of expression"), ""); if (Expr[0] == '(') std::tie(SubExprResult, RemainingExpr) = evalParensExpr(Expr, PCtx); else if (Expr[0] == '*') std::tie(SubExprResult, RemainingExpr) = evalLoadExpr(Expr); else if (isalpha(Expr[0]) || Expr[0] == '_') std::tie(SubExprResult, RemainingExpr) = evalIdentifierExpr(Expr, PCtx); else if (isdigit(Expr[0])) std::tie(SubExprResult, RemainingExpr) = evalNumberExpr(Expr); else return std::make_pair( unexpectedToken(Expr, Expr, "expected '(', '*', identifier, or number"), ""); if (SubExprResult.hasError()) return std::make_pair(SubExprResult, RemainingExpr); // Evaluate bit-slice if present. if (RemainingExpr.startswith("[")) std::tie(SubExprResult, RemainingExpr) = evalSliceExpr(std::make_pair(SubExprResult, RemainingExpr)); return std::make_pair(SubExprResult, RemainingExpr); } // Evaluate a bit-slice of an expression. // A bit-slice has the form "[high:low]". The result of evaluating a // slice is the bits between high and low (inclusive) in the original // expression, right shifted so that the "low" bit is in position 0 in the // result. // Returns a pair containing the result of the slice operation, plus the // expression remaining to be parsed. std::pair evalSliceExpr(const std::pair &Ctx) const { EvalResult SubExprResult; StringRef RemainingExpr; std::tie(SubExprResult, RemainingExpr) = Ctx; assert(RemainingExpr.startswith("[") && "Not a slice expr."); RemainingExpr = RemainingExpr.substr(1).ltrim(); EvalResult HighBitExpr; std::tie(HighBitExpr, RemainingExpr) = evalNumberExpr(RemainingExpr); if (HighBitExpr.hasError()) return std::make_pair(HighBitExpr, RemainingExpr); if (!RemainingExpr.startswith(":")) return std::make_pair( unexpectedToken(RemainingExpr, RemainingExpr, "expected ':'"), ""); RemainingExpr = RemainingExpr.substr(1).ltrim(); EvalResult LowBitExpr; std::tie(LowBitExpr, RemainingExpr) = evalNumberExpr(RemainingExpr); if (LowBitExpr.hasError()) return std::make_pair(LowBitExpr, RemainingExpr); if (!RemainingExpr.startswith("]")) return std::make_pair( unexpectedToken(RemainingExpr, RemainingExpr, "expected ']'"), ""); RemainingExpr = RemainingExpr.substr(1).ltrim(); unsigned HighBit = HighBitExpr.getValue(); unsigned LowBit = LowBitExpr.getValue(); uint64_t Mask = ((uint64_t)1 << (HighBit - LowBit + 1)) - 1; uint64_t SlicedValue = (SubExprResult.getValue() >> LowBit) & Mask; return std::make_pair(EvalResult(SlicedValue), RemainingExpr); } // Evaluate a "complex" expression. // Takes an already evaluated subexpression and checks for the presence of a // binary operator, computing the result of the binary operation if one is // found. Used to make arithmetic expressions left-associative. // Returns a pair containing the ultimate result of evaluating the // expression, plus the expression remaining to be evaluated. std::pair evalComplexExpr(const std::pair &LHSAndRemaining, ParseContext PCtx) const { EvalResult LHSResult; StringRef RemainingExpr; std::tie(LHSResult, RemainingExpr) = LHSAndRemaining; // If there was an error, or there's nothing left to evaluate, return the // result. if (LHSResult.hasError() || RemainingExpr == "") return std::make_pair(LHSResult, RemainingExpr); // Otherwise check if this is a binary expressioan. BinOpToken BinOp; std::tie(BinOp, RemainingExpr) = parseBinOpToken(RemainingExpr); // If this isn't a recognized expression just return. if (BinOp == BinOpToken::Invalid) return std::make_pair(LHSResult, RemainingExpr); // This is a recognized bin-op. Evaluate the RHS, then evaluate the binop. EvalResult RHSResult; std::tie(RHSResult, RemainingExpr) = evalSimpleExpr(RemainingExpr, PCtx); // If there was an error evaluating the RHS, return it. if (RHSResult.hasError()) return std::make_pair(RHSResult, RemainingExpr); // This is a binary expression - evaluate and try to continue as a // complex expr. EvalResult ThisResult(computeBinOpResult(BinOp, LHSResult, RHSResult)); return evalComplexExpr(std::make_pair(ThisResult, RemainingExpr), PCtx); } bool decodeInst(StringRef Symbol, MCInst &Inst, uint64_t &Size, int64_t Offset) const { MCDisassembler *Dis = Checker.Disassembler; StringRef SymbolMem = Checker.getSymbolContent(Symbol); ArrayRef SymbolBytes(SymbolMem.bytes_begin() + Offset, SymbolMem.size() - Offset); MCDisassembler::DecodeStatus S = Dis->getInstruction(Inst, Size, SymbolBytes, 0, nulls()); return (S == MCDisassembler::Success); } }; } // namespace llvm RuntimeDyldCheckerImpl::RuntimeDyldCheckerImpl( IsSymbolValidFunction IsSymbolValid, GetSymbolInfoFunction GetSymbolInfo, GetSectionInfoFunction GetSectionInfo, GetStubInfoFunction GetStubInfo, GetGOTInfoFunction GetGOTInfo, support::endianness Endianness, MCDisassembler *Disassembler, MCInstPrinter *InstPrinter, raw_ostream &ErrStream) : IsSymbolValid(std::move(IsSymbolValid)), GetSymbolInfo(std::move(GetSymbolInfo)), GetSectionInfo(std::move(GetSectionInfo)), GetStubInfo(std::move(GetStubInfo)), GetGOTInfo(std::move(GetGOTInfo)), Endianness(Endianness), Disassembler(Disassembler), InstPrinter(InstPrinter), ErrStream(ErrStream) {} bool RuntimeDyldCheckerImpl::check(StringRef CheckExpr) const { CheckExpr = CheckExpr.trim(); LLVM_DEBUG(dbgs() << "RuntimeDyldChecker: Checking '" << CheckExpr << "'...\n"); RuntimeDyldCheckerExprEval P(*this, ErrStream); bool Result = P.evaluate(CheckExpr); (void)Result; LLVM_DEBUG(dbgs() << "RuntimeDyldChecker: '" << CheckExpr << "' " << (Result ? "passed" : "FAILED") << ".\n"); return Result; } bool RuntimeDyldCheckerImpl::checkAllRulesInBuffer(StringRef RulePrefix, MemoryBuffer *MemBuf) const { bool DidAllTestsPass = true; unsigned NumRules = 0; std::string CheckExpr; const char *LineStart = MemBuf->getBufferStart(); // Eat whitespace. while (LineStart != MemBuf->getBufferEnd() && isSpace(*LineStart)) ++LineStart; while (LineStart != MemBuf->getBufferEnd() && *LineStart != '\0') { const char *LineEnd = LineStart; while (LineEnd != MemBuf->getBufferEnd() && *LineEnd != '\r' && *LineEnd != '\n') ++LineEnd; StringRef Line(LineStart, LineEnd - LineStart); if (Line.startswith(RulePrefix)) CheckExpr += Line.substr(RulePrefix.size()).str(); // If there's a check expr string... if (!CheckExpr.empty()) { // ... and it's complete then run it, otherwise remove the trailer '\'. if (CheckExpr.back() != '\\') { DidAllTestsPass &= check(CheckExpr); CheckExpr.clear(); ++NumRules; } else CheckExpr.pop_back(); } // Eat whitespace. LineStart = LineEnd; while (LineStart != MemBuf->getBufferEnd() && isSpace(*LineStart)) ++LineStart; } return DidAllTestsPass && (NumRules != 0); } bool RuntimeDyldCheckerImpl::isSymbolValid(StringRef Symbol) const { return IsSymbolValid(Symbol); } uint64_t RuntimeDyldCheckerImpl::getSymbolLocalAddr(StringRef Symbol) const { auto SymInfo = GetSymbolInfo(Symbol); if (!SymInfo) { logAllUnhandledErrors(SymInfo.takeError(), errs(), "RTDyldChecker: "); return 0; } if (SymInfo->isZeroFill()) return 0; return static_cast( reinterpret_cast(SymInfo->getContent().data())); } uint64_t RuntimeDyldCheckerImpl::getSymbolRemoteAddr(StringRef Symbol) const { auto SymInfo = GetSymbolInfo(Symbol); if (!SymInfo) { logAllUnhandledErrors(SymInfo.takeError(), errs(), "RTDyldChecker: "); return 0; } return SymInfo->getTargetAddress(); } uint64_t RuntimeDyldCheckerImpl::readMemoryAtAddr(uint64_t SrcAddr, unsigned Size) const { uintptr_t PtrSizedAddr = static_cast(SrcAddr); assert(PtrSizedAddr == SrcAddr && "Linker memory pointer out-of-range."); void *Ptr = reinterpret_cast(PtrSizedAddr); switch (Size) { case 1: return support::endian::read(Ptr, Endianness); case 2: return support::endian::read(Ptr, Endianness); case 4: return support::endian::read(Ptr, Endianness); case 8: return support::endian::read(Ptr, Endianness); } llvm_unreachable("Unsupported read size"); } StringRef RuntimeDyldCheckerImpl::getSymbolContent(StringRef Symbol) const { auto SymInfo = GetSymbolInfo(Symbol); if (!SymInfo) { logAllUnhandledErrors(SymInfo.takeError(), errs(), "RTDyldChecker: "); return StringRef(); } return {SymInfo->getContent().data(), SymInfo->getContent().size()}; } std::pair RuntimeDyldCheckerImpl::getSectionAddr( StringRef FileName, StringRef SectionName, bool IsInsideLoad) const { auto SecInfo = GetSectionInfo(FileName, SectionName); if (!SecInfo) { std::string ErrMsg; { raw_string_ostream ErrMsgStream(ErrMsg); logAllUnhandledErrors(SecInfo.takeError(), ErrMsgStream, "RTDyldChecker: "); } return std::make_pair(0, std::move(ErrMsg)); } // If this address is being looked up in "load" mode, return the content // pointer, otherwise return the target address. uint64_t Addr = 0; if (IsInsideLoad) { if (SecInfo->isZeroFill()) Addr = 0; else Addr = pointerToJITTargetAddress(SecInfo->getContent().data()); } else Addr = SecInfo->getTargetAddress(); return std::make_pair(Addr, ""); } std::pair RuntimeDyldCheckerImpl::getStubOrGOTAddrFor( StringRef StubContainerName, StringRef SymbolName, bool IsInsideLoad, bool IsStubAddr) const { auto StubInfo = IsStubAddr ? GetStubInfo(StubContainerName, SymbolName) : GetGOTInfo(StubContainerName, SymbolName); if (!StubInfo) { std::string ErrMsg; { raw_string_ostream ErrMsgStream(ErrMsg); logAllUnhandledErrors(StubInfo.takeError(), ErrMsgStream, "RTDyldChecker: "); } return std::make_pair((uint64_t)0, std::move(ErrMsg)); } uint64_t Addr = 0; if (IsInsideLoad) { if (StubInfo->isZeroFill()) return std::make_pair((uint64_t)0, "Detected zero-filled stub/GOT entry"); Addr = pointerToJITTargetAddress(StubInfo->getContent().data()); } else Addr = StubInfo->getTargetAddress(); return std::make_pair(Addr, ""); } RuntimeDyldChecker::RuntimeDyldChecker( IsSymbolValidFunction IsSymbolValid, GetSymbolInfoFunction GetSymbolInfo, GetSectionInfoFunction GetSectionInfo, GetStubInfoFunction GetStubInfo, GetGOTInfoFunction GetGOTInfo, support::endianness Endianness, MCDisassembler *Disassembler, MCInstPrinter *InstPrinter, raw_ostream &ErrStream) : Impl(::std::make_unique( std::move(IsSymbolValid), std::move(GetSymbolInfo), std::move(GetSectionInfo), std::move(GetStubInfo), std::move(GetGOTInfo), Endianness, Disassembler, InstPrinter, ErrStream)) {} RuntimeDyldChecker::~RuntimeDyldChecker() = default; bool RuntimeDyldChecker::check(StringRef CheckExpr) const { return Impl->check(CheckExpr); } bool RuntimeDyldChecker::checkAllRulesInBuffer(StringRef RulePrefix, MemoryBuffer *MemBuf) const { return Impl->checkAllRulesInBuffer(RulePrefix, MemBuf); } std::pair RuntimeDyldChecker::getSectionAddr(StringRef FileName, StringRef SectionName, bool LocalAddress) { return Impl->getSectionAddr(FileName, SectionName, LocalAddress); }