Thanks to visit codestin.com
Credit goes to clang.llvm.org

clang 22.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 "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"
24
25namespace clang {
26class QualType;
27
28namespace interp {
29
30template <class Emitter> class LocalScope;
31template <class Emitter> class DestructorScope;
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 LabelScope;
41template <class Emitter> class SwitchScope;
42template <class Emitter> class StmtExprScope;
43template <class Emitter> class LocOverrideScope;
44
45template <class Emitter> class Compiler;
46struct InitLink {
47public:
48 enum {
49 K_This = 0,
51 K_Temp = 2,
52 K_Decl = 3,
53 K_Elem = 5,
54 K_RVO = 6,
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 Field(unsigned Offset) {
62 InitLink IL{K_Field};
63 IL.Offset = Offset;
64 return IL;
65 }
66 static InitLink Temp(unsigned Offset) {
67 InitLink IL{K_Temp};
68 IL.Offset = Offset;
69 return IL;
70 }
71 static InitLink Decl(const ValueDecl *D) {
72 InitLink IL{K_Decl};
73 IL.D = D;
74 return IL;
75 }
76 static InitLink Elem(unsigned Index) {
77 InitLink IL{K_Elem};
78 IL.Offset = Index;
79 return IL;
80 }
81
82 InitLink(uint8_t Kind) : Kind(Kind) {}
83 template <class Emitter>
84 bool emit(Compiler<Emitter> *Ctx, const Expr *E) const;
85
86 uint32_t Kind;
87 union {
88 unsigned Offset;
89 const ValueDecl *D;
90 };
91};
92
93/// State encapsulating if a the variable creation has been successful,
94/// unsuccessful, or no variable has been created at all.
96 std::optional<bool> S = std::nullopt;
97 VarCreationState() = default;
98 VarCreationState(bool b) : S(b) {}
100
101 operator bool() const { return S && *S; }
102 bool notCreated() const { return !S; }
103};
104
105enum class ScopeKind { Call, Block };
106
107/// Compilation context for expressions.
108template <class Emitter>
109class Compiler : public ConstStmtVisitor<Compiler<Emitter>, bool>,
110 public Emitter {
111protected:
112 // Aliases for types defined in the emitter.
113 using LabelTy = typename Emitter::LabelTy;
114 using AddrTy = typename Emitter::AddrTy;
116 using CaseMap = llvm::DenseMap<const SwitchCase *, LabelTy>;
117
131
132 /// Current compilation context.
134 /// Program to link to.
136
137public:
138 /// Initializes the compiler and the backend emitter.
139 template <typename... Tys>
140 Compiler(Context &Ctx, Program &P, Tys &&...Args)
141 : Emitter(Ctx, P, Args...), Ctx(Ctx), P(P) {}
142
143 // Expressions.
144 bool VisitCastExpr(const CastExpr *E);
146 bool VisitIntegerLiteral(const IntegerLiteral *E);
150 bool VisitParenExpr(const ParenExpr *E);
151 bool VisitBinaryOperator(const BinaryOperator *E);
152 bool VisitLogicalBinOp(const BinaryOperator *E);
154 bool VisitComplexBinOp(const BinaryOperator *E);
155 bool VisitVectorBinOp(const BinaryOperator *E);
159 bool VisitCallExpr(const CallExpr *E);
160 bool VisitBuiltinCallExpr(const CallExpr *E, unsigned BuiltinID);
164 bool VisitGNUNullExpr(const GNUNullExpr *E);
165 bool VisitCXXThisExpr(const CXXThisExpr *E);
166 bool VisitUnaryOperator(const UnaryOperator *E);
169 bool VisitDeclRefExpr(const DeclRefExpr *E);
173 bool VisitInitListExpr(const InitListExpr *E);
175 bool VisitConstantExpr(const ConstantExpr *E);
177 bool VisitMemberExpr(const MemberExpr *E);
182 bool VisitStringLiteral(const StringLiteral *E);
184 bool VisitObjCEncodeExpr(const ObjCEncodeExpr *E);
194 bool VisitTypeTraitExpr(const TypeTraitExpr *E);
196 bool VisitLambdaExpr(const LambdaExpr *E);
197 bool VisitPredefinedExpr(const PredefinedExpr *E);
198 bool VisitCXXThrowExpr(const CXXThrowExpr *E);
203 bool VisitSourceLocExpr(const SourceLocExpr *E);
204 bool VisitOffsetOfExpr(const OffsetOfExpr *E);
206 bool VisitSizeOfPackExpr(const SizeOfPackExpr *E);
208 bool VisitChooseExpr(const ChooseExpr *E);
209 bool VisitEmbedExpr(const EmbedExpr *E);
213 bool VisitCXXUuidofExpr(const CXXUuidofExpr *E);
214 bool VisitRequiresExpr(const RequiresExpr *E);
219 bool VisitRecoveryExpr(const RecoveryExpr *E);
220 bool VisitAddrLabelExpr(const AddrLabelExpr *E);
224 bool VisitObjCBoxedExpr(const ObjCBoxedExpr *E);
226 bool VisitStmtExpr(const StmtExpr *E);
227 bool VisitCXXNewExpr(const CXXNewExpr *E);
228 bool VisitCXXDeleteExpr(const CXXDeleteExpr *E);
229 bool VisitBlockExpr(const BlockExpr *E);
230 bool VisitCXXTypeidExpr(const CXXTypeidExpr *E);
231
232 // Statements.
233 bool visitCompoundStmt(const CompoundStmt *S);
234 bool visitDeclStmt(const DeclStmt *DS, bool EvaluateConditionDecl = false);
235 bool visitReturnStmt(const ReturnStmt *RS);
236 bool visitIfStmt(const IfStmt *IS);
237 bool visitWhileStmt(const WhileStmt *S);
238 bool visitDoStmt(const DoStmt *S);
239 bool visitForStmt(const ForStmt *S);
241 bool visitBreakStmt(const BreakStmt *S);
242 bool visitContinueStmt(const ContinueStmt *S);
243 bool visitSwitchStmt(const SwitchStmt *S);
244 bool visitCaseStmt(const CaseStmt *S);
245 bool visitDefaultStmt(const DefaultStmt *S);
246 bool visitAttributedStmt(const AttributedStmt *S);
247 bool visitCXXTryStmt(const CXXTryStmt *S);
248
249protected:
250 bool visitStmt(const Stmt *S);
251 bool visitExpr(const Expr *E, bool DestroyToplevelScope) override;
252 bool visitFunc(const FunctionDecl *F) override;
253
254 bool visitDeclAndReturn(const VarDecl *VD, const Expr *Init,
255 bool ConstantContext) override;
256
257protected:
258 /// Emits scope cleanup instructions.
259 void emitCleanup();
260
261 /// Returns a record type from a record or pointer type.
262 const RecordType *getRecordTy(QualType Ty);
263
264 /// Returns a record from a record or pointer type.
266 Record *getRecord(const RecordDecl *RD);
267
268 /// Returns a function for the given FunctionDecl.
269 /// If the function does not exist yet, it is compiled.
270 const Function *getFunction(const FunctionDecl *FD);
271
272 OptPrimType classify(const Expr *E) const { return Ctx.classify(E); }
273 OptPrimType classify(QualType Ty) const { return Ctx.classify(Ty); }
274 bool canClassify(const Expr *E) const { return Ctx.canClassify(E); }
275 bool canClassify(QualType T) const { return Ctx.canClassify(T); }
276
277 /// Classifies a known primitive type.
279 if (auto T = classify(Ty)) {
280 return *T;
281 }
282 llvm_unreachable("not a primitive type");
283 }
284 /// Classifies a known primitive expression.
285 PrimType classifyPrim(const Expr *E) const {
286 if (auto T = classify(E))
287 return *T;
288 llvm_unreachable("not a primitive type");
289 }
290
291 /// Evaluates an expression and places the result on the stack. If the
292 /// expression is of composite type, a local variable will be created
293 /// and a pointer to said variable will be placed on the stack.
294 bool visit(const Expr *E) override;
295 /// Compiles an initializer. This is like visit() but it will never
296 /// create a variable and instead rely on a variable already having
297 /// been created. visitInitializer() then relies on a pointer to this
298 /// variable being on top of the stack.
299 bool visitInitializer(const Expr *E);
300 bool visitAsLValue(const Expr *E);
301 /// Evaluates an expression for side effects and discards the result.
302 bool discard(const Expr *E);
303 /// Just pass evaluation on to \p E. This leaves all the parsing flags
304 /// intact.
305 bool delegate(const Expr *E);
306 /// Creates and initializes a variable from the given decl.
308 bool Toplevel = false,
309 bool IsConstexprUnknown = false);
311 bool IsConstexprUnknown = false);
312 /// Visit an APValue.
313 bool visitAPValue(const APValue &Val, PrimType ValType, const Expr *E);
314 bool visitAPValueInitializer(const APValue &Val, const Expr *E, QualType T);
315 /// Visit the given decl as if we have a reference to it.
316 bool visitDeclRef(const ValueDecl *D, const Expr *E);
317
318 /// Visits an expression and converts it to a boolean.
319 bool visitBool(const Expr *E);
320
321 bool visitInitList(ArrayRef<const Expr *> Inits, const Expr *ArrayFiller,
322 const Expr *E);
323 bool visitArrayElemInit(unsigned ElemIndex, const Expr *Init,
324 OptPrimType InitT);
325 bool visitCallArgs(ArrayRef<const Expr *> Args, const FunctionDecl *FuncDecl,
326 bool Activate, bool IsOperatorCall);
327
328 /// Creates a local primitive value.
329 unsigned allocateLocalPrimitive(DeclTy &&Decl, PrimType Ty, bool IsConst,
330 bool IsVolatile = false,
331 const ValueDecl *ExtendingDecl = nullptr,
333 bool IsConstexprUnknown = false);
334
335 /// Allocates a space storing a local given its type.
337 const ValueDecl *ExtendingDecl = nullptr,
339 bool IsConstexprUnknown = false);
341
342private:
343 friend class VariableScope<Emitter>;
344 friend class LocalScope<Emitter>;
345 friend class DestructorScope<Emitter>;
346 friend class DeclScope<Emitter>;
347 friend class InitLinkScope<Emitter>;
348 friend class InitStackScope<Emitter>;
349 friend class OptionScope<Emitter>;
350 friend class ArrayIndexScope<Emitter>;
351 friend class SourceLocScope<Emitter>;
352 friend struct InitLink;
353 friend class LoopScope<Emitter>;
354 friend class LabelScope<Emitter>;
355 friend class SwitchScope<Emitter>;
356 friend class StmtExprScope<Emitter>;
357 friend class LocOverrideScope<Emitter>;
358
359 /// Emits a zero initializer.
360 bool visitZeroInitializer(PrimType T, QualType QT, const Expr *E);
361 bool visitZeroRecordInitializer(const Record *R, const Expr *E);
362 bool visitZeroArrayInitializer(QualType T, const Expr *E);
363 bool visitAssignment(const Expr *LHS, const Expr *RHS, const Expr *E);
364
365 /// Emits an APSInt constant.
366 bool emitConst(const llvm::APSInt &Value, PrimType Ty, const Expr *E);
367 bool emitConst(const llvm::APInt &Value, PrimType Ty, const Expr *E);
368 bool emitConst(const llvm::APSInt &Value, const Expr *E);
369 bool emitConst(const llvm::APInt &Value, const Expr *E) {
370 return emitConst(Value, classifyPrim(E), E);
371 }
372
373 /// Emits an integer constant.
374 template <typename T> bool emitConst(T Value, PrimType Ty, const Expr *E);
375 template <typename T> bool emitConst(T Value, const Expr *E);
376 bool emitBool(bool V, const Expr *E) override {
377 return this->emitConst(V, E);
378 }
379
380 llvm::RoundingMode getRoundingMode(const Expr *E) const {
382
383 if (FPO.getRoundingMode() == llvm::RoundingMode::Dynamic)
384 return llvm::RoundingMode::NearestTiesToEven;
385
386 return FPO.getRoundingMode();
387 }
388
389 uint32_t getFPOptions(const Expr *E) const {
390 return E->getFPFeaturesInEffect(Ctx.getLangOpts()).getAsOpaqueInt();
391 }
392
393 bool emitPrimCast(PrimType FromT, PrimType ToT, QualType ToQT, const Expr *E);
394 PrimType classifyComplexElementType(QualType T) const {
395 assert(T->isAnyComplexType());
396
397 QualType ElemType = T->getAs<ComplexType>()->getElementType();
398
399 return *this->classify(ElemType);
400 }
401
402 PrimType classifyVectorElementType(QualType T) const {
403 assert(T->isVectorType());
404 return *this->classify(T->getAs<VectorType>()->getElementType());
405 }
406
407 bool emitComplexReal(const Expr *SubExpr);
408 bool emitComplexBoolCast(const Expr *E);
409 bool emitComplexComparison(const Expr *LHS, const Expr *RHS,
410 const BinaryOperator *E);
411 bool emitRecordDestructionPop(const Record *R, SourceInfo Loc);
412 bool emitDestructionPop(const Descriptor *Desc, SourceInfo Loc);
413 bool emitDummyPtr(const DeclTy &D, const Expr *E);
414 bool emitFloat(const APFloat &F, const Expr *E);
415 unsigned collectBaseOffset(const QualType BaseType,
416 const QualType DerivedType);
417 bool emitLambdaStaticInvokerBody(const CXXMethodDecl *MD);
418 bool emitBuiltinBitCast(const CastExpr *E);
419 bool compileConstructor(const CXXConstructorDecl *Ctor);
420 bool compileDestructor(const CXXDestructorDecl *Dtor);
421 bool compileUnionAssignmentOperator(const CXXMethodDecl *MD);
422
423 bool checkLiteralType(const Expr *E);
424 bool maybeEmitDeferredVarInit(const VarDecl *VD);
425
426 bool refersToUnion(const Expr *E);
427
428protected:
429 /// Variable to storage mapping.
430 llvm::DenseMap<const ValueDecl *, Scope::Local> Locals;
431
432 /// OpaqueValueExpr to location mapping.
433 llvm::DenseMap<const OpaqueValueExpr *, unsigned> OpaqueExprs;
434
435 /// Current scope.
437
438 /// Current argument index. Needed to emit ArrayInitIndexExpr.
439 std::optional<uint64_t> ArrayIndex;
440
441 /// DefaultInit- or DefaultArgExpr, needed for SourceLocExpr.
442 const Expr *SourceLocDefaultExpr = nullptr;
443
444 /// Flag indicating if return value is to be discarded.
445 bool DiscardResult = false;
446
447 bool InStmtExpr = false;
448 bool ToLValue = false;
449
450 /// Flag inidicating if we're initializing an already created
451 /// variable. This is set in visitInitializer().
452 bool Initializing = false;
453 const ValueDecl *InitializingDecl = nullptr;
454
456 bool InitStackActive = false;
457
458 /// Type of the expression returned by the function.
460
461 /// Switch case mapping.
463 /// Stack of label information for loops and switch statements.
465
467};
468
469extern template class Compiler<ByteCodeEmitter>;
470extern template class Compiler<EvalEmitter>;
471
472/// Scope chain managing the variable lifetimes.
473template <class Emitter> class VariableScope {
474public:
477 : Ctx(Ctx), Parent(Ctx->VarScope), ValDecl(VD), Kind(Kind) {
478 Ctx->VarScope = this;
479 }
480
481 virtual ~VariableScope() { Ctx->VarScope = this->Parent; }
482
483 virtual void addLocal(const Scope::Local &Local) {
484 llvm_unreachable("Shouldn't be called");
485 }
486
487 void addExtended(const Scope::Local &Local, const ValueDecl *ExtendingDecl) {
488 // Walk up the chain of scopes until we find the one for ExtendingDecl.
489 // If there is no such scope, attach it to the parent one.
490 VariableScope *P = this;
491 while (P) {
492 if (P->ValDecl == ExtendingDecl) {
493 P->addLocal(Local);
494 return;
495 }
496 P = P->Parent;
497 if (!P)
498 break;
499 }
500
501 // Use the parent scope.
502 if (this->Parent)
503 this->Parent->addLocal(Local);
504 else
505 this->addLocal(Local);
506 }
507
508 /// Like addExtended, but adds to the nearest scope of the given kind.
510 VariableScope *P = this;
511 while (P) {
512 if (P->Kind == Kind) {
513 P->addLocal(Local);
514 return;
515 }
516 P = P->Parent;
517 if (!P)
518 break;
519 }
520
521 // Add to this scope.
522 this->addLocal(Local);
523 }
524
525 virtual void emitDestruction() {}
526 virtual bool emitDestructors(const Expr *E = nullptr) { return true; }
527 virtual bool destroyLocals(const Expr *E = nullptr) { return true; }
528 VariableScope *getParent() const { return Parent; }
529 ScopeKind getKind() const { return Kind; }
530
531protected:
532 /// Compiler instance.
534 /// Link to the parent scope.
536 const ValueDecl *ValDecl = nullptr;
538};
539
540/// Generic scope for local variables.
541template <class Emitter> class LocalScope : public VariableScope<Emitter> {
542public:
547
548 /// Emit a Destroy op for this scope.
549 ~LocalScope() override {
550 if (!Idx)
551 return;
552 this->Ctx->emitDestroy(*Idx, SourceInfo{});
554 }
555
556 /// Overriden to support explicit destruction.
557 void emitDestruction() override {
558 if (!Idx)
559 return;
560
561 this->emitDestructors();
562 this->Ctx->emitDestroy(*Idx, SourceInfo{});
563 }
564
565 /// Explicit destruction of local variables.
566 bool destroyLocals(const Expr *E = nullptr) override {
567 if (!Idx)
568 return true;
569
570 // NB: We are *not* resetting Idx here as to allow multiple
571 // calls to destroyLocals().
572 bool Success = this->emitDestructors(E);
573 this->Ctx->emitDestroy(*Idx, E);
574 return Success;
575 }
576
577 void addLocal(const Scope::Local &Local) override {
578 if (!Idx) {
579 Idx = static_cast<unsigned>(this->Ctx->Descriptors.size());
580 this->Ctx->Descriptors.emplace_back();
581 this->Ctx->emitInitScope(*Idx, {});
582 }
583
584 this->Ctx->Descriptors[*Idx].emplace_back(Local);
585 }
586
587 bool emitDestructors(const Expr *E = nullptr) override {
588 if (!Idx)
589 return true;
590 // Emit destructor calls for local variables of record
591 // type with a destructor.
592 for (Scope::Local &Local : llvm::reverse(this->Ctx->Descriptors[*Idx])) {
593 if (Local.Desc->hasTrivialDtor())
594 continue;
595 if (!this->Ctx->emitGetPtrLocal(Local.Offset, E))
596 return false;
597
598 if (!this->Ctx->emitDestructionPop(Local.Desc, Local.Desc->getLoc()))
599 return false;
600
602 }
603 return true;
604 }
605
607 if (!Idx)
608 return;
609
610 for (const Scope::Local &Local : this->Ctx->Descriptors[*Idx]) {
612 }
613 }
614
616 if (const auto *OVE =
617 llvm::dyn_cast_if_present<OpaqueValueExpr>(Local.Desc->asExpr())) {
618 if (auto It = this->Ctx->OpaqueExprs.find(OVE);
619 It != this->Ctx->OpaqueExprs.end())
620 this->Ctx->OpaqueExprs.erase(It);
621 };
622 }
623
624 /// Index of the scope in the chain.
625 UnsignedOrNone Idx = std::nullopt;
626};
627
628template <class Emitter> class ArrayIndexScope final {
629public:
630 ArrayIndexScope(Compiler<Emitter> *Ctx, uint64_t Index) : Ctx(Ctx) {
631 OldArrayIndex = Ctx->ArrayIndex;
632 Ctx->ArrayIndex = Index;
633 }
634
635 ~ArrayIndexScope() { Ctx->ArrayIndex = OldArrayIndex; }
636
637private:
639 std::optional<uint64_t> OldArrayIndex;
640};
641
642template <class Emitter> class SourceLocScope final {
643public:
644 SourceLocScope(Compiler<Emitter> *Ctx, const Expr *DefaultExpr) : Ctx(Ctx) {
645 assert(DefaultExpr);
646 // We only switch if the current SourceLocDefaultExpr is null.
647 if (!Ctx->SourceLocDefaultExpr) {
648 Enabled = true;
649 Ctx->SourceLocDefaultExpr = DefaultExpr;
650 }
651 }
652
654 if (Enabled)
655 Ctx->SourceLocDefaultExpr = nullptr;
656 }
657
658private:
660 bool Enabled = false;
661};
662
663template <class Emitter> class InitLinkScope final {
664public:
666 Ctx->InitStack.push_back(std::move(Link));
667 }
668
669 ~InitLinkScope() { this->Ctx->InitStack.pop_back(); }
670
671private:
673};
674
675template <class Emitter> class InitStackScope final {
676public:
678 : Ctx(Ctx), OldValue(Ctx->InitStackActive) {
679 Ctx->InitStackActive = Active;
680 }
681
682 ~InitStackScope() { this->Ctx->InitStackActive = OldValue; }
683
684private:
686 bool OldValue;
687};
688
689} // namespace interp
690} // namespace clang
691
692#endif
#define V(N, I)
llvm::MachO::Record Record
Definition MachO.h:31
__device__ __2f16 b
APValue - This class implements a discriminated union of [uninitialized] [APSInt] [APFloat],...
Definition APValue.h:122
AbstractConditionalOperator - An abstract base class for ConditionalOperator and BinaryConditionalOpe...
Definition Expr.h:4287
AddrLabelExpr - The GNU address of label extension, representing &&label.
Definition Expr.h:4484
Represents the index of the current element of an array being initialized by an ArrayInitLoopExpr.
Definition Expr.h:5955
Represents a loop initializing the elements of an array.
Definition Expr.h:5902
ArraySubscriptExpr - [C99 6.5.2.1] Array Subscripting.
Definition Expr.h:2721
An Embarcadero array type trait, as used in the implementation of __array_rank and __array_extent.
Definition ExprCXX.h:2998
Represents an attribute applied to a statement.
Definition Stmt.h:2203
A builtin binary operation expression such as "x + y" or "x <= y".
Definition Expr.h:3972
BlockExpr - Adaptor class for mixing a BlockDecl with expressions.
Definition Expr.h:6558
BreakStmt - This represents a break.
Definition Stmt.h:3135
Represents a C++2a __builtin_bit_cast(T, v) expression.
Definition ExprCXX.h:5478
Represents binding an expression to a temporary.
Definition ExprCXX.h:1494
A boolean literal, per ([C++ lex.bool] Boolean literals).
Definition ExprCXX.h:723
Represents a call to a C++ constructor.
Definition ExprCXX.h:1549
A default argument (C++ [dcl.fct.default]).
Definition ExprCXX.h:1271
A use of a default initializer in a constructor or in aggregate initialization.
Definition ExprCXX.h:1378
Represents a delete expression for memory deallocation and destructor calls, e.g.
Definition ExprCXX.h:2628
A C++ dynamic_cast expression (C++ [expr.dynamic.cast]).
Definition ExprCXX.h:481
CXXForRangeStmt - This represents C++0x [stmt.ranged]'s ranged for statement, represented as 'for (ra...
Definition StmtCXX.h:135
Represents a call to an inherited base class constructor from an inheriting constructor.
Definition ExprCXX.h:1753
Represents a new-expression for memory allocation and constructor calls, e.g: "new CXXNewExpr(foo)".
Definition ExprCXX.h:2357
Represents a C++11 noexcept expression (C++ [expr.unary.noexcept]).
Definition ExprCXX.h:4311
The null pointer literal (C++11 [lex.nullptr])
Definition ExprCXX.h:768
Represents a list-initialization with parenthesis.
Definition ExprCXX.h:5143
A C++ reinterpret_cast expression (C++ [expr.reinterpret.cast]).
Definition ExprCXX.h:526
A rewritten comparison expression that was originally written using operator syntax.
Definition ExprCXX.h:286
An expression "T()" which creates an rvalue of a non-class type T.
Definition ExprCXX.h:2198
Implicit construction of a std::initializer_list<T> object from an array temporary within list-initia...
Definition ExprCXX.h:800
Represents the this expression in C++.
Definition ExprCXX.h:1155
A C++ throw-expression (C++ [except.throw]).
Definition ExprCXX.h:1209
CXXTryStmt - A C++ try block, including all handlers.
Definition StmtCXX.h:69
A C++ typeid expression (C++ [expr.typeid]), which gets the type_info that corresponds to the supplie...
Definition ExprCXX.h:848
A Microsoft C++ __uuidof expression, which gets the _GUID that corresponds to the supplied type or ex...
Definition ExprCXX.h:1069
CallExpr - Represents a function call (C99 6.5.2.2, C++ [expr.call]).
Definition Expr.h:2877
CaseStmt - Represent a case statement.
Definition Stmt.h:1920
CastExpr - Base class for type casts, including both implicit casts (ImplicitCastExpr) and explicit c...
Definition Expr.h:3610
ChooseExpr - GNU builtin-in function __builtin_choose_expr.
Definition Expr.h:4782
CompoundAssignOperator - For compound assignments (e.g.
Definition Expr.h:4234
CompoundLiteralExpr - [C99 6.5.2.5].
Definition Expr.h:3539
CompoundStmt - This represents a group of statements like { stmt stmt }.
Definition Stmt.h:1720
Represents the specialization of a concept - evaluates to a prvalue of type bool.
ConstStmtVisitor - This class implements a simple visitor for Stmt subclasses.
ConstantExpr - An expression that occurs in a constant context and optionally the result of evaluatin...
Definition Expr.h:1082
ContinueStmt - This represents a continue.
Definition Stmt.h:3119
ConvertVectorExpr - Clang builtin function __builtin_convertvector This AST node provides support for...
Definition Expr.h:4653
A reference to a declared variable, function, enum, etc.
Definition Expr.h:1270
DeclStmt - Adaptor class for mixing declarations with statements and expressions.
Definition Stmt.h:1611
Decl - This represents one declaration (or definition), e.g.
Definition DeclBase.h:86
DoStmt - This represents a 'do/while' stmt.
Definition Stmt.h:2832
Represents a reference to emded data.
Definition Expr.h:5060
Represents an expression – generally a full-expression – that introduces cleanups to be run at the en...
Definition ExprCXX.h:3663
This represents one expression.
Definition Expr.h:112
FPOptions getFPFeaturesInEffect(const LangOptions &LO) const
Returns the set of floating point options that apply to this expression.
Definition Expr.cpp:3963
An expression trait intrinsic.
Definition ExprCXX.h:3071
ExtVectorElementExpr - This represents access to specific elements of a vector, and may occur on the ...
Definition Expr.h:6498
RoundingMode getRoundingMode() const
ForStmt - This represents a 'for (init;cond;inc)' stmt.
Definition Stmt.h:2888
Represents a function declaration or definition.
Definition Decl.h:2000
GNUNullExpr - Implements the GNU __null extension, which is a name for a null pointer constant that h...
Definition Expr.h:4857
Represents a C11 generic selection.
Definition Expr.h:6112
IfStmt - This represents an if/then/else.
Definition Stmt.h:2259
ImaginaryLiteral - We support imaginary integer and floating point literals, like "1....
Definition Expr.h:1731
Represents an implicitly-generated value initialization of an object of a given type.
Definition Expr.h:5991
Describes an C or C++ initializer list.
Definition Expr.h:5233
A C++ lambda expression, which produces a function object (of unspecified type) that can be invoked l...
Definition ExprCXX.h:1970
Represents a prvalue temporary that is written into memory so that a reference can bind to it.
Definition ExprCXX.h:4922
MemberExpr - [C99 6.5.2.3] Structure and Union Members.
Definition Expr.h:3298
ObjCBoolLiteralExpr - Objective-C Boolean Literal.
Definition ExprObjC.h:88
ObjCBoxedExpr - used for generalized expression boxing.
Definition ExprObjC.h:128
ObjCEncodeExpr, used for @encode in Objective-C.
Definition ExprObjC.h:409
ObjCStringLiteral, used for Objective-C string literals i.e.
Definition ExprObjC.h:52
OffsetOfExpr - [C99 7.17] - This represents an expression of the form offsetof(record-type,...
Definition Expr.h:2527
OpaqueValueExpr - An expression referring to an opaque object of a fixed type and value class.
Definition Expr.h:1178
ParenExpr - This represents a parenthesized expression, e.g.
Definition Expr.h:2182
[C99 6.4.2.2] - A predefined identifier such as func.
Definition Expr.h:2005
PseudoObjectExpr - An expression which accesses a pseudo-object l-value.
Definition Expr.h:6690
A (possibly-)qualified type.
Definition TypeBase.h:937
Represents a struct/union/class.
Definition Decl.h:4312
Frontend produces RecoveryExprs on semantic errors that prevent creating other well-formed expression...
Definition Expr.h:7377
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:3160
ShuffleVectorExpr - clang-specific builtin-in function __builtin_shufflevector.
Definition Expr.h:4577
Represents an expression that computes the length of a parameter pack.
Definition ExprCXX.h:4443
Represents a function call to one of __builtin_LINE(), __builtin_COLUMN(), __builtin_FUNCTION(),...
Definition Expr.h:4951
StmtExpr - This is the GNU Statement Expression extension: ({int X=4; X;}).
Definition Expr.h:4529
Stmt - This represents one statement.
Definition Stmt.h:85
StringLiteral - This represents a string literal expression, e.g.
Definition Expr.h:1799
Represents a reference to a non-type template parameter that has been substituted with a template arg...
Definition ExprCXX.h:4666
SwitchStmt - This represents a 'switch' stmt.
Definition Stmt.h:2509
A type trait used in the implementation of various C++11 and Library TR1 trait templates.
Definition ExprCXX.h:2898
bool isAnyComplexType() const
Definition TypeBase.h:8659
bool isVectorType() const
Definition TypeBase.h:8663
const T * getAs() const
Member-template getAs<specific type>'.
Definition TypeBase.h:9100
UnaryExprOrTypeTraitExpr - expression with either a type or (unevaluated) expression operand.
Definition Expr.h:2625
UnaryOperator - This represents the unary-expression's (except sizeof and alignof),...
Definition Expr.h:2244
Represent the declaration of a variable (in which case it is an lvalue) a function (in which case it ...
Definition Decl.h:712
Represents a variable declaration or definition.
Definition Decl.h:926
WhileStmt - This represents a 'while' stmt.
Definition Stmt.h:2697
ArrayIndexScope(Compiler< Emitter > *Ctx, uint64_t Index)
Definition Compiler.h:630
A memory block, either on the stack or in the heap.
Definition InterpBlock.h:44
Compilation context for expressions.
Definition Compiler.h:110
llvm::SmallVector< InitLink > InitStack
Definition Compiler.h:455
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:285
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 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:278
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:433
bool VisitBinaryOperator(const BinaryOperator *E)
Definition Compiler.cpp:841
bool visitAttributedStmt(const AttributedStmt *S)
bool VisitPackIndexingExpr(const PackIndexingExpr *E)
VarCreationState visitDecl(const VarDecl *VD, bool IsConstexprUnknown=false)
bool visitAPValueInitializer(const APValue &Val, const Expr *E, QualType T)
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:439
bool VisitPseudoObjectExpr(const PseudoObjectExpr *E)
bool VisitCXXReinterpretCastExpr(const CXXReinterpretCastExpr *E)
const Function * getFunction(const FunctionDecl *FD)
Returns a function for the given FunctionDecl.
void emitCleanup()
Emits scope cleanup instructions.
bool VisitFixedPointBinOp(const BinaryOperator *E)
bool VisitCastExpr(const CastExpr *E)
Definition Compiler.cpp:212
bool VisitObjCEncodeExpr(const ObjCEncodeExpr *E)
bool VisitFixedPointUnaryOperator(const UnaryOperator *E)
bool VisitComplexUnaryOperator(const UnaryOperator *E)
llvm::DenseMap< const SwitchCase *, LabelTy > CaseMap
Definition Compiler.h:116
bool VisitBlockExpr(const BlockExpr *E)
friend struct InitLink
Definition Compiler.h:352
bool visitAPValue(const APValue &Val, PrimType ValType, const Expr *E)
Visit an APValue.
bool VisitCXXScalarValueInitExpr(const CXXScalarValueInitExpr *E)
bool VisitLogicalBinOp(const BinaryOperator *E)
bool visitCompoundStmt(const CompoundStmt *S)
Context & Ctx
Current compilation context.
Definition Compiler.h:133
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 VisitStmtExpr(const StmtExpr *E)
bool VisitBuiltinBitCastExpr(const BuiltinBitCastExpr *E)
Definition Compiler.cpp:777
bool VisitFixedPointLiteral(const FixedPointLiteral *E)
Definition Compiler.cpp:823
const FunctionDecl * CompilingFunction
Definition Compiler.h:466
bool VisitCXXBoolLiteralExpr(const CXXBoolLiteralExpr *E)
VariableScope< Emitter > * VarScope
Current scope.
Definition Compiler.h:436
bool visitDeclAndReturn(const VarDecl *VD, const Expr *Init, bool ConstantContext) override
Toplevel visitDeclAndReturn().
bool VisitCXXNewExpr(const CXXNewExpr *E)
const ValueDecl * InitializingDecl
Definition Compiler.h:453
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 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:462
Record * getRecord(QualType Ty)
Returns a record from a record or pointer type.
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:140
bool visitDeclStmt(const DeclStmt *DS, bool EvaluateConditionDecl=false)
bool VisitExtVectorElementExpr(const ExtVectorElementExpr *E)
bool VisitObjCStringLiteral(const ObjCStringLiteral *E)
bool VisitArrayTypeTraitExpr(const ArrayTypeTraitExpr *E)
bool visitInitializer(const Expr *E)
Compiles an initializer.
const Expr * SourceLocDefaultExpr
DefaultInit- or DefaultArgExpr, needed for SourceLocExpr.
Definition Compiler.h:442
UnsignedOrNone OptLabelTy
Definition Compiler.h:115
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)
typename Emitter::LabelTy LabelTy
Definition Compiler.h:113
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)
VarCreationState visitVarDecl(const VarDecl *VD, const Expr *Init, bool Toplevel=false, bool IsConstexprUnknown=false)
Creates and initializes a variable from the given decl.
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:452
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:430
bool VisitAbstractConditionalOperator(const AbstractConditionalOperator *E)
unsigned allocateLocalPrimitive(DeclTy &&Decl, PrimType Ty, bool IsConst, bool IsVolatile=false, const ValueDecl *ExtendingDecl=nullptr, ScopeKind SC=ScopeKind::Block, bool IsConstexprUnknown=false)
Creates a local primitive value.
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:114
bool VisitCXXRewrittenBinaryOperator(const CXXRewrittenBinaryOperator *E)
OptPrimType classify(QualType Ty) const
Definition Compiler.h:273
OptPrimType ReturnType
Type of the expression returned by the function.
Definition Compiler.h:459
bool VisitUnaryOperator(const UnaryOperator *E)
bool VisitFloatCompoundAssignOperator(const CompoundAssignOperator *E)
OptPrimType classify(const Expr *E) const
Definition Compiler.h:272
llvm::SmallVector< LabelInfo > LabelInfoStack
Stack of label information for loops and switch statements.
Definition Compiler.h:464
bool VisitGenericSelectionExpr(const GenericSelectionExpr *E)
bool visitDoStmt(const DoStmt *S)
bool VisitIntegerLiteral(const IntegerLiteral *E)
Definition Compiler.cpp:782
bool VisitInitListExpr(const InitListExpr *E)
UnsignedOrNone allocateLocal(DeclTy &&Decl, QualType Ty=QualType(), const ValueDecl *ExtendingDecl=nullptr, ScopeKind=ScopeKind::Block, bool IsConstexprUnknown=false)
Allocates a space storing a local given its type.
bool VisitVectorBinOp(const BinaryOperator *E)
bool VisitStringLiteral(const StringLiteral *E)
bool VisitParenExpr(const ParenExpr *E)
Definition Compiler.cpp:836
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:445
bool VisitEmbedExpr(const EmbedExpr *E)
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:275
bool VisitCXXUuidofExpr(const CXXUuidofExpr *E)
bool VisitExprWithCleanups(const ExprWithCleanups *E)
bool visitAsLValue(const Expr *E)
bool visitWhileStmt(const WhileStmt *S)
bool visitIfStmt(const IfStmt *IS)
bool VisitAddrLabelExpr(const AddrLabelExpr *E)
bool canClassify(const Expr *E) const
Definition Compiler.h:274
bool VisitFloatingLiteral(const FloatingLiteral *E)
Definition Compiler.cpp:790
Program & P
Program to link to.
Definition Compiler.h:135
bool VisitMaterializeTemporaryExpr(const MaterializeTemporaryExpr *E)
bool VisitGNUNullExpr(const GNUNullExpr *E)
bool VisitImaginaryLiteral(const ImaginaryLiteral *E)
Definition Compiler.cpp:799
bool VisitSYCLUniqueStableNameExpr(const SYCLUniqueStableNameExpr *E)
bool visitCXXTryStmt(const CXXTryStmt *S)
Holds all information required to evaluate constexpr code in a module.
Definition Context.h:41
const LangOptions & getLangOpts() const
Returns the language options.
Definition Context.cpp:326
Scope used to handle temporaries in toplevel variable declarations.
Definition Compiler.cpp:39
Bytecode function.
Definition Function.h:86
InitLinkScope(Compiler< Emitter > *Ctx, InitLink &&Link)
Definition Compiler.h:665
InitStackScope(Compiler< Emitter > *Ctx, bool Active)
Definition Compiler.h:677
When generating code for e.g.
Definition Compiler.cpp:187
Generic scope for local variables.
Definition Compiler.h:541
UnsignedOrNone Idx
Index of the scope in the chain.
Definition Compiler.h:625
~LocalScope() override
Emit a Destroy op for this scope.
Definition Compiler.h:549
bool destroyLocals(const Expr *E=nullptr) override
Explicit destruction of local variables.
Definition Compiler.h:566
LocalScope(Compiler< Emitter > *Ctx, const ValueDecl *VD)
Definition Compiler.h:545
bool emitDestructors(const Expr *E=nullptr) override
Definition Compiler.h:587
void emitDestruction() override
Overriden to support explicit destruction.
Definition Compiler.h:557
void removeIfStoredOpaqueValue(const Scope::Local &Local)
Definition Compiler.h:615
void addLocal(const Scope::Local &Local) override
Definition Compiler.h:577
LocalScope(Compiler< Emitter > *Ctx, ScopeKind Kind=ScopeKind::Block)
Definition Compiler.h:543
Sets the context for break/continue statements.
Definition Compiler.cpp:113
Scope used to handle initialization methods.
Definition Compiler.cpp:59
The program contains and links the bytecode for all functions.
Definition Program.h:36
Structure/Class descriptor.
Definition Record.h:25
Describes the statement/declaration an opcode was generated from.
Definition Source.h:73
SourceLocScope(Compiler< Emitter > *Ctx, const Expr *DefaultExpr)
Definition Compiler.h:644
Scope chain managing the variable lifetimes.
Definition Compiler.h:473
void addExtended(const Scope::Local &Local, const ValueDecl *ExtendingDecl)
Definition Compiler.h:487
void addForScopeKind(const Scope::Local &Local, ScopeKind Kind)
Like addExtended, but adds to the nearest scope of the given kind.
Definition Compiler.h:509
Compiler< Emitter > * Ctx
Compiler instance.
Definition Compiler.h:533
virtual bool emitDestructors(const Expr *E=nullptr)
Definition Compiler.h:526
virtual bool destroyLocals(const Expr *E=nullptr)
Definition Compiler.h:527
const ValueDecl * ValDecl
Definition Compiler.h:536
VariableScope * Parent
Link to the parent scope.
Definition Compiler.h:535
VariableScope(Compiler< Emitter > *Ctx, const ValueDecl *VD, ScopeKind Kind=ScopeKind::Block)
Definition Compiler.h:475
virtual void addLocal(const Scope::Local &Local)
Definition Compiler.h:483
ScopeKind getKind() const
Definition Compiler.h:529
VariableScope * getParent() const
Definition Compiler.h:528
virtual void emitDestruction()
Definition Compiler.h:525
#define bool
Definition gpuintrin.h:32
bool Call(InterpState &S, CodePtr OpPC, const Function *Func, uint32_t VarArgSize)
Definition Interp.cpp:1555
llvm::PointerUnion< const Decl *, const Expr * > DeclTy
Definition Descriptor.h:29
static bool Activate(InterpState &S, CodePtr OpPC)
Definition Interp.h:1983
llvm::APFloat APFloat
Definition Floating.h:27
PrimType
Enumeration of the primitive types of the VM.
Definition PrimType.h:34
bool Init(InterpState &S, CodePtr OpPC)
Definition Interp.h:2099
The JSON file list parser is used to communicate input to InstallAPI.
@ Success
Annotation was successful.
Definition Parser.h:65
@ Link
'link' clause, allowed on 'declare' construct.
nullptr
This class represents a compute construct, representing a 'Kind' of ‘parallel’, 'serial',...
const FunctionProtoType * T
const VariableScope< Emitter > * BreakOrContinueScope
Definition Compiler.h:120
LabelInfo(const Stmt *Name, OptLabelTy BreakLabel, OptLabelTy ContinueLabel, OptLabelTy DefaultLabel, const VariableScope< Emitter > *BreakOrContinueScope)
Definition Compiler.h:124
Information about a local's storage.
Definition Function.h:39
State encapsulating if a the variable creation has been successful, unsuccessful, or no variable has ...
Definition Compiler.h:95
static VarCreationState NotCreated()
Definition Compiler.h:99
std::optional< bool > S
Definition Compiler.h:96