1//===--- RuntimeDyldChecker.cpp - RuntimeDyld tester framework --*- C++ -*-===//
2//
3//                     The LLVM Compiler Infrastructure
4//
5// This file is distributed under the University of Illinois Open Source
6// License. See LICENSE.TXT for details.
7//
8//===----------------------------------------------------------------------===//
9
10#include "llvm/ExecutionEngine/RuntimeDyldChecker.h"
11#include "llvm/MC/MCContext.h"
12#include "llvm/MC/MCDisassembler.h"
13#include "llvm/MC/MCInst.h"
14#include "llvm/Support/StringRefMemoryObject.h"
15#include "RuntimeDyldImpl.h"
16#include <cctype>
17#include <memory>
18
19#define DEBUG_TYPE "rtdyld"
20
21using namespace llvm;
22
23namespace llvm {
24
25  // Helper class that implements the language evaluated by RuntimeDyldChecker.
26  class RuntimeDyldCheckerExprEval {
27  public:
28
29    RuntimeDyldCheckerExprEval(const RuntimeDyldChecker &Checker,
30                               llvm::raw_ostream &ErrStream)
31      : Checker(Checker), ErrStream(ErrStream) {}
32
33    bool evaluate(StringRef Expr) const {
34      // Expect equality expression of the form 'LHS = RHS'.
35      Expr = Expr.trim();
36      size_t EQIdx = Expr.find('=');
37
38      // Evaluate LHS.
39      StringRef LHSExpr = Expr.substr(0, EQIdx).rtrim();
40      StringRef RemainingExpr;
41      EvalResult LHSResult;
42      std::tie(LHSResult, RemainingExpr) =
43        evalComplexExpr(evalSimpleExpr(LHSExpr));
44      if (LHSResult.hasError())
45        return handleError(Expr, LHSResult);
46      if (RemainingExpr != "")
47        return handleError(Expr, unexpectedToken(RemainingExpr, LHSExpr, ""));
48
49      // Evaluate RHS.
50      StringRef RHSExpr = Expr.substr(EQIdx + 1).ltrim();
51      EvalResult RHSResult;
52      std::tie(RHSResult, RemainingExpr) =
53        evalComplexExpr(evalSimpleExpr(RHSExpr));
54      if (RHSResult.hasError())
55        return handleError(Expr, RHSResult);
56      if (RemainingExpr != "")
57        return handleError(Expr, unexpectedToken(RemainingExpr, RHSExpr, ""));
58
59      if (LHSResult.getValue() != RHSResult.getValue()) {
60        ErrStream << "Expression '" << Expr << "' is false: "
61                  << format("0x%lx", LHSResult.getValue()) << " != "
62                  << format("0x%lx", RHSResult.getValue()) << "\n";
63        return false;
64      }
65      return true;
66    }
67
68  private:
69    const RuntimeDyldChecker &Checker;
70    llvm::raw_ostream &ErrStream;
71
72    enum class BinOpToken : unsigned { Invalid, Add, Sub, BitwiseAnd,
73                                       BitwiseOr, ShiftLeft, ShiftRight };
74
75    class EvalResult {
76    public:
77      EvalResult()
78        : Value(0), ErrorMsg("") {}
79      EvalResult(uint64_t Value)
80        : Value(Value), ErrorMsg("") {}
81      EvalResult(std::string ErrorMsg)
82        : Value(0), ErrorMsg(ErrorMsg) {}
83      uint64_t getValue() const { return Value; }
84      bool hasError() const { return ErrorMsg != ""; }
85      const std::string& getErrorMsg() const { return ErrorMsg; }
86    private:
87      uint64_t Value;
88      std::string ErrorMsg;
89    };
90
91    StringRef getTokenForError(StringRef Expr) const {
92      if (Expr.empty())
93        return "";
94
95      StringRef Token, Remaining;
96      if (isalpha(Expr[0]))
97        std::tie(Token, Remaining) = parseSymbol(Expr);
98      else if (isdigit(Expr[0]))
99        std::tie(Token, Remaining) = parseNumberString(Expr);
100      else {
101        unsigned TokLen = 1;
102        if (Expr.startswith("<<") || Expr.startswith(">>"))
103          TokLen = 2;
104        Token = Expr.substr(0, TokLen);
105      }
106      return Token;
107    }
108
109    EvalResult unexpectedToken(StringRef TokenStart,
110                               StringRef SubExpr,
111                               StringRef ErrText) const {
112      std::string ErrorMsg("Encountered unexpected token '");
113      ErrorMsg += getTokenForError(TokenStart);
114      if (SubExpr != "") {
115        ErrorMsg += "' while parsing subexpression '";
116        ErrorMsg += SubExpr;
117      }
118      ErrorMsg += "'";
119      if (ErrText != "") {
120        ErrorMsg += " ";
121        ErrorMsg += ErrText;
122      }
123      return EvalResult(std::move(ErrorMsg));
124    }
125
126    bool handleError(StringRef Expr, const EvalResult &R) const {
127      assert(R.hasError() && "Not an error result.");
128      ErrStream << "Error evaluating expression '" << Expr << "': "
129                << R.getErrorMsg() << "\n";
130      return false;
131    }
132
133    std::pair<BinOpToken, StringRef> parseBinOpToken(StringRef Expr) const {
134      if (Expr.empty())
135        return std::make_pair(BinOpToken::Invalid, "");
136
137      // Handle the two 2-character tokens.
138      if (Expr.startswith("<<"))
139        return std::make_pair(BinOpToken::ShiftLeft,
140                              Expr.substr(2).ltrim());
141      if (Expr.startswith(">>"))
142        return std::make_pair(BinOpToken::ShiftRight,
143                              Expr.substr(2).ltrim());
144
145      // Handle one-character tokens.
146      BinOpToken Op;
147      switch (Expr[0]) {
148        default: return std::make_pair(BinOpToken::Invalid, Expr);
149        case '+': Op = BinOpToken::Add; break;
150        case '-': Op = BinOpToken::Sub; break;
151        case '&': Op = BinOpToken::BitwiseAnd; break;
152        case '|': Op = BinOpToken::BitwiseOr; break;
153      }
154
155      return std::make_pair(Op, Expr.substr(1).ltrim());
156    }
157
158    EvalResult computeBinOpResult(BinOpToken Op, const EvalResult &LHSResult,
159                                  const EvalResult &RHSResult) const {
160      switch (Op) {
161      default: llvm_unreachable("Tried to evaluate unrecognized operation.");
162      case BinOpToken::Add:
163        return EvalResult(LHSResult.getValue() + RHSResult.getValue());
164      case BinOpToken::Sub:
165        return EvalResult(LHSResult.getValue() - RHSResult.getValue());
166      case BinOpToken::BitwiseAnd:
167        return EvalResult(LHSResult.getValue() & RHSResult.getValue());
168      case BinOpToken::BitwiseOr:
169        return EvalResult(LHSResult.getValue() | RHSResult.getValue());
170      case BinOpToken::ShiftLeft:
171        return EvalResult(LHSResult.getValue() << RHSResult.getValue());
172      case BinOpToken::ShiftRight:
173        return EvalResult(LHSResult.getValue() >> RHSResult.getValue());
174      }
175    }
176
177    // Parse a symbol and return a (string, string) pair representing the symbol
178    // name and expression remaining to be parsed.
179    std::pair<StringRef, StringRef> parseSymbol(StringRef Expr) const {
180      size_t FirstNonSymbol =
181        Expr.find_first_not_of("0123456789"
182                               "abcdefghijklmnopqrstuvwxyz"
183                               "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
184                               ":_");
185      return std::make_pair(Expr.substr(0, FirstNonSymbol),
186                            Expr.substr(FirstNonSymbol).ltrim());
187    }
188
189    // Evaluate a call to decode_operand. Decode the instruction operand at the
190    // given symbol and get the value of the requested operand.
191    // Returns an error if the instruction cannot be decoded, or the requested
192    // operand is not an immediate.
193    // On success, retuns a pair containing the value of the operand, plus
194    // the expression remaining to be evaluated.
195    std::pair<EvalResult, StringRef> evalDecodeOperand(StringRef Expr) const {
196      if (!Expr.startswith("("))
197        return std::make_pair(unexpectedToken(Expr, Expr, "expected '('"), "");
198      StringRef RemainingExpr = Expr.substr(1).ltrim();
199      StringRef Symbol;
200      std::tie(Symbol, RemainingExpr) = parseSymbol(RemainingExpr);
201
202      if (!Checker.checkSymbolIsValidForLoad(Symbol))
203        return std::make_pair(EvalResult(("Cannot decode unknown symbol '" +
204                                          Symbol + "'").str()),
205                              "");
206
207      if (!RemainingExpr.startswith(","))
208        return std::make_pair(unexpectedToken(RemainingExpr, RemainingExpr,
209                                              "expected ','"),
210                              "");
211      RemainingExpr = RemainingExpr.substr(1).ltrim();
212
213      EvalResult OpIdxExpr;
214      std::tie(OpIdxExpr, RemainingExpr) = evalNumberExpr(RemainingExpr);
215      if (OpIdxExpr.hasError())
216        return std::make_pair(OpIdxExpr, "");
217
218      if (!RemainingExpr.startswith(")"))
219        return std::make_pair(unexpectedToken(RemainingExpr, RemainingExpr,
220                                              "expected ')'"),
221                              "");
222      RemainingExpr = RemainingExpr.substr(1).ltrim();
223
224      MCInst Inst;
225      uint64_t Size;
226      if (!decodeInst(Symbol, Inst, Size))
227        return std::make_pair(EvalResult(("Couldn't decode instruction at '" +
228                                          Symbol + "'").str()),
229                              "");
230
231      unsigned OpIdx = OpIdxExpr.getValue();
232      if (OpIdx >= Inst.getNumOperands()) {
233        std::string ErrMsg;
234        raw_string_ostream ErrMsgStream(ErrMsg);
235        ErrMsgStream << "Invalid operand index '" << format("%i", OpIdx)
236                     << " for instruction '" << Symbol
237                     << ". Instruction has only "
238                     << format("%i", Inst.getNumOperands()) << " operands.";
239        return std::make_pair(EvalResult(ErrMsgStream.str()), "");
240      }
241
242      const MCOperand &Op = Inst.getOperand(OpIdx);
243      if (!Op.isImm()) {
244        std::string ErrMsg;
245        raw_string_ostream ErrMsgStream(ErrMsg);
246        ErrMsgStream << "Operand '" << format("%i", OpIdx)
247                     << "' of instruction '" << Symbol
248                     << "' is not an immediate.\nInstruction is:\n  ";
249        Inst.dump_pretty(ErrMsgStream,
250                         Checker.Disassembler->getContext().getAsmInfo(),
251                         Checker.InstPrinter);
252
253        return std::make_pair(EvalResult(ErrMsgStream.str()), "");
254      }
255
256      return std::make_pair(EvalResult(Op.getImm()), RemainingExpr);
257    }
258
259    // Evaluate a call to next_pc. Decode the instruction at the given
260    // symbol and return the following program counter..
261    // Returns an error if the instruction cannot be decoded.
262    // On success, returns a pair containing the next PC, plus the length of the
263    // expression remaining to be evaluated.
264    std::pair<EvalResult, StringRef> evalNextPC(StringRef Expr) const {
265      if (!Expr.startswith("("))
266        return std::make_pair(unexpectedToken(Expr, Expr, "expected '('"), "");
267      StringRef RemainingExpr = Expr.substr(1).ltrim();
268      StringRef Symbol;
269      std::tie(Symbol, RemainingExpr) = parseSymbol(RemainingExpr);
270
271      if (!Checker.checkSymbolIsValidForLoad(Symbol))
272        return std::make_pair(EvalResult(("Cannot decode unknown symbol '"
273                                          + Symbol + "'").str()),
274                              "");
275
276      if (!RemainingExpr.startswith(")"))
277        return std::make_pair(unexpectedToken(RemainingExpr, RemainingExpr,
278                                              "expected ')'"),
279                              "");
280      RemainingExpr = RemainingExpr.substr(1).ltrim();
281
282      MCInst Inst;
283      uint64_t Size;
284      if (!decodeInst(Symbol, Inst, Size))
285        return std::make_pair(EvalResult(("Couldn't decode instruction at '" +
286                                          Symbol + "'").str()),
287                              "");
288      uint64_t NextPC = Checker.getSymbolAddress(Symbol) + Size;
289
290      return std::make_pair(EvalResult(NextPC), RemainingExpr);
291    }
292
293    // Evaluate an identiefer expr, which may be a symbol, or a call to
294    // one of the builtin functions: get_insn_opcode or get_insn_length.
295    // Return the result, plus the expression remaining to be parsed.
296    std::pair<EvalResult, StringRef> evalIdentifierExpr(StringRef Expr) const {
297      StringRef Symbol;
298      StringRef RemainingExpr;
299      std::tie(Symbol, RemainingExpr) = parseSymbol(Expr);
300
301      // Check for builtin function calls.
302      if (Symbol == "decode_operand")
303        return evalDecodeOperand(RemainingExpr);
304      else if (Symbol == "next_pc")
305        return evalNextPC(RemainingExpr);
306
307      // Looks like a plain symbol reference.
308      return std::make_pair(EvalResult(Checker.getSymbolAddress(Symbol)),
309                            RemainingExpr);
310    }
311
312    // Parse a number (hexadecimal or decimal) and return a (string, string)
313    // pair representing the number and the expression remaining to be parsed.
314    std::pair<StringRef, StringRef> parseNumberString(StringRef Expr) const {
315      size_t FirstNonDigit = StringRef::npos;
316      if (Expr.startswith("0x")) {
317        FirstNonDigit = Expr.find_first_not_of("0123456789abcdefABCDEF", 2);
318        if (FirstNonDigit == StringRef::npos)
319          FirstNonDigit = Expr.size();
320      } else {
321        FirstNonDigit = Expr.find_first_not_of("0123456789");
322        if (FirstNonDigit == StringRef::npos)
323          FirstNonDigit = Expr.size();
324      }
325      return std::make_pair(Expr.substr(0, FirstNonDigit),
326                            Expr.substr(FirstNonDigit));
327    }
328
329    // Evaluate a constant numeric expression (hexidecimal or decimal) and
330    // return a pair containing the result, and the expression remaining to be
331    // evaluated.
332    std::pair<EvalResult, StringRef> evalNumberExpr(StringRef Expr) const {
333      StringRef ValueStr;
334      StringRef RemainingExpr;
335      std::tie(ValueStr, RemainingExpr) = parseNumberString(Expr);
336
337      if (ValueStr.empty() || !isdigit(ValueStr[0]))
338        return std::make_pair(unexpectedToken(RemainingExpr, RemainingExpr,
339                                              "expected number"),
340                              "");
341      uint64_t Value;
342      ValueStr.getAsInteger(0, Value);
343      return std::make_pair(EvalResult(Value), RemainingExpr);
344    }
345
346    // Evaluate an expression of the form "(<expr>)" and return a pair
347    // containing the result of evaluating <expr>, plus the expression
348    // remaining to be parsed.
349    std::pair<EvalResult, StringRef> evalParensExpr(StringRef Expr) const {
350      assert(Expr.startswith("(") && "Not a parenthesized expression");
351      EvalResult SubExprResult;
352      StringRef RemainingExpr;
353      std::tie(SubExprResult, RemainingExpr) =
354        evalComplexExpr(evalSimpleExpr(Expr.substr(1).ltrim()));
355      if (SubExprResult.hasError())
356        return std::make_pair(SubExprResult, "");
357      if (!RemainingExpr.startswith(")"))
358        return std::make_pair(unexpectedToken(RemainingExpr, Expr,
359                                              "expected ')'"),
360                              "");
361      RemainingExpr = RemainingExpr.substr(1).ltrim();
362      return std::make_pair(SubExprResult, RemainingExpr);
363    }
364
365    // Evaluate an expression in one of the following forms:
366    //   *{<number>}<symbol>
367    //   *{<number>}(<symbol> + <number>)
368    //   *{<number>}(<symbol> - <number>)
369    // Return a pair containing the result, plus the expression remaining to be
370    // parsed.
371    std::pair<EvalResult, StringRef> evalLoadExpr(StringRef Expr) const {
372      assert(Expr.startswith("*") && "Not a load expression");
373      StringRef RemainingExpr = Expr.substr(1).ltrim();
374      // Parse read size.
375      if (!RemainingExpr.startswith("{"))
376        return std::make_pair(EvalResult("Expected '{' following '*'."), "");
377      RemainingExpr = RemainingExpr.substr(1).ltrim();
378      EvalResult ReadSizeExpr;
379      std::tie(ReadSizeExpr, RemainingExpr) = evalNumberExpr(RemainingExpr);
380      if (ReadSizeExpr.hasError())
381        return std::make_pair(ReadSizeExpr, RemainingExpr);
382      uint64_t ReadSize = ReadSizeExpr.getValue();
383      if (ReadSize < 1 || ReadSize > 8)
384        return std::make_pair(EvalResult("Invalid size for dereference."), "");
385      if (!RemainingExpr.startswith("}"))
386        return std::make_pair(EvalResult("Missing '}' for dereference."), "");
387      RemainingExpr = RemainingExpr.substr(1).ltrim();
388
389      // Check for '(symbol +/- constant)' form.
390      bool SymbolPlusConstant = false;
391      if (RemainingExpr.startswith("(")) {
392        SymbolPlusConstant = true;
393        RemainingExpr = RemainingExpr.substr(1).ltrim();
394      }
395
396      // Read symbol.
397      StringRef Symbol;
398      std::tie(Symbol, RemainingExpr) = parseSymbol(RemainingExpr);
399
400      if (!Checker.checkSymbolIsValidForLoad(Symbol))
401        return std::make_pair(EvalResult(("Cannot dereference unknown symbol '"
402                                          + Symbol + "'").str()),
403                              "");
404
405      // Set up defaut offset.
406      int64_t Offset = 0;
407
408      // Handle "+/- constant)" portion if necessary.
409      if (SymbolPlusConstant) {
410        char OpChar = RemainingExpr[0];
411        if (OpChar != '+' && OpChar != '-')
412          return std::make_pair(EvalResult("Invalid operator in load address."),
413                                "");
414        RemainingExpr = RemainingExpr.substr(1).ltrim();
415
416        EvalResult OffsetExpr;
417        std::tie(OffsetExpr, RemainingExpr) = evalNumberExpr(RemainingExpr);
418
419        Offset = (OpChar == '+') ?
420                   OffsetExpr.getValue() : -1 * OffsetExpr.getValue();
421
422        if (!RemainingExpr.startswith(")"))
423          return std::make_pair(EvalResult("Missing ')' in load address."),
424                                "");
425
426        RemainingExpr = RemainingExpr.substr(1).ltrim();
427      }
428
429      return std::make_pair(
430               EvalResult(Checker.readMemoryAtSymbol(Symbol, Offset, ReadSize)),
431               RemainingExpr);
432    }
433
434    // Evaluate a "simple" expression. This is any expression that _isn't_ an
435    // un-parenthesized binary expression.
436    //
437    // "Simple" expressions can be optionally bit-sliced. See evalSlicedExpr.
438    //
439    // Returns a pair containing the result of the evaluation, plus the
440    // expression remaining to be parsed.
441    std::pair<EvalResult, StringRef> evalSimpleExpr(StringRef Expr) const {
442      EvalResult SubExprResult;
443      StringRef RemainingExpr;
444
445      if (Expr.empty())
446        return std::make_pair(EvalResult("Unexpected end of expression"), "");
447
448      if (Expr[0] == '(')
449        std::tie(SubExprResult, RemainingExpr) = evalParensExpr(Expr);
450      else if (Expr[0] == '*')
451        std::tie(SubExprResult, RemainingExpr) = evalLoadExpr(Expr);
452      else if (isalpha(Expr[0]))
453        std::tie(SubExprResult, RemainingExpr) = evalIdentifierExpr(Expr);
454      else if (isdigit(Expr[0]))
455        std::tie(SubExprResult, RemainingExpr) = evalNumberExpr(Expr);
456
457      if (SubExprResult.hasError())
458        return std::make_pair(SubExprResult, RemainingExpr);
459
460      // Evaluate bit-slice if present.
461      if (RemainingExpr.startswith("["))
462        std::tie(SubExprResult, RemainingExpr) =
463          evalSliceExpr(std::make_pair(SubExprResult, RemainingExpr));
464
465      return std::make_pair(SubExprResult, RemainingExpr);
466    }
467
468    // Evaluate a bit-slice of an expression.
469    // A bit-slice has the form "<expr>[high:low]". The result of evaluating a
470    // slice is the bits between high and low (inclusive) in the original
471    // expression, right shifted so that the "low" bit is in position 0 in the
472    // result.
473    // Returns a pair containing the result of the slice operation, plus the
474    // expression remaining to be parsed.
475    std::pair<EvalResult, StringRef> evalSliceExpr(
476                                    std::pair<EvalResult, StringRef> Ctx) const{
477      EvalResult SubExprResult;
478      StringRef RemainingExpr;
479      std::tie(SubExprResult, RemainingExpr) = Ctx;
480
481      assert(RemainingExpr.startswith("[") && "Not a slice expr.");
482      RemainingExpr = RemainingExpr.substr(1).ltrim();
483
484      EvalResult HighBitExpr;
485      std::tie(HighBitExpr, RemainingExpr) = evalNumberExpr(RemainingExpr);
486
487      if (HighBitExpr.hasError())
488        return std::make_pair(HighBitExpr, RemainingExpr);
489
490      if (!RemainingExpr.startswith(":"))
491        return std::make_pair(unexpectedToken(RemainingExpr, RemainingExpr,
492                                              "expected ':'"),
493                              "");
494      RemainingExpr = RemainingExpr.substr(1).ltrim();
495
496      EvalResult LowBitExpr;
497      std::tie(LowBitExpr, RemainingExpr) = evalNumberExpr(RemainingExpr);
498
499      if (LowBitExpr.hasError())
500        return std::make_pair(LowBitExpr, RemainingExpr);
501
502      if (!RemainingExpr.startswith("]"))
503        return std::make_pair(unexpectedToken(RemainingExpr, RemainingExpr,
504                                              "expected ']'"),
505                              "");
506      RemainingExpr = RemainingExpr.substr(1).ltrim();
507
508      unsigned HighBit = HighBitExpr.getValue();
509      unsigned LowBit = LowBitExpr.getValue();
510      uint64_t Mask = ((uint64_t)1 << (HighBit - LowBit + 1)) - 1;
511      uint64_t SlicedValue = (SubExprResult.getValue() >> LowBit) & Mask;
512      return std::make_pair(EvalResult(SlicedValue), RemainingExpr);
513    }
514
515    // Evaluate a "complex" expression.
516    // Takes an already evaluated subexpression and checks for the presence of a
517    // binary operator, computing the result of the binary operation if one is
518    // found. Used to make arithmetic expressions left-associative.
519    // Returns a pair containing the ultimate result of evaluating the
520    // expression, plus the expression remaining to be evaluated.
521    std::pair<EvalResult, StringRef> evalComplexExpr(
522                                   std::pair<EvalResult, StringRef> Ctx) const {
523      EvalResult LHSResult;
524      StringRef RemainingExpr;
525      std::tie(LHSResult, RemainingExpr) = Ctx;
526
527      // If there was an error, or there's nothing left to evaluate, return the
528      // result.
529      if (LHSResult.hasError() || RemainingExpr == "")
530        return std::make_pair(LHSResult, RemainingExpr);
531
532      // Otherwise check if this is a binary expressioan.
533      BinOpToken BinOp;
534      std::tie(BinOp, RemainingExpr) = parseBinOpToken(RemainingExpr);
535
536      // If this isn't a recognized expression just return.
537      if (BinOp == BinOpToken::Invalid)
538        return std::make_pair(LHSResult, RemainingExpr);
539
540      // This is a recognized bin-op. Evaluate the RHS, then evaluate the binop.
541      EvalResult RHSResult;
542      std::tie(RHSResult, RemainingExpr) = evalSimpleExpr(RemainingExpr);
543
544      // If there was an error evaluating the RHS, return it.
545      if (RHSResult.hasError())
546        return std::make_pair(RHSResult, RemainingExpr);
547
548      // This is a binary expression - evaluate and try to continue as a
549      // complex expr.
550      EvalResult ThisResult(computeBinOpResult(BinOp, LHSResult, RHSResult));
551
552      return evalComplexExpr(std::make_pair(ThisResult, RemainingExpr));
553    }
554
555    bool decodeInst(StringRef Symbol, MCInst &Inst, uint64_t &Size) const {
556      MCDisassembler *Dis = Checker.Disassembler;
557      StringRef SectionMem = Checker.getSubsectionStartingAt(Symbol);
558      StringRefMemoryObject SectionBytes(SectionMem, 0);
559
560      MCDisassembler::DecodeStatus S =
561        Dis->getInstruction(Inst, Size, SectionBytes, 0, nulls(), nulls());
562
563      return (S == MCDisassembler::Success);
564    }
565
566  };
567
568}
569
570bool RuntimeDyldChecker::check(StringRef CheckExpr) const {
571  CheckExpr = CheckExpr.trim();
572  DEBUG(llvm::dbgs() << "RuntimeDyldChecker: Checking '" << CheckExpr
573                     << "'...\n");
574  RuntimeDyldCheckerExprEval P(*this, ErrStream);
575  bool Result = P.evaluate(CheckExpr);
576  (void)Result;
577  DEBUG(llvm::dbgs() << "RuntimeDyldChecker: '" << CheckExpr << "' "
578                     << (Result ? "passed" : "FAILED") << ".\n");
579  return Result;
580}
581
582bool RuntimeDyldChecker::checkAllRulesInBuffer(StringRef RulePrefix,
583                                               MemoryBuffer* MemBuf) const {
584  bool DidAllTestsPass = true;
585  unsigned NumRules = 0;
586
587  const char *LineStart = MemBuf->getBufferStart();
588
589  // Eat whitespace.
590  while (LineStart != MemBuf->getBufferEnd() &&
591         std::isspace(*LineStart))
592    ++LineStart;
593
594  while (LineStart != MemBuf->getBufferEnd() && *LineStart != '\0') {
595    const char *LineEnd = LineStart;
596    while (LineEnd != MemBuf->getBufferEnd() &&
597           *LineEnd != '\r' && *LineEnd != '\n')
598      ++LineEnd;
599
600    StringRef Line(LineStart, LineEnd - LineStart);
601    if (Line.startswith(RulePrefix)) {
602      DidAllTestsPass &= check(Line.substr(RulePrefix.size()));
603      ++NumRules;
604    }
605
606    // Eat whitespace.
607    LineStart = LineEnd;
608    while (LineStart != MemBuf->getBufferEnd() &&
609           std::isspace(*LineStart))
610      ++LineStart;
611  }
612  return DidAllTestsPass && (NumRules != 0);
613}
614
615bool RuntimeDyldChecker::checkSymbolIsValidForLoad(StringRef Symbol) const {
616  return RTDyld.getSymbolAddress(Symbol) != nullptr;
617}
618
619uint64_t RuntimeDyldChecker::getSymbolAddress(StringRef Symbol) const {
620  return RTDyld.getAnySymbolRemoteAddress(Symbol);
621}
622
623uint64_t RuntimeDyldChecker::readMemoryAtSymbol(StringRef Symbol,
624                                                int64_t Offset,
625                                                unsigned Size) const {
626  uint8_t *Src = RTDyld.getSymbolAddress(Symbol);
627  uint64_t Result = 0;
628  memcpy(&Result, Src + Offset, Size);
629  return Result;
630}
631
632StringRef RuntimeDyldChecker::getSubsectionStartingAt(StringRef Name) const {
633  RuntimeDyldImpl::SymbolTableMap::const_iterator pos =
634    RTDyld.GlobalSymbolTable.find(Name);
635  if (pos == RTDyld.GlobalSymbolTable.end())
636    return StringRef();
637  RuntimeDyldImpl::SymbolLoc Loc = pos->second;
638  uint8_t *SectionAddr = RTDyld.getSectionAddress(Loc.first);
639  return StringRef(reinterpret_cast<const char*>(SectionAddr) + Loc.second,
640                   RTDyld.Sections[Loc.first].Size - Loc.second);
641}
642