Debian Codegraph @

llvm-project/clang/lib/AST/Interp/ByteCodeExprGen.h

raw
1 //===--- ByteCodeExprGen.h - Code generator for expressions -----*- 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 constexpr bytecode compiler.
10 //
11 //===----------------------------------------------------------------------===//
12
13 #ifndef LLVM_CLANG_AST_INTERP_BYTECODEEXPRGEN_H
14 #define LLVM_CLANG_AST_INTERP_BYTECODEEXPRGEN_H
15
16 #include "ByteCodeEmitter.h"
17 #include "EvalEmitter.h"
18 #include "Pointer.h"
19 #include "PrimType.h"
20 #include "Record.h"
21 #include "clang/AST/Decl.h"
22 #include "clang/AST/Expr.h"
23 #include "clang/AST/StmtVisitor.h"
24 #include "clang/Basic/TargetInfo.h"
25
26 namespace clang {
27 class QualType;
28
29 namespace interp {
30
31 template <class Emitter> class LocalScope;
32 template <class Emitter> class RecordScope;
33 template <class Emitter> class VariableScope;
34 template <class Emitter> class DeclScope;
35 template <class Emitter> class OptionScope;
36 template <class Emitter> class ArrayIndexScope;
37
38 /// Compilation context for expressions.
39 template <class Emitter>
40 class ByteCodeExprGen : public ConstStmtVisitor<ByteCodeExprGen<Emitter>, bool>,
41 public Emitter {
42 protected:
43 // Aliases for types defined in the emitter.
44 using LabelTy = typename Emitter::LabelTy;
45 using AddrTy = typename Emitter::AddrTy;
46
47 /// Current compilation context.
48 Context &Ctx;
49 /// Program to link to.
50 Program &P;
51
52 public:
53 /// Initializes the compiler and the backend emitter.
54 template <typename... Tys>
55 ByteCodeExprGen(Context &Ctx, Program &P, Tys &&... Args)
56 : Emitter(Ctx, P, Args...), Ctx(Ctx), P(P) {}
57
58 // Expression visitors - result returned on interp stack.
59 bool VisitCastExpr(const CastExpr *E);
60 bool VisitIntegerLiteral(const IntegerLiteral *E);
61 bool VisitParenExpr(const ParenExpr *E);
62 bool VisitBinaryOperator(const BinaryOperator *E);
63 bool VisitPointerArithBinOp(const BinaryOperator *E);
64 bool VisitCXXDefaultArgExpr(const CXXDefaultArgExpr *E);
65 bool VisitCallExpr(const CallExpr *E);
66 bool VisitCXXMemberCallExpr(const CXXMemberCallExpr *E);
67 bool VisitCXXDefaultInitExpr(const CXXDefaultInitExpr *E);
68 bool VisitCXXBoolLiteralExpr(const CXXBoolLiteralExpr *E);
69 bool VisitCXXNullPtrLiteralExpr(const CXXNullPtrLiteralExpr *E);
70 bool VisitCXXThisExpr(const CXXThisExpr *E);
71 bool VisitUnaryOperator(const UnaryOperator *E);
72 bool VisitDeclRefExpr(const DeclRefExpr *E);
73 bool VisitImplicitValueInitExpr(const ImplicitValueInitExpr *E);
74 bool VisitSubstNonTypeTemplateParmExpr(const SubstNonTypeTemplateParmExpr *E);
75 bool VisitArraySubscriptExpr(const ArraySubscriptExpr *E);
76 bool VisitInitListExpr(const InitListExpr *E);
77 bool VisitConstantExpr(const ConstantExpr *E);
78 bool VisitUnaryExprOrTypeTraitExpr(const UnaryExprOrTypeTraitExpr *E);
79 bool VisitMemberExpr(const MemberExpr *E);
80 bool VisitArrayInitIndexExpr(const ArrayInitIndexExpr *E);
81 bool VisitOpaqueValueExpr(const OpaqueValueExpr *E);
82 bool VisitAbstractConditionalOperator(const AbstractConditionalOperator *E);
83 bool VisitStringLiteral(const StringLiteral *E);
84 bool VisitCharacterLiteral(const CharacterLiteral *E);
85 bool VisitCompoundAssignOperator(const CompoundAssignOperator *E);
86
87 protected:
88 bool visitExpr(const Expr *E) override;
89 bool visitDecl(const VarDecl *VD) override;
90
91 protected:
92 /// Emits scope cleanup instructions.
93 void emitCleanup();
94
95 /// Returns a record type from a record or pointer type.
96 const RecordType *getRecordTy(QualType Ty);
97
98 /// Returns a record from a record or pointer type.
99 Record *getRecord(QualType Ty);
100 Record *getRecord(const RecordDecl *RD);
101
102 // Returns a function for the given FunctionDecl.
103 // If the function does not exist yet, it is compiled.
104 const Function *getFunction(const FunctionDecl *FD);
105
106 /// Classifies a type.
107 std::optional<PrimType> classify(const Expr *E) const {
108 return E->isGLValue() ? PT_Ptr : classify(E->getType());
109 }
110 std::optional<PrimType> classify(QualType Ty) const {
111 return Ctx.classify(Ty);
112 }
113
114 /// Classifies a known primitive type
115 PrimType classifyPrim(QualType Ty) const {
116 if (auto T = classify(Ty)) {
117 return *T;
118 }
119 llvm_unreachable("not a primitive type");
120 }
121
122 /// Evaluates an expression for side effects and discards the result.
123 bool discard(const Expr *E);
124 /// Evaluates an expression and places result on stack.
125 bool visit(const Expr *E);
126 /// Compiles an initializer.
127 bool visitInitializer(const Expr *E);
128 /// Compiles an array initializer.
129 bool visitArrayInitializer(const Expr *Initializer);
130 /// Compiles a record initializer.
131 bool visitRecordInitializer(const Expr *Initializer);
132 /// Creates and initializes a variable from the given decl.
133 bool visitVarDecl(const VarDecl *VD);
134
135 /// Visits an expression and converts it to a boolean.
136 bool visitBool(const Expr *E);
137
138 /// Visits an initializer for a local.
139 bool visitLocalInitializer(const Expr *Init, unsigned I) {
140 if (!this->emitGetPtrLocal(I, Init))
141 return false;
142
143 if (!visitInitializer(Init))
144 return false;
145
146 return this->emitPopPtr(Init);
147 }
148
149 /// Visits an initializer for a global.
150 bool visitGlobalInitializer(const Expr *Init, unsigned I) {
151 if (!this->emitGetPtrGlobal(I, Init))
152 return false;
153
154 if (!visitInitializer(Init))
155 return false;
156
157 return this->emitPopPtr(Init);
158 }
159
160 /// Visits a delegated initializer.
161 bool visitThisInitializer(const Expr *I) {
162 if (!this->emitThis(I))
163 return false;
164
165 if (!visitInitializer(I))
166 return false;
167
168 return this->emitPopPtr(I);
169 }
170
171 /// Creates a local primitive value.
172 unsigned allocateLocalPrimitive(DeclTy &&Decl, PrimType Ty, bool IsMutable,
173 bool IsExtended = false);
174
175 /// Allocates a space storing a local given its type.
176 std::optional<unsigned> allocateLocal(DeclTy &&Decl, bool IsExtended = false);
177
178 private:
179 friend class VariableScope<Emitter>;
180 friend class LocalScope<Emitter>;
181 friend class RecordScope<Emitter>;
182 friend class DeclScope<Emitter>;
183 friend class OptionScope<Emitter>;
184 friend class ArrayIndexScope<Emitter>;
185
186 /// Emits a zero initializer.
187 bool visitZeroInitializer(PrimType T, const Expr *E);
188
189 enum class DerefKind {
190 /// Value is read and pushed to stack.
191 Read,
192 /// Direct method generates a value which is written. Returns pointer.
193 Write,
194 /// Direct method receives the value, pushes mutated value. Returns pointer.
195 ReadWrite,
196 };
197
198 /// Method to directly load a value. If the value can be fetched directly,
199 /// the direct handler is called. Otherwise, a pointer is left on the stack
200 /// and the indirect handler is expected to operate on that.
201 bool dereference(const Expr *LV, DerefKind AK,
202 llvm::function_ref<bool(PrimType)> Direct,
203 llvm::function_ref<bool(PrimType)> Indirect);
204 bool dereferenceParam(const Expr *LV, PrimType T, const ParmVarDecl *PD,
205 DerefKind AK,
206 llvm::function_ref<bool(PrimType)> Direct,
207 llvm::function_ref<bool(PrimType)> Indirect);
208 bool dereferenceVar(const Expr *LV, PrimType T, const VarDecl *PD,
209 DerefKind AK, llvm::function_ref<bool(PrimType)> Direct,
210 llvm::function_ref<bool(PrimType)> Indirect);
211
212 /// Emits an APSInt constant.
213 bool emitConst(const APSInt &Value, const Expr *E);
214 bool emitConst(const APInt &Value, const Expr *E) {
215 return emitConst(static_cast<APSInt>(Value), E);
216 }
217
218 /// Emits an integer constant.
219 template <typename T> bool emitConst(T Value, const Expr *E);
220
221 /// Returns the CXXRecordDecl for the type of the given expression,
222 /// or nullptr if no such decl exists.
223 const CXXRecordDecl *getRecordDecl(const Expr *E) const {
224 QualType T = E->getType();
225 if (const auto *RD = T->getPointeeCXXRecordDecl())
226 return RD;
227 return T->getAsCXXRecordDecl();
228 }
229
230 /// Returns whether we should create a global variable for the
231 /// given VarDecl.
232 bool shouldBeGloballyIndexed(const VarDecl *VD) const {
233 return VD->hasGlobalStorage() || VD->isConstexpr();
234 }
235
236 protected:
237 /// Variable to storage mapping.
238 llvm::DenseMap<const ValueDecl *, Scope::Local> Locals;
239
240 /// OpaqueValueExpr to location mapping.
241 llvm::DenseMap<const OpaqueValueExpr *, unsigned> OpaqueExprs;
242
243 /// Current scope.
244 VariableScope<Emitter> *VarScope = nullptr;
245
246 /// Current argument index. Needed to emit ArrayInitIndexExpr.
247 std::optional<uint64_t> ArrayIndex;
248
249 /// Flag indicating if return value is to be discarded.
250 bool DiscardResult = false;
251 };
252
253 extern template class ByteCodeExprGen<ByteCodeEmitter>;
254 extern template class ByteCodeExprGen<EvalEmitter>;
255
256 /// Scope chain managing the variable lifetimes.
257 template <class Emitter> class VariableScope {
258 public:
259 VariableScope(ByteCodeExprGen<Emitter> *Ctx)
260 : Ctx(Ctx), Parent(Ctx->VarScope) {
261 Ctx->VarScope = this;
262 }
263
264 virtual ~VariableScope() { Ctx->VarScope = this->Parent; }
265
266 void add(const Scope::Local &Local, bool IsExtended) {
267 if (IsExtended)
268 this->addExtended(Local);
269 else
270 this->addLocal(Local);
271 }
272
273 virtual void addLocal(const Scope::Local &Local) {
274 if (this->Parent)
275 this->Parent->addLocal(Local);
276 }
277
278 virtual void addExtended(const Scope::Local &Local) {
279 if (this->Parent)
280 this->Parent->addExtended(Local);
281 }
282
283 virtual void emitDestruction() {}
284
285 VariableScope *getParent() { return Parent; }
286
287 protected:
288 /// ByteCodeExprGen instance.
289 ByteCodeExprGen<Emitter> *Ctx;
290 /// Link to the parent scope.
291 VariableScope *Parent;
292 };
293
294 /// Scope for local variables.
295 ///
296 /// When the scope is destroyed, instructions are emitted to tear down
297 /// all variables declared in this scope.
298 template <class Emitter> class LocalScope : public VariableScope<Emitter> {
299 public:
300 LocalScope(ByteCodeExprGen<Emitter> *Ctx) : VariableScope<Emitter>(Ctx) {}
301
302 ~LocalScope() override { this->emitDestruction(); }
303
304 void addLocal(const Scope::Local &Local) override {
305 if (!Idx) {
306 Idx = this->Ctx->Descriptors.size();
307 this->Ctx->Descriptors.emplace_back();
308 }
309
310 this->Ctx->Descriptors[*Idx].emplace_back(Local);
311 }
312
313 void emitDestruction() override {
314 if (!Idx)
315 return;
316 this->Ctx->emitDestroy(*Idx, SourceInfo{});
317 }
318
319 protected:
320 /// Index of the scope in the chain.
321 std::optional<unsigned> Idx;
322 };
323
324 /// Scope for storage declared in a compound statement.
325 template <class Emitter> class BlockScope final : public LocalScope<Emitter> {
326 public:
327 BlockScope(ByteCodeExprGen<Emitter> *Ctx) : LocalScope<Emitter>(Ctx) {}
328
329 void addExtended(const Scope::Local &Local) override {
330 llvm_unreachable("Cannot create temporaries in full scopes");
331 }
332 };
333
334 /// Expression scope which tracks potentially lifetime extended
335 /// temporaries which are hoisted to the parent scope on exit.
336 template <class Emitter> class ExprScope final : public LocalScope<Emitter> {
337 public:
338 ExprScope(ByteCodeExprGen<Emitter> *Ctx) : LocalScope<Emitter>(Ctx) {}
339
340 void addExtended(const Scope::Local &Local) override {
341 assert(this->Parent);
342 this->Parent->addLocal(Local);
343 }
344 };
345
346 template <class Emitter> class ArrayIndexScope final {
347 public:
348 ArrayIndexScope(ByteCodeExprGen<Emitter> *Ctx, uint64_t Index) : Ctx(Ctx) {
349 OldArrayIndex = Ctx->ArrayIndex;
350 Ctx->ArrayIndex = Index;
351 }
352
353 ~ArrayIndexScope() { Ctx->ArrayIndex = OldArrayIndex; }
354
355 private:
356 ByteCodeExprGen<Emitter> *Ctx;
357 std::optional<uint64_t> OldArrayIndex;
358 };
359
360 } // namespace interp
361 } // namespace clang
362
363 #endif