clang 24.0.0git
Compiler.h
Go to the documentation of this file.
1//===--- Compiler.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 "DeclOrExpr.h"
18#include "EvalEmitter.h"
19#include "Pointer.h"
20#include "PrimType.h"
21#include "Record.h"
22#include "clang/AST/Decl.h"
23#include "clang/AST/Expr.h"
25
26namespace clang {
27class QualType;
28
29namespace interp {
30
31template <class Emitter> class LocalScope;
32template <class Emitter> class VariableScope;
33template <class Emitter> class DeclScope;
34template <class Emitter> class InitLinkScope;
35template <class Emitter> class InitStackScope;
36template <class Emitter> class OptionScope;
37template <class Emitter> class ArrayIndexScope;
38template <class Emitter> class SourceLocScope;
39template <class Emitter> class LoopScope;
40template <class Emitter> class SwitchScope;
41template <class Emitter> class LocOverrideScope;
42
43template <class Emitter> class Compiler;
44struct InitLink {
45public:
46 enum {
47 K_This = 0,
49 K_Base = 2,
50 K_Temp = 3,
51 K_Decl = 4,
52 K_Elem = 6,
53 K_RVO = 7,
55 K_DIE = 9,
56 };
57
58 static InitLink This() { return InitLink{K_This}; }
59 static InitLink InitList() { return InitLink{K_InitList}; }
60 static InitLink RVO() { return InitLink{K_RVO}; }
61 static InitLink DIE() { return InitLink{K_DIE}; }
62 static InitLink Field(unsigned Offset) {
63 InitLink IL{K_Field};
64 IL.Offset = Offset;
65 return IL;
66 }
67 static InitLink Base(unsigned Offset) {
68 InitLink IL{K_Base};
69 IL.Offset = Offset;
70 return IL;
71 }
72 static InitLink Temp(unsigned Offset) {
73 InitLink IL{K_Temp};
74 IL.Offset = Offset;
75 return IL;
76 }
77 static InitLink Decl(const ValueDecl *D) {
78 InitLink IL{K_Decl};
79 IL.D = D;
80 return IL;
81 }
82 static InitLink Elem(unsigned Index) {
83 InitLink IL{K_Elem};
84 IL.Offset = Index;
85 return IL;
86 }
87
88 InitLink(uint8_t Kind) : Kind(Kind) {}
89 template <class Emitter>
90 bool emit(Compiler<Emitter> *Ctx, const Expr *E) const;
91
92 uint32_t Kind;
93 union {
94 unsigned Offset;
95 const ValueDecl *D;
96 };
97};
98
99/// State encapsulating if a the variable creation has been successful,
100/// unsuccessful, or no variable has been created at all.
102 std::optional<bool> S = std::nullopt;
103 VarCreationState() = default;
104 VarCreationState(bool b) : S(b) {}
106
107 operator bool() const { return S && *S; }
108 bool notCreated() const { return !S; }
109};
110
112
113/// Compilation context for expressions.
114template <class Emitter>
115class Compiler final : public ConstStmtVisitor<Compiler<Emitter>, bool>,
116 public Emitter {
117protected:
118 // Aliases for types defined in the emitter.
119 using LabelTy = typename Emitter::LabelTy;
120 using AddrTy = typename Emitter::AddrTy;
122 using CaseMap = llvm::DenseMap<const SwitchCase *, LabelTy>;
123
137
138 /// Current compilation context.
140 /// Program to link to.
142
143public:
144 /// Initializes the compiler and the backend emitter.
145 template <typename... Tys>
146 Compiler(Context &Ctx, Program &P, Tys &&...Args)
147 : Emitter(Ctx, P, Args...), Ctx(Ctx), P(P) {}
148
149 // Expressions.
150 bool VisitCastExpr(const CastExpr *E);
152 bool VisitIntegerLiteral(const IntegerLiteral *E);
156 bool VisitParenExpr(const ParenExpr *E);
157 bool VisitBinaryOperator(const BinaryOperator *E);
158 bool VisitLogicalBinOp(const BinaryOperator *E);
160 bool VisitComplexBinOp(const BinaryOperator *E);
161 bool VisitVectorBinOp(const BinaryOperator *E);
165 bool VisitCallExpr(const CallExpr *E);
166 bool VisitBuiltinCallExpr(const CallExpr *E, unsigned BuiltinID);
170 bool VisitGNUNullExpr(const GNUNullExpr *E);
171 bool VisitCXXThisExpr(const CXXThisExpr *E);
172 bool VisitUnaryOperator(const UnaryOperator *E);
175 bool VisitDeclRefExpr(const DeclRefExpr *E);
179 bool VisitInitListExpr(const InitListExpr *E);
181 bool VisitConstantExpr(const ConstantExpr *E);
183 bool VisitMemberExpr(const MemberExpr *E);
188 bool VisitStringLiteral(const StringLiteral *E);
190 bool VisitObjCEncodeExpr(const ObjCEncodeExpr *E);
200 bool VisitTypeTraitExpr(const TypeTraitExpr *E);
202 bool VisitLambdaExpr(const LambdaExpr *E);
203 bool VisitPredefinedExpr(const PredefinedExpr *E);
204 bool VisitCXXThrowExpr(const CXXThrowExpr *E);
209 bool VisitSourceLocExpr(const SourceLocExpr *E);
210 bool VisitOffsetOfExpr(const OffsetOfExpr *E);
212 bool VisitSizeOfPackExpr(const SizeOfPackExpr *E);
214 bool VisitChooseExpr(const ChooseExpr *E);
215 bool VisitEmbedExpr(const EmbedExpr *E);
219 bool VisitCXXUuidofExpr(const CXXUuidofExpr *E);
220 bool VisitRequiresExpr(const RequiresExpr *E);
225 bool VisitRecoveryExpr(const RecoveryExpr *E);
226 bool VisitAddrLabelExpr(const AddrLabelExpr *E);
230 bool VisitObjCBoxedExpr(const ObjCBoxedExpr *E);
232 bool VisitStmtExpr(const StmtExpr *E);
233 bool VisitCXXNewExpr(const CXXNewExpr *E);
234 bool VisitCXXDeleteExpr(const CXXDeleteExpr *E);
235 bool VisitBlockExpr(const BlockExpr *E);
236 bool VisitCXXTypeidExpr(const CXXTypeidExpr *E);
239 bool VisitCXXReflectExpr(const CXXReflectExpr *E);
241
242 // Statements.
243 bool visitCompoundStmt(const CompoundStmt *S);
244 bool visitDeclStmt(const DeclStmt *DS, bool EvaluateConditionDecl = false);
245 bool visitReturnStmt(const ReturnStmt *RS);
246 bool visitIfStmt(const IfStmt *IS);
247 bool visitWhileStmt(const WhileStmt *S);
248 bool visitDoStmt(const DoStmt *S);
249 bool visitForStmt(const ForStmt *S);
251 bool visitBreakStmt(const BreakStmt *S);
252 bool visitContinueStmt(const ContinueStmt *S);
253 bool visitSwitchStmt(const SwitchStmt *S);
254 bool visitCaseStmt(const CaseStmt *S);
255 bool visitDefaultStmt(const DefaultStmt *S);
256 bool visitAttributedStmt(const AttributedStmt *S);
257 bool visitCXXTryStmt(const CXXTryStmt *S);
258 bool
260
261 bool registerRedecl(const VarDecl *VD, const APValue &V);
262
263protected:
264 bool visitStmt(const Stmt *S);
265 bool visitExpr(const Expr *E, bool DestroyToplevelScope) override;
266 bool visitLValueExpr(const Expr *E, bool DestroyToplevelScope) override;
267 bool visitFunc(const FunctionDecl *F) override;
268
269 bool visitDeclAndReturn(const VarDecl *VD, const Expr *Init,
270 bool ConstantContext) override;
271 bool visitDtorCall(const VarDecl *VD, const APValue &Value) override;
272 bool visitWithSubstitutions(const FunctionDecl *Callee,
273 ArrayRef<const Expr *> Args, const Expr *This,
274 const Expr *Condition) override;
275
276protected:
277 /// Emits scope cleanup instructions.
278 bool emitCleanup();
279
280 /// Returns a record type from a record or pointer type.
281 const RecordType *getRecordTy(QualType Ty);
282
283 /// Returns a record from a record or pointer type.
285 Record *getRecord(const RecordDecl *RD);
286
287 /// Returns a function for the given FunctionDecl.
288 /// If the function does not exist yet, it is compiled.
289 const Function *getFunction(const FunctionDecl *FD);
290
291 OptPrimType classify(const Expr *E) const { return Ctx.classify(E); }
292 OptPrimType classify(QualType Ty) const { return Ctx.classify(Ty); }
293 bool canClassify(const Expr *E) const { return Ctx.canClassify(E); }
294 bool canClassify(QualType T) const { return Ctx.canClassify(T); }
295
296 /// Classifies a known primitive type.
298 if (auto T = classify(Ty)) {
299 return *T;
300 }
301 llvm_unreachable("not a primitive type");
302 }
303 /// Classifies a known primitive expression.
304 PrimType classifyPrim(const Expr *E) const {
305 if (auto T = classify(E))
306 return *T;
307 llvm_unreachable("not a primitive type");
308 }
309
310 /// Evaluates an expression and places the result on the stack. If the
311 /// expression is of composite type, a local variable will be created
312 /// and a pointer to said variable will be placed on the stack.
313 bool visit(const Expr *E) override;
314 /// Compiles an initializer. This is like visit() but it will never
315 /// create a variable and instead rely on a variable already having
316 /// been created. visitInitializer() then relies on a pointer to this
317 /// variable being on top of the stack.
318 bool visitInitializer(const Expr *E);
319 /// Similar, but will also pop the pointer.
320 bool visitInitializerPop(const Expr *E);
321 bool visitAsLValue(const Expr *E);
322 /// Evaluates an expression for side effects and discards the result.
323 bool discard(const Expr *E);
324 /// Just pass evaluation on to \p E. This leaves all the parsing flags
325 /// intact.
326 bool delegate(const Expr *E);
327 /// Creates and initializes a variable from the given decl.
329 bool Toplevel = false);
331 /// Visit an APValue.
332 bool visitAPValue(const APValue &Val, PrimType ValType, SourceInfo Info);
333 bool visitAPValueInitializer(const APValue &Val, SourceInfo Info, QualType T,
334 bool IsCompleteClass = true);
335 /// Visit the given decl as if we have a reference to it.
336 bool visitDeclRef(const ValueDecl *D, const Expr *E);
337
338 /// Visits an expression and converts it to a boolean.
339 bool visitBool(const Expr *E);
340
341 bool visitInitList(ArrayRef<const Expr *> Inits, const Expr *ArrayFiller,
342 const Expr *E);
343 bool visitArrayElemInit(unsigned ElemIndex, const Expr *Init,
344 OptPrimType InitT);
345 bool visitCallArgs(ArrayRef<const Expr *> Args, const FunctionDecl *FuncDecl,
346 bool Activate, bool IsOperatorCall);
347
348 /// Creates a local primitive value.
349 unsigned allocateLocalPrimitive(DeclOrExpr Decl, PrimType Ty, bool IsConst,
350 bool IsVolatile = false,
352
353 /// Allocates a space storing a local given its type.
357
358private:
359 friend class VariableScope<Emitter>;
360 friend class LocalScope<Emitter>;
361 friend class DeclScope<Emitter>;
362 friend class InitLinkScope<Emitter>;
363 friend class InitStackScope<Emitter>;
364 friend class OptionScope<Emitter>;
365 friend class ArrayIndexScope<Emitter>;
366 friend class SourceLocScope<Emitter>;
367 friend struct InitLink;
368 friend class LoopScope<Emitter>;
369 friend class SwitchScope<Emitter>;
370 friend class LocOverrideScope<Emitter>;
371
372 /// Emits a zero initializer.
373 bool visitZeroInitializer(PrimType T, QualType QT, const Expr *E);
374 bool visitZeroRecordInitializer(const Record *R, const Expr *E,
375 bool IsCompleteClass = true);
376 bool visitZeroArrayInitializer(QualType T, const Expr *E);
377 bool visitAssignment(const Expr *LHS, const Expr *RHS, const Expr *E);
378
379 /// Emits an APSInt constant.
380 bool emitConst(const llvm::APSInt &Value, PrimType Ty, SourceInfo Info);
381 bool emitConst(const llvm::APInt &Value, PrimType Ty, SourceInfo Info);
382 bool emitConst(const llvm::APSInt &Value, const Expr *E);
383 bool emitConst(const llvm::APInt &Value, const Expr *E) {
384 return emitConst(Value, classifyPrim(E), E);
385 }
386
387 /// Emits an integer constant.
388 template <typename T> bool emitConst(T Value, PrimType Ty, SourceInfo Info);
389 template <typename T> bool emitConst(T Value, const Expr *E);
390 bool emitBool(bool V, const Expr *E) override {
391 return this->emitConst(V, E);
392 }
393
394 llvm::RoundingMode getRoundingMode(const Expr *E) const {
396
397 if (FPO.getRoundingMode() == llvm::RoundingMode::Dynamic)
398 return llvm::RoundingMode::NearestTiesToEven;
399
400 return FPO.getRoundingMode();
401 }
402
403 uint32_t getFPOptions(const Expr *E) const {
405 }
406
407 bool emitPrimCast(PrimType FromT, PrimType ToT, QualType ToQT, const Expr *E);
408 bool emitIntegralCast(PrimType FromT, PrimType ToT, QualType ToQT,
409 const Expr *E);
410 PrimType classifyComplexElementType(QualType T) const {
411 assert(T->isAnyComplexType());
412
413 QualType ElemType = T->getAs<ComplexType>()->getElementType();
414
415 return *this->classify(ElemType);
416 }
417
418 PrimType classifyVectorElementType(QualType T) const {
419 assert(T->isVectorType());
420 return *this->classify(T->getAs<VectorType>()->getElementType());
421 }
422
423 PrimType classifyMatrixElementType(QualType T) const {
424 assert(T->isMatrixType());
425 return *this->classify(T->getAs<MatrixType>()->getElementType());
426 }
427
428 bool emitComplexReal(const Expr *SubExpr);
429 bool emitComplexBoolCast(const Expr *E);
430 bool emitComplexComparison(const Expr *LHS, const Expr *RHS,
431 const BinaryOperator *E);
432 bool emitRecordDestructionPop(const Record *R, SourceInfo Loc);
433 bool emitDestructionPop(const Descriptor *Desc, SourceInfo Loc);
434 bool emitDummyPtr(DeclOrExpr D, const Expr *E, bool CU = false);
435 bool emitFloat(const APFloat &F, SourceInfo Info);
436 unsigned collectBaseOffset(const QualType BaseType,
437 const QualType DerivedType);
438 bool emitLambdaStaticInvokerBody(const CXXMethodDecl *MD);
439 bool emitBuiltinBitCast(const CastExpr *E);
440
441 bool emitHLSLAggregateSplat(PrimType SrcT, unsigned SrcOffset,
442 QualType DestType, const Expr *E);
443 bool emitVectorConversion(const Expr *Src, const Expr *E);
444
445 /// A scalar element extracted during HLSL aggregate flattening.
446 struct HLSLFlatElement {
447 unsigned LocalOffset;
448 PrimType Type;
449 };
450 unsigned countHLSLFlatElements(QualType Ty);
451 bool emitHLSLFlattenAggregate(QualType SrcType, unsigned SrcPtrOffset,
452 SmallVectorImpl<HLSLFlatElement> &Elements,
453 unsigned MaxElements, const Expr *E);
454 bool emitHLSLConstructAggregate(QualType DestType,
455 ArrayRef<HLSLFlatElement> Elements,
456 unsigned &ElemIdx, const Expr *E);
457 bool emitHLSLConstructAggregate(QualType DestType,
458 ArrayRef<HLSLFlatElement> Elements,
459 const Expr *E) {
460 unsigned ElemIdx = 0;
461 return emitHLSLConstructAggregate(DestType, Elements, ElemIdx, E);
462 }
463
464 bool compileConstructor(const CXXConstructorDecl *Ctor);
465 bool compileDestructor(const CXXDestructorDecl *Dtor);
466 bool compileUnionAssignmentOperator(const CXXMethodDecl *MD);
467
468 bool checkLiteralType(const Expr *E);
469 bool maybeEmitDeferredVarInit(const VarDecl *VD);
470
471 bool refersToUnion(const Expr *E);
472
473protected:
474 /// Variable to storage mapping.
475 llvm::DenseMap<const ValueDecl *, Scope::Local> Locals;
476
477 /// OpaqueValueExpr to location mapping.
478 llvm::DenseMap<const OpaqueValueExpr *, unsigned> OpaqueExprs;
479
480 /// Current scope.
482
483 /// Current argument index. Needed to emit ArrayInitIndexExpr.
484 std::optional<uint64_t> ArrayIndex;
485
486 /// DefaultInit- or DefaultArgExpr, needed for SourceLocExpr.
487 const Expr *SourceLocDefaultExpr = nullptr;
488
489 /// Flag indicating if return value is to be discarded.
490 bool DiscardResult = false;
491
492 bool SwitchInStmtExpr = false;
493 bool InStmtExpr = false;
494 bool ToLValue = false;
495
497
498 /// Flag inidicating if we're initializing an already created
499 /// variable. This is set in visitInitializer().
500 bool Initializing = false;
501 const VarDecl *InitializingDecl = nullptr;
502
504 bool InitStackActive = false;
505
506 /// Type of the expression returned by the function.
508
509 /// Switch case mapping.
511 /// Stack of label information for loops and switch statements.
513
515};
516
517extern template class Compiler<ByteCodeEmitter>;
518extern template class Compiler<EvalEmitter>;
519
520} // namespace interp
521} // namespace clang
522
523#endif
#define V(N, I)
llvm::MachO::Record Record
Definition MachO.h:31
APValue - This class implements a discriminated union of [uninitialized] [APSInt] [APFloat],...
Definition APValue.h:158
AbstractConditionalOperator - An abstract base class for ConditionalOperator and BinaryConditionalOpe...
Definition Expr.h:4422
AddrLabelExpr - The GNU address of label extension, representing &&label.
Definition Expr.h:4619
Represents the index of the current element of an array being initialized by an ArrayInitLoopExpr.
Definition Expr.h:6107
Represents a loop initializing the elements of an array.
Definition Expr.h:6054
ArraySubscriptExpr - [C99 6.5.2.1] Array Subscripting.
Definition Expr.h:2790
An Embarcadero array type trait, as used in the implementation of __array_rank and __array_extent.
Definition ExprCXX.h:3011
Represents an attribute applied to a statement.
Definition Stmt.h:2214
A builtin binary operation expression such as "x + y" or "x <= y".
Definition Expr.h:4107
BlockExpr - Adaptor class for mixing a BlockDecl with expressions.
Definition Expr.h:6758
BreakStmt - This represents a break.
Definition Stmt.h:3148
Represents a C++2a __builtin_bit_cast(T, v) expression.
Definition ExprCXX.h:5530
Represents binding an expression to a temporary.
Definition ExprCXX.h:1498
A boolean literal, per ([C++ lex.bool] Boolean literals).
Definition ExprCXX.h:728
Represents a call to a C++ constructor.
Definition ExprCXX.h:1553
A default argument (C++ [dcl.fct.default]).
Definition ExprCXX.h:1275
A use of a default initializer in a constructor or in aggregate initialization.
Definition ExprCXX.h:1382
Represents a delete expression for memory deallocation and destructor calls, e.g.
Definition ExprCXX.h:2631
A C++ dynamic_cast expression (C++ [expr.dynamic.cast]).
Definition ExprCXX.h:486
Represents the code generated for an expanded expansion statement.
Definition StmtCXX.h:1028
CXXForRangeStmt - This represents C++0x [stmt.ranged]'s ranged for statement, represented as 'for (ra...
Definition StmtCXX.h:136
Represents a call to an inherited base class constructor from an inheriting constructor.
Definition ExprCXX.h:1756
Represents a new-expression for memory allocation and constructor calls, e.g: "new CXXNewExpr(foo)".
Definition ExprCXX.h:2360
Represents a C++11 noexcept expression (C++ [expr.unary.noexcept]).
Definition ExprCXX.h:4363
The null pointer literal (C++11 [lex.nullptr])
Definition ExprCXX.h:773
Represents a list-initialization with parenthesis.
Definition ExprCXX.h:5195
Represents a C++26 reflect expression [expr.reflect].
Definition ExprCXX.h:5562
A C++ reinterpret_cast expression (C++ [expr.reinterpret.cast]).
Definition ExprCXX.h:531
A rewritten comparison expression that was originally written using operator syntax.
Definition ExprCXX.h:291
An expression "T()" which creates an rvalue of a non-class type T.
Definition ExprCXX.h:2201
Implicit construction of a std::initializer_list<T> object from an array temporary within list-initia...
Definition ExprCXX.h:805
Represents the this expression in C++.
Definition ExprCXX.h:1159
A C++ throw-expression (C++ [except.throw]).
Definition ExprCXX.h:1213
CXXTryStmt - A C++ try block, including all handlers.
Definition StmtCXX.h:70
A C++ typeid expression (C++ [expr.typeid]), which gets the type_info that corresponds to the supplie...
Definition ExprCXX.h:853
A Microsoft C++ __uuidof expression, which gets the _GUID that corresponds to the supplied type or ex...
Definition ExprCXX.h:1073
CallExpr - Represents a function call (C99 6.5.2.2, C++ [expr.call]).
Definition Expr.h:3012
CaseStmt - Represent a case statement.
Definition Stmt.h:1931
CastExpr - Base class for type casts, including both implicit casts (ImplicitCastExpr) and explicit c...
Definition Expr.h:3745
ChooseExpr - GNU builtin-in function __builtin_choose_expr.
Definition Expr.h:4917
CompoundAssignOperator - For compound assignments (e.g.
Definition Expr.h:4369
CompoundLiteralExpr - [C99 6.5.2.5].
Definition Expr.h:3674
CompoundStmt - This represents a group of statements like { stmt stmt }.
Definition Stmt.h:1751
Represents the specialization of a concept - evaluates to a prvalue of type bool.
ConstStmtVisitor - This class implements a simple visitor for Stmt subclasses.
An expression that occurs in a constant context and the result of evaluating the expression.
Definition Expr.h:1127
ContinueStmt - This represents a continue.
Definition Stmt.h:3132
ConvertVectorExpr - Clang builtin function __builtin_convertvector This AST node provides support for...
Definition Expr.h:4788
A reference to a declared variable, function, enum, etc.
Definition Expr.h:1315
DeclStmt - Adaptor class for mixing declarations with statements and expressions.
Definition Stmt.h:1642
Decl - This represents one declaration (or definition), e.g.
Definition DeclBase.h:86
DoStmt - This represents a 'do/while' stmt.
Definition Stmt.h:2843
Represents a reference to emded data.
Definition Expr.h:5204
Represents an expression – generally a full-expression – that introduces cleanups to be run at the en...
Definition ExprCXX.h:3715
This represents one expression.
Definition Expr.h:114
FPOptions getFPFeaturesInEffect(const LangOptions &LO) const
Returns the set of floating point options that apply to this expression.
Definition Expr.cpp:4031
An expression trait intrinsic.
Definition ExprCXX.h:3084
ExtVectorElementExpr - This represents access to specific elements of a vector, and may occur on the ...
Definition Expr.h:6696
storage_type getAsOpaqueInt() const
RoundingMode getRoundingMode() const
ForStmt - This represents a 'for (init;cond;inc)' stmt.
Definition Stmt.h:2899
Represents a function declaration or definition.
Definition Decl.h:2082
GNUNullExpr - Implements the GNU __null extension, which is a name for a null pointer constant that h...
Definition Expr.h:4992
Represents a C11 generic selection.
Definition Expr.h:6268
IfStmt - This represents an if/then/else.
Definition Stmt.h:2270
ImaginaryLiteral - We support imaginary integer and floating point literals, like "1....
Definition Expr.h:1776
Represents an implicitly-generated value initialization of an object of a given type.
Definition Expr.h:6143
Describes an C or C++ initializer list.
Definition Expr.h:5377
A C++ lambda expression, which produces a function object (of unspecified type) that can be invoked l...
Definition ExprCXX.h:1973
Represents a prvalue temporary that is written into memory so that a reference can bind to it.
Definition ExprCXX.h:4974
MemberExpr - [C99 6.5.2.3] Structure and Union Members.
Definition Expr.h:3433
ObjCArrayLiteral - used for objective-c array containers; as in: @["Hello", NSApp,...
Definition ExprObjC.h:219
ObjCBoolLiteralExpr - Objective-C Boolean Literal.
Definition ExprObjC.h:118
ObjCBoxedExpr - used for generalized expression boxing.
Definition ExprObjC.h:158
ObjCDictionaryLiteral - AST node to represent objective-c dictionary literals; as in:"name" : NSUserN...
Definition ExprObjC.h:341
ObjCEncodeExpr, used for @encode in Objective-C.
Definition ExprObjC.h:440
ObjCStringLiteral, used for Objective-C string literals i.e.
Definition ExprObjC.h:83
OffsetOfExpr - [C99 7.17] - This represents an expression of the form offsetof(record-type,...
Definition Expr.h:2596
OpaqueValueExpr - An expression referring to an opaque object of a fixed type and value class.
Definition Expr.h:1223
ParenExpr - This represents a parenthesized expression, e.g.
Definition Expr.h:2251
[C99 6.4.2.2] - A predefined identifier such as func.
Definition Expr.h:2074
PseudoObjectExpr - An expression which accesses a pseudo-object l-value.
Definition Expr.h:6890
A (possibly-)qualified type.
Definition TypeBase.h:938
Represents a struct/union/class.
Definition Decl.h:4508
Frontend produces RecoveryExprs on semantic errors that prevent creating other well-formed expression...
Definition Expr.h:7589
C++2a [expr.prim.req]: A requires-expression provides a concise way to express requirements on templa...
ReturnStmt - This represents a return, optionally of an expression: return; return 4;.
Definition Stmt.h:3173
ShuffleVectorExpr - clang-specific builtin-in function __builtin_shufflevector.
Definition Expr.h:4712
Represents an expression that computes the length of a parameter pack.
Definition ExprCXX.h:4495
Represents a function call to one of __builtin_LINE(), __builtin_COLUMN(), __builtin_FUNCTION(),...
Definition Expr.h:5095
StmtExpr - This is the GNU Statement Expression extension: ({int X=4; X;}).
Definition Expr.h:4664
Stmt - This represents one statement.
Definition Stmt.h:85
StringLiteral - This represents a string literal expression, e.g.
Definition Expr.h:1844
Represents a reference to a non-type template parameter that has been substituted with a template arg...
Definition ExprCXX.h:4718
SwitchStmt - This represents a 'switch' stmt.
Definition Stmt.h:2520
A type trait used in the implementation of various C++11 and Library TR1 trait templates.
Definition ExprCXX.h:2901
bool isAnyComplexType() const
Definition TypeBase.h:8950
bool isMatrixType() const
Definition TypeBase.h:8978
bool isVectorType() const
Definition TypeBase.h:8954
const T * getAs() const
Member-template getAs<specific type>'.
Definition TypeBase.h:9431
UnaryExprOrTypeTraitExpr - expression with either a type or (unevaluated) expression operand.
Definition Expr.h:2694
UnaryOperator - This represents the unary-expression's (except sizeof and alignof),...
Definition Expr.h:2313
Represent the declaration of a variable (in which case it is an lvalue) a function (in which case it ...
Definition Decl.h:714
Represents a variable declaration or definition.
Definition Decl.h:934
WhileStmt - This represents a 'while' stmt.
Definition Stmt.h:2708
A memory block, either on the stack or in the heap.
Definition Block.h:68
Compilation context for expressions.
Definition Compiler.h:116
llvm::SmallVector< InitLink > InitStack
Definition Compiler.h:503
bool VisitArrayInitIndexExpr(const ArrayInitIndexExpr *E)
bool VisitCXXDeleteExpr(const CXXDeleteExpr *E)
bool VisitOffsetOfExpr(const OffsetOfExpr *E)
bool visitContinueStmt(const ContinueStmt *S)
bool VisitCharacterLiteral(const CharacterLiteral *E)
PrimType classifyPrim(const Expr *E) const
Classifies a known primitive expression.
Definition Compiler.h:304
bool visitArrayElemInit(unsigned ElemIndex, const Expr *Init, OptPrimType InitT)
Pointer to the array(not the element!) must be on the stack when calling this.
bool VisitCXXParenListInitExpr(const CXXParenListInitExpr *E)
bool VisitConceptSpecializationExpr(const ConceptSpecializationExpr *E)
bool visitInitializerPop(const Expr *E)
Similar, but will also pop the pointer.
bool VisitCompoundLiteralExpr(const CompoundLiteralExpr *E)
bool visitBool(const Expr *E)
Visits an expression and converts it to a boolean.
bool VisitCXXDefaultInitExpr(const CXXDefaultInitExpr *E)
PrimType classifyPrim(QualType Ty) const
Classifies a known primitive type.
Definition Compiler.h:297
bool VisitTypeTraitExpr(const TypeTraitExpr *E)
bool VisitLambdaExpr(const LambdaExpr *E)
bool VisitMemberExpr(const MemberExpr *E)
llvm::DenseMap< const OpaqueValueExpr *, unsigned > OpaqueExprs
OpaqueValueExpr to location mapping.
Definition Compiler.h:478
bool VisitBinaryOperator(const BinaryOperator *E)
bool visitCXXExpansionStmtInstantiation(const CXXExpansionStmtInstantiation *S)
template for (auto x : {1, 2}) {}
bool visitAttributedStmt(const AttributedStmt *S)
bool VisitPackIndexingExpr(const PackIndexingExpr *E)
bool VisitArraySubscriptExpr(const ArraySubscriptExpr *E)
bool VisitCallExpr(const CallExpr *E)
std::optional< uint64_t > ArrayIndex
Current argument index. Needed to emit ArrayInitIndexExpr.
Definition Compiler.h:484
bool VisitPseudoObjectExpr(const PseudoObjectExpr *E)
bool VisitCXXReinterpretCastExpr(const CXXReinterpretCastExpr *E)
bool visitAPValueInitializer(const APValue &Val, SourceInfo Info, QualType T, bool IsCompleteClass=true)
const Function * getFunction(const FunctionDecl *FD)
Returns a function for the given FunctionDecl.
bool VisitFixedPointBinOp(const BinaryOperator *E)
bool VisitCastExpr(const CastExpr *E)
Definition Compiler.cpp:447
bool VisitObjCEncodeExpr(const ObjCEncodeExpr *E)
bool VisitFixedPointUnaryOperator(const UnaryOperator *E)
bool VisitComplexUnaryOperator(const UnaryOperator *E)
llvm::DenseMap< const SwitchCase *, LabelTy > CaseMap
Definition Compiler.h:122
bool VisitBlockExpr(const BlockExpr *E)
friend struct InitLink
Definition Compiler.h:367
bool VisitCXXScalarValueInitExpr(const CXXScalarValueInitExpr *E)
bool VisitLogicalBinOp(const BinaryOperator *E)
bool visitCompoundStmt(const CompoundStmt *S)
Context & Ctx
Current compilation context.
Definition Compiler.h:139
const VarDecl * InitializingDecl
Definition Compiler.h:501
bool visitDeclRef(const ValueDecl *D, const Expr *E)
Visit the given decl as if we have a reference to it.
bool visitBreakStmt(const BreakStmt *S)
bool visitExpr(const Expr *E, bool DestroyToplevelScope) override
bool visitForStmt(const ForStmt *S)
bool VisitDeclRefExpr(const DeclRefExpr *E)
bool VisitOpaqueValueExpr(const OpaqueValueExpr *E)
bool VisitArrayInitLoopExpr(const ArrayInitLoopExpr *E)
bool visitAPValue(const APValue &Val, PrimType ValType, SourceInfo Info)
Visit an APValue.
bool VisitStmtExpr(const StmtExpr *E)
bool VisitBuiltinBitCastExpr(const BuiltinBitCastExpr *E)
bool VisitFixedPointLiteral(const FixedPointLiteral *E)
const FunctionDecl * CompilingFunction
Definition Compiler.h:514
bool VisitCXXBoolLiteralExpr(const CXXBoolLiteralExpr *E)
VarCreationState visitVarDecl(const VarDecl *VD, const Expr *Init, bool Toplevel=false)
Creates and initializes a variable from the given decl.
VariableScope< Emitter > * VarScope
Current scope.
Definition Compiler.h:481
bool visitDeclAndReturn(const VarDecl *VD, const Expr *Init, bool ConstantContext) override
Toplevel visitDeclAndReturn().
bool VisitCXXNewExpr(const CXXNewExpr *E)
bool VisitCompoundAssignOperator(const CompoundAssignOperator *E)
bool visit(const Expr *E) override
Evaluates an expression and places the result on the stack.
bool delegate(const Expr *E)
Just pass evaluation on to E.
bool visitLValueExpr(const Expr *E, bool DestroyToplevelScope) override
bool discard(const Expr *E)
Evaluates an expression for side effects and discards the result.
bool VisitCXXDefaultArgExpr(const CXXDefaultArgExpr *E)
CaseMap CaseLabels
Switch case mapping.
Definition Compiler.h:510
Record * getRecord(QualType Ty)
Returns a record from a record or pointer type.
bool VisitCXXReflectExpr(const CXXReflectExpr *E)
const RecordType * getRecordTy(QualType Ty)
Returns a record type from a record or pointer type.
bool VisitCXXStdInitializerListExpr(const CXXStdInitializerListExpr *E)
bool visitInitList(ArrayRef< const Expr * > Inits, const Expr *ArrayFiller, const Expr *E)
bool VisitSizeOfPackExpr(const SizeOfPackExpr *E)
bool VisitPredefinedExpr(const PredefinedExpr *E)
bool VisitSourceLocExpr(const SourceLocExpr *E)
Compiler(Context &Ctx, Program &P, Tys &&...Args)
Initializes the compiler and the backend emitter.
Definition Compiler.h:146
bool visitDeclStmt(const DeclStmt *DS, bool EvaluateConditionDecl=false)
bool registerRedecl(const VarDecl *VD, const APValue &V)
bool emitCleanup()
Emits scope cleanup instructions.
bool VisitExtVectorElementExpr(const ExtVectorElementExpr *E)
bool VisitObjCStringLiteral(const ObjCStringLiteral *E)
bool VisitArrayTypeTraitExpr(const ArrayTypeTraitExpr *E)
bool visitInitializer(const Expr *E)
Compiles an initializer.
bool visitDtorCall(const VarDecl *VD, const APValue &Value) override
const Expr * SourceLocDefaultExpr
DefaultInit- or DefaultArgExpr, needed for SourceLocExpr.
Definition Compiler.h:487
bool VisitObjCArrayLiteral(const ObjCArrayLiteral *E)
UnsignedOrNone OptLabelTy
Definition Compiler.h:121
bool VisitCXXBindTemporaryExpr(const CXXBindTemporaryExpr *E)
bool VisitPointerArithBinOp(const BinaryOperator *E)
Perform addition/subtraction of a pointer and an integer or subtraction of two pointers.
bool visitCallArgs(ArrayRef< const Expr * > Args, const FunctionDecl *FuncDecl, bool Activate, bool IsOperatorCall)
bool VisitObjCBoolLiteralExpr(const ObjCBoolLiteralExpr *E)
bool visitDefaultStmt(const DefaultStmt *S)
bool VisitObjCDictionaryLiteral(const ObjCDictionaryLiteral *E)
bool visitWithSubstitutions(const FunctionDecl *Callee, ArrayRef< const Expr * > Args, const Expr *This, const Expr *Condition) override
Evaluate the Condition as if it was in the body of Callee.
typename Emitter::LabelTy LabelTy
Definition Compiler.h:119
VarCreationState visitDecl(const VarDecl *VD)
bool VisitCXXDynamicCastExpr(const CXXDynamicCastExpr *E)
bool visitStmt(const Stmt *S)
bool VisitExpressionTraitExpr(const ExpressionTraitExpr *E)
bool VisitVectorUnaryOperator(const UnaryOperator *E)
bool VisitCXXConstructExpr(const CXXConstructExpr *E)
bool VisitCXXNullPtrLiteralExpr(const CXXNullPtrLiteralExpr *E)
bool VisitObjCBoxedExpr(const ObjCBoxedExpr *E)
bool VisitDesignatedInitUpdateExpr(const DesignatedInitUpdateExpr *E)
bool VisitCXXInheritedCtorInitExpr(const CXXInheritedCtorInitExpr *E)
bool VisitRecoveryExpr(const RecoveryExpr *E)
bool VisitRequiresExpr(const RequiresExpr *E)
bool Initializing
Flag inidicating if we're initializing an already created variable.
Definition Compiler.h:500
bool visitReturnStmt(const ReturnStmt *RS)
bool VisitCXXThrowExpr(const CXXThrowExpr *E)
bool VisitSubstNonTypeTemplateParmExpr(const SubstNonTypeTemplateParmExpr *E)
bool VisitChooseExpr(const ChooseExpr *E)
bool visitFunc(const FunctionDecl *F) override
bool visitCXXForRangeStmt(const CXXForRangeStmt *S)
bool visitCaseStmt(const CaseStmt *S)
bool VisitComplexBinOp(const BinaryOperator *E)
llvm::DenseMap< const ValueDecl *, Scope::Local > Locals
Variable to storage mapping.
Definition Compiler.h:475
bool VisitAbstractConditionalOperator(const AbstractConditionalOperator *E)
bool VisitCXXTypeidExpr(const CXXTypeidExpr *E)
UnsignedOrNone allocateTemporary(const Expr *E)
bool VisitBuiltinCallExpr(const CallExpr *E, unsigned BuiltinID)
bool VisitImplicitValueInitExpr(const ImplicitValueInitExpr *E)
typename Emitter::AddrTy AddrTy
Definition Compiler.h:120
bool VisitCXXRewrittenBinaryOperator(const CXXRewrittenBinaryOperator *E)
OptPrimType classify(QualType Ty) const
Definition Compiler.h:292
OptPrimType ReturnType
Type of the expression returned by the function.
Definition Compiler.h:507
bool VisitUnaryOperator(const UnaryOperator *E)
bool VisitFloatCompoundAssignOperator(const CompoundAssignOperator *E)
OptPrimType classify(const Expr *E) const
Definition Compiler.h:291
llvm::SmallVector< LabelInfo > LabelInfoStack
Stack of label information for loops and switch statements.
Definition Compiler.h:512
bool VisitGenericSelectionExpr(const GenericSelectionExpr *E)
bool visitDoStmt(const DoStmt *S)
bool VisitIntegerLiteral(const IntegerLiteral *E)
bool VisitInitListExpr(const InitListExpr *E)
bool VisitVectorBinOp(const BinaryOperator *E)
bool VisitStringLiteral(const StringLiteral *E)
bool VisitParenExpr(const ParenExpr *E)
bool VisitCXXNoexceptExpr(const CXXNoexceptExpr *E)
bool VisitShuffleVectorExpr(const ShuffleVectorExpr *E)
bool VisitPointerCompoundAssignOperator(const CompoundAssignOperator *E)
bool DiscardResult
Flag indicating if return value is to be discarded.
Definition Compiler.h:490
bool VisitEmbedExpr(const EmbedExpr *E)
UnsignedOrNone allocateLocal(DeclOrExpr Decl, QualType Ty=QualType(), ScopeKind=ScopeKind::Block)
Allocates a space storing a local given its type.
bool VisitConvertVectorExpr(const ConvertVectorExpr *E)
bool VisitCXXThisExpr(const CXXThisExpr *E)
bool VisitConstantExpr(const ConstantExpr *E)
bool VisitUnaryExprOrTypeTraitExpr(const UnaryExprOrTypeTraitExpr *E)
bool visitSwitchStmt(const SwitchStmt *S)
bool canClassify(QualType T) const
Definition Compiler.h:294
bool VisitCXXUuidofExpr(const CXXUuidofExpr *E)
bool VisitExprWithCleanups(const ExprWithCleanups *E)
bool visitAsLValue(const Expr *E)
unsigned allocateLocalPrimitive(DeclOrExpr Decl, PrimType Ty, bool IsConst, bool IsVolatile=false, ScopeKind SC=ScopeKind::Block)
Creates a local primitive value.
bool visitWhileStmt(const WhileStmt *S)
bool visitIfStmt(const IfStmt *IS)
bool VisitAddrLabelExpr(const AddrLabelExpr *E)
bool canClassify(const Expr *E) const
Definition Compiler.h:293
bool VisitFloatingLiteral(const FloatingLiteral *E)
Program & P
Program to link to.
Definition Compiler.h:141
bool VisitMaterializeTemporaryExpr(const MaterializeTemporaryExpr *E)
bool VisitGNUNullExpr(const GNUNullExpr *E)
bool VisitImaginaryLiteral(const ImaginaryLiteral *E)
bool VisitSYCLUniqueStableNameExpr(const SYCLUniqueStableNameExpr *E)
bool visitCXXTryStmt(const CXXTryStmt *S)
Holds all information required to evaluate constexpr code in a module.
Definition Context.h:49
const LangOptions & getLangOpts() const
Returns the language options.
Definition Context.cpp:490
Scope used to handle temporaries in toplevel variable declarations.
Definition Compiler.cpp:285
Bytecode function.
Definition Function.h:98
When generating code for e.g.
Definition Compiler.cpp:422
Generic scope for local variables.
Definition Compiler.cpp:121
Sets the context for break/continue statements.
Definition Compiler.cpp:361
Scope used to handle initialization methods.
Definition Compiler.cpp:305
The program contains and links the bytecode for all functions.
Definition Program.h:38
Structure/Class descriptor.
Definition Record.h:27
Describes the statement/declaration an opcode was generated from.
Definition Source.h:77
Scope chain managing the variable lifetimes.
Definition Compiler.cpp:64
bool Call(InterpState &S, CodePtr OpPC, const Function *Func, uint32_t VarArgSize)
Definition Interp.cpp:2131
bool This(InterpState &S, CodePtr OpPC)
Definition Interp.h:3183
llvm::APFloat APFloat
Definition Floating.h:27
PrimType
Enumeration of the primitive types of the VM.
Definition PrimType.h:35
static bool Activate(InterpState &S)
Definition Interp.h:2276
bool Init(InterpState &S, CodePtr OpPC)
Definition Interp.h:2381
Top level wrappers for InstallAPI frontend operations.
OptionalUnsigned< unsigned > UnsignedOrNone
const FunctionProtoType * T
const VariableScope< Emitter > * BreakOrContinueScope
Definition Compiler.h:126
LabelInfo(const Stmt *Name, OptLabelTy BreakLabel, OptLabelTy ContinueLabel, OptLabelTy DefaultLabel, const VariableScope< Emitter > *BreakOrContinueScope)
Definition Compiler.h:130
State encapsulating if a the variable creation has been successful, unsuccessful, or no variable has ...
Definition Compiler.h:101
static VarCreationState NotCreated()
Definition Compiler.h:105
std::optional< bool > S
Definition Compiler.h:102