Coverage Report

Created: 2020-02-15 09:57

/Users/buildslave/jenkins/workspace/coverage/llvm-project/clang/lib/AST/Interp/EvalEmitter.h
Line
Count
Source (jump to first uncovered line)
1
//===--- EvalEmitter.h - Instruction emitter for the VM ---------*- C++ -*-===//
2
//
3
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4
// See https://llvm.org/LICENSE.txt for license information.
5
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6
//
7
//===----------------------------------------------------------------------===//
8
//
9
// Defines the instruction emitters.
10
//
11
//===----------------------------------------------------------------------===//
12
13
#ifndef LLVM_CLANG_AST_INTERP_EVALEMITTER_H
14
#define LLVM_CLANG_AST_INTERP_EVALEMITTER_H
15
16
#include "ByteCodeGenError.h"
17
#include "Context.h"
18
#include "InterpStack.h"
19
#include "InterpState.h"
20
#include "PrimType.h"
21
#include "Program.h"
22
#include "Source.h"
23
#include "llvm/Support/Error.h"
24
25
namespace clang {
26
class FunctionDecl;
27
namespace interp {
28
class Context;
29
class Function;
30
class InterpState;
31
class Program;
32
class SourceInfo;
33
enum Opcode : uint32_t;
34
35
/// An emitter which evaluates opcodes as they are emitted.
36
class EvalEmitter : public SourceMapper {
37
public:
38
  using LabelTy = uint32_t;
39
  using AddrTy = uintptr_t;
40
  using Local = Scope::Local;
41
42
  llvm::Expected<bool> interpretExpr(const Expr *E);
43
  llvm::Expected<bool> interpretDecl(const VarDecl *VD);
44
45
protected:
46
  EvalEmitter(Context &Ctx, Program &P, State &Parent, InterpStack &Stk,
47
              APValue &Result);
48
49
7
  virtual ~EvalEmitter() {}
50
51
  /// Define a label.
52
  void emitLabel(LabelTy Label);
53
  /// Create a label.
54
  LabelTy getLabel();
55
56
  /// Methods implemented by the compiler.
57
  virtual bool visitExpr(const Expr *E) = 0;
58
  virtual bool visitDecl(const VarDecl *VD) = 0;
59
60
0
  bool bail(const Stmt *S) { return bail(S->getBeginLoc()); }
61
0
  bool bail(const Decl *D) { return bail(D->getBeginLoc()); }
62
  bool bail(const SourceLocation &Loc);
63
64
  /// Emits jumps.
65
  bool jumpTrue(const LabelTy &Label);
66
  bool jumpFalse(const LabelTy &Label);
67
  bool jump(const LabelTy &Label);
68
  bool fallthrough(const LabelTy &Label);
69
70
  /// Callback for registering a local.
71
  Local createLocal(Descriptor *D);
72
73
  /// Returns the source location of the current opcode.
74
0
  SourceInfo getSource(Function *F, CodePtr PC) const override {
75
0
    return F ? F->getSource(PC) : CurrentSource;
76
0
  }
77
78
  /// Parameter indices.
79
  llvm::DenseMap<const ParmVarDecl *, unsigned> Params;
80
  /// Local descriptors.
81
  llvm::SmallVector<SmallVector<Local, 8>, 2> Descriptors;
82
83
private:
84
  /// Current compilation context.
85
  Context &Ctx;
86
  /// Current program.
87
  Program &P;
88
  /// Callee evaluation state.
89
  InterpState S;
90
  /// Location to write the result to.
91
  APValue &Result;
92
93
  /// Temporaries which require storage.
94
  llvm::DenseMap<unsigned, std::unique_ptr<char[]>> Locals;
95
96
  // The emitter always tracks the current instruction and sets OpPC to a token
97
  // value which is mapped to the location of the opcode being evaluated.
98
  CodePtr OpPC;
99
  /// Location of a failure.
100
  llvm::Optional<SourceLocation> BailLocation;
101
  /// Location of the current instruction.
102
  SourceInfo CurrentSource;
103
104
  /// Next label ID to generate - first label is 1.
105
  LabelTy NextLabel = 1;
106
  /// Label being executed - 0 is the entry label.
107
  LabelTy CurrentLabel = 0;
108
  /// Active block which should be executed.
109
  LabelTy ActiveLabel = 0;
110
111
  /// Since expressions can only jump forward, predicated execution is
112
  /// used to deal with if-else statements.
113
0
  bool isActive() { return CurrentLabel == ActiveLabel; }
114
115
  /// Helper to invoke a method.
116
  bool ExecuteCall(Function *F, Pointer &&This, const SourceInfo &Info);
117
  /// Helper to emit a diagnostic on a missing method.
118
  bool ExecuteNoCall(const FunctionDecl *F, const SourceInfo &Info);
119
120
protected:
121
#define GET_EVAL_PROTO
122
#include "Opcodes.inc"
123
#undef GET_EVAL_PROTO
124
};
125
126
} // namespace interp
127
} // namespace clang
128
129
#endif