16#include "mlir/IR/Builders.h"
17#include "mlir/IR/Location.h"
18#include "mlir/Support/LLVM.h"
29 const Stmt *exprResult,
38 if (
const auto *ls = dyn_cast<LabelStmt>(exprResult)) {
39 if (cgf.
emitLabel(*ls->getDecl()).failed())
40 return mlir::failure();
41 exprResult = ls->getSubStmt();
42 }
else if (
const auto *as = dyn_cast<AttributedStmt>(exprResult)) {
45 exprResult = as->getSubStmt();
47 llvm_unreachable(
"Unknown value statement");
63 return mlir::success();
68 mlir::LogicalResult result = mlir::success();
69 const Stmt *exprResult =
s.getStmtExprResult();
70 assert((!lastValue || (lastValue && exprResult)) &&
71 "If lastValue is not null then the CompoundStmt must have a "
74 for (
const Stmt *curStmt :
s.body()) {
75 const bool saveResult = lastValue && exprResult == curStmt;
78 result = mlir::failure();
80 if (
emitStmt(curStmt,
false).failed())
81 result = mlir::failure();
92 mlir::Location scopeLoc =
getLoc(
s.getSourceRange());
93 mlir::OpBuilder::InsertPoint scopeInsPt;
94 builder.create<cir::ScopeOp>(
95 scopeLoc, [&](mlir::OpBuilder &
b, mlir::Type &
type, mlir::Location loc) {
96 scopeInsPt =
b.saveInsertionPoint();
98 mlir::OpBuilder::InsertionGuard guard(builder);
99 builder.restoreInsertionPoint(scopeInsPt);
100 LexicalScope lexScope(*
this, scopeLoc, builder.getInsertionBlock());
111 bool useCurrentScope,
114 return mlir::success();
116 switch (
s->getStmtClass()) {
118 case Stmt::CXXCatchStmtClass:
119 case Stmt::SEHExceptStmtClass:
120 case Stmt::SEHFinallyStmtClass:
121 case Stmt::MSDependentExistsStmtClass:
122 llvm_unreachable(
"invalid statement class to emit generically");
123 case Stmt::BreakStmtClass:
124 case Stmt::NullStmtClass:
125 case Stmt::CompoundStmtClass:
126 case Stmt::ContinueStmtClass:
127 case Stmt::DeclStmtClass:
128 case Stmt::ReturnStmtClass:
129 llvm_unreachable(
"should have emitted these statements as simple");
131#define STMT(Type, Base)
132#define ABSTRACT_STMT(Op)
133#define EXPR(Type, Base) case Stmt::Type##Class:
134#include "clang/AST/StmtNodes.inc"
136 assert(builder.getInsertionBlock() &&
137 "expression emission must have an insertion point");
145 return mlir::success();
147 case Stmt::IfStmtClass:
149 case Stmt::SwitchStmtClass:
151 case Stmt::ForStmtClass:
153 case Stmt::WhileStmtClass:
155 case Stmt::DoStmtClass:
157 case Stmt::CXXForRangeStmtClass:
159 case Stmt::OpenACCComputeConstructClass:
161 case Stmt::OpenACCLoopConstructClass:
163 case Stmt::OpenACCCombinedConstructClass:
165 case Stmt::OpenACCDataConstructClass:
167 case Stmt::OpenACCEnterDataConstructClass:
169 case Stmt::OpenACCExitDataConstructClass:
171 case Stmt::OpenACCHostDataConstructClass:
173 case Stmt::OpenACCWaitConstructClass:
175 case Stmt::OpenACCInitConstructClass:
177 case Stmt::OpenACCShutdownConstructClass:
179 case Stmt::OpenACCSetConstructClass:
181 case Stmt::OpenACCUpdateConstructClass:
183 case Stmt::OpenACCCacheConstructClass:
185 case Stmt::OpenACCAtomicConstructClass:
187 case Stmt::GCCAsmStmtClass:
188 case Stmt::MSAsmStmtClass:
190 case Stmt::OMPScopeDirectiveClass:
191 case Stmt::OMPErrorDirectiveClass:
192 case Stmt::LabelStmtClass:
193 case Stmt::AttributedStmtClass:
194 case Stmt::GotoStmtClass:
195 case Stmt::DefaultStmtClass:
196 case Stmt::CaseStmtClass:
197 case Stmt::SEHLeaveStmtClass:
198 case Stmt::SYCLKernelCallStmtClass:
199 case Stmt::CoroutineBodyStmtClass:
200 case Stmt::CoreturnStmtClass:
201 case Stmt::CXXTryStmtClass:
202 case Stmt::IndirectGotoStmtClass:
203 case Stmt::OMPParallelDirectiveClass:
204 case Stmt::OMPTaskwaitDirectiveClass:
205 case Stmt::OMPTaskyieldDirectiveClass:
206 case Stmt::OMPBarrierDirectiveClass:
207 case Stmt::CapturedStmtClass:
208 case Stmt::ObjCAtTryStmtClass:
209 case Stmt::ObjCAtThrowStmtClass:
210 case Stmt::ObjCAtSynchronizedStmtClass:
211 case Stmt::ObjCForCollectionStmtClass:
212 case Stmt::ObjCAutoreleasePoolStmtClass:
213 case Stmt::SEHTryStmtClass:
214 case Stmt::OMPMetaDirectiveClass:
215 case Stmt::OMPCanonicalLoopClass:
216 case Stmt::OMPSimdDirectiveClass:
217 case Stmt::OMPTileDirectiveClass:
218 case Stmt::OMPUnrollDirectiveClass:
219 case Stmt::OMPForDirectiveClass:
220 case Stmt::OMPForSimdDirectiveClass:
221 case Stmt::OMPSectionsDirectiveClass:
222 case Stmt::OMPSectionDirectiveClass:
223 case Stmt::OMPSingleDirectiveClass:
224 case Stmt::OMPMasterDirectiveClass:
225 case Stmt::OMPCriticalDirectiveClass:
226 case Stmt::OMPParallelForDirectiveClass:
227 case Stmt::OMPParallelForSimdDirectiveClass:
228 case Stmt::OMPParallelMasterDirectiveClass:
229 case Stmt::OMPParallelSectionsDirectiveClass:
230 case Stmt::OMPTaskDirectiveClass:
231 case Stmt::OMPTaskgroupDirectiveClass:
232 case Stmt::OMPFlushDirectiveClass:
233 case Stmt::OMPDepobjDirectiveClass:
234 case Stmt::OMPScanDirectiveClass:
235 case Stmt::OMPOrderedDirectiveClass:
236 case Stmt::OMPAtomicDirectiveClass:
237 case Stmt::OMPTargetDirectiveClass:
238 case Stmt::OMPTeamsDirectiveClass:
239 case Stmt::OMPCancellationPointDirectiveClass:
240 case Stmt::OMPCancelDirectiveClass:
241 case Stmt::OMPTargetDataDirectiveClass:
242 case Stmt::OMPTargetEnterDataDirectiveClass:
243 case Stmt::OMPTargetExitDataDirectiveClass:
244 case Stmt::OMPTargetParallelDirectiveClass:
245 case Stmt::OMPTargetParallelForDirectiveClass:
246 case Stmt::OMPTaskLoopDirectiveClass:
247 case Stmt::OMPTaskLoopSimdDirectiveClass:
248 case Stmt::OMPMaskedTaskLoopDirectiveClass:
249 case Stmt::OMPMaskedTaskLoopSimdDirectiveClass:
250 case Stmt::OMPMasterTaskLoopDirectiveClass:
251 case Stmt::OMPMasterTaskLoopSimdDirectiveClass:
252 case Stmt::OMPParallelGenericLoopDirectiveClass:
253 case Stmt::OMPParallelMaskedDirectiveClass:
254 case Stmt::OMPParallelMaskedTaskLoopDirectiveClass:
255 case Stmt::OMPParallelMaskedTaskLoopSimdDirectiveClass:
256 case Stmt::OMPParallelMasterTaskLoopDirectiveClass:
257 case Stmt::OMPParallelMasterTaskLoopSimdDirectiveClass:
258 case Stmt::OMPDistributeDirectiveClass:
259 case Stmt::OMPDistributeParallelForDirectiveClass:
260 case Stmt::OMPDistributeParallelForSimdDirectiveClass:
261 case Stmt::OMPDistributeSimdDirectiveClass:
262 case Stmt::OMPTargetParallelGenericLoopDirectiveClass:
263 case Stmt::OMPTargetParallelForSimdDirectiveClass:
264 case Stmt::OMPTargetSimdDirectiveClass:
265 case Stmt::OMPTargetTeamsGenericLoopDirectiveClass:
266 case Stmt::OMPTargetUpdateDirectiveClass:
267 case Stmt::OMPTeamsDistributeDirectiveClass:
268 case Stmt::OMPTeamsDistributeSimdDirectiveClass:
269 case Stmt::OMPTeamsDistributeParallelForSimdDirectiveClass:
270 case Stmt::OMPTeamsDistributeParallelForDirectiveClass:
271 case Stmt::OMPTeamsGenericLoopDirectiveClass:
272 case Stmt::OMPTargetTeamsDirectiveClass:
273 case Stmt::OMPTargetTeamsDistributeDirectiveClass:
274 case Stmt::OMPTargetTeamsDistributeParallelForDirectiveClass:
275 case Stmt::OMPTargetTeamsDistributeParallelForSimdDirectiveClass:
276 case Stmt::OMPTargetTeamsDistributeSimdDirectiveClass:
277 case Stmt::OMPInteropDirectiveClass:
278 case Stmt::OMPDispatchDirectiveClass:
279 case Stmt::OMPGenericLoopDirectiveClass:
280 case Stmt::OMPReverseDirectiveClass:
281 case Stmt::OMPInterchangeDirectiveClass:
282 case Stmt::OMPAssumeDirectiveClass:
283 case Stmt::OMPMaskedDirectiveClass:
284 case Stmt::OMPStripeDirectiveClass:
285 case Stmt::ObjCAtCatchStmtClass:
286 case Stmt::ObjCAtFinallyStmtClass:
287 cgm.errorNYI(
s->getSourceRange(),
288 std::string(
"emitStmt: ") +
s->getStmtClassName());
289 return mlir::failure();
292 llvm_unreachable(
"Unexpected statement class");
296 bool useCurrentScope) {
297 switch (
s->getStmtClass()) {
299 return mlir::failure();
300 case Stmt::DeclStmtClass:
302 case Stmt::CompoundStmtClass:
306 case Stmt::GotoStmtClass:
308 case Stmt::ContinueStmtClass:
312 case Stmt::NullStmtClass:
315 case Stmt::LabelStmtClass:
317 case Stmt::CaseStmtClass:
318 case Stmt::DefaultStmtClass:
324 case Stmt::BreakStmtClass:
326 case Stmt::ReturnStmtClass:
330 return mlir::success();
336 return mlir::failure();
346 mlir::Location loc) {
351 unsigned numBlocks = r.getBlocks().size();
352 for (
auto &block : r.getBlocks()) {
355 if (numBlocks != 1 && block.empty() && block.hasNoPredecessors() &&
356 block.hasNoSuccessors())
357 eraseBlocks.push_back(&block);
360 !block.back().hasTrait<mlir::OpTrait::IsTerminator>()) {
361 mlir::OpBuilder::InsertionGuard guardCase(builder);
362 builder.setInsertionPointToEnd(&block);
367 for (
auto *
b : eraseBlocks)
372 mlir::LogicalResult res = mlir::success();
375 const Stmt *constevalExecuted;
376 if (
s.isConsteval()) {
377 constevalExecuted =
s.isNegatedConsteval() ?
s.getThen() :
s.getElse();
378 if (!constevalExecuted) {
386 auto ifStmtBuilder = [&]() -> mlir::LogicalResult {
388 return emitStmt(constevalExecuted,
true);
391 if (
emitStmt(
s.getInit(),
true).failed())
392 return mlir::failure();
394 if (
s.getConditionVariable())
401 if (
s.isConstexpr()) {
406 if (
const Stmt *executed = condConstant ?
s.getThen() :
s.getElse())
410 return mlir::success();
422 mlir::Location scopeLoc =
getLoc(
s.getSourceRange());
423 builder.create<cir::ScopeOp>(
425 [&](mlir::OpBuilder &
b, mlir::Location loc) {
426 LexicalScope lexScope{*
this, scopeLoc, builder.getInsertionBlock()};
427 res = ifStmtBuilder();
434 assert(builder.getInsertionBlock() &&
"expected valid insertion point");
436 for (
const Decl *i :
s.decls())
439 return mlir::success();
443 mlir::Location loc =
getLoc(
s.getSourceRange());
444 const Expr *rv =
s.getRetValue();
447 s.getNRVOCandidate()->isNRVOVariable()) {
460 ->isReferenceType()) {
466 mlir::Value value =
nullptr;
471 builder.CIRBaseBuilderTy::createStore(loc, value, *
fnRetAlloca);
476 "complex function return type");
488 auto *retBlock =
curLexScope->getOrCreateRetBlock(*
this, loc);
490 builder.create<cir::BrOp>(loc, retBlock);
493 cgm.errorNYI(
s.getSourceRange(),
"return with cleanup stack");
496 builder.createBlock(builder.getBlock()->getParent());
498 return mlir::success();
508 cir::GotoOp::create(builder,
getLoc(
s.getSourceRange()),
509 s.getLabel()->getName());
514 builder.createBlock(builder.getBlock()->getParent());
516 return mlir::success();
521 builder.createContinue(
getLoc(
s.getKwLoc()));
524 builder.createBlock(builder.getBlock()->getParent());
526 return mlir::success();
533 mlir::Block *currBlock = builder.getBlock();
534 mlir::Block *labelBlock = currBlock;
536 if (!currBlock->empty()) {
538 mlir::OpBuilder::InsertionGuard guard(builder);
539 labelBlock = builder.createBlock(builder.getBlock()->getParent());
544 builder.setInsertionPointToEnd(labelBlock);
546 builder.setInsertionPointToEnd(labelBlock);
552 return mlir::success();
556 builder.createBreak(
getLoc(
s.getKwLoc()));
559 builder.createBlock(builder.getBlock()->getParent());
561 return mlir::success();
567 mlir::ArrayAttr value, CaseOpKind kind,
568 bool buildingTopLevelCase) {
571 "only case or default stmt go here");
573 mlir::LogicalResult result = mlir::success();
575 mlir::Location loc =
getLoc(
stmt->getBeginLoc());
578 SubStmtKind subStmtKind = SubStmtKind::Other;
579 const Stmt *sub =
stmt->getSubStmt();
581 mlir::OpBuilder::InsertPoint insertPoint;
582 builder.create<CaseOp>(loc, value, kind, insertPoint);
585 mlir::OpBuilder::InsertionGuard guardSwitch(builder);
586 builder.restoreInsertionPoint(insertPoint);
589 subStmtKind = SubStmtKind::Default;
590 builder.createYield(loc);
592 subStmtKind = SubStmtKind::Case;
593 builder.createYield(loc);
598 insertPoint = builder.saveInsertionPoint();
633 if (subStmtKind == SubStmtKind::Case) {
635 }
else if (subStmtKind == SubStmtKind::Default) {
637 buildingTopLevelCase);
638 }
else if (buildingTopLevelCase) {
642 builder.restoreInsertionPoint(insertPoint);
650 bool buildingTopLevelCase) {
651 cir::CaseOpKind kind;
652 mlir::ArrayAttr value;
653 llvm::APSInt intVal =
s.getLHS()->EvaluateKnownConstInt(
getContext());
658 if (
const Expr *rhs =
s.getRHS()) {
659 llvm::APSInt endVal = rhs->EvaluateKnownConstInt(
getContext());
660 value = builder.getArrayAttr({cir::IntAttr::get(condType, intVal),
661 cir::IntAttr::get(condType, endVal)});
662 kind = cir::CaseOpKind::Range;
664 value = builder.getArrayAttr({cir::IntAttr::get(condType, intVal)});
665 kind = cir::CaseOpKind::Equal;
669 buildingTopLevelCase);
674 bool buildingTopLevelCase) {
676 cir::CaseOpKind::Default, buildingTopLevelCase);
680 bool buildingTopLevelCase) {
682 "build switch case without specifying the type of the condition");
684 if (
s.getStmtClass() == Stmt::CaseStmtClass)
686 buildingTopLevelCase);
688 if (
s.getStmtClass() == Stmt::DefaultStmtClass)
690 buildingTopLevelCase);
692 llvm_unreachable(
"expect case or default stmt");
701 auto forStmtBuilder = [&]() -> mlir::LogicalResult {
702 mlir::LogicalResult loopRes = mlir::success();
705 if (
emitStmt(
s.getInit(),
true).failed())
706 return mlir::failure();
707 if (
emitStmt(
s.getRangeStmt(),
true).failed())
708 return mlir::failure();
709 if (
emitStmt(
s.getBeginStmt(),
true).failed())
710 return mlir::failure();
711 if (
emitStmt(
s.getEndStmt(),
true).failed())
712 return mlir::failure();
721 forOp = builder.createFor(
724 [&](mlir::OpBuilder &
b, mlir::Location loc) {
725 assert(!cir::MissingFeatures::createProfileWeightsForLoop());
726 assert(!cir::MissingFeatures::emitCondLikelihoodViaExpectIntrinsic());
727 mlir::Value condVal = evaluateExprAsBool(s.getCond());
728 builder.createCondition(condVal);
731 [&](mlir::OpBuilder &
b, mlir::Location loc) {
735 bool useCurrentScope = true;
736 if (emitStmt(s.getLoopVarStmt(), useCurrentScope).failed())
737 loopRes = mlir::failure();
738 if (emitStmt(s.getBody(), useCurrentScope).failed())
739 loopRes = mlir::failure();
743 [&](mlir::OpBuilder &
b, mlir::Location loc) {
745 if (emitStmt(s.getInc(), true).failed())
746 loopRes = mlir::failure();
747 builder.createYield(loc);
752 mlir::LogicalResult res = mlir::success();
753 mlir::Location scopeLoc =
getLoc(
s.getSourceRange());
754 builder.create<cir::ScopeOp>(scopeLoc,
755 [&](mlir::OpBuilder &
b, mlir::Location loc) {
761 *
this, loc, builder.getInsertionBlock()};
762 res = forStmtBuilder();
769 return mlir::success();
776 auto forStmtBuilder = [&]() -> mlir::LogicalResult {
777 mlir::LogicalResult loopRes = mlir::success();
780 if (
emitStmt(
s.getInit(),
true).failed())
781 return mlir::failure();
789 forOp = builder.createFor(
792 [&](mlir::OpBuilder &
b, mlir::Location loc) {
793 assert(!cir::MissingFeatures::createProfileWeightsForLoop());
794 assert(!cir::MissingFeatures::emitCondLikelihoodViaExpectIntrinsic());
799 if (s.getConditionVariable())
800 emitDecl(*s.getConditionVariable());
804 condVal = evaluateExprAsBool(s.getCond());
806 condVal = b.create<cir::ConstantOp>(loc, builder.getTrueAttr());
808 builder.createCondition(condVal);
811 [&](mlir::OpBuilder &
b, mlir::Location loc) {
814 if (
emitStmt(
s.getBody(),
false).failed())
815 loopRes = mlir::failure();
819 [&](mlir::OpBuilder &
b, mlir::Location loc) {
822 loopRes = mlir::failure();
823 builder.createYield(loc);
828 auto res = mlir::success();
829 auto scopeLoc = getLoc(
s.getSourceRange());
830 builder.create<cir::ScopeOp>(scopeLoc,
831 [&](mlir::OpBuilder &
b, mlir::Location loc) {
832 LexicalScope lexScope{
833 *
this, loc, builder.getInsertionBlock()};
834 res = forStmtBuilder();
841 return mlir::success();
845 cir::DoWhileOp doWhileOp;
848 auto doStmtBuilder = [&]() -> mlir::LogicalResult {
849 mlir::LogicalResult loopRes = mlir::success();
857 doWhileOp = builder.createDoWhile(
860 [&](mlir::OpBuilder &
b, mlir::Location loc) {
861 assert(!cir::MissingFeatures::createProfileWeightsForLoop());
862 assert(!cir::MissingFeatures::emitCondLikelihoodViaExpectIntrinsic());
866 mlir::Value condVal = evaluateExprAsBool(s.getCond());
867 builder.createCondition(condVal);
870 [&](mlir::OpBuilder &
b, mlir::Location loc) {
872 if (emitStmt(s.getBody(), false).failed())
873 loopRes = mlir::failure();
879 mlir::LogicalResult res = mlir::success();
880 mlir::Location scopeLoc =
getLoc(
s.getSourceRange());
881 builder.create<cir::ScopeOp>(scopeLoc,
882 [&](mlir::OpBuilder &
b, mlir::Location loc) {
884 *
this, loc, builder.getInsertionBlock()};
885 res = doStmtBuilder();
892 return mlir::success();
896 cir::WhileOp whileOp;
899 auto whileStmtBuilder = [&]() -> mlir::LogicalResult {
900 mlir::LogicalResult loopRes = mlir::success();
908 whileOp = builder.createWhile(
911 [&](mlir::OpBuilder &
b, mlir::Location loc) {
912 assert(!cir::MissingFeatures::createProfileWeightsForLoop());
913 assert(!cir::MissingFeatures::emitCondLikelihoodViaExpectIntrinsic());
917 if (s.getConditionVariable())
918 emitDecl(*s.getConditionVariable());
922 condVal = evaluateExprAsBool(s.getCond());
923 builder.createCondition(condVal);
926 [&](mlir::OpBuilder &
b, mlir::Location loc) {
928 if (emitStmt(s.getBody(), false).failed())
929 loopRes = mlir::failure();
935 mlir::LogicalResult res = mlir::success();
936 mlir::Location scopeLoc =
getLoc(
s.getSourceRange());
937 builder.create<cir::ScopeOp>(scopeLoc,
938 [&](mlir::OpBuilder &
b, mlir::Location loc) {
940 *
this, loc, builder.getInsertionBlock()};
941 res = whileStmtBuilder();
948 return mlir::success();
966 mlir::Block *swtichBlock = builder.getBlock();
969 builder.setInsertionPointToEnd(swtichBlock);
975 return mlir::failure();
982 return mlir::failure();
985 return mlir::success();
996 auto switchStmtBuilder = [&]() -> mlir::LogicalResult {
998 if (
emitStmt(
s.getInit(),
true).failed())
999 return mlir::failure();
1001 if (
s.getConditionVariable())
1002 emitDecl(*
s.getConditionVariable(),
true);
1012 mlir::LogicalResult res = mlir::success();
1013 swop = builder.create<SwitchOp>(
1014 getLoc(
s.getBeginLoc()), condV,
1016 [&](mlir::OpBuilder &
b, mlir::Location loc, mlir::OperationState &os) {
1030 mlir::Location scopeLoc =
getLoc(
s.getSourceRange());
1031 mlir::LogicalResult res = mlir::success();
1032 builder.create<cir::ScopeOp>(scopeLoc,
1033 [&](mlir::OpBuilder &
b, mlir::Location loc) {
1035 *
this, loc, builder.getInsertionBlock()};
1036 res = switchStmtBuilder();
1040 swop.collectCases(cases);
1041 for (
auto caseOp : cases)
1042 terminateBody(builder, caseOp.getCaseRegion(), caseOp.getLoc());
1057 cgm.errorNYI(loc,
"emitReturnOfRValue: complex return type");
1059 mlir::Block *retBlock =
curLexScope->getOrCreateRetBlock(*
this, loc);
1061 builder.create<cir::BrOp>(loc, retBlock);
1063 cgm.errorNYI(loc,
"return with cleanup stack");
static void terminateBody(CIRGenBuilderTy &builder, mlir::Region &r, mlir::Location loc)
static mlir::LogicalResult emitStmtWithResult(CIRGenFunction &cgf, const Stmt *exprResult, AggValueSlot slot, Address *lastValue)
Defines the clang::Expr interface and subclasses for C++ expressions.
This file defines OpenACC AST classes for statement-level contructs.
__device__ __2f16 float __ockl_bool s
__device__ __2f16 float c
cir::YieldOp createYield(mlir::Location loc, mlir::ValueRange value={})
Create a yield operation.
BreakStmt - This represents a break.
static AggValueSlot forAddr(Address addr, clang::Qualifiers quals, IsDestructed_t isDestructed, IsAliased_t isAliased, Overlap_t mayOverlap, IsZeroed_t isZeroed=IsNotZeroed)
mlir::LogicalResult emitDoStmt(const clang::DoStmt &s)
static cir::TypeEvaluationKind getEvaluationKind(clang::QualType type)
Return the cir::TypeEvaluationKind of QualType type.
clang::GlobalDecl curGD
The GlobalDecl for the current function being compiled or the global variable currently being initial...
mlir::LogicalResult emitOpenACCDataConstruct(const OpenACCDataConstruct &s)
mlir::LogicalResult emitOpenACCCombinedConstruct(const OpenACCCombinedConstruct &s)
mlir::LogicalResult emitOpenACCWaitConstruct(const OpenACCWaitConstruct &s)
const clang::LangOptions & getLangOpts() const
mlir::LogicalResult emitOpenACCUpdateConstruct(const OpenACCUpdateConstruct &s)
mlir::LogicalResult emitIfOnBoolExpr(const clang::Expr *cond, const clang::Stmt *thenS, const clang::Stmt *elseS)
Emit an if on a boolean condition to the specified blocks.
mlir::LogicalResult emitOpenACCCacheConstruct(const OpenACCCacheConstruct &s)
mlir::LogicalResult emitCXXForRangeStmt(const CXXForRangeStmt &s, llvm::ArrayRef< const Attr * > attrs)
mlir::Location getLoc(clang::SourceLocation srcLoc)
Helpers to convert Clang's SourceLocation to a MLIR Location.
bool constantFoldsToBool(const clang::Expr *cond, bool &resultBool, bool allowLabels=false)
If the specified expression does not fold to a constant, or if it does but contains a label,...
mlir::LogicalResult emitReturnStmt(const clang::ReturnStmt &s)
mlir::LogicalResult emitOpenACCInitConstruct(const OpenACCInitConstruct &s)
void emitAnyExprToMem(const Expr *e, Address location, Qualifiers quals, bool isInitializer)
Emits the code necessary to evaluate an arbitrary expression into the given memory location.
mlir::LogicalResult emitOpenACCSetConstruct(const OpenACCSetConstruct &s)
RValue emitReferenceBindingToExpr(const Expr *e)
Emits a reference binding to the passed in expression.
RValue emitAnyExpr(const clang::Expr *e, AggValueSlot aggSlot=AggValueSlot::ignored())
Emit code to compute the specified expression which can have any type.
mlir::LogicalResult emitSwitchStmt(const clang::SwitchStmt &s)
mlir::LogicalResult emitCaseStmt(const clang::CaseStmt &s, mlir::Type condType, bool buildingTopLevelCase)
llvm::ScopedHashTableScope< const clang::Decl *, mlir::Value > SymTableScopeTy
mlir::LogicalResult emitSimpleStmt(const clang::Stmt *s, bool useCurrentScope)
mlir::LogicalResult emitAsmStmt(const clang::AsmStmt &s)
mlir::LogicalResult emitOpenACCComputeConstruct(const OpenACCComputeConstruct &s)
EHScopeStack ehStack
Tracks function scope overall cleanup handling.
mlir::LogicalResult emitSwitchBody(const clang::Stmt *s)
mlir::LogicalResult emitForStmt(const clang::ForStmt &s)
std::optional< mlir::Value > fnRetAlloca
The compiler-generated variable that holds the return value.
Address returnValue
The temporary alloca to hold the return value.
mlir::LogicalResult emitLabel(const clang::LabelDecl &d)
static bool hasAggregateEvaluationKind(clang::QualType type)
mlir::LogicalResult emitOpenACCShutdownConstruct(const OpenACCShutdownConstruct &s)
mlir::LogicalResult emitBreakStmt(const clang::BreakStmt &s)
void emitReturnOfRValue(mlir::Location loc, RValue rv, QualType ty)
mlir::LogicalResult emitContinueStmt(const clang::ContinueStmt &s)
llvm::SmallVector< mlir::Type, 2 > condTypeStack
The type of the condition for the emitting switch statement.
mlir::Value emitScalarExpr(const clang::Expr *e)
Emit the computation of the specified expression of scalar type.
void emitStopPoint(const Stmt *s)
Build a debug stoppoint if we are emitting debug info.
mlir::LogicalResult emitOpenACCHostDataConstruct(const OpenACCHostDataConstruct &s)
mlir::LogicalResult emitIfStmt(const clang::IfStmt &s)
AggValueSlot::Overlap_t getOverlapForReturnValue()
Determine whether a return value slot may overlap some other object.
mlir::LogicalResult emitSwitchCase(const clang::SwitchCase &s, bool buildingTopLevelCase)
void emitDecl(const clang::Decl &d, bool evaluateConditionDecl=false)
CIRGenModule & getCIRGenModule()
mlir::LogicalResult emitOpenACCEnterDataConstruct(const OpenACCEnterDataConstruct &s)
mlir::LogicalResult emitCaseDefaultCascade(const T *stmt, mlir::Type condType, mlir::ArrayAttr value, cir::CaseOpKind kind, bool buildingTopLevelCase)
LValue makeAddrLValue(Address addr, QualType ty, AlignmentSource source=AlignmentSource::Type)
mlir::LogicalResult emitDeclStmt(const clang::DeclStmt &s)
mlir::LogicalResult emitDefaultStmt(const clang::DefaultStmt &s, mlir::Type condType, bool buildingTopLevelCase)
mlir::LogicalResult emitWhileStmt(const clang::WhileStmt &s)
mlir::LogicalResult emitLabelStmt(const clang::LabelStmt &s)
EHScopeStack::stable_iterator currentCleanupStackDepth
LexicalScope * curLexScope
clang::ASTContext & getContext() const
void emitAggregateCopy(LValue dest, LValue src, QualType eltTy, AggValueSlot::Overlap_t mayOverlap)
Emit an aggregate copy.
mlir::LogicalResult emitCompoundStmt(const clang::CompoundStmt &s, Address *lastValue=nullptr, AggValueSlot slot=AggValueSlot::ignored())
mlir::LogicalResult emitGotoStmt(const clang::GotoStmt &s)
mlir::LogicalResult emitStmt(const clang::Stmt *s, bool useCurrentScope, llvm::ArrayRef< const Attr * > attrs={})
mlir::LogicalResult emitCompoundStmtWithoutScope(const clang::CompoundStmt &s, Address *lastValue=nullptr, AggValueSlot slot=AggValueSlot::ignored())
mlir::LogicalResult emitOpenACCExitDataConstruct(const OpenACCExitDataConstruct &s)
void emitIgnoredExpr(const clang::Expr *e)
Emit code to compute the specified expression, ignoring the result.
void emitAggExpr(const clang::Expr *e, AggValueSlot slot)
mlir::LogicalResult emitOpenACCAtomicConstruct(const OpenACCAtomicConstruct &s)
mlir::LogicalResult emitOpenACCLoopConstruct(const OpenACCLoopConstruct &s)
DiagnosticBuilder errorNYI(SourceLocation, llvm::StringRef)
Helpers to emit "not yet implemented" error diagnostics.
This trivial value class is used to represent the result of an expression that is evaluated.
Address getAggregateAddress() const
Return the value of the address of the aggregate.
mlir::Value getValue() const
Return the value of this scalar value.
CXXForRangeStmt - This represents C++0x [stmt.ranged]'s ranged for statement, represented as 'for (ra...
CaseStmt - Represent a case statement.
CompoundStmt - This represents a group of statements like { stmt stmt }.
ContinueStmt - This represents a continue.
DeclStmt - Adaptor class for mixing declarations with statements and expressions.
DoStmt - This represents a 'do/while' stmt.
This represents one expression.
ForStmt - This represents a 'for (init;cond;inc)' stmt.
GotoStmt - This represents a direct goto.
IfStmt - This represents an if/then/else.
Represents the declaration of a label.
SourceRange getSourceRange() const override LLVM_READONLY
Source range that this declaration covers.
LabelStmt - Represents a label, which has a substatement.
StringRef getName() const
Get the name of identifier for this declaration as a StringRef.
A (possibly-)qualified type.
The collection of all-type qualifiers we support.
ReturnStmt - This represents a return, optionally of an expression: return; return 4;.
Stmt - This represents one statement.
SwitchStmt - This represents a 'switch' stmt.
WhileStmt - This represents a 'while' stmt.
@ Decl
The l-value was an access to a declared entity or something equivalently strong, like the address of ...
const internal::VariadicDynCastAllOfMatcher< Stmt, CompoundStmt > compoundStmt
Matches compound statements.
const internal::VariadicAllOfMatcher< Type > type
Matches Types in the clang AST.
const internal::VariadicDynCastAllOfMatcher< Stmt, SwitchCase > switchCase
Matches case and default statements inside switch statements.
const internal::VariadicAllOfMatcher< Stmt > stmt
Matches statements.
The JSON file list parser is used to communicate input to InstallAPI.
bool isa(CodeGen::Address addr)
const FunctionProtoType * T
U cast(CodeGen::Address addr)
@ Other
Other implicit parameter.
static bool aggValueSlotGC()
static bool loopInfoStack()
static bool emitCondLikelihoodViaExpectIntrinsic()
static bool constantFoldSwitchStatement()
static bool insertBuiltinUnpredictable()
static bool ehstackBranches()
static bool emitBranchThroughCleanup()
static bool requiresCleanups()
static bool generateDebugInfo()
static bool incrementProfileCounter()
Represents a scope, including function bodies, compound statements, and the substatements of if/while...