clang 20.0.0git
EvalEmitter.cpp
Go to the documentation of this file.
1//===--- EvalEmitter.cpp - 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#include "EvalEmitter.h"
10#include "Context.h"
11#include "IntegralAP.h"
12#include "Interp.h"
13#include "Opcode.h"
14#include "clang/AST/DeclCXX.h"
15
16using namespace clang;
17using namespace clang::interp;
18
20 InterpStack &Stk)
21 : Ctx(Ctx), P(P), S(Parent, P, Stk, Ctx, this), EvalResult(&Ctx) {
22 // Create a dummy frame for the interpreter which does not have locals.
23 S.Current =
24 new InterpFrame(S, /*Func=*/nullptr, /*Caller=*/nullptr, CodePtr(), 0);
25}
26
28 for (auto &[K, V] : Locals) {
29 Block *B = reinterpret_cast<Block *>(V.get());
30 if (B->isInitialized())
31 B->invokeDtor();
32 }
33}
34
35/// Clean up all our resources. This needs to done in failed evaluations before
36/// we call InterpStack::clear(), because there might be a Pointer on the stack
37/// pointing into a Block in the EvalEmitter.
39
41 bool ConvertResultToRValue) {
43 this->ConvertResultToRValue = ConvertResultToRValue && !isa<ConstantExpr>(E);
44 this->CheckFullyInitialized = isa<ConstantExpr>(E);
45 EvalResult.setSource(E);
46
47 if (!this->visitExpr(E)) {
48 // EvalResult may already have a result set, but something failed
49 // after that (e.g. evaluating destructors).
50 EvalResult.setInvalid();
51 }
52
53 return std::move(this->EvalResult);
54}
55
58 this->CheckFullyInitialized = CheckFullyInitialized;
59 S.EvaluatingDecl = VD;
60 EvalResult.setSource(VD);
61
62 if (const Expr *Init = VD->getAnyInitializer()) {
63 QualType T = VD->getType();
64 this->ConvertResultToRValue = !Init->isGLValue() && !T->isPointerType() &&
66 } else
67 this->ConvertResultToRValue = false;
68
69 EvalResult.setSource(VD);
70
71 if (!this->visitDeclAndReturn(VD, S.inConstantContext()))
72 EvalResult.setInvalid();
73
74 S.EvaluatingDecl = nullptr;
75 updateGlobalTemporaries();
76 return std::move(this->EvalResult);
77}
78
80 CurrentLabel = Label;
81}
82
84
86 // Allocate memory for a local.
87 auto Memory = std::make_unique<char[]>(sizeof(Block) + D->getAllocSize());
88 auto *B = new (Memory.get()) Block(Ctx.getEvalID(), D, /*isStatic=*/false);
89 B->invokeCtor();
90
91 // Initialize local variable inline descriptor.
92 InlineDescriptor &Desc = *reinterpret_cast<InlineDescriptor *>(B->rawData());
93 Desc.Desc = D;
94 Desc.Offset = sizeof(InlineDescriptor);
95 Desc.IsActive = true;
96 Desc.IsBase = false;
97 Desc.IsFieldMutable = false;
98 Desc.IsConst = false;
99 Desc.IsInitialized = false;
100
101 // Register the local.
102 unsigned Off = Locals.size();
103 Locals.insert({Off, std::move(Memory)});
104 return {Off, D};
105}
106
108 if (isActive()) {
109 if (S.Stk.pop<bool>())
110 ActiveLabel = Label;
111 }
112 return true;
113}
114
116 if (isActive()) {
117 if (!S.Stk.pop<bool>())
118 ActiveLabel = Label;
119 }
120 return true;
121}
122
124 if (isActive())
125 CurrentLabel = ActiveLabel = Label;
126 return true;
127}
128
130 if (isActive())
131 ActiveLabel = Label;
132 CurrentLabel = Label;
133 return true;
134}
135
137 return S.maybeDiagnoseDanglingAllocations();
138}
139
140template <PrimType OpType> bool EvalEmitter::emitRet(const SourceInfo &Info) {
141 if (!isActive())
142 return true;
143
144 if (!checkReturnState(S))
145 return false;
146
147 using T = typename PrimConv<OpType>::T;
148 EvalResult.setValue(S.Stk.pop<T>().toAPValue(Ctx.getASTContext()));
149 return true;
150}
151
152template <> bool EvalEmitter::emitRet<PT_Ptr>(const SourceInfo &Info) {
153 if (!isActive())
154 return true;
155
156 const Pointer &Ptr = S.Stk.pop<Pointer>();
157
158 if (!EvalResult.checkReturnValue(S, Ctx, Ptr, Info))
159 return false;
160 if (CheckFullyInitialized && !EvalResult.checkFullyInitialized(S, Ptr))
161 return false;
162
163 if (!checkReturnState(S))
164 return false;
165
166 // Implicitly convert lvalue to rvalue, if requested.
167 if (ConvertResultToRValue) {
168 if (!Ptr.isZero() && !Ptr.isDereferencable())
169 return false;
170 // Never allow reading from a non-const pointer, unless the memory
171 // has been created in this evaluation.
172 if (!Ptr.isZero() && Ptr.isBlockPointer() &&
173 Ptr.block()->getEvalID() != Ctx.getEvalID() &&
174 (!CheckLoad(S, OpPC, Ptr, AK_Read) || !Ptr.isConst()))
175 return false;
176
177 if (std::optional<APValue> V =
178 Ptr.toRValue(Ctx, EvalResult.getSourceType())) {
179 EvalResult.setValue(*V);
180 } else {
181 return false;
182 }
183 } else {
184 EvalResult.setValue(Ptr.toAPValue(Ctx.getASTContext()));
185 }
186
187 return true;
188}
189template <> bool EvalEmitter::emitRet<PT_FnPtr>(const SourceInfo &Info) {
190 if (!isActive())
191 return true;
192
193 if (!checkReturnState(S))
194 return false;
195 // Function pointers cannot be converted to rvalues.
196 EvalResult.setFunctionPointer(S.Stk.pop<FunctionPointer>());
197 return true;
198}
199
200bool EvalEmitter::emitRetVoid(const SourceInfo &Info) {
201 if (!checkReturnState(S))
202 return false;
203 EvalResult.setValid();
204 return true;
205}
206
207bool EvalEmitter::emitRetValue(const SourceInfo &Info) {
208 const auto &Ptr = S.Stk.pop<Pointer>();
209
210 if (!EvalResult.checkReturnValue(S, Ctx, Ptr, Info))
211 return false;
212 if (CheckFullyInitialized && !EvalResult.checkFullyInitialized(S, Ptr))
213 return false;
214
215 if (!checkReturnState(S))
216 return false;
217
218 if (std::optional<APValue> APV =
219 Ptr.toRValue(S.getCtx(), EvalResult.getSourceType())) {
220 EvalResult.setValue(*APV);
221 return true;
222 }
223
224 EvalResult.setInvalid();
225 return false;
226}
227
228bool EvalEmitter::emitGetPtrLocal(uint32_t I, const SourceInfo &Info) {
229 if (!isActive())
230 return true;
231
232 Block *B = getLocal(I);
233 S.Stk.push<Pointer>(B, sizeof(InlineDescriptor));
234 return true;
235}
236
237template <PrimType OpType>
238bool EvalEmitter::emitGetLocal(uint32_t I, const SourceInfo &Info) {
239 if (!isActive())
240 return true;
241
242 using T = typename PrimConv<OpType>::T;
243
244 Block *B = getLocal(I);
245 S.Stk.push<T>(*reinterpret_cast<T *>(B->data()));
246 return true;
247}
248
249template <PrimType OpType>
250bool EvalEmitter::emitSetLocal(uint32_t I, const SourceInfo &Info) {
251 if (!isActive())
252 return true;
253
254 using T = typename PrimConv<OpType>::T;
255
256 Block *B = getLocal(I);
257 *reinterpret_cast<T *>(B->data()) = S.Stk.pop<T>();
258 InlineDescriptor &Desc = *reinterpret_cast<InlineDescriptor *>(B->rawData());
259 Desc.IsInitialized = true;
260
261 return true;
262}
263
264bool EvalEmitter::emitDestroy(uint32_t I, const SourceInfo &Info) {
265 if (!isActive())
266 return true;
267
268 for (auto &Local : Descriptors[I]) {
269 Block *B = getLocal(Local.Offset);
270 S.deallocate(B);
271 }
272
273 return true;
274}
275
276/// Global temporaries (LifetimeExtendedTemporary) carry their value
277/// around as an APValue, which codegen accesses.
278/// We set their value once when creating them, but we don't update it
279/// afterwards when code changes it later.
280/// This is what we do here.
281void EvalEmitter::updateGlobalTemporaries() {
282 for (const auto &[E, Temp] : S.SeenGlobalTemporaries) {
283 if (std::optional<unsigned> GlobalIndex = P.getGlobal(E)) {
284 const Pointer &Ptr = P.getPtrGlobal(*GlobalIndex);
285 APValue *Cached = Temp->getOrCreateValue(true);
286
287 if (std::optional<PrimType> T = Ctx.classify(E->getType())) {
289 *T, { *Cached = Ptr.deref<T>().toAPValue(Ctx.getASTContext()); });
290 } else {
291 if (std::optional<APValue> APV =
292 Ptr.toRValue(Ctx, Temp->getTemporaryExpr()->getType()))
293 *Cached = *APV;
294 }
295 }
296 }
297 S.SeenGlobalTemporaries.clear();
298}
299
300//===----------------------------------------------------------------------===//
301// Opcode evaluators
302//===----------------------------------------------------------------------===//
303
304#define GET_EVAL_IMPL
305#include "Opcodes.inc"
306#undef GET_EVAL_IMPL
#define V(N, I)
Definition: ASTContext.h:3341
NodeId Parent
Definition: ASTDiff.cpp:191
StringRef P
const Decl * D
Expr * E
Defines the C++ Decl subclasses, other than those for templates (found in DeclTemplate....
static bool checkReturnState(InterpState &S)
static bool CheckFullyInitialized(EvalInfo &Info, SourceLocation DiagLoc, QualType Type, const APValue &Value)
Check that this evaluated value is fully-initialized and can be loaded by an lvalue-to-rvalue convers...
#define TYPE_SWITCH(Expr, B)
Definition: PrimType.h:122
std::string Label
APValue - This class implements a discriminated union of [uninitialized] [APSInt] [APFloat],...
Definition: APValue.h:122
This represents one expression.
Definition: Expr.h:110
SourceLocation getExprLoc() const LLVM_READONLY
getExprLoc - Return the preferred location for the arrow when diagnosing a problem with a generic exp...
Definition: Expr.cpp:277
QualType getType() const
Definition: Expr.h:142
A (possibly-)qualified type.
Definition: Type.h:941
bool isPointerType() const
Definition: Type.h:8003
bool isObjCObjectPointerType() const
Definition: Type.h:8145
QualType getType() const
Definition: Decl.h:678
Represents a variable declaration or definition.
Definition: Decl.h:879
const Expr * getAnyInitializer() const
Get the initializer for this variable, no matter which declaration it is attached to.
Definition: Decl.h:1306
A memory block, either on the stack or in the heap.
Definition: InterpBlock.h:49
void invokeDtor()
Invokes the Destructor.
Definition: InterpBlock.h:121
std::byte * data()
Returns a pointer to the stored data.
Definition: InterpBlock.h:89
void invokeCtor()
Invokes the constructor.
Definition: InterpBlock.h:110
std::byte * rawData()
Returns a pointer to the raw data, including metadata.
Definition: InterpBlock.h:102
bool isInitialized() const
Returns whether the data of this block has been initialized via invoking the Ctor func.
Definition: InterpBlock.h:83
unsigned getEvalID() const
The Evaluation ID this block was created in.
Definition: InterpBlock.h:85
Pointer into the code segment.
Definition: Source.h:30
Holds all information required to evaluate constexpr code in a module.
Definition: Context.h:40
ASTContext & getASTContext() const
Returns the AST context.
Definition: Context.h:61
std::optional< PrimType > classify(QualType T) const
Classifies a type.
Definition: Context.cpp:130
unsigned getEvalID() const
Definition: Context.h:112
bool jump(const LabelTy &Label)
EvaluationResult interpretExpr(const Expr *E, bool ConvertResultToRValue=false)
Definition: EvalEmitter.cpp:40
EvaluationResult interpretDecl(const VarDecl *VD, bool CheckFullyInitialized)
Definition: EvalEmitter.cpp:56
virtual bool visitExpr(const Expr *E)=0
Methods implemented by the compiler.
bool jumpFalse(const LabelTy &Label)
Local createLocal(Descriptor *D)
Callback for registering a local.
Definition: EvalEmitter.cpp:85
void emitLabel(LabelTy Label)
Define a label.
Definition: EvalEmitter.cpp:79
bool isActive() const
Since expressions can only jump forward, predicated execution is used to deal with if-else statements...
Definition: EvalEmitter.h:69
bool fallthrough(const LabelTy &Label)
void cleanup()
Clean up all resources.
Definition: EvalEmitter.cpp:38
LabelTy getLabel()
Create a label.
Definition: EvalEmitter.cpp:83
EvalEmitter(Context &Ctx, Program &P, State &Parent, InterpStack &Stk)
Definition: EvalEmitter.cpp:19
virtual bool visitDeclAndReturn(const VarDecl *VD, bool ConstantContext)=0
llvm::SmallVector< SmallVector< Local, 8 >, 2 > Descriptors
Local descriptors.
Definition: EvalEmitter.h:86
bool jumpTrue(const LabelTy &Label)
Emits jumps.
Defines the result of an evaluation.
bool checkReturnValue(InterpState &S, const Context &Ctx, const Pointer &Ptr, const SourceInfo &Info)
Check that none of the blocks the given pointer (transitively) points to are dynamically allocated.
bool checkFullyInitialized(InterpState &S, const Pointer &Ptr) const
Check that all subobjects of the given pointer have been initialized.
Frame storing local variables.
Definition: InterpFrame.h:26
Stack frame storing temporaries and parameters.
Definition: InterpStack.h:27
T pop()
Returns the value from the top of the stack and removes it.
Definition: InterpStack.h:43
void push(Tys &&... Args)
Constructs a value in place on the top of the stack.
Definition: InterpStack.h:35
Interpreter context.
Definition: InterpState.h:36
llvm::SmallVector< std::pair< const Expr *, const LifetimeExtendedTemporaryDecl * > > SeenGlobalTemporaries
Definition: InterpState.h:140
InterpStack & Stk
Temporary stack.
Definition: InterpState.h:128
bool inConstantContext() const
Definition: InterpState.h:77
const VarDecl * EvaluatingDecl
Declaration we're initializing/evaluting, if any.
Definition: InterpState.h:136
InterpFrame * Current
The current frame.
Definition: InterpState.h:132
void deallocate(Block *B)
Deallocates a pointer.
Definition: InterpState.cpp:60
ASTContext & getCtx() const override
Definition: InterpState.h:62
void setEvalLocation(SourceLocation SL)
Definition: InterpState.h:104
A pointer to a memory block, live or dead.
Definition: Pointer.h:82
bool isConst() const
Checks if an object or a subfield is mutable.
Definition: Pointer.h:538
T & deref() const
Dereferences the pointer, if it's live.
Definition: Pointer.h:623
bool isZero() const
Checks if the pointer is null.
Definition: Pointer.h:260
APValue toAPValue(const ASTContext &ASTCtx) const
Converts the pointer to an APValue.
Definition: Pointer.cpp:140
bool isDereferencable() const
Whether this block can be read from at all.
Definition: Pointer.h:649
bool isBlockPointer() const
Definition: Pointer.h:456
std::optional< APValue > toRValue(const Context &Ctx, QualType ResultType) const
Converts the pointer to an APValue that is an rvalue.
Definition: Pointer.cpp:459
const Block * block() const
Definition: Pointer.h:569
The program contains and links the bytecode for all functions.
Definition: Program.h:39
Block * getGlobal(unsigned Idx)
Returns the value of a global.
Definition: Program.h:73
Pointer getPtrGlobal(unsigned Idx) const
Returns a pointer to a global.
Definition: Program.cpp:104
Describes the statement/declaration an opcode was generated from.
Definition: Source.h:77
Interface for the VM to interact with the AST walker's context.
Definition: State.h:56
bool CheckLoad(InterpState &S, CodePtr OpPC, const Pointer &Ptr, AccessKinds AK)
Checks if a value can be loaded from a block.
Definition: Interp.cpp:536
The JSON file list parser is used to communicate input to InstallAPI.
@ AK_Read
Definition: State.h:27
const FunctionProtoType * T
Describes a memory block created by an allocation site.
Definition: Descriptor.h:111
Inline descriptor embedded in structures and arrays.
Definition: Descriptor.h:69
unsigned IsActive
Flag indicating if the field is the active member of a union.
Definition: Descriptor.h:91
unsigned IsBase
Flag indicating if the field is an embedded base class.
Definition: Descriptor.h:85
const Descriptor * Desc
Definition: Descriptor.h:99
unsigned Offset
Offset inside the structure/array.
Definition: Descriptor.h:71
unsigned IsInitialized
For primitive fields, it indicates if the field was initialized.
Definition: Descriptor.h:82
unsigned IsConst
Flag indicating if the storage is constant or not.
Definition: Descriptor.h:76
unsigned IsFieldMutable
Flag indicating if the field is mutable (if in a record).
Definition: Descriptor.h:97
Mapping from primitive types to their representation.
Definition: PrimType.h:75
Information about a local's storage.
Definition: Function.h:38
unsigned Offset
Offset of the local in frame.
Definition: Function.h:40